gogcli-mcp-calendar 4.5.0 → 4.5.2

package/dist/index.js

@@ -19790,7 +19790,7 @@ function date4(params) {
   return _coercedDate(ZodDate, params);
 }
 
-// ../../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,
@@ -20627,7 +20627,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(),
@@ -20728,7 +20729,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();
@@ -20842,8 +20843,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";
@@ -20854,8 +20865,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() {
@@ -23806,7 +23820,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",
@@ -24607,7 +24621,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) {
@@ -25006,19 +25020,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) => {
@@ -25098,7 +25113,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(() => {
@@ -32401,7 +32416,7 @@ var Ajv = import_ajv.Ajv;
 // ../../node_modules/@modelcontextprotocol/server/dist/shimsNode.mjs
 import process2 from "node:process";
 
-// ../../node_modules/@modelcontextprotocol/server/dist/mcp-DXXb3Vv3.mjs
+// ../../node_modules/@modelcontextprotocol/server/dist/mcp-Dw2OlZ1f.mjs
 var COMPLETABLE_SYMBOL = /* @__PURE__ */ Symbol.for("mcp.completable");
 function isCompletable(schema) {
   return !!schema && typeof schema === "object" && COMPLETABLE_SYMBOL in schema;
@@ -32594,6 +32609,9 @@ function notificationToServerEvent(method, uri) {
       };
   }
 }
+function supportsScopeChallengeResolver(transport) {
+  return typeof transport === "object" && transport !== null && "setScopeChallengeResolver" in transport && typeof transport.setScopeChallengeResolver === "function";
+}
 var DEFAULT_LEGACY_SHIM_MAX_ROUNDS = 8;
 var DEFAULT_LEGACY_SHIM_ROUND_TIMEOUT_MS = 6e5;
 function resolveLegacyShimOptions(options) {
@@ -33404,6 +33422,7 @@ var McpServer = class {
   * ```
   */
   async connect(transport) {
+    if (supportsScopeChallengeResolver(transport)) transport.setScopeChallengeResolver((context) => this.resolveScopeChallenge(context));
     return await this.server.connect(transport);
   }
   /**
@@ -33412,6 +33431,41 @@ var McpServer = class {
   async close() {
     await this.server.close();
   }
+  /** @internal */
+  resolveScopeChallenge = (context) => {
+    switch (context.request.method) {
+      case "tools/call": {
+        const toolName = context.request.params?.name;
+        if (typeof toolName !== "string") return;
+        const tool = this._registeredTools[toolName];
+        if (tool === void 0 || !tool.enabled) return;
+        return tool.scopeChallenge?.(context);
+      }
+      case "resources/read": {
+        const resourceUri = context.request.params?.uri;
+        if (typeof resourceUri !== "string") return;
+        let uri;
+        try {
+          uri = new URL(resourceUri);
+        } catch {
+          return;
+        }
+        const resource = this._registeredResources[uri.toString()];
+        if (resource !== void 0) return resource.enabled ? resource.scopeChallenge?.(context) : void 0;
+        for (const template of Object.values(this._registeredResourceTemplates)) if (template.resourceTemplate.uriTemplate.match(uri.toString())) return template.enabled ? template.scopeChallenge?.(context) : void 0;
+        return;
+      }
+      case "prompts/get": {
+        const promptName = context.request.params?.name;
+        if (typeof promptName !== "string") return;
+        const prompt = this._registeredPrompts[promptName];
+        if (prompt === void 0 || !prompt.enabled) return;
+        return prompt.scopeChallenge?.(context);
+      }
+      default:
+        return;
+    }
+  };
   _toolHandlersInitialized = false;
   setToolRequestHandlers() {
     if (this._toolHandlersInitialized) return;
@@ -33578,7 +33632,10 @@ var McpServer = class {
       }
       for (const template of Object.values(this._registeredResourceTemplates)) {
         const variables = template.resourceTemplate.uriTemplate.match(uri.toString());
-        if (variables) return attachCacheHintFallback(await template.readCallback(uri, variables, ctx), template.cacheHint);
+        if (variables) {
+          if (!template.enabled) throw new ProtocolError(ProtocolErrorCode.InvalidParams, `Resource template ${template.resourceTemplate.uriTemplate} disabled`);
+          return attachCacheHintFallback(await template.readCallback(uri, variables, ctx), template.cacheHint);
+        }
       }
       throw new ResourceNotFoundError(request.params.uri);
     });
@@ -33609,36 +33666,32 @@ var McpServer = class {
     this._promptHandlersInitialized = true;
   }
   registerResource(name, uriOrTemplate, config2, readCallback) {
-    const cacheHint = config2.cacheHint;
-    let metadata = config2;
-    if (cacheHint !== void 0) {
-      assertValidCacheHint(cacheHint, `resource ${name}`);
-      const rest = { ...config2 };
-      delete rest.cacheHint;
-      metadata = rest;
-    }
+    const { cacheHint, scopeChallenge, ...resourceMetadata } = config2;
+    const metadata = resourceMetadata;
+    if (cacheHint !== void 0) assertValidCacheHint(cacheHint, `resource ${name}`);
     if (typeof uriOrTemplate === "string") {
       if (this._registeredResources[uriOrTemplate]) throw new Error(`Resource ${uriOrTemplate} is already registered`);
-      const registeredResource = this._createRegisteredResource(name, config2.title, uriOrTemplate, metadata, readCallback);
+      const registeredResource = this._createRegisteredResource(name, config2.title, uriOrTemplate, metadata, scopeChallenge, readCallback);
       if (cacheHint !== void 0) registeredResource.cacheHint = cacheHint;
       this.setResourceRequestHandlers();
       this.sendResourceListChanged();
       return registeredResource;
     } else {
       if (this._registeredResourceTemplates[name]) throw new Error(`Resource template ${name} is already registered`);
-      const registeredResourceTemplate = this._createRegisteredResourceTemplate(name, config2.title, uriOrTemplate, metadata, readCallback);
+      const registeredResourceTemplate = this._createRegisteredResourceTemplate(name, config2.title, uriOrTemplate, metadata, scopeChallenge, readCallback);
       if (cacheHint !== void 0) registeredResourceTemplate.cacheHint = cacheHint;
       this.setResourceRequestHandlers();
       this.sendResourceListChanged();
       return registeredResourceTemplate;
     }
   }
-  _createRegisteredResource(name, title, uri, metadata, readCallback) {
+  _createRegisteredResource(name, title, uri, metadata, scopeChallenge, readCallback) {
     const registeredResource = {
       name,
       title,
       metadata,
       readCallback,
+      scopeChallenge,
       enabled: true,
       disable: () => registeredResource.update({ enabled: false }),
       enable: () => registeredResource.update({ enabled: true }),
@@ -33652,6 +33705,7 @@ var McpServer = class {
         if (updates.title !== void 0) registeredResource.title = updates.title;
         if (updates.metadata !== void 0) registeredResource.metadata = updates.metadata;
         if (updates.callback !== void 0) registeredResource.readCallback = updates.callback;
+        if (updates.scopeChallenge !== void 0) registeredResource.scopeChallenge = updates.scopeChallenge === null ? void 0 : updates.scopeChallenge;
         if (updates.enabled !== void 0) registeredResource.enabled = updates.enabled;
         this.sendResourceListChanged();
       }
@@ -33659,12 +33713,13 @@ var McpServer = class {
     this._registeredResources[uri] = registeredResource;
     return registeredResource;
   }
-  _createRegisteredResourceTemplate(name, title, template, metadata, readCallback) {
+  _createRegisteredResourceTemplate(name, title, template, metadata, scopeChallenge, readCallback) {
     const registeredResourceTemplate = {
       resourceTemplate: template,
       title,
       metadata,
       readCallback,
+      scopeChallenge,
       enabled: true,
       disable: () => registeredResourceTemplate.update({ enabled: false }),
       enable: () => registeredResourceTemplate.update({ enabled: true }),
@@ -33678,6 +33733,7 @@ var McpServer = class {
         if (updates.template !== void 0) registeredResourceTemplate.resourceTemplate = updates.template;
         if (updates.metadata !== void 0) registeredResourceTemplate.metadata = updates.metadata;
         if (updates.callback !== void 0) registeredResourceTemplate.readCallback = updates.callback;
+        if (updates.scopeChallenge !== void 0) registeredResourceTemplate.scopeChallenge = updates.scopeChallenge === null ? void 0 : updates.scopeChallenge;
         if (updates.enabled !== void 0) registeredResourceTemplate.enabled = updates.enabled;
         this.sendResourceListChanged();
       }
@@ -33687,7 +33743,7 @@ var McpServer = class {
     if (Array.isArray(variableNames) && variableNames.some((v) => !!template.completeCallback(v))) this.setCompletionRequestHandler();
     return registeredResourceTemplate;
   }
-  _createRegisteredPrompt(name, title, description, argsSchema, callback, icons, _meta) {
+  _createRegisteredPrompt(name, title, description, argsSchema, callback, icons, scopeChallenge, _meta) {
     let currentArgsSchema = argsSchema;
     let currentCallback = callback;
     const registeredPrompt = {
@@ -33695,6 +33751,7 @@ var McpServer = class {
       description,
       argsSchema,
       icons,
+      scopeChallenge,
       _meta,
       handler: createPromptHandler(name, argsSchema, callback),
       enabled: true,
@@ -33709,6 +33766,7 @@ var McpServer = class {
         if (updates.title !== void 0) registeredPrompt.title = updates.title;
         if (updates.description !== void 0) registeredPrompt.description = updates.description;
         if (updates.icons !== void 0) registeredPrompt.icons = updates.icons;
+        if (updates.scopeChallenge !== void 0) registeredPrompt.scopeChallenge = updates.scopeChallenge === null ? void 0 : updates.scopeChallenge;
         if (updates._meta !== void 0) registeredPrompt._meta = updates._meta;
         let needsHandlerRegen = false;
         if (updates.argsSchema !== void 0) {
@@ -33736,7 +33794,7 @@ var McpServer = class {
     }
     return registeredPrompt;
   }
-  _createRegisteredTool(name, title, description, inputSchema, outputSchema, annotations, icons, execution, _meta, handler) {
+  _createRegisteredTool(name, title, description, inputSchema, outputSchema, annotations, icons, execution, scopeChallenge, _meta, handler) {
     validateAndWarnToolName(name);
     if (inputSchema !== void 0) try {
       const json2 = standardSchemaToJsonSchema(inputSchema, "input");
@@ -33755,6 +33813,7 @@ var McpServer = class {
       annotations,
       icons,
       execution,
+      scopeChallenge,
       _meta,
       handler,
       executor: createToolExecutor(inputSchema, handler),
@@ -33793,6 +33852,7 @@ var McpServer = class {
         }
         if (updates.annotations !== void 0) registeredTool.annotations = updates.annotations;
         if (updates.icons !== void 0) registeredTool.icons = updates.icons;
+        if (updates.scopeChallenge !== void 0) registeredTool.scopeChallenge = updates.scopeChallenge === null ? void 0 : updates.scopeChallenge;
         if (updates._meta !== void 0) registeredTool._meta = updates._meta;
         if (updates.enabled !== void 0) registeredTool.enabled = updates.enabled;
         this.sendToolListChanged();
@@ -33805,13 +33865,13 @@ var McpServer = class {
   }
   registerTool(name, config2, cb) {
     if (this._registeredTools[name]) throw new Error(`Tool ${name} is already registered`);
-    const { title, description, inputSchema, outputSchema, annotations, icons, _meta } = config2;
-    return this._createRegisteredTool(name, title, description, normalizeRawShapeSchema(inputSchema), normalizeRawShapeSchema(outputSchema), annotations, icons, void 0, _meta, cb);
+    const { title, description, inputSchema, outputSchema, annotations, icons, scopeChallenge, _meta } = config2;
+    return this._createRegisteredTool(name, title, description, normalizeRawShapeSchema(inputSchema), normalizeRawShapeSchema(outputSchema), annotations, icons, void 0, scopeChallenge, _meta, cb);
   }
   registerPrompt(name, config2, cb) {
     if (this._registeredPrompts[name]) throw new Error(`Prompt ${name} is already registered`);
-    const { title, description, argsSchema, icons, _meta } = config2;
-    const registeredPrompt = this._createRegisteredPrompt(name, title, description, normalizeRawShapeSchema(argsSchema), cb, icons, _meta);
+    const { title, description, argsSchema, icons, scopeChallenge, _meta } = config2;
+    const registeredPrompt = this._createRegisteredPrompt(name, title, description, normalizeRawShapeSchema(argsSchema), cb, icons, scopeChallenge, _meta);
     this.setPromptRequestHandlers();
     this.sendPromptListChanged();
     return registeredPrompt;
@@ -33923,6 +33983,7 @@ function unwrapOptionalSchema(schema) {
 }
 
 // ../../node_modules/@modelcontextprotocol/server/dist/stdio.mjs
+var swallowsErrorsAfterClose = /* @__PURE__ */ Symbol("swallowsErrorsAfterClose");
 var StdioServerTransport = class {
   _readBuffer;
   _started = false;
@@ -33949,18 +34010,27 @@ var StdioServerTransport = class {
     this.onerror?.(error62);
   };
   _onstdouterror = (error62) => {
+    if (this._closed) return;
     this.onerror?.(error62);
     this.close().catch(() => {
     });
   };
+  _onstdinclose = () => {
+    this.close().catch(() => {
+    });
+  };
   /**
   * Starts listening for messages on `stdin`.
   */
   async start() {
     if (this._started) throw new Error("StdioServerTransport already started! If using Server class, note that connect() calls start() automatically.");
     this._started = true;
+    for (const listener of this._stdout.listeners("error")) if (listener[swallowsErrorsAfterClose]) this._stdout.off("error", listener);
+    if (this._stdin.readableEnded || this._stdin.destroyed) setImmediate(this._onstdinclose);
     this._stdin.on("data", this._ondata);
     this._stdin.on("error", this._onerror);
+    this._stdin.on("end", this._onstdinclose);
+    this._stdin.on("close", this._onstdinclose);
     this._stdout.on("error", this._onstdouterror);
   }
   processReadBuffer() {
@@ -33977,7 +34047,9 @@ var StdioServerTransport = class {
     this._closed = true;
     this._stdin.off("data", this._ondata);
     this._stdin.off("error", this._onerror);
-    this._stdout.off("error", this._onstdouterror);
+    this._stdin.off("end", this._onstdinclose);
+    this._stdin.off("close", this._onstdinclose);
+    this._onstdouterror[swallowsErrorsAfterClose] = true;
     if (this._stdin.listenerCount("data") === 0) this._stdin.pause();
     this._readBuffer.clear();
     this.onclose?.();
@@ -34254,6 +34326,7 @@ function serveStdio(factory, options = {}) {
         return;
       }
       if (state.era === "modern" && await tryServeListen(message)) return;
+      if (isTornDown()) return;
       state.instance.channel.deliver(message);
       return;
     }
@@ -34320,6 +34393,7 @@ function serveStdio(factory, options = {}) {
           };
         }
         if (await tryServeListen(message)) return;
+        if (isTornDown()) return;
         state.instance.channel.deliver(message, { classification: opening.classification });
         return;
       case "legacy": {
@@ -34406,6 +34480,9 @@ function toError(value) {
   return value instanceof Error ? value : new Error(String(value));
 }
 
+// ../../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 McpToolError = class extends Error {
   /** Actionable remediation text, when one applies. */
@@ -35946,6 +36023,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}
@@ -36043,8 +36121,20 @@ function confirmSpentStore() {
 // ../gogcli-mcp/src/dispatch-confirmation.ts
 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 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;
 }
 async function requireDispatchConfirmation(ctx, options) {
   const { action, fallback } = options;
@@ -36206,21 +36296,47 @@ function authToolsFor(defaultServices) {
 }
 
 // ../gogcli-mcp/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 [];
@@ -36245,6 +36361,8 @@ function eventSnapshot(raw) {
     organizer: str(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),
+    // 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: str(event?.etag)
   };
 }
@@ -36466,14 +36584,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", {
@@ -36566,7 +36705,7 @@ var failIfNotEmptyParam = external_exports.boolean().optional().describe(
 );
 
 // ../gogcli-mcp/src/server.ts
-var VERSION = true ? "4.5.0" : "0.0.0";
+var VERSION = true ? "4.5.2" : "0.0.0";
 
 // ../gogcli-mcp/src/bootstrap-auth.ts
 import { join as join5 } from "node:path";
@@ -36642,6 +36781,20 @@ var MAX_BLOB_UPLOAD_BYTES = 100 * 1024 * 1024;
 
 // src/tools/calendar-extra.ts
 var meetAccess = external_exports.enum(["open", "trusted", "restricted"]);
+function calendarSnapshot(raw, calendarId) {
+  let cal;
+  try {
+    const parsed = JSON.parse(raw);
+    cal = parsed?.result ?? parsed ?? void 0;
+  } catch {
+    cal = void 0;
+  }
+  return {
+    id: calendarId,
+    ...typeof cal?.summary === "string" ? { summary: cal.summary } : {},
+    ...typeof cal?.etag === "string" ? { etag: cal.etag } : {}
+  };
+}
 function registerExtraCalendarTools(server) {
   server.registerTool("gog_meet_create", {
     description: "Create a Google Meet space and return its meeting code.",
@@ -36856,34 +37009,56 @@ function registerExtraCalendarTools(server) {
     return runOrDiagnose(args, { account });
   });
   server.registerTool("gog_calendar_move", {
-    description: "Move an event from one calendar to another; the destination calendar becomes the organizer.",
+    description: "Move an event from one calendar to another; the destination calendar becomes the organizer. With sendUpdates all or externalOnly Google emails the guests, so this reads the event and asks the MCP host to show the user a confirmation prompt with the event, its guests and the destination first; a move that notifies nobody (the default) is made without asking." + CONFIRM_FALLBACK_DESCRIPTION,
     annotations: { destructiveHint: false },
     inputSchema: external_exports.object({
       calendarId: external_exports.string().describe("Source calendar ID"),
       eventId: external_exports.string().describe("Event ID"),
       destinationCalendarId: external_exports.string().describe("Destination calendar ID that becomes the event organizer"),
-      sendUpdates: external_exports.enum(["all", "externalOnly", "none"]).optional().describe("Notification mode (default: none)"),
-      account: accountParam
+      sendUpdates: external_exports.enum(["all", "externalOnly", "none"]).optional().describe("Notification mode (default: none). all / externalOnly email the guests and ask the user first."),
+      account: accountParam,
+      confirmToken: confirmTokenParam
     })
-  }, async ({ calendarId, eventId, destinationCalendarId, sendUpdates, account }) => {
+  }, async ({ calendarId, eventId, destinationCalendarId, sendUpdates, account, confirmToken }, ctx) => {
     const args = ["calendar", "move", pos(calendarId), pos(eventId), pos(destinationCalendarId)];
     if (sendUpdates) args.push(`--send-updates=${sendUpdates}`);
+    if (sendUpdates === "all" || sendUpdates === "externalOnly") {
+      const got = await runOrDiagnose(["calendar", "event", pos(calendarId), pos(eventId)], { account });
+      if (got.isError) return got;
+      const { etag, ...event } = eventSnapshot(resultText(got));
+      const view = { calendarId, eventId, event, destinationCalendarId, emails: sendUpdates === "all" ? "every guest" : "guests outside your domain" };
+      const confirmation = await requireDispatchConfirmation(ctx, {
+        action: "calendar.move",
+        message: "Review and confirm moving this event \u2014 Google will email the guests:",
+        confirmationLabel: "Confirm that this event should be moved and the guests notified now.",
+        details: view,
+        unsupportedNote: "Move it with sendUpdates none instead, which notifies nobody.",
+        fallback: {
+          tool: "gog_calendar_move",
+          account,
+          confirmToken,
+          subject: () => ({ target: `${calendarId}/${eventId}`, revision: etag, payload: view, preview: view })
+        }
+      });
+      if (confirmation) return confirmation;
+    }
     return runOrDiagnose(args, { account });
   });
   server.registerTool("gog_calendar_out_of_office", {
-    description: "Create an Out of Office event that auto-declines invitations during the block.",
+    description: "Create an Out of Office event that auto-declines invitations during the block. gog auto-declines EVERY conflicting meeting by default (autoDecline all), and each organizer is notified, so unless autoDecline is none this asks the MCP host to show the user a confirmation prompt with the window, the decline mode and the message first; nothing is created unless they accept." + CONFIRM_FALLBACK_DESCRIPTION,
     annotations: { destructiveHint: true },
     inputSchema: external_exports.object({
       from: external_exports.string().describe("Start date or datetime (RFC3339 or YYYY-MM-DD)"),
       to: external_exports.string().describe("End date or datetime (RFC3339 or YYYY-MM-DD)"),
       calendarId: external_exports.string().optional().describe("Calendar ID (default: primary)"),
       summary: external_exports.string().optional().describe('Out of office title (default: "Out of office")'),
-      autoDecline: external_exports.enum(["none", "all", "new"]).optional().describe("Auto-decline mode (default: all)"),
+      autoDecline: external_exports.enum(["none", "all", "new"]).optional().describe("Auto-decline mode (default: all \u2014 declines existing AND new conflicting meetings; none notifies nobody and does not ask)"),
       declineMessage: external_exports.string().optional().describe("Message for declined invitations"),
       allDay: external_exports.boolean().optional().describe("Create as an all-day event"),
-      account: accountParam
+      account: accountParam,
+      confirmToken: confirmTokenParam
     })
-  }, async ({ from, to, calendarId, summary, autoDecline, declineMessage, allDay, account }) => {
+  }, async ({ from, to, calendarId, summary, autoDecline, declineMessage, allDay, account, confirmToken }, ctx) => {
     const args = ["calendar", "out-of-office"];
     if (calendarId) args.push(pos(calendarId));
     args.push(`--from=${from}`);
@@ -36892,6 +37067,32 @@ function registerExtraCalendarTools(server) {
     if (autoDecline) args.push(`--auto-decline=${autoDecline}`);
     if (declineMessage) args.push(`--decline-message=${declineMessage}`);
     if (allDay) args.push("--all-day");
+    if (autoDecline !== "none") {
+      const mode = autoDecline ?? "all";
+      const view = {
+        calendarId: calendarId ?? "primary",
+        from,
+        to,
+        allDay: Boolean(allDay),
+        summary: summary ?? "Out of office",
+        declines: mode === "all" ? "every existing and new conflicting meeting" : "new conflicting invitations",
+        declineMessage
+      };
+      const confirmation = await requireDispatchConfirmation(ctx, {
+        action: "calendar.out-of-office",
+        message: "Review and confirm this Out of Office block \u2014 conflicting meetings are declined and their organizers notified:",
+        confirmationLabel: "Confirm that meetings in this window should be auto-declined.",
+        details: view,
+        unsupportedNote: "Create it with autoDecline none instead; the user can turn on auto-decline in Google Calendar.",
+        fallback: {
+          tool: "gog_calendar_out_of_office",
+          account,
+          confirmToken,
+          subject: () => ({ target: view.calendarId, payload: view, preview: view })
+        }
+      });
+      if (confirmation) return confirmation;
+    }
     return runOrDiagnose(args, { account });
   });
   server.registerTool("gog_calendar_unsubscribe", {
@@ -36905,13 +37106,35 @@ function registerExtraCalendarTools(server) {
     return runOrDiagnose(["calendar", "unsubscribe", pos(calendarId)], { account });
   });
   server.registerTool("gog_calendar_delete_calendar", {
-    description: "Permanently delete an owned secondary calendar and all its events. Cannot delete your primary calendar. To merely remove a calendar you do not own from your list, use gog_calendar_unsubscribe.",
+    description: "Permanently delete an owned secondary calendar and all its events. Cannot delete your primary calendar. To merely remove a calendar you do not own from your list, use gog_calendar_unsubscribe. Reads the calendar and asks the MCP host to show the user a confirmation prompt naming it first; nothing is deleted unless they accept." + CONFIRM_FALLBACK_DESCRIPTION,
     annotations: { destructiveHint: true },
     inputSchema: external_exports.object({
       calendarId: external_exports.string().describe("Owned secondary calendar ID or alias"),
-      account: accountParam
+      account: accountParam,
+      confirmToken: confirmTokenParam
     })
-  }, async ({ calendarId, account }) => {
+  }, async ({ calendarId, account, confirmToken }, ctx) => {
+    const got = await runOrDiagnose(
+      ["api", "call", "calendar", "v3", "calendars.get", `--params=${JSON.stringify({ calendarId })}`],
+      { account }
+    );
+    if (got.isError) return got;
+    const { etag, ...calendar } = calendarSnapshot(resultText(got), calendarId);
+    const view = { calendar, deletes: "the calendar and every event on it, for good" };
+    const confirmation = await requireDispatchConfirmation(ctx, {
+      action: "calendar.delete-calendar",
+      message: "Review and confirm PERMANENTLY deleting this calendar and all of its events:",
+      confirmationLabel: "Confirm that this calendar should be deleted now.",
+      details: view,
+      unsupportedNote: "Ask the user to delete it from Google Calendar's settings, or use gog_calendar_unsubscribe to only hide it.",
+      fallback: {
+        tool: "gog_calendar_delete_calendar",
+        account,
+        confirmToken,
+        subject: () => ({ target: calendarId, revision: etag, payload: view, preview: view })
+      }
+    });
+    if (confirmation) return confirmation;
     return runOrDiagnose(["calendar", "delete-calendar", pos(calendarId), "--force"], { account });
   });
   server.registerTool("gog_meet_participants", {
@@ -36946,7 +37169,7 @@ await runMcp({
 });
 /*! Bundled license information:
 
-@modelcontextprotocol/server/dist/src-CX2iR2pK.mjs:
+@modelcontextprotocol/server/dist/src-D-y6h4N7.mjs:
   (*!
   * content-type
   * Copyright(c) 2015 Douglas Christopher Wilson

package/manifest.json

@@ -3,7 +3,7 @@
   "manifest_version": "0.3",
   "name": "gogcli-mcp-calendar",
   "display_name": "gogcli (Calendar)",
-  "version": "4.5.0",
+  "version": "4.5.2",
   "description": "Extended Google Calendar for Claude via gogcli — auth + Calendar events + Meet space management",
   "author": {
     "name": "Chris Hall",
@@ -111,7 +111,7 @@
     },
     {
       "name": "gog_calendar_delete",
-      "description": "Delete a calendar event"
+      "description": "Delete a calendar event (asks the user to confirm when it has guests or recurs)"
     },
     {
       "name": "gog_calendar_respond",
@@ -147,11 +147,11 @@
     },
     {
       "name": "gog_calendar_move",
-      "description": "Move an event to another calendar"
+      "description": "Move an event to another calendar (asks the user to confirm when guests are emailed)"
     },
     {
       "name": "gog_calendar_out_of_office",
-      "description": "Create an Out of Office event that auto-declines invitations"
+      "description": "Create an Out of Office event that auto-declines invitations (asks the user to confirm unless autoDecline is none)"
     },
     {
       "name": "gog_calendar_unsubscribe",
@@ -159,7 +159,7 @@
     },
     {
       "name": "gog_calendar_delete_calendar",
-      "description": "Delete an owned secondary calendar"
+      "description": "Delete an owned secondary calendar (asks the user to confirm)"
     },
     {
       "name": "gog_meet_create",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gogcli-mcp-calendar",
-  "version": "4.5.0",
+  "version": "4.5.2",
   "mcpName": "io.github.chrischall/gogcli-mcp-calendar",
   "description": "Extended Google Calendar + Meet MCP server via gogcli — auth + Calendar events + Meet space management",
   "author": "Claude Code (AI) <https://www.anthropic.com/claude>",
@@ -25,7 +25,7 @@
   },
   "dependencies": {
     "@chrischall/mcp-utils": "^2.6.0",
-    "@modelcontextprotocol/server": "^2.0.0",
+    "@modelcontextprotocol/server": "^2.1.0",
     "zod": "^4.6.1"
   },
   "license": "MIT",

package/src/tools/calendar-extra.ts

@@ -1,10 +1,38 @@
 import { McpServer } from '@modelcontextprotocol/server';
 import { z } from 'zod';
-import { accountParam, runOrDiagnose, pageTokenParam, pageAliasParam, resolvePageToken, pos} from '../../../gogcli-mcp/src/lib.js';
+import {
+  accountParam,
+  runOrDiagnose,
+  pageTokenParam,
+  pageAliasParam,
+  resolvePageToken,
+  pos,
+  CONFIRM_FALLBACK_DESCRIPTION,
+  confirmTokenParam,
+  eventSnapshot,
+  requireDispatchConfirmation,
+  resultText,
+} from '../../../gogcli-mcp/src/lib.js';
 import type { GogArg } from '../../../gogcli-mcp/src/lib.js';
 
 const meetAccess = z.enum(['open', 'trusted', 'restricted']);
 
+/** A calendar by name, for a delete's prompt; `etag` apart as the token's revision. Unreadable output names nothing. */
+export function calendarSnapshot(raw: string, calendarId: string): { id: string; summary?: string; etag?: string } {
+  let cal: { summary?: unknown; etag?: unknown } | undefined;
+  try {
+    const parsed = JSON.parse(raw) as ({ result?: typeof cal } & NonNullable<typeof cal>) | null;
+    cal = parsed?.result ?? parsed ?? undefined;
+  } catch {
+    cal = undefined;
+  }
+  return {
+    id: calendarId,
+    ...(typeof cal?.summary === 'string' ? { summary: cal.summary } : {}),
+    ...(typeof cal?.etag === 'string' ? { etag: cal.etag } : {}),
+  };
+}
+
 // Meet spaces are the conferencing surface attached to calendar events,
 // so they live in the calendar sub-package.
 export function registerExtraCalendarTools(server: McpServer): void {
@@ -241,35 +269,63 @@ export function registerExtraCalendarTools(server: McpServer): void {
   });
 
   server.registerTool('gog_calendar_move', {
-    description: 'Move an event from one calendar to another; the destination calendar becomes the organizer.',
+    description: 'Move an event from one calendar to another; the destination calendar becomes the organizer. With '
+      + 'sendUpdates all or externalOnly Google emails the guests, so this reads the event and asks the MCP host to '
+      + 'show the user a confirmation prompt with the event, its guests and the destination first; a move that '
+      + 'notifies nobody (the default) is made without asking.' + CONFIRM_FALLBACK_DESCRIPTION,
     annotations: { destructiveHint: false },
     inputSchema: z.object({
       calendarId: z.string().describe('Source calendar ID'),
       eventId: z.string().describe('Event ID'),
       destinationCalendarId: z.string().describe('Destination calendar ID that becomes the event organizer'),
-      sendUpdates: z.enum(['all', 'externalOnly', 'none']).optional().describe('Notification mode (default: none)'),
+      sendUpdates: z.enum(['all', 'externalOnly', 'none']).optional().describe('Notification mode (default: none). all / externalOnly email the guests and ask the user first.'),
       account: accountParam,
+      confirmToken: confirmTokenParam,
     }),
-  }, async ({ calendarId, eventId, destinationCalendarId, sendUpdates, account }) => {
+  }, async ({ calendarId, eventId, destinationCalendarId, sendUpdates, account, confirmToken }, ctx) => {
     const args: GogArg[] = ['calendar', 'move', pos(calendarId), pos(eventId), pos(destinationCalendarId)];
     if (sendUpdates) args.push(`--send-updates=${sendUpdates}`);
+    if (sendUpdates === 'all' || sendUpdates === 'externalOnly') {
+      const got = await runOrDiagnose(['calendar', 'event', pos(calendarId), pos(eventId)], { account });
+      if (got.isError) return got;
+      const { etag, ...event } = eventSnapshot(resultText(got));
+      const view = { calendarId, eventId, event, destinationCalendarId, emails: sendUpdates === 'all' ? 'every guest' : 'guests outside your domain' };
+      const confirmation = await requireDispatchConfirmation(ctx, {
+        action: 'calendar.move',
+        message: 'Review and confirm moving this event — Google will email the guests:',
+        confirmationLabel: 'Confirm that this event should be moved and the guests notified now.',
+        details: view,
+        unsupportedNote: 'Move it with sendUpdates none instead, which notifies nobody.',
+        fallback: {
+          tool: 'gog_calendar_move',
+          account,
+          confirmToken,
+          subject: () => ({ target: `${calendarId}/${eventId}`, revision: etag, payload: view, preview: view }),
+        },
+      });
+      if (confirmation) return confirmation;
+    }
     return runOrDiagnose(args, { account });
   });
 
   server.registerTool('gog_calendar_out_of_office', {
-    description: 'Create an Out of Office event that auto-declines invitations during the block.',
+    description: 'Create an Out of Office event that auto-declines invitations during the block. gog auto-declines '
+      + 'EVERY conflicting meeting by default (autoDecline all), and each organizer is notified, so unless autoDecline '
+      + 'is none this asks the MCP host to show the user a confirmation prompt with the window, the decline mode and '
+      + 'the message first; nothing is created unless they accept.' + CONFIRM_FALLBACK_DESCRIPTION,
     annotations: { destructiveHint: true },
     inputSchema: z.object({
       from: z.string().describe('Start date or datetime (RFC3339 or YYYY-MM-DD)'),
       to: z.string().describe('End date or datetime (RFC3339 or YYYY-MM-DD)'),
       calendarId: z.string().optional().describe('Calendar ID (default: primary)'),
       summary: z.string().optional().describe('Out of office title (default: "Out of office")'),
-      autoDecline: z.enum(['none', 'all', 'new']).optional().describe('Auto-decline mode (default: all)'),
+      autoDecline: z.enum(['none', 'all', 'new']).optional().describe('Auto-decline mode (default: all — declines existing AND new conflicting meetings; none notifies nobody and does not ask)'),
       declineMessage: z.string().optional().describe('Message for declined invitations'),
       allDay: z.boolean().optional().describe('Create as an all-day event'),
       account: accountParam,
+      confirmToken: confirmTokenParam,
     }),
-  }, async ({ from, to, calendarId, summary, autoDecline, declineMessage, allDay, account }) => {
+  }, async ({ from, to, calendarId, summary, autoDecline, declineMessage, allDay, account, confirmToken }, ctx) => {
     const args: GogArg[] = ['calendar', 'out-of-office'];
     if (calendarId) args.push(pos(calendarId));
     args.push(`--from=${from}`);
@@ -278,6 +334,32 @@ export function registerExtraCalendarTools(server: McpServer): void {
     if (autoDecline) args.push(`--auto-decline=${autoDecline}`);
     if (declineMessage) args.push(`--decline-message=${declineMessage}`);
     if (allDay) args.push('--all-day');
+    if (autoDecline !== 'none') {
+      const mode = autoDecline ?? 'all';
+      const view = {
+        calendarId: calendarId ?? 'primary',
+        from,
+        to,
+        allDay: Boolean(allDay),
+        summary: summary ?? 'Out of office',
+        declines: mode === 'all' ? 'every existing and new conflicting meeting' : 'new conflicting invitations',
+        declineMessage,
+      };
+      const confirmation = await requireDispatchConfirmation(ctx, {
+        action: 'calendar.out-of-office',
+        message: 'Review and confirm this Out of Office block — conflicting meetings are declined and their organizers notified:',
+        confirmationLabel: 'Confirm that meetings in this window should be auto-declined.',
+        details: view,
+        unsupportedNote: 'Create it with autoDecline none instead; the user can turn on auto-decline in Google Calendar.',
+        fallback: {
+          tool: 'gog_calendar_out_of_office',
+          account,
+          confirmToken,
+          subject: () => ({ target: view.calendarId, payload: view, preview: view }),
+        },
+      });
+      if (confirmation) return confirmation;
+    }
     return runOrDiagnose(args, { account });
   });
 
@@ -293,13 +375,36 @@ export function registerExtraCalendarTools(server: McpServer): void {
   });
 
   server.registerTool('gog_calendar_delete_calendar', {
-    description: 'Permanently delete an owned secondary calendar and all its events. Cannot delete your primary calendar. To merely remove a calendar you do not own from your list, use gog_calendar_unsubscribe.',
+    description: 'Permanently delete an owned secondary calendar and all its events. Cannot delete your primary calendar. '
+      + 'To merely remove a calendar you do not own from your list, use gog_calendar_unsubscribe. Reads the calendar and '
+      + 'asks the MCP host to show the user a confirmation prompt naming it first; nothing is deleted unless they accept.'
+      + CONFIRM_FALLBACK_DESCRIPTION,
     annotations: { destructiveHint: true },
     inputSchema: z.object({
       calendarId: z.string().describe('Owned secondary calendar ID or alias'),
       account: accountParam,
+      confirmToken: confirmTokenParam,
     }),
-  }, async ({ calendarId, account }) => {
+  }, async ({ calendarId, account, confirmToken }, ctx) => {
+    const got = await runOrDiagnose(
+      ['api', 'call', 'calendar', 'v3', 'calendars.get', `--params=${JSON.stringify({ calendarId })}`], { account });
+    if (got.isError) return got;
+    const { etag, ...calendar } = calendarSnapshot(resultText(got), calendarId);
+    const view = { calendar, deletes: 'the calendar and every event on it, for good' };
+    const confirmation = await requireDispatchConfirmation(ctx, {
+      action: 'calendar.delete-calendar',
+      message: 'Review and confirm PERMANENTLY deleting this calendar and all of its events:',
+      confirmationLabel: 'Confirm that this calendar should be deleted now.',
+      details: view,
+      unsupportedNote: 'Ask the user to delete it from Google Calendar\'s settings, or use gog_calendar_unsubscribe to only hide it.',
+      fallback: {
+        tool: 'gog_calendar_delete_calendar',
+        account,
+        confirmToken,
+        subject: () => ({ target: calendarId, revision: etag, payload: view, preview: view }),
+      },
+    });
+    if (confirmation) return confirmation;
     return runOrDiagnose(['calendar', 'delete-calendar', pos(calendarId), '--force'], { account }); // gog gates this op; without --force the runner's --no-input makes it refuse
   });
 

package/tests/tools/calendar-extra-gates.test.ts

@@ -0,0 +1,221 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { registerExtraCalendarTools, calendarSnapshot } from '../../src/tools/calendar-extra.js';
+import * as lib from '../../../gogcli-mcp/src/lib.js';
+import { createTestHarness } from '@chrischall/mcp-utils/test';
+import { rawTextResult } from '@chrischall/mcp-utils';
+import type { ElicitRequest, ElicitResult } from '@modelcontextprotocol/server';
+import { pos } from '../../../gogcli-mcp/src/argv.js';
+import { resetConfirmTokenState } from '../../../gogcli-mcp/src/send-confirm-token.js';
+
+vi.mock('../../../gogcli-mcp/src/lib.js', async (importOriginal) => {
+  const actual = await importOriginal<typeof lib>();
+  return { ...actual, runOrDiagnose: vi.fn() };
+});
+
+// ============================================================================
+// Fleet audit 2026-09-24 SEC-6: a move that emails the guests, an Out of Office
+// block that auto-declines (and notifies) every conflicting organizer, and a
+// calendar delete all ask first — prompted, refused, and via the token fallback.
+// ============================================================================
+
+const ORIGINAL_ENV = { ...process.env };
+beforeEach(() => {
+  vi.clearAllMocks();
+  process.env = { ...ORIGINAL_ENV };
+  delete process.env.MCP_CONFIRM_MODE;
+  process.env.GOG_ACCOUNT = 'me@example.com';
+  resetConfirmTokenState();
+});
+afterEach(() => { process.env = ORIGINAL_ENV; });
+
+const json = (r: { content: Array<{ text?: string }> }) => JSON.parse(r.content[0]!.text as string);
+
+async function prompted(answer: ElicitResult = { action: 'accept', content: { confirmed: true } }) {
+  const seen: ElicitRequest[] = [];
+  const harness = await createTestHarness(registerExtraCalendarTools, { elicitation: async (r) => { seen.push(r); return answer; } });
+  const details = () => JSON.parse(seen[0]!.params.message.split('\n').slice(1).join('\n')).details;
+  return { harness, seen, details };
+}
+const unprompted = () => createTestHarness(registerExtraCalendarTools);
+
+/** Answer reads keyed by their command words; a `failing` prefix returns an error result. */
+function stub(reads: Record<string, string>, failing?: string) {
+  vi.mocked(lib.runOrDiagnose).mockImplementation(async (args) => {
+    const key = args.filter((a): a is string => typeof a === 'string' && !a.startsWith('--')).join(' ');
+    if (failing && key.startsWith(failing)) return { content: [{ type: 'text', text: 'Error: not found' }], isError: true };
+    for (const [prefix, out] of Object.entries(reads)) if (key.startsWith(prefix)) return rawTextResult(out);
+    return rawTextResult('{"ok":true}');
+  });
+}
+const callsTo = (...words: string[]) => vi.mocked(lib.runOrDiagnose).mock.calls.filter(([args]) =>
+  words.every((w, i) => args[i] === w));
+
+describe('gog_calendar_move', () => {
+  const EVENT = (etag = '"v1"') => JSON.stringify({ event: {
+    id: 'e1', etag, summary: 'Budget review', start: { dateTime: '2026-09-30T14:00:00-04:00' },
+    end: { dateTime: '2026-09-30T15:00:00-04:00' }, organizer: { email: 'me@example.com' },
+    attendees: [{ email: 'me@example.com', self: true }, { email: 'boss@example.com' }],
+  } });
+  const ARGS = { calendarId: 'primary', eventId: 'e1', destinationCalendarId: 'team@example.com', sendUpdates: 'all' as const };
+
+  it.each([undefined, 'none'] as const)('moves without reading or asking when sendUpdates is %s', async (sendUpdates) => {
+    stub({});
+    const { harness, seen } = await prompted();
+    await harness.callTool('gog_calendar_move', { ...ARGS, sendUpdates });
+    expect(seen).toHaveLength(0);
+    expect(callsTo('calendar', 'event')).toHaveLength(0);
+    expect(callsTo('calendar', 'move')).toHaveLength(1);
+  });
+
+  it('reads the event and asks, naming it, its guests and who is emailed', async () => {
+    stub({ 'calendar event': EVENT() });
+    const { harness, details } = await prompted();
+    await harness.callTool('gog_calendar_move', { ...ARGS, sendUpdates: 'externalOnly' });
+    expect(details()).toEqual({
+      calendarId: 'primary', eventId: 'e1', destinationCalendarId: 'team@example.com',
+      event: { summary: 'Budget review', start: '2026-09-30T14:00:00-04:00', end: '2026-09-30T15:00:00-04:00', organizer: 'me@example.com', guests: ['boss@example.com'] },
+      emails: 'guests outside your domain',
+    });
+    expect(callsTo('calendar', 'move')[0]![0]).toEqual(
+      ['calendar', 'move', pos('primary'), pos('e1'), pos('team@example.com'), '--send-updates=externalOnly']);
+  });
+
+  it('moves nothing when the user declines, or when the read fails', async () => {
+    stub({ 'calendar event': EVENT() });
+    const declined = await prompted({ action: 'decline' });
+    expect(json(await declined.harness.callTool('gog_calendar_move', ARGS))).toMatchObject({ cancelled: true, action: 'calendar.move' });
+    stub({}, 'calendar event');
+    const { harness, seen } = await prompted();
+    expect((await harness.callTool('gog_calendar_move', ARGS)).isError).toBe(true);
+    expect(seen).toHaveLength(0);
+    expect(callsTo('calendar', 'move')).toHaveLength(0);
+  });
+
+  it('refuses a client that cannot be prompted, pointing at sendUpdates none', async () => {
+    process.env.MCP_CONFIRM_MODE = 'refuse';
+    stub({ 'calendar event': EVENT() });
+    const r = json(await (await unprompted()).callTool('gog_calendar_move', ARGS));
+    expect(r).toMatchObject({ reason: 'confirmation-unsupported', action: 'calendar.move' });
+    expect(r.note).toMatch(/sendUpdates none/);
+  });
+
+  it('token fallback: an event edited between the phases (etag rotated) is DRAFT_CHANGED', async () => {
+    process.env.MCP_CONFIRM_MODE = 'ask-user';
+    stub({ 'calendar event': EVENT() });
+    const harness = await unprompted();
+    const p1 = json(await harness.callTool('gog_calendar_move', ARGS));
+    expect(p1.preview).toMatchObject({ event: { summary: 'Budget review', guests: ['boss@example.com'] }, emails: 'every guest' });
+    stub({ 'calendar event': EVENT('"v2"') });
+    expect(json(await harness.callTool('gog_calendar_move', { ...ARGS, confirmToken: p1.confirmToken })))
+      .toMatchObject({ error: 'DRAFT_CHANGED' });
+    stub({ 'calendar event': EVENT() });
+    await harness.callTool('gog_calendar_move', { ...ARGS, confirmToken: p1.confirmToken });
+    expect(callsTo('calendar', 'move')).toHaveLength(1);
+  });
+});
+
+describe('gog_calendar_out_of_office', () => {
+  const ARGS = { from: '2026-10-01', to: '2026-10-05' };
+
+  it('creates a block that declines nothing without asking', async () => {
+    stub({});
+    const { harness, seen } = await prompted();
+    await harness.callTool('gog_calendar_out_of_office', { ...ARGS, autoDecline: 'none' });
+    expect(seen).toHaveLength(0);
+    expect(callsTo('calendar', 'out-of-office')).toHaveLength(1);
+  });
+
+  it("asks by default, because gog's default declines every conflicting meeting", async () => {
+    stub({});
+    const { harness, details } = await prompted();
+    await harness.callTool('gog_calendar_out_of_office', ARGS);
+    expect(details()).toEqual({
+      calendarId: 'primary', from: '2026-10-01', to: '2026-10-05', allDay: false,
+      summary: 'Out of office', declines: 'every existing and new conflicting meeting',
+    });
+    expect(callsTo('calendar', 'out-of-office')).toHaveLength(1);
+  });
+
+  it('asks for new-only declines too, showing the message', async () => {
+    stub({});
+    const { harness, details } = await prompted({ action: 'decline' });
+    await harness.callTool('gog_calendar_out_of_office', { ...ARGS, calendarId: 'work', summary: 'Leave', autoDecline: 'new', declineMessage: 'Back Monday', allDay: true });
+    expect(details()).toEqual({
+      calendarId: 'work', from: '2026-10-01', to: '2026-10-05', allDay: true,
+      summary: 'Leave', declines: 'new conflicting invitations', declineMessage: 'Back Monday',
+    });
+    expect(callsTo('calendar', 'out-of-office')).toHaveLength(0);
+  });
+
+  it('refuses a client that cannot be prompted, pointing at autoDecline none', async () => {
+    process.env.MCP_CONFIRM_MODE = 'refuse';
+    const r = json(await (await unprompted()).callTool('gog_calendar_out_of_office', ARGS));
+    expect(r).toMatchObject({ reason: 'confirmation-unsupported', action: 'calendar.out-of-office' });
+    expect(r.note).toMatch(/autoDecline none/);
+    expect(lib.runOrDiagnose).not.toHaveBeenCalled();
+  });
+
+  it('token fallback: a changed message is DRAFT_CHANGED; the same call creates', async () => {
+    process.env.MCP_CONFIRM_MODE = 'ask-user';
+    stub({});
+    const harness = await unprompted();
+    const args = { ...ARGS, declineMessage: 'Away' };
+    const p1 = json(await harness.callTool('gog_calendar_out_of_office', args));
+    expect(p1.status).toBe('confirmation-required');
+    expect(json(await harness.callTool('gog_calendar_out_of_office', { ...args, declineMessage: 'Gone', confirmToken: p1.confirmToken })))
+      .toMatchObject({ error: 'DRAFT_CHANGED' });
+    await harness.callTool('gog_calendar_out_of_office', { ...args, confirmToken: p1.confirmToken });
+    expect(callsTo('calendar', 'out-of-office')).toHaveLength(1);
+  });
+});
+
+describe('gog_calendar_delete_calendar', () => {
+  const CAL = (etag = '"c1"') => JSON.stringify({ id: 'cal1', summary: 'Team offsite', etag });
+
+  it('reads the calendar and asks by name', async () => {
+    stub({ 'api call calendar': CAL() });
+    const { harness, details, seen } = await prompted();
+    await harness.callTool('gog_calendar_delete_calendar', { calendarId: 'cal1' });
+    expect(seen[0]!.params.message).toMatch(/PERMANENTLY/);
+    expect(details()).toEqual({ calendar: { id: 'cal1', summary: 'Team offsite' }, deletes: 'the calendar and every event on it, for good' });
+    expect(callsTo('api', 'call')[0]![0]).toEqual(['api', 'call', 'calendar', 'v3', 'calendars.get', '--params={"calendarId":"cal1"}']);
+    expect(callsTo('calendar', 'delete-calendar')).toHaveLength(1);
+  });
+
+  it('deletes nothing when the user declines, or when the read fails', async () => {
+    stub({ 'api call calendar': CAL() });
+    await (await prompted({ action: 'decline' })).harness.callTool('gog_calendar_delete_calendar', { calendarId: 'cal1' });
+    stub({}, 'api call calendar');
+    expect((await (await prompted()).harness.callTool('gog_calendar_delete_calendar', { calendarId: 'cal1' })).isError).toBe(true);
+    expect(callsTo('calendar', 'delete-calendar')).toHaveLength(0);
+  });
+
+  it('refuses a client that cannot be prompted', async () => {
+    process.env.MCP_CONFIRM_MODE = 'refuse';
+    stub({ 'api call calendar': CAL() });
+    const r = json(await (await unprompted()).callTool('gog_calendar_delete_calendar', { calendarId: 'cal1' }));
+    expect(r).toMatchObject({ reason: 'confirmation-unsupported', action: 'calendar.delete-calendar' });
+    expect(r.note).toMatch(/gog_calendar_unsubscribe/);
+  });
+
+  it('token fallback: a calendar changed between the phases (etag rotated) is DRAFT_CHANGED', async () => {
+    process.env.MCP_CONFIRM_MODE = 'ask-user';
+    stub({ 'api call calendar': CAL() });
+    const harness = await unprompted();
+    const p1 = json(await harness.callTool('gog_calendar_delete_calendar', { calendarId: 'cal1' }));
+    expect(p1.preview.calendar).toEqual({ id: 'cal1', summary: 'Team offsite' });
+    stub({ 'api call calendar': CAL('"c2"') });
+    expect(json(await harness.callTool('gog_calendar_delete_calendar', { calendarId: 'cal1', confirmToken: p1.confirmToken })))
+      .toMatchObject({ error: 'DRAFT_CHANGED' });
+    stub({ 'api call calendar': CAL() });
+    await harness.callTool('gog_calendar_delete_calendar', { calendarId: 'cal1', confirmToken: p1.confirmToken });
+    expect(callsTo('calendar', 'delete-calendar')).toHaveLength(1);
+  });
+
+  it('calendarSnapshot reads a bare or result-wrapped calendar and tolerates unreadable output', () => {
+    expect(calendarSnapshot(JSON.stringify({ result: { summary: 'X', etag: 'e' } }), 'c')).toEqual({ id: 'c', summary: 'X', etag: 'e' });
+    expect(calendarSnapshot('{"summary":7}', 'c')).toEqual({ id: 'c' });
+    expect(calendarSnapshot('null', 'c')).toEqual({ id: 'c' });
+    expect(calendarSnapshot('nope', 'c')).toEqual({ id: 'c' });
+  });
+});

package/tests/tools/calendar-extra.test.ts

@@ -18,7 +18,11 @@ let harness: TestHarness;
 beforeEach(async () => {
   vi.clearAllMocks();
   vi.mocked(lib.runOrDiagnose).mockResolvedValue(rawTextResult('{}'));
-  harness = await createTestHarness(registerExtraCalendarTools);
+  // The gated tools (move with sendUpdates, out-of-office, delete-calendar) are
+  // exercised prompt-by-prompt in calendar-extra-gates.test.ts; here the user accepts.
+  harness = await createTestHarness(registerExtraCalendarTools, {
+    elicitation: async () => ({ action: 'accept', content: { confirmed: true } }),
+  });
 });
 
 describe('gog_meet_create', () => {