@rubytech/create-maxy-code 0.1.191 → 0.1.193

package/payload/server/server.js

@@ -815,8 +815,8 @@ var serveStatic = (options = { root: "" }) => {
 };
 
 // server/index.ts
-import { readFileSync as readFileSync20, existsSync as existsSync23, watchFile } from "fs";
-import { resolve as resolve24, join as join15, basename as basename5 } from "path";
+import { readFileSync as readFileSync20, existsSync as existsSync21, watchFile } from "fs";
+import { resolve as resolve23, join as join15, basename as basename6 } from "path";
 import { homedir as homedir2 } from "os";
 import { monitorEventLoopDelay } from "perf_hooks";
 
@@ -1274,7 +1274,7 @@ var credsSaveQueue = Promise.resolve();
 async function drainCredsSaveQueue(timeoutMs = 5e3) {
   console.error(`${TAG2} draining credential save queue\u2026`);
   const timer2 = new Promise(
-    (resolve25) => setTimeout(() => resolve25("timeout"), timeoutMs)
+    (resolve24) => setTimeout(() => resolve24("timeout"), timeoutMs)
   );
   const result = await Promise.race([
     credsSaveQueue.then(() => "drained"),
@@ -1402,11 +1402,11 @@ async function createWaSocket(opts) {
   return sock;
 }
 async function waitForConnection(sock) {
-  return new Promise((resolve25, reject) => {
+  return new Promise((resolve24, reject) => {
     const handler = (update) => {
       if (update.connection === "open") {
         sock.ev.off("connection.update", handler);
-        resolve25();
+        resolve24();
       }
       if (update.connection === "close") {
         sock.ev.off("connection.update", handler);
@@ -1520,14 +1520,14 @@ ${inspected}`;
   return inspect2(err, INSPECT_OPTS2);
 }
 function withTimeout(label, promise, timeoutMs) {
-  return new Promise((resolve25, reject) => {
+  return new Promise((resolve24, reject) => {
     const timer2 = setTimeout(() => {
       reject(new Error(`${label} timed out after ${timeoutMs}ms`));
     }, timeoutMs);
     promise.then(
       (value) => {
         clearTimeout(timer2);
-        resolve25(value);
+        resolve24(value);
       },
       (err) => {
         clearTimeout(timer2);
@@ -2062,8 +2062,8 @@ async function persistWhatsAppMessage(input) {
   const { givenName, familyName } = splitName(input.pushName);
   const prev = sessionWriteLocks.get(input.cacheKey);
   let release;
-  const mine = new Promise((resolve25) => {
-    release = resolve25;
+  const mine = new Promise((resolve24) => {
+    release = resolve24;
   });
   const chained = (prev ?? Promise.resolve()).then(() => mine);
   sessionWriteLocks.set(input.cacheKey, chained);
@@ -3099,11 +3099,11 @@ async function connectWithReconnect(conn) {
       console.error(
         `${TAG12} reconnecting account=${conn.accountId} in ${delay}ms (attempt ${decision.nextAttempts}/${maxAttempts})`
       );
-      await new Promise((resolve25) => {
-        const timer2 = setTimeout(resolve25, delay);
+      await new Promise((resolve24) => {
+        const timer2 = setTimeout(resolve24, delay);
         conn.abortController.signal.addEventListener("abort", () => {
           clearTimeout(timer2);
-          resolve25();
+          resolve24();
         }, { once: true });
       });
     }
@@ -3111,16 +3111,16 @@ async function connectWithReconnect(conn) {
   }
 }
 function waitForDisconnectEvent(conn) {
-  return new Promise((resolve25) => {
+  return new Promise((resolve24) => {
     if (!conn.sock) {
-      resolve25();
+      resolve24();
       return;
     }
     const sock = conn.sock;
     const handler = (update) => {
       if (update.connection === "close") {
         sock.ev.off("connection.update", handler);
-        resolve25();
+        resolve24();
       }
     };
     sock.ev.on("connection.update", handler);
@@ -3382,8 +3382,8 @@ async function handleInboundMessage(conn, msg) {
     const conversationKey = isGroup ? remoteJid : senderPhone;
     const debounceKey = `${conn.accountId}:${conversationKey}:${senderPhone}`;
     let resolvePending;
-    const sttPending = new Promise((resolve25) => {
-      resolvePending = resolve25;
+    const sttPending = new Promise((resolve24) => {
+      resolvePending = resolve24;
     });
     if (conn.debouncer) conn.debouncer.registerPending(debounceKey, sttPending);
     try {
@@ -3787,20 +3787,20 @@ function buildX11Env(chromiumWrapperPath, transport = "vnc") {
 
 // server/routes/health.ts
 function checkPort(port2, timeoutMs = 500) {
-  return new Promise((resolve25) => {
+  return new Promise((resolve24) => {
     const socket = createConnection2(port2, "127.0.0.1");
     socket.setTimeout(timeoutMs);
     socket.once("connect", () => {
       socket.destroy();
-      resolve25(true);
+      resolve24(true);
     });
     socket.once("error", () => {
       socket.destroy();
-      resolve25(false);
+      resolve24(false);
     });
     socket.once("timeout", () => {
       socket.destroy();
-      resolve25(false);
+      resolve24(false);
     });
   });
 }
@@ -4536,12 +4536,12 @@ async function dispatchOnce(input) {
   });
   if (!entry) return { error: "spawn-failed" };
   entry.lastInboundAt = Date.now();
-  let resolve25;
+  let resolve24;
   const turnPromise = new Promise((r) => {
-    resolve25 = r;
+    resolve24 = r;
   });
   const listener = (text) => {
-    resolve25(text);
+    resolve24(text);
   };
   entry.subscribers.add(listener);
   const writeOk = await writeInput(entry, input.text);
@@ -4983,8 +4983,8 @@ async function startLogin(opts) {
   resetActiveLogin(accountId);
   let resolveQr = null;
   let rejectQr = null;
-  const qrPromise = new Promise((resolve25, reject) => {
-    resolveQr = resolve25;
+  const qrPromise = new Promise((resolve24, reject) => {
+    resolveQr = resolve24;
     rejectQr = reject;
   });
   const qrTimer = setTimeout(
@@ -7245,24 +7245,6 @@ function openResumeStreamLog(accountId, sessionId) {
   }
   return createWriteStream(resolvePath(dir, `${sessionId}.log`), { flags: "a" });
 }
-var healPending = /* @__PURE__ */ new Map();
-function markHealPending(accountId, attachmentId) {
-  let set = healPending.get(accountId);
-  if (!set) {
-    set = /* @__PURE__ */ new Set();
-    healPending.set(accountId, set);
-  }
-  set.add(attachmentId);
-}
-function clearHealPending(accountId, attachmentId) {
-  const set = healPending.get(accountId);
-  if (!set) return;
-  set.delete(attachmentId);
-  if (set.size === 0) healPending.delete(accountId);
-}
-function isHealPending(accountId, attachmentId) {
-  return healPending.get(accountId)?.has(attachmentId) ?? false;
-}
 function validateAndShapeAttachments(raws, conversationAccountId, sessionId, messageId, streamLogPath) {
   const chips = [];
   let valid = 0;
@@ -7640,17 +7622,14 @@ app11.post("/:id/resume", async (c) => {
                 textOffset: c2.textOffset
               };
               if (!c2.artefactAttachmentId || !c2.artefactMimeType || !c2.artefactTitle) return base;
-              markHealPending(accountId, c2.artefactAttachmentId);
               try {
                 const dataObj = JSON.parse(c2.data);
                 const bytesPick = pickComponentBytes(dataObj);
                 if (!bytesPick) {
-                  clearHealPending(accountId, c2.artefactAttachmentId);
                   return base;
                 }
                 const filename = bytesPick.mimeType === "text/html" ? `${c2.artefactTitle}.html` : `${c2.artefactTitle}.md`;
                 await storeComponentArtefact(accountId, c2.artefactAttachmentId, bytesPick.mimeType, bytesPick.content, filename);
-                clearHealPending(accountId, c2.artefactAttachmentId);
                 streamLogPath.write(
                   `[${(/* @__PURE__ */ new Date()).toISOString()}] [component-persist] heal componentName=${c2.name} attachmentId=${c2.artefactAttachmentId.slice(0, 8)} mimeType=${bytesPick.mimeType} bytes=${bytesPick.content.length} outcome=ok
 `
@@ -7662,7 +7641,6 @@ app11.post("/:id/resume", async (c) => {
                   artefactTitle: c2.artefactTitle
                 };
               } catch (writeErr) {
-                clearHealPending(accountId, c2.artefactAttachmentId);
                 const reason2 = writeErr instanceof Error ? writeErr.message : String(writeErr);
                 streamLogPath.write(
                   `[${(/* @__PURE__ */ new Date()).toISOString()}] [component-persist] heal componentName=${c2.name} attachmentId=${c2.artefactAttachmentId.slice(0, 8)} outcome=disk-fail reason=${JSON.stringify(reason2.slice(0, 200))}
@@ -8769,11 +8747,23 @@ async function cascadeDeleteDocument(params) {
 // app/lib/file-index.ts
 import * as fsp from "fs/promises";
 import { resolve as resolve13, relative as relative2, join as join11, basename as basename3, extname as extname2, sep as sep3 } from "path";
+import { tmpdir as tmpdir2 } from "os";
 import { execFile as execFile2 } from "child_process";
 import { promisify as promisify2 } from "util";
 var execFileAsync2 = promisify2(execFile2);
 var CONTENT_CAP = 1e5;
-var RECONCILE_DEBOUNCE_MS = 1e4;
+var OCR_TIMEOUT_MS = 3e4;
+var OCR_IMAGE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".webp",
+  ".tiff",
+  ".tif",
+  ".bmp"
+]);
+var RECONCILE_DEBOUNCE_MS = 5 * 60 * 1e3;
 var lastReconcileAt = /* @__PURE__ */ new Map();
 var TEXT_EXTENSIONS = /* @__PURE__ */ new Set([
   ".txt",
@@ -8826,26 +8816,60 @@ async function extractPdf(absolute) {
   });
   return stdout.trim();
 }
+async function ocrPdf(absolute) {
+  const outPdf = join11(tmpdir2(), `file-index-ocr-${process.pid}-${Date.now()}.pdf`);
+  try {
+    await execFileAsync2(
+      "ocrmypdf",
+      ["--skip-text", "--quiet", "--output-type", "pdf", absolute, outPdf],
+      { maxBuffer: 10 * 1024 * 1024, timeout: OCR_TIMEOUT_MS }
+    );
+    const { stdout } = await execFileAsync2("pdftotext", [outPdf, "-"], {
+      maxBuffer: 10 * 1024 * 1024,
+      timeout: OCR_TIMEOUT_MS
+    });
+    return stdout.trim();
+  } finally {
+    await fsp.rm(outPdf, { force: true });
+  }
+}
+async function ocrImage(absolute) {
+  const { stdout } = await execFileAsync2(
+    "tesseract",
+    [absolute, "-", "-l", "eng", "--psm", "3"],
+    { maxBuffer: 10 * 1024 * 1024, timeout: OCR_TIMEOUT_MS }
+  );
+  return stdout.trim();
+}
 function stripHtml(html) {
   return html.replace(/<script[\s\S]*?<\/script>/gi, " ").replace(/<style[\s\S]*?<\/style>/gi, " ").replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim();
 }
 async function extractFileContent(absolute) {
   const ext = extname2(absolute).toLowerCase();
   try {
-    if (ext === ".pdf") return (await extractPdf(absolute)).slice(0, CONTENT_CAP);
+    if (ext === ".pdf") {
+      const text = (await extractPdf(absolute)).slice(0, CONTENT_CAP);
+      if (text.length > 0) return { content: text, route: "pdftotext" };
+      const ocred = (await ocrPdf(absolute)).slice(0, CONTENT_CAP);
+      return ocred.length > 0 ? { content: ocred, route: "ocr-pdf" } : { content: "", route: "name-only" };
+    }
     if (HTML_EXTENSIONS.has(ext)) {
       const raw = await fsp.readFile(absolute, "utf-8");
-      return stripHtml(raw).slice(0, CONTENT_CAP);
+      return { content: stripHtml(raw).slice(0, CONTENT_CAP), route: "html" };
     }
     if (TEXT_EXTENSIONS.has(ext)) {
       const raw = await fsp.readFile(absolute, "utf-8");
-      return raw.slice(0, CONTENT_CAP);
+      return { content: raw.slice(0, CONTENT_CAP), route: "text" };
     }
-    return "";
+    if (OCR_IMAGE_EXTENSIONS.has(ext)) {
+      const ocred = (await ocrImage(absolute)).slice(0, CONTENT_CAP);
+      return ocred.length > 0 ? { content: ocred, route: "ocr-image" } : { content: "", route: "name-only" };
+    }
+    return { content: "", route: "name-only" };
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     console.error(`[file-index] extract-failed path="${relative2(DATA_ROOT, absolute)}" err="${msg}"`);
-    return "";
+    return { content: "", route: "name-only" };
   }
 }
 async function readDisplayName(absolute) {
@@ -8909,9 +8933,86 @@ async function upsertFileArtifact(session, f) {
     f
   );
 }
+async function linkFileArtifactToKnowledgeDocument(session, accountId, relativePath, absolutePath) {
+  const res = await session.run(
+    `MATCH (f:FileArtifact {accountId: $accountId, relativePath: $relativePath})
+     OPTIONAL MATCH (d:KnowledgeDocument {accountId: $accountId, sourcePath: $absolutePath})
+     WHERE NOT d:Trashed
+     FOREACH (_ IN CASE WHEN d IS NULL THEN [] ELSE [1] END |
+       MERGE (f)-[:INGESTED_AS]->(d))
+     RETURN elementId(d) AS docId`,
+    { accountId, relativePath, absolutePath }
+  );
+  const docId = res.records[0]?.get("docId");
+  if (docId) {
+    console.error(
+      `[file-index] linked-kd account=${accountId} relativePath="${relativePath}" docId=${docId.slice(0, 12)}`
+    );
+  }
+}
+async function findLinkedKnowledgeDocs(session, accountId, relativePaths) {
+  if (relativePaths.length === 0) return [];
+  const res = await session.run(
+    `MATCH (f:FileArtifact {accountId: $accountId})-[:INGESTED_AS]->(d:KnowledgeDocument)
+     WHERE f.relativePath IN $relativePaths AND NOT d:Trashed
+     OPTIONAL MATCH (d)-[:HAS_SECTION]->(s:Section)
+     OPTIONAL MATCH (s)-[:HAS_CHUNK]->(c:Chunk)
+     WITH d, collect(DISTINCT s) AS ss, collect(DISTINCT c) AS cc
+     RETURN elementId(d) AS docId,
+            [x IN ss WHERE x IS NOT NULL | elementId(x)] AS sectionIds,
+            [x IN cc WHERE x IS NOT NULL | elementId(x)] AS chunkIds`,
+    { accountId, relativePaths }
+  );
+  return res.records.map((rec) => ({
+    docId: rec.get("docId"),
+    sectionIds: rec.get("sectionIds") ?? [],
+    chunkIds: rec.get("chunkIds") ?? []
+  }));
+}
+async function cascadeTrashLinkedKnowledgeDocs(session, accountId, relativePaths) {
+  const linked = await findLinkedKnowledgeDocs(session, accountId, relativePaths);
+  let kds = 0, sections = 0, chunks = 0;
+  for (const { docId, sectionIds, chunkIds } of linked) {
+    try {
+      await trashNode({
+        session,
+        accountId,
+        elementId: docId,
+        by: "file-index:cascade",
+        reason: "physical file removed from FileArtifact index"
+      });
+      kds++;
+      for (const sid of sectionIds) {
+        await trashNode({
+          session,
+          accountId,
+          elementId: sid,
+          by: `file-index:cascade:from-${docId}`,
+          reason: `cascade from KnowledgeDocument ${docId}`
+        });
+        sections++;
+      }
+      for (const cid of chunkIds) {
+        await trashNode({
+          session,
+          accountId,
+          elementId: cid,
+          by: `file-index:cascade:from-${docId}`,
+          reason: `cascade from KnowledgeDocument ${docId}`
+        });
+        chunks++;
+      }
+    } catch (err) {
+      console.error(
+        `[file-index] cascade-trash-failed account=${accountId} docId=${docId.slice(0, 12)} err="${err.message}"`
+      );
+    }
+  }
+  return { kds, sections, chunks };
+}
 async function buildArtifact(accountId, wf, embed2) {
   const name = basename3(wf.absolute);
-  const content = await extractFileContent(wf.absolute);
+  const { content, route } = await extractFileContent(wf.absolute);
   const displayName = await readDisplayName(wf.absolute);
   const embedInput = `${name}
 ${content}`.slice(0, CONTENT_CAP);
@@ -8923,7 +9024,7 @@ ${content}`.slice(0, CONTENT_CAP);
     console.error(`[file-index] embed-failed path="${wf.relativePath}" err="${err.message}"`);
   }
   console.error(
-    `[file-index] index-file account=${accountId} path="${wf.relativePath}" chars=${content.length} embed-ms=${Date.now() - embedStart}`
+    `[file-index] index-file account=${accountId} path="${wf.relativePath}" extractor=${route} chars=${content.length} embed-ms=${Date.now() - embedStart}`
   );
   return {
     accountId,
@@ -8982,14 +9083,29 @@ async function reconcileFileIndex(accountId, opts) {
       const unchanged = prior && prior.sizeBytes === wf.sizeBytes && prior.modifiedAt === wf.modifiedAt && prior.hasEmbedding;
       if (unchanged) {
         skipped++;
-        continue;
+      } else {
+        await upsertFileArtifact(session, await buildArtifact(accountId, wf, embed2));
+        upserted++;
       }
-      await upsertFileArtifact(session, await buildArtifact(accountId, wf, embed2));
-      upserted++;
+      await linkFileArtifactToKnowledgeDocument(session, accountId, wf.relativePath, wf.absolute);
     }
     let pruned = 0;
+    let cascadeKds = 0, cascadeSections = 0, cascadeChunks = 0;
     if (clean) {
       const foundPaths = walked.map((w) => w.relativePath);
+      const goneRes = await session.run(
+        `MATCH (f:FileArtifact {accountId: $accountId})
+         WHERE NOT f.relativePath IN $foundPaths
+         RETURN f.relativePath AS rp`,
+        { accountId, foundPaths }
+      );
+      const gonePaths = goneRes.records.map((r) => r.get("rp"));
+      if (gonePaths.length > 0) {
+        const cascade = await cascadeTrashLinkedKnowledgeDocs(session, accountId, gonePaths);
+        cascadeKds = cascade.kds;
+        cascadeSections = cascade.sections;
+        cascadeChunks = cascade.chunks;
+      }
       const pruneRes = await session.run(
         `MATCH (f:FileArtifact {accountId: $accountId})
          WHERE NOT f.relativePath IN $foundPaths
@@ -9001,7 +9117,7 @@ async function reconcileFileIndex(accountId, opts) {
       pruned = typeof c?.toNumber === "function" ? c.toNumber() : Number(c ?? 0);
     }
     console.error(
-      `[file-index] reconcile account=${accountId} walked=${walked.length} upserted=${upserted} skipped=${skipped} pruned=${pruned} clean=${clean} ms=${Date.now() - t0}`
+      `[file-index] reconcile account=${accountId} walked=${walked.length} upserted=${upserted} skipped=${skipped} pruned=${pruned} cascade-kds=${cascadeKds} cascade-sections=${cascadeSections} cascade-chunks=${cascadeChunks} clean=${clean} ms=${Date.now() - t0}`
     );
     return { walked: walked.length, upserted, skipped, pruned };
   });
@@ -9030,10 +9146,12 @@ async function indexFile(accountId, relativePath, opts) {
       modifiedAt: st.mtime.toISOString()
     };
     await upsertFileArtifact(session, await buildArtifact(accountId, wf, embed2));
+    await linkFileArtifactToKnowledgeDocument(session, accountId, relativePath, absolute);
   });
 }
 async function dropFileIndex(accountId, relativePath, opts) {
   await withSession(opts, async (session) => {
+    const cascade = await cascadeTrashLinkedKnowledgeDocs(session, accountId, [relativePath]);
     const res = await session.run(
       `MATCH (f:FileArtifact {accountId: $accountId, relativePath: $relativePath})
        DETACH DELETE f
@@ -9042,7 +9160,9 @@ async function dropFileIndex(accountId, relativePath, opts) {
     );
     const c = res.records[0]?.get("dropped");
     const dropped = typeof c?.toNumber === "function" ? c.toNumber() : Number(c ?? 0);
-    console.error(`[file-index] drop account=${accountId} path="${relativePath}" dropped=${dropped}`);
+    console.error(
+      `[file-index] drop account=${accountId} path="${relativePath}" dropped=${dropped} cascade-kds=${cascade.kds} cascade-sections=${cascade.sections} cascade-chunks=${cascade.chunks}`
+    );
   });
 }
 
@@ -9139,7 +9259,8 @@ async function knowledgeDocOwnedByAccount(accountId, attachmentId) {
 var app15 = new Hono();
 app15.get("/", requireAdminSession, async (c) => {
   const cacheKey = c.var.cacheKey;
-  if (!getAccountIdForSession(cacheKey)) {
+  const accountId = getAccountIdForSession(cacheKey);
+  if (!accountId) {
     console.error(`[data] auth-rejected endpoint="/api/admin/files" reason="no account for session"`);
     return c.json({ error: "Account not found for session" }, 401);
   }
@@ -9152,17 +9273,26 @@ app15.get("/", requireAdminSession, async (c) => {
     return c.json({ error: resolution.error }, resolution.status);
   }
   const { absolute, relative: relPath2 } = resolution;
+  if (crossesForeignAccountPartition(relPath2, accountId)) {
+    console.error(`[data] account-scope-blocked endpoint="/api/admin/files" path="${relPath2}" account=${accountId.slice(0, 8)}\u2026`);
+    return c.json({ error: "Not found" }, 404);
+  }
   try {
     const info = await stat4(absolute);
     if (!info.isDirectory()) {
       return c.json({ error: "Path is not a directory \u2014 use /api/admin/files/download for files" }, 400);
     }
     const names = await readdir3(absolute);
+    const segs = relPath2.split("/").filter(Boolean);
+    const isAccountParent = segs.length === 1 && (segs[0] === "accounts" || segs[0] === "uploads");
     const entries = [];
     for (const name of names) {
       if (UUID_RE3.test(name.replace(/\.meta\.json$/, "")) && name.endsWith(".meta.json")) {
         continue;
       }
+      if (isAccountParent && UUID_RE3.test(name) && name !== accountId) {
+        continue;
+      }
       try {
         const entryPath = join12(absolute, name);
         const s = await stat4(entryPath);
@@ -9340,6 +9470,10 @@ app15.delete("/", requireAdminSession, async (c) => {
     return c.json({ error: resolution.error }, resolution.status);
   }
   const { absolute, relative: relPath2 } = resolution;
+  if (crossesForeignAccountPartition(relPath2, accountId)) {
+    console.error(`[data] account-scope-blocked endpoint="DELETE /api/admin/files" path="${relPath2}" account=${accountId.slice(0, 8)}\u2026`);
+    return c.json({ error: "Not found" }, 404);
+  }
   const base = basename4(absolute);
   const segments = relPath2.split("/").filter(Boolean);
   if (base === "account.json" || segments.includes(".git")) {
@@ -11397,126 +11531,14 @@ var WRITE_CYPHER = `
 var graph_default_view_default = app21;
 
 // server/routes/admin/sidebar-artefacts.ts
-import neo4j2 from "neo4j-driver";
-import { readFile as readFile5, readdir as readdir4, stat as stat5 } from "fs/promises";
-import { resolve as resolve16, relative as relative4, isAbsolute, sep as sep6 } from "path";
+import { readdir as readdir4, stat as stat5 } from "fs/promises";
+import { resolve as resolve15, relative as relative3, isAbsolute, sep as sep5, basename as basename5 } from "path";
 import { existsSync as existsSync16 } from "fs";
-
-// app/lib/doc-source-resolve.ts
-import { readdirSync as readdirSync8, realpathSync as realpathSync5, statSync as statSync7 } from "fs";
-import { relative as relative3, resolve as resolve15, sep as sep5 } from "path";
-function containedFile(absPath, root) {
-  try {
-    const real = realpathSync5(absPath);
-    const rootReal = realpathSync5(root);
-    if (real !== rootReal && !real.startsWith(rootReal + sep5)) return null;
-    return statSync7(real).isFile() ? real : null;
-  } catch {
-    return null;
-  }
-}
-function dataFileInDir(dir) {
-  let entries;
-  try {
-    entries = readdirSync8(dir, { withFileTypes: true }).flatMap((e) => e.isFile() ? [e.name] : []);
-  } catch {
-    return null;
-  }
-  const file = entries.find((e) => !e.endsWith(".meta.json"));
-  return file ? resolve15(dir, file) : null;
-}
-function mapToDownloadRoot(absPath, roots) {
-  const underData = containedFile(absPath, roots.dataRoot);
-  if (underData) {
-    return { root: "data", relPath: relative3(realpathSync5(roots.dataRoot), underData), absReal: underData };
-  }
-  if (roots.claudeUploadsRoot) {
-    const underClaude = containedFile(absPath, roots.claudeUploadsRoot);
-    if (underClaude) {
-      return {
-        root: "claude-uploads",
-        relPath: relative3(realpathSync5(roots.claudeUploadsRoot), underClaude),
-        absReal: underClaude
-      };
-    }
-  }
-  return null;
-}
-function resolveDocDownload(input, roots) {
-  const { accountId, attachmentId, name, sourcePath, sourceType } = input;
-  if (sourcePath) {
-    const mapped = mapToDownloadRoot(sourcePath, roots);
-    if (mapped) {
-      return { ok: true, absPath: mapped.absReal, root: mapped.root, relPath: mapped.relPath, via: "stored" };
-    }
-  }
-  if (attachmentId) {
-    const uploadsDir = resolve15(roots.attachmentsRoot, accountId, attachmentId);
-    const file = dataFileInDir(uploadsDir);
-    if (file) {
-      const real = containedFile(file, roots.dataRoot);
-      if (real) {
-        return { ok: true, absPath: real, root: "data", relPath: relative3(realpathSync5(roots.dataRoot), real), via: "uploads" };
-      }
-    }
-  }
-  if (attachmentId && roots.claudeUploadsRoot) {
-    const claudeDir = resolve15(roots.claudeUploadsRoot, attachmentId);
-    const file = dataFileInDir(claudeDir);
-    if (file) {
-      const real = containedFile(file, roots.claudeUploadsRoot);
-      if (real) {
-        return {
-          ok: true,
-          absPath: real,
-          root: "claude-uploads",
-          relPath: relative3(realpathSync5(roots.claudeUploadsRoot), real),
-          via: "claude-uploads"
-        };
-      }
-    }
-  }
-  if (name) {
-    const outputFile = resolve15(roots.accountsDir, accountId, "output", name);
-    const real = containedFile(outputFile, roots.dataRoot);
-    if (real) {
-      return { ok: true, absPath: real, root: "data", relPath: relative3(realpathSync5(roots.dataRoot), real), via: "output" };
-    }
-  }
-  return { ok: false, reason: sourceType === "web" ? "no-persisted-file" : "unresolved" };
-}
-
-// server/routes/admin/sidebar-artefacts.ts
 var LIMIT = 50;
-var TEXT_MIME_PREFIXES = ["text/", "application/json", "application/markdown"];
 var ADMIN_AGENT_FILES = ["IDENTITY.md", "SOUL.md", "KNOWLEDGE.md"];
 function toDataRootRelPath(absPath) {
-  if (absPath !== DATA_ROOT && !absPath.startsWith(DATA_ROOT + sep6)) return null;
-  return relative4(DATA_ROOT, absPath);
-}
-function resolveDocDownloadRow(meta) {
-  const result = resolveDocDownload(
-    {
-      accountId: meta.accountId,
-      attachmentId: meta.attachmentId,
-      name: meta.name,
-      sourcePath: meta.sourcePath,
-      sourceType: meta.sourceType
-    },
-    {
-      dataRoot: DATA_ROOT,
-      attachmentsRoot: ATTACHMENTS_ROOT,
-      accountsDir: ACCOUNTS_DIR,
-      claudeUploadsRoot: CLAUDE_UPLOADS_ROOT
-    }
-  );
-  const aid = meta.attachmentId ? meta.attachmentId.slice(0, 8) : "none";
-  if (result.ok) {
-    console.log(`[admin/sidebar-artefacts] download-resolved id=${aid} via=${result.via} root=${result.root}`);
-    return { downloadPath: result.relPath, downloadRoot: result.root };
-  }
-  console.log(`[admin/sidebar-artefacts] not-downloadable id=${aid} reason=${result.reason}`);
-  return { downloadPath: null, downloadRoot: null };
+  if (absPath !== DATA_ROOT && !absPath.startsWith(DATA_ROOT + sep5)) return null;
+  return relative3(DATA_ROOT, absPath);
 }
 var app22 = new Hono();
 app22.get("/", requireAdminSession, async (c) => {
@@ -11526,118 +11548,64 @@ app22.get("/", requireAdminSession, async (c) => {
     return c.json({ error: "Account not found for session" }, 401);
   }
   const start = Date.now();
-  const docs = await fetchKnowledgeDocs(accountId);
-  if (docs === null) {
+  const outputs = await fetchOutputArtefacts(accountId);
+  if (outputs === null) {
     return c.json({ error: "Failed to load artefacts" }, 500);
   }
-  const accountDir = resolve16(ACCOUNTS_DIR, accountId);
+  const accountDir = resolve15(ACCOUNTS_DIR, accountId);
   const agents = await fetchAgentTemplateRows(accountDir);
-  const artefacts = [...docs, ...agents].sort(
+  const artefacts = [...outputs, ...agents].sort(
     (a, b) => (b.updatedAt ?? "").localeCompare(a.updatedAt ?? "")
   ).slice(0, LIMIT);
   const ms = Date.now() - start;
   console.log(
-    `[admin/sidebar-artefacts] account=${accountId} count=${artefacts.length} docs=${docs.length} agents=${agents.length} ms=${ms}`
+    `[admin/sidebar-artefacts] account=${accountId} count=${artefacts.length} outputs=${outputs.length} agents=${agents.length} ms=${ms}`
   );
   return c.json({ artefacts });
 });
-async function fetchKnowledgeDocs(accountId) {
+async function fetchOutputArtefacts(accountId) {
   const session = getSession();
-  let metas = [];
   try {
     const result = await session.run(
-      `MATCH (d:KnowledgeDocument { accountId: $accountId })
-       WHERE d.deletedAt IS NULL AND NOT d:Trashed
-       RETURN d.attachmentId AS id, d.name AS name, d.updatedAt AS updatedAt,
-              d.attachmentId AS attachmentId, d.encodingFormat AS mimeType,
-              d.sourcePath AS sourcePath, d.sourceType AS sourceType
-       ORDER BY d.updatedAt DESC
-       LIMIT $limit`,
-      { accountId, limit: neo4j2.int(LIMIT) }
-    );
-    metas = result.records.map((r) => ({
-      id: r.get("id"),
-      name: r.get("name") ?? "",
-      updatedAt: r.get("updatedAt") ?? "",
-      attachmentId: r.get("attachmentId"),
-      mimeType: r.get("mimeType") ?? "",
-      sourcePath: r.get("sourcePath") ?? null,
-      sourceType: r.get("sourceType") ?? null
-    }));
+      `MATCH (f:FileArtifact { accountId: $accountId })
+       WHERE f.relativePath CONTAINS '/output/'
+       RETURN f.relativePath AS relativePath,
+              f.displayName  AS displayName,
+              f.mimeType     AS mimeType,
+              f.modifiedAt   AS modifiedAt
+       ORDER BY f.modifiedAt DESC
+       LIMIT 50`,
+      { accountId }
+    );
+    return result.records.map((r) => {
+      const relativePath = r.get("relativePath");
+      const displayName = r.get("displayName") ?? null;
+      const mimeType = r.get("mimeType") ?? "";
+      const modifiedAt = r.get("modifiedAt") ?? "";
+      return {
+        id: `output-file:${relativePath}`,
+        name: displayName ?? basename5(relativePath),
+        kind: "output-file",
+        updatedAt: modifiedAt,
+        editable: false,
+        mimeType,
+        downloadPath: relativePath,
+        downloadRoot: "data"
+      };
+    });
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     console.error(`[admin/sidebar-artefacts] account=${accountId} error="${message}"`);
-    await session.close();
     return null;
   } finally {
     await session.close();
   }
-  return Promise.all(metas.map(async (m) => {
-    const { content, skipReason } = await readArtefactContent(accountId, m.attachmentId, m.mimeType, m.name);
-    const { downloadPath, downloadRoot } = resolveDocDownloadRow({
-      accountId,
-      attachmentId: m.attachmentId,
-      name: m.name,
-      sourcePath: m.sourcePath,
-      sourceType: m.sourceType
-    });
-    return {
-      id: m.id,
-      name: m.name,
-      kind: "knowledge-doc",
-      updatedAt: m.updatedAt,
-      content,
-      editable: skipReason === null,
-      mimeType: m.mimeType,
-      skipReason,
-      downloadPath,
-      downloadRoot
-    };
-  }));
-}
-async function readArtefactContent(accountId, attachmentId, mimeType, displayName) {
-  if (!attachmentId) {
-    logSkip(displayName, "null-attachmentId", mimeType);
-    return { content: "", skipReason: "null-attachmentId" };
-  }
-  const isText = TEXT_MIME_PREFIXES.some((p) => mimeType.startsWith(p));
-  if (!isText) {
-    logSkip(displayName, "non-text-mime", mimeType);
-    return { content: "", skipReason: "non-text-mime" };
-  }
-  const accountDir = resolve16(ATTACHMENTS_ROOT, accountId);
-  const dir = resolve16(accountDir, attachmentId);
-  try {
-    validateFilePathInAccount(dir, accountDir);
-  } catch {
-    logSkip(displayName, "containment-rejected", mimeType);
-    return { content: "", skipReason: "containment-rejected" };
-  }
-  try {
-    const entries = await readdir4(dir);
-    const dataFile = entries.find((f) => !f.endsWith(".meta.json"));
-    if (!dataFile) {
-      logSkip(displayName, "missing-on-disk", mimeType);
-      return { content: "", skipReason: "missing-on-disk" };
-    }
-    return { content: await readFile5(resolve16(dir, dataFile), "utf-8"), skipReason: null };
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    console.error(`[admin/sidebar-artefacts] read-failed attachmentId=${attachmentId.slice(0, 8)} error="${message}"`);
-    logSkip(displayName, "missing-on-disk", mimeType);
-    return { content: "", skipReason: "missing-on-disk" };
-  }
-}
-function logSkip(name, reason, mimeType) {
-  console.log(
-    `[admin/sidebar-artefacts] content-skipped name="${name}" reason=${reason} mimeType=${mimeType || "none"}`
-  );
 }
 async function fetchAgentTemplateRows(accountDir) {
   const rows = [];
   for (const filename of ADMIN_AGENT_FILES) {
-    const overridePath = resolve16(accountDir, "agents", "admin", filename);
-    const bundledPath = resolve16(PLATFORM_ROOT, "templates", "agents", "admin", filename);
+    const overridePath = resolve15(accountDir, "agents", "admin", filename);
+    const bundledPath = resolve15(PLATFORM_ROOT, "templates", "agents", "admin", filename);
     const labelStem = filename.replace(/\.md$/, "");
     const row = await readAgentTemplateRow({
       id: `agent-template:admin:${filename}`,
@@ -11651,12 +11619,12 @@ async function fetchAgentTemplateRows(accountDir) {
     });
     if (row) rows.push(row);
   }
-  const overrideDir = resolve16(accountDir, "specialists", "agents");
-  const bundledDir = resolve16(PLATFORM_ROOT, "templates", "specialists", "agents");
+  const overrideDir = resolve15(accountDir, "specialists", "agents");
+  const bundledDir = resolve15(PLATFORM_ROOT, "templates", "specialists", "agents");
   const specialistNames = await unionSpecialistFilenames(overrideDir, bundledDir);
   for (const filename of specialistNames) {
-    const overridePath = resolve16(overrideDir, filename);
-    const bundledPath = resolve16(bundledDir, filename);
+    const overridePath = resolve15(overrideDir, filename);
+    const bundledPath = resolve15(bundledDir, filename);
     const row = await readAgentTemplateRow({
       id: `agent-template:specialist:${filename}`,
       displayName: filename.replace(/\.md$/, ""),
@@ -11711,20 +11679,15 @@ async function readAgentTemplateRow(inp) {
   }
   if (!chosenPath) return null;
   try {
-    const [content, st] = await Promise.all([
-      readFile5(chosenPath, "utf-8"),
-      stat5(chosenPath)
-    ]);
+    const st = await stat5(chosenPath);
     const dlPath = toDataRootRelPath(chosenPath);
     return {
       id: inp.id,
       name: inp.displayName,
       kind: "agent-template",
       updatedAt: st.mtime.toISOString(),
-      content,
       editable: inp.editable,
       mimeType: "text/markdown",
-      skipReason: null,
       // Override paths live under <accountDir> (inside DATA_ROOT) and are
       // downloadable; bundled-fallback templates live under PLATFORM_ROOT
       // (outside DATA_ROOT) → null, so the client shows "not downloadable".
@@ -11742,17 +11705,15 @@ async function readAgentTemplateRow(inp) {
   }
 }
 function isWithin(target, root) {
-  const rel = relative4(root, target);
+  const rel = relative3(root, target);
   return !rel.startsWith("..") && !isAbsolute(rel);
 }
 var sidebar_artefacts_default = app22;
 
 // server/routes/admin/sidebar-artefact-save.ts
-import { mkdir as mkdir4, readdir as readdir5, stat as stat6, writeFile as writeFile5 } from "fs/promises";
-import { resolve as resolve17 } from "path";
-import { existsSync as existsSync17 } from "fs";
+import { mkdir as mkdir4, stat as stat6, writeFile as writeFile5 } from "fs/promises";
+import { resolve as resolve16 } from "path";
 var ADMIN_AGENT_FILES2 = /* @__PURE__ */ new Set(["IDENTITY.md", "SOUL.md", "KNOWLEDGE.md"]);
-var UUID_RE4 = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
 var app23 = new Hono();
 app23.post("/", requireAdminSession, async (c) => {
   const cacheKey = c.var.cacheKey;
@@ -11762,12 +11723,8 @@ app23.post("/", requireAdminSession, async (c) => {
   if (!body || typeof body.id !== "string" || typeof body.content !== "string") {
     return c.json({ error: "id and content required" }, 400);
   }
-  const accountDir = resolve17(ACCOUNTS_DIR, accountId);
-  const resolved = await resolveSavePath(body.id, accountId, accountDir);
-  if (resolved.kind === "heal-race") {
-    c.header("Retry-After", "2");
-    return c.json({ error: "heal-race", reason: resolved.reason }, 503);
-  }
+  const accountDir = resolve16(ACCOUNTS_DIR, accountId);
+  const resolved = await resolveSavePath(body.id, accountDir);
   if (resolved.kind === "reject") {
     console.error(
       `[admin/sidebar-artefact-save] auth-rejected reason=${resolved.reason} path=${body.id}`
@@ -11796,129 +11753,88 @@ app23.post("/", requireAdminSession, async (c) => {
   );
   return c.json({ updatedAt });
 });
-async function resolveSavePath(id, accountId, accountDir) {
-  if (id.startsWith("agent-template:")) {
-    const parts = id.split(":");
-    if (parts.length !== 3) return { kind: "reject", status: 400, reason: "invalid-id" };
-    const [, role, filename] = parts;
-    if (role === "specialist") {
-      return { kind: "reject", status: 403, reason: "specialist-write-blocked" };
-    }
-    if (role !== "admin" || !ADMIN_AGENT_FILES2.has(filename)) {
-      return { kind: "reject", status: 400, reason: "invalid-id" };
-    }
-    const parent = resolve17(accountDir, "agents", "admin");
-    await mkdir4(parent, { recursive: true });
-    try {
-      validateFilePathInAccount(parent, accountDir);
-    } catch {
-      return { kind: "reject", status: 400, reason: "containment-rejected" };
-    }
-    return { kind: "admin-template", path: resolve17(parent, filename) };
+async function resolveSavePath(id, accountDir) {
+  if (!id.startsWith("agent-template:")) {
+    return { kind: "reject", status: 400, reason: "invalid-id" };
   }
-  if (UUID_RE4.test(id)) {
-    const dir = resolve17(ATTACHMENTS_ROOT, accountId, id);
-    if (!existsSync17(dir)) {
-      const attShort = id.slice(0, 8);
-      if (isHealPending(accountId, id)) {
-        console.error(`[admin/sidebar-artefact-save] heal-race attachmentId=${attShort} outcome=503-retry source=heal-pending`);
-        return { kind: "heal-race", reason: "dir-pending" };
-      }
-      const session = getSession();
-      try {
-        const result = await session.run(
-          `MATCH (k:KnowledgeDocument {accountId: $accountId, attachmentId: $attachmentId})
-           RETURN count(k) AS cnt`,
-          { accountId, attachmentId: id }
-        );
-        const cnt = result.records[0]?.get("cnt")?.toNumber?.() ?? 0;
-        if (cnt > 0) {
-          console.error(`[admin/sidebar-artefact-save] heal-race attachmentId=${attShort} outcome=503-retry source=neo4j-row`);
-          return { kind: "heal-race", reason: "dir-pending" };
-        }
-        console.error(`[admin/sidebar-artefact-save] heal-race attachmentId=${attShort} outcome=400-terminal`);
-        return { kind: "reject", status: 400, reason: "not-found" };
-      } catch (neoErr) {
-        const reason = neoErr instanceof Error ? neoErr.message.slice(0, 120) : String(neoErr).slice(0, 120);
-        console.error(`[admin/sidebar-artefact-save] heal-race attachmentId=${attShort} outcome=neo4j-fail reason="${reason}"`);
-        return { kind: "heal-race", reason: "neo4j-fail" };
-      } finally {
-        try {
-          await session.close();
-        } catch {
-        }
-      }
-    }
-    try {
-      validateFilePathInAccount(dir, resolve17(ATTACHMENTS_ROOT, accountId));
-    } catch {
-      return { kind: "reject", status: 400, reason: "containment-rejected" };
-    }
-    const entries = await readdir5(dir);
-    const dataFile = entries.find((f) => !f.endsWith(".meta.json"));
-    if (!dataFile) {
-      return { kind: "reject", status: 400, reason: "not-found" };
-    }
-    return { kind: "knowledge-doc", path: resolve17(dir, dataFile) };
+  const parts = id.split(":");
+  if (parts.length !== 3) return { kind: "reject", status: 400, reason: "invalid-id" };
+  const [, role, filename] = parts;
+  if (role === "specialist") {
+    return { kind: "reject", status: 403, reason: "specialist-write-blocked" };
+  }
+  if (role !== "admin" || !ADMIN_AGENT_FILES2.has(filename)) {
+    return { kind: "reject", status: 400, reason: "invalid-id" };
+  }
+  const parent = resolve16(accountDir, "agents", "admin");
+  await mkdir4(parent, { recursive: true });
+  try {
+    validateFilePathInAccount(parent, accountDir);
+  } catch {
+    return { kind: "reject", status: 400, reason: "containment-rejected" };
   }
-  return { kind: "reject", status: 400, reason: "invalid-id" };
+  return { kind: "admin-template", path: resolve16(parent, filename) };
 }
 function relPath(absPath, root) {
   return absPath.startsWith(root) ? absPath.slice(root.length + 1) : absPath;
 }
 var sidebar_artefact_save_default = app23;
 
-// server/routes/admin/sidebar-artefact-content.ts
-import { readFile as readFile6, readdir as readdir6 } from "fs/promises";
-import { existsSync as existsSync18 } from "fs";
-import { resolve as resolve18 } from "path";
-var UUID_RE5 = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+// server/routes/admin/sidebar-sessions.ts
 var app24 = new Hono();
 app24.get("/", requireAdminSession, async (c) => {
   const cacheKey = c.var.cacheKey;
   const accountId = getAccountIdForSession(cacheKey);
-  if (!accountId) return new Response("Unauthorized", { status: 401 });
-  const id = c.req.query("id") ?? "";
-  if (!UUID_RE5.test(id)) {
-    console.error(`[admin/sidebar-artefact-content] not-found id=${id.slice(0, 8)}`);
-    return new Response("Not found", { status: 404 });
+  if (!accountId) {
+    return c.json({ error: "Account not found for session" }, 401);
   }
-  const dir = resolve18(ATTACHMENTS_ROOT, accountId, id);
-  if (!existsSync18(dir)) {
-    console.error(`[admin/sidebar-artefact-content] not-found id=${id.slice(0, 8)}`);
-    return new Response("Not found", { status: 404 });
+  const port2 = requirePortEnv("CLAUDE_SESSION_MANAGER_PORT", { tag: "admin-sessions-list" });
+  const url = `http://127.0.0.1:${port2}/list?senderId=${encodeURIComponent(accountId)}`;
+  let upstream = null;
+  try {
+    upstream = await fetch(url);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(`[admin-sessions-list] account=${accountId} fetch-failed error="${message}"`);
+    return c.json({ error: "session-manager-unreachable" }, 503);
   }
-  let meta;
+  if (!upstream.ok) {
+    console.error(`[admin-sessions-list] account=${accountId} upstream-status=${upstream.status}`);
+    return c.json({ error: "session-manager-error", status: upstream.status }, 502);
+  }
+  let payloads;
   try {
-    meta = JSON.parse(await readFile6(resolve18(dir, `${id}.meta.json`), "utf-8"));
-  } catch {
-    console.error(`[admin/sidebar-artefact-content] not-found id=${id.slice(0, 8)}`);
-    return new Response("Not found", { status: 404 });
+    payloads = await upstream.json();
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(`[admin-sessions-list] account=${accountId} parse-failed error="${message}"`);
+    return c.json({ error: "session-manager-bad-body" }, 502);
   }
-  const entries = await readdir6(dir);
-  const dataFile = entries.find((f) => !f.endsWith(".meta.json"));
-  if (!dataFile) {
-    console.error(`[admin/sidebar-artefact-content] not-found id=${id.slice(0, 8)}`);
-    return new Response("Not found", { status: 404 });
+  if (!Array.isArray(payloads)) {
+    console.error(`[admin-sessions-list] account=${accountId} bad-shape=not-array`);
+    return c.json({ error: "session-manager-bad-body" }, 502);
   }
-  const start = Date.now();
-  const buffer = await readFile6(resolve18(dir, dataFile));
-  const ms = Date.now() - start;
-  console.log(
-    `[admin/sidebar-artefact-content] account=${accountId} id=${id.slice(0, 8)} mime=${meta.mimeType} bytes=${buffer.length} ms=${ms}`
-  );
-  return new Response(new Uint8Array(buffer), {
-    headers: {
-      "Content-Type": meta.mimeType,
-      "Content-Disposition": `inline; filename="${meta.filename}"`,
-      "Cache-Control": "private, max-age=3600"
-    }
-  });
+  const rows = [];
+  for (const p of payloads) {
+    const sessionId = typeof p.sessionId === "string" ? p.sessionId : null;
+    const capturedUrl = typeof p.url === "string" ? p.url : null;
+    const startedAt = typeof p.startedAt === "string" ? p.startedAt : null;
+    if (!sessionId || !capturedUrl || !startedAt) continue;
+    const displayName = typeof p.displayName === "string" && p.displayName.length > 0 ? p.displayName : sessionId.slice(0, 8);
+    rows.push({
+      sessionId,
+      title: displayName,
+      url: capturedUrl,
+      capturedAt: startedAt
+    });
+  }
+  console.log(`[admin-sessions-list] account=${accountId} rows=${rows.length}`);
+  return c.json({ sessions: rows });
 });
-var sidebar_artefact_content_default = app24;
+var sidebar_sessions_default = app24;
 
 // server/routes/admin/system-stats.ts
-import { readFile as readFile7 } from "fs/promises";
+import { readFile as readFile5 } from "fs/promises";
 import { cpus, loadavg, totalmem, freemem } from "os";
 function parseCpuStat(blob) {
   const line = blob.split("\n", 1)[0] ?? "";
@@ -11962,11 +11878,11 @@ function parseMeminfo(blob) {
 }
 var SAMPLE_DELAY_MS = 100;
 async function sampleLinux() {
-  const a = parseCpuStat(await readFile7("/proc/stat", "utf-8"));
+  const a = parseCpuStat(await readFile5("/proc/stat", "utf-8"));
   await new Promise((r) => setTimeout(r, SAMPLE_DELAY_MS));
-  const b = parseCpuStat(await readFile7("/proc/stat", "utf-8"));
-  const meminfo = parseMeminfo(await readFile7("/proc/meminfo", "utf-8"));
-  const loadavgRaw = (await readFile7("/proc/loadavg", "utf-8")).trim();
+  const b = parseCpuStat(await readFile5("/proc/stat", "utf-8"));
+  const meminfo = parseMeminfo(await readFile5("/proc/meminfo", "utf-8"));
+  const loadavgRaw = (await readFile5("/proc/loadavg", "utf-8")).trim();
   const [l1, l5, l15] = loadavgRaw.split(/\s+/, 3).map(Number);
   if (![l1, l5, l15].every(Number.isFinite)) {
     throw new Error(`malformed /proc/loadavg: ${loadavgRaw}`);
@@ -12039,23 +11955,23 @@ app25.get("/", async (c) => {
 var system_stats_default = app25;
 
 // server/routes/admin/health.ts
-import { existsSync as existsSync19, readFileSync as readFileSync14 } from "fs";
-import { resolve as resolve19, join as join13 } from "path";
-var PLATFORM_ROOT6 = process.env.MAXY_PLATFORM_ROOT ?? resolve19(process.cwd(), "..");
+import { existsSync as existsSync17, readFileSync as readFileSync14 } from "fs";
+import { resolve as resolve17, join as join13 } from "path";
+var PLATFORM_ROOT6 = process.env.MAXY_PLATFORM_ROOT ?? resolve17(process.cwd(), "..");
 var brandHostname = "maxy";
 var brandJsonPath = join13(PLATFORM_ROOT6, "config", "brand.json");
-if (existsSync19(brandJsonPath)) {
+if (existsSync17(brandJsonPath)) {
   try {
     const brand = JSON.parse(readFileSync14(brandJsonPath, "utf-8"));
     if (brand.hostname) brandHostname = brand.hostname;
   } catch {
   }
 }
-var VERSION_FILE = resolve19(PLATFORM_ROOT6, `config/.${brandHostname}-version`);
+var VERSION_FILE = resolve17(PLATFORM_ROOT6, `config/.${brandHostname}-version`);
 var PROCESS_STARTED_AT = (/* @__PURE__ */ new Date()).toISOString();
 var PROBE_TIMEOUT_MS = 1e3;
 function readVersion() {
-  if (!existsSync19(VERSION_FILE)) return "unknown";
+  if (!existsSync17(VERSION_FILE)) return "unknown";
   return readFileSync14(VERSION_FILE, "utf-8").trim() || "unknown";
 }
 async function probeConversationDb() {
@@ -12258,7 +12174,7 @@ app27.post("/", requireAdminSession, async (c) => {
 var linkedin_ingest_default = app27;
 
 // server/routes/admin/post-turn-context.ts
-import neo4j3 from "neo4j-driver";
+import neo4j2 from "neo4j-driver";
 var TAG21 = "[post-turn-context]";
 var STRIPPED_PROPERTIES2 = /* @__PURE__ */ new Set([
   "embedding",
@@ -12271,10 +12187,10 @@ function isLoopbackAddr2(addr) {
   return addr === "127.0.0.1" || addr === "::1" || addr === "::ffff:127.0.0.1";
 }
 function convertValue(value) {
-  if (neo4j3.isDateTime(value) || neo4j3.isDate(value) || neo4j3.isLocalDateTime(value) || neo4j3.isLocalTime(value) || neo4j3.isTime(value) || neo4j3.isDuration(value)) {
+  if (neo4j2.isDateTime(value) || neo4j2.isDate(value) || neo4j2.isLocalDateTime(value) || neo4j2.isLocalTime(value) || neo4j2.isTime(value) || neo4j2.isDuration(value)) {
     return value.toString();
   }
-  if (neo4j3.isInt(value)) {
+  if (neo4j2.isInt(value)) {
     return value.inSafeRange() ? value.toNumber() : value.toString();
   }
   if (Array.isArray(value)) {
@@ -12361,7 +12277,7 @@ app28.get("/", async (c) => {
 var post_turn_context_default = app28;
 
 // server/routes/admin/public-session-context.ts
-import neo4j4 from "neo4j-driver";
+import neo4j3 from "neo4j-driver";
 var TAG22 = "[public-session-context]";
 var STRIPPED_PROPERTIES3 = /* @__PURE__ */ new Set([
   "embedding",
@@ -12374,10 +12290,10 @@ function isLoopbackAddr3(addr) {
   return addr === "127.0.0.1" || addr === "::1" || addr === "::ffff:127.0.0.1";
 }
 function convertValue2(value) {
-  if (neo4j4.isDateTime(value) || neo4j4.isDate(value) || neo4j4.isLocalDateTime(value) || neo4j4.isLocalTime(value) || neo4j4.isTime(value) || neo4j4.isDuration(value)) {
+  if (neo4j3.isDateTime(value) || neo4j3.isDate(value) || neo4j3.isLocalDateTime(value) || neo4j3.isLocalTime(value) || neo4j3.isTime(value) || neo4j3.isDuration(value)) {
     return value.toString();
   }
-  if (neo4j4.isInt(value)) {
+  if (neo4j3.isInt(value)) {
     return value.inSafeRange() ? value.toNumber() : value.toString();
   }
   if (Array.isArray(value)) {
@@ -12553,7 +12469,7 @@ app32.route("/graph-labels-in-graph", graph_labels_in_graph_default);
 app32.route("/graph-default-view", graph_default_view_default);
 app32.route("/sidebar-artefacts", sidebar_artefacts_default);
 app32.route("/sidebar-artefact-save", sidebar_artefact_save_default);
-app32.route("/sidebar-artefact-content", sidebar_artefact_content_default);
+app32.route("/sidebar-sessions", sidebar_sessions_default);
 app32.route("/system-stats", system_stats_default);
 app32.route("/health-brand", health_default2);
 app32.route("/linkedin-ingest", linkedin_ingest_default);
@@ -12564,15 +12480,15 @@ app32.route("/access-session-evict", access_session_evict_default);
 var admin_default = app32;
 
 // app/lib/access-gate.ts
-import neo4j5 from "neo4j-driver";
+import neo4j4 from "neo4j-driver";
 import { readFileSync as readFileSync15 } from "fs";
-import { resolve as resolve20 } from "path";
+import { resolve as resolve18 } from "path";
 import { randomUUID as randomUUID8 } from "crypto";
-var PLATFORM_ROOT7 = process.env.MAXY_PLATFORM_ROOT ?? resolve20(process.cwd(), "..");
+var PLATFORM_ROOT7 = process.env.MAXY_PLATFORM_ROOT ?? resolve18(process.cwd(), "..");
 var driver = null;
 function readPassword() {
   if (process.env.NEO4J_PASSWORD) return process.env.NEO4J_PASSWORD;
-  const passwordFile = resolve20(PLATFORM_ROOT7, "config/.neo4j-password");
+  const passwordFile = resolve18(PLATFORM_ROOT7, "config/.neo4j-password");
   try {
     return readFileSync15(passwordFile, "utf-8").trim();
   } catch {
@@ -12592,7 +12508,7 @@ function getDriver() {
     const user = process.env.NEO4J_USER ?? "neo4j";
     const password = readPassword();
     console.error(`[ui/access-gate] resolved neo4j_uri=${uri}`);
-    driver = neo4j5.driver(uri, neo4j5.auth.basic(user, password), {
+    driver = neo4j4.driver(uri, neo4j4.auth.basic(user, password), {
       maxConnectionPoolSize: 5
     });
   }
@@ -12862,9 +12778,9 @@ var verify_token_default = app33;
 
 // app/lib/access-email.ts
 import { spawn as spawn2 } from "child_process";
-import { resolve as resolve21 } from "path";
-var PLATFORM_ROOT8 = process.env.MAXY_PLATFORM_ROOT ?? resolve21(process.cwd(), "..");
-var SEND_SCRIPT = resolve21(
+import { resolve as resolve19 } from "path";
+var PLATFORM_ROOT8 = process.env.MAXY_PLATFORM_ROOT ?? resolve19(process.cwd(), "..");
+var SEND_SCRIPT = resolve19(
   PLATFORM_ROOT8,
   "plugins",
   "email",
@@ -13006,8 +12922,8 @@ app35.route("/request-magic-link", request_magic_link_default);
 var access_default = app35;
 
 // server/routes/sites.ts
-import { existsSync as existsSync20, readFileSync as readFileSync16, realpathSync as realpathSync6, statSync as statSync8 } from "fs";
-import { resolve as resolve22 } from "path";
+import { existsSync as existsSync18, readFileSync as readFileSync16, realpathSync as realpathSync5, statSync as statSync7 } from "fs";
+import { resolve as resolve20 } from "path";
 var SAFE_SEG_RE = /^[a-z0-9_][a-z0-9_.-]{0,99}$/i;
 var MIME = {
   ".html": "text/html; charset=utf-8",
@@ -13064,19 +12980,19 @@ app36.get("/:rel{.*}", (c) => {
     }
     segments.push(seg);
   }
-  const rootDir = resolve22(account.accountDir, "sites");
-  let filePath = segments.length === 0 ? rootDir : resolve22(rootDir, ...segments);
+  const rootDir = resolve20(account.accountDir, "sites");
+  let filePath = segments.length === 0 ? rootDir : resolve20(rootDir, ...segments);
   if (filePath !== rootDir && !filePath.startsWith(rootDir + "/")) {
     console.error(`[sites] path-traversal-rejected path=${reqPath} reason=escape status=403`);
     return c.text("Forbidden", 403);
   }
-  let stat7;
+  let stat8;
   try {
-    stat7 = existsSync20(filePath) ? statSync8(filePath) : null;
+    stat8 = existsSync18(filePath) ? statSync7(filePath) : null;
   } catch {
-    stat7 = null;
+    stat8 = null;
   }
-  if (stat7?.isDirectory() && !reqPath.endsWith("/")) {
+  if (stat8?.isDirectory() && !reqPath.endsWith("/")) {
     const search = new URL(c.req.url).search;
     const target = `${reqPath}/${search}`;
     console.log(
@@ -13084,22 +13000,22 @@ app36.get("/:rel{.*}", (c) => {
     );
     return c.redirect(target, 301);
   }
-  if (stat7?.isDirectory()) {
-    filePath = resolve22(filePath, "index.html");
+  if (stat8?.isDirectory()) {
+    filePath = resolve20(filePath, "index.html");
   }
   if (!filePath.startsWith(rootDir + "/")) {
     console.error(`[sites] path-traversal-rejected path=${reqPath} reason=escape status=403`);
     return c.text("Forbidden", 403);
   }
-  if (!existsSync20(filePath)) {
+  if (!existsSync18(filePath)) {
     console.error(`[sites] not-found path=${reqPath} status=404`);
     return c.text("Not found", 404);
   }
   let realPath;
   let realRoot;
   try {
-    realPath = realpathSync6(filePath);
-    realRoot = realpathSync6(rootDir);
+    realPath = realpathSync5(filePath);
+    realRoot = realpathSync5(rootDir);
   } catch {
     console.error(`[sites] not-found path=${reqPath} status=404`);
     return c.text("Not found", 404);
@@ -13222,7 +13138,7 @@ var VISITOR_COOKIE_NAME = "mxy_v";
 var VISITOR_COOKIE_MAX_AGE_SECONDS = Math.floor(DEFAULT_TTL_MS / 1e3);
 
 // app/lib/brand-config.ts
-import { existsSync as existsSync21, readFileSync as readFileSync18 } from "fs";
+import { existsSync as existsSync19, readFileSync as readFileSync18 } from "fs";
 import { join as join14 } from "path";
 var cached2 = null;
 var cachedAttempted = false;
@@ -13232,7 +13148,7 @@ function readBrandConfig() {
   const platformRoot = process.env.MAXY_PLATFORM_ROOT;
   if (!platformRoot) return null;
   const brandPath = join14(platformRoot, "config", "brand.json");
-  if (!existsSync21(brandPath)) return null;
+  if (!existsSync19(brandPath)) return null;
   try {
     cached2 = JSON.parse(readFileSync18(brandPath, "utf-8"));
     return cached2;
@@ -13802,6 +13718,109 @@ function startGraphHealthTimer() {
   if (typeof timer.unref === "function") timer.unref();
 }
 
+// app/lib/file-watcher.ts
+import * as fsp2 from "fs/promises";
+import { resolve as resolve21, sep as sep6 } from "path";
+var ACCOUNT_UUID_RE2 = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var DEFAULT_COALESCE_MS = 500;
+var ROOTS = ["uploads", "accounts"];
+function _routeEvent(rootName, filename) {
+  if (!filename) return null;
+  const segs = filename.split(sep6).filter(Boolean);
+  if (segs.length < 2) return null;
+  const accountId = segs[0];
+  if (!ACCOUNT_UUID_RE2.test(accountId)) return null;
+  return { accountId, relativePath: `${rootName}/${segs.join("/")}` };
+}
+async function startFileWatcher(opts = {}) {
+  const dataRoot = opts.dataRoot ?? DATA_ROOT;
+  const coalesceMs = opts.coalesceMs ?? DEFAULT_COALESCE_MS;
+  const indexFn = opts.index ?? indexFile;
+  const dropFn = opts.drop ?? dropFileIndex;
+  for (const r of ROOTS) {
+    try {
+      await fsp2.mkdir(resolve21(dataRoot, r), { recursive: true });
+    } catch (err) {
+      console.error(
+        `[file-watcher] start-failed root="${r}" err="${err.message}" \u2014 index will be maintained by the 5-min reconcile backstop only`
+      );
+      return { stop: async () => {
+      } };
+    }
+  }
+  const controller = new AbortController();
+  const timers = /* @__PURE__ */ new Map();
+  function schedule(relativePath, accountId) {
+    const existing = timers.get(relativePath);
+    if (existing) clearTimeout(existing);
+    const t = setTimeout(() => {
+      timers.delete(relativePath);
+      void runHook(relativePath, accountId);
+    }, coalesceMs);
+    timers.set(relativePath, t);
+  }
+  async function runHook(relativePath, accountId) {
+    const absolute = resolve21(dataRoot, relativePath);
+    let exists = false;
+    try {
+      const st = await fsp2.stat(absolute);
+      exists = st.isFile();
+    } catch (err) {
+      const code = err.code;
+      if (code !== "ENOENT") {
+        console.error(`[file-watcher] stat-error path="${relativePath}" err="${err.message}"`);
+      }
+    }
+    try {
+      if (exists) {
+        await indexFn(accountId, relativePath);
+      } else {
+        await dropFn(accountId, relativePath);
+      }
+    } catch (err) {
+      console.error(`[file-watcher] hook-failed path="${relativePath}" err="${err.message}"`);
+    } finally {
+      opts.onSettled?.(relativePath);
+    }
+  }
+  async function watchRoot(rootName) {
+    const absRoot = resolve21(dataRoot, rootName);
+    try {
+      const iter = fsp2.watch(absRoot, { recursive: true, signal: controller.signal });
+      for await (const event of iter) {
+        const routed = _routeEvent(rootName, event.filename);
+        if (!routed) continue;
+        schedule(routed.relativePath, routed.accountId);
+      }
+    } catch (err) {
+      const code = err.code;
+      const name = err.name;
+      if (code === "ABORT_ERR" || name === "AbortError") return;
+      console.error(`[file-watcher] loop-error root="${rootName}" err="${err.message}"`);
+    }
+  }
+  for (const r of ROOTS) void watchRoot(r);
+  const sigHandler = () => {
+    void stop();
+  };
+  process.once("SIGTERM", sigHandler);
+  process.once("SIGINT", sigHandler);
+  let stopped = false;
+  async function stop() {
+    if (stopped) return;
+    stopped = true;
+    process.off("SIGTERM", sigHandler);
+    process.off("SIGINT", sigHandler);
+    controller.abort();
+    for (const t of timers.values()) clearTimeout(t);
+    timers.clear();
+  }
+  console.error(
+    `[file-watcher] started roots=${ROOTS.join(",")} dataRoot="${dataRoot}" coalesce-ms=${coalesceMs}`
+  );
+  return { stop };
+}
+
 // app/lib/whatsapp/inbound/claude-bridge.ts
 var TAG27 = "[whatsapp-adaptor]";
 function whatsappTurnTimeoutMs() {
@@ -13863,8 +13882,8 @@ function broadcastAdminShutdown(reason) {
 
 // ../lib/entitlement/src/index.ts
 import { createPublicKey, createHash as createHash4, verify as cryptoVerify } from "crypto";
-import { existsSync as existsSync22, readFileSync as readFileSync19, statSync as statSync9 } from "fs";
-import { resolve as resolve23 } from "path";
+import { existsSync as existsSync20, readFileSync as readFileSync19, statSync as statSync8 } from "fs";
+import { resolve as resolve22 } from "path";
 
 // ../lib/entitlement/src/canonicalize.ts
 function canonicalize(value) {
@@ -13899,7 +13918,7 @@ var PUBKEY_SHA256 = "8eee6bcb33545fd13b16d3199a5735ca5db5062834c7b49dfe4f23801d9
 var GRACE_DAYS = 7;
 var GRACE_MS = GRACE_DAYS * 24 * 60 * 60 * 1e3;
 function pubkeyPath(brand) {
-  return resolve23(brand.platformRoot, "lib", "entitlement", "rubytech-pubkey.pem");
+  return resolve22(brand.platformRoot, "lib", "entitlement", "rubytech-pubkey.pem");
 }
 var memo = null;
 function memoKey(mtimeMs, account) {
@@ -13911,12 +13930,12 @@ function resolveEntitlement(brand, account) {
   if (brand.commercialMode !== true) {
     return logResolved(implicitTrust(account), null);
   }
-  const entitlementPath = resolve23(brand.configDir, "entitlement.json");
-  if (!existsSync22(entitlementPath)) {
+  const entitlementPath = resolve22(brand.configDir, "entitlement.json");
+  if (!existsSync20(entitlementPath)) {
     return logResolved(anonymousFallback("missing"), { reason: "missing" });
   }
-  const stat7 = statSync9(entitlementPath);
-  const key = memoKey(stat7.mtimeMs, account);
+  const stat8 = statSync8(entitlementPath);
+  const key = memoKey(stat8.mtimeMs, account);
   if (memo && memo.key === key) {
     return memo.result;
   }
@@ -14104,10 +14123,10 @@ function clientFrom(c) {
 var PLATFORM_ROOT9 = process.env.MAXY_PLATFORM_ROOT || "";
 var BRAND_JSON_PATH = PLATFORM_ROOT9 ? join15(PLATFORM_ROOT9, "config", "brand.json") : "";
 var BRAND = { productName: "Maxy", hostname: "maxy", configDir: ".maxy", marketingUrl: "https://getmaxy.com" };
-if (BRAND_JSON_PATH && !existsSync23(BRAND_JSON_PATH)) {
+if (BRAND_JSON_PATH && !existsSync21(BRAND_JSON_PATH)) {
   console.error(`[brand] WARNING: brand.json not found at ${BRAND_JSON_PATH} \u2014 using Maxy defaults`);
 }
-if (BRAND_JSON_PATH && existsSync23(BRAND_JSON_PATH)) {
+if (BRAND_JSON_PATH && existsSync21(BRAND_JSON_PATH)) {
   try {
     const parsed = JSON.parse(readFileSync20(BRAND_JSON_PATH, "utf-8"));
     BRAND = { ...BRAND, ...parsed };
@@ -14131,7 +14150,7 @@ var brandLoginOpts = {
 var ALIAS_DOMAINS_PATH = join15(homedir2(), BRAND.configDir, "alias-domains.json");
 function loadAliasDomains() {
   try {
-    if (!existsSync23(ALIAS_DOMAINS_PATH)) return null;
+    if (!existsSync21(ALIAS_DOMAINS_PATH)) return null;
     const parsed = JSON.parse(readFileSync20(ALIAS_DOMAINS_PATH, "utf-8"));
     if (!Array.isArray(parsed)) {
       console.error("[alias-domains] malformed alias-domains.json \u2014 expected array");
@@ -14496,13 +14515,13 @@ app40.get("/agent-assets/:slug/:filename", (c) => {
     console.error(`[agent-assets] no-account slug=${slug} file=${filename}`);
     return c.text("Not found", 404);
   }
-  const filePath = resolve24(account.accountDir, "agents", slug, "assets", filename);
-  const expectedDir = resolve24(account.accountDir, "agents", slug, "assets");
+  const filePath = resolve23(account.accountDir, "agents", slug, "assets", filename);
+  const expectedDir = resolve23(account.accountDir, "agents", slug, "assets");
   if (!filePath.startsWith(expectedDir + "/")) {
     console.error(`[agent-assets] path-traversal-rejected slug=${slug} file=${filename}`);
     return c.text("Forbidden", 403);
   }
-  if (!existsSync23(filePath)) {
+  if (!existsSync21(filePath)) {
     console.error(`[agent-assets] serve slug=${slug} file=${filename} status=404`);
     return c.text("Not found", 404);
   }
@@ -14526,13 +14545,13 @@ app40.get("/generated/:filename", (c) => {
     console.error(`[generated] serve file=${filename} status=404`);
     return c.text("Not found", 404);
   }
-  const filePath = resolve24(account.accountDir, "generated", filename);
-  const expectedDir = resolve24(account.accountDir, "generated");
+  const filePath = resolve23(account.accountDir, "generated", filename);
+  const expectedDir = resolve23(account.accountDir, "generated");
   if (!filePath.startsWith(expectedDir + "/")) {
     console.error(`[generated] serve file=${filename} status=403`);
     return c.text("Forbidden", 403);
   }
-  if (!existsSync23(filePath)) {
+  if (!existsSync21(filePath)) {
     console.error(`[generated] serve file=${filename} status=404`);
     return c.text("Not found", 404);
   }
@@ -14552,7 +14571,7 @@ app40.route("/v", visitor_consent_default);
 var htmlCache = /* @__PURE__ */ new Map();
 var brandLogoPath = "/brand/maxy-monochrome.png";
 var brandIconPath = "/brand/maxy-monochrome.png";
-if (BRAND_JSON_PATH && existsSync23(BRAND_JSON_PATH)) {
+if (BRAND_JSON_PATH && existsSync21(BRAND_JSON_PATH)) {
   try {
     const fullBrand = JSON.parse(readFileSync20(BRAND_JSON_PATH, "utf-8"));
     if (fullBrand.assets?.logo) brandLogoPath = `/brand/${fullBrand.assets.logo}`;
@@ -14572,7 +14591,7 @@ function readInstalledVersion() {
   try {
     if (!PLATFORM_ROOT9) return "unknown";
     const versionFile = join15(PLATFORM_ROOT9, "config", `.${BRAND.hostname}-version`);
-    if (!existsSync23(versionFile)) return "unknown";
+    if (!existsSync21(versionFile)) return "unknown";
     const content = readFileSync20(versionFile, "utf-8").trim();
     return content || "unknown";
   } catch {
@@ -14614,7 +14633,7 @@ var clientErrorReporterScript = `<script>
 function cachedHtml(file) {
   let html = htmlCache.get(file);
   if (!html) {
-    html = readFileSync20(resolve24(process.cwd(), "public", file), "utf-8");
+    html = readFileSync20(resolve23(process.cwd(), "public", file), "utf-8");
     const productNameEsc = escapeHtml(BRAND.productName);
     html = html.replace(/<title>([^<]*)<\/title>/, (_match, inner) => `<title>${escapeHtml(inner).replace(/Maxy/g, productNameEsc)}</title>`);
     html = html.replace('href="/favicon.ico"', `href="${escapeHtml(brandFaviconPath)}"`);
@@ -14633,12 +14652,12 @@ function loadBrandingCache(agentSlug) {
   const configDir2 = join15(homedir2(), BRAND.configDir);
   try {
     const accountJsonPath = join15(configDir2, "account.json");
-    if (!existsSync23(accountJsonPath)) return null;
+    if (!existsSync21(accountJsonPath)) return null;
     const account = JSON.parse(readFileSync20(accountJsonPath, "utf-8"));
     const accountId = account.accountId;
     if (!accountId) return null;
     const cachePath = join15(configDir2, "branding-cache", accountId, `${agentSlug}.json`);
-    if (!existsSync23(cachePath)) return null;
+    if (!existsSync21(cachePath)) return null;
     return JSON.parse(readFileSync20(cachePath, "utf-8"));
   } catch {
     return null;
@@ -14648,7 +14667,7 @@ function resolveDefaultSlug() {
   try {
     const configDir2 = join15(homedir2(), BRAND.configDir);
     const accountJsonPath = join15(configDir2, "account.json");
-    if (!existsSync23(accountJsonPath)) return null;
+    if (!existsSync21(accountJsonPath)) return null;
     const account = JSON.parse(readFileSync20(accountJsonPath, "utf-8"));
     return account.defaultAgent || null;
   } catch {
@@ -14722,7 +14741,7 @@ app40.use("/vnc-popout.html", logViewerFetch);
 app40.get("/vnc-popout.html", (c) => {
   let html = htmlCache.get("vnc-popout.html");
   if (!html) {
-    html = readFileSync20(resolve24(process.cwd(), "public", "vnc-popout.html"), "utf-8");
+    html = readFileSync20(resolve23(process.cwd(), "public", "vnc-popout.html"), "utf-8");
     const name = escapeHtml(BRAND.productName);
     html = html.replace("<title>Browser \u2014 Maxy</title>", `<title>${name}</title>`);
     html = html.replace("</head>", `  ${brandScript}
@@ -14847,7 +14866,7 @@ try {
 }
 (async () => {
   try {
-    if (!existsSync23(USERS_FILE)) return;
+    if (!existsSync21(USERS_FILE)) return;
     const usersRaw = readFileSync20(USERS_FILE, "utf-8").trim();
     if (!usersRaw) return;
     const users = JSON.parse(usersRaw);
@@ -14864,6 +14883,9 @@ try {
   }
 })();
 startGraphHealthTimer();
+void startFileWatcher().catch((err) => {
+  console.error(`[file-watcher] start-failed err="${err instanceof Error ? err.message : String(err)}"`);
+});
 try {
   const accounts = enumerateValidAccountIds(getAccountsDirFromEnv());
   console.error(`[graph-health] account-enumeration accounts=${accounts.length}`);
@@ -14882,7 +14904,7 @@ try {
 } catch (err) {
   console.error(`[graph-health] account-enumeration unavailable reason=${err instanceof Error ? err.message : String(err)}`);
 }
-var configDirForWhatsApp = basename5(MAXY_DIR) || ".maxy";
+var configDirForWhatsApp = basename6(MAXY_DIR) || ".maxy";
 var bootAccount = resolveAccount();
 var bootAccountConfig = bootAccount?.config;
 var bootPublicAgent = bootAccount ? resolvePublicAgent(bootAccount.accountDir, { accountId: bootAccount.accountId })?.slug ?? null : null;
@@ -14940,7 +14962,7 @@ if (bootAccountConfig?.whatsapp) {
 }
 init({
   configDir: configDirForWhatsApp,
-  platformRoot: resolve24(process.env.MAXY_PLATFORM_ROOT ?? join15(__dirname, "..")),
+  platformRoot: resolve23(process.env.MAXY_PLATFORM_ROOT ?? join15(__dirname, "..")),
   accountConfig: bootAccountConfig,
   onMessage: async (msg) => {
     if (process.env.WHATSAPP_PTY_BRIDGE_ENABLED === "true" && msg.text && !msg.isOwnerMirror) {