From c58afeb3745e08b01dc964628b7e7520ca76603f Mon Sep 17 00:00:00 2001
From: Adam Teichert <adam.teichert@snow.edu>
Date: Sat, 10 Oct 2026 23:51:50 -0600
Subject: [PATCH 1/5] Update in Canvas moves an item to its file's module

Creating an item put it in the module named after its folder, but
updating never looked at modules, so moving a file to another module
changed nothing in Canvas. After updating an assignment, quiz or page,
Update in Canvas now finds the item's module items (module_item_sequence)
and moves one into the right module, or adds it when it is in none. The
module list is loaded first so a missing module isn't created twice.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 docs/getting-started.html                     |  3 +-
 .../AssignmentDayItemContextMenu.tsx          |  1 +
 .../day/itemInDay/QuizDayItemContextMenu.tsx  |  1 +
 .../AssignmentFooterButtons.tsx               |  1 +
 .../compare/CompareWithCanvas.tsx             | 11 ++-
 .../page/[pageName]/EditPageButtons.tsx       |  3 +-
 .../quiz/[quizName]/QuizButton.tsx            |  2 +-
 .../canvas/hooks/canvasAssignmentHooks.ts     |  9 +++
 .../canvas/hooks/canvasModuleHooks.ts         | 38 +++++++++
 src/features/canvas/hooks/canvasPageHooks.ts  | 23 ++++--
 src/features/canvas/hooks/canvasQuizHooks.ts  |  9 +++
 .../services/canvasModuleService.test.ts      | 77 +++++++++++++++++++
 .../canvas/services/canvasModuleService.ts    | 43 +++++++++++
 13 files changed, 209 insertions(+), 12 deletions(-)
 create mode 100644 src/features/canvas/services/canvasModuleService.test.ts

diff --git a/docs/getting-started.html b/docs/getting-started.html
index 9b1427c8..290c4180 100644
--- a/docs/getting-started.html
+++ b/docs/getting-started.html
@@ -291,7 +291,7 @@ <h2 id="publishing">Publishing to Canvas</h2>
 <p>Each editor&rsquo;s footer says where the item stands and shows the one button you need next:</p>
 <ul>
 <li><b>Not in Canvas yet</b>: <b>Add to Canvas</b> creates the item in Canvas, unpublished, with its rendered description, dates, rubric and module entry. A module that does not exist yet is created.</li>
-<li><b>3 differences from Canvas</b> (in amber): <b>Update in Canvas</b> pushes the current file over the existing Canvas item. Submissions and grades are untouched. Click the amber text to open <a href="#compare">Compare with Canvas</a>.</li>
+<li><b>3 differences from Canvas</b> (in amber): <b>Update in Canvas</b> pushes the current file over the existing Canvas item, and moves it into the module its file is in if you moved the file. Submissions and grades are untouched. Click the amber text to open <a href="#compare">Compare with Canvas</a>.</li>
 <li><b>In sync &middot; students can&rsquo;t see it yet</b>: <b>Publish in Canvas</b> makes it visible to students. If the item&rsquo;s module is still unpublished in Canvas, the app says so and links to the modules page; it does not publish the module for you.</li>
 <li><b>In sync &middot; Published</b>: nothing to do; <b>View in Canvas</b> opens it.</li>
 <li>For a <b>quiz</b>, Update in Canvas also replaces the questions with the file&rsquo;s when any of them differ. If students have already started, it asks first: their attempts keep the questions they got and are not regraded. It refuses a change to the quiz&rsquo;s point total, since their scores are out of the total they were given.</li>
@@ -364,6 +364,7 @@ <h2 id="tips">Tips</h2>
 <h2 id="changes">Recent changes</h2>
 <div class="tw"><table>
 <tr><th>When</th><th>What changed</th></tr>
+<tr><td style="white-space:nowrap">Oct 2026</td><td><a href="#publishing">Update in Canvas</a> moves an item to the module its file is now in, or adds it to that module if it was in none.</td></tr>
 <tr><td style="white-space:nowrap">Oct 2026</td><td><a href="#compare">Compare with Canvas</a> checks a quiz&rsquo;s password, allowed attempts, shuffle answers, show correct answers and one question at a time, so changing only one of them no longer shows the quiz as in sync.</td></tr>
 <tr><td style="white-space:nowrap">Oct 2026</td><td><a href="#compare">Compare with Canvas</a> compares short-answer answers as plain text, so an answer like <code>+</code> or <code>a*b*c</code> no longer shows as different when it matches.</td></tr>
 <tr><td style="white-space:nowrap">Oct 2026</td><td><a href="#publishing">Update in Canvas</a> refuses to change a quiz&rsquo;s point total once students have started, since their scores are out of the total they were given.</td></tr>
diff --git a/src/app/course/[courseName]/calendar/day/itemInDay/AssignmentDayItemContextMenu.tsx b/src/app/course/[courseName]/calendar/day/itemInDay/AssignmentDayItemContextMenu.tsx
index 65af31b7..59e2ff76 100644
--- a/src/app/course/[courseName]/calendar/day/itemInDay/AssignmentDayItemContextMenu.tsx
+++ b/src/app/course/[courseName]/calendar/day/itemInDay/AssignmentDayItemContextMenu.tsx
@@ -140,6 +140,7 @@ export const AssignmentDayItemContextMenu: FC<{
       updateInCanvasMutation.mutate({
         canvasAssignmentId: assignmentInCanvas.id,
         assignment: item as LocalAssignment,
+        moduleName,
       });
       handleClose();
     }
diff --git a/src/app/course/[courseName]/calendar/day/itemInDay/QuizDayItemContextMenu.tsx b/src/app/course/[courseName]/calendar/day/itemInDay/QuizDayItemContextMenu.tsx
index 23784ca9..8f81de95 100644
--- a/src/app/course/[courseName]/calendar/day/itemInDay/QuizDayItemContextMenu.tsx
+++ b/src/app/course/[courseName]/calendar/day/itemInDay/QuizDayItemContextMenu.tsx
@@ -107,6 +107,7 @@ export const QuizDayItemContextMenu: FC<{
     updateInCanvasMutation.mutate({
       quiz: item as LocalQuiz,
       canvasQuizId: quizInCanvas.id,
+      moduleName,
     });
     handleClose();
   };
diff --git a/src/app/course/[courseName]/modules/[moduleName]/assignment/[assignmentName]/AssignmentFooterButtons.tsx b/src/app/course/[courseName]/modules/[moduleName]/assignment/[assignmentName]/AssignmentFooterButtons.tsx
index 633559fb..c62b7951 100644
--- a/src/app/course/[courseName]/modules/[moduleName]/assignment/[assignmentName]/AssignmentFooterButtons.tsx
+++ b/src/app/course/[courseName]/modules/[moduleName]/assignment/[assignmentName]/AssignmentFooterButtons.tsx
@@ -159,6 +159,7 @@ export function AssignmentFooterButtons({
         updateAssignment.mutate({
           canvasAssignmentId: assignmentInCanvas.id,
           assignment,
+          moduleName,
         })
       }
       onViewInCanvas={() => {
diff --git a/src/app/course/[courseName]/modules/[moduleName]/compare/CompareWithCanvas.tsx b/src/app/course/[courseName]/modules/[moduleName]/compare/CompareWithCanvas.tsx
index 9eb60a6d..1367ad61 100644
--- a/src/app/course/[courseName]/modules/[moduleName]/compare/CompareWithCanvas.tsx
+++ b/src/app/course/[courseName]/modules/[moduleName]/compare/CompareWithCanvas.tsx
@@ -131,7 +131,11 @@ export function CompareAssignmentWithCanvas({
       onRefresh={() => refetch()}
       onUpdate={() =>
         canvasAssignment &&
-        update.mutate({ assignment, canvasAssignmentId: canvasAssignment.id })
+        update.mutate({
+          assignment,
+          canvasAssignmentId: canvasAssignment.id,
+          moduleName,
+        })
       }
       updating={update.isPending}
       updateNote="Update Canvas pushes the file's dates, group settings, rubric and description. Submissions and grades are untouched."
@@ -219,7 +223,8 @@ export function CompareQuizWithCanvas({
         }
       }}
       onUpdate={() =>
-        canvasQuiz && update.mutate({ quiz, canvasQuizId: canvasQuiz.id })
+        canvasQuiz &&
+        update.mutate({ quiz, canvasQuizId: canvasQuiz.id, moduleName })
       }
       updating={update.isPending}
       updateNote="Update Canvas pushes the file's settings and, if any question differs, replaces the questions in Canvas with the file's. When it replaces them on a published quiz, students keep getting the old questions until you click Save it now on the quiz page in Canvas (the API can't do that). If students have started, it warns first: they keep the questions they got and are not regraded. It refuses to change the point total they were scored out of."
@@ -293,7 +298,7 @@ export function ComparePageWithCanvas({
       onRefresh={() => refetch()}
       onUpdate={() =>
         canvasPage &&
-        update.mutate({ page, canvasPageId: canvasPage.page_id })
+        update.mutate({ page, canvasPage, moduleName })
       }
       updating={update.isPending}
       updateNote="Update in Canvas replaces the page's content with the file's."
diff --git a/src/app/course/[courseName]/modules/[moduleName]/page/[pageName]/EditPageButtons.tsx b/src/app/course/[courseName]/modules/[moduleName]/page/[pageName]/EditPageButtons.tsx
index af0f994b..95341c9f 100644
--- a/src/app/course/[courseName]/modules/[moduleName]/page/[pageName]/EditPageButtons.tsx
+++ b/src/app/course/[courseName]/modules/[moduleName]/page/[pageName]/EditPageButtons.tsx
@@ -121,7 +121,8 @@ export default function EditPageButtons({
         pageInCanvas &&
         updatePageInCanvas.mutate({
           page,
-          canvasPageId: pageInCanvas.page_id,
+          canvasPage: pageInCanvas,
+          moduleName,
         })
       }
       extraActions={extraActions}
diff --git a/src/app/course/[courseName]/modules/[moduleName]/quiz/[quizName]/QuizButton.tsx b/src/app/course/[courseName]/modules/[moduleName]/quiz/[quizName]/QuizButton.tsx
index c16472f9..d2941d68 100644
--- a/src/app/course/[courseName]/modules/[moduleName]/quiz/[quizName]/QuizButton.tsx
+++ b/src/app/course/[courseName]/modules/[moduleName]/quiz/[quizName]/QuizButton.tsx
@@ -128,7 +128,7 @@ export function QuizButtons({
       onAdd={() => addToCanvas.mutate({ quiz, moduleName })}
       onUpdate={() =>
         quizInCanvas &&
-        updateInCanvas.mutate({ quiz, canvasQuizId: quizInCanvas.id })
+        updateInCanvas.mutate({ quiz, canvasQuizId: quizInCanvas.id, moduleName })
       }
       updateTitle="Pushes settings and, if any question differs, replaces the questions in Canvas with the file's. If it replaced them on a published quiz, click Save it now in Canvas afterwards so students get them. Warns first if students have started."
       extraActions={extraActions}
diff --git a/src/features/canvas/hooks/canvasAssignmentHooks.ts b/src/features/canvas/hooks/canvasAssignmentHooks.ts
index cead312a..52b5a339 100644
--- a/src/features/canvas/hooks/canvasAssignmentHooks.ts
+++ b/src/features/canvas/hooks/canvasAssignmentHooks.ts
@@ -12,6 +12,7 @@ import { useCanvasLinkTargets } from "./useCanvasLinkTargets";
 import { useCommitAfterPublish } from "@/features/local/git/gitHooks";
 import { useAssignmentPublishOptions } from "./useAssignmentPublishOptions";
 import { usePrepareImagesForCanvas } from "./usePrepareImagesForCanvas";
+import { usePlaceInCanvasModule } from "./canvasModuleHooks";
 
 export const canvasAssignmentKeys = {
   assignments: (canvasCourseId: number) =>
@@ -96,6 +97,7 @@ export const useUpdateAssignmentInCanvasMutation = () => {
   const canvasLinkTargets = useCanvasLinkTargets();
   const getPublishOptions = useAssignmentPublishOptions();
   const prepareImages = usePrepareImagesForCanvas();
+  const placeInModule = usePlaceInCanvasModule();
 
   const commitAfterPublish = useCommitAfterPublish();
 
@@ -103,9 +105,11 @@ export const useUpdateAssignmentInCanvasMutation = () => {
     mutationFn: async ({
       assignment,
       canvasAssignmentId,
+      moduleName,
     }: {
       assignment: LocalAssignment;
       canvasAssignmentId: number;
+      moduleName: string;
     }) => {
       const assignmentGroup = settings.assignmentGroups.find(
         (g) => g.name === assignment.localAssignmentGroupName,
@@ -120,6 +124,11 @@ export const useUpdateAssignmentInCanvasMutation = () => {
         canvasLinkTargets,
         getPublishOptions(assignment),
       );
+      await placeInModule(moduleName, {
+        type: "Assignment",
+        id: canvasAssignmentId,
+        title: assignment.name,
+      });
     },
     onSuccess: (_data, variables) => {
       commitAfterPublish(`assignment "${variables.assignment.name}"`);
diff --git a/src/features/canvas/hooks/canvasModuleHooks.ts b/src/features/canvas/hooks/canvasModuleHooks.ts
index 3e9799bc..dddaacbe 100644
--- a/src/features/canvas/hooks/canvasModuleHooks.ts
+++ b/src/features/canvas/hooks/canvasModuleHooks.ts
@@ -2,6 +2,7 @@ import { useLocalCourseSettingsQuery } from "@/features/local/course/localCourse
 import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
 import { canvasModuleService } from "../services/canvasModuleService";
 import { IModuleItem } from "@/features/local/modules/IModuleItem";
+import toast from "react-hot-toast";
 
 export const canvasCourseModuleKeys = {
   modules: (canvasId: number) => ["canvas", canvasId, "module list"] as const,
@@ -30,6 +31,43 @@ export const useAddCanvasModuleMutation = () => {
   });
 };
 
+/**
+ * For Update in Canvas: puts an item in the Canvas module named after its
+ * folder, so moving a file to another module moves it in Canvas too.
+ */
+export const usePlaceInCanvasModule = () => {
+  const { data: settings } = useLocalCourseSettingsQuery();
+  const queryClient = useQueryClient();
+  const addModule = useAddCanvasModuleMutation();
+  return async (
+    moduleName: string,
+    item: Parameters<typeof canvasModuleService.placeInModule>[2]
+  ) => {
+    // loaded, not just cached, so a missing module isn't created twice
+    const modules = await queryClient.ensureQueryData({
+      queryKey: canvasCourseModuleKeys.modules(settings.canvasId),
+      queryFn: () => canvasModuleService.getCourseModules(settings.canvasId),
+    });
+    const moduleId =
+      modules.find((m) => m.name === moduleName)?.id ??
+      (await addModule.mutateAsync(moduleName));
+    const placed = await canvasModuleService.placeInModule(
+      settings.canvasId,
+      moduleId,
+      item
+    );
+    if (placed !== "already") {
+      toast.success(
+        `${placed === "moved" ? "Moved" : "Added"} "${item.title}" to the "${moduleName}" module in Canvas.`
+      );
+      queryClient.invalidateQueries({
+        queryKey: canvasCourseModuleKeys.modules(settings.canvasId),
+      });
+    }
+    return placed;
+  };
+};
+
 export const useReorderCanvasModuleItemsMutation = () => {
   const { data: settings } = useLocalCourseSettingsQuery();
   const queryClient = useQueryClient();
diff --git a/src/features/canvas/hooks/canvasPageHooks.ts b/src/features/canvas/hooks/canvasPageHooks.ts
index 58794ded..281c72e5 100644
--- a/src/features/canvas/hooks/canvasPageHooks.ts
+++ b/src/features/canvas/hooks/canvasPageHooks.ts
@@ -10,6 +10,7 @@ import { canvasPageService } from "../services/canvasPageService";
 import { useCanvasLinkTargets } from "./useCanvasLinkTargets";
 import { useCommitAfterPublish } from "@/features/local/git/gitHooks";
 import { usePrepareImagesForCanvas } from "./usePrepareImagesForCanvas";
+import { usePlaceInCanvasModule } from "./canvasModuleHooks";
 
 export const canvasPageKeys = {
   pagesInCourse: (courseCanvasId: number) => [
@@ -85,22 +86,32 @@ export const useUpdateCanvasPageMutation = () => {
   const canvasLinkTargets = useCanvasLinkTargets();
   const prepareImages = usePrepareImagesForCanvas();
   const commitAfterPublish = useCommitAfterPublish();
+  const placeInModule = usePlaceInCanvasModule();
 
   return useMutation({
     mutationFn: async ({
       page,
-      canvasPageId,
+      canvasPage,
+      moduleName,
     }: {
       page: LocalCoursePage;
-      canvasPageId: number;
-    }) =>
-      canvasPageService.update(
+      canvasPage: { page_id: number; url: string };
+      moduleName: string;
+    }) => {
+      await canvasPageService.update(
         settings.canvasId,
-        canvasPageId,
+        canvasPage.page_id,
         page,
         await prepareImages([page.text]),
         canvasLinkTargets
-      ),
+      );
+      await placeInModule(moduleName, {
+        type: "Page",
+        id: canvasPage.page_id,
+        title: page.name,
+        pageUrl: canvasPage.url,
+      });
+    },
     onSuccess: (_data, variables) => {
       commitAfterPublish(`page "${variables.page.name}"`);
       queryClient.invalidateQueries({
diff --git a/src/features/canvas/hooks/canvasQuizHooks.ts b/src/features/canvas/hooks/canvasQuizHooks.ts
index 3122509f..3a606818 100644
--- a/src/features/canvas/hooks/canvasQuizHooks.ts
+++ b/src/features/canvas/hooks/canvasQuizHooks.ts
@@ -2,6 +2,7 @@ import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
 import {
   useAddCanvasModuleMutation,
   useCanvasModulesQuery,
+  usePlaceInCanvasModule,
 } from "./canvasModuleHooks";
 import { LocalQuiz } from "@/features/local/quizzes/models/localQuiz";
 import { useLocalCourseSettingsQuery } from "@/features/local/course/localCoursesHooks";
@@ -149,6 +150,7 @@ export const useUpdateQuizInCanvasMutation = () => {
   const queryClient = useQueryClient();
   const canvasLinkTargets = useCanvasLinkTargets();
   const prepareImages = usePrepareImagesForCanvas();
+  const placeInModule = usePlaceInCanvasModule();
 
   const commitAfterPublish = useCommitAfterPublish();
 
@@ -156,9 +158,11 @@ export const useUpdateQuizInCanvasMutation = () => {
     mutationFn: async ({
       quiz,
       canvasQuizId,
+      moduleName,
     }: {
       quiz: LocalQuiz;
       canvasQuizId: number;
+      moduleName: string;
     }) => {
       const versions = await canvasQuizService.getVersionsTaken(
         settings.canvasId,
@@ -197,6 +201,11 @@ export const useUpdateQuizInCanvasMutation = () => {
               ).every((q) => q.same),
           }
         );
+        await placeInModule(moduleName, {
+          type: "Quiz",
+          id: canvasQuizId,
+          title: quiz.name,
+        });
         const updated = summary.questionsReplaced
           ? `Updated "${quiz.name}" in Canvas: settings, ${summary.questionsRemoved} questions removed, ${summary.questionsAdded} added.`
           : `Updated "${quiz.name}" in Canvas: settings. Its questions already matched the file, so they were left alone.`;
diff --git a/src/features/canvas/services/canvasModuleService.test.ts b/src/features/canvas/services/canvasModuleService.test.ts
new file mode 100644
index 00000000..b61a4eb9
--- /dev/null
+++ b/src/features/canvas/services/canvasModuleService.test.ts
@@ -0,0 +1,77 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { canvasModuleService } from "./canvasModuleService";
+import { axiosClient } from "@/services/axiosUtils";
+import { rateLimitAwarePost } from "./canvasWebRequestUtils";
+
+vi.mock("@/services/axiosUtils", () => ({
+  axiosClient: { get: vi.fn(), put: vi.fn() },
+}));
+vi.mock("./canvasWebRequestUtils", () => ({ rateLimitAwarePost: vi.fn() }));
+vi.mock("./canvasServiceUtils", () => ({
+  canvasApi: "https://test.instructure.com/api/v1",
+  paginatedRequest: vi.fn(),
+}));
+
+const inModules = (...moduleIds: number[]) =>
+  vi.mocked(axiosClient.get).mockResolvedValue({
+    data: {
+      items: moduleIds.map((module_id, i) => ({
+        current: { id: 500 + i, module_id },
+      })),
+    },
+  });
+
+describe("placeInModule", () => {
+  const quiz = { type: "Quiz" as const, id: 7, title: "Quiz 1" };
+  beforeEach(() => vi.clearAllMocks());
+
+  it("leaves an item alone when it is already in the module", async () => {
+    inModules(3, 9);
+
+    expect(await canvasModuleService.placeInModule(42, 9, quiz)).toBe("already");
+    expect(axiosClient.put).not.toHaveBeenCalled();
+    expect(rateLimitAwarePost).not.toHaveBeenCalled();
+  });
+
+  it("moves an item from another module", async () => {
+    inModules(3);
+
+    expect(await canvasModuleService.placeInModule(42, 9, quiz)).toBe("moved");
+    expect(vi.mocked(axiosClient.put).mock.calls).toEqual([
+      [
+        "https://test.instructure.com/api/v1/courses/42/modules/3/items/500",
+        { module_item: { module_id: 9 } },
+      ],
+    ]);
+  });
+
+  it("adds an item that is in no module", async () => {
+    inModules();
+
+    expect(await canvasModuleService.placeInModule(42, 9, quiz)).toBe("added");
+    expect(vi.mocked(rateLimitAwarePost).mock.calls).toEqual([
+      [
+        "https://test.instructure.com/api/v1/courses/42/modules/9/items",
+        { module_item: { title: "Quiz 1", type: "Quiz", content_id: 7 } },
+      ],
+    ]);
+  });
+
+  it("finds a page by its id and adds it by its url", async () => {
+    inModules();
+
+    await canvasModuleService.placeInModule(42, 9, {
+      type: "Page",
+      id: 12,
+      title: "Schedule",
+      pageUrl: "schedule",
+    });
+    expect(vi.mocked(axiosClient.get).mock.calls[0]).toEqual([
+      "https://test.instructure.com/api/v1/courses/42/module_item_sequence",
+      { params: { asset_type: "Page", asset_id: 12 } },
+    ]);
+    expect(vi.mocked(rateLimitAwarePost).mock.calls[0][1]).toEqual({
+      module_item: { title: "Schedule", type: "Page", page_url: "schedule" },
+    });
+  });
+});
diff --git a/src/features/canvas/services/canvasModuleService.ts b/src/features/canvas/services/canvasModuleService.ts
index e05c0049..1748b09a 100644
--- a/src/features/canvas/services/canvasModuleService.ts
+++ b/src/features/canvas/services/canvasModuleService.ts
@@ -55,6 +55,49 @@ export const canvasModuleService = {
     await rateLimitAwarePost<CanvasModuleItem>(url, body);
   },
 
+  /**
+   * Puts an item in a module: leaves it if it's already there, moves it from
+   * another module, or adds it when it's in none.
+   */
+  async placeInModule(
+    canvasCourseId: number,
+    canvasModuleId: number,
+    item: {
+      type: "Assignment" | "Quiz" | "Page";
+      id: number;
+      title: string;
+      pageUrl?: string;
+    }
+  ): Promise<"already" | "moved" | "added"> {
+    const { data } = await axiosClient.get<{
+      items: { current?: { id: number; module_id: number } }[];
+    }>(`${canvasApi}/courses/${canvasCourseId}/module_item_sequence`, {
+      params: { asset_type: item.type, asset_id: item.id },
+    });
+    const placements = data.items.flatMap((i) => (i.current ? [i.current] : []));
+    if (placements.some((p) => p.module_id === canvasModuleId)) return "already";
+
+    if (placements.length > 0) {
+      const [from] = placements;
+      await axiosClient.put(
+        `${canvasApi}/courses/${canvasCourseId}/modules/${from.module_id}/items/${from.id}`,
+        { module_item: { module_id: canvasModuleId } }
+      );
+      return "moved";
+    }
+
+    await rateLimitAwarePost(
+      `${canvasApi}/courses/${canvasCourseId}/modules/${canvasModuleId}/items`,
+      {
+        module_item:
+          item.type === "Page"
+            ? { title: item.title, type: "Page", page_url: item.pageUrl }
+            : { title: item.title, type: item.type, content_id: item.id },
+      }
+    );
+    return "added";
+  },
+
   async getCourseModules(canvasCourseId: number) {
     const url = `${canvasApi}/courses/${canvasCourseId}/modules`;
     const response = await paginatedRequest<CanvasModule[]>({ url });

From 87082491766af24b22b2f84565535ac943a14872 Mon Sep 17 00:00:00 2001
From: Adam Teichert <adam.teichert@snow.edu>
Date: Mon, 12 Oct 2026 14:51:23 -0600
Subject: [PATCH 2/5] Add to Canvas shares the module lookup with Update

One addModuleItem replaces createModuleItem and createPageModuleItem, and
useCanvasModuleIdByName replaces the find-or-create copied into each add
hook. Adding a quiz or page before the module list loaded used to do
nothing; now it loads the list first.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 .../quiz/[quizName]/QuizButton.tsx            |  6 +-
 .../canvas/hooks/canvasAssignmentHooks.ts     | 26 ++------
 .../canvas/hooks/canvasModuleHooks.ts         | 37 ++++++++----
 src/features/canvas/hooks/canvasPageHooks.ts  | 30 ++++------
 src/features/canvas/hooks/canvasQuizHooks.ts  | 24 ++------
 .../canvas/services/canvasModuleService.ts    | 59 +++++++------------
 6 files changed, 73 insertions(+), 109 deletions(-)

diff --git a/src/app/course/[courseName]/modules/[moduleName]/quiz/[quizName]/QuizButton.tsx b/src/app/course/[courseName]/modules/[moduleName]/quiz/[quizName]/QuizButton.tsx
index d2941d68..f200eb55 100644
--- a/src/app/course/[courseName]/modules/[moduleName]/quiz/[quizName]/QuizButton.tsx
+++ b/src/app/course/[courseName]/modules/[moduleName]/quiz/[quizName]/QuizButton.tsx
@@ -128,7 +128,11 @@ export function QuizButtons({
       onAdd={() => addToCanvas.mutate({ quiz, moduleName })}
       onUpdate={() =>
         quizInCanvas &&
-        updateInCanvas.mutate({ quiz, canvasQuizId: quizInCanvas.id, moduleName })
+        updateInCanvas.mutate({
+          quiz,
+          canvasQuizId: quizInCanvas.id,
+          moduleName,
+        })
       }
       updateTitle="Pushes settings and, if any question differs, replaces the questions in Canvas with the file's. If it replaced them on a published quiz, click Save it now in Canvas afterwards so students get them. Warns first if students have started."
       extraActions={extraActions}
diff --git a/src/features/canvas/hooks/canvasAssignmentHooks.ts b/src/features/canvas/hooks/canvasAssignmentHooks.ts
index 52b5a339..fcdc356d 100644
--- a/src/features/canvas/hooks/canvasAssignmentHooks.ts
+++ b/src/features/canvas/hooks/canvasAssignmentHooks.ts
@@ -1,8 +1,8 @@
 import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
 import { LocalAssignment } from "@/features/local/assignments/models/localAssignment";
 import {
-  useAddCanvasModuleMutation,
-  useCanvasModulesQuery,
+  useCanvasModuleIdByName,
+  usePlaceInCanvasModule,
 } from "./canvasModuleHooks";
 import { useLocalCourseSettingsQuery } from "@/features/local/course/localCoursesHooks";
 import { canvasModuleService } from "../services/canvasModuleService";
@@ -12,7 +12,6 @@ import { useCanvasLinkTargets } from "./useCanvasLinkTargets";
 import { useCommitAfterPublish } from "@/features/local/git/gitHooks";
 import { useAssignmentPublishOptions } from "./useAssignmentPublishOptions";
 import { usePrepareImagesForCanvas } from "./usePrepareImagesForCanvas";
-import { usePlaceInCanvasModule } from "./canvasModuleHooks";
 
 export const canvasAssignmentKeys = {
   assignments: (canvasCourseId: number) =>
@@ -30,8 +29,7 @@ export const useCanvasAssignmentsQuery = () => {
 
 export const useAddAssignmentToCanvasMutation = () => {
   const { data: settings } = useLocalCourseSettingsQuery();
-  const { data: canvasModules } = useCanvasModulesQuery();
-  const addModule = useAddCanvasModuleMutation();
+  const moduleIdByName = useCanvasModuleIdByName();
   const queryClient = useQueryClient();
   const canvasLinkTargets = useCanvasLinkTargets();
   const getPublishOptions = useAssignmentPublishOptions();
@@ -47,11 +45,6 @@ export const useAddAssignmentToCanvasMutation = () => {
       assignment: LocalAssignment;
       moduleName: string;
     }) => {
-      if (!canvasModules) {
-        // console.log("cannot add assignment until modules loaded");
-        throw new Error("cannot add assignment until modules loaded");
-      }
-
       const assignmentGroup = settings.assignmentGroups.find(
         (g) => g.name === assignment.localAssignmentGroupName,
       );
@@ -65,17 +58,10 @@ export const useAddAssignmentToCanvasMutation = () => {
         canvasLinkTargets,
         getPublishOptions(assignment),
       );
-      const canvasModule = canvasModules.find((c) => c.name === moduleName);
-      const moduleId = canvasModule
-        ? canvasModule.id
-        : await addModule.mutateAsync(moduleName);
-
-      await canvasModuleService.createModuleItem(
+      await canvasModuleService.addModuleItem(
         settings.canvasId,
-        moduleId,
-        assignment.name,
-        "Assignment",
-        canvasAssignmentId,
+        await moduleIdByName(moduleName),
+        { type: "Assignment", id: canvasAssignmentId, title: assignment.name },
       );
     },
     onSuccess: (_data, variables) => {
diff --git a/src/features/canvas/hooks/canvasModuleHooks.ts b/src/features/canvas/hooks/canvasModuleHooks.ts
index dddaacbe..78aa1d14 100644
--- a/src/features/canvas/hooks/canvasModuleHooks.ts
+++ b/src/features/canvas/hooks/canvasModuleHooks.ts
@@ -1,6 +1,9 @@
 import { useLocalCourseSettingsQuery } from "@/features/local/course/localCoursesHooks";
 import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
-import { canvasModuleService } from "../services/canvasModuleService";
+import {
+  canvasModuleService,
+  ModuleItemContent,
+} from "../services/canvasModuleService";
 import { IModuleItem } from "@/features/local/modules/IModuleItem";
 import toast from "react-hot-toast";
 
@@ -32,28 +35,38 @@ export const useAddCanvasModuleMutation = () => {
 };
 
 /**
- * For Update in Canvas: puts an item in the Canvas module named after its
- * folder, so moving a file to another module moves it in Canvas too.
+ * Finds a Canvas module's id by name, creating the module if Canvas has none.
+ * Loads the module list first (not just whatever is cached), so a missing
+ * module isn't created twice.
  */
-export const usePlaceInCanvasModule = () => {
+export const useCanvasModuleIdByName = () => {
   const { data: settings } = useLocalCourseSettingsQuery();
   const queryClient = useQueryClient();
   const addModule = useAddCanvasModuleMutation();
-  return async (
-    moduleName: string,
-    item: Parameters<typeof canvasModuleService.placeInModule>[2]
-  ) => {
-    // loaded, not just cached, so a missing module isn't created twice
+  return async (moduleName: string) => {
     const modules = await queryClient.ensureQueryData({
       queryKey: canvasCourseModuleKeys.modules(settings.canvasId),
       queryFn: () => canvasModuleService.getCourseModules(settings.canvasId),
     });
-    const moduleId =
+    return (
       modules.find((m) => m.name === moduleName)?.id ??
-      (await addModule.mutateAsync(moduleName));
+      (await addModule.mutateAsync(moduleName))
+    );
+  };
+};
+
+/**
+ * For Update in Canvas: puts an item in the Canvas module named after its
+ * folder, so moving a file to another module moves it in Canvas too.
+ */
+export const usePlaceInCanvasModule = () => {
+  const { data: settings } = useLocalCourseSettingsQuery();
+  const queryClient = useQueryClient();
+  const moduleIdByName = useCanvasModuleIdByName();
+  return async (moduleName: string, item: ModuleItemContent) => {
     const placed = await canvasModuleService.placeInModule(
       settings.canvasId,
-      moduleId,
+      await moduleIdByName(moduleName),
       item
     );
     if (placed !== "already") {
diff --git a/src/features/canvas/hooks/canvasPageHooks.ts b/src/features/canvas/hooks/canvasPageHooks.ts
index 281c72e5..674ae917 100644
--- a/src/features/canvas/hooks/canvasPageHooks.ts
+++ b/src/features/canvas/hooks/canvasPageHooks.ts
@@ -1,8 +1,8 @@
 import { LocalCoursePage } from "@/features/local/pages/localCoursePageModels";
 import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
 import {
-  useCanvasModulesQuery,
-  useAddCanvasModuleMutation,
+  useCanvasModuleIdByName,
+  usePlaceInCanvasModule,
 } from "./canvasModuleHooks";
 import { useLocalCourseSettingsQuery } from "@/features/local/course/localCoursesHooks";
 import { canvasModuleService } from "../services/canvasModuleService";
@@ -10,7 +10,6 @@ import { canvasPageService } from "../services/canvasPageService";
 import { useCanvasLinkTargets } from "./useCanvasLinkTargets";
 import { useCommitAfterPublish } from "@/features/local/git/gitHooks";
 import { usePrepareImagesForCanvas } from "./usePrepareImagesForCanvas";
-import { usePlaceInCanvasModule } from "./canvasModuleHooks";
 
 export const canvasPageKeys = {
   pagesInCourse: (courseCanvasId: number) => [
@@ -31,8 +30,7 @@ export const useCanvasPagesQuery = () => {
 export const useCreateCanvasPageMutation = () => {
   const { data: settings } = useLocalCourseSettingsQuery();
   const queryClient = useQueryClient();
-  const { data: canvasModules } = useCanvasModulesQuery();
-  const addModule = useAddCanvasModuleMutation();
+  const moduleIdByName = useCanvasModuleIdByName();
   const canvasLinkTargets = useCanvasLinkTargets();
   const prepareImages = usePrepareImagesForCanvas();
 
@@ -46,10 +44,6 @@ export const useCreateCanvasPageMutation = () => {
       page: LocalCoursePage;
       moduleName: string;
     }) => {
-      if (!canvasModules) {
-        console.log("cannot add page until modules loaded");
-        return;
-      }
       const publishSettings = await prepareImages([page.text]);
       const canvasPage = await canvasPageService.create(
         settings.canvasId,
@@ -57,17 +51,15 @@ export const useCreateCanvasPageMutation = () => {
         publishSettings,
         canvasLinkTargets
       );
-
-      const canvasModule = canvasModules.find((c) => c.name === moduleName);
-      const moduleId = canvasModule
-        ? canvasModule.id
-        : await addModule.mutateAsync(moduleName);
-
-      await canvasModuleService.createPageModuleItem(
+      await canvasModuleService.addModuleItem(
         settings.canvasId,
-        moduleId,
-        page.name,
-        canvasPage
+        await moduleIdByName(moduleName),
+        {
+          type: "Page",
+          id: canvasPage.page_id,
+          title: page.name,
+          pageUrl: canvasPage.url,
+        }
       );
       return canvasPage;
     },
diff --git a/src/features/canvas/hooks/canvasQuizHooks.ts b/src/features/canvas/hooks/canvasQuizHooks.ts
index 3a606818..79bf8721 100644
--- a/src/features/canvas/hooks/canvasQuizHooks.ts
+++ b/src/features/canvas/hooks/canvasQuizHooks.ts
@@ -1,7 +1,6 @@
 import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
 import {
-  useAddCanvasModuleMutation,
-  useCanvasModulesQuery,
+  useCanvasModuleIdByName,
   usePlaceInCanvasModule,
 } from "./canvasModuleHooks";
 import { LocalQuiz } from "@/features/local/quizzes/models/localQuiz";
@@ -79,8 +78,7 @@ export const useCanvasAttemptQuestionsQuery = (attemptId: number | undefined) =>
 export const useAddQuizToCanvasMutation = () => {
   const { data: settings } = useLocalCourseSettingsQuery();
   const queryClient = useQueryClient();
-  const { data: canvasModules } = useCanvasModulesQuery();
-  const addModule = useAddCanvasModuleMutation();
+  const moduleIdByName = useCanvasModuleIdByName();
   const canvasLinkTargets = useCanvasLinkTargets();
   const prepareImages = usePrepareImagesForCanvas();
 
@@ -94,10 +92,6 @@ export const useAddQuizToCanvasMutation = () => {
       quiz: LocalQuiz;
       moduleName: string;
     }) => {
-      if (!canvasModules) {
-        console.log("cannot add quiz until modules loaded");
-        return;
-      }
       const assignmentGroup = settings.assignmentGroups.find(
         (g) => g.name === quiz.localAssignmentGroupName
       );
@@ -109,18 +103,10 @@ export const useAddQuizToCanvasMutation = () => {
         assignmentGroup?.canvasId,
         canvasLinkTargets
       );
-
-      const canvasModule = canvasModules.find((c) => c.name === moduleName);
-      const moduleId = canvasModule
-        ? canvasModule.id
-        : await addModule.mutateAsync(moduleName);
-
-      await canvasModuleService.createModuleItem(
+      await canvasModuleService.addModuleItem(
         settings.canvasId,
-        moduleId,
-        quiz.name,
-        "Quiz",
-        canvasQuizId
+        await moduleIdByName(moduleName),
+        { type: "Quiz", id: canvasQuizId, title: quiz.name }
       );
     },
     onSuccess: (_data, variables) => {
diff --git a/src/features/canvas/services/canvasModuleService.ts b/src/features/canvas/services/canvasModuleService.ts
index 1748b09a..689ac35a 100644
--- a/src/features/canvas/services/canvasModuleService.ts
+++ b/src/features/canvas/services/canvasModuleService.ts
@@ -1,10 +1,17 @@
 import { CanvasModuleItem } from "@/features/canvas/models/modules/canvasModuleItems";
-import { CanvasPage } from "@/features/canvas/models/pages/canvasPageModel";
 import { canvasApi, paginatedRequest } from "./canvasServiceUtils";
 import { CanvasModule } from "@/features/canvas/models/modules/canvasModule";
 import { axiosClient } from "@/services/axiosUtils";
 import { rateLimitAwarePost } from "./canvasWebRequestUtils";
 
+/** A Canvas item to put in a module; a page is added by its url. */
+export interface ModuleItemContent {
+  type: "Assignment" | "Quiz" | "Page";
+  id: number;
+  title: string;
+  pageUrl?: string;
+}
+
 export const canvasModuleService = {
   async updateModuleItem(
     canvasCourseId: number,
@@ -28,31 +35,20 @@ export const canvasModuleService = {
     return response.data;
   },
 
-  async createModuleItem(
+  async addModuleItem(
     canvasCourseId: number,
     canvasModuleId: number,
-    title: string,
-    type: "Assignment" | "Quiz",
-    contentId: number | string
+    item: ModuleItemContent
   ) {
-    console.log(`Creating new module item ${title}`);
-    const url = `${canvasApi}/courses/${canvasCourseId}/modules/${canvasModuleId}/items`;
-    const body = { module_item: { title, type, content_id: contentId } };
-    await rateLimitAwarePost(url, body);
-  },
-
-  async createPageModuleItem(
-    canvasCourseId: number,
-    canvasModuleId: number,
-    title: string,
-    canvasPage: CanvasPage
-  ) {
-    console.log(`Creating new module item ${title}`);
-    const url = `${canvasApi}/courses/${canvasCourseId}/modules/${canvasModuleId}/items`;
-    const body = {
-      module_item: { title, type: "Page", page_url: canvasPage.url },
-    };
-    await rateLimitAwarePost<CanvasModuleItem>(url, body);
+    await rateLimitAwarePost<CanvasModuleItem>(
+      `${canvasApi}/courses/${canvasCourseId}/modules/${canvasModuleId}/items`,
+      {
+        module_item:
+          item.type === "Page"
+            ? { title: item.title, type: "Page", page_url: item.pageUrl }
+            : { title: item.title, type: item.type, content_id: item.id },
+      }
+    );
   },
 
   /**
@@ -62,12 +58,7 @@ export const canvasModuleService = {
   async placeInModule(
     canvasCourseId: number,
     canvasModuleId: number,
-    item: {
-      type: "Assignment" | "Quiz" | "Page";
-      id: number;
-      title: string;
-      pageUrl?: string;
-    }
+    item: ModuleItemContent
   ): Promise<"already" | "moved" | "added"> {
     const { data } = await axiosClient.get<{
       items: { current?: { id: number; module_id: number } }[];
@@ -86,15 +77,7 @@ export const canvasModuleService = {
       return "moved";
     }
 
-    await rateLimitAwarePost(
-      `${canvasApi}/courses/${canvasCourseId}/modules/${canvasModuleId}/items`,
-      {
-        module_item:
-          item.type === "Page"
-            ? { title: item.title, type: "Page", page_url: item.pageUrl }
-            : { title: item.title, type: item.type, content_id: item.id },
-      }
-    );
+    await canvasModuleService.addModuleItem(canvasCourseId, canvasModuleId, item);
     return "added";
   },
 

From 40c10be8fb128c5edfa24855d64de7800b83dd27 Mon Sep 17 00:00:00 2001
From: Adam Teichert <adam.teichert@snow.edu>
Date: Mon, 12 Oct 2026 16:45:06 -0600
Subject: [PATCH 3/5] Compare with Canvas shows when an item's file moved
 module

The editor footer, compare page and calendar compare the file's module
folder with the Canvas modules that hold the item (one request for the
course's modules with their items), so a moved file is a difference
instead of In sync. Add to Canvas refreshes that list, so a new item
doesn't show as in no module. getStatus was a pass-through to
getSyncStatus and is gone.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 docs/getting-started.html                     |  4 +-
 .../calendar/day/getAssignmentSyncStatus.ts   | 24 ++++++-
 .../[courseName]/calendar/day/getStatus.tsx   | 43 -------------
 .../calendar/day/getSyncStatus.test.ts        | 36 +++++++++++
 .../calendar/day/useTodaysItems.tsx           | 27 ++++++--
 .../AssignmentFooterButtons.tsx               |  8 +++
 .../compare/CompareWithCanvas.tsx             | 64 +++++++++++++++----
 .../page/[pageName]/EditPageButtons.tsx       | 13 +++-
 .../quiz/[quizName]/QuizButton.tsx            |  5 ++
 .../canvas/hooks/canvasAssignmentHooks.ts     | 15 ++---
 .../canvas/hooks/canvasModuleHooks.ts         | 46 +++++++++++++
 src/features/canvas/hooks/canvasPageHooks.ts  | 21 +++---
 src/features/canvas/hooks/canvasQuizHooks.ts  | 15 ++---
 .../services/canvasModuleService.test.ts      | 28 +++++++-
 .../canvas/services/canvasModuleService.ts    | 33 ++++++++++
 15 files changed, 286 insertions(+), 96 deletions(-)
 delete mode 100644 src/app/course/[courseName]/calendar/day/getStatus.tsx

diff --git a/docs/getting-started.html b/docs/getting-started.html
index f093f860..493e1954 100644
--- a/docs/getting-started.html
+++ b/docs/getting-started.html
@@ -308,7 +308,7 @@ <h2 id="publishing">Publishing to Canvas</h2>
 <h3 id="compare">Compare with Canvas</h3>
 <p>When an item&rsquo;s border is red, <b>Compare with Canvas</b> (the amber <em>differences from Canvas</em> text in the editor footer, the menu on the footer&rsquo;s main button, the right-click menu, and the red pill&rsquo;s hover card) opens a page that lists every difference between your file and Canvas:</p>
 <ul>
-<li>A settings table with the file&rsquo;s value and Canvas&rsquo;s side by side: dates, assignment group, group set, points and each rubric row, and for a quiz its password, attempts and other options.</li>
+<li>A settings table with the file&rsquo;s value and Canvas&rsquo;s side by side: the module, dates, assignment group, group set, points and each rubric row, and for a quiz its password, attempts and other options.</li>
 <li>For a <b>quiz</b>, a row for every question, compared on type, points, text, answers (correct ones marked &#10003;) and feedback. Questions are lined up by what they say, not by number, so deleting or adding one doesn&rsquo;t make every later question look changed: a question you deleted from the file shows as one <em>Canvas question N</em> row, one you added as a row with nothing on the Canvas side, and one you moved as a <em>position</em> difference. Every question shows in full on both sides, answers included, and &#8800; marks the lines of each part that differs. The quiz editor&rsquo;s footer counts these differences too. The calendar checks questions for this week&rsquo;s quizzes and the next three weeks&rsquo;, fetching them in the background one quiz at a time (this week first) so Canvas doesn&rsquo;t throttle you; a quiz outside those four weeks gets its red border from settings and description only.</li>
 <li>For a quiz students have started, a <b>What students got</b> section for each quiz version they took, comparing the file with the questions from one of its attempts (ignoring each attempt&rsquo;s own answer shuffle). Canvas&rsquo;s current questions can differ from these until <em>Save it now</em>, and this is the only way to see what students actually got.</li>
 <li>The description (a page&rsquo;s content) <em>side by side</em>, as <em>changes only</em> (a word-level diff), or as the normalized <em>HTML</em> when you need to see why two descriptions that look the same count as different.</li>
@@ -364,7 +364,7 @@ <h2 id="tips">Tips</h2>
 <h2 id="changes">Recent changes</h2>
 <div class="tw"><table>
 <tr><th>When</th><th>What changed</th></tr>
-<tr><td style="white-space:nowrap">Oct 2026</td><td><a href="#publishing">Update in Canvas</a> moves an item to the module its file is now in, or adds it to that module if it was in none.</td></tr>
+<tr><td style="white-space:nowrap">Oct 2026</td><td><a href="#publishing">Update in Canvas</a> moves an item to the module its file is now in, or adds it to that module if it was in none. <a href="#compare">Compare with Canvas</a>, the editor footer and the calendar count a moved file as a difference.</td></tr>
 <tr><td style="white-space:nowrap">Oct 2026</td><td>Opening a course whose term has ended no longer shows a <em>roster.groupSets &hellip; 403</em> error: Canvas won&rsquo;t list group sets for a finished course, so it shows none.</td></tr>
 <tr><td style="white-space:nowrap">Oct 2026</td><td><a href="#compare">Compare with Canvas</a> checks a quiz&rsquo;s password, allowed attempts, shuffle answers, show correct answers and one question at a time, so changing only one of them no longer shows the quiz as in sync.</td></tr>
 <tr><td style="white-space:nowrap">Oct 2026</td><td><a href="#compare">Compare with Canvas</a> compares short-answer answers as plain text, so an answer like <code>+</code> or <code>a*b*c</code> no longer shows as different when it matches.</td></tr>
diff --git a/src/app/course/[courseName]/calendar/day/getAssignmentSyncStatus.ts b/src/app/course/[courseName]/calendar/day/getAssignmentSyncStatus.ts
index a0c06a87..41683e8c 100644
--- a/src/app/course/[courseName]/calendar/day/getAssignmentSyncStatus.ts
+++ b/src/app/course/[courseName]/calendar/day/getAssignmentSyncStatus.ts
@@ -35,6 +35,7 @@ export interface RosterForStatus {
 }
 
 export type SyncSection =
+  | "module"
   | "dates"
   | "grading"
   | "groups"
@@ -677,6 +678,22 @@ function buildReport(
   };
 }
 
+/** The file's module folder against the Canvas modules the item is in. */
+function checkModule(file: string, canvas: string[]): SyncField {
+  return field({
+    key: "module",
+    label: "Module",
+    section: "module",
+    local: file,
+    canvas: canvas.join(", ") || UNSET,
+    same: canvas.includes(file),
+    message:
+      canvas.length > 0
+        ? `module different: ${file} vs ${canvas.join(", ")}`
+        : "not in a module in canvas",
+  });
+}
+
 /**
  * Compares a local item with its Canvas copy field by field. `status` and
  * `message` drive the calendar border and tooltip; `fields` and `description`
@@ -690,6 +707,7 @@ export function getSyncReport({
   canvasLinkTargets,
   roster,
   canvasQuestions,
+  module,
 }: {
   item: LocalQuiz | LocalAssignment | LocalCoursePage;
   canvasItem: CanvasQuiz | CanvasAssignment | CanvasPage | undefined;
@@ -699,6 +717,8 @@ export function getSyncReport({
   roster?: RosterForStatus;
   /** A quiz's questions in Canvas; without them only its settings are compared. */
   canvasQuestions?: CanvasQuizQuestion[];
+  /** The file's module and the Canvas modules holding the item; without them the module is not compared. */
+  module?: { file: string; canvas: string[] };
 }): SyncReport {
   if (!canvasItem)
     return {
@@ -708,7 +728,9 @@ export function getSyncReport({
       fields: [],
     };
 
-  const fields: SyncField[] = [];
+  const fields: SyncField[] = module
+    ? [checkModule(module.file, module.canvas)]
+    : [];
 
   if (type === "page") {
     const page = item as LocalCoursePage;
diff --git a/src/app/course/[courseName]/calendar/day/getStatus.tsx b/src/app/course/[courseName]/calendar/day/getStatus.tsx
deleted file mode 100644
index 50abe5df..00000000
--- a/src/app/course/[courseName]/calendar/day/getStatus.tsx
+++ /dev/null
@@ -1,43 +0,0 @@
-"use client";
-import { CanvasAssignment } from "@/features/canvas/models/assignments/canvasAssignment";
-import { CanvasPage } from "@/features/canvas/models/pages/canvasPageModel";
-import { CanvasQuiz } from "@/features/canvas/models/quizzes/canvasQuizModel";
-import { LocalAssignment } from "@/features/local/assignments/models/localAssignment";
-import { LocalCoursePage } from "@/features/local/pages/localCoursePageModels";
-import { LocalQuiz } from "@/features/local/quizzes/models/localQuiz";
-import { LocalCourseSettings } from "@/features/local/course/localCourseSettings";
-import {
-  getSyncStatus,
-  ItemSyncStatus,
-  RosterForStatus,
-} from "./getAssignmentSyncStatus";
-import { CanvasLinkTargets } from "@/services/urlUtils";
-import { CanvasQuizQuestion } from "@/features/canvas/models/quizzes/canvasQuizQuestionModel";
-
-export const getStatus = ({
-  item,
-  canvasItem,
-  type,
-  settings,
-  canvasLinkTargets,
-  roster,
-  canvasQuestions,
-}: {
-  item: LocalQuiz | LocalAssignment | LocalCoursePage;
-  canvasItem?: CanvasQuiz | CanvasAssignment | CanvasPage;
-  type: "assignment" | "page" | "quiz";
-  settings: LocalCourseSettings;
-  canvasLinkTargets?: CanvasLinkTargets;
-  roster?: RosterForStatus;
-  canvasQuestions?: CanvasQuizQuestion[];
-}): ItemSyncStatus => {
-  return getSyncStatus({
-    item,
-    canvasItem,
-    type,
-    settings,
-    canvasLinkTargets,
-    roster,
-    canvasQuestions,
-  });
-};
diff --git a/src/app/course/[courseName]/calendar/day/getSyncStatus.test.ts b/src/app/course/[courseName]/calendar/day/getSyncStatus.test.ts
index 51cc69fa..5a272ce3 100644
--- a/src/app/course/[courseName]/calendar/day/getSyncStatus.test.ts
+++ b/src/app/course/[courseName]/calendar/day/getSyncStatus.test.ts
@@ -534,3 +534,39 @@ describe("getSyncReport - quiz options", () => {
     ).toEqual([]);
   });
 });
+
+describe("getSyncReport - module", () => {
+  const report = (canvasModules?: string[]) =>
+    getSyncReport({
+      item: baseLocalAssignment,
+      canvasItem: baseCanvasAssignment,
+      type: "assignment",
+      settings: baseSettings,
+      module: canvasModules && { file: "Week 2", canvas: canvasModules },
+    });
+
+  it("matches when the Canvas item is in the file's module", () => {
+    expect(report(["Week 1", "Week 2"]).differences).toEqual([]);
+  });
+
+  it("differs when the file moved to another module", () => {
+    const [difference] = report(["Week 1"]).differences;
+    expect(difference).toMatchObject({
+      key: "module",
+      local: "Week 2",
+      canvas: "Week 1",
+      message: "module different: Week 2 vs Week 1",
+    });
+  });
+
+  it("differs when the Canvas item is in no module", () => {
+    expect(report([]).differences[0]).toMatchObject({
+      canvas: "—",
+      message: "not in a module in canvas",
+    });
+  });
+
+  it("is not compared until the Canvas modules load", () => {
+    expect(report(undefined).fields.map((f) => f.key)).not.toContain("module");
+  });
+});
diff --git a/src/app/course/[courseName]/calendar/day/useTodaysItems.tsx b/src/app/course/[courseName]/calendar/day/useTodaysItems.tsx
index 66726a03..46bbea15 100644
--- a/src/app/course/[courseName]/calendar/day/useTodaysItems.tsx
+++ b/src/app/course/[courseName]/calendar/day/useTodaysItems.tsx
@@ -6,7 +6,6 @@ import {
 } from "@/features/local/utils/timeUtils";
 import { ReactNode } from "react";
 import { useCalendarItemsContext } from "../../context/calendarItemsContext";
-import { getStatus } from "./getStatus";
 import { useLocalCourseSettingsQuery } from "@/features/local/course/localCoursesHooks";
 import { useCanvasAssignmentsQuery } from "@/features/canvas/hooks/canvasAssignmentHooks";
 import { useCanvasPagesQuery } from "@/features/canvas/hooks/canvasPageHooks";
@@ -16,7 +15,13 @@ import {
   useRosterGroupSetsQuery,
   useRosterStudentsQuery,
 } from "@/features/canvas/roster/rosterHooks";
-import { getScheduleEntryStatus, SyncField } from "./getAssignmentSyncStatus";
+import {
+  getScheduleEntryStatus,
+  getSyncStatus,
+  SyncField,
+} from "./getAssignmentSyncStatus";
+import { useCanvasModulesWithItemsQuery } from "@/features/canvas/hooks/canvasModuleHooks";
+import { canvasModuleNames } from "@/features/canvas/services/canvasModuleService";
 import { AssignmentScheduleEntry } from "@/features/local/assignments/models/localAssignment";
 import { useCalendarQuizQuestions } from "../../context/CalendarQuizQuestionsProvider";
 
@@ -52,6 +57,15 @@ export function useTodaysItems(day: string) {
   const roster = { students: rosterStudents, groupSets: rosterGroupSets };
   // filled in the background for this week's and the next three weeks' quizzes
   const quizQuestions = useCalendarQuizQuestions();
+  const { data: canvasModules } = useCanvasModulesWithItemsQuery();
+  const module = (
+    file: string,
+    type: TodayItem["type"],
+    canvasItem: { id?: number; url?: string } | undefined,
+  ) =>
+    canvasModules && canvasItem
+      ? { file, canvas: canvasModuleNames(canvasModules, type, canvasItem) }
+      : undefined;
 
   const assignments: TodayItem[] = todaysModules
     ? Object.keys(todaysModules).flatMap((moduleName) =>
@@ -63,7 +77,7 @@ export function useTodaysItems(day: string) {
             type: "assignment" as const,
             item: assignment,
             moduleName,
-            ...getStatus({
+            ...getSyncStatus({
               item: assignment,
               canvasItem: canvasAssignment,
               type: "assignment",
@@ -73,6 +87,7 @@ export function useTodaysItems(day: string) {
                 quizzes: canvasQuizzes,
               },
               roster,
+              module: module(moduleName, "assignment", canvasAssignment),
             }),
           };
         }),
@@ -111,12 +126,13 @@ export function useTodaysItems(day: string) {
             type: "quiz" as const,
             item: quiz,
             moduleName,
-            ...getStatus({
+            ...getSyncStatus({
               item: quiz,
               canvasItem: canvasQuiz,
               type: "quiz",
               settings,
               canvasQuestions: quizQuestions[quiz.name],
+              module: module(moduleName, "quiz", canvasQuiz),
             }),
           };
         }),
@@ -131,11 +147,12 @@ export function useTodaysItems(day: string) {
             type: "page" as const,
             item: page,
             moduleName,
-            ...getStatus({
+            ...getSyncStatus({
               item: page,
               canvasItem: canvasPage,
               type: "page",
               settings,
+              module: module(moduleName, "page", canvasPage),
             }),
           };
         }),
diff --git a/src/app/course/[courseName]/modules/[moduleName]/assignment/[assignmentName]/AssignmentFooterButtons.tsx b/src/app/course/[courseName]/modules/[moduleName]/assignment/[assignmentName]/AssignmentFooterButtons.tsx
index c62b7951..7d9aa18e 100644
--- a/src/app/course/[courseName]/modules/[moduleName]/assignment/[assignmentName]/AssignmentFooterButtons.tsx
+++ b/src/app/course/[courseName]/modules/[moduleName]/assignment/[assignmentName]/AssignmentFooterButtons.tsx
@@ -2,6 +2,7 @@ import {
   EditorFooter,
   FooterAction,
 } from "@/app/course/[courseName]/EditorFooter";
+import { useCanvasModuleNames } from "@/features/canvas/hooks/canvasModuleHooks";
 import { getSyncReport } from "@/app/course/[courseName]/calendar/day/getAssignmentSyncStatus";
 import { ClassroomIcon, TrashIcon } from "@/components/icons/ActionIcons";
 import { useCourseContext } from "@/app/course/[courseName]/context/courseContext";
@@ -71,6 +72,10 @@ export function AssignmentFooterButtons({
   const assignmentInCanvas = canvasAssignments?.find(
     (a) => a.name === assignmentName,
   );
+  const { names: canvasModules } = useCanvasModuleNames(
+    "assignment",
+    assignmentInCanvas,
+  );
 
   const anythingIsLoading =
     addToCanvas.isPending ||
@@ -92,13 +97,16 @@ export function AssignmentFooterButtons({
               quizzes: canvasQuizzes,
             },
             roster: { students: rosterStudents, groupSets: rosterGroupSets },
+            module: canvasModules && { file: moduleName, canvas: canvasModules },
           }).differences
         : [],
     [
       assignment,
       assignmentInCanvas,
       canvasAssignments,
+      canvasModules,
       canvasQuizzes,
+      moduleName,
       rosterGroupSets,
       rosterStudents,
       settings,
diff --git a/src/app/course/[courseName]/modules/[moduleName]/compare/CompareWithCanvas.tsx b/src/app/course/[courseName]/modules/[moduleName]/compare/CompareWithCanvas.tsx
index 1367ad61..7bc5263b 100644
--- a/src/app/course/[courseName]/modules/[moduleName]/compare/CompareWithCanvas.tsx
+++ b/src/app/course/[courseName]/modules/[moduleName]/compare/CompareWithCanvas.tsx
@@ -25,6 +25,7 @@ import {
   useCanvasQuizzesQuery,
   useUpdateQuizInCanvasMutation,
 } from "@/features/canvas/hooks/canvasQuizHooks";
+import { useCanvasModuleNames } from "@/features/canvas/hooks/canvasModuleHooks";
 import { checkQuizQuestions } from "@/app/course/[courseName]/calendar/day/quizQuestionSync";
 import { LocalQuiz } from "@/features/local/quizzes/models/localQuiz";
 import { LocalCourseSettings } from "@/features/local/course/localCourseSettings";
@@ -47,6 +48,7 @@ import {
 } from "@/services/utils/htmlTextDiff";
 
 const sectionLabels: Record<SyncSection, string> = {
+  module: "Module",
   dates: "Dates",
   grading: "Grading",
   groups: "Groups",
@@ -81,14 +83,18 @@ export function CompareAssignmentWithCanvas({
   const { data: rosterGroupSets } = useRosterGroupSetsQuery();
   const update = useUpdateAssignmentInCanvasMutation();
 
+  const canvasAssignment = canvasAssignments?.find(
+    (a) => a.name === assignmentName,
+  );
+  const { names: canvasModules, refetch: refetchModules } =
+    useCanvasModuleNames("assignment", canvasAssignment);
+
   // never compare against a stale copy
   useEffect(() => {
     refetch();
-  }, [refetch]);
+    refetchModules();
+  }, [refetch, refetchModules]);
 
-  const canvasAssignment = canvasAssignments?.find(
-    (a) => a.name === assignmentName,
-  );
   const report = useMemo(
     () =>
       getSyncReport({
@@ -101,12 +107,15 @@ export function CompareAssignmentWithCanvas({
           quizzes: canvasQuizzes,
         },
         roster: { students: rosterStudents, groupSets: rosterGroupSets },
+        module: canvasModules && { file: moduleName, canvas: canvasModules },
       }),
     [
       assignment,
       canvasAssignment,
       canvasAssignments,
+      canvasModules,
       canvasQuizzes,
+      moduleName,
       rosterGroupSets,
       rosterStudents,
       settings,
@@ -128,7 +137,10 @@ export function CompareAssignmentWithCanvas({
         canvasAssignment &&
         `${baseCanvasUrl}/courses/${settings.canvasId}/assignments/${canvasAssignment.id}`
       }
-      onRefresh={() => refetch()}
+      onRefresh={() => {
+        refetch();
+        refetchModules();
+      }}
       onUpdate={() =>
         canvasAssignment &&
         update.mutate({
@@ -138,7 +150,7 @@ export function CompareAssignmentWithCanvas({
         })
       }
       updating={update.isPending}
-      updateNote="Update Canvas pushes the file's dates, group settings, rubric and description. Submissions and grades are untouched."
+      updateNote="Update Canvas pushes the file's dates, group settings, rubric and description, and moves the assignment to the file's module. Submissions and grades are untouched."
     />
   );
 }
@@ -161,11 +173,15 @@ export function CompareQuizWithCanvas({
   const { data: canvasAssignments } = useCanvasAssignmentsQuery();
   const update = useUpdateQuizInCanvasMutation();
 
+  const canvasQuiz = canvasQuizzes?.find((q) => q.title === quizName);
+  const { names: canvasModules, refetch: refetchModules } =
+    useCanvasModuleNames("quiz", canvasQuiz);
+
   useEffect(() => {
     refetch();
-  }, [refetch]);
+    refetchModules();
+  }, [refetch, refetchModules]);
 
-  const canvasQuiz = canvasQuizzes?.find((q) => q.title === quizName);
   const {
     data: canvasQuestions,
     isFetching: questionsFetching,
@@ -186,12 +202,15 @@ export function CompareQuizWithCanvas({
           quizzes: canvasQuizzes,
         },
         canvasQuestions,
+        module: canvasModules && { file: moduleName, canvas: canvasModules },
       }),
     [
       canvasAssignments,
+      canvasModules,
       canvasQuestions,
       canvasQuiz,
       canvasQuizzes,
+      moduleName,
       quiz,
       settings,
     ],
@@ -217,6 +236,7 @@ export function CompareQuizWithCanvas({
       }
       onRefresh={() => {
         refetch();
+        refetchModules();
         if (canvasQuiz) {
           refetchQuestions();
           refetchVersions();
@@ -227,7 +247,7 @@ export function CompareQuizWithCanvas({
         update.mutate({ quiz, canvasQuizId: canvasQuiz.id, moduleName })
       }
       updating={update.isPending}
-      updateNote="Update Canvas pushes the file's settings and, if any question differs, replaces the questions in Canvas with the file's. When it replaces them on a published quiz, students keep getting the old questions until you click Save it now on the quiz page in Canvas (the API can't do that). If students have started, it warns first: they keep the questions they got and are not regraded. It refuses to change the point total they were scored out of."
+      updateNote="Update Canvas pushes the file's settings, moves the quiz to the file's module and, if any question differs, replaces the questions in Canvas with the file's. When it replaces them on a published quiz, students keep getting the old questions until you click Save it now on the quiz page in Canvas (the API can't do that). If students have started, it warns first: they keep the questions they got and are not regraded. It refuses to change the point total they were scored out of."
     >
       {versions?.map((v, i) => (
         <VersionSection
@@ -261,11 +281,15 @@ export function ComparePageWithCanvas({
   const { data: canvasQuizzes } = useCanvasQuizzesQuery();
   const update = useUpdateCanvasPageMutation();
 
+  const canvasPage = canvasPages?.find((p) => p.title === pageName);
+  const { names: canvasModules, refetch: refetchModules } =
+    useCanvasModuleNames("page", canvasPage);
+
   useEffect(() => {
     refetch();
-  }, [refetch]);
+    refetchModules();
+  }, [refetch, refetchModules]);
 
-  const canvasPage = canvasPages?.find((p) => p.title === pageName);
   const report = useMemo(
     () =>
       getSyncReport({
@@ -277,8 +301,17 @@ export function ComparePageWithCanvas({
           assignments: canvasAssignments,
           quizzes: canvasQuizzes,
         },
+        module: canvasModules && { file: moduleName, canvas: canvasModules },
       }),
-    [canvasAssignments, canvasPage, canvasQuizzes, page, settings],
+    [
+      canvasAssignments,
+      canvasModules,
+      canvasPage,
+      canvasQuizzes,
+      moduleName,
+      page,
+      settings,
+    ],
   );
 
   return (
@@ -295,13 +328,16 @@ export function ComparePageWithCanvas({
         canvasPage &&
         `${baseCanvasUrl}/courses/${settings.canvasId}/pages/${canvasPage.url}`
       }
-      onRefresh={() => refetch()}
+      onRefresh={() => {
+        refetch();
+        refetchModules();
+      }}
       onUpdate={() =>
         canvasPage &&
         update.mutate({ page, canvasPage, moduleName })
       }
       updating={update.isPending}
-      updateNote="Update in Canvas replaces the page's content with the file's."
+      updateNote="Update in Canvas replaces the page's content with the file's and moves the page to the file's module."
     />
   );
 }
diff --git a/src/app/course/[courseName]/modules/[moduleName]/page/[pageName]/EditPageButtons.tsx b/src/app/course/[courseName]/modules/[moduleName]/page/[pageName]/EditPageButtons.tsx
index 95341c9f..3d1b9c1b 100644
--- a/src/app/course/[courseName]/modules/[moduleName]/page/[pageName]/EditPageButtons.tsx
+++ b/src/app/course/[courseName]/modules/[moduleName]/page/[pageName]/EditPageButtons.tsx
@@ -20,6 +20,7 @@ import {
 } from "@/features/local/pages/pageHooks";
 import { useCanvasAssignmentsQuery } from "@/features/canvas/hooks/canvasAssignmentHooks";
 import { useCanvasQuizzesQuery } from "@/features/canvas/hooks/canvasQuizHooks";
+import { useCanvasModuleNames } from "@/features/canvas/hooks/canvasModuleHooks";
 import { getSyncReport } from "@/app/course/[courseName]/calendar/day/getAssignmentSyncStatus";
 import { getCompareUrl, getCourseUrl } from "@/services/urlUtils";
 import { useNavigate } from "@tanstack/react-router";
@@ -51,6 +52,7 @@ export default function EditPageButtons({
   );
 
   const pageInCanvas = canvasPages?.find((p) => p.title === pageName);
+  const { names: canvasModules } = useCanvasModuleNames("page", pageInCanvas);
   const { data: canvasAssignments } = useCanvasAssignmentsQuery();
   const { data: canvasQuizzes } = useCanvasQuizzesQuery();
   const differences = useMemo(
@@ -65,9 +67,18 @@ export default function EditPageButtons({
               assignments: canvasAssignments,
               quizzes: canvasQuizzes,
             },
+            module: canvasModules && { file: moduleName, canvas: canvasModules },
           }).differences.filter((d) => d.key !== "published")
         : [],
-    [canvasAssignments, canvasQuizzes, page, pageInCanvas, settings],
+    [
+      canvasAssignments,
+      canvasModules,
+      canvasQuizzes,
+      moduleName,
+      page,
+      pageInCanvas,
+      settings,
+    ],
   );
 
   const requestIsPending =
diff --git a/src/app/course/[courseName]/modules/[moduleName]/quiz/[quizName]/QuizButton.tsx b/src/app/course/[courseName]/modules/[moduleName]/quiz/[quizName]/QuizButton.tsx
index f200eb55..2157d1e4 100644
--- a/src/app/course/[courseName]/modules/[moduleName]/quiz/[quizName]/QuizButton.tsx
+++ b/src/app/course/[courseName]/modules/[moduleName]/quiz/[quizName]/QuizButton.tsx
@@ -2,6 +2,7 @@ import {
   EditorFooter,
   FooterAction,
 } from "@/app/course/[courseName]/EditorFooter";
+import { useCanvasModuleNames } from "@/features/canvas/hooks/canvasModuleHooks";
 import { getSyncReport } from "@/app/course/[courseName]/calendar/day/getAssignmentSyncStatus";
 import { TrashIcon } from "@/components/icons/ActionIcons";
 import { useCanvasAssignmentsQuery } from "@/features/canvas/hooks/canvasAssignmentHooks";
@@ -53,6 +54,7 @@ export function QuizButtons({
   );
 
   const quizInCanvas = canvasQuizzes?.find((c) => c.title === quizName);
+  const { names: canvasModules } = useCanvasModuleNames("quiz", quizInCanvas);
   const { data: canvasQuestions } = useCanvasQuizQuestionsQuery(
     quizInCanvas?.id,
   );
@@ -70,12 +72,15 @@ export function QuizButtons({
               quizzes: canvasQuizzes,
             },
             canvasQuestions,
+            module: canvasModules && { file: moduleName, canvas: canvasModules },
           }).differences
         : [],
     [
       canvasAssignments,
+      canvasModules,
       canvasQuestions,
       canvasQuizzes,
+      moduleName,
       quiz,
       quizInCanvas,
       settings,
diff --git a/src/features/canvas/hooks/canvasAssignmentHooks.ts b/src/features/canvas/hooks/canvasAssignmentHooks.ts
index fcdc356d..e9dc2474 100644
--- a/src/features/canvas/hooks/canvasAssignmentHooks.ts
+++ b/src/features/canvas/hooks/canvasAssignmentHooks.ts
@@ -1,11 +1,10 @@
 import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
 import { LocalAssignment } from "@/features/local/assignments/models/localAssignment";
 import {
-  useCanvasModuleIdByName,
+  useAddToCanvasModule,
   usePlaceInCanvasModule,
 } from "./canvasModuleHooks";
 import { useLocalCourseSettingsQuery } from "@/features/local/course/localCoursesHooks";
-import { canvasModuleService } from "../services/canvasModuleService";
 import { canvasAssignmentService } from "../services/canvasAssignmentService";
 import { showErrorToast } from "@/app/MyToaster";
 import { useCanvasLinkTargets } from "./useCanvasLinkTargets";
@@ -29,7 +28,7 @@ export const useCanvasAssignmentsQuery = () => {
 
 export const useAddAssignmentToCanvasMutation = () => {
   const { data: settings } = useLocalCourseSettingsQuery();
-  const moduleIdByName = useCanvasModuleIdByName();
+  const addToModule = useAddToCanvasModule();
   const queryClient = useQueryClient();
   const canvasLinkTargets = useCanvasLinkTargets();
   const getPublishOptions = useAssignmentPublishOptions();
@@ -58,11 +57,11 @@ export const useAddAssignmentToCanvasMutation = () => {
         canvasLinkTargets,
         getPublishOptions(assignment),
       );
-      await canvasModuleService.addModuleItem(
-        settings.canvasId,
-        await moduleIdByName(moduleName),
-        { type: "Assignment", id: canvasAssignmentId, title: assignment.name },
-      );
+      await addToModule(moduleName, {
+        type: "Assignment",
+        id: canvasAssignmentId,
+        title: assignment.name,
+      });
     },
     onSuccess: (_data, variables) => {
       commitAfterPublish(`assignment "${variables.assignment.name}"`);
diff --git a/src/features/canvas/hooks/canvasModuleHooks.ts b/src/features/canvas/hooks/canvasModuleHooks.ts
index 78aa1d14..cbe3c3a2 100644
--- a/src/features/canvas/hooks/canvasModuleHooks.ts
+++ b/src/features/canvas/hooks/canvasModuleHooks.ts
@@ -2,10 +2,12 @@ import { useLocalCourseSettingsQuery } from "@/features/local/course/localCourse
 import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
 import {
   canvasModuleService,
+  canvasModuleNames,
   ModuleItemContent,
 } from "../services/canvasModuleService";
 import { IModuleItem } from "@/features/local/modules/IModuleItem";
 import toast from "react-hot-toast";
+import { useMemo } from "react";
 
 export const canvasCourseModuleKeys = {
   modules: (canvasId: number) => ["canvas", canvasId, "module list"] as const,
@@ -20,6 +22,33 @@ export const useCanvasModulesQuery = () => {
   });
 };
 
+/** Every Canvas module with its items, for finding which modules hold an item. */
+export const useCanvasModulesWithItemsQuery = () => {
+  const { data: settings } = useLocalCourseSettingsQuery();
+  return useQuery({
+    // under the module list's key, so whatever refreshes the list refreshes this
+    queryKey: [...canvasCourseModuleKeys.modules(settings.canvasId), "items"],
+    queryFn: () =>
+      canvasModuleService.getCourseModulesWithItems(settings.canvasId),
+  });
+};
+
+/**
+ * For comparing an item's module: the names of the Canvas modules holding it,
+ * undefined while they load or when the item isn't in Canvas.
+ */
+export const useCanvasModuleNames = (
+  type: Parameters<typeof canvasModuleNames>[1],
+  canvasItem: Parameters<typeof canvasModuleNames>[2] | undefined
+) => {
+  const { data: modules, refetch } = useCanvasModulesWithItemsQuery();
+  const names = useMemo(
+    () => modules && canvasItem && canvasModuleNames(modules, type, canvasItem),
+    [modules, type, canvasItem]
+  );
+  return { names, refetch };
+};
+
 export const useAddCanvasModuleMutation = () => {
   const { data: settings } = useLocalCourseSettingsQuery();
   const queryClient = useQueryClient();
@@ -55,6 +84,23 @@ export const useCanvasModuleIdByName = () => {
   };
 };
 
+/** For Add to Canvas: adds a new item to the module named after its folder. */
+export const useAddToCanvasModule = () => {
+  const { data: settings } = useLocalCourseSettingsQuery();
+  const queryClient = useQueryClient();
+  const moduleIdByName = useCanvasModuleIdByName();
+  return async (moduleName: string, item: ModuleItemContent) => {
+    await canvasModuleService.addModuleItem(
+      settings.canvasId,
+      await moduleIdByName(moduleName),
+      item
+    );
+    queryClient.invalidateQueries({
+      queryKey: canvasCourseModuleKeys.modules(settings.canvasId),
+    });
+  };
+};
+
 /**
  * For Update in Canvas: puts an item in the Canvas module named after its
  * folder, so moving a file to another module moves it in Canvas too.
diff --git a/src/features/canvas/hooks/canvasPageHooks.ts b/src/features/canvas/hooks/canvasPageHooks.ts
index 674ae917..f51a14e0 100644
--- a/src/features/canvas/hooks/canvasPageHooks.ts
+++ b/src/features/canvas/hooks/canvasPageHooks.ts
@@ -1,11 +1,10 @@
 import { LocalCoursePage } from "@/features/local/pages/localCoursePageModels";
 import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
 import {
-  useCanvasModuleIdByName,
+  useAddToCanvasModule,
   usePlaceInCanvasModule,
 } from "./canvasModuleHooks";
 import { useLocalCourseSettingsQuery } from "@/features/local/course/localCoursesHooks";
-import { canvasModuleService } from "../services/canvasModuleService";
 import { canvasPageService } from "../services/canvasPageService";
 import { useCanvasLinkTargets } from "./useCanvasLinkTargets";
 import { useCommitAfterPublish } from "@/features/local/git/gitHooks";
@@ -30,7 +29,7 @@ export const useCanvasPagesQuery = () => {
 export const useCreateCanvasPageMutation = () => {
   const { data: settings } = useLocalCourseSettingsQuery();
   const queryClient = useQueryClient();
-  const moduleIdByName = useCanvasModuleIdByName();
+  const addToModule = useAddToCanvasModule();
   const canvasLinkTargets = useCanvasLinkTargets();
   const prepareImages = usePrepareImagesForCanvas();
 
@@ -51,16 +50,12 @@ export const useCreateCanvasPageMutation = () => {
         publishSettings,
         canvasLinkTargets
       );
-      await canvasModuleService.addModuleItem(
-        settings.canvasId,
-        await moduleIdByName(moduleName),
-        {
-          type: "Page",
-          id: canvasPage.page_id,
-          title: page.name,
-          pageUrl: canvasPage.url,
-        }
-      );
+      await addToModule(moduleName, {
+        type: "Page",
+        id: canvasPage.page_id,
+        title: page.name,
+        pageUrl: canvasPage.url,
+      });
       return canvasPage;
     },
     onSuccess: (_data, variables) => {
diff --git a/src/features/canvas/hooks/canvasQuizHooks.ts b/src/features/canvas/hooks/canvasQuizHooks.ts
index 79bf8721..5371d505 100644
--- a/src/features/canvas/hooks/canvasQuizHooks.ts
+++ b/src/features/canvas/hooks/canvasQuizHooks.ts
@@ -1,11 +1,10 @@
 import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
 import {
-  useCanvasModuleIdByName,
+  useAddToCanvasModule,
   usePlaceInCanvasModule,
 } from "./canvasModuleHooks";
 import { LocalQuiz } from "@/features/local/quizzes/models/localQuiz";
 import { useLocalCourseSettingsQuery } from "@/features/local/course/localCoursesHooks";
-import { canvasModuleService } from "../services/canvasModuleService";
 import { canvasQuizService } from "../services/canvasQuizService";
 import { useCanvasLinkTargets } from "./useCanvasLinkTargets";
 import { useCommitAfterPublish } from "@/features/local/git/gitHooks";
@@ -78,7 +77,7 @@ export const useCanvasAttemptQuestionsQuery = (attemptId: number | undefined) =>
 export const useAddQuizToCanvasMutation = () => {
   const { data: settings } = useLocalCourseSettingsQuery();
   const queryClient = useQueryClient();
-  const moduleIdByName = useCanvasModuleIdByName();
+  const addToModule = useAddToCanvasModule();
   const canvasLinkTargets = useCanvasLinkTargets();
   const prepareImages = usePrepareImagesForCanvas();
 
@@ -103,11 +102,11 @@ export const useAddQuizToCanvasMutation = () => {
         assignmentGroup?.canvasId,
         canvasLinkTargets
       );
-      await canvasModuleService.addModuleItem(
-        settings.canvasId,
-        await moduleIdByName(moduleName),
-        { type: "Quiz", id: canvasQuizId, title: quiz.name }
-      );
+      await addToModule(moduleName, {
+        type: "Quiz",
+        id: canvasQuizId,
+        title: quiz.name,
+      });
     },
     onSuccess: (_data, variables) => {
       commitAfterPublish(`quiz "${variables.quiz.name}"`);
diff --git a/src/features/canvas/services/canvasModuleService.test.ts b/src/features/canvas/services/canvasModuleService.test.ts
index b61a4eb9..7158e734 100644
--- a/src/features/canvas/services/canvasModuleService.test.ts
+++ b/src/features/canvas/services/canvasModuleService.test.ts
@@ -1,5 +1,6 @@
 import { describe, it, expect, vi, beforeEach } from "vitest";
-import { canvasModuleService } from "./canvasModuleService";
+import { canvasModuleNames, canvasModuleService } from "./canvasModuleService";
+import { CanvasModule } from "../models/modules/canvasModule";
 import { axiosClient } from "@/services/axiosUtils";
 import { rateLimitAwarePost } from "./canvasWebRequestUtils";
 
@@ -75,3 +76,28 @@ describe("placeInModule", () => {
     });
   });
 });
+
+describe("canvasModuleNames", () => {
+  const module = (name: string, items: object[]) =>
+    ({ name, items }) as unknown as CanvasModule;
+  const modules = [
+    module("Week 1", [
+      { type: "Assignment", content_id: 7 },
+      { type: "Page", page_url: "schedule" },
+    ]),
+    module("Week 2", [{ type: "Quiz", content_id: 7 }]),
+  ];
+
+  it("finds an assignment or quiz by type and id", () => {
+    expect(canvasModuleNames(modules, "assignment", { id: 7 })).toEqual(["Week 1"]);
+    expect(canvasModuleNames(modules, "quiz", { id: 7 })).toEqual(["Week 2"]);
+  });
+
+  it("finds a page by its url", () => {
+    expect(canvasModuleNames(modules, "page", { url: "schedule" })).toEqual(["Week 1"]);
+  });
+
+  it("is empty for an item in no module", () => {
+    expect(canvasModuleNames(modules, "quiz", { id: 8 })).toEqual([]);
+  });
+});
diff --git a/src/features/canvas/services/canvasModuleService.ts b/src/features/canvas/services/canvasModuleService.ts
index 689ac35a..c6285921 100644
--- a/src/features/canvas/services/canvasModuleService.ts
+++ b/src/features/canvas/services/canvasModuleService.ts
@@ -12,6 +12,20 @@ export interface ModuleItemContent {
   pageUrl?: string;
 }
 
+/** The names of the Canvas modules that hold an item; a page is matched by its url. */
+export function canvasModuleNames(
+  modules: CanvasModule[],
+  type: "assignment" | "quiz" | "page",
+  canvasItem: { id?: number; url?: string },
+): string[] {
+  const holds = (i: CanvasModuleItem) =>
+    type === "page"
+      ? i.type === "Page" && i.page_url === canvasItem.url
+      : i.type === (type === "quiz" ? "Quiz" : "Assignment") &&
+        i.content_id === canvasItem.id;
+  return modules.filter((m) => m.items?.some(holds)).map((m) => m.name);
+}
+
 export const canvasModuleService = {
   async updateModuleItem(
     canvasCourseId: number,
@@ -87,6 +101,25 @@ export const canvasModuleService = {
     return response;
   },
 
+  /** Every module with its items; Canvas leaves the items out of a large module, so those are fetched on their own. */
+  async getCourseModulesWithItems(canvasCourseId: number) {
+    const modules = await paginatedRequest<CanvasModule[]>({
+      url: `${canvasApi}/courses/${canvasCourseId}/modules?include[]=items`,
+    });
+    return Promise.all(
+      modules.map(async (m) =>
+        m.items
+          ? m
+          : {
+              ...m,
+              items: await paginatedRequest<CanvasModuleItem[]>({
+                url: `${canvasApi}/courses/${canvasCourseId}/modules/${m.id}/items`,
+              }),
+            }
+      )
+    );
+  },
+
   async createModule(canvasCourseId: number, moduleName: string) {
     const url = `${canvasApi}/courses/${canvasCourseId}/modules`;
     const body = {

From d440e660b3d500838c385857945271cc293e897c Mon Sep 17 00:00:00 2001
From: Adam Teichert <adam.teichert@snow.edu>
Date: Mon, 12 Oct 2026 16:49:31 -0600
Subject: [PATCH 4/5] Mention the module in the calendar note and the quiz
 Update tooltip

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 docs/getting-started.html                                       | 2 +-
 .../modules/[moduleName]/quiz/[quizName]/QuizButton.tsx         | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/docs/getting-started.html b/docs/getting-started.html
index 493e1954..c5de83ee 100644
--- a/docs/getting-started.html
+++ b/docs/getting-started.html
@@ -309,7 +309,7 @@ <h3 id="compare">Compare with Canvas</h3>
 <p>When an item&rsquo;s border is red, <b>Compare with Canvas</b> (the amber <em>differences from Canvas</em> text in the editor footer, the menu on the footer&rsquo;s main button, the right-click menu, and the red pill&rsquo;s hover card) opens a page that lists every difference between your file and Canvas:</p>
 <ul>
 <li>A settings table with the file&rsquo;s value and Canvas&rsquo;s side by side: the module, dates, assignment group, group set, points and each rubric row, and for a quiz its password, attempts and other options.</li>
-<li>For a <b>quiz</b>, a row for every question, compared on type, points, text, answers (correct ones marked &#10003;) and feedback. Questions are lined up by what they say, not by number, so deleting or adding one doesn&rsquo;t make every later question look changed: a question you deleted from the file shows as one <em>Canvas question N</em> row, one you added as a row with nothing on the Canvas side, and one you moved as a <em>position</em> difference. Every question shows in full on both sides, answers included, and &#8800; marks the lines of each part that differs. The quiz editor&rsquo;s footer counts these differences too. The calendar checks questions for this week&rsquo;s quizzes and the next three weeks&rsquo;, fetching them in the background one quiz at a time (this week first) so Canvas doesn&rsquo;t throttle you; a quiz outside those four weeks gets its red border from settings and description only.</li>
+<li>For a <b>quiz</b>, a row for every question, compared on type, points, text, answers (correct ones marked &#10003;) and feedback. Questions are lined up by what they say, not by number, so deleting or adding one doesn&rsquo;t make every later question look changed: a question you deleted from the file shows as one <em>Canvas question N</em> row, one you added as a row with nothing on the Canvas side, and one you moved as a <em>position</em> difference. Every question shows in full on both sides, answers included, and &#8800; marks the lines of each part that differs. The quiz editor&rsquo;s footer counts these differences too. The calendar checks questions for this week&rsquo;s quizzes and the next three weeks&rsquo;, fetching them in the background one quiz at a time (this week first) so Canvas doesn&rsquo;t throttle you; a quiz outside those four weeks gets its red border from its module, settings and description only.</li>
 <li>For a quiz students have started, a <b>What students got</b> section for each quiz version they took, comparing the file with the questions from one of its attempts (ignoring each attempt&rsquo;s own answer shuffle). Canvas&rsquo;s current questions can differ from these until <em>Save it now</em>, and this is the only way to see what students actually got.</li>
 <li>The description (a page&rsquo;s content) <em>side by side</em>, as <em>changes only</em> (a word-level diff), or as the normalized <em>HTML</em> when you need to see why two descriptions that look the same count as different.</li>
 <li>An <b>Update Canvas</b> button at the bottom that pushes the file, with a note saying exactly what it will change. The top of the page says when it last read Canvas, and <em>refresh</em> reads it again.</li>
diff --git a/src/app/course/[courseName]/modules/[moduleName]/quiz/[quizName]/QuizButton.tsx b/src/app/course/[courseName]/modules/[moduleName]/quiz/[quizName]/QuizButton.tsx
index 2157d1e4..3ebae311 100644
--- a/src/app/course/[courseName]/modules/[moduleName]/quiz/[quizName]/QuizButton.tsx
+++ b/src/app/course/[courseName]/modules/[moduleName]/quiz/[quizName]/QuizButton.tsx
@@ -139,7 +139,7 @@ export function QuizButtons({
           moduleName,
         })
       }
-      updateTitle="Pushes settings and, if any question differs, replaces the questions in Canvas with the file's. If it replaced them on a published quiz, click Save it now in Canvas afterwards so students get them. Warns first if students have started."
+      updateTitle="Pushes settings, moves the quiz to this file's module and, if any question differs, replaces the questions in Canvas with the file's. If it replaced them on a published quiz, click Save it now in Canvas afterwards so students get them. Warns first if students have started."
       extraActions={extraActions}
       toggleHelp={toggleHelp}
       previousUrl={previousUrl}

From 181e975eb00cf7f97f9c84b5af9e0cf9f58fca28 Mon Sep 17 00:00:00 2001
From: Adam Teichert <adam.teichert@snow.edu>
Date: Mon, 12 Oct 2026 17:08:12 -0600
Subject: [PATCH 5/5] An item belongs in one Canvas module: its file's

Modules are compared as a set: an item also in another Canvas module is
a difference, and Update in Canvas removes it from the others.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 docs/getting-started.html                     |  6 +-
 .../calendar/day/getAssignmentSyncStatus.ts   | 22 ++++---
 .../calendar/day/getSyncStatus.test.ts        | 18 ++++--
 .../compare/CompareWithCanvas.tsx             |  2 +-
 .../canvas/hooks/canvasModuleHooks.ts         | 20 ++++---
 .../services/canvasModuleService.test.ts      | 57 ++++++++++++++++---
 .../canvas/services/canvasModuleService.ts    | 35 +++++++-----
 7 files changed, 112 insertions(+), 48 deletions(-)

diff --git a/docs/getting-started.html b/docs/getting-started.html
index c5de83ee..d791310e 100644
--- a/docs/getting-started.html
+++ b/docs/getting-started.html
@@ -291,7 +291,7 @@ <h2 id="publishing">Publishing to Canvas</h2>
 <p>Each editor&rsquo;s footer says where the item stands and shows the one button you need next:</p>
 <ul>
 <li><b>Not in Canvas yet</b>: <b>Add to Canvas</b> creates the item in Canvas, unpublished, with its rendered description, dates, rubric and module entry. A module that does not exist yet is created.</li>
-<li><b>3 differences from Canvas</b> (in amber): <b>Update in Canvas</b> pushes the current file over the existing Canvas item, and moves it into the module its file is in if you moved the file. Submissions and grades are untouched. Click the amber text to open <a href="#compare">Compare with Canvas</a>.</li>
+<li><b>3 differences from Canvas</b> (in amber): <b>Update in Canvas</b> pushes the current file over the existing Canvas item, and moves it into the module its file is in if you moved the file, taking it out of any other module. Submissions and grades are untouched. Click the amber text to open <a href="#compare">Compare with Canvas</a>.</li>
 <li><b>In sync &middot; students can&rsquo;t see it yet</b>: <b>Publish in Canvas</b> makes it visible to students. If the item&rsquo;s module is still unpublished in Canvas, the app says so and links to the modules page; it does not publish the module for you.</li>
 <li><b>In sync &middot; Published</b>: nothing to do; <b>View in Canvas</b> opens it.</li>
 <li>For a <b>quiz</b>, Update in Canvas also replaces the questions with the file&rsquo;s when any of them differ. If students have already started, it asks first: their attempts keep the questions they got and are not regraded. It refuses a change to the quiz&rsquo;s point total, since their scores are out of the total they were given.</li>
@@ -308,7 +308,7 @@ <h2 id="publishing">Publishing to Canvas</h2>
 <h3 id="compare">Compare with Canvas</h3>
 <p>When an item&rsquo;s border is red, <b>Compare with Canvas</b> (the amber <em>differences from Canvas</em> text in the editor footer, the menu on the footer&rsquo;s main button, the right-click menu, and the red pill&rsquo;s hover card) opens a page that lists every difference between your file and Canvas:</p>
 <ul>
-<li>A settings table with the file&rsquo;s value and Canvas&rsquo;s side by side: the module, dates, assignment group, group set, points and each rubric row, and for a quiz its password, attempts and other options.</li>
+<li>A settings table with the file&rsquo;s value and Canvas&rsquo;s side by side: the modules (Canvas should have the item only in the module its file is in), dates, assignment group, group set, points and each rubric row, and for a quiz its password, attempts and other options.</li>
 <li>For a <b>quiz</b>, a row for every question, compared on type, points, text, answers (correct ones marked &#10003;) and feedback. Questions are lined up by what they say, not by number, so deleting or adding one doesn&rsquo;t make every later question look changed: a question you deleted from the file shows as one <em>Canvas question N</em> row, one you added as a row with nothing on the Canvas side, and one you moved as a <em>position</em> difference. Every question shows in full on both sides, answers included, and &#8800; marks the lines of each part that differs. The quiz editor&rsquo;s footer counts these differences too. The calendar checks questions for this week&rsquo;s quizzes and the next three weeks&rsquo;, fetching them in the background one quiz at a time (this week first) so Canvas doesn&rsquo;t throttle you; a quiz outside those four weeks gets its red border from its module, settings and description only.</li>
 <li>For a quiz students have started, a <b>What students got</b> section for each quiz version they took, comparing the file with the questions from one of its attempts (ignoring each attempt&rsquo;s own answer shuffle). Canvas&rsquo;s current questions can differ from these until <em>Save it now</em>, and this is the only way to see what students actually got.</li>
 <li>The description (a page&rsquo;s content) <em>side by side</em>, as <em>changes only</em> (a word-level diff), or as the normalized <em>HTML</em> when you need to see why two descriptions that look the same count as different.</li>
@@ -364,7 +364,7 @@ <h2 id="tips">Tips</h2>
 <h2 id="changes">Recent changes</h2>
 <div class="tw"><table>
 <tr><th>When</th><th>What changed</th></tr>
-<tr><td style="white-space:nowrap">Oct 2026</td><td><a href="#publishing">Update in Canvas</a> moves an item to the module its file is now in, or adds it to that module if it was in none. <a href="#compare">Compare with Canvas</a>, the editor footer and the calendar count a moved file as a difference.</td></tr>
+<tr><td style="white-space:nowrap">Oct 2026</td><td><a href="#publishing">Update in Canvas</a> moves an item to the module its file is now in, or adds it to that module if it was in none, and takes it out of any other module. <a href="#compare">Compare with Canvas</a>, the editor footer and the calendar count a moved file, or an item in more than one Canvas module, as a difference.</td></tr>
 <tr><td style="white-space:nowrap">Oct 2026</td><td>Opening a course whose term has ended no longer shows a <em>roster.groupSets &hellip; 403</em> error: Canvas won&rsquo;t list group sets for a finished course, so it shows none.</td></tr>
 <tr><td style="white-space:nowrap">Oct 2026</td><td><a href="#compare">Compare with Canvas</a> checks a quiz&rsquo;s password, allowed attempts, shuffle answers, show correct answers and one question at a time, so changing only one of them no longer shows the quiz as in sync.</td></tr>
 <tr><td style="white-space:nowrap">Oct 2026</td><td><a href="#compare">Compare with Canvas</a> compares short-answer answers as plain text, so an answer like <code>+</code> or <code>a*b*c</code> no longer shows as different when it matches.</td></tr>
diff --git a/src/app/course/[courseName]/calendar/day/getAssignmentSyncStatus.ts b/src/app/course/[courseName]/calendar/day/getAssignmentSyncStatus.ts
index 41683e8c..41a3fc87 100644
--- a/src/app/course/[courseName]/calendar/day/getAssignmentSyncStatus.ts
+++ b/src/app/course/[courseName]/calendar/day/getAssignmentSyncStatus.ts
@@ -35,7 +35,7 @@ export interface RosterForStatus {
 }
 
 export type SyncSection =
-  | "module"
+  | "modules"
   | "dates"
   | "grading"
   | "groups"
@@ -678,18 +678,22 @@ function buildReport(
   };
 }
 
-/** The file's module folder against the Canvas modules the item is in. */
-function checkModule(file: string, canvas: string[]): SyncField {
+/**
+ * The file's module folder against the Canvas modules holding the item: a
+ * file is in one folder, so Canvas should have the item in that module only.
+ */
+function checkModules(file: string, canvasModules: string[]): SyncField {
+  const canvas = [...new Set(canvasModules)].sort();
   return field({
-    key: "module",
-    label: "Module",
-    section: "module",
+    key: "modules",
+    label: "Modules",
+    section: "modules",
     local: file,
     canvas: canvas.join(", ") || UNSET,
-    same: canvas.includes(file),
+    same: canvas.length === 1 && canvas[0] === file,
     message:
       canvas.length > 0
-        ? `module different: ${file} vs ${canvas.join(", ")}`
+        ? `modules different: ${file} vs ${canvas.join(", ")}`
         : "not in a module in canvas",
   });
 }
@@ -729,7 +733,7 @@ export function getSyncReport({
     };
 
   const fields: SyncField[] = module
-    ? [checkModule(module.file, module.canvas)]
+    ? [checkModules(module.file, module.canvas)]
     : [];
 
   if (type === "page") {
diff --git a/src/app/course/[courseName]/calendar/day/getSyncStatus.test.ts b/src/app/course/[courseName]/calendar/day/getSyncStatus.test.ts
index 5a272ce3..4f637c7e 100644
--- a/src/app/course/[courseName]/calendar/day/getSyncStatus.test.ts
+++ b/src/app/course/[courseName]/calendar/day/getSyncStatus.test.ts
@@ -545,17 +545,25 @@ describe("getSyncReport - module", () => {
       module: canvasModules && { file: "Week 2", canvas: canvasModules },
     });
 
-  it("matches when the Canvas item is in the file's module", () => {
-    expect(report(["Week 1", "Week 2"]).differences).toEqual([]);
+  it("matches when the Canvas item is only in the file's module", () => {
+    expect(report(["Week 2"]).differences).toEqual([]);
+  });
+
+  it("differs when the Canvas item is also in another module", () => {
+    expect(report(["Week 2", "Week 1"]).differences[0]).toMatchObject({
+      label: "Modules",
+      canvas: "Week 1, Week 2",
+      message: "modules different: Week 2 vs Week 1, Week 2",
+    });
   });
 
   it("differs when the file moved to another module", () => {
     const [difference] = report(["Week 1"]).differences;
     expect(difference).toMatchObject({
-      key: "module",
+      key: "modules",
       local: "Week 2",
       canvas: "Week 1",
-      message: "module different: Week 2 vs Week 1",
+      message: "modules different: Week 2 vs Week 1",
     });
   });
 
@@ -567,6 +575,6 @@ describe("getSyncReport - module", () => {
   });
 
   it("is not compared until the Canvas modules load", () => {
-    expect(report(undefined).fields.map((f) => f.key)).not.toContain("module");
+    expect(report(undefined).fields.map((f) => f.key)).not.toContain("modules");
   });
 });
diff --git a/src/app/course/[courseName]/modules/[moduleName]/compare/CompareWithCanvas.tsx b/src/app/course/[courseName]/modules/[moduleName]/compare/CompareWithCanvas.tsx
index 7bc5263b..8dfaff7d 100644
--- a/src/app/course/[courseName]/modules/[moduleName]/compare/CompareWithCanvas.tsx
+++ b/src/app/course/[courseName]/modules/[moduleName]/compare/CompareWithCanvas.tsx
@@ -48,7 +48,7 @@ import {
 } from "@/services/utils/htmlTextDiff";
 
 const sectionLabels: Record<SyncSection, string> = {
-  module: "Module",
+  modules: "Modules",
   dates: "Dates",
   grading: "Grading",
   groups: "Groups",
diff --git a/src/features/canvas/hooks/canvasModuleHooks.ts b/src/features/canvas/hooks/canvasModuleHooks.ts
index cbe3c3a2..561f60a8 100644
--- a/src/features/canvas/hooks/canvasModuleHooks.ts
+++ b/src/features/canvas/hooks/canvasModuleHooks.ts
@@ -102,28 +102,32 @@ export const useAddToCanvasModule = () => {
 };
 
 /**
- * For Update in Canvas: puts an item in the Canvas module named after its
- * folder, so moving a file to another module moves it in Canvas too.
+ * For Update in Canvas: makes the Canvas module named after an item's folder
+ * the only one holding it, so moving a file to another module moves it in
+ * Canvas too.
  */
 export const usePlaceInCanvasModule = () => {
   const { data: settings } = useLocalCourseSettingsQuery();
   const queryClient = useQueryClient();
   const moduleIdByName = useCanvasModuleIdByName();
   return async (moduleName: string, item: ModuleItemContent) => {
-    const placed = await canvasModuleService.placeInModule(
+    const { placed, removed } = await canvasModuleService.placeInModule(
       settings.canvasId,
       await moduleIdByName(moduleName),
       item
     );
-    if (placed !== "already") {
-      toast.success(
-        `${placed === "moved" ? "Moved" : "Added"} "${item.title}" to the "${moduleName}" module in Canvas.`
-      );
+    const changes = [
+      placed === "moved" && `moved it to the "${moduleName}" module`,
+      placed === "added" && `added it to the "${moduleName}" module`,
+      removed > 0 &&
+        `removed it from ${removed} other module${removed === 1 ? "" : "s"}`,
+    ].filter(Boolean);
+    if (changes.length > 0) {
+      toast.success(`In Canvas, ${changes.join(" and ")}: "${item.title}".`);
       queryClient.invalidateQueries({
         queryKey: canvasCourseModuleKeys.modules(settings.canvasId),
       });
     }
-    return placed;
   };
 };
 
diff --git a/src/features/canvas/services/canvasModuleService.test.ts b/src/features/canvas/services/canvasModuleService.test.ts
index 7158e734..255222f8 100644
--- a/src/features/canvas/services/canvasModuleService.test.ts
+++ b/src/features/canvas/services/canvasModuleService.test.ts
@@ -2,12 +2,18 @@ import { describe, it, expect, vi, beforeEach } from "vitest";
 import { canvasModuleNames, canvasModuleService } from "./canvasModuleService";
 import { CanvasModule } from "../models/modules/canvasModule";
 import { axiosClient } from "@/services/axiosUtils";
-import { rateLimitAwarePost } from "./canvasWebRequestUtils";
+import {
+  rateLimitAwareDelete,
+  rateLimitAwarePost,
+} from "./canvasWebRequestUtils";
 
 vi.mock("@/services/axiosUtils", () => ({
   axiosClient: { get: vi.fn(), put: vi.fn() },
 }));
-vi.mock("./canvasWebRequestUtils", () => ({ rateLimitAwarePost: vi.fn() }));
+vi.mock("./canvasWebRequestUtils", () => ({
+  rateLimitAwarePost: vi.fn(),
+  rateLimitAwareDelete: vi.fn(),
+}));
 vi.mock("./canvasServiceUtils", () => ({
   canvasApi: "https://test.instructure.com/api/v1",
   paginatedRequest: vi.fn(),
@@ -26,18 +32,37 @@ describe("placeInModule", () => {
   const quiz = { type: "Quiz" as const, id: 7, title: "Quiz 1" };
   beforeEach(() => vi.clearAllMocks());
 
-  it("leaves an item alone when it is already in the module", async () => {
-    inModules(3, 9);
+  it("leaves an item alone when it is only in the module", async () => {
+    inModules(9);
 
-    expect(await canvasModuleService.placeInModule(42, 9, quiz)).toBe("already");
+    expect(await canvasModuleService.placeInModule(42, 9, quiz)).toEqual({
+      placed: "already",
+      removed: 0,
+    });
     expect(axiosClient.put).not.toHaveBeenCalled();
     expect(rateLimitAwarePost).not.toHaveBeenCalled();
+    expect(rateLimitAwareDelete).not.toHaveBeenCalled();
+  });
+
+  it("removes an item from other modules when it is also in the module", async () => {
+    inModules(3, 9);
+
+    expect(await canvasModuleService.placeInModule(42, 9, quiz)).toEqual({
+      placed: "already",
+      removed: 1,
+    });
+    expect(vi.mocked(rateLimitAwareDelete).mock.calls).toEqual([
+      ["https://test.instructure.com/api/v1/courses/42/modules/3/items/500"],
+    ]);
   });
 
   it("moves an item from another module", async () => {
     inModules(3);
 
-    expect(await canvasModuleService.placeInModule(42, 9, quiz)).toBe("moved");
+    expect(await canvasModuleService.placeInModule(42, 9, quiz)).toEqual({
+      placed: "moved",
+      removed: 0,
+    });
     expect(vi.mocked(axiosClient.put).mock.calls).toEqual([
       [
         "https://test.instructure.com/api/v1/courses/42/modules/3/items/500",
@@ -46,10 +71,28 @@ describe("placeInModule", () => {
     ]);
   });
 
+  it("moves one copy and removes the rest when it is in other modules", async () => {
+    inModules(3, 4);
+
+    expect(await canvasModuleService.placeInModule(42, 9, quiz)).toEqual({
+      placed: "moved",
+      removed: 1,
+    });
+    expect(vi.mocked(axiosClient.put).mock.calls[0][0]).toBe(
+      "https://test.instructure.com/api/v1/courses/42/modules/3/items/500",
+    );
+    expect(vi.mocked(rateLimitAwareDelete).mock.calls).toEqual([
+      ["https://test.instructure.com/api/v1/courses/42/modules/4/items/501"],
+    ]);
+  });
+
   it("adds an item that is in no module", async () => {
     inModules();
 
-    expect(await canvasModuleService.placeInModule(42, 9, quiz)).toBe("added");
+    expect(await canvasModuleService.placeInModule(42, 9, quiz)).toEqual({
+      placed: "added",
+      removed: 0,
+    });
     expect(vi.mocked(rateLimitAwarePost).mock.calls).toEqual([
       [
         "https://test.instructure.com/api/v1/courses/42/modules/9/items",
diff --git a/src/features/canvas/services/canvasModuleService.ts b/src/features/canvas/services/canvasModuleService.ts
index c6285921..dd82893f 100644
--- a/src/features/canvas/services/canvasModuleService.ts
+++ b/src/features/canvas/services/canvasModuleService.ts
@@ -2,7 +2,7 @@ import { CanvasModuleItem } from "@/features/canvas/models/modules/canvasModuleI
 import { canvasApi, paginatedRequest } from "./canvasServiceUtils";
 import { CanvasModule } from "@/features/canvas/models/modules/canvasModule";
 import { axiosClient } from "@/services/axiosUtils";
-import { rateLimitAwarePost } from "./canvasWebRequestUtils";
+import { rateLimitAwareDelete, rateLimitAwarePost } from "./canvasWebRequestUtils";
 
 /** A Canvas item to put in a module; a page is added by its url. */
 export interface ModuleItemContent {
@@ -66,33 +66,38 @@ export const canvasModuleService = {
   },
 
   /**
-   * Puts an item in a module: leaves it if it's already there, moves it from
-   * another module, or adds it when it's in none.
+   * Makes a module the only one holding an item: keeps or moves one copy into
+   * it (adding one when the item is in no module) and removes every other.
    */
   async placeInModule(
     canvasCourseId: number,
     canvasModuleId: number,
     item: ModuleItemContent
-  ): Promise<"already" | "moved" | "added"> {
+  ): Promise<{ placed: "already" | "moved" | "added"; removed: number }> {
     const { data } = await axiosClient.get<{
       items: { current?: { id: number; module_id: number } }[];
     }>(`${canvasApi}/courses/${canvasCourseId}/module_item_sequence`, {
       params: { asset_type: item.type, asset_id: item.id },
     });
     const placements = data.items.flatMap((i) => (i.current ? [i.current] : []));
-    if (placements.some((p) => p.module_id === canvasModuleId)) return "already";
+    const itemUrl = (p: { id: number; module_id: number }) =>
+      `${canvasApi}/courses/${canvasCourseId}/modules/${p.module_id}/items/${p.id}`;
 
-    if (placements.length > 0) {
-      const [from] = placements;
-      await axiosClient.put(
-        `${canvasApi}/courses/${canvasCourseId}/modules/${from.module_id}/items/${from.id}`,
-        { module_item: { module_id: canvasModuleId } }
-      );
-      return "moved";
-    }
+    const kept =
+      placements.find((p) => p.module_id === canvasModuleId) ?? placements[0];
+    const extras = placements.filter((p) => p !== kept);
+    for (const extra of extras) await rateLimitAwareDelete(itemUrl(extra));
 
-    await canvasModuleService.addModuleItem(canvasCourseId, canvasModuleId, item);
-    return "added";
+    if (!kept) {
+      await canvasModuleService.addModuleItem(canvasCourseId, canvasModuleId, item);
+      return { placed: "added", removed: 0 };
+    }
+    if (kept.module_id === canvasModuleId)
+      return { placed: "already", removed: extras.length };
+    await axiosClient.put(itemUrl(kept), {
+      module_item: { module_id: canvasModuleId },
+    });
+    return { placed: "moved", removed: extras.length };
   },
 
   async getCourseModules(canvasCourseId: number) {