gogcli-mcp 4.4.0 → 4.5.1

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++;
     }
@@ -25182,7 +25182,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 +25193,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 +25226,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 +26105,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 +27005,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 +27898,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 +28415,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 +29121,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 +31841,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 +31857,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 +31895,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 +31917,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 +31937,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;
@@ -33017,10 +33017,8 @@ function errorResult(message) {
 
 // ../../node_modules/@chrischall/mcp-utils/dist/server/confirmation.js
 import { createHash, createHmac, timingSafeEqual } from "node:crypto";
-var DEFAULT_REQUEST_KEY = "confirmation";
-var DEFAULT_CONFIRMATION_LABEL = "Confirm this action should proceed.";
-var UNSUPPORTED_NOTE = "Nothing was done because this client cannot show a confirmation prompt (it declares no MCP elicitation capability), and this action is never taken without one";
-var STATE_PREFIX = "mcpu.confirm.v1.";
+
+// ../../node_modules/@chrischall/mcp-utils/dist/server/canonical.js
 function canonicalJson(value) {
   if (value === null || typeof value === "string" || typeof value === "boolean")
     return JSON.stringify(value);
@@ -33031,7 +33029,7 @@ function canonicalJson(value) {
   if (typeof value === "bigint")
     return `{"$bigint":"${value.toString()}"}`;
   if (typeof value === "function" || typeof value === "symbol") {
-    throw new TypeError(`requireConfirmation: cannot bind a ${typeof value} argument value.`);
+    throw new TypeError(`confirmation: cannot bind a ${typeof value} argument value.`);
   }
   if (Array.isArray(value))
     return `[${value.map(canonicalJson).join(",")}]`;
@@ -33053,7 +33051,7 @@ function canonicalJson(value) {
   }
   const proto = Object.getPrototypeOf(value);
   if (proto !== Object.prototype && proto !== null) {
-    throw new TypeError("requireConfirmation: cannot bind a non-plain object argument value (class instance).");
+    throw new TypeError("confirmation: cannot bind a non-plain object argument value (class instance).");
   }
   const entries = Object.entries(value).filter(([, v]) => v !== void 0).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
   return `{${entries.map(([k, v]) => `${JSON.stringify(escapeKey(k))}:${canonicalJson(v)}`).join(",")}}`;
@@ -33061,6 +33059,12 @@ function canonicalJson(value) {
 function escapeKey(key) {
   return key.startsWith("$") ? `$${key}` : key;
 }
+
+// ../../node_modules/@chrischall/mcp-utils/dist/server/confirmation.js
+var DEFAULT_REQUEST_KEY = "confirmation";
+var DEFAULT_CONFIRMATION_LABEL = "Confirm this action should proceed.";
+var UNSUPPORTED_NOTE = "Nothing was done because this client cannot show a confirmation prompt (it declares no MCP elicitation capability), and this action is never taken without one";
+var STATE_PREFIX = "mcpu.confirm.v1.";
 function bindingKey(binding) {
   if (binding.ttlSeconds !== void 0 && !(Number.isFinite(binding.ttlSeconds) && binding.ttlSeconds > 0)) {
     throw new RangeError("requireConfirmation: binding.ttlSeconds must be a finite number greater than 0.");
@@ -33163,11 +33167,169 @@ ${JSON.stringify(preview, null, 2)}`,
   });
 }
 
-// ../../node_modules/@chrischall/mcp-utils/dist/server/index.js
-var SERVER_PROTOCOL_VERSIONS = Object.freeze([
-  "2026-07-28",
-  ...SUPPORTED_PROTOCOL_VERSIONS
-]);
+// ../../node_modules/@chrischall/mcp-utils/dist/server/confirm-token.js
+import { createHash as createHash2, createHmac as createHmac2, randomBytes, timingSafeEqual as timingSafeEqual2 } from "node:crypto";
+function createSpentTokenStore() {
+  const spent2 = /* @__PURE__ */ new Map();
+  return {
+    has: (nonce) => spent2.has(nonce),
+    add: (nonce, exp) => {
+      spent2.set(nonce, exp);
+    },
+    prune: (now) => {
+      for (const [nonce, exp] of spent2)
+        if (exp < now)
+          spent2.delete(nonce);
+    },
+    clear: () => spent2.clear(),
+    get size() {
+      return spent2.size;
+    }
+  };
+}
+var PROCESS_SPENT = createSpentTokenStore();
+var PREFIX = "mcpu.token.v1.";
+var DEFAULT_TTL_SECONDS = 600;
+function tokenKey(key) {
+  const bytes = typeof key === "string" ? Buffer.from(key, "utf8") : Buffer.from(key);
+  if (bytes.length < 32)
+    throw new RangeError("confirm token: key must be at least 32 bytes.");
+  return bytes;
+}
+function ttlOf(ttlSeconds) {
+  if (ttlSeconds === void 0)
+    return DEFAULT_TTL_SECONDS;
+  if (!(Number.isFinite(ttlSeconds) && ttlSeconds > 0)) {
+    throw new RangeError("confirm token: ttlSeconds must be a finite number greater than 0.");
+  }
+  return ttlSeconds;
+}
+function sign(key, body) {
+  return createHmac2("sha256", key).update(`${PREFIX}${body}`).digest();
+}
+function hashConfirmPayload(payload) {
+  return createHash2("sha256").update(canonicalJson(payload)).digest("base64url");
+}
+function issueConfirmToken(key, binding, options = {}) {
+  const k = tokenKey(key);
+  const now = options.now ?? Date.now();
+  const exp = now + ttlOf(options.ttlSeconds) * 1e3;
+  const claims = {
+    t: binding.tool,
+    ...binding.account === void 0 ? {} : { a: binding.account },
+    g: binding.target,
+    ...binding.revision === void 0 ? {} : { r: binding.revision },
+    h: binding.payloadHash,
+    exp,
+    n: randomBytes(16).toString("base64url")
+  };
+  const body = Buffer.from(JSON.stringify(claims), "utf8").toString("base64url");
+  return { token: `${PREFIX}${body}.${sign(k, body).toString("base64url")}`, expiresAt: new Date(exp).toISOString() };
+}
+function parseClaims(body) {
+  try {
+    const claims = JSON.parse(Buffer.from(body, "base64url").toString("utf8"));
+    return claims && typeof claims === "object" ? claims : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function verifyConfirmToken(key, token, binding, options = {}) {
+  const k = tokenKey(key);
+  const now = options.now ?? Date.now();
+  const spent2 = options.spent ?? PROCESS_SPENT;
+  spent2.prune(now);
+  if (!token.startsWith(PREFIX))
+    return { ok: false, error: "TOKEN_INVALID" };
+  const rest = token.slice(PREFIX.length);
+  const dot = rest.indexOf(".");
+  const body = dot < 0 ? "" : rest.slice(0, dot);
+  const mac3 = Buffer.from(dot < 0 ? "" : rest.slice(dot + 1), "base64url");
+  const expected = sign(k, body);
+  if (!body || mac3.length !== expected.length || !timingSafeEqual2(mac3, expected))
+    return { ok: false, error: "TOKEN_INVALID" };
+  const claims = parseClaims(body);
+  if (!claims)
+    return { ok: false, error: "TOKEN_INVALID" };
+  if (claims.t !== binding.tool || claims.a !== binding.account || claims.g !== binding.target) {
+    return { ok: false, error: "TOKEN_INVALID" };
+  }
+  if (spent2.has(claims.n))
+    return { ok: false, error: "TOKEN_REUSED" };
+  if (now > claims.exp)
+    return { ok: false, error: "TOKEN_EXPIRED" };
+  if (claims.r !== binding.revision)
+    return { ok: false, error: "DRAFT_CHANGED", reason: "revision-changed" };
+  if (claims.h !== binding.payloadHash)
+    return { ok: false, error: "DRAFT_CHANGED", reason: "payload-changed" };
+  spent2.add(claims.n, claims.exp);
+  return { ok: true };
+}
+var CONFIRM_TOKEN_INSTRUCTION = "Show this preview to the user verbatim and proceed only after they explicitly approve in chat. Then call again with confirmToken.";
+var confirmTokenParam = external_exports.string().optional().describe(`ONLY for the two-step confirmation fallback (a client without MCP elicitation). The confirmToken from this same tool's phase-1 "confirmation-required" response, passed back ONLY after the user has seen that preview and explicitly approved it in chat \u2014 never on the first call, never invented, never reused. Call again with the same arguments. Ignored when the client supports elicitation.`);
+var TOKEN_ERROR_NOTE = {
+  TOKEN_EXPIRED: "Nothing was sent or changed: the confirmToken expired. Call again WITHOUT confirmToken for a fresh preview, and ask the user to approve it again.",
+  TOKEN_REUSED: "Nothing was sent or changed by this call: this confirmToken was already used, and one approval acts once. If doing it again is really intended, call again WITHOUT confirmToken and get a new approval.",
+  TOKEN_INVALID: "Nothing was sent or changed: this confirmToken was not issued by this server for this tool, account and target (or the server has restarted since). Call again WITHOUT confirmToken for a fresh preview and approval."
+};
+var CHANGED_NOTE = {
+  "revision-changed": "Nothing was sent or changed: the target was edited since the user approved it (its version rotated), so what would happen is not what they saw.",
+  "payload-changed": "Nothing was sent or changed: what would happen no longer matches what the user approved."
+};
+function isToolResult(value) {
+  return Array.isArray(value.content);
+}
+function rejection(data) {
+  return { ...textResult({ status: "confirmation-rejected", confirmed: false, dispatched: false, ...data }), isError: true };
+}
+async function tokenConfirmation(action, fb) {
+  const subject = await fb.subject();
+  if (isToolResult(subject))
+    return subject;
+  const binding = {
+    tool: fb.tool,
+    ...fb.account === void 0 ? {} : { account: fb.account },
+    target: subject.target,
+    ...subject.revision === void 0 ? {} : { revision: subject.revision },
+    payloadHash: hashConfirmPayload(subject.payload)
+  };
+  const phaseOne = () => {
+    const { token, expiresAt } = issueConfirmToken(fb.key, binding, { ttlSeconds: fb.ttlSeconds });
+    return {
+      action,
+      preview: subject.preview,
+      confirmToken: token,
+      expiresAt,
+      ttlSeconds: ttlOf(fb.ttlSeconds),
+      instruction: fb.instruction ?? CONFIRM_TOKEN_INSTRUCTION
+    };
+  };
+  if (!fb.confirmToken) {
+    return textResult({ status: "confirmation-required", confirmed: false, dispatched: false, ...phaseOne() });
+  }
+  const verdict = verifyConfirmToken(fb.key, fb.confirmToken, binding, { spent: fb.spent });
+  if (verdict.ok)
+    return void 0;
+  if (verdict.error === "DRAFT_CHANGED") {
+    return rejection({
+      error: "DRAFT_CHANGED",
+      reason: verdict.reason,
+      note: `${CHANGED_NOTE[verdict.reason]} The current preview and a fresh confirmToken are below.`,
+      ...phaseOne()
+    });
+  }
+  return rejection({ error: verdict.error, action, note: TOKEN_ERROR_NOTE[verdict.error] });
+}
+async function requireConfirmationWithFallback(ctx, options) {
+  const { tokenFallback, ...confirmation } = options;
+  if (tokenFallback && callerAcceptsFormElicitation(ctx) === false) {
+    return tokenConfirmation(options.action, tokenFallback);
+  }
+  return requireConfirmation(ctx, confirmation);
+}
+
+// ../../node_modules/@chrischall/mcp-utils/dist/server/confirm-env.js
+import { createHash as createHash3, randomBytes as randomBytes2 } from "node:crypto";
 
 // ../../node_modules/@chrischall/mcp-utils/dist/config/index.js
 import { homedir } from "node:os";
@@ -33208,6 +33370,67 @@ function expandPath(p) {
   return isAbsolute(expanded) ? expanded : resolve(expanded);
 }
 
+// ../../node_modules/@chrischall/mcp-utils/dist/server/confirm-env.js
+var MODES = /* @__PURE__ */ new Set(["ask-user", "auto", "refuse"]);
+var DEFAULT_TTL_SECONDS2 = 600;
+var warned = /* @__PURE__ */ new Set();
+function readConfirmMode(env = process.env) {
+  const raw = readEnvVar("MCP_CONFIRM_MODE", { env })?.trim().toLowerCase();
+  if (!raw)
+    return "ask-user";
+  if (MODES.has(raw))
+    return raw;
+  if (!warned.has(raw)) {
+    warned.add(raw);
+    process.stderr.write(`MCP_CONFIRM_MODE="${raw}" is not one of ask-user, auto, refuse; treating it as refuse.
+`);
+  }
+  return "refuse";
+}
+function confirmTtlFromEnv(env = process.env) {
+  const raw = readEnvVar("MCP_CONFIRM_TTL_SECONDS", { env })?.trim();
+  return raw && /^[1-9]\d*$/.test(raw) ? Number(raw) : DEFAULT_TTL_SECONDS2;
+}
+var processKey;
+function confirmKeyFromEnv(env = process.env) {
+  const secret = readEnvVar("MCP_CONFIRM_SECRET", { env });
+  if (secret)
+    return createHash3("sha256").update(secret, "utf8").digest();
+  processKey ??= randomBytes2(32);
+  return processKey;
+}
+var CONFIRM_TOKEN_AUTO_INSTRUCTION = "Nothing has been done yet. Review this preview; if it is what was intended, call again with the same arguments plus confirmToken. (This server runs with MCP_CONFIRM_MODE=auto, so the user's approval in chat is not required.)";
+var REFUSE_HINT = "Set MCP_CONFIRM_MODE=ask-user on the server to allow two-step confirmation instead.";
+function confirmationFromEnv(options) {
+  const { tool, account, confirmToken, subject, instruction, spent: spent2, env = process.env, ...confirmation } = options;
+  const mode = readConfirmMode(env);
+  if (mode === "refuse") {
+    return {
+      ...confirmation,
+      unsupportedNote: confirmation.unsupportedNote ? `${confirmation.unsupportedNote} ${REFUSE_HINT}` : REFUSE_HINT
+    };
+  }
+  return {
+    ...confirmation,
+    tokenFallback: {
+      key: confirmKeyFromEnv(env),
+      tool,
+      ...account === void 0 ? {} : { account },
+      ...confirmToken === void 0 ? {} : { confirmToken },
+      subject,
+      ttlSeconds: confirmTtlFromEnv(env),
+      instruction: mode === "auto" ? CONFIRM_TOKEN_AUTO_INSTRUCTION : instruction ?? CONFIRM_TOKEN_INSTRUCTION,
+      ...spent2 === void 0 ? {} : { spent: spent2 }
+    }
+  };
+}
+
+// ../../node_modules/@chrischall/mcp-utils/dist/server/index.js
+var SERVER_PROTOCOL_VERSIONS = Object.freeze([
+  "2026-07-28",
+  ...SUPPORTED_PROTOCOL_VERSIONS
+]);
+
 // ../../node_modules/@chrischall/mcp-utils/dist/fs/confine.js
 import { existsSync, realpathSync } from "node:fs";
 import { dirname, isAbsolute as isAbsolute2, relative, resolve as resolve2, sep } from "node:path";
@@ -34104,6 +34327,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}
@@ -34200,95 +34424,13 @@ function assertNotBoth(inlineParam, fileParam, inlineValue, fileValue) {
 }
 
 // src/dispatch-confirmation.ts
-import { createHash as createHash3 } from "node:crypto";
+import { createHash as createHash4 } from "node:crypto";
 import { readFileSync } from "node:fs";
 
 // src/send-confirm-token.ts
-import { createHash as createHash2, createHmac as createHmac2, randomBytes, timingSafeEqual as timingSafeEqual2 } from "node:crypto";
-var CONFIRM_TOKEN_TTL_DEFAULT_SECONDS = 600;
-var PREFIX = "gct1";
-var secret;
-var spent = /* @__PURE__ */ new Map();
-function sendConfirmFallbackEnabled() {
-  return readEnvVar("GOG_SEND_CONFIRM_FALLBACK")?.trim().toLowerCase() === "token";
-}
-function confirmTokenTtlSeconds() {
-  const raw = readEnvVar("GOG_CONFIRM_TTL_SECONDS")?.trim();
-  if (raw && /^\d+$/.test(raw)) {
-    const n = Number(raw);
-    if (n > 0) return n;
-  }
-  return CONFIRM_TOKEN_TTL_DEFAULT_SECONDS;
-}
-function hmacKey() {
-  if (!secret) {
-    const configured = readEnvVar("GOG_CONFIRM_SECRET");
-    secret = configured ? Buffer.from(configured, "utf8") : randomBytes(32);
-  }
-  return secret;
-}
-function canonicalize(value) {
-  if (Array.isArray(value)) return value.map(canonicalize);
-  if (value && typeof value === "object") {
-    const out = {};
-    for (const key of Object.keys(value).sort()) {
-      const v = value[key];
-      if (v !== void 0) out[key] = canonicalize(v);
-    }
-    return out;
-  }
-  return value;
-}
-function hashSendPayload(payload) {
-  return createHash2("sha256").update(JSON.stringify(canonicalize(payload))).digest("hex");
-}
-function sign(body) {
-  return createHmac2("sha256", hmacKey()).update(`${PREFIX}.${body}`).digest("base64url");
-}
-function issueConfirmToken(binding, now = Date.now()) {
-  const exp = now + confirmTokenTtlSeconds() * 1e3;
-  const claims = {
-    t: binding.tool,
-    a: binding.account,
-    g: binding.target,
-    ...binding.revision === void 0 ? {} : { r: binding.revision },
-    h: binding.payloadHash,
-    iat: now,
-    exp,
-    n: randomBytes(16).toString("base64url")
-  };
-  const body = Buffer.from(JSON.stringify(claims), "utf8").toString("base64url");
-  return { token: `${PREFIX}.${body}.${sign(body)}`, expiresAt: new Date(exp).toISOString() };
-}
-function signatureMatches(body, sig) {
-  const expected = Buffer.from(sign(body), "utf8");
-  const actual = Buffer.from(sig, "utf8");
-  return expected.length === actual.length && timingSafeEqual2(expected, actual);
-}
-function parseClaims(body) {
-  try {
-    return JSON.parse(Buffer.from(body, "base64url").toString("utf8"));
-  } catch {
-    return void 0;
-  }
-}
-function verifyConfirmToken(token, binding, now = Date.now()) {
-  for (const [nonce, exp] of spent) if (exp < now) spent.delete(nonce);
-  const parts = token.split(".");
-  if (parts.length !== 3 || parts[0] !== PREFIX || !parts[1] || !parts[2]) return { ok: false, error: "TOKEN_INVALID" };
-  const [, body, sig] = parts;
-  if (!signatureMatches(body, sig)) return { ok: false, error: "TOKEN_INVALID" };
-  const claims = parseClaims(body);
-  if (!claims) return { ok: false, error: "TOKEN_INVALID" };
-  if (claims.t !== binding.tool || claims.a !== binding.account || claims.g !== binding.target) {
-    return { ok: false, error: "TOKEN_INVALID" };
-  }
-  if (spent.has(claims.n)) return { ok: false, error: "TOKEN_REUSED" };
-  if (now > claims.exp) return { ok: false, error: "TOKEN_EXPIRED" };
-  if (claims.r !== binding.revision) return { ok: false, error: "DRAFT_CHANGED", reason: "message-id-rotated" };
-  if (claims.h !== binding.payloadHash) return { ok: false, error: "DRAFT_CHANGED", reason: "payload-changed" };
-  spent.set(claims.n, claims.exp);
-  return { ok: true };
+var spent = createSpentTokenStore();
+function confirmSpentStore() {
+  return spent;
 }
 
 // src/dispatch-confirmation.ts
@@ -34310,13 +34452,13 @@ function attachmentDetails(paths, inline) {
     } catch {
       bytes = void 0;
     }
-    out.push(bytes ? { name: path, size: bytes.length, sha256: createHash3("sha256").update(bytes).digest("hex") } : { name: path, size: null });
+    out.push(bytes ? { name: path, size: bytes.length, sha256: createHash4("sha256").update(bytes).digest("hex") } : { name: path, size: null });
   }
   for (const a of inline ?? []) {
     out.push({
       name: a.filename,
       size: Buffer.from(a.contentBase64, "base64").length,
-      sha256: createHash3("sha256").update(a.contentBase64).digest("hex")
+      sha256: createHash4("sha256").update(a.contentBase64).digest("hex")
     });
   }
   return out;
@@ -34328,82 +34470,74 @@ function attachmentPreview(details) {
   return details.map(({ name, size }) => ({ name, size }));
 }
 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 = "Show this preview to the user verbatim and proceed only after they explicitly approve in chat. Then call again with confirmToken.";
-var FALLBACK_HINT = "Or set GOG_SEND_CONFIRM_FALLBACK=token to enable two-step confirmation.";
-var CONFIRM_FALLBACK_DESCRIPTION = ' If the client cannot show that prompt (no MCP elicitation, e.g. claude.ai) and the server sets GOG_SEND_CONFIRM_FALLBACK=token, 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. Show that preview to the user verbatim; 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.';
-var confirmTokenParam = external_exports.string().optional().describe(
-  `ONLY for the two-step fallback (client without MCP elicitation, server with GOG_SEND_CONFIRM_FALLBACK=token). The confirmToken from this same tool's phase-1 "confirmation-required" response, passed back ONLY after the user has seen that preview and explicitly approved it in chat \u2014 never on the first call, never invented, never reused. Call again with the same arguments. Ignored when the client supports elicitation.`
-);
-var TOKEN_ERROR_NOTE = {
-  TOKEN_EXPIRED: "Nothing was sent or changed: the confirmToken expired. Call again WITHOUT confirmToken for a fresh preview, and ask the user to approve it again.",
-  TOKEN_REUSED: "Nothing was sent or changed by this call: this confirmToken was already used, and one approval acts once. If doing it again is really intended, call again WITHOUT confirmToken and get a new approval.",
-  TOKEN_INVALID: "Nothing was sent or changed: this confirmToken was not issued by this server for this tool, account and target (or the server has restarted since). Call again WITHOUT confirmToken for a fresh preview and approval."
-};
-var DRAFT_CHANGED_NOTE = {
-  "message-id-rotated": "Nothing was sent or changed: the target was edited since the user approved it (a draft's messageId or an event's version rotated), so what would happen is not what they saw.",
-  "payload-changed": "Nothing was sent or changed: what would happen no longer matches what the user approved."
-};
-function isToolResult(value) {
-  return Array.isArray(value.content);
-}
-function rejection(data) {
-  return { ...textResult({ status: "confirmation-rejected", confirmed: false, dispatched: false, ...data }), isError: true };
-}
-async function tokenConfirmation(op, fallback) {
-  const subject = await fallback.subject();
-  if (isToolResult(subject)) return subject;
-  const binding = {
-    tool: fallback.tool,
-    account: fallback.account ?? readEnvVar("GOG_ACCOUNT") ?? "",
-    target: subject.target,
-    ...subject.revision === void 0 ? {} : { revision: subject.revision },
-    payloadHash: hashSendPayload(subject.payload)
-  };
-  const phaseOne = () => {
-    const { token, expiresAt } = issueConfirmToken(binding);
-    return {
-      action: op,
-      preview: subject.preview,
-      confirmToken: token,
-      expiresAt,
-      ttlSeconds: confirmTokenTtlSeconds(),
-      instruction: fallback.instruction ?? CONFIRM_ACTION_INSTRUCTION
-    };
-  };
-  if (!fallback.confirmToken) {
-    return textResult({ status: "confirmation-required", confirmed: false, dispatched: false, ...phaseOne() });
-  }
-  const verdict = verifyConfirmToken(fallback.confirmToken, binding);
-  if (verdict.ok) return void 0;
-  if (verdict.error === "DRAFT_CHANGED") {
-    return rejection({
-      error: "DRAFT_CHANGED",
-      reason: verdict.reason,
-      note: `${DRAFT_CHANGED_NOTE[verdict.reason]} The current preview and a fresh confirmToken are below.`,
-      ...phaseOne()
-    });
-  }
-  return rejection({ error: verdict.error, action: op, note: TOKEN_ERROR_NOTE[verdict.error] });
+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;
-  if (fallback && callerAcceptsFormElicitation(ctx) === false && sendConfirmFallbackEnabled()) {
-    return tokenConfirmation(action, fallback);
-  }
-  const note = fallback ? [options.unsupportedNote, FALLBACK_HINT].filter(Boolean).join(" ") : options.unsupportedNote;
-  return requireConfirmation(ctx, {
+  const confirmation = {
     action,
     message: options.message,
     details: options.details,
     confirmationLabel: options.confirmationLabel,
-    ...note ? { unsupportedNote: note } : {}
-  });
+    ...options.unsupportedNote ? { unsupportedNote: options.unsupportedNote } : {}
+  };
+  if (!fallback) return requireConfirmationWithFallback(ctx, confirmation);
+  return requireConfirmationWithFallback(ctx, confirmationFromEnv({
+    ...confirmation,
+    tool: fallback.tool,
+    account: fallback.account ?? readEnvVar("GOG_ACCOUNT") ?? "",
+    confirmToken: fallback.confirmToken,
+    subject: fallback.subject,
+    instruction: fallback.instruction ?? CONFIRM_ACTION_INSTRUCTION,
+    spent: confirmSpentStore()
+  }));
 }
 function resultText(result) {
   const first = result.content[0];
@@ -34413,16 +34547,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();
@@ -34433,6 +34584,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).",
@@ -34461,7 +34620,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)"),
@@ -34470,11 +34629,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);
@@ -34484,6 +34644,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}`);
@@ -34496,6 +34677,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"
@@ -34576,16 +34773,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 {
@@ -34596,7 +34795,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");
@@ -34605,6 +34823,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."
   });
 }
@@ -34747,21 +34966,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 [];
@@ -34778,15 +35023,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) {
@@ -35007,14 +35254,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", {
@@ -35136,8 +35404,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;
@@ -35188,16 +35462,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", {
@@ -35391,20 +35683,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 });
@@ -35423,6 +35780,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.",
@@ -35635,15 +36049,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", {
@@ -35705,13 +36142,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
     })
@@ -35719,7 +36156,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";
@@ -35891,6 +36328,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.",
@@ -35987,12 +36427,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) {
@@ -36003,6 +36460,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;
@@ -36111,16 +36588,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 });
   });
@@ -36446,18 +36943,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)}
@@ -36624,6 +37125,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.";
@@ -36631,6 +37165,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) {
@@ -36842,6 +37378,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."
@@ -36957,7 +37500,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
@@ -37121,7 +37664,7 @@ function registerTasksTools(server) {
 }
 
 // src/server.ts
-var VERSION = true ? "4.4.0" : "0.0.0";
+var VERSION = true ? "4.5.1" : "0.0.0";
 var BASE_TOOL_REGISTRARS = [
   registerApiTools,
   registerAppScriptTools,
@@ -37173,12 +37716,12 @@ async function bootstrapGogAuth(env = process.env, options = {}) {
   const [clientId, clientSecret, refreshToken, account] = values;
   const { spawner } = options;
   try {
-    const { createHash: createHash4 } = await import("node:crypto");
+    const { createHash: createHash5 } = await import("node:crypto");
     const { mkdir, readFile, writeFile, chmod } = await import("node:fs/promises");
     const home = options.home ?? (await import("node:os")).homedir();
     const dir = join5(home, ".gogcli-mcp");
     const marker = join5(dir, AUTH_BOOTSTRAP_MARKER);
-    const fingerprint = createHash4("sha256").update(values.join("\0")).digest("hex");
+    const fingerprint = createHash5("sha256").update(values.join("\0")).digest("hex");
     const previous = await readFile(marker, "utf8").catch(() => void 0);
     if (previous === fingerprint && await accountListed(account, spawner)) return "present";
     await run(
@@ -37423,6 +37966,8 @@ export {
   blobStoreFromEnv,
   bodyPreview,
   bootstrapGogAuth,
+  commentMentions,
+  commentSnapshot,
   confineAtFile,
   confinePath,
   confinePaths,
@@ -37431,6 +37976,7 @@ export {
   defaultFileRoot,
   diagnose,
   errorText,
+  eventSnapshot,
   extractEmails,
   fetchGmailPages,
   fileRoots,
@@ -37445,11 +37991,14 @@ export {
   pageAliasParam,
   pageTokenParam,
   paginationParams,
+  parseMetadataHeaders,
   payloadArg,
   pos,
   prepareDownloadRoot,
   pushPaginationFlags,
+  readClassroomWork,
   readCourse,
+  readCoursework,
   registerApiTools,
   registerAppScriptTools,
   registerAuthTools,
@@ -37474,7 +38023,9 @@ export {
   runBinary,
   runOrDiagnose,
   senderPreview,
+  shareTargetMeta,
   stripConsumedPageToken,
+  studentLabel,
   uploadToBlobStore
 };
 /*! Bundled license information: