gogcli-mcp 4.5.0 → 4.5.2

package/dist/lib.js

@@ -838,14 +838,14 @@ function promiseAllObject(promisesObj) {
 }
 function randomString(length = 10) {
   const chars = "abcdefghijklmnopqrstuvwxyz";
-  let str = "";
+  let str2 = "";
   for (let i = 0; i < length; i++) {
-    str += chars[Math.floor(Math.random() * chars.length)];
+    str2 += chars[Math.floor(Math.random() * chars.length)];
   }
-  return str;
+  return str2;
 }
-function esc(str) {
-  return JSON.stringify(str);
+function esc(str2) {
+  return JSON.stringify(str2);
 }
 function slugify(input2) {
   return input2.toLowerCase().trim().replace(/[^\w\s-]/g, "").replace(/[\s_-]+/g, "-").replace(/^-+|-+$/g, "");
@@ -959,8 +959,8 @@ var primitiveTypes = /* @__PURE__ */ new Set([
   "symbol",
   "undefined"
 ]);
-function escapeRegex(str) {
-  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function escapeRegex(str2) {
+  return str2.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function clone(inst, def, params) {
   const cl = new inst._zod.constr(def ?? inst._zod.def);
@@ -1214,13 +1214,13 @@ function getSizableOrigin(input2) {
   return "unknown";
 }
 var highSurrogate = /[\uD800-\uDBFF]/;
-function codePointLength(str) {
-  const units = str.length;
-  if (!highSurrogate.test(str))
+function codePointLength(str2) {
+  const units = str2.length;
+  if (!highSurrogate.test(str2))
     return units;
   let count = units;
   for (let i = 0; i < units - 1; i++) {
-    if ((str.charCodeAt(i) & 64512) === 55296 && (str.charCodeAt(i + 1) & 64512) === 56320) {
+    if ((str2.charCodeAt(i) & 64512) === 55296 && (str2.charCodeAt(i + 1) & 64512) === 56320) {
       count--;
       i++;
     }
@@ -19783,7 +19783,7 @@ function declaredDialect(schema, remedy) {
   throw new Error(`JSON Schema declares an unsupported dialect ("$schema": "${schema.$schema.slice(0, 200)}"). The default validator supports JSON Schema 2020-12, 2019-09, draft-07, and draft-06; ${remedy}`);
 }
 
-// ../../node_modules/@modelcontextprotocol/core/dist/auth-CUe6YdwF.mjs
+// ../../node_modules/@modelcontextprotocol/server/node_modules/@modelcontextprotocol/core/dist/auth-CGP0BDVq.mjs
 var LATEST_PROTOCOL_VERSION = "2025-11-25";
 var SUPPORTED_PROTOCOL_VERSIONS = [
   LATEST_PROTOCOL_VERSION,
@@ -20620,7 +20620,8 @@ var OAuthMetadataSchema = looseObject({
   introspection_endpoint_auth_signing_alg_values_supported: array(string2()).optional(),
   code_challenge_methods_supported: array(string2()).optional(),
   client_id_metadata_document_supported: boolean2().optional(),
-  authorization_response_iss_parameter_supported: boolean2().optional().catch(void 0)
+  authorization_response_iss_parameter_supported: boolean2().optional().catch(void 0),
+  dpop_signing_alg_values_supported: array(string2()).optional()
 });
 var OpenIdProviderMetadataSchema = looseObject({
   issuer: string2(),
@@ -20721,7 +20722,7 @@ var OAuthTokenRevocationRequestSchema = object({
   token_type_hint: string2().optional()
 }).strip();
 
-// ../../node_modules/@modelcontextprotocol/server/dist/src-CX2iR2pK.mjs
+// ../../node_modules/@modelcontextprotocol/server/dist/src-D-y6h4N7.mjs
 var BRANDS = /* @__PURE__ */ Symbol.for("mcp.sdk.errorBrands");
 function stampErrorBrands(instance, ctor) {
   const brands = /* @__PURE__ */ new Set();
@@ -20835,8 +20836,18 @@ var SdkError = class extends Error {
     if (typeof this !== "function") throw new TypeError("isInstance must be called on the class (e.g. `SdkError.isInstance(value)`); for callbacks use `v => SdkError.isInstance(v)`");
     return brandedHasInstance(this, value);
   }
-  constructor(code, message, data) {
-    super(message);
+  /**
+  * @param code - Stable string code identifying the failure ({@linkcode SdkErrorCode}).
+  * @param message - Human-readable description.
+  * @param data - Optional structured payload (for example the HTTP status carried by
+  * {@linkcode SdkHttpError}). Opaque to the SDK: a `cause` key inside `data` is not
+  * promoted to `Error.cause`.
+  * @param options - Standard `ErrorOptions`, forwarded to `Error`. Pass the underlying
+  * failure as `{ cause }` so it is reachable through the `Error.cause` chain that
+  * loggers and error trackers walk.
+  */
+  constructor(code, message, data, options) {
+    super(message, options);
     this.code = code;
     this.data = data;
     this.name = "SdkError";
@@ -20847,8 +20858,11 @@ var SdkHttpError = class extends SdkError {
   static {
     Object.defineProperty(this, "mcpBrand", { value: "mcp.SdkHttpError" });
   }
-  constructor(code, message, data) {
-    super(code, message, data);
+  /**
+  * @param options - Standard `ErrorOptions`, forwarded to `Error` (see {@linkcode SdkError}).
+  */
+  constructor(code, message, data, options) {
+    super(code, message, data, options);
     this.name = "SdkHttpError";
   }
   get status() {
@@ -23689,7 +23703,7 @@ var INBOUND_VALIDATION_LADDER = [
     evaluatedAt: "pre-dispatch",
     codes: [HEADER_MISMATCH_ERROR_CODE],
     conformance: ["http-header-validation"],
-    rationale: "SEP-2243 standard `Mcp-Method` / `Mcp-Name` headers \u2014 presence, sentinel decoding, and `Mcp-Name` \u2194 body cross-check \u2014 are validated by the HTTP entry on a modern-classified request after the supported-revision gate and before dispatch. The classifier\u2019s own header-mismatch cells (protocol-version, `Mcp-Method` mismatch) stay on the edge `era-classification` rung; this rung carries the entry-layer presence/`Mcp-Name` half. Evaluated before the capability gate, the factory call, and the `Mcp-Param-*` rung so a request that fails several rungs is answered by the standard-header rung first. The documented order (after method-registry 5 and request-params 6) is NOT the observed precedence: serveModern evaluates this rung immediately after the supported-revision gate, so a request that also fails a dispatch rung is answered here before the dispatch rungs (5\u20136) are consulted."
+    rationale: "SEP-2243 standard `MCP-Protocol-Version` / `Mcp-Method` / `Mcp-Name` headers \u2014 presence, sentinel decoding, and `Mcp-Name` \u2194 body cross-check \u2014 are validated by the HTTP entry on a modern-classified request after the supported-revision gate and before dispatch. The spec requires `MCP-Protocol-Version` and `Mcp-Method` on every modern *request* POST (`Mcp-Name` only for the methods that mirror `params.name` / `params.uri` / `params.taskId`, see `MCP_NAME_HEADER_SOURCE`) and names them in that order, so a request missing several is answered by the earliest. Notification POSTs are exempt: the presence half runs on requests only, so a modern-enveloped notification is dispatched even with no standard headers at all. The classifier\u2019s own header-mismatch cells (protocol-version, `Mcp-Method` mismatch) stay on the edge `era-classification` rung; this rung carries the entry-layer presence/`Mcp-Name` half \u2014 including the missing `MCP-Protocol-Version` cell, which cannot live on the edge rung without breaking body-primary classification. Evaluated before the capability gate, the factory call, and the `Mcp-Param-*` rung so a request that fails several rungs is answered by the standard-header rung first. The documented order (after method-registry 5 and request-params 6) is NOT the observed precedence: serveModern evaluates this rung immediately after the supported-revision gate, so a request that also fails a dispatch rung is answered here before the dispatch rungs (5\u20136) are consulted."
   },
   {
     rung: "client-capabilities",
@@ -24438,7 +24452,7 @@ var Protocol = class {
     return this._requestHandlers.get(method);
   }
   async _oncancel(notification) {
-    if (!notification.params.requestId) return;
+    if (notification.params.requestId === void 0) return;
     this._requestHandlerAbortControllers.get(notification.params.requestId)?.abort(notification.params.reason);
   }
   _setupTimeout(messageId, timeout, maxTotalTimeout, onTimeout, resetTimeoutOnProgress = false) {
@@ -24837,19 +24851,20 @@ var Protocol = class {
       const cancel = (reason) => {
         if (responseReceived) return;
         this._progressHandlers.delete(messageId);
-        if (requestAbort === void 0) this._transport?.send(this._envelopeOutbound({
-          jsonrpc: "2.0",
-          method: "notifications/cancelled",
-          params: {
-            requestId: messageId,
-            reason: String(reason)
-          }
-        }), {
-          relatedRequestId,
-          resumptionToken,
-          onresumptiontoken
-        }).catch((error62) => this._onerror(/* @__PURE__ */ new Error(`Failed to send cancellation: ${error62}`)));
-        else requestAbort.abort();
+        if (requestAbort === void 0) {
+          if (request.method !== "initialize") this._transport?.send(this._envelopeOutbound({
+            jsonrpc: "2.0",
+            method: "notifications/cancelled",
+            params: {
+              requestId: messageId,
+              reason: String(reason)
+            }
+          }), {
+            relatedRequestId,
+            resumptionToken,
+            onresumptiontoken
+          }).catch((error62) => this._onerror(/* @__PURE__ */ new Error(`Failed to send cancellation: ${error62}`)));
+        } else requestAbort.abort();
         reject(reason instanceof SdkError ? reason : new SdkError(SdkErrorCode.RequestTimeout, String(reason)));
       };
       this._responseHandlers.set(messageId, (response) => {
@@ -24929,7 +24944,7 @@ var Protocol = class {
       jsonrpc: "2.0",
       ...notification
     });
-    if ((this._options?.debouncedNotificationMethods ?? []).includes(notification.method) && !notification.params && !options?.relatedRequestId) {
+    if ((this._options?.debouncedNotificationMethods ?? []).includes(notification.method) && !notification.params && options?.relatedRequestId === void 0) {
       if (this._pendingDebouncedNotifications.has(notification.method)) return;
       this._pendingDebouncedNotifications.add(notification.method);
       Promise.resolve().then(() => {
@@ -25182,7 +25197,7 @@ var require_code$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
   }
   exports._ = _;
   const plus = new _Code("+");
-  function str(strs, ...args) {
+  function str2(strs, ...args) {
     const expr = [safeStringify(strs[0])];
     let i = 0;
     while (i < args.length) {
@@ -25193,7 +25208,7 @@ var require_code$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
     optimize(expr);
     return new _Code(expr);
   }
-  exports.str = str;
+  exports.str = str2;
   function addCodeArg(code, arg) {
     if (arg instanceof _Code) code.push(...arg._items);
     else if (arg instanceof Name) code.push(arg);
@@ -25226,7 +25241,7 @@ var require_code$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
     if (typeof b == "string" && b[0] === '"' && !(a instanceof Name)) return `"${a}${b.slice(1)}`;
   }
   function strConcat(c1, c2) {
-    return c2.emptyStr() ? c1 : c1.emptyStr() ? c2 : str`${c1}${c2}`;
+    return c2.emptyStr() ? c1 : c1.emptyStr() ? c2 : str2`${c1}${c2}`;
   }
   exports.strConcat = strConcat;
   function interpolate(x) {
@@ -26105,21 +26120,21 @@ var require_util = /* @__PURE__ */ __commonJSMin(((exports) => {
     return (0, codegen_1._)`${topSchemaRef}${schemaPath}${(0, codegen_1.getProperty)(keyword)}`;
   }
   exports.schemaRefOrVal = schemaRefOrVal;
-  function unescapeFragment(str) {
-    return unescapeJsonPointer(decodeURIComponent(str));
+  function unescapeFragment(str2) {
+    return unescapeJsonPointer(decodeURIComponent(str2));
   }
   exports.unescapeFragment = unescapeFragment;
-  function escapeFragment(str) {
-    return encodeURIComponent(escapeJsonPointer(str));
+  function escapeFragment(str2) {
+    return encodeURIComponent(escapeJsonPointer(str2));
   }
   exports.escapeFragment = escapeFragment;
-  function escapeJsonPointer(str) {
-    if (typeof str == "number") return `${str}`;
-    return str.replace(/~/g, "~0").replace(/\//g, "~1");
+  function escapeJsonPointer(str2) {
+    if (typeof str2 == "number") return `${str2}`;
+    return str2.replace(/~/g, "~0").replace(/\//g, "~1");
   }
   exports.escapeJsonPointer = escapeJsonPointer;
-  function unescapeJsonPointer(str) {
-    return str.replace(/~1/g, "/").replace(/~0/g, "~");
+  function unescapeJsonPointer(str2) {
+    return str2.replace(/~1/g, "/").replace(/~0/g, "~");
   }
   exports.unescapeJsonPointer = unescapeJsonPointer;
   function eachItem(xs, f) {
@@ -27005,8 +27020,8 @@ var require_json_schema_traverse = /* @__PURE__ */ __commonJSMin(((exports, modu
       post(schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex);
     }
   }
-  function escapeJsonPtr(str) {
-    return str.replace(/~/g, "~0").replace(/\//g, "~1");
+  function escapeJsonPtr(str2) {
+    return str2.replace(/~/g, "~0").replace(/\//g, "~1");
   }
 }));
 var require_resolve = /* @__PURE__ */ __commonJSMin(((exports) => {
@@ -27898,9 +27913,9 @@ var require_utils = /* @__PURE__ */ __commonJSMin(((exports, module) => {
       isIPV6: false
     };
   }
-  function findToken(str, token) {
+  function findToken(str2, token) {
     let ind = 0;
-    for (let i = 0; i < str.length; i++) if (str[i] === token) ind++;
+    for (let i = 0; i < str2.length; i++) if (str2[i] === token) ind++;
     return ind;
   }
   function removeDotSegments(path) {
@@ -28415,7 +28430,7 @@ var require_core$3 = /* @__PURE__ */ __commonJSMin(((exports) => {
   const util_1 = require_util();
   const $dataRefSchema = require_data();
   const uri_1 = require_uri();
-  const defaultRegExp = (str, flags) => new RegExp(str, flags);
+  const defaultRegExp = (str2, flags) => new RegExp(str2, flags);
   defaultRegExp.code = "new RegExp";
   const META_IGNORE_OPTIONS = [
     "removeAdditional",
@@ -29121,16 +29136,16 @@ var require_multipleOf = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 var require_ucs2length = /* @__PURE__ */ __commonJSMin(((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
-  function ucs2length(str) {
-    const len = str.length;
+  function ucs2length(str2) {
+    const len = str2.length;
     let length = 0;
     let pos2 = 0;
     let value;
     while (pos2 < len) {
       length++;
-      value = str.charCodeAt(pos2++);
+      value = str2.charCodeAt(pos2++);
       if (value >= 55296 && value <= 56319 && pos2 < len) {
-        value = str.charCodeAt(pos2);
+        value = str2.charCodeAt(pos2);
         if ((value & 64512) === 56320) pos2++;
       }
     }
@@ -31841,8 +31856,8 @@ var require_formats = /* @__PURE__ */ __commonJSMin(((exports) => {
     30,
     31
   ];
-  function date5(str) {
-    const matches = DATE.exec(str);
+  function date5(str2) {
+    const matches = DATE.exec(str2);
     if (!matches) return false;
     const year = +matches[1];
     const month = +matches[2];
@@ -31857,8 +31872,8 @@ var require_formats = /* @__PURE__ */ __commonJSMin(((exports) => {
   }
   const TIME = /^(\d\d):(\d\d):(\d\d(?:\.\d+)?)(z|([+-])(\d\d)(?::?(\d\d))?)?$/i;
   function getTime(strictTimeZone) {
-    return function time3(str) {
-      const matches = TIME.exec(str);
+    return function time3(str2) {
+      const matches = TIME.exec(str2);
       if (!matches) return false;
       const hr = +matches[1];
       const min = +matches[2];
@@ -31895,8 +31910,8 @@ var require_formats = /* @__PURE__ */ __commonJSMin(((exports) => {
   const DATE_TIME_SEPARATOR = /t|\s/i;
   function getDateTime(strictTimeZone) {
     const time3 = getTime(strictTimeZone);
-    return function date_time(str) {
-      const dateTime = str.split(DATE_TIME_SEPARATOR);
+    return function date_time(str2) {
+      const dateTime = str2.split(DATE_TIME_SEPARATOR);
       return dateTime.length === 2 && date5(dateTime[0]) && time3(dateTime[1]);
     };
   }
@@ -31917,13 +31932,13 @@ var require_formats = /* @__PURE__ */ __commonJSMin(((exports) => {
   }
   const NOT_URI_FRAGMENT = /\/|:/;
   const URI = /^(?:[a-z][a-z0-9+\-.]*:)(?:\/?\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:]|%[0-9a-f]{2})*@)?(?:\[(?:(?:(?:(?:[0-9a-f]{1,4}:){6}|::(?:[0-9a-f]{1,4}:){5}|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}|(?:(?:[0-9a-f]{1,4}:){0,1}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::)(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?))|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)|[Vv][0-9a-f]+\.[a-z0-9\-._~!$&'()*+,;=:]+)\]|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)|(?:[a-z0-9\-._~!$&'()*+,;=]|%[0-9a-f]{2})*)(?::\d*)?(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*|\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)?|(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)(?:\?(?:[a-z0-9\-._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?(?:#(?:[a-z0-9\-._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?$/i;
-  function uri(str) {
-    return NOT_URI_FRAGMENT.test(str) && URI.test(str);
+  function uri(str2) {
+    return NOT_URI_FRAGMENT.test(str2) && URI.test(str2);
   }
   const BYTE = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/gm;
-  function byte(str) {
+  function byte(str2) {
     BYTE.lastIndex = 0;
-    return BYTE.test(str);
+    return BYTE.test(str2);
   }
   const MIN_INT32 = -(2 ** 31);
   const MAX_INT32 = 2 ** 31 - 1;
@@ -31937,10 +31952,10 @@ var require_formats = /* @__PURE__ */ __commonJSMin(((exports) => {
     return true;
   }
   const Z_ANCHOR = /[^\\]\\Z/;
-  function regex(str) {
-    if (Z_ANCHOR.test(str)) return false;
+  function regex(str2) {
+    if (Z_ANCHOR.test(str2)) return false;
     try {
-      new RegExp(str);
+      new RegExp(str2);
       return true;
     } catch (e) {
       return false;
@@ -32129,7 +32144,7 @@ var AjvJsonSchemaValidator = class {
 };
 var Ajv = import_ajv.Ajv;
 
-// ../../node_modules/@modelcontextprotocol/server/dist/mcp-DXXb3Vv3.mjs
+// ../../node_modules/@modelcontextprotocol/server/dist/mcp-Dw2OlZ1f.mjs
 var MAX_TIMER_DELAY_MS = 2 ** 31 - 1;
 var DEFAULT_LEGACY_SHIM_MAX_ROUNDS = 8;
 var DEFAULT_LEGACY_SHIM_ROUND_TIMEOUT_MS = 6e5;
@@ -32880,6 +32895,9 @@ function discoverAdvertisedCapabilities(capabilities) {
   return { ...capabilities };
 }
 
+// ../../node_modules/@modelcontextprotocol/server/dist/index.mjs
+var DEFAULT_MAX_REQUEST_BODY_SIZE = 4 * 1024 * 1024;
+
 // ../../node_modules/@chrischall/mcp-utils/dist/errors/index.js
 var BEARER_RE = /(bearer\s+)[A-Za-z0-9._~+/=-]{8,}/gi;
 var JWT_RE = /\b[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{8,}\b/g;
@@ -34327,6 +34345,7 @@ async function diagnose(err) {
   const isAuthError = !isTransientError && AUTH_ERROR_PATTERN.test(errText);
   const isGridLimitError = GRID_LIMIT_ERROR_PATTERN.test(errText);
   const hint = isInvalidGrant ? INVALID_GRANT_HINT : isAuthError ? AUTH_HINT : isTransientError ? TRANSIENT_HINT : isGridLimitError ? GRID_LIMIT_HINT : "";
+  if (!isAuthError && !isInvalidGrant) return errorResult(`${errText}${hint}`);
   try {
     const accounts = formatAccountList(await run(["auth", "list"]));
     return errorResult(`${errText}
@@ -34471,12 +34490,53 @@ function attachmentPreview(details) {
 var CONFIRM_SEND_INSTRUCTION = "Show this preview to the user verbatim and send only after they explicitly approve in chat. Then call again with confirmToken.";
 var CONFIRM_ACTION_INSTRUCTION = CONFIRM_TOKEN_INSTRUCTION;
 var CONFIRM_FALLBACK_DESCRIPTION = ' If the client cannot show that prompt (no MCP elicitation, e.g. claude.ai), a two-step flow applies instead: call WITHOUT confirmToken and nothing is sent or changed \u2014 the result has status "confirmation-required", the full preview and a confirmToken. Follow its instruction (by default: show the preview to the user verbatim and only after they explicitly approve it in chat, call again with the SAME arguments plus confirmToken). The tool re-reads what it would act on and refuses (DRAFT_CHANGED, with a fresh preview and token) if it changed; TOKEN_EXPIRED / TOKEN_REUSED / TOKEN_INVALID also do nothing. A server set to MCP_CONFIRM_MODE=refuse refuses instead.';
+function refusedInRun(what, via, does, instead) {
+  return `${what} ${does} and is not available through ${via}. ${instead}`;
+}
 function gatedElsewhere(what, via, does, tool) {
-  return `${what} ${does} and is not available through ${via}. Use ${tool}, which asks the user to confirm.`;
+  return refusedInRun(what, via, does, `Use ${tool}, which asks the user to confirm.`);
 }
 function hasCommandWord(args, words) {
   return args.find((a) => words.has(a.toLowerCase()));
 }
+function flagValue(args, name) {
+  const flag = `--${name}`;
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === flag) return args[i + 1] ?? "";
+    if (a.startsWith(`${flag}=`)) return a.slice(flag.length + 1);
+  }
+  return void 0;
+}
+var COMMENT_ADD_WORDS = /* @__PURE__ */ new Set(["create", "add", "new"]);
+var COMMENT_REPLY_WORDS = /* @__PURE__ */ new Set(["reply", "respond"]);
+function hasTrueFlag(args, flag) {
+  const name = `--${flag}`;
+  return args.some((a) => {
+    const lower = a.toLowerCase();
+    if (lower === name) return true;
+    return lower.startsWith(`${name}=`) && lower.slice(name.length + 1) !== "false";
+  });
+}
+function vetCommentsRun(service, subcommand, args) {
+  if (subcommand.toLowerCase() !== "comments") return void 0;
+  const reply = hasCommandWord(args, COMMENT_REPLY_WORDS);
+  if (reply) {
+    return gatedElsewhere(
+      `gog ${service} comments ${reply.toLowerCase()}`,
+      `gog_${service}_run`,
+      "notifies the comment thread",
+      `gog_${service}_comments_reply`
+    );
+  }
+  const add = hasCommandWord(args, COMMENT_ADD_WORDS);
+  return add ? gatedElsewhere(
+    `gog ${service} comments ${add.toLowerCase()}`,
+    `gog_${service}_run`,
+    "notifies the file's owner and anyone it mentions",
+    `gog_${service}_comments_add`
+  ) : void 0;
+}
 async function requireDispatchConfirmation(ctx, options) {
   const { action, fallback } = options;
   const confirmation = {
@@ -34505,16 +34565,33 @@ function resultText(result) {
 // src/tools/api.ts
 var GMAIL_API_BLOCKED = /(?:\.send$|forwarding|filters\.create|filters\.update|delegates\.create)/i;
 var DISPATCH_API_BLOCKED = {
-  chat: [{ method: /(?:^|\.)spaces\.messages\.create$/i, does: "posts a Chat message", tool: "gog_chat_messages_send / gog_chat_dm_send" }],
-  drive: [{ method: /(?:^|\.)permissions\.(?:create|update)$/i, does: "grants access to a file", tool: "gog_drive_share" }],
+  chat: [
+    { method: /(?:^|\.)spaces\.messages\.create$/i, does: "posts a Chat message", tool: "gog_chat_messages_send / gog_chat_dm_send" },
+    { method: /(?:^|\.)spaces\.(?:setup|members\.create)$/i, does: "adds people to a space", tool: "gog_chat_spaces_create" }
+  ],
+  drive: [
+    { method: /(?:^|\.)permissions\.(?:create|update)$/i, does: "grants access to a file", tool: "gog_drive_share" },
+    { method: /(?:^|\.)comments\.create$/i, does: "notifies the file's owner and anyone it mentions", tool: "gog_drive_comments_add / gog_docs_comments_add" },
+    { method: /(?:^|\.)replies\.create$/i, does: "notifies the comment thread", tool: "gog_drive_comments_reply / gog_docs_comments_reply" }
+  ],
   classroom: [
     { method: /(?:^|\.)courses\.announcements\.create$/i, does: "posts to a class", tool: "gog_classroom_announcements_create" },
-    { method: /(?:^|\.)invitations\.create$/i, does: "invites someone to a class", tool: "gog_classroom_invitations_create" }
+    { method: /(?:^|\.)invitations\.create$/i, does: "invites someone to a class", tool: "gog_classroom_invitations_create" },
+    { method: /(?:^|\.)courses\.students\.create$/i, does: "adds someone to a class", tool: "gog_classroom_students_add" },
+    { method: /(?:^|\.)courses\.teachers\.create$/i, does: "gives someone teacher access to a class", tool: "gog_classroom_teachers_add" },
+    { method: /(?:^|\.)courses\.coursework\.create$/i, does: "posts coursework to a class", tool: "gog_classroom_coursework_create" },
+    { method: /(?:^|\.)studentsubmissions\.return$/i, does: "returns work to a student", tool: "gog_classroom_submissions_return" }
   ],
   calendar: [
     { method: /(?:^|\.)events\.(?:insert|import|quickadd)$/i, does: "can put an event on guests' calendars", tool: "gog_calendar_create" },
-    { method: /(?:^|\.)events\.(?:update|patch)$/i, does: "can change what guests see", tool: "gog_calendar_update / gog_calendar_respond" }
-  ]
+    { method: /(?:^|\.)events\.(?:update|patch)$/i, does: "can change what guests see", tool: "gog_calendar_update / gog_calendar_respond" },
+    { method: /(?:^|\.)events\.move$/i, does: "can email every guest", tool: "gog_calendar_move" }
+  ],
+  gmail: [
+    { method: /(?:^|\.)settings\.sendas\.create$/i, does: "makes Google email the address and adds a sending identity", tool: "gog_gmail_sendas_create" },
+    { method: /(?:^|\.)settings\.updatevacation$/i, does: "can turn on an auto-reply to every sender", tool: "gog_gmail_vacation_update" }
+  ],
+  script: [{ method: /(?:^|\.)scripts\.run$/i, does: "executes code with this account's authority", tool: "gog_appscript_run_function" }]
 };
 function refusedApiCall(api, method) {
   const name = api.trim().toLowerCase();
@@ -34525,6 +34602,14 @@ function refusedApiCall(api, method) {
   const hit = (Object.hasOwn(DISPATCH_API_BLOCKED, name) ? DISPATCH_API_BLOCKED[name] : []).find((b) => b.method.test(m));
   return hit ? gatedElsewhere(`${name} ${m}`, "gog_api_call", hit.does, hit.tool) : void 0;
 }
+function previewJson(text) {
+  if (text.length > BODY_PREVIEW_MAX) return bodyPreview(text);
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
 function registerApiTools(server) {
   server.registerTool("gog_api_list", {
     description: "List the Google Discovery APIs available for gog_api_call / gog_api_describe (name + version + title).",
@@ -34553,7 +34638,7 @@ function registerApiTools(server) {
     return runOrDiagnose(args, { account });
   });
   server.registerTool("gog_api_call", {
-    description: "Call any Discovery-described Google API method directly \u2014 an escape hatch for endpoints gog has no dedicated tool for. Find the exact api/version/method/params with gog_api_describe first. Read methods (GET/LIST) run as-is. Mutating methods (POST/PUT/PATCH/DELETE) are refused unless you set allowWrite=true \u2014 keep it false to preview, or set dryRun=true to print the intended request without sending it. Gmail send and forwarding methods (users.messages.send, users.drafts.send, forwarding/auto-forwarding, filters, delegates) are refused \u2014 use the dedicated gog_gmail_* tools, which ask the user to confirm. So are the other methods a dedicated tool asks about: Chat spaces.messages.create, Drive permissions.create/update, Classroom courses.announcements.create and invitations.create, and Calendar events.insert/import/quickAdd/update/patch.",
+    description: "Call any Discovery-described Google API method directly \u2014 an escape hatch for endpoints gog has no dedicated tool for. Find the exact api/version/method/params with gog_api_describe first. Read methods (GET/LIST) run as-is. Mutating methods (POST/PUT/PATCH/DELETE) are refused unless you set allowWrite=true, and every write then asks the MCP host to show the user a confirmation prompt with the exact api/version/method/params/body before anything is sent; set dryRun=true to print the intended request without sending it (no prompt, no changes). Gmail send and forwarding methods (users.messages.send, users.drafts.send, forwarding/auto-forwarding, filters, delegates) are refused outright \u2014 use the dedicated gog_gmail_* tools, which ask the user to confirm. So are the other methods a dedicated tool asks about with a better preview: Chat spaces.messages.create, Drive permissions.create/update, Classroom courses.announcements.create and invitations.create, and Calendar events.insert/import/quickAdd/update/patch." + CONFIRM_FALLBACK_DESCRIPTION,
     annotations: { destructiveHint: true },
     inputSchema: external_exports.object({
       api: external_exports.string().describe("Discovery API name (e.g. drive, gmail, calendar)"),
@@ -34562,11 +34647,12 @@ function registerApiTools(server) {
       params: external_exports.string().optional().describe('Query/path parameters as a JSON object string (e.g. {"fileId":"abc","fields":"name"})'),
       body: external_exports.string().optional().describe("Request body as a JSON string (for write methods)"),
       scope: external_exports.string().optional().describe("Override the OAuth scope used for the call"),
-      allowWrite: external_exports.boolean().optional().describe("Required to invoke a mutating method (POST/PUT/PATCH/DELETE). Without it, gog refuses write methods. Leave unset for read-only calls."),
-      dryRun: external_exports.boolean().optional().describe("Print the intended request and exit without sending it (no changes made)"),
-      account: accountParam
+      allowWrite: external_exports.boolean().optional().describe("Required to invoke a mutating method (POST/PUT/PATCH/DELETE); the user is asked to confirm the exact request first. Without it, gog refuses write methods. Leave unset for read-only calls."),
+      dryRun: external_exports.boolean().optional().describe("Print the intended request and exit without sending it (no changes made, no confirmation prompt)"),
+      account: accountParam,
+      confirmToken: confirmTokenParam
     })
-  }, async ({ api, version: version2, method, params, body, scope, allowWrite, dryRun, account }) => {
+  }, async ({ api, version: version2, method, params, body, scope, allowWrite, dryRun, account, confirmToken }, ctx) => {
     try {
       assertSafeForwardedArgs([api, version2, method]);
       const refusal = refusedApiCall(api, method);
@@ -34576,6 +34662,27 @@ function registerApiTools(server) {
     } catch (err) {
       return errorResult(errorText(err));
     }
+    if (allowWrite && !dryRun) {
+      const request = { api, version: version2, method, params, body, scope };
+      const view = { api, version: version2, method };
+      if (params !== void 0) view.params = previewJson(params);
+      if (body !== void 0) view.body = previewJson(body);
+      if (scope !== void 0) view.scope = scope;
+      const confirmation = await requireDispatchConfirmation(ctx, {
+        action: "api.call",
+        message: `Review and confirm this raw Google API write (${api} ${version2} ${method}):`,
+        confirmationLabel: "Confirm that this API method should be invoked with exactly these parameters.",
+        details: view,
+        unsupportedNote: "Set dryRun=true to see the request gog would send without sending it, or use the dedicated gog_* tool for this operation.",
+        fallback: {
+          tool: "gog_api_call",
+          account,
+          confirmToken,
+          subject: () => ({ target: `${api}/${version2}/${method}`, payload: request, preview: view })
+        }
+      });
+      if (confirmation) return confirmation;
+    }
     const args = ["api", "call", pos(api), pos(version2), pos(method)];
     if (params) args.push(`--params=${params}`);
     if (body) args.push(`--body=${body}`);
@@ -34588,6 +34695,22 @@ function registerApiTools(server) {
 }
 
 // src/tools/appscript.ts
+function vetAppScriptRun(subcommand, _args) {
+  return subcommand.toLowerCase() === "run" ? gatedElsewhere("gog appscript run", "gog_appscript_run", "executes code with this account's authority", "gog_appscript_run_function") : void 0;
+}
+function projectSnapshot(raw, scriptId) {
+  let project;
+  try {
+    project = JSON.parse(raw)?.project;
+  } catch {
+    project = void 0;
+  }
+  return {
+    scriptId,
+    ...typeof project?.title === "string" ? { title: project.title } : {},
+    ...typeof project?.updateTime === "string" ? { updateTime: project.updateTime } : {}
+  };
+}
 function registerAppScriptTools(server) {
   const scriptIdParam = external_exports.string().describe(
     "Apps Script project ID \u2014 the long ID in script.google.com/\u2026/projects/<scriptId>/\u2026, NOT the Drive file ID of a container document"
@@ -34668,16 +34791,18 @@ function registerAppScriptTools(server) {
     return runOrDiagnose(args, { account });
   });
   server.registerTool("gog_appscript_run_function", {
-    description: "Execute a function in a deployed Apps Script project. TREAT THIS AS ARBITRARY CODE EXECUTION: the script runs with this Google account's authority and can send mail, edit Drive files or call external services, and the wrapper cannot tell a read from a write \u2014 read the code with gog_appscript_content first if you did not write it. Requires the project to be deployed as an API executable and to share the OAuth client with the calling credentials, otherwise Google refuses regardless of scopes. devMode runs the latest saved code instead of the deployed version, and only works if the account owns the script. This is NOT the escape hatch \u2014 gog_appscript_run is that." + apiEnableNote,
+    description: "Execute a function in a deployed Apps Script project. TREAT THIS AS ARBITRARY CODE EXECUTION: the script runs with this Google account's authority and can send mail, edit Drive files or call external services, and the wrapper cannot tell a read from a write \u2014 read the code with gog_appscript_content first if you did not write it. Requires the project to be deployed as an API executable and to share the OAuth client with the calling credentials, otherwise Google refuses regardless of scopes. devMode runs the latest saved code instead of the deployed version, and only works if the account owns the script. This is NOT the escape hatch \u2014 gog_appscript_run is that. Because the wrapper cannot tell what the code will do, it reads the project and asks the MCP host to show the user a confirmation prompt with the project, the function and its arguments first; nothing runs unless they accept." + CONFIRM_FALLBACK_DESCRIPTION + apiEnableNote,
     annotations: { destructiveHint: true },
     inputSchema: external_exports.object({
       scriptId: scriptIdParam,
       functionName: external_exports.string().describe('Name of the function to call, e.g. "doWork"'),
       params: external_exports.string().optional().describe(`Function parameters as a JSON ARRAY of positional arguments, e.g. '["a", 1]' \u2014 not an object`),
       devMode: external_exports.boolean().optional().describe("Run the latest saved code rather than the deployed version (owner only)"),
-      account: accountParam
+      account: accountParam,
+      confirmToken: confirmTokenParam
     })
-  }, async ({ scriptId, functionName, params, devMode, account }) => {
+  }, async ({ scriptId, functionName, params, devMode, account, confirmToken }, ctx) => {
+    let parsedParams;
     if (params !== void 0) {
       let parsed;
       try {
@@ -34688,7 +34813,26 @@ function registerAppScriptTools(server) {
       if (!Array.isArray(parsed)) {
         throw new Error(`params must be a JSON ARRAY of positional arguments, e.g. '["a", 1]' \u2014 Apps Script takes positional arguments, not named ones. Received: ${params}`);
       }
+      parsedParams = parsed;
     }
+    const got = await runOrDiagnose(["appscript", "get", pos(scriptId)], { account });
+    if (got.isError) return got;
+    const { updateTime, ...project } = projectSnapshot(resultText(got), scriptId);
+    const execution = { project, functionName, params: parsedParams, devMode: Boolean(devMode), runsAs: senderPreview(account) };
+    const confirmation = await requireDispatchConfirmation(ctx, {
+      action: "appscript.run-function",
+      message: "Review and confirm running this Apps Script function with the account's full authority:",
+      confirmationLabel: "Confirm that this code should run now.",
+      details: execution,
+      unsupportedNote: "Ask the user to run it themselves from the Apps Script editor.",
+      fallback: {
+        tool: "gog_appscript_run_function",
+        account,
+        confirmToken,
+        subject: () => ({ target: `${scriptId}/${functionName}`, revision: updateTime, payload: execution, preview: execution })
+      }
+    });
+    if (confirmation) return confirmation;
     const args = ["appscript", "run", pos(scriptId), pos(functionName)];
     if (params !== void 0) args.push(`--params=${params}`);
     if (devMode) args.push("--dev-mode");
@@ -34697,6 +34841,7 @@ function registerAppScriptTools(server) {
   registerRunTool(server, {
     service: "appscript",
     examples: '"get", "content", "deployments"',
+    vet: vetAppScriptRun,
     note: "To execute a function, use gog_appscript_run_function \u2014 this tool is the generic escape hatch."
   });
 }
@@ -34839,21 +34984,47 @@ function authToolsFor(defaultServices) {
 }
 
 // src/tools/calendar.ts
-var CALENDAR_GATED = {
-  create: "gog_calendar_create",
-  add: "gog_calendar_create",
-  new: "gog_calendar_create",
-  update: "gog_calendar_update",
-  edit: "gog_calendar_update",
-  set: "gog_calendar_update",
-  respond: "gog_calendar_respond",
-  rsvp: "gog_calendar_respond",
-  reply: "gog_calendar_respond"
+var ASKS = (tool) => `Use ${tool}, which asks the user to confirm.`;
+var CALENDAR_REFUSED = {
+  create: { does: "can change what guests see", instead: ASKS("gog_calendar_create") },
+  add: { does: "can change what guests see", instead: ASKS("gog_calendar_create") },
+  new: { does: "can change what guests see", instead: ASKS("gog_calendar_create") },
+  update: { does: "can change what guests see", instead: ASKS("gog_calendar_update") },
+  edit: { does: "can change what guests see", instead: ASKS("gog_calendar_update") },
+  set: { does: "can change what guests see", instead: ASKS("gog_calendar_update") },
+  respond: { does: "can change what guests see", instead: ASKS("gog_calendar_respond") },
+  rsvp: { does: "can change what guests see", instead: ASKS("gog_calendar_respond") },
+  reply: { does: "can change what guests see", instead: ASKS("gog_calendar_respond") },
+  move: { does: "moves an event off guests' calendars (and can email them)", instead: ASKS("gog_calendar_move") },
+  transfer: { does: "moves an event off guests' calendars (and can email them)", instead: ASKS("gog_calendar_move") },
+  delete: { does: "removes an event from every guest's calendar (the whole series by default)", instead: ASKS("gog_calendar_delete") },
+  del: { does: "removes an event from every guest's calendar (the whole series by default)", instead: ASKS("gog_calendar_delete") },
+  rm: { does: "removes an event from every guest's calendar (the whole series by default)", instead: ASKS("gog_calendar_delete") },
+  remove: { does: "removes an event from every guest's calendar (the whole series by default)", instead: ASKS("gog_calendar_delete") },
+  "delete-calendar": { does: "deletes a calendar and every event on it", instead: ASKS("gog_calendar_delete_calendar") },
+  "out-of-office": { does: "auto-declines invitations and notifies their organizers", instead: ASKS("gog_calendar_out_of_office") },
+  ooo: { does: "auto-declines invitations and notifies their organizers", instead: ASKS("gog_calendar_out_of_office") }
 };
-function vetCalendarRun(subcommand, _args) {
+function vetCalendarRun(subcommand, args) {
   const sub = subcommand.toLowerCase();
-  const tool = Object.hasOwn(CALENDAR_GATED, sub) ? CALENDAR_GATED[sub] : void 0;
-  return tool ? gatedElsewhere(`gog calendar ${sub}`, "gog_calendar_run", "can change what guests see", tool) : void 0;
+  const what = `gog calendar ${sub}`;
+  const via = "gog_calendar_run";
+  if (Object.hasOwn(CALENDAR_REFUSED, sub)) {
+    const { does, instead } = CALENDAR_REFUSED[sub];
+    return refusedInRun(what, via, does, instead);
+  }
+  if (sub === "propose-time" && (flagValue(args, "decline") !== void 0 || flagValue(args, "comment") !== void 0)) {
+    return gatedElsewhere(`${what} --decline`, via, "declines the event and notifies the organizer", "gog_calendar_respond");
+  }
+  if ((sub === "focus-time" || sub === "focus") && flagValue(args, "auto-decline")?.toLowerCase() !== "none") {
+    return refusedInRun(
+      what,
+      via,
+      "auto-declines invitations and notifies their organizers (gog defaults --auto-decline to all)",
+      "Pass --auto-decline=none, or ask the user to create it from Google Calendar."
+    );
+  }
+  return void 0;
 }
 function parseAttendees(value) {
   if (!value) return [];
@@ -34870,15 +35041,17 @@ function eventSnapshot(raw) {
   } catch {
     event = void 0;
   }
-  const str = (v) => typeof v === "string" ? v : void 0;
+  const str2 = (v) => typeof v === "string" ? v : void 0;
   return {
-    summary: str(event?.summary),
+    summary: str2(event?.summary),
     start: timeOf(event?.start),
     end: timeOf(event?.end),
-    organizer: str(event?.organizer?.email),
+    organizer: str2(event?.organizer?.email),
     // Guests are the OTHER people: not this account's own attendee row, not rooms.
     guests: (Array.isArray(event?.attendees) ? event.attendees : []).filter((a) => a.self !== true && a.resource !== true && typeof a.email === "string").map((a) => a.email),
-    etag: str(event?.etag)
+    // A series, or one instance of one: gog's delete --scope defaults to all.
+    ...Array.isArray(event?.recurrence) && event.recurrence.length > 0 || typeof event?.recurringEventId === "string" ? { recurring: true } : {},
+    etag: str2(event?.etag)
   };
 }
 async function readEvent(calendarId, eventId, account) {
@@ -35099,14 +35272,35 @@ function registerCalendarTools(server) {
     return runOrDiagnose(args, { account });
   });
   server.registerTool("gog_calendar_delete", {
-    description: "Delete a calendar event.",
+    description: "Delete a calendar event. It disappears from every guest's calendar too, and for a recurring event gog deletes the WHOLE series, so when the event has guests or recurs this reads it and asks the MCP host to show the user a confirmation prompt with the event as it stands; a guest-free, one-off event is deleted without asking." + CONFIRM_FALLBACK_DESCRIPTION,
     annotations: { destructiveHint: true },
     inputSchema: external_exports.object({
       calendarId: external_exports.string().describe("Calendar ID"),
       eventId: external_exports.string().describe("Event ID"),
-      account: accountParam
+      account: accountParam,
+      confirmToken: confirmTokenParam
     })
-  }, async ({ calendarId, eventId, account }) => {
+  }, async ({ calendarId, eventId, account, confirmToken }, ctx) => {
+    const read = await readEvent(calendarId, eventId, account);
+    if (read.error) return read.error;
+    const { etag, ...event } = read.event;
+    if (event.guests.length > 0 || event.recurring) {
+      const view = { calendarId, eventId, event, scope: event.recurring ? "the whole recurring series" : "this event" };
+      const confirmation = await requireDispatchConfirmation(ctx, {
+        action: "calendar.delete",
+        message: event.recurring ? "Review and confirm deleting this ENTIRE recurring series:" : "Review and confirm deleting this event from every guest's calendar:",
+        confirmationLabel: "Confirm that this event should be deleted now.",
+        details: view,
+        unsupportedNote: "Ask the user to delete it from Google Calendar.",
+        fallback: {
+          tool: "gog_calendar_delete",
+          account,
+          confirmToken,
+          subject: () => ({ target: `${calendarId}/${eventId}`, revision: etag, payload: view, preview: view })
+        }
+      });
+      if (confirmation) return confirmation;
+    }
     return runOrDiagnose(["calendar", "delete", pos(calendarId), pos(eventId), "--force"], { account });
   });
   server.registerTool("gog_calendar_respond", {
@@ -35228,8 +35422,14 @@ function inlineAttachmentArgs(flag, attachments, siblingArgs = []) {
 
 // src/tools/chat.ts
 var CHAT_SEND_WORDS = /* @__PURE__ */ new Set(["send", "create", "post"]);
+var CHAT_SPACE_CREATE_WORDS = /* @__PURE__ */ new Set(["create", "add", "new"]);
 function vetChatRun(subcommand, args) {
   const sub = subcommand.toLowerCase();
+  if (sub === "spaces") {
+    const word2 = hasCommandWord(args, CHAT_SPACE_CREATE_WORDS);
+    const withMembers = args.some((a) => /^--members?(?:=|$)/i.test(a));
+    return word2 && withMembers ? gatedElsewhere(`gog chat spaces ${word2.toLowerCase()} --member`, "gog_chat_run", "adds people to a space", "gog_chat_spaces_create") : void 0;
+  }
   if (sub !== "messages" && sub !== "dm") return void 0;
   const word = hasCommandWord(args, CHAT_SEND_WORDS);
   if (!word) return void 0;
@@ -35280,16 +35480,34 @@ function registerChatTools(server) {
     return runOrDiagnose(args, { account });
   });
   server.registerTool("gog_chat_spaces_create", {
-    description: "Create a named Chat space, optionally seeding its membership. Members are added immediately and are notified \u2014 this is visible to other people the moment it runs, so confirm the member list before calling it." + workspaceOnlyNote,
+    description: "Create a named Chat space, optionally seeding its membership. Members are added immediately and are notified, so with members this asks the MCP host to show the user a confirmation prompt with the space name and every member first; nothing is created unless they accept. A space with no members reaches nobody and is created without asking." + CONFIRM_FALLBACK_DESCRIPTION + workspaceOnlyNote,
     annotations: { destructiveHint: true },
     inputSchema: external_exports.object({
       displayName: external_exports.string().describe("Display name for the new space"),
       members: external_exports.array(external_exports.string()).optional().describe('Initial members, as email addresses or "users/..." resource names'),
-      account: accountParam
+      account: accountParam,
+      confirmToken: confirmTokenParam
     })
-  }, async ({ displayName, members: members2, account }) => {
+  }, async ({ displayName, members: members2, account, confirmToken }, ctx) => {
     const args = ["chat", "spaces", "create", pos(displayName)];
     if (members2) for (const member of members2) args.push(`--member=${member}`);
+    if (members2?.length) {
+      const space = { displayName, members: members2 };
+      const confirmation = await requireDispatchConfirmation(ctx, {
+        action: "chat.space-create",
+        message: "Review and confirm this Chat space \u2014 every member is added and notified:",
+        confirmationLabel: "Confirm that these people should be added to a new space now.",
+        details: space,
+        unsupportedNote: "Create the space without members instead; the user can add people from Google Chat.",
+        fallback: {
+          tool: "gog_chat_spaces_create",
+          account,
+          confirmToken,
+          subject: () => ({ target: displayName, payload: space, preview: space })
+        }
+      });
+      if (confirmation) return confirmation;
+    }
     return runOrDiagnose(args, { account });
   });
   server.registerTool("gog_chat_threads_list", {
@@ -35483,20 +35701,85 @@ function registerChatTools(server) {
 
 // src/tools/classroom.ts
 var CLASSROOM_CREATE_WORDS = /* @__PURE__ */ new Set(["create", "add", "new"]);
-var CLASSROOM_GATED = {
-  announcements: { does: "posts to a class", tool: "gog_classroom_announcements_create" },
-  announcement: { does: "posts to a class", tool: "gog_classroom_announcements_create" },
-  ann: { does: "posts to a class", tool: "gog_classroom_announcements_create" },
-  invitations: { does: "invites someone to a class", tool: "gog_classroom_invitations_create" },
-  invitation: { does: "invites someone to a class", tool: "gog_classroom_invitations_create" },
-  invites: { does: "invites someone to a class", tool: "gog_classroom_invitations_create" }
+var CLASSROOM_DELETE_WORDS = /* @__PURE__ */ new Set(["delete", "rm", "del", "remove"]);
+var CLASSROOM_UPDATE_WORDS = /* @__PURE__ */ new Set(["update", "edit", "set"]);
+var CLASSROOM_RETURN_WORDS = /* @__PURE__ */ new Set(["return", "send"]);
+var CLASSROOM_ASSIGNEE_WORDS = /* @__PURE__ */ new Set(["assignees", "assign"]);
+var CLASSROOM_GROUPS = {
+  courses: "courses",
+  course: "courses",
+  announcements: "announcements",
+  announcement: "announcements",
+  ann: "announcements",
+  invitations: "invitations",
+  invitation: "invitations",
+  invites: "invitations",
+  coursework: "coursework",
+  work: "coursework",
+  materials: "materials",
+  material: "materials",
+  students: "students",
+  student: "students",
+  teachers: "teachers",
+  teacher: "teachers",
+  submissions: "submissions",
+  submission: "submissions",
+  "guardian-invitations": "guardian-invitations",
+  "guardian-invites": "guardian-invitations"
 };
+function publishesToStudents(args) {
+  return flagValue(args, "state")?.toUpperCase() === "PUBLISHED" || flagValue(args, "scheduled") !== void 0;
+}
+function createsVisibleWork(args) {
+  return flagValue(args, "state")?.toUpperCase() !== "DRAFT" || flagValue(args, "scheduled") !== void 0;
+}
+function widensAssignees(args) {
+  return flagValue(args, "mode")?.toUpperCase() === "ALL_STUDENTS" || flagValue(args, "add-student") !== void 0;
+}
 function vetClassroomRun(subcommand, args) {
   const sub = subcommand.toLowerCase();
-  const gated = Object.hasOwn(CLASSROOM_GATED, sub) ? CLASSROOM_GATED[sub] : void 0;
-  if (!gated) return void 0;
-  const word = hasCommandWord(args, CLASSROOM_CREATE_WORDS);
-  return word ? gatedElsewhere(`gog classroom ${sub} ${word.toLowerCase()}`, "gog_classroom_run", gated.does, gated.tool) : void 0;
+  if (!Object.hasOwn(CLASSROOM_GROUPS, sub)) return void 0;
+  const group = CLASSROOM_GROUPS[sub];
+  const via = "gog_classroom_run";
+  const what = (word) => `gog classroom ${sub} ${word.toLowerCase()}`;
+  const create = hasCommandWord(args, CLASSROOM_CREATE_WORDS);
+  const update = hasCommandWord(args, CLASSROOM_UPDATE_WORDS);
+  const remove = hasCommandWord(args, CLASSROOM_DELETE_WORDS);
+  const widenedAssignees = () => {
+    const word = hasCommandWord(args, CLASSROOM_ASSIGNEE_WORDS);
+    return word && widensAssignees(args) ? refusedInRun(what(word), via, "shows it to more students", "Ask the user to change who it is assigned to from Classroom.") : void 0;
+  };
+  switch (group) {
+    case "courses":
+      return remove ? gatedElsewhere(what(remove), via, "deletes a course", "gog_classroom_courses_delete") : void 0;
+    case "announcements":
+      if (create) return gatedElsewhere(what(create), via, "posts to a class", "gog_classroom_announcements_create");
+      if (update && publishesToStudents(args)) return gatedElsewhere(what(update), via, "publishes an announcement to a class", "gog_classroom_announcements_update");
+      return widenedAssignees();
+    case "invitations":
+      return create ? gatedElsewhere(what(create), via, "invites someone to a class", "gog_classroom_invitations_create") : void 0;
+    case "coursework":
+      if (create && createsVisibleWork(args)) return gatedElsewhere(what(create), via, "posts coursework to a class", "gog_classroom_coursework_create");
+      if (remove) return gatedElsewhere(what(remove), via, "deletes coursework and every submission to it", "gog_classroom_coursework_delete");
+      if (update && publishesToStudents(args)) return gatedElsewhere(what(update), via, "publishes work to students", "gog_classroom_coursework_update");
+      return widenedAssignees();
+    case "materials":
+      if (create && createsVisibleWork(args)) {
+        return refusedInRun(what(create), via, "publishes material to students", "Create it with --state=DRAFT and no --scheduled; ask the user to publish it from Classroom.");
+      }
+      if (update && publishesToStudents(args)) return refusedInRun(what(update), via, "publishes material to students", "Ask the user to publish it from Classroom.");
+      return void 0;
+    case "students":
+      return create ? gatedElsewhere(what(create), via, "enrols someone in a class", "gog_classroom_students_add") : void 0;
+    case "teachers":
+      return create ? gatedElsewhere(what(create), via, "gives someone a teacher's access to a class and its roster", "gog_classroom_teachers_add") : void 0;
+    case "submissions": {
+      const word = hasCommandWord(args, CLASSROOM_RETURN_WORDS);
+      return word ? gatedElsewhere(what(word), via, "returns work to a student, who is notified", "gog_classroom_submissions_return") : void 0;
+    }
+    case "guardian-invitations":
+      return create ? refusedInRun(what(create), via, "emails a guardian invitation", "Ask the user to invite the guardian from Classroom.") : void 0;
+  }
 }
 async function readCourse(courseId, account, runner = runOrDiagnose) {
   const got = await runner(["classroom", "courses", "get", pos(courseId)], { account });
@@ -35515,6 +35798,63 @@ async function readCourse(courseId, account, runner = runOrDiagnose) {
     }
   };
 }
+function nested(raw, key) {
+  try {
+    const parsed = JSON.parse(raw);
+    const inner = parsed?.[key];
+    return inner && typeof inner === "object" ? inner : void 0;
+  } catch {
+    return void 0;
+  }
+}
+var str = (v) => typeof v === "string" ? v : void 0;
+var num = (v) => typeof v === "number" ? v : void 0;
+async function readCoursework(courseId, courseworkId, account, runner = runOrDiagnose) {
+  const got = await runner(["classroom", "coursework", "get", pos(courseId), pos(courseworkId)], { account });
+  if (got.isError) return { error: got };
+  const work = nested(resultText(got), "coursework");
+  const title = str(work?.title);
+  return { coursework: { id: courseworkId, ...title !== void 0 ? { title } : {} } };
+}
+async function readClassroomWork(kind, courseId, itemId, account, runner = runOrDiagnose) {
+  const got = await runner(["classroom", kind, "get", pos(courseId), pos(itemId)], { account });
+  if (got.isError) return { error: got };
+  const item = nested(resultText(got), kind === "announcements" ? "announcement" : "coursework");
+  const work = { id: itemId };
+  for (const key of ["text", "title", "description", "state", "updateTime"]) {
+    const value = str(item?.[key]);
+    if (value !== void 0) work[key] = value;
+  }
+  return { work };
+}
+async function readSubmission(courseId, courseworkId, submissionId, account, runner = runOrDiagnose) {
+  const got = await runner(["classroom", "submissions", "get", pos(courseId), pos(courseworkId), pos(submissionId)], { account });
+  if (got.isError) return { error: got };
+  const sub = nested(resultText(got), "submission");
+  const fields = {
+    student: str(sub?.userId),
+    state: str(sub?.state),
+    draftGrade: num(sub?.draftGrade),
+    assignedGrade: num(sub?.assignedGrade)
+  };
+  const updateTime = str(sub?.updateTime);
+  return {
+    submission: {
+      id: submissionId,
+      ...Object.fromEntries(Object.entries(fields).filter(([, v]) => v !== void 0))
+    },
+    ...updateTime !== void 0 ? { updateTime } : {}
+  };
+}
+async function studentLabel(courseId, userId, account, runner = runOrDiagnose) {
+  const got = await runner(["classroom", "students", "get", pos(courseId), pos(userId)], { account });
+  if (got.isError) return userId;
+  const profile = nested(resultText(got), "student")?.profile;
+  const name = str(profile?.name?.fullName);
+  const email3 = str(profile?.emailAddress);
+  if (name && email3) return `${name} <${email3}>`;
+  return name ?? email3 ?? userId;
+}
 function registerClassroomTools(server) {
   server.registerTool("gog_classroom_courses_list", {
     description: "List Google Classroom courses.",
@@ -35727,15 +36067,38 @@ function registerClassroomTools(server) {
     return runOrDiagnose(args, { account });
   });
   server.registerTool("gog_classroom_submissions_return", {
-    description: "Return a graded submission to the student.",
+    description: "Return a graded submission to the student, who is notified and sees the grade. Reads the course, the coursework and the submission and asks the MCP host to show the user a confirmation prompt with the class, the assignment, the student and the grade being returned; nothing is returned unless they accept." + CONFIRM_FALLBACK_DESCRIPTION,
     annotations: { destructiveHint: true },
     inputSchema: external_exports.object({
       courseId: external_exports.string().describe("Course ID"),
       courseworkId: external_exports.string().describe("Coursework ID"),
       submissionId: external_exports.string().describe("Submission ID"),
-      account: accountParam
+      account: accountParam,
+      confirmToken: confirmTokenParam
     })
-  }, async ({ courseId, courseworkId, submissionId, account }) => {
+  }, async ({ courseId, courseworkId, submissionId, account, confirmToken }, ctx) => {
+    const course = await readCourse(courseId, account);
+    if (course.error) return course.error;
+    const work = await readCoursework(courseId, courseworkId, account);
+    if (work.error) return work.error;
+    const sub = await readSubmission(courseId, courseworkId, submissionId, account);
+    if (sub.error) return sub.error;
+    const submission = sub.submission.student ? { ...sub.submission, student: await studentLabel(courseId, sub.submission.student, account) } : sub.submission;
+    const view = { course: course.course, coursework: work.coursework, submission };
+    const confirmation = await requireDispatchConfirmation(ctx, {
+      action: "classroom.submission-return",
+      message: "Review and confirm returning this work \u2014 the student is notified and sees the grade:",
+      confirmationLabel: "Confirm that this submission should be returned to the student now.",
+      details: view,
+      unsupportedNote: "Ask the user to return it from Classroom.",
+      fallback: {
+        tool: "gog_classroom_submissions_return",
+        account,
+        confirmToken,
+        subject: () => ({ target: `${courseId}/${courseworkId}/${submissionId}`, revision: sub.updateTime, payload: view, preview: view })
+      }
+    });
+    if (confirmation) return confirmation;
     return runOrDiagnose(["classroom", "submissions", "return", pos(courseId), pos(courseworkId), pos(submissionId)], { account });
   });
   server.registerTool("gog_classroom_submissions_turn_in", {
@@ -35797,13 +36160,13 @@ function registerClassroomTools(server) {
     return runOrDiagnose(["classroom", "announcements", "get", pos(courseId), pos(announcementId)], { account });
   });
   server.registerTool("gog_classroom_announcements_create", {
-    description: "Create an announcement in a Google Classroom course. Unless state is DRAFT (which students cannot see), this reads the course and asks the MCP host to show the user a confirmation prompt with the class, the full text and when it publishes; nothing is posted unless they accept. To stage one without asking, pass state DRAFT." + CONFIRM_FALLBACK_DESCRIPTION,
+    description: "Create an announcement in a Google Classroom course. Unless state is DRAFT with no scheduled time (which students cannot see; a scheduled draft publishes itself), this reads the course and asks the MCP host to show the user a confirmation prompt with the class, the full text and when it publishes; nothing is posted unless they accept. To stage one without asking, pass state DRAFT and no scheduled time." + CONFIRM_FALLBACK_DESCRIPTION,
     annotations: { destructiveHint: true },
     inputSchema: external_exports.object({
       courseId: external_exports.string().describe("Course ID"),
       text: external_exports.string().describe("Announcement text"),
-      state: external_exports.enum(["PUBLISHED", "DRAFT"]).optional().describe("State (DRAFT is visible only to teachers and needs no confirmation)"),
-      scheduled: external_exports.string().optional().describe("Scheduled publish time"),
+      state: external_exports.enum(["PUBLISHED", "DRAFT"]).optional().describe("State (an unscheduled DRAFT is visible only to teachers and needs no confirmation)"),
+      scheduled: external_exports.string().optional().describe("Scheduled publish time (asks the user to confirm, even for a DRAFT)"),
       account: accountParam,
       confirmToken: confirmTokenParam
     })
@@ -35811,7 +36174,7 @@ function registerClassroomTools(server) {
     const args = ["classroom", "announcements", "create", pos(courseId), `--text=${text}`];
     if (state) args.push(`--state=${state}`);
     if (scheduled) args.push(`--scheduled=${scheduled}`);
-    if (state !== "DRAFT") {
+    if (state !== "DRAFT" || scheduled) {
       const read = await readCourse(courseId, account);
       if (read.error) return read.error;
       const publishes = scheduled ? `at ${scheduled}` : "immediately";
@@ -35983,6 +36346,9 @@ function registerContactsTools(server) {
 }
 
 // src/tools/docs.ts
+function vetDocsRun(subcommand, args) {
+  return vetCommentsRun("docs", subcommand, args);
+}
 function registerDocsTools(server) {
   server.registerTool("gog_docs_info", {
     description: "Get Google Doc metadata: title, ID, and other properties.",
@@ -36079,12 +36445,29 @@ function registerDocsTools(server) {
   }, async ({ docId, account }) => {
     return runOrDiagnose(["docs", "structure", pos(docId)], { account });
   });
-  registerRunTool(server, { service: "docs", examples: '"copy", "clear", "insert", "sed", "export"' });
+  registerRunTool(server, { service: "docs", examples: '"copy", "clear", "insert", "sed", "export"', vet: vetDocsRun });
 }
 
 // src/tools/drive.ts
-function vetDriveRun(subcommand, _args) {
-  return subcommand.toLowerCase() === "share" ? gatedElsewhere("gog drive share", "gog_drive_run", "grants access to a file", "gog_drive_share") : void 0;
+var DRIVE_DELETE_WORDS = /* @__PURE__ */ new Set(["delete", "rm", "del"]);
+function vetDriveRun(subcommand, args) {
+  const sub = subcommand.toLowerCase();
+  if (sub === "share") return gatedElsewhere("gog drive share", "gog_drive_run", "grants access to a file", "gog_drive_share");
+  if (DRIVE_DELETE_WORDS.has(sub) && hasTrueFlag(args, "permanent")) {
+    return gatedElsewhere(`gog drive ${sub} --permanent`, "gog_drive_run", "deletes a file for good, bypassing the trash", "gog_drive_delete");
+  }
+  if (sub === "bulk") {
+    return gatedElsewhere(
+      "gog drive bulk",
+      "gog_drive_run",
+      "rewrites sharing permissions across every matching file in a tree",
+      "gog_drive_share (one file at a time)"
+    );
+  }
+  if (sub === "unshare") {
+    return refusedInRun("gog drive unshare", "gog_drive_run", "removes someone's access to a file", "Use gog_drive_unshare.");
+  }
+  return vetCommentsRun("drive", sub, args);
 }
 var GOOGLE_DOC_MIME = "application/vnd.google-apps.document";
 function shareTargetMeta(raw) {
@@ -36095,6 +36478,26 @@ function shareTargetMeta(raw) {
     return {};
   }
 }
+function commentSnapshot(raw) {
+  let comment;
+  try {
+    const parsed = JSON.parse(raw);
+    comment = parsed?.comment ?? parsed ?? void 0;
+  } catch {
+    comment = void 0;
+  }
+  const name = typeof comment?.author?.displayName === "string" ? comment.author.displayName : void 0;
+  const email3 = typeof comment?.author?.emailAddress === "string" ? comment.author.emailAddress : void 0;
+  const author = name && email3 ? `${name} <${email3}>` : name ?? email3;
+  return {
+    ...author ? { author } : {},
+    ...typeof comment?.content === "string" ? { content: comment.content } : {},
+    ...typeof comment?.resolved === "boolean" ? { resolved: comment.resolved } : {}
+  };
+}
+function commentMentions(text) {
+  return [...new Set(text.match(/(?<=[+@])[\w.+-]+@[\w-]+(?:\.[\w-]+)+/g) ?? [])];
+}
 function fileMeta(raw) {
   const parsed = JSON.parse(raw);
   const f = parsed.file ?? parsed;
@@ -36203,16 +36606,36 @@ function registerDriveTools(server) {
     return runOrDiagnose(["drive", "move", pos(fileId), `--parent=${parentId}`], { account });
   });
   server.registerTool("gog_drive_delete", {
-    description: "Move a Google Drive file to trash, or permanently delete it with permanent=true (irreversible).",
+    description: "Move a Google Drive file to trash, or permanently delete it with permanent=true (irreversible). A permanent delete reads the file and asks the MCP host to show the user a confirmation prompt naming it first; nothing is deleted unless they accept. Moving to trash is recoverable and does not ask." + CONFIRM_FALLBACK_DESCRIPTION,
     annotations: { destructiveHint: true },
     inputSchema: external_exports.object({
       fileId: external_exports.string().describe("File ID to delete"),
-      permanent: external_exports.boolean().optional().describe("Permanently delete instead of moving to trash (irreversible)"),
-      account: accountParam
+      permanent: external_exports.boolean().optional().describe("Permanently delete instead of moving to trash (irreversible; asks the user first)"),
+      account: accountParam,
+      confirmToken: confirmTokenParam
     })
-  }, async ({ fileId, permanent, account }) => {
+  }, async ({ fileId, permanent, account, confirmToken }, ctx) => {
     const args = ["drive", "delete", pos(fileId)];
-    if (permanent) args.push("--permanent");
+    if (permanent) {
+      const got = await runOrDiagnose(["drive", "get", pos(fileId)], { account });
+      if (got.isError) return got;
+      const target = { file: { id: fileId, ...shareTargetMeta(resultText(got)) }, permanent: true };
+      const confirmation = await requireDispatchConfirmation(ctx, {
+        action: "drive.delete-permanent",
+        message: "Review and confirm PERMANENTLY deleting this file \u2014 it skips the trash and cannot be recovered:",
+        confirmationLabel: "Confirm that this file should be permanently deleted now.",
+        details: target,
+        unsupportedNote: "Move it to the trash instead (permanent=false); the user can empty the trash from Google Drive.",
+        fallback: {
+          tool: "gog_drive_delete",
+          account,
+          confirmToken,
+          subject: () => ({ target: fileId, payload: target, preview: target })
+        }
+      });
+      if (confirmation) return confirmation;
+      args.push("--permanent");
+    }
     args.push("--force");
     return runOrDiagnose(args, { account });
   });
@@ -36538,18 +36961,22 @@ function trustedDomains(account) {
 }
 function logGmailDispatch(tool, recipients, account) {
   const domains = trustedDomains(account);
-  const externalRecipients = recipients.filter((recipient) => {
+  const externalDomains = /* @__PURE__ */ new Set();
+  let externalRecipientCount = 0;
+  for (const recipient of recipients) {
     const at = recipient.indexOf("@");
-    const domain2 = at > -1 ? recipient.slice(at + 1) : "";
-    return !domain2 || !domains.has(domain2);
-  });
+    const domain2 = at > -1 ? recipient.slice(at + 1).toLowerCase() : "";
+    if (domain2 && domains.has(domain2)) continue;
+    externalRecipientCount += 1;
+    externalDomains.add(domain2 || "(no domain)");
+  }
   const event = {
     event: "gmail_dispatch",
     tool,
     recipientCount: recipients.length,
-    externalRecipientCount: externalRecipients.length,
-    hasExternalRecipients: externalRecipients.length > 0,
-    externalRecipients,
+    externalRecipientCount,
+    hasExternalRecipients: externalRecipientCount > 0,
+    externalDomains: [...externalDomains].sort(),
     timestamp: (/* @__PURE__ */ new Date()).toISOString()
   };
   process.stderr.write(`${JSON.stringify(event)}
@@ -36716,6 +37143,39 @@ async function sendReply(kind, toolName, messageId, account, flags, ctx, confirm
   return result;
 }
 var GMAIL_RUN_BLOCKED_SETTINGS = /* @__PURE__ */ new Set(["forwarding", "autoforward", "filters", "delegates"]);
+var GMAIL_DELETE_WORDS = /* @__PURE__ */ new Set(["delete", "rm", "del", "remove"]);
+var GMAIL_CREATE_WORDS = /* @__PURE__ */ new Set(["create", "add", "new"]);
+var GMAIL_UPDATE_WORDS = /* @__PURE__ */ new Set(["update", "edit", "set"]);
+var SENDAS = /* @__PURE__ */ new Set(["sendas"]);
+var VACATION = /* @__PURE__ */ new Set(["vacation"]);
+function vetGmailGatedRun(sub, args) {
+  if (sub === "batch") {
+    const word = hasCommandWord(args, GMAIL_DELETE_WORDS);
+    return word ? gatedElsewhere(`gog gmail batch ${word.toLowerCase()}`, "gog_gmail_run", "deletes mail for good, bypassing the Trash", "gog_gmail_batch_delete") : void 0;
+  }
+  if (sub !== "settings" && sub !== "sendas" && sub !== "vacation") return void 0;
+  const words = sub === "settings" ? args : [sub, ...args];
+  if (hasCommandWord(words, SENDAS)) {
+    const word = hasCommandWord(args, GMAIL_CREATE_WORDS);
+    if (word) {
+      return gatedElsewhere(
+        `gog gmail sendas ${word.toLowerCase()}`,
+        "gog_gmail_run",
+        "makes Google email the address and adds a sending identity",
+        "gog_gmail_sendas_create"
+      );
+    }
+  }
+  if (hasCommandWord(words, VACATION) && hasCommandWord(args, GMAIL_UPDATE_WORDS) && hasTrueFlag(args, "enable")) {
+    return gatedElsewhere(
+      "gog gmail vacation update --enable",
+      "gog_gmail_run",
+      "turns on an auto-reply to every sender",
+      "gog_gmail_vacation_update"
+    );
+  }
+  return void 0;
+}
 function vetGmailRun(subcommand, args) {
   if (subcommand === "autoreply") {
     return "gog gmail autoreply sends mail and is not available through gog_gmail_run. Use gog_gmail_autoreply, which asks the user to confirm.";
@@ -36723,6 +37183,8 @@ function vetGmailRun(subcommand, args) {
   if (GMAIL_RUN_BLOCKED_SETTINGS.has(subcommand)) {
     return `gog gmail ${subcommand} can forward or hand over mail and is not available through gog_gmail_run. Use the dedicated gog_gmail_* tool instead.`;
   }
+  const gated = vetGmailGatedRun(subcommand.toLowerCase(), args);
+  if (gated) return gated;
   if (subcommand === "settings") {
     const blocked = hasCommandWord(args, GMAIL_RUN_BLOCKED_SETTINGS);
     if (blocked) {
@@ -36934,6 +37396,13 @@ function countNonEmptyCells(getOutput) {
 }
 
 // src/tools/sheets.ts
+var DATASOURCE_ALIASES = /* @__PURE__ */ new Set(["datasource", "data-source", "data-sources", "connected-sheets"]);
+var DATASOURCE_BILLED = /* @__PURE__ */ new Set(["add", "update", "refresh"]);
+function vetSheetsRun(subcommand, args) {
+  if (!DATASOURCE_ALIASES.has(subcommand.toLowerCase())) return void 0;
+  const word = hasCommandWord(args, DATASOURCE_BILLED)?.toLowerCase();
+  return word ? gatedElsewhere(`gog sheets datasource ${word}`, "gog_sheets_run", "runs a billed BigQuery job", `gog_sheets_datasource_${word}`) : void 0;
+}
 var cellValueParam = external_exports.union([external_exports.string(), external_exports.number(), external_exports.boolean(), external_exports.null()]);
 var dryRunParam = external_exports.boolean().optional().describe(
   "Preview the operation without modifying the sheet (gog --dry-run): reports the intended actions and exits without writing."
@@ -37049,7 +37518,7 @@ function registerSheetsTools(server) {
   }, async ({ spreadsheetId, find, replace, account }) => {
     return runOrDiagnose(["sheets", "find-replace", pos(spreadsheetId), pos(find), pos(replace)], { account });
   });
-  registerRunTool(server, { service: "sheets", examples: '"freeze", "add-tab", "rename-tab"' });
+  registerRunTool(server, { service: "sheets", examples: '"freeze", "add-tab", "rename-tab"', vet: vetSheetsRun });
 }
 
 // src/tools/slides.ts
@@ -37213,7 +37682,7 @@ function registerTasksTools(server) {
 }
 
 // src/server.ts
-var VERSION = true ? "4.5.0" : "0.0.0";
+var VERSION = true ? "4.5.2" : "0.0.0";
 var BASE_TOOL_REGISTRARS = [
   registerApiTools,
   registerAppScriptTools,
@@ -37515,6 +37984,8 @@ export {
   blobStoreFromEnv,
   bodyPreview,
   bootstrapGogAuth,
+  commentMentions,
+  commentSnapshot,
   confineAtFile,
   confinePath,
   confinePaths,
@@ -37523,6 +37994,7 @@ export {
   defaultFileRoot,
   diagnose,
   errorText,
+  eventSnapshot,
   extractEmails,
   fetchGmailPages,
   fileRoots,
@@ -37537,11 +38009,14 @@ export {
   pageAliasParam,
   pageTokenParam,
   paginationParams,
+  parseMetadataHeaders,
   payloadArg,
   pos,
   prepareDownloadRoot,
   pushPaginationFlags,
+  readClassroomWork,
   readCourse,
+  readCoursework,
   registerApiTools,
   registerAppScriptTools,
   registerAuthTools,
@@ -37566,12 +38041,14 @@ export {
   runBinary,
   runOrDiagnose,
   senderPreview,
+  shareTargetMeta,
   stripConsumedPageToken,
+  studentLabel,
   uploadToBlobStore
 };
 /*! Bundled license information:
 
-@modelcontextprotocol/server/dist/src-CX2iR2pK.mjs:
+@modelcontextprotocol/server/dist/src-D-y6h4N7.mjs:
   (*!
   * content-type
   * Copyright(c) 2015 Douglas Christopher Wilson