mcp-google-multi 6.0.0-beta.3 → 6.0.0-beta.4

package/dist/tools/drive.js

@@ -24,9 +24,8 @@ const GOOGLE_WORKSPACE_TYPES = new Set([
     'application/vnd.google-apps.presentation',
     'application/vnd.google-apps.drawing',
 ]);
-// drive_read inlines only textual content. Beyond text/*, RFC 6839 structured-
-// syntax suffixes (+json/+xml/...) and a few bare application/* types are text
-// in practice — image/svg+xml was the motivating false "binary" refusal.
+// drive_read inlines only textual content; RFC 6839 +json/+xml/... suffixes and
+// a few bare application/* types count too (image/svg+xml was the motivating case).
 const TEXTUAL_EXACT = new Set([
     'application/json',
     'application/xml',
@@ -81,17 +80,14 @@ export const DRIVE_QUERY_HINT = "Drive search syntax: a plain keyword is treated
     "structured query needs an operator, e.g. \"name contains 'report'\", " +
     "\"mimeType = 'application/pdf'\", or \"'me' in owners\". " +
     'Reference: https://developers.google.com/drive/api/guides/search-files';
-// A bare keyword is not valid Drive `q` syntax (Google 400s "Invalid Value"), yet
-// it is the natural thing to pass to a "search" tool, so wrap it as a full-text
-// match. A query already carrying a comparison operator or a quoted literal is a
-// structured query and is passed through untouched.
+// A bare keyword isn't valid Drive `q` syntax (400s "Invalid Value"), so wrap it
+// as a full-text match; a query with a comparison operator is passed through untouched.
 export function normalizeDriveQuery(raw) {
     const q = raw.trim();
     if (q === '')
         return q;
-    // Structured iff it carries a comparison operator or the membership form
-    // "<value> in (parents|owners|writers|readers)". A bare apostrophe does NOT
-    // count (names like O'Brien are keywords, not query syntax).
+    // Structured iff it has a comparison operator or the membership form "<value> in
+    // (parents|owners|writers|readers)"; a bare apostrophe (e.g. O'Brien) doesn't count.
     const hasComparison = /(\bcontains\b|!=|<=|>=|[=<>])/i.test(q);
     const hasMembership = /\bin\s+(parents|owners|writers|readers)\b/i.test(q);
     if (hasComparison || hasMembership)
@@ -99,9 +95,8 @@ export function normalizeDriveQuery(raw) {
     const escaped = q.replace(/\\/g, '\\\\').replace(/'/g, "\\'");
     return `fullText contains '${escaped}'`;
 }
-// Drive rejects a malformed query with HTTP 400 / reason "invalid" and the opaque
-// message "Invalid Value"; detect that so drive_search returns query-syntax help
-// instead of a generic upstream_error.
+// Drive 400s a malformed query with the opaque reason "invalid"/"Invalid Value";
+// detect it so drive_search returns query-syntax help instead of a generic upstream_error.
 export function isDriveInvalidQuery(error) {
     const raw = error?.code ?? error?.status ?? error?.response?.status;
     const status = typeof raw === 'string' ? Number(raw) : raw;
@@ -122,9 +117,8 @@ export function resolveShareNotification(opts) {
     return opts.sendNotification ?? true;
 }
 export function registerDriveTools(server, deps = {}) {
-    // Per-registry, LIVE account enum + injectable client (S1.10): the
-    // schema follows the registry's account view at parse time, and the
-    // custody path is the context's, not the process global.
+    // Per-registry, live account enum + injectable client: the schema follows
+    // the registry's account view at parse time, not a process-global default.
     const accountEnum = accountArgLive(() => server.accountAliases()).optional();
     const requiredAccountEnum = accountArgLive(() => server.accountAliases());
     const getClientFn = deps.getClientFn ?? getClient;
@@ -144,8 +138,8 @@ export function registerDriveTools(server, deps = {}) {
         },
     }, async ({ account, query, maxResults, driveId, pageToken }) => {
         try {
-            // normalizeDriveQuery trims to '' and Drive reads that as "everything",
-            // so a blank query returned a raw directory listing as a search result.
+            // normalizeDriveQuery trims to '' and Drive reads that as "everything", so
+            // a blank query would list the whole drive as a "search" result.
             if (query.trim() === '') {
                 return invalidParams(account, '`query` is empty, and Drive reads an empty query as "match everything".', 'Pass a search term, or a structured Drive query such as "mimeType = \'application/pdf\'". To browse a folder instead, use drive_list.');
             }
@@ -154,9 +148,8 @@ export function registerDriveTools(server, deps = {}) {
             const params = {
                 q: normalizeDriveQuery(query),
                 pageSize: maxResults ?? 10,
-                // nextPageToken and incompleteSearch live OUTSIDE files(...): omit
-                // them from the mask and Drive drops them, so a partial result was
-                // indistinguishable from a complete one.
+                // nextPageToken and incompleteSearch live OUTSIDE files(...): omit them from
+                // the mask and Drive drops them, making a partial result indistinguishable from a complete one.
                 fields: 'nextPageToken,incompleteSearch,files(id,name,mimeType,modifiedTime,webViewLink,size,parents,driveId)',
                 supportsAllDrives: true,
                 includeItemsFromAllDrives: true,
@@ -182,9 +175,8 @@ export function registerDriveTools(server, deps = {}) {
         }
         catch (error) {
             if (isDriveInvalidQuery(error)) {
-                // Through safeMessage and stringifyEnvelope like every other
-                // envelope: this path used to read the upstream body directly, so a
-                // non-JSON response landed here uncapped.
+                // Goes through safeMessage/stringifyEnvelope like every other envelope
+                // so a non-JSON upstream response can't land here uncapped.
                 return {
                     content: [{ type: 'text', text: stringifyEnvelope({
                                 error: 'invalid_query',
@@ -685,9 +677,8 @@ export function registerDriveTools(server, deps = {}) {
         },
     }, async ({ account, fileId, type, role, emailAddress, domain, sendNotification, emailMessage, transferOwnership, expirationTime }) => {
         {
-            // Outbound allowlist (off unless GOOGLE_OUTBOUND_ALLOWLIST is set):
-            // user/group grantees must match; a domain share needs its exact
-            // "@domain" entry; "anyone" (link sharing) is refused while active.
+            // Outbound allowlist (off unless GOOGLE_OUTBOUND_ALLOWLIST is set): user/group
+            // grantees must match, a domain share needs its exact "@domain" entry, "anyone" is refused while active.
             const list = resolveOutboundAllowlist();
             if (list) {
                 if ((type === 'user' || type === 'group') && emailAddress) {

package/dist/tools/forms.js

@@ -5,9 +5,8 @@ import { getClient } from '../client.js';
 import { handleGoogleApiError } from './_errors.js';
 import { coerceArray, coerceBoolean, coerceJson } from './_coerce.js';
 export function registerFormsTools(server, deps = {}) {
-    // Per-registry, LIVE account enum + injectable client (S1.10): the
-    // schema follows the registry's account view at parse time, and the
-    // custody path is the context's, not the process global.
+    // Per-registry, live account enum + injectable client: the schema follows
+    // the registry's account view at parse time, not a process-global default.
     const accountEnum = accountArgLive(() => server.accountAliases()).optional();
     const getClientFn = deps.getClientFn ?? getClient;
     server.registerTool('forms_get', {

package/dist/tools/gmail-mime.d.ts

@@ -37,7 +37,7 @@ export declare class HeaderInjectionError extends Error {
     constructor(field: string);
 }
 /**
- * The single MIME-assembly seam for gmail_send and gmail_create_draft (A4).
+ * The single MIME-assembly seam for gmail_send and gmail_create_draft.
  * MailComposer owns header/RFC-2047/address encoding and boundary generation,
  * which closes the CRLF header-injection hole in the old hand-rolled encoders.
  * A deterministic pre-check rejects CR/LF in address/subject headers with a

package/dist/tools/gmail-mime.js

@@ -3,10 +3,8 @@ import MarkdownIt from 'markdown-it';
 import TurndownService from 'turndown';
 // @ts-expect-error turndown-plugin-gfm ships no type declarations
 import { gfm } from 'turndown-plugin-gfm';
-// D6 send: one symmetric text format. body is Markdown; text/plain = the
-// source verbatim, text/html = this render. html:false ESCAPES raw HTML in
-// the body (the XSS-safe default); allowRawHtml swaps to the html:true
-// instance so an audited caller can pass literal HTML (e.g. inline color).
+// Send: body is Markdown; text/plain is the source, text/html is this render.
+// html:false escapes raw HTML in the body (XSS-safe default); allowRawHtml opts into html:true for an audited caller.
 const mdSafe = new MarkdownIt({ html: false, linkify: true });
 const mdRaw = new MarkdownIt({ html: true, linkify: true });
 export function renderMarkdown(body, allowRawHtml = false) {
@@ -87,10 +85,8 @@ export function htmlToText(html) {
         .replace(/\n{3,}/g, '\n\n')
         .trim();
 }
-// D6 read: HTML-only bodies convert to Markdown so the model reads structure
-// (headings, links, lists, GFM tables), not a flat text dump. turndown's
-// bundled @mixmark-io/domino fork does NOT execute scripts; remove() drops
-// script/style/head entirely (turndown otherwise leaks their text content).
+// HTML-only bodies convert to Markdown so the model reads structure, not a flat
+// text dump; turndown's bundled domino fork doesn't execute scripts, and remove() drops script/style/head (which otherwise leak text).
 const turndownService = new TurndownService({ headingStyle: 'atx', codeBlockStyle: 'fenced', bulletListMarker: '-' });
 turndownService.use(gfm);
 turndownService.remove(['script', 'style', 'head']);
@@ -125,7 +121,7 @@ export class HeaderInjectionError extends Error {
     }
 }
 /**
- * The single MIME-assembly seam for gmail_send and gmail_create_draft (A4).
+ * The single MIME-assembly seam for gmail_send and gmail_create_draft.
  * MailComposer owns header/RFC-2047/address encoding and boundary generation,
  * which closes the CRLF header-injection hole in the old hand-rolled encoders.
  * A deterministic pre-check rejects CR/LF in address/subject headers with a
@@ -152,9 +148,8 @@ export async function composeRaw(input) {
         attachments: input.attachments,
         newline: '\r\n',
         textEncoding: 'base64',
-        // This server reads any attachment file itself and passes a Buffer;
-        // MailComposer must never touch the filesystem or network (SSRF / local
-        // file-read defense-in-depth).
+        // This server reads attachment files itself and passes a Buffer; MailComposer
+        // must never touch the filesystem or network (SSRF / local file-read defense-in-depth).
         disableFileAccess: true,
         disableUrlAccess: true,
     };

package/dist/tools/gmail.d.ts

@@ -16,7 +16,7 @@ interface ReplyDerivation {
 }
 /** Fetch the reply source once and derive threading headers plus (auto-fill)
  * to/cc/subject. On any fetch failure, degrade to the API id for threading and
- * report sourceFound:false so the caller can decide (per A8 error dispositions). */
+ * report sourceFound:false so the caller can decide. */
 export declare function resolveReply(gmail: any, account: string, primaryEmail: string, replyToMessageId: string, replyAll: boolean): Promise<ReplyDerivation>;
 export declare function readAttachments(raw: Array<{
     path: string;
@@ -27,7 +27,7 @@ export declare function parseMessage(msg: any, bodyCap?: number, opts?: {
     rawHtml?: boolean;
 }): GmailMessageFull;
 /**
- * A9 gmail_read_batch core: fetch N ids with bounded parallelism, parse each,
+ * gmail_read_batch core: fetch N ids with bounded parallelism, parse each,
  * and bound the aggregate output. Order is preserved by input index. A per-id
  * failure becomes a `{ id, error }` entry; an account-wide auth/scope failure
  * is rethrown so the caller maps it to a whole-call isError. Returns the

package/dist/tools/gmail.js

@@ -38,16 +38,15 @@ function decodeBody(payload, rawHtml = false) {
     const plain = [];
     const html = [];
     collectTextParts(payload, plain, html, true);
-    // Concatenating every plain leaf keeps forwarded/mixed messages whole;
-    // any plain content beats HTML because alternatives duplicate the same body.
-    // A plain leaf is returned verbatim (byte-identical to v5).
+    // Concatenating every plain leaf keeps forwarded/mixed messages whole; plain
+    // always wins over HTML since alternatives duplicate the same body.
     if (plain.length > 0)
         return { body: plain.join('\n\n'), bodyFormat: 'plain' };
     if (html.length > 0) {
         const joined = html.join('\n\n');
         if (rawHtml)
             return { body: joined, bodyFormat: 'html' };
-        // HTML-only -> Markdown (D6). turndown failure degrades to plain text.
+        // HTML-only -> Markdown. turndown failure degrades to plain text.
         const { text, ok } = htmlToMarkdown(joined);
         return { body: text, bodyFormat: ok ? 'markdown' : 'plain' };
     }
@@ -91,9 +90,8 @@ function parseAddresses(headerValue) {
     return out;
 }
 const normAddr = (a) => a.trim().toLowerCase();
-/** Rebuild a comma-separated address header; composeRaw/MailComposer re-encodes
- * names (RFC 2047) and the A4 CRLF pre-check applies, so derived recipients get
- * the same header-injection guard as caller-supplied ones. */
+/** Rebuilds a comma-separated address header; composeRaw/MailComposer re-encodes
+ * names and apply the same header-injection guard as caller-supplied recipients. */
 function formatAddresses(list) {
     return list.map((a) => (a.name ? `${a.name} <${a.address}>` : a.address)).join(', ');
 }
@@ -103,10 +101,8 @@ export function deriveReplySubject(sourceSubject) {
     const s = sourceSubject.trim();
     return /^re:/i.test(s) ? s : `Re: ${s}`;
 }
-// The account's own-address set (primary + Gmail send-as aliases) used to
-// exclude the caller from reply-all. Send-as rarely changes, so memoize per
-// process; a stale miss only costs one extra self-copy, never a wrong send.
-// Keyed by alias AND mailbox: two contexts can share an alias name.
+// Own-address set (primary + send-as aliases) for excluding the caller from
+// reply-all; memoized per-process (a stale miss just costs one self-copy), keyed by alias+mailbox.
 const ownAddressCache = new Map();
 function getOwnAddresses(gmail, account, primaryEmail) {
     const key = `${account} ${normAddr(primaryEmail)}`;
@@ -122,7 +118,7 @@ function getOwnAddresses(gmail, account, primaryEmail) {
                 }
             }
             catch {
-                // insufficient_scope / 5xx: degrade to the primary alone, never block the send.
+                // insufficient_scope/5xx: degrade silently
             }
             return set;
         })();
@@ -132,7 +128,7 @@ function getOwnAddresses(gmail, account, primaryEmail) {
 }
 /** Fetch the reply source once and derive threading headers plus (auto-fill)
  * to/cc/subject. On any fetch failure, degrade to the API id for threading and
- * report sourceFound:false so the caller can decide (per A8 error dispositions). */
+ * report sourceFound:false so the caller can decide. */
 export async function resolveReply(gmail, account, primaryEmail, replyToMessageId, replyAll) {
     let headers;
     try {
@@ -145,7 +141,7 @@ export async function resolveReply(gmail, account, primaryEmail, replyToMessageI
         headers = meta.data.payload?.headers;
     }
     catch {
-        // Degrade to the API id (pre-lookup behavior) rather than blocking the send.
+        // Degrade to the API id rather than blocking the send.
         return { inReplyTo: replyToMessageId, references: replyToMessageId, sourceFound: false };
     }
     const threading = buildReplyHeaders(replyToMessageId, getHeader(headers, 'Message-ID'), getHeader(headers, 'References'));
@@ -181,15 +177,11 @@ export async function resolveReply(gmail, account, primaryEmail, replyToMessageI
     };
 }
 const BODY_CAP_CHARS = 50_000;
-// gmail_read_batch aggregate ceiling: a batch of up to 100 messages must never
-// blow the context window, so the summed serialized output is bounded here
-// (matches the tool's anthropic/maxResultSizeChars hint). Per-message bodies are
-// still individually capped at BODY_CAP_CHARS first.
+// gmail_read_batch aggregate ceiling: bounds the summed serialized output so a
+// 100-message batch can't blow the context window (per-message bodies are capped at BODY_CAP_CHARS first).
 const BATCH_MAX_RESULT_CHARS = 100_000;
-// Gmail's messages.send raw/JSON path rejects messages near ~25 MB (the wire
-// message is base64-encoded, ~+33% over the raw bytes), so cap the ESTIMATED
-// ENCODED total there rather than the spec's nominal 35 MB raw (spike/live
-// correction — a 35 MB raw payload is ~47 MB on the wire and Gmail 400s it).
+// messages.send rejects near ~25MB on the wire (base64 adds ~33%), so cap the
+// estimated ENCODED total here rather than the nominal 35MB raw limit, which 400s at ~47MB wire.
 const GMAIL_MAX_MESSAGE_BYTES = 25 * 1024 * 1024;
 const estimateEncoded = (rawBytes) => Math.ceil((rawBytes * 4) / 3);
 const attachmentSchema = z
@@ -203,10 +195,8 @@ const attachmentSchema = z
 /** Reads attachment files into buffers (THIS server reads them, never
  * MailComposer), enforces absolute-path + total-size guards, and derives the
  * MIME filename via basename so a caller name can't inject path separators. */
-// Deny reading anything inside the server's own secret dirs — mailing out
-// master.key / <alias>.enc / mcp-jwt.key would be a full-account-takeover
-// exfil channel (this same server also reads untrusted mail/drive content, so
-// a prompt-injected attach path is a real confused-deputy vector).
+// Deny reading inside the server's own secret dirs; mailing out master.key /
+// <alias>.enc / mcp-jwt.key would be account takeover (also guards against a prompt-injected attach path).
 function isInside(dir, target) {
     let d = path.resolve(dir);
     let t = path.resolve(target);
@@ -280,9 +270,8 @@ export async function readAttachments(raw, bodyBytes) {
     }
     return out;
 }
-/** Tagged compose-time failure; the handlers map it to an isError envelope.
- * `category` is the taxonomy error field (default validation_error); reply
- * auto-fill raises it as not_found when a source message can't be fetched. */
+/** Tagged compose-time failure mapped to an isError envelope; `category`
+ * defaults to validation_error (reply auto-fill raises not_found instead). */
 class GmailComposeError extends Error {
     slug;
     category;
@@ -336,7 +325,7 @@ export function parseMessage(msg, bodyCap, opts) {
     };
 }
 /**
- * A9 gmail_read_batch core: fetch N ids with bounded parallelism, parse each,
+ * gmail_read_batch core: fetch N ids with bounded parallelism, parse each,
  * and bound the aggregate output. Order is preserved by input index. A per-id
  * failure becomes a `{ id, error }` entry; an account-wide auth/scope failure
  * is rethrown so the caller maps it to a whole-call isError. Returns the
@@ -383,9 +372,8 @@ export async function readBatch(gmail, account, ids, full, rawHtml) {
             }
         }
     }
-    // Aggregate guard: walk in order, accumulating serialized size. Once the
-    // running total would exceed the maxResultSizeChars budget, cap this and every
-    // later success body so a big batch never blows the context window.
+    // Aggregate guard: walk in order accumulating serialized size; once the running
+    // total would exceed the budget, cap this and every later success body so the batch never blows the context window.
     let running = 0;
     let truncatedAny = false;
     let exhausted = false;
@@ -438,9 +426,8 @@ export function compactMessageRow(m) {
     };
 }
 export function registerGmailTools(server, deps = {}) {
-    // Per-registry, LIVE account enum + injectable client (S1.10): the
-    // schema follows the registry's account view at parse time, and the
-    // custody path is the context's, not the process global.
+    // Per-registry, live account enum + injectable client: the schema follows
+    // the registry's account view at parse time, not a process-global default.
     const accountEnum = accountArgLive(() => server.accountAliases()).optional();
     const getClientFn = deps.getClientFn ?? getClient;
     const localFiles = deps.localFiles ?? true;
@@ -450,7 +437,7 @@ export function registerGmailTools(server, deps = {}) {
             'pass full=true for threadId, to, labelIds and the untruncated snippet.',
         inputSchema: {
             account: accountEnum.describe('Google account alias'),
-            query: z.string().describe('Gmail search syntax, e.g. "from:monaam is:unread"'),
+            query: z.string().describe('Gmail search syntax, e.g. "from:alice is:unread"'),
             maxResults: coerceNumber(z.number().min(1).max(100)).optional()
                 .describe('Max results to return (default: 20, max: 100)'),
             full: coerceBoolean.optional().describe('Return the full row shape instead of the compact default'),
@@ -494,9 +481,8 @@ export function registerGmailTools(server, deps = {}) {
                     });
                 }
             }
-            // Search is a pick-one-message step ~always followed by gmail_read;
-            // the compact row is the selection signal, the rest was measured burn
-            // (p90 14.4k chars per call). full=true restores the pre-6.0 shape.
+            // Search is a pick-one-message step almost always followed by gmail_read;
+            // the compact row is the selection signal (full=true returns the previous, heavier row).
             const rows = full === true ? results : results.map(compactMessageRow);
             return {
                 content: [{ type: 'text', text: JSON.stringify(rows, null, 2) }],

package/dist/tools/google-api.js

@@ -64,7 +64,7 @@ function describeMethod(m) {
     };
 }
 export function registerEscapeTools(registry, policy, deps = {}) {
-    // Live per-registry account validation (S1.10), same as the curated files.
+    // Live per-registry account validation, same as the curated files.
     const accountEnum = accountArgLive(() => registry.accountAliases()).optional();
     const getClientFn = deps.getClientFn ?? getClient;
     const toolsets = deps.toolsets ?? getToolsets();
@@ -178,9 +178,8 @@ export function registerEscapeTools(registry, policy, deps = {}) {
         }
         let method = index.find((m) => m.id === methodId);
         if (!method) {
-            // Some discovery docs keep a legacy id prefix (the searchconsole doc's
-            // methods are webmasters.*): when the caller prefixed with our api
-            // alias, retry under the doc's own prefix before failing.
+            // Some discovery docs keep a legacy id prefix (searchconsole's methods are
+            // webmasters.*): retry under the doc's own prefix if the caller used our api alias.
             const docPrefix = index[0]?.id.split('.')[0];
             const [head, ...rest] = String(methodId).split('.');
             if (docPrefix && (head === apiKey || head === api) && head !== docPrefix && rest.length > 0) {
@@ -205,9 +204,8 @@ export function registerEscapeTools(registry, policy, deps = {}) {
         const cud = cudFromMethod(method);
         const policyService = serviceForAlias(apiKey);
         const lastSegment = method.id.split('.').pop() ?? method.id;
-        // The escape hatch self-gates, so it needs the same scope signal the
-        // registry wrapper gets; without it a privileged method would slip past
-        // safe-writes here while its generated twin is refused.
+        // The escape hatch self-gates, so it needs the same scope signal as the registry
+        // wrapper, or a privileged method would slip past safe-writes here while its generated twin is refused.
         const toolRef = { name: `${policyService}_${lastSegment}`, service: policyService, cud, scopes: method.scopes };
         if (cud !== 'read' && !isAllowed(toolRef, policy)) {
             return writeDisabledResult(toolRef, policy, account);

package/dist/tools/meet.js

@@ -4,9 +4,8 @@ import { accountArgLive } from '../accounts.js';
 import { getClient } from '../client.js';
 import { handleGoogleApiError } from './_errors.js';
 export function registerMeetTools(server, deps = {}) {
-    // Per-registry, LIVE account enum + injectable client (S1.10): the
-    // schema follows the registry's account view at parse time, and the
-    // custody path is the context's, not the process global.
+    // Per-registry, live account enum + injectable client: the schema follows
+    // the registry's account view at parse time, not a process-global default.
     const accountEnum = accountArgLive(() => server.accountAliases()).optional();
     const getClientFn = deps.getClientFn ?? getClient;
     // ─── Conference records (past meetings) ────────────────────────────────

package/dist/tools/searchconsole.js

@@ -6,9 +6,8 @@ import { accountArgLive } from '../accounts.js';
 import { getClient } from '../client.js';
 import { handleGoogleApiError } from './_errors.js';
 export function registerSearchConsoleTools(server, deps = {}) {
-    // Per-registry, LIVE account enum + injectable client (S1.10): the
-    // schema follows the registry's account view at parse time, and the
-    // custody path is the context's, not the process global.
+    // Per-registry, live account enum + injectable client: the schema follows
+    // the registry's account view at parse time, not a process-global default.
     const accountEnum = accountArgLive(() => server.accountAliases()).optional();
     const getClientFn = deps.getClientFn ?? getClient;
     // ─── Sites ───────────────────────────────────────────────

package/dist/tools/sheets.js

@@ -5,9 +5,8 @@ import { accountArgLive } from '../accounts.js';
 import { getClient } from '../client.js';
 import { handleGoogleApiError, invalidParams } from './_errors.js';
 export function registerSheetsTools(server, deps = {}) {
-    // Per-registry, LIVE account enum + injectable client (S1.10): the
-    // schema follows the registry's account view at parse time, and the
-    // custody path is the context's, not the process global.
+    // Per-registry, live account enum + injectable client: the schema follows
+    // the registry's account view at parse time, not a process-global default.
     const accountEnum = accountArgLive(() => server.accountAliases()).optional();
     const getClientFn = deps.getClientFn ?? getClient;
     server.registerTool('sheets_create', {

package/dist/tools/slides.js

@@ -7,9 +7,8 @@ import { coerceArray, coerceBoolean, coerceJson } from './_coerce.js';
 import { sliceClean } from '../trim.js';
 const SLIDE_TEXT_DIGEST_CHARS = 200;
 export function registerSlidesTools(server, deps = {}) {
-    // Per-registry, LIVE account enum + injectable client (S1.10): the
-    // schema follows the registry's account view at parse time, and the
-    // custody path is the context's, not the process global.
+    // Per-registry, live account enum + injectable client: the schema follows
+    // the registry's account view at parse time, not a process-global default.
     const accountEnum = accountArgLive(() => server.accountAliases()).optional();
     const getClientFn = deps.getClientFn ?? getClient;
     server.registerTool('slides_create', {

package/dist/tools/tasks.js

@@ -5,9 +5,8 @@ import { accountArgLive } from '../accounts.js';
 import { getClient } from '../client.js';
 import { handleGoogleApiError, invalidParams } from './_errors.js';
 export function registerTasksTools(server, deps = {}) {
-    // Per-registry, LIVE account enum + injectable client (S1.10): the
-    // schema follows the registry's account view at parse time, and the
-    // custody path is the context's, not the process global.
+    // Per-registry, live account enum + injectable client: the schema follows
+    // the registry's account view at parse time, not a process-global default.
     const accountEnum = accountArgLive(() => server.accountAliases()).optional();
     const getClientFn = deps.getClientFn ?? getClient;
     // ─── Tasklists ─────────────────────────────────────────────────────────

package/dist/trim.js

@@ -11,9 +11,8 @@ export function sliceClean(text, max) {
     const sliced = text.slice(0, max);
     return /[\uD800-\uDBFF]$/.test(sliced) ? sliced.slice(0, -1) : sliced;
 }
-// C0, DEL and C1 (NEL, 8-bit CSI and OSC) can end a line or drive a terminal;
-// the line and paragraph separators end a line for many readers; the bidi and
-// invisible format controls make a line read differently from its bytes.
+// C0/C1/DEL can end a line or drive a terminal; bidi/invisible format
+// controls make a line read differently from its bytes.
 const LOG_UNSAFE = /[\p{Cc}\u061c\u200e\u200f\u202a-\u202e\u2028\u2029\u2066-\u2069]/gu;
 /** An untrusted value made fit for one log line: never throws, at most `max`
  * characters of it (then `...(len=N)`), each unsafe character as a literal

package/dist/usage-metrics.js

@@ -4,14 +4,8 @@ import * as os from 'node:os';
 import { randomBytes } from 'node:crypto';
 import { performance } from 'node:perf_hooks';
 import { withFileLock, atomicWriteFileSync } from './fs-atomic.js';
-// Local usage metrics (metrics-feature-spec.md). Default OFF at every layer;
-// when off, nothing here initializes and the dispatch chain carries no wrapper.
-// Zero network egress is structural: this module's import set is a tested
-// allowlist (fs/path/os/crypto/perf_hooks/fs-atomic), so egress code cannot
-// even be expressed here. Every string persisted is a member of a server-owned
-// closed vocabulary, matches a pinned shape regex, or is other/unknown_*/
-// _overflow; free text is unrepresentable in the file format. No identity
-// dimension of any kind: no aliases, hashes, emails, or exact account counts.
+// Local usage metrics, default OFF; zero network egress is structural (a
+// tested import allowlist). See docs/usage-metrics.md.
 export const METRICS_DIR_NAME = 'metrics';
 const FLUSH_MS = 60_000;
 const RETRY_WINDOW_MS = 10 * 60_000;
@@ -26,7 +20,7 @@ const WRITE_FAILURE_LIMIT = 3;
 const LAT_BOUNDS = [100, 250, 500, 1000, 2500, 5000, 10000, 30000];
 const CHARS_BOUNDS = [64, 256, 1024, 4096, 16384, 65536];
 // methodId backstop shape gate: even a tampered discovery cache cannot turn
-// arbitrary strings into recorded values (spec section 1).
+// arbitrary strings into recorded values.
 const METHOD_ID_RE = /^[a-z][a-zA-Z0-9]*(\.[a-zA-Z0-9]+)+$/;
 const METHOD_ID_MAX = 128;
 const TOOL_NAME_RE = /^[a-z][a-z0-9_]{0,63}$/;
@@ -366,9 +360,8 @@ export class Metrics {
             f.calls += 1;
             addInto(f, fan);
         }
-        // retry self-correction chain (spec section 1): in-memory only. Both
-        // chains link consecutive calls, so they only run when one caller owns
-        // the process (sequencingEnabled).
+        // retry self-correction chain, in-memory only; links consecutive calls,
+        // so it only runs when one caller owns the process (sequencingEnabled).
         const nowM = this.mono();
         if (this.sequencing) {
             const prev = this.lastError.get(entry.name);

package/dist/write-control.d.ts

@@ -7,12 +7,11 @@ export interface Policy {
     allow: string[];
     deny: string[];
     /**
-     * B14 reserved seam (cc-write-control "HTTP posture", LOCKED to OQ-5
-     * "annotations only"): the dispatch transport is threaded into the resolved
-     * policy for the EE/future seam, but in v6 alpha it does NOT stiffen the
+     * Reserved seam (HTTP posture is "annotations only"): the dispatch
+     * transport is threaded into the resolved policy for a future seam, but in v6 alpha it does NOT stiffen the
      * profile or alter any `isAllowed` verdict. "Stricter on HTTP" is achieved
      * entirely by the `anthropic/requiresUserInteraction` annotation on the
-     * irreversible set (A12), emitted identically on both transports.
+     * irreversible set, emitted identically on both transports.
      * Optional so existing Policy literals (codegen/tests) need no change;
      * resolvePolicy always populates it.
      */
@@ -22,12 +21,9 @@ interface ToolRef {
     name: string;
     service: string;
     cud: Cud;
-    /** The method's required OAuth scopes, when the caller knows them. Absent
-     * means "unknown", which is treated as not privileged: a missing scope list
-     * must not silently widen the gate OR silently break an ordinary write. */
     scopes?: readonly string[];
 }
-/** The irreversible set (frozen, cc-write-control): real sends leave the
+/** The irreversible set (frozen): real sends leave the
  * user's (or org's) identity unrecallably; permanent deletes bypass Trash.
  * Includes the callable GENERATED twins of the curated ops — the surface is
  * always callable by name, so a prompt-free twin would defeat the layer.

package/dist/write-control.js

@@ -1,6 +1,6 @@
 import { hints } from './hint-provider.js';
 const PROFILES = ['read-only', 'safe-writes', 'full-writes'];
-/** The irreversible set (frozen, cc-write-control): real sends leave the
+/** The irreversible set (frozen): real sends leave the
  * user's (or org's) identity unrecallably; permanent deletes bypass Trash.
  * Includes the callable GENERATED twins of the curated ops — the surface is
  * always callable by name, so a prompt-free twin would defeat the layer.
@@ -64,9 +64,8 @@ function firstMatch(tool, globs) {
 function matchesAny(tool, globs) {
     return firstMatch(tool, globs) !== undefined;
 }
-/** Scopes that authorize acting on the whole organization, on legal holds, on
- * billing, or on deployed code. A write behind one of these is not a "safe"
- * write in any useful sense of the word, whatever its HTTP verb. */
+// Scopes that authorize acting on the whole organization, legal holds,
+// billing, or deployed code: not a "safe" write, whatever its HTTP verb.
 const PRIVILEGED_SCOPE_RE = /\/auth\/(admin\.directory|admin\.datatransfer|cloud-identity|apps\.licensing|apps\.order|apps\.groups\.settings|apps\.groups\.migration|ediscovery|script\.projects|script\.deployments)/;
 /** Registering a push channel hands this account's activity to an external URL.
  * It is shaped like a create and behaves like an export, so the verb hides it. */