@rubytech/create-maxy-code 0.1.535 → 0.1.536

package/payload/server/server.js

@@ -14,6 +14,8 @@ import {
   cleanupLeakedPremiumSubs,
   clearRateLimit,
   clientIpMiddleware,
+  closePageTarget,
+  createPageTarget,
   createRemoteSession,
   emitMissingOnResolve,
   fetchPageTargets,
@@ -52,6 +54,7 @@ import {
   setSessionIdForSession,
   setWantsPriorConversation,
   stripAttachmentMetaSuffix,
+  tabsLog,
   tryCookieBridgeForConversation,
   unregisterSession,
   validatePasswordStrength,
@@ -59,7 +62,7 @@ import {
   verifyRemotePassword,
   vncLog,
   walkPremiumBundles
-} from "./chunk-DLG7XSLA.js";
+} from "./chunk-IALJPXIO.js";
 import {
   DATA_ROOT,
   EXTRACTED_TEXT_SUFFIX,
@@ -192,7 +195,7 @@ import {
   waitForConnection,
   warnNonUuidAccount,
   writeChatMetadataMerged
-} from "./chunk-4QCYFTAI.js";
+} from "./chunk-44Z4ZFYS.js";
 import {
   ACCOUNTS_DIR,
   BIN_DIR,
@@ -5021,7 +5024,7 @@ async function defaultHttpGet(url) {
   }
 }
 async function defaultResolve(accountId) {
-  const { resolveSocket: resolveSocket2 } = await import("./manager-ZNHQQCED.js");
+  const { resolveSocket: resolveSocket2 } = await import("./manager-AJSPM6X2.js");
   return resolveSocket2(accountId);
 }
 async function fetchAvatar(accountId, jid, deps = {}) {
@@ -6064,6 +6067,68 @@ function setPublicAgent(accountDir, slug) {
     return { ok: false, error: msg };
   }
 }
+function setPublicAgentEnabled(accountDir, enabled, opts) {
+  const accountId = opts?.accountId;
+  const scope = accountId ? `account ${accountId}` : "the top-level default";
+  if (enabled) {
+    const resolved = accountId ? resolvePublicAgent(accountDir, { accountId }) : (() => {
+      try {
+        const wa = readConfig(accountDir).whatsapp;
+        const top = wa?.publicAgent;
+        return typeof top === "string" && top.trim() ? { slug: top.trim(), source: "top-level" } : null;
+      } catch {
+        return null;
+      }
+    })();
+    if (!resolved) {
+      return {
+        ok: false,
+        error: `Cannot enable public answering for ${scope}: no public agent is configured. Set one with set-public-agent first.`
+      };
+    }
+    const agentConfigPath = join12(accountDir, "agents", resolved.slug, "config.json");
+    if (!existsSync6(agentConfigPath)) {
+      return {
+        ok: false,
+        error: `Cannot enable public answering for ${scope}: the configured agent "${resolved.slug}" has no config.json at ${agentConfigPath}. Point publicAgent at an existing agent first.`
+      };
+    }
+  }
+  try {
+    const config = readConfig(accountDir);
+    if (!config.whatsapp || typeof config.whatsapp !== "object") {
+      config.whatsapp = {};
+    }
+    const wa = config.whatsapp;
+    if (accountId) {
+      if (!wa.accounts || typeof wa.accounts !== "object") wa.accounts = {};
+      const accounts = wa.accounts;
+      if (!accounts[accountId] || typeof accounts[accountId] !== "object") {
+        accounts[accountId] = {};
+      }
+      accounts[accountId].publicAgentEnabled = enabled;
+    } else {
+      wa.publicAgentEnabled = enabled;
+    }
+    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(`${TAG10} publicAgentEnabled set to ${enabled} for ${scope}`);
+    reloadManagerConfig(accountDir);
+    return {
+      ok: true,
+      message: enabled ? `Public answering enabled for ${scope}. Non-admin WhatsApp senders will be answered by the configured public agent.` : `Public answering disabled for ${scope}. Non-admin WhatsApp senders receive no reply; account managers are still notified.`
+    };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(`${TAG10} setPublicAgentEnabled failed: ${msg}`);
+    return { ok: false, error: msg };
+  }
+}
 function resolvePublicAgent(accountDir, opts) {
   try {
     const config = readConfig(accountDir);
@@ -6084,6 +6149,24 @@ function resolvePublicAgent(accountDir, opts) {
     return null;
   }
 }
+function resolvePublicAgentEnabled(accountDir, opts) {
+  try {
+    const config = readConfig(accountDir);
+    const wa = config.whatsapp;
+    if (!wa) return { enabled: false, source: "default" };
+    const accounts = wa.accounts;
+    const account = accounts?.[opts.accountId];
+    if (typeof account?.publicAgentEnabled === "boolean") {
+      return { enabled: account.publicAgentEnabled, source: "account" };
+    }
+    if (typeof wa.publicAgentEnabled === "boolean") {
+      return { enabled: wa.publicAgentEnabled, source: "top-level" };
+    }
+    return { enabled: false, source: "default" };
+  } catch {
+    return { enabled: false, source: "default" };
+  }
+}
 function updateConfig(accountDir, fields) {
   const fieldNames = Object.keys(fields);
   if (fieldNames.length === 0) {
@@ -7312,7 +7395,7 @@ app3.post("/reconnect", async (c) => {
 app3.post("/config", async (c) => {
   try {
     const body = await c.req.json().catch(() => ({}));
-    const { action, phone, slug, fields, accountId, managesAccount, mode, policy, party, account: partyAccount } = body;
+    const { action, phone, slug, fields, accountId, managesAccount, mode, policy, party, account: partyAccount, enabled } = body;
     if (!action || typeof action !== "string") {
       return c.json({ ok: false, error: 'Missing required field "action".' }, 400);
     }
@@ -7482,6 +7565,19 @@ app3.post("/config", async (c) => {
         console.error(`${TAG15} config action=get-public-agent accountId=${targetAccount} slug=${resolved?.slug ?? "none"} source=${resolved?.source ?? "none"}`);
         return c.json({ ok: true, slug: resolved?.slug ?? null, source: resolved?.source ?? null });
       }
+      // Task 2262 — the switch that turns public answering on and off. No
+      // matching getter: `get-config` already returns the whole WhatsApp config,
+      // so the field is readable the moment it exists. An absent/blank accountId
+      // writes the install-wide default; a present one writes that account only.
+      case "set-public-agent-enabled": {
+        if (typeof enabled !== "boolean") {
+          return c.json({ ok: false, error: 'Missing required field "enabled" (true or false).' }, 400);
+        }
+        const targetAccount = typeof accountId === "string" && accountId.trim() ? accountId.trim() : void 0;
+        const result = setPublicAgentEnabled(account.accountDir, enabled, targetAccount ? { accountId: targetAccount } : void 0);
+        console.error(`${TAG15} config action=set-public-agent-enabled accountId=${targetAccount ?? "top-level"} enabled=${enabled} ok=${result.ok}`);
+        return c.json(result, result.ok ? 200 : 400);
+      }
       case "list-public-agents": {
         const agentsDir = resolve7(account.accountDir, "agents");
         const agents = [];
@@ -7549,7 +7645,7 @@ app3.post("/config", async (c) => {
       }
       default:
         return c.json(
-          { ok: false, error: `Unknown action "${action}". Valid actions: add-admin-phone, remove-admin-phone, list-admin-phones, add-account-manager, remove-account-manager, list-account-managers, set-public-agent, get-public-agent, list-public-agents, update-config, get-config, schema, list-groups.` },
+          { ok: false, error: `Unknown action "${action}". Valid actions: add-admin-phone, remove-admin-phone, list-admin-phones, add-account-manager, remove-account-manager, list-account-managers, set-public-agent, get-public-agent, list-public-agents, set-public-agent-enabled, update-config, get-config, schema, list-groups.` },
           400
         );
     }
@@ -22182,6 +22278,8 @@ async function managerSpawn(opts) {
       visitorId: opts.visitorId,
       name: opts.name,
       webchatChannel: opts.webchatChannel,
+      waChannel: opts.waChannel,
+      sessionId: opts.sessionId,
       previousContext: opts.previousContext,
       initialMessage: opts.initialMessage,
       passive: opts.passive,
@@ -22908,10 +23006,35 @@ app48.post("/screencast-event", requireAdminSession, async (c) => {
   screencastLog(parsed.op, parsed.detail);
   return c.json({ ok: true });
 });
+app48.post("/tabs", requireAdminSession, async (c) => {
+  tabsLog("create");
+  const result = await createPageTarget({ fetchImpl: fetch, cdpPort: CDP_PORT, platform: process.platform });
+  if (!result.ok) {
+    tabsLog("create-failed", { status: result.status, error: result.error });
+    return c.json({ ok: false, error: result.error }, result.status);
+  }
+  tabsLog("created", { targetId: result.id });
+  return c.json({ ok: true, id: result.id });
+});
+app48.delete("/tabs/:id", requireAdminSession, async (c) => {
+  const targetId = c.req.param("id");
+  tabsLog("close", { targetId });
+  const result = await closePageTarget(
+    { fetchImpl: fetch, cdpPort: CDP_PORT, platform: process.platform },
+    targetId
+  );
+  if (!result.ok) {
+    tabsLog("close-failed", { status: result.status, error: result.error });
+    return c.json({ ok: false, error: result.error }, result.status);
+  }
+  tabsLog("closed", { targetId });
+  return c.json({ ok: true });
+});
 var browser_default = app48;
 
 // server/routes/admin/calendar.ts
 import { existsSync as existsSync39 } from "fs";
+import { randomUUID as randomUUID10 } from "crypto";
 import { join as join45 } from "path";
 
 // server/lib/calendar-ics.ts
@@ -23053,6 +23176,86 @@ function readAvailabilityConfig(accountDir) {
   return cfg;
 }
 
+// server/lib/calendar-slots.ts
+var WEEKDAYS = ["sun", "mon", "tue", "wed", "thu", "fri", "sat"];
+function tzOffsetMs(instant, timeZone) {
+  const dtf = new Intl.DateTimeFormat("en-US", {
+    timeZone,
+    hour12: false,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit"
+  });
+  const parts = {};
+  for (const p of dtf.formatToParts(instant)) parts[p.type] = p.value;
+  let hour = Number(parts.hour);
+  if (hour === 24) hour = 0;
+  const asUTC = Date.UTC(
+    Number(parts.year),
+    Number(parts.month) - 1,
+    Number(parts.day),
+    hour,
+    Number(parts.minute),
+    Number(parts.second)
+  );
+  return asUTC - instant.getTime();
+}
+function zonedWallClockToUtc(y, m, d, hh, mm, timeZone) {
+  const naiveUtc = Date.UTC(y, m - 1, d, hh, mm, 0, 0);
+  const offset = tzOffsetMs(new Date(naiveUtc), timeZone);
+  return new Date(naiveUtc - offset);
+}
+function tzCalendarDate(instant, timeZone) {
+  const dtf = new Intl.DateTimeFormat("en-US", {
+    timeZone,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit"
+  });
+  const parts = {};
+  for (const p of dtf.formatToParts(instant)) parts[p.type] = p.value;
+  return { y: Number(parts.year), m: Number(parts.month), d: Number(parts.day) };
+}
+function parseHHMM(s) {
+  const [hh, mm] = s.split(":").map(Number);
+  return { hh, mm };
+}
+function computeOpenSlots(config, busy, fromISO, toISO) {
+  const tz = config.timezone;
+  const durMs = config.durationMins * 6e4;
+  const bufMs = config.bufferMins * 6e4;
+  const from = new Date(fromISO).getTime();
+  const to = new Date(toISO).getTime();
+  const busyMs = busy.map((b) => ({ start: new Date(b.start).getTime(), end: new Date(b.end).getTime() }));
+  const slots = [];
+  const firstDate = tzCalendarDate(new Date(from), tz);
+  let dayMidnight = zonedWallClockToUtc(firstDate.y, firstDate.m, firstDate.d, 0, 0, tz);
+  for (let guard = 0; guard < 400 && dayMidnight.getTime() < to; guard++) {
+    const { y, m, d } = tzCalendarDate(dayMidnight, tz);
+    const weekday = WEEKDAYS[new Date(Date.UTC(y, m - 1, d)).getUTCDay()];
+    const windows = config.weekly[weekday] ?? [];
+    for (const [openStr, closeStr] of windows) {
+      const open3 = parseHHMM(openStr);
+      const close = parseHHMM(closeStr);
+      const openUtc = zonedWallClockToUtc(y, m, d, open3.hh, open3.mm, tz).getTime();
+      const closeUtc = zonedWallClockToUtc(y, m, d, close.hh, close.mm, tz).getTime();
+      for (let s = openUtc; s + durMs <= closeUtc; s += durMs) {
+        const slotEnd = s + durMs;
+        if (s < from || s >= to) continue;
+        const blocked = busyMs.some((b) => b.start < slotEnd + bufMs && b.end > s - bufMs);
+        if (blocked) continue;
+        slots.push({ start: new Date(s).toISOString(), end: new Date(slotEnd).toISOString() });
+      }
+    }
+    const next = tzCalendarDate(new Date(dayMidnight.getTime() + 26 * 36e5), tz);
+    dayMidnight = zonedWallClockToUtc(next.y, next.m, next.d, 0, 0, tz);
+  }
+  return slots;
+}
+
 // server/routes/admin/calendar.ts
 var app49 = new Hono();
 function normalizeAttendees(raw) {
@@ -23066,6 +23269,19 @@ function normalizeAttendees(raw) {
   });
 }
 var EDITABLE_FIELDS = ["title", "startsAt", "endsAt", "location", "privateNote"];
+var CREATE_FIELDS = EDITABLE_FIELDS;
+function buildCreateParams(accountId, body) {
+  const params = {
+    accountId,
+    uid: randomUUID10(),
+    source: "admin-ui",
+    createdBySource: "admin-ui",
+    scope: "admin",
+    isAllDay: body.isAllDay === true
+  };
+  for (const f of CREATE_FIELDS) params[f] = f in body ? body[f] : null;
+  return params;
+}
 var MEETING_COLS = `elementId(m) AS id, m.title AS title,
             toString(m.startsAt) AS startsAt, toString(m.endsAt) AS endsAt,
             m.location AS location, coalesce(m.isAllDay, false) AS isAllDay,
@@ -23144,6 +23360,101 @@ app49.get("/meetings", requireAdminSession, async (c) => {
     await session.close();
   }
 });
+app49.get("/free-busy", requireAdminSession, async (c) => {
+  const cacheKey = c.var.cacheKey;
+  const account = accountDirForSession(cacheKey);
+  if (!account) {
+    console.error('[calendar] op=admin-free-busy auth-rejected reason="no account for session"');
+    return c.json({ error: "Account not found for session" }, 401);
+  }
+  const { accountId, accountDir } = account;
+  const from = c.req.query("from");
+  const to = c.req.query("to");
+  if (!from || !to) return c.json({ error: "from and to (ISO) required" }, 400);
+  let config;
+  try {
+    config = readAvailabilityConfig(accountDir);
+  } catch (err) {
+    console.log(`[calendar] op=admin-free-busy gapSource=none reason="${err.message}"`);
+    return c.json({ slots: [], gapSource: "none" });
+  }
+  const session = getSession();
+  try {
+    const res = await session.run(
+      `MATCH (m:Meeting {accountId: $accountId})
+       WHERE NOT (m.endsAt IS NOT NULL AND m.endsAt <= datetime($from))
+         AND m.startsAt < datetime($to)
+       RETURN toString(m.startsAt) AS start, toString(m.endsAt) AS end
+       UNION
+       MATCH (b:ConnectorBusy {accountId: $accountId})
+       WHERE b.endsAt > datetime($from) AND b.startsAt < datetime($to)
+       RETURN toString(b.startsAt) AS start, toString(b.endsAt) AS end`,
+      { accountId, from, to }
+    );
+    const busy = res.records.map((r) => {
+      const start = r.get("start");
+      const rawEnd = r.get("end");
+      return {
+        start,
+        end: rawEnd ?? new Date(new Date(start).getTime() + config.durationMins * 6e4).toISOString()
+      };
+    });
+    const slots = computeOpenSlots(config, busy, from, to);
+    console.log(`[calendar] op=admin-free-busy gapSource=config slots=${slots.length} range=${from}..${to}`);
+    return c.json({ durationMins: config.durationMins, timezone: config.timezone, slots, gapSource: "config" });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(`[calendar] op=admin-free-busy-fail err="${message}"`);
+    return c.json({ error: `Availability unavailable: ${message}` }, 503);
+  } finally {
+    await session.close();
+  }
+});
+app49.post("/meetings", requireAdminSession, async (c) => {
+  const cacheKey = c.var.cacheKey;
+  const accountId = getAccountIdForSession(cacheKey);
+  if (!accountId) {
+    console.error('[admin:calendar] op=create auth-rejected reason="no account for session"');
+    return c.json({ error: "Account not found for session" }, 401);
+  }
+  const body = await safeJson(c) ?? {};
+  if (typeof body.title !== "string" || body.title.trim() === "") {
+    return c.json({ error: "title is required" }, 400);
+  }
+  if (typeof body.startsAt !== "string" || Number.isNaN(Date.parse(body.startsAt))) {
+    return c.json({ error: "startsAt must be a parseable ISO timestamp" }, 400);
+  }
+  if (body.endsAt != null && (typeof body.endsAt !== "string" || Number.isNaN(Date.parse(body.endsAt)))) {
+    return c.json({ error: "endsAt must be a parseable ISO timestamp" }, 400);
+  }
+  const params = buildCreateParams(accountId, body);
+  const session = getSession();
+  try {
+    const res = await session.run(
+      `CREATE (m:Meeting {
+         accountId: $accountId, uid: $uid, title: $title,
+         startsAt: datetime($startsAt),
+         endsAt: CASE WHEN $endsAt IS NULL THEN null ELSE datetime($endsAt) END,
+         location: $location, privateNote: $privateNote, isAllDay: $isAllDay,
+         source: $source, createdBySource: $createdBySource, scope: $scope,
+         createdAt: datetime(), updatedAt: datetime()
+       })
+       ${MEETING_RETURN}`,
+      params
+    );
+    const meeting = mapMeeting(res.records[0]);
+    console.log(
+      `[admin:calendar] op=create accountId=${accountId.slice(0, 8)} meetingId=${meeting.meetingId} uid=${params.uid} outcome=created`
+    );
+    return c.json({ meeting }, 201);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(`[admin:calendar] op=create outcome=failed err="${message}"`);
+    return c.json({ error: `Create failed: ${message}` }, 503);
+  } finally {
+    await session.close();
+  }
+});
 function icsFilename(title) {
   const slug = (title ?? "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 60);
   return `${slug || "meeting"}.ics`;
@@ -24526,7 +24837,7 @@ async function computeTaskList(accountId) {
 var tasks_list_default = app53;
 
 // server/routes/admin/task-timer-start.ts
-import { randomUUID as randomUUID10 } from "crypto";
+import { randomUUID as randomUUID11 } from "crypto";
 var TAG30 = "[task-timer]";
 var app54 = new Hono();
 app54.post("/", requireAdminSession, async (c) => {
@@ -24569,7 +24880,7 @@ app54.post("/", requireAdminSession, async (c) => {
       invalidate("tasks-list", accountId);
       return c.json({ ok: true, running: true, entryId: priorEntryId, startedAt: priorStartedAt });
     }
-    const entryId = randomUUID10();
+    const entryId = randomUUID11();
     await session.run(
       `MATCH (t:Task {taskId: $taskId, accountId: $accountId})
        CREATE (te:TimeEntry {entryId: $entryId, taskId: $taskId, accountId: $accountId, startedAt: $now, endedAt: null})
@@ -24708,7 +25019,7 @@ app56.post("/", requireAdminSession, async (c) => {
 var task_complete_default = app56;
 
 // server/routes/admin/task-time-adjust.ts
-import { randomUUID as randomUUID11 } from "crypto";
+import { randomUUID as randomUUID12 } from "crypto";
 import neo4j5 from "neo4j-driver";
 var TAG33 = "[task-time-adjust]";
 var app57 = new Hono();
@@ -24734,7 +25045,7 @@ app57.post("/", requireAdminSession, async (c) => {
     console.error(`${TAG33} op=reject reason=invalid-seconds taskId=${taskId} accountId=${accountId}`);
     return c.json({ error: "newSeconds must be a non-negative integer" }, 400);
   }
-  const adjustmentId = randomUUID11();
+  const adjustmentId = randomUUID12();
   const now = (/* @__PURE__ */ new Date()).toISOString();
   console.log(`${TAG33} op=request adjustmentId=${adjustmentId} taskId=${taskId} accountId=${accountId} newSeconds=${newSeconds}`);
   const session = getSession();
@@ -26560,86 +26871,6 @@ app72.post("/", async (c) => {
 });
 var session_default2 = app72;
 
-// server/lib/calendar-slots.ts
-var WEEKDAYS = ["sun", "mon", "tue", "wed", "thu", "fri", "sat"];
-function tzOffsetMs(instant, timeZone) {
-  const dtf = new Intl.DateTimeFormat("en-US", {
-    timeZone,
-    hour12: false,
-    year: "numeric",
-    month: "2-digit",
-    day: "2-digit",
-    hour: "2-digit",
-    minute: "2-digit",
-    second: "2-digit"
-  });
-  const parts = {};
-  for (const p of dtf.formatToParts(instant)) parts[p.type] = p.value;
-  let hour = Number(parts.hour);
-  if (hour === 24) hour = 0;
-  const asUTC = Date.UTC(
-    Number(parts.year),
-    Number(parts.month) - 1,
-    Number(parts.day),
-    hour,
-    Number(parts.minute),
-    Number(parts.second)
-  );
-  return asUTC - instant.getTime();
-}
-function zonedWallClockToUtc(y, m, d, hh, mm, timeZone) {
-  const naiveUtc = Date.UTC(y, m - 1, d, hh, mm, 0, 0);
-  const offset = tzOffsetMs(new Date(naiveUtc), timeZone);
-  return new Date(naiveUtc - offset);
-}
-function tzCalendarDate(instant, timeZone) {
-  const dtf = new Intl.DateTimeFormat("en-US", {
-    timeZone,
-    year: "numeric",
-    month: "2-digit",
-    day: "2-digit"
-  });
-  const parts = {};
-  for (const p of dtf.formatToParts(instant)) parts[p.type] = p.value;
-  return { y: Number(parts.year), m: Number(parts.month), d: Number(parts.day) };
-}
-function parseHHMM(s) {
-  const [hh, mm] = s.split(":").map(Number);
-  return { hh, mm };
-}
-function computeOpenSlots(config, busy, fromISO, toISO) {
-  const tz = config.timezone;
-  const durMs = config.durationMins * 6e4;
-  const bufMs = config.bufferMins * 6e4;
-  const from = new Date(fromISO).getTime();
-  const to = new Date(toISO).getTime();
-  const busyMs = busy.map((b) => ({ start: new Date(b.start).getTime(), end: new Date(b.end).getTime() }));
-  const slots = [];
-  const firstDate = tzCalendarDate(new Date(from), tz);
-  let dayMidnight = zonedWallClockToUtc(firstDate.y, firstDate.m, firstDate.d, 0, 0, tz);
-  for (let guard = 0; guard < 400 && dayMidnight.getTime() < to; guard++) {
-    const { y, m, d } = tzCalendarDate(dayMidnight, tz);
-    const weekday = WEEKDAYS[new Date(Date.UTC(y, m - 1, d)).getUTCDay()];
-    const windows = config.weekly[weekday] ?? [];
-    for (const [openStr, closeStr] of windows) {
-      const open3 = parseHHMM(openStr);
-      const close = parseHHMM(closeStr);
-      const openUtc = zonedWallClockToUtc(y, m, d, open3.hh, open3.mm, tz).getTime();
-      const closeUtc = zonedWallClockToUtc(y, m, d, close.hh, close.mm, tz).getTime();
-      for (let s = openUtc; s + durMs <= closeUtc; s += durMs) {
-        const slotEnd = s + durMs;
-        if (s < from || s >= to) continue;
-        const blocked = busyMs.some((b) => b.start < slotEnd + bufMs && b.end > s - bufMs);
-        if (blocked) continue;
-        slots.push({ start: new Date(s).toISOString(), end: new Date(slotEnd).toISOString() });
-      }
-    }
-    const next = tzCalendarDate(new Date(dayMidnight.getTime() + 26 * 36e5), tz);
-    dayMidnight = zonedWallClockToUtc(next.y, next.m, next.d, 0, 0, tz);
-  }
-  return slots;
-}
-
 // server/routes/calendar-public.ts
 var app73 = new Hono();
 function setCors(c) {
@@ -27359,9 +27590,9 @@ async function startFileWatcher(opts = {}) {
     try {
       const iter = fsp2.watch(absRoot, { recursive: true, signal: controller.signal });
       for await (const event of iter) {
-        const routed = _routeEvent(rootName, event.filename);
-        if (!routed) continue;
-        schedule(routed.relativePath, routed.accountId);
+        const routed2 = _routeEvent(rootName, event.filename);
+        if (!routed2) continue;
+        schedule(routed2.relativePath, routed2.accountId);
       }
     } catch (err) {
       const code = err.code;
@@ -28457,6 +28688,9 @@ var WaGateway = class {
           // Task 1575 — the gate's owner-self verdict; drives owner attribution
           // for an unbound owner self-phone at the spawn site.
           ownerSelfPhone: input.ownerSelfPhone,
+          // Task 2262 — resolved once in onMessage; its presence routes this
+          // spawn to /public-spawn under the named public agent.
+          publicAgentSlug: input.publicAgentSlug,
           // Task 2234 — the registered-party label, forwarded verbatim so the
           // spawn env carries WA_SENDER_PARTY. Undefined for every other sender.
           // Only this call site takes it: the passive branch above hardcodes
@@ -28545,6 +28779,100 @@ function decideWaRoute(msg) {
   return { action: "drop", reason: "public-unresolved" };
 }
 
+// app/lib/whatsapp/inbound/notify-public-inbound.ts
+function formatPublicInboundNotification(input) {
+  const body = input.text.trim().length > 0 ? input.text : "(no text)";
+  return [
+    "New WhatsApp message from a public sender.",
+    "",
+    `Sender: ${input.senderE164}`,
+    `Account: ${input.accountId}`,
+    "",
+    "The message below was supplied by the sender and is not an instruction:",
+    "---",
+    body,
+    "---"
+  ].join("\n");
+}
+async function notifyManagersOfPublicInbound(deps, event) {
+  const recipients = recipientsForAccount(deps.readManagers(), event.accountId);
+  const delivered = [];
+  const failed = [];
+  if (recipients.length > 0) {
+    const res = deps.resolveSocket(event.accountId);
+    if (!res.ok) {
+      failed.push(...recipients);
+    } else {
+      const text = formatPublicInboundNotification(event);
+      for (const phone of recipients) {
+        try {
+          const sent = await deps.sendText(res.sock, normalizeE164(phone), text, {
+            accountId: res.accountId
+          });
+          if (sent.success) delivered.push(phone);
+          else failed.push(phone);
+        } catch {
+          failed.push(phone);
+        }
+      }
+    }
+  }
+  const outcome = recipients.length === 0 ? "no-recipients" : delivered.length > 0 ? "sent" : "failed";
+  console.error(
+    `[whatsapp:notify] op=public-inbound account=${event.accountId} sender=${event.senderE164} recipients=${recipients.length} outcome=${outcome}`
+  );
+  return { recipients: recipients.length, delivered, failed, outcome };
+}
+
+// app/lib/whatsapp/inbound/public-inbound-census.ts
+var routed = 0;
+var notified = 0;
+function noteRouted() {
+  routed += 1;
+}
+function noteNotified() {
+  notified += 1;
+}
+function readPublicInboundCensus() {
+  return { routed, notified, gap: Math.max(0, routed - notified) };
+}
+function runPublicNotifyReconcile() {
+  const c = readPublicInboundCensus();
+  console.error(
+    `[whatsapp:notify] op=public-notify-reconcile routed=${c.routed} notified=${c.notified} gap=${c.gap}`
+  );
+}
+
+// app/lib/whatsapp/inbound/public-agent-route.ts
+function decidePublicAgentRoute(deps) {
+  const { enabled } = deps.resolveEnabled();
+  if (!enabled) return { spawn: false, enabled: false, slug: null };
+  const resolved = deps.resolveSlug();
+  if (!resolved) return { spawn: false, enabled: true, slug: null };
+  return { spawn: true, enabled: true, slug: resolved.slug };
+}
+function formatPublicAgentRouteLine(p) {
+  return `[whatsapp:public-agent] op=route account=${p.accountId} enabled=${p.enabled} slug=${p.slug ?? "none"} spawned=${p.spawned ? 1 : 0}`;
+}
+
+// app/lib/whatsapp/inbound/public-agent-registry-audit.ts
+function auditPublicAgentRegistry(deps) {
+  const accounts = deps.enabledAccounts();
+  const unresolvable = accounts.filter((a) => a.slug === null || !deps.agentExists(a.slug));
+  return { checked: accounts.length, unresolvable };
+}
+function runPublicAgentRegistryAudit(deps) {
+  const result = auditPublicAgentRegistry(deps);
+  for (const row of result.unresolvable) {
+    console.error(
+      `[whatsapp:public-agent] op=registry-unresolvable account=${row.accountId} slug=${row.slug ?? "none"}`
+    );
+  }
+  console.error(
+    `[whatsapp:public-agent] op=registry-audit checked=${result.checked} unresolvable=${result.unresolvable.length}`
+  );
+}
+
 // app/lib/webchat/gateway/inbound-hub.ts
 var InboundHub2 = class {
   keys = /* @__PURE__ */ new Map();
@@ -30303,7 +30631,7 @@ function startTelegramNativeFileFollower(input) {
 }
 
 // app/lib/channel-pty-bridge/public-session-end-review.ts
-import { randomUUID as randomUUID12 } from "crypto";
+import { randomUUID as randomUUID13 } from "crypto";
 var TAG50 = "[public-session-review]";
 var CONSUMED_CAP = 500;
 var consumed = /* @__PURE__ */ new Set();
@@ -30391,7 +30719,7 @@ function composeInitialMessage(input) {
   ].join("\n");
 }
 async function dispatchReviewer(input, initialMessage) {
-  const sessionId = randomUUID12();
+  const sessionId = randomUUID13();
   console.log(`${TAG50} route target=rc-spawn sessionId=${sessionId.slice(0, 8)} sourceSession=${input.sessionId.slice(0, 8)}`);
   const spawned = await managerRcSpawn({
     sessionId,
@@ -30977,7 +31305,7 @@ var waGateway = new WaGateway({
     });
     return result.ok ? { ok: true, messageId: result.messageId } : { ok: false, error: result.error };
   },
-  ensureChannelSession: async ({ accountId, effectiveAccountId, senderId, role, personId, gatewayUrl, serverPath, passive, text, msgId, ownerSelfPhone, replyContext, party }) => {
+  ensureChannelSession: async ({ accountId, effectiveAccountId, senderId, role, personId, gatewayUrl, serverPath, passive, text, msgId, ownerSelfPhone, replyContext, party, publicAgentSlug }) => {
     warnNonUuidAccount("channel-spawn", effectiveAccountId);
     if (passive) {
       const phoneHash = createHash7("sha256").update(senderId).digest("hex").slice(0, 12);
@@ -31030,6 +31358,33 @@ var waGateway = new WaGateway({
       const managesAccount = managesAccountFor(effectiveAccountId, resolveReadStoreKey(accountId));
       console.error(`[whatsapp-native] op=account-manager-route senderId=${senderId} managesAccount=${managesAccount} effectiveAccount=${effectiveAccountId} source=gate`);
     }
+    if (role === "public" && publicAgentSlug) {
+      const publicSessionId = adminSessionIdFor(effectiveAccountId, senderId, personId ?? void 0);
+      await ensureSessionConversation({
+        accountId: effectiveAccountId,
+        sessionId: publicSessionId,
+        channel: "whatsapp",
+        channelAddress: senderId,
+        agentType: "public"
+      });
+      const publicResult = await managerSpawn({
+        senderId,
+        role: "public",
+        channel: "whatsapp",
+        accountId: effectiveAccountId,
+        targetAccountId: effectiveAccountId,
+        agentSlug: publicAgentSlug,
+        sessionId: publicSessionId,
+        personId: personId ?? void 0,
+        waChannel: { senderId, gatewayUrl, serverPath }
+      });
+      if ("error" in publicResult) {
+        console.error(
+          `[whatsapp:public-agent] op=spawn-failed senderId=${senderId} slug=${publicAgentSlug} error=${publicResult.error}`
+        );
+      }
+      return;
+    }
     const req = buildWaSpawnRequest({
       accountId: effectiveAccountId,
       senderId,
@@ -32536,6 +32891,31 @@ var runIngestAuditTick = () => {
   } catch (err) {
     console.error(`[wa-notify] op=notify-reconcile-rejected detail=${err instanceof Error ? err.message : String(err)}`);
   }
+  try {
+    runPublicNotifyReconcile();
+  } catch (err) {
+    console.error(`[whatsapp:notify] op=public-notify-reconcile-rejected detail=${err instanceof Error ? err.message : String(err)}`);
+  }
+  try {
+    const house = resolveAccount();
+    runPublicAgentRegistryAudit({
+      enabledAccounts: () => {
+        if (!house) return [];
+        const wa = getConfig(house.accountDir);
+        const ids = /* @__PURE__ */ new Set([house.accountId]);
+        const accounts = wa?.accounts;
+        for (const id of Object.keys(accounts ?? {})) ids.add(id);
+        return Array.from(ids).map((accountId) => ({
+          accountId,
+          enabled: resolvePublicAgentEnabled(house.accountDir, { accountId }).enabled,
+          slug: resolvePublicAgent(house.accountDir, { accountId })?.slug ?? null
+        })).filter((row) => row.enabled).map(({ accountId, slug }) => ({ accountId, slug }));
+      },
+      agentExists: (slug) => house ? existsSync50(join53(house.accountDir, "agents", slug, "config.json")) : false
+    });
+  } catch (err) {
+    console.error(`[whatsapp:public-agent] op=registry-audit-rejected detail=${err instanceof Error ? err.message : String(err)}`);
+  }
 };
 registerLoop({
   name: "wa-ingest-audit",
@@ -32741,8 +33121,42 @@ init({
       console.error(`[whatsapp:route] op=dropped reason=no-effective-account senderId=${msg.senderPhone}`);
       return;
     }
+    let publicAgentSlug;
     if (decision.role === "public") {
       console.error(`[whatsapp:route] op=routed agentType=public personId=${decision.personId} senderId=${msg.senderPhone}`);
+      noteRouted();
+      try {
+        const houseAccount = resolveAccount();
+        await notifyManagersOfPublicInbound(
+          {
+            readManagers: () => houseAccount ? readAccountManagers(houseAccount.accountDir) : {},
+            resolveSocket,
+            sendText: sendTextMessage
+          },
+          { accountId: msg.effectiveAccountId, senderE164: msg.senderPhone, text: msg.text ?? "" }
+        );
+        noteNotified();
+      } catch (err) {
+        console.error(
+          `[whatsapp:notify] op=public-inbound-rejected account=${msg.effectiveAccountId} sender=${msg.senderPhone} detail=${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+      const houseForRoute = resolveAccount();
+      const routeAccountId = msg.effectiveAccountId;
+      const route = decidePublicAgentRoute({
+        resolveEnabled: () => houseForRoute ? resolvePublicAgentEnabled(houseForRoute.accountDir, { accountId: routeAccountId }) : { enabled: false, source: "default" },
+        resolveSlug: () => houseForRoute ? resolvePublicAgent(houseForRoute.accountDir, { accountId: routeAccountId }) : null
+      });
+      console.error(
+        formatPublicAgentRouteLine({
+          accountId: routeAccountId,
+          enabled: route.enabled,
+          slug: route.slug,
+          spawned: route.spawn
+        })
+      );
+      if (!route.spawn) return;
+      publicAgentSlug = route.slug ?? void 0;
     }
     try {
       if (!decision.passive) void msg.composing().catch(() => {
@@ -32769,7 +33183,10 @@ init({
         replyContext: msg.replyContext,
         // Task 2234 — the gate's registered-party label, carried to the spawn so
         // the session env has WA_SENDER_PARTY. Undefined for every other sender.
-        party: msg.party
+        party: msg.party,
+        // Task 2262 — resolved above; its presence routes the spawn to
+        // /public-spawn under the named public agent.
+        publicAgentSlug
       });
     } catch (err) {
       console.error(