@rubytech/create-sitedesk-code 0.1.518 → 0.1.520

package/payload/server/{chunk-S6HYTIU3.js → chunk-UX2FRNO7.js}

@@ -1,4 +1,17 @@
 import { createRequire as __createRequire } from 'node:module'; const require = __createRequire(import.meta.url);
+import {
+  BRAND_NAME,
+  BUNDLE_ALLOWLIST,
+  BUNDLE_MODE,
+  LOG_DIR,
+  MAXY_DIR,
+  PLATFORM_ROOT,
+  REMOTE_PASSWORD_FILE,
+  REMOTE_SESSION_SECRET_FILE,
+  USERS_FILE,
+  getConversationOwner,
+  isValidAccountId
+} from "./chunk-PXNY2TAP.js";
 
 // node_modules/hono/dist/compose.js
 var compose = (middleware, onError, onNotFound) => {
@@ -2514,7 +2527,7 @@ var responseViaResponseObject = async (res, outgoing, options = {}) => {
         });
         if (!chunk) {
           if (i === 1) {
-            await new Promise((resolve7) => setTimeout(resolve7));
+            await new Promise((resolve4) => setTimeout(resolve4));
             maxReadCount = 3;
             continue;
           }
@@ -2657,396 +2670,6 @@ var serve = (options, listeningListener) => {
   return server;
 };
 
-// app/lib/paths.ts
-import { homedir } from "os";
-import { resolve, join } from "path";
-import { existsSync, readFileSync } from "fs";
-var configDirName = ".maxy";
-var commercialMode = false;
-var bundleMode = "none";
-var bundleAllowlist = [];
-var vncDisplayNum = 99;
-var rfbPortNum = 5900;
-var websockifyPortNum = 6080;
-var cdpPortNum = 9222;
-var portSource = "dev-default";
-var platformRoot = process.env.MAXY_PLATFORM_ROOT;
-if (platformRoot) {
-  const brandPath = join(platformRoot, "config", "brand.json");
-  if (existsSync(brandPath)) {
-    let brand;
-    try {
-      brand = JSON.parse(readFileSync(brandPath, "utf-8"));
-    } catch (err) {
-      const detail = (err instanceof Error ? err.message : String(err)).slice(0, 160);
-      console.error(`[paths] error reason=brand-config-missing path=${brandPath} detail="parse failed: ${detail.replace(/"/g, "'")}"`);
-      throw err;
-    }
-    if (typeof brand.configDir === "string") configDirName = brand.configDir;
-    if (brand.commercialMode === true) commercialMode = true;
-    if (brand.shipsPremiumBundles === true) {
-      bundleMode = "all";
-    } else if (Array.isArray(brand.shipsPremiumBundles)) {
-      const arr = brand.shipsPremiumBundles;
-      for (const entry of arr) {
-        if (typeof entry !== "string" || entry.length === 0) {
-          throw new Error(
-            `brand.json at ${brandPath} shipsPremiumBundles array contains invalid entry: ${JSON.stringify(entry)}`
-          );
-        }
-      }
-      bundleMode = "allowlist";
-      bundleAllowlist = arr;
-    }
-    if (typeof brand.vncDisplay === "number") vncDisplayNum = brand.vncDisplay;
-    const brandLabel = configDirName.replace(/^\./, "");
-    const required = [
-      ["rfbPort", brand.rfbPort],
-      ["websockifyPort", brand.websockifyPort],
-      ["cdpPort", brand.cdpPort]
-    ];
-    for (const [field, value] of required) {
-      if (typeof value !== "number") {
-        const keys = Object.keys(brand).join(",");
-        console.error(`[paths] error reason=cdp-port-unresolved brand=${brandLabel} path=${brandPath} field=${field} json_keys=${keys}`);
-        throw new Error(`brand.json at ${brandPath} missing required field: ${field}`);
-      }
-    }
-    rfbPortNum = brand.rfbPort;
-    websockifyPortNum = brand.websockifyPort;
-    cdpPortNum = brand.cdpPort;
-    portSource = "brand.json";
-  }
-}
-var MAXY_DIR = resolve(homedir(), configDirName);
-var BRAND_NAME = configDirName.replace(/^\./, "");
-var COMMERCIAL_MODE = commercialMode;
-var BUNDLE_MODE = bundleMode;
-var BUNDLE_ALLOWLIST = bundleAllowlist;
-var VNC_DISPLAY = `:${vncDisplayNum}`;
-var RFB_PORT = rfbPortNum;
-var WEBSOCKIFY_PORT = websockifyPortNum;
-var CDP_PORT = cdpPortNum;
-console.log(
-  `[paths] brand=${configDirName.replace(/^\./, "")} vncDisplay=${vncDisplayNum} rfbPort=${RFB_PORT} websockifyPort=${WEBSOCKIFY_PORT} cdpPort=${CDP_PORT} source=${portSource}`
-);
-var CHROMIUM_PROFILE_DIR = resolve(homedir(), configDirName, "chromium-profile");
-var PLATFORM_ROOT = process.env.MAXY_PLATFORM_ROOT ?? resolve(process.cwd(), "..");
-var USERS_FILE = resolve(MAXY_DIR, "users.json");
-var LID_MAP_FILE = resolve(MAXY_DIR, "whatsapp-lid-map.json");
-var LOG_DIR = resolve(MAXY_DIR, "logs");
-var USERS_AUDIT_LOG = resolve(LOG_DIR, "users-audit.log");
-var BIN_DIR = resolve(MAXY_DIR, "bin");
-var REMOTE_PASSWORD_FILE = resolve(MAXY_DIR, ".remote-password");
-var REMOTE_SESSION_SECRET_FILE = resolve(MAXY_DIR, "credentials", "remote-session-secret");
-var ADMIN_SESSION_SECRET_FILE = resolve(MAXY_DIR, "credentials", "admin-session-secret");
-var INSTALL_OWNER_FILE = resolve(MAXY_DIR, ".install-owner");
-var TELEGRAM_WEBHOOK_SECRET_FILE = resolve(MAXY_DIR, ".telegram-webhook-secret");
-var TELEGRAM_ADMIN_WEBHOOK_SECRET_FILE = resolve(MAXY_DIR, ".telegram-admin-webhook-secret");
-var VISITOR_TOKEN_SECRET_FILE = resolve(MAXY_DIR, "credentials", "visitor-token-secret");
-var CLAUDE_CREDENTIALS_FILE = resolve(MAXY_DIR, ".claude", ".credentials.json");
-
-// app/lib/system-path-slugs.ts
-var SYSTEM_PATH_SLUGS = ["public", "public-chat", "chat", "graph", "data", "browser"];
-
-// app/lib/claude-agent/account.ts
-import { resolve as resolve2 } from "path";
-import { readFileSync as readFileSync3, readdirSync, existsSync as existsSync3, statSync } from "fs";
-
-// ../lib/brand-templating/src/index.ts
-import { join as join2 } from "path";
-import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
-var PLACEHOLDER = "{{productName}}";
-var cachedProductName = null;
-function brandJsonPath() {
-  const platformRoot2 = process.env.MAXY_PLATFORM_ROOT;
-  if (!platformRoot2) {
-    throw new Error(
-      "[skill-loader] MAXY_PLATFORM_ROOT not set \u2014 cannot resolve brand.json"
-    );
-  }
-  return join2(platformRoot2, "config", "brand.json");
-}
-function getBrandProductName() {
-  if (cachedProductName !== null) return cachedProductName;
-  const path = brandJsonPath();
-  if (!existsSync2(path)) {
-    throw new Error(`[skill-loader] brand.json missing at ${path}`);
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(readFileSync2(path, "utf-8"));
-  } catch (err) {
-    throw new Error(
-      `[skill-loader] brand.json unreadable at ${path}: ${err instanceof Error ? err.message : String(err)}`
-    );
-  }
-  const value = parsed.productName;
-  if (typeof value !== "string" || value.trim() === "") {
-    throw new Error(
-      `[skill-loader] brand.json at ${path} has missing or empty productName`
-    );
-  }
-  cachedProductName = value;
-  return value;
-}
-function substituteBrandPlaceholders(content, sourcePath) {
-  if (!content.includes(PLACEHOLDER)) return content;
-  let productName;
-  try {
-    productName = getBrandProductName();
-  } catch (err) {
-    console.error(
-      `[skill-loader] ERROR: brand.json missing \u2014 cannot resolve productName for skill ${sourcePath}`
-    );
-    throw err;
-  }
-  const occurrences = content.split(PLACEHOLDER).length - 1;
-  const substituted = content.split(PLACEHOLDER).join(productName);
-  console.log(
-    `[skill-loader] brand-substituted productName=${productName} skill=${sourcePath} occurrences=${occurrences}`
-  );
-  return substituted;
-}
-
-// app/lib/claude-agent/account.ts
-var PLATFORM_ROOT2 = process.env.MAXY_PLATFORM_ROOT ?? resolve2(process.cwd(), "..");
-var ACCOUNTS_DIR = resolve2(PLATFORM_ROOT2, "..", "data/accounts");
-if (!existsSync3(PLATFORM_ROOT2)) {
-  throw new Error(
-    `PLATFORM_ROOT does not exist: ${PLATFORM_ROOT2}
-Set the MAXY_PLATFORM_ROOT environment variable to the absolute path of the platform directory.`
-  );
-}
-var _stubDirsLoggedThisBoot = /* @__PURE__ */ new Set();
-function listValidAccounts() {
-  if (!existsSync3(ACCOUNTS_DIR)) return [];
-  const out = [];
-  const entries2 = readdirSync(ACCOUNTS_DIR, { withFileTypes: true });
-  for (const entry of entries2) {
-    if (!entry.isDirectory()) continue;
-    if (entry.name.startsWith(".")) continue;
-    const accountDir = resolve2(ACCOUNTS_DIR, entry.name);
-    const configPath = resolve2(accountDir, "account.json");
-    if (!existsSync3(configPath)) {
-      if (!_stubDirsLoggedThisBoot.has(entry.name)) {
-        console.error(
-          `[platform] accounts-state STUB-DIR id=${entry.name} \u2014 onboarding leak; remove or repair`
-        );
-        _stubDirsLoggedThisBoot.add(entry.name);
-      }
-      continue;
-    }
-    let config;
-    try {
-      config = JSON.parse(readFileSync3(configPath, "utf-8"));
-    } catch {
-      console.error(
-        `[platform] accounts-state CORRUPT-JSON id=${entry.name} \u2014 account.json failed to parse; treating as stub`
-      );
-      continue;
-    }
-    out.push({ accountId: config.accountId, accountDir, config });
-  }
-  return out;
-}
-function isValidAccountId(id) {
-  return listValidAccounts().some((a) => a.accountId === id);
-}
-function resolveAccount() {
-  if (!existsSync3(ACCOUNTS_DIR)) return null;
-  let usersJsonUserId = null;
-  if (existsSync3(USERS_FILE)) {
-    try {
-      const raw2 = readFileSync3(USERS_FILE, "utf-8").trim();
-      if (raw2) {
-        const users = JSON.parse(raw2);
-        if (users.length > 0) {
-          usersJsonUserId = users[0].userId;
-        }
-      }
-    } catch {
-    }
-  }
-  const entries2 = readdirSync(ACCOUNTS_DIR, { withFileTypes: true });
-  let fallback = null;
-  for (const entry of entries2) {
-    if (!entry.isDirectory()) continue;
-    const configPath = resolve2(ACCOUNTS_DIR, entry.name, "account.json");
-    if (!existsSync3(configPath)) continue;
-    const raw2 = readFileSync3(configPath, "utf-8");
-    let config;
-    try {
-      config = JSON.parse(raw2);
-    } catch {
-      console.error(`[maxy] account.json is corrupt at ${configPath} \u2014 skipping`);
-      continue;
-    }
-    if (!config.adminModel || !config.publicModel) {
-      throw new Error(
-        `[maxy] account.json at ${configPath} is missing required model fields (adminModel / publicModel). Update account.json with valid model identifiers.`
-      );
-    }
-    const result = {
-      accountId: config.accountId,
-      accountDir: resolve2(ACCOUNTS_DIR, entry.name),
-      config
-    };
-    if (usersJsonUserId && config.admins?.some((a) => a.userId === usersJsonUserId)) {
-      return result;
-    }
-    if (!fallback) {
-      fallback = result;
-    }
-  }
-  if (usersJsonUserId && fallback) {
-    console.warn(
-      `[maxy] resolveAccount: no account matches users.json userId ${usersJsonUserId} \u2014 falling back to ${fallback.accountId}`
-    );
-  }
-  return fallback;
-}
-function readAgentFile(accountDir, agentName, filename) {
-  const filePath = resolve2(accountDir, "agents", agentName, filename);
-  if (!existsSync3(filePath)) return null;
-  const raw2 = readFileSync3(filePath, "utf-8");
-  if (filename.endsWith(".md")) {
-    return substituteBrandPlaceholders(raw2, filePath);
-  }
-  return raw2;
-}
-var RESERVED_SLUGS = /* @__PURE__ */ new Set(["admin", "api", "assets", "agent-assets", "brand", "bot", "privacy"]);
-var SHADOWED_SLUGS = new Set(SYSTEM_PATH_SLUGS);
-var SLUG_PATTERN = /^[a-z][a-z0-9-]{2,49}$/;
-function validateAgentSlug(slug) {
-  if (!SLUG_PATTERN.test(slug)) return false;
-  if (RESERVED_SLUGS.has(slug)) {
-    console.error(`[agent-slug] op=reject slug=${slug} reason=reserved`);
-    return false;
-  }
-  if (SHADOWED_SLUGS.has(slug)) {
-    console.error(`[agent-slug] op=reject slug=${slug} reason=shadowed`);
-    return false;
-  }
-  return true;
-}
-function resolveDefaultAgentSlug(accountDir) {
-  const configPath = resolve2(accountDir, "account.json");
-  if (!existsSync3(configPath)) {
-    console.error("[agent-resolve] account.json not found \u2014 cannot resolve defaultAgent");
-    return null;
-  }
-  let config;
-  try {
-    config = JSON.parse(readFileSync3(configPath, "utf-8"));
-  } catch (err) {
-    console.error("[agent-resolve] failed to read account.json:", err);
-    return null;
-  }
-  if (!config.defaultAgent) {
-    console.error("[agent-resolve] defaultAgent not configured in account.json \u2014 set it via the connect-whatsapp skill");
-    return null;
-  }
-  const agentConfigPath = resolve2(accountDir, "agents", config.defaultAgent, "config.json");
-  if (!existsSync3(agentConfigPath)) {
-    console.error(`[agent-resolve] defaultAgent="${config.defaultAgent}" has no config.json at ${agentConfigPath}`);
-    return null;
-  }
-  return config.defaultAgent;
-}
-function estimateTokens(text) {
-  return Math.ceil(text.length / 4);
-}
-function resolveAgentConfig(accountDir, agentName) {
-  let model = null;
-  let status = null;
-  let displayName = null;
-  let image = null;
-  let imageShape = null;
-  let showAgentName = false;
-  let knowledgeKeywords = null;
-  let accessMode = "open";
-  const MAX_KNOWLEDGE_KEYWORDS = 5;
-  const configRaw = readAgentFile(accountDir, agentName, "config.json");
-  if (configRaw) {
-    let parsed;
-    try {
-      parsed = JSON.parse(configRaw);
-    } catch {
-      console.warn(`[agent-config] ${agentName}/config.json: invalid JSON \u2014 using defaults`);
-      parsed = {};
-    }
-    model = typeof parsed.model === "string" ? parsed.model : null;
-    status = typeof parsed.status === "string" ? parsed.status : null;
-    displayName = typeof parsed.displayName === "string" ? parsed.displayName : null;
-    image = typeof parsed.image === "string" ? parsed.image : null;
-    if (typeof parsed.imageShape === "string" && ["circle", "rounded"].includes(parsed.imageShape)) {
-      imageShape = parsed.imageShape;
-    }
-    if (parsed.showAgentName === true) {
-      showAgentName = true;
-    } else if (parsed.showAgentName === "none") {
-      showAgentName = "none";
-    }
-    if (image || imageShape || showAgentName) {
-      console.log(`[agent-config] ${agentName}: image=${image || "(none)"} imageShape=${imageShape || "(none)"} showAgentName=${showAgentName}`);
-    }
-    if (typeof parsed.accessMode === "string" && ["gated", "paid"].includes(parsed.accessMode)) {
-      accessMode = parsed.accessMode;
-    }
-    if (Array.isArray(parsed.knowledgeKeywords) && parsed.knowledgeKeywords.length > 0) {
-      const filtered = parsed.knowledgeKeywords.filter((k) => typeof k === "string" && k.trim()).map((k) => k.replace(/,/g, "").trim().toLowerCase()).filter(Boolean);
-      if (filtered.length > MAX_KNOWLEDGE_KEYWORDS) {
-        console.warn(`[agent-config] ${agentName}: knowledgeKeywords has ${filtered.length} entries \u2014 capping at ${MAX_KNOWLEDGE_KEYWORDS}`);
-      }
-      knowledgeKeywords = filtered.length > 0 ? filtered.slice(0, MAX_KNOWLEDGE_KEYWORDS) : null;
-    }
-  }
-  let knowledge = null;
-  let knowledgeBaked = false;
-  const agentDir = resolve2(accountDir, "agents", agentName);
-  const knowledgePath = resolve2(agentDir, "KNOWLEDGE.md");
-  const summaryPath = resolve2(agentDir, "KNOWLEDGE-SUMMARY.md");
-  const hasKnowledge = existsSync3(knowledgePath);
-  const hasSummary = existsSync3(summaryPath);
-  if (hasKnowledge && hasSummary) {
-    const knowledgeMtime = statSync(knowledgePath).mtimeMs;
-    const summaryMtime = statSync(summaryPath).mtimeMs;
-    if (summaryMtime >= knowledgeMtime) {
-      knowledge = readFileSync3(summaryPath, "utf-8");
-    } else {
-      console.warn(`[agent-config] ${agentName}: KNOWLEDGE-SUMMARY.md is stale (KNOWLEDGE.md is newer) \u2014 using full knowledge`);
-      knowledge = readFileSync3(knowledgePath, "utf-8");
-    }
-    knowledgeBaked = true;
-  } else if (hasKnowledge) {
-    knowledge = readFileSync3(knowledgePath, "utf-8");
-    knowledgeBaked = true;
-  }
-  let budget = null;
-  const identityRaw = readAgentFile(accountDir, agentName, "IDENTITY.md");
-  const soulRaw = readAgentFile(accountDir, agentName, "SOUL.md");
-  if (identityRaw || soulRaw || knowledge) {
-    const identityTokens = identityRaw ? estimateTokens(identityRaw) : 0;
-    const soulTokens = soulRaw ? estimateTokens(soulRaw) : 0;
-    const knowledgeTokens = knowledge ? estimateTokens(knowledge) : 0;
-    budget = {
-      identity: identityTokens,
-      soul: soulTokens,
-      knowledge: knowledgeTokens,
-      plugins: 0,
-      total: identityTokens + soulTokens + knowledgeTokens
-    };
-  }
-  return { model, status, displayName, image, imageShape, showAgentName, knowledge, knowledgeBaked, knowledgeKeywords, budget, accessMode };
-}
-function isActiveAgentSlug(accountDir, slug) {
-  return resolveAgentConfig(accountDir, slug).status === "active";
-}
-function getDefaultAccountId() {
-  return resolveAccount()?.accountId ?? null;
-}
-
 // ../lib/require-port-env/src/index.ts
 var MissingPortEnvError = class extends Error {
   envName;
@@ -3143,7 +2766,7 @@ function getSessionKeyBySessionId(_sessionId) {
 }
 
 // server/loop-registry.ts
-import { readFileSync as readFileSync4 } from "fs";
+import { readFileSync } from "fs";
 var TAG = "[loop-registry]";
 var STALL_INTERVALS = 3;
 var entries = /* @__PURE__ */ new Map();
@@ -3167,7 +2790,7 @@ function parsePidStatCpuUs(raw2) {
 function readPidCpuUs(pid) {
   if (process.platform !== "linux") return null;
   try {
-    return parsePidStatCpuUs(readFileSync4(`/proc/${pid}/stat`, "utf8"));
+    return parsePidStatCpuUs(readFileSync(`/proc/${pid}/stat`, "utf8"));
   } catch {
     return null;
   }
@@ -3368,8 +2991,8 @@ function armedCount() {
 
 // app/lib/vnc-logger.ts
 import { appendFileSync, mkdirSync } from "fs";
-import { resolve as resolve3 } from "path";
-var VNC_LOG_FILE = resolve3(LOG_DIR, "vnc-boot.log");
+import { resolve } from "path";
+var VNC_LOG_FILE = resolve(LOG_DIR, "vnc-boot.log");
 try {
   mkdirSync(LOG_DIR, { recursive: true });
 } catch (err) {
@@ -3412,7 +3035,7 @@ function websockifyLog(event, fields = {}) {
 
 // ../lib/admin-access-password/src/index.ts
 import { scrypt, randomBytes, timingSafeEqual } from "crypto";
-import { existsSync as existsSync4, readFileSync as readFileSync5, writeFileSync, renameSync, unlinkSync, appendFileSync as appendFileSync2, mkdirSync as mkdirSync2 } from "fs";
+import { existsSync, readFileSync as readFileSync2, writeFileSync, renameSync, unlinkSync, appendFileSync as appendFileSync2, mkdirSync as mkdirSync2 } from "fs";
 import { dirname } from "path";
 var SCRYPT_N = 16384;
 var SCRYPT_R = 8;
@@ -3440,10 +3063,10 @@ function appendUsersAuditLine(audit, fields) {
   }
 }
 function scryptAsync(password, salt) {
-  return new Promise((resolve7, reject) => {
+  return new Promise((resolve4, reject) => {
     scrypt(password, salt, SCRYPT_KEYLEN, { N: SCRYPT_N, r: SCRYPT_R, p: SCRYPT_P }, (err, key) => {
       if (err) reject(err);
-      else resolve7(key);
+      else resolve4(key);
     });
   });
 }
@@ -3467,8 +3090,8 @@ async function matchesHash(password, stored) {
   return timingSafeEqual(computed, storedHash);
 }
 function readUsers(usersFile) {
-  if (!existsSync4(usersFile)) return [];
-  const raw2 = readFileSync5(usersFile, "utf-8").trim();
+  if (!existsSync(usersFile)) return [];
+  const raw2 = readFileSync2(usersFile, "utf-8").trim();
   if (!raw2) return [];
   const parsed = JSON.parse(raw2);
   if (!Array.isArray(parsed)) throw new Error("users.json is not an array");
@@ -3530,7 +3153,7 @@ function anyAccessPasswordConfigured(usersFile) {
   return users.some((u) => typeof u.accessHash === "string" && u.accessHash.length > 0);
 }
 function accessStoreUnreadable(usersFile) {
-  if (!existsSync4(usersFile)) return false;
+  if (!existsSync(usersFile)) return false;
   try {
     readUsers(usersFile);
     return false;
@@ -3539,8 +3162,8 @@ function accessStoreUnreadable(usersFile) {
   }
 }
 function migrateLegacyRemotePassword(usersFile, legacyFile, ownerUserId, audit) {
-  if (!existsSync4(legacyFile)) return "noop-no-legacy";
-  const legacy = readFileSync5(legacyFile, "utf-8").trim();
+  if (!existsSync(legacyFile)) return "noop-no-legacy";
+  const legacy = readFileSync2(legacyFile, "utf-8").trim();
   const users = readUsers(usersFile);
   const idx = users.findIndex((u) => u.userId === ownerUserId);
   if (idx === -1) return "noop-no-owner";
@@ -3561,8 +3184,8 @@ function migrateLegacyRemotePassword(usersFile, legacyFile, ownerUserId, audit)
   return "migrated";
 }
 function readLegacyRemoteHash(legacyFile) {
-  if (!existsSync4(legacyFile)) return null;
-  const raw2 = readFileSync5(legacyFile, "utf-8").trim();
+  if (!existsSync(legacyFile)) return null;
+  const raw2 = readFileSync2(legacyFile, "utf-8").trim();
   return raw2.includes(":") ? raw2 : null;
 }
 
@@ -3581,17 +3204,17 @@ function isPasswordValid(password) {
 
 // app/lib/remote-auth.ts
 import { scrypt as scrypt2, randomBytes as randomBytes2, timingSafeEqual as timingSafeEqual2, createHmac } from "crypto";
-import { readFileSync as readFileSync6, writeFileSync as writeFileSync2, mkdirSync as mkdirSync3 } from "fs";
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync2, mkdirSync as mkdirSync3 } from "fs";
 import { dirname as dirname2 } from "path";
 var SCRYPT_N2 = 16384;
 var SCRYPT_R2 = 8;
 var SCRYPT_P2 = 1;
 var SCRYPT_KEYLEN2 = 64;
 function scryptAsync2(password, salt) {
-  return new Promise((resolve7, reject) => {
+  return new Promise((resolve4, reject) => {
     scrypt2(password, salt, SCRYPT_KEYLEN2, { N: SCRYPT_N2, r: SCRYPT_R2, p: SCRYPT_P2 }, (err, key) => {
       if (err) reject(err);
-      else resolve7(key);
+      else resolve4(key);
     });
   });
 }
@@ -3627,7 +3250,7 @@ var cachedSecret = null;
 function getSecret() {
   if (cachedSecret) return cachedSecret;
   try {
-    const hex2 = readFileSync6(REMOTE_SESSION_SECRET_FILE, "utf-8").trim();
+    const hex2 = readFileSync3(REMOTE_SESSION_SECRET_FILE, "utf-8").trim();
     if (hex2.length === SECRET_BYTES * 2) {
       cachedSecret = Buffer.from(hex2, "hex");
       return cachedSecret;
@@ -3640,7 +3263,7 @@ function getSecret() {
     writeFileSync2(REMOTE_SESSION_SECRET_FILE, fresh, { mode: 384, flag: "wx" });
   } catch {
   }
-  const hex = readFileSync6(REMOTE_SESSION_SECRET_FILE, "utf-8").trim();
+  const hex = readFileSync3(REMOTE_SESSION_SECRET_FILE, "utf-8").trim();
   cachedSecret = Buffer.from(hex, "hex");
   return cachedSecret;
 }
@@ -4308,13 +3931,13 @@ function classifyHost(host, operatorDomains2, isPublicHost) {
 import { watchFile } from "fs";
 
 // app/lib/operator-domains.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync4, readFileSync as readFileSync7, writeFileSync as writeFileSync3 } from "fs";
-import { dirname as dirname3, resolve as resolve4 } from "path";
-var OPERATOR_DOMAINS_PATH = resolve4(MAXY_DIR, "operator-domains.json");
+import { existsSync as existsSync2, mkdirSync as mkdirSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
+import { dirname as dirname3, resolve as resolve2 } from "path";
+var OPERATOR_DOMAINS_PATH = resolve2(MAXY_DIR, "operator-domains.json");
 function loadOperatorDomains() {
-  if (!existsSync5(OPERATOR_DOMAINS_PATH)) return /* @__PURE__ */ new Set();
+  if (!existsSync2(OPERATOR_DOMAINS_PATH)) return /* @__PURE__ */ new Set();
   try {
-    const parsed = JSON.parse(readFileSync7(OPERATOR_DOMAINS_PATH, "utf-8"));
+    const parsed = JSON.parse(readFileSync4(OPERATOR_DOMAINS_PATH, "utf-8"));
     if (!Array.isArray(parsed)) return /* @__PURE__ */ new Set();
     return new Set(parsed.filter((h) => typeof h === "string"));
   } catch {
@@ -4340,20 +3963,20 @@ function getOperatorDomains() {
 }
 
 // app/lib/claude-agent/plugin-manifest.ts
-import { resolve as resolve5, join as join3 } from "path";
+import { resolve as resolve3, join } from "path";
 import {
-  readFileSync as readFileSync8,
+  readFileSync as readFileSync5,
   writeFileSync as writeFileSync4,
-  readdirSync as readdirSync2,
-  existsSync as existsSync6,
-  statSync as statSync2,
+  readdirSync,
+  existsSync as existsSync3,
+  statSync,
   rmSync
 } from "fs";
 import { createHash as createHash2 } from "crypto";
 function isMissingPluginDir(pluginDir) {
-  const pluginRoot = resolve5(PLATFORM_ROOT2, "plugins", pluginDir);
-  if (existsSync6(resolve5(pluginRoot, "PLUGIN.md"))) return false;
-  if (existsSync6(resolve5(pluginRoot, "mcp/dist/index.js"))) return false;
+  const pluginRoot = resolve3(PLATFORM_ROOT, "plugins", pluginDir);
+  if (existsSync3(resolve3(pluginRoot, "PLUGIN.md"))) return false;
+  if (existsSync3(resolve3(pluginRoot, "mcp/dist/index.js"))) return false;
   return true;
 }
 function findMissingPlugins(enabledPlugins) {
@@ -4361,10 +3984,10 @@ function findMissingPlugins(enabledPlugins) {
   return enabledPlugins.filter(isMissingPluginDir);
 }
 function readBundleSubPlugins(bundlePath) {
-  if (!existsSync6(bundlePath)) return [];
+  if (!existsSync3(bundlePath)) return [];
   let raw2;
   try {
-    raw2 = readFileSync8(bundlePath, "utf-8");
+    raw2 = readFileSync5(bundlePath, "utf-8");
   } catch {
     return [];
   }
@@ -4406,24 +4029,24 @@ function walkPremiumBundles() {
   return kept;
 }
 function walkPremiumBundlesOnDisk() {
-  const stagingRoot = resolve5(PLATFORM_ROOT2, "../premium-plugins");
-  if (!existsSync6(stagingRoot)) return [];
+  const stagingRoot = resolve3(PLATFORM_ROOT, "../premium-plugins");
+  if (!existsSync3(stagingRoot)) return [];
   let entries2;
   try {
-    entries2 = readdirSync2(stagingRoot);
+    entries2 = readdirSync(stagingRoot);
   } catch {
     return [];
   }
   const result = [];
   for (const bundle of entries2) {
     if (bundle.startsWith(".")) continue;
-    const bundleDir = resolve5(stagingRoot, bundle);
+    const bundleDir = resolve3(stagingRoot, bundle);
     try {
-      if (!statSync2(bundleDir).isDirectory()) continue;
+      if (!statSync(bundleDir).isDirectory()) continue;
     } catch {
       continue;
     }
-    const declared = readBundleSubPlugins(join3(bundleDir, "BUNDLE.md"));
+    const declared = readBundleSubPlugins(join(bundleDir, "BUNDLE.md"));
     result.push({ bundle, subs: declared.length > 0 ? declared : [bundle] });
   }
   return result;
@@ -4431,14 +4054,14 @@ function walkPremiumBundlesOnDisk() {
 function reapDuplicateFlatPremiumSubs(bundles, stagingRoot, pluginsDir) {
   const TAG2 = "[premium-auto-deliver]";
   for (const { bundle, subs } of bundles) {
-    const isBundle = existsSync6(join3(stagingRoot, bundle, "BUNDLE.md"));
+    const isBundle = existsSync3(join(stagingRoot, bundle, "BUNDLE.md"));
     for (const sub of subs) {
-      const premiumManifest = isBundle ? resolve5(stagingRoot, bundle, "plugins", sub, "PLUGIN.md") : resolve5(stagingRoot, bundle, "PLUGIN.md");
-      const flatDir = resolve5(pluginsDir, sub);
-      const flatManifest = resolve5(flatDir, "PLUGIN.md");
-      if (!existsSync6(premiumManifest) || !existsSync6(flatManifest)) continue;
-      const premiumSha = createHash2("sha256").update(readFileSync8(premiumManifest)).digest("hex");
-      const flatSha = createHash2("sha256").update(readFileSync8(flatManifest)).digest("hex");
+      const premiumManifest = isBundle ? resolve3(stagingRoot, bundle, "plugins", sub, "PLUGIN.md") : resolve3(stagingRoot, bundle, "PLUGIN.md");
+      const flatDir = resolve3(pluginsDir, sub);
+      const flatManifest = resolve3(flatDir, "PLUGIN.md");
+      if (!existsSync3(premiumManifest) || !existsSync3(flatManifest)) continue;
+      const premiumSha = createHash2("sha256").update(readFileSync5(premiumManifest)).digest("hex");
+      const flatSha = createHash2("sha256").update(readFileSync5(flatManifest)).digest("hex");
       if (isBundle) {
         if (premiumSha === flatSha) {
           try {
@@ -4464,24 +4087,24 @@ function reapDuplicateFlatPremiumSubs(bundles, stagingRoot, pluginsDir) {
 function autoDeliverPremiumPlugins() {
   const bundles = walkPremiumBundles();
   if (bundles.length === 0) return;
-  const stagingRoot = resolve5(PLATFORM_ROOT2, "../premium-plugins");
-  const pluginsDir = resolve5(PLATFORM_ROOT2, "plugins");
+  const stagingRoot = resolve3(PLATFORM_ROOT, "../premium-plugins");
+  const pluginsDir = resolve3(PLATFORM_ROOT, "plugins");
   reapDuplicateFlatPremiumSubs(bundles, stagingRoot, pluginsDir);
 }
 function reconcileEnabledPlugins(accountDir, config, accountId) {
   const TAG2 = "[premium-auto-deliver]";
   if (!accountDir || !config) return;
   const bundles = walkPremiumBundles();
-  const stagingRoot = resolve5(PLATFORM_ROOT2, "../premium-plugins");
+  const stagingRoot = resolve3(PLATFORM_ROOT, "../premium-plugins");
   const bundleNames = [];
   const allSubs = [];
   for (const { bundle, subs } of bundles) {
     bundleNames.push(bundle);
-    const bundlePath = join3(stagingRoot, bundle, "BUNDLE.md");
-    const isBundle = existsSync6(bundlePath);
+    const bundlePath = join(stagingRoot, bundle, "BUNDLE.md");
+    const isBundle = existsSync3(bundlePath);
     for (const sub of subs) {
-      const subManifest = isBundle ? resolve5(stagingRoot, bundle, "plugins", sub, "PLUGIN.md") : resolve5(stagingRoot, bundle, "PLUGIN.md");
-      if (!existsSync6(subManifest)) continue;
+      const subManifest = isBundle ? resolve3(stagingRoot, bundle, "plugins", sub, "PLUGIN.md") : resolve3(stagingRoot, bundle, "PLUGIN.md");
+      if (!existsSync3(subManifest)) continue;
       allSubs.push(sub);
     }
   }
@@ -4498,9 +4121,9 @@ function reconcileEnabledPlugins(accountDir, config, accountId) {
   );
   if (added.length === 0) return;
   const merged = [...currentSet];
-  const configPath = resolve5(accountDir, "account.json");
+  const configPath = resolve3(accountDir, "account.json");
   try {
-    const raw2 = readFileSync8(configPath, "utf-8");
+    const raw2 = readFileSync5(configPath, "utf-8");
     const parsed = JSON.parse(raw2);
     parsed.enabledPlugins = merged;
     writeFileSync4(configPath, JSON.stringify(parsed, null, 2) + "\n");
@@ -4534,9 +4157,9 @@ function cleanupLeakedPremiumSubs(accountDir, config, accountId) {
     else kept.push(name);
   }
   if (removed.length === 0) return;
-  const configPath = resolve5(accountDir, "account.json");
+  const configPath = resolve3(accountDir, "account.json");
   try {
-    const raw2 = readFileSync8(configPath, "utf-8");
+    const raw2 = readFileSync5(configPath, "utf-8");
     const parsed = JSON.parse(raw2);
     parsed.enabledPlugins = kept;
     writeFileSync4(configPath, JSON.stringify(parsed, null, 2) + "\n");
@@ -4553,1531 +4176,6 @@ var emitMissingOnResolve = (..._args) => null;
 // app/lib/claude-agent/summary-helpers.ts
 var stripAttachmentMetaSuffix = (..._args) => null;
 
-// app/lib/neo4j-store.ts
-import neo4j from "neo4j-driver";
-import { randomUUID } from "crypto";
-import { readFileSync as readFileSync9, readdirSync as readdirSync3, existsSync as existsSync7, openSync, readSync, closeSync, statSync as statSync3 } from "fs";
-import { resolve as resolve6 } from "path";
-var PLATFORM_ROOT3 = process.env.MAXY_PLATFORM_ROOT ?? resolve6(process.cwd(), "..");
-var driver = null;
-function readPassword() {
-  if (process.env.NEO4J_PASSWORD) return process.env.NEO4J_PASSWORD;
-  const passwordFile = resolve6(PLATFORM_ROOT3, "config/.neo4j-password");
-  try {
-    return readFileSync9(passwordFile, "utf-8").trim();
-  } catch {
-    throw new Error(
-      `Neo4j password not found. Expected at ${passwordFile} or in NEO4J_PASSWORD env var.`
-    );
-  }
-}
-function getDriver() {
-  if (!driver) {
-    const uri = process.env.NEO4J_URI;
-    if (!uri) {
-      throw new Error(
-        "[ui/neo4j-store] NEO4J_URI unset \u2014 refusing to default to bolt://localhost:7687"
-      );
-    }
-    const user = process.env.NEO4J_USER ?? "neo4j";
-    const password = readPassword();
-    console.error(`[ui/neo4j-store] resolved neo4j_uri=${uri}`);
-    driver = neo4j.driver(uri, neo4j.auth.basic(user, password), {
-      maxConnectionPoolSize: 5
-    });
-  }
-  return driver;
-}
-function getSession() {
-  return getDriver().session();
-}
-async function runAdminUserSelfHeal(args) {
-  const { selfHealAdminUser } = await import("./adminuser-self-heal-LC7HZAC6.js");
-  return selfHealAdminUser({ driver: getDriver(), ...args });
-}
-async function runUserProfileReconcile() {
-  const { reconcileUserProfiles } = await import("./userprofile-reconcile-QHVLY2AH.js");
-  return reconcileUserProfiles({ driver: getDriver() });
-}
-process.on("SIGINT", async () => {
-  if (driver) {
-    await driver.close();
-    driver = null;
-  }
-});
-var OLLAMA_URL = process.env.OLLAMA_URL ?? "http://localhost:11434";
-var EMBED_MODEL = process.env.EMBED_MODEL ?? "nomic-embed-text";
-function envInt(name, def) {
-  const raw2 = process.env[name];
-  if (raw2 === void 0 || raw2 === "") return def;
-  const n = Number(raw2);
-  return Number.isFinite(n) ? n : def;
-}
-var EMBED_MODEL_CONTEXT_TOKENS = Math.max(1, Math.floor(envInt("EMBED_MODEL_CONTEXT_TOKENS", 2048)));
-var EMBED_CONTEXT_MARGIN_TOKENS = 48;
-var EMBED_WORST_CASE_CHARS_PER_TOKEN = 2;
-var EMBED_INPUT_MAX_CHARS = Math.max(
-  1,
-  Math.floor(
-    envInt(
-      "EMBED_INPUT_MAX_CHARS",
-      (EMBED_MODEL_CONTEXT_TOKENS - EMBED_CONTEXT_MARGIN_TOKENS) * EMBED_WORST_CASE_CHARS_PER_TOKEN
-    )
-  )
-);
-var EMBED_KEEP_ALIVE_RAW = process.env.EMBED_KEEP_ALIVE === void 0 || process.env.EMBED_KEEP_ALIVE === "" ? "-1" : process.env.EMBED_KEEP_ALIVE;
-var EMBED_KEEP_ALIVE = /^-?\d+$/.test(EMBED_KEEP_ALIVE_RAW) ? Number(EMBED_KEEP_ALIVE_RAW) : EMBED_KEEP_ALIVE_RAW;
-var EMBED_INTERACTIVE_TIMEOUT_MS = 5e3;
-var EMBED_PRELOAD_TIMEOUT_MS = 6e4;
-async function embed(text, timeoutMs = EMBED_INTERACTIVE_TIMEOUT_MS) {
-  const input = text.length > EMBED_INPUT_MAX_CHARS ? text.slice(0, EMBED_INPUT_MAX_CHARS) : text;
-  const startedAt = Date.now();
-  const target = `${OLLAMA_URL}/api/embed`;
-  let res;
-  try {
-    res = await fetch(target, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ model: EMBED_MODEL, input, keep_alive: EMBED_KEEP_ALIVE }),
-      signal: AbortSignal.timeout(timeoutMs)
-    });
-  } catch (err) {
-    const name = err instanceof Error ? err.name : "";
-    if (name === "TimeoutError" || name === "AbortError") {
-      throw new Error(
-        `Ollama embed request timed out after ${timeoutMs}ms (inputChars=${input.length}) at ${target}; ollama did not respond in time (slow, cold-loading, or CPU-saturated).`
-      );
-    }
-    let detail = err instanceof Error ? err.message : String(err);
-    const cause = err instanceof Error ? err.cause : void 0;
-    if (cause !== void 0) {
-      detail += `: ${cause instanceof Error ? cause.message : String(cause)}`;
-    }
-    throw new Error(
-      `Ollama embed request failed (inputChars=${input.length}) at ${target}: ${detail}`
-    );
-  }
-  if (!res.ok) {
-    const body = await res.text();
-    throw new Error(
-      `Ollama embedding failed (HTTP ${res.status}, inputChars=${input.length}): ${body}`
-    );
-  }
-  const data = await res.json();
-  const ms = Date.now() - startedAt;
-  console.error(`[embed-query] warmth=${ms > 1e3 ? "cold" : "warm"} ms=${ms}`);
-  return data.embeddings[0];
-}
-async function preloadEmbedModel() {
-  try {
-    await embed("warm", EMBED_PRELOAD_TIMEOUT_MS);
-    console.error("[embed-query] op=preload result=ok");
-  } catch (err) {
-    console.error(
-      `[embed-query] op=preload result=skip err="${err instanceof Error ? err.message : String(err)}"`
-    );
-  }
-}
-var sessionStoreRef = null;
-function getCachedSessionId(cacheKey2) {
-  return sessionStoreRef?.get(cacheKey2)?.sessionId;
-}
-function cacheSessionId(cacheKey2, sessionId) {
-  const session = sessionStoreRef?.get(cacheKey2);
-  if (session) {
-    session.sessionId = sessionId;
-  }
-}
-var GREETING_DIRECTIVE = "[New session. Greet the visitor.]";
-async function ensureConversation(accountId, agentType, cacheKey2, visitorId, agentSlug, userId, channelOverride, channelAddressOverride) {
-  const cached = getCachedSessionId(cacheKey2);
-  if (cached) return { sessionId: cached, created: false };
-  const sessionId = randomUUID();
-  const channel = channelOverride ?? (cacheKey2.startsWith("whatsapp:") ? "whatsapp" : cacheKey2.startsWith("telegram:") ? "telegram" : "webchat");
-  const channelAddress = channelAddressOverride ?? (cacheKey2.startsWith("whatsapp:") ? cacheKey2.slice("whatsapp:".length) : cacheKey2.startsWith("telegram:") ? cacheKey2.slice("telegram:".length) : sessionId);
-  const conversationSublabel = agentType === "admin" ? "AdminConversation" : "PublicConversation";
-  const handlerSlug = agentSlug ?? (agentType === "admin" ? "admin" : null);
-  const wantsHandledByEdge = !!handlerSlug;
-  const handledByClause = wantsHandledByEdge ? `WITH c, created
-       OPTIONAL MATCH (a:Agent {accountId: $accountId, slug: $handlerSlug})
-       FOREACH (_ IN CASE WHEN a IS NULL THEN [] ELSE [1] END | MERGE (c)-[:HANDLED_BY]->(a))
-       RETURN c.sessionId AS sessionId, created AS created, a IS NOT NULL AS handledBy` : `RETURN c.sessionId AS sessionId, created AS created, false AS handledBy`;
-  const session = getSession();
-  try {
-    const result = await session.run(
-      `OPTIONAL MATCH (prior:Conversation {accountId: $accountId, channel: $channel, channelAddress: $channelAddress})
-       WITH prior, coalesce(prior.sessionId, $sessionId) AS finalConvId, prior IS NULL AS created
-       MERGE (c:Conversation {sessionId: finalConvId})
-       ON CREATE SET
-         c:${conversationSublabel},
-         c.accountId = $accountId,
-         c.agentType = $agentType,
-         c.channel = $channel,
-         c.channelAddress = $channelAddress,
-         ${visitorId ? "c.visitorId = $visitorId," : ""}
-         ${agentSlug ? "c.agentSlug = $agentSlug," : ""}
-         ${userId ? "c.userId = $userId," : ""}
-         c.createdAt = datetime(),
-         c.updatedAt = datetime()
-       ON MATCH SET
-         c.updatedAt = datetime()
-       ${handledByClause}`,
-      {
-        sessionId,
-        accountId,
-        agentType,
-        channel,
-        channelAddress,
-        ...visitorId ? { visitorId } : {},
-        ...agentSlug ? { agentSlug } : {},
-        ...handlerSlug ? { handlerSlug } : {},
-        ...userId ? { userId } : {}
-      }
-    );
-    const id = result.records[0]?.get("sessionId");
-    const created = result.records[0]?.get("created") === true;
-    if (id) {
-      cacheSessionId(cacheKey2, id);
-      console.error(`[session] conversation attributed: sessionId=${id.slice(0, 8)}\u2026 userId=${userId ?? "none"} ${agentType}/${accountId.slice(0, 8)}\u2026 sublabel=${conversationSublabel}`);
-      if (wantsHandledByEdge) {
-        const handled = result.records[0]?.get("handledBy");
-        const id82 = id.slice(0, 8);
-        if (handled === true) {
-          console.error(`[agent-graph] handled-by-write sessionId=${id82} slug=${handlerSlug}`);
-        } else {
-          console.error(`[agent-graph] handled-by-skip reason=no-agent-node sessionId=${id82} slug=${handlerSlug}`);
-        }
-      }
-    }
-    return { sessionId: id ?? null, created };
-  } catch (err) {
-    console.error(`[persist] ensureConversation failed: ${err instanceof Error ? err.message : String(err)}`);
-    return { sessionId: null, created: false };
-  } finally {
-    await session.close();
-  }
-}
-async function ensureSessionConversation(input) {
-  const t0 = Date.now();
-  const sublabel = input.agentType === "admin" ? "AdminConversation" : "PublicConversation";
-  const session = getSession();
-  try {
-    const result = await session.run(
-      `OPTIONAL MATCH (prior:Conversation {sessionId: $sessionId})
-       WITH prior IS NULL AS created
-       MERGE (c:Conversation {sessionId: $sessionId})
-       ON CREATE SET
-         c:${sublabel},
-         c.accountId = $accountId,
-         c.agentType = $agentType,
-         c.channel = $channel,
-         c.channelAddress = $channelAddress,
-         c.createdAt = datetime(),
-         c.updatedAt = datetime()
-       ON MATCH SET
-         c.updatedAt = datetime()
-       RETURN created`,
-      {
-        sessionId: input.sessionId,
-        accountId: input.accountId,
-        agentType: input.agentType,
-        channel: input.channel,
-        channelAddress: input.channelAddress
-      }
-    );
-    const created = result.records[0]?.get("created") === true;
-    console.error(
-      `[wa-session] op=conversation-ensure sessionId=${input.sessionId} accountId=${input.accountId} channel=${input.channel} sublabel=${sublabel} created=${created} ms=${Date.now() - t0}`
-    );
-    return { created };
-  } catch (err) {
-    const reason = err instanceof Error ? `${err.name}:${err.message.slice(0, 200)}` : String(err).slice(0, 200);
-    console.error(
-      `[wa-session] op=conversation-ensure FAIL sessionId=${input.sessionId} accountId=${input.accountId} reason=${reason} ms=${Date.now() - t0}`
-    );
-    return null;
-  } finally {
-    await session.close();
-  }
-}
-async function findRecentConversation(visitorId, accountId, agentSlug, maxAgeHours = 24) {
-  const session = getSession();
-  try {
-    const result = await session.run(
-      `MATCH (c:Conversation {visitorId: $visitorId, accountId: $accountId, agentType: 'public'})
-       WHERE c.agentSlug = $agentSlug
-         AND c.updatedAt > datetime() - duration({hours: $maxAgeHours})
-         AND NOT c:Trashed
-       RETURN c.sessionId AS sessionId
-       ORDER BY c.updatedAt DESC
-       LIMIT 1`,
-      { visitorId, accountId, agentSlug, maxAgeHours: neo4j.int(maxAgeHours) },
-      { timeout: 2e3 }
-    );
-    const record = result.records[0];
-    if (!record) return null;
-    const sessionId = record.get("sessionId");
-    if (!sessionId) return null;
-    console.log(`[persist] found recent conversation ${sessionId.slice(0, 8)}\u2026 for visitor ${visitorId.slice(0, 8)}\u2026`);
-    return { sessionId };
-  } catch (err) {
-    console.error(`[persist] findRecentConversation failed: ${err instanceof Error ? err.message : String(err)}`);
-    return null;
-  } finally {
-    await session.close();
-  }
-}
-async function createNewAdminConversation(userId, accountId, cacheKey2, preMintedSessionId) {
-  if (!userId || !cacheKey2 || !accountId) {
-    console.error(`[admin/conversation-write] schema-violation userId=${userId ? "set" : "EMPTY"} cacheKey=${cacheKey2 ? "set" : "EMPTY"} accountId=${accountId ? "set" : "EMPTY"}`);
-    return null;
-  }
-  const sessionId = preMintedSessionId ?? randomUUID();
-  const session = getSession();
-  try {
-    const result = await session.run(
-      `OPTIONAL MATCH (existing:AdminUser {userId: $userId})
-       WITH existing IS NULL AS adminUserCreated
-       MERGE (au:AdminUser {userId: $userId})
-       ON CREATE SET au.accountId = $accountId,
-                     au.createdAt = datetime(),
-                     au.scope = 'admin'
-       CREATE (c:Conversation:AdminConversation {
-         sessionId: $sessionId,
-         accountId: $accountId,
-         agentType: 'admin',
-         channel: 'webchat',
-         channelAddress: $sessionId,
-         userId: $userId,
-         createdBySource: 'admin-conversation',
-         createdAt: datetime(),
-         updatedAt: datetime()
-       })-[:STARTED_BY]->(au)
-       RETURN adminUserCreated`,
-      { sessionId, accountId, userId }
-    );
-    const adminUserCreated = result.records[0]?.get("adminUserCreated") === true;
-    cacheSessionId(cacheKey2, sessionId);
-    console.log(`[session] conversation created: sessionId=${sessionId.slice(0, 8)}\u2026 cacheKey=${cacheKey2.slice(0, 8)}\u2026 accountId=${accountId.slice(0, 8)}\u2026 userId=${userId} agentType=admin createdBySource=admin-conversation createdAt=set updatedAt=set sublabel=AdminConversation adminUserCreated=${adminUserCreated}`);
-    return sessionId;
-  } catch (err) {
-    console.error(`[session] createNewAdminConversation failed: ${err instanceof Error ? err.message : String(err)}`);
-    return null;
-  } finally {
-    await session.close();
-  }
-}
-var HEX_COLOR_RE = /^#[0-9a-fA-F]{3,8}$/;
-async function fetchBranding(accountId) {
-  const session = getSession();
-  try {
-    const result = await session.run(
-      `MATCH (b:LocalBusiness {accountId: $accountId})
-       OPTIONAL MATCH (b)-[:HAS_BRAND_ASSET]->(logo:ImageObject {purpose: "logo"})
-       OPTIONAL MATCH (b)-[:HAS_BRAND_ASSET]->(icon:ImageObject {purpose: "icon"})
-       RETURN b.name AS name,
-              b.primaryColor AS primaryColor,
-              b.accentColor AS accentColor,
-              b.backgroundColor AS backgroundColor,
-              b.tagline AS tagline,
-              logo.contentUrl AS logoUrl,
-              icon.contentUrl AS faviconUrl`,
-      { accountId },
-      { timeout: 2e3 }
-    );
-    const record = result.records[0];
-    if (!record) return null;
-    const name = record.get("name");
-    if (!name) return null;
-    const primaryColor = record.get("primaryColor");
-    const accentColor = record.get("accentColor");
-    const backgroundColor = record.get("backgroundColor");
-    const tagline = record.get("tagline");
-    const logoUrl = record.get("logoUrl");
-    const faviconUrl = record.get("faviconUrl");
-    const hasBranding = primaryColor || accentColor || backgroundColor || tagline || logoUrl || faviconUrl;
-    if (!hasBranding) return null;
-    const branding = { name };
-    if (primaryColor && HEX_COLOR_RE.test(primaryColor)) branding.primaryColor = primaryColor;
-    if (accentColor && HEX_COLOR_RE.test(accentColor)) branding.accentColor = accentColor;
-    if (backgroundColor && HEX_COLOR_RE.test(backgroundColor)) branding.backgroundColor = backgroundColor;
-    if (tagline) branding.tagline = tagline;
-    if (logoUrl) branding.logoUrl = logoUrl;
-    if (faviconUrl) branding.faviconUrl = faviconUrl;
-    console.error(`[branding] resolved for accountId=${accountId.slice(0, 8)}\u2026: primary=${branding.primaryColor ?? "\u2013"} logo=${branding.logoUrl ? "yes" : "no"}`);
-    return branding;
-  } catch (err) {
-    console.error(`[branding] fetchBranding failed for accountId=${accountId.slice(0, 8)}\u2026: ${err instanceof Error ? err.message : String(err)}`);
-    return null;
-  } finally {
-    await session.close();
-  }
-}
-async function fetchAccountName(accountId) {
-  const session = getSession();
-  try {
-    const result = await session.run(
-      `MATCH (b:LocalBusiness {accountId: $accountId}) RETURN b.name AS name`,
-      { accountId },
-      { timeout: 2e3 }
-    );
-    const name = result.records[0]?.get("name")?.trim();
-    if (!name) {
-      console.error(`[branding] account-name-fallback accountId=${accountId.slice(0, 8)}\u2026 reason=no-name`);
-      return null;
-    }
-    return name;
-  } catch (err) {
-    console.error(`[branding] fetchAccountName failed for accountId=${accountId.slice(0, 8)}\u2026: ${err instanceof Error ? err.message : String(err)}`);
-    return null;
-  } finally {
-    await session.close();
-  }
-}
-var SUMMARY_MAX_LEN = 200;
-var persistMessageLocks = /* @__PURE__ */ new Map();
-async function persistMessage(sessionId, role, content, accountId, tokens, createdAt, sender, components, attachments) {
-  if (!content) return null;
-  const messageId = randomUUID();
-  const summary = role === "user" ? content.slice(0, SUMMARY_MAX_LEN).trim() : "";
-  let embedding = null;
-  try {
-    embedding = await embed(content);
-  } catch (err) {
-    console.error(`[persist] Embedding failed, storing without: ${err instanceof Error ? err.message : String(err)}`);
-  }
-  const prev = persistMessageLocks.get(sessionId);
-  const waited = prev !== void 0;
-  let release;
-  const mine = new Promise((resolve7) => {
-    release = resolve7;
-  });
-  const chained = (prev ?? Promise.resolve()).then(() => mine);
-  persistMessageLocks.set(sessionId, chained);
-  await prev;
-  const session = getSession();
-  try {
-    const result = await session.run(
-      `MATCH (c:Conversation {sessionId: $sessionId})
-       OPTIONAL MATCH (tail:Message)-[:PART_OF]->(c)
-         WHERE NOT (tail)-[:NEXT]->(:Message)
-           AND (tail:UserMessage OR tail:AssistantMessage)
-       // sublabel-scope the tail to the agent-path's own sublabels.
-       // Without this, a Task-857 :WhatsAppMessage row (no outgoing :NEXT)
-       // would be picked as tail and the agent-path would chain
-       // :WhatsAppMessage\u2192:UserMessage, crossing the live-channel chain.
-       // The live writer's tail predicate is sublabel-scoped to
-       // :WhatsAppMessage; this clause is the matching defence on the
-       // agent side.
-       // Capture whether THIS write's guard will fire. Read c.summary
-       // before the SET so the boolean reflects the pre-state, not the
-       // post-state \u2014 a false positive otherwise when a new user message
-       // happens to equal an already-set summary (verbatim retry, short
-       // catchphrase) and fooled a post-state equality check.
-       WITH c, tail, (c.summary IS NULL AND $role = 'user' AND $summary <> '') AS summarySetThisWrite
-       CREATE (m:Message:${role === "user" ? "UserMessage" : "AssistantMessage"} {
-         messageId: $messageId,
-         sessionId: $sessionId,
-         accountId: $accountId,
-         role: $role,
-         content: $content,
-         createdAt: ${createdAt ? "datetime($createdAt)" : "datetime()"}
-         ${embedding ? ", embedding: $embedding" : ""}
-         ${sender ? ", senderVisitorId: $senderVisitorId, senderName: $senderName" : ""}
-         ${tokens?.inputTokens != null ? ", inputTokens: $inputTokens" : ""}
-         ${tokens?.outputTokens != null ? ", outputTokens: $outputTokens" : ""}
-         ${tokens?.cacheReadTokens != null ? ", cacheReadTokens: $cacheReadTokens" : ""}
-         ${tokens?.cacheCreationTokens != null ? ", cacheCreationTokens: $cacheCreationTokens" : ""}
-       })
-       SET c.updatedAt = datetime()
-       CREATE (m)-[:PART_OF]->(c)
-       FOREACH (prev IN CASE WHEN tail IS NULL THEN [] ELSE [tail] END |
-         CREATE (prev)-[:NEXT]->(m)
-       )
-       FOREACH (_ IN CASE WHEN summarySetThisWrite THEN [1] ELSE [] END |
-         SET c.summary = $summary
-       )
-       FOREACH (comp IN $components |
-         CREATE (m)-[:HAS_COMPONENT]->(:Component {
-           componentId: comp.componentId,
-           sessionId: $sessionId,
-           accountId: $accountId,
-           messageId: $messageId,
-           name: comp.name,
-           data: comp.data,
-           ordinal: comp.ordinal,
-           textOffset: comp.textOffset,
-           submitted: false,
-           createdAt: datetime(),
-           // store the artefact attachmentId on the:Component
-           // itself when this is a PERSISTENT_COMPONENTS write whose disk
-           // write succeeded. Field is null for non-persistent / mime-skip
-           // / disk-fail components. Lets the audit + backfill scripts
-           // read the attachmentId directly off the :Component row instead
-           // of re-deriving (the live + heal paths use different sources \u2014
-           // sha256(block.id) live, componentId-fallback backfill \u2014 and
-           // the audit must match either).
-           attachmentId: comp.artefactAttachmentId
-         })
-       )
-       // for PERSISTENT_COMPONENTS whose disk write succeeded
-       // (artefactAttachmentId is non-null), MERGE the sibling
-       // :KnowledgeDocument projection AND a :HAS_KNOWLEDGE_DOCUMENT edge
-       // from the parent :Message in the same Cypher tx. ON CREATE stamps
-       // name+encodingFormat from the live render; ON MATCH only bumps
-       // updatedAt so a heal-on-resume re-run cannot clobber an operator's
-       // subsequent rename via the knowledge-documents API (eng-review \xA72).
-       // The edge makes the projection graph-discoverable from the
-       // conversation timeline so file-delete-cascade and conversation
-       // cleanup can reach it. FOREACH on the filtered list collapses to a
-       // no-op when no component has an attachmentId, preserving the
-       // text-only-turn fast path.
-       FOREACH (kd IN $knowledgeDocs |
-         MERGE (k:KnowledgeDocument {accountId: $accountId, attachmentId: kd.attachmentId})
-         ON CREATE SET k.name = kd.title,
-                       k.encodingFormat = kd.mimeType,
-                       k.createdAt = datetime(),
-                       k.updatedAt = datetime()
-         ON MATCH SET k.updatedAt = datetime()
-         MERGE (m)-[:HAS_KNOWLEDGE_DOCUMENT]->(k)
-       )
-       FOREACH (att IN $attachments |
-         CREATE (m)-[:HAS_ATTACHMENT]->(:Attachment {
-           attachmentId: att.attachmentId,
-           sessionId: $sessionId,
-           accountId: $accountId,
-           messageId: $messageId,
-           filename: att.filename,
-           mimeType: att.mimeType,
-           sizeBytes: att.sizeBytes,
-           storagePath: att.storagePath,
-           ordinal: att.ordinal,
-           createdAt: datetime()
-         })
-       )
-       RETURN tail.messageId AS prevMessageId,
-              summarySetThisWrite,
-              size([(m2:Message)-[:PART_OF]->(c) | m2]) AS chainLen`,
-      {
-        messageId,
-        sessionId,
-        accountId,
-        role,
-        content,
-        summary,
-        ...createdAt ? { createdAt } : {},
-        ...embedding ? { embedding } : {},
-        ...sender ? { senderVisitorId: sender.visitorId, senderName: sender.displayName } : {},
-        ...tokens?.inputTokens != null ? { inputTokens: neo4j.int(tokens.inputTokens) } : {},
-        ...tokens?.outputTokens != null ? { outputTokens: neo4j.int(tokens.outputTokens) } : {},
-        ...tokens?.cacheReadTokens != null ? { cacheReadTokens: neo4j.int(tokens.cacheReadTokens) } : {},
-        ...tokens?.cacheCreationTokens != null ? { cacheCreationTokens: neo4j.int(tokens.cacheCreationTokens) } : {},
-        components: (components ?? []).map((comp) => ({
-          componentId: comp.componentId,
-          name: comp.name,
-          data: comp.data,
-          ordinal: neo4j.int(comp.ordinal),
-          textOffset: neo4j.int(comp.textOffset),
-          // null for non-persistent / mime-skip / disk-fail
-          // components; the FOREACH stamps this directly onto the
-          // :Component row so audit + backfill read attachmentId without
-          // re-deriving from componentId.
-          artefactAttachmentId: comp.artefactAttachmentId ?? null
-        })),
-        //:KnowledgeDocument MERGE list. One row per
-        // PERSISTENT_COMPONENTS component whose disk write succeeded;
-        // text-only / mime-skip / disk-fail components are absent so
-        // the FOREACH no-ops on them. attachmentId here matches the
-        // value the stream-parser stamped after writeAttachment.
-        knowledgeDocs: (components ?? []).filter((comp) => typeof comp.artefactAttachmentId === "string").map((comp) => ({
-          attachmentId: comp.artefactAttachmentId,
-          title: comp.artefactTitle ?? "",
-          mimeType: comp.artefactMimeType ?? ""
-        })),
-        attachments: (attachments ?? []).map((att) => ({
-          attachmentId: att.attachmentId,
-          filename: att.filename,
-          mimeType: att.mimeType,
-          sizeBytes: neo4j.int(att.sizeBytes),
-          storagePath: att.storagePath,
-          ordinal: neo4j.int(att.ordinal)
-        }))
-      }
-    );
-    if (result.records.length === 0) {
-      console.error(`[persist] Neo4j write skipped \u2014 conversation not found: ${sessionId.slice(0, 8)}\u2026`);
-      return null;
-    }
-    const record = result.records[0];
-    const prevMessageId = record.get("prevMessageId") ?? null;
-    const summarySetThisWrite = record.get("summarySetThisWrite") === true;
-    const chainLenRaw = record.get("chainLen");
-    const chainLen = typeof chainLenRaw === "bigint" ? Number(chainLenRaw) : typeof chainLenRaw?.toNumber === "function" ? chainLenRaw.toNumber() : Number(chainLenRaw ?? 0);
-    const messageSublabel = role === "user" ? "UserMessage" : "AssistantMessage";
-    console.error(`[neo4j-store] append-message sessionId=${sessionId.slice(0, 8)}\u2026 messageId=${messageId.slice(0, 8)}\u2026 prev=${prevMessageId ? prevMessageId.slice(0, 8) + "\u2026" : "null"} chainLen=${chainLen} waited=${waited} sublabel=${messageSublabel}`);
-    if (summarySetThisWrite) {
-      console.error(`[neo4j-store] conversation-summary-set sessionId=${sessionId.slice(0, 8)}\u2026 len=${summary.length}`);
-    }
-    const componentList = components ?? [];
-    if (componentList.length > 0) {
-      const relsCreated = result.summary.counters.updates().relationshipsCreated;
-      const expectedComponentEdges = componentList.length;
-      const baseEdges = relsCreated - expectedComponentEdges;
-      if (baseEdges < 1) {
-        console.error(`[neo4j-store] persist-component WARN sessionId=${sessionId.slice(0, 8)}\u2026 messageId=${messageId.slice(0, 8)}\u2026 relsCreated=${relsCreated} expected\u2265${1 + expectedComponentEdges} \u2014 component edges may not have been created`);
-      }
-      for (const comp of componentList) {
-        console.error(`[neo4j-store] persist-component sessionId=${sessionId.slice(0, 8)}\u2026 messageId=${messageId.slice(0, 8)}\u2026 componentId=${comp.componentId.slice(0, 8)}\u2026 name=${comp.name} dataLen=${comp.data.length} ordinal=${comp.ordinal} textOffset=${comp.textOffset}`);
-      }
-    }
-    const attachmentList = attachments ?? [];
-    if (attachmentList.length > 0) {
-      const relsCreated = result.summary.counters.updates().relationshipsCreated;
-      const expectedAttachmentEdges = attachmentList.length;
-      const expectedComponentEdges = (components ?? []).length;
-      const baseEdges = relsCreated - expectedComponentEdges - expectedAttachmentEdges;
-      if (baseEdges < 1) {
-        console.error(`[neo4j-store] persist-attachment WARN sessionId=${sessionId.slice(0, 8)}\u2026 messageId=${messageId.slice(0, 8)}\u2026 relsCreated=${relsCreated} expected\u2265${1 + expectedComponentEdges + expectedAttachmentEdges} \u2014 attachment edges may not have been created`);
-      }
-      for (const att of attachmentList) {
-        console.error(`[neo4j-store] persist-attachment sessionId=${sessionId.slice(0, 8)}\u2026 messageId=${messageId.slice(0, 8)}\u2026 attachmentId=${att.attachmentId.slice(0, 8)}\u2026 filename=${att.filename} mimeType=${att.mimeType} sizeBytes=${att.sizeBytes} ordinal=${att.ordinal}`);
-      }
-    }
-    console.error(`[persist] sessionId=${sessionId.slice(0, 8)}\u2026 role=${role} len=${content.length}${sender ? ` sender=${sender.displayName}` : ""}`);
-    return messageId;
-  } catch (err) {
-    console.error(`[persist] Neo4j write failed: ${err instanceof Error ? err.message : String(err)}`);
-    return null;
-  } finally {
-    release();
-    if (persistMessageLocks.get(sessionId) === chained) {
-      persistMessageLocks.delete(sessionId);
-    }
-    await session.close();
-  }
-}
-async function getAgentSessionIdForConversation(sessionId) {
-  const session = getSession();
-  try {
-    const result = await session.run(
-      `MATCH (c:Conversation {sessionId: $sessionId})
-       RETURN c.agentSessionId AS agentSessionId`,
-      { sessionId }
-    );
-    const value = result.records[0]?.get("agentSessionId");
-    return typeof value === "string" && value.length > 0 ? value : null;
-  } catch (err) {
-    console.error(`[persist] agent-session-id read failed convId=${sessionId.slice(0, 8)}\u2026 error=${err instanceof Error ? err.message : String(err)}`);
-    return null;
-  } finally {
-    await session.close();
-  }
-}
-async function getRecentMessages(sessionId, limit = 50) {
-  const session = getSession();
-  try {
-    const result = await session.run(
-      `MATCH (tail:Message {sessionId: $sessionId})
-         WHERE NOT (tail)-[:NEXT]->(:Message)
-       WITH tail ORDER BY tail.createdAt DESC LIMIT 1
-       MATCH path = (m:Message)-[:NEXT*0..]->(tail)
-         WHERE m.sessionId = $sessionId
-           AND length(path) < $limit
-       WITH m, length(path) AS depthFromTail
-       OPTIONAL MATCH (m)-[:HAS_COMPONENT]->(c:Component)
-       WITH m, depthFromTail, c ORDER BY c.ordinal ASC
-       WITH m, depthFromTail,
-            [comp IN collect(c) WHERE comp IS NOT NULL | comp {.*}] AS components
-       OPTIONAL MATCH (m)-[:HAS_ATTACHMENT]->(a:Attachment)
-       WITH m, depthFromTail, components, a ORDER BY a.ordinal ASC
-       WITH m, depthFromTail, components,
-            [att IN collect(a) WHERE att IS NOT NULL | att {.*}] AS attachments
-       RETURN m.messageId AS messageId, m.role AS role, m.content AS content,
-              m.createdAt AS createdAt, components, attachments
-       ORDER BY depthFromTail DESC`,
-      { sessionId, limit: neo4j.int(limit) }
-    );
-    return result.records.map((r) => {
-      const rawComponents = r.get("components") ?? [];
-      const components = rawComponents.map((c) => {
-        const rawAttachmentId = c.attachmentId;
-        const attachmentId = typeof rawAttachmentId === "string" && rawAttachmentId.length > 0 ? rawAttachmentId : void 0;
-        return {
-          componentId: String(c.componentId ?? ""),
-          name: String(c.name ?? ""),
-          data: String(c.data ?? ""),
-          ordinal: typeof c.ordinal?.toNumber === "function" ? c.ordinal.toNumber() : Number(c.ordinal ?? 0),
-          textOffset: typeof c.textOffset?.toNumber === "function" ? c.textOffset.toNumber() : Number(c.textOffset ?? 0),
-          submitted: c.submitted === true,
-          ...attachmentId ? { attachmentId } : {}
-        };
-      });
-      const rawAttachments = r.get("attachments") ?? [];
-      const attachments = rawAttachments.map((a) => ({
-        attachmentId: String(a.attachmentId ?? ""),
-        filename: String(a.filename ?? ""),
-        mimeType: String(a.mimeType ?? ""),
-        sizeBytes: typeof a.sizeBytes?.toNumber === "function" ? a.sizeBytes.toNumber() : Number(a.sizeBytes ?? 0),
-        storagePath: String(a.storagePath ?? ""),
-        ordinal: typeof a.ordinal?.toNumber === "function" ? a.ordinal.toNumber() : Number(a.ordinal ?? 0),
-        accountId: String(a.accountId ?? "")
-      }));
-      return {
-        messageId: r.get("messageId"),
-        role: r.get("role"),
-        content: r.get("content"),
-        createdAt: String(r.get("createdAt")),
-        components,
-        attachments
-      };
-    });
-  } catch (err) {
-    console.error(`[persist] getRecentMessages failed: ${err instanceof Error ? err.message : String(err)}`);
-    return [];
-  } finally {
-    await session.close();
-  }
-}
-async function verifyConversationOwnership(sessionId, accountId) {
-  const session = getSession();
-  try {
-    const result = await session.run(
-      `MATCH (c:Conversation {sessionId: $sessionId, accountId: $accountId})
-       RETURN c.sessionId AS id LIMIT 1`,
-      { sessionId, accountId }
-    );
-    return result.records.length > 0;
-  } catch (err) {
-    console.error(`[persist] verifyConversationOwnership failed: ${err instanceof Error ? err.message : String(err)}`);
-    return false;
-  } finally {
-    await session.close();
-  }
-}
-async function getConversationOwner(sessionId) {
-  const session = getSession();
-  try {
-    const result = await session.run(
-      `MATCH (c:Conversation {sessionId: $sessionId})
-       RETURN c.accountId AS accountId, c.userId AS userId LIMIT 1`,
-      { sessionId }
-    );
-    const record = result.records[0];
-    if (!record) return null;
-    const accountId = record.get("accountId");
-    const userId = record.get("userId");
-    if (!accountId) return null;
-    return { accountId, userId: userId ?? null };
-  } catch (err) {
-    console.error(`[persist] getConversationOwner failed: ${err instanceof Error ? err.message : String(err)}`);
-    return null;
-  } finally {
-    await session.close();
-  }
-}
-async function verifyAndGetConversationUpdatedAt(sessionId, accountId) {
-  const session = getSession();
-  try {
-    const result = await session.run(
-      `MATCH (c:Conversation {sessionId: $sessionId, accountId: $accountId})
-       RETURN toString(c.updatedAt) AS updatedAt LIMIT 1`,
-      { sessionId, accountId }
-    );
-    const record = result.records[0];
-    return record ? record.get("updatedAt") : null;
-  } catch (err) {
-    console.error(`[persist] verifyAndGetConversationUpdatedAt failed: ${err instanceof Error ? err.message : String(err)}`);
-    return null;
-  } finally {
-    await session.close();
-  }
-}
-async function listAdminSessions(accountId, userId, limit = 20) {
-  const session = getSession();
-  try {
-    const result = await session.run(
-      `MATCH (c:Conversation {accountId: $accountId, agentType: 'admin', userId: $userId})
-       WHERE NOT c:Trashed
-       RETURN c.sessionId AS sessionId,
-              c.name AS name,
-              c.updatedAt AS updatedAt,
-              c.channel AS channel
-       ORDER BY c.updatedAt DESC
-       LIMIT $limit`,
-      { accountId, userId, limit: neo4j.int(limit) }
-    );
-    return result.records.map((r) => ({
-      sessionId: r.get("sessionId"),
-      name: r.get("name"),
-      updatedAt: String(r.get("updatedAt")),
-      channel: r.get("channel")
-    }));
-  } catch (err) {
-    console.error(`[persist] listAdminSessions failed: ${err instanceof Error ? err.message : String(err)}`);
-    return [];
-  } finally {
-    await session.close();
-  }
-}
-async function deleteConversation(sessionId) {
-  const session = getSession();
-  try {
-    const result = await session.run(
-      `MATCH (c:Conversation {sessionId: $sessionId})
-       OPTIONAL MATCH (m:Message)-[:PART_OF]->(c)
-       OPTIONAL MATCH (m)-[:HAS_COMPONENT]->(comp:Component)
-       OPTIONAL MATCH (m)-[:HAS_ATTACHMENT]->(att:Attachment)
-       OPTIONAL MATCH (c)-[:HAS_TRANSCRIPT]->(t:ClaudeSession)
-       DETACH DELETE att, comp, m, t, c
-       RETURN count(c) AS deleted`,
-      { sessionId }
-    );
-    const deleted = result.records[0]?.get("deleted");
-    const count = typeof deleted === "object" && deleted !== null ? Number(deleted) : Number(deleted ?? 0);
-    const found = count > 0;
-    console.error(`[persist] deleteConversation ${sessionId.slice(0, 8)}\u2026: ${found ? "deleted" : "not found"}`);
-    return { found };
-  } finally {
-    await session.close();
-  }
-}
-async function linkConversationTranscript(sessionId, claudeSessionId, accountId) {
-  if (!sessionId || !claudeSessionId || !accountId) {
-    console.error(`[transcript-link] schema-violation sessionId=${sessionId ? "set" : "EMPTY"} claudeSessionId=${claudeSessionId ? "set" : "EMPTY"} accountId=${accountId ? "set" : "EMPTY"}`);
-    return { linked: false };
-  }
-  const session = getSession();
-  try {
-    const result = await session.run(
-      `MATCH (c:Conversation {sessionId: $sessionId, accountId: $accountId})
-       MERGE (c)-[:HAS_TRANSCRIPT]->(t:ClaudeSession {claudeSessionId: $claudeSessionId})
-       ON CREATE SET
-         t.accountId = $accountId,
-         t.createdAt = datetime()
-       RETURN count(t) AS linked`,
-      { sessionId, claudeSessionId, accountId }
-    );
-    const linked = Number(result.records[0]?.get("linked") ?? 0) > 0;
-    if (!linked) {
-      console.error(`[transcript-link] convId=${sessionId.slice(0, 8)}\u2026 claudeSessionId=${claudeSessionId.slice(0, 8)}\u2026 status=skipped reason=conversation-not-found`);
-    }
-    return { linked };
-  } catch (err) {
-    console.error(`[transcript-link] convId=${sessionId.slice(0, 8)}\u2026 claudeSessionId=${claudeSessionId.slice(0, 8)}\u2026 status=failed error=${err instanceof Error ? err.message : String(err)}`);
-    return { linked: false };
-  } finally {
-    await session.close();
-  }
-}
-async function getConversationClaudeSessionIds(sessionId, accountId) {
-  const session = getSession();
-  try {
-    const result = await session.run(
-      `MATCH (c:Conversation {sessionId: $sessionId, accountId: $accountId})-[:HAS_TRANSCRIPT]->(t:ClaudeSession)
-       RETURN t.claudeSessionId AS claudeSessionId
-       ORDER BY t.createdAt ASC`,
-      { sessionId, accountId }
-    );
-    return result.records.map((r) => r.get("claudeSessionId")).filter((v) => typeof v === "string" && v.length > 0);
-  } finally {
-    await session.close();
-  }
-}
-async function renameConversation(sessionId, label) {
-  let embedding = null;
-  try {
-    embedding = await embed(label);
-  } catch (err) {
-    console.error(`[persist] manual-label: embedding failed, persisting without: ${err instanceof Error ? err.message : String(err)}`);
-  }
-  const session = getSession();
-  try {
-    await session.run(
-      `MATCH (c:Conversation {sessionId: $sessionId})
-       SET c.name = $label, c.updatedAt = datetime()
-       ${embedding ? ", c.embedding = $embedding" : ""}`,
-      { sessionId, label, ...embedding ? { embedding } : {} }
-    );
-    console.error(`[persist] manual-label: renamed ${sessionId} to "${label}"${embedding ? " (embedded)" : ""}`);
-  } finally {
-    await session.close();
-  }
-}
-var DECAY_THRESHOLD_DAYS = 14;
-var DECAY_RATE_PER_DAY = 0.05;
-var INJECTION_THRESHOLD = 0.4;
-var MAX_SUMMARY_PREFERENCES = 30;
-async function getUserTimezone(accountId, userId) {
-  const session = getSession();
-  try {
-    const query = userId ? `MATCH (up:UserProfile {accountId: $accountId, userId: $userId})
-         RETURN up.timezone AS timezone` : `MATCH (up:UserProfile {accountId: $accountId})
-         RETURN up.timezone AS timezone ORDER BY up.createdAt LIMIT 1`;
-    const result = await session.run(query, { accountId, userId: userId ?? "" });
-    if (result.records.length === 0) return null;
-    const tz = result.records[0].get("timezone");
-    return tz && tz.trim().length > 0 ? tz : null;
-  } catch (err) {
-    console.error(`[datetime] getUserTimezone failed: ${err instanceof Error ? err.message : String(err)}`);
-    return null;
-  } finally {
-    await session.close();
-  }
-}
-async function loadAdminUserName(userId) {
-  const session = getSession();
-  try {
-    const result = await session.run(
-      `MATCH (au:AdminUser {userId: $userId})-[:OWNS]->(p:Person)
-       WHERE p.accountId = au.accountId
-       RETURN p.givenName AS givenName, p.familyName AS familyName, p.avatar AS avatar
-       LIMIT 1`,
-      { userId }
-    );
-    if (result.records.length === 0) {
-      return { source: "fallback", reason: "no-person-node" };
-    }
-    const givenName = result.records[0].get("givenName");
-    const familyName = result.records[0].get("familyName");
-    const avatar = result.records[0].get("avatar");
-    if (!givenName || givenName.trim().length === 0) {
-      return { source: "fallback", reason: "no-givenName" };
-    }
-    const trimmedFamily = familyName && familyName.trim().length > 0 ? familyName.trim() : null;
-    const trimmedAvatar = avatar && avatar.trim().length > 0 ? avatar.trim() : null;
-    const joined = trimmedFamily ? `${givenName.trim()} ${trimmedFamily}` : givenName.trim();
-    return { source: "neo4j", joined, givenName: givenName.trim(), familyName: trimmedFamily, avatar: trimmedAvatar };
-  } catch (err) {
-    console.error(`[admin-identity] loadAdminUserName failed: ${err instanceof Error ? err.message : String(err)}`);
-    return { source: "fallback", reason: "neo4j-unreachable" };
-  } finally {
-    await session.close();
-  }
-}
-async function loadPersonNameByElementId(accountId, personId) {
-  const session = getSession();
-  try {
-    const result = await session.run(
-      `MATCH (p:Person {accountId: $accountId})
-       WHERE elementId(p) = $personId
-       RETURN p.givenName AS givenName, p.familyName AS familyName
-       LIMIT 1`,
-      { accountId, personId },
-      { timeout: 2e3 }
-    );
-    if (result.records.length === 0) return null;
-    const given = result.records[0].get("givenName");
-    const family = result.records[0].get("familyName");
-    if (!given || given.trim().length === 0) return null;
-    const fam = family && family.trim().length > 0 ? family.trim() : null;
-    return fam ? `${given.trim()} ${fam}` : given.trim();
-  } catch (err) {
-    console.error(
-      `[admin-sessions-list] loadPersonNameByElementId failed: ${err instanceof Error ? err.message : String(err)}`
-    );
-    return null;
-  } finally {
-    await session.close();
-  }
-}
-async function writeAdminUserAndPerson(params) {
-  const { userId, fullName, accountId } = params;
-  const trimmed = fullName.trim();
-  if (!trimmed) {
-    throw new Error("writeAdminUserAndPerson: fullName cannot be empty");
-  }
-  const firstSpace = trimmed.search(/\s/);
-  const givenName = firstSpace === -1 ? trimmed : trimmed.slice(0, firstSpace).trim();
-  const familyName = firstSpace === -1 ? null : trimmed.slice(firstSpace + 1).trim() || null;
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  let personEmbedding = null;
-  try {
-    personEmbedding = await embed(
-      `[Person] ${[givenName, familyName].filter(Boolean).join(" ")} role: admin-personal`
-    );
-  } catch (err) {
-    process.stderr.write(
-      `[graph-write] warn reason=embed-failed labels=Person agent=admin-bootstrap detail=${err instanceof Error ? err.message : String(err)}
-`
-    );
-  }
-  const serverTimezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
-  const session = getSession();
-  try {
-    const result = await session.run(
-      `MERGE (au:AdminUser {userId: $userId})
-       // Task 669 \u2014 stamp accountId/role at creation so the account-scoped
-       // graph-write gate (MATCH (au:AdminUser {accountId:$accountId})) matches
-       // on the operator's first memory write. Mirrors seed-neo4j.sh:175-181
-       // and the sibling writers (neo4j-store.ts:537,:931). COALESCE on MATCH
-       // preserves an already-stamped node.
-       ON CREATE SET au.createdAt = $now,
-                     au.accountId = $accountId, au.role = 'owner'
-       ON MATCH SET au.updatedAt = $now,
-                    au.accountId = COALESCE(au.accountId, $accountId),
-                    au.role = COALESCE(au.role, 'owner')
-       WITH au
-
-       // Task 1150 \u2014 UserProfile guaranteed off the just-MERGEd AdminUser.
-       MERGE (au)-[:HAS_PROFILE]->(up:UserProfile {accountId: $accountId, userId: $userId})
-       ON CREATE SET
-         up.createdAt = $now,
-         up.updatedAt = $now,
-         up.profileVersion = 0,
-         up.scope = 'admin',
-         up.timezone = $serverTimezone,
-         up.timezoneSource = 'server-default'
-       ON MATCH SET
-         up.timezoneSource = CASE WHEN up.timezone IS NULL OR trim(up.timezone) = '' THEN 'server-default' ELSE up.timezoneSource END,
-         up.timezone = CASE WHEN up.timezone IS NULL OR trim(up.timezone) = '' THEN $serverTimezone ELSE up.timezone END
-       WITH au, (up.createdAt = $now) AS profileIsNew
-
-       // Case-insensitive Person reuse: same accountId, same givenName, same familyName
-       // (null/empty familyName collapsed to '' so 'Joel' does NOT match 'Joel Smalley').
-       OPTIONAL MATCH (existingPerson:Person {accountId: $accountId})
-       WHERE toLower(existingPerson.givenName) = toLower($givenName)
-         AND coalesce(toLower(existingPerson.familyName), '') = coalesce(toLower($familyName), '')
-       WITH au, profileIsNew, existingPerson
-
-       CALL {
-         WITH au, existingPerson
-         WITH au, existingPerson WHERE existingPerson IS NOT NULL
-         MERGE (au)-[:OWNS]->(existingPerson)
-         RETURN existingPerson AS p, true AS reused
-         UNION
-         WITH au, existingPerson
-         WITH au WHERE existingPerson IS NULL
-         CREATE (newPerson:Person {
-           accountId: $accountId,
-           givenName: $givenName,
-           familyName: $familyName,
-           role: 'admin-personal',
-           scope: 'admin',
-           embedding: $personEmbedding,
-           createdAt: $now
-         })
-         MERGE (au)-[:OWNS]->(newPerson)
-         RETURN newPerson AS p, false AS reused
-       }
-       RETURN reused, profileIsNew, elementId(p) AS personElementId,
-              p.givenName AS givenName, p.familyName AS familyName`,
-      { userId, accountId, givenName, familyName, now, personEmbedding, serverTimezone }
-    );
-    if (result.records.length === 0) {
-      throw new Error("writeAdminUserAndPerson: no record returned");
-    }
-    const record = result.records[0];
-    if (record.get("profileIsNew")) {
-      console.error(
-        `[profile] provisioned at admin-bootstrap userId=${userId} accountId=${accountId.slice(0, 8)}\u2026 timezone=${serverTimezone}`
-      );
-    }
-    return {
-      personReused: record.get("reused"),
-      personElementId: record.get("personElementId"),
-      givenName: record.get("givenName"),
-      familyName: record.get("familyName")
-    };
-  } finally {
-    await session.close();
-  }
-}
-var PROFILE_CATEGORIES = [
-  "communication",
-  "scheduling",
-  "decision",
-  "workflow",
-  "content",
-  "interaction"
-];
-var PROFILE_FIELD_TEMPLATES = {
-  communication: [
-    "preferredChannel",
-    "quietHours",
-    "responseLatencyExpectation",
-    "formalityLevel",
-    "escalationPath"
-  ],
-  scheduling: [
-    "workdayStartTime",
-    "workdayEndTime",
-    "weekendAvailability",
-    "meetingBlockPreference",
-    "focusBlockTiming"
-  ],
-  decision: [
-    "riskTolerance",
-    "autonomyBoundary",
-    "evidenceThreshold",
-    "reversibilityPreference",
-    "stakeholderConsultation"
-  ],
-  workflow: [
-    "batchingPreference",
-    "taskGranularity",
-    "deepWorkBlocks",
-    "statusUpdateCadence",
-    "toolingChoices"
-  ],
-  content: [
-    "outputFormat",
-    "lengthPreference",
-    "citationStyle",
-    "tonality"
-  ],
-  interaction: [
-    "addressForm",
-    "humourTolerance",
-    "directnessLevel",
-    "emotionalRegisterPreference"
-  ]
-};
-var TOTAL_PROFILE_FIELDS = Object.values(PROFILE_FIELD_TEMPLATES).reduce(
-  (n, fs) => n + fs.length,
-  0
-);
-function computeAbsentFields(preferences, extraTemplates = {}) {
-  const covered = /* @__PURE__ */ new Set();
-  for (const pref of preferences) {
-    const isCovered = pref.notApplicable === true || pref.confidence >= INJECTION_THRESHOLD;
-    if (isCovered) covered.add(`${pref.category}.${pref.key}`);
-  }
-  const absent = [];
-  for (const [category, fields] of Object.entries(PROFILE_FIELD_TEMPLATES)) {
-    for (const field of fields) {
-      const dotted = `${category}.${field}`;
-      if (!covered.has(dotted)) absent.push(dotted);
-    }
-  }
-  for (const [category, fields] of Object.entries(extraTemplates)) {
-    if (category in PROFILE_FIELD_TEMPLATES) continue;
-    for (const field of fields) {
-      const dotted = `${category}.${field}`;
-      if (!covered.has(dotted)) absent.push(dotted);
-    }
-  }
-  return absent;
-}
-function parsePluginProfileKeys(manifest) {
-  const fm = manifest.match(/^---\n([\s\S]*?)\n---/);
-  if (!fm) return [];
-  const out = [];
-  let inBlock = false;
-  for (const line of fm[1].split("\n")) {
-    if (/^profileKeys:/.test(line)) {
-      inBlock = true;
-      continue;
-    }
-    if (inBlock) {
-      const m = line.match(/^\s+-\s+(.+?)\s*$/);
-      if (m) out.push(m[1]);
-      else break;
-    }
-  }
-  return out;
-}
-function loadEnabledPluginProfileKeys(accountId) {
-  const accountFile = resolve6(PLATFORM_ROOT3, "..", "data/accounts", accountId, "account.json");
-  if (!existsSync7(accountFile)) return {};
-  let enabled;
-  try {
-    const raw2 = readFileSync9(accountFile, "utf-8");
-    const parsed = JSON.parse(raw2);
-    enabled = Array.isArray(parsed.enabledPlugins) ? parsed.enabledPlugins.filter((p) => typeof p === "string") : [];
-  } catch (err) {
-    console.error(
-      `[profile-keys] account.json read failed for ${accountId.slice(0, 8)}\u2026: ${err instanceof Error ? err.message : String(err)}`
-    );
-    return {};
-  }
-  const merged = {};
-  for (const pluginName of enabled) {
-    const manifestPath = resolve6(PLATFORM_ROOT3, "plugins", pluginName, "PLUGIN.md");
-    if (!existsSync7(manifestPath)) continue;
-    let manifest;
-    try {
-      manifest = readFileSync9(manifestPath, "utf-8");
-    } catch {
-      continue;
-    }
-    for (const dotted of parsePluginProfileKeys(manifest)) {
-      const dot = dotted.indexOf(".");
-      if (dot <= 0 || dot === dotted.length - 1) {
-        console.error(`[profile-keys] malformed dotted key in ${pluginName}: ${dotted}`);
-        continue;
-      }
-      const category = dotted.slice(0, dot);
-      const key = dotted.slice(dot + 1);
-      if (!merged[category]) merged[category] = /* @__PURE__ */ new Set();
-      merged[category].add(key);
-    }
-  }
-  const out = {};
-  for (const [cat, set] of Object.entries(merged)) out[cat] = [...set];
-  return out;
-}
-var sparseStateLogged = /* @__PURE__ */ new Set();
-async function loadUserProfile(accountId, userId, sessionId) {
-  console.error(
-    `[profile] loadUserProfile entry accountId=${accountId.slice(0, 8)}\u2026 userId=${userId} sessionId=${sessionId ? `${sessionId.slice(0, 8)}\u2026` : "<none>"}`
-  );
-  const session = getSession();
-  try {
-    const serverTimezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
-    const mergeResult = await session.run(
-      `MATCH (au:AdminUser {userId: $userId})
-       MERGE (au)-[:HAS_PROFILE]->(up:UserProfile {accountId: $accountId, userId: $userId})
-       ON CREATE SET
-         up.createdAt = $now,
-         up.updatedAt = $now,
-         up.profileVersion = 0,
-         up.scope = 'admin',
-         up.timezone = $serverTimezone,
-         up.timezoneSource = 'server-default'
-       ON MATCH SET
-         up.timezoneSource = CASE WHEN up.timezone IS NULL OR trim(up.timezone) = '' THEN 'server-default' ELSE up.timezoneSource END,
-         up.timezone = CASE WHEN up.timezone IS NULL OR trim(up.timezone) = '' THEN $serverTimezone ELSE up.timezone END
-       RETURN up.createdAt = $now AS isNew`,
-      { accountId, userId, now: (/* @__PURE__ */ new Date()).toISOString(), serverTimezone }
-    );
-    if (mergeResult.records.length === 0) {
-      console.error(`[profile] loadUserProfile: AdminUser not found for userId=${userId} accountId=${accountId.slice(0, 8)}\u2026 \u2014 profile not created, invariant violated`);
-      return null;
-    }
-    const isNew = mergeResult.records[0].get("isNew");
-    if (isNew) {
-      console.error(`[profile] created new profile: userId=${userId} accountId=${accountId.slice(0, 8)}\u2026 timezone=${serverTimezone}`);
-    }
-    const nowMs = Date.now();
-    const thresholdMs = DECAY_THRESHOLD_DAYS * 24 * 60 * 60 * 1e3;
-    const staleResult = await session.run(
-      `MATCH (up:UserProfile {accountId: $accountId, userId: $userId})-[:HAS_PREFERENCE]->(pref:Preference)
-       WHERE pref.observedAt IS NOT NULL
-       RETURN pref.preferenceId AS preferenceId,
-              pref.observedAt AS observedAt,
-              pref.confidence AS confidence`,
-      { accountId, userId }
-    );
-    let decayCount = 0;
-    for (const record of staleResult.records) {
-      const observedAt = record.get("observedAt");
-      const confidence = record.get("confidence");
-      const observedMs = new Date(observedAt).getTime();
-      const ageMs = nowMs - observedMs;
-      if (ageMs > thresholdMs && confidence > 0) {
-        const daysPastThreshold = (ageMs - thresholdMs) / (24 * 60 * 60 * 1e3);
-        const decayedConfidence = Math.max(0, confidence - DECAY_RATE_PER_DAY * daysPastThreshold);
-        if (decayedConfidence !== confidence) {
-          await session.run(
-            `MATCH (pref:Preference {preferenceId: $preferenceId, accountId: $accountId})
-             SET pref.confidence = $confidence`,
-            {
-              preferenceId: record.get("preferenceId"),
-              accountId,
-              confidence: decayedConfidence
-            }
-          );
-          decayCount++;
-        }
-      }
-    }
-    const result = await session.run(
-      `MATCH (up:UserProfile {accountId: $accountId, userId: $userId})
-       OPTIONAL MATCH (au:AdminUser {userId: $userId})-[:OWNS]->(p:Person {accountId: $accountId})
-       OPTIONAL MATCH (up)-[:HAS_PREFERENCE]->(pref:Preference)
-       WHERE pref.confidence >= $threshold OR pref.notApplicable = true
-       WITH up, p, pref
-       ORDER BY pref.confidence DESC
-       WITH up, p, collect(pref) AS allPrefs
-       WITH up, p, allPrefs[0..$limit] AS prefs
-       RETURN up, p AS person, prefs`,
-      // List-range slice bounds are an integer position; a raw JS number
-      // serializes as a Cypher float. Bind a Neo4j integer.
-      { accountId, userId, threshold: INJECTION_THRESHOLD, limit: neo4j.int(MAX_SUMMARY_PREFERENCES) }
-    );
-    if (result.records.length === 0 || !result.records[0].get("up")) {
-      return null;
-    }
-    const upNode = result.records[0].get("up");
-    const profileProps = { ...upNode.properties };
-    const personNode = result.records[0].get("person");
-    if (personNode?.properties) {
-      if (personNode.properties.givenName !== void 0) profileProps.givenName = personNode.properties.givenName;
-      if (personNode.properties.familyName !== void 0) profileProps.familyName = personNode.properties.familyName;
-      if (personNode.properties.email !== void 0) profileProps.email = personNode.properties.email;
-      if (personNode.properties.telephone !== void 0) profileProps.telephone = personNode.properties.telephone;
-    }
-    const prefNodes = result.records[0].get("prefs");
-    const preferences = prefNodes.map((p) => ({
-      preferenceId: p.properties.preferenceId,
-      category: p.properties.category,
-      key: p.properties.key,
-      value: p.properties.value,
-      confidence: p.properties.confidence,
-      source: p.properties.source,
-      observedAt: p.properties.observedAt,
-      notApplicable: p.properties.notApplicable === true
-    }));
-    const extraTemplates = loadEnabledPluginProfileKeys(accountId);
-    const extraFieldCount = Object.values(extraTemplates).reduce((n, fs) => n + fs.length, 0);
-    const summary = formatProfileSummary(profileProps, preferences, extraTemplates);
-    const absentFields = computeAbsentFields(preferences, extraTemplates);
-    const totalFields = TOTAL_PROFILE_FIELDS + extraFieldCount;
-    const fieldCoverageCount = totalFields - absentFields.length;
-    const presentCategories = new Set(
-      preferences.filter((p) => p.notApplicable === true || p.confidence >= INJECTION_THRESHOLD).map((p) => p.category)
-    );
-    const absentCategories = PROFILE_CATEGORIES.filter((c) => !presentCategories.has(c));
-    const categoryCoverage = PROFILE_CATEGORIES.length - absentCategories.length;
-    console.error(
-      `[profile] loaded for userId=${userId} accountId=${accountId.slice(0, 8)}\u2026 preferences=${preferences.length} fieldCoverage=${fieldCoverageCount}/${totalFields} categoryCoverage=${categoryCoverage}/${PROFILE_CATEGORIES.length} (decay: ${decayCount} updated)`
-    );
-    const identityKeys = [
-      { prop: "email", token: "email" },
-      // Schema-canonical name. `phone` is the synonym (rejected at tool
-      // surface); the log uses `telephone` to keep grep aligned with
-      // schema-base.md doctrine the brief enforces.
-      { prop: "telephone", token: "telephone" },
-      { prop: "givenName", token: "givenName" },
-      { prop: "familyName", token: "familyName" },
-      { prop: "role", token: "role" }
-    ];
-    const absentIdentity = identityKeys.filter((k) => {
-      const v = profileProps[k.prop];
-      return typeof v !== "string" || v.trim().length === 0;
-    });
-    const sparseFired = absentCategories.length > 0 || absentFields.length > 0 || absentIdentity.length > 0;
-    if (sessionId && sparseFired) {
-      const dedupeKey = `${accountId}:${userId}:${sessionId}`;
-      if (!sparseStateLogged.has(dedupeKey)) {
-        sparseStateLogged.add(dedupeKey);
-        const FIELDS_LOG_CAP = 10;
-        const absentFieldsTruncated = absentFields.length <= FIELDS_LOG_CAP ? absentFields.join(",") : `${absentFields.slice(0, FIELDS_LOG_CAP).join(",")}+${absentFields.length - FIELDS_LOG_CAP} more`;
-        console.error(
-          `[profile] sparse-state injected accountId=${accountId.slice(0, 8)}\u2026 userId=${userId} sessionId=${sessionId.slice(0, 8)}\u2026 absentCategories=${absentCategories.join(",")} absentFields=${absentFieldsTruncated || "none"} absentIdentity=${absentIdentity.map((k) => k.token).join(",") || "none"}`
-        );
-      }
-    }
-    return summary;
-  } catch (err) {
-    console.error(`[profile] loadUserProfile failed: ${err instanceof Error ? err.message : String(err)}`);
-    return null;
-  } finally {
-    await session.close();
-  }
-}
-function formatProfileSummary(profile, preferences, extraTemplates = {}) {
-  const summary = composeOperatorSummary(profile, preferences);
-  return [
-    `This is what you know about the operator: ${summary}.`,
-    `You must seek to MAXIMISE what you know about the operator to do your job effectively.`
-  ].join("\n");
-}
-function composeOperatorSummary(profile, preferences) {
-  const facts = [];
-  const givenName = typeof profile.givenName === "string" ? profile.givenName.trim() : "";
-  const familyName = typeof profile.familyName === "string" ? profile.familyName.trim() : "";
-  const fullName = [givenName, familyName].filter((s) => s.length > 0).join(" ");
-  if (fullName) facts.push(`name ${fullName}`);
-  if (typeof profile.role === "string" && profile.role.trim()) {
-    facts.push(`role ${profile.role.trim()}`);
-  }
-  if (typeof profile.timezone === "string" && profile.timezone.trim()) {
-    facts.push(`timezone ${profile.timezone.trim()}`);
-  }
-  if (typeof profile.locale === "string" && profile.locale.trim()) {
-    facts.push(`locale ${profile.locale.trim()}`);
-  }
-  if (typeof profile.email === "string" && profile.email.trim()) {
-    facts.push(`email ${profile.email.trim()}`);
-  }
-  if (typeof profile.telephone === "string" && profile.telephone.trim()) {
-    facts.push(`telephone ${profile.telephone.trim()}`);
-  }
-  if (profile.expertise) {
-    const expVal = typeof profile.expertise === "string" ? profile.expertise : JSON.stringify(profile.expertise);
-    if (expVal.trim()) facts.push(`expertise ${expVal.trim()}`);
-  }
-  const byCategory = {};
-  for (const pref of preferences) {
-    if (pref.notApplicable === true) continue;
-    if (typeof pref.value !== "string" || pref.value.trim().length === 0) continue;
-    if (!byCategory[pref.category]) byCategory[pref.category] = [];
-    byCategory[pref.category].push(pref.value.trim());
-  }
-  for (const [cat, vals] of Object.entries(byCategory)) {
-    facts.push(`${cat} ${vals.join(", ")}`);
-  }
-  return facts.length > 0 ? facts.join("; ") : "NOTHING";
-}
-var RECENT_FAILURES_TAIL_BYTES = 10 * 1024;
-var AGENT_FILE_ROLES = [
-  { filename: "IDENTITY.md", role: "identity" },
-  { filename: "SOUL.md", role: "soul" },
-  { filename: "KNOWLEDGE.md", role: "knowledge" },
-  { filename: "KNOWLEDGE-SUMMARY.md", role: "knowledge-summary" }
-];
-var ROLE_TO_EDGE = {
-  identity: "HAS_IDENTITY",
-  soul: "HAS_SOUL",
-  knowledge: "HAS_KNOWLEDGE",
-  "knowledge-summary": "HAS_KNOWLEDGE"
-};
-function assertSafeAgentSlug(slug) {
-  if (!slug || slug.includes("/") || slug.includes("\\") || slug.includes("..")) {
-    throw new Error(`[agent-graph] refusing unsafe slug=${JSON.stringify(slug)}`);
-  }
-}
-function agentAttachmentId(accountId, slug, role) {
-  return `agent:${accountId}:${slug}:${role}`;
-}
-async function projectAgent(accountId, accountDir, slug) {
-  const start = Date.now();
-  const account8 = accountId.slice(0, 8);
-  try {
-    assertSafeAgentSlug(slug);
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    console.error(
-      `[agent-graph] project FAILED slug=${slug} account=${account8} error="${msg}"`
-    );
-    return;
-  }
-  const agentDir = resolve6(accountDir, "agents", slug);
-  const configPath = resolve6(agentDir, "config.json");
-  let config;
-  let presentRoles = [];
-  try {
-    if (!existsSync7(configPath)) {
-      console.error(
-        `[agent-graph] project FAILED slug=${slug} account=${account8} error="config.json missing at ${configPath}"`
-      );
-      return;
-    }
-    config = JSON.parse(readFileSync9(configPath, "utf-8"));
-    for (const { filename, role } of AGENT_FILE_ROLES) {
-      const filePath = resolve6(agentDir, filename);
-      if (!existsSync7(filePath)) continue;
-      const body = readFileSync9(filePath, "utf-8");
-      presentRoles.push({ role, body, edge: ROLE_TO_EDGE[role] });
-    }
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    console.error(
-      `[agent-graph] project FAILED slug=${slug} account=${account8} error="${msg}"`
-    );
-    return;
-  }
-  const session = getSession();
-  try {
-    await session.run(
-      `MERGE (a:Agent {accountId: $accountId, slug: $slug})
-       ON CREATE SET a.createdAt = datetime()
-       SET a.displayName = $displayName,
-           a.status = $status,
-           a.model = $model,
-           a.knowledgeKeywords = $knowledgeKeywords,
-           a.role = 'agent',
-           a.updatedAt = datetime()
-       RETURN a.slug AS slug`,
-      {
-        accountId,
-        slug,
-        displayName: config.displayName ?? slug,
-        status: config.status ?? "unknown",
-        model: config.model ?? "",
-        knowledgeKeywords: config.knowledgeKeywords ?? []
-      }
-    );
-    for (const { role, body, edge } of presentRoles) {
-      const attachmentId = agentAttachmentId(accountId, slug, role);
-      await session.run(
-        `MATCH (a:Agent {accountId: $accountId, slug: $slug})
-         MERGE (k:KnowledgeDocument {attachmentId: $attachmentId})
-         ON CREATE SET k.createdAt = datetime()
-         SET k.accountId = $accountId,
-             k.role = $role,
-             k.name = $name,
-             k.text = $text,
-             k.scope = 'admin',
-             k.updatedAt = datetime()
-         MERGE (a)-[:${edge}]->(k)
-         RETURN k.attachmentId AS attachmentId`,
-        {
-          accountId,
-          slug,
-          attachmentId,
-          role,
-          name: `${slug} ${role}`,
-          text: body
-        }
-      );
-    }
-    const usesResult = await session.run(
-      `MATCH (a:Agent {accountId: $accountId, slug: $slug})
-       MATCH (k:KnowledgeDocument {accountId: $accountId})
-       WHERE $slug IN coalesce(k.agents, [])
-         AND NOT k.attachmentId STARTS WITH $namespacePrefix
-       MERGE (a)-[:USES_KNOWLEDGE]->(k)
-       RETURN count(k) AS uses`,
-      {
-        accountId,
-        slug,
-        namespacePrefix: `agent:${accountId}:${slug}:`
-      }
-    );
-    const uses = usesResult.records[0]?.get("uses");
-    const usesCount = typeof uses === "number" ? uses : uses && typeof uses.toNumber === "function" ? uses.toNumber() : 0;
-    const ms = Date.now() - start;
-    console.error(
-      `[agent-graph] project slug=${slug} account=${account8} docs=${presentRoles.length} uses=${usesCount} ms=${ms}`
-    );
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    console.error(
-      `[agent-graph] project FAILED slug=${slug} account=${account8} error="${msg}"`
-    );
-    throw err;
-  } finally {
-    await session.close();
-  }
-}
-async function deleteAgentProjection(accountId, slug) {
-  const start = Date.now();
-  const account8 = accountId.slice(0, 8);
-  assertSafeAgentSlug(slug);
-  const session = getSession();
-  try {
-    await session.run(
-      `MATCH (a:Agent {accountId: $accountId, slug: $slug})
-       DETACH DELETE a
-       WITH 1 AS _
-       UNWIND $attachmentIds AS aid
-       OPTIONAL MATCH (k:KnowledgeDocument {accountId: $accountId, attachmentId: aid})
-       WHERE k.attachmentId STARTS WITH $namespacePrefix
-       DETACH DELETE k`,
-      {
-        accountId,
-        slug,
-        namespacePrefix: `agent:${accountId}:${slug}:`,
-        attachmentIds: ["identity", "soul", "knowledge", "knowledge-summary"].map((role) => agentAttachmentId(accountId, slug, role))
-      }
-    );
-    const ms = Date.now() - start;
-    console.error(
-      `[agent-graph] delete slug=${slug} account=${account8} ms=${ms}`
-    );
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    console.error(
-      `[agent-graph] delete FAILED slug=${slug} account=${account8} error="${msg}"`
-    );
-    throw err;
-  } finally {
-    await session.close();
-  }
-}
-
 // server/routes/_helpers.ts
 async function safeJson(c) {
   try {
@@ -6207,34 +4305,6 @@ export {
   Hono2 as Hono,
   getRequestListener,
   serve,
-  MAXY_DIR,
-  BRAND_NAME,
-  COMMERCIAL_MODE,
-  VNC_DISPLAY,
-  RFB_PORT,
-  WEBSOCKIFY_PORT,
-  CDP_PORT,
-  CHROMIUM_PROFILE_DIR,
-  USERS_FILE,
-  LID_MAP_FILE,
-  LOG_DIR,
-  USERS_AUDIT_LOG,
-  BIN_DIR,
-  REMOTE_PASSWORD_FILE,
-  INSTALL_OWNER_FILE,
-  VISITOR_TOKEN_SECRET_FILE,
-  CLAUDE_CREDENTIALS_FILE,
-  SYSTEM_PATH_SLUGS,
-  PLATFORM_ROOT2 as PLATFORM_ROOT,
-  ACCOUNTS_DIR,
-  listValidAccounts,
-  isValidAccountId,
-  resolveAccount,
-  validateAgentSlug,
-  resolveDefaultAgentSlug,
-  resolveAgentConfig,
-  isActiveAgentSlug,
-  getDefaultAccountId,
   requirePortEnv,
   fingerprintSessionKey,
   registerSession,
@@ -6290,35 +4360,6 @@ export {
   cleanupLeakedPremiumSubs,
   emitMissingOnResolve,
   stripAttachmentMetaSuffix,
-  getSession,
-  runAdminUserSelfHeal,
-  runUserProfileReconcile,
-  embed,
-  preloadEmbedModel,
-  GREETING_DIRECTIVE,
-  ensureConversation,
-  ensureSessionConversation,
-  findRecentConversation,
-  createNewAdminConversation,
-  fetchBranding,
-  fetchAccountName,
-  persistMessage,
-  getAgentSessionIdForConversation,
-  getRecentMessages,
-  verifyConversationOwnership,
-  verifyAndGetConversationUpdatedAt,
-  listAdminSessions,
-  deleteConversation,
-  linkConversationTranscript,
-  getConversationClaudeSessionIds,
-  renameConversation,
-  getUserTimezone,
-  loadAdminUserName,
-  loadPersonNameByElementId,
-  writeAdminUserAndPerson,
-  loadUserProfile,
-  projectAgent,
-  deleteAgentProjection,
   safeJson,
   resolveCacheKey,
   requireAdminSession,