@rubytech/create-maxy-code 0.1.39 → 0.1.41

package/payload/server/server.js

@@ -60,7 +60,7 @@ import {
   vncLog,
   waitForExit,
   walkPremiumBundles
-} from "./chunk-3G6JMV7N.js";
+} from "./chunk-MEGIQYUD.js";
 import {
   CLOUDFLARE_TASK_DIAGNOSTICS,
   appendCloudflareSteps,
@@ -69,7 +69,7 @@ import {
   openCloudflareTask,
   readTunnelState,
   resolveUnitGoneVerdict
-} from "./chunk-QC5LHYPH.js";
+} from "./chunk-XJVJ2B2Q.js";
 import {
   GREETING_DIRECTIVE,
   HAIKU_MODEL,
@@ -93,7 +93,7 @@ import {
   verifyAndGetConversationUpdatedAt,
   verifyConversationOwnership,
   writeAdminUserAndPerson
-} from "./chunk-NNHHGQJL.js";
+} from "./chunk-4P2MPERV.js";
 import {
   __commonJS,
   __toESM
@@ -596,14 +596,14 @@ var serveStatic = (options = { root: "" }) => {
 
 // server/index.ts
 import { readFileSync as readFileSync20, existsSync as existsSync22, watchFile } from "fs";
-import { resolve as resolve23, join as join12, basename as basename5 } from "path";
+import { resolve as resolve23, join as join13, basename as basename5 } from "path";
 import { homedir as homedir4 } from "os";
 
 // app/lib/agent-slug-pattern.ts
 var AGENT_SLUG_PATTERN = /^\/([a-z][a-z0-9-]{2,49})$/;
 
 // server/routes/health.ts
-import { existsSync as existsSync3, readFileSync as readFileSync5 } from "fs";
+import { existsSync as existsSync2, readFileSync as readFileSync4 } from "fs";
 import { createConnection as createConnection2 } from "net";
 
 // app/lib/claude-auth.ts
@@ -863,617 +863,254 @@ var WhatsAppConfigSchema = z.object({
   });
 });
 
-// app/lib/whatsapp/config-persist.ts
-import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync2 } from "fs";
-import { resolve, join as join2 } from "path";
-var TAG = "[whatsapp:config]";
-function configPath(accountDir) {
-  return resolve(accountDir, "account.json");
+// app/lib/whatsapp/auth-store.ts
+import fsSync from "fs";
+import fs from "fs/promises";
+import path from "path";
+import os from "os";
+var TAG = "[whatsapp:auth]";
+function resolveAuthDir(configDir2, accountId) {
+  return path.join(os.homedir(), configDir2, "credentials", "whatsapp", accountId);
 }
-function readConfig(accountDir) {
-  const path2 = configPath(accountDir);
-  if (!existsSync2(path2)) throw new Error(`account.json not found at ${path2}`);
-  return JSON.parse(readFileSync2(path2, "utf-8"));
+function resolveCredsPath(authDir) {
+  return path.join(authDir, "creds.json");
 }
-function writeConfig(accountDir, config) {
-  const path2 = configPath(accountDir);
-  writeFileSync2(path2, JSON.stringify(config, null, 2) + "\n", "utf-8");
+function resolveCredsBackupPath(authDir) {
+  return path.join(authDir, "creds.json.bak");
 }
-function reloadManagerConfig(accountDir) {
+function hasCredsSync(authDir) {
   try {
-    const config = readConfig(accountDir);
-    reloadConfig(config);
-    console.error(`${TAG} reloaded manager config`);
-  } catch (err) {
-    console.error(`${TAG} manager config reload failed: ${String(err)}`);
+    const stats = fsSync.statSync(resolveCredsPath(authDir));
+    return stats.isFile() && stats.size > 1;
+  } catch {
+    return false;
   }
 }
-var E164_PATTERN = /^\+\d{7,15}$/;
-function migrateAdminPhones(wa) {
-  if (wa.adminPhones !== void 0) return 0;
-  if (!Array.isArray(wa.allowFrom)) return 0;
-  const allowFrom = wa.allowFrom;
-  const phones = [];
-  const remaining = [];
-  for (const entry of allowFrom) {
-    if (E164_PATTERN.test(entry)) {
-      phones.push(entry);
-    } else {
-      remaining.push(entry);
-    }
+async function authExists(authDir) {
+  const credsPath = resolveCredsPath(authDir);
+  try {
+    await fs.access(authDir);
+  } catch {
+    return false;
   }
-  if (phones.length === 0) return 0;
-  wa.adminPhones = phones;
-  wa.allowFrom = remaining;
-  console.error(`${TAG} migrated ${phones.length} phone(s) from allowFrom to adminPhones`);
-  return phones.length;
-}
-function persistAfterPairing(accountDir, accountId, selfPhone) {
   try {
-    const config = readConfig(accountDir);
-    if (!config.whatsapp || typeof config.whatsapp !== "object") {
-      config.whatsapp = {};
-    }
-    const wa = config.whatsapp;
-    if (!wa.accounts || typeof wa.accounts !== "object") {
-      wa.accounts = {};
-    }
-    const accounts = wa.accounts;
-    if (!accounts[accountId] || typeof accounts[accountId] !== "object") {
-      accounts[accountId] = { name: "Main" };
-    }
-    if (selfPhone) {
-      const normalized = selfPhone.startsWith("+") ? selfPhone : `+${selfPhone}`;
-      if (!Array.isArray(wa.adminPhones)) {
-        wa.adminPhones = [];
-      }
-      const adminPhones = wa.adminPhones;
-      if (!adminPhones.includes(normalized)) {
-        adminPhones.push(normalized);
-        console.error(`${TAG} added selfPhone=${normalized} to adminPhones`);
-      }
-    } else {
-      console.error(`${TAG} skipping adminPhones \u2014 selfPhone is null account=${accountId}`);
-    }
-    const parsed = WhatsAppConfigSchema.safeParse(wa);
-    if (!parsed.success) {
-      const msg = parsed.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ");
-      console.error(`${TAG} validation failed after pairing: ${msg}`);
-      return { ok: false, error: `Validation failed: ${msg}` };
-    }
-    config.whatsapp = parsed.data;
-    writeConfig(accountDir, config);
-    console.error(`${TAG} persisted after pairing account=${accountId} phone=${selfPhone ?? "null"}`);
-    reloadManagerConfig(accountDir);
-    return { ok: true };
+    const stats = await fs.stat(credsPath);
+    if (!stats.isFile() || stats.size <= 1) return false;
+    const raw = await fs.readFile(credsPath, "utf-8");
+    JSON.parse(raw);
+    return true;
   } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    console.error(`${TAG} persist failed account=${accountId}: ${msg}`);
-    return { ok: false, error: msg };
+    console.warn(`${TAG} credential validation failed path=${credsPath}: ${String(err)}`);
+    return false;
   }
 }
-function addAdminPhone(accountDir, phone) {
-  const normalized = phone.trim();
-  if (!E164_PATTERN.test(normalized)) {
-    return { ok: false, error: `Invalid phone format "${normalized}". Expected E.164 (e.g. +441234567890).` };
+function readCredsJsonRaw(filePath) {
+  try {
+    if (!fsSync.existsSync(filePath)) return null;
+    const stats = fsSync.statSync(filePath);
+    if (!stats.isFile() || stats.size <= 1) return null;
+    return fsSync.readFileSync(filePath, "utf-8");
+  } catch {
+    return null;
   }
+}
+function maybeRestoreCredsFromBackup(authDir) {
   try {
-    const config = readConfig(accountDir);
-    if (!config.whatsapp || typeof config.whatsapp !== "object") {
-      config.whatsapp = {};
-    }
-    const wa = config.whatsapp;
-    migrateAdminPhones(wa);
-    if (!Array.isArray(wa.adminPhones)) {
-      wa.adminPhones = [];
-    }
-    const adminPhones = wa.adminPhones;
-    if (adminPhones.includes(normalized)) {
-      return { ok: true, message: `Phone ${normalized} is already in the admin list.` };
-    }
-    adminPhones.push(normalized);
-    const parsed = WhatsAppConfigSchema.safeParse(wa);
-    if (!parsed.success) {
-      const msg = parsed.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ");
-      return { ok: false, error: `Validation failed: ${msg}` };
+    const credsPath = resolveCredsPath(authDir);
+    const backupPath = resolveCredsBackupPath(authDir);
+    const raw = readCredsJsonRaw(credsPath);
+    if (raw) {
+      JSON.parse(raw);
+      return;
     }
-    config.whatsapp = parsed.data;
-    writeConfig(accountDir, config);
-    console.error(`${TAG} added admin phone=${normalized}`);
-    reloadManagerConfig(accountDir);
-    return { ok: true, message: `Added ${normalized} as admin phone. Messages from this number will route to the admin agent.` };
+    const backupRaw = readCredsJsonRaw(backupPath);
+    if (!backupRaw) return;
+    JSON.parse(backupRaw);
+    fsSync.copyFileSync(backupPath, credsPath);
+    console.error(`${TAG} restored corrupted creds.json from backup in ${authDir}`);
   } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    console.error(`${TAG} addAdminPhone failed: ${msg}`);
-    return { ok: false, error: msg };
+    console.warn(`${TAG} credential restore failed authDir=${authDir}: ${String(err)}`);
   }
 }
-function removeAdminPhone(accountDir, phone) {
-  const normalized = phone.trim();
+function readSelfId(authDir) {
   try {
-    const config = readConfig(accountDir);
-    if (!config.whatsapp || typeof config.whatsapp !== "object") {
-      return { ok: true, message: `No WhatsApp config exists \u2014 nothing to remove.` };
-    }
-    const wa = config.whatsapp;
-    migrateAdminPhones(wa);
-    if (!Array.isArray(wa.adminPhones)) {
-      return { ok: true, message: `No admin phones configured \u2014 nothing to remove.` };
-    }
-    const adminPhones = wa.adminPhones;
-    const idx = adminPhones.indexOf(normalized);
-    if (idx === -1) {
-      return { ok: true, message: `Phone ${normalized} is not in the admin list.` };
+    const credsPath = resolveCredsPath(authDir);
+    if (!fsSync.existsSync(credsPath)) return { e164: null, jid: null, lid: null };
+    const raw = fsSync.readFileSync(credsPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    const jid = parsed?.me?.id ?? null;
+    const lidRaw = parsed?.me?.lid ?? null;
+    let e164 = null;
+    if (jid) {
+      const match = jid.match(/^(\d+)(?::\d+)?@s\.whatsapp\.net$/i);
+      if (match) e164 = match[1];
     }
-    adminPhones.splice(idx, 1);
-    const parsed = WhatsAppConfigSchema.safeParse(wa);
-    if (!parsed.success) {
-      const msg = parsed.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ");
-      return { ok: false, error: `Validation failed: ${msg}` };
+    let lid = null;
+    if (lidRaw) {
+      const lidMatch = lidRaw.match(/^(\d+)(?::\d+)?@lid$/i);
+      if (lidMatch) lid = `${lidMatch[1]}@lid`;
     }
-    config.whatsapp = parsed.data;
-    writeConfig(accountDir, config);
-    console.error(`${TAG} removed admin phone=${normalized}`);
-    reloadManagerConfig(accountDir);
-    return { ok: true, message: `Removed ${normalized} from admin phones. Messages from this number will now route to the public agent.` };
+    return { e164, jid, lid };
   } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    console.error(`${TAG} removeAdminPhone failed: ${msg}`);
-    return { ok: false, error: msg };
+    console.warn(`${TAG} readSelfId failed authDir=${authDir}: ${String(err)}`);
+    return { e164: null, jid: null, lid: null };
   }
 }
-function readAdminPhones(accountDir) {
+async function clearAuth(authDir) {
   try {
-    const config = readConfig(accountDir);
-    const wa = config.whatsapp;
-    if (!wa) return [];
-    const migrated = migrateAdminPhones(wa);
-    if (migrated > 0) {
-      const parsed = WhatsAppConfigSchema.safeParse(wa);
-      if (parsed.success) {
-        config.whatsapp = parsed.data;
-        writeConfig(accountDir, config);
-        reloadManagerConfig(accountDir);
-      }
-    }
-    if (!Array.isArray(wa.adminPhones)) return [];
-    return wa.adminPhones.filter((p) => typeof p === "string");
+    await fs.access(authDir);
   } catch {
-    return [];
+    console.error(`${TAG} no auth dir found at ${authDir}`);
+    return false;
   }
+  await fs.rm(authDir, { recursive: true, force: true });
+  console.error(`${TAG} cleared credentials at ${authDir}`);
+  return true;
 }
-function setPublicAgent(accountDir, slug) {
-  const trimmed = slug.trim();
-  if (!trimmed) {
-    return { ok: false, error: "Agent slug cannot be empty." };
+function listCredentialAccountIds(configDir2) {
+  const credsRoot = path.join(os.homedir(), configDir2, "credentials", "whatsapp");
+  try {
+    const entries = fsSync.readdirSync(credsRoot, { withFileTypes: true });
+    return entries.filter((e) => e.isDirectory() && hasCredsSync(path.join(credsRoot, e.name))).map((e) => e.name);
+  } catch {
+    return [];
   }
-  const agentConfigPath = join2(accountDir, "agents", trimmed, "config.json");
-  if (!existsSync2(agentConfigPath)) {
-    return { ok: false, error: `Agent "${trimmed}" not found \u2014 no config.json at ${agentConfigPath}. Check the agent slug and try again.` };
+}
+
+// app/lib/whatsapp/session.ts
+import { randomUUID } from "crypto";
+import fsSync2 from "fs";
+import fs2 from "fs/promises";
+import { inspect } from "util";
+import {
+  Browsers,
+  DisconnectReason,
+  fetchLatestBaileysVersion,
+  makeCacheableSignalKeyStore,
+  makeWASocket,
+  useMultiFileAuthState
+} from "@whiskeysockets/baileys";
+import { createRequire } from "module";
+var TAG2 = "[whatsapp:session]";
+var baileysPkgVersion = (() => {
+  try {
+    const req = createRequire(import.meta.url);
+    return req("@whiskeysockets/baileys/package.json").version ?? "unknown";
+  } catch {
+    return "unknown";
   }
+})();
+console.error(`${TAG2} baileys package loaded version=${baileysPkgVersion}`);
+var __BAILEYS_TAG = "[whatsapp:baileys]";
+var INSPECT_OPTS = {
+  depth: null,
+  breakLength: Infinity,
+  compact: true,
+  maxArrayLength: 100,
+  maxStringLength: 1e4
+};
+function serializeArg(arg) {
+  if (typeof arg === "string") return arg;
   try {
-    const config = readConfig(accountDir);
-    if (!config.whatsapp || typeof config.whatsapp !== "object") {
-      config.whatsapp = {};
-    }
-    const wa = config.whatsapp;
-    wa.publicAgent = trimmed;
-    const parsed = WhatsAppConfigSchema.safeParse(wa);
-    if (!parsed.success) {
-      const msg = parsed.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ");
-      return { ok: false, error: `Validation failed: ${msg}` };
-    }
-    config.whatsapp = parsed.data;
-    writeConfig(accountDir, config);
-    console.error(`${TAG} publicAgent set to ${trimmed}`);
-    reloadManagerConfig(accountDir);
-    return { ok: true, message: `Public agent set to "${trimmed}". WhatsApp messages from non-admin phones will be handled by this agent.` };
+    return inspect(arg, INSPECT_OPTS);
   } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    console.error(`${TAG} setPublicAgent failed: ${msg}`);
-    return { ok: false, error: msg };
+    return `[inspect-failed: ${String(err)}]`;
   }
 }
-function resolvePublicAgent(accountDir, opts) {
-  try {
-    const config = readConfig(accountDir);
-    const wa = config.whatsapp;
-    if (!wa) return null;
-    if (opts.groupJid) {
-      const accounts2 = wa.accounts;
-      const account2 = accounts2?.[opts.accountId];
-      const groups = account2?.groups;
-      const group = groups?.[opts.groupJid];
-      const groupSlug = group?.publicAgent;
-      if (typeof groupSlug === "string" && groupSlug.trim()) {
-        return { slug: groupSlug.trim(), source: "group" };
-      }
-    }
-    const accounts = wa.accounts;
-    const account = accounts?.[opts.accountId];
-    const accountSlug = account?.publicAgent;
-    if (typeof accountSlug === "string" && accountSlug.trim()) {
-      return { slug: accountSlug.trim(), source: "account" };
-    }
-    const topSlug = wa.publicAgent;
-    if (typeof topSlug === "string" && topSlug.trim()) {
-      return { slug: topSlug.trim(), source: "top-level" };
-    }
-    return null;
-  } catch {
-    return null;
-  }
-}
-function setGroupPublicAgent(accountDir, accountId, groupJid, slug) {
-  const trimmedSlug = slug.trim();
-  const trimmedGroup = groupJid.trim();
-  const trimmedAccount = accountId.trim();
-  if (!trimmedSlug) return { ok: false, error: "Agent slug cannot be empty." };
-  if (!trimmedGroup) return { ok: false, error: "Group JID cannot be empty." };
-  if (!trimmedAccount) return { ok: false, error: "Account ID cannot be empty." };
-  const agentConfigPath = join2(accountDir, "agents", trimmedSlug, "config.json");
-  if (!existsSync2(agentConfigPath)) {
-    return { ok: false, error: `Agent "${trimmedSlug}" not found \u2014 no config.json at ${agentConfigPath}. Check the agent slug and try again.` };
-  }
-  try {
-    const config = readConfig(accountDir);
-    if (!config.whatsapp || typeof config.whatsapp !== "object") config.whatsapp = {};
-    const wa = config.whatsapp;
-    if (!wa.accounts || typeof wa.accounts !== "object") wa.accounts = {};
-    const accounts = wa.accounts;
-    if (!accounts[trimmedAccount] || typeof accounts[trimmedAccount] !== "object") accounts[trimmedAccount] = {};
-    const account = accounts[trimmedAccount];
-    if (!account.groups || typeof account.groups !== "object") account.groups = {};
-    const groups = account.groups;
-    const existing = groups[trimmedGroup] && typeof groups[trimmedGroup] === "object" ? groups[trimmedGroup] : {};
-    groups[trimmedGroup] = { ...existing, publicAgent: trimmedSlug };
-    const parsed = WhatsAppConfigSchema.safeParse(wa);
-    if (!parsed.success) {
-      const msg = parsed.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ");
-      return { ok: false, error: `Validation failed: ${msg}` };
-    }
-    config.whatsapp = parsed.data;
-    writeConfig(accountDir, config);
-    console.error(`${TAG} setGroupPublicAgent account=${trimmedAccount} groupJid=${trimmedGroup} slug=${trimmedSlug}`);
-    reloadManagerConfig(accountDir);
-    return { ok: true, message: `Per-group public agent set to "${trimmedSlug}" for group ${trimmedGroup}.` };
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    console.error(`${TAG} setGroupPublicAgent failed: ${msg}`);
-    return { ok: false, error: msg };
-  }
-}
-function unsetGroupPublicAgent(accountDir, accountId, groupJid) {
-  const trimmedGroup = groupJid.trim();
-  const trimmedAccount = accountId.trim();
-  if (!trimmedGroup) return { ok: false, error: "Group JID cannot be empty." };
-  if (!trimmedAccount) return { ok: false, error: "Account ID cannot be empty." };
-  try {
-    const config = readConfig(accountDir);
-    const wa = config.whatsapp ?? {};
-    const accounts = wa.accounts;
-    const account = accounts?.[trimmedAccount];
-    const groups = account?.groups;
-    const group = groups?.[trimmedGroup];
-    if (!group || typeof group.publicAgent !== "string") {
-      return { ok: true, message: `No per-group publicAgent override for group ${trimmedGroup}; nothing to remove.` };
-    }
-    delete group.publicAgent;
-    const parsed = WhatsAppConfigSchema.safeParse(wa);
-    if (!parsed.success) {
-      const msg = parsed.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ");
-      return { ok: false, error: `Validation failed: ${msg}` };
-    }
-    config.whatsapp = parsed.data;
-    writeConfig(accountDir, config);
-    console.error(`${TAG} unsetGroupPublicAgent account=${trimmedAccount} groupJid=${trimmedGroup}`);
-    reloadManagerConfig(accountDir);
-    return { ok: true, message: `Per-group public agent override removed for group ${trimmedGroup}.` };
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    console.error(`${TAG} unsetGroupPublicAgent failed: ${msg}`);
-    return { ok: false, error: msg };
-  }
-}
-function updateConfig(accountDir, fields) {
-  const fieldNames = Object.keys(fields);
-  if (fieldNames.length === 0) {
-    return { ok: false, error: "No fields provided to update." };
-  }
-  try {
-    const config = readConfig(accountDir);
-    if (!config.whatsapp || typeof config.whatsapp !== "object") {
-      config.whatsapp = {};
-    }
-    const wa = config.whatsapp;
-    migrateAdminPhones(wa);
-    for (const [key, value] of Object.entries(fields)) {
-      wa[key] = value;
-    }
-    const parsed = WhatsAppConfigSchema.safeParse(wa);
-    if (!parsed.success) {
-      const msg = parsed.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ");
-      console.error(`${TAG} update validation failed: ${msg}`);
-      return { ok: false, error: `Validation failed: ${msg}` };
-    }
-    config.whatsapp = parsed.data;
-    writeConfig(accountDir, config);
-    console.error(`${TAG} updated fields=[${fieldNames.join(",")}]`);
-    reloadManagerConfig(accountDir);
-    return { ok: true, message: `Updated WhatsApp config: ${fieldNames.join(", ")}.` };
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    console.error(`${TAG} updateConfig failed: ${msg}`);
-    return { ok: false, error: msg };
+function bindingsToPrefix(bindings) {
+  const parts = [];
+  for (const [key, value] of Object.entries(bindings)) {
+    const rendered = typeof value === "string" || typeof value === "number" || typeof value === "boolean" ? String(value) : serializeArg(value);
+    parts.push(`${key}=${rendered}`);
   }
+  return parts.join(" ");
 }
-function getConfig(accountDir) {
-  try {
-    const config = readConfig(accountDir);
-    const wa = config.whatsapp;
-    if (!wa) return null;
-    const migrated = migrateAdminPhones(wa);
-    const parsed = WhatsAppConfigSchema.safeParse(wa);
-    if (!parsed.success) return wa;
-    if (migrated > 0) {
-      config.whatsapp = parsed.data;
-      writeConfig(accountDir, config);
-      reloadManagerConfig(accountDir);
+function createBaileysLogger(bindings = {}) {
+  const prefix = Object.keys(bindings).length > 0 ? bindingsToPrefix(bindings) : "";
+  const emit = (level, args) => {
+    const serialized = args.map(serializeArg).join(" ");
+    if (prefix) {
+      console.error(__BAILEYS_TAG, level, prefix, serialized);
+    } else {
+      console.error(__BAILEYS_TAG, level, serialized);
     }
-    return parsed.data;
-  } catch {
-    return null;
-  }
-}
-
-// app/lib/whatsapp/auth-store.ts
-import fsSync from "fs";
-import fs from "fs/promises";
-import path from "path";
-import os from "os";
-var TAG2 = "[whatsapp:auth]";
-function resolveAuthDir(configDir2, accountId) {
-  return path.join(os.homedir(), configDir2, "credentials", "whatsapp", accountId);
-}
-function resolveCredsPath(authDir) {
-  return path.join(authDir, "creds.json");
-}
-function resolveCredsBackupPath(authDir) {
-  return path.join(authDir, "creds.json.bak");
-}
-function hasCredsSync(authDir) {
-  try {
-    const stats = fsSync.statSync(resolveCredsPath(authDir));
-    return stats.isFile() && stats.size > 1;
-  } catch {
-    return false;
-  }
+  };
+  return {
+    level: "warn",
+    trace: () => {
+    },
+    debug: () => {
+    },
+    info: () => {
+    },
+    warn: (...args) => emit("WARN", args),
+    error: (...args) => emit("ERROR", args),
+    fatal: (...args) => emit("FATAL", args),
+    child: (childBindings) => createBaileysLogger({ ...bindings, ...childBindings ?? {} })
+  };
 }
-async function authExists(authDir) {
-  const credsPath = resolveCredsPath(authDir);
-  try {
-    await fs.access(authDir);
-  } catch {
-    return false;
-  }
-  try {
-    const stats = await fs.stat(credsPath);
-    if (!stats.isFile() || stats.size <= 1) return false;
-    const raw = await fs.readFile(credsPath, "utf-8");
-    JSON.parse(raw);
-    return true;
-  } catch (err) {
-    console.warn(`${TAG2} credential validation failed path=${credsPath}: ${String(err)}`);
-    return false;
+var credsSaveQueue = Promise.resolve();
+async function drainCredsSaveQueue(timeoutMs = 5e3) {
+  console.error(`${TAG2} draining credential save queue\u2026`);
+  const timer2 = new Promise(
+    (resolve24) => setTimeout(() => resolve24("timeout"), timeoutMs)
+  );
+  const result = await Promise.race([
+    credsSaveQueue.then(() => "drained"),
+    timer2
+  ]);
+  if (result === "timeout") {
+    console.error(`${TAG2} credential save queue drain timed out after ${timeoutMs}ms`);
+  } else {
+    console.error(`${TAG2} credential save queue drained`);
   }
 }
-function readCredsJsonRaw(filePath) {
+function readCredsJsonRaw2(filePath) {
   try {
-    if (!fsSync.existsSync(filePath)) return null;
-    const stats = fsSync.statSync(filePath);
+    if (!fsSync2.existsSync(filePath)) return null;
+    const stats = fsSync2.statSync(filePath);
     if (!stats.isFile() || stats.size <= 1) return null;
-    return fsSync.readFileSync(filePath, "utf-8");
+    return fsSync2.readFileSync(filePath, "utf-8");
   } catch {
     return null;
   }
 }
-function maybeRestoreCredsFromBackup(authDir) {
+async function safeSaveCreds(authDir, saveCreds) {
   try {
     const credsPath = resolveCredsPath(authDir);
     const backupPath = resolveCredsBackupPath(authDir);
-    const raw = readCredsJsonRaw(credsPath);
+    const raw = readCredsJsonRaw2(credsPath);
     if (raw) {
-      JSON.parse(raw);
-      return;
+      try {
+        JSON.parse(raw);
+        fsSync2.copyFileSync(credsPath, backupPath);
+      } catch (err) {
+        console.warn(`${TAG2} backup pre-copy failed (parse or write) authDir=${authDir}: ${String(err)}`);
+      }
     }
-    const backupRaw = readCredsJsonRaw(backupPath);
-    if (!backupRaw) return;
-    JSON.parse(backupRaw);
-    fsSync.copyFileSync(backupPath, credsPath);
-    console.error(`${TAG2} restored corrupted creds.json from backup in ${authDir}`);
   } catch (err) {
-    console.warn(`${TAG2} credential restore failed authDir=${authDir}: ${String(err)}`);
+    console.warn(`${TAG2} backup preparation failed authDir=${authDir}: ${String(err)}`);
   }
-}
-function readSelfId(authDir) {
   try {
+    await Promise.resolve(saveCreds());
     const credsPath = resolveCredsPath(authDir);
-    if (!fsSync.existsSync(credsPath)) return { e164: null, jid: null, lid: null };
-    const raw = fsSync.readFileSync(credsPath, "utf-8");
-    const parsed = JSON.parse(raw);
-    const jid = parsed?.me?.id ?? null;
-    const lidRaw = parsed?.me?.lid ?? null;
-    let e164 = null;
-    if (jid) {
-      const match = jid.match(/^(\d+)(?::\d+)?@s\.whatsapp\.net$/i);
-      if (match) e164 = match[1];
-    }
-    let lid = null;
-    if (lidRaw) {
-      const lidMatch = lidRaw.match(/^(\d+)(?::\d+)?@lid$/i);
-      if (lidMatch) lid = `${lidMatch[1]}@lid`;
+    try {
+      const stats = await fs2.stat(credsPath);
+      if (stats.size <= 1) {
+        console.error(`${TAG2} WARNING: creds file empty/truncated after save path=${credsPath} size=${stats.size}`);
+      } else {
+        console.error(`${TAG2} creds saved and verified path=${credsPath} size=${stats.size}`);
+      }
+    } catch (statErr) {
+      console.error(`${TAG2} creds NOT found on disk after save path=${credsPath}: ${String(statErr)}`);
     }
-    return { e164, jid, lid };
   } catch (err) {
-    console.warn(`${TAG2} readSelfId failed authDir=${authDir}: ${String(err)}`);
-    return { e164: null, jid: null, lid: null };
-  }
-}
-async function clearAuth(authDir) {
-  try {
-    await fs.access(authDir);
-  } catch {
-    console.error(`${TAG2} no auth dir found at ${authDir}`);
-    return false;
-  }
-  await fs.rm(authDir, { recursive: true, force: true });
-  console.error(`${TAG2} cleared credentials at ${authDir}`);
-  return true;
-}
-function listCredentialAccountIds(configDir2) {
-  const credsRoot = path.join(os.homedir(), configDir2, "credentials", "whatsapp");
-  try {
-    const entries = fsSync.readdirSync(credsRoot, { withFileTypes: true });
-    return entries.filter((e) => e.isDirectory() && hasCredsSync(path.join(credsRoot, e.name))).map((e) => e.name);
-  } catch {
-    return [];
-  }
-}
-
-// app/lib/whatsapp/session.ts
-import { randomUUID } from "crypto";
-import fsSync2 from "fs";
-import fs2 from "fs/promises";
-import { inspect } from "util";
-import {
-  Browsers,
-  DisconnectReason,
-  fetchLatestBaileysVersion,
-  makeCacheableSignalKeyStore,
-  makeWASocket,
-  useMultiFileAuthState
-} from "@whiskeysockets/baileys";
-import { createRequire } from "module";
-var TAG3 = "[whatsapp:session]";
-var baileysPkgVersion = (() => {
-  try {
-    const req = createRequire(import.meta.url);
-    return req("@whiskeysockets/baileys/package.json").version ?? "unknown";
-  } catch {
-    return "unknown";
-  }
-})();
-console.error(`${TAG3} baileys package loaded version=${baileysPkgVersion}`);
-var __BAILEYS_TAG = "[whatsapp:baileys]";
-var INSPECT_OPTS = {
-  depth: null,
-  breakLength: Infinity,
-  compact: true,
-  maxArrayLength: 100,
-  maxStringLength: 1e4
-};
-function serializeArg(arg) {
-  if (typeof arg === "string") return arg;
-  try {
-    return inspect(arg, INSPECT_OPTS);
-  } catch (err) {
-    return `[inspect-failed: ${String(err)}]`;
-  }
-}
-function bindingsToPrefix(bindings) {
-  const parts = [];
-  for (const [key, value] of Object.entries(bindings)) {
-    const rendered = typeof value === "string" || typeof value === "number" || typeof value === "boolean" ? String(value) : serializeArg(value);
-    parts.push(`${key}=${rendered}`);
-  }
-  return parts.join(" ");
-}
-function createBaileysLogger(bindings = {}) {
-  const prefix = Object.keys(bindings).length > 0 ? bindingsToPrefix(bindings) : "";
-  const emit = (level, args) => {
-    const serialized = args.map(serializeArg).join(" ");
-    if (prefix) {
-      console.error(__BAILEYS_TAG, level, prefix, serialized);
-    } else {
-      console.error(__BAILEYS_TAG, level, serialized);
-    }
-  };
-  return {
-    level: "warn",
-    trace: () => {
-    },
-    debug: () => {
-    },
-    info: () => {
-    },
-    warn: (...args) => emit("WARN", args),
-    error: (...args) => emit("ERROR", args),
-    fatal: (...args) => emit("FATAL", args),
-    child: (childBindings) => createBaileysLogger({ ...bindings, ...childBindings ?? {} })
-  };
-}
-var credsSaveQueue = Promise.resolve();
-async function drainCredsSaveQueue(timeoutMs = 5e3) {
-  console.error(`${TAG3} draining credential save queue\u2026`);
-  const timer2 = new Promise(
-    (resolve24) => setTimeout(() => resolve24("timeout"), timeoutMs)
-  );
-  const result = await Promise.race([
-    credsSaveQueue.then(() => "drained"),
-    timer2
-  ]);
-  if (result === "timeout") {
-    console.error(`${TAG3} credential save queue drain timed out after ${timeoutMs}ms`);
-  } else {
-    console.error(`${TAG3} credential save queue drained`);
-  }
-}
-function readCredsJsonRaw2(filePath) {
-  try {
-    if (!fsSync2.existsSync(filePath)) return null;
-    const stats = fsSync2.statSync(filePath);
-    if (!stats.isFile() || stats.size <= 1) return null;
-    return fsSync2.readFileSync(filePath, "utf-8");
-  } catch {
-    return null;
-  }
-}
-async function safeSaveCreds(authDir, saveCreds) {
-  try {
-    const credsPath = resolveCredsPath(authDir);
-    const backupPath = resolveCredsBackupPath(authDir);
-    const raw = readCredsJsonRaw2(credsPath);
-    if (raw) {
-      try {
-        JSON.parse(raw);
-        fsSync2.copyFileSync(credsPath, backupPath);
-      } catch (err) {
-        console.warn(`${TAG3} backup pre-copy failed (parse or write) authDir=${authDir}: ${String(err)}`);
-      }
-    }
-  } catch (err) {
-    console.warn(`${TAG3} backup preparation failed authDir=${authDir}: ${String(err)}`);
-  }
-  try {
-    await Promise.resolve(saveCreds());
-    const credsPath = resolveCredsPath(authDir);
-    try {
-      const stats = await fs2.stat(credsPath);
-      if (stats.size <= 1) {
-        console.error(`${TAG3} WARNING: creds file empty/truncated after save path=${credsPath} size=${stats.size}`);
-      } else {
-        console.error(`${TAG3} creds saved and verified path=${credsPath} size=${stats.size}`);
-      }
-    } catch (statErr) {
-      console.error(`${TAG3} creds NOT found on disk after save path=${credsPath}: ${String(statErr)}`);
-    }
-  } catch (err) {
-    console.error(`${TAG3} failed saving creds to ${authDir}: ${String(err)}`);
+    console.error(`${TAG2} failed saving creds to ${authDir}: ${String(err)}`);
   }
 }
 function enqueueSaveCreds(authDir, saveCreds) {
   credsSaveQueue = credsSaveQueue.then(() => safeSaveCreds(authDir, saveCreds)).catch((err) => {
-    console.error(`${TAG3} creds save queue error: ${String(err)}`);
+    console.error(`${TAG2} creds save queue error: ${String(err)}`);
   });
 }
 async function createWaSocket(opts) {
@@ -1483,7 +1120,7 @@ async function createWaSocket(opts) {
   const { state, saveCreds } = await useMultiFileAuthState(authDir);
   const { version } = await fetchLatestBaileysVersion();
   console.error(
-    `${TAG3} creating socket authDir=${authDir} baileysVersion=${baileysPkgVersion} waProtocolVersion=${version.join(".")}`
+    `${TAG2} creating socket authDir=${authDir} baileysVersion=${baileysPkgVersion} waProtocolVersion=${version.join(".")}`
   );
   const baileysLogger = createBaileysLogger();
   const sock = makeWASocket({
@@ -1500,7 +1137,7 @@ async function createWaSocket(opts) {
     fireInitQueries: false
   });
   sock.ev.on("creds.update", () => {
-    console.error(`${TAG3} creds.update received \u2014 saving to ${authDir}`);
+    console.error(`${TAG2} creds.update received \u2014 saving to ${authDir}`);
     enqueueSaveCreds(authDir, saveCreds);
   });
   let qrSequence = 0;
@@ -1517,7 +1154,7 @@ async function createWaSocket(opts) {
         parts.push(`disconnectReason=${formatError(update.lastDisconnect.error)}`);
       }
       if (!silent && parts.length > 0) {
-        console.error(`${TAG3} connection.update ${parts.join(" ")}`);
+        console.error(`${TAG2} connection.update ${parts.join(" ")}`);
       }
       if (update.qr && onQr) {
         onQr(update.qr);
@@ -1525,20 +1162,20 @@ async function createWaSocket(opts) {
       if (update.connection === "close") {
         const status = getStatusCode(update.lastDisconnect?.error);
         if (status === DisconnectReason.loggedOut && !silent) {
-          console.error(`${TAG3} session logged out (401) \u2014 re-link required`);
+          console.error(`${TAG2} session logged out (401) \u2014 re-link required`);
         }
       }
       if (update.connection === "open" && !silent) {
-        console.error(`${TAG3} connected`);
+        console.error(`${TAG2} connected`);
       }
       onConnectionUpdate?.(update);
     } catch (err) {
-      console.error(`${TAG3} connection.update handler error: ${String(err)}`);
+      console.error(`${TAG2} connection.update handler error: ${String(err)}`);
     }
   });
   if (sock.ws && typeof sock.ws.on === "function") {
     sock.ws.on("error", (err) => {
-      console.error(`${TAG3} WebSocket error: ${String(err)}`);
+      console.error(`${TAG2} WebSocket error: ${String(err)}`);
     });
   }
   return sock;
@@ -1644,7 +1281,7 @@ function computeBackoff(attempt, config = {}) {
 
 // app/lib/whatsapp/init-queries.ts
 import { inspect as inspect2 } from "util";
-var TAG4 = "[whatsapp:init]";
+var TAG3 = "[whatsapp:init]";
 var DEFAULT_QUERY_TIMEOUT_MS = 15e3;
 var INSPECT_OPTS2 = {
   depth: null,
@@ -1689,20 +1326,20 @@ async function runInitQueries(sock, ctx) {
     elapsedMs: 0
   };
   console.error(
-    `${TAG4} runInitQueries start account=${ctx.accountId} attempt=${ctx.attempt} selfPhone=${ctx.selfPhone ?? "unknown"} authDir=${ctx.authDir} queryTimeoutMs=${queryTimeoutMs}`
+    `${TAG3} runInitQueries start account=${ctx.accountId} attempt=${ctx.attempt} selfPhone=${ctx.selfPhone ?? "unknown"} authDir=${ctx.authDir} queryTimeoutMs=${queryTimeoutMs}`
   );
   console.error(
-    `${TAG4} fetchProps SKIPPED account=${ctx.accountId} reason=no-platform-consumer`
+    `${TAG3} fetchProps SKIPPED account=${ctx.accountId} reason=no-platform-consumer`
   );
   if (ctx.signal?.aborted) {
     result.aborted = true;
     result.elapsedMs = Date.now() - startedAt;
     console.error(
-      `${TAG4} runInitQueries aborted before start account=${ctx.accountId}`
+      `${TAG3} runInitQueries aborted before start account=${ctx.accountId}`
     );
     return result;
   }
-  console.error(`${TAG4} fetchBlocklist start account=${ctx.accountId}`);
+  console.error(`${TAG3} fetchBlocklist start account=${ctx.accountId}`);
   try {
     const blocklist = await withTimeout(
       "fetchBlocklist",
@@ -1712,24 +1349,24 @@ async function runInitQueries(sock, ctx) {
     const count = Array.isArray(blocklist) ? blocklist.length : 0;
     result.blocklistOk = true;
     console.error(
-      `${TAG4} fetchBlocklist ok account=${ctx.accountId} count=${count}`
+      `${TAG3} fetchBlocklist ok account=${ctx.accountId} count=${count}`
     );
   } catch (err) {
     const formatted = formatErr(err);
     result.errors.blocklist = formatted;
     console.error(
-      `${TAG4} fetchBlocklist FAILED account=${ctx.accountId}: ${formatted}`
+      `${TAG3} fetchBlocklist FAILED account=${ctx.accountId}: ${formatted}`
     );
   }
   if (ctx.signal?.aborted) {
     result.aborted = true;
     result.elapsedMs = Date.now() - startedAt;
     console.error(
-      `${TAG4} runInitQueries aborted mid-sequence account=${ctx.accountId} after=fetchBlocklist`
+      `${TAG3} runInitQueries aborted mid-sequence account=${ctx.accountId} after=fetchBlocklist`
     );
     return result;
   }
-  console.error(`${TAG4} fetchPrivacySettings start account=${ctx.accountId}`);
+  console.error(`${TAG3} fetchPrivacySettings start account=${ctx.accountId}`);
   try {
     const settings = await withTimeout(
       "fetchPrivacySettings",
@@ -1739,18 +1376,18 @@ async function runInitQueries(sock, ctx) {
     );
     result.privacySettingsOk = true;
     console.error(
-      `${TAG4} fetchPrivacySettings ok account=${ctx.accountId} keys=${settings ? Object.keys(settings).join(",") : ""}`
+      `${TAG3} fetchPrivacySettings ok account=${ctx.accountId} keys=${settings ? Object.keys(settings).join(",") : ""}`
     );
   } catch (err) {
     const formatted = formatErr(err);
     result.errors.privacySettings = formatted;
     console.error(
-      `${TAG4} fetchPrivacySettings FAILED account=${ctx.accountId}: ${formatted}`
+      `${TAG3} fetchPrivacySettings FAILED account=${ctx.accountId}: ${formatted}`
     );
   }
   result.elapsedMs = Date.now() - startedAt;
   console.error(
-    `${TAG4} runInitQueries done account=${ctx.accountId} blocklistOk=${result.blocklistOk} privacySettingsOk=${result.privacySettingsOk} elapsedMs=${result.elapsedMs}`
+    `${TAG3} runInitQueries done account=${ctx.accountId} blocklistOk=${result.blocklistOk} privacySettingsOk=${result.privacySettingsOk} elapsedMs=${result.elapsedMs}`
   );
   return result;
 }
@@ -2054,7 +1691,7 @@ function isDuplicateInbound(key) {
 }
 
 // app/lib/whatsapp/activity.ts
-var TAG5 = "[whatsapp:activity]";
+var TAG4 = "[whatsapp:activity]";
 var RECENT_EVENTS_MAX = 200;
 var counters = /* @__PURE__ */ new Map();
 var recentEvents = [];
@@ -2082,10 +1719,10 @@ function recordActivity(event) {
       recentEvents.splice(0, recentEvents.length - RECENT_EVENTS_MAX);
     }
     console.error(
-      `${TAG5} channel-activity: direction=${direction} account=${accountId} jid=${jid}` + (messageType ? ` type=${messageType}` : "")
+      `${TAG4} channel-activity: direction=${direction} account=${accountId} jid=${jid}` + (messageType ? ` type=${messageType}` : "")
     );
   } catch (err) {
-    console.error(`${TAG5} recording failed: ${String(err)}`);
+    console.error(`${TAG4} recording failed: ${String(err)}`);
   }
 }
 function getChannelActivity(accountId) {
@@ -2106,7 +1743,7 @@ function getChannelActivity(accountId) {
 }
 
 // app/lib/whatsapp/outbound/send.ts
-var TAG6 = "[whatsapp:outbound]";
+var TAG5 = "[whatsapp:outbound]";
 async function sendTextMessage(sock, to, text, opts) {
   try {
     const jid = to.includes("@") ? to : toWhatsappJid(to);
@@ -2118,14 +1755,14 @@ async function sendTextMessage(sock, to, text, opts) {
     const messageId = result?.key?.id;
     if (messageId) {
       trackAgentSentMessage(messageId);
-      console.error(`${TAG6} sent text to=${jid} id=${messageId}`);
+      console.error(`${TAG5} sent text to=${jid} id=${messageId}`);
     }
     if (opts?.accountId) {
       recordActivity({ accountId: opts.accountId, direction: "outbound", jid, messageType: "text" });
     }
     return { success: true, messageId: messageId ?? void 0 };
   } catch (err) {
-    console.error(`${TAG6} send failed to=${to}: ${String(err)}`);
+    console.error(`${TAG5} send failed to=${to}: ${String(err)}`);
     return { success: false, error: String(err) };
   }
 }
@@ -2180,20 +1817,20 @@ async function sendMediaMessage(sock, to, media, opts) {
     const messageId = result?.key?.id;
     if (messageId) {
       trackAgentSentMessage(messageId);
-      console.error(`${TAG6} sent ${media.type} to=${jid} id=${messageId}`);
+      console.error(`${TAG5} sent ${media.type} to=${jid} id=${messageId}`);
     }
     if (opts?.accountId) {
       recordActivity({ accountId: opts.accountId, direction: "outbound", jid, messageType: media.type });
     }
     return { success: true, messageId: messageId ?? void 0 };
   } catch (err) {
-    console.error(`${TAG6} send media failed to=${to}: ${String(err)}`);
+    console.error(`${TAG5} send media failed to=${to}: ${String(err)}`);
     return { success: false, error: String(err) };
   }
 }
 
 // app/lib/whatsapp/persist-message.ts
-var TAG7 = "[whatsapp-persist]";
+var TAG6 = "[whatsapp-persist]";
 var sessionWriteLocks = /* @__PURE__ */ new Map();
 async function persistWhatsAppMessage(input) {
   if (!input.body || !input.msgKeyId) return null;
@@ -2298,7 +1935,7 @@ async function persistWhatsAppMessage(input) {
     const result = await session.run(cypher, params);
     const ms = Date.now() - t0;
     if (result.records.length === 0) {
-      console.error(`${TAG7} skip reason=conversation-not-found accountId=${input.platformAccountId} cacheKey=${input.cacheKey} messageId=${messageId}`);
+      console.error(`${TAG6} skip reason=conversation-not-found accountId=${input.platformAccountId} cacheKey=${input.cacheKey} messageId=${messageId}`);
       return null;
     }
     const rec = result.records[0];
@@ -2307,26 +1944,26 @@ async function persistWhatsAppMessage(input) {
     const senderElementId = rec.get("senderElementId");
     const senderReused = rec.get("senderReused") === true;
     if (existed) {
-      console.error(`${TAG7} noop reason=existing-message messageId=${messageId}`);
+      console.error(`${TAG6} noop reason=existing-message messageId=${messageId}`);
       return { messageId, created: false, senderElementId };
     }
     console.error(
-      `${TAG7} sender-resolved telephone=${senderTelephone} nodeKind=Person elementId=${senderElementId} reused=${senderReused}`
+      `${TAG6} sender-resolved telephone=${senderTelephone} nodeKind=Person elementId=${senderElementId} reused=${senderReused}`
     );
     if (prevMessageId) {
-      console.error(`${TAG7} next-merge prior=${prevMessageId} next=${messageId}`);
+      console.error(`${TAG6} next-merge prior=${prevMessageId} next=${messageId}`);
     } else {
-      console.error(`${TAG7} next-skip reason=no-prior msgId=${messageId}`);
+      console.error(`${TAG6} next-skip reason=no-prior msgId=${messageId}`);
     }
     console.error(
-      `${TAG7} write messageId=${messageId} accountId=${input.platformAccountId} cacheKey=${input.cacheKey} fromMe=${input.fromMe} dateSent=${dateSentIso} bodyBytes=${Buffer.byteLength(input.body, "utf8")} ms=${ms}`
+      `${TAG6} write messageId=${messageId} accountId=${input.platformAccountId} cacheKey=${input.cacheKey} fromMe=${input.fromMe} dateSent=${dateSentIso} bodyBytes=${Buffer.byteLength(input.body, "utf8")} ms=${ms}`
     );
     return { messageId, created: true, senderElementId };
   } catch (err) {
     const ms = Date.now() - t0;
     const reason = sanitizeReason(err);
     console.error(
-      `${TAG7} FAIL accountId=${input.platformAccountId} waname=${input.accountId} remoteJid=${input.remoteJid} msgKey=${input.msgKeyId} reason=${reason} ms=${ms}`
+      `${TAG6} FAIL accountId=${input.platformAccountId} waname=${input.accountId} remoteJid=${input.remoteJid} msgKey=${input.msgKeyId} reason=${reason} ms=${ms}`
     );
     return null;
   } finally {
@@ -2359,7 +1996,7 @@ function sanitizeReason(err) {
 }
 
 // app/lib/whatsapp/ensure-conversation.ts
-var TAG8 = "[whatsapp-persist]";
+var TAG7 = "[whatsapp-persist]";
 async function ensureWhatsAppConversation(input) {
   const t0 = Date.now();
   try {
@@ -2371,27 +2008,27 @@ async function ensureWhatsAppConversation(input) {
     const ms = Date.now() - t0;
     if (!result.conversationId) {
       console.error(
-        `${TAG8} conversation-merged FAIL cacheKey=${input.cacheKey} reason=null-conversationId ms=${ms}`
+        `${TAG7} conversation-merged FAIL cacheKey=${input.cacheKey} reason=null-conversationId ms=${ms}`
       );
       return null;
     }
     console.error(
-      `${TAG8} conversation-merged cacheKey=${input.cacheKey} agentType=${input.agentType} channel=whatsapp created=${result.created} ms=${ms}`
+      `${TAG7} conversation-merged cacheKey=${input.cacheKey} agentType=${input.agentType} channel=whatsapp created=${result.created} ms=${ms}`
     );
     return { conversationId: result.conversationId, created: result.created };
   } catch (err) {
     const ms = Date.now() - t0;
     const reason = err instanceof Error ? `${err.name}:${err.message.slice(0, 200)}` : String(err).slice(0, 200);
     console.error(
-      `${TAG8} conversation-merged FAIL cacheKey=${input.cacheKey} reason=${reason} ms=${ms}`
+      `${TAG7} conversation-merged FAIL cacheKey=${input.cacheKey} reason=${reason} ms=${ms}`
     );
     return null;
   }
 }
 
 // ../lib/account-enumeration/src/index.ts
-import { readdirSync, readFileSync as readFileSync3 } from "fs";
-import { resolve as resolve2 } from "path";
+import { readdirSync, readFileSync as readFileSync2 } from "fs";
+import { resolve } from "path";
 var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 var cache = /* @__PURE__ */ new Map();
 function enumerateValidAccountIds(accountsDir) {
@@ -2410,9 +2047,9 @@ function enumerateValidAccountIds(accountsDir) {
   const valid = [];
   for (const name of names) {
     if (!UUID_RE.test(name)) continue;
-    const configPath2 = resolve2(accountsDir, name, "account.json");
+    const configPath2 = resolve(accountsDir, name, "account.json");
     try {
-      JSON.parse(readFileSync3(configPath2, "utf-8"));
+      JSON.parse(readFileSync2(configPath2, "utf-8"));
       valid.push(name);
     } catch (err) {
       const code = err.code;
@@ -2429,7 +2066,7 @@ function getAccountsDirFromEnv() {
       "[graph-write] MAXY_PLATFORM_ROOT not set \u2014 cannot enforce accountId gate. Set MAXY_PLATFORM_ROOT in the spawning process or pass `accountsDir` explicitly."
     );
   }
-  return resolve2(root, "..", "data/accounts");
+  return resolve(root, "..", "data/accounts");
 }
 function validateAccountIdEnv(envValue, diskIds) {
   if (!envValue) {
@@ -2468,13 +2105,13 @@ function resolvePlatformAccountId(accountsDir = ACCOUNTS_DIR) {
 // app/lib/whatsapp/inbound/media.ts
 import { randomUUID as randomUUID2 } from "crypto";
 import { writeFile, mkdir } from "fs/promises";
-import { join as join3 } from "path";
+import { join as join2 } from "path";
 import {
   downloadMediaMessage,
   downloadContentFromMessage,
   normalizeMessageContent as normalizeMessageContent2
 } from "@whiskeysockets/baileys";
-var TAG9 = "[whatsapp:media]";
+var TAG8 = "[whatsapp:media]";
 var MEDIA_DIR = "/tmp/maxy-media";
 function mimeToExt(mimetype) {
   const map = {
@@ -2530,47 +2167,47 @@ async function downloadInboundMedia(msg, sock, opts) {
       }
     );
     if (!buffer || buffer.length === 0) {
-      console.error(`${TAG9} primary download returned empty, trying direct fallback`);
+      console.error(`${TAG8} primary download returned empty, trying direct fallback`);
       const downloadable = getDownloadableContent(content);
       if (downloadable) {
         try {
           const stream = await downloadContentFromMessage(downloadable.downloadable, downloadable.mediaType);
           buffer = await streamToBuffer(stream);
         } catch (fallbackErr) {
-          console.error(`${TAG9} direct download fallback failed: ${String(fallbackErr)}`);
+          console.error(`${TAG8} direct download fallback failed: ${String(fallbackErr)}`);
         }
       }
     }
     if (!buffer || buffer.length === 0) {
-      console.error(`${TAG9} download failed: empty buffer for ${mimetype ?? "unknown"}`);
+      console.error(`${TAG8} download failed: empty buffer for ${mimetype ?? "unknown"}`);
       return void 0;
     }
     if (buffer.length > maxBytes) {
       const sizeMB = (buffer.length / (1024 * 1024)).toFixed(1);
       const limitMB = (maxBytes / (1024 * 1024)).toFixed(0);
-      console.error(`${TAG9} media too large type=${mimetype ?? "unknown"} size=${sizeMB}MB limit=${limitMB}MB`);
+      console.error(`${TAG8} media too large type=${mimetype ?? "unknown"} size=${sizeMB}MB limit=${limitMB}MB`);
       return void 0;
     }
     await mkdir(MEDIA_DIR, { recursive: true });
     const ext = mimeToExt(mimetype ?? "application/octet-stream");
     const filename = `${randomUUID2()}.${ext}`;
-    const filePath = join3(MEDIA_DIR, filename);
+    const filePath = join2(MEDIA_DIR, filename);
     await writeFile(filePath, buffer);
     const sizeKB = (buffer.length / 1024).toFixed(0);
-    console.error(`${TAG9} media downloaded type=${mimetype ?? "unknown"} size=${sizeKB}KB path=${filePath}`);
+    console.error(`${TAG8} media downloaded type=${mimetype ?? "unknown"} size=${sizeKB}KB path=${filePath}`);
     return {
       path: filePath,
       mimetype: mimetype ?? "application/octet-stream",
       size: buffer.length
     };
   } catch (err) {
-    console.error(`${TAG9} media download failed type=${mimetype ?? "unknown"} error=${String(err)}`);
+    console.error(`${TAG8} media download failed type=${mimetype ?? "unknown"} error=${String(err)}`);
     return void 0;
   }
 }
 
 // app/lib/whatsapp/inbound/debounce.ts
-var TAG10 = "[whatsapp:debounce]";
+var TAG9 = "[whatsapp:debounce]";
 var STT_TAG = "[whatsapp:stt-await]";
 function createInboundDebouncer(opts) {
   const { debounceMs, buildKey, onFlush, onError } = opts;
@@ -2601,7 +2238,7 @@ function createInboundDebouncer(opts) {
     pending.delete(key);
     const batchSize = batch.entries.length;
     try {
-      console.error(`${TAG10} debounce flush key=${key} batchSize=${batchSize}`);
+      console.error(`${TAG9} debounce flush key=${key} batchSize=${batchSize}`);
       const result = onFlush(batch.entries);
       if (result && typeof result.catch === "function") {
         result.catch(onError);
@@ -2673,7 +2310,7 @@ function createInboundDebouncer(opts) {
 }
 
 // app/lib/whatsapp/opening-hours.ts
-var TAG11 = "[whatsapp:hours]";
+var TAG10 = "[whatsapp:hours]";
 async function isBusinessOpen(accountId) {
   try {
     const timezone = await resolveTimezone(accountId);
@@ -2691,7 +2328,7 @@ async function isBusinessOpen(accountId) {
         { accountId, dayOfWeek, previousDayOfWeek }
       );
       if (result.records.length === 0) {
-        console.error(`${TAG11} [${accountId}] business hours check: no opening hours configured, treating as open`);
+        console.error(`${TAG10} [${accountId}] business hours check: no opening hours configured, treating as open`);
         return { open: true, reason: "no opening hours configured" };
       }
       const specs = result.records.filter((r) => r.get("opens") != null && r.get("closes") != null).map((r) => ({
@@ -2700,7 +2337,7 @@ async function isBusinessOpen(accountId) {
         closes: String(r.get("closes")).trim()
       }));
       if (specs.length === 0) {
-        console.error(`${TAG11} [${accountId}] business hours check: no opening hours configured, treating as open`);
+        console.error(`${TAG10} [${accountId}] business hours check: no opening hours configured, treating as open`);
         return { open: true, reason: "no opening hours configured" };
       }
       for (const spec of specs) {
@@ -2710,7 +2347,7 @@ async function isBusinessOpen(accountId) {
           if (spec.opens > spec.closes && currentTime < spec.closes) {
             const hoursStr = `${spec.opens}-${spec.closes} (${spec.day})`;
             console.error(
-              `${TAG11} [${accountId}] business hours check: open (day=${dayOfWeek}, time=${currentTime}, hours=${hoursStr})`
+              `${TAG10} [${accountId}] business hours check: open (day=${dayOfWeek}, time=${currentTime}, hours=${hoursStr})`
             );
             return {
               open: true,
@@ -2723,7 +2360,7 @@ async function isBusinessOpen(accountId) {
         } else if (isTimeInRange(currentTime, spec.opens, spec.closes)) {
           const hoursStr = `${spec.opens}-${spec.closes}`;
           console.error(
-            `${TAG11} [${accountId}] business hours check: open (day=${dayOfWeek}, time=${currentTime}, hours=${hoursStr})`
+            `${TAG10} [${accountId}] business hours check: open (day=${dayOfWeek}, time=${currentTime}, hours=${hoursStr})`
           );
           return {
             open: true,
@@ -2737,7 +2374,7 @@ async function isBusinessOpen(accountId) {
       const todaySpecs = specs.filter((s) => s.day === dayOfWeek);
       const allHours = todaySpecs.map((s) => `${s.opens}-${s.closes}`).join(", ") || "none today";
       console.error(
-        `${TAG11} [${accountId}] business hours check: closed (day=${dayOfWeek}, time=${currentTime}, hours=${allHours})`
+        `${TAG10} [${accountId}] business hours check: closed (day=${dayOfWeek}, time=${currentTime}, hours=${allHours})`
       );
       return {
         open: false,
@@ -2751,7 +2388,7 @@ async function isBusinessOpen(accountId) {
     }
   } catch (err) {
     console.error(
-      `${TAG11} [${accountId}] business hours check failed, treating as open: ${err instanceof Error ? err.message : String(err)}`
+      `${TAG10} [${accountId}] business hours check failed, treating as open: ${err instanceof Error ? err.message : String(err)}`
     );
     return { open: true, reason: "hours check failed (treating as open)" };
   }
@@ -2797,7 +2434,7 @@ import { execFile } from "child_process";
 import { unlink, stat } from "fs/promises";
 import { promisify } from "util";
 var execFileAsync = promisify(execFile);
-var TAG12 = "[stt]";
+var TAG11 = "[stt]";
 var WHISPER_BINARY = process.env.WHISPER_BINARY ?? "/opt/whisper.cpp/build/bin/whisper-cli";
 var WHISPER_MODEL = process.env.WHISPER_MODEL ?? "/opt/whisper.cpp/models/ggml-base.bin";
 var WHISPER_TIMEOUT_MS = 20 * 60 * 1e3;
@@ -2808,11 +2445,11 @@ async function transcribe(audioPath, mimetype) {
     const s = await stat(audioPath);
     audioBytes = s.size;
   } catch {
-    console.error(`${TAG12} failed: file not readable path=${audioPath}`);
+    console.error(`${TAG11} failed: file not readable path=${audioPath}`);
     return void 0;
   }
   console.error(
-    `${TAG12} start provider=whisper-local audio_bytes=${audioBytes} mimetype=${mimetype} path=${audioPath}`
+    `${TAG11} start provider=whisper-local audio_bytes=${audioBytes} mimetype=${mimetype} path=${audioPath}`
   );
   const wavPath = audioPath.replace(/\.[^.]+$/, "") + ".wav";
   try {
@@ -2831,7 +2468,7 @@ async function transcribe(audioPath, mimetype) {
     ], { timeout: 3e4 });
   } catch (err) {
     const reason = err instanceof Error ? err.message : String(err);
-    console.error(`${TAG12} failed: ffmpeg conversion error=${reason}`);
+    console.error(`${TAG11} failed: ffmpeg conversion error=${reason}`);
     return void 0;
   }
   try {
@@ -2849,20 +2486,20 @@ async function transcribe(audioPath, mimetype) {
     const text = stdout.trim();
     const durationMs = Date.now() - startMs;
     if (!text) {
-      console.error(`${TAG12} failed: whisper returned empty output duration_ms=${durationMs}`);
+      console.error(`${TAG11} failed: whisper returned empty output duration_ms=${durationMs}`);
       return void 0;
     }
     const langMatch = stderr.match(/auto-detected language:\s*(\w+)/);
     const language = langMatch?.[1] ?? "unknown";
     const words = text.split(/\s+/).filter(Boolean).length;
     console.error(
-      `${TAG12} done provider=whisper-local duration_ms=${durationMs} words=${words} lang=${language}`
+      `${TAG11} done provider=whisper-local duration_ms=${durationMs} words=${words} lang=${language}`
     );
     return { text, language, durationMs };
   } catch (err) {
     const durationMs = Date.now() - startMs;
     const reason = err instanceof Error ? err.message : String(err);
-    console.error(`${TAG12} failed provider=whisper-local duration_ms=${durationMs} error=${reason}`);
+    console.error(`${TAG11} failed provider=whisper-local duration_ms=${durationMs} error=${reason}`);
     return void 0;
   } finally {
     unlink(wavPath).catch(() => {
@@ -2871,7 +2508,7 @@ async function transcribe(audioPath, mimetype) {
 }
 
 // app/lib/whatsapp/manager.ts
-var TAG13 = "[whatsapp:manager]";
+var TAG12 = "[whatsapp:manager]";
 var MAX_RECONNECT_ATTEMPTS = 10;
 var MESSAGE_STORE_MAX = 500;
 var GROUP_META_TTL = 5 * 60 * 1e3;
@@ -2891,7 +2528,7 @@ function storeMessage(storeKey, entry) {
   if (entries.length > MESSAGE_STORE_MAX) {
     const trimmed = entries.length - MESSAGE_STORE_MAX;
     entries.splice(0, trimmed);
-    console.error(`${TAG13} message store trimmed for ${storeKey}: ${trimmed} oldest messages removed`);
+    console.error(`${TAG12} message store trimmed for ${storeKey}: ${trimmed} oldest messages removed`);
   }
 }
 function deriveCacheKey(input) {
@@ -2910,7 +2547,7 @@ function deriveCacheKey(input) {
 }
 async function init(opts) {
   if (initialized) {
-    console.error(`${TAG13} already initialized`);
+    console.error(`${TAG12} already initialized`);
     return;
   }
   configDir = opts.configDir;
@@ -2918,20 +2555,20 @@ async function init(opts) {
   loadConfig(opts.accountConfig);
   const accountIds = listCredentialAccountIds(configDir);
   if (accountIds.length === 0) {
-    console.error(`${TAG13} init: no stored WhatsApp credentials found`);
+    console.error(`${TAG12} init: no stored WhatsApp credentials found`);
     initialized = true;
     return;
   }
-  console.error(`${TAG13} init: found ${accountIds.length} credentialed account(s): ${accountIds.join(", ")}`);
+  console.error(`${TAG12} init: found ${accountIds.length} credentialed account(s): ${accountIds.join(", ")}`);
   initialized = true;
   for (const accountId of accountIds) {
     const accountCfg = whatsAppConfig.accounts?.[accountId];
     if (accountCfg?.enabled === false) {
-      console.error(`${TAG13} skipping disabled account=${accountId}`);
+      console.error(`${TAG12} skipping disabled account=${accountId}`);
       continue;
     }
     startConnection(accountId).catch((err) => {
-      console.error(`${TAG13} failed to auto-start account=${accountId}: ${formatError(err)}`);
+      console.error(`${TAG12} failed to auto-start account=${accountId}: ${formatError(err)}`);
     });
   }
 }
@@ -2940,7 +2577,7 @@ async function startConnection(accountId) {
   const authDir = resolveAuthDir(configDir, accountId);
   const hasAuth = await authExists(authDir);
   if (!hasAuth) {
-    console.error(`${TAG13} no credentials for account=${accountId}`);
+    console.error(`${TAG12} no credentials for account=${accountId}`);
     return;
   }
   let platformAccountId;
@@ -2991,11 +2628,11 @@ async function stopConnection(accountId) {
       conn.sock.ev.removeAllListeners("creds.update");
       conn.sock.ws?.close?.();
     } catch (err) {
-      console.warn(`${TAG13} socket cleanup error during stop account=${accountId}: ${String(err)}`);
+      console.warn(`${TAG12} socket cleanup error during stop account=${accountId}: ${String(err)}`);
     }
   }
   connections.delete(accountId);
-  console.error(`${TAG13} stopped account=${accountId}`);
+  console.error(`${TAG12} stopped account=${accountId}`);
 }
 function getStatus() {
   return Array.from(connections.values()).map((conn) => ({
@@ -3057,9 +2694,9 @@ async function registerLoginSocket(accountId, sock, authDir) {
   connections.set(accountId, conn);
   try {
     await sock.sendPresenceUpdate("available");
-    console.error(`${TAG13} presence set to available account=${accountId}`);
+    console.error(`${TAG12} presence set to available account=${accountId}`);
   } catch (err) {
-    console.error(`${TAG13} presence update failed account=${accountId}: ${String(err)}`);
+    console.error(`${TAG12} presence update failed account=${accountId}: ${String(err)}`);
   }
   await runInitQueries(sock, {
     accountId,
@@ -3071,7 +2708,7 @@ async function registerLoginSocket(accountId, sock, authDir) {
   monitorInbound(conn);
   watchForDisconnect(conn);
   attachSelfIdRefreshOnCredsUpdate(conn);
-  console.error(`${TAG13} registered login socket for account=${accountId} phone=${selfId.e164 ?? "unknown"}`);
+  console.error(`${TAG12} registered login socket for account=${accountId} phone=${selfId.e164 ?? "unknown"}`);
 }
 function attachSelfIdRefreshOnCredsUpdate(conn) {
   if (!conn.sock) return;
@@ -3122,24 +2759,23 @@ async function shutdown() {
   const ids = Array.from(connections.keys());
   await Promise.all(ids.map((id) => stopConnection(id)));
   initialized = false;
-  console.error(`${TAG13} shutdown complete`);
+  console.error(`${TAG12} shutdown complete`);
 }
 function loadConfig(accountConfig) {
   try {
     const raw = accountConfig?.whatsapp;
     if (raw && typeof raw === "object") {
       const wa = raw;
-      migrateAdminPhones(wa);
       const parsed = WhatsAppConfigSchema.safeParse(wa);
       if (parsed.success) {
         whatsAppConfig = parsed.data;
       } else {
-        console.error(`${TAG13} config validation failed: ${parsed.error.message}`);
+        console.error(`${TAG12} config validation failed: ${parsed.error.message}`);
         whatsAppConfig = {};
       }
     }
   } catch (err) {
-    console.error(`${TAG13} config load error: ${String(err)}`);
+    console.error(`${TAG12} config load error: ${String(err)}`);
     whatsAppConfig = {};
   }
 }
@@ -3150,13 +2786,13 @@ async function connectWithReconnect(conn) {
     let cycleError = null;
     let connectedAt;
     try {
-      console.error(`${TAG13} connecting account=${conn.accountId} attempt=${conn.reconnectAttempts}`);
+      console.error(`${TAG12} connecting account=${conn.accountId} attempt=${conn.reconnectAttempts}`);
       const sock = await createWaSocket({
         authDir: conn.authDir,
         silent: true
       });
       conn.sock = sock;
-      console.error(`${TAG13} socket created account=${conn.accountId} \u2014 waiting for connection`);
+      console.error(`${TAG12} socket created account=${conn.accountId} \u2014 waiting for connection`);
       await waitForConnection(sock);
       const selfId = readSelfId(conn.authDir);
       connectedAt = Date.now();
@@ -3173,12 +2809,12 @@ async function connectWithReconnect(conn) {
       } else {
         console.error(`[whatsapp:lid] FAIL self-lid-resolution accountId=${conn.accountId} reason=creds-missing-lid`);
       }
-      console.error(`${TAG13} connected account=${conn.accountId} phone=${selfId.e164 ?? "unknown"}`);
+      console.error(`${TAG12} connected account=${conn.accountId} phone=${selfId.e164 ?? "unknown"}`);
       try {
         await sock.sendPresenceUpdate("available");
-        console.error(`${TAG13} presence set to available account=${conn.accountId}`);
+        console.error(`${TAG12} presence set to available account=${conn.accountId}`);
       } catch (err) {
-        console.error(`${TAG13} presence update failed account=${conn.accountId}: ${String(err)}`);
+        console.error(`${TAG12} presence update failed account=${conn.accountId}: ${String(err)}`);
       }
       await runInitQueries(sock, {
         accountId: conn.accountId,
@@ -3206,9 +2842,9 @@ async function connectWithReconnect(conn) {
       }
       const classification = classifyDisconnect(err);
       conn.lastError = classification.message;
-      console.error(`${TAG13} disconnect account=${conn.accountId}: ${classification.kind} \u2014 ${classification.message}`);
+      console.error(`${TAG12} disconnect account=${conn.accountId}: ${classification.kind} \u2014 ${classification.message}`);
       if (!classification.shouldRetry) {
-        console.error(`${TAG13} terminal disconnect for account=${conn.accountId}, stopping reconnection`);
+        console.error(`${TAG12} terminal disconnect for account=${conn.accountId}, stopping reconnection`);
         return;
       }
     }
@@ -3221,7 +2857,7 @@ async function connectWithReconnect(conn) {
     if (decision.action === "abort") {
       const stuckReason = `GIVING UP account=${conn.accountId} attempts=${decision.finalAttempts}/${maxAttempts} uptimeMsLast=${uptimeMs} stableThresholdMs=${STABLE_UPTIME_MS} lastError=${conn.lastError ?? "(none)"}`;
       console.error(
-        `${TAG13} ${stuckReason} \u2014 re-pair via QR or restart required; WhatsApp will not reconnect automatically`
+        `${TAG12} ${stuckReason} \u2014 re-pair via QR or restart required; WhatsApp will not reconnect automatically`
       );
       conn.sessionStuckReason = stuckReason;
       conn.lastError = stuckReason;
@@ -3230,17 +2866,17 @@ async function connectWithReconnect(conn) {
     conn.reconnectAttempts = decision.nextAttempts;
     if (decision.reason === "short-lived") {
       console.error(
-        `${TAG13} short-lived session account=${conn.accountId} uptimeMs=${uptimeMs} attempt=${decision.nextAttempts}/${maxAttempts} lastError=${conn.lastError ?? "(clean disconnect)"}`
+        `${TAG12} short-lived session account=${conn.accountId} uptimeMs=${uptimeMs} attempt=${decision.nextAttempts}/${maxAttempts} lastError=${conn.lastError ?? "(clean disconnect)"}`
       );
     } else {
       console.error(
-        `${TAG13} session stable account=${conn.accountId} uptimeMs=${uptimeMs} \u2014 reconnect counter reset`
+        `${TAG12} session stable account=${conn.accountId} uptimeMs=${uptimeMs} \u2014 reconnect counter reset`
       );
     }
     if (decision.reason === "short-lived" || cycleError) {
       const delay = computeBackoff(Math.max(1, decision.nextAttempts));
       console.error(
-        `${TAG13} reconnecting account=${conn.accountId} in ${delay}ms (attempt ${decision.nextAttempts}/${maxAttempts})`
+        `${TAG12} reconnecting account=${conn.accountId} in ${delay}ms (attempt ${decision.nextAttempts}/${maxAttempts})`
       );
       await new Promise((resolve24) => {
         const timer2 = setTimeout(resolve24, delay);
@@ -3274,11 +2910,11 @@ function watchForDisconnect(conn) {
   conn.sock.ev.on("connection.update", (update) => {
     if (update.connection === "close") {
       if (connections.get(conn.accountId) !== conn) return;
-      console.error(`${TAG13} socket disconnected for account=${conn.accountId}`);
+      console.error(`${TAG12} socket disconnected for account=${conn.accountId}`);
       conn.connected = false;
       conn.sock = null;
       connectWithReconnect(conn).catch((err) => {
-        console.error(`${TAG13} reconnection failed for account=${conn.accountId}: ${formatError(err)}`);
+        console.error(`${TAG12} reconnection failed for account=${conn.accountId}: ${formatError(err)}`);
       });
     }
   });
@@ -3287,7 +2923,7 @@ async function getGroupMeta(conn, jid) {
   const cached2 = conn.groupMetaCache.get(jid);
   if (cached2 && cached2.expires > Date.now()) return cached2;
   if (!conn.sock) return null;
-  console.error(`${TAG13} group metadata cache miss for ${jid}, fetching from Baileys account=${conn.accountId}`);
+  console.error(`${TAG12} group metadata cache miss for ${jid}, fetching from Baileys account=${conn.accountId}`);
   try {
     const meta = await conn.sock.groupMetadata(jid);
     const participants = await Promise.all(
@@ -3302,12 +2938,12 @@ async function getGroupMeta(conn, jid) {
     };
     conn.groupMetaCache.set(jid, entry);
     console.error(
-      `${TAG13} group metadata cached for ${jid}: "${meta.subject}", ${participants.length} participants, expires in ${GROUP_META_TTL}ms account=${conn.accountId}`
+      `${TAG12} group metadata cached for ${jid}: "${meta.subject}", ${participants.length} participants, expires in ${GROUP_META_TTL}ms account=${conn.accountId}`
     );
     return entry;
   } catch (err) {
     console.error(
-      `${TAG13} group metadata fetch failed for ${jid}: ${err instanceof Error ? err.message : String(err)}, caching empty entry for ${GROUP_META_TTL}ms account=${conn.accountId}`
+      `${TAG12} group metadata fetch failed for ${jid}: ${err instanceof Error ? err.message : String(err)}, caching empty entry for ${GROUP_META_TTL}ms account=${conn.accountId}`
     );
     const emptyEntry = { expires: Date.now() + GROUP_META_TTL };
     conn.groupMetaCache.set(jid, emptyEntry);
@@ -3318,7 +2954,7 @@ function monitorInbound(conn) {
   if (!conn.sock || !onInboundMessage) return;
   const sock = conn.sock;
   const debounceMs = whatsAppConfig.accounts?.[conn.accountId]?.debounceMs ?? whatsAppConfig.debounceMs ?? 0;
-  console.error(`${TAG13} monitorInbound started account=${conn.accountId} debounceMs=${debounceMs}`);
+  console.error(`${TAG12} monitorInbound started account=${conn.accountId} debounceMs=${debounceMs}`);
   conn.debouncer = createInboundDebouncer({
     debounceMs,
     buildKey: (payload) => {
@@ -3331,7 +2967,7 @@ function monitorInbound(conn) {
         onInboundMessage(entries[0]);
         return;
       }
-      console.error(`${TAG13} debounce: combining ${entries.length} messages account=${conn.accountId} from=${entries[0].senderPhone}`);
+      console.error(`${TAG12} debounce: combining ${entries.length} messages account=${conn.accountId} from=${entries[0].senderPhone}`);
       const last = entries[entries.length - 1];
       const mediaEntry = entries.find((e) => e.mediaPath);
       const combinedText = entries.map((e) => e.text).filter(Boolean).join("\n");
@@ -3344,7 +2980,7 @@ function monitorInbound(conn) {
       });
     },
     onError: (err) => {
-      console.error(`${TAG13} debounce flush error account=${conn.accountId}: ${String(err)}`);
+      console.error(`${TAG12} debounce flush error account=${conn.accountId}: ${String(err)}`);
     }
   });
   sock.ev.on("messages.upsert", async (upsert) => {
@@ -3372,7 +3008,7 @@ function monitorInbound(conn) {
           });
           const entries = messageStore.get(storeKey);
           console.error(
-            `${TAG13} stored message ${msg.key.id ?? "?"} for ${remoteJid} (type: ${upsert.type}, store size: ${entries?.length ?? 0}/${MESSAGE_STORE_MAX}) account=${conn.accountId}`
+            `${TAG12} stored message ${msg.key.id ?? "?"} for ${remoteJid} (type: ${upsert.type}, store size: ${entries?.length ?? 0}/${MESSAGE_STORE_MAX}) account=${conn.accountId}`
           );
           recordActivity({
             accountId: conn.accountId,
@@ -3436,13 +3072,13 @@ function monitorInbound(conn) {
             );
           }
           console.error(
-            `${TAG13} append-type message ${msg.key.id ?? "?"} stored, dispatch skipped account=${conn.accountId}`
+            `${TAG12} append-type message ${msg.key.id ?? "?"} stored, dispatch skipped account=${conn.accountId}`
           );
           continue;
         }
         await handleInboundMessage(conn, msg);
       } catch (err) {
-        console.error(`${TAG13} inbound handler error account=${conn.accountId}: ${String(err)}`);
+        console.error(`${TAG12} inbound handler error account=${conn.accountId}: ${String(err)}`);
       }
     }
   });
@@ -3452,31 +3088,31 @@ async function handleInboundMessage(conn, msg) {
   const remoteJid = msg.key.remoteJid;
   if (!remoteJid) return;
   if (remoteJid === "status@broadcast") {
-    console.error(`${TAG13} drop: status broadcast account=${conn.accountId}`);
+    console.error(`${TAG12} drop: status broadcast account=${conn.accountId}`);
     return;
   }
   if (!msg.message) {
-    console.error(`${TAG13} drop: empty message account=${conn.accountId} from=${remoteJid}`);
+    console.error(`${TAG12} drop: empty message account=${conn.accountId} from=${remoteJid}`);
     return;
   }
   const dedupKey = `${conn.accountId}:${remoteJid}:${msg.key.id}`;
   if (isDuplicateInbound(dedupKey)) {
-    console.error(`${TAG13} drop: duplicate account=${conn.accountId} key=${dedupKey}`);
+    console.error(`${TAG12} drop: duplicate account=${conn.accountId} key=${dedupKey}`);
     return;
   }
   if (msg.key.fromMe) {
     if (msg.key.id && isAgentSentMessage(msg.key.id)) {
-      console.error(`${TAG13} drop: echo suppression account=${conn.accountId} msgId=${msg.key.id}`);
+      console.error(`${TAG12} drop: echo suppression account=${conn.accountId} msgId=${msg.key.id}`);
       return;
     }
     const extracted2 = extractMessage(msg);
     if (!extracted2.text) {
-      console.error(`${TAG13} owner reply skipped \u2014 no text content account=${conn.accountId}`);
+      console.error(`${TAG12} owner reply skipped \u2014 no text content account=${conn.accountId}`);
       return;
     }
     const isGroup2 = isGroupJid(remoteJid);
     const senderPhone2 = conn.selfPhone ?? "owner";
-    console.error(`${TAG13} owner reply mirrored to session from=${senderPhone2} account=${conn.accountId}`);
+    console.error(`${TAG12} owner reply mirrored to session from=${senderPhone2} account=${conn.accountId}`);
     const reply2 = async (text) => {
       const currentSock = conn.sock;
       if (!currentSock) throw new Error("WhatsApp disconnected \u2014 cannot reply");
@@ -3504,7 +3140,7 @@ async function handleInboundMessage(conn, msg) {
   }
   const extracted = extractMessage(msg);
   if (!extracted.text && !extracted.mediaType) {
-    console.error(`${TAG13} drop: no text or media account=${conn.accountId} from=${remoteJid}`);
+    console.error(`${TAG12} drop: no text or media account=${conn.accountId} from=${remoteJid}`);
     return;
   }
   let mediaResult;
@@ -3514,7 +3150,7 @@ async function handleInboundMessage(conn, msg) {
       maxBytes: maxMb * 1024 * 1024
     });
     if (!mediaResult) {
-      console.error(`${TAG13} media download returned undefined account=${conn.accountId} type=${extracted.mediaType} from=${remoteJid}`);
+      console.error(`${TAG12} media download returned undefined account=${conn.accountId} type=${extracted.mediaType} from=${remoteJid}`);
     }
   }
   const isGroup = isGroupJid(remoteJid);
@@ -3567,7 +3203,7 @@ async function handleInboundMessage(conn, msg) {
     });
   }
   console.error(
-    `${TAG13} inbound account=${conn.accountId} from=${senderPhone} group=${isGroup} access=${accessResult.allowed ? "allowed" : "blocked"}(${accessResult.reason}) agent=${accessResult.agentType}` + (extracted.mediaType ? ` media=${extracted.mediaType}` : "") + (mediaResult ? ` mediaPath=${mediaResult.path}` : "") + (extracted.quotedMessage ? ` replyTo=${extracted.quotedMessage.id}` : "")
+    `${TAG12} inbound account=${conn.accountId} from=${senderPhone} group=${isGroup} access=${accessResult.allowed ? "allowed" : "blocked"}(${accessResult.reason}) agent=${accessResult.agentType}` + (extracted.mediaType ? ` media=${extracted.mediaType}` : "") + (mediaResult ? ` mediaPath=${mediaResult.path}` : "") + (extracted.quotedMessage ? ` replyTo=${extracted.quotedMessage.id}` : "")
   );
   if (!accessResult.allowed) return;
   let groupSubject;
@@ -3610,15 +3246,15 @@ async function handleInboundMessage(conn, msg) {
   if (accessResult.agentType === "public") {
     const hoursResult = await isBusinessOpen(conn.accountId);
     if (!hoursResult.open) {
-      console.error(`${TAG13} [${conn.accountId}] dispatch skipped: business closed`);
+      console.error(`${TAG12} [${conn.accountId}] dispatch skipped: business closed`);
       const afterHoursMessage = whatsAppConfig.accounts?.[conn.accountId]?.afterHoursMessage ?? whatsAppConfig.afterHoursMessage;
       if (afterHoursMessage) {
         try {
           await reply(afterHoursMessage);
-          console.error(`${TAG13} [${conn.accountId}] after-hours auto-reply sent to ${remoteJid}`);
+          console.error(`${TAG12} [${conn.accountId}] after-hours auto-reply sent to ${remoteJid}`);
         } catch (err) {
           console.error(
-            `${TAG13} [${conn.accountId}] after-hours auto-reply failed: ${err instanceof Error ? err.message : String(err)}`
+            `${TAG12} [${conn.accountId}] after-hours auto-reply failed: ${err instanceof Error ? err.message : String(err)}`
           );
         }
       }
@@ -3635,10 +3271,10 @@ async function handleInboundMessage(conn, msg) {
 // app/lib/vnc.ts
 import { spawnSync, execFileSync } from "child_process";
 import { createConnection } from "net";
-import { mkdirSync, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
-import { resolve as resolve3 } from "path";
-var PLATFORM_ROOT2 = process.env.MAXY_PLATFORM_ROOT ?? resolve3(process.cwd(), "..");
-var VNC_SCRIPT = resolve3(PLATFORM_ROOT2, "scripts/vnc.sh");
+import { mkdirSync, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
+import { resolve as resolve2 } from "path";
+var PLATFORM_ROOT2 = process.env.MAXY_PLATFORM_ROOT ?? resolve2(process.cwd(), "..");
+var VNC_SCRIPT = resolve2(PLATFORM_ROOT2, "scripts/vnc.sh");
 var displayMode = process.env.DISPLAY_MODE ?? "virtual";
 if (displayMode === "native") {
   console.log(`[vnc] DISPLAY_MODE=native \u2014 local requests use desktop display, remote requests use VNC`);
@@ -3693,7 +3329,7 @@ function discoverNativeDisplay() {
       const leaderPid = leaderResult.stdout?.trim();
       if (leaderPid) {
         try {
-          const environ = readFileSync4(`/proc/${leaderPid}/environ`, "utf8");
+          const environ = readFileSync3(`/proc/${leaderPid}/environ`, "utf8");
           const match = environ.split("\0").find((e) => e.startsWith("WAYLAND_DISPLAY="));
           if (match) waylandDisplay = match.split("=")[1];
         } catch {
@@ -3751,7 +3387,7 @@ function ensureLogDir() {
   mkdirSync(LOG_DIR, { recursive: true });
 }
 function logPath(name) {
-  return resolve3(LOG_DIR, `${name}.log`);
+  return resolve2(LOG_DIR, `${name}.log`);
 }
 async function ensureVnc() {
   const up = await waitForPort(RFB_PORT, 1e3);
@@ -3830,8 +3466,8 @@ function killChromium() {
 }
 function writeChromiumWrapper() {
   mkdirSync(BIN_DIR, { recursive: true });
-  const wrapperPath = resolve3(BIN_DIR, "chromium");
-  writeFileSync3(wrapperPath, `#!/bin/bash
+  const wrapperPath = resolve2(BIN_DIR, "chromium");
+  writeFileSync2(wrapperPath, `#!/bin/bash
 LOG="${LOG_DIR}/chromium.log"
 echo "==== [$(date)] chromium wrapper ====" >> "$LOG"
 echo "  DISPLAY=$DISPLAY WAYLAND=$WAYLAND_DISPLAY XDG_SESSION_TYPE=$XDG_SESSION_TYPE" >> "$LOG"
@@ -3952,8 +3588,8 @@ app.get("/", async (c) => {
   const browserTransport = resolveBrowserTransport(c.req.raw, c.env?.incoming?.socket?.remoteAddress);
   let pinConfigured = false;
   try {
-    if (existsSync3(USERS_FILE)) {
-      const raw = readFileSync5(USERS_FILE, "utf-8").trim();
+    if (existsSync2(USERS_FILE)) {
+      const raw = readFileSync4(USERS_FILE, "utf-8").trim();
       if (raw) {
         const users = JSON.parse(raw);
         pinConfigured = Array.isArray(users) && users.length > 0;
@@ -4010,9 +3646,9 @@ var health_default = app;
 import { randomUUID as randomUUID3 } from "crypto";
 import { mkdir as mkdir2, readFile, stat as stat2, writeFile as writeFile2 } from "fs/promises";
 import { realpathSync } from "fs";
-import { resolve as resolve4, extname, basename } from "path";
-var PLATFORM_ROOT3 = process.env.MAXY_PLATFORM_ROOT ?? resolve4(process.cwd(), "../platform");
-var ATTACHMENTS_ROOT = resolve4(PLATFORM_ROOT3, "..", "data/uploads");
+import { resolve as resolve3, extname, basename } from "path";
+var PLATFORM_ROOT3 = process.env.MAXY_PLATFORM_ROOT ?? resolve3(process.cwd(), "../platform");
+var ATTACHMENTS_ROOT = resolve3(PLATFORM_ROOT3, "..", "data/uploads");
 var SUPPORTED_MIME_TYPES = /* @__PURE__ */ new Set([
   "image/jpeg",
   "image/png",
@@ -4039,11 +3675,11 @@ function assertSupportedMime(mimeType) {
 }
 async function writeAttachment(scope, filename, mimeType, sizeBytes, buffer) {
   const attachmentId = randomUUID3();
-  const dir = resolve4(ATTACHMENTS_ROOT, scope, attachmentId);
+  const dir = resolve3(ATTACHMENTS_ROOT, scope, attachmentId);
   await mkdir2(dir, { recursive: true });
   const ext = extname(filename) || "";
-  const storagePath = resolve4(dir, `${attachmentId}${ext}`);
-  const metaPath = resolve4(dir, `${attachmentId}.meta.json`);
+  const storagePath = resolve3(dir, `${attachmentId}${ext}`);
+  const metaPath = resolve3(dir, `${attachmentId}.meta.json`);
   const meta = {
     attachmentId,
     scope,
@@ -4119,11 +3755,11 @@ async function storeComponentArtefact(accountId, attachmentId, mimeType, content
       `Component artefact exceeds the 50 MB limit (${(buffer.byteLength / 1024 / 1024).toFixed(1)} MB).`
     );
   }
-  const dir = resolve4(ATTACHMENTS_ROOT, accountId, attachmentId);
+  const dir = resolve3(ATTACHMENTS_ROOT, accountId, attachmentId);
   await mkdir2(dir, { recursive: true });
   const ext = extname(filename) || (mimeType === "text/html" ? ".html" : ".md");
-  const storagePath = resolve4(dir, `${attachmentId}${ext}`);
-  const metaPath = resolve4(dir, `${attachmentId}.meta.json`);
+  const storagePath = resolve3(dir, `${attachmentId}${ext}`);
+  const metaPath = resolve3(dir, `${attachmentId}.meta.json`);
   const meta = {
     attachmentId,
     scope: accountId,
@@ -4140,8 +3776,8 @@ async function storeComponentArtefact(accountId, attachmentId, mimeType, content
 // app/lib/stt/voice-note.ts
 import { writeFile as writeFile3, mkdtemp, rm } from "fs/promises";
 import { tmpdir } from "os";
-import { join as join4 } from "path";
-var TAG14 = "[voice]";
+import { join as join3 } from "path";
+var TAG13 = "[voice]";
 var AUDIO_MIME_TYPES = /* @__PURE__ */ new Set([
   "audio/ogg",
   "audio/opus",
@@ -4179,19 +3815,19 @@ async function transcribeVoiceNote(file, source) {
   const bytes = file.size;
   const mimeType = file.type;
   console.error(
-    `${TAG14} recording send source=${source} duration_ms=unknown bytes=${bytes} format=${mimeType}`
+    `${TAG13} recording send source=${source} duration_ms=unknown bytes=${bytes} format=${mimeType}`
   );
   let tempDir;
   let tempPath;
   try {
-    tempDir = await mkdtemp(join4(tmpdir(), "voice-"));
+    tempDir = await mkdtemp(join3(tmpdir(), "voice-"));
     const ext = audioExtension(mimeType);
-    tempPath = join4(tempDir, `recording${ext}`);
+    tempPath = join3(tempDir, `recording${ext}`);
     const buffer = Buffer.from(await file.arrayBuffer());
     await writeFile3(tempPath, buffer);
   } catch (err) {
     const reason = err instanceof Error ? err.message : String(err);
-    console.error(`${TAG14} failed source=${source} error=temp-file-write: ${reason}`);
+    console.error(`${TAG13} failed source=${source} error=temp-file-write: ${reason}`);
     return { ok: false, error: "Could not process voice note" };
   }
   try {
@@ -4199,7 +3835,7 @@ async function transcribeVoiceNote(file, source) {
     if (!sttResult) {
       const elapsed2 = Date.now() - startMs;
       console.error(
-        `${TAG14} failed source=${source} error=transcription-failed duration_ms=${elapsed2}`
+        `${TAG13} failed source=${source} error=transcription-failed duration_ms=${elapsed2}`
       );
       return { ok: false, error: "Could not transcribe voice note. Please try again or type your message." };
     }
@@ -4207,7 +3843,7 @@ async function transcribeVoiceNote(file, source) {
     const elapsed = Date.now() - startMs;
     const words = rawText.split(/\s+/).filter(Boolean).length;
     console.error(
-      `${TAG14} transcribed source=${source} duration_ms=${elapsed} stt_ms=${sttResult.durationMs} words=${words}`
+      `${TAG13} transcribed source=${source} duration_ms=${elapsed} stt_ms=${sttResult.durationMs} words=${words}`
     );
     return {
       ok: true,
@@ -4217,7 +3853,7 @@ async function transcribeVoiceNote(file, source) {
     const elapsed = Date.now() - startMs;
     const reason = err instanceof Error ? err.message : String(err);
     console.error(
-      `${TAG14} failed source=${source} error=${reason} duration_ms=${elapsed}`
+      `${TAG13} failed source=${source} error=${reason} duration_ms=${elapsed}`
     );
     return { ok: false, error: "Voice note transcription failed. Please try again or type your message." };
   } finally {
@@ -4227,10 +3863,10 @@ async function transcribeVoiceNote(file, source) {
 }
 
 // ../lib/oauth-llm/src/index.ts
-import { readFileSync as readFileSync6, writeFileSync as writeFileSync4 } from "fs";
-import { resolve as resolve5 } from "path";
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "fs";
+import { resolve as resolve4 } from "path";
 import { homedir } from "os";
-var CREDENTIALS_FILE = process.env.CLAUDE_CONFIG_DIR ? resolve5(process.env.CLAUDE_CONFIG_DIR, ".credentials.json") : resolve5(homedir(), ".claude", ".credentials.json");
+var CREDENTIALS_FILE = process.env.CLAUDE_CONFIG_DIR ? resolve4(process.env.CLAUDE_CONFIG_DIR, ".credentials.json") : resolve4(homedir(), ".claude", ".credentials.json");
 var TOKEN_ENDPOINT2 = "https://platform.claude.com/v1/oauth/token";
 var ANTHROPIC_MESSAGES_ENDPOINT = "https://api.anthropic.com/v1/messages";
 var ANTHROPIC_VERSION = "2023-06-01";
@@ -4249,7 +3885,7 @@ function isInputTooLargeBody(body) {
 function readCredentials2() {
   let raw;
   try {
-    raw = readFileSync6(CREDENTIALS_FILE, "utf-8");
+    raw = readFileSync5(CREDENTIALS_FILE, "utf-8");
   } catch {
     return null;
   }
@@ -4278,7 +3914,7 @@ function writeCredentials(tokens) {
   const newExpiresAt = typeof tokens.expiresIn === "number" && tokens.expiresIn > 0 ? Date.now() + tokens.expiresIn * 1e3 : Date.now() + 3600 * 1e3;
   let fileData = {};
   try {
-    fileData = JSON.parse(readFileSync6(CREDENTIALS_FILE, "utf-8"));
+    fileData = JSON.parse(readFileSync5(CREDENTIALS_FILE, "utf-8"));
   } catch {
   }
   const existing = fileData.claudeAiOauth;
@@ -4288,7 +3924,7 @@ function writeCredentials(tokens) {
     ...tokens.refreshToken != null ? { refreshToken: tokens.refreshToken } : {},
     expiresAt: newExpiresAt
   };
-  writeFileSync4(CREDENTIALS_FILE, JSON.stringify(fileData, null, 2), "utf-8");
+  writeFileSync3(CREDENTIALS_FILE, JSON.stringify(fileData, null, 2), "utf-8");
   return newExpiresAt;
 }
 var refreshLock2 = null;
@@ -4556,7 +4192,7 @@ var VERDICT_DEFINITIONS = {
 };
 
 // app/lib/inbound-gateway.ts
-var TAG15 = "[inbound-gateway]";
+var TAG14 = "[inbound-gateway]";
 var GATEWAY_TIMEOUT_MS = 1e4;
 var MIN_WORDS_FOR_PROCESSING = 5;
 function defaultResult(rawText, latencyMs) {
@@ -4679,11 +4315,11 @@ async function processInbound(rawText, channel) {
       };
       result.fallthrough = false;
       console.warn(
-        `${TAG15} short-message-injection channel=${channel} words=${words.length} latency_ms=${result.latencyMs}`
+        `${TAG14} short-message-injection channel=${channel} words=${words.length} latency_ms=${result.latencyMs}`
       );
     } else {
       console.log(
-        `${TAG15} passthrough channel=${channel} reason=short-message words=${words.length} latency_ms=${result.latencyMs}`
+        `${TAG14} passthrough channel=${channel} reason=short-message words=${words.length} latency_ms=${result.latencyMs}`
       );
     }
     return result;
@@ -4700,13 +4336,13 @@ async function processInbound(rawText, channel) {
   const latencyMs = Date.now() - startMs;
   if (llmResult.kind === "fallback") {
     console.warn(
-      `${TAG15} fallthrough channel=${channel} reason=${llmResult.cause} detail=${llmResult.reason} latency_ms=${latencyMs}`
+      `${TAG14} fallthrough channel=${channel} reason=${llmResult.cause} detail=${llmResult.reason} latency_ms=${latencyMs}`
     );
     return defaultResult(rawText.trim(), latencyMs);
   }
   if (llmResult.kind !== "ok-tool") {
     console.warn(
-      `${TAG15} fallthrough channel=${channel} reason=no-tool-response latency_ms=${latencyMs}`
+      `${TAG14} fallthrough channel=${channel} reason=no-tool-response latency_ms=${latencyMs}`
     );
     return defaultResult(rawText.trim(), latencyMs);
   }
@@ -4716,7 +4352,7 @@ async function processInbound(rawText, channel) {
     const verdict = input.verdict;
     if (!processedText || !verdict || !["clean", "suspicious", "discard"].includes(verdict)) {
       console.warn(
-        `${TAG15} fallthrough channel=${channel} reason=mandatory-fields-missing latency_ms=${latencyMs} hasProcessedText=${!!processedText} verdict=${String(verdict)}`
+        `${TAG14} fallthrough channel=${channel} reason=mandatory-fields-missing latency_ms=${latencyMs} hasProcessedText=${!!processedText} verdict=${String(verdict)}`
       );
       return defaultResult(rawText.trim(), latencyMs);
     }
@@ -4744,25 +4380,25 @@ async function processInbound(rawText, channel) {
       fallthrough: false
     };
     console.log(
-      `${TAG15} channel=${channel} verdict=${verdict} promptInjection=${promptInjectionRisk} intent=${intent} language=${language} complexity=${complexity} requiresHistory=${requiresHistory} rewrite=${!isAdmin && processedText !== rawText.trim()} searchQuery=${searchQuery ? "yes" : "null"} latency_ms=${latencyMs}`
+      `${TAG14} channel=${channel} verdict=${verdict} promptInjection=${promptInjectionRisk} intent=${intent} language=${language} complexity=${complexity} requiresHistory=${requiresHistory} rewrite=${!isAdmin && processedText !== rawText.trim()} searchQuery=${searchQuery ? "yes" : "null"} latency_ms=${latencyMs}`
     );
     if (verdict !== "clean") {
       console.warn(
-        `${TAG15} ${verdict.toUpperCase()} channel=${channel} reason=${reason} promptInjection=${promptInjectionRisk}`
+        `${TAG14} ${verdict.toUpperCase()} channel=${channel} reason=${reason} promptInjection=${promptInjectionRisk}`
       );
     }
     return result;
   } catch (err) {
     const reason = err instanceof Error ? err.message : String(err);
     console.warn(
-      `${TAG15} fallthrough channel=${channel} reason=parse-error: ${reason} latency_ms=${latencyMs}`
+      `${TAG14} fallthrough channel=${channel} reason=parse-error: ${reason} latency_ms=${latencyMs}`
     );
     return defaultResult(rawText.trim(), latencyMs);
   }
 }
 
 // app/lib/channel-pty-bridge/bridge.ts
-import { resolve as resolve6 } from "path";
+import { resolve as resolve5 } from "path";
 
 // app/lib/channel-pty-bridge/manager-client.ts
 function managerBase() {
@@ -4780,7 +4416,9 @@ async function managerSpawn(opts) {
       accountId: opts.accountId,
       attachmentDir: opts.attachmentDir,
       aboutOwner: opts.aboutOwner,
-      dormantPlugins: opts.dormantPlugins
+      dormantPlugins: opts.dormantPlugins,
+      activePlugins: opts.activePlugins,
+      specialistDomains: opts.specialistDomains
     })
   }).catch((err) => ({ __throw: err instanceof Error ? err.message : String(err) }));
   if ("__throw" in res) {
@@ -4922,7 +4560,7 @@ async function ensureEntry(input) {
     }
     return existing;
   }
-  const attachmentDir = input.role === "public" ? resolve6(ATTACHMENTS_ROOT, "public", input.senderId) : void 0;
+  const attachmentDir = input.role === "public" ? resolve5(ATTACHMENTS_ROOT, "public", input.senderId) : void 0;
   const spawned = await managerSpawn({
     senderId: input.senderId,
     role: input.role,
@@ -5285,14 +4923,14 @@ import { realpathSync as realpathSync2, readdirSync as readdirSync2, readFileSyn
 
 // app/lib/whatsapp/login.ts
 import { randomUUID as randomUUID4 } from "crypto";
-var TAG16 = "[whatsapp:login]";
+var TAG15 = "[whatsapp:login]";
 var ACTIVE_LOGIN_TTL_MS = 3 * 6e4;
 var activeLogins = /* @__PURE__ */ new Map();
 function closeSocket(sock) {
   try {
     sock.ws?.close?.();
   } catch (err) {
-    console.warn(`${TAG16} socket close error during cleanup: ${String(err)}`);
+    console.warn(`${TAG15} socket close error during cleanup: ${String(err)}`);
   }
 }
 function resetActiveLogin(accountId) {
@@ -5315,7 +4953,7 @@ async function loginConnectionLoop(accountId, login) {
       const current = activeLogins.get(accountId);
       if (current?.id === login.id) {
         current.connected = true;
-        console.error(`${TAG16} loginConnectionLoop: connected account=${accountId} attempt=${attempt}`);
+        console.error(`${TAG15} loginConnectionLoop: connected account=${accountId} attempt=${attempt}`);
       }
       return;
     } catch (err) {
@@ -5325,7 +4963,7 @@ async function loginConnectionLoop(accountId, login) {
       if (!classification.shouldRetry || attempt >= LOGIN_MAX_RECONNECTS) {
         if (attempt >= LOGIN_MAX_RECONNECTS) {
           console.error(
-            `${TAG16} login reconnect attempts exhausted (${attempt}/${LOGIN_MAX_RECONNECTS}) \u2014 surfacing error to agent`
+            `${TAG15} login reconnect attempts exhausted (${attempt}/${LOGIN_MAX_RECONNECTS}) \u2014 surfacing error to agent`
           );
           current.error = `Login failed after ${attempt} reconnect attempts: ${formatError(err)}`;
         } else {
@@ -5337,7 +4975,7 @@ async function loginConnectionLoop(accountId, login) {
       attempt++;
       const delay = LOGIN_RECONNECT_DELAYS[attempt - 1] ?? 8e3;
       console.error(
-        `${TAG16} status=${classification.statusCode ?? "unknown"} restart required \u2014 reconnecting with saved creds (attempt ${attempt}/${LOGIN_MAX_RECONNECTS}) delay=${delay}ms`
+        `${TAG15} status=${classification.statusCode ?? "unknown"} restart required \u2014 reconnecting with saved creds (attempt ${attempt}/${LOGIN_MAX_RECONNECTS}) delay=${delay}ms`
       );
       closeSocket(current.sock);
       await new Promise((r) => setTimeout(r, delay));
@@ -5348,7 +4986,7 @@ async function loginConnectionLoop(accountId, login) {
         current.sock = newSock;
       } catch (sockErr) {
         console.error(
-          `${TAG16} reconnect socket creation failed (attempt ${attempt}/${LOGIN_MAX_RECONNECTS}): ${String(sockErr)}`
+          `${TAG15} reconnect socket creation failed (attempt ${attempt}/${LOGIN_MAX_RECONNECTS}): ${String(sockErr)}`
         );
         current.error = `Reconnection failed: ${String(sockErr)}`;
         return;
@@ -5362,7 +5000,7 @@ async function startLogin(opts) {
   const hasAuth = await authExists(authDir);
   const selfId = readSelfId(authDir);
   console.error(
-    `${TAG16} startLogin account=${accountId} force=${!!force} hasAuth=${hasAuth}` + (existing0 ? ` activeLogin={id=${existing0.id.slice(0, 8)},age=${Math.round((Date.now() - existing0.startedAt) / 1e3)}s,hasQr=${!!existing0.qr}}` : " activeLogin=none")
+    `${TAG15} startLogin account=${accountId} force=${!!force} hasAuth=${hasAuth}` + (existing0 ? ` activeLogin={id=${existing0.id.slice(0, 8)},age=${Math.round((Date.now() - existing0.startedAt) / 1e3)}s,hasQr=${!!existing0.qr}}` : " activeLogin=none")
   );
   if (hasAuth && !force) {
     const who = selfId.e164 ?? selfId.jid ?? "unknown";
@@ -5374,7 +5012,7 @@ async function startLogin(opts) {
   await clearAuth(authDir);
   const existing = activeLogins.get(accountId);
   if (existing && isLoginFresh(existing) && existing.qrDataUrl && !force) {
-    console.error(`${TAG16} startLogin account=${accountId} guard: returning existing QR (age=${Math.round((Date.now() - existing.startedAt) / 1e3)}s)`);
+    console.error(`${TAG15} startLogin account=${accountId} guard: returning existing QR (age=${Math.round((Date.now() - existing.startedAt) / 1e3)}s)`);
     return {
       qrDataUrl: existing.qrDataUrl,
       qrRaw: existing.qr,
@@ -5382,7 +5020,7 @@ async function startLogin(opts) {
     };
   }
   if (existing) {
-    console.error(`${TAG16} startLogin account=${accountId} ${force ? "force override" : "stale/no-QR"}, resetting active login`);
+    console.error(`${TAG15} startLogin account=${accountId} ${force ? "force override" : "stale/no-QR"}, resetting active login`);
   }
   resetActiveLogin(accountId);
   let resolveQr = null;
@@ -5399,99 +5037,425 @@ async function startLogin(opts) {
   let pendingQr = null;
   let loginQrCount = 0;
   try {
-    sock = await createWaSocket({
-      authDir,
-      onQr: (qr2) => {
-        loginQrCount++;
-        if (pendingQr) {
-          console.error(`${TAG16} QR rotation #${loginQrCount} received for account=${accountId} \u2014 not forwarded (initial QR already captured)`);
-          return;
-        }
-        pendingQr = qr2;
-        const current = activeLogins.get(accountId);
-        if (current && !current.qr) current.qr = qr2;
-        clearTimeout(qrTimer);
-        console.error(`${TAG16} QR #${loginQrCount} received for account=${accountId} \u2014 forwarding to caller`);
-        resolveQr?.(qr2);
-      }
-    });
+    sock = await createWaSocket({
+      authDir,
+      onQr: (qr2) => {
+        loginQrCount++;
+        if (pendingQr) {
+          console.error(`${TAG15} QR rotation #${loginQrCount} received for account=${accountId} \u2014 not forwarded (initial QR already captured)`);
+          return;
+        }
+        pendingQr = qr2;
+        const current = activeLogins.get(accountId);
+        if (current && !current.qr) current.qr = qr2;
+        clearTimeout(qrTimer);
+        console.error(`${TAG15} QR #${loginQrCount} received for account=${accountId} \u2014 forwarding to caller`);
+        resolveQr?.(qr2);
+      }
+    });
+  } catch (err) {
+    clearTimeout(qrTimer);
+    resetActiveLogin(accountId);
+    return { message: `Failed to start WhatsApp login: ${String(err)}` };
+  }
+  const login = {
+    accountId,
+    authDir,
+    id: randomUUID4(),
+    sock,
+    startedAt: Date.now(),
+    connected: false
+  };
+  activeLogins.set(accountId, login);
+  if (pendingQr && !login.qr) login.qr = pendingQr;
+  loginConnectionLoop(accountId, login).catch((err) => {
+    console.error(`${TAG15} loginConnectionLoop unexpected error: ${String(err)}`);
+    const current = activeLogins.get(accountId);
+    if (current?.id === login.id) {
+      current.error = `Unexpected login error: ${String(err)}`;
+    }
+  });
+  let qr;
+  try {
+    qr = await qrPromise;
+  } catch (err) {
+    clearTimeout(qrTimer);
+    resetActiveLogin(accountId);
+    return { message: `Failed to get QR: ${String(err)}` };
+  }
+  login.qrDataUrl = `qr:${qr}`;
+  return {
+    qrDataUrl: login.qrDataUrl,
+    qrRaw: qr,
+    message: "Scan this QR in WhatsApp \u2192 Linked Devices."
+  };
+}
+async function waitForLogin(opts) {
+  const { accountId, timeoutMs = 6e4 } = opts;
+  const login = activeLogins.get(accountId);
+  console.error(
+    `${TAG15} waitForLogin account=${accountId} timeout=${timeoutMs}ms` + (login ? ` login={id=${login.id.slice(0, 8)},age=${Math.round((Date.now() - login.startedAt) / 1e3)}s,connected=${login.connected},hasQr=${!!login.qr}}` : " login=none")
+  );
+  if (!login) {
+    return { connected: false, message: "No active WhatsApp login in progress." };
+  }
+  if (!isLoginFresh(login)) {
+    resetActiveLogin(accountId);
+    return { connected: false, message: "The login QR expired. Ask me to generate a new one." };
+  }
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (login.connected) {
+      const selfId = readSelfId(login.authDir);
+      console.error(`${TAG15} login complete for account=${accountId} phone=${selfId.e164 ?? "unknown"}`);
+      const sock = login.sock;
+      const authDir = login.authDir;
+      activeLogins.delete(accountId);
+      return {
+        connected: true,
+        message: `WhatsApp connected as ${selfId.e164 ?? selfId.jid ?? "unknown"}.`,
+        selfPhone: selfId.e164 ?? void 0,
+        sock,
+        authDir
+      };
+    }
+    if (login.error) {
+      const msg = login.error;
+      resetActiveLogin(accountId);
+      return { connected: false, message: `WhatsApp login failed: ${msg}` };
+    }
+    await new Promise((r) => setTimeout(r, 1e3));
+  }
+  const elapsed = Math.round((Date.now() - (deadline - timeoutMs)) / 1e3);
+  console.error(`${TAG15} waitForLogin timeout account=${accountId} elapsed=${elapsed}s \u2014 cleaning up active login`);
+  resetActiveLogin(accountId);
+  return { connected: false, message: "Login timed out. Try generating a new QR." };
+}
+
+// app/lib/whatsapp/config-persist.ts
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync4, existsSync as existsSync3 } from "fs";
+import { resolve as resolve6, join as join4 } from "path";
+var TAG16 = "[whatsapp:config]";
+function configPath(accountDir) {
+  return resolve6(accountDir, "account.json");
+}
+function readConfig(accountDir) {
+  const path2 = configPath(accountDir);
+  if (!existsSync3(path2)) throw new Error(`account.json not found at ${path2}`);
+  return JSON.parse(readFileSync6(path2, "utf-8"));
+}
+function writeConfig(accountDir, config) {
+  const path2 = configPath(accountDir);
+  writeFileSync4(path2, JSON.stringify(config, null, 2) + "\n", "utf-8");
+}
+function reloadManagerConfig(accountDir) {
+  try {
+    const config = readConfig(accountDir);
+    reloadConfig(config);
+    console.error(`${TAG16} reloaded manager config`);
+  } catch (err) {
+    console.error(`${TAG16} manager config reload failed: ${String(err)}`);
+  }
+}
+var E164_PATTERN = /^\+\d{7,15}$/;
+function persistAfterPairing(accountDir, accountId, selfPhone) {
+  try {
+    const config = readConfig(accountDir);
+    if (!config.whatsapp || typeof config.whatsapp !== "object") {
+      config.whatsapp = {};
+    }
+    const wa = config.whatsapp;
+    if (!wa.accounts || typeof wa.accounts !== "object") {
+      wa.accounts = {};
+    }
+    const accounts = wa.accounts;
+    if (!accounts[accountId] || typeof accounts[accountId] !== "object") {
+      accounts[accountId] = { name: "Main" };
+    }
+    if (selfPhone) {
+      const normalized = selfPhone.startsWith("+") ? selfPhone : `+${selfPhone}`;
+      if (!Array.isArray(wa.adminPhones)) {
+        wa.adminPhones = [];
+      }
+      const adminPhones = wa.adminPhones;
+      if (!adminPhones.includes(normalized)) {
+        adminPhones.push(normalized);
+        console.error(`${TAG16} added selfPhone=${normalized} to adminPhones`);
+      }
+    } else {
+      console.error(`${TAG16} skipping adminPhones \u2014 selfPhone is null account=${accountId}`);
+    }
+    const parsed = WhatsAppConfigSchema.safeParse(wa);
+    if (!parsed.success) {
+      const msg = parsed.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ");
+      console.error(`${TAG16} validation failed after pairing: ${msg}`);
+      return { ok: false, error: `Validation failed: ${msg}` };
+    }
+    config.whatsapp = parsed.data;
+    writeConfig(accountDir, config);
+    console.error(`${TAG16} persisted after pairing account=${accountId} phone=${selfPhone ?? "null"}`);
+    reloadManagerConfig(accountDir);
+    return { ok: true };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(`${TAG16} persist failed account=${accountId}: ${msg}`);
+    return { ok: false, error: msg };
+  }
+}
+function addAdminPhone(accountDir, phone) {
+  const normalized = phone.trim();
+  if (!E164_PATTERN.test(normalized)) {
+    return { ok: false, error: `Invalid phone format "${normalized}". Expected E.164 (e.g. +441234567890).` };
+  }
+  try {
+    const config = readConfig(accountDir);
+    if (!config.whatsapp || typeof config.whatsapp !== "object") {
+      config.whatsapp = {};
+    }
+    const wa = config.whatsapp;
+    if (!Array.isArray(wa.adminPhones)) {
+      wa.adminPhones = [];
+    }
+    const adminPhones = wa.adminPhones;
+    if (adminPhones.includes(normalized)) {
+      return { ok: true, message: `Phone ${normalized} is already in the admin list.` };
+    }
+    adminPhones.push(normalized);
+    const parsed = WhatsAppConfigSchema.safeParse(wa);
+    if (!parsed.success) {
+      const msg = parsed.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ");
+      return { ok: false, error: `Validation failed: ${msg}` };
+    }
+    config.whatsapp = parsed.data;
+    writeConfig(accountDir, config);
+    console.error(`${TAG16} added admin phone=${normalized}`);
+    reloadManagerConfig(accountDir);
+    return { ok: true, message: `Added ${normalized} as admin phone. Messages from this number will route to the admin agent.` };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(`${TAG16} addAdminPhone failed: ${msg}`);
+    return { ok: false, error: msg };
+  }
+}
+function removeAdminPhone(accountDir, phone) {
+  const normalized = phone.trim();
+  try {
+    const config = readConfig(accountDir);
+    if (!config.whatsapp || typeof config.whatsapp !== "object") {
+      return { ok: true, message: `No WhatsApp config exists \u2014 nothing to remove.` };
+    }
+    const wa = config.whatsapp;
+    if (!Array.isArray(wa.adminPhones)) {
+      return { ok: true, message: `No admin phones configured \u2014 nothing to remove.` };
+    }
+    const adminPhones = wa.adminPhones;
+    const idx = adminPhones.indexOf(normalized);
+    if (idx === -1) {
+      return { ok: true, message: `Phone ${normalized} is not in the admin list.` };
+    }
+    adminPhones.splice(idx, 1);
+    const parsed = WhatsAppConfigSchema.safeParse(wa);
+    if (!parsed.success) {
+      const msg = parsed.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ");
+      return { ok: false, error: `Validation failed: ${msg}` };
+    }
+    config.whatsapp = parsed.data;
+    writeConfig(accountDir, config);
+    console.error(`${TAG16} removed admin phone=${normalized}`);
+    reloadManagerConfig(accountDir);
+    return { ok: true, message: `Removed ${normalized} from admin phones. Messages from this number will now route to the public agent.` };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(`${TAG16} removeAdminPhone failed: ${msg}`);
+    return { ok: false, error: msg };
+  }
+}
+function readAdminPhones(accountDir) {
+  try {
+    const config = readConfig(accountDir);
+    const wa = config.whatsapp;
+    if (!wa) return [];
+    if (!Array.isArray(wa.adminPhones)) return [];
+    return wa.adminPhones.filter((p) => typeof p === "string");
+  } catch {
+    return [];
+  }
+}
+function setPublicAgent(accountDir, slug) {
+  const trimmed = slug.trim();
+  if (!trimmed) {
+    return { ok: false, error: "Agent slug cannot be empty." };
+  }
+  const agentConfigPath = join4(accountDir, "agents", trimmed, "config.json");
+  if (!existsSync3(agentConfigPath)) {
+    return { ok: false, error: `Agent "${trimmed}" not found \u2014 no config.json at ${agentConfigPath}. Check the agent slug and try again.` };
+  }
+  try {
+    const config = readConfig(accountDir);
+    if (!config.whatsapp || typeof config.whatsapp !== "object") {
+      config.whatsapp = {};
+    }
+    const wa = config.whatsapp;
+    wa.publicAgent = trimmed;
+    const parsed = WhatsAppConfigSchema.safeParse(wa);
+    if (!parsed.success) {
+      const msg = parsed.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ");
+      return { ok: false, error: `Validation failed: ${msg}` };
+    }
+    config.whatsapp = parsed.data;
+    writeConfig(accountDir, config);
+    console.error(`${TAG16} publicAgent set to ${trimmed}`);
+    reloadManagerConfig(accountDir);
+    return { ok: true, message: `Public agent set to "${trimmed}". WhatsApp messages from non-admin phones will be handled by this agent.` };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(`${TAG16} setPublicAgent failed: ${msg}`);
+    return { ok: false, error: msg };
+  }
+}
+function resolvePublicAgent(accountDir, opts) {
+  try {
+    const config = readConfig(accountDir);
+    const wa = config.whatsapp;
+    if (!wa) return null;
+    if (opts.groupJid) {
+      const accounts2 = wa.accounts;
+      const account2 = accounts2?.[opts.accountId];
+      const groups = account2?.groups;
+      const group = groups?.[opts.groupJid];
+      const groupSlug = group?.publicAgent;
+      if (typeof groupSlug === "string" && groupSlug.trim()) {
+        return { slug: groupSlug.trim(), source: "group" };
+      }
+    }
+    const accounts = wa.accounts;
+    const account = accounts?.[opts.accountId];
+    const accountSlug = account?.publicAgent;
+    if (typeof accountSlug === "string" && accountSlug.trim()) {
+      return { slug: accountSlug.trim(), source: "account" };
+    }
+    const topSlug = wa.publicAgent;
+    if (typeof topSlug === "string" && topSlug.trim()) {
+      return { slug: topSlug.trim(), source: "top-level" };
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function setGroupPublicAgent(accountDir, accountId, groupJid, slug) {
+  const trimmedSlug = slug.trim();
+  const trimmedGroup = groupJid.trim();
+  const trimmedAccount = accountId.trim();
+  if (!trimmedSlug) return { ok: false, error: "Agent slug cannot be empty." };
+  if (!trimmedGroup) return { ok: false, error: "Group JID cannot be empty." };
+  if (!trimmedAccount) return { ok: false, error: "Account ID cannot be empty." };
+  const agentConfigPath = join4(accountDir, "agents", trimmedSlug, "config.json");
+  if (!existsSync3(agentConfigPath)) {
+    return { ok: false, error: `Agent "${trimmedSlug}" not found \u2014 no config.json at ${agentConfigPath}. Check the agent slug and try again.` };
+  }
+  try {
+    const config = readConfig(accountDir);
+    if (!config.whatsapp || typeof config.whatsapp !== "object") config.whatsapp = {};
+    const wa = config.whatsapp;
+    if (!wa.accounts || typeof wa.accounts !== "object") wa.accounts = {};
+    const accounts = wa.accounts;
+    if (!accounts[trimmedAccount] || typeof accounts[trimmedAccount] !== "object") accounts[trimmedAccount] = {};
+    const account = accounts[trimmedAccount];
+    if (!account.groups || typeof account.groups !== "object") account.groups = {};
+    const groups = account.groups;
+    const existing = groups[trimmedGroup] && typeof groups[trimmedGroup] === "object" ? groups[trimmedGroup] : {};
+    groups[trimmedGroup] = { ...existing, publicAgent: trimmedSlug };
+    const parsed = WhatsAppConfigSchema.safeParse(wa);
+    if (!parsed.success) {
+      const msg = parsed.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ");
+      return { ok: false, error: `Validation failed: ${msg}` };
+    }
+    config.whatsapp = parsed.data;
+    writeConfig(accountDir, config);
+    console.error(`${TAG16} setGroupPublicAgent account=${trimmedAccount} groupJid=${trimmedGroup} slug=${trimmedSlug}`);
+    reloadManagerConfig(accountDir);
+    return { ok: true, message: `Per-group public agent set to "${trimmedSlug}" for group ${trimmedGroup}.` };
   } catch (err) {
-    clearTimeout(qrTimer);
-    resetActiveLogin(accountId);
-    return { message: `Failed to start WhatsApp login: ${String(err)}` };
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(`${TAG16} setGroupPublicAgent failed: ${msg}`);
+    return { ok: false, error: msg };
   }
-  const login = {
-    accountId,
-    authDir,
-    id: randomUUID4(),
-    sock,
-    startedAt: Date.now(),
-    connected: false
-  };
-  activeLogins.set(accountId, login);
-  if (pendingQr && !login.qr) login.qr = pendingQr;
-  loginConnectionLoop(accountId, login).catch((err) => {
-    console.error(`${TAG16} loginConnectionLoop unexpected error: ${String(err)}`);
-    const current = activeLogins.get(accountId);
-    if (current?.id === login.id) {
-      current.error = `Unexpected login error: ${String(err)}`;
-    }
-  });
-  let qr;
+}
+function unsetGroupPublicAgent(accountDir, accountId, groupJid) {
+  const trimmedGroup = groupJid.trim();
+  const trimmedAccount = accountId.trim();
+  if (!trimmedGroup) return { ok: false, error: "Group JID cannot be empty." };
+  if (!trimmedAccount) return { ok: false, error: "Account ID cannot be empty." };
   try {
-    qr = await qrPromise;
+    const config = readConfig(accountDir);
+    const wa = config.whatsapp ?? {};
+    const accounts = wa.accounts;
+    const account = accounts?.[trimmedAccount];
+    const groups = account?.groups;
+    const group = groups?.[trimmedGroup];
+    if (!group || typeof group.publicAgent !== "string") {
+      return { ok: true, message: `No per-group publicAgent override for group ${trimmedGroup}; nothing to remove.` };
+    }
+    delete group.publicAgent;
+    const parsed = WhatsAppConfigSchema.safeParse(wa);
+    if (!parsed.success) {
+      const msg = parsed.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ");
+      return { ok: false, error: `Validation failed: ${msg}` };
+    }
+    config.whatsapp = parsed.data;
+    writeConfig(accountDir, config);
+    console.error(`${TAG16} unsetGroupPublicAgent account=${trimmedAccount} groupJid=${trimmedGroup}`);
+    reloadManagerConfig(accountDir);
+    return { ok: true, message: `Per-group public agent override removed for group ${trimmedGroup}.` };
   } catch (err) {
-    clearTimeout(qrTimer);
-    resetActiveLogin(accountId);
-    return { message: `Failed to get QR: ${String(err)}` };
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(`${TAG16} unsetGroupPublicAgent failed: ${msg}`);
+    return { ok: false, error: msg };
   }
-  login.qrDataUrl = `qr:${qr}`;
-  return {
-    qrDataUrl: login.qrDataUrl,
-    qrRaw: qr,
-    message: "Scan this QR in WhatsApp \u2192 Linked Devices."
-  };
 }
-async function waitForLogin(opts) {
-  const { accountId, timeoutMs = 6e4 } = opts;
-  const login = activeLogins.get(accountId);
-  console.error(
-    `${TAG16} waitForLogin account=${accountId} timeout=${timeoutMs}ms` + (login ? ` login={id=${login.id.slice(0, 8)},age=${Math.round((Date.now() - login.startedAt) / 1e3)}s,connected=${login.connected},hasQr=${!!login.qr}}` : " login=none")
-  );
-  if (!login) {
-    return { connected: false, message: "No active WhatsApp login in progress." };
-  }
-  if (!isLoginFresh(login)) {
-    resetActiveLogin(accountId);
-    return { connected: false, message: "The login QR expired. Ask me to generate a new one." };
+function updateConfig(accountDir, fields) {
+  const fieldNames = Object.keys(fields);
+  if (fieldNames.length === 0) {
+    return { ok: false, error: "No fields provided to update." };
   }
-  const deadline = Date.now() + timeoutMs;
-  while (Date.now() < deadline) {
-    if (login.connected) {
-      const selfId = readSelfId(login.authDir);
-      console.error(`${TAG16} login complete for account=${accountId} phone=${selfId.e164 ?? "unknown"}`);
-      const sock = login.sock;
-      const authDir = login.authDir;
-      activeLogins.delete(accountId);
-      return {
-        connected: true,
-        message: `WhatsApp connected as ${selfId.e164 ?? selfId.jid ?? "unknown"}.`,
-        selfPhone: selfId.e164 ?? void 0,
-        sock,
-        authDir
-      };
+  try {
+    const config = readConfig(accountDir);
+    if (!config.whatsapp || typeof config.whatsapp !== "object") {
+      config.whatsapp = {};
     }
-    if (login.error) {
-      const msg = login.error;
-      resetActiveLogin(accountId);
-      return { connected: false, message: `WhatsApp login failed: ${msg}` };
+    const wa = config.whatsapp;
+    for (const [key, value] of Object.entries(fields)) {
+      wa[key] = value;
     }
-    await new Promise((r) => setTimeout(r, 1e3));
+    const parsed = WhatsAppConfigSchema.safeParse(wa);
+    if (!parsed.success) {
+      const msg = parsed.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ");
+      console.error(`${TAG16} update validation failed: ${msg}`);
+      return { ok: false, error: `Validation failed: ${msg}` };
+    }
+    config.whatsapp = parsed.data;
+    writeConfig(accountDir, config);
+    console.error(`${TAG16} updated fields=[${fieldNames.join(",")}]`);
+    reloadManagerConfig(accountDir);
+    return { ok: true, message: `Updated WhatsApp config: ${fieldNames.join(", ")}.` };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(`${TAG16} updateConfig failed: ${msg}`);
+    return { ok: false, error: msg };
+  }
+}
+function getConfig(accountDir) {
+  try {
+    const config = readConfig(accountDir);
+    const wa = config.whatsapp;
+    if (!wa) return null;
+    const parsed = WhatsAppConfigSchema.safeParse(wa);
+    if (!parsed.success) return wa;
+    return parsed.data;
+  } catch {
+    return null;
   }
-  const elapsed = Math.round((Date.now() - (deadline - timeoutMs)) / 1e3);
-  console.error(`${TAG16} waitForLogin timeout account=${accountId} elapsed=${elapsed}s \u2014 cleaning up active login`);
-  resetActiveLogin(accountId);
-  return { connected: false, message: "Login timed out. Try generating a new QR." };
 }
 
 // app/lib/whatsapp/validate.ts
@@ -7886,8 +7850,8 @@ app14.put("/:id/label", requireAdminSession, async (c) => {
 var sessions_default = app14;
 
 // app/lib/claude-agent/spawn-context.ts
-import { existsSync as existsSync14, readFileSync as readFileSync13, readdirSync as readdirSync7 } from "fs";
-import { resolve as resolve11 } from "path";
+import { existsSync as existsSync14, readFileSync as readFileSync13, readdirSync as readdirSync7, statSync as statSync6 } from "fs";
+import { dirname as dirname2, resolve as resolve11, join as join10 } from "path";
 async function resolveOwnerProfileBlock(accountId, userId) {
   if (!userId) return { ok: false, reason: "missing-user-id" };
   try {
@@ -7913,6 +7877,213 @@ function frontmatterField(manifest, field) {
   }
   return value || null;
 }
+function extractPluginToolDescriptions(pluginDir) {
+  const out = /* @__PURE__ */ new Map();
+  const candidates = [
+    join10(pluginDir, "mcp/dist/index.js"),
+    join10(pluginDir, "mcp/src/index.ts")
+  ];
+  let raw = null;
+  for (const path2 of candidates) {
+    if (!existsSync14(path2)) continue;
+    try {
+      raw = readFileSync13(path2, "utf-8");
+      break;
+    } catch {
+    }
+  }
+  if (!raw) return out;
+  const re = /(?:server\.tool\(|eagerTool\(\s*server\s*,)\s*"((?:[^"\\]|\\.)*)"\s*,\s*"((?:[^"\\]|\\.)*)"/g;
+  let m;
+  while ((m = re.exec(raw)) !== null) {
+    const name = m[1];
+    const desc = m[2].replace(/\\n/g, " ").replace(/\\"/g, '"').replace(/\\\\/g, "\\").replace(/\s+/g, " ").trim();
+    if (name && desc && !out.has(name)) out.set(name, desc);
+  }
+  return out;
+}
+function parseToolNamesFromFrontmatter(fm) {
+  const lines = fm.split(/\r?\n/);
+  let i = 0;
+  while (i < lines.length && !/^tools:\s*$/.test(lines[i])) i++;
+  if (i >= lines.length) return [];
+  i++;
+  const out = [];
+  for (; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.length === 0) continue;
+    if (/^[A-Za-z_]/.test(line)) break;
+    const m = line.match(/^\s+-\s+name:\s*(.+?)\s*$/);
+    if (m) out.push(m[1]);
+  }
+  return out;
+}
+function parseSkillPathsFromFrontmatter(fm) {
+  const lines = fm.split(/\r?\n/);
+  let i = 0;
+  while (i < lines.length && !/^skills:\s*$/.test(lines[i])) i++;
+  if (i >= lines.length) return [];
+  i++;
+  const out = [];
+  for (; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.length === 0) continue;
+    if (/^[A-Za-z_]/.test(line)) break;
+    const m = line.match(/^\s+-\s+(.+?)\s*$/);
+    if (m) out.push(m[1]);
+  }
+  return out;
+}
+function listPluginDirs() {
+  const out = /* @__PURE__ */ new Map();
+  const platformPlugins = resolve11(PLATFORM_ROOT, "plugins");
+  if (existsSync14(platformPlugins)) {
+    for (const name of readdirSync7(platformPlugins)) {
+      const dir = join10(platformPlugins, name);
+      try {
+        if (statSync6(dir).isDirectory()) out.set(name, dir);
+      } catch {
+      }
+    }
+  }
+  const premiumRoot = resolve11(dirname2(PLATFORM_ROOT), "premium-plugins");
+  if (existsSync14(premiumRoot)) {
+    for (const bundle of readdirSync7(premiumRoot)) {
+      const bundlePlugins = join10(premiumRoot, bundle, "plugins");
+      if (!existsSync14(bundlePlugins)) continue;
+      try {
+        for (const name of readdirSync7(bundlePlugins)) {
+          const dir = join10(bundlePlugins, name);
+          try {
+            if (statSync6(dir).isDirectory()) out.set(name, dir);
+          } catch {
+          }
+        }
+      } catch {
+      }
+    }
+  }
+  return out;
+}
+function readEnabledPlugins(accountId) {
+  const accountFile = resolve11(PLATFORM_ROOT, "..", "data/accounts", accountId, "account.json");
+  if (!existsSync14(accountFile)) return /* @__PURE__ */ new Set();
+  try {
+    const parsed = JSON.parse(readFileSync13(accountFile, "utf-8"));
+    return new Set(
+      Array.isArray(parsed.enabledPlugins) ? parsed.enabledPlugins.filter((p) => typeof p === "string") : []
+    );
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+}
+function readFrontmatter(path2) {
+  if (!existsSync14(path2)) return null;
+  let raw;
+  try {
+    raw = readFileSync13(path2, "utf-8");
+  } catch {
+    return null;
+  }
+  const m = raw.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  return m ? m[1] : null;
+}
+function computeActivePlugins(accountId) {
+  const enabled = readEnabledPlugins(accountId);
+  if (enabled.size === 0) return [];
+  const pluginDirs = listPluginDirs();
+  const out = [];
+  for (const name of Array.from(enabled).sort()) {
+    const dir = pluginDirs.get(name);
+    if (!dir) continue;
+    const fm = readFrontmatter(join10(dir, "PLUGIN.md"));
+    if (!fm) continue;
+    const description = frontmatterField(`---
+${fm}
+---`, "description");
+    if (!description) continue;
+    const toolNames = parseToolNamesFromFrontmatter(fm);
+    const descMap = extractPluginToolDescriptions(dir);
+    const tools = toolNames.map((n) => {
+      const d = descMap.get(n);
+      return d ? { name: n, description: d } : { name: n };
+    });
+    const withDesc = tools.filter((t) => t.description).length;
+    console.log(
+      `plugin-manifest-tool-coverage plugin=${name} tools=${tools.length} with-desc=${withDesc}`
+    );
+    if (toolNames.length > 0 && descMap.size === 0) {
+      const hasSource = existsSync14(join10(dir, "mcp/dist/index.js")) || existsSync14(join10(dir, "mcp/src/index.ts"));
+      if (hasSource) {
+        console.warn(
+          `[spawn-context] WARN plugin=${name} mcp source present but tool-description regex matched zero entries \u2014 SDK upgrade may have changed the registration shape`
+        );
+      }
+    }
+    const skillPaths = parseSkillPathsFromFrontmatter(fm);
+    const skills = [];
+    for (const relPath2 of skillPaths) {
+      const skillPath = join10(dir, relPath2);
+      const skillFm = readFrontmatter(skillPath);
+      if (!skillFm) continue;
+      const skillName = frontmatterField(`---
+${skillFm}
+---`, "name") ?? relPath2;
+      const skillDesc = frontmatterField(`---
+${skillFm}
+---`, "description");
+      skills.push(skillDesc ? { name: skillName, description: skillDesc } : { name: skillName });
+    }
+    out.push({ name, description, tools, skills });
+  }
+  return out;
+}
+function computeSpecialistDomains(accountId) {
+  const specialistsDir = resolve11(PLATFORM_ROOT, "..", "data/accounts", accountId, "specialists", "agents");
+  if (!existsSync14(specialistsDir)) return [];
+  let entries;
+  try {
+    entries = readdirSync7(specialistsDir);
+  } catch {
+    return [];
+  }
+  const pluginDirs = listPluginDirs();
+  const descByPlugin = /* @__PURE__ */ new Map();
+  const resolveDesc = (qualified) => {
+    if (!qualified.startsWith("mcp__")) return void 0;
+    const rest = qualified.slice(5);
+    const sep4 = rest.indexOf("__");
+    if (sep4 < 0) return void 0;
+    const plugin = rest.slice(0, sep4);
+    const tool = rest.slice(sep4 + 2);
+    let map = descByPlugin.get(plugin);
+    if (!map) {
+      const dir = pluginDirs.get(plugin);
+      map = dir ? extractPluginToolDescriptions(dir) : /* @__PURE__ */ new Map();
+      descByPlugin.set(plugin, map);
+    }
+    return map.get(tool);
+  };
+  const out = [];
+  for (const file of entries.sort()) {
+    if (!file.endsWith(".md")) continue;
+    const fm = readFrontmatter(join10(specialistsDir, file));
+    if (!fm) continue;
+    const wrapped = `---
+${fm}
+---`;
+    const name = frontmatterField(wrapped, "name");
+    const description = frontmatterField(wrapped, "description");
+    if (!name || !description) continue;
+    const toolsRaw = frontmatterField(wrapped, "tools") ?? "";
+    const tools = toolsRaw.split(",").map((t) => t.trim()).filter((t) => t.length > 0).map((t) => {
+      const d = resolveDesc(t);
+      return d ? { name: t, description: d } : { name: t };
+    });
+    out.push({ name, description, tools });
+  }
+  return out;
+}
 function computeDormantPlugins(accountId) {
   const accountFile = resolve11(PLATFORM_ROOT, "..", "data/accounts", accountId, "account.json");
   if (!existsSync14(accountFile)) return [];
@@ -8007,6 +8178,12 @@ app15.post("/", async (c) => {
   const dormantStart = Date.now();
   const dormantPlugins = computeDormantPlugins(senderId);
   console.log(`${TAG18} dormant-plugins-computed count=${Array.isArray(dormantPlugins) ? dormantPlugins.length : 0} ms=${Date.now() - dormantStart}`);
+  const activeStart = Date.now();
+  const activePlugins = computeActivePlugins(senderId);
+  console.log(`${TAG18} active-plugins-computed count=${activePlugins.length} ms=${Date.now() - activeStart}`);
+  const specStart = Date.now();
+  const specialistDomains = computeSpecialistDomains(senderId);
+  console.log(`${TAG18} specialist-domains-computed count=${specialistDomains.length} ms=${Date.now() - specStart}`);
   const tunnelUrl = resolveTunnelUrl();
   console.log(`${TAG18} tunnel-url-resolved value=${tunnelUrl ?? "null"}`);
   const forwardStart = Date.now();
@@ -8017,6 +8194,8 @@ app15.post("/", async (c) => {
     permissionMode,
     aboutOwner,
     dormantPlugins,
+    activePlugins,
+    specialistDomains,
     tunnelUrl
   });
   console.log(`${TAG18} forward-spawn-start managerBase=${managerBase2()} bytes=${upstreamPayload.length}`);
@@ -8048,6 +8227,24 @@ app15.post("/", async (c) => {
   }
   return new Response(upstream.body, { status: upstream.status, headers: upstream.headers });
 });
+app15.get("/events", async (c) => {
+  const upstream = await fetch(`${managerBase2()}/events`, {
+    headers: { accept: "text/event-stream" }
+  }).catch((err) => {
+    console.error(`${TAG18} fetch-failed op=events message=${err instanceof Error ? err.message : String(err)}`);
+    return null;
+  });
+  if (!upstream || !upstream.body) return c.json({ error: "manager-unreachable" }, 503);
+  return new Response(upstream.body, {
+    status: upstream.status,
+    headers: {
+      "content-type": "text/event-stream",
+      "cache-control": "no-cache, no-transform",
+      "x-accel-buffering": "no",
+      connection: "keep-alive"
+    }
+  });
+});
 app15.get("/", async (c) => {
   const cacheKey = c.get("cacheKey") ?? "";
   const senderId = getAccountIdForSession(cacheKey) ?? "";
@@ -8078,6 +8275,8 @@ app15.post("/resume", async (c) => {
   const channel = typeof body.channel === "string" ? body.channel : "browser";
   const aboutOwner = await resolveOwnerProfileBlock(senderId, userId);
   const dormantPlugins = computeDormantPlugins(senderId);
+  const activePlugins = computeActivePlugins(senderId);
+  const specialistDomains = computeSpecialistDomains(senderId);
   const tunnelUrl = resolveTunnelUrl();
   const upstream = await fetch(`${managerBase2()}/resume`, {
     method: "POST",
@@ -8089,6 +8288,8 @@ app15.post("/resume", async (c) => {
       claudeSessionId: body.claudeSessionId,
       aboutOwner,
       dormantPlugins,
+      activePlugins,
+      specialistDomains,
       tunnelUrl
     })
   }).catch((err) => {
@@ -8098,11 +8299,22 @@ app15.post("/resume", async (c) => {
   if (!upstream) return c.json({ error: "manager-unreachable" }, 503);
   return new Response(upstream.body, { status: upstream.status, headers: upstream.headers });
 });
+app15.post("/:sessionId/stop", async (c) => {
+  const sessionId = c.req.param("sessionId");
+  const upstream = await fetch(
+    `${managerBase2()}/${encodeURIComponent(sessionId)}/stop`,
+    { method: "POST" }
+  ).catch((err) => {
+    console.error(`${TAG18} fetch-failed op=stop message=${err instanceof Error ? err.message : String(err)}`);
+    return null;
+  });
+  if (!upstream) return c.json({ error: "manager-unreachable" }, 503);
+  return new Response(upstream.body, { status: upstream.status, headers: upstream.headers });
+});
 app15.delete("/:sessionId", async (c) => {
   const sessionId = c.req.param("sessionId");
-  const purge = c.req.query("purge") === "1" ? "?purge=1" : "";
   const upstream = await fetch(
-    `${managerBase2()}/${encodeURIComponent(sessionId)}${purge}`,
+    `${managerBase2()}/${encodeURIComponent(sessionId)}`,
     { method: "DELETE" }
   ).catch((err) => {
     console.error(`${TAG18} fetch-failed op=delete message=${err instanceof Error ? err.message : String(err)}`);
@@ -8444,7 +8656,7 @@ function isValidDomain(value) {
 
 // app/lib/alias-domains.ts
 import { existsSync as existsSync15, mkdirSync as mkdirSync4, readFileSync as readFileSync15, writeFileSync as writeFileSync8 } from "fs";
-import { dirname as dirname2 } from "path";
+import { dirname as dirname3 } from "path";
 import { resolve as resolve13 } from "path";
 var ALIAS_DOMAINS_PATH = resolve13(MAXY_DIR, "alias-domains.json");
 function readExisting() {
@@ -8461,14 +8673,14 @@ function addAliasDomain(hostname2) {
   const existing = readExisting();
   if (existing.has(hostname2)) return;
   existing.add(hostname2);
-  mkdirSync4(dirname2(ALIAS_DOMAINS_PATH), { recursive: true });
+  mkdirSync4(dirname3(ALIAS_DOMAINS_PATH), { recursive: true });
   writeFileSync8(ALIAS_DOMAINS_PATH, JSON.stringify([...existing], null, 2) + "\n", "utf-8");
 }
 
 // app/lib/script-stream-tailer.ts
 import * as childProcess from "child_process";
-import { appendFileSync as appendFileSync2, createReadStream as createReadStream2, mkdirSync as mkdirSync5, statSync as statSync6 } from "fs";
-import { dirname as dirname3 } from "path";
+import { appendFileSync as appendFileSync2, createReadStream as createReadStream2, mkdirSync as mkdirSync5, statSync as statSync7 } from "fs";
+import { dirname as dirname4 } from "path";
 import { StringDecoder } from "string_decoder";
 var SCRIPT_STREAM_RE = /^\[([^\]]+)\] \[script:([a-z][a-z0-9-]*)((?::[a-z0-9:_-]+)?)\] (.*)$/;
 function parseLine(line) {
@@ -8486,7 +8698,7 @@ function startScriptStreamTailer(opts) {
   const { path: path2, onEvent, onError } = opts;
   let offset;
   try {
-    offset = statSync6(path2).size;
+    offset = statSync7(path2).size;
   } catch {
     offset = 0;
   }
@@ -8505,7 +8717,7 @@ function startScriptStreamTailer(opts) {
     try {
       let size;
       try {
-        size = statSync6(path2).size;
+        size = statSync7(path2).size;
       } catch {
         return;
       }
@@ -8577,7 +8789,7 @@ function writeRouteMilestone(streamLogPath, scope, line) {
   }
   const ts = (/* @__PURE__ */ new Date()).toISOString();
   try {
-    mkdirSync5(dirname3(streamLogPath), { recursive: true });
+    mkdirSync5(dirname4(streamLogPath), { recursive: true });
     appendFileSync2(streamLogPath, `[${ts}] [script:${scope}] ${line}
 `);
   } catch (err) {
@@ -9295,7 +9507,7 @@ var cloudflare_default = app20;
 import { createReadStream as createReadStream3 } from "fs";
 import { readdir as readdir2, readFile as readFile4, stat as stat4, mkdir as mkdir3, writeFile as writeFile4, unlink as unlink2 } from "fs/promises";
 import { realpathSync as realpathSync4 } from "fs";
-import { basename as basename4, dirname as dirname4, join as join10, resolve as resolve16, sep as sep3 } from "path";
+import { basename as basename4, dirname as dirname5, join as join11, resolve as resolve16, sep as sep3 } from "path";
 import { Readable as Readable2 } from "stream";
 
 // app/lib/data-path.ts
@@ -9652,7 +9864,7 @@ async function cascadeDeleteDocument(params) {
 var UUID_RE4 = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 async function readMeta(absDir, baseName) {
   try {
-    const raw = await readFile4(join10(absDir, `${baseName}.meta.json`), "utf8");
+    const raw = await readFile4(join11(absDir, `${baseName}.meta.json`), "utf8");
     const parsed = JSON.parse(raw);
     if (typeof parsed?.filename === "string") {
       return { filename: parsed.filename, mimeType: typeof parsed.mimeType === "string" ? parsed.mimeType : void 0 };
@@ -9690,7 +9902,7 @@ async function readAccountNames() {
 }
 async function enrich(absolute, entry, accountNames) {
   if (entry.kind === "directory" && UUID_RE4.test(entry.name)) {
-    const meta = await readMeta(join10(absolute, entry.name), entry.name);
+    const meta = await readMeta(join11(absolute, entry.name), entry.name);
     if (meta?.filename) {
       entry.displayName = meta.filename;
       entry.mimeType = meta.mimeType;
@@ -9749,7 +9961,7 @@ app21.get("/", requireAdminSession, async (c) => {
         continue;
       }
       try {
-        const entryPath = join10(absolute, name);
+        const entryPath = join11(absolute, name);
         const s = await stat4(entryPath);
         entries.push({
           name,
@@ -9922,7 +10134,7 @@ app21.delete("/", requireAdminSession, async (c) => {
     }
     const dot = base.lastIndexOf(".");
     const stem = dot === -1 ? base : base.slice(0, dot);
-    const sidecarPath = UUID_RE4.test(stem) && base !== `${stem}.meta.json` ? join10(dirname4(absolute), `${stem}.meta.json`) : null;
+    const sidecarPath = UUID_RE4.test(stem) && base !== `${stem}.meta.json` ? join11(dirname5(absolute), `${stem}.meta.json`) : null;
     await unlink2(absolute);
     if (sidecarPath) {
       try {
@@ -11969,10 +12181,10 @@ var sidebar_artefact_content_default = app31;
 
 // server/routes/admin/health.ts
 import { existsSync as existsSync19, readFileSync as readFileSync17 } from "fs";
-import { resolve as resolve20, join as join11 } from "path";
+import { resolve as resolve20, join as join12 } from "path";
 var PLATFORM_ROOT6 = process.env.MAXY_PLATFORM_ROOT ?? resolve20(process.cwd(), "..");
 var brandHostname = "maxy";
-var brandJsonPath = join11(PLATFORM_ROOT6, "config", "brand.json");
+var brandJsonPath = join12(PLATFORM_ROOT6, "config", "brand.json");
 if (existsSync19(brandJsonPath)) {
   try {
     const brand = JSON.parse(readFileSync17(brandJsonPath, "utf-8"));
@@ -12067,7 +12279,7 @@ app33.route("/health-brand", health_default2);
 var admin_default = app33;
 
 // server/routes/sites.ts
-import { existsSync as existsSync20, readFileSync as readFileSync18, realpathSync as realpathSync5, statSync as statSync7 } from "fs";
+import { existsSync as existsSync20, readFileSync as readFileSync18, realpathSync as realpathSync5, statSync as statSync8 } from "fs";
 import { resolve as resolve21 } from "path";
 var SAFE_SEG_RE = /^[a-z0-9_][a-z0-9_.-]{0,99}$/i;
 var MIME = {
@@ -12133,7 +12345,7 @@ app34.get("/:rel{.*}", (c) => {
   }
   let stat7;
   try {
-    stat7 = existsSync20(filePath) ? statSync7(filePath) : null;
+    stat7 = existsSync20(filePath) ? statSync8(filePath) : null;
   } catch {
     stat7 = null;
   }
@@ -12317,7 +12529,7 @@ function startReaper2() {
 
 // ../lib/entitlement/src/index.ts
 import { createPublicKey, createHash as createHash3, verify as cryptoVerify } from "crypto";
-import { existsSync as existsSync21, readFileSync as readFileSync19, statSync as statSync8 } from "fs";
+import { existsSync as existsSync21, readFileSync as readFileSync19, statSync as statSync9 } from "fs";
 import { resolve as resolve22 } from "path";
 
 // ../lib/entitlement/src/canonicalize.ts
@@ -12369,7 +12581,7 @@ function resolveEntitlement(brand, account) {
   if (!existsSync21(entitlementPath)) {
     return logResolved(anonymousFallback("missing"), { reason: "missing" });
   }
-  const stat7 = statSync8(entitlementPath);
+  const stat7 = statSync9(entitlementPath);
   const key = memoKey(stat7.mtimeMs, account);
   if (memo && memo.key === key) {
     return memo.result;
@@ -12556,7 +12768,7 @@ function clientFrom(c) {
   );
 }
 var PLATFORM_ROOT7 = process.env.MAXY_PLATFORM_ROOT || "";
-var BRAND_JSON_PATH = PLATFORM_ROOT7 ? join12(PLATFORM_ROOT7, "config", "brand.json") : "";
+var BRAND_JSON_PATH = PLATFORM_ROOT7 ? join13(PLATFORM_ROOT7, "config", "brand.json") : "";
 var BRAND = { productName: "Maxy", hostname: "maxy", configDir: ".maxy", domain: "getmaxy.com" };
 if (BRAND_JSON_PATH && !existsSync22(BRAND_JSON_PATH)) {
   console.error(`[brand] WARNING: brand.json not found at ${BRAND_JSON_PATH} \u2014 using Maxy defaults`);
@@ -12582,7 +12794,7 @@ var brandLoginOpts = {
   bodyFont: BRAND.defaultFonts?.body,
   logoContainsName: !!BRAND.logoContainsName
 };
-var ALIAS_DOMAINS_PATH2 = join12(homedir4(), BRAND.configDir, "alias-domains.json");
+var ALIAS_DOMAINS_PATH2 = join13(homedir4(), BRAND.configDir, "alias-domains.json");
 function loadAliasDomains() {
   try {
     if (!existsSync22(ALIAS_DOMAINS_PATH2)) return null;
@@ -13028,7 +13240,7 @@ var brandScript = `<script>window.__BRAND__=${JSON.stringify({
 function readInstalledVersion() {
   try {
     if (!PLATFORM_ROOT7) return "unknown";
-    const versionFile = join12(PLATFORM_ROOT7, "config", `.${BRAND.hostname}-version`);
+    const versionFile = join13(PLATFORM_ROOT7, "config", `.${BRAND.hostname}-version`);
     if (!existsSync22(versionFile)) return "unknown";
     const content = readFileSync20(versionFile, "utf-8").trim();
     return content || "unknown";
@@ -13087,14 +13299,14 @@ ${clientErrorReporterScript}
 }
 var brandedHtmlCache = /* @__PURE__ */ new Map();
 function loadBrandingCache(agentSlug) {
-  const configDir2 = join12(homedir4(), BRAND.configDir);
+  const configDir2 = join13(homedir4(), BRAND.configDir);
   try {
-    const accountJsonPath = join12(configDir2, "account.json");
+    const accountJsonPath = join13(configDir2, "account.json");
     if (!existsSync22(accountJsonPath)) return null;
     const account = JSON.parse(readFileSync20(accountJsonPath, "utf-8"));
     const accountId = account.accountId;
     if (!accountId) return null;
-    const cachePath = join12(configDir2, "branding-cache", accountId, `${agentSlug}.json`);
+    const cachePath = join13(configDir2, "branding-cache", accountId, `${agentSlug}.json`);
     if (!existsSync22(cachePath)) return null;
     return JSON.parse(readFileSync20(cachePath, "utf-8"));
   } catch {
@@ -13103,8 +13315,8 @@ function loadBrandingCache(agentSlug) {
 }
 function resolveDefaultSlug() {
   try {
-    const configDir2 = join12(homedir4(), BRAND.configDir);
-    const accountJsonPath = join12(configDir2, "account.json");
+    const configDir2 = join13(homedir4(), BRAND.configDir);
+    const accountJsonPath = join13(configDir2, "account.json");
     if (!existsSync22(accountJsonPath)) return null;
     const account = JSON.parse(readFileSync20(accountJsonPath, "utf-8"));
     return account.defaultAgent || null;
@@ -13352,7 +13564,7 @@ reconcileEnabledPlugins(bootAccount?.accountDir, bootAccount?.config);
 (async () => {
   if (!bootAccount) return;
   try {
-    const { recoverRunningCloudflareTasks } = await import("./cloudflare-task-tracker-NEB3X6O2.js");
+    const { recoverRunningCloudflareTasks } = await import("./cloudflare-task-tracker-R6MMORFU.js");
     const result = await recoverRunningCloudflareTasks(
       bootAccount.accountId,
       configDirForWhatsApp,
@@ -13412,7 +13624,7 @@ if (bootAccountConfig?.whatsapp) {
 }
 init({
   configDir: configDirForWhatsApp,
-  platformRoot: resolve23(process.env.MAXY_PLATFORM_ROOT ?? join12(__dirname, "..")),
+  platformRoot: resolve23(process.env.MAXY_PLATFORM_ROOT ?? join13(__dirname, "..")),
   accountConfig: bootAccountConfig,
   onMessage: async (msg) => {
     if (process.env.WHATSAPP_PTY_BRIDGE_ENABLED === "true" && msg.text && !msg.isOwnerMirror) {