gogcli-mcp 4.4.0 → 4.5.1

package/tests/tools/docs.test.ts

@@ -19,13 +19,13 @@ describe('gog_docs_info', () => {
     expect(result.content[0].text).toContain('My Doc');
   });
 
-  it('appends auth list on failure when auth list succeeds', async () => {
+  it('appends the account list only on an auth failure', async () => {
     vi.mocked(runner.run)
-      .mockRejectedValueOnce(new Error('Doc not found'))
-      .mockResolvedValueOnce('user@gmail.com');
+      .mockRejectedValueOnce(new Error('Doc not found'));
     const harness = await setupHandlers();
     const result = await harness.callTool('gog_docs_info', { docId: 'bad' });
-    expect(result.content[0].text).toBe('Error: Doc not found\n\nConfigured accounts:\nuser@gmail.com');
+    expect(result.content[0].text).toBe('Error: Doc not found');
+    expect(runner.run).toHaveBeenCalledTimes(1);
   });
 
   it('returns plain error text when auth list also fails', async () => {
@@ -37,8 +37,7 @@ describe('gog_docs_info', () => {
 
   it('handles non-Error rejection', async () => {
     vi.mocked(runner.run)
-      .mockRejectedValueOnce('raw error string')
-      .mockRejectedValueOnce(new Error('auth list failed'));
+      .mockRejectedValueOnce('raw error string');
     const harness = await setupHandlers();
     const result = await harness.callTool('gog_docs_info', { docId: 'bad' });
     expect(result.content[0].text).toBe('raw error string');

package/tests/tools/drive.test.ts

@@ -433,7 +433,6 @@ describe('gog_drive_extract_text', () => {
       .mockResolvedValueOnce(PDF_META)                              // drive get
       .mockResolvedValueOnce(JSON.stringify({ id: 'tmpDoc3' }))     // files.copy
       .mockRejectedValueOnce(new Error('export exploded'))          // files.export fails
-      .mockResolvedValueOnce('user@x.com')                          // diagnose -> auth list
       .mockResolvedValueOnce('deleted');                            // cleanup delete
     const harness = await setupHandlers();
     const result = await harness.callTool('gog_drive_extract_text', { fileId: 'pdf1' });
@@ -445,8 +444,7 @@ describe('gog_drive_extract_text', () => {
   it('errors clearly when OCR conversion returns no id (and creates nothing to clean up)', async () => {
     vi.mocked(runner.run)
       .mockResolvedValueOnce(PDF_META)               // drive get
-      .mockResolvedValueOnce('{}')                   // files.copy: no id
-      .mockResolvedValueOnce('user@x.com');          // diagnose -> auth list
+      .mockResolvedValueOnce('{}');                  // files.copy: no id
     const harness = await setupHandlers();
     const result = await harness.callTool('gog_drive_extract_text', { fileId: 'pdf1' });
     expect(result.isError).toBe(true);
@@ -560,8 +558,7 @@ describe('gog_drive_read_bytes', () => {
 
   it('surfaces a byte-fetch failure via diagnose', async () => {
     vi.mocked(runner.run)
-      .mockResolvedValueOnce(JSON.stringify({ file: { name: 'a.pdf', mimeType: 'application/pdf' } }))
-      .mockResolvedValueOnce('user@x.com'); // diagnose -> auth list
+      .mockResolvedValueOnce(JSON.stringify({ file: { name: 'a.pdf', mimeType: 'application/pdf' } }));
     vi.mocked(runner.runBinary).mockRejectedValueOnce(new Error('gog exited with code 1'));
     const harness = await setupHandlers();
     const result = await harness.callTool('gog_drive_read_bytes', { fileId: 'f1' });

package/tests/tools/gmail-confirm-token.test.ts

@@ -23,9 +23,9 @@ let fileRoot: string;
 beforeEach(() => {
   vi.clearAllMocks();
   process.env = { ...ORIGINAL_ENV };
-  delete process.env.GOG_SEND_CONFIRM_FALLBACK;
-  delete process.env.GOG_CONFIRM_TTL_SECONDS;
-  delete process.env.GOG_CONFIRM_SECRET;
+  delete process.env.MCP_CONFIRM_MODE;
+  delete process.env.MCP_CONFIRM_TTL_SECONDS;
+  delete process.env.MCP_CONFIRM_SECRET;
   process.env.GOG_ACCOUNT = 'me@example.com';
   fileRoot = mkdtempSync(join(tmpdir(), 'gct-roots-'));
   process.env.GOG_FILE_ROOTS = fileRoot;
@@ -58,24 +58,26 @@ const sendCalls = () => vi.mocked(runner.run).mock.calls.filter(([args]) => args
 
 describe('gog_gmail_send — token fallback', () => {
   it('elicitation supported: unchanged — prompts and sends, confirmToken or not', async () => {
-    process.env.GOG_SEND_CONFIRM_FALLBACK = 'token';
+    process.env.MCP_CONFIRM_MODE = 'ask-user';
     vi.mocked(runner.run).mockResolvedValue(SENT);
     const harness = await withElicitation();
-    const result = await harness.callTool('gog_gmail_send', { ...SEND_ARGS, confirmToken: 'gct1.not.real' });
+    const result = await harness.callTool('gog_gmail_send', { ...SEND_ARGS, confirmToken: 'not-a-real-token' });
     expect(result.content[0]!.text).toBe(SENT);
     expect(sendCalls()).toHaveLength(1);
   });
 
-  it('unsupported + env unset: refuses, with the new hint', async () => {
+  it('unsupported + MCP_CONFIRM_MODE=refuse: refuses, naming the switch', async () => {
+
+    process.env.MCP_CONFIRM_MODE = 'refuse';
     const harness = await noElicitation();
     const body = json(await harness.callTool('gog_gmail_send', SEND_ARGS));
     expect(body).toMatchObject({ confirmed: false, dispatched: false, reason: 'confirmation-unsupported' });
-    expect(body.note).toContain('set GOG_SEND_CONFIRM_FALLBACK=token to enable two-step confirmation');
+    expect(body.note).toContain('Set MCP_CONFIRM_MODE=ask-user');
     expect(runner.run).not.toHaveBeenCalled();
   });
 
-  describe('unsupported + GOG_SEND_CONFIRM_FALLBACK=token', () => {
-    beforeEach(() => { process.env.GOG_SEND_CONFIRM_FALLBACK = 'token'; });
+  describe('unsupported + MCP_CONFIRM_MODE=ask-user', () => {
+    beforeEach(() => { process.env.MCP_CONFIRM_MODE = 'ask-user'; });
 
     it('phase 1 previews everything (Bcc included, full body) and sends nothing', async () => {
       const long = `${'x'.repeat(5000)}END`;
@@ -101,7 +103,7 @@ describe('gog_gmail_send — token fallback', () => {
         inReplyTo: 'm0',
         quotesOriginal: false,
       });
-      expect(body.confirmToken).toMatch(/^gct1\./);
+      expect(body.confirmToken).toMatch(/^mcpu\.token\.v1\./);
       expect(body.instruction).toMatch(/verbatim/);
       expect(runner.run).not.toHaveBeenCalled();
     });
@@ -185,7 +187,7 @@ describe.each([
   });
   const replyCalls = () => vi.mocked(runner.run).mock.calls.filter(([args]) => args[1] === subcommand);
 
-  beforeEach(() => { process.env.GOG_SEND_CONFIRM_FALLBACK = 'token'; });
+  beforeEach(() => { process.env.MCP_CONFIRM_MODE = 'ask-user'; });
 
   it('phase 1 previews the resolved recipients, Bcc, full body and In-Reply-To; nothing sent', async () => {
     vi.mocked(runner.run).mockResolvedValue(metadata());

package/tests/tools/run-vets-more.test.ts

@@ -0,0 +1,269 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { createTestHarness } from '@chrischall/mcp-utils/test';
+import * as runner from '../../src/runner.js';
+import { registerChatTools, vetChatRun } from '../../src/tools/chat.js';
+import { registerDriveTools, vetDriveRun } from '../../src/tools/drive.js';
+import { registerClassroomTools, vetClassroomRun } from '../../src/tools/classroom.js';
+import { registerCalendarTools, vetCalendarRun } from '../../src/tools/calendar.js';
+import { registerGmailTools, vetGmailRun } from '../../src/tools/gmail.js';
+import { registerDocsTools, vetDocsRun } from '../../src/tools/docs.js';
+import { registerSheetsTools, vetSheetsRun } from '../../src/tools/sheets.js';
+import { registerAppScriptTools, vetAppScriptRun } from '../../src/tools/appscript.js';
+import { refusedApiCall } from '../../src/tools/api.js';
+
+vi.mock('../../src/runner.js');
+
+// ============================================================================
+// The second wave of gates (fleet audit 2026-09-24 SEC-6) is refused by the
+// escape hatches under every alias gog 0.41.0 accepts for it, so
+// gog_<service>_run is not a way around a prompt the dedicated tool shows.
+// ============================================================================
+
+beforeEach(() => vi.clearAllMocks());
+
+describe('vetCalendarRun — move, out-of-office, delete, delete-calendar', () => {
+  it.each([
+    ['move', 'gog_calendar_move'],
+    ['transfer', 'gog_calendar_move'],
+    ['out-of-office', 'gog_calendar_out_of_office'],
+    ['OOO', 'gog_calendar_out_of_office'],
+    ['delete', 'gog_calendar_delete'],
+    ['del', 'gog_calendar_delete'],
+    ['remove', 'gog_calendar_delete'],
+    ['rm', 'gog_calendar_delete'],
+    ['delete-calendar', 'gog_calendar_delete_calendar'],
+  ])('refuses %s in favour of %s', (sub, tool) => {
+    expect(vetCalendarRun(sub, ['primary', 'e1'])).toMatch(new RegExp(`${tool}.*asks the user`));
+  });
+
+  it.each(['events', 'freebusy', 'calendars', 'unsubscribe', 'event'])('still allows %s', (sub) => {
+    expect(vetCalendarRun(sub, ['primary'])).toBeUndefined();
+  });
+});
+
+describe('vetClassroomRun — roster, coursework, submissions and course deletes', () => {
+  it.each([
+    ['students', ['add', 'c1', 'u1'], 'gog_classroom_students_add'],
+    ['student', ['create', 'c1', 'u1'], 'gog_classroom_students_add'],
+    ['students', ['NEW', 'c1', 'u1'], 'gog_classroom_students_add'],
+    ['teachers', ['add', 'c1', 'u1'], 'gog_classroom_teachers_add'],
+    ['teacher', ['new', 'c1', 'u1'], 'gog_classroom_teachers_add'],
+    ['submissions', ['return', 'c1', 'w1', 's1'], 'gog_classroom_submissions_return'],
+    ['submission', ['send', 'c1', 'w1', 's1'], 'gog_classroom_submissions_return'],
+    ['coursework', ['create', 'c1', '--title=HW'], 'gog_classroom_coursework_create'],
+    ['work', ['add', 'c1'], 'gog_classroom_coursework_create'],
+    ['coursework', ['delete', 'c1', 'w1'], 'gog_classroom_coursework_delete'],
+    ['work', ['rm', 'c1', 'w1'], 'gog_classroom_coursework_delete'],
+    ['courses', ['delete', 'c1'], 'gog_classroom_courses_delete'],
+    ['course', ['remove', 'c1'], 'gog_classroom_courses_delete'],
+    ['courses', ['--color', 'never', 'del', 'c1'], 'gog_classroom_courses_delete'],
+  ])('refuses %s %j in favour of %s', (sub, args, tool) => {
+    expect(vetClassroomRun(sub, args)).toMatch(new RegExp(`${tool}.*asks the user`));
+  });
+
+  it.each([
+    ['students', ['list', 'c1']],
+    ['students', ['remove', 'c1', 'u1']],
+    ['students', ['delete', 'c1', 'u1']],
+    ['teachers', ['remove', 'c1', 'u1']],
+    ['submissions', ['grade', 'c1', 'w1', 's1', '--assigned=90']],
+    ['submissions', ['list', 'c1', 'w1']],
+    ['coursework', ['update', 'c1', 'w1', '--title=x']],
+    ['coursework', ['list', 'c1']],
+    ['courses', ['create', '--name=x']],
+    ['courses', ['archive', 'c1']],
+    ['announcements', ['create', 'c1']],
+  ])('allows %s %j (or leaves it to the existing vet)', (sub, args) => {
+    const refusal = vetClassroomRun(sub, args);
+    if (sub === 'announcements') expect(refusal).toMatch(/gog_classroom_announcements_create/);
+    else expect(refusal).toBeUndefined();
+  });
+});
+
+describe('vetDriveRun — comments and permanent deletes', () => {
+  it.each([
+    ['comments', ['create', 'f1', 'text'], 'gog_drive_comments_add'],
+    ['comments', ['add', 'f1', 'text'], 'gog_drive_comments_add'],
+    ['comments', ['new', 'f1', 'text'], 'gog_drive_comments_add'],
+    ['comments', ['reply', 'f1', 'c1', 'text'], 'gog_drive_comments_reply'],
+    ['comments', ['respond', 'f1', 'c1', 'text'], 'gog_drive_comments_reply'],
+    ['delete', ['f1', '--permanent'], 'gog_drive_delete'],
+    ['del', ['f1', '--permanent=true', '--force'], 'gog_drive_delete'],
+    ['rm', ['--PERMANENT', 'f1'], 'gog_drive_delete'],
+    ['share', ['f1', '--to=anyone'], 'gog_drive_share'],
+  ])('refuses %s %j in favour of %s', (sub, args, tool) => {
+    expect(vetDriveRun(sub, args)).toMatch(new RegExp(`${tool}.*asks the user`));
+  });
+
+  it.each([
+    ['comments', ['list', 'f1']],
+    ['comments', ['resolve', 'f1', 'c1']],
+    ['comments', ['update', 'f1', 'c1', 'text']],
+    ['delete', ['f1']],
+    ['delete', ['f1', '--force']],
+    ['copy', ['f1']],
+  ])('allows %s %j', (sub, args) => {
+    expect(vetDriveRun(sub, args)).toBeUndefined();
+  });
+});
+
+describe('vetChatRun — spaces created with members', () => {
+  it.each([
+    ['spaces', ['create', 'Launch', '--member=a@example.com']],
+    ['spaces', ['add', 'Launch', '--member', 'a@example.com']],
+    ['SPACES', ['new', 'Launch', '--members=a@example.com,b@example.com']],
+  ])('refuses %s %j', (sub, args) => {
+    expect(vetChatRun(sub, args)).toMatch(/gog_chat_spaces_create.*asks the user/);
+  });
+
+  it.each([
+    ['spaces', ['create', 'Launch']],
+    ['spaces', ['list']],
+    ['spaces', ['find', 'launch']],
+    ['messages', ['list', 'spaces/A']],
+    ['threads', ['list', 'spaces/A']],
+  ])('allows %s %j', (sub, args) => {
+    expect(vetChatRun(sub, args)).toBeUndefined();
+  });
+});
+
+describe('vetGmailRun — batch delete, send-as aliases, vacation responder', () => {
+  it.each([
+    ['batch', ['delete', 'm1', 'm2'], 'gog_gmail_batch_delete'],
+    ['batch', ['del', 'm1', '--force'], 'gog_gmail_batch_delete'],
+    ['batch', ['remove', 'm1'], 'gog_gmail_batch_delete'],
+    ['batch', ['rm', 'm1'], 'gog_gmail_batch_delete'],
+    ['settings', ['sendas', 'create', 'x@example.com'], 'gog_gmail_sendas_create'],
+    ['settings', ['sendas', 'add', 'x@example.com'], 'gog_gmail_sendas_create'],
+    ['sendas', ['new', 'x@example.com'], 'gog_gmail_sendas_create'],
+    ['settings', ['vacation', 'update', '--enable', '--subject=Away'], 'gog_gmail_vacation_update'],
+    ['settings', ['vacation', 'edit', '--enable=true'], 'gog_gmail_vacation_update'],
+    ['vacation', ['set', '--enable'], 'gog_gmail_vacation_update'],
+  ])('refuses %s %j in favour of %s', (sub, args, tool) => {
+    expect(vetGmailRun(sub, args)).toMatch(new RegExp(`${tool}.*asks the user`));
+  });
+
+  it.each([
+    ['batch', ['modify', 'm1', '--add=Label']],
+    ['batch', ['trash', 'm1']],
+    ['settings', ['sendas', 'list']],
+    ['sendas', ['get', 'x@example.com']],
+    ['settings', ['vacation', 'get']],
+    ['settings', ['vacation', 'update', '--disable']],
+    ['vacation', ['update', '--subject=Away']],
+    ['archive', ['m1']],
+  ])('allows %s %j', (sub, args) => {
+    expect(vetGmailRun(sub, args)).toBeUndefined();
+  });
+
+  it('still refuses the settings that route mail elsewhere', () => {
+    expect(vetGmailRun('filters', ['create'])).toMatch(/gog_gmail_\*/);
+    expect(vetGmailRun('settings', ['forwarding', 'add'])).toMatch(/gog_gmail_\*/);
+    expect(vetGmailRun('autoreply', [])).toMatch(/gog_gmail_autoreply/);
+  });
+});
+
+describe('vetDocsRun — comments', () => {
+  it.each([
+    ['comments', ['add', 'd1', 'text'], 'gog_docs_comments_add'],
+    ['comments', ['create', 'd1', 'text'], 'gog_docs_comments_add'],
+    ['comments', ['new', 'd1', 'text'], 'gog_docs_comments_add'],
+    ['comments', ['reply', 'd1', 'c1', 'text'], 'gog_docs_comments_reply'],
+    ['COMMENTS', ['respond', 'd1', 'c1', 'text'], 'gog_docs_comments_reply'],
+  ])('refuses %s %j in favour of %s', (sub, args, tool) => {
+    expect(vetDocsRun(sub, args)).toMatch(new RegExp(`${tool}.*asks the user`));
+  });
+
+  it.each([
+    ['comments', ['list', 'd1']],
+    ['comments', ['resolve', 'd1', 'c1']],
+    ['copy', ['d1']],
+    ['sed', ['d1', 's/a/b/']],
+  ])('allows %s %j', (sub, args) => {
+    expect(vetDocsRun(sub, args)).toBeUndefined();
+  });
+});
+
+describe('vetSheetsRun — billed Connected Sheets executions', () => {
+  it.each([
+    ['datasource', ['add', 'sid', '--billing-project=p'], 'gog_sheets_datasource_add'],
+    ['data-source', ['add', 'sid'], 'gog_sheets_datasource_add'],
+    ['datasource', ['update', 'sid', 'ds1', '--query=SELECT 1'], 'gog_sheets_datasource_update'],
+    ['data-sources', ['update', 'sid', 'ds1'], 'gog_sheets_datasource_update'],
+    ['datasource', ['refresh', 'sid', 'ds1'], 'gog_sheets_datasource_refresh'],
+    ['connected-sheets', ['REFRESH', 'sid', 'ds1'], 'gog_sheets_datasource_refresh'],
+  ])('refuses %s %j in favour of %s', (sub, args, tool) => {
+    expect(vetSheetsRun(sub, args)).toMatch(new RegExp(`${tool}.*asks the user`));
+  });
+
+  it.each([
+    ['datasource', ['list', 'sid']],
+    ['datasource', ['describe', 'sid', 'ds1']],
+    ['datasource', ['delete', 'sid', 'ds1']],
+    ['datasource', ['table', 'read', 'sid', 'A1']],
+    ['freeze', ['sid', '--rows=1']],
+    ['add-tab', ['sid', 'Data']],
+  ])('allows %s %j', (sub, args) => {
+    expect(vetSheetsRun(sub, args)).toBeUndefined();
+  });
+});
+
+describe('vetAppScriptRun — running code', () => {
+  it.each(['run', 'RUN'])('refuses %s', (sub) => {
+    expect(vetAppScriptRun(sub, ['S1', 'doWork'])).toMatch(/gog_appscript_run_function.*asks the user/);
+  });
+
+  it.each(['get', 'content', 'deployments', 'versions', 'create'])('allows %s', (sub) => {
+    expect(vetAppScriptRun(sub, ['S1'])).toBeUndefined();
+  });
+});
+
+describe('the vets are wired into the run tools', () => {
+  it.each([
+    [registerCalendarTools, 'gog_calendar_run', { subcommand: 'move', args: ['primary', 'e1', 'other', '--send-updates=all'] }],
+    [registerClassroomTools, 'gog_classroom_run', { subcommand: 'students', args: ['add', 'c1', 'u1'] }],
+    [registerDriveTools, 'gog_drive_run', { subcommand: 'comments', args: ['create', 'f1', 'hi'] }],
+    [registerChatTools, 'gog_chat_run', { subcommand: 'spaces', args: ['create', 'Launch', '--member=a@example.com'] }],
+    [registerGmailTools, 'gog_gmail_run', { subcommand: 'batch', args: ['delete', 'm1'] }],
+    [registerDocsTools, 'gog_docs_run', { subcommand: 'comments', args: ['add', 'd1', 'hi'] }],
+    [registerSheetsTools, 'gog_sheets_run', { subcommand: 'datasource', args: ['refresh', 'sid', 'ds1'] }],
+    [registerAppScriptTools, 'gog_appscript_run', { subcommand: 'run', args: ['S1', 'doWork'] }],
+  ] as const)('%#: %s refuses without spawning gog', async (register, tool, args) => {
+    const harness = await createTestHarness(register);
+    const result = await harness.callTool(tool, args);
+    expect(result.isError).toBe(true);
+    expect(result.content[0]!.text).toMatch(/asks the user to confirm/);
+    expect(runner.run).not.toHaveBeenCalled();
+  });
+});
+
+describe('refusedApiCall — the second wave', () => {
+  it.each([
+    ['chat', 'spaces.setup', 'gog_chat_spaces_create'],
+    ['chat', 'chat.spaces.members.create', 'gog_chat_spaces_create'],
+    ['drive', 'comments.create', 'gog_drive_comments_add'],
+    ['drive', 'replies.create', 'gog_drive_comments_reply'],
+    ['classroom', 'courses.students.create', 'gog_classroom_students_add'],
+    ['classroom', 'courses.teachers.create', 'gog_classroom_teachers_add'],
+    ['classroom', 'courses.courseWork.create', 'gog_classroom_coursework_create'],
+    ['classroom', 'courses.courseWork.studentSubmissions.return', 'gog_classroom_submissions_return'],
+    ['calendar', 'events.move', 'gog_calendar_move'],
+    ['gmail', 'users.settings.sendAs.create', 'gog_gmail_sendas_create'],
+    ['gmail', 'users.settings.updateVacation', 'gog_gmail_vacation_update'],
+    ['script', 'scripts.run', 'gog_appscript_run_function'],
+  ])('refuses %s %s', (api, method, tool) => {
+    expect(refusedApiCall(api, method)).toContain(tool);
+  });
+
+  it.each([
+    ['chat', 'spaces.members.list'],
+    ['drive', 'comments.list'],
+    ['classroom', 'courses.students.list'],
+    ['classroom', 'courses.courseWork.studentSubmissions.patch'],
+    ['gmail', 'users.settings.getVacation'],
+    ['gmail', 'users.settings.sendAs.list'],
+    ['script', 'projects.get'],
+  ])('allows %s %s', (api, method) => {
+    expect(refusedApiCall(api, method)).toBeUndefined();
+  });
+});

package/tests/tools/run-vets.test.ts

@@ -44,7 +44,30 @@ describe('vetDriveRun', () => {
     expect(vetDriveRun(sub, ['f1', '--to=anyone'])).toMatch(/gog_drive_share.*asks the user/);
   });
 
-  it.each(['permissions', 'unshare', 'copy'])('allows %s', (sub) => {
+  // SEC-1 (fleet-audit #930): `drive bulk update-role --from=reader --to=writer`
+  // rewrites every matching permission across a tree with no positional path,
+  // so neither the share vet nor the path guard saw it.
+  it.each([
+    ['bulk', ['update-role', '--from=reader', '--to=writer', '--depth=0', '--force']],
+    ['BULK', ['remove-public', '--parent=folder1']],
+    ['bulk', []],
+  ])('refuses %s %j', (sub, args) => {
+    const refusal = vetDriveRun(sub, args);
+    expect(refusal).toMatch(/gog drive bulk/);
+    expect(refusal).toMatch(/every matching file/);
+    expect(refusal).toMatch(/gog_drive_share/);
+  });
+
+  // `unshare` removes a collaborator's access with no preview of who: route it
+  // through the dedicated tool, whose call the host shows structured.
+  it('refuses unshare in favour of gog_drive_unshare', () => {
+    const refusal = vetDriveRun('Unshare', ['f1', 'p1']);
+    expect(refusal).toMatch(/not available through gog_drive_run/);
+    expect(refusal).toMatch(/gog_drive_unshare/);
+  });
+
+  // `permissions <fileId>` only lists (gog 0.41.0 has no mutating form).
+  it.each(['permissions', 'copy'])('allows %s', (sub) => {
     expect(vetDriveRun(sub, ['f1'])).toBeUndefined();
   });
 });
@@ -61,10 +84,91 @@ describe('vetClassroomRun', () => {
     expect(vetClassroomRun(sub, args)).toMatch(/gog_classroom_(announcements|invitations)_create.*asks the user/);
   });
 
+  // SEC-3 (fleet-audit #932): create-as-DRAFT then update-to-PUBLISHED was the
+  // same two-step around the create gate that closed for Gmail drafts.
+  it.each([
+    ['announcements', ['update', 'c1', 'a1', '--state=PUBLISHED']],
+    ['announcement', ['edit', 'c1', 'a1', '--state', 'published']],
+    ['ann', ['SET', 'c1', 'a1', '--scheduled=2026-10-01T12:00:00Z']],
+    ['ann', ['set', 'c1', 'a1', '--state=DRAFT', '--scheduled=2026-10-01T12:00:00Z']],
+  ])('refuses publishing an announcement via %s %j', (sub, args) => {
+    expect(vetClassroomRun(sub, args)).toMatch(/gog_classroom_announcements_update.*asks the user/);
+  });
+
+  it.each([
+    ['coursework', ['update', 'c1', 'w1', '--state=PUBLISHED']],
+    ['work', ['edit', 'c1', 'w1', '--scheduled=2026-10-01T12:00:00Z']],
+  ])('refuses publishing coursework via %s %j', (sub, args) => {
+    expect(vetClassroomRun(sub, args)).toMatch(/gog_classroom_coursework_update.*asks the user/);
+  });
+
+  // Materials have no dedicated update tool, so publishing one through
+  // update/edit/set was the create-as-DRAFT then update-to-PUBLISHED route.
+  it.each([
+    ['materials', ['update', 'c1', 'm1', '--state=PUBLISHED']],
+    ['materials', ['update', 'c1', 'm1', '--state', 'PUBLISHED']],
+    ['material', ['edit', 'c1', 'm1', '--state=published']],
+    ['material', ['SET', 'c1', 'm1', '--state', 'Published']],
+    ['materials', ['set', 'c1', 'm1', '--scheduled=2026-10-01T12:00:00Z']],
+    ['material', ['update', 'c1', 'm1', '--state=DRAFT', '--scheduled', '2026-10-01T12:00:00Z']],
+  ])('refuses publishing material via %s %j', (sub, args) => {
+    const refusal = vetClassroomRun(sub, args);
+    expect(refusal).toMatch(/publishes material to students and is not available through gog_classroom_run/);
+    expect(refusal).toMatch(/Ask the user to publish it from Classroom/);
+  });
+
+  // Assigning a published item to more students widens who sees it.
+  it.each([
+    ['announcements', ['assignees', 'c1', 'a1', '--mode=ALL_STUDENTS']],
+    ['ann', ['assign', 'c1', 'a1', '--add-student=s1,s2']],
+    ['coursework', ['assignees', 'c1', 'w1', '--mode', 'all_students']],
+    ['work', ['ASSIGN', 'c1', 'w1', '--add-student', 's1']],
+  ])('refuses widening assignees via %s %j', (sub, args) => {
+    const refusal = vetClassroomRun(sub, args);
+    expect(refusal).toMatch(/shows it to more students and is not available through gog_classroom_run/);
+    expect(refusal).toMatch(/from Classroom/);
+  });
+
+  it.each([
+    ['coursework', ['create', 'c1', '--title=HW'], /gog_classroom_coursework_create/],
+    ['work', ['add', 'c1', '--title=HW', '--state=PUBLISHED'], /gog_classroom_coursework_create/],
+    ['coursework', ['new', 'c1', '--title=HW', '--state=DRAFT', '--scheduled=2026-10-01T12:00:00Z'], /gog_classroom_coursework_create/],
+    ['materials', ['create', 'c1', '--title=Notes'], /--state=DRAFT/],
+    ['material', ['add', 'c1', '--title=Notes', '--state=DRAFT', '--scheduled=2026-10-01T12:00:00Z'], /--state=DRAFT/],
+    ['students', ['add', 'c1', 'u1'], /gog_classroom_students_add/],
+    ['student', ['create', 'c1', 'u1'], /gog_classroom_students_add/],
+    ['teachers', ['new', 'c1', 'u1'], /gog_classroom_teachers_add/],
+    ['teacher', ['add', 'c1', 'u1'], /gog_classroom_teachers_add/],
+    ['submissions', ['return', 'c1', 'w1', 's1'], /gog_classroom_submissions_return/],
+    ['submission', ['send', 'c1', 'w1', 's1'], /gog_classroom_submissions_return/],
+    ['guardian-invitations', ['create', 'student1', '--email=parent@example.com'], /from Classroom/],
+    ['guardian-invites', ['add', 'student1', '--email=parent@example.com'], /from Classroom/],
+  ])('refuses %s %j', (sub, args, instead) => {
+    const refusal = vetClassroomRun(sub, args);
+    expect(refusal).toMatch(/not available through gog_classroom_run/);
+    expect(refusal).toMatch(instead);
+  });
+
   it.each([
     ['announcements', ['list', 'c1']],
-    ['invitations', ['accept', 'i1']],
+    ['announcements', ['update', 'c1', 'a1', '--text=fixed typo']],
+    ['announcements', ['update', 'c1', 'a1', '--state=DRAFT']],
+    ['coursework', ['update', 'c1', 'w1', '--title=Renamed']],
+    ['coursework', ['create', 'c1', '--title=HW', '--state=DRAFT']],
+    ['materials', ['create', 'c1', '--title=Notes', '--state=draft']],
+    ['materials', ['list', 'c1']],
+    ['materials', ['update', 'c1', 'm1', '--state=DRAFT']],
+    ['material', ['edit', 'c1', 'm1', '--title=Renamed']],
+    ['announcements', ['assignees', 'c1', 'a1', '--remove-student=s1']],
+    ['coursework', ['assign', 'c1', 'w1', '--mode=INDIVIDUAL_STUDENTS', '--remove-student', 's1']],
+    ['students', ['list', 'c1']],
+    ['students', ['remove', 'c1', 'u1', '--force']],
+    ['teachers', ['get', 'c1', 'u1']],
+    ['submissions', ['grade', 'c1', 'w1', 's1', '--draft=90']],
+    ['submissions', ['turn-in', 'c1', 'w1', 's1']],
+    ['guardian-invitations', ['list', 'student1']],
     ['guardians', ['create', 'c1']],
+    ['invitations', ['accept', 'i1']],
     ['courses', ['create']],
   ])('allows %s %j', (sub, args) => {
     expect(vetClassroomRun(sub, args)).toBeUndefined();
@@ -76,7 +180,49 @@ describe('vetCalendarRun', () => {
     expect(vetCalendarRun(sub, ['primary'])).toMatch(/gog_calendar_(create|update|respond).*asks the user/);
   });
 
-  it.each(['events', 'freebusy', 'calendars', 'create-calendar', 'focus-time'])('allows %s', (sub) => {
+  // SEC-4 (fleet-audit #933): `propose-time --decline` (and --comment, which
+  // implies it) declines the event and notifies the organizer, exactly what
+  // gog_calendar_respond asks about.
+  it.each([
+    ['propose-time', ['primary', 'e1', '--decline']],
+    ['PROPOSE-TIME', ['primary', 'e1', '--decline=true']],
+    ['propose-time', ['primary', 'e1', '--comment=Can we do Tuesday?']],
+    ['propose-time', ['primary', 'e1', '--comment', 'Tuesday?']],
+  ])('refuses %s %j', (sub, args) => {
+    expect(vetCalendarRun(sub, args)).toMatch(/gog_calendar_respond.*asks the user/);
+  });
+
+  it('allows propose-time when it only generates the URL', () => {
+    expect(vetCalendarRun('propose-time', ['primary', 'e1'])).toBeUndefined();
+  });
+
+  // The run tool cannot see an event's guests, so the rest of the guest-visible
+  // subcommands are refused outright in favour of their dedicated tools.
+  it.each([
+    ['move', ['primary', 'e1', 'other'], /gog_calendar_move/],
+    ['transfer', ['primary', 'e1', 'other', '--send-updates=none'], /gog_calendar_move/],
+    ['delete', ['primary', 'e1', '--force'], /gog_calendar_delete\b/],
+    ['del', ['primary', 'e1'], /gog_calendar_delete\b/],
+    ['rm', ['primary', 'e1'], /gog_calendar_delete\b/],
+    ['remove', ['primary', 'e1'], /gog_calendar_delete\b/],
+    ['delete-calendar', ['cal1'], /gog_calendar_delete_calendar/],
+    ['out-of-office', ['--from=2026-10-01T09:00:00Z', '--to=2026-10-02T09:00:00Z'], /gog_calendar_out_of_office/],
+    ['ooo', ['--from=2026-10-01T09:00:00Z', '--to=2026-10-02T09:00:00Z', '--auto-decline=none'], /gog_calendar_out_of_office/],
+    ['focus-time', ['--from=2026-10-01T09:00:00Z', '--to=2026-10-01T10:00:00Z'], /--auto-decline=none/],
+    ['focus', ['--from=2026-10-01T09:00:00Z', '--to=2026-10-01T10:00:00Z', '--auto-decline=all'], /--auto-decline=none/],
+    ['Focus-Time', ['--from=2026-10-01T09:00:00Z', '--to=2026-10-01T10:00:00Z', '--auto-decline', 'new'], /--auto-decline=none/],
+  ])('refuses %s %j', (sub, args, instead) => {
+    const refusal = vetCalendarRun(sub, args);
+    expect(refusal).toMatch(/not available through gog_calendar_run/);
+    expect(refusal).toMatch(instead);
+  });
+
+  it('allows a focus-time block that declines nobody', () => {
+    expect(vetCalendarRun('focus-time', ['--from=2026-10-01T09:00:00Z', '--to=2026-10-01T10:00:00Z', '--auto-decline=none'])).toBeUndefined();
+    expect(vetCalendarRun('focus', ['--from=2026-10-01T09:00:00Z', '--to=2026-10-01T10:00:00Z', '--auto-decline', 'none'])).toBeUndefined();
+  });
+
+  it.each(['events', 'freebusy', 'calendars', 'create-calendar', 'working-location', 'unsubscribe'])('allows %s', (sub) => {
     expect(vetCalendarRun(sub, [])).toBeUndefined();
   });
 });
@@ -85,8 +231,11 @@ describe('the vets are wired into the run tools', () => {
   it.each([
     [registerChatTools, 'gog_chat_run', { subcommand: 'messages', args: ['send', 'spaces/A', '--text=hi'] }],
     [registerDriveTools, 'gog_drive_run', { subcommand: 'share', args: ['f1', '--to=anyone'] }],
+    [registerDriveTools, 'gog_drive_run', { subcommand: 'bulk', args: ['update-role', '--from=reader', '--to=writer', '--depth=0', '--force'] }],
     [registerClassroomTools, 'gog_classroom_run', { subcommand: 'ann', args: ['create', 'c1', '--text=x'] }],
+    [registerClassroomTools, 'gog_classroom_run', { subcommand: 'announcements', args: ['update', 'c1', 'a1', '--state=PUBLISHED'] }],
     [registerCalendarTools, 'gog_calendar_run', { subcommand: 'rsvp', args: ['primary', 'e1', '--status=accepted'] }],
+    [registerCalendarTools, 'gog_calendar_run', { subcommand: 'propose-time', args: ['primary', 'e1', '--decline'] }],
   ] as const)('%#: %s refuses without spawning gog', async (register, tool, args) => {
     const harness = await createTestHarness(register);
     const result = await harness.callTool(tool, args);
@@ -113,6 +262,11 @@ describe('refusedApiCall — the dispatch rail\'s other escape hatch', () => {
     expect(refusedApiCall(api, method)).toContain(tool);
   });
 
+  // Not refused OUTRIGHT — but not waved through either. Every write here goes
+  // through gog_api_call's generic confirmation (SEC-2, fleet-audit #931; see
+  // tests/tools/api.test.ts), which asks about the exact method and payload.
+  // The hard refusals above are only for actions a dedicated tool already
+  // gates with a better preview.
   it.each([
     ['chat', 'spaces.messages.list'],
     ['drive', 'permissions.list'],
@@ -121,7 +275,7 @@ describe('refusedApiCall — the dispatch rail\'s other escape hatch', () => {
     ['calendar', 'events.list'],
     ['calendar', 'events.delete'],
     ['sheets', 'spreadsheets.values.update'],
-  ])('allows %s %s', (api, method) => {
+  ])('leaves %s %s to the generic write gate', (api, method) => {
     expect(refusedApiCall(api, method)).toBeUndefined();
   });