gogcli-mcp-classroom 4.5.0 → 4.5.2

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

@@ -0,0 +1,211 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { registerExtraClassroomTools } from '../../src/tools/classroom-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: roster adds grant access to a class, coursework
+// is announced to it, and the deletes destroy submissions for good — each asks
+// first, naming the class (and coursework) rather than an opaque id.
+// ============================================================================
+
+const ORIGINAL_ENV = { ...process.env };
+beforeEach(() => {
+  vi.clearAllMocks();
+  process.env = { ...ORIGINAL_ENV };
+  delete process.env.MCP_CONFIRM_MODE;
+  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(registerExtraClassroomTools, { 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(registerExtraClassroomTools);
+
+const COURSE = JSON.stringify({ course: { id: 'c1', name: 'Algebra II', section: 'Period 3' } });
+const WORK = JSON.stringify({ coursework: { id: 'w1', title: 'HW 3' } });
+const COURSE_VIEW = { id: 'c1', name: 'Algebra II', section: 'Period 3' };
+
+function stub(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 };
+    if (key.startsWith('classroom courses get')) return rawTextResult(COURSE);
+    if (key.startsWith('classroom coursework get')) return rawTextResult(WORK);
+    return rawTextResult('{"ok":true}');
+  });
+}
+const callsTo = (...words: string[]) => vi.mocked(lib.runOrDiagnose).mock.calls.filter(([args]) =>
+  words.every((w, i) => args[i] === w));
+
+type Case = {
+  tool: string;
+  args: Record<string, unknown>;
+  action: string;
+  details: Record<string, unknown>;
+  write: string[];
+  argv: unknown[];
+  note: RegExp;
+  reads: string[];
+  changed: Record<string, unknown>;
+};
+
+const CASES: Case[] = [
+  {
+    tool: 'gog_classroom_students_add',
+    args: { courseId: 'c1', userId: 'kid@example.com' },
+    action: 'classroom.student-add',
+    details: { course: COURSE_VIEW, student: 'kid@example.com' },
+    write: ['classroom', 'students', 'add'],
+    argv: ['classroom', 'students', 'add', pos('c1'), pos('kid@example.com')],
+    note: /gog_classroom_invitations_create/,
+    reads: ['classroom courses get'],
+    changed: { userId: 'other@example.com' },
+  },
+  {
+    tool: 'gog_classroom_teachers_add',
+    args: { courseId: 'c1', userId: 'co@example.com' },
+    action: 'classroom.teacher-add',
+    details: { course: COURSE_VIEW, teacher: 'co@example.com', grants: "teacher access: every student's work, grades and roster" },
+    write: ['classroom', 'teachers', 'add'],
+    argv: ['classroom', 'teachers', 'add', pos('c1'), pos('co@example.com')],
+    note: /invitations_create/,
+    reads: ['classroom courses get'],
+    changed: { userId: 'other@example.com' },
+  },
+  {
+    tool: 'gog_classroom_courses_delete',
+    args: { courseId: 'c1' },
+    action: 'classroom.course-delete',
+    details: { course: COURSE_VIEW, deletes: 'the course with all of its coursework, submissions and grades, for good' },
+    write: ['classroom', 'courses', 'delete'],
+    argv: ['classroom', 'courses', 'delete', pos('c1'), '--force'],
+    note: /gog_classroom_courses_archive/,
+    reads: ['classroom courses get'],
+    changed: { courseId: 'c2' },
+  },
+  {
+    tool: 'gog_classroom_coursework_delete',
+    args: { courseId: 'c1', courseworkId: 'w1' },
+    action: 'classroom.coursework-delete',
+    details: { course: COURSE_VIEW, coursework: { id: 'w1', title: 'HW 3' }, deletes: 'the coursework and every student submission to it, for good' },
+    write: ['classroom', 'coursework', 'delete'],
+    argv: ['classroom', 'coursework', 'delete', pos('c1'), pos('w1'), '--force'],
+    note: /delete it from Classroom/,
+    reads: ['classroom courses get', 'classroom coursework get'],
+    changed: { courseworkId: 'w2' },
+  },
+  {
+    tool: 'gog_classroom_coursework_create',
+    args: { courseId: 'c1', title: 'HW 4', description: 'Chapter 5, all odd problems', dueDate: '2026-10-01', dueTime: '09:00', maxPoints: 10 },
+    action: 'classroom.coursework-create',
+    details: {
+      course: COURSE_VIEW, title: 'HW 4', type: 'ASSIGNMENT', publishes: 'immediately', due: '2026-10-01 09:00',
+      maxPoints: 10, descriptionPreview: 'Chapter 5, all odd problems',
+    },
+    write: ['classroom', 'coursework', 'create'],
+    argv: ['classroom', 'coursework', 'create', pos('c1'), '--title=HW 4', '--description=Chapter 5, all odd problems',
+      '--max-points=10', '--due-date=2026-10-01', '--due-time=09:00'],
+    note: /state DRAFT/,
+    reads: ['classroom courses get'],
+    changed: { description: 'Chapter 6' },
+  },
+];
+
+describe.each(CASES)('$tool', (c) => {
+  it('reads what it acts on and asks, naming it; acts once accepted', async () => {
+    stub();
+    const { harness, details } = await prompted();
+    await harness.callTool(c.tool, c.args);
+    expect(details()).toEqual(c.details);
+    expect(callsTo(...c.write).map(([args]) => args)).toEqual([c.argv]);
+  });
+
+  it('does nothing when the user declines', async () => {
+    stub();
+    const { harness } = await prompted({ action: 'decline' });
+    expect(json(await harness.callTool(c.tool, c.args))).toMatchObject({ cancelled: true, action: c.action });
+    expect(callsTo(...c.write)).toHaveLength(0);
+  });
+
+  it.each(c.reads)('returns a failed read (%s) without asking or acting', async (failing) => {
+    stub(failing);
+    const { harness, seen } = await prompted();
+    expect((await harness.callTool(c.tool, c.args)).isError).toBe(true);
+    expect(seen).toHaveLength(0);
+    expect(callsTo(...c.write)).toHaveLength(0);
+  });
+
+  it('refuses a client that cannot be prompted, with a way through', async () => {
+    process.env.MCP_CONFIRM_MODE = 'refuse';
+    stub();
+    const r = json(await (await unprompted()).callTool(c.tool, c.args));
+    expect(r).toMatchObject({ reason: 'confirmation-unsupported', action: c.action });
+    expect(r.note).toMatch(c.note);
+    expect(callsTo(...c.write)).toHaveLength(0);
+  });
+
+  it('token fallback: previews in full, refuses changed arguments, acts on phase 2', async () => {
+    process.env.MCP_CONFIRM_MODE = 'ask-user';
+    stub();
+    const harness = await unprompted();
+    const p1 = json(await harness.callTool(c.tool, c.args));
+    expect(p1.status).toBe('confirmation-required');
+    expect(p1.preview.course).toEqual(COURSE_VIEW);
+    expect(json(await harness.callTool(c.tool, { ...c.args, ...c.changed, confirmToken: p1.confirmToken })))
+      .toMatchObject({ error: expect.stringMatching(/DRAFT_CHANGED|TOKEN_INVALID/) });
+    await harness.callTool(c.tool, { ...c.args, confirmToken: p1.confirmToken });
+    expect(callsTo(...c.write)).toHaveLength(1);
+  });
+});
+
+describe('the paths that reach nobody stay unprompted', () => {
+  it('enrolling yourself with a code', async () => {
+    stub();
+    const { harness, seen } = await prompted();
+    await harness.callTool('gog_classroom_students_add', { courseId: 'c1', userId: 'ME', enrollmentCode: 'abc123' });
+    expect(seen).toHaveLength(0);
+    expect(callsTo('classroom', 'courses', 'get')).toHaveLength(0);
+    expect(callsTo('classroom', 'students', 'add')[0]![0]).toEqual(
+      ['classroom', 'students', 'add', pos('c1'), pos('ME'), '--enrollment-code=abc123']);
+  });
+
+  it('a DRAFT coursework item', async () => {
+    stub();
+    const { harness, seen } = await prompted();
+    await harness.callTool('gog_classroom_coursework_create', { courseId: 'c1', title: 'HW 4', state: 'DRAFT' });
+    expect(seen).toHaveLength(0);
+    expect(callsTo('classroom', 'coursework', 'create')).toHaveLength(1);
+  });
+
+  // A scheduled item is a DRAFT that publishes itself at that time: only an
+  // unscheduled DRAFT reaches nobody.
+  it('a scheduled DRAFT coursework item still asks', async () => {
+    stub();
+    const { harness, details } = await prompted({ action: 'decline' });
+    await harness.callTool('gog_classroom_coursework_create', { courseId: 'c1', title: 'Quiz', state: 'DRAFT', scheduled: '2026-10-01T08:00' });
+    expect(details()).toMatchObject({ course: COURSE_VIEW, title: 'Quiz', publishes: 'at 2026-10-01T08:00' });
+    expect(callsTo('classroom', 'coursework', 'create')).toHaveLength(0);
+  });
+
+  it('a scheduled coursework item says when it publishes, and a combined due passes through', async () => {
+    stub();
+    const { harness, details } = await prompted({ action: 'decline' });
+    await harness.callTool('gog_classroom_coursework_create', { courseId: 'c1', title: 'Quiz', type: 'SHORT_ANSWER_QUESTION', due: '2026-10-02T09:00', scheduled: '2026-10-01T08:00' });
+    expect(details()).toEqual({ course: COURSE_VIEW, title: 'Quiz', type: 'SHORT_ANSWER_QUESTION', publishes: 'at 2026-10-01T08:00', due: '2026-10-02T09:00' });
+  });
+});

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

@@ -219,6 +219,239 @@ describe('gog_classroom_announcements_update', () => {
   });
 });
 
+// ============================================================================
+// 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. Publishing
+// (state PUBLISHED, or a schedule) through update now reads the course and the
+// item and asks, exactly as announcements_create does.
+// ============================================================================
+
+const COURSE_JSON = JSON.stringify({ course: { id: 'c1', name: 'Algebra II', section: 'Period 3' } });
+const ANNOUNCEMENT_JSON = JSON.stringify({ announcement: { id: 'a1', text: 'Homework is due Friday', state: 'DRAFT', updateTime: '2026-09-20T10:00:00Z' } });
+// gog 0.41.0 nests coursework under `coursework` (not the API's `courseWork`).
+const COURSEWORK_JSON = JSON.stringify({ coursework: { id: 'w1', title: 'Chapter 4 problem set', description: 'Problems 1-20, show your work', state: 'DRAFT', updateTime: '2026-09-21T10:00:00Z' } });
+
+/** Answer reads with `reads[<joined command words>]`, everything else with `{}`. */
+function stubReads(reads: Record<string, string>) {
+  vi.mocked(lib.runOrDiagnose).mockImplementation(async (args) => {
+    const key = (args as unknown[]).map((a) => (typeof a === 'string' ? a : (a as { value: string }).value)).filter((a) => !a.startsWith('--')).join(' ');
+    for (const [prefix, out] of Object.entries(reads)) if (key.startsWith(prefix)) return rawTextResult(out);
+    return rawTextResult('{"ok":true}');
+  });
+}
+
+const calls = (...words: string[]) => vi.mocked(lib.runOrDiagnose).mock.calls.filter(([args]) =>
+  words.every((w, i) => args[i] === w));
+const json = (r: { content: Array<{ text?: string }> }) => JSON.parse(r.content[0]!.text as string);
+
+async function prompted(answer: { action: 'accept' | 'decline'; content?: { confirmed: boolean } } = { action: 'accept', content: { confirmed: true } }) {
+  const messages: string[] = [];
+  const h = await createTestHarness(registerExtraClassroomTools, {
+    elicitation: async (r) => { messages.push(r.params.message); return answer; },
+  });
+  const details = () => JSON.parse(messages[0]!.split('\n').slice(1).join('\n')).details;
+  return { h, messages, details };
+}
+
+describe('gog_classroom_announcements_update — publishing asks', () => {
+  beforeEach(() => stubReads({ 'classroom courses get': COURSE_JSON, 'classroom announcements get': ANNOUNCEMENT_JSON }));
+
+  it('reads the course and the announcement, prompts with the class and the CURRENT text, then publishes once accepted', async () => {
+    const { h, details, messages } = await prompted();
+    await h.callTool('gog_classroom_announcements_update', { courseId: 'c1', announcementId: 'a1', state: 'PUBLISHED' });
+    expect(messages[0]).toMatch(/publish/i);
+    expect(details()).toEqual({
+      course: { id: 'c1', name: 'Algebra II', section: 'Period 3' },
+      announcement: { id: 'a1', state: 'DRAFT' },
+      publishes: 'immediately',
+      textPreview: 'Homework is due Friday',
+    });
+    // Read before asking (the elicitation round-trip re-runs the handler, so
+    // the reads repeat); the write happens exactly once, after acceptance.
+    expect(calls('classroom', 'courses', 'get').length).toBeGreaterThanOrEqual(1);
+    expect(calls('classroom', 'announcements', 'get').length).toBeGreaterThanOrEqual(1);
+    expect(calls('classroom', 'announcements', 'update')).toHaveLength(1);
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['classroom', 'announcements', 'update', pos('c1'), pos('a1'), '--state=PUBLISHED'], { account: undefined });
+  });
+
+  it('previews the NEW text when the same call replaces it, and a schedule as when it publishes', async () => {
+    const { h, details } = await prompted({ action: 'decline' });
+    await h.callTool('gog_classroom_announcements_update', {
+      courseId: 'c1', announcementId: 'a1', text: 'Homework is due Monday', state: 'DRAFT', scheduled: '2026-10-01T12:00:00Z', account: 't@example.com',
+    });
+    expect(details()).toMatchObject({ publishes: 'at 2026-10-01T12:00:00Z', textPreview: 'Homework is due Monday' });
+    expect(calls('classroom', 'announcements', 'update')).toHaveLength(0);
+  });
+
+  it('previews the CURRENT text when text is empty (gog keeps it: an empty --text is never sent)', async () => {
+    const { h, details } = await prompted({ action: 'decline' });
+    await h.callTool('gog_classroom_announcements_update', { courseId: 'c1', announcementId: 'a1', text: '', state: 'PUBLISHED' });
+    expect(details()).toMatchObject({ textPreview: 'Homework is due Friday' });
+    expect(calls('classroom', 'announcements', 'update')).toHaveLength(0);
+  });
+
+  it.each([
+    ['a text edit', { text: 'fixed typo' }],
+    ['unpublishing back to DRAFT', { state: 'DRAFT' as const }],
+  ])('does not ask for %s (nobody new sees it)', async (_label, extra) => {
+    const { h, messages } = await prompted();
+    await h.callTool('gog_classroom_announcements_update', { courseId: 'c1', announcementId: 'a1', ...extra });
+    expect(messages).toHaveLength(0);
+    expect(lib.runOrDiagnose).toHaveBeenCalledTimes(1);
+    expect(calls('classroom', 'announcements', 'update')).toHaveLength(1);
+  });
+
+  it('publishes nothing when the user declines', async () => {
+    const { h } = await prompted({ action: 'decline' });
+    const r = json(await h.callTool('gog_classroom_announcements_update', { courseId: 'c1', announcementId: 'a1', state: 'PUBLISHED' }));
+    expect(r).toMatchObject({ confirmed: false, cancelled: true, action: 'classroom.announcement-publish' });
+    expect(calls('classroom', 'announcements', 'update')).toHaveLength(0);
+  });
+
+  it('refuses a client that cannot be prompted under MCP_CONFIRM_MODE=refuse, naming the way through', async () => {
+    process.env.MCP_CONFIRM_MODE = 'refuse';
+    const h = await createTestHarness(registerExtraClassroomTools);
+    const r = json(await h.callTool('gog_classroom_announcements_update', { courseId: 'c1', announcementId: 'a1', state: 'PUBLISHED' }));
+    expect(r).toMatchObject({ reason: 'confirmation-unsupported', action: 'classroom.announcement-publish' });
+    expect(r.note).toMatch(/DRAFT/);
+    expect(calls('classroom', 'announcements', 'update')).toHaveLength(0);
+  });
+
+  it('token fallback: previews, binds the announcement revision, publishes on phase 2', async () => {
+    process.env.MCP_CONFIRM_MODE = 'ask-user';
+    const h = await createTestHarness(registerExtraClassroomTools);
+    const args = { courseId: 'c1', announcementId: 'a1', state: 'PUBLISHED' as const };
+    const p1 = json(await h.callTool('gog_classroom_announcements_update', args));
+    expect(p1).toMatchObject({
+      status: 'confirmation-required',
+      preview: { course: { id: 'c1', name: 'Algebra II', section: 'Period 3' }, announcement: { id: 'a1', state: 'DRAFT' }, publishes: 'immediately', textPreview: 'Homework is due Friday' },
+    });
+    expect(calls('classroom', 'announcements', 'update')).toHaveLength(0);
+    // The teacher edits the draft between the phases: the approval no longer names this text.
+    stubReads({ 'classroom courses get': COURSE_JSON, 'classroom announcements get': ANNOUNCEMENT_JSON.replace('2026-09-20T10:00:00Z', '2026-09-22T08:00:00Z') });
+    expect(json(await h.callTool('gog_classroom_announcements_update', { ...args, confirmToken: p1.confirmToken }))).toMatchObject({ error: 'DRAFT_CHANGED' });
+    stubReads({ 'classroom courses get': COURSE_JSON, 'classroom announcements get': ANNOUNCEMENT_JSON });
+    await h.callTool('gog_classroom_announcements_update', { ...args, confirmToken: p1.confirmToken });
+    expect(calls('classroom', 'announcements', 'update')).toHaveLength(1);
+  });
+
+  it.each([
+    ['course', 'classroom courses get'],
+    ['announcement', 'classroom announcements get'],
+  ])('returns a failed %s read without prompting or publishing', async (_what, failing) => {
+    vi.mocked(lib.runOrDiagnose).mockImplementation(async (args) => {
+      const key = (args as unknown[]).map((a) => (typeof a === 'string' ? a : (a as { value: string }).value)).join(' ');
+      if (key.startsWith(failing)) return { content: [{ type: 'text', text: 'Error: not found' }], isError: true };
+      return rawTextResult(key.startsWith('classroom courses get') ? COURSE_JSON : ANNOUNCEMENT_JSON);
+    });
+    const { h, messages } = await prompted();
+    const r = await h.callTool('gog_classroom_announcements_update', { courseId: 'c1', announcementId: 'a1', state: 'PUBLISHED' });
+    expect(r.isError).toBe(true);
+    expect(messages).toHaveLength(0);
+    expect(calls('classroom', 'announcements', 'update')).toHaveLength(0);
+  });
+});
+
+describe('gog_classroom_coursework_update — publishing asks', () => {
+  beforeEach(() => stubReads({ 'classroom courses get': COURSE_JSON, 'classroom coursework get': COURSEWORK_JSON }));
+
+  it('reads the course and the coursework, prompts with the class and the CURRENT title and description, then publishes once accepted', async () => {
+    const { h, details, messages } = await prompted();
+    await h.callTool('gog_classroom_coursework_update', { courseId: 'c1', courseworkId: 'w1', state: 'PUBLISHED', maxPoints: 100 });
+    expect(messages[0]).toMatch(/publish/i);
+    expect(details()).toEqual({
+      course: { id: 'c1', name: 'Algebra II', section: 'Period 3' },
+      coursework: { id: 'w1', title: 'Chapter 4 problem set', state: 'DRAFT' },
+      publishes: 'immediately',
+      descriptionPreview: 'Problems 1-20, show your work',
+    });
+    expect(calls('classroom', 'courses', 'get').length).toBeGreaterThanOrEqual(1);
+    expect(calls('classroom', 'coursework', 'get').length).toBeGreaterThanOrEqual(1);
+    expect(calls('classroom', 'coursework', 'update')).toHaveLength(1);
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['classroom', 'coursework', 'update', pos('c1'), pos('w1'), '--state=PUBLISHED', '--max-points=100'], { account: undefined });
+  });
+
+  it('previews the NEW title and description when the same call replaces them, and a schedule as when it publishes', async () => {
+    const { h, details } = await prompted({ action: 'decline' });
+    await h.callTool('gog_classroom_coursework_update', { courseId: 'c1', courseworkId: 'w1', title: 'Chapter 5 problem set', description: 'Odd problems only', scheduled: '2026-10-01T12:00:00Z' });
+    expect(details()).toMatchObject({ coursework: { id: 'w1', title: 'Chapter 5 problem set', state: 'DRAFT' }, publishes: 'at 2026-10-01T12:00:00Z', descriptionPreview: 'Odd problems only' });
+    expect(calls('classroom', 'coursework', 'update')).toHaveLength(0);
+  });
+
+  it('previews the CURRENT title and description when they are empty (gog keeps them: empty flags are never sent)', async () => {
+    const { h, details } = await prompted({ action: 'decline' });
+    await h.callTool('gog_classroom_coursework_update', { courseId: 'c1', courseworkId: 'w1', title: '', description: '', state: 'PUBLISHED' });
+    expect(details()).toMatchObject({ coursework: { id: 'w1', title: 'Chapter 4 problem set', state: 'DRAFT' }, descriptionPreview: 'Problems 1-20, show your work' });
+    expect(calls('classroom', 'coursework', 'update')).toHaveLength(0);
+  });
+
+  it('token fallback binds the text students will see, not an ignored empty one', async () => {
+    process.env.MCP_CONFIRM_MODE = 'ask-user';
+    const h = await createTestHarness(registerExtraClassroomTools);
+    const p1 = json(await h.callTool('gog_classroom_coursework_update', { courseId: 'c1', courseworkId: 'w1', title: '', description: '', state: 'PUBLISHED' }));
+    const p2 = json(await h.callTool('gog_classroom_coursework_update', { courseId: 'c1', courseworkId: 'w1', state: 'PUBLISHED' }));
+    expect(p1.preview).toEqual(p2.preview);
+    expect(p1.confirmToken).toBeDefined();
+  });
+
+  it('does not ask for a due-date change', async () => {
+    const { h, messages } = await prompted();
+    await h.callTool('gog_classroom_coursework_update', { courseId: 'c1', courseworkId: 'w1', dueDate: '2026-10-03' });
+    expect(messages).toHaveLength(0);
+    expect(lib.runOrDiagnose).toHaveBeenCalledTimes(1);
+  });
+
+  it('refuses a client that cannot be prompted under MCP_CONFIRM_MODE=refuse', async () => {
+    process.env.MCP_CONFIRM_MODE = 'refuse';
+    const h = await createTestHarness(registerExtraClassroomTools);
+    const r = json(await h.callTool('gog_classroom_coursework_update', { courseId: 'c1', courseworkId: 'w1', state: 'PUBLISHED' }));
+    expect(r).toMatchObject({ reason: 'confirmation-unsupported', action: 'classroom.coursework-publish' });
+    expect(calls('classroom', 'coursework', 'update')).toHaveLength(0);
+  });
+
+  it('token fallback: previews, then publishes on phase 2', async () => {
+    process.env.MCP_CONFIRM_MODE = 'ask-user';
+    const h = await createTestHarness(registerExtraClassroomTools);
+    const args = { courseId: 'c1', courseworkId: 'w1', state: 'PUBLISHED' as const };
+    const p1 = json(await h.callTool('gog_classroom_coursework_update', args));
+    expect(p1).toMatchObject({ status: 'confirmation-required', preview: { coursework: { id: 'w1', title: 'Chapter 4 problem set', state: 'DRAFT' }, publishes: 'immediately', descriptionPreview: 'Problems 1-20, show your work' } });
+    // The teacher edits the coursework between the phases (updateTime rotates): the approval no longer names it.
+    stubReads({ 'classroom courses get': COURSE_JSON, 'classroom coursework get': COURSEWORK_JSON.replace('2026-09-21T10:00:00Z', '2026-09-22T08:00:00Z') });
+    expect(json(await h.callTool('gog_classroom_coursework_update', { ...args, confirmToken: p1.confirmToken }))).toMatchObject({ error: 'DRAFT_CHANGED' });
+    stubReads({ 'classroom courses get': COURSE_JSON, 'classroom coursework get': COURSEWORK_JSON });
+    await h.callTool('gog_classroom_coursework_update', { ...args, confirmToken: p1.confirmToken });
+    expect(calls('classroom', 'coursework', 'update')).toHaveLength(1);
+  });
+
+  it('returns a failed course read without prompting or publishing', async () => {
+    vi.mocked(lib.runOrDiagnose).mockImplementation(async (args) => {
+      const key = (args as unknown[]).map((a) => (typeof a === 'string' ? a : (a as { value: string }).value)).join(' ');
+      if (key.startsWith('classroom courses get')) return { content: [{ type: 'text', text: 'Error: not found' }], isError: true };
+      return rawTextResult(COURSEWORK_JSON);
+    });
+    const { h, messages } = await prompted();
+    const r = await h.callTool('gog_classroom_coursework_update', { courseId: 'c1', courseworkId: 'w1', state: 'PUBLISHED' });
+    expect(r.isError).toBe(true);
+    expect(messages).toHaveLength(0);
+    expect(calls('classroom', 'coursework', 'update')).toHaveLength(0);
+  });
+
+  it('returns a failed coursework read without prompting or publishing', async () => {
+    vi.mocked(lib.runOrDiagnose).mockImplementation(async (args) => {
+      const key = (args as unknown[]).map((a) => (typeof a === 'string' ? a : (a as { value: string }).value)).join(' ');
+      if (key.startsWith('classroom coursework get')) return { content: [{ type: 'text', text: 'Error: not found' }], isError: true };
+      return rawTextResult(COURSE_JSON);
+    });
+    const { h, messages } = await prompted();
+    const r = await h.callTool('gog_classroom_coursework_update', { courseId: 'c1', courseworkId: 'w1', state: 'PUBLISHED' });
+    expect(r.isError).toBe(true);
+    expect(messages).toHaveLength(0);
+    expect(calls('classroom', 'coursework', 'update')).toHaveLength(0);
+  });
+});
+
 describe('gog_classroom_announcements_delete', () => {
   it('calls runOrDiagnose with ids', async () => {
     await harness.callTool('gog_classroom_announcements_delete', { courseId: 'c1', announcementId: 'a1' });