@rubytech/create-maxy-code 0.1.108 → 0.1.110

package/payload/server/{chunk-AGFS3TVN.js → chunk-FSPPVVWM.js}

@@ -1,7 +1,3 @@
-import {
-  getConversationOwner
-} from "./chunk-JRBCOVA4.js";
-
 // node_modules/hono/dist/compose.js
 var compose = (middleware, onError, onNotFound) => {
   return (context, next) => {
@@ -2754,9 +2750,6 @@ function httpLog(fields) {
 function websockifyLog(event, fields = {}) {
   console.error(`[websockify] ${formatKv({ event, ...fields })}`);
 }
-function browserViewerLog(event, fields = {}) {
-  console.error(`[browser-viewer] ${formatKv({ event, ...fields })}`);
-}
 
 // app/lib/password-strength.ts
 function validatePasswordStrength(password) {
@@ -3876,6 +3869,1285 @@ function requirePortEnv(envName, options = {}) {
   return parsed;
 }
 
+// app/lib/neo4j-store.ts
+import neo4j from "neo4j-driver";
+import { randomUUID } from "crypto";
+import { readFileSync as readFileSync6, readdirSync as readdirSync3, existsSync as existsSync6, openSync, readSync, closeSync, statSync as statSync3 } from "fs";
+import { resolve as resolve5 } from "path";
+var PLATFORM_ROOT3 = process.env.MAXY_PLATFORM_ROOT ?? resolve5(process.cwd(), "..");
+var driver = null;
+function readPassword() {
+  if (process.env.NEO4J_PASSWORD) return process.env.NEO4J_PASSWORD;
+  const passwordFile = resolve5(PLATFORM_ROOT3, "config/.neo4j-password");
+  try {
+    return readFileSync6(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-QAWOZ3JV.js");
+  return selfHealAdminUser({ driver: getDriver(), ...args });
+}
+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";
+async function embed(text) {
+  const res = await fetch(`${OLLAMA_URL}/api/embed`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ model: EMBED_MODEL, input: text }),
+    signal: AbortSignal.timeout(5e3)
+  });
+  if (!res.ok) {
+    const body = await res.text();
+    throw new Error(`Ollama embedding failed (${res.status}): ${body}`);
+  }
+  const data = await res.json();
+  return data.embeddings[0];
+}
+var sessionStoreRef = null;
+function getCachedConversationId(cacheKey2) {
+  return sessionStoreRef?.get(cacheKey2)?.conversationId;
+}
+function cacheConversationId(cacheKey2, conversationId) {
+  const session = sessionStoreRef?.get(cacheKey2);
+  if (session) {
+    session.conversationId = conversationId;
+  }
+}
+var GREETING_DIRECTIVE = "[New session. Greet the visitor.]";
+async function ensureConversation(accountId, agentType, cacheKey2, visitorId, agentSlug, userId, channelOverride, channelAddressOverride) {
+  const cached = getCachedConversationId(cacheKey2);
+  if (cached) return { conversationId: cached, created: false };
+  const conversationId = 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) : conversationId);
+  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.conversationId AS conversationId, created AS created, a IS NOT NULL AS handledBy` : `RETURN c.conversationId AS conversationId, 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.conversationId, $conversationId) AS finalConvId, prior IS NULL AS created
+       MERGE (c:Conversation {conversationId: 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}`,
+      {
+        conversationId,
+        accountId,
+        agentType,
+        channel,
+        channelAddress,
+        ...visitorId ? { visitorId } : {},
+        ...agentSlug ? { agentSlug } : {},
+        ...handlerSlug ? { handlerSlug } : {},
+        ...userId ? { userId } : {}
+      }
+    );
+    const id = result.records[0]?.get("conversationId");
+    const created = result.records[0]?.get("created") === true;
+    if (id) {
+      cacheConversationId(cacheKey2, id);
+      console.error(`[session] ${(/* @__PURE__ */ new Date()).toISOString()} conversation attributed: conversationId=${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 conversationId=${id8} slug=${handlerSlug}`);
+        } else {
+          console.error(`[agent-graph] handled-by-skip reason=no-agent-node conversationId=${id8} slug=${handlerSlug}`);
+        }
+      }
+    }
+    return { conversationId: id ?? null, created };
+  } catch (err) {
+    console.error(`[persist] ensureConversation failed: ${err instanceof Error ? err.message : String(err)}`);
+    return { conversationId: null, created: false };
+  } 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();
+  }
+}
+var SUMMARY_MAX_LEN = 200;
+var persistMessageLocks = /* @__PURE__ */ new Map();
+async function persistMessage(conversationId, 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(conversationId);
+  const waited = prev !== void 0;
+  let release;
+  const mine = new Promise((resolve6) => {
+    release = resolve6;
+  });
+  const chained = (prev ?? Promise.resolve()).then(() => mine);
+  persistMessageLocks.set(conversationId, chained);
+  await prev;
+  const session = getSession();
+  try {
+    const result = await session.run(
+      `MATCH (c:Conversation {conversationId: $conversationId})
+       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,
+         conversationId: $conversationId,
+         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,
+           conversationId: $conversationId,
+           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,
+           conversationId: $conversationId,
+           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,
+        conversationId,
+        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: ${conversationId.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 conversationId=${conversationId.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 conversationId=${conversationId.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 conversationId=${conversationId.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 conversationId=${conversationId.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 conversationId=${conversationId.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 conversationId=${conversationId.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] ${(/* @__PURE__ */ new Date()).toISOString()} conversationId=${conversationId.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(conversationId) === chained) {
+      persistMessageLocks.delete(conversationId);
+    }
+    await session.close();
+  }
+}
+async function getAgentSessionIdForConversation(conversationId) {
+  const session = getSession();
+  try {
+    const result = await session.run(
+      `MATCH (c:Conversation {conversationId: $conversationId})
+       RETURN c.agentSessionId AS agentSessionId`,
+      { conversationId }
+    );
+    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=${conversationId.slice(0, 8)}\u2026 error=${err instanceof Error ? err.message : String(err)}`);
+    return null;
+  } finally {
+    await session.close();
+  }
+}
+async function getRecentMessages(conversationId, limit = 50) {
+  const session = getSession();
+  try {
+    const result = await session.run(
+      `MATCH (tail:Message {conversationId: $conversationId})
+         WHERE NOT (tail)-[:NEXT]->(:Message)
+       WITH tail ORDER BY tail.createdAt DESC LIMIT 1
+       MATCH path = (m:Message)-[:NEXT*0..]->(tail)
+         WHERE m.conversationId = $conversationId
+           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`,
+      { conversationId, 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(conversationId, accountId) {
+  const session = getSession();
+  try {
+    const result = await session.run(
+      `MATCH (c:Conversation {conversationId: $conversationId, accountId: $accountId})
+       RETURN c.conversationId AS id LIMIT 1`,
+      { conversationId, 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(conversationId) {
+  const session = getSession();
+  try {
+    const result = await session.run(
+      `MATCH (c:Conversation {conversationId: $conversationId})
+       RETURN c.accountId AS accountId, c.userId AS userId LIMIT 1`,
+      { conversationId }
+    );
+    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(conversationId, accountId) {
+  const session = getSession();
+  try {
+    const result = await session.run(
+      `MATCH (c:Conversation {conversationId: $conversationId, accountId: $accountId})
+       RETURN toString(c.updatedAt) AS updatedAt LIMIT 1`,
+      { conversationId, 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.conversationId AS conversationId,
+              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) => ({
+      conversationId: r.get("conversationId"),
+      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(conversationId) {
+  const session = getSession();
+  try {
+    const result = await session.run(
+      `MATCH (c:Conversation {conversationId: $conversationId})
+       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`,
+      { conversationId }
+    );
+    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 ${conversationId.slice(0, 8)}\u2026: ${found ? "deleted" : "not found"}`);
+    return { found };
+  } finally {
+    await session.close();
+  }
+}
+async function linkConversationTranscript(conversationId, claudeSessionId, accountId) {
+  if (!conversationId || !claudeSessionId || !accountId) {
+    console.error(`[transcript-link] schema-violation conversationId=${conversationId ? "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 {conversationId: $conversationId, accountId: $accountId})
+       MERGE (c)-[:HAS_TRANSCRIPT]->(t:ClaudeSession {claudeSessionId: $claudeSessionId})
+       ON CREATE SET
+         t.accountId = $accountId,
+         t.createdAt = datetime()
+       RETURN count(t) AS linked`,
+      { conversationId, claudeSessionId, accountId }
+    );
+    const linked = Number(result.records[0]?.get("linked") ?? 0) > 0;
+    if (!linked) {
+      console.error(`[transcript-link] convId=${conversationId.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=${conversationId.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(conversationId, accountId) {
+  const session = getSession();
+  try {
+    const result = await session.run(
+      `MATCH (c:Conversation {conversationId: $conversationId, accountId: $accountId})-[:HAS_TRANSCRIPT]->(t:ClaudeSession)
+       RETURN t.claudeSessionId AS claudeSessionId
+       ORDER BY t.createdAt ASC`,
+      { conversationId, accountId }
+    );
+    return result.records.map((r) => r.get("claudeSessionId")).filter((v) => typeof v === "string" && v.length > 0);
+  } finally {
+    await session.close();
+  }
+}
+async function getConversationIdByClaudeSessionId(claudeSessionId, accountId) {
+  const session = getSession();
+  try {
+    const result = await session.run(
+      `MATCH (c:Conversation {accountId: $accountId})-[:HAS_TRANSCRIPT]->(t:ClaudeSession {claudeSessionId: $claudeSessionId})
+       RETURN c.conversationId AS conversationId
+       LIMIT 1`,
+      { claudeSessionId, accountId }
+    );
+    const value = result.records[0]?.get("conversationId");
+    return typeof value === "string" && value.length > 0 ? value : null;
+  } finally {
+    await session.close();
+  }
+}
+async function renameConversation(conversationId, 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 {conversationId: $conversationId})
+       SET c.name = $label, c.updatedAt = datetime()
+       ${embedding ? ", c.embedding = $embedding" : ""}`,
+      { conversationId, label, ...embedding ? { embedding } : {} }
+    );
+    console.error(`[persist] manual-label: renamed ${conversationId} 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(accountId, userId) {
+  const session = getSession();
+  try {
+    const result = await session.run(
+      `MATCH (au:AdminUser {userId: $userId})-[:OWNS]->(p:Person {accountId: $accountId})
+       RETURN p.givenName AS givenName, p.familyName AS familyName, p.avatar AS avatar
+       LIMIT 1`,
+      { accountId, 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 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();
+  const session = getSession();
+  try {
+    const result = await session.run(
+      `MERGE (au:AdminUser {userId: $userId})
+       ON CREATE SET au.name = $fullName, au.createdAt = $now
+       ON MATCH SET au.name = $fullName, au.updatedAt = $now
+       WITH au
+
+       // 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, 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',
+           createdAt: $now
+         })
+         MERGE (au)-[:OWNS]->(newPerson)
+         RETURN newPerson AS p, false AS reused
+       }
+       RETURN reused, elementId(p) AS personElementId,
+              p.givenName AS givenName, p.familyName AS familyName`,
+      { userId, fullName: trimmed, accountId, givenName, familyName, now }
+    );
+    if (result.records.length === 0) {
+      throw new Error("writeAdminUserAndPerson: no record returned");
+    }
+    const record = result.records[0];
+    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 = resolve5(PLATFORM_ROOT3, "..", "data/accounts", accountId, "account.json");
+  if (!existsSync6(accountFile)) return {};
+  let enabled;
+  try {
+    const raw2 = readFileSync6(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 = resolve5(PLATFORM_ROOT3, "plugins", pluginName, "PLUGIN.md");
+    if (!existsSync6(manifestPath)) continue;
+    let manifest;
+    try {
+      manifest = readFileSync6(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, conversationId) {
+  console.error(
+    `[profile] loadUserProfile entry accountId=${accountId.slice(0, 8)}\u2026 userId=${userId} conversationId=${conversationId ? `${conversationId.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
+       ON MATCH SET
+         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`,
+      { accountId, userId, threshold: INJECTION_THRESHOLD, limit: 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 (conversationId && sparseFired) {
+      const dedupeKey = `${accountId}:${userId}:${conversationId}`;
+      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} conversationId=${conversationId.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 = resolve5(accountDir, "agents", slug);
+  const configPath = resolve5(agentDir, "config.json");
+  let config;
+  let presentRoles = [];
+  try {
+    if (!existsSync6(configPath)) {
+      console.error(
+        `[agent-graph] project FAILED slug=${slug} account=${account8} error="config.json missing at ${configPath}"`
+      );
+      return;
+    }
+    config = JSON.parse(readFileSync6(configPath, "utf-8"));
+    for (const { filename, role } of AGENT_FILE_ROLES) {
+      const filePath = resolve5(agentDir, filename);
+      if (!existsSync6(filePath)) continue;
+      const body = readFileSync6(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.liveMemory = $liveMemory,
+           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 ?? "",
+        liveMemory: config.liveMemory ?? false,
+        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 {
@@ -3999,486 +5271,6 @@ var clientIpMiddleware = async (c, next) => {
   await next();
 };
 
-// server/lib/action-runner.ts
-import { spawn } from "child_process";
-import { createReadStream, existsSync as existsSync6, mkdirSync as mkdirSync3, readdirSync as readdirSync3, statSync as statSync3, unlinkSync, watch } from "fs";
-import { homedir as homedir2 } from "os";
-import { join as join4, resolve as resolve5 } from "path";
-import { readFileSync as readFileSync6 } from "fs";
-import { setTimeout as delay } from "timers/promises";
-function loadBrandInfo() {
-  const platformRoot2 = process.env.MAXY_PLATFORM_ROOT ?? resolve5(process.cwd(), "..");
-  const brandPath = resolve5(platformRoot2, "config", "brand.json");
-  try {
-    const parsed = JSON.parse(readFileSync6(brandPath, "utf-8"));
-    const hostname = typeof parsed.hostname === "string" && parsed.hostname ? parsed.hostname : "maxy";
-    const configDir = typeof parsed.configDir === "string" && parsed.configDir ? parsed.configDir : ".maxy";
-    return { hostname, configDir };
-  } catch {
-    return { hostname: "maxy", configDir: ".maxy" };
-  }
-}
-function actionLogDir() {
-  const { configDir } = loadBrandInfo();
-  return join4(homedir2(), configDir, "logs", "actions");
-}
-function actionLogPath(actionId) {
-  return join4(actionLogDir(), `${actionId}.log`);
-}
-var WHITELIST = {
-  upgrade: {
-    build: ({ sudoPassword }) => {
-      const { hostname } = loadBrandInfo();
-      const pkg = `@rubytech/create-${hostname}`;
-      const cmd = [
-        // prime: read pw from stdin, silently cache
-        'printf %s "$SUDO_PASSWORD"',
-        "|",
-        "sudo -S -v 2>/dev/null",
-        "&&",
-        // run installer — it will re-prompt only if the cache expires
-        `npx -y ${pkg}@latest`
-      ].join(" ");
-      return {
-        argv: ["bash", "-c", cmd],
-        env: sudoPassword ? { SUDO_PASSWORD: sudoPassword } : void 0
-      };
-    }
-  },
-  "cloudflare-setup": {
-    build: ({ positional, streamLogPath, accountDir, tunnelId, tunnelName }) => {
-      if (!positional || positional.length < 3) {
-        throw new Error("cloudflare-setup requires [brand, port, ...hostnames]");
-      }
-      if (!accountDir) {
-        throw new Error("cloudflare-setup requires accountDir");
-      }
-      const idSet = typeof tunnelId === "string" && tunnelId.length > 0;
-      const nameSet = typeof tunnelName === "string" && tunnelName.length > 0;
-      if (idSet && nameSet) {
-        throw new Error("cloudflare-setup: tunnelId and tunnelName are mutually exclusive \u2014 pass exactly one");
-      }
-      if (!idSet && !nameSet) {
-        throw new Error("cloudflare-setup: requires tunnelId (operator-selected) OR tunnelName (operator-created)");
-      }
-      const scriptPath = join4(homedir2(), "setup-tunnel.sh");
-      if (!existsSync6(scriptPath)) {
-        throw new Error(
-          `cloudflare-setup: ~/setup-tunnel.sh not found. Re-run the installer to repair the symlink.`
-        );
-      }
-      const platformRoot2 = process.env.MAXY_PLATFORM_ROOT ?? resolve5(process.cwd(), "..");
-      return {
-        argv: [scriptPath, ...positional],
-        env: {
-          MAXY_PLATFORM_ROOT: platformRoot2,
-          ...streamLogPath ? { STREAM_LOG_PATH: streamLogPath } : {},
-          ACCOUNT_DIR: accountDir,
-          ...idSet ? { TUNNEL_ID: tunnelId } : {},
-          ...nameSet ? { TUNNEL_NAME: tunnelName } : {}
-        }
-      };
-    },
-    reconcileFromLog: reconcileCloudflareSetupFromLog
-  }
-};
-var ARMING_LINE_RE = /\bstep=service-restart-armed\b[^\n]*\bexit=0\b/;
-var DONE_LINE_RE = /\bstep=done\b/;
-var ERROR_LINE_RE = /\bresult=error\b/;
-function reconcileCloudflareSetupFromLog(lines) {
-  let hasArming = false;
-  let hasDone = false;
-  let hasError = false;
-  for (const line of lines) {
-    if (!hasArming && ARMING_LINE_RE.test(line)) hasArming = true;
-    if (!hasDone && DONE_LINE_RE.test(line)) hasDone = true;
-    if (!hasError && ERROR_LINE_RE.test(line)) hasError = true;
-  }
-  if (hasDone && hasArming) return { kind: "succeeded", code: 0 };
-  if (hasError) return { kind: "failed", code: 1 };
-  if (hasArming && !hasDone) return { kind: "restart-in-progress", code: null };
-  return null;
-}
-function isKnownAction(name) {
-  return Object.prototype.hasOwnProperty.call(WHITELIST, name);
-}
-function generateActionId(name) {
-  const ts = Date.now().toString(36);
-  const nonce = Math.floor(Math.random() * 4294967295).toString(16).padStart(8, "0");
-  return `${name}-${ts}-${nonce}`;
-}
-function actionNameFromId(actionId) {
-  for (const name of Object.keys(WHITELIST)) {
-    if (actionId.startsWith(`${name}-`)) return name;
-  }
-  return "unknown";
-}
-function cleanupStaleLogs() {
-  const dir = actionLogDir();
-  if (!existsSync6(dir)) return;
-  const cutoff = Date.now() - 7 * 24 * 60 * 60 * 1e3;
-  for (const entry of readdirSync3(dir)) {
-    const full = join4(dir, entry);
-    try {
-      const st = statSync3(full);
-      if (st.isFile() && st.mtimeMs < cutoff) unlinkSync(full);
-    } catch {
-    }
-  }
-}
-async function isActionActive(actionName) {
-  return new Promise((resolveP) => {
-    const proc = spawn(
-      "systemctl",
-      ["--user", "list-units", "--no-legend", "--state=active", `maxy-action-${actionName}-*`],
-      { stdio: ["ignore", "pipe", "pipe"] }
-    );
-    let out = "";
-    proc.stdout.on("data", (chunk) => {
-      out += chunk.toString();
-    });
-    proc.on("close", () => resolveP(out.trim().length > 0));
-    proc.on("error", () => resolveP(false));
-  });
-}
-function buildSystemdArgs(name, args, actionId, logPath) {
-  const unit = `maxy-action-${actionId}`;
-  const built = WHITELIST[name].build(args);
-  const systemdArgs = [
-    "--user",
-    `--unit=${unit}`,
-    "--collect",
-    "--property=RemainAfterExit=false",
-    `--property=StandardOutput=append:${logPath}`,
-    `--property=StandardError=append:${logPath}`,
-    `--description=Maxy action ${name} (${actionId})`
-  ];
-  if (built.env) {
-    for (const [k, v] of Object.entries(built.env)) {
-      systemdArgs.push(`--setenv=${k}=${v}`);
-    }
-  }
-  systemdArgs.push("--", ...built.argv);
-  return systemdArgs;
-}
-async function launchAction(name, args) {
-  const actionId = generateActionId(name);
-  const dir = actionLogDir();
-  mkdirSync3(dir, { recursive: true });
-  cleanupStaleLogs();
-  const logPath = actionLogPath(actionId);
-  const unit = `maxy-action-${actionId}`;
-  const systemdArgs = buildSystemdArgs(name, args, actionId, logPath);
-  await new Promise((resolveP, rejectP) => {
-    const proc = spawn("systemd-run", systemdArgs, { stdio: ["ignore", "pipe", "pipe"] });
-    let stderr = "";
-    proc.stderr.on("data", (chunk) => {
-      stderr += chunk.toString();
-    });
-    proc.on("close", (code) => {
-      if (code === 0) resolveP();
-      else rejectP(new Error(`systemd-run exited ${code}: ${stderr.trim().slice(0, 400)}`));
-    });
-    proc.on("error", rejectP);
-  });
-  console.log(`[action-runner] launched action=${name} id=${actionId} unit=${unit} log=${logPath}`);
-  return { actionId, unit, logPath };
-}
-function parseUnitShow(out) {
-  const kv = {};
-  for (const line of out.split("\n")) {
-    const eq = line.indexOf("=");
-    if (eq > 0) kv[line.slice(0, eq)] = line.slice(eq + 1);
-  }
-  const loadState = kv.LoadState ?? "";
-  if (loadState !== "loaded" || !kv.ActiveState) {
-    return { status: null, loadState };
-  }
-  return {
-    status: {
-      activeState: kv.ActiveState,
-      subState: kv.SubState ?? "",
-      mainPid: kv.MainPID ? Number(kv.MainPID) || null : null,
-      execMainStatus: kv.ExecMainStatus ? Number(kv.ExecMainStatus) : null,
-      execMainSignal: null
-      // systemd reports signal in SIGNAL (SIGTERM etc.), deferred — code is enough for our contract
-    },
-    loadState
-  };
-}
-async function showUnit(unit) {
-  return new Promise((resolveP) => {
-    const proc = spawn(
-      "systemctl",
-      ["--user", "show", unit, "--property=ActiveState,SubState,MainPID,ExecMainStatus,ExecMainCode,LoadState"],
-      { stdio: ["ignore", "pipe", "pipe"] }
-    );
-    let out = "";
-    proc.stdout.on("data", (chunk) => {
-      out += chunk.toString();
-    });
-    proc.on("close", () => resolveP(parseUnitShow(out)));
-    proc.on("error", () => resolveP({ status: null, loadState: "error" }));
-  });
-}
-async function getUnitStatus(unit) {
-  return (await showUnit(unit)).status;
-}
-var HEARTBEAT_INTERVAL_MS = 5e3;
-var exitEmittedFor = /* @__PURE__ */ new Set();
-var PHASE_BRACKETED = /\[(\d+)\/(\d+)\]/;
-var PHASE_STREAM_LOG = /step=([a-z0-9-]+)/;
-function extractPhase(text) {
-  const m1 = text.match(PHASE_BRACKETED);
-  if (m1) return m1[0];
-  const m2 = text.match(PHASE_STREAM_LOG);
-  if (m2) return m2[1];
-  return null;
-}
-function readLogTailLines(path, tailLines) {
-  if (!existsSync6(path)) return [];
-  let raw2;
-  try {
-    raw2 = readFileSync6(path, "utf-8");
-  } catch {
-    return [];
-  }
-  const all = raw2.split("\n");
-  if (all.length <= tailLines) return all;
-  return all.slice(all.length - tailLines);
-}
-async function* streamActionEvents(opts) {
-  const { actionId, unit, signal } = opts;
-  const logPath = actionLogPath(actionId);
-  const startedAt = Date.now();
-  let lastLineAt = startedAt;
-  let lastPhase = null;
-  let byteOffset = opts.fromByteOffset ?? 0;
-  const actionName = actionNameFromId(actionId);
-  const reconcileFromLog = isKnownAction(actionName) ? WHITELIST[actionName].reconcileFromLog : void 0;
-  if (existsSync6(logPath)) {
-    const snapshot = statSync3(logPath).size;
-    if (byteOffset < snapshot) {
-      for await (const ev of readLogLines(logPath, byteOffset, snapshot)) {
-        const phase = extractPhase(ev.text);
-        if (phase) lastPhase = phase;
-        lastLineAt = ev.ts;
-        byteOffset = ev.byteOffset;
-        yield ev;
-        if (signal.aborted) return;
-      }
-    }
-  }
-  if (exitEmittedFor.has(actionId)) {
-    return;
-  }
-  let watching = true;
-  let hbTimer = null;
-  const queue = [];
-  let resolveNext = null;
-  function push(ev) {
-    queue.push(ev);
-    if (resolveNext) {
-      const r = resolveNext;
-      resolveNext = null;
-      r();
-    }
-  }
-  const watcher = existsSync6(logPath) ? watch(logPath, async () => {
-    if (!watching) return;
-    try {
-      const size = statSync3(logPath).size;
-      if (size <= byteOffset) return;
-      for await (const ev of readLogLines(logPath, byteOffset, size)) {
-        const phase = extractPhase(ev.text);
-        if (phase) lastPhase = phase;
-        lastLineAt = ev.ts;
-        byteOffset = ev.byteOffset;
-        push(ev);
-      }
-    } catch (err) {
-      console.error(`[action-runner] watcher error action=${actionId}: ${err}`);
-    }
-  }) : null;
-  hbTimer = setInterval(async () => {
-    const probe = await showUnit(unit);
-    const status = probe.status;
-    const now = Date.now();
-    push({
-      type: "heartbeat",
-      ts: now,
-      elapsed_since_last_line_ms: now - lastLineAt,
-      systemd_state: status ? status.activeState : "unknown",
-      pid: status ? status.mainPid : null,
-      last_phase: lastPhase
-    });
-    if (!status) {
-      if (exitEmittedFor.has(actionId)) {
-        watching = false;
-        return;
-      }
-      exitEmittedFor.add(actionId);
-      console.log(`[action-runner] unit-not-loaded action=${actionNameFromId(actionId)} id=${actionId} loadState=${probe.loadState || "empty"}`);
-      const reconciled = reconcileFromLog ? reconcileFromLog(readLogTailLines(logPath, 200)) : null;
-      const reconcileMs = Date.now() - startedAt;
-      if (reconciled) {
-        console.log(
-          `[action-runner] reconcile actionId=${actionId} result=${reconciled.kind} source=persisted-log ms=${reconcileMs}`
-        );
-        push({
-          type: "exit",
-          ts: Date.now(),
-          code: reconciled.code,
-          signal: null,
-          duration_ms: reconcileMs,
-          source: "persisted-log",
-          ...reconciled.kind === "restart-in-progress" ? { kind: "restart-in-progress" } : {}
-        });
-      } else {
-        console.log(
-          `[action-runner] reconcile actionId=${actionId} result=unresolved source=persisted-log ms=${reconcileMs}`
-        );
-        push({
-          type: "exit",
-          ts: Date.now(),
-          code: null,
-          signal: null,
-          duration_ms: reconcileMs,
-          source: "persisted-log"
-        });
-      }
-      watching = false;
-      return;
-    }
-    if (status.activeState !== "active" && status.activeState !== "activating") {
-      if (exitEmittedFor.has(actionId)) {
-        watching = false;
-        return;
-      }
-      exitEmittedFor.add(actionId);
-      const finalStatus = await getUnitStatus(unit);
-      if (finalStatus?.execMainStatus == null && reconcileFromLog) {
-        const reconciled = reconcileFromLog(readLogTailLines(logPath, 200));
-        const reconcileMs = Date.now() - startedAt;
-        if (reconciled) {
-          console.log(
-            `[action-runner] reconcile actionId=${actionId} result=${reconciled.kind} source=persisted-log ms=${reconcileMs}`
-          );
-          push({
-            type: "exit",
-            ts: Date.now(),
-            code: reconciled.code,
-            signal: null,
-            duration_ms: reconcileMs,
-            source: "persisted-log",
-            ...reconciled.kind === "restart-in-progress" ? { kind: "restart-in-progress" } : {}
-          });
-          watching = false;
-          return;
-        }
-      }
-      const ms = Date.now() - startedAt;
-      const source = finalStatus?.execMainStatus != null ? "systemd" : "persisted-log";
-      const result = finalStatus?.execMainStatus === 0 ? "succeeded" : finalStatus?.execMainStatus != null ? "failed" : "unresolved";
-      console.log(
-        `[action-runner] reconcile actionId=${actionId} result=${result} source=${source} ms=${ms}`
-      );
-      push({
-        type: "exit",
-        ts: Date.now(),
-        code: finalStatus?.execMainStatus ?? null,
-        signal: null,
-        duration_ms: ms,
-        source
-      });
-      watching = false;
-    }
-  }, HEARTBEAT_INTERVAL_MS);
-  try {
-    while (watching && !signal.aborted) {
-      if (queue.length === 0) {
-        await new Promise((r) => {
-          resolveNext = r;
-        });
-      }
-      while (queue.length > 0) {
-        const ev = queue.shift();
-        yield ev;
-        if (ev.type === "exit") {
-          watching = false;
-          break;
-        }
-      }
-    }
-  } finally {
-    if (hbTimer) clearInterval(hbTimer);
-    watcher?.close();
-  }
-}
-async function* readLogLines(path, fromOffset, toOffset) {
-  const stream = createReadStream(path, { start: fromOffset, end: toOffset - 1, encoding: "utf-8" });
-  let buffer = "";
-  let offset = fromOffset;
-  for await (const chunk of stream) {
-    buffer += chunk;
-    let nl;
-    while ((nl = buffer.indexOf("\n")) !== -1) {
-      const text = buffer.slice(0, nl);
-      offset += Buffer.byteLength(text, "utf-8") + 1;
-      buffer = buffer.slice(nl + 1);
-      yield { type: "line", ts: Date.now(), stream: "stdout", text, byteOffset: offset };
-    }
-  }
-}
-var RATE_LIMIT_WINDOW_MS = 6e4;
-var RATE_LIMIT_MAX_ATTEMPTS = 5;
-var rateLimitBuckets = /* @__PURE__ */ new Map();
-function rateLimitCheck(ip) {
-  const now = Date.now();
-  const bucket = rateLimitBuckets.get(ip);
-  if (!bucket || now - bucket.windowStart > RATE_LIMIT_WINDOW_MS) {
-    rateLimitBuckets.set(ip, { count: 1, windowStart: now });
-    return "ok";
-  }
-  bucket.count += 1;
-  if (bucket.count > RATE_LIMIT_MAX_ATTEMPTS) return "limited";
-  return "ok";
-}
-async function primeSudo(password, clientIp) {
-  if (!password) return "invalid";
-  if (rateLimitCheck(clientIp) === "limited") return "limited";
-  return new Promise((resolveP) => {
-    const proc = spawn("sudo", ["-S", "-v"], { stdio: ["pipe", "ignore", "pipe"] });
-    let stderr = "";
-    proc.stderr.on("data", (chunk) => {
-      stderr += chunk.toString();
-    });
-    proc.on("close", (code) => {
-      if (code === 0) return resolveP("ok");
-      if (/incorrect password|authentication failure/i.test(stderr)) return resolveP("invalid");
-      console.error(`[action-runner] sudo-prime failed code=${code} stderr=${stderr.slice(0, 200)}`);
-      resolveP("error");
-    });
-    proc.on("error", (err) => {
-      console.error(`[action-runner] sudo-prime spawn error: ${err}`);
-      resolveP("error");
-    });
-    proc.stdin.write(`${password}
-`);
-    proc.stdin.end();
-  });
-}
-async function waitForExit(unit, timeoutMs = 10 * 60 * 1e3) {
-  const deadline = Date.now() + timeoutMs;
-  while (Date.now() < deadline) {
-    const status = await getUnitStatus(unit);
-    if (!status) return null;
-    if (status.activeState !== "active" && status.activeState !== "activating") return status;
-    await delay(500);
-  }
-  return null;
-}
-
 export {
   Hono2 as Hono,
   getRequestListener,
@@ -4500,7 +5292,6 @@ export {
   sanitizeClientCorrId,
   httpLog,
   websockifyLog,
-  browserViewerLog,
   validatePasswordStrength,
   isPasswordValid,
   isRemoteAuthConfigured,
@@ -4540,16 +5331,32 @@ export {
   emitMissingOnResolve,
   stripAttachmentMetaSuffix,
   requirePortEnv,
+  getSession,
+  runAdminUserSelfHeal,
+  embed,
+  GREETING_DIRECTIVE,
+  ensureConversation,
+  fetchBranding,
+  persistMessage,
+  getAgentSessionIdForConversation,
+  getRecentMessages,
+  verifyConversationOwnership,
+  verifyAndGetConversationUpdatedAt,
+  listAdminSessions,
+  deleteConversation,
+  linkConversationTranscript,
+  getConversationClaudeSessionIds,
+  getConversationIdByClaudeSessionId,
+  renameConversation,
+  getUserTimezone,
+  loadAdminUserName,
+  writeAdminUserAndPerson,
+  loadUserProfile,
+  projectAgent,
+  deleteAgentProjection,
   safeJson,
   requireAdminSession,
   tryCookieBridgeForConversation,
   requireAdminCookie,
-  clientIpMiddleware,
-  actionLogPath,
-  isKnownAction,
-  isActionActive,
-  launchAction,
-  streamActionEvents,
-  primeSudo,
-  waitForExit
+  clientIpMiddleware
 };