@okostream/mcp 0.12.7 → 0.12.9

package/dist/server.js

@@ -70639,7 +70639,7 @@ var GUIDE_RESOURCES = [
       "1. Call `oko_whoami` and inspect scopes.",
       "2. If the workspace is unclear, call `oko_list_workspaces`.",
       "3. Call `oko_create_webinar` with title/date/workspace and video URL when known.",
-      "4. Call `oko_configure_blocks` for video, forms, CTA, banner, and Telegram settings.",
+      "4. Call `oko_configure_blocks` for video, forms, CTA, banner, and Telegram settings (Telegram channels there need telegram:write plus the notification permission on the event).",
       "5. Call `oko_configure_cards` with stable card ids before uploading card images.",
       "6. Upload images with `oko_upload_card_images_batch` or `oko_upload_image`, then wait for variants.",
       "7. Call `oko_validate_event_setup` and fix blocking findings.",
@@ -70731,8 +70731,9 @@ var GUIDE_RESOURCES = [
       "1. Call `oko_create_telegram_link` and complete the one-time bot link in the organizer's account.",
       "2. Add `@OKOStreamBot` to the target channel as an administrator with posting permission.",
       "3. Use the claim code returned by the bot with `oko_claim_telegram_channel` and `confirm:true`.",
-      "4. Call `oko_list_telegram_channels`, then connect the selected id through `oko_configure_blocks`.",
+      "4. Call `oko_list_telegram_channels`, then connect the selected id through `oko_configure_blocks` \u2014 its `telegramChannelIds` needs the telegram:write scope and the notification permission on the event, and is refused before the write without them.",
       "5. Publish or schedule with `oko_publish_telegram_post` only after showing the exact channel and copy.",
+      "   The caption is Telegram HTML: `<b>`, `<i>` and `<a href>` are markup. Escape `&`, `<` and `>` in any text copied from event fields, or Telegram rejects the message and the post lands in `failed`.",
       "6. Inspect delivery through `oko_list_telegram_posts`; avoid retrying `delivery_unknown` automatically.",
       "",
       "The MCP does not toggle the platform auto-reminder. Schedule an explicit reminder post or use web setup."
@@ -70855,6 +70856,18 @@ var DEFAULT_CHARACTER_LIMIT = 3e4;
 var MAX_COMPACT_ARRAY_ITEMS = 25;
 var MAX_COMPACT_OBJECT_KEYS = 60;
 var MAX_COMPACT_STRING_LENGTH = 2e3;
+function isFirestorePermissionDenied(error3) {
+  if (!error3 || typeof error3 !== "object")
+    return false;
+  const code = error3.code;
+  return code === "permission-denied" || code === "firestore/permission-denied" || code === "PERMISSION_DENIED";
+}
+function isFirestoreNotFound(error3) {
+  if (!error3 || typeof error3 !== "object")
+    return false;
+  const code = error3.code;
+  return code === "not-found" || code === "firestore/not-found" || code === "NOT_FOUND";
+}
 function serialize(value) {
   if (value == null)
     return value;
@@ -116130,6 +116143,41 @@ function readImageRoots() {
   }
   return roots;
 }
+var FIREBASE_FIELDS = [
+  ["apiKey", ["OKO_FIREBASE_API_KEY", "NEXT_PUBLIC_FIREBASE_API_KEY"]],
+  ["authDomain", ["OKO_FIREBASE_AUTH_DOMAIN", "NEXT_PUBLIC_FIREBASE_AUTH_DOMAIN"]],
+  ["databaseURL", ["OKO_FIREBASE_DATABASE_URL", "NEXT_PUBLIC_FIREBASE_DATABASE_URL"]],
+  ["projectId", ["OKO_FIREBASE_PROJECT_ID", "NEXT_PUBLIC_FIREBASE_PROJECT_ID"]],
+  ["storageBucket", ["OKO_FIREBASE_STORAGE_BUCKET", "NEXT_PUBLIC_FIREBASE_STORAGE_BUCKET"]],
+  ["messagingSenderId", ["OKO_FIREBASE_MESSAGING_SENDER_ID", "NEXT_PUBLIC_FIREBASE_MESSAGING_SENDER_ID"]],
+  ["appId", ["OKO_FIREBASE_APP_ID", "NEXT_PUBLIC_FIREBASE_APP_ID"]],
+  ["chatDatabaseURL", ["OKO_FIREBASE_CHAT_DB_URL", "NEXT_PUBLIC_FIREBASE_CHAT_DB_URL"]]
+];
+function firebaseConfigError(source) {
+  const overridden = [];
+  const missing = [];
+  for (const [field2, names] of FIREBASE_FIELDS) {
+    const label = names[0] ?? field2;
+    let value = null;
+    for (const name7 of names) {
+      const candidate = normalizeOptionalEnv(source[name7]);
+      if (candidate) {
+        value = candidate;
+        break;
+      }
+    }
+    if (value === null)
+      missing.push(label);
+    else if (value !== DEFAULT_FIREBASE_CONFIG[field2])
+      overridden.push(label);
+  }
+  if (overridden.length === 0 || missing.length === 0)
+    return null;
+  return `OKO MCP: the Firebase config is only partially set. ${overridden.join(", ")} point at another project, while ${missing.join(", ")} are not set and would silently fall back to the built-in okostreamcore values. Set the whole Firebase config or none of it.`;
+}
+var firebaseConfigProblem = firebaseConfigError(process.env);
+if (firebaseConfigProblem)
+  throw new Error(firebaseConfigProblem);
 var env = {
   apiKey: readOptionalEnv("OKO_API_KEY"),
   imageRoots: readImageRoots(),
@@ -116224,7 +116272,7 @@ function sanitizeScopes(scopes) {
 }
 
 // build/version.js
-var OKO_MCP_VERSION = "0.12.7";
+var OKO_MCP_VERSION = "0.12.9";
 
 // build/auth.js
 var state = null;
@@ -116348,29 +116396,40 @@ async function exchangeApiKey() {
     latestVersion: typeof data.latestVersion === "string" && parseVersion(data.latestVersion) ? data.latestVersion.trim() : null
   };
 }
-async function ensureAuth(requiredScopes = []) {
+function singleFlight(run) {
+  let inFlight = null;
+  return () => {
+    inFlight ??= run().finally(() => {
+      inFlight = null;
+    });
+    return inFlight;
+  };
+}
+var refreshSession = singleFlight(async () => {
   const now = Date.now();
-  if (!state || now > state.expiresAt - 5 * 60 * 1e3 || !auth.currentUser) {
-    const exchanged = await exchangeApiKey();
-    try {
-      await signInWithCustomToken(auth, exchanged.customToken);
-    } catch {
-      throw new OkoAuthError("unavailable", "OKO MCP received an organizer session but could not initialize it. Reconnect and try again.");
-    }
-    state = {
-      uid: exchanged.organizerUid,
-      scopes: exchanged.scopes,
-      expiresAt: now + exchanged.expiresIn * 1e3
-    };
-    if (exchanged.latestVersion)
-      recordLatestPublishedVersion(exchanged.latestVersion);
+  const exchanged = await exchangeApiKey();
+  try {
+    await signInWithCustomToken(auth, exchanged.customToken);
+  } catch {
+    throw new OkoAuthError("unavailable", "OKO MCP received an organizer session but could not initialize it. Reconnect and try again.");
   }
+  state = {
+    uid: exchanged.organizerUid,
+    scopes: exchanged.scopes,
+    expiresAt: now + exchanged.expiresIn * 1e3
+  };
+  if (exchanged.latestVersion)
+    recordLatestPublishedVersion(exchanged.latestVersion);
+  return state;
+});
+async function ensureAuth(requiredScopes = []) {
+  const current = state && Date.now() <= state.expiresAt - 5 * 60 * 1e3 && auth.currentUser ? state : await refreshSession();
   for (const scope of requiredScopes) {
-    if (!state.scopes.includes(scope)) {
+    if (!current.scopes.includes(scope)) {
       throw new OkoScopeError(scope);
     }
   }
-  return state;
+  return current;
 }
 function currentScopes() {
   return state?.scopes ?? [];
@@ -116389,7 +116448,9 @@ async function getConnectionStatus() {
     if (error3 instanceof OkoAuthError) {
       return buildConnectionStatus(error3.status, authErrorOptions(error3));
     }
-    return buildConnectionStatus("unavailable");
+    const detail = error3 instanceof Error ? `${error3.name}: ${error3.message}` : String(error3);
+    console.error(`[oko-mcp] connection status: unexpected error \u2014 ${detail}`);
+    return buildConnectionStatus("unavailable", { serverMessage: `Unexpected client-side error: ${detail}` });
   }
 }
 function authErrorOptions(error3) {
@@ -116444,14 +116505,14 @@ var telegramChannelSchema = external_exports.object({
   chatId: external_exports.number().int(),
   title: external_exports.string().max(200).optional(),
   username: external_exports.string().max(120).nullable().optional()
-}).strict();
+}).passthrough();
 var canonicalTelegramChannelSchema = telegramChannelSchema.extend({
   workspaceIds: external_exports.array(external_exports.string()).max(50),
   owned: external_exports.boolean(),
   subscriberCount: external_exports.number().int().nonnegative().nullable().optional(),
   health: external_exports.enum(["connected", "needs_attention", "unknown"]).optional(),
   healthCheckedAt: external_exports.number().int().nonnegative().nullable().optional()
-}).strict();
+}).passthrough();
 
 // build/tools/imagePipeline.js
 var import_undici = __toESM(require_undici(), 1);
@@ -116491,6 +116552,24 @@ function isPublicUnicastAddress(address) {
     return false;
   return import_ipaddr.default.parse(normalized).range() === "unicast";
 }
+function orderAddressCandidates(addresses, maxCandidates = 4) {
+  const known = addresses.filter((item) => item.family === 4 || item.family === 6);
+  const preferred = known[0]?.family;
+  if (preferred === void 0)
+    return [];
+  const first = known.filter((item) => item.family === preferred);
+  const second = known.filter((item) => item.family !== preferred);
+  const ordered = [];
+  for (let index = 0; index < Math.max(first.length, second.length); index += 1) {
+    const fromFirst = first[index];
+    const fromSecond = second[index];
+    if (fromFirst)
+      ordered.push(fromFirst);
+    if (fromSecond)
+      ordered.push(fromSecond);
+  }
+  return ordered.slice(0, maxCandidates);
+}
 function pinnedLookup(address, family) {
   return (_hostname, options2, callback) => {
     if (options2 && typeof options2 === "object" && options2.all) {
@@ -116523,13 +116602,7 @@ function legacyEventAllowsMode(data, uid, mode) {
   const fields = mode === "read" ? ["accessibleBy", "editors"] : [EVENT_ACCESS_FIELD_BY_MODE[mode]];
   return fields.some((field2) => Array.isArray(data[field2]) && data[field2].includes(uid));
 }
-function isFirestorePermissionDenied(error3) {
-  if (!error3 || typeof error3 !== "object")
-    return false;
-  const code = error3.code;
-  return code === "permission-denied" || code === "firestore/permission-denied" || code === "PERMISSION_DENIED";
-}
-async function readEvent(eventId, uid, mode = "read") {
+async function readEventAccess(eventId, uid, mode) {
   const [snap, grant] = await Promise.all([
     getDoc(doc(firestore, "events", eventId)),
     getDoc(doc(firestore, "eventAccess", uid, "grants", eventId)).catch((error3) => {
@@ -116542,6 +116615,13 @@ async function readEvent(eventId, uid, mode = "read") {
     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);
+  return { data, allowed };
+}
+async function eventGrantsMode(eventId, uid, mode) {
+  return (await readEventAccess(eventId, uid, mode)).allowed;
+}
+async function readEvent(eventId, uid, mode = "read") {
+  const { data, allowed } = await readEventAccess(eventId, uid, mode);
   if (!allowed) {
     throw new Error(`Event does not grant ${mode} access to this organizer.`);
   }
@@ -116604,10 +116684,6 @@ function nonPublicResolutionMessage(hostname2, addresses) {
   const environmentHint = fakeIp ? "Addresses in 198.18.0.0/15 mean a VPN or proxy with DNS interception (fake-IP mode) is active on this machine: every public host resolves there, so no remote URL can be verified." : "If other public hosts resolve to private addresses too, a VPN or proxy with DNS interception is active on this machine.";
   return `Image URL resolves to a non-public IP address (${hostname2} \u2192 ${list}), which is not allowed. ${environmentHint} Workarounds: upload the file from disk via source.path (allowed directories come from OKO_IMAGE_ROOTS; the organizer can download the image first), or disable the VPN/proxy for this upload.`;
 }
-var remoteFetchNotes = [];
-function takeRemoteFetchNotes() {
-  return remoteFetchNotes.splice(0, remoteFetchNotes.length);
-}
 async function resolveRemoteImageAddress(url) {
   if (url.protocol !== "https:") {
     throw new Error("Image URL must use https://.");
@@ -116624,18 +116700,18 @@ async function resolveRemoteImageAddress(url) {
     if (!isPublicUnicastAddress(literalAddress)) {
       throw new Error(`Image URL points to a private/local IP address (${literalAddress}), which is not allowed. Use a public HTTPS image URL, or upload the file from disk via source.path (requires OKO_IMAGE_ROOTS).`);
     }
-    return { address: literalAddress, family: literalFamily, transparentProxy: false };
+    return { addresses: [{ address: literalAddress, family: literalFamily }], transparentProxy: false };
   }
   const addresses = await lookup(url.hostname, { all: true });
   const transparentProxy = addresses.length > 0 && addresses.every((item) => isTransparentProxyAddress(item.address));
   if (!transparentProxy && (addresses.length === 0 || addresses.some((item) => !isPublicUnicastAddress(item.address)))) {
     throw new Error(nonPublicResolutionMessage(url.hostname, addresses.map((item) => item.address)));
   }
-  const selected = addresses[0];
-  if (!selected || selected.family !== 4 && selected.family !== 6) {
+  const candidates = orderAddressCandidates(addresses);
+  if (candidates.length === 0) {
     throw new Error("Image URL host could not be resolved safely.");
   }
-  return { address: selected.address, family: selected.family, transparentProxy };
+  return { addresses: candidates, transparentProxy };
 }
 async function responseBufferWithLimit(response, maxBytes) {
   const body = response.body;
@@ -116665,39 +116741,80 @@ async function responseBufferWithLimit(response, maxBytes) {
   }
   return Buffer.concat(chunks, total);
 }
-async function readRemoteImage(rawUrl, redirects = 0) {
+function shareLinkHint(url) {
+  let host = "";
+  try {
+    host = new URL(url).hostname.toLowerCase();
+  } catch {
+    return "";
+  }
+  if (host === "drive.google.com" || host === "docs.google.com") {
+    return " This is a Google Drive page, not the file: share it as 'anyone with the link' and use https://drive.google.com/uc?export=download&id=<fileId>, or download the file and pass source.path.";
+  }
+  if (host.endsWith("disk.yandex.ru") || host.endsWith("disk.yandex.com") || host === "yadi.sk" || host.endsWith("disk.360.yandex.ru")) {
+    return " This is a Yandex Disk page, not the file: use the direct download link from the page (\u0421\u043A\u0430\u0447\u0430\u0442\u044C \u2192 copy link), or download the file and pass source.path.";
+  }
+  if (host === "dropbox.com" || host.endsWith(".dropbox.com")) {
+    return " This is a Dropbox page: replace ?dl=0 with ?dl=1 in the link, or download the file and pass source.path.";
+  }
+  if (host.endsWith("onedrive.live.com") || host === "1drv.ms" || host.endsWith("sharepoint.com")) {
+    return " This is a OneDrive page: use its direct download link, or download the file and pass source.path.";
+  }
+  return " Use a direct link to the image file (right-click the image \u2192 copy image address), or download the file and pass source.path.";
+}
+async function readRemoteImage(rawUrl, redirects = 0, notes = []) {
   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);
   if (pinned.transparentProxy && redirects === 0) {
-    remoteFetchNotes.push(`Image fetched through a VPN/proxy with DNS interception: ${url.hostname} resolved to ${pinned.address}, so OKO could not verify the destination address itself; the connection went through the proxy. This is expected on such machines and fine for public image links.`);
+    notes.push(`Image fetched through a VPN/proxy with DNS interception: ${url.hostname} resolved to ${pinned.addresses[0]?.address}, so OKO could not verify the destination address itself; the connection went through the proxy. This is expected on such machines and fine for public image links.`);
   }
+  let lastConnectError = null;
+  for (const candidate of pinned.addresses) {
+    const attempt = await readRemoteImageFrom(url, rawUrl, candidate, redirects);
+    if ("buffer" in attempt)
+      return attempt.buffer;
+    if ("redirectTo" in attempt)
+      return readRemoteImage(attempt.redirectTo, redirects + 1, notes);
+    lastConnectError = attempt.connectError;
+  }
+  throw new Error(`Image URL host ${url.hostname} could not be reached at any of its addresses (${pinned.addresses.map((item) => item.address).join(", ")}): ${lastConnectError?.message ?? "connection failed"}.`);
+}
+async function readRemoteImageFrom(url, rawUrl, candidate, redirects) {
   const dispatcher = new import_undici.Agent({
-    connect: { lookup: pinnedLookup(pinned.address, pinned.family) }
+    connect: { lookup: pinnedLookup(candidate.address, candidate.family) }
   });
   const controller = new AbortController();
   const timeout = setTimeout(() => controller.abort(), REMOTE_IMAGE_TIMEOUT_MS);
   try {
-    const response = await (0, import_undici.fetch)(url, {
-      redirect: "manual",
-      signal: controller.signal,
-      headers: { accept: "image/avif,image/webp,image/png,image/jpeg,image/gif" },
-      dispatcher
-    });
+    let response;
+    try {
+      response = await (0, import_undici.fetch)(url, {
+        redirect: "manual",
+        signal: controller.signal,
+        headers: { accept: "image/avif,image/webp,image/png,image/jpeg,image/gif" },
+        dispatcher
+      });
+    } catch (err) {
+      if (err instanceof Error && err.name === "AbortError") {
+        throw new Error("Image URL fetch timed out.");
+      }
+      return { connectError: err instanceof Error ? err : new Error(String(err)) };
+    }
     if (response.status >= 300 && response.status < 400) {
       const location2 = response.headers.get("location");
       if (!location2)
         throw new Error(`Image URL redirected with HTTP ${response.status} but no Location header.`);
-      return readRemoteImage(new URL(location2, url).toString(), redirects + 1);
+      return { redirectTo: new URL(location2, url).toString() };
     }
     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/*.");
+      throw new Error(`Image URL must return Content-Type image/* (got ${contentType || "none"}).${shareLinkHint(rawUrl)}`);
     }
     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.`);
@@ -116706,7 +116823,7 @@ async function readRemoteImage(rawUrl, redirects = 0) {
     if (Number.isFinite(contentLength) && contentLength > MAX_SOURCE_IMAGE_BYTES) {
       throw new Error("Image URL is larger than 15MB.");
     }
-    return await responseBufferWithLimit(response, MAX_SOURCE_IMAGE_BYTES);
+    return { buffer: await responseBufferWithLimit(response, MAX_SOURCE_IMAGE_BYTES) };
   } catch (err) {
     if (err instanceof Error && err.name === "AbortError") {
       throw new Error("Image URL fetch timed out.");
@@ -116760,6 +116877,12 @@ function serverFetchRefusal(error3) {
   if (code === "functions/invalid-argument" && message.includes("Image payload is empty or too large")) {
     return { reason: "server_without_url_support", message: "The OKO server release in use does not fetch URLs yet." };
   }
+  if (code === "functions/deadline-exceeded") {
+    return { reason: "server_timeout", message: "The OKO server did not finish fetching the URL within its time limit." };
+  }
+  if (code === "functions/internal") {
+    return { reason: "server_error", message: message && message !== "internal" ? message : "The OKO server failed while fetching the URL." };
+  }
   return null;
 }
 var SERVER_FETCH_NOTE = "Image fetched by the OKO server directly from the URL; this machine's network was not involved.";
@@ -116789,10 +116912,10 @@ async function uploadImageFromSource(eventId, kind, cardId, source) {
     serverFailure = refusal;
   }
   let buffer;
+  const fetchNotes = [];
   try {
-    buffer = await readRemoteImage(source.url);
+    buffer = await readRemoteImage(source.url, 0, fetchNotes);
   } catch (localError) {
-    takeRemoteFetchNotes();
     throw new Error(remoteImageUnavailableMessage(source.url, serverFailure, localError));
   }
   const uploaded = await uploadMasterImage(eventId, kind, cardId, { imageBase64: buffer.toString("base64") });
@@ -116800,7 +116923,7 @@ async function uploadImageFromSource(eventId, kind, cardId, source) {
     uploaded,
     sourceBytes: buffer.byteLength,
     sourceVia: "client",
-    notes: [localFallbackNote(serverFailure), ...takeRemoteFetchNotes()]
+    notes: [localFallbackNote(serverFailure), ...fetchNotes]
   };
 }
 function readImageRef(eventData, kind, cardId) {
@@ -116907,20 +117030,23 @@ function normalizeNullableText(value) {
     return null;
   return value.trim() || null;
 }
+var CARD_LINK_SCHEME = /^(https?:\/\/|mailto:|tel:|\/(?!\/))/i;
+var CARD_BARE_DOMAIN = /^[\p{L}\d-]+(\.[\p{L}\d-]+)+(:\d+)?(\/\S*)?$/u;
 function normalizeCardButtonUrl(value) {
   const trimmed = normalizeNullableText(value);
   if (!trimmed)
     return null;
+  if (CARD_LINK_SCHEME.test(trimmed))
+    return trimmed;
+  if (CARD_BARE_DOMAIN.test(trimmed))
+    return `https://${trimmed}`;
   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.`);
+    throw new Error(`Invalid card buttonUrl "${trimmed}". Use http(s), mailto, tel, a site-relative /path, or set formId instead.`);
   }
-  return trimmed;
+  throw new Error(`Unsupported card buttonUrl protocol "${url.protocol}". Use http(s), mailto, tel, a site-relative /path, or set formId instead.`);
 }
 function eventFormIds(eventData) {
   const rawForms = Array.isArray(eventData.forms) ? eventData.forms : [];
@@ -117692,6 +117818,7 @@ function detectAndNormalize(url) {
 }
 
 // build/tools/formatting.js
+var RETIRED_SESSION_FIELDS = ["nmoEvaluation"];
 function cursorMeta(count, max, hasMore, nextCursor) {
   return {
     count,
@@ -117715,8 +117842,8 @@ function assertEmbeddableUrl(value) {
   } catch {
     throw new Error(`Invalid videoUrl "${value}". Provide an https:// link or a full <iframe> embed code.`);
   }
-  if (url.protocol !== "https:" && url.protocol !== "http:") {
-    throw new Error(`Unsupported videoUrl protocol "${url.protocol}". Only http(s) links can be embedded.`);
+  if (url.protocol !== "https:") {
+    throw new Error(`Unsupported videoUrl protocol "${url.protocol}". The player must be served over https:// \u2014 http:// links are refused by the platform.`);
   }
   return value;
 }
@@ -117760,15 +117887,31 @@ function timestampCursorFrom(value) {
   const millis = toMillis(value);
   return millis == null ? null : String(millis);
 }
+var ISO_WITH_OFFSET = /(?:Z|[+-]\d{2}:?\d{2})$/;
 function parseIsoBound(value, label) {
   if (value === void 0)
     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.`);
+  if (!Number.isFinite(parsed) || !ISO_WITH_OFFSET.test(value.trim())) {
+    throw new Error(`Invalid ${label}: expected an ISO timestamp with an explicit offset, such as 2026-08-28T00:00:00+03:00 or 2026-08-27T21:00:00Z.`);
   }
   return Timestamp.fromMillis(parsed);
 }
+function absoluteHttpUrl(value, label) {
+  const trimmed = (value ?? "").trim();
+  if (!trimmed)
+    return null;
+  let url;
+  try {
+    url = new URL(trimmed);
+  } catch {
+    throw new Error(`Invalid ${label} "${trimmed}": Telegram needs an absolute http(s) URL.`);
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    throw new Error(`Unsupported ${label} protocol "${url.protocol}": Telegram needs an absolute http(s) URL.`);
+  }
+  return trimmed;
+}
 function compactAnalyticsSession(raw, options2) {
   const session = serialize(raw);
   const timeline = Array.isArray(session.timeline) ? session.timeline : null;
@@ -117794,7 +117937,8 @@ function compactAnalyticsSession(raw, options2) {
       session.finalSnapshotOmitted = true;
     }
   }
-  delete session[["n", "moEvaluation"].join("")];
+  for (const field2 of RETIRED_SESSION_FIELDS)
+    delete session[field2];
   return session;
 }
 function numberMetric(value) {
@@ -117865,15 +118009,78 @@ function copyableTelegram(source) {
 
 // build/tools/workspaceAccess.js
 import { randomBytes as randomBytes2 } from "node:crypto";
-async function readWorkspaceForOwner(workspaceId, uid) {
-  const snap = await getDoc(doc(firestore, "workspaces", workspaceId));
-  if (!snap.exists())
+
+// build/personalWorkspace.js
+var PERSONAL_WORKSPACE_NAME = "Personal";
+function personalWorkspaceRecord(uid) {
+  return { id: uid, name: PERSONAL_WORKSPACE_NAME, ownerId: uid, personal: true };
+}
+function resolveWorkspaceForOwner(workspaceId, uid, snapshot) {
+  if (!snapshot.exists) {
+    if (workspaceId === uid)
+      return personalWorkspaceRecord(uid);
     throw new Error("Workspace not found.");
-  const data = snap.data();
+  }
+  const data = snapshot.data ?? {};
   if (data.ownerId !== uid)
     throw new Error("Only the workspace owner can manage this workspace.");
   return data;
 }
+function refusalMayMeanMissing(error3, workspaceId, uid) {
+  if (workspaceId !== uid)
+    return false;
+  return isFirestorePermissionDenied(error3) || isFirestoreNotFound(error3);
+}
+function withSyntheticPersonalWorkspace(uid, rows) {
+  if (rows.some((row) => row.id === uid))
+    return rows;
+  return [{ ...personalWorkspaceRecord(uid), isOwner: true }, ...rows];
+}
+function isSharedWorkspaceId(workspaceId) {
+  return /^[A-Za-z0-9]{20}$/.test(workspaceId);
+}
+function workspaceMemberRemoval(existed, workspaceId, targetUid) {
+  if (existed)
+    return { removed: true };
+  return {
+    removed: false,
+    missing: true,
+    hints: [`No share for ${targetUid} exists in workspace ${workspaceId}: nothing was removed. List the members with oko_list_workspace_access before removing one.`]
+  };
+}
+function personalWorkspaceLimitMessage(action) {
+  return `A personal workspace has no members or invites: it exists for its owner alone, and the platform refuses ${action} there. Create a shared workspace with oko_create_workspace, move the event into it with oko_move_event, and repeat this call with the shared workspace id.`;
+}
+
+// build/tools/workspaceAccess.js
+async function readWorkspaceForOwnerDetailed(workspaceId, uid) {
+  let snap;
+  try {
+    snap = await getDoc(doc(firestore, "workspaces", workspaceId));
+  } catch (error3) {
+    if (!refusalMayMeanMissing(error3, workspaceId, uid))
+      throw error3;
+    const owned = await getDocs(query2(collection(firestore, "workspaces"), where("ownerId", "==", uid)));
+    const existing = owned.docs.find((item) => item.id === workspaceId);
+    if (existing) {
+      return {
+        workspace: resolveWorkspaceForOwner(workspaceId, uid, { exists: true, data: existing.data() }),
+        synthesized: false
+      };
+    }
+    return { workspace: personalWorkspaceRecord(uid), synthesized: true };
+  }
+  return {
+    workspace: resolveWorkspaceForOwner(workspaceId, uid, {
+      exists: snap.exists(),
+      data: snap.exists() ? snap.data() : void 0
+    }),
+    synthesized: !snap.exists()
+  };
+}
+async function readWorkspaceForOwner(workspaceId, uid) {
+  return (await readWorkspaceForOwnerDetailed(workspaceId, uid)).workspace;
+}
 function normalizeWorkspacePermissions(value) {
   const out = {};
   for (const key of WORKSPACE_PERMISSION_KEYS) {
@@ -117900,7 +118107,7 @@ async function listVisibleWorkspaces(uid, includeShared) {
         out.push({ id: workspaceId, ...serialize(wsSnap.data()), isOwner: false, permissions: serialize(shareSnap.data()?.permissions ?? {}) });
     }
   }
-  return out;
+  return withSyntheticPersonalWorkspace(uid, out);
 }
 async function getChatRole(eventId, uid) {
   const snap = await get(ref(chatRtdb, `settings/${eventId}/roles/${uid}`));
@@ -117986,7 +118193,7 @@ function registerChatTools(server2) {
     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: serverTimestamp(), ts: Date.now(), by: uid });
+    await set(ref(chatRtdb, `mod/deleted/${eventId}/${messageId}`), { deletedAt: serverTimestamp(), ts: Date.now(), by: uid, reason: "manual" });
     return textResult({ eventId, messageId, deleted: true });
   });
   server2.registerTool("oko_mute_user", {
@@ -118074,7 +118281,7 @@ function registerChatTools(server2) {
     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."],
+      args: ["eventId: target event.", "slowModeMs: optional slow mode delay, 0-60000 ms.", "automodEnabled: optional automod toggle.", "allowViewerLinks: optional; true lets viewers post links (the chat rule and automod both honour it; default false).", "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."]
     }),
@@ -118082,19 +118289,22 @@ function registerChatTools(server2) {
       eventId: eventIdField,
       slowModeMs: external_exports.number().int().min(0).max(6e4).optional().describe("Slow mode delay in milliseconds."),
       automodEnabled: external_exports.boolean().optional().describe("Enable or disable chat automoderation."),
+      allowViewerLinks: external_exports.boolean().optional().describe("Allow viewers to post links in chat (default false: the rule blocks links from viewers)."),
       confirm: external_exports.boolean().optional().describe("Required true to change live chat settings.")
     },
     outputSchema: basicEventOutputSchema,
     annotations: idempotentWriteTool
-  }, async ({ eventId, slowModeMs, automodEnabled, confirm }) => {
+  }, async ({ eventId, slowModeMs, automodEnabled, allowViewerLinks, 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 });
+    requireConfirm(confirm, "oko_set_chat_settings", { eventId, slowModeMs: slowModeMs ?? null, automodEnabled: automodEnabled ?? null, allowViewerLinks: allowViewerLinks ?? null });
     const patch = {};
     if (slowModeMs !== void 0)
       patch[`settings/${eventId}/slowModeMs`] = slowModeMs;
     if (automodEnabled !== void 0)
       patch[`settings/${eventId}/automodEnabled`] = automodEnabled;
+    if (allowViewerLinks !== void 0)
+      patch[`settings/${eventId}/allowViewerLinks`] = allowViewerLinks;
     if (Object.keys(patch).length === 0) {
       throw new Error("Provide slowModeMs and/or automodEnabled to change chat settings.");
     }
@@ -118281,6 +118491,17 @@ function validateEventSetup(eventId, event) {
 }
 
 // build/tools/events.js
+function telegramBlocksPatch(args) {
+  if (args.telegramChannelIds === void 0)
+    return {};
+  return {
+    "telegram.enabled": args.telegramChannelIds.length > 0,
+    "telegram.channelIds": args.telegramChannelIds
+  };
+}
+function configureBlocksScopes(args) {
+  return Object.keys(telegramBlocksPatch(args)).length > 0 ? ["setup:write", "telegram:write"] : ["setup:write"];
+}
 function registerEventTools(server2) {
   server2.registerTool("oko_list_my_events", {
     title: "List my events",
@@ -118348,7 +118569,8 @@ function registerEventTools(server2) {
           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 projectionHint = args.detail === "compact" ? { hints: ['Compact rows are a projection rebuilt after each change and can lag the event by seconds (title, date, permissions). For fields that must be current, call oko_get_event or use detail="full".'] } : {};
+      return textResult({ events, ...cursorMeta(events.length, args.limit, hasMore, nextCursor), ...projectionHint }, { truncationHint: 'Use a smaller limit, cursor pagination, or detail="compact".' });
     }
     throw new Error("Event list not received: the eventAccess index returned an empty result.");
   });
@@ -118358,7 +118580,10 @@ function registerEventTools(server2) {
       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."]
+      examples: ["Use after oko_create_webinar to verify setup and return the event URL to the user."],
+      notes: [
+        "blocks.chat.mode and blocks.chat.visibility are both legacy: the event page reads neither \u2014 the chat panel exists exactly when blocks.chat.enabled is true, and sending is opened or closed live with oko_set_chat_mode. Ignore both fields."
+      ]
     }),
     inputSchema: { eventId: eventIdField },
     outputSchema: eventOutputSchema,
@@ -118517,20 +118742,21 @@ function registerEventTools(server2) {
     title: "Configure event blocks",
     description: toolDescription({
       summary: "Configure supported event setup blocks, forms, and Telegram channel ids.",
-      exampleCall: { "eventId": "Kx9pQ2mR7tL4vB8nW3cY", "chat": { "enabled": true, "visibility": "always" }, "promoBanner": { "enabled": false }, "primaryCta": { "enabled": true, "title": "Get the slides", "buttonLabel": "Download", "buttonUrl": "https://example.com/slides" }, "videoPlaceholder": { "enabled": true, "mode": "glass", "showTimer": true, "title": "The webinar starts at 14:00", "subtitle": "Moscow time" } },
+      exampleCall: { "eventId": "Kx9pQ2mR7tL4vB8nW3cY", "chat": { "enabled": true }, "promoBanner": { "enabled": false }, "primaryCta": { "enabled": true, "title": "Get the slides", "buttonLabel": "Download", "buttonUrl": "https://example.com/slides" }, "videoPlaceholder": { "enabled": true, "mode": "glass", "showTimer": true, "title": "The webinar starts at 14:00", "subtitle": "Moscow time" } },
       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."
+        "telegramChannelIds: replaces configured Telegram channels when provided; needs the telegram:write scope AND the notification permission on the event, and is refused before anything is written when either is missing."
       ],
       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."],
+      examples: ["Use after oko_create_webinar to enable chat, bind a CTA/form, and configure 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.",
         'videoPlaceholder.enabled only allows the placeholder; viewers see it after oko_set_block_visibility with block "placeholder" and visible true (a live override, stored outside the event document). Chat, CTA, banner and cards appear as soon as they are enabled here.',
-        "Setup toggle vs live override: enabled=false removes a block from the page for everyone and persists (its uploaded image stays); oko_set_block_visibility hides or shows an enabled block temporarily and is the tool for the live show. Uploading an image never enables a block."
+        "Setup toggle vs live override: enabled=false removes a block from the page for everyone and persists (its uploaded image stays); oko_set_block_visibility hides or shows an enabled block temporarily and is the tool for the live show. Uploading an image never enables a block.",
+        "telegramChannelIds is the only field here that is not a page setting: it decides which channel carries this event's messages, and the automatic reminder goes out under the event owner's name. Omit the field to configure blocks with setup:write alone; pass it only with a key that holds telegram:write and for an organizer who may send notifications for this event."
       ]
     }),
     inputSchema: {
@@ -118545,8 +118771,12 @@ function registerEventTools(server2) {
     outputSchema: updateOutputSchema,
     annotations: writeTool
   }, async (args) => {
-    const { uid } = await authed(["setup:write"]);
+    const { uid } = await authed(configureBlocksScopes(args));
     const current = await readEvent(args.eventId, uid, "edit");
+    const telegramPatch = telegramBlocksPatch(args);
+    if (Object.keys(telegramPatch).length > 0 && !await eventGrantsMode(args.eventId, uid, "notify")) {
+      throw new Error("Configuring Telegram channels needs the notification permission on this event, not just setup rights: the channels decide where this event's messages go, and the reminder is sent under the event owner's name. Ask the event owner (or the workspace owner) to grant sendNotifications, or call this tool without telegramChannelIds \u2014 every other block is still yours to configure.");
+    }
     const patch = {};
     if (args.chat?.enabled !== void 0)
       patch["blocks.chat.enabled"] = args.chat.enabled;
@@ -118602,10 +118832,7 @@ function registerEventTools(server2) {
           placeholder: field2.placeholder?.trim() || null
         }))
       }));
-    if (args.telegramChannelIds !== void 0) {
-      patch["telegram.enabled"] = args.telegramChannelIds.length > 0;
-      patch["telegram.channelIds"] = args.telegramChannelIds;
-    }
+    Object.assign(patch, telegramPatch);
     const formsAfterPatch = patch.forms ?? current.forms;
     const knownFormIds = new Set((Array.isArray(formsAfterPatch) ? formsAfterPatch : []).map((form) => typeof form?.id === "string" ? form.id : null).filter((id) => Boolean(id)));
     for (const [field2, value] of [
@@ -118618,6 +118845,9 @@ function registerEventTools(server2) {
     }
     await updateDoc(doc(firestore, "events", args.eventId), patch);
     const hints = [];
+    if (args.chat?.visibility !== void 0) {
+      hints.push("blocks.chat.visibility was stored but the event page does not read it: the chat panel exists exactly when blocks.chat.enabled is true, and sending is opened or closed live with oko_set_chat_mode. Drop the field.");
+    }
     const currentBlocks = current.blocks && typeof current.blocks === "object" ? current.blocks : {};
     const bannerHasImage = Boolean(safeString(currentBlocks.promoBanner?.imageUrl) || safeString(currentBlocks.promoBanner?.imageMasterUrl));
     if (args.promoBanner?.enabled === false && bannerHasImage) {
@@ -118717,6 +118947,9 @@ function registerEventTools(server2) {
     const warnings = removedCardsWithImages.length > 0 ? [`Removed cards had images and their Storage files were not deleted: ${removedCardsWithImages.join(", ")}.`] : [];
     if (finalCards.repairedIdPositions.length > 0) {
       warnings.push(`Cards at position(s) ${finalCards.repairedIdPositions.join(", ")} had no usable id in Firestore; a temporary one was generated, so their previous images could not be matched and were dropped. Re-upload images for these cards.`);
+      if (args.items === void 0) {
+        warnings.push("The ids shown for those positions are provisional (generated on read) and were NOT stored: oko_upload_image and oko_delete_image will not accept them. Save the cards first by passing items to oko_configure_cards \u2014 the saved ids are the ones to use.");
+      }
     }
     return textResult({
       eventId: args.eventId,
@@ -118826,8 +119059,16 @@ function registerImageTools(server2) {
       }
     }
     const uploadedCardIds = new Set(images.map((image) => image.cardId).filter((cardId) => !failures.some((failure) => failure.cardId === cardId)));
-    const variants = uploadedCardIds.size > 0 ? await waitForImageVariantTargets(uid, eventId, [...uploadedCardIds].map((cardId) => ({ kind: "card", cardId })), timeoutSec) : [];
-    const warnings = variants.filter((item) => !item.ready).map((item) => `Card ${item.cardId ?? "unknown"} variants are not ready yet: ${item.reason ?? "unknown"}.`);
+    let variants = [];
+    const warnings = [];
+    if (uploadedCardIds.size > 0) {
+      try {
+        variants = await waitForImageVariantTargets(uid, eventId, [...uploadedCardIds].map((cardId) => ({ kind: "card", cardId })), timeoutSec);
+      } catch (error3) {
+        warnings.push(`Uploads succeeded, but waiting for their variants failed: ${error3 instanceof Error ? error3.message : String(error3)}. Check readiness later with oko_wait_for_image_variants.`);
+      }
+    }
+    warnings.push(...variants.filter((item) => !item.ready).map((item) => `Card ${item.cardId ?? "unknown"} variants are not ready yet: ${item.reason ?? "unknown"}.`));
     warnings.push(...failures.map((failure) => `Card ${failure.cardId} upload failed: ${failure.error}`));
     return textResult({
       eventId,
@@ -118989,14 +119230,37 @@ async function recordToolAudit(toolName, outcome, args, startedAt, error3) {
 // build/tools/instrumentation.js
 var REPORT_URL = `${APP_ORIGIN}/contact`;
 var KEYS_URL = `${APP_ORIGIN}/app/mcp`;
-var SCOPE_WORKAROUNDS = {
-  oko_trash_event: "This key cannot delete events. Tell the organizer which event to remove; they can do it in the OKO cabinet, or create a key with the full preset.",
-  oko_delete_event_permanently: "This key cannot delete events. Tell the organizer which event to remove; they can do it in the OKO cabinet, or create a key with the full preset.",
-  oko_publish_telegram_post: "This key cannot publish to Telegram. The organizer can publish the announcement from the OKO cabinet, or create a key with the full preset."
+var PERMISSION_GATED_ARGS = {
+  telegramChannelIds: "telegramChannelIds \u2014 needs the telegram:write scope and the notification permission on the event"
 };
+var SCOPE_WORKAROUNDS = {
+  "oko_trash_event|events:delete": { text: "This key cannot delete events. Tell the organizer which event to remove; they can do it in the OKO cabinet, or create a key with the full preset." },
+  "oko_delete_event_permanently|events:delete": { text: "This key cannot delete events. Tell the organizer which event to remove; they can do it in the OKO cabinet, or create a key with the full preset." },
+  "oko_publish_telegram_post|telegram:write": { text: "This key cannot publish to Telegram. The organizer can publish the announcement from the OKO cabinet, or create a key with the full preset." },
+  // 🔴 The most frequent refusal of this whole release (`ADV-A6-19`): an
+  // `operator` key calling oko_configure_blocks with channel ids. The advice
+  // promises that the rest of the call would work — true only when the key can
+  // configure blocks at all.
+  "oko_configure_blocks|telegram:write": {
+    text: "Repeat the call WITHOUT telegramChannelIds: every other block, form and CTA in it will be configured normally. Choosing which channel carries an event is a send permission, so the channels themselves need a key with the full preset (or telegram:write) and an organizer allowed to send notifications for that event.",
+    requires: ["setup:write"]
+  }
+};
+function scopeWorkaroundFor(toolName, missing, granted) {
+  const entry = SCOPE_WORKAROUNDS[`${toolName}|${missing}`];
+  if (!entry)
+    return void 0;
+  if (entry.requires?.some((scope) => !granted.includes(scope)))
+    return void 0;
+  return entry.text;
+}
 function presetsWithScope2(scope) {
   return Object.entries(MCP_PRESETS).filter(([, scopes]) => scopes.includes(scope)).map(([name7]) => name7);
 }
+function permissionGatedArgsIn(args) {
+  const source = args && typeof args === "object" ? args : {};
+  return Object.entries(PERMISSION_GATED_ARGS).filter(([key]) => source[key] !== void 0).map(([, explanation]) => explanation);
+}
 function idsFromArgs(args) {
   if (!args || typeof args !== "object")
     return {};
@@ -119011,7 +119275,7 @@ function idsFromArgs(args) {
 function scopeRejectionResult(toolName, scope) {
   const granted = currentScopes();
   const presets = presetsWithScope2(scope);
-  const workaround = SCOPE_WORKAROUNDS[toolName];
+  const workaround = scopeWorkaroundFor(toolName, scope, granted);
   return {
     ...textResult({
       errorCode: "SCOPE_REQUIRED",
@@ -119050,22 +119314,27 @@ function platformRejectionResult(toolName, args, readOnly) {
       isError: true
     };
   }
+  const gated = permissionGatedArgsIn(args);
   return {
     ...textResult({
       errorCode: "PLATFORM_REJECTED_WRITE",
       tool: toolName,
       ...ids,
-      message: "OKO's security rules refused this write. The request reached the platform and was rejected server-side; nothing was changed.",
+      message: "OKO's security rules refused this write. The request reached the platform and was rejected server-side; nothing was changed. A rule can refuse the whole write because of a single field in it.",
+      mayBeCausedBy: [
+        `A field that needs a permission of its own: ${gated.length ? gated.join("; ") : "none of the fields this client knows to be permission-gated is present in this call, but the platform may gate others"}.`,
+        `A permission on the target itself: this key holds ${currentScopes().join(", ") || "no scopes"} and acts for the organizer behind it, who may not hold the right this particular field requires.`
+      ],
       notCausedBy: [
-        `API key scopes: this key holds ${currentScopes().join(", ") || "no scopes"}, and the tool's scope check passed before the write.`,
         `Client version: ${OKO_MCP_VERSION}${update2.updateAvailable ? ` (an update to ${update2.latest} is available, but rules apply to every version equally)` : " (current)"}.`,
         "Wording or parameter choice: the same rule rejects the same data regardless of phrasing."
       ],
       whatToDo: [
         "Do not retry with different parameters and do not create the event again: retries hit the same rule and only produce duplicates.",
-        "Tell the organizer plainly that the OKO platform refused this change; it is a platform-side issue, not their input.",
+        ...gated.length ? [`Repeat the call WITHOUT ${gated.length > 1 ? "those fields" : "that field"} first: if it succeeds, the refusal was about ${gated.length > 1 ? "them" : "it"} \u2014 the organizer then needs a key with the missing scope, or the missing permission on the event, and the rest of the change is already saved.`] : [],
+        "If no such field is involved, tell the organizer plainly that the OKO platform refused this change.",
         `Ask them to report it to OKO at ${REPORT_URL} with the "report" block below, so it can be fixed on the platform side.`,
-        ...toolName === "oko_create_webinar" ? ["If the organizer needs the page today: oko_duplicate_event of an existing event usually works when creation is refused."] : []
+        ...toolName === "oko_create_webinar" ? ["If the organizer needs the page today: oko_duplicate_event of an existing event often works when creation is refused \u2014 but pick a source event WITHOUT Telegram channels, or hold telegram:write: duplicating a Telegram-configured event needs the same permission that creating one does."] : []
       ],
       report: {
         tool: toolName,
@@ -119134,6 +119403,17 @@ function installToolInstrumentation(server2) {
 }
 
 // build/tools/leads.js
+function leadSubmittedMs(lead) {
+  const value = lead.submittedAt;
+  if (typeof value === "number" && Number.isFinite(value))
+    return value;
+  if (typeof value === "string") {
+    const parsed = Date.parse(value);
+    if (Number.isFinite(parsed))
+      return parsed;
+  }
+  return 0;
+}
 function registerLeadTools(server2) {
   server2.registerTool("oko_list_leads", {
     title: "List form leads",
@@ -119146,7 +119426,7 @@ function registerLeadTools(server2) {
         "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.",
+      returns: "leads or csv plus count, limit, hasMore/has_more, nextCursor/next_cursor. Without formId the rows are newest-first across pages; with formId they are newest-first WITHIN a page only, because paging there follows document ids \u2014 to rank one form's submissions by time, read every page and sort by submittedAt.",
       examples: ["Use formId to export one form; if Firestore requests an index, create it from the error link and rerun."]
     }),
     inputSchema: {
@@ -119162,10 +119442,21 @@ function registerLeadTools(server2) {
     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$1()), ...cursor ? [startAfter(cursor)] : [], limit(max + 1)] : [orderBy(documentId$1()), ...cursor ? [startAfter(cursor)] : [], limit(max + 1)];
+    let constraints;
+    if (formId) {
+      constraints = [where("formId", "==", formId), orderBy(documentId$1()), ...cursor ? [startAfter(cursor)] : [], limit(max + 1)];
+    } else {
+      const cursorSnap = cursor ? await getDoc(doc(base, cursor)) : null;
+      if (cursor && !cursorSnap?.exists()) {
+        throw new Error(`Lead cursor ${cursor} no longer exists (the submission was deleted). Restart the listing without a cursor.`);
+      }
+      constraints = [orderBy("submittedAt", "desc"), ...cursorSnap ? [startAfter(cursorSnap)] : [], limit(max + 1)];
+    }
     const snap = await getDocs(query2(base, ...constraints));
     const page = snap.docs.slice(0, max);
     const leads = page.map((item) => ({ id: item.id, ...serialize(item.data()) }));
+    if (formId)
+      leads.sort((a, b) => leadSubmittedMs(b) - leadSubmittedMs(a));
     const hasMore = snap.docs.length > max;
     const nextCursor = hasMore ? page.at(-1)?.id ?? null : null;
     const meta2 = cursorMeta(leads.length, max, hasMore, nextCursor);
@@ -119207,6 +119498,13 @@ function registerLeadTools(server2) {
 
 // build/tools/lifecycle.js
 function registerLifecycleTools(server2) {
+  const moveToTrash = async (toolName, { eventId, confirm }) => {
+    const { uid } = await authed(["events:delete"]);
+    const event = await readEvent(eventId, uid, "delete");
+    requireConfirm(confirm, toolName, { eventId, title: event.title });
+    const trash = httpsCallable(functions, "trashEvent");
+    return textResult((await trash({ eventId })).data);
+  };
   server2.registerTool("oko_delete_event", {
     title: "Move event to trash",
     description: toolDescription({
@@ -119219,14 +119517,7 @@ function registerLifecycleTools(server2) {
     inputSchema: { eventId: eventIdField, confirm: external_exports.boolean().optional().describe("Required true to move the event to trash.") },
     outputSchema: external_exports.object({ trashed: external_exports.string(), purgeAfter: external_exports.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);
-  });
+  }, async ({ eventId, confirm }) => moveToTrash("oko_delete_event", { eventId, confirm }));
   server2.registerTool("oko_trash_event", {
     title: "Move event to trash",
     description: toolDescription({
@@ -119239,13 +119530,7 @@ function registerLifecycleTools(server2) {
     inputSchema: { eventId: eventIdField, confirm: external_exports.boolean().optional().describe("Required true to move the event to trash.") },
     outputSchema: external_exports.object({ trashed: external_exports.string(), purgeAfter: external_exports.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);
-  });
+  }, async ({ eventId, confirm }) => moveToTrash("oko_trash_event", { eventId, confirm }));
   server2.registerTool("oko_restore_event", {
     title: "Restore event",
     description: toolDescription({
@@ -119305,7 +119590,8 @@ function registerLifecycleTools(server2) {
       notes: [
         "Copies title, video, meta, blocks, forms, and Telegram config; does not copy analytics sessions or leads.",
         "Live overrides are NOT copied: the copy starts with chat mode public and the placeholder hidden, whatever the source had. Set them again with oko_set_chat_mode and oko_set_block_visibility on the new event.",
-        "Requires only events:write plus createEvents in the target workspace. To move (not copy) an event, use oko_move_event with the same scope."
+        "Requires only events:write plus createEvents in the target workspace. To move (not copy) an event, use oko_move_event with the same scope.",
+        "Telegram config is copied only when the key holds telegram:write AND the organizer may send notifications for the source event; otherwise the copy starts with Telegram off and a hint says so. Deciding which channel carries an event is a send permission, not a setup one."
       ]
     }),
     inputSchema: {
@@ -119319,6 +119605,8 @@ function registerLifecycleTools(server2) {
     const source = await readEvent(eventId, uid, "read");
     const workspaceId = targetWorkspaceId ?? safeString(source.workspaceId, uid);
     await assertCanCreateInWorkspace(uid, workspaceId);
+    const sourceHasTelegram = !!source.telegram && typeof source.telegram === "object";
+    const mayCopyTelegram = sourceHasTelegram && currentScopes().includes("telegram:write") && await eventGrantsMode(eventId, uid, "notify");
     const newRef = await addEventWithRtdbMirror({
       ownerId: uid,
       workspaceId,
@@ -119334,7 +119622,7 @@ function registerLifecycleTools(server2) {
       // function skips events with this flag forever: a copy of an event whose
       // reminder has already gone out would never get its own — silently
       // (review 02.09, R3b-5).
-      ...source.telegram && typeof source.telegram === "object" ? { telegram: copyableTelegram(source.telegram) } : {}
+      ...mayCopyTelegram ? { telegram: copyableTelegram(source.telegram) } : {}
     });
     return textResult({
       id: newRef.id,
@@ -119342,7 +119630,9 @@ function registerLifecycleTools(server2) {
       workspaceId,
       ...eventLinks(newRef.id),
       liveStateNotCopied: ["chatMode", "placeholderVisible", "liveBadge", "block visibility overrides"],
+      telegramCopied: mayCopyTelegram,
       hints: [
+        ...sourceHasTelegram && !mayCopyTelegram ? ["Telegram config was NOT copied: this key needs telegram:write and the notification permission on the source event. The copy starts with Telegram off; ask the event owner to grant the permission, then configure channels on the copy."] : [],
         "Live state was not copied: chat mode is public and the placeholder is hidden on the copy. If the source had chat off or the placeholder shown, set them again with oko_set_chat_mode and oko_set_block_visibility on the new event.",
         "The copy is live at publicUrl immediately; edit title, eventDate, and video with oko_update_event, then run oko_validate_event_setup."
       ]
@@ -119373,6 +119663,14 @@ function registerLifecycleTools(server2) {
     requireConfirm(confirm, "oko_move_event", { eventId, targetWorkspaceId });
     const moveEvent = httpsCallable(functions, "moveEventToWorkspace");
     const result = await moveEvent({ eventId, targetWorkspaceId });
+    if (result.data.rtdbMirrorUpdated === false) {
+      return textResult({
+        ...result.data,
+        hints: [
+          "The event document moved, but the live-control mirror in the main RTDB did not confirm: members of the ORIGINAL workspace keep live control (start/end sessions, live badge, analytics) and members of the target workspace do not have it yet. Retry oko_move_event with the same target \u2014 the call is idempotent \u2014 and check oko_get_live_state afterwards."
+        ]
+      });
+    }
     return textResult(result.data);
   });
 }
@@ -119443,18 +119741,15 @@ function registerLiveTools(server2) {
     };
     if (block === "chat") {
       const modeRef = ref(rtdb, `events/${eventId}/ctrl/chatMode`);
-      const legacyRef = ref(rtdb, `events/${eventId}/ctrl/chatVisible`);
-      if (visible === null) {
-        await Promise.all([remove(modeRef), remove(legacyRef)]);
-      } else if (visible === false) {
-        await set(modeRef, "off");
-        await remove(legacyRef);
+      const patch = { chatVisible: null };
+      if (visible === null || visible === false) {
+        patch.chatMode = visible === false ? "off" : null;
       } else {
         const current = await get(modeRef);
         if (current.val() === "off")
-          await remove(modeRef);
-        await remove(legacyRef);
+          patch.chatMode = null;
       }
+      await update(ref(rtdb, `events/${eventId}/ctrl`), patch);
       return textResult({ eventId, block, visible, hints });
     }
     const target = ref(rtdb, `events/${eventId}/ctrl/${paths[block]}`);
@@ -119479,7 +119774,7 @@ function registerLiveTools(server2) {
     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());
+    await runTransaction(ref(rtdb, `events/${eventId}/ctrl/refreshTick`), (current) => (current ?? 0) + 1);
     return textResult({ eventId, refreshed: true });
   });
   server2.registerTool("oko_set_live_badge", {
@@ -119523,23 +119818,26 @@ function registerLiveTools(server2) {
   server2.registerTool("oko_set_chat_mode", {
     title: "Set chat mode",
     description: toolDescription({
-      summary: "Set who can send chat messages on the public event page.",
+      summary: "Open or close chat sending on the public event page.",
       exampleCall: { "eventId": "Kx9pQ2mR7tL4vB8nW3cY", "mode": "off", "confirm": true },
       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).",
+        "mode: public (anyone can send), 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."
+        "There are no other levels: the server has exactly two states, sending open or closed. History is always visible; the mode never restricts who can read or hides anyone's messages."
       ]
     }),
     inputSchema: {
       eventId: eventIdField,
-      mode: external_exports.enum(["public", "auth", "owner", "off"]).nullable().describe("Chat mode; null resets the override to the default."),
+      // LD5a-2 / A8 (owner decision 03.09): "auth" and "owner" were promised
+      // here and enforced nowhere — the rule and every client only check
+      // `mode !== "off"`. The contract now says what the server does.
+      mode: external_exports.enum(["public", "off"]).nullable().describe("Chat mode: public or off; null resets the override to the default."),
       confirm: external_exports.boolean().optional().describe("Required true to change the live chat mode.")
     },
     outputSchema: basicEventOutputSchema,
@@ -119548,11 +119846,7 @@ function registerLiveTools(server2) {
     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);
+    await update(ref(rtdb, `events/${eventId}/ctrl`), { chatMode: mode, chatVisible: null });
     return textResult({ eventId, mode });
   });
   server2.registerTool("oko_force_viewer_reload", {
@@ -119645,7 +119939,7 @@ function registerNotificationTools(server2) {
       ],
       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."]
+      notes: ["Provide either notificationIds or allUnread=true. This can update only the current organizer's own notifications.", "Requires workspace:read (marking your own notifications read is not a workspace write)."]
     }),
     inputSchema: {
       notificationIds: external_exports.array(external_exports.string().min(1).max(160)).max(100).optional().describe("Specific notification document ids."),
@@ -119655,7 +119949,7 @@ function registerNotificationTools(server2) {
     outputSchema: notificationsMarkOutputSchema,
     annotations: idempotentWriteTool
   }, async ({ notificationIds, allUnread, limit: max }) => {
-    const { uid } = await authed(["workspace:write"]);
+    const { uid } = await authed(["workspace:read"]);
     if (Boolean(notificationIds?.length) === allUnread) {
       throw new Error("Provide either notificationIds or allUnread=true.");
     }
@@ -120111,7 +120405,7 @@ function registerTelegramTools(server2) {
         "limit: max posts, default 30, max 100.",
         "cursor: createdAt cursor returned by previous page."
       ],
-      returns: "posts plus cursor pagination metadata.",
+      returns: "posts plus cursor pagination metadata. A failed post may carry deliveryError: sender_right_revoked (the author lost the notification permission and the queued post was cancelled on purpose) or orphaned_pending (delivery never started).",
       examples: ["Use to review scheduled/sent/failed Telegram posts before canceling or cloning."]
     }),
     inputSchema: {
@@ -120177,18 +120471,21 @@ function registerTelegramTools(server2) {
       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.",
+        "caption: post caption, max 4096 chars, parsed as Telegram HTML.",
         "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."]
+      notes: [
+        "External side effect: immediate sends can publish to real Telegram channels.",
+        "The caption is parsed as Telegram HTML, so <b>, <i> and <a href> are markup. Text copied from event fields (title, speaker, description) must have &, < and > escaped as &amp;, &lt; and &gt; first \u2014 an unescaped < makes Telegram reject the whole message and the post ends up failed."
+      ]
     }),
     inputSchema: {
       eventId: eventIdField,
       channelId: external_exports.number().int().describe("Telegram channel id."),
-      caption: external_exports.string().min(1).max(4096).describe("Telegram post caption."),
+      caption: external_exports.string().min(1).max(4096).describe("Telegram post caption, parsed as Telegram HTML; escape &, < and > in text taken from event fields."),
       imageUrl: external_exports.string().nullable().optional().describe("Optional image URL."),
       buttonLabel: external_exports.string().max(64).nullable().optional().describe("Optional inline button label."),
       buttonUrl: external_exports.string().max(1e3).nullable().optional().describe("Optional inline button URL; defaults to event URL when buttonLabel is set."),
@@ -120226,8 +120523,10 @@ function registerTelegramTools(server2) {
       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) }] : [],
+      // R3c-10 (04.09): a wrong protocol used to surface only from Telegram at
+      // delivery, leaving the post `failed`; the check now precedes the write.
+      imageUrl: absoluteHttpUrl(args.imageUrl, "imageUrl"),
+      buttons: args.buttonLabel?.trim() ? [{ label: args.buttonLabel.trim(), url: absoluteHttpUrl(args.buttonUrl, "buttonUrl") ?? eventUrl(args.eventId) }] : [],
       // 🔴 Immediate sending is `pending`, as in the web, not `draft`. A break
       // between creating the document and sending left the post a "draft",
       // indistinguishable from one never sent: CF15 picks up only `scheduled`,
@@ -120301,8 +120600,17 @@ function registerWorkspaceTools(server2) {
     annotations: idempotentWriteTool
   }, async ({ workspaceId, name: name7 }) => {
     const { uid } = await authed(["workspace:write"]);
-    await readWorkspaceForOwner(workspaceId, uid);
-    await updateDoc(doc(firestore, "workspaces", workspaceId), { name: name7.trim() });
+    const { synthesized } = await readWorkspaceForOwnerDetailed(workspaceId, uid);
+    if (synthesized) {
+      await setDoc(doc(firestore, "workspaces", workspaceId), {
+        name: name7.trim(),
+        ownerId: uid,
+        personal: true,
+        createdAt: serverTimestamp2()
+      });
+    } else {
+      await updateDoc(doc(firestore, "workspaces", workspaceId), { name: name7.trim() });
+    }
     return textResult({ workspaceId, updated: ["name"] });
   });
   server2.registerTool("oko_delete_workspace", {
@@ -120320,12 +120628,12 @@ function registerWorkspaceTools(server2) {
   }, 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.");
+    requireConfirm(confirm, "oko_delete_workspace", { workspaceId, name: workspace.name, personal: workspace.personal });
     const removeWorkspace = httpsCallable(functions, "deleteWorkspaceCompletely");
     const removed = await removeWorkspace({ workspaceId });
-    return textResult({ ...removed.data, workspaceId, deleted: true });
+    return textResult({ ...removed.data, deleted: removed.data.deleted === true });
   });
   server2.registerTool("oko_list_workspace_access", {
     title: "List workspace access",
@@ -120346,16 +120654,26 @@ function registerWorkspaceTools(server2) {
       getDocs(query2(collection(firestore, "workspaceInvites"), where("workspaceId", "==", workspaceId)))
     ]);
     const members = [];
+    let anyProfileRestricted = false;
     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);
+      const profile = await getDoc(doc(firestore, "userProfiles", share.id)).then((snap) => ({ value: snap.exists() ? serialize(snap.data()) : null, restricted: false })).catch((error3) => {
+        if (isFirestorePermissionDenied(error3))
+          return { value: null, restricted: true };
+        console.error(`[oko-mcp] userProfiles/${share.id} read failed: ${error3 instanceof Error ? error3.message : String(error3)}`);
+        return { value: null, restricted: false, failed: true };
+      });
+      if (profile.restricted)
+        anyProfileRestricted = true;
       members.push({
         uid: share.id,
         ...serialize(share.data()),
-        profile
+        profile: profile.value,
+        profileAccess: profile.restricted ? "restricted" : "failed" in profile ? "unavailable" : "readable"
       });
     }
     const invites = invitesSnap.docs.map((invite) => ({ code: invite.id, ...serialize(invite.data()) }));
-    return textResult({ workspaceId, workspace: { id: workspaceId, ...serialize(workspace) }, members, invites });
+    const hints = anyProfileRestricted ? ["Some members report profileAccess=restricted: this client may not read other people's profiles, so their display name and avatar are unavailable here even though the OKO cabinet shows them. Refer to those members by uid or by the email stored on the share."] : [];
+    return textResult({ workspaceId, workspace: { id: workspaceId, ...serialize(workspace) }, members, invites, hints });
   });
   server2.registerTool("oko_update_workspace_member", {
     title: "Update workspace member",
@@ -120379,6 +120697,11 @@ function registerWorkspaceTools(server2) {
   }, async (args) => {
     const { uid } = await authed(["workspace:write"]);
     const workspace = await readWorkspaceForOwner(args.workspaceId, uid);
+    if (!isSharedWorkspaceId(args.workspaceId))
+      throw new Error(personalWorkspaceLimitMessage("adding or changing members"));
+    if (args.uid === workspace.ownerId) {
+      throw new Error("The workspace owner already holds every permission; a share for the owner is not needed and would be undone by the platform. Pick another member uid.");
+    }
     requireConfirm(args.confirm, "oko_update_workspace_member", { workspaceId: args.workspaceId, workspaceName: workspace.name, targetUid: args.uid, permissions: args.permissions });
     const shareRef = doc(firestore, "workspaces", args.workspaceId, "shares", args.uid);
     const existing = await getDoc(shareRef);
@@ -120423,9 +120746,15 @@ function registerWorkspaceTools(server2) {
   }, async ({ workspaceId, uid: targetUid, confirm }) => {
     const { uid } = await authed(["workspace:write"]);
     const workspace = await readWorkspaceForOwner(workspaceId, uid);
+    if (!isSharedWorkspaceId(workspaceId))
+      throw new Error(personalWorkspaceLimitMessage("removing members"));
     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 });
+    const shareRef = doc(firestore, "workspaces", workspaceId, "shares", targetUid);
+    const outcome = workspaceMemberRemoval((await getDoc(shareRef)).exists(), workspaceId, targetUid);
+    if (outcome.removed === false)
+      return textResult({ workspaceId, uid: targetUid, ...outcome });
+    await deleteDoc(shareRef);
+    return textResult({ workspaceId, uid: targetUid, ...outcome });
   });
   server2.registerTool("oko_list_workspace_invites", {
     title: "List workspace invites",
@@ -120474,7 +120803,7 @@ function registerWorkspaceTools(server2) {
     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.",
+      returns: "success, workspace id/name, and keptExistingPermissions: true when the organizer was already a member \u2014 an invite never changes existing permissions; the owner changes them with oko_update_workspace_member.",
       examples: ["Use when the organizer wants to join a workspace from an invite code."]
     }),
     inputSchema: {
@@ -120483,6 +120812,7 @@ function registerWorkspaceTools(server2) {
     },
     outputSchema: external_exports.object({
       success: external_exports.boolean(),
+      keptExistingPermissions: external_exports.boolean().optional(),
       workspace: external_exports.object({ id: external_exports.string(), name: external_exports.string() }).passthrough()
     }).passthrough(),
     annotations: writeTool
@@ -120527,6 +120857,8 @@ function registerWorkspaceTools(server2) {
   }, async (args) => {
     const { uid } = await authed(["workspace:write"]);
     const workspace = await readWorkspaceForOwner(args.workspaceId, uid);
+    if (!isSharedWorkspaceId(args.workspaceId))
+      throw new Error(personalWorkspaceLimitMessage("creating invites"));
     requireConfirm(args.confirm, "oko_create_workspace_invite", { workspaceId: args.workspaceId, code: args.code, email: args.email });
     const code = (args.code?.trim() || randomInviteCode()).toUpperCase();
     const url = inviteUrl(code);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@okostream/mcp",
-  "version": "0.12.7",
+  "version": "0.12.9",
   "description": "Control OKO Stream webinars from Claude, Codex, and other MCP clients.",
   "license": "UNLICENSED",
   "author": {