n2n-nexus 0.7.0 → 0.8.0

package/build/daemon/server.js

@@ -1,18 +1,19 @@
 import http from "node:http";
 import net from "node:net";
+import { EventEmitter } from "node:events";
 import { URL } from "node:url";
 import { StorageManager } from "../storage/index.js";
 import { SqliteMeetingStore } from "../storage/sqlite-meeting.js";
 import { GlobalMessageStore } from "../storage/global-messages.js";
-import { SessionStore } from "../storage/sessions.js";
-import { DirectMessageStore } from "../storage/direct-messages.js";
 import { EventStore } from "../storage/events.js";
 import { runMigrations } from "../storage/migrations.js";
 import { createTask, updateTask, getTask, listTasks, cancelTask } from "../storage/tasks.js";
+import { AgentStore, messagePreview } from "../storage/agents.js";
 import { MAX_BODY_BYTES } from "../constants.js";
 import { ADDRESS_LIMIT_FACTOR, RateLimiter, rateLimitFromEnv } from "./rate-limit.js";
 import { ResultContractError, finalizeResult } from "./tool-outputs.js";
-import { TOOL_DEFINITIONS, isToolName, parseToolArgs, taskUpdateSchema, sessionRegistrationSchema, sessionDisconnectSchema, ToolValidationError } from "./tools.js";
+import { TOOL_DEFINITIONS, isToolName, parseToolArgs, taskUpdateSchema, callerSchema, hookRequestSchema, ToolValidationError } from "./tools.js";
+import { LISTEN_WAIT_MS, MESSAGE_TRUST_NOTE, NO_AGENT_SESSION_ERROR, NOTICE_PREFIX, NOTIFY_CLOSING, NOTIFY_LIST_LIMIT, STOP_CLOSING, agentSessionId } from "./hook-contract.js";
 import { z } from "zod";
 // ---------------------------------------------------------------------------
 // Storage bootstrap
@@ -79,20 +80,7 @@ async function toolGetProject(args) {
         ? { manifest, internalDocs: await StorageManager.getProjectDocs(args.projectId) }
         : { manifest };
 }
-function requireSession(sessionId, instanceId) {
-    if (!sessionId)
-        throw new Error("A registered sessionId is required");
-    return SessionStore.require(sessionId, instanceId);
-}
-async function toolSendMessage(args, instanceId, sessionId) {
-    if (args.to !== undefined) {
-        const sender = requireSession(sessionId, instanceId);
-        const saved = DirectMessageStore.send(sender.sessionId, { ...args, to: args.to });
-        return {
-            ok: true, sentTo: "session", messageId: saved.messageId, status: saved.status,
-            to: saved.to, replyTo: saved.replyTo, message: `Direct message ${saved.status}.`
-        };
-    }
+async function toolSendMessage(args, instanceId) {
     const meetingId = args.meetingId ?? SqliteMeetingStore.getActiveMeetingId();
     if (meetingId) {
         const msg = {
@@ -221,34 +209,231 @@ async function toolHostDeleteProject(args, instanceId) {
     return { ok: true, projectId: args.projectId, message: `Project '${args.projectId}' deleted.` };
 }
 // ---------------------------------------------------------------------------
-// Tool dispatcher
+// Agent sessions: direct-message tools
 // ---------------------------------------------------------------------------
-async function dispatchTool(name, rawArgs, instanceId, sessionId) {
-    switch (name) {
-        case "list_sessions": {
-            const args = parseToolArgs(name, rawArgs);
-            const self = sessionId ? requireSession(sessionId, instanceId) : null;
-            const sessions = SessionStore.list(args);
-            return { self, sessions, count: sessions.length };
-        }
-        case "update_session": {
-            const args = parseToolArgs(name, rawArgs);
-            return { session: SessionStore.update(requireSession(sessionId, instanceId).sessionId, args) };
-        }
-        case "read_inbox": {
-            const args = parseToolArgs(name, rawArgs);
-            const self = requireSession(sessionId, instanceId);
-            const messages = DirectMessageStore.readInbox(self.sessionId, args.count);
-            return { sessionId: self.sessionId, messages, count: messages.length };
+/** Wakes a Stop hook waiting in listen mode; the event name is the session id. */
+const agentWake = new EventEmitter();
+agentWake.setMaxListeners(0);
+function wake(sessionIds) {
+    for (const id of sessionIds)
+        agentWake.emit(id);
+}
+/** Expire overdue messages and wake the senders that got a notice. */
+function expireMessages(now) {
+    wake(AgentStore.expireMessages(now));
+}
+function profileOf(s) {
+    return { id: s.id, name: s.name, client: s.client, cwd: s.cwd, note: s.note, status: s.status, lastActiveAt: s.lastActiveAt };
+}
+/**
+ * The agent session behind a direct-message tool call: Claude through the
+ * toolUseId its PreToolUse hook bound, Codex through its session id.
+ */
+function resolveAgent(caller) {
+    const now = Date.now();
+    let id = null;
+    if (caller?.client === "claude")
+        id = AgentStore.resolveToolUse(caller.toolUseId, now);
+    else if (caller?.client === "codex")
+        id = agentSessionId("codex", caller.sessionId);
+    if (!id || !AgentStore.get(id))
+        throw new Error(NO_AGENT_SESSION_ERROR);
+    AgentStore.refresh(id, now);
+    expireMessages(now);
+    return AgentStore.get(id);
+}
+function deliver(from, to, text, replyTo, notifyWhenIdle) {
+    if (to.id === from.id)
+        throw new Error("You cannot send a message to yourself.");
+    const messageId = AgentStore.addMessage(from.id, to.id, text, replyTo);
+    if (notifyWhenIdle)
+        AgentStore.subscribeIdle(from.id, to.id);
+    wake([to.id]);
+    return { messageId, to: { id: to.id, name: to.name, status: to.status } };
+}
+async function toolPeers(caller) {
+    const self = resolveAgent(caller);
+    return { self: profileOf(self), peers: AgentStore.listPeers(self.id).map(profileOf) };
+}
+async function toolSend(args, caller) {
+    const self = resolveAgent(caller);
+    const to = AgentStore.findRecipient(args.to);
+    if (!to)
+        throw new Error(`Unknown recipient '${args.to}'. Call peers for session ids and names.`);
+    return deliver(self, to, args.text, null, args.notifyWhenIdle);
+}
+async function toolReply(args, caller) {
+    const self = resolveAgent(caller);
+    const original = AgentStore.getMessage(args.messageId);
+    if (!original || original.toId !== self.id)
+        throw new Error(`Message '${args.messageId}' was not sent to you.`);
+    return deliver(self, AgentStore.get(original.fromId), args.text, original.id, false);
+}
+async function toolRead(args, caller) {
+    const self = resolveAgent(caller);
+    const { messages, remaining } = AgentStore.readUnread(self.id, args.count);
+    return {
+        messages: messages.map(m => ({
+            messageId: m.id, from: { id: m.fromId, name: m.fromName }, replyTo: m.replyTo, text: m.text, createdAt: m.createdAt
+        })),
+        remaining
+    };
+}
+async function toolListen(args, caller) {
+    const self = resolveAgent(caller);
+    AgentStore.setListening(self.id, args.on);
+    return { listening: args.on };
+}
+async function toolSetProfile(args, caller) {
+    const self = resolveAgent(caller);
+    return { profile: profileOf(AgentStore.updateProfile(self.id, args)) };
+}
+/**
+ * Notification text for messages and notices; marks them notified. `closing` ends
+ * the message part: NOTIFY_CLOSING, or STOP_CLOSING when it continues a turn that was
+ * about to end (a model left to itself there tended to stop after the preview).
+ */
+function notify(messages, notices, label, closing) {
+    const lines = [];
+    if (messages.length > 0) {
+        const n = messages.length;
+        lines.push(`${NOTICE_PREFIX} ${n} ${label} direct message${n === 1 ? "" : "s"}:`);
+        for (const m of messages.slice(0, NOTIFY_LIST_LIMIT)) {
+            lines.push(`- From ${m.fromName} (${m.fromId}) at ${m.createdAt}: ${messagePreview(m.text)}`);
         }
-        case "get_message": {
-            const args = parseToolArgs(name, rawArgs);
-            return { message: DirectMessageStore.get(args.messageId, requireSession(sessionId, instanceId).sessionId) };
+        if (n > NOTIFY_LIST_LIMIT)
+            lines.push(`- ...and ${n - NOTIFY_LIST_LIMIT} more`);
+    }
+    if (notices.length > 0) {
+        lines.push(messages.length > 0 ? "Notices:" : `${NOTICE_PREFIX} Notices:`);
+        for (const notice of notices)
+            lines.push(`- ${notice.text}`);
+    }
+    if (messages.length > 0)
+        lines.push(`${MESSAGE_TRUST_NOTE} ${closing}`);
+    AgentStore.markNotified(messages.map(m => m.id), notices.map(n => n.id));
+    return lines.join("\n");
+}
+/** Notification for every unread message and pending notice, or null when there are none. */
+function notifyAll(sessionId, closing = NOTIFY_CLOSING) {
+    const messages = AgentStore.unread(sessionId);
+    const notices = AgentStore.pendingNotices(sessionId);
+    return messages.length || notices.length ? notify(messages, notices, "unread", closing) : null;
+}
+/** Notification for what was not notified yet, or null when nothing is new. */
+function notifyFresh(sessionId, closing = NOTIFY_CLOSING) {
+    const messages = AgentStore.unread(sessionId, true);
+    const notices = AgentStore.pendingNotices(sessionId);
+    return messages.length || notices.length ? notify(messages, notices, "new", closing) : null;
+}
+const contextOutput = (hookEventName, text) => text === null ? null : { hookSpecificOutput: { hookEventName, additionalContext: text } };
+const blockOutput = (reason) => ({ decision: "block", reason });
+/**
+ * Listen mode: wait until something not notified yet arrives (then block the
+ * stop with it), the wait runs out, or the hook's HTTP client goes away.
+ */
+function waitForMessages(sessionId, waitMs, signal) {
+    return new Promise((resolve) => {
+        let done = false;
+        const finish = (output) => {
+            if (done)
+                return;
+            done = true;
+            clearTimeout(timer);
+            agentWake.off(sessionId, check);
+            signal.removeEventListener("abort", stopWaiting);
+            resolve(output);
+        };
+        const stopWaiting = () => {
+            if (done)
+                return;
+            AgentStore.setStatusIf(sessionId, "listening", "idle");
+            finish(null);
+        };
+        function check() {
+            if (done)
+                return;
+            // SessionEnd (or listen off) during the wait: nobody will act on a block any more.
+            if (!AgentStore.get(sessionId)?.listening)
+                return finish(null);
+            const text = notifyFresh(sessionId, STOP_CLOSING);
+            if (text === null)
+                return;
+            AgentStore.setStatus(sessionId, "working");
+            finish(blockOutput(text));
         }
-        case "acknowledge_message": {
-            const args = parseToolArgs(name, rawArgs);
-            return { message: DirectMessageStore.acknowledge(args.messageId, requireSession(sessionId, instanceId).sessionId, args.outcome) };
+        const timer = setTimeout(stopWaiting, waitMs);
+        agentWake.on(sessionId, check);
+        signal.addEventListener("abort", stopWaiting, { once: true });
+        if (signal.aborted)
+            stopWaiting();
+        else
+            check();
+    });
+}
+async function handleStop(sessionId, input, listenWaitMs, signal) {
+    if (input.stop_hook_active !== true) {
+        const text = notifyAll(sessionId, STOP_CLOSING);
+        if (text !== null) {
+            AgentStore.setStatus(sessionId, "working");
+            return blockOutput(text);
         }
+    }
+    if (AgentStore.get(sessionId).listening) {
+        AgentStore.setStatus(sessionId, "listening");
+        wake(AgentStore.fireIdle(sessionId, "idle"));
+        return waitForMessages(sessionId, listenWaitMs, signal);
+    }
+    AgentStore.setStatus(sessionId, "idle");
+    wake(AgentStore.fireIdle(sessionId, "idle"));
+    return null;
+}
+/** One client hook event (POST /api/hook). Returns what the hook prints, or null. */
+async function handleHook(client, input, listenWaitMs, signal) {
+    if (typeof input.session_id !== "string" || !input.session_id)
+        return null;
+    const id = agentSessionId(client, input.session_id);
+    const now = Date.now();
+    AgentStore.touch(id, client, typeof input.cwd === "string" ? input.cwd : "", now);
+    expireMessages(now);
+    switch (input.hook_event_name) {
+        case "SessionStart":
+            AgentStore.setStatus(id, "idle");
+            return null;
+        case "UserPromptSubmit":
+            AgentStore.setStatus(id, "working");
+            return contextOutput("UserPromptSubmit", notifyAll(id));
+        case "PreToolUse":
+            if (typeof input.tool_use_id === "string" && input.tool_use_id)
+                AgentStore.bindToolUse(input.tool_use_id, id, now);
+            return null;
+        case "PostToolUse":
+            AgentStore.setStatus(id, "working");
+            return contextOutput("PostToolUse", notifyFresh(id));
+        case "Stop":
+            return handleStop(id, input, listenWaitMs, signal);
+        case "SessionEnd":
+            AgentStore.setStatus(id, "offline");
+            AgentStore.setListening(id, false);
+            wake([id, ...AgentStore.fireIdle(id, "offline")]);
+            return null;
+        default:
+            return null;
+    }
+}
+// ---------------------------------------------------------------------------
+// Tool dispatcher
+// ---------------------------------------------------------------------------
+async function dispatchTool(name, rawArgs, instanceId, caller) {
+    switch (name) {
+        case "peers":
+            parseToolArgs(name, rawArgs);
+            return toolPeers(caller);
+        case "send": return toolSend(parseToolArgs(name, rawArgs), caller);
+        case "read": return toolRead(parseToolArgs(name, rawArgs), caller);
+        case "reply": return toolReply(parseToolArgs(name, rawArgs), caller);
+        case "listen": return toolListen(parseToolArgs(name, rawArgs), caller);
+        case "set_profile": return toolSetProfile(parseToolArgs(name, rawArgs), caller);
         case "sync_project_assets": return toolSyncProjectAssets(parseToolArgs(name, rawArgs), instanceId);
         case "upload_project_asset": return toolUploadAsset(parseToolArgs(name, rawArgs), instanceId);
         case "update_project": return toolUpdateProject(parseToolArgs(name, rawArgs), instanceId);
@@ -256,7 +441,7 @@ async function dispatchTool(name, rawArgs, instanceId, sessionId) {
         case "search_projects": return toolSearchProjects(parseToolArgs(name, rawArgs));
         case "get_global_topology": return toolGetGlobalTopology(parseToolArgs(name, rawArgs));
         case "get_project": return toolGetProject(parseToolArgs(name, rawArgs));
-        case "send_message": return toolSendMessage(parseToolArgs(name, rawArgs), instanceId, sessionId);
+        case "send_message": return toolSendMessage(parseToolArgs(name, rawArgs), instanceId);
         case "read_messages": return toolReadMessages(parseToolArgs(name, rawArgs), instanceId);
         case "list_events": return toolListEvents(parseToolArgs(name, rawArgs));
         case "get_global_strategy":
@@ -310,9 +495,9 @@ function rateLimited(retryAfterSec, scope) {
  * Run a tool for an HTTP request. Validation failures and handler rejections
  * are the caller's fault and surface as 400, not as daemon errors.
  */
-async function callTool(name, args, instanceId, sessionId) {
+async function callTool(name, args, instanceId, caller) {
     try {
-        return finalizeResult(name, await dispatchTool(name, args, instanceId, sessionId));
+        return finalizeResult(name, await dispatchTool(name, args, instanceId, caller));
     }
     catch (e) {
         if (e instanceof HttpError)
@@ -330,8 +515,10 @@ const UNKNOWN_INSTANCE = "unknown";
 function actor(body) {
     return typeof body.instanceId === "string" && body.instanceId ? body.instanceId : UNKNOWN_INSTANCE;
 }
-function sessionActor(body) {
-    return z.string().min(1).optional().parse(body.sessionId);
+/** A malformed caller names no session: direct-message tools then refuse, every other tool ignores it. */
+function callerOf(body) {
+    const parsed = callerSchema.safeParse(body.caller);
+    return parsed.success ? parsed.data : undefined;
 }
 /** Query-string parameters as tool arguments; `numeric` names are converted to numbers. */
 function queryArgs(url, numeric) {
@@ -435,6 +622,7 @@ export async function createDaemonServer(options) {
     await initializeStorage();
     const maxBodyBytes = options.maxBodyBytes ?? MAX_BODY_BYTES;
     const allowedHosts = options.allowedHosts ?? allowedHostsFromEnv();
+    const listenWaitMs = options.listenWaitMs ?? LISTEN_WAIT_MS;
     const limit = options.rateLimit ?? rateLimitFromEnv();
     const instanceLimiter = new RateLimiter(limit.perSecond, limit.burst);
     const addressLimiter = new RateLimiter(limit.perSecond * ADDRESS_LIMIT_FACTOR, limit.burst * ADDRESS_LIMIT_FACTOR);
@@ -443,13 +631,13 @@ export async function createDaemonServer(options) {
      * Requests that name no instance ("unknown") are only limited per address:
      * pooling them in one shared bucket let any client exhaust it for all others.
      */
-    const call = (name, args, instanceId, sessionId) => {
+    const call = (name, args, instanceId, caller) => {
         if (instanceId !== UNKNOWN_INSTANCE) {
             const wait = instanceLimiter.take(`instance:${instanceId}`);
             if (wait)
                 throw rateLimited(wait, `instance '${instanceId}'`);
         }
-        return callTool(name, args, instanceId, sessionId);
+        return callTool(name, args, instanceId, caller);
     };
     const server = http.createServer(async (req, res) => {
         const method = req.method || "GET";
@@ -487,27 +675,6 @@ export async function createDaemonServer(options) {
             if (method === "GET" && path === "/api/tools") {
                 return jsonResponse(res, 200, { tools: TOOL_DEFINITIONS });
             }
-            if (method === "POST" && path === "/api/sessions/register") {
-                const input = sessionRegistrationSchema.parse(await parseBody(req));
-                let session;
-                try {
-                    session = SessionStore.register(input);
-                }
-                catch (e) {
-                    throw new HttpError(400, e instanceof Error ? e.message : String(e));
-                }
-                return jsonResponse(res, 200, { ok: true, session });
-            }
-            if (method === "POST" && path === "/api/sessions/disconnect") {
-                const input = sessionDisconnectSchema.parse(await parseBody(req));
-                try {
-                    SessionStore.disconnect(input.sessionId, input.instanceId);
-                }
-                catch (e) {
-                    throw new HttpError(400, e instanceof Error ? e.message : String(e));
-                }
-                return jsonResponse(res, 200, { ok: true });
-            }
             // Tool call dispatcher  ← core endpoint
             if (method === "POST" && path === "/api/tools/call") {
                 const body = await parseBody(req);
@@ -519,12 +686,27 @@ export async function createDaemonServer(options) {
                 if (!isToolName(toolName)) {
                     return jsonResponse(res, 404, { ok: false, error: `Unknown tool: '${toolName}'` });
                 }
-                return jsonResponse(res, 200, { ok: true, result: await call(toolName, args, instanceId, sessionActor(body)) });
+                return jsonResponse(res, 200, { ok: true, result: await call(toolName, args, instanceId, callerOf(body)) });
+            }
+            // Client hook events. Hooks name no instance, so only the per-address limit above applies.
+            if (method === "POST" && path === "/api/hook") {
+                const body = await parseBody(req);
+                const hook = hookRequestSchema.safeParse(body);
+                if (!hook.success)
+                    return jsonResponse(res, 400, { ok: false, error: `Invalid hook request:\n${z.prettifyError(hook.error)}` });
+                // A listening Stop hook is held open; the client killing the hook or the daemon closing ends the wait.
+                const gone = new AbortController();
+                res.on("close", () => { if (!res.writableEnded)
+                    gone.abort(); });
+                const output = await handleHook(hook.data.client, hook.data.input, listenWaitMs, AbortSignal.any([gone.signal, closing.signal]));
+                if (gone.signal.aborted)
+                    return;
+                return jsonResponse(res, 200, { output }, closing.signal.aborted ? { Connection: "close" } : {});
             }
             // Messages
             if (method === "POST" && path === "/api/messages/send") {
                 const body = await parseBody(req);
-                return jsonResponse(res, 200, await call("send_message", body, actor(body), sessionActor(body)));
+                return jsonResponse(res, 200, await call("send_message", body, actor(body)));
             }
             if (method === "GET" && path === "/api/messages/unread") {
                 const result = await call("read_messages", queryArgs(url, ["count"]), url.searchParams.get("instanceId") || UNKNOWN_INSTANCE);
@@ -664,5 +846,13 @@ export async function createDaemonServer(options) {
             jsonResponse(res, 500, { ok: false, error: message });
         }
     });
+    // server.close() waits for in-flight requests, and a listening Stop hook stays open
+    // for minutes: release those first so a shutdown is not held up by them.
+    const closing = new AbortController();
+    const close = server.close.bind(server);
+    server.close = (callback) => {
+        closing.abort();
+        return close(callback);
+    };
     return { server };
 }

package/build/daemon/tool-outputs.js

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { MESSAGE_CATEGORIES } from "../types.js";
 import { TASK_STATUSES } from "../storage/tasks.js";
+import { AGENT_STATUSES, HOOK_CLIENTS } from "./hook-contract.js";
 /**
  * Result contracts, one per tool. Every result passes through its contract on
  * the way out of the daemon (`finalizeResult`): undeclared fields are stripped
@@ -12,19 +13,14 @@ import { TASK_STATUSES } from "../storage/tasks.js";
  * 2025-era clients require.
  */
 const ack = { ok: z.literal(true), message: z.string() };
-const sessionSchema = z.object({
-    sessionId: z.string(), instanceId: z.string(), name: z.string(),
-    clientName: z.string(), workspace: z.string(), projectId: z.string().nullable(),
-    inbound: z.enum(["accept", "refuse"]), reception: z.literal("pull"),
-    online: z.boolean(), createdAt: z.string(), lastSeenAt: z.string()
+const agentStatus = z.enum(AGENT_STATUSES);
+const agentProfileSchema = z.object({
+    id: z.string(), name: z.string(), client: z.enum(HOOK_CLIENTS), cwd: z.string(),
+    note: z.string(), status: agentStatus, lastActiveAt: z.string()
 });
-const deliveryStatus = z.enum(["accepted", "fetched", "acknowledged", "replied", "refused", "expired"]);
-const directMessageSchema = z.object({
-    messageId: z.string(), from: z.string(), to: z.string(), text: z.string(),
-    category: z.enum(MESSAGE_CATEGORIES).optional(), replyTo: z.string().nullable(),
-    status: deliveryStatus, createdAt: z.string(), expiresAt: z.string(),
-    fetchedAt: z.string().nullable(), acknowledgedAt: z.string().nullable(),
-    repliedAt: z.string().nullable(), reason: z.string().nullable()
+const sentDirectSchema = z.object({
+    messageId: z.string(),
+    to: z.object({ id: z.string(), name: z.string(), status: agentStatus })
 });
 const messageSchema = z.object({
     id: z.number().int().optional(),
@@ -94,19 +90,26 @@ export const TOOL_OUTPUT_SCHEMAS = {
         manifest: storedManifest,
         internalDocs: z.string().optional()
     }),
-    list_sessions: z.object({ self: sessionSchema.nullable(), sessions: z.array(sessionSchema), count: z.number().int() }),
-    update_session: z.object({ session: sessionSchema }),
-    read_inbox: z.object({ sessionId: z.string(), messages: z.array(directMessageSchema), count: z.number().int() }),
-    get_message: z.object({ message: directMessageSchema }),
-    acknowledge_message: z.object({ message: directMessageSchema }),
+    peers: z.object({ self: agentProfileSchema, peers: z.array(agentProfileSchema) }),
+    send: sentDirectSchema,
+    read: z.object({
+        messages: z.array(z.object({
+            messageId: z.string(),
+            from: z.object({ id: z.string(), name: z.string() }),
+            replyTo: z.string().nullable(),
+            text: z.string(),
+            createdAt: z.string()
+        })),
+        remaining: z.number().int().describe("Unread messages left after this batch")
+    }),
+    reply: sentDirectSchema,
+    listen: z.object({ listening: z.boolean() }),
+    set_profile: z.object({ profile: agentProfileSchema }),
     send_message: z.object({
         ...ack,
-        sentTo: z.enum(["meeting", "global", "session"]),
+        sentTo: z.enum(["meeting", "global"]),
         meetingId: z.string().optional(),
-        messageId: z.union([z.number().int(), z.string()]).optional(),
-        status: deliveryStatus.optional(),
-        to: z.string().optional(),
-        replyTo: z.string().nullable().optional()
+        messageId: z.number().int().optional()
     }),
     read_messages: z.object({
         source: z.enum(["meeting", "global"]),