@okostream/mcp 0.11.0 → 0.11.2

package/dist/tools.js

@@ -1,3491 +1,38 @@
-import { lookup } from "node:dns/promises";
-import { stat, readFile, realpath } from "node:fs/promises";
-import { homedir } from "node:os";
-import { isAbsolute, join, relative, resolve, sep } from "node:path";
-import { randomBytes, randomUUID } from "node:crypto";
-import { Agent, fetch as undiciFetch } from "undici";
-import { z } from "zod";
-import { addDoc, collection, deleteDoc, deleteField, documentId, doc, getDoc, getDocs, limit, orderBy, query, runTransaction as runFirestoreTransaction, serverTimestamp, setDoc, startAfter, Timestamp, updateDoc, where, } from "firebase/firestore";
-import { get, endBefore, limitToLast, orderByKey, push, query as dbQuery, ref, remove, runTransaction, serverTimestamp as rtdbServerTimestamp, set, update, } from "firebase/database";
-import { httpsCallable } from "firebase/functions";
-import { authErrorResult, currentScopes, ensureAuth, getConnectionStatus, OkoAuthError, } from "./auth.js";
-import { env } from "./env.js";
-import { ipLiteralFamily, isPublicUnicastAddress, normalizeIpLiteralHostname, } from "./networkPolicy.js";
-import { chatRtdb, firestore, functions, rtdb } from "./firebase.js";
-import { OKO_CONNECTION_STATUSES } from "./onboarding.js";
-import { summarizeSessionRepair } from "./sessionRepair.js";
-import { canonicalTelegramChannelSchema, telegramChannelSchema, } from "./telegramChannelSchema.js";
-import { csvCell, requireConfirm, safeString, serialize, textResult } from "./utils.js";
-import { detectAndNormalize, extractIframeSrc } from "./videoUrl.js";
-const boolOrNull = z.boolean().nullable();
-const IMAGE_KINDS = ["promoBanner", "videoPlaceholder", "card"];
-const IMAGE_VARIANT_NAMES = ["thumb_320.webp", "card_800.webp", "hero_1600.webp"];
-const CARD_IMAGE_RATIOS = ["auto", "1:1", "4:3", "3:2", "16:9", "2:3", "3:4"];
-const CARD_ID_PATTERN = /^[A-Za-z0-9_-]{1,80}$/;
-const MAX_CARD_ITEMS = 6;
-const MAX_CARD_TITLE_LENGTH = 160;
-const MAX_CARD_TEXT_LENGTH = 500;
-const MAX_CARD_BUTTON_LABEL_LENGTH = 80;
-const MAX_CARD_BUTTON_URL_LENGTH = 1000;
-const MAX_SOURCE_IMAGE_BYTES = 15 * 1024 * 1024;
-const REMOTE_IMAGE_TIMEOUT_MS = 15_000;
-const REMOTE_IMAGE_MAX_REDIRECTS = 3;
-const ALLOWED_REMOTE_IMAGE_TYPES = new Set(["image/jpeg", "image/jpg", "image/png", "image/webp", "image/gif", "image/avif"]);
-const DEFAULT_LIST_LIMIT = 30;
-const MAX_LIST_LIMIT = 100;
-const MAX_EXPORT_LIMIT = 200;
-const ANALYTICS_DEFAULT_LIMIT = 10;
-const ANALYTICS_TIMELINE_DEFAULT_LIMIT = 120;
-const MAX_WORKSPACE_NAME_LENGTH = 120;
-const MAX_WORKSPACE_INVITE_CODE_LENGTH = 64;
-const TELEGRAM_POST_STATUSES = ["draft", "scheduled", "sent", "failed", "delivery_unknown"];
-const readOnlyTool = {
-    readOnlyHint: true,
-    destructiveHint: false,
-    idempotentHint: true,
-    openWorldHint: true,
-};
-const writeTool = {
-    readOnlyHint: false,
-    destructiveHint: false,
-    idempotentHint: false,
-    openWorldHint: true,
-};
-const idempotentWriteTool = {
-    readOnlyHint: false,
-    destructiveHint: false,
-    idempotentHint: true,
-    openWorldHint: true,
-};
-const destructiveTool = {
-    readOnlyHint: false,
-    destructiveHint: true,
-    idempotentHint: false,
-    openWorldHint: true,
-};
-const unknownRecordSchema = z.record(z.unknown());
-const basicEventOutputSchema = z.object({
-    eventId: z.string(),
-}).passthrough();
-const updateOutputSchema = z.object({
-    id: z.string().optional(),
-    eventId: z.string().optional(),
-    updated: z.array(z.string()).optional(),
-}).passthrough();
-const eventLinksOutputShape = {
-    url: z.string().url(),
-    setupUrl: z.string().url(),
-    analyticsUrl: z.string().url(),
-};
-const createWebinarOutputSchema = z.object({
-    id: z.string(),
-    workspaceId: z.string(),
-    sourceEventId: z.string().optional(),
-    ...eventLinksOutputShape,
-}).passthrough();
-const connectionStatusOutputSchema = z.object({
-    connected: z.boolean(),
-    status: z.enum(OKO_CONNECTION_STATUSES),
-    errorCode: z.string().nullable(),
-    message: z.string(),
-    product: z.object({
-        name: z.string(),
-        summary: z.string(),
-        videoBoundary: z.string(),
-        accountRequirement: z.string(),
-        accessModel: z.string(),
-    }),
-    organizerAccountRequired: z.boolean(),
-    credentialConfigured: z.boolean(),
-    links: z.object({
-        website: z.string().url(),
-        signIn: z.string().url(),
-        installCenter: z.string().url(),
-    }),
-    nextSteps: z.array(z.object({
-        id: z.string(),
-        label: z.string(),
-        url: z.string().url().optional(),
-        command: z.string().optional(),
-    })),
-    minimumVersion: z.string().optional(),
-    uid: z.string().optional(),
-    scopes: z.array(z.string()).optional(),
-});
-const cursorMetaSchema = {
-    count: z.number().int().nonnegative(),
-    limit: z.number().int().positive(),
-    hasMore: z.boolean(),
-    nextCursor: z.string().nullable(),
-    has_more: z.boolean(),
-    next_cursor: z.string().nullable(),
-};
-const workspacesOutputSchema = z.object({
-    workspaces: z.array(unknownRecordSchema),
-    count: z.number().int().nonnegative(),
-}).passthrough();
-const eventsOutputSchema = z.object({
-    events: z.array(unknownRecordSchema),
-    ...cursorMetaSchema,
-}).passthrough();
-const eventOutputSchema = z.object({
-    id: z.string(),
-    ...eventLinksOutputShape,
-}).passthrough();
-const liveStateOutputSchema = z.object({
-    eventId: z.string(),
-    agg: unknownRecordSchema,
-    ctrl: unknownRecordSchema,
-    chat: unknownRecordSchema,
-}).passthrough();
-const analyticsOutputSchema = z.object({
-    sessions: z.array(unknownRecordSchema),
-    ...cursorMetaSchema,
-}).passthrough();
-const chatOutputSchema = z.object({
-    messages: z.array(unknownRecordSchema),
-    ...cursorMetaSchema,
-}).passthrough();
-const leadsOutputSchema = z.object({
-    leads: z.array(unknownRecordSchema).optional(),
-    csv: z.string().optional(),
-    ...cursorMetaSchema,
-}).passthrough();
-const imageOutputSchema = z.object({
-    eventId: z.string(),
-    kind: z.enum(IMAGE_KINDS),
-    imageId: z.string(),
-    storagePath: z.string(),
-    masterUrl: z.string().url(),
-    variantsPending: z.boolean(),
-    sourceBytes: z.number().int().nonnegative(),
-    masterBytes: z.number().int().nonnegative(),
-    imageWidth: z.number().int().positive(),
-    imageHeight: z.number().int().positive(),
-    note: z.string(),
-}).passthrough();
-const deleteImageOutputSchema = z.object({
-    eventId: z.string(),
-    kind: z.enum(IMAGE_KINDS),
-    imageId: z.string().nullable(),
-    deleted: z.boolean(),
-    storageDeletesAttempted: z.number().int().nonnegative(),
-    storageDeleteWarnings: z.array(z.string()),
-}).passthrough();
-const imageVariantsOutputSchema = z.object({
-    eventId: z.string(),
-    kind: z.enum(IMAGE_KINDS),
-    cardId: z.string().nullable(),
-    imageId: z.string().nullable(),
-    imageUrl: z.string().url().nullable(),
-    imageMasterUrl: z.string().url().nullable(),
-    imageVariants: unknownRecordSchema.nullable(),
-    ready: z.boolean(),
-    reason: z.string().nullable(),
-    elapsedMs: z.number().int().nonnegative(),
-}).passthrough();
-const cardImagesBatchOutputSchema = z.object({
-    eventId: z.string(),
-    uploads: z.array(unknownRecordSchema),
-    variants: z.array(unknownRecordSchema),
-    ready: z.boolean(),
-    warnings: z.array(z.string()),
-}).passthrough();
-const setupValidationOutputSchema = z.object({
-    eventId: z.string(),
-    ok: z.boolean(),
-    score: z.number().int().min(0).max(100),
-    errors: z.array(unknownRecordSchema),
-    warnings: z.array(unknownRecordSchema),
-    suggestions: z.array(unknownRecordSchema),
-    nextActions: z.array(z.string()),
-    links: unknownRecordSchema,
-}).passthrough();
-const workspaceAccessOutputSchema = z.object({
-    workspaceId: z.string(),
-    workspace: unknownRecordSchema,
-    members: z.array(unknownRecordSchema),
-    invites: z.array(unknownRecordSchema),
-}).passthrough();
-const telegramChannelsOutputSchema = z.object({
-    channels: z.array(canonicalTelegramChannelSchema),
-    count: z.number().int().nonnegative(),
-}).passthrough();
-const telegramPostsOutputSchema = z.object({
-    posts: z.array(unknownRecordSchema),
-    ...cursorMetaSchema,
-}).passthrough();
-const sessionReportOutputSchema = z.object({
-    eventId: z.string(),
-    sessionId: z.string(),
-    reportUrl: z.string().url(),
-    markdown: z.string(),
-    session: unknownRecordSchema,
-}).passthrough();
-const profileOutputSchema = z.object({
-    uid: z.string(),
-    profile: unknownRecordSchema,
-    updated: z.array(z.string()),
-}).passthrough();
-const deleteLeadOutputSchema = z.object({
-    eventId: z.string(),
-    leadId: z.string(),
-    deleted: z.boolean(),
-}).passthrough();
-const notificationsOutputSchema = z.object({
-    notifications: z.array(unknownRecordSchema),
-    unreadCountOnPage: z.number().int().nonnegative(),
-    ...cursorMetaSchema,
-}).passthrough();
-const notificationsMarkOutputSchema = z.object({
-    markedRead: z.number().int().nonnegative(),
-    notificationIds: z.array(z.string()),
-}).passthrough();
-const formFieldSchema = z.object({
-    id: z.string().min(1).optional(),
-    label: z.string().max(120),
-    type: z.enum(["text", "tel", "email", "textarea"]).default("text"),
-    required: z.boolean().default(false),
-    placeholder: z.string().max(160).nullable().optional(),
-}).strict();
-const formSchema = z.object({
-    id: z.string().min(1).optional(),
-    title: z.string().max(160).nullable().optional(),
-    description: z.string().max(1000).nullable().optional(),
-    submitLabel: z.string().max(80).nullable().optional(),
-    successText: z.string().max(500).nullable().optional(),
-    consentText: z.string().max(500).nullable().optional(),
-    consentRequired: z.boolean().default(true),
-    fields: z.array(formFieldSchema).max(30),
-}).strict();
-const imageSourceSchema = z.object({
-    path: z.string().min(1).optional().describe("Local image path on the MCP client machine."),
-    url: z.string().url().optional().describe("HTTPS image URL to fetch from the MCP client machine."),
-}).strict().refine((source) => Boolean(source.path) !== Boolean(source.url), {
-    message: "Provide exactly one image source: path or url.",
-});
-const cardIdSchema = z.string()
-    .regex(CARD_ID_PATTERN, "Use 1-80 characters: letters, numbers, underscore, or hyphen.")
-    .describe("Stable card id. Omit to generate one; keep it to preserve images and analytics continuity.");
-const cardItemInputSchema = z.object({
-    id: cardIdSchema.optional(),
-    title: z.string().max(MAX_CARD_TITLE_LENGTH).nullable().optional(),
-    text: z.string().max(MAX_CARD_TEXT_LENGTH).nullable().optional(),
-    buttonLabel: z.string().max(MAX_CARD_BUTTON_LABEL_LENGTH).nullable().optional(),
-    buttonUrl: z.string().max(MAX_CARD_BUTTON_URL_LENGTH).nullable().optional(),
-    formId: cardIdSchema.nullable().optional(),
-}).strict();
-const profileDisplayNameSchema = z.string().max(40).nullable();
-const timezoneSchema = z.string()
-    .min(1)
-    .max(100)
-    .regex(/^[A-Za-z0-9_+./-]+$/, "Use an IANA timezone such as Europe/Moscow or UTC.");
-const cardsConfigOutputSchema = z.object({
-    eventId: z.string(),
-    updated: z.array(z.string()),
-    cards: z.object({
-        enabled: z.boolean(),
-        visibility: z.enum(["always", "hidden"]),
-        cardImageRatio: z.enum(CARD_IMAGE_RATIOS),
-        items: z.array(unknownRecordSchema),
-    }).passthrough(),
-    generatedCardIds: z.array(z.string()),
-    removedCardIds: z.array(z.string()),
-    removedCardsWithImages: z.array(z.string()),
-    preservedImageCardIds: z.array(z.string()),
-    warnings: z.array(z.string()),
-}).passthrough();
-const workspacePermissionsSchema = z.object({
-    createEvents: z.boolean().optional(),
-    editSetup: z.boolean().optional(),
-    deleteEvents: z.boolean().optional(),
-    controlLive: z.boolean().optional(),
-    moderateChat: z.boolean().optional(),
-    startSession: z.boolean().optional(),
-    viewAnalytics: z.boolean().optional(),
-    downloadReports: z.boolean().optional(),
-    sendNotifications: z.boolean().optional(),
-}).strict().default({});
-const WORKSPACE_PERMISSION_KEYS = [
-    "createEvents",
-    "editSetup",
-    "deleteEvents",
-    "controlLive",
-    "moderateChat",
-    "startSession",
-    "viewAnalytics",
-    "downloadReports",
-    "sendNotifications",
-];
-const eventIdField = z.string().min(1).describe("OKO event document id, for example KJsAku48821hB4PXTW0S.");
-const limitField = (max = MAX_LIST_LIMIT, defaultValue = DEFAULT_LIST_LIMIT) => z.number().int().min(1).max(max).default(defaultValue).describe(`Maximum items to return, 1-${max}.`);
-const cursorField = z.string().min(1).optional().describe("Cursor returned as nextCursor by the previous page.");
-function toolDescription({ summary, args = [], returns, examples = [], notes = [], }) {
-    return [
-        summary,
-        args.length ? `Args:\n${args.map((item) => `- ${item}`).join("\n")}` : "",
-        `Returns:\n- ${returns}`,
-        examples.length ? `Examples:\n${examples.map((item) => `- ${item}`).join("\n")}` : "",
-        notes.length ? `Notes:\n${notes.map((item) => `- ${item}`).join("\n")}` : "",
-    ].filter(Boolean).join("\n\n");
-}
-function cursorMeta(count, max, hasMore, nextCursor) {
-    return {
-        count,
-        limit: max,
-        hasMore,
-        nextCursor,
-        has_more: hasMore,
-        next_cursor: nextCursor,
-    };
-}
-function pickPage(items, max) {
-    return {
-        page: items.slice(0, max),
-        hasMore: items.length > max,
-    };
-}
-function randomId() {
-    return randomUUID();
-}
-function imageStoragePath(eventId, uid, kind, imageId) {
-    return `events/${eventId}/${uid}/images/${kind}/${imageId}/master.webp`;
-}
-function storagePathFromDownloadUrl(downloadUrl) {
-    if (!downloadUrl)
-        return null;
-    const match = downloadUrl.match(/\/o\/([^?]+)/);
-    if (!match)
-        return null;
-    const encodedPath = match[1];
-    if (!encodedPath)
-        return null;
-    try {
-        return decodeURIComponent(encodedPath);
-    }
-    catch {
-        return null;
-    }
-}
-function variantPathsFromMasterPath(masterPath) {
-    if (!masterPath.endsWith("/master.webp"))
-        return [];
-    return IMAGE_VARIANT_NAMES.map((name) => masterPath.replace(/master\.webp$/, name));
-}
-function resolveLocalImagePath(inputPath) {
-    const expanded = inputPath === "~" || inputPath.startsWith("~/")
-        ? join(homedir(), inputPath.slice(2))
-        : inputPath;
-    return isAbsolute(expanded) ? resolve(expanded) : resolve(process.cwd(), expanded);
-}
-function isBlockedHostname(hostname) {
-    const host = hostname.toLowerCase();
-    return host === "localhost" || host.endsWith(".localhost") || host.endsWith(".local");
-}
-async function resolveRemoteImageAddress(url) {
-    if (url.protocol !== "https:") {
-        throw new Error("Image URL must use https://.");
-    }
-    if (url.username || url.password) {
-        throw new Error("Image URL must not include embedded credentials.");
-    }
-    if (isBlockedHostname(url.hostname)) {
-        throw new Error("Image URL host is not allowed. Use a public HTTPS image URL.");
-    }
-    const literalAddress = normalizeIpLiteralHostname(url.hostname);
-    const literalFamily = ipLiteralFamily(literalAddress);
-    if (literalFamily !== 0) {
-        if (!isPublicUnicastAddress(literalAddress)) {
-            throw new Error("Image URL points to a private/local IP address, which is not allowed.");
-        }
-        return { address: literalAddress, family: literalFamily };
-    }
-    const addresses = await lookup(url.hostname, { all: true });
-    if (addresses.length === 0 || addresses.some((item) => !isPublicUnicastAddress(item.address))) {
-        throw new Error("Image URL resolves to a non-public IP address, which is not allowed.");
-    }
-    const selected = addresses[0];
-    if (!selected || (selected.family !== 4 && selected.family !== 6)) {
-        throw new Error("Image URL host could not be resolved safely.");
-    }
-    return { address: selected.address, family: selected.family };
-}
-async function responseBufferWithLimit(response, maxBytes) {
-    const body = response.body;
-    if (!body) {
-        const bytes = Buffer.from(await response.arrayBuffer());
-        if (bytes.byteLength > maxBytes)
-            throw new Error(`Image exceeds ${Math.floor(maxBytes / 1024 / 1024)}MB limit.`);
-        return bytes;
-    }
-    const reader = body.getReader();
-    const chunks = [];
-    let total = 0;
-    try {
-        while (true) {
-            const { done, value } = await reader.read();
-            if (done)
-                break;
-            const chunk = Buffer.from(value);
-            total += chunk.byteLength;
-            if (total > maxBytes) {
-                throw new Error(`Image exceeds ${Math.floor(maxBytes / 1024 / 1024)}MB limit.`);
-            }
-            chunks.push(chunk);
-        }
-    }
-    finally {
-        reader.releaseLock();
-    }
-    return Buffer.concat(chunks, total);
-}
-async function readRemoteImage(rawUrl, redirects = 0) {
-    if (redirects > REMOTE_IMAGE_MAX_REDIRECTS) {
-        throw new Error("Image URL has too many redirects.");
-    }
-    const url = new URL(rawUrl);
-    const pinned = await resolveRemoteImageAddress(url);
-    const dispatcher = new Agent({
-        connect: {
-            lookup: (_hostname, _options, callback) => callback(null, pinned.address, pinned.family),
-        },
-    });
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), REMOTE_IMAGE_TIMEOUT_MS);
-    try {
-        const response = await undiciFetch(url, {
-            redirect: "manual",
-            signal: controller.signal,
-            headers: { accept: "image/avif,image/webp,image/png,image/jpeg,image/gif" },
-            dispatcher,
-        });
-        if (response.status >= 300 && response.status < 400) {
-            const location = response.headers.get("location");
-            if (!location)
-                throw new Error(`Image URL redirected with HTTP ${response.status} but no Location header.`);
-            return readRemoteImage(new URL(location, url).toString(), redirects + 1);
-        }
-        if (!response.ok) {
-            throw new Error(`Image URL fetch failed with HTTP ${response.status}.`);
-        }
-        const contentType = (response.headers.get("content-type") ?? "").split(";")[0]?.trim().toLowerCase();
-        if (!contentType || !contentType.startsWith("image/")) {
-            throw new Error("Image URL must return Content-Type image/*.");
-        }
-        if (!ALLOWED_REMOTE_IMAGE_TYPES.has(contentType)) {
-            throw new Error(`Image URL Content-Type ${contentType} is not supported. Use JPEG, PNG, WEBP, GIF, or AVIF.`);
-        }
-        const contentLength = Number(response.headers.get("content-length") ?? 0);
-        if (Number.isFinite(contentLength) && contentLength > MAX_SOURCE_IMAGE_BYTES) {
-            throw new Error("Image URL is larger than 15MB.");
-        }
-        return responseBufferWithLimit(response, MAX_SOURCE_IMAGE_BYTES);
-    }
-    catch (err) {
-        if (err instanceof Error && err.name === "AbortError") {
-            throw new Error("Image URL fetch timed out.");
-        }
-        throw err;
-    }
-    finally {
-        clearTimeout(timeout);
-        await dispatcher.close();
-    }
-}
-async function readLocalImage(inputPath) {
-    if (env.imageRoots.length === 0) {
-        throw new Error("Local image reads are disabled. Set OKO_IMAGE_ROOTS to an explicit trusted directory and restart the MCP client.");
-    }
-    const filePath = await realpath(resolveLocalImagePath(inputPath));
-    const roots = await Promise.all(env.imageRoots.map(async (root) => {
-        try {
-            return await realpath(root);
-        }
-        catch {
-            return resolve(root);
-        }
-    }));
-    const allowed = roots.some((root) => {
-        const child = relative(root, filePath);
-        return child === "" || (!child.startsWith(`..${sep}`) && child !== ".." && !isAbsolute(child));
-    });
-    if (!allowed) {
-        throw new Error("Image path is outside OKO_IMAGE_ROOTS. Add a trusted root to the MCP client environment.");
-    }
-    const info = await stat(filePath);
-    if (!info.isFile())
-        throw new Error("Image path must point to a regular file.");
-    if (info.size > MAX_SOURCE_IMAGE_BYTES)
-        throw new Error("Image file is larger than 15MB.");
-    return readFile(filePath);
-}
-async function readImageSource(source) {
-    if (source.path)
-        return readLocalImage(source.path);
-    if (source.url)
-        return readRemoteImage(source.url);
-    throw new Error("Provide image source path or url.");
-}
-function readImageRef(eventData, kind, cardId) {
-    const blocks = (eventData.blocks && typeof eventData.blocks === "object" ? eventData.blocks : {});
-    if (kind === "promoBanner") {
-        const banner = (blocks.promoBanner && typeof blocks.promoBanner === "object" ? blocks.promoBanner : {});
-        return {
-            imageId: storagePathFromDownloadUrl(safeString(banner.imageMasterUrl))?.split("/").at(-2) ?? null,
-            imageUrl: safeString(banner.imageUrl) || null,
-            imageMasterUrl: safeString(banner.imageMasterUrl) || null,
-            imageVariants: readImageVariants(banner.imageVariants),
-        };
-    }
-    if (kind === "videoPlaceholder") {
-        const video = (blocks.video && typeof blocks.video === "object" ? blocks.video : {});
-        const placeholder = (video.placeholder && typeof video.placeholder === "object" ? video.placeholder : {});
-        return {
-            imageId: storagePathFromDownloadUrl(safeString(placeholder.imageMasterUrl))?.split("/").at(-2) ?? null,
-            imageUrl: safeString(placeholder.imageUrl) || null,
-            imageMasterUrl: safeString(placeholder.imageMasterUrl) || null,
-            imageVariants: readImageVariants(placeholder.imageVariants),
-        };
-    }
-    if (!cardId)
-        throw new Error("cardId is required when kind is card.");
-    const cards = (blocks.cards && typeof blocks.cards === "object" ? blocks.cards : {});
-    const items = Array.isArray(cards.items) ? cards.items : [];
-    const item = items.find((raw) => Boolean(raw) && typeof raw === "object" && raw.id === cardId);
-    if (!item)
-        throw new Error(`Card ${cardId} not found in blocks.cards.items. Create/configure the card before uploading its image.`);
-    return {
-        imageId: cardId,
-        imageUrl: safeString(item.imageUrl) || null,
-        imageMasterUrl: safeString(item.imageMasterUrl) || null,
-        imageVariants: readImageVariants(item.imageVariants),
-    };
-}
-function cardItemsWithImage(eventData, cardId, patch) {
-    const blocks = (eventData.blocks && typeof eventData.blocks === "object" ? eventData.blocks : {});
-    const cards = (blocks.cards && typeof blocks.cards === "object" ? blocks.cards : {});
-    const items = Array.isArray(cards.items) ? cards.items : [];
-    let found = false;
-    const next = items.map((raw) => {
-        const item = (raw && typeof raw === "object" ? raw : {});
-        if (item.id !== cardId)
-            return item;
-        found = true;
-        return { ...item, ...patch };
-    });
-    if (!found)
-        throw new Error(`Card ${cardId} not found in blocks.cards.items.`);
-    return next;
-}
-function readImageVariants(value) {
-    if (!value || typeof value !== "object" || Array.isArray(value))
-        return null;
-    const data = value;
-    if (typeof data.thumbUrl !== "string" || typeof data.cardUrl !== "string" || typeof data.heroUrl !== "string") {
-        return null;
-    }
-    return {
-        thumbUrl: data.thumbUrl,
-        cardUrl: data.cardUrl,
-        heroUrl: data.heroUrl,
-    };
-}
-function readCardsConfig(eventData) {
-    const blocks = (eventData.blocks && typeof eventData.blocks === "object" ? eventData.blocks : {});
-    const raw = (blocks.cards && typeof blocks.cards === "object" ? blocks.cards : {});
-    const rawItems = Array.isArray(raw.items) ? raw.items : [];
-    const items = rawItems
-        .filter((item) => Boolean(item) && typeof item === "object" && !Array.isArray(item))
-        .map((item) => {
-        const fallbackId = randomUUID();
-        return {
-            id: typeof item.id === "string" && CARD_ID_PATTERN.test(item.id) ? item.id : fallbackId,
-            title: safeString(item.title).trim() || null,
-            text: safeString(item.text).trim() || null,
-            buttonLabel: safeString(item.buttonLabel).trim() || null,
-            buttonUrl: safeString(item.buttonUrl).trim() || null,
-            imageUrl: safeString(item.imageUrl).trim() || null,
-            imageMasterUrl: safeString(item.imageMasterUrl).trim() || null,
-            imageVariants: readImageVariants(item.imageVariants),
-            imageWidth: typeof item.imageWidth === "number" ? item.imageWidth : null,
-            imageHeight: typeof item.imageHeight === "number" ? item.imageHeight : null,
-            formId: safeString(item.formId).trim() || null,
-        };
-    });
-    const ratio = safeString(raw.cardImageRatio);
-    return {
-        enabled: raw.enabled === true,
-        visibility: raw.visibility === "hidden" ? "hidden" : "always",
-        cardImageRatio: CARD_IMAGE_RATIOS.includes(ratio) ? ratio : "16:9",
-        items,
-    };
-}
-function normalizeNullableText(value) {
-    if (value == null)
-        return null;
-    return value.trim() || null;
-}
-function normalizeCardButtonUrl(value) {
-    const trimmed = normalizeNullableText(value);
-    if (!trimmed)
-        return null;
-    let url;
-    try {
-        url = new URL(trimmed);
-    }
-    catch {
-        throw new Error(`Invalid card buttonUrl "${trimmed}". Use http(s), mailto, tel, or set formId instead.`);
-    }
-    if (!["http:", "https:", "mailto:", "tel:"].includes(url.protocol)) {
-        throw new Error(`Unsupported card buttonUrl protocol "${url.protocol}". Use http(s), mailto, tel, or set formId instead.`);
-    }
-    return trimmed;
-}
-function eventFormIds(eventData) {
-    const rawForms = Array.isArray(eventData.forms) ? eventData.forms : [];
-    return new Set(rawForms
-        .map((form) => form && typeof form === "object" && !Array.isArray(form) ? safeString(form.id).trim() : "")
-        .filter(Boolean));
-}
-function cardHasImage(item) {
-    return Boolean(item.imageMasterUrl || item.imageUrl || item.imageVariants);
-}
-function buildCardsItems({ inputs, existing, formIds, }) {
-    const existingById = new Map(existing.map((item) => [item.id, item]));
-    const seen = new Set();
-    const generatedCardIds = [];
-    const preservedImageCardIds = [];
-    const items = inputs.map((input) => {
-        const id = input.id ?? randomUUID();
-        if (seen.has(id))
-            throw new Error(`Duplicate card id "${id}". Each card id must be unique.`);
-        seen.add(id);
-        if (!CARD_ID_PATTERN.test(id))
-            throw new Error(`Invalid card id "${id}". Use 1-80 characters: letters, numbers, underscore, or hyphen.`);
-        if (!input.id)
-            generatedCardIds.push(id);
-        const formId = normalizeNullableText(input.formId);
-        if (formId && !formIds.has(formId)) {
-            throw new Error(`Form ${formId} not found in event.forms. Create it with oko_configure_blocks forms first, or set formId:null.`);
-        }
-        const previous = existingById.get(id);
-        if (previous && cardHasImage(previous))
-            preservedImageCardIds.push(id);
-        return {
-            id,
-            title: normalizeNullableText(input.title),
-            text: normalizeNullableText(input.text),
-            buttonLabel: normalizeNullableText(input.buttonLabel),
-            buttonUrl: normalizeCardButtonUrl(input.buttonUrl),
-            imageUrl: previous?.imageUrl ?? null,
-            imageMasterUrl: previous?.imageMasterUrl ?? null,
-            imageVariants: previous?.imageVariants ?? null,
-            imageWidth: previous?.imageWidth ?? null,
-            imageHeight: previous?.imageHeight ?? null,
-            formId,
-        };
-    });
-    return { items, generatedCardIds, preservedImageCardIds };
-}
-async function deleteStoragePaths(eventId, paths) {
-    const uniquePaths = [...new Set(paths.filter(Boolean))];
-    if (uniquePaths.length === 0)
-        return [];
-    const removeImages = httpsCallable(functions, "deleteMcpImages");
-    const result = await removeImages({ eventId, paths: uniquePaths });
-    return Array.isArray(result.data.warnings) ? result.data.warnings : [];
-}
-async function deleteStorageUrls(eventId, masterUrl, fallbackUrl) {
-    const paths = [];
-    const masterPath = storagePathFromDownloadUrl(masterUrl);
-    if (masterPath) {
-        paths.push(masterPath, ...variantPathsFromMasterPath(masterPath));
-    }
-    else {
-        const fallbackPath = storagePathFromDownloadUrl(fallbackUrl);
-        if (fallbackPath)
-            paths.push(fallbackPath);
-    }
-    const warnings = await deleteStoragePaths(eventId, paths);
-    return { attempted: [...new Set(paths)].length, warnings };
-}
-async function uploadMasterImage(eventId, kind, cardId, image) {
-    const uploadImage = httpsCallable(functions, "uploadMcpImage");
-    const result = await uploadImage({
-        eventId,
-        kind,
-        ...(cardId ? { cardId } : {}),
-        imageBase64: image.toString("base64"),
-    });
-    return result.data;
-}
-async function updateCardImageInTransaction(eventId, cardId, patch) {
-    const eventRef = doc(firestore, "events", eventId);
-    await runFirestoreTransaction(firestore, async (transaction) => {
-        const snap = await transaction.get(eventRef);
-        if (!snap.exists())
-            throw new Error("Event not found.");
-        const data = snap.data();
-        transaction.update(eventRef, {
-            "blocks.cards.items": cardItemsWithImage(data, cardId, patch),
-        });
-    });
-}
-function imageVariantReason(ref) {
-    if (!ref.imageMasterUrl && !ref.imageUrl)
-        return "image_missing";
-    if (!ref.imageMasterUrl)
-        return "master_missing";
-    if (!ref.imageVariants)
-        return "variants_pending";
-    if (!ref.imageUrl)
-        return "image_url_pending";
-    return null;
-}
-function imageVariantStatus(eventId, eventData, kind, cardId, elapsedMs) {
-    const ref = readImageRef(eventData, kind, cardId ?? undefined);
-    const reason = imageVariantReason(ref);
-    return {
-        eventId,
-        kind,
-        cardId,
-        imageId: ref.imageId,
-        imageUrl: ref.imageUrl,
-        imageMasterUrl: ref.imageMasterUrl,
-        imageVariants: ref.imageVariants,
-        ready: reason === null,
-        reason,
-        elapsedMs,
-    };
-}
-function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
-async function waitForImageVariantTargets(uid, eventId, targets, timeoutSec) {
-    const startedAt = Date.now();
-    const deadline = startedAt + timeoutSec * 1000;
-    let latest = targets.map((target) => ({
-        eventId,
-        kind: target.kind,
-        cardId: target.cardId,
-        imageId: target.cardId,
-        imageUrl: null,
-        imageMasterUrl: null,
-        imageVariants: null,
-        ready: false,
-        reason: "not_checked",
-        elapsedMs: 0,
-    }));
-    while (true) {
-        const elapsedMs = Date.now() - startedAt;
-        const event = await readEvent(eventId, uid, "read");
-        latest = targets.map((target) => imageVariantStatus(eventId, event, target.kind, target.cardId, elapsedMs));
-        if (latest.every((item) => item.ready) || Date.now() >= deadline)
-            return latest;
-        await sleep(Math.min(2000, Math.max(250, deadline - Date.now())));
-    }
-}
-async function uploadEventImageForUser(uid, eventId, kind, cardId, source) {
-    if (kind === "card" && !cardId)
-        throw new Error("cardId is required when kind is card.");
-    if (kind !== "card" && cardId)
-        throw new Error("cardId is only valid when kind is card.");
-    const event = await readEvent(eventId, uid, "edit");
-    const previous = readImageRef(event, kind, cardId);
-    const sourceBuffer = await readImageSource(source);
-    const previousMasterPath = storagePathFromDownloadUrl(previous.imageMasterUrl);
-    const deleteWarnings = [];
-    let deletesAttempted = 0;
-    const expectedCardPath = kind === "card" ? imageStoragePath(eventId, uid, kind, cardId) : null;
-    if (expectedCardPath && previousMasterPath === expectedCardPath) {
-        const variantPaths = variantPathsFromMasterPath(expectedCardPath);
-        deletesAttempted += variantPaths.length;
-        deleteWarnings.push(...await deleteStoragePaths(eventId, variantPaths));
-    }
-    let uploaded = null;
-    try {
-        uploaded = await uploadMasterImage(eventId, kind, cardId, sourceBuffer);
-    }
-    catch (err) {
-        if (uploaded) {
-            await deleteStoragePaths(eventId, [uploaded.storagePath, ...variantPathsFromMasterPath(uploaded.storagePath)]).catch(() => []);
-        }
-        throw err;
-    }
-    if (!uploaded)
-        throw new Error("Image upload did not return a result.");
-    if (kind !== "card" || (previousMasterPath && previousMasterPath !== uploaded.storagePath) || (!previous.imageMasterUrl && previous.imageUrl)) {
-        const cleanup = await deleteStorageUrls(eventId, previous.imageMasterUrl, previous.imageUrl);
-        deletesAttempted += cleanup.attempted;
-        deleteWarnings.push(...cleanup.warnings);
-    }
-    return {
-        eventId,
-        kind,
-        imageId: uploaded.imageId,
-        storagePath: uploaded.storagePath,
-        masterUrl: uploaded.masterUrl,
-        variantsPending: true,
-        sourceBytes: sourceBuffer.byteLength,
-        masterBytes: uploaded.masterBytes,
-        imageWidth: uploaded.imageWidth,
-        imageHeight: uploaded.imageHeight,
-        note: "Image master uploaded. CF generateImageVariants should publish thumb/card/hero variants and update imageUrl/imageVariants in about 10-30 seconds.",
-        storageDeletesAttempted: deletesAttempted,
-        storageDeleteWarnings: deleteWarnings,
-    };
-}
-async function authed(scopes) {
-    return ensureAuth(scopes);
-}
-function normalizeVideo(videoUrl) {
-    const raw = videoUrl?.trim();
-    if (!raw)
-        return { originalUrl: null, embedUrl: null };
-    const effective = extractIframeSrc(raw) ?? raw;
-    const detected = detectAndNormalize(effective);
-    if (detected.provider !== "unknown" && !detected.normalizedUrl) {
-        throw new Error(`Could not extract a valid ${detected.provider} video id from videoUrl.`);
-    }
-    return { originalUrl: raw, embedUrl: detected.normalizedUrl ?? effective };
-}
-function eventUrl(eventId) {
-    return `https://okostream.app/event/${eventId}`;
-}
-function setupUrl(eventId) {
-    return `https://okostream.app/setup/${eventId}`;
-}
-function analyticsUrl(eventId) {
-    return `https://okostream.app/analytics/${eventId}`;
-}
-function sessionReportUrl(eventId, sessionId) {
-    return `${analyticsUrl(eventId)}/report/${sessionId}`;
-}
-function eventLinks(eventId) {
-    return {
-        url: eventUrl(eventId),
-        setupUrl: setupUrl(eventId),
-        analyticsUrl: analyticsUrl(eventId),
-    };
-}
-const EVENT_ACCESS_FIELD_BY_MODE = {
-    read: "accessibleBy",
-    edit: "editors",
-    delete: "deleters",
-    live: "liveControllers",
-    session: "sessionManagers",
-    analytics: "analyticsViewers",
-    report: "reportDownloaders",
-    moderate: "chatModerators",
-    notify: "notificationSenders",
-};
-function grantAllowsMode(data, mode) {
-    const field = EVENT_ACCESS_FIELD_BY_MODE[mode];
-    return asRecord(data.capabilities)[field] === true;
-}
-function legacyEventAllowsMode(data, uid, mode) {
-    if (data.ownerId === uid)
-        return true;
-    const fields = mode === "read"
-        ? ["accessibleBy", "editors"]
-        : [EVENT_ACCESS_FIELD_BY_MODE[mode]];
-    return fields.some((field) => (Array.isArray(data[field]) && data[field].includes(uid)));
-}
-function isFirestorePermissionDenied(error) {
-    if (!error || typeof error !== "object")
-        return false;
-    const code = error.code;
-    return code === "permission-denied"
-        || code === "firestore/permission-denied"
-        || code === "PERMISSION_DENIED";
-}
-async function readEvent(eventId, uid, mode = "read") {
-    const [snap, grant] = await Promise.all([
-        getDoc(doc(firestore, "events", eventId)),
-        getDoc(doc(firestore, "eventAccess", uid, "grants", eventId)).catch((error) => {
-            if (!isFirestorePermissionDenied(error))
-                throw error;
-            return null;
-        }),
-    ]);
-    if (!snap.exists())
-        throw new Error("Event not found.");
-    const data = snap.data();
-    const allowed = grant === null
-        ? legacyEventAllowsMode(data, uid, mode)
-        : data.ownerId === uid || (grant.exists() && grantAllowsMode(grant.data(), mode));
-    if (!allowed) {
-        throw new Error(`Event does not grant ${mode} access to this organizer.`);
-    }
-    if (data.trashedAt && mode !== "read" && mode !== "delete") {
-        throw new Error("Event is in trash. Restore it before making changes or live actions.");
-    }
-    return data;
-}
-function asRecord(value) {
-    return value && typeof value === "object" && !Array.isArray(value) ? value : {};
-}
-function validateEventSetup(eventId, event) {
-    const errors = [];
-    const warnings = [];
-    const suggestions = [];
-    const add = (target, code, path, message) => {
-        target.push({ code, path, message });
-    };
-    const blocks = asRecord(event.blocks);
-    const forms = Array.isArray(event.forms) ? event.forms.filter((item) => item && typeof item === "object") : [];
-    const formIds = eventFormIds(event);
-    const title = safeString(event.title).trim();
-    if (!title)
-        add(errors, "title_missing", "title", "Event title is required.");
-    const video = asRecord(event.video);
-    if (!safeString(video.embedUrl).trim()) {
-        add(warnings, "video_missing", "video.embedUrl", "No normalized video URL is configured. This warning is for the organizer only and never appears as page text above other blocks. Without a video URL the player slot shows a small 'video not configured' notice, but when the video placeholder block is enabled and switched on, the placeholder fully covers that slot and viewers see only the placeholder.");
-    }
-    const meta = asRecord(event.meta);
-    const eventDateMs = toMillis(meta.eventDate);
-    if (eventDateMs == null) {
-        add(suggestions, "date_missing", "meta.eventDate", "Add the webinar date/time if it is known.");
-    }
-    else if (eventDateMs < Date.now() - 60 * 60 * 1000) {
-        add(warnings, "date_in_past", "meta.eventDate", "Configured webinar date appears to be in the past.");
-    }
-    const duplicateFormIds = new Set();
-    const seenFormIds = new Set();
-    forms.forEach((form, index) => {
-        const id = safeString(form.id).trim();
-        if (!id)
-            add(errors, "form_id_missing", `forms[${index}].id`, "Every form must have a stable id.");
-        else if (seenFormIds.has(id))
-            duplicateFormIds.add(id);
-        else
-            seenFormIds.add(id);
-        const fields = Array.isArray(form.fields) ? form.fields : [];
-        if (fields.length === 0)
-            add(warnings, "form_fields_missing", `forms[${index}].fields`, "Lead form has no fields.");
-    });
-    for (const id of duplicateFormIds)
-        add(errors, "form_id_duplicate", "forms", `Duplicate form id: ${id}.`);
-    const checkFormBinding = (path, formId) => {
-        const id = safeString(formId).trim();
-        if (id && !formIds.has(id))
-            add(errors, "form_binding_missing", path, `Referenced formId "${id}" does not exist in event.forms.`);
-    };
-    const promo = asRecord(blocks.promoBanner);
-    if (promo.enabled === true) {
-        checkFormBinding("blocks.promoBanner.formId", promo.formId);
-        if (!safeString(promo.link).trim() && !safeString(promo.formId).trim()) {
-            add(suggestions, "promo_target_missing", "blocks.promoBanner", "Enabled promo banner has no link or form binding.");
-        }
-        if (!safeString(promo.imageUrl).trim()) {
-            add(warnings, "promo_image_missing", "blocks.promoBanner.imageUrl", "Enabled promo banner has no image.");
-        }
-        else if (safeString(promo.imageMasterUrl).trim() && !readImageVariants(promo.imageVariants)) {
-            add(warnings, "promo_variants_pending", "blocks.promoBanner.imageVariants", "Promo banner image variants are not ready yet.");
-        }
-    }
-    const cta = asRecord(blocks.primaryCta);
-    if (cta.enabled === true) {
-        checkFormBinding("blocks.primaryCta.formId", cta.formId);
-        if (!safeString(cta.title).trim() && !safeString(cta.text).trim()) {
-            add(suggestions, "cta_copy_missing", "blocks.primaryCta", "Enabled CTA has no title or text.");
-        }
-        if (!safeString(cta.buttonLabel).trim()) {
-            add(warnings, "cta_button_missing", "blocks.primaryCta.buttonLabel", "Enabled CTA has no button label.");
-        }
-        if (safeString(cta.buttonLabel).trim() && !safeString(cta.buttonUrl).trim() && !safeString(cta.formId).trim()) {
-            add(warnings, "cta_target_missing", "blocks.primaryCta", "CTA button has no URL or form binding.");
-        }
-    }
-    const videoPlaceholder = asRecord(asRecord(blocks.video).placeholder);
-    if (videoPlaceholder.enabled === true && videoPlaceholder.mode === "image") {
-        if (!safeString(videoPlaceholder.imageUrl).trim()) {
-            add(warnings, "placeholder_image_missing", "blocks.video.placeholder.imageUrl", "Image placeholder mode is enabled but no image is configured.");
-        }
-        else if (safeString(videoPlaceholder.imageMasterUrl).trim() && !readImageVariants(videoPlaceholder.imageVariants)) {
-            add(warnings, "placeholder_variants_pending", "blocks.video.placeholder.imageVariants", "Video placeholder image variants are not ready yet.");
-        }
-    }
-    const cards = readCardsConfig(event);
-    if (cards.enabled) {
-        if (cards.items.length === 0)
-            add(warnings, "cards_empty", "blocks.cards.items", "Cards block is enabled but has no cards.");
-        const cardIds = new Set();
-        cards.items.forEach((card, index) => {
-            const path = `blocks.cards.items[${index}]`;
-            if (cardIds.has(card.id))
-                add(errors, "card_id_duplicate", `${path}.id`, `Duplicate card id: ${card.id}.`);
-            cardIds.add(card.id);
-            if (!card.title && !card.text)
-                add(suggestions, "card_copy_missing", path, "Card has no title or text.");
-            if (card.buttonLabel && !card.buttonUrl && !card.formId)
-                add(warnings, "card_target_missing", path, "Card button has no URL or form binding.");
-            if (card.formId && !formIds.has(card.formId))
-                add(errors, "card_form_missing", `${path}.formId`, `Referenced formId "${card.formId}" does not exist.`);
-            if (card.imageMasterUrl && !card.imageVariants)
-                add(warnings, "card_variants_pending", `${path}.imageVariants`, "Card image variants are not ready yet.");
-        });
-    }
-    const telegram = asRecord(event.telegram);
-    const telegramChannels = Array.isArray(telegram.channelIds) ? telegram.channelIds : [];
-    if (telegram.enabled === true && telegramChannels.length === 0 && typeof telegram.channelId !== "number") {
-        add(warnings, "telegram_channel_missing", "telegram.channelIds", "Telegram is enabled but no channel is configured.");
-    }
-    const nextActions = [
-        ...errors.map((item) => `Fix error: ${item.message}`),
-        ...warnings.slice(0, 5).map((item) => `Review warning: ${item.message}`),
-    ];
-    if (nextActions.length === 0)
-        nextActions.push("No blocking setup issues found.");
-    const penalty = errors.length * 25 + warnings.length * 8 + suggestions.length * 2;
-    return {
-        eventId,
-        ok: errors.length === 0,
-        score: Math.max(0, Math.min(100, 100 - penalty)),
-        errors,
-        warnings,
-        suggestions,
-        nextActions,
-        links: eventLinks(eventId),
-    };
-}
-function initialEventAccess(uid) {
-    return {
-        accessibleBy: [uid],
-        editors: [uid],
-        deleters: [uid],
-        liveControllers: [uid],
-        chatModerators: [uid],
-        sessionManagers: [uid],
-        analyticsViewers: [uid],
-        reportDownloaders: [uid],
-        notificationSenders: [uid],
-    };
-}
-async function addEventWithRtdbMirror(eventData) {
-    const eventRef = await addDoc(collection(firestore, "events"), eventData);
-    try {
-        const ensureRuntime = httpsCallable(functions, "ensureEventRuntime");
-        await ensureRuntime({ eventId: eventRef.id });
-    }
-    catch (error) {
-        console.error(`[OKO MCP] RTDB mirror deferred to onEventCreated for event ${eventRef.id}:`, error);
-    }
-    return eventRef;
-}
-async function assertCanCreateInWorkspace(uid, workspaceId) {
-    if (workspaceId === uid)
-        return;
-    const wsSnap = await getDoc(doc(firestore, "workspaces", workspaceId));
-    if (!wsSnap.exists())
-        throw new Error("Workspace not found or not readable.");
-    const wsOwnerId = safeString(wsSnap.data().ownerId);
-    if (wsOwnerId !== uid) {
-        const shareSnap = await getDoc(doc(firestore, "workspaces", workspaceId, "shares", uid));
-        const perms = (shareSnap.data()?.permissions ?? {});
-        if (!shareSnap.exists() || perms.createEvents !== true) {
-            throw new Error("This organizer lacks createEvents permission in the workspace.");
-        }
-    }
-}
-async function readWorkspaceForOwner(workspaceId, uid) {
-    const snap = await getDoc(doc(firestore, "workspaces", workspaceId));
-    if (!snap.exists())
-        throw new Error("Workspace not found.");
-    const data = snap.data();
-    if (data.ownerId !== uid)
-        throw new Error("Only the workspace owner can manage this workspace.");
-    return data;
-}
-function normalizeWorkspacePermissions(value) {
-    const out = {};
-    for (const key of WORKSPACE_PERMISSION_KEYS) {
-        if (value[key] === true)
-            out[key] = true;
-        else if (value[key] === false)
-            out[key] = false;
-    }
-    return out;
-}
-function randomInviteCode() {
-    return randomBytes(8).toString("hex").toUpperCase();
-}
-async function listVisibleWorkspaces(uid, includeShared) {
-    const out = [];
-    const ownedSnap = await getDocs(query(collection(firestore, "workspaces"), where("ownerId", "==", uid)));
-    ownedSnap.forEach((item) => out.push({ id: item.id, ...serialize(item.data()), isOwner: true }));
-    if (includeShared) {
-        const profileSnap = await getDoc(doc(firestore, "userProfiles", uid));
-        const sharedIds = (profileSnap.data()?.sharedWorkspaceIds ?? []);
-        for (const workspaceId of sharedIds) {
-            if (out.some((row) => row.id === workspaceId))
-                continue;
-            const wsSnap = await getDoc(doc(firestore, "workspaces", workspaceId));
-            const shareSnap = await getDoc(doc(firestore, "workspaces", workspaceId, "shares", uid));
-            if (wsSnap.exists())
-                out.push({ id: workspaceId, ...serialize(wsSnap.data()), isOwner: false, permissions: serialize(shareSnap.data()?.permissions ?? {}) });
-        }
-    }
-    return out;
-}
-async function getChatRole(eventId, uid) {
-    const snap = await get(ref(chatRtdb, `settings/${eventId}/roles/${uid}`));
-    return typeof snap.val() === "string" ? snap.val() : "viewer";
-}
-function csvRows(headers, rows) {
-    return [headers, ...rows].map((row) => row.map(csvCell).join(",")).join("\n");
-}
-function toMillis(value) {
-    if (typeof value === "number" && Number.isFinite(value))
-        return value;
-    if (value && typeof value === "object" && typeof value.toMillis === "function") {
-        return value.toMillis();
-    }
-    return null;
-}
-function parseTimestampCursor(cursor) {
-    const millis = Number(cursor);
-    if (Number.isFinite(millis) && millis > 0)
-        return Timestamp.fromMillis(millis);
-    const parsed = Date.parse(cursor);
-    if (Number.isFinite(parsed))
-        return Timestamp.fromMillis(parsed);
-    throw new Error("Invalid cursor. Use the nextCursor value returned by the previous page.");
-}
-function timestampCursorFrom(value) {
-    const millis = toMillis(value);
-    return millis == null ? null : String(millis);
-}
-function parseIsoBound(value, label) {
-    if (value === undefined)
-        return null;
-    const parsed = Date.parse(value);
-    if (!Number.isFinite(parsed)) {
-        throw new Error(`Invalid ${label}: expected an ISO timestamp such as 2026-08-28T00:00:00+03:00.`);
-    }
-    return Timestamp.fromMillis(parsed);
-}
-// Компактная карточка события из полного (сериализованного) документа —
-// той же формы, что grant-проекция в eventAccess.
-function compactEventFromFullDoc(event) {
-    const meta = (event.meta && typeof event.meta === "object" ? event.meta : {});
-    const telegram = (event.telegram && typeof event.telegram === "object" ? event.telegram : {});
-    return {
-        id: event.id,
-        ownerId: event.ownerId ?? null,
-        workspaceId: event.workspaceId ?? null,
-        title: event.title ?? null,
-        createdAt: event.createdAt ?? null,
-        eventDate: meta.eventDate ?? null,
-        speakerName: meta.speakerName ?? null,
-        pinned: event.pinned === true,
-        telegramEnabled: telegram.enabled === true,
-        trashed: Boolean(event.trashedAt),
-        trashedAt: event.trashedAt ?? null,
-        activeAnalyticsSessionId: event.activeAnalyticsSessionId ?? null,
-    };
-}
-function compactAnalyticsSession(raw, options) {
-    const session = serialize(raw);
-    const timeline = Array.isArray(session.timeline) ? session.timeline : null;
-    if (timeline) {
-        session.timelineBucketCount = timeline.length;
-        if (options.includeTimeline) {
-            const page = timeline.slice(-options.timelineLimit);
-            session.timeline = page;
-            session.timelineTruncated = timeline.length > page.length;
-            session.timelineReturned = page.length;
-        }
-        else {
-            delete session.timeline;
-            session.timelineOmitted = true;
-        }
-    }
-    if (!options.includeSnapshots) {
-        if (session.baselineSnapshot !== undefined) {
-            delete session.baselineSnapshot;
-            session.baselineSnapshotOmitted = true;
-        }
-        if (session.finalSnapshot !== undefined) {
-            delete session.finalSnapshot;
-            session.finalSnapshotOmitted = true;
-        }
-    }
-    delete session[["n", "moEvaluation"].join("")];
-    return session;
-}
-function numberMetric(value) {
-    return typeof value === "number" && Number.isFinite(value) ? value : null;
-}
-function formatSeconds(value) {
-    const seconds = numberMetric(value);
-    if (seconds == null)
-        return "n/a";
-    const total = Math.max(0, Math.round(seconds));
-    const h = Math.floor(total / 3600);
-    const m = Math.floor((total % 3600) / 60);
-    const s = total % 60;
-    if (h > 0)
-        return `${h}h ${String(m).padStart(2, "0")}m ${String(s).padStart(2, "0")}s`;
-    return `${m}m ${String(s).padStart(2, "0")}s`;
-}
-function formatDateTime(value) {
-    const millis = toMillis(value);
-    if (millis == null)
-        return "n/a";
-    return new Date(millis).toISOString();
-}
-function markdownMetric(label, value, suffix = "") {
-    const metric = value === null || value === undefined || value === "" ? "n/a" : String(value);
-    return `- ${label}: ${metric}${suffix}`;
-}
-function sessionReportMarkdown({ eventId, event, sessionId, session, }) {
-    const lines = [
-        `# OKO session report`,
-        "",
-        `Event: ${safeString(event.title, eventId)}`,
-        `Event URL: ${eventUrl(eventId)}`,
-        `Report URL: ${sessionReportUrl(eventId, sessionId)}`,
-        `Session: ${sessionId}`,
-        "",
-        "## Timing",
-        markdownMetric("Started", formatDateTime(session.startedAt)),
-        markdownMetric("Ended", formatDateTime(session.endedAt)),
-        markdownMetric("Duration", formatSeconds(session.durationSec)),
-        "",
-        "## Audience",
-        markdownMetric("Peak viewers", session.peakViewers),
-        markdownMetric("Unique visitors", session.uniqueVisitors),
-        markdownMetric("Views", session.viewCount),
-        markdownMetric("Average watch time", formatSeconds(session.avgTimeSec)),
-        markdownMetric("Median watch time", formatSeconds(session.medianTimeSec)),
-        "",
-        "## Engagement",
-        markdownMetric("Chat messages", session.chatMessages),
-        markdownMetric("Banner impressions", session.bannerImpressions),
-        markdownMetric("Banner clicks", session.bannerClicks),
-        markdownMetric("Banner CTR", session.bannerCtr, session.bannerCtr == null ? "" : "%"),
-        markdownMetric("CTA clicks", session.ctaClicks),
-        markdownMetric("Cards clicks", session.cardsClicks),
-    ];
-    return lines.join("\n");
-}
-const MCP_AUDIT_TARGET_KEYS = new Set([
-    "eventId", "workspaceId", "targetWorkspaceId", "sessionId", "postId",
-    "messageId", "leadId", "participantUid", "uid", "channelId", "cardId", "imageId",
-]);
-function auditTargets(args) {
-    if (!args || typeof args !== "object" || Array.isArray(args))
-        return {};
-    const targets = {};
-    for (const [key, value] of Object.entries(args)) {
-        if (!MCP_AUDIT_TARGET_KEYS.has(key))
-            continue;
-        if (typeof value === "string")
-            targets[key] = value.slice(0, 160);
-        else if (typeof value === "number" || typeof value === "boolean" || value === null)
-            targets[key] = value;
-    }
-    return targets;
-}
-async function recordToolAudit(toolName, outcome, args, startedAt, error) {
-    try {
-        const audit = httpsCallable(functions, "recordMcpToolAudit");
-        const errorCode = error && typeof error === "object" && "code" in error
-            ? String(error.code ?? "error")
-            : error instanceof Error ? error.name : null;
-        await audit({
-            toolName,
-            outcome,
-            targets: auditTargets(args),
-            durationMs: Date.now() - startedAt,
-            errorCode,
-        });
-    }
-    catch (auditError) {
-        console.error(`[oko-mcp] audit failed for ${toolName}:`, auditError instanceof Error ? auditError.message : String(auditError));
-    }
-}
+// Точка входа инструментов OKO MCP.
+//
+// Здесь нет ни одного обработчика — только порядок сборки: обёртка аудита,
+// затем одиннадцать доменов. Порядок вызовов задаёт порядок в tools/list,
+// поэтому он сохранён с дораборного файла.
+//
+// Инвентарь (63 инструмента) и области доступа описаны в public-contract.json;
+// его сверяет protocol.test, поднимая настоящий сервер.
+import { registerAccountTools } from "./tools/account.js";
+import { registerChatTools } from "./tools/chat.js";
+import { registerEventTools } from "./tools/events.js";
+import { registerImageTools } from "./tools/images.js";
+import { installToolInstrumentation } from "./tools/instrumentation.js";
+import { registerLeadTools } from "./tools/leads.js";
+import { registerLifecycleTools } from "./tools/lifecycle.js";
+import { registerLiveTools } from "./tools/live.js";
+import { registerNotificationTools } from "./tools/notifications.js";
+import { registerSessionTools } from "./tools/sessions.js";
+import { registerTelegramTools } from "./tools/telegram.js";
+import { registerWorkspaceTools } from "./tools/workspaces.js";
 export function registerTools(server) {
-    const rawRegisterTool = server.registerTool.bind(server);
-    server.registerTool = (name, config, handler) => {
-        if (typeof name !== "string" || typeof handler !== "function") {
-            return rawRegisterTool(name, config, handler);
-        }
-        const readOnly = Boolean(config && typeof config === "object"
-            && config.annotations?.readOnlyHint === true);
-        const wrapped = async (...handlerArgs) => {
-            const startedAt = Date.now();
-            try {
-                const result = await handler(...handlerArgs);
-                if (!readOnly)
-                    await recordToolAudit(name, "success", handlerArgs[0], startedAt);
-                return result;
-            }
-            catch (error) {
-                if (error instanceof OkoAuthError)
-                    return authErrorResult(error);
-                if (!readOnly)
-                    await recordToolAudit(name, "error", handlerArgs[0], startedAt, error);
-                throw error;
-            }
-        };
-        return rawRegisterTool(name, config, wrapped);
-    };
-    server.registerTool("oko_connection_status", {
-        title: "Check OKO connection",
-        description: toolDescription({
-            summary: "Check whether this MCP process is connected to an active OKO organizer account.",
-            returns: "A factual connection status, product boundary, and setup links. This tool works without OKO_API_KEY and never changes data.",
-            examples: [
-                "Use when an OKO request is made and the organizer connection state is unknown.",
-                "Use after installing the package without a key to explain the exact next setup step.",
-            ],
-            notes: ["This tool does not create accounts, invitations, or API keys."],
-        }),
-        outputSchema: connectionStatusOutputSchema,
-        annotations: readOnlyTool,
-    }, async () => textResult(await getConnectionStatus()));
-    server.registerTool("oko_whoami", {
-        title: "Who am I",
-        description: toolDescription({
-            summary: "Return the authenticated OKO organizer uid and granted MCP scopes.",
-            returns: "uid plus the exact scopes granted by OKO API key exchange. Use this before write workflows to check permissions.",
-            examples: ['Use when starting a session: call first, then choose tools allowed by "scopes".'],
-        }),
-        outputSchema: {
-            uid: z.string(),
-            scopes: z.array(z.string()),
-        },
-        annotations: readOnlyTool,
-    }, async () => {
-        const auth = await authed([]);
-        return textResult({ uid: auth.uid, scopes: currentScopes() });
-    });
-    server.registerTool("oko_update_profile", {
-        title: "Update profile",
-        description: toolDescription({
-            summary: "Update the authenticated organizer profile fields used by OKO UI.",
-            args: [
-                "displayName: optional display name, max 40 chars; null clears it.",
-                "timezone: optional IANA timezone such as Europe/Moscow or UTC.",
-            ],
-            returns: "uid, updated field names, and the resulting profile snapshot.",
-            examples: ["Use when the organizer asks to change their visible OKO name or timezone."],
-            notes: ["Edits the organizer profile that owns this key. Requires workspace:write: the key holder is not necessarily the organizer, so a read-only key must not rewrite the owner's name, avatar or timezone."],
-        }),
-        inputSchema: {
-            displayName: profileDisplayNameSchema.optional().describe("Display name, max 40 chars. Null clears it."),
-            timezone: timezoneSchema.optional().describe("IANA timezone, for example Europe/Moscow or UTC."),
-        },
-        outputSchema: profileOutputSchema,
-        annotations: idempotentWriteTool,
-    }, async ({ displayName, timezone }) => {
-        const { uid } = await authed(["workspace:write"]);
-        const patch = { updatedAt: serverTimestamp() };
-        if (displayName !== undefined)
-            patch.displayName = displayName?.trim() || null;
-        if (timezone !== undefined)
-            patch.timezone = timezone.trim();
-        const updated = Object.keys(patch).filter((key) => key !== "updatedAt");
-        if (updated.length === 0)
-            throw new Error("Provide displayName and/or timezone.");
-        const profileRef = doc(firestore, "userProfiles", uid);
-        await setDoc(profileRef, patch, { merge: true });
-        const profileSnap = await getDoc(profileRef);
-        return textResult({ uid, updated, profile: profileSnap.exists() ? serialize(profileSnap.data()) : {} });
-    });
-    server.registerTool("oko_list_workspaces", {
-        title: "List workspaces",
-        description: toolDescription({
-            summary: "List OKO workspaces visible to the authenticated organizer.",
-            args: ["includeShared: include workspaces shared with this organizer, default true."],
-            returns: "workspaces array with id, ownership flag, and permissions for shared workspaces, plus count.",
-            examples: ["Use before oko_create_webinar when the user wants to create a webinar in a shared workspace."],
-        }),
-        inputSchema: { includeShared: z.boolean().default(true).describe("Include workspaces shared with this organizer.") },
-        outputSchema: workspacesOutputSchema,
-        annotations: readOnlyTool,
-    }, async ({ includeShared }) => {
-        const { uid } = await authed(["workspace:read"]);
-        const out = await listVisibleWorkspaces(uid, includeShared);
-        return textResult({ workspaces: out, count: out.length });
-    });
-    server.registerTool("oko_create_workspace", {
-        title: "Create workspace",
-        description: toolDescription({
-            summary: "Create a shared OKO workspace owned by the authenticated organizer.",
-            args: ["name: workspace display name."],
-            returns: "workspaceId, name, and created=true.",
-            examples: ["Use when the organizer wants to create a new team/workspace for events."],
-        }),
-        inputSchema: { name: z.string().min(1).max(MAX_WORKSPACE_NAME_LENGTH).describe("Workspace name.") },
-        outputSchema: z.object({ workspaceId: z.string(), created: z.boolean() }).passthrough(),
-        annotations: writeTool,
-    }, async ({ name }) => {
-        const { uid } = await authed(["workspace:write"]);
-        const workspaceRef = await addDoc(collection(firestore, "workspaces"), {
-            name: name.trim(),
-            ownerId: uid,
-            personal: false,
-            createdAt: serverTimestamp(),
-        });
-        return textResult({ workspaceId: workspaceRef.id, name: name.trim(), created: true });
-    });
-    server.registerTool("oko_update_workspace", {
-        title: "Update workspace",
-        description: toolDescription({
-            summary: "Rename a workspace owned by the authenticated organizer.",
-            args: ["workspaceId: workspace to update.", "name: new workspace display name."],
-            returns: "workspaceId and updated fields.",
-            examples: ["Use for workspace rename requests."],
-        }),
-        inputSchema: { workspaceId: z.string().min(1), name: z.string().min(1).max(MAX_WORKSPACE_NAME_LENGTH).describe("New workspace name.") },
-        outputSchema: updateOutputSchema,
-        annotations: idempotentWriteTool,
-    }, async ({ workspaceId, name }) => {
-        const { uid } = await authed(["workspace:write"]);
-        await readWorkspaceForOwner(workspaceId, uid);
-        await updateDoc(doc(firestore, "workspaces", workspaceId), { name: name.trim() });
-        return textResult({ workspaceId, updated: ["name"] });
-    });
-    server.registerTool("oko_delete_workspace", {
-        title: "Delete workspace",
-        description: toolDescription({
-            summary: "Delete an empty non-personal workspace owned by the authenticated organizer.",
-            args: ["workspaceId: workspace to delete.", "confirm: must be true."],
-            returns: "workspaceId and deleted=true.",
-            examples: ["Use after listing workspace access and confirming the workspace is empty."],
-            notes: ["Personal workspaces cannot be deleted. This tool refuses to delete workspaces that still contain events; move/delete events first."],
-        }),
-        inputSchema: { workspaceId: z.string().min(1), confirm: z.boolean().optional().describe("Required true for workspace deletion.") },
-        outputSchema: z.object({ workspaceId: z.string(), deleted: z.boolean() }).passthrough(),
-        annotations: destructiveTool,
-    }, async ({ workspaceId, confirm }) => {
-        const { uid } = await authed(["workspace:write"]);
-        const workspace = await readWorkspaceForOwner(workspaceId, uid);
-        requireConfirm(confirm, "oko_delete_workspace", { workspaceId, name: workspace.name, personal: workspace.personal });
-        if (workspace.personal === true)
-            throw new Error("Personal workspace cannot be deleted.");
-        const eventsSnap = await getDocs(query(collection(firestore, "events"), where("workspaceId", "==", workspaceId), limit(1)));
-        if (!eventsSnap.empty)
-            throw new Error("Workspace still has events. Move or delete its events before deleting the workspace.");
-        await deleteDoc(doc(firestore, "workspaces", workspaceId));
-        return textResult({ workspaceId, deleted: true });
-    });
-    server.registerTool("oko_list_workspace_access", {
-        title: "List workspace access",
-        description: toolDescription({
-            summary: "List workspace members/shares and pending invites.",
-            args: ["workspaceId: workspace owned by the authenticated organizer."],
-            returns: "workspace document, members array, invites array.",
-            examples: ["Use before changing permissions, removing a member, or revoking an invite."],
-        }),
-        inputSchema: { workspaceId: z.string().min(1) },
-        outputSchema: workspaceAccessOutputSchema,
-        annotations: readOnlyTool,
-    }, async ({ workspaceId }) => {
-        const { uid } = await authed(["workspace:read"]);
-        const workspace = await readWorkspaceForOwner(workspaceId, uid);
-        const [sharesSnap, invitesSnap] = await Promise.all([
-            getDocs(collection(firestore, "workspaces", workspaceId, "shares")),
-            getDocs(query(collection(firestore, "workspaceInvites"), where("workspaceId", "==", workspaceId))),
-        ]);
-        const members = [];
-        for (const share of sharesSnap.docs) {
-            // Правила разрешают читать чужой профиль только владельцу платформы,
-            // поэтому на любом рабочем пространстве с участниками это чтение
-            // заканчивается отказом. Без обработки инструмент падал целиком вместо
-            // того, чтобы вернуть состав команды без необязательных профилей.
-            const profile = await getDoc(doc(firestore, "userProfiles", share.id))
-                .then((snap) => (snap.exists() ? serialize(snap.data()) : null))
-                .catch(() => null);
-            members.push({
-                uid: share.id,
-                ...serialize(share.data()),
-                profile,
-            });
-        }
-        const invites = invitesSnap.docs.map((invite) => ({ code: invite.id, ...serialize(invite.data()) }));
-        return textResult({ workspaceId, workspace: { id: workspaceId, ...serialize(workspace) }, members, invites });
-    });
-    server.registerTool("oko_update_workspace_member", {
-        title: "Update workspace member",
-        description: toolDescription({
-            summary: "Create or update a workspace share/member permissions document.",
-            args: ["workspaceId: workspace owned by the organizer.", "uid: member uid.", "permissions: 9 workspace permission booleans.", "confirm: must be true."],
-            returns: "workspaceId, uid, and updated=true.",
-            examples: ["Use to change an existing member's permissions, or direct-add a known uid."],
-            notes: ["Changing a share materializes lightweight event grants and updates RTDB workspace/chat mirrors."],
-        }),
-        inputSchema: {
-            workspaceId: z.string().min(1),
-            uid: z.string().min(1).describe("Member Firebase uid."),
-            email: z.string().email().optional().describe("Optional member email cache."),
-            comment: z.string().max(500).default(""),
-            permissions: workspacePermissionsSchema,
-            confirm: z.boolean().optional().describe("Required true for share updates."),
-        },
-        outputSchema: updateOutputSchema,
-        annotations: writeTool,
-    }, async (args) => {
-        const { uid } = await authed(["workspace:write"]);
-        const workspace = await readWorkspaceForOwner(args.workspaceId, uid);
-        requireConfirm(args.confirm, "oko_update_workspace_member", { workspaceId: args.workspaceId, workspaceName: workspace.name, targetUid: args.uid, permissions: args.permissions });
-        await setDoc(doc(firestore, "workspaces", args.workspaceId, "shares", args.uid), {
-            email: args.email ?? "",
-            comment: args.comment.trim(),
-            permissions: normalizeWorkspacePermissions(args.permissions),
-            sharedAt: serverTimestamp(),
-            sharedBy: uid,
-        }, { merge: true });
-        return textResult({ workspaceId: args.workspaceId, uid: args.uid, updated: true });
-    });
-    server.registerTool("oko_remove_workspace_member", {
-        title: "Remove workspace member",
-        description: toolDescription({
-            summary: "Remove a member/share from a workspace.",
-            args: ["workspaceId: workspace owned by the organizer.", "uid: member uid.", "confirm: must be true."],
-            returns: "workspaceId, uid, removed=true.",
-            examples: ["Use after listing workspace access and confirming the exact uid."],
-            notes: ["Removing a share revokes its event grants and RTDB workspace/chat mirrors."],
-        }),
-        inputSchema: { workspaceId: z.string().min(1), uid: z.string().min(1), confirm: z.boolean().optional().describe("Required true for member removal.") },
-        outputSchema: z.object({ workspaceId: z.string(), uid: z.string(), removed: z.boolean() }).passthrough(),
-        annotations: destructiveTool,
-    }, async ({ workspaceId, uid: targetUid, confirm }) => {
-        const { uid } = await authed(["workspace:write"]);
-        const workspace = await readWorkspaceForOwner(workspaceId, uid);
-        requireConfirm(confirm, "oko_remove_workspace_member", { workspaceId, workspaceName: workspace.name, targetUid });
-        await deleteDoc(doc(firestore, "workspaces", workspaceId, "shares", targetUid));
-        return textResult({ workspaceId, uid: targetUid, removed: true });
-    });
-    server.registerTool("oko_list_workspace_invites", {
-        title: "List workspace invites",
-        description: toolDescription({
-            summary: "List workspace invite links for a workspace owned by the organizer.",
-            args: ["workspaceId: workspace owned by the organizer."],
-            returns: "invites array with code, claim status, permissions, and inviteUrl.",
-            examples: ["Use before revoking or sharing an invite code."],
-        }),
-        inputSchema: { workspaceId: z.string().min(1) },
-        outputSchema: z.object({ workspaceId: z.string(), invites: z.array(unknownRecordSchema), count: z.number().int().nonnegative() }).passthrough(),
-        annotations: readOnlyTool,
-    }, async ({ workspaceId }) => {
-        const { uid } = await authed(["workspace:read"]);
-        await readWorkspaceForOwner(workspaceId, uid);
-        const snap = await getDocs(query(collection(firestore, "workspaceInvites"), where("workspaceId", "==", workspaceId)));
-        const invites = snap.docs.map((invite) => ({ code: invite.id, ...serialize(invite.data()), inviteUrl: `https://okostream.app/invite/${invite.id}` }));
-        return textResult({ workspaceId, invites, count: invites.length });
-    });
-    server.registerTool("oko_revoke_workspace_invite", {
-        title: "Revoke workspace invite",
-        description: toolDescription({
-            summary: "Delete a pending workspace invite code.",
-            args: ["code: invite code.", "confirm: must be true."],
-            returns: "code and revoked=true.",
-            examples: ["Use after confirming the exact invite code."],
-        }),
-        inputSchema: { code: z.string().min(4).max(MAX_WORKSPACE_INVITE_CODE_LENGTH), confirm: z.boolean().optional().describe("Required true for invite revocation.") },
-        outputSchema: z.object({ code: z.string(), revoked: z.boolean() }).passthrough(),
-        annotations: destructiveTool,
-    }, async ({ code, confirm }) => {
-        const { uid } = await authed(["workspace:write"]);
-        const normalizedCode = code.trim().toUpperCase();
-        const inviteSnap = await getDoc(doc(firestore, "workspaceInvites", normalizedCode));
-        if (!inviteSnap.exists())
-            throw new Error("Workspace invite not found.");
-        const invite = inviteSnap.data();
-        if (invite.createdBy !== uid)
-            throw new Error("Only the invite creator/workspace owner can revoke this invite.");
-        requireConfirm(confirm, "oko_revoke_workspace_invite", { code: normalizedCode, workspaceId: invite.workspaceId, claimed: invite.claimed });
-        await deleteDoc(doc(firestore, "workspaceInvites", normalizedCode));
-        return textResult({ code: normalizedCode, revoked: true });
-    });
-    server.registerTool("oko_claim_workspace_invite", {
-        title: "Claim workspace invite",
-        description: toolDescription({
-            summary: "Accept a workspace invite code for the authenticated organizer.",
-            args: ["code: invite code from /invite/{code}.", "confirm: must be true."],
-            returns: "success plus workspace id/name returned by OKO CF19.",
-            examples: ["Use when the organizer wants to join a workspace from an invite code."],
-        }),
-        inputSchema: {
-            code: z.string().min(4).max(MAX_WORKSPACE_INVITE_CODE_LENGTH),
-            confirm: z.boolean().optional().describe("Required true to join the workspace."),
-        },
-        outputSchema: z.object({
-            success: z.boolean(),
-            workspace: z.object({ id: z.string(), name: z.string() }).passthrough(),
-        }).passthrough(),
-        annotations: writeTool,
-    }, async ({ code, confirm }) => {
-        await authed(["workspace:write"]);
-        requireConfirm(confirm, "oko_claim_workspace_invite", { code: code.trim().toUpperCase() });
-        const claimInvite = httpsCallable(functions, "claimWorkspaceInvite");
-        const result = await claimInvite({ code: code.trim().toUpperCase() });
-        return textResult({ ...serialize(result.data) });
-    });
-    server.registerTool("oko_list_my_events", {
-        title: "List my events",
-        description: toolDescription({
-            summary: "List OKO events visible to the authenticated organizer.",
-            args: [
-                "limit: maximum events to return, default 30, max 100.",
-                "cursor: pagination cursor returned as nextCursor by the previous page; reuse it with the same filters.",
-                "workspaceId: optional workspace filter.",
-                'detail: "compact" (default) returns the light card projection; "full" returns complete event documents.',
-                "from/to: optional ISO timestamps bounding meta.eventDate; sorting switches to eventDate descending and undated events are excluded.",
-            ],
-            returns: "events plus count, limit, hasMore/has_more, nextCursor/next_cursor.",
-            examples: [
-                "Use limit=10 first; if hasMore is true, call again with cursor=nextCursor.",
-                'For "today\'s webinar" pass from/to covering the day; use detail="full" only when block contents are needed.',
-            ],
-        }),
-        inputSchema: {
-            limit: limitField(),
-            cursor: cursorField,
-            workspaceId: z.string().optional().describe("Optional workspace id to filter returned events."),
-            detail: z.enum(["compact", "full"]).default("compact").describe('Response shape: "compact" card projection (default) or "full" event documents.'),
-            from: z.string().optional().describe("Include only events with meta.eventDate at or after this ISO timestamp."),
-            to: z.string().optional().describe("Include only events with meta.eventDate at or before this ISO timestamp."),
-        },
-        outputSchema: eventsOutputSchema,
-        annotations: readOnlyTool,
-    }, async (args) => {
-        const { uid } = await authed(["events:read"]);
-        const fromTs = parseIsoBound(args.from, "from");
-        const toTs = parseIsoBound(args.to, "to");
-        const dateFiltered = fromTs !== null || toTs !== null;
-        const orderField = dateFiltered ? "eventDate" : "createdAt";
-        const constraints = [
-            // При датном фильтре workspaceId отсеивается по загруженной странице:
-            // составного индекса grants(workspaceId+eventDate) нет намеренно.
-            ...(!dateFiltered && args.workspaceId ? [where("workspaceId", "==", args.workspaceId)] : []),
-            ...(fromTs ? [where("eventDate", ">=", fromTs)] : []),
-            ...(toTs ? [where("eventDate", "<=", toTs)] : []),
-            orderBy(orderField, "desc"),
-            limit(args.limit + 1),
-        ];
-        if (args.cursor)
-            constraints.splice(constraints.length - 1, 0, startAfter(parseTimestampCursor(args.cursor)));
-        const snap = await getDocs(query(collection(firestore, "eventAccess", uid, "grants"), ...constraints)).catch((error) => {
-            if (!isFirestorePermissionDenied(error))
-                throw error;
-            return null;
-        });
-        if (snap !== null) {
-            const { page, hasMore } = pickPage(snap.docs, args.limit);
-            const nextCursor = hasMore ? timestampCursorFrom(page.at(-1)?.data()[orderField]) : null;
-            const pageItems = dateFiltered && args.workspaceId
-                ? page.filter((item) => item.data().workspaceId === args.workspaceId)
-                : page;
-            let events;
-            if (args.detail === "full") {
-                const eventDocuments = await Promise.all(pageItems.map((item) => (getDoc(doc(firestore, "events", item.id)))));
-                events = eventDocuments.flatMap((item) => (item.exists()
-                    ? [{ id: item.id, ...serialize(item.data()) }]
-                    : []));
-            }
-            else {
-                // Компактный режим отдаёт grant-проекцию как есть — без чтения
-                // полных документов событий.
-                events = pageItems.map((item) => {
-                    const data = serialize(item.data());
-                    delete data.schemaVersion;
-                    delete data.uid;
-                    delete data.eventId;
-                    return { id: item.id, ...data };
-                });
-            }
-            return textResult({ events, ...cursorMeta(events.length, args.limit, hasMore, nextCursor) }, { truncationHint: 'Use a smaller limit, cursor pagination, or detail="compact".' });
-        }
-        const legacyConstraints = [
-            where("accessibleBy", "array-contains", uid),
-            orderBy("createdAt", "desc"),
-            limit(args.limit + 1),
-        ];
-        if (args.cursor) {
-            legacyConstraints.splice(legacyConstraints.length - 1, 0, startAfter(parseTimestampCursor(args.cursor)));
-        }
-        const legacySnap = await getDocs(query(collection(firestore, "events"), ...legacyConstraints));
-        const { page, hasMore } = pickPage(legacySnap.docs, args.limit);
-        const fromMs = fromTs ? fromTs.toMillis() : null;
-        const toMs = toTs ? toTs.toMillis() : null;
-        const events = page
-            .map((item) => ({
-            id: item.id,
-            ...serialize(item.data()),
-        }))
-            .filter((event) => !args.workspaceId || event.workspaceId === args.workspaceId)
-            .filter((event) => {
-            if (fromMs === null && toMs === null)
-                return true;
-            const meta = (event.meta && typeof event.meta === "object" ? event.meta : {});
-            const ms = typeof meta.eventDate === "string" ? Date.parse(meta.eventDate) : NaN;
-            if (!Number.isFinite(ms))
-                return false;
-            return (fromMs === null || ms >= fromMs) && (toMs === null || ms <= toMs);
-        })
-            .map((event) => (args.detail === "full" ? event : compactEventFromFullDoc(event)));
-        const nextCursor = hasMore ? timestampCursorFrom(page.at(-1)?.data().createdAt) : null;
-        return textResult({ events, ...cursorMeta(events.length, args.limit, hasMore, nextCursor) }, { truncationHint: 'Use a smaller limit, cursor pagination, or detail="compact".' });
-    });
-    server.registerTool("oko_get_event", {
-        title: "Get event",
-        description: toolDescription({
-            summary: "Read one OKO event visible to the organizer.",
-            args: ["eventId: OKO event document id."],
-            returns: "full event document fields plus id and public event URL.",
-            examples: ["Use after oko_create_webinar to verify setup and return the event URL to the user."],
-        }),
-        inputSchema: { eventId: eventIdField },
-        outputSchema: eventOutputSchema,
-        annotations: readOnlyTool,
-    }, async ({ eventId }) => {
-        const { uid } = await authed(["events:read"]);
-        const data = await readEvent(eventId, uid, "read");
-        return textResult({ id: eventId, ...serialize(data), ...eventLinks(eventId) });
-    });
-    server.registerTool("oko_validate_event_setup", {
-        title: "Validate event setup",
-        description: toolDescription({
-            summary: "Run a read-only setup readiness lint for one OKO event.",
-            args: ["eventId: OKO event document id."],
-            returns: "ok flag, score, errors, warnings, suggestions, next actions, and useful links.",
-            examples: [
-                "Use after creating/configuring a webinar and before telling the organizer it is ready.",
-                "Use before live-session prep to catch missing video, pending image variants, and invalid form bindings.",
-            ],
-            notes: ["This tool does not modify the event and does not start/end analytics sessions."],
-        }),
-        inputSchema: { eventId: eventIdField },
-        outputSchema: setupValidationOutputSchema,
-        annotations: readOnlyTool,
-    }, async ({ eventId }) => {
-        const { uid } = await authed(["events:read"]);
-        const data = await readEvent(eventId, uid, "read");
-        return textResult(validateEventSetup(eventId, data));
-    });
-    server.registerTool("oko_create_webinar", {
-        title: "Create webinar",
-        description: toolDescription({
-            summary: "Create an OKO webinar and its required RTDB owner/workspace mirror.",
-            args: [
-                "title: webinar title.",
-                "workspaceId: optional workspace id; omitted means personal workspace.",
-                "videoUrl: optional iframe/source/player URL; normalized by OKO.",
-                "eventDate: optional ISO datetime.",
-                "chatEnabled: whether the chat block is enabled at creation.",
-            ],
-            returns: "new event id, public event URL, and workspaceId.",
-            examples: ["Use for a complete create flow, then call oko_configure_blocks and oko_get_event."],
-            notes: ["This creates an event page; OKO has no draft/live/ended event status."],
-        }),
-        inputSchema: {
-            title: z.string().min(1).max(160).describe("Webinar title shown on the public event page."),
-            workspaceId: z.string().optional().describe("Workspace id; omit for the organizer's personal workspace."),
-            videoUrl: z.string().nullable().optional().describe("Optional source/player/iframe URL to normalize."),
-            eventDate: z.string().datetime().nullable().optional().describe("Optional webinar datetime in ISO format."),
-            speakerName: z.string().max(160).nullable().optional().describe("Optional speaker display name."),
-            description: z.string().max(3000).nullable().optional().describe("Optional event description."),
-            chatEnabled: z.boolean().default(false).describe("Whether the chat block starts enabled."),
-        },
-        outputSchema: createWebinarOutputSchema,
-        annotations: writeTool,
-    }, async (args) => {
-        const { uid } = await authed(["events:write"]);
-        const workspaceId = args.workspaceId ?? uid;
-        await assertCanCreateInWorkspace(uid, workspaceId);
-        const video = normalizeVideo(args.videoUrl);
-        const docRef = await addEventWithRtdbMirror({
-            ownerId: uid,
-            workspaceId,
-            ...initialEventAccess(uid),
-            createdAt: serverTimestamp(),
-            title: args.title.trim(),
-            pinned: false,
-            video,
-            meta: {
-                eventDate: args.eventDate ? Timestamp.fromDate(new Date(args.eventDate)) : null,
-                speakerName: args.speakerName?.trim() || null,
-                description: args.description?.trim() || null,
-            },
-            blocks: {
-                chat: { enabled: args.chatEnabled, visibility: "always" },
-                promoBanner: { enabled: false, text: "", link: "", visibility: "always" },
-            },
-        });
-        return textResult({ id: docRef.id, ...eventLinks(docRef.id), workspaceId });
-    });
-    server.registerTool("oko_update_event", {
-        title: "Update event metadata",
-        description: toolDescription({
-            summary: "Update safe top-level event/setup metadata fields.",
-            args: ["eventId plus any subset of title, videoUrl, eventDate, speakerName, description, pinned, sessionMode, durationMinutes."],
-            returns: "event id and the list of Firestore fields updated.",
-            examples: ["Use for title/date/speaker/video edits; use oko_configure_blocks for blocks and forms."],
-            notes: [
-                "sessionMode 'schedule' makes OKO start and end the analytics session automatically at eventDate for durationMinutes; 'manual' keeps the Start/End buttons and a Telegram reminder 10 minutes before eventDate. This is still an analytics session, not an event status.",
-            ],
-        }),
-        inputSchema: {
-            eventId: eventIdField,
-            title: z.string().min(1).max(160).optional().describe("New webinar title."),
-            videoUrl: z.string().nullable().optional().describe("New source/player/iframe URL, or null to clear."),
-            eventDate: z.string().datetime().nullable().optional().describe("New ISO datetime, or null to clear."),
-            speakerName: z.string().max(160).nullable().optional().describe("New speaker display name, or null to clear."),
-            description: z.string().max(3000).nullable().optional().describe("New description, or null to clear."),
-            pinned: z.boolean().optional().describe("Whether this event is pinned in the dashboard."),
-            sessionMode: z.enum(["manual", "schedule"]).optional().describe("Analytics session mode: manual Start/End buttons, or automatic start/end on schedule at eventDate."),
-            durationMinutes: z.number().int().min(15).max(1440).optional().describe("Event duration in minutes (15-1440) used by schedule mode to end the session."),
-        },
-        outputSchema: updateOutputSchema,
-        annotations: writeTool,
-    }, async (args) => {
-        const requiredScopes = new Set();
-        if (args.title !== undefined || args.pinned !== undefined)
-            requiredScopes.add("events:write");
-        if (args.videoUrl !== undefined
-            || args.eventDate !== undefined
-            || args.speakerName !== undefined
-            || args.description !== undefined
-            || args.sessionMode !== undefined
-            || args.durationMinutes !== undefined) {
-            requiredScopes.add("setup:write");
-        }
-        if (requiredScopes.size === 0)
-            throw new Error("Provide at least one field to update.");
-        const { uid } = await authed([...requiredScopes]);
-        await readEvent(args.eventId, uid, "edit");
-        const patch = {};
-        if (args.title !== undefined)
-            patch.title = args.title.trim();
-        if (args.videoUrl !== undefined) {
-            const video = normalizeVideo(args.videoUrl);
-            patch["video.originalUrl"] = video.originalUrl;
-            patch["video.embedUrl"] = video.embedUrl;
-        }
-        if (args.eventDate !== undefined)
-            patch["meta.eventDate"] = args.eventDate ? Timestamp.fromDate(new Date(args.eventDate)) : null;
-        if (args.speakerName !== undefined)
-            patch["meta.speakerName"] = args.speakerName?.trim() || null;
-        if (args.description !== undefined)
-            patch["meta.description"] = args.description?.trim() || null;
-        if (args.pinned !== undefined)
-            patch.pinned = args.pinned;
-        if (args.sessionMode !== undefined)
-            patch.analyticsSessionMode = args.sessionMode;
-        if (args.durationMinutes !== undefined)
-            patch["meta.durationMinutes"] = args.durationMinutes;
-        await updateDoc(doc(firestore, "events", args.eventId), patch);
-        return textResult({ id: args.eventId, updated: Object.keys(patch) });
-    });
-    server.registerTool("oko_configure_blocks", {
-        title: "Configure event blocks",
-        description: toolDescription({
-            summary: "Configure supported event setup blocks, forms, and Telegram channel ids.",
-            args: [
-                "eventId: event to edit.",
-                "chat/promoBanner/primaryCta/videoPlaceholder: optional block patches.",
-                "forms: replaces configured lead forms when provided.",
-                "telegramChannelIds: replaces configured Telegram channels when provided.",
-            ],
-            returns: "event id and the list of Firestore fields updated.",
-            examples: ["Use after oko_create_webinar to set chat visibility, CTA/form binding, and other audience blocks."],
-            notes: [
-                "A block toggle and its image are independent: enabling a block here works with an image already uploaded via oko_upload_image, and uploading an image never enables the block by itself.",
-                "promoBanner has no text field by design: the banner is image+link. blocks.promoBanner.text seen in event documents is legacy and is never rendered on the event page.",
-            ],
-        }),
-        inputSchema: {
-            eventId: eventIdField,
-            chat: z.object({ enabled: z.boolean().optional(), visibility: z.enum(["always", "hidden"]).optional() }).optional(),
-            promoBanner: z.object({ enabled: z.boolean().optional(), link: z.string().max(1000).optional(), visibility: z.enum(["always", "hidden"]).optional(), formId: z.string().nullable().optional() }).optional(),
-            primaryCta: z.object({ enabled: z.boolean().optional(), visibility: z.enum(["always", "hidden"]).optional(), title: z.string().nullable().optional(), text: z.string().nullable().optional(), buttonLabel: z.string().nullable().optional(), buttonUrl: z.string().nullable().optional(), formId: z.string().nullable().optional() }).optional(),
-            videoPlaceholder: z.object({ enabled: z.boolean().optional(), mode: z.enum(["glass", "image"]).optional(), title: z.string().nullable().optional(), subtitle: z.string().nullable().optional(), showTimer: z.boolean().optional() }).optional(),
-            forms: z.array(formSchema).max(20).optional(),
-            telegramChannelIds: z.array(z.number().int()).max(20).optional(),
-        },
-        outputSchema: updateOutputSchema,
-        annotations: writeTool,
-    }, async (args) => {
-        const { uid } = await authed(["setup:write"]);
-        await readEvent(args.eventId, uid, "edit");
-        const patch = {};
-        if (args.chat?.enabled !== undefined)
-            patch["blocks.chat.enabled"] = args.chat.enabled;
-        if (args.chat?.visibility !== undefined)
-            patch["blocks.chat.visibility"] = args.chat.visibility;
-        if (args.promoBanner?.enabled !== undefined)
-            patch["blocks.promoBanner.enabled"] = args.promoBanner.enabled;
-        if (args.promoBanner?.link !== undefined)
-            patch["blocks.promoBanner.link"] = args.promoBanner.link;
-        if (args.promoBanner?.visibility !== undefined)
-            patch["blocks.promoBanner.visibility"] = args.promoBanner.visibility;
-        if (args.promoBanner?.formId !== undefined)
-            patch["blocks.promoBanner.formId"] = args.promoBanner.formId;
-        if (args.primaryCta?.enabled !== undefined)
-            patch["blocks.primaryCta.enabled"] = args.primaryCta.enabled;
-        if (args.primaryCta?.visibility !== undefined)
-            patch["blocks.primaryCta.visibility"] = args.primaryCta.visibility;
-        if (args.primaryCta?.title !== undefined)
-            patch["blocks.primaryCta.title"] = args.primaryCta.title?.trim() || null;
-        if (args.primaryCta?.text !== undefined)
-            patch["blocks.primaryCta.text"] = args.primaryCta.text?.trim() || null;
-        if (args.primaryCta?.buttonLabel !== undefined)
-            patch["blocks.primaryCta.buttonLabel"] = args.primaryCta.buttonLabel?.trim() || null;
-        if (args.primaryCta?.buttonUrl !== undefined)
-            patch["blocks.primaryCta.buttonUrl"] = args.primaryCta.buttonUrl?.trim() || null;
-        if (args.primaryCta?.formId !== undefined)
-            patch["blocks.primaryCta.formId"] = args.primaryCta.formId;
-        if (args.videoPlaceholder?.enabled !== undefined)
-            patch["blocks.video.placeholder.enabled"] = args.videoPlaceholder.enabled;
-        if (args.videoPlaceholder?.mode !== undefined)
-            patch["blocks.video.placeholder.mode"] = args.videoPlaceholder.mode;
-        if (args.videoPlaceholder?.title !== undefined)
-            patch["blocks.video.placeholder.title"] = args.videoPlaceholder.title?.trim() || null;
-        if (args.videoPlaceholder?.subtitle !== undefined)
-            patch["blocks.video.placeholder.subtitle"] = args.videoPlaceholder.subtitle?.trim() || null;
-        if (args.videoPlaceholder?.showTimer !== undefined)
-            patch["blocks.video.placeholder.showTimer"] = args.videoPlaceholder.showTimer;
-        if (args.forms !== undefined)
-            patch.forms = args.forms.map((form) => ({
-                id: form.id ?? randomId(),
-                type: "lead",
-                title: form.title?.trim() || null,
-                description: form.description?.trim() || null,
-                submitLabel: form.submitLabel?.trim() || null,
-                successText: form.successText?.trim() || null,
-                consentText: form.consentText?.trim() || null,
-                consentRequired: form.consentRequired !== false,
-                fields: form.fields.map((field) => ({
-                    id: field.id ?? randomId(),
-                    label: field.label.trim(),
-                    type: field.type,
-                    required: field.required === true,
-                    placeholder: field.placeholder?.trim() || null,
-                })),
-            }));
-        if (args.telegramChannelIds !== undefined) {
-            patch["telegram.enabled"] = args.telegramChannelIds.length > 0;
-            patch["telegram.channelIds"] = args.telegramChannelIds;
-            patch["telegram.channelId"] = args.telegramChannelIds[0] ?? null;
-        }
-        await updateDoc(doc(firestore, "events", args.eventId), patch);
-        return textResult({ id: args.eventId, updated: Object.keys(patch) });
-    });
-    server.registerTool("oko_configure_cards", {
-        title: "Configure event cards",
-        description: toolDescription({
-            summary: "Configure the Cards setup block and replace its card list. Images are managed separately through oko_upload_image and are preserved by matching card id.",
-            args: [
-                "eventId: event to edit.",
-                "enabled: optional Cards block enabled flag.",
-                "visibility: optional default visibility, always or hidden.",
-                "cardImageRatio: optional image ratio, one of auto, 1:1, 4:3, 3:2, 16:9, 2:3, 3:4.",
-                "items: optional full replacement array, max 6 cards. Each item may include id, title, text, buttonLabel, buttonUrl, formId.",
-            ],
-            returns: "event id, updated Firestore fields, normalized cards config, generated card ids, preserved image ids, removed card ids, and warnings.",
-            examples: [
-                "Use after oko_create_webinar to create cards before uploading per-card images.",
-                "Call oko_get_event first and pass the full desired items array when editing existing cards.",
-                "Use formId instead of buttonUrl when a card button should open a lead form.",
-            ],
-            notes: [
-                "This tool replaces blocks.cards.items when items is provided; omitted text fields become null.",
-                "Existing card images are preserved only when the same card id remains in the replacement list.",
-                "buttonUrl allows http(s), mailto, or tel URLs; javascript/data URLs are rejected.",
-                "If a removed card had an image, Storage cleanup is not automatic; this matches the web Setup behavior.",
-            ],
-        }),
-        inputSchema: {
-            eventId: eventIdField,
-            enabled: z.boolean().optional().describe("Whether the Cards block is enabled in setup."),
-            visibility: z.enum(["always", "hidden"]).optional().describe("Default visibility when no live override exists."),
-            cardImageRatio: z.enum(CARD_IMAGE_RATIOS).optional().describe("Image aspect ratio for all cards."),
-            items: z.array(cardItemInputSchema).max(MAX_CARD_ITEMS).optional().describe("Full replacement list, max 6 cards. Omit to update only block settings."),
-        },
-        outputSchema: cardsConfigOutputSchema,
-        annotations: writeTool,
-    }, async (args) => {
-        const { uid } = await authed(["setup:write"]);
-        const event = await readEvent(args.eventId, uid, "edit");
-        const currentCards = readCardsConfig(event);
-        const patch = {};
-        const finalCards = {
-            enabled: args.enabled ?? currentCards.enabled,
-            visibility: args.visibility ?? currentCards.visibility,
-            cardImageRatio: args.cardImageRatio ?? currentCards.cardImageRatio,
-            items: currentCards.items,
-        };
-        const generatedCardIds = [];
-        const preservedImageCardIds = [];
-        let removedCardIds = [];
-        let removedCardsWithImages = [];
-        if (args.enabled !== undefined)
-            patch["blocks.cards.enabled"] = args.enabled;
-        if (args.visibility !== undefined)
-            patch["blocks.cards.visibility"] = args.visibility;
-        if (args.cardImageRatio !== undefined)
-            patch["blocks.cards.cardImageRatio"] = args.cardImageRatio;
-        if (args.items !== undefined) {
-            const built = buildCardsItems({
-                inputs: args.items,
-                existing: currentCards.items,
-                formIds: eventFormIds(event),
-            });
-            finalCards.items = built.items;
-            generatedCardIds.push(...built.generatedCardIds);
-            preservedImageCardIds.push(...built.preservedImageCardIds);
-            const nextIds = new Set(built.items.map((item) => item.id));
-            const removed = currentCards.items.filter((item) => !nextIds.has(item.id));
-            removedCardIds = removed.map((item) => item.id);
-            removedCardsWithImages = removed.filter(cardHasImage).map((item) => item.id);
-            patch["blocks.cards.items"] = built.items;
-        }
-        if (Object.keys(patch).length > 0) {
-            await updateDoc(doc(firestore, "events", args.eventId), patch);
-        }
-        const warnings = removedCardsWithImages.length > 0
-            ? [`Removed cards had images and their Storage files were not deleted: ${removedCardsWithImages.join(", ")}.`]
-            : [];
-        return textResult({
-            eventId: args.eventId,
-            updated: Object.keys(patch),
-            cards: finalCards,
-            generatedCardIds,
-            removedCardIds,
-            removedCardsWithImages,
-            preservedImageCardIds,
-            warnings,
-        });
-    });
-    server.registerTool("oko_upload_image", {
-        title: "Upload event image",
-        description: toolDescription({
-            summary: "Upload and compress an image for an OKO setup block, then write the master URL back to Firestore.",
-            args: [
-                "eventId: event to edit.",
-                "kind: promoBanner, videoPlaceholder, or card.",
-                "cardId: required when kind=card; must match an existing blocks.cards.items id.",
-                "source: exactly one of local path or HTTPS image URL.",
-                "confirm: must be true because the public event image may be replaced.",
-            ],
-            returns: "eventId, kind, imageId, Storage path, masterUrl, byte counts, and a note that CF-generated variants are pending.",
-            examples: [
-                'Use kind="promoBanner" with source.url to set a webinar banner from an image link.',
-                'Use kind="card" with cardId after the card item already exists.',
-            ],
-            notes: [
-                "Uploading an image does not enable its block: toggle the block independently via oko_configure_blocks, in either order.",
-                "The MCP server reads local paths on the organizer machine.",
-                "Remote URLs must be public HTTPS images, max 15MB; private/local hosts are blocked.",
-                "For card images, imageId is the cardId so OKO CF4 can update the correct item.",
-            ],
-        }),
-        inputSchema: {
-            eventId: eventIdField,
-            kind: z.enum(IMAGE_KINDS).describe("Target image slot."),
-            cardId: z.string().min(1).optional().describe("Required when kind=card."),
-            source: imageSourceSchema.describe("Image source: exactly one of path or url."),
-            confirm: z.boolean().optional().describe("Required true for image upload/replacement."),
-        },
-        outputSchema: imageOutputSchema,
-        annotations: writeTool,
-    }, async ({ eventId, kind, cardId, source, confirm }) => {
-        const { uid } = await authed(["setup:write"]);
-        requireConfirm(confirm, "oko_upload_image", { eventId, kind, cardId: cardId ?? null, sourceType: source.path ? "local" : "https" });
-        return textResult(await uploadEventImageForUser(uid, eventId, kind, cardId, source));
-    });
-    server.registerTool("oko_upload_card_images_batch", {
-        title: "Upload card images batch",
-        description: toolDescription({
-            summary: "Upload images for multiple existing cards, preserving card metadata with Firestore transactions and waiting for generated variants.",
-            args: [
-                "eventId: event to edit.",
-                "images: 1-6 card image uploads. Each cardId must already exist in blocks.cards.items.",
-                "timeoutSec: max wait for all CF-generated image variants, default 60 seconds.",
-                "confirm: must be true because existing card images may be replaced.",
-            ],
-            returns: "eventId, per-card upload details, per-card variant readiness, ready flag, and warnings.",
-            examples: [
-                "Use after oko_configure_cards has returned stable card ids.",
-                "Use for webinar cards where an agent generated several local images and needs to attach all of them.",
-            ],
-            notes: [
-                "This is a workflow tool for cards only. Use oko_upload_image for promoBanner or videoPlaceholder.",
-                "The tool does not create cards; it only attaches images to existing cards.",
-            ],
-        }),
-        inputSchema: {
-            eventId: eventIdField,
-            images: z.array(z.object({
-                cardId: cardIdSchema.describe("Existing card id."),
-                source: imageSourceSchema.describe("Image source for this card."),
-            }).strict()).min(1).max(MAX_CARD_ITEMS).describe("Card images to upload."),
-            timeoutSec: z.number().int().min(1).max(120).default(60).describe("Maximum seconds to wait for all generated variants."),
-            confirm: z.boolean().optional().describe("Required true for batch image upload/replacement."),
-        },
-        outputSchema: cardImagesBatchOutputSchema,
-        annotations: writeTool,
-    }, async ({ eventId, images, timeoutSec, confirm }) => {
-        const { uid } = await authed(["setup:write"]);
-        requireConfirm(confirm, "oko_upload_card_images_batch", { eventId, cardIds: images.map((image) => image.cardId).join(",") });
-        const uploads = [];
-        for (const image of images) {
-            uploads.push(await uploadEventImageForUser(uid, eventId, "card", image.cardId, image.source));
-        }
-        const variants = await waitForImageVariantTargets(uid, eventId, images.map((image) => ({ kind: "card", cardId: image.cardId })), timeoutSec);
-        const warnings = variants
-            .filter((item) => !item.ready)
-            .map((item) => `Card ${item.cardId ?? "unknown"} variants are not ready yet: ${item.reason ?? "unknown"}.`);
-        return textResult({
-            eventId,
-            uploads,
-            variants,
-            ready: variants.every((item) => item.ready),
-            warnings,
-        });
-    });
-    server.registerTool("oko_wait_for_image_variants", {
-        title: "Wait for image variants",
-        description: toolDescription({
-            summary: "Poll an event image slot until Cloud Function generated thumb/card/hero variants are visible in Firestore.",
-            args: [
-                "eventId: event to inspect.",
-                "kind: promoBanner, videoPlaceholder, or card.",
-                "cardId: required when kind=card.",
-                "timeoutSec: max wait, default 60 seconds.",
-            ],
-            returns: "image URLs, imageVariants, ready flag, pending reason, and elapsed time.",
-            examples: ["Use after oko_upload_image to avoid checking the UI before image variants are ready."],
-            notes: ["Read-only. It does not trigger variant generation; it only waits for CF4's Firestore update."],
-        }),
-        inputSchema: {
-            eventId: eventIdField,
-            kind: z.enum(IMAGE_KINDS).describe("Target image slot."),
-            cardId: z.string().min(1).optional().describe("Required when kind=card."),
-            timeoutSec: z.number().int().min(1).max(120).default(60).describe("Maximum seconds to wait."),
-        },
-        outputSchema: imageVariantsOutputSchema,
-        annotations: readOnlyTool,
-    }, async ({ eventId, kind, cardId, timeoutSec }) => {
-        const { uid } = await authed(["events:read"]);
-        if (kind === "card" && !cardId)
-            throw new Error("cardId is required when kind is card.");
-        if (kind !== "card" && cardId)
-            throw new Error("cardId is only valid when kind is card.");
-        const statuses = await waitForImageVariantTargets(uid, eventId, [{ kind, cardId: cardId ?? null }], timeoutSec);
-        const status = statuses[0];
-        if (!status)
-            throw new Error("Image variant status was not produced.");
-        return textResult(status);
-    });
-    server.registerTool("oko_delete_image", {
-        title: "Delete event image",
-        description: toolDescription({
-            summary: "Delete an OKO setup block image from Storage and clear the corresponding Firestore image fields.",
-            args: [
-                "eventId: event to edit.",
-                "kind: promoBanner, videoPlaceholder, or card.",
-                "cardId: required when kind=card.",
-                "confirm: must be true.",
-            ],
-            returns: "eventId, kind, deleted=true, and best-effort Storage cleanup warnings if any.",
-            examples: ["Use only after confirming the exact event and image slot with the user."],
-            notes: ["Destructive. Storage cleanup mirrors the web Setup screen: failed object deletes do not block clearing Firestore fields."],
-        }),
-        inputSchema: {
-            eventId: eventIdField,
-            kind: z.enum(IMAGE_KINDS).describe("Target image slot."),
-            cardId: z.string().min(1).optional().describe("Required when kind=card."),
-            confirm: z.boolean().optional().describe("Required true for image deletion."),
-        },
-        outputSchema: deleteImageOutputSchema,
-        annotations: destructiveTool,
-    }, async ({ eventId, kind, cardId, confirm }) => {
-        const { uid } = await authed(["setup:write"]);
-        if (kind === "card" && !cardId)
-            throw new Error("cardId is required when kind is card.");
-        if (kind !== "card" && cardId)
-            throw new Error("cardId is only valid when kind is card.");
-        const event = await readEvent(eventId, uid, "edit");
-        const previous = readImageRef(event, kind, cardId);
-        requireConfirm(confirm, "oko_delete_image", { eventId, kind, cardId: cardId ?? null, imageId: previous.imageId });
-        const cleanup = await deleteStorageUrls(eventId, previous.imageMasterUrl, previous.imageUrl);
-        if (kind === "promoBanner") {
-            await updateDoc(doc(firestore, "events", eventId), {
-                "blocks.promoBanner.imageMasterUrl": deleteField(),
-                "blocks.promoBanner.imageUrl": deleteField(),
-                "blocks.promoBanner.imageVariants": deleteField(),
-                "blocks.promoBanner.imageWidth": deleteField(),
-                "blocks.promoBanner.imageHeight": deleteField(),
-            });
-        }
-        else if (kind === "videoPlaceholder") {
-            await updateDoc(doc(firestore, "events", eventId), {
-                "blocks.video.placeholder.imageMasterUrl": deleteField(),
-                "blocks.video.placeholder.imageUrl": deleteField(),
-                "blocks.video.placeholder.imageVariants": deleteField(),
-                "blocks.video.placeholder.imageWidth": deleteField(),
-                "blocks.video.placeholder.imageHeight": deleteField(),
-            });
-        }
-        else {
-            await updateCardImageInTransaction(eventId, cardId, {
-                imageUrl: null,
-                imageMasterUrl: null,
-                imageVariants: null,
-                imageWidth: null,
-                imageHeight: null,
-            });
-        }
-        return textResult({
-            eventId,
-            kind,
-            imageId: previous.imageId ?? (kind === "card" ? cardId : null),
-            deleted: true,
-            storageDeletesAttempted: cleanup.attempted,
-            storageDeleteWarnings: cleanup.warnings,
-        });
-    });
-    server.registerTool("oko_delete_event", {
-        title: "Move event to trash",
-        description: toolDescription({
-            summary: "Move an OKO event to the 30-day trash. This compatibility alias has the same behavior as oko_trash_event.",
-            args: ["eventId: event to move to trash.", "confirm: must be true."],
-            returns: "trashed event id and purge deadline in epoch milliseconds.",
-            examples: ["Use after showing the exact event title and asking the organizer to confirm moving it to trash."],
-            notes: ["Recoverable for 30 days with oko_restore_event. This does not create an event lifecycle status."],
-        }),
-        inputSchema: { eventId: eventIdField, confirm: z.boolean().optional().describe("Required true to move the event to trash.") },
-        outputSchema: z.object({ trashed: z.string(), purgeAfter: z.number().nullable() }).passthrough(),
-        annotations: destructiveTool,
-    }, async ({ eventId, confirm }) => {
-        const { uid } = await authed(["events:delete"]);
-        const data = await readEvent(eventId, uid, "delete");
-        requireConfirm(confirm, "oko_delete_event", { eventId, title: data.title });
-        const trash = httpsCallable(functions, "trashEvent");
-        const result = await trash({ eventId });
-        return textResult(result.data);
-    });
-    server.registerTool("oko_trash_event", {
-        title: "Move event to trash",
-        description: toolDescription({
-            summary: "Move an OKO event to the recoverable 30-day trash.",
-            args: ["eventId: event to move to trash.", "confirm: must be true."],
-            returns: "trashed event id and purge deadline in epoch milliseconds.",
-            examples: ["Use after showing the exact event title and asking the organizer to confirm moving it to trash."],
-            notes: ["End any active analytics session first. Restore with oko_restore_event before the purge deadline."],
-        }),
-        inputSchema: { eventId: eventIdField, confirm: z.boolean().optional().describe("Required true to move the event to trash.") },
-        outputSchema: z.object({ trashed: z.string(), purgeAfter: z.number().nullable() }).passthrough(),
-        annotations: destructiveTool,
-    }, async ({ eventId, confirm }) => {
-        const { uid } = await authed(["events:delete"]);
-        const event = await readEvent(eventId, uid, "delete");
-        requireConfirm(confirm, "oko_trash_event", { eventId, title: event.title });
-        const trash = httpsCallable(functions, "trashEvent");
-        return textResult((await trash({ eventId })).data);
-    });
-    server.registerTool("oko_restore_event", {
-        title: "Restore event",
-        description: toolDescription({
-            summary: "Restore an OKO event from the 30-day trash before its purge deadline.",
-            args: ["eventId: trashed event to restore."],
-            returns: "restored event id.",
-            examples: ["Use when the organizer asks to undo a trash action."],
-            notes: ["Idempotent. Fails after the trash retention deadline has expired."],
-        }),
-        inputSchema: { eventId: eventIdField },
-        outputSchema: z.object({ restored: z.string() }).passthrough(),
-        annotations: idempotentWriteTool,
-    }, async ({ eventId }) => {
-        const { uid } = await authed(["events:delete"]);
-        await readEvent(eventId, uid, "delete");
-        const restore = httpsCallable(functions, "restoreEvent");
-        return textResult((await restore({ eventId })).data);
-    });
-    server.registerTool("oko_delete_event_permanently", {
-        title: "Delete event permanently",
-        description: toolDescription({
-            summary: "Permanently delete a trashed OKO event and all associated Firestore, RTDB, chat, Storage, participant, session, and Telegram data.",
-            args: [
-                "eventId: trashed event to delete permanently.",
-                "confirmTitle: exact current event title, including case and spacing.",
-                "confirm: must be true.",
-            ],
-            returns: "deleted event id and cross-store cleanup counts.",
-            examples: ["Read the event first, show its exact title, and proceed only after the organizer explicitly types or confirms that exact title."],
-            notes: ["Irreversible. The event must already be in trash; use oko_trash_event first."],
-        }),
-        inputSchema: {
-            eventId: eventIdField,
-            confirmTitle: z.string().max(500).describe("Exact current event title."),
-            confirm: z.boolean().optional().describe("Required true for permanent deletion."),
-        },
-        outputSchema: z.object({ deleted: z.string(), cleanup: unknownRecordSchema }).passthrough(),
-        annotations: destructiveTool,
-    }, async ({ eventId, confirmTitle, confirm }) => {
-        const { uid } = await authed(["events:delete"]);
-        const event = await readEvent(eventId, uid, "delete");
-        const title = safeString(event.title);
-        if (confirmTitle !== title)
-            throw new Error("confirmTitle must exactly match the current event title.");
-        requireConfirm(confirm, "oko_delete_event_permanently", { eventId, title });
-        const remove = httpsCallable(functions, "deleteEventCompletely");
-        return textResult((await remove({ eventId, confirmTitle })).data);
-    });
-    server.registerTool("oko_duplicate_event", {
-        title: "Duplicate event",
-        description: toolDescription({
-            summary: "Duplicate an event setup into the same or another workspace without analytics/session history.",
-            args: ["eventId: source event.", "targetWorkspaceId: optional target workspace; omitted means source workspace or personal workspace."],
-            returns: "new event id, public/setup/analytics URLs, source event id, and workspaceId.",
-            examples: ["Use to create a reusable copy of a configured webinar before editing the new copy."],
-            notes: ["Copies title, video, meta, blocks, forms, and Telegram config; does not copy analytics sessions or leads."],
-        }),
-        inputSchema: {
-            eventId: eventIdField,
-            targetWorkspaceId: z.string().min(1).optional().describe("Target workspace id; omit to use the source workspace or personal workspace."),
-        },
-        outputSchema: createWebinarOutputSchema,
-        annotations: writeTool,
-    }, async ({ eventId, targetWorkspaceId }) => {
-        const { uid } = await authed(["events:write"]);
-        const source = await readEvent(eventId, uid, "read");
-        const workspaceId = targetWorkspaceId ?? safeString(source.workspaceId, uid);
-        await assertCanCreateInWorkspace(uid, workspaceId);
-        const newRef = await addEventWithRtdbMirror({
-            ownerId: uid,
-            workspaceId,
-            ...initialEventAccess(uid),
-            createdAt: serverTimestamp(),
-            title: safeString(source.title, "Untitled event"),
-            pinned: false,
-            video: source.video ?? { originalUrl: null, embedUrl: null },
-            meta: source.meta ?? { eventDate: null, speakerName: null, description: null },
-            blocks: source.blocks ?? {},
-            ...(Array.isArray(source.forms) ? { forms: source.forms } : {}),
-            ...(source.telegram && typeof source.telegram === "object" ? { telegram: source.telegram } : {}),
-        });
-        return textResult({ id: newRef.id, sourceEventId: eventId, workspaceId, ...eventLinks(newRef.id) });
-    });
-    server.registerTool("oko_move_event", {
-        title: "Move event",
-        description: toolDescription({
-            summary: "Move an event to another workspace and recompute accessibleBy/editors.",
-            args: ["eventId: event to move.", "targetWorkspaceId: target workspace id.", "confirm: must be true because access changes."],
-            returns: "eventId, targetWorkspaceId, updated Firestore fields, and RTDB mirror status.",
-            examples: ["Use when an event belongs in another workspace. Call oko_list_workspaces first to choose the target."],
-            notes: ["Reads target workspace shares from Firestore with permissions; does not use RTDB workspaceMembers."],
-        }),
-        inputSchema: {
-            eventId: eventIdField,
-            targetWorkspaceId: z.string().min(1).describe("Target workspace id."),
-            confirm: z.boolean().optional().describe("Required true for event move."),
-        },
-        outputSchema: updateOutputSchema,
-        annotations: writeTool,
-    }, async ({ eventId, targetWorkspaceId, confirm }) => {
-        await authed(["events:write", "workspace:write"]);
-        requireConfirm(confirm, "oko_move_event", { eventId, targetWorkspaceId });
-        const moveEvent = httpsCallable(functions, "moveEventToWorkspace");
-        const result = await moveEvent({ eventId, targetWorkspaceId });
-        return textResult(result.data);
-    });
-    server.registerTool("oko_get_live_state", {
-        title: "Get live state",
-        description: toolDescription({
-            summary: "Read main RTDB live controls, aggregate analytics, and chat settings for an event.",
-            args: ["eventId: event to inspect."],
-            returns: "eventId, agg metrics, ctrl live overrides, and chat settings.",
-            examples: ["Use during a webinar before changing live block visibility or starting/ending sessions."],
-        }),
-        inputSchema: { eventId: eventIdField },
-        outputSchema: liveStateOutputSchema,
-        annotations: readOnlyTool,
-    }, async ({ eventId }) => {
-        const { uid } = await authed(["analytics:read"]);
-        await readEvent(eventId, uid, "analytics");
-        const [aggSnap, ctrlSnap, chatSettingsSnap] = await Promise.all([
-            get(ref(rtdb, `events/${eventId}/agg`)),
-            get(ref(rtdb, `events/${eventId}/ctrl`)),
-            get(ref(chatRtdb, `settings/${eventId}`)),
-        ]);
-        return textResult({ eventId, agg: aggSnap.val() ?? {}, ctrl: ctrlSnap.val() ?? {}, chat: chatSettingsSnap.val() ?? {} });
-    });
-    server.registerTool("oko_set_block_visibility", {
-        title: "Set live block visibility",
-        description: toolDescription({
-            summary: "Set or reset a live RTDB visibility override for a public event block.",
-            args: ["eventId: event to control.", "block: chat, banner, cta, cards, or placeholder.", "visible: true/false, or null to reset override.", "confirm: must be true."],
-            returns: "eventId, block, and effective override value.",
-            examples: ["Use visible=false to hide the CTA live; use visible=null to return to setup defaults."],
-            notes: [
-                "block=chat with visible=false PAUSES message input: viewers keep seeing the chat history but cannot send. It does not hide the chat panel.",
-            ],
-        }),
-        inputSchema: {
-            eventId: eventIdField,
-            block: z.enum(["chat", "banner", "cta", "cards", "placeholder"]).describe("Public block whose live override should change."),
-            visible: boolOrNull.describe("true/false to force visibility, null to reset override."),
-            confirm: z.boolean().optional().describe("Required true for live visibility change."),
-        },
-        outputSchema: basicEventOutputSchema,
-        annotations: idempotentWriteTool,
-    }, async ({ eventId, block, visible, confirm }) => {
-        const { uid } = await authed(["live:control"]);
-        await readEvent(eventId, uid, "live");
-        requireConfirm(confirm, "oko_set_block_visibility", { eventId, block, visible });
-        const paths = {
-            chat: "chatVisible",
-            banner: "bannerVisible",
-            cta: "ctaVisible",
-            cards: "cardsVisible",
-            placeholder: "placeholderVisible",
-        };
-        const target = ref(rtdb, `events/${eventId}/ctrl/${paths[block]}`);
-        if (visible === null)
-            await remove(target);
-        else
-            await set(target, visible);
-        return textResult({ eventId, block, visible });
-    });
-    server.registerTool("oko_refresh_viewers", {
-        title: "Refresh viewers",
-        description: toolDescription({
-            summary: "Trigger a live viewer refresh tick for an event.",
-            args: ["eventId: event whose viewers should refresh.", "confirm: must be true."],
-            returns: "eventId and refreshed=true.",
-            examples: ["Use after a setup/live change if viewers should reload state immediately."],
-        }),
-        inputSchema: { eventId: eventIdField, confirm: z.boolean().optional().describe("Required true to refresh connected viewers.") },
-        outputSchema: basicEventOutputSchema,
-        annotations: writeTool,
-    }, async ({ eventId, confirm }) => {
-        const { uid } = await authed(["live:control"]);
-        await readEvent(eventId, uid, "live");
-        requireConfirm(confirm, "oko_refresh_viewers", { eventId });
-        await set(ref(rtdb, `events/${eventId}/ctrl/refreshTick`), Date.now());
-        return textResult({ eventId, refreshed: true });
-    });
-    server.registerTool("oko_set_live_badge", {
-        title: "Set live badge",
-        description: toolDescription({
-            summary: "Control the public 'Live' badge on the event page.",
-            args: [
-                "eventId: event to control.",
-                "mode: session (follows the analytics session, product default), manual (badge shown now for durationMinutes), schedule (shown around meta.eventDate), hidden (never shown).",
-                "durationMinutes: badge window for manual/schedule, 15-1440 minutes, default 120.",
-                "confirm: must be true.",
-            ],
-            returns: "eventId, mode, durationMinutes.",
-            examples: ['Use mode="manual" during an unscheduled stream; return to mode="session" afterwards.'],
-            notes: ["The badge is a page indicator only; it never starts or stops video or analytics."],
-        }),
-        inputSchema: {
-            eventId: eventIdField,
-            mode: z.enum(["session", "manual", "schedule", "hidden"]).describe("Live badge mode."),
-            durationMinutes: z.number().int().min(15).max(1440).optional().describe("Badge window in minutes for manual/schedule modes; default 120."),
-            confirm: z.boolean().optional().describe("Required true to change the public live badge."),
-        },
-        outputSchema: basicEventOutputSchema,
-        annotations: idempotentWriteTool,
-    }, async ({ eventId, mode, durationMinutes, confirm }) => {
-        const { uid } = await authed(["live:control"]);
-        await readEvent(eventId, uid, "live");
-        requireConfirm(confirm, "oko_set_live_badge", { eventId, mode, durationMinutes: durationMinutes ?? null });
-        const value = { mode, durationMinutes: durationMinutes ?? 120 };
-        await set(ref(rtdb, `events/${eventId}/ctrl/liveBadge`), value);
-        return textResult({ eventId, ...value });
-    });
-    server.registerTool("oko_set_chat_mode", {
-        title: "Set chat mode",
-        description: toolDescription({
-            summary: "Set who can send chat messages on the public event page.",
-            args: [
-                "eventId: event to control.",
-                "mode: public (anyone), auth (signed-in viewers only), owner (organizers only), off (input closed, history stays visible), or null to reset to the product default (public).",
-                "confirm: must be true.",
-            ],
-            returns: "eventId and the effective chat mode.",
-            examples: ['Use mode="off" to pause a chat storm; use mode=null or "public" to reopen.'],
-            notes: [
-                'This is the full replacement for the legacy pause via oko_set_block_visibility(block="chat"): prefer oko_set_chat_mode.',
-                "History always stays visible to viewers; mode only gates sending.",
-            ],
-        }),
-        inputSchema: {
-            eventId: eventIdField,
-            mode: z.enum(["public", "auth", "owner", "off"]).nullable().describe("Chat mode; null resets the override to the default."),
-            confirm: z.boolean().optional().describe("Required true to change the live chat mode."),
-        },
-        outputSchema: basicEventOutputSchema,
-        annotations: idempotentWriteTool,
-    }, async ({ eventId, mode, confirm }) => {
-        const { uid } = await authed(["live:control"]);
-        await readEvent(eventId, uid, "live");
-        requireConfirm(confirm, "oko_set_chat_mode", { eventId, mode });
-        const target = ref(rtdb, `events/${eventId}/ctrl/chatMode`);
-        if (mode === null)
-            await remove(target);
-        else
-            await set(target, mode);
-        return textResult({ eventId, mode });
-    });
-    server.registerTool("oko_force_viewer_reload", {
-        title: "Force viewer reload",
-        description: toolDescription({
-            summary: "Force a hard page reload for every connected viewer (emergency recovery).",
-            args: ["eventId: event whose viewer pages must reload.", "confirm: must be true."],
-            returns: "eventId and reloaded=true.",
-            examples: ["Use only when viewer pages are stuck (broken bundle or state) and oko_refresh_viewers did not help."],
-            notes: [
-                "Server enforces a 120-second cooldown per event; a repeated call returns the seconds left.",
-                "Viewers reload with up to 4 seconds of jitter. Prefer oko_refresh_viewers for ordinary content updates.",
-            ],
-        }),
-        inputSchema: {
-            eventId: eventIdField,
-            confirm: z.boolean().optional().describe("Required true to hard-reload all viewer pages."),
-        },
-        outputSchema: basicEventOutputSchema,
-        annotations: writeTool,
-    }, async ({ eventId, confirm }) => {
-        const { uid } = await authed(["live:control"]);
-        await readEvent(eventId, uid, "live");
-        requireConfirm(confirm, "oko_force_viewer_reload", { eventId });
-        const forceReload = httpsCallable(functions, "forceViewerReload");
-        try {
-            await forceReload({ eventId });
-        }
-        catch (error) {
-            const details = error.details;
-            if (typeof details?.retryInSec === "number") {
-                throw new Error(`Force reload is cooling down: retry in ${details.retryInSec} seconds.`);
-            }
-            throw error;
-        }
-        return textResult({ eventId, reloaded: true });
-    });
-    server.registerTool("oko_start_session", {
-        title: "Start analytics session",
-        description: toolDescription({
-            summary: "Start an analytics session using the same Firestore/RTDB pointers as the dashboard.",
-            args: ["eventId: event whose analytics session should start.", "confirm: must be true."],
-            returns: "eventId, new sessionId, and started=true.",
-            examples: ["Use when the organizer wants analytics tracking to begin; it does not start the video stream."],
-            notes: ["OKO Start/End controls analytics sessions only, not stream publishing."],
-        }),
-        inputSchema: { eventId: eventIdField, confirm: z.boolean().optional().describe("Required true to start analytics collection session.") },
-        outputSchema: basicEventOutputSchema,
-        annotations: writeTool,
-    }, async ({ eventId, confirm }) => {
-        const { uid } = await authed(["analytics:write", "live:control"]);
-        const event = await readEvent(eventId, uid, "session");
-        requireConfirm(confirm, "oko_start_session", { eventId, title: event.title ?? null });
-        if (event.activeAnalyticsSessionId)
-            throw new Error("An analytics session is already active.");
-        const start = httpsCallable(functions, "startAnalyticsSessionV3");
-        const result = await start({ eventId });
-        return textResult({ started: true, ...result.data });
-    });
-    server.registerTool("oko_end_session", {
-        title: "End analytics session",
-        description: toolDescription({
-            summary: "End the active analytics session and persist the session snapshot.",
-            args: ["eventId: event with an active analytics session.", "confirm: must be true."],
-            returns: "eventId, sessionId, and ended=true.",
-            examples: ["Use after the webinar analytics window is over and the user confirms the exact event."],
-            notes: ["Destructive for the active session pointer, but it does not stop the video stream."],
-        }),
-        inputSchema: { eventId: eventIdField, confirm: z.boolean().optional().describe("Required true for ending the active session.") },
-        outputSchema: basicEventOutputSchema,
-        annotations: destructiveTool,
-    }, async ({ eventId, confirm }) => {
-        const { uid } = await authed(["analytics:write", "live:control"]);
-        const event = await readEvent(eventId, uid, "session");
-        const sessionId = safeString(event.activeAnalyticsSessionId);
-        if (!sessionId)
-            throw new Error("No active analytics session.");
-        requireConfirm(confirm, "oko_end_session", { eventId, sessionId });
-        const end = httpsCallable(functions, "endAnalyticsSessionV3");
-        const result = await end({ eventId, sessionId });
-        return textResult(result.data);
-    });
-    server.registerTool("oko_fix_orphan_session", {
-        title: "Fix orphan analytics session",
-        description: toolDescription({
-            summary: "Clear stuck active-session pointers when an analytics session cannot be ended normally.",
-            args: [
-                "eventId: event with stuck session pointers.",
-                "deleteRtdbSessionData: optional, also delete events/{eventId}/sessions/{sessionId}; default false.",
-                "confirm: must be true.",
-            ],
-            returns: "eventId, cleared sessionId if found, and cleaned paths.",
-            examples: ["Use when oko_end_session says the baseline is missing or dashboard shows a stuck/orphan session."],
-            notes: ["This does not stop the video stream; OKO Start/End controls analytics sessions only."],
-        }),
-        inputSchema: {
-            eventId: eventIdField,
-            deleteRtdbSessionData: z.boolean().default(false).describe("Also delete RTDB session data for the stuck session."),
-            confirm: z.boolean().optional().describe("Required true for clearing session pointers."),
-        },
-        outputSchema: basicEventOutputSchema,
-        annotations: destructiveTool,
-    }, async ({ eventId, deleteRtdbSessionData, confirm }) => {
-        const { uid } = await authed(["analytics:write", "live:control"]);
-        const event = await readEvent(eventId, uid, "session");
-        const ctrlSnap = await get(ref(rtdb, `events/${eventId}/ctrl/activeSessionId`));
-        const sessionId = safeString(event.activeAnalyticsSessionId) || safeString(ctrlSnap.val());
-        requireConfirm(confirm, "oko_fix_orphan_session", { eventId, sessionId: sessionId || null, deleteRtdbSessionData });
-        const cleanup = [
-            {
-                path: "events.activeAnalyticsSessionId",
-                promise: updateDoc(doc(firestore, "events", eventId), { activeAnalyticsSessionId: deleteField() }),
-            },
-            {
-                path: "ctrl/activeSessionId",
-                promise: remove(ref(rtdb, `events/${eventId}/ctrl/activeSessionId`)),
-            },
-        ];
-        if (sessionId) {
-            cleanup.push({
-                path: `activeSessions/${sessionId}`,
-                promise: remove(ref(rtdb, `activeSessions/${sessionId}`)),
-            });
-        }
-        if (sessionId && deleteRtdbSessionData) {
-            cleanup.push({
-                path: `events/${eventId}/sessions/${sessionId}`,
-                promise: remove(ref(rtdb, `events/${eventId}/sessions/${sessionId}`)),
-            });
-        }
-        const settled = await Promise.allSettled(cleanup.map((operation) => operation.promise));
-        const attempts = settled.map((result, index) => {
-            const operation = cleanup[index];
-            if (!operation)
-                throw new Error("Session repair result has no matching cleanup operation.");
-            return {
-                path: operation.path,
-                status: result.status,
-                ...(result.status === "rejected" ? {
-                    error: result.reason instanceof Error ? result.reason.message : String(result.reason),
-                } : {}),
-            };
-        });
-        let firestorePointer = null;
-        let rtdbPointer = null;
-        let verificationError;
-        try {
-            const [eventAfter, ctrlAfter] = await Promise.all([
-                getDoc(doc(firestore, "events", eventId)),
-                get(ref(rtdb, `events/${eventId}/ctrl/activeSessionId`)),
-            ]);
-            firestorePointer = eventAfter.exists()
-                ? safeString(eventAfter.data().activeAnalyticsSessionId) || null
-                : null;
-            rtdbPointer = safeString(ctrlAfter.val()) || null;
-        }
-        catch (error) {
-            verificationError = error instanceof Error ? error.message : String(error);
-        }
-        return textResult(summarizeSessionRepair({
-            eventId,
-            sessionId: sessionId || null,
-            deleteRtdbSessionData,
-            attempts,
-            firestorePointer,
-            rtdbPointer,
-            verificationError,
-        }));
-    });
-    server.registerTool("oko_delete_session", {
-        title: "Delete analytics session",
-        description: toolDescription({
-            summary: "Delete an analytics session document and optionally its RTDB session data.",
-            args: [
-                "eventId: event id.",
-                "sessionId: analytics session id.",
-                "deleteRtdbData: best-effort delete of events/{eventId}/sessions/{sessionId}; default false.",
-                "confirm: must be true.",
-            ],
-            returns: "eventId, sessionId, deleted=true, and cleaned paths.",
-            examples: ["Use only after confirming the exact session id with the organizer."],
-            notes: ["Destructive. If the session is active, active pointers are cleared first. RTDB session data cleanup is best-effort because rules may deny deleting historical session snapshots."],
-        }),
-        inputSchema: {
-            eventId: eventIdField,
-            sessionId: z.string().min(1).describe("analyticsSessions document id."),
-            deleteRtdbData: z.boolean().default(false).describe("Best-effort delete RTDB session data for this session."),
-            confirm: z.boolean().optional().describe("Required true for session deletion."),
-        },
-        outputSchema: basicEventOutputSchema,
-        annotations: destructiveTool,
-    }, async ({ eventId, sessionId, deleteRtdbData, confirm }) => {
-        const { uid } = await authed(["analytics:write", "live:control"]);
-        const event = await readEvent(eventId, uid, "session");
-        requireConfirm(confirm, "oko_delete_session", { eventId, sessionId, deleteRtdbData });
-        const isActive = safeString(event.activeAnalyticsSessionId) === sessionId;
-        const cleanup = [];
-        if (isActive) {
-            cleanup.push(updateDoc(doc(firestore, "events", eventId), { activeAnalyticsSessionId: deleteField() }));
-            cleanup.push(remove(ref(rtdb, `events/${eventId}/ctrl/activeSessionId`)));
-            cleanup.push(remove(ref(rtdb, `activeSessions/${sessionId}`)));
-        }
-        cleanup.push(deleteDoc(doc(firestore, "events", eventId, "analyticsSessions", sessionId)));
-        const results = await Promise.allSettled(cleanup);
-        const warnings = results
-            .filter((result) => result.status === "rejected")
-            .map((result) => result.reason instanceof Error ? result.reason.message : String(result.reason));
-        if (warnings.length > 0)
-            throw new Error(`Session delete partially failed: ${warnings.join("; ")}`);
-        const rtdbCleanupWarnings = [];
-        if (deleteRtdbData) {
-            try {
-                await remove(ref(rtdb, `events/${eventId}/sessions/${sessionId}`));
-            }
-            catch (err) {
-                rtdbCleanupWarnings.push(err instanceof Error ? err.message : String(err));
-            }
-        }
-        return textResult({ eventId, sessionId, deleted: true, wasActive: isActive, deleteRtdbData, rtdbCleanupWarnings });
-    });
-    server.registerTool("oko_get_analytics", {
-        title: "Get analytics sessions",
-        description: toolDescription({
-            summary: "Read paginated analytics session summaries for an event.",
-            args: [
-                "eventId: event to inspect.",
-                "limit: max sessions to return, default 10, max 50.",
-                "cursor: timestamp cursor returned as nextCursor by the previous page.",
-                "includeTimeline: include recent timeline buckets; default false to keep context small.",
-                "timelineLimit: max timeline buckets per session when includeTimeline=true.",
-                "includeSnapshots: include baseline/final snapshots; default false.",
-            ],
-            returns: "sessions plus count, limit, hasMore/has_more, nextCursor/next_cursor. Heavy timeline/snapshot fields are omitted unless requested.",
-            examples: ["Use default options for dashboard-like summaries; request includeTimeline only for chart/debug tasks."],
-        }),
-        inputSchema: {
-            eventId: eventIdField,
-            limit: limitField(50, ANALYTICS_DEFAULT_LIMIT),
-            cursor: cursorField,
-            includeTimeline: z.boolean().default(false).describe("Include recent timeline buckets for each session."),
-            timelineLimit: z.number().int().min(1).max(500).default(ANALYTICS_TIMELINE_DEFAULT_LIMIT).describe("Max timeline buckets per session when includeTimeline=true."),
-            includeSnapshots: z.boolean().default(false).describe("Include baselineSnapshot and finalSnapshot."),
-        },
-        outputSchema: analyticsOutputSchema,
-        annotations: readOnlyTool,
-    }, async ({ eventId, limit: max, cursor, includeTimeline, timelineLimit, includeSnapshots }) => {
-        const { uid } = await authed(["analytics:read"]);
-        await readEvent(eventId, uid, "analytics");
-        const constraints = [
-            orderBy("startedAt", "desc"),
-            limit(max + 1),
-        ];
-        if (cursor)
-            constraints.splice(1, 0, startAfter(parseTimestampCursor(cursor)));
-        const snap = await getDocs(query(collection(firestore, "events", eventId, "analyticsSessions"), ...constraints));
-        const { page, hasMore } = pickPage(snap.docs, max);
-        const sessions = page.map((item) => compactAnalyticsSession({ id: item.id, ...item.data() }, { includeTimeline, timelineLimit, includeSnapshots }));
-        const nextCursor = hasMore ? timestampCursorFrom(page.at(-1)?.data().startedAt) : null;
-        return textResult({ sessions, ...cursorMeta(sessions.length, max, hasMore, nextCursor) }, { truncationHint: "Use limit/cursor or keep includeTimeline/includeSnapshots disabled." });
-    });
-    server.registerTool("oko_get_session_report", {
-        title: "Get session report",
-        description: toolDescription({
-            summary: "Build a ready-to-share report for one analytics session, with compact structured data and markdown.",
-            args: [
-                "eventId: event to inspect.",
-                "sessionId: optional analytics session id; omitted means latest session.",
-                "includeTimeline: include recent timeline buckets; default false.",
-                "timelineLimit: max timeline buckets when includeTimeline=true.",
-                "includeSnapshots: include baseline/final snapshots; default false.",
-            ],
-            returns: "event/session ids, report URL, markdown summary, event summary, and compact session object.",
-            examples: ["Use after a webinar when the user asks for the finished session report without manually opening the report page."],
-        }),
-        inputSchema: {
-            eventId: eventIdField,
-            sessionId: z.string().min(1).optional().describe("analyticsSessions document id. Omit to use the latest session."),
-            includeTimeline: z.boolean().default(false).describe("Include recent timeline buckets."),
-            timelineLimit: z.number().int().min(1).max(500).default(ANALYTICS_TIMELINE_DEFAULT_LIMIT).describe("Max timeline buckets when includeTimeline=true."),
-            includeSnapshots: z.boolean().default(false).describe("Include baselineSnapshot and finalSnapshot."),
-        },
-        outputSchema: sessionReportOutputSchema,
-        annotations: readOnlyTool,
-    }, async ({ eventId, sessionId, includeTimeline, timelineLimit, includeSnapshots }) => {
-        const { uid } = await authed(["analytics:read"]);
-        const event = await readEvent(eventId, uid, "report");
-        let resolvedSessionId = sessionId;
-        let sessionData = null;
-        if (resolvedSessionId) {
-            const sessionSnap = await getDoc(doc(firestore, "events", eventId, "analyticsSessions", resolvedSessionId));
-            if (!sessionSnap.exists())
-                throw new Error("Analytics session not found.");
-            sessionData = sessionSnap.data();
-        }
-        else {
-            const snap = await getDocs(query(collection(firestore, "events", eventId, "analyticsSessions"), orderBy("startedAt", "desc"), limit(1)));
-            const first = snap.docs[0];
-            if (!first)
-                throw new Error("No analytics sessions found for this event.");
-            resolvedSessionId = first.id;
-            sessionData = first.data();
-        }
-        const session = compactAnalyticsSession({ id: resolvedSessionId, ...sessionData }, { includeTimeline, timelineLimit, includeSnapshots });
-        const markdown = sessionReportMarkdown({ eventId, event, sessionId: resolvedSessionId, session });
-        return textResult({
-            eventId,
-            sessionId: resolvedSessionId,
-            event: {
-                id: eventId,
-                title: safeString(event.title, eventId),
-                ...eventLinks(eventId),
-            },
-            reportUrl: sessionReportUrl(eventId, resolvedSessionId),
-            markdown,
-            session,
-        }, { truncationHint: "Keep includeTimeline/includeSnapshots disabled or lower timelineLimit." });
-    });
-    server.registerTool("oko_list_recent_chat", {
-        title: "List recent chat",
-        description: toolDescription({
-            summary: "Read recent chat messages from chat RTDB with cursor pagination.",
-            args: [
-                "eventId: event chat to inspect.",
-                "limit: max messages to return, default 50, max 100.",
-                "cursor: message id returned as nextCursor by the previous page to read older messages.",
-            ],
-            returns: "messages array sorted newest-first plus count, limit, hasMore/has_more, nextCursor/next_cursor.",
-            examples: ["Use limit=20 first; if hasMore is true, call again with cursor=nextCursor for older chat."],
-        }),
-        inputSchema: { eventId: eventIdField, limit: limitField(100, 50), cursor: cursorField },
-        outputSchema: chatOutputSchema,
-        annotations: readOnlyTool,
-    }, async ({ eventId, limit: max, cursor }) => {
-        const { uid } = await authed(["analytics:read"]);
-        await readEvent(eventId, uid, "read");
-        const constraints = cursor
-            ? [orderByKey(), endBefore(cursor), limitToLast(max + 1)]
-            : [orderByKey(), limitToLast(max + 1)];
-        const snap = await get(dbQuery(ref(chatRtdb, `messages/${eventId}`), ...constraints));
-        const entries = Object.entries((snap.val() ?? {}))
-            .sort(([a], [b]) => b.localeCompare(a));
-        const { page, hasMore } = pickPage(entries, max);
-        const messages = page.map(([id, message]) => ({ id, ...serialize(message) }));
-        const nextCursor = hasMore ? messages.at(-1)?.id ?? null : null;
-        return textResult({ messages, ...cursorMeta(messages.length, max, hasMore, nextCursor) });
-    });
-    server.registerTool("oko_send_chat_message", {
-        title: "Send chat message",
-        description: toolDescription({
-            summary: "Send a chat message as the authenticated organizer/moderator.",
-            args: ["eventId: target event chat.", "text: message text, max 500 chars.", "name: display name, default OKO MCP.", "confirm: must be true."],
-            returns: "eventId, new messageId, and sent=true.",
-            examples: ["Use for organizer announcements in chat after user confirms the exact text."],
-        }),
-        inputSchema: {
-            eventId: eventIdField,
-            text: z.string().min(1).max(500).describe("Message text."),
-            name: z.string().min(1).max(24).default("OKO MCP").describe("Display name."),
-            confirm: z.boolean().optional().describe("Required true to post to live chat."),
-        },
-        outputSchema: basicEventOutputSchema,
-        annotations: writeTool,
-    }, async ({ eventId, text, name, confirm }) => {
-        const { uid } = await authed(["chat:write"]);
-        await readEvent(eventId, uid, "read");
-        requireConfirm(confirm, "oko_send_chat_message", { eventId, name, text });
-        const role = await getChatRole(eventId, uid);
-        const msgRef = push(ref(chatRtdb, `messages/${eventId}`));
-        if (!msgRef.key)
-            throw new Error("Could not allocate chat message id");
-        const timestamp = rtdbServerTimestamp();
-        await update(ref(chatRtdb), {
-            [`messages/${eventId}/${msgRef.key}`]: { text, uid, name, role, ts: timestamp },
-            [`rate_limits/${eventId}/${uid}`]: { ts: timestamp, messageId: msgRef.key },
-        });
-        await runTransaction(ref(rtdb, `events/${eventId}/agg/chatMessages`), (n) => (n ?? 0) + 1)
-            .catch(() => undefined);
-        return textResult({ eventId, messageId: msgRef.key, sent: true });
-    });
-    server.registerTool("oko_delete_chat_message", {
-        title: "Delete chat message",
-        description: toolDescription({
-            summary: "Soft-delete a chat message through moderation metadata.",
-            args: ["eventId: target event.", "messageId: chat RTDB message id.", "confirm: must be true."],
-            returns: "eventId, messageId, and deleted=true.",
-            examples: ["Use only after showing the message text/id and receiving explicit confirmation."],
-        }),
-        inputSchema: { eventId: eventIdField, messageId: z.string().min(1).describe("Chat RTDB message id."), confirm: z.boolean().optional().describe("Required true for deletion.") },
-        outputSchema: basicEventOutputSchema,
-        annotations: destructiveTool,
-    }, async ({ eventId, messageId, confirm }) => {
-        const { uid } = await authed(["chat:moderate"]);
-        await readEvent(eventId, uid, "moderate");
-        requireConfirm(confirm, "oko_delete_chat_message", { eventId, messageId });
-        await set(ref(chatRtdb, `mod/deleted/${eventId}/${messageId}`), { deletedAt: rtdbServerTimestamp(), ts: Date.now(), by: uid });
-        return textResult({ eventId, messageId, deleted: true });
-    });
-    server.registerTool("oko_mute_user", {
-        title: "Mute chat user",
-        description: toolDescription({
-            summary: "Mute a chat user for a bounded time window.",
-            args: ["eventId: target event.", "uid: Firebase uid to mute.", "minutes: mute duration, 1-1440, default 5.", "confirm: must be true."],
-            returns: "eventId, targetUid, and mutedMinutes.",
-            examples: ["Use after reading chat messages and confirming the exact uid with the user."],
-        }),
-        inputSchema: { eventId: eventIdField, uid: z.string().min(1).describe("Firebase uid to mute."), minutes: z.number().int().min(1).max(1440).default(5).describe("Mute duration in minutes."), confirm: z.boolean().optional().describe("Required true for mute.") },
-        outputSchema: basicEventOutputSchema,
-        annotations: destructiveTool,
-    }, async ({ eventId, uid: targetUid, minutes, confirm }) => {
-        const actor = await authed(["chat:moderate"]);
-        await readEvent(eventId, actor.uid, "moderate");
-        requireConfirm(confirm, "oko_mute_user", { eventId, targetUid, minutes });
-        await set(ref(chatRtdb, `mutes/${eventId}/${targetUid}`), { until: Date.now() + minutes * 60_000, by: actor.uid, reason: "manual" });
-        return textResult({ eventId, targetUid, mutedMinutes: minutes });
-    });
-    server.registerTool("oko_ban_user", {
-        title: "Ban chat user",
-        description: toolDescription({
-            summary: "Ban a chat user and soft-delete up to 500 recent messages from that uid.",
-            args: ["eventId: target event.", "uid: Firebase uid to ban.", "confirm: must be true."],
-            returns: "eventId, targetUid, banned=true, and deletedMessages count.",
-            examples: ["Use only after explicit user confirmation; prefer mute for temporary moderation."],
-        }),
-        inputSchema: { eventId: eventIdField, uid: z.string().min(1).describe("Firebase uid to ban."), confirm: z.boolean().optional().describe("Required true for ban.") },
-        outputSchema: basicEventOutputSchema,
-        annotations: destructiveTool,
-    }, async ({ eventId, uid: targetUid, confirm }) => {
-        const actor = await authed(["chat:moderate"]);
-        await readEvent(eventId, actor.uid, "moderate");
-        requireConfirm(confirm, "oko_ban_user", { eventId, targetUid });
-        await set(ref(chatRtdb, `bans/${eventId}/${targetUid}`), true);
-        const messagesSnap = await get(dbQuery(ref(chatRtdb, `messages/${eventId}`), limitToLast(500)));
-        const messages = (messagesSnap.val() ?? {});
-        const deletes = {};
-        for (const [messageId, message] of Object.entries(messages)) {
-            if (message.uid === targetUid)
-                deletes[`mod/deleted/${eventId}/${messageId}`] = { deletedAt: rtdbServerTimestamp(), ts: Date.now(), by: actor.uid, reason: "ban" };
-        }
-        if (Object.keys(deletes).length > 0)
-            await update(ref(chatRtdb), deletes);
-        return textResult({ eventId, targetUid, banned: true, deletedMessages: Object.keys(deletes).length });
-    });
-    server.registerTool("oko_unmute_user", {
-        title: "Unmute chat user",
-        description: toolDescription({
-            summary: "Remove a chat mute for a user.",
-            args: ["eventId: target event.", "uid: Firebase uid to unmute.", "confirm: must be true."],
-            returns: "eventId, targetUid, and unmuted=true.",
-            examples: ["Use when a user was muted by mistake or the organizer wants to restore chat access."],
-        }),
-        inputSchema: { eventId: eventIdField, uid: z.string().min(1).describe("Firebase uid to unmute."), confirm: z.boolean().optional().describe("Required true for unmute.") },
-        outputSchema: basicEventOutputSchema,
-        annotations: idempotentWriteTool,
-    }, async ({ eventId, uid: targetUid, confirm }) => {
-        const actor = await authed(["chat:moderate"]);
-        await readEvent(eventId, actor.uid, "moderate");
-        requireConfirm(confirm, "oko_unmute_user", { eventId, targetUid });
-        await remove(ref(chatRtdb, `mutes/${eventId}/${targetUid}`));
-        return textResult({ eventId, targetUid, unmuted: true });
-    });
-    server.registerTool("oko_unban_user", {
-        title: "Unban chat user",
-        description: toolDescription({
-            summary: "Remove a chat ban for a user.",
-            args: ["eventId: target event.", "uid: Firebase uid to unban.", "confirm: must be true."],
-            returns: "eventId, targetUid, and unbanned=true.",
-            examples: ["Use when a user was banned by mistake or the organizer wants to restore event chat access."],
-        }),
-        inputSchema: { eventId: eventIdField, uid: z.string().min(1).describe("Firebase uid to unban."), confirm: z.boolean().optional().describe("Required true for unban.") },
-        outputSchema: basicEventOutputSchema,
-        annotations: idempotentWriteTool,
-    }, async ({ eventId, uid: targetUid, confirm }) => {
-        const actor = await authed(["chat:moderate"]);
-        await readEvent(eventId, actor.uid, "moderate");
-        requireConfirm(confirm, "oko_unban_user", { eventId, targetUid });
-        await remove(ref(chatRtdb, `bans/${eventId}/${targetUid}`));
-        return textResult({ eventId, targetUid, unbanned: true });
-    });
-    server.registerTool("oko_set_chat_settings", {
-        title: "Set chat settings",
-        description: toolDescription({
-            summary: "Set slow mode and automod settings for an event chat.",
-            args: ["eventId: target event.", "slowModeMs: optional slow mode delay, 0-60000 ms.", "automodEnabled: optional automod toggle.", "confirm: must be true."],
-            returns: "eventId and updated RTDB setting paths.",
-            examples: ["Use slowModeMs=5000 to slow busy chats; use automodEnabled=false as an emergency kill switch."],
-        }),
-        inputSchema: {
-            eventId: eventIdField,
-            slowModeMs: z.number().int().min(0).max(60000).optional().describe("Slow mode delay in milliseconds."),
-            automodEnabled: z.boolean().optional().describe("Enable or disable chat automoderation."),
-            confirm: z.boolean().optional().describe("Required true to change live chat settings."),
-        },
-        outputSchema: basicEventOutputSchema,
-        annotations: idempotentWriteTool,
-    }, async ({ eventId, slowModeMs, automodEnabled, confirm }) => {
-        const { uid } = await authed(["chat:moderate"]);
-        await readEvent(eventId, uid, "moderate");
-        requireConfirm(confirm, "oko_set_chat_settings", { eventId, slowModeMs: slowModeMs ?? null, automodEnabled: automodEnabled ?? null });
-        const patch = {};
-        if (slowModeMs !== undefined)
-            patch[`settings/${eventId}/slowModeMs`] = slowModeMs;
-        if (automodEnabled !== undefined)
-            patch[`settings/${eventId}/automodEnabled`] = automodEnabled;
-        await update(ref(chatRtdb), patch);
-        return textResult({ eventId, updated: Object.keys(patch) });
-    });
-    server.registerTool("oko_list_leads", {
-        title: "List form leads",
-        description: toolDescription({
-            summary: "Read paginated lead form submissions for an event.",
-            args: [
-                "eventId: target event.",
-                "formId: optional lead form id filter.",
-                "csv: return CSV string instead of leads array.",
-                "limit: max rows, default 50, max 200.",
-                "cursor: lead document id returned as nextCursor by the previous page.",
-            ],
-            returns: "leads or csv plus count, limit, hasMore/has_more, nextCursor/next_cursor.",
-            examples: ["Use formId to export one form; if Firestore requests an index, create it from the error link and rerun."],
-        }),
-        inputSchema: {
-            eventId: eventIdField,
-            formId: z.string().optional().describe("Optional lead form id to filter submissions."),
-            csv: z.boolean().default(false).describe("Return CSV string instead of JSON rows."),
-            limit: limitField(MAX_EXPORT_LIMIT, 50),
-            cursor: cursorField,
-        },
-        outputSchema: leadsOutputSchema,
-        annotations: readOnlyTool,
-    }, async ({ eventId, formId, csv, limit: max, cursor }) => {
-        const { uid } = await authed(["leads:read"]);
-        await readEvent(eventId, uid, "analytics");
-        const base = collection(firestore, "events", eventId, "leads");
-        const constraints = formId
-            ? [where("formId", "==", formId), orderBy(documentId()), ...(cursor ? [startAfter(cursor)] : []), limit(max + 1)]
-            : [orderBy(documentId()), ...(cursor ? [startAfter(cursor)] : []), limit(max + 1)];
-        const snap = await getDocs(query(base, ...constraints));
-        const page = snap.docs.slice(0, max);
-        const leads = page.map((item) => ({ id: item.id, ...serialize(item.data()) }));
-        const hasMore = snap.docs.length > max;
-        const nextCursor = hasMore ? page.at(-1)?.id ?? null : null;
-        const meta = cursorMeta(leads.length, max, hasMore, nextCursor);
-        if (csv) {
-            const text = csvRows(["id", "formId", "source", "submittedAt", "valuesJson"], leads.map((lead) => [lead.id, lead.formId, lead.source, lead.submittedAt, JSON.stringify(lead.values ?? {})]));
-            return textResult({ csv: text, ...meta });
-        }
-        return textResult({ leads, ...meta });
-    });
-    server.registerTool("oko_delete_lead", {
-        title: "Delete form lead",
-        description: toolDescription({
-            summary: "Delete one lead/form submission from an event.",
-            args: ["eventId: event id.", "leadId: events/{eventId}/leads document id.", "confirm: must be true."],
-            returns: "eventId, leadId, deleted=true, and a small preview of the deleted lead.",
-            examples: ["Use after listing leads and confirming the exact submission to remove."],
-            notes: ["Destructive. Requires setup:write in addition to leads:read so read-only keys cannot delete leads."],
-        }),
-        inputSchema: {
-            eventId: eventIdField,
-            leadId: z.string().min(1).max(160).describe("Lead document id under events/{eventId}/leads."),
-            confirm: z.boolean().optional().describe("Required true for lead deletion."),
-        },
-        outputSchema: deleteLeadOutputSchema,
-        annotations: destructiveTool,
-    }, async ({ eventId, leadId, confirm }) => {
-        const { uid } = await authed(["leads:read", "setup:write"]);
-        await readEvent(eventId, uid, "edit");
-        const leadRef = doc(firestore, "events", eventId, "leads", leadId);
-        const leadSnap = await getDoc(leadRef);
-        if (!leadSnap.exists())
-            throw new Error("Lead not found.");
-        const lead = serialize(leadSnap.data());
-        requireConfirm(confirm, "oko_delete_lead", { eventId, leadId, formId: lead.formId, source: lead.source, submittedAt: lead.submittedAt });
-        await deleteDoc(leadRef);
-        return textResult({ eventId, leadId, deleted: true, leadPreview: lead });
-    });
-    server.registerTool("oko_list_notifications", {
-        title: "List notifications",
-        description: toolDescription({
-            summary: "List in-app notifications for the authenticated organizer.",
-            args: [
-                "unreadOnly: only unread notifications, default false.",
-                "limit: max notifications, default 20, max 100.",
-                "cursor: createdAt cursor returned as nextCursor by the previous page.",
-            ],
-            returns: "notifications plus unreadCountOnPage and cursor pagination metadata.",
-            examples: ["Use when the organizer asks what changed in OKO or what notifications are waiting."],
-        }),
-        inputSchema: {
-            unreadOnly: z.boolean().default(false).describe("Return only unread notifications."),
-            limit: limitField(100, 20),
-            cursor: cursorField,
-        },
-        outputSchema: notificationsOutputSchema,
-        annotations: readOnlyTool,
-    }, async ({ unreadOnly, limit: max, cursor }) => {
-        const { uid } = await authed(["workspace:read"]);
-        const fetchLimit = unreadOnly ? Math.min(max * 5 + 1, 501) : max + 1;
-        const constraints = [
-            orderBy("createdAt", "desc"),
-            limit(fetchLimit),
-        ];
-        if (cursor)
-            constraints.splice(1, 0, startAfter(parseTimestampCursor(cursor)));
-        const snap = await getDocs(query(collection(firestore, "userNotifications", uid, "items"), ...constraints));
-        const matchingDocs = unreadOnly ? snap.docs.filter((item) => item.data().read !== true) : snap.docs;
-        const { page, hasMore: hasMoreInMatches } = pickPage(matchingDocs, max);
-        const hasMore = hasMoreInMatches || snap.docs.length >= fetchLimit;
-        const cursorSource = hasMoreInMatches ? page.at(-1) : snap.docs.at(-1);
-        const notifications = page.map((item) => ({ id: item.id, ...serialize(item.data()) }));
-        const nextCursor = hasMore ? timestampCursorFrom(cursorSource?.data().createdAt) : null;
-        return textResult({
-            notifications,
-            unreadCountOnPage: notifications.filter((item) => item.read !== true).length,
-            ...cursorMeta(notifications.length, max, hasMore, nextCursor),
-        });
-    });
-    server.registerTool("oko_mark_notifications_read", {
-        title: "Mark notifications read",
-        description: toolDescription({
-            summary: "Mark own OKO in-app notifications as read.",
-            args: [
-                "notificationIds: optional explicit notification ids, max 100.",
-                "allUnread: true to mark unread notifications on the first page, max controlled by limit.",
-                "limit: when allUnread=true, max unread notifications to mark, default 100, max 200.",
-            ],
-            returns: "markedRead count and notification ids updated.",
-            examples: ["Use after oko_list_notifications when the user asks to clear the bell/unread state."],
-            notes: ["Provide either notificationIds or allUnread=true. This can update only the current organizer's own notifications."],
-        }),
-        inputSchema: {
-            notificationIds: z.array(z.string().min(1).max(160)).max(100).optional().describe("Specific notification document ids."),
-            allUnread: z.boolean().default(false).describe("Mark unread notifications as read."),
-            limit: limitField(200, 100),
-        },
-        outputSchema: notificationsMarkOutputSchema,
-        annotations: idempotentWriteTool,
-    }, async ({ notificationIds, allUnread, limit: max }) => {
-        const { uid } = await authed(["workspace:read"]);
-        if (Boolean(notificationIds?.length) === allUnread) {
-            throw new Error("Provide either notificationIds or allUnread=true.");
-        }
-        let ids = [...new Set(notificationIds ?? [])];
-        if (allUnread) {
-            const snap = await getDocs(query(collection(firestore, "userNotifications", uid, "items"), where("read", "==", false), limit(max)));
-            ids = snap.docs.map((item) => item.id);
-        }
-        await Promise.all(ids.map((id) => updateDoc(doc(firestore, "userNotifications", uid, "items", id), { read: true })));
-        return textResult({ markedRead: ids.length, notificationIds: ids });
-    });
-    server.registerTool("oko_create_telegram_link", {
-        title: "Link personal Telegram",
-        description: toolDescription({
-            summary: "Create a short-lived Telegram deep link that binds the organizer's personal Telegram identity to OKO.",
-            args: [],
-            returns: "@OKOStreamBot link and expiry in seconds.",
-            examples: ["Open the returned link in the organizer's Telegram account before claiming a channel."],
-            notes: ["The link expires in 15 minutes and can be used only once. Opening it is a user action outside MCP."],
-        }),
-        inputSchema: {},
-        outputSchema: z.object({ url: z.string().url(), expiresIn: z.number().int().positive() }).passthrough(),
-        annotations: writeTool,
-    }, async () => {
-        await authed(["telegram:write"]);
-        const createLink = httpsCallable(functions, "createTelegramLink");
-        return textResult((await createLink({})).data);
-    });
-    server.registerTool("oko_list_telegram_channels", {
-        title: "List Telegram channels",
-        description: toolDescription({
-            summary: "List Telegram channels available to the authenticated organizer.",
-            args: [
-                "eventId: optional event; when provided, include channels explicitly shared to that event's workspace.",
-                "includeWorkspaceChannels: deprecated compatibility field; eventId is required to resolve workspace sharing safely.",
-            ],
-            returns: "canonical channels with identity, workspace sharing, ownership, subscriber count, and connection health.",
-            examples: ["Use before oko_publish_telegram_post so the user can choose a channel by title instead of numeric id."],
-        }),
-        inputSchema: {
-            eventId: eventIdField.optional().describe("Optional event used to include channels shared to its workspace."),
-            includeWorkspaceChannels: z.boolean().optional().describe("Deprecated; retained for client compatibility."),
-        },
-        outputSchema: telegramChannelsOutputSchema,
-        annotations: readOnlyTool,
-    }, async ({ eventId }) => {
-        await authed(["telegram:write"]);
-        const listChannels = httpsCallable(functions, "listTelegramChannels");
-        const result = await listChannels(eventId ? { eventId } : {});
-        const parsed = z.array(canonicalTelegramChannelSchema).safeParse(result.data.channels);
-        if (!parsed.success)
-            throw new Error("OKO listTelegramChannels returned an invalid channel payload.");
-        const channels = parsed.data.sort((a, b) => (a.title ?? "").localeCompare(b.title ?? ""));
-        return textResult({ channels, count: channels.length });
-    });
-    server.registerTool("oko_claim_telegram_channel", {
-        title: "Claim Telegram channel",
-        description: toolDescription({
-            summary: "Claim a pending Telegram channel using the code sent by OKO bot.",
-            args: [
-                "claimCode: code posted by the bot after it was added to a channel.",
-                "workspaceIds: optional owned workspaces to expose this channel to after claim.",
-                "confirm: must be true.",
-            ],
-            returns: "claimed channel and workspace ids updated.",
-            examples: ["Link personal Telegram first, add @OKOStreamBot as channel administrator, copy the claim code, then call this tool."],
-            notes: ["The linked personal Telegram user must be a channel administrator. Workspace sharing is server-validated."],
-        }),
-        inputSchema: {
-            claimCode: z.string().min(4).max(32).describe("Telegram channel claim code."),
-            workspaceIds: z.array(z.string().min(1)).max(20).default([]).describe("Optional workspace ids to attach the channel to."),
-            confirm: z.boolean().optional().describe("Required true to claim and attach the channel."),
-        },
-        outputSchema: z.object({ channel: unknownRecordSchema, workspaceIdsUpdated: z.array(z.string()) }).passthrough(),
-        annotations: writeTool,
-    }, async ({ claimCode, workspaceIds, confirm }) => {
-        await authed(["telegram:write"]);
-        requireConfirm(confirm, "oko_claim_telegram_channel", { workspaceIds: workspaceIds.join(",") });
-        const claimChannel = httpsCallable(functions, "claimTelegramChannel");
-        const result = await claimChannel({ code: claimCode.trim().toUpperCase() });
-        const data = serialize(result.data);
-        const channelRaw = data.channel && typeof data.channel === "object" ? data.channel : {};
-        const parsed = telegramChannelSchema.safeParse(channelRaw);
-        if (!parsed.success)
-            throw new Error("OKO claimTelegramChannel returned an invalid channel payload.");
-        if (workspaceIds.length > 0) {
-            const setWorkspaces = httpsCallable(functions, "setTelegramChannelWorkspaces");
-            await setWorkspaces({ channelId: parsed.data.chatId, workspaceIds });
-        }
-        return textResult({ ...data, channel: parsed.data, workspaceIdsUpdated: workspaceIds });
-    });
-    server.registerTool("oko_set_telegram_channel_workspaces", {
-        title: "Share Telegram channel to workspaces",
-        description: toolDescription({
-            summary: "Replace the owned Telegram channel's explicit OKO workspace sharing list.",
-            args: ["channelId: owned Telegram channel id.", "workspaceIds: complete replacement list, up to 50.", "confirm: must be true."],
-            returns: "channel id and the applied workspace ids.",
-            examples: ["Use an empty workspaceIds list to make the channel private to its owner again."],
-            notes: ["This replaces, rather than appends to, the current sharing list. Every workspace must be owned by the organizer."],
-        }),
-        inputSchema: {
-            channelId: z.number().int().describe("Owned Telegram channel id."),
-            workspaceIds: z.array(z.string().min(1).max(128)).max(50).describe("Complete replacement workspace sharing list."),
-            confirm: z.boolean().optional().describe("Required true to change workspace sharing."),
-        },
-        outputSchema: z.object({ success: z.boolean(), channelId: z.number().int(), workspaceIds: z.array(z.string()) }).passthrough(),
-        annotations: writeTool,
-    }, async ({ channelId, workspaceIds, confirm }) => {
-        await authed(["telegram:write"]);
-        requireConfirm(confirm, "oko_set_telegram_channel_workspaces", { channelId, workspaceIds: workspaceIds.join(",") });
-        const setWorkspaces = httpsCallable(functions, "setTelegramChannelWorkspaces");
-        return textResult((await setWorkspaces({ channelId, workspaceIds })).data);
-    });
-    server.registerTool("oko_disconnect_telegram_channel", {
-        title: "Disconnect Telegram channel",
-        description: toolDescription({
-            summary: "Disconnect an owned Telegram channel from OKO and clear all workspace sharing.",
-            args: ["channelId: owned Telegram channel id.", "confirm: must be true."],
-            returns: "disconnected channel id.",
-            examples: ["Use only after showing the exact channel selected from oko_list_telegram_channels."],
-            notes: ["Existing sent Telegram messages are not deleted. The channel must be claimed again before future publication."],
-        }),
-        inputSchema: {
-            channelId: z.number().int().describe("Owned Telegram channel id."),
-            confirm: z.boolean().optional().describe("Required true to disconnect the channel."),
-        },
-        outputSchema: z.object({ success: z.boolean(), channelId: z.number().int() }).passthrough(),
-        annotations: destructiveTool,
-    }, async ({ channelId, confirm }) => {
-        await authed(["telegram:write"]);
-        requireConfirm(confirm, "oko_disconnect_telegram_channel", { channelId });
-        const disconnect = httpsCallable(functions, "disconnectTelegramChannel");
-        return textResult((await disconnect({ channelId })).data);
-    });
-    server.registerTool("oko_list_telegram_posts", {
-        title: "List Telegram posts",
-        description: toolDescription({
-            summary: "List Telegram notification posts for an event.",
-            args: [
-                "eventId: event whose Telegram posts to list.",
-                "status: optional client-side status filter.",
-                "limit: max posts, default 30, max 100.",
-                "cursor: createdAt cursor returned by previous page.",
-            ],
-            returns: "posts plus cursor pagination metadata.",
-            examples: ["Use to review scheduled/sent/failed Telegram posts before canceling or cloning."],
-        }),
-        inputSchema: {
-            eventId: eventIdField,
-            status: z.enum(TELEGRAM_POST_STATUSES).optional().describe("Optional post status filter."),
-            limit: limitField(),
-            cursor: cursorField,
-        },
-        outputSchema: telegramPostsOutputSchema,
-        annotations: readOnlyTool,
-    }, async ({ eventId, status, limit: max, cursor }) => {
-        const { uid } = await authed(["telegram:write"]);
-        await readEvent(eventId, uid, "notify");
-        const constraints = [
-            where("eventId", "==", eventId),
-            orderBy("createdAt", "desc"),
-            limit(max + 1),
-        ];
-        if (cursor)
-            constraints.splice(2, 0, startAfter(parseTimestampCursor(cursor)));
-        const snap = await getDocs(query(collection(firestore, "telegramPosts"), ...constraints));
-        const { page, hasMore } = pickPage(snap.docs, max);
-        let posts = page.map((item) => ({ id: item.id, ...serialize(item.data()) }));
-        if (status)
-            posts = posts.filter((post) => post.status === status);
-        const nextCursor = hasMore ? timestampCursorFrom(page.at(-1)?.data().createdAt) : null;
-        return textResult({ posts, ...cursorMeta(posts.length, max, hasMore, nextCursor) });
-    });
-    server.registerTool("oko_cancel_telegram_post", {
-        title: "Cancel Telegram post",
-        description: toolDescription({
-            summary: "Delete a draft/scheduled/failed Telegram post record before it is sent.",
-            args: ["postId: telegramPosts document id.", "confirm: must be true."],
-            returns: "postId, eventId, status, and canceled=true.",
-            examples: ["Use for scheduled posts that should not be sent."],
-            notes: ["Already sent Telegram messages cannot be unsent through OKO; this tool refuses status=sent."],
-        }),
-        inputSchema: { postId: z.string().min(1), confirm: z.boolean().optional().describe("Required true for cancellation.") },
-        outputSchema: z.object({ postId: z.string(), canceled: z.boolean() }).passthrough(),
-        annotations: destructiveTool,
-    }, async ({ postId, confirm }) => {
-        const { uid } = await authed(["telegram:write"]);
-        const postRef = doc(firestore, "telegramPosts", postId);
-        const postSnap = await getDoc(postRef);
-        if (!postSnap.exists())
-            throw new Error("Telegram post not found.");
-        const post = postSnap.data();
-        if (typeof post.eventId !== "string")
-            throw new Error("Telegram post has no valid event.");
-        await readEvent(post.eventId, uid, "notify");
-        if (!["draft", "pending", "scheduled", "failed"].includes(safeString(post.status))) {
-            throw new Error("Only draft, pending, scheduled, or failed Telegram posts can be canceled. A sent or delivery-unknown post must be reviewed manually.");
-        }
-        requireConfirm(confirm, "oko_cancel_telegram_post", { postId, eventId: post.eventId, status: post.status, caption: post.caption });
-        await deleteDoc(postRef);
-        return textResult({ postId, eventId: post.eventId, status: post.status, canceled: true });
-    });
-    server.registerTool("oko_publish_telegram_post", {
-        title: "Publish Telegram post",
-        description: toolDescription({
-            summary: "Create and optionally send or schedule a Telegram post for an OKO event.",
-            args: [
-                "eventId: event used for access checks and default button URL.",
-                "channelId: Telegram channel id configured for the organizer.",
-                "caption: post caption, max 4096 chars.",
-                "scheduleAt: optional ISO datetime; omitted means immediate send.",
-                "confirm: must be true for both immediate and scheduled publication.",
-            ],
-            returns: "postId, scheduled flag, and sent flag.",
-            examples: ["Use scheduleAt for scheduled posts; for immediate send, show the exact channel/caption and ask for confirmation."],
-            notes: ["External side effect: immediate sends can publish to real Telegram channels."],
-        }),
-        inputSchema: {
-            eventId: eventIdField,
-            channelId: z.number().int().describe("Telegram channel id."),
-            caption: z.string().min(1).max(4096).describe("Telegram post caption."),
-            imageUrl: z.string().nullable().optional().describe("Optional image URL."),
-            buttonLabel: z.string().max(64).nullable().optional().describe("Optional inline button label."),
-            buttonUrl: z.string().max(1000).nullable().optional().describe("Optional inline button URL; defaults to event URL when buttonLabel is set."),
-            scheduleAt: z.string().datetime().nullable().optional().describe("Optional ISO datetime for scheduled send."),
-            confirm: z.boolean().optional().describe("Required true to create the external Telegram side effect."),
-        },
-        outputSchema: z.object({ postId: z.string(), scheduled: z.boolean(), sent: z.boolean() }).passthrough(),
-        annotations: writeTool,
-    }, async (args) => {
-        const { uid } = await authed(["telegram:write"]);
-        await readEvent(args.eventId, uid, "notify");
-        const listChannels = httpsCallable(functions, "listTelegramChannels");
-        const availableResult = await listChannels({ eventId: args.eventId });
-        const available = z.array(canonicalTelegramChannelSchema).safeParse(availableResult.data.channels);
-        if (!available.success)
-            throw new Error("OKO listTelegramChannels returned an invalid channel payload.");
-        const channel = available.data.find((item) => item.chatId === args.channelId);
-        if (!channel)
-            throw new Error("Telegram channel is not available for this event. List channels with this eventId and choose a returned channel.");
-        const scheduled = !!args.scheduleAt;
-        requireConfirm(args.confirm, "oko_publish_telegram_post", {
-            eventId: args.eventId,
-            channelId: args.channelId,
-            channelTitle: channel.title ?? "",
-            caption: args.caption,
-            scheduleAt: args.scheduleAt ?? null,
-        });
-        const postData = {
-            eventId: args.eventId,
-            ownerId: uid,
-            ownerEmail: "",
-            channelId: args.channelId,
-            channelKey: String(args.channelId),
-            caption: args.caption.trim(),
-            imageUrl: args.imageUrl?.trim() || null,
-            buttons: args.buttonLabel?.trim() ? [{ label: args.buttonLabel.trim(), url: args.buttonUrl?.trim() || eventUrl(args.eventId) }] : [],
-            status: scheduled ? "scheduled" : "draft",
-            scheduledAt: args.scheduleAt ? Timestamp.fromDate(new Date(args.scheduleAt)) : null,
-            sentAt: null,
-            telegramMessageId: null,
-            error: null,
-            createdAt: serverTimestamp(),
-            updatedAt: serverTimestamp(),
-        };
-        const postRef = await addDoc(collection(firestore, "telegramPosts"), postData);
-        if (!scheduled) {
-            const sendPost = httpsCallable(functions, "sendTelegramPost");
-            await sendPost({ postId: postRef.id });
-        }
-        return textResult({ postId: postRef.id, scheduled, sent: !scheduled });
-    });
-    server.registerTool("oko_create_workspace_invite", {
-        title: "Create workspace invite",
-        description: toolDescription({
-            summary: "Create a workspace invite for a known OKO workspace.",
-            args: [
-                "workspaceId: workspace owned by the authenticated organizer.",
-                "code: optional invite code, 4-64 chars; omitted means generated.",
-                "email: optional intended recipient email.",
-                "permissions: optional whitelist of workspace permission booleans.",
-                "confirm: must be true.",
-            ],
-            returns: "workspaceId, invite code, inviteUrl, and created=true.",
-            examples: ["Use only after confirming the recipient and permission set with the workspace owner."],
-        }),
-        inputSchema: {
-            workspaceId: z.string().min(1),
-            code: z.string().min(4).max(MAX_WORKSPACE_INVITE_CODE_LENGTH).optional(),
-            email: z.string().email().optional(),
-            comment: z.string().max(500).default(""),
-            permissions: workspacePermissionsSchema,
-            confirm: z.boolean().optional(),
-        },
-        outputSchema: z.object({ workspaceId: z.string(), code: z.string(), inviteUrl: z.string().url(), created: z.boolean() }).passthrough(),
-        annotations: writeTool,
-    }, async (args) => {
-        const { uid } = await authed(["workspace:write"]);
-        const workspace = await readWorkspaceForOwner(args.workspaceId, uid);
-        requireConfirm(args.confirm, "oko_create_workspace_invite", { workspaceId: args.workspaceId, code: args.code, email: args.email });
-        const code = (args.code?.trim() || randomInviteCode()).toUpperCase();
-        const inviteUrl = `https://okostream.app/invite/${code}`;
-        await setDoc(doc(firestore, "workspaceInvites", code), {
-            workspaceId: args.workspaceId,
-            workspaceName: safeString(workspace.name, "Workspace"),
-            email: args.email ?? "",
-            comment: args.comment,
-            permissions: normalizeWorkspacePermissions(args.permissions),
-            createdBy: uid,
-            createdAt: serverTimestamp(),
-            claimed: false,
-            claimedBy: null,
-        });
-        return textResult({ workspaceId: args.workspaceId, code, inviteUrl, created: true });
-    });
+    // Обёртка ставится первой: она подменяет server.registerTool, и всё
+    // зарегистрированное ПОСЛЕ получает аудит записей и человеческий ответ
+    // на отказ авторизации.
+    installToolInstrumentation(server);
+    // Порядок сохранён с дораборного файла — он задаёт порядок в tools/list.
+    registerAccountTools(server);
+    registerWorkspaceTools(server);
+    registerEventTools(server);
+    registerImageTools(server);
+    registerLifecycleTools(server);
+    registerLiveTools(server);
+    registerSessionTools(server);
+    registerChatTools(server);
+    registerLeadTools(server);
+    registerNotificationTools(server);
+    registerTelegramTools(server);
 }