@rubytech/create-sitedesk-code 0.1.517 → 0.1.519

package/payload/server/chunk-PXNY2TAP.js

@@ -0,0 +1,1980 @@
+import { createRequire as __createRequire } from 'node:module'; const require = __createRequire(import.meta.url);
+
+// 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 entries = readdirSync(ACCOUNTS_DIR, { withFileTypes: true });
+  for (const entry of entries) {
+    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 raw = readFileSync3(USERS_FILE, "utf-8").trim();
+      if (raw) {
+        const users = JSON.parse(raw);
+        if (users.length > 0) {
+          usersJsonUserId = users[0].userId;
+        }
+      }
+    } catch {
+    }
+  }
+  const entries = readdirSync(ACCOUNTS_DIR, { withFileTypes: true });
+  let fallback = null;
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const configPath = resolve2(ACCOUNTS_DIR, entry.name, "account.json");
+    if (!existsSync3(configPath)) continue;
+    const raw = readFileSync3(configPath, "utf-8");
+    let config;
+    try {
+      config = JSON.parse(raw);
+    } 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 raw = readFileSync3(filePath, "utf-8");
+  if (filename.endsWith(".md")) {
+    return substituteBrandPlaceholders(raw, filePath);
+  }
+  return raw;
+}
+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;
+}
+
+// app/lib/neo4j-store.ts
+import neo4j from "neo4j-driver";
+import { randomUUID } from "crypto";
+import { readFileSync as readFileSync4, readdirSync as readdirSync2, existsSync as existsSync4, openSync, readSync, closeSync, statSync as statSync2 } from "fs";
+import { resolve as resolve3 } from "path";
+var PLATFORM_ROOT3 = process.env.MAXY_PLATFORM_ROOT ?? resolve3(process.cwd(), "..");
+var driver = null;
+function readPassword() {
+  if (process.env.NEO4J_PASSWORD) return process.env.NEO4J_PASSWORD;
+  const passwordFile = resolve3(PLATFORM_ROOT3, "config/.neo4j-password");
+  try {
+    return readFileSync4(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 raw = process.env[name];
+  if (raw === void 0 || raw === "") return def;
+  const n = Number(raw);
+  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(cacheKey) {
+  return sessionStoreRef?.get(cacheKey)?.sessionId;
+}
+function cacheSessionId(cacheKey, sessionId) {
+  const session = sessionStoreRef?.get(cacheKey);
+  if (session) {
+    session.sessionId = sessionId;
+  }
+}
+var GREETING_DIRECTIVE = "[New session. Greet the visitor.]";
+async function ensureConversation(accountId, agentType, cacheKey, visitorId, agentSlug, userId, channelOverride, channelAddressOverride) {
+  const cached = getCachedSessionId(cacheKey);
+  if (cached) return { sessionId: cached, created: false };
+  const sessionId = randomUUID();
+  const channel = channelOverride ?? (cacheKey.startsWith("whatsapp:") ? "whatsapp" : cacheKey.startsWith("telegram:") ? "telegram" : "webchat");
+  const channelAddress = channelAddressOverride ?? (cacheKey.startsWith("whatsapp:") ? cacheKey.slice("whatsapp:".length) : cacheKey.startsWith("telegram:") ? cacheKey.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(cacheKey, 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 id8 = id.slice(0, 8);
+        if (handled === true) {
+          console.error(`[agent-graph] handled-by-write sessionId=${id8} slug=${handlerSlug}`);
+        } else {
+          console.error(`[agent-graph] handled-by-skip reason=no-agent-node sessionId=${id8} 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, cacheKey, preMintedSessionId) {
+  if (!userId || !cacheKey || !accountId) {
+    console.error(`[admin/conversation-write] schema-violation userId=${userId ? "set" : "EMPTY"} cacheKey=${cacheKey ? "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(cacheKey, sessionId);
+    console.log(`[session] conversation created: sessionId=${sessionId.slice(0, 8)}\u2026 cacheKey=${cacheKey.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((resolve4) => {
+    release = resolve4;
+  });
+  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 = resolve3(PLATFORM_ROOT3, "..", "data/accounts", accountId, "account.json");
+  if (!existsSync4(accountFile)) return {};
+  let enabled;
+  try {
+    const raw = readFileSync4(accountFile, "utf-8");
+    const parsed = JSON.parse(raw);
+    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 = resolve3(PLATFORM_ROOT3, "plugins", pluginName, "PLUGIN.md");
+    if (!existsSync4(manifestPath)) continue;
+    let manifest;
+    try {
+      manifest = readFileSync4(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 = resolve3(accountDir, "agents", slug);
+  const configPath = resolve3(agentDir, "config.json");
+  let config;
+  let presentRoles = [];
+  try {
+    if (!existsSync4(configPath)) {
+      console.error(
+        `[agent-graph] project FAILED slug=${slug} account=${account8} error="config.json missing at ${configPath}"`
+      );
+      return;
+    }
+    config = JSON.parse(readFileSync4(configPath, "utf-8"));
+    for (const { filename, role } of AGENT_FILE_ROLES) {
+      const filePath = resolve3(agentDir, filename);
+      if (!existsSync4(filePath)) continue;
+      const body = readFileSync4(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();
+  }
+}
+
+export {
+  MAXY_DIR,
+  BRAND_NAME,
+  COMMERCIAL_MODE,
+  BUNDLE_MODE,
+  BUNDLE_ALLOWLIST,
+  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,
+  REMOTE_SESSION_SECRET_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,
+  getSession,
+  runAdminUserSelfHeal,
+  runUserProfileReconcile,
+  embed,
+  preloadEmbedModel,
+  GREETING_DIRECTIVE,
+  ensureConversation,
+  ensureSessionConversation,
+  findRecentConversation,
+  createNewAdminConversation,
+  fetchBranding,
+  fetchAccountName,
+  persistMessage,
+  getAgentSessionIdForConversation,
+  getRecentMessages,
+  verifyConversationOwnership,
+  getConversationOwner,
+  verifyAndGetConversationUpdatedAt,
+  listAdminSessions,
+  deleteConversation,
+  linkConversationTranscript,
+  getConversationClaudeSessionIds,
+  renameConversation,
+  getUserTimezone,
+  loadAdminUserName,
+  loadPersonNameByElementId,
+  writeAdminUserAndPerson,
+  loadUserProfile,
+  projectAgent,
+  deleteAgentProjection
+};