diff --git a/apps/ai-game-creator-shell/src/features/resource-canvas/resourceCanvasHistoryModel.ts b/apps/ai-game-creator-shell/src/features/resource-canvas/resourceCanvasHistoryModel.ts
index 9ee3d1ee4..4a625a4ae 100644
--- a/apps/ai-game-creator-shell/src/features/resource-canvas/resourceCanvasHistoryModel.ts
+++ b/apps/ai-game-creator-shell/src/features/resource-canvas/resourceCanvasHistoryModel.ts
@@ -2,8 +2,8 @@
  * 资源画布的组织操作历史：只记录资源卡的布局坐标，**不记录、也不回滚素材内容**。
  *
  * 素材不可变是硬约束，所以撤销/重做只作用于「画布上卡片怎么排」，绝不反向修改
- * manifest 条目或素材文件。持久化仍走现役的手动 CAS 写链（`commitPosition`），
- * 本模块只做纯函数的快照栈。
+ * manifest 条目或素材文件。持久化仍走现役的手动 CAS 写链（`commitPositions` 的一笔批量
+ * 写入），本模块只做纯函数的快照栈。
  */
 
 import {
@@ -82,10 +82,9 @@ export function captureResourceCanvasSnapshot(
 /**
  * 两份快照是否算「同一版布局」。
  *
- * 只比 `section / x / y`：撤销写回走 `commitPosition(resourceId, section, x, y)`，
- * `manuallyPlaced` 不在写回入参里（`moveResourceCanvasPosition` 自己会置 true），
- * 所以它本来就不是可恢复的维度。把它算进相等判定，只会在「只有这个标记不同」时压进一条
- * 历史，而 `resolveResourceCanvasRestoreEntries` 按坐标过滤后返回空表 —— 撤销变成静默空操作。
+ * 比 `section / x / y / manuallyPlaced` 四项。手动标记是**可恢复的维度**：「整理画布」
+ * 会把目标栏目里连手动卡一起重排成自动坐标，撤销要恢复的正是"原坐标 + 原手动标记"；
+ * 只比坐标就会把"坐标恰好重合、标记不同"的那次操作判成没变过，撤销变成静默空操作。
  */
 export function resourceCanvasSnapshotsEqual(
   left: ResourceCanvasLayoutSnapshot,
@@ -101,7 +100,8 @@ export function resourceCanvasSnapshotsEqual(
       entry.resourceId === other.resourceId &&
       entry.section === other.section &&
       entry.x === other.x &&
-      entry.y === other.y
+      entry.y === other.y &&
+      entry.manuallyPlaced === other.manuallyPlaced
     );
   });
 }
@@ -214,6 +214,8 @@ export function canRedoResourceCanvasHistory(history: ResourceCanvasHistory) {
 
 /**
  * 只回写和快照不一致的位置，避免撤销时把没动过的卡片也当成一次手动摆放写回后端。
+ * `manuallyPlaced` 同样参与判定：「整理画布」之后这些卡的坐标可能恰好与整理前一致
+ * （例如本来就已经整齐），但标记从手动变成了自动，撤销必须把标记恢复回去。
  */
 export function resolveResourceCanvasRestoreEntries(
   snapshot: ResourceCanvasLayoutSnapshot,
@@ -230,7 +232,8 @@ export function resolveResourceCanvasRestoreEntries(
     return (
       existing.section !== entry.section ||
       existing.x !== entry.x ||
-      existing.y !== entry.y
+      existing.y !== entry.y ||
+      existing.manuallyPlaced !== entry.manuallyPlaced
     );
   });
 }
diff --git a/apps/ai-game-creator-shell/src/view/project-development/index.tsx b/apps/ai-game-creator-shell/src/view/project-development/index.tsx
index d4a9a3219..27b8867ad 100644
--- a/apps/ai-game-creator-shell/src/view/project-development/index.tsx
+++ b/apps/ai-game-creator-shell/src/view/project-development/index.tsx
@@ -238,7 +238,6 @@ import {
 import {
   buildResourceBookScenePlan,
   resolveResourceBookAllLayout,
-  resourceBookAllBandLocalPoint,
   type ResourceBookAllLayoutCache,
   type ResourceBookOverviewRect,
   resourceBookSceneCardKey,
@@ -280,6 +279,7 @@ import {
   createResourceCanvasCardSizeByResourceId,
   fitResourceCanvasViewportToContent,
   normalizeInfiniteResourceCanvasViewport,
+  type ResourceCanvasPositionWrite,
   RESOURCE_CANVAS_CARD_HEIGHT,
   RESOURCE_CANVAS_CARD_WIDTH,
   RESOURCE_CANVAS_DRAG_THRESHOLD,
@@ -369,6 +369,56 @@ type ResourceSortMode = ProjectResourceCanvasLayoutMode;
 type WorkbenchMode = 'resources' | 'run';
 type OrchestrationMode = 'single-supervisor' | 'professional-dag';
 
+/**
+ * 一次资源卡拖动参与位移的卡集合与它们的起始局部坐标。
+ *
+ * 判据只认**当前画布可见的选中集**：按住已选中的卡时整批跟随，按住未选中的卡时只有它自己
+ * （保持既有单选语义）。集合按 `visibleResourceIds`（筛选后可见）与当前栏目页的栏目双重
+ * 过滤——被筛选藏起来的、以及停留在其他栏目里的残留选中都不参与位移，也不会被写回坐标。
+ * 起始坐标取拖动开始那一刻的布局局部坐标（`positions`），不随拖动过程中的重算漂移。
+ */
+export function resolveResourceCardDragMoves({
+  resource,
+  resources,
+  selectedResourceIds,
+  visibleResourceIds,
+  positions,
+  opensAllResources,
+  activePageCategory,
+}: {
+  resource: ProjectResource;
+  resources: readonly ProjectResource[];
+  selectedResourceIds: readonly string[];
+  visibleResourceIds: ReadonlySet<string>;
+  positions: ReadonlyMap<string, { x: number; y: number }>;
+  opensAllResources: boolean;
+  activePageCategory: ResourceCategory | null;
+}) {
+  const moveFor = (candidate: ProjectResource) => {
+    const position = positions.get(candidate.id);
+    return {
+      resourceId: candidate.id,
+      section: candidate.category,
+      startX: position?.x ?? 0,
+      startY: position?.y ?? 0,
+    };
+  };
+  const selected = new Set(selectedResourceIds);
+  if (!selected.has(resource.id)) {
+    return [moveFor(resource)];
+  }
+  const movable = resources.filter(
+    (candidate) =>
+      selected.has(candidate.id) &&
+      visibleResourceIds.has(candidate.id) &&
+      (opensAllResources || candidate.category === activePageCategory),
+  );
+  const moves = movable.map(moveFor);
+  // 被选中的卡一定在画布里渲染得出来；真出现过滤后为空（例如集合已过期）时退回单选，
+  // 至少让用户按住的那张卡跟着指针走。
+  return moves.length > 0 ? moves : [moveFor(resource)];
+}
+
 function isPlatformAuthenticationRequired(error: unknown) {
   const message = error instanceof Error ? error.message : String(error);
   return (
@@ -1300,6 +1350,7 @@ function ResourceBookScene({
   onPointerMove,
   onPointerUp,
   onPointerCancel,
+  onLostPointerCapture,
 }: {
   plan: ResourceBookSceneCategoryPlan[];
   resourceBookState: ResourceBookState;
@@ -1329,6 +1380,11 @@ function ResourceBookScene({
   onPointerMove: (event: ReactPointerEvent<HTMLDivElement>) => void;
   onPointerUp: (event: ReactPointerEvent<HTMLDivElement>) => void;
   onPointerCancel: (event: ReactPointerEvent<HTMLDivElement>) => void;
+  /**
+   * 指针捕获丢失时的收口。缺省沿用 `onPointerCancel`（只负责画布平移/框选），资源卡拖动
+   * 需要在这一刻按取消回滚，因此工作台会传一个同时终止两者的处理器。
+   */
+  onLostPointerCapture?: (event: ReactPointerEvent<HTMLDivElement>) => void;
 }) {
   const sceneViewport = normalizeResourceBookViewport(
     resourceBookState.view === 'main' ? mainViewport : viewport,
@@ -1382,7 +1438,7 @@ function ResourceBookScene({
       onPointerMove={onPointerMove}
       onPointerUp={onPointerUp}
       onPointerCancel={onPointerCancel}
-      onLostPointerCapture={onPointerCancel}
+      onLostPointerCapture={onLostPointerCapture ?? onPointerCancel}
     >
       <div
         className="game-resource-book-scene-world"
@@ -1822,19 +1878,33 @@ export default function ProjectDevelopmentView({
   const resourceCardDragRef = useRef<{
     pointerId: number;
     captureTarget: HTMLDivElement;
+    /**
+     * 本次拖动真正参与位移的卡（第 0 项是被按住的那张）。框选多选后按住的卡是已选卡时，
+     * 这里就是"当前画布可见的选中集"——筛选隐藏与跨栏目残留的选中不进来；按住未选卡时
+     * 只有它自己，保持原有单选语义。
+     */
+    moves: Array<{
+      resourceId: string;
+      section: ResourceCategory;
+      /** 拖动开始那一刻的栏目内局部坐标：整批位移的基准，落盘时不再重新读布局。 */
+      startX: number;
+      startY: number;
+    }>;
     resourceId: string;
     section: ResourceCategory;
     startClientX: number;
     startClientY: number;
     startScale: number;
-    startX: number;
-    startY: number;
+    /** 拖动开始时的项目作用域：切项目后松手不得把位移写进新项目。 */
+    scopeKey: string;
     changed: boolean;
   } | null>(null);
   const [resourceCardDragPreview, setResourceCardDragPreview] = useState<{
     resourceId: string;
-    x: number;
-    y: number;
+    /** 整次选择集共用的位移（世界坐标单位，已按 scale 换算）。 */
+    deltaX: number;
+    deltaY: number;
+    movedResourceIds: readonly string[];
   } | null>(null);
   const resourceDependencyOverlayRef =
     useRef<ResourceDependencyOverlayHandle>(null);
@@ -2614,6 +2684,9 @@ export default function ProjectDevelopmentView({
       ),
     [resourceLayout.positions],
   );
+  /** 拖动起点坐标的读取口：`pointerdown` 与渲染同源，避免两处各取一份布局快照。 */
+  const resourceLayoutPositionsRef = useRef(resourcePositionById);
+  resourceLayoutPositionsRef.current = resourcePositionById;
   const selectedVersionBindingResourceIds = useMemo(() => {
     const selectedVersion = resources.find(
       (resource) => resource.id === selectedResourceId,
@@ -3508,11 +3581,13 @@ export default function ProjectDevelopmentView({
     }
     return signatures;
   }, [resourceBookScenePlan, resourceBookOverviewRects]);
-  // 拖拽中的卡片只跟指针走，不参与布局 FLIP。
+  // 拖拽中的卡片只跟指针走，不参与布局 FLIP；多选时整批移动的卡一起冻结。
   const resourceBookFrozenMotionKeys = useMemo(() => {
     const keys = new Set<string>();
     if (resourceCardDragPreview) {
-      keys.add(resourceBookSceneCardKey(resourceCardDragPreview.resourceId));
+      for (const resourceId of resourceCardDragPreview.movedResourceIds) {
+        keys.add(resourceBookSceneCardKey(resourceId));
+      }
     }
     return keys;
   }, [resourceCardDragPreview]);
@@ -4515,17 +4590,27 @@ export default function ProjectDevelopmentView({
 
   const applyResourceCanvasLayoutSnapshot = useCallback(
     (snapshot: ResourceCanvasLayoutSnapshot) => {
-      resolveResourceCanvasRestoreEntries(
+      /**
+       * 撤销/重做一次只写一笔：整份快照里与当前布局不同的位置合成一次批量写入（含
+       * `manuallyPlaced`），不再每张卡排一笔 CAS。写回顺序、失败提示与冲突恢复都沿用
+       * 既有写队列。
+       */
+      const entries = resolveResourceCanvasRestoreEntries(
         snapshot,
         activeResourceLayout.layout.positions,
-      ).forEach((entry) => {
-        activeResourceLayout.commitPosition(
-          entry.resourceId,
-          entry.section,
-          entry.x,
-          entry.y,
-        );
-      });
+      );
+      if (entries.length === 0) {
+        return;
+      }
+      activeResourceLayout.commitPositions(
+        entries.map((entry) => ({
+          resourceId: entry.resourceId,
+          section: entry.section,
+          x: entry.x,
+          y: entry.y,
+          manuallyPlaced: entry.manuallyPlaced,
+        })),
+      );
     },
     [activeResourceLayout],
   );
@@ -4569,6 +4654,52 @@ export default function ProjectDevelopmentView({
     resourceCanvasHistory,
   );
 
+  /**
+   * 「整理画布」的作用范围。
+   *
+   * - 栏目页：当前栏目这一栏，栏内**全部**素材（含手动摆放过的卡，筛选也不缩小集合）；
+   * - 「所有资源」页：当前项目所有可展示素材，即全部栏目；
+   * - 没有当前栏目（空项目）时范围为空，按钮不产生任何写入。
+   *
+   * 其他栏目不在范围内：既有的自动坐标、手动坐标都逐值不动。
+   */
+  const resourceOrganizeSections = useMemo<
+    readonly ResourceCategory[] | null
+  >(() => {
+    if (resourceBookOpensAllResources) {
+      return null;
+    }
+    return activePageCategory ? [activePageCategory] : [];
+  }, [activePageCategory, resourceBookOpensAllResources]);
+
+  /**
+   * 整理是一次可撤销操作：先按"整理前"的坐标与手动标记记一笔历史，再交给布局写链按
+   * 目标栏目重算并落盘。失败/冲突仍由布局 hook 的既有提示与恢复分支承担。
+   *
+   * 已经整齐、这一按不会改变任何坐标与标记时不记历史、不落盘：撤销栈里不该出现
+   * "按了却什么也没做"的一步。
+   */
+  const organizeResourceCanvasLayout = useCallback(() => {
+    if (
+      resourceOrganizeSections !== null &&
+      resourceOrganizeSections.length === 0
+    ) {
+      return;
+    }
+    const snapshot = captureResourceCanvasSnapshot(
+      activeResourceLayout.layout.positions,
+    );
+    if (!activeResourceLayout.organizeNow(resourceOrganizeSections)) {
+      return;
+    }
+    setResourceCanvasHistory((history) =>
+      pushResourceCanvasHistory(history, {
+        label: '整理画布',
+        snapshot,
+      }),
+    );
+  }, [activeResourceLayout, resourceOrganizeSections]);
+
   useEffect(() => {
     const handleHistoryShortcut = (event: KeyboardEvent) => {
       if (!(event.ctrlKey || event.metaKey) || event.altKey) {
@@ -4792,6 +4923,8 @@ export default function ProjectDevelopmentView({
     const handleBlur = () => {
       resourceCanvasSpacePanRef.current = false;
       cancelResourceCanvasPan();
+      // 窗口失焦＝这次拖动不会再有可信的 pointerup：按取消处理，回滚到拖动前坐标。
+      cancelResourceCardDrag();
       setResourceCanvasMarquee(null);
     };
     window.addEventListener('keydown', handleKeyDown);
@@ -4802,7 +4935,7 @@ export default function ProjectDevelopmentView({
       window.removeEventListener('keyup', handleKeyUp);
       window.removeEventListener('blur', handleBlur);
     };
-  }, [cancelResourceCanvasPan]);
+  }, [cancelResourceCanvasPan, cancelResourceCardDrag]);
 
   const handleResourceBookWheel = useCallback(
     (event: ReactWheelEvent<HTMLDivElement> | WheelEvent) => {
@@ -4959,8 +5092,6 @@ export default function ProjectDevelopmentView({
     (
       event: ReactPointerEvent<HTMLDivElement>,
       resource: ProjectResource,
-      x: number,
-      y: number,
     ) => {
       if (event.button !== 0) {
         return;
@@ -5000,20 +5131,32 @@ export default function ProjectDevelopmentView({
       resourceCardDragRef.current = {
         pointerId: event.pointerId,
         captureTarget: event.currentTarget,
+        moves: resolveResourceCardDragMoves({
+          resource,
+          resources: canvasResources,
+          selectedResourceIds,
+          visibleResourceIds,
+          positions: resourceLayoutPositionsRef.current,
+          opensAllResources: resourceBookOpensAllResources,
+          activePageCategory,
+        }),
         resourceId: resource.id,
         section: resource.category,
         startClientX: event.clientX,
         startClientY: event.clientY,
         startScale: scale,
-        startX: x,
-        startY: y,
+        scopeKey: resourceCategoryScopeKey,
         changed: false,
       };
     },
     [
       activePageCategory,
+      canvasResources,
+      resourceCategoryScopeKey,
       resourceBookOpensAllResources,
       resourceReplacementPickMode,
+      selectedResourceIds,
+      visibleResourceIds,
     ],
   );
 
@@ -5035,15 +5178,22 @@ export default function ProjectDevelopmentView({
         skipNextResourceCardClickRef.current = drag.resourceId;
       }
       drag.changed = true;
-      const coordinate = (start: number, delta: number) =>
-        start + delta / drag.startScale;
-      const preview = {
+      // 位移只有一份：整张选择集按同一个世界坐标位移走，渲染时每张卡各自加上它（见
+      // `renderResourceBookCard`），落盘时再按同一尺度换成栏目内局部坐标。
+      const scaledDeltaX = deltaX / drag.startScale;
+      const scaledDeltaY = deltaY / drag.startScale;
+      setResourceCardDragPreview({
         resourceId: drag.resourceId,
-        x: coordinate(drag.startX, deltaX),
-        y: coordinate(drag.startY, deltaY),
-      };
-      setResourceCardDragPreview(preview);
-      resourceDependencyOverlayRef.current?.updateDragPreview(preview);
+        deltaX: scaledDeltaX,
+        deltaY: scaledDeltaY,
+        movedResourceIds: drag.moves.map((move) => move.resourceId),
+      });
+      const primary = drag.moves[0];
+      resourceDependencyOverlayRef.current?.updateDragPreview({
+        resourceId: drag.resourceId,
+        x: (primary?.startX ?? 0) + scaledDeltaX,
+        y: (primary?.startY ?? 0) + scaledDeltaY,
+      });
     },
     [],
   );
@@ -5071,55 +5221,50 @@ export default function ProjectDevelopmentView({
       } else {
         deferSkippedResourceCardClickCleanup(drag.resourceId);
       }
-      const preview = drag.changed
-        ? {
-            resourceId: drag.resourceId,
-            x:
-              drag.startX +
-              (event.clientX - drag.startClientX) / drag.startScale,
-            y:
-              drag.startY +
-              (event.clientY - drag.startClientY) / drag.startScale,
-          }
-        : null;
       setResourceCardDragPreview(null);
-      if (commit && drag.changed && preview?.resourceId === drag.resourceId) {
-        // 先落"拖动前"的快照，撤销才有回退点；它只含布局坐标。
-        setResourceCanvasHistory((history) =>
-          pushResourceCanvasHistory(history, {
-            label: '移动资源卡',
-            snapshot: captureResourceCanvasSnapshot(
-              activeResourceLayout.layout.positions,
-            ),
-          }),
-        );
-        /**
-         * 拖动算出来的 `preview` 与画面同系：栏目页就是栏目内局部坐标，展开态则是
-         * "局部坐标 + 带原点"。落盘只认栏目内局部坐标（`section` 就是资源当前分类，
-         * 没有 `all` 这个分区），所以展开态提交前必须减掉带原点——写回去的正是这张卡
-         * 在它自己栏目里的同一个槽位，栏目页立刻看到同一位置，不存在第二份空间。
-         * 栏目页 `layout` 传 null，减 0，与原行为逐字等价。
-         */
-        const local = resourceBookAllBandLocalPoint({
-          layout: resourceBookOpensAllResources ? resourceBookAllLayout : null,
-          category: drag.section,
-          x: preview.x,
-          y: preview.y,
-        });
-        activeResourceLayout.commitPosition(
-          drag.resourceId,
-          drag.section,
-          local.x,
-          local.y,
-        );
+      // 取消手势（pointercancel / 捕获丢失 / 窗口失焦）：拖动期间从未改写坐标，丢掉预览即
+      // 回到拖动前的位置；已选中的多选保持不动，不在这里清选择。
+      if (!commit || !drag.changed) {
+        return;
       }
+      // 拖动开始后切了项目：位移只属于原项目，松手不得写进新项目。
+      if (drag.scopeKey !== resourceCategoryScopeKey) {
+        return;
+      }
+      const deltaX = (event.clientX - drag.startClientX) / drag.startScale;
+      const deltaY = (event.clientY - drag.startClientY) / drag.startScale;
+      /**
+       * 每张卡各自的位移与整批相同：卡片画的是"栏目内局部坐标 + 该栏目的带原点"（展开态），
+       * 带原点在一次拖动期间冻结，同一个世界坐标位移换成局部位移后逐卡拉平——于是展开态
+       * 与栏目页共用同一条换算，不需要按卡再减一次带原点，也不存在第二份空间。
+       */
+      const writes: ResourceCanvasPositionWrite[] = drag.moves.map((move) => ({
+        resourceId: move.resourceId,
+        section: move.section,
+        x: move.startX + deltaX,
+        y: move.startY + deltaY,
+        manuallyPlaced: true,
+      }));
+      if (writes.length === 0) {
+        return;
+      }
+      // 先落"拖动前"的快照，撤销才有回退点；它只含布局坐标与手动标记。
+      setResourceCanvasHistory((history) =>
+        pushResourceCanvasHistory(history, {
+          label: writes.length > 1 ? '移动所选资源卡' : '移动资源卡',
+          snapshot: captureResourceCanvasSnapshot(
+            activeResourceLayout.layout.positions,
+          ),
+        }),
+      );
+      // 整批一次提交：一张卡与多张卡走的都是这一次批量写入，撤销也只回滚这一次。
+      activeResourceLayout.commitPositions(writes);
     },
     [
       activeResourceLayout,
       clearSkippedResourceCardClick,
       deferSkippedResourceCardClickCleanup,
-      resourceBookAllLayout,
-      resourceBookOpensAllResources,
+      resourceCategoryScopeKey,
     ],
   );
 
@@ -5269,6 +5414,22 @@ export default function ProjectDevelopmentView({
     [resourceCanvasMarquee],
   );
 
+  /**
+   * 场景根上的「指针捕获丢失」总收口。
+   *
+   * 资源卡把指针捕获在**自己**身上，`lostpointercapture` 因此先在卡片上触发、再冒泡到这里；
+   * 这条路径既要终止画布平移/框选，也要按取消结束资源卡拖动——否则捕获一丢，拖动预览再也
+   * 收不到 pointerup，卡片会一直挂在指针上。两个处理器各自按 `pointerId` 判据过滤，
+   * 与本次指针无关的事件不会误伤另一个手势。
+   */
+  const handleResourceCanvasLostPointerCapture = useCallback(
+    (event: ReactPointerEvent<HTMLDivElement>) => {
+      stopResourceCanvasPan(event);
+      handleResourceCardPointerCancel(event);
+    },
+    [handleResourceCardPointerCancel, stopResourceCanvasPan],
+  );
+
   function showResourceSortMode(nextMode: ResourceSortMode) {
     if (nextMode === sortMode) {
       return;
@@ -6297,11 +6458,12 @@ export default function ProjectDevelopmentView({
         return null;
       }
       const dragPreview =
-        resourceCardDragPreview?.resourceId === resource.id
+        resourceCardDragPreview?.movedResourceIds.includes(resource.id)
           ? resourceCardDragPreview
           : null;
-      const previewX = dragPreview ? dragPreview.x : undefined;
-      const previewY = dragPreview ? dragPreview.y : undefined;
+      // 整张选择集按同一个位移走：每张卡各自加上同一份位移，相对位置保持原样。
+      const previewX = dragPreview ? layout.x + dragPreview.deltaX : undefined;
+      const previewY = dragPreview ? layout.y + dragPreview.deltaY : undefined;
       return (
         <ResourceCard
           resource={resource}
@@ -6335,12 +6497,7 @@ export default function ProjectDevelopmentView({
           activeMediaIdentity={activeCardMediaIdentity}
           onSelect={handleResourceSelect}
           onPointerDown={(event) =>
-            handleResourceCardPointerDown(
-              event,
-              resource,
-              layout.dragX,
-              layout.dragY,
-            )
+            handleResourceCardPointerDown(event, resource)
           }
           onPointerMove={handleResourceCardPointerMove}
           onPointerUp={handleResourceCardPointerUp}
@@ -7818,16 +7975,21 @@ export default function ProjectDevelopmentView({
                     样式（有边圆角 + secondary 填充），与分段 pill 的模式切换一眼可分；因此不
                     新增任何 CSS。**不要放到这一行的行尾**：行尾会被读成“针对整个工具条”的动作。
 
-                    画布不再自动重排，整张整理只由这一次显式动作发起：丢掉全部自动坐标、按当前
-                    资源与拓扑重算（手动拖过的卡原地不动）。进行中的保存/重算仍然由既有的
-                    「保存中 / 布局已保存」状态位反馈。
+                    画布不再自动重排，整张整理只由这一次显式动作发起：目标栏目（「所有资源」页
+                    为全部栏目）内**全部**素材连手动坐标一起丢掉、按当前资源与拓扑重算成自动
+                    坐标，其他栏目一格不动；筛选不缩小整理集合。一次整理＝一笔可撤销操作，
+                    进行中的保存/重算仍然由既有的「保存中 / 布局已保存」状态位反馈。
                   */}
                   <button
                     type="button"
                     aria-label="整理画布"
-                    disabled={!resourceLayoutReady}
+                    disabled={
+                      !resourceLayoutReady ||
+                      (resourceOrganizeSections !== null &&
+                        resourceOrganizeSections.length === 0)
+                    }
                     aria-busy={resourceLayoutSaving}
-                    onClick={() => activeResourceLayout.rederiveNow()}
+                    onClick={organizeResourceCanvasLayout}
                   >
                     <LayoutGrid size={15} aria-hidden="true" />
                     整理画布
@@ -8324,6 +8486,7 @@ export default function ProjectDevelopmentView({
                   onPointerMove={handleResourceCanvasPointerMove}
                   onPointerUp={stopResourceCanvasPan}
                   onPointerCancel={stopResourceCanvasPan}
+                  onLostPointerCapture={handleResourceCanvasLostPointerCapture}
                 />
                 {resourceReplacementPickMode ? (
                   <div className="game-resource-canvas-pick-hint">
diff --git a/apps/ai-game-creator-shell/src/view/project-development/resourceCanvasLayoutModel.ts b/apps/ai-game-creator-shell/src/view/project-development/resourceCanvasLayoutModel.ts
index 322d76306..97ba9a92b 100644
--- a/apps/ai-game-creator-shell/src/view/project-development/resourceCanvasLayoutModel.ts
+++ b/apps/ai-game-creator-shell/src/view/project-development/resourceCanvasLayoutModel.ts
@@ -1334,31 +1334,76 @@ export function moveResourceCanvasPosition(
   x: number,
   y: number,
 ): ProjectResourceCanvasLayout {
-  const finiteX = Number.isFinite(x) ? x : 0;
-  const finiteY = Number.isFinite(y) ? y : 0;
-  const normalizedX = Math.min(
-    GAME_CREATION_RESOURCE_LAYOUT_MAX_COORDINATE,
-    Math.max(GAME_CREATION_RESOURCE_LAYOUT_MIN_COORDINATE, Math.round(finiteX)),
-  );
-  const normalizedY = Math.min(
-    GAME_CREATION_RESOURCE_LAYOUT_MAX_COORDINATE,
-    Math.max(GAME_CREATION_RESOURCE_LAYOUT_MIN_COORDINATE, Math.round(finiteY)),
-  );
+  return applyResourceCanvasPositionWrites(layout, [
+    { resourceId, section, x, y, manuallyPlaced: true },
+  ]);
+}
+
+/**
+ * 一笔写回里的单张卡坐标。`manuallyPlaced` 由调用方显式给出，不从"是不是用户拖的"推断：
+ * 多选拖动与撤销恢复都可能在一笔里同时出现手动卡与自动卡（撤销「整理画布」恢复的正是
+ * 原来的**自动**卡标记），因此这个标记必须是入参，不能由写入本身改写。
+ */
+export type ResourceCanvasPositionWrite = {
+  resourceId: string;
+  section: ProjectResourceCanvasCategory;
+  x: number;
+  y: number;
+  manuallyPlaced: boolean;
+};
+
+/**
+ * 批量坐标写入：一次把多张卡的坐标（含手动标记）落到同一个布局对象上。
+ *
+ * 与 `moveResourceCanvasPosition` 同一条归一化与匹配口径——只改写 `resourceId + section`
+ * 都对得上的那一条，坐标夹到安全范围并取整；不新增、不删除、不重排分区，找不到的写入
+ * 静默跳过（资源可能在拖动期间被删掉）。调用方据此把"多选拖动 / 撤销一次"变成**一笔**
+ * 布局写入，而不是每张卡各排一笔。
+ */
+export function applyResourceCanvasPositionWrites(
+  layout: ProjectResourceCanvasLayout,
+  writes: readonly ResourceCanvasPositionWrite[],
+): ProjectResourceCanvasLayout {
+  if (writes.length === 0) {
+    return layout;
+  }
+  const writeByResourceId = new Map<
+    string,
+    Pick<ResourceCanvasPositionWrite, 'section' | 'x' | 'y' | 'manuallyPlaced'>
+  >();
+  for (const write of writes) {
+    writeByResourceId.set(write.resourceId, {
+      section: write.section,
+      x: write.x,
+      y: write.y,
+      manuallyPlaced: write.manuallyPlaced,
+    });
+  }
   return {
     ...layout,
-    positions: layout.positions.map((position) =>
-      position.resourceId === resourceId && position.section === section
-        ? {
-            ...position,
-            x: normalizedX,
-            y: normalizedY,
-            manuallyPlaced: true,
-          }
-        : position,
-    ),
+    positions: layout.positions.map((position) => {
+      const write = writeByResourceId.get(position.resourceId);
+      if (!write || write.section !== position.section) {
+        return position;
+      }
+      return {
+        ...position,
+        x: normalizedResourceCanvasCoordinate(write.x),
+        y: normalizedResourceCanvasCoordinate(write.y),
+        manuallyPlaced: write.manuallyPlaced,
+      };
+    }),
   };
 }
 
+function normalizedResourceCanvasCoordinate(value: number) {
+  const finite = Number.isFinite(value) ? value : 0;
+  return Math.min(
+    GAME_CREATION_RESOURCE_LAYOUT_MAX_COORDINATE,
+    Math.max(GAME_CREATION_RESOURCE_LAYOUT_MIN_COORDINATE, Math.round(finite)),
+  );
+}
+
 export function resourceCanvasSectionExtent(
   positions: readonly ProjectResourceCanvasPosition[],
   cardSizeByResourceId?: ResourceCanvasCardSizeByResourceId,
diff --git a/apps/ai-game-creator-shell/src/view/project-development/useProjectResourceCanvasLayout.ts b/apps/ai-game-creator-shell/src/view/project-development/useProjectResourceCanvasLayout.ts
index 0a7a3c789..31f4ce99d 100644
--- a/apps/ai-game-creator-shell/src/view/project-development/useProjectResourceCanvasLayout.ts
+++ b/apps/ai-game-creator-shell/src/view/project-development/useProjectResourceCanvasLayout.ts
@@ -12,11 +12,12 @@ import {
 } from '../../../../../packages/shared/src/contracts/gameCreationApp';
 import { normalizeDiagnosticText } from '../../services/errorReporting';
 import {
+  applyResourceCanvasPositionWrites,
   createEmptyResourceCanvasLayout,
-  moveResourceCanvasPosition,
   reconcileResourceCanvasLayout,
   type ResourceCanvasItem,
   type ResourceCanvasLayoutTopology,
+  type ResourceCanvasPositionWrite,
 } from './resourceCanvasLayoutModel';
 import { normalizeResourceCanvasPosition } from './resourceCanvasSectionMapping';
 
@@ -53,29 +54,46 @@ type LayoutScope = {
   mode: ProjectResourceCanvasLayoutMode;
 };
 
+/**
+ * 一笔手动坐标写入：多选拖动、撤销/重做恢复都只排**一笔**，`positions` 里的每一张卡各自
+ * 带自己的 `section` 与 `manuallyPlaced`。队列按 `resourceId + section` 合并同一张卡的重复
+ * 写入，语义仍是"最后落点赢"，不会因为一次多选拖动就生成 N 笔 CAS。
+ */
 type ManualLayoutWriteIntent = {
   kind: 'manual';
   scopeEpoch: number;
-  resourceId: string;
-  section: ProjectResourceCanvasCategory;
-  x: number;
-  y: number;
+  positions: ResourceCanvasPositionWrite[];
 };
 
+/**
+ * 自动坐标重派生请求。
+ *
+ * - `automatic`：只丢自动坐标，手动卡原地不动（关系图首次就绪那一次）。
+ * - `organize`：用户显式「整理画布」。目标栏目内的坐标**连手动一起丢**再重算，结果一律是
+ *   自动坐标；`sections` 为 `null` 表示「所有资源」页＝当前项目全部可展示素材。
+ *   保存仍走同一条写队列与 CAS，只是重算前的取舍不同。
+ */
+type LayoutRederiveRequest =
+  | { kind: 'automatic' }
+  | {
+      kind: 'organize';
+      sections: readonly ProjectResourceCanvasCategory[] | null;
+    };
+
 type ResourceLayoutWriteIntent = {
   kind: 'resources';
   scopeEpoch: number;
   resourceSignature: string;
   conflictRetries: number;
   /**
-   * 显式「整理画布」写意图：这一笔写回按 `rederive` 策略丢掉全部自动坐标重算。
+   * 显式「整理画布」/「关系图首次就绪」写意图：这一笔写回按 `rederive` 策略丢坐标重算。
    *
    * 仍然是"坐标真的变了才落盘"（沿用既有 `changed` 门）：已经整齐的画布按一下不该产生
    * 一次无意义的 CAS / revision 推进，也不该在关系图被截断这类"重算结果同样可信但不能
    * 声称变过"的场景里凭空写一笔。自动（签名变化触发）的资源同步永远是 `false`，
    * 只补新卡、不动既有坐标。
    */
-  rederive: boolean;
+  rederive: LayoutRederiveRequest | null;
 };
 
 type LayoutWriteIntent = ManualLayoutWriteIntent | ResourceLayoutWriteIntent;
@@ -365,8 +383,46 @@ function reconcileLayout(
   resources: ResourceCanvasItem[],
   policy: AutomaticPositionPolicy,
   topology: ResourceCanvasLayoutTopology | undefined,
+  /**
+   * 「整理画布」的目标栏目集合。给了（含 `null` ＝ 全部栏目）就在重算前把这些栏目里的坐标
+   * **连手动标记一起丢掉**，重算结果一律落成自动坐标；没给的栏目**逐值不动、连自动坐标也不
+   * 重排**（详见下面的保留判据）。判定按 `normalizeResourceCanvasPosition` 归并后的现行分区
+   * 做，磁盘上仍是旧栏目取值的坐标不会因为 `section` 字面量不同而漏出整理范围。
+   */
+  organizeSections:
+    | readonly ProjectResourceCanvasCategory[]
+    | null
+    | undefined = undefined,
 ) {
-  if (policy === 'preserve') {
+  // `undefined` ＝ 不是整理；`null` ＝ 整理全部栏目；否则按集合判定。
+  const organizedSections =
+    organizeSections === undefined
+      ? undefined
+      : organizeSections === null
+        ? null
+        : new Set(organizeSections);
+  const categoryByResourceId = new Map(
+    resources.map((resource) => [resource.id, resource.category]),
+  );
+  const dropPosition = (
+    position: ProjectResourceCanvasLayout['positions'][number],
+  ) => {
+    if (organizedSections === undefined) {
+      return false;
+    }
+    const normalized = normalizeResourceCanvasPosition(
+      position,
+      categoryByResourceId,
+    );
+    if (!normalized) {
+      return false;
+    }
+    return (
+      organizedSections === null ||
+      organizedSections.has(normalized.position.section)
+    );
+  };
+  if (policy === 'preserve' && organizeSections === undefined) {
     const reconciled = reconcileResourceCanvasLayout(
       source,
       resources,
@@ -376,12 +432,27 @@ function reconcileLayout(
       ? reconciled
       : { layout: source, changed: false };
   }
-  const manualSource = {
+  /**
+   * 保留判据按「这一次重算的范围」分两种口径：
+   * - **整理**（`organizeSections` 已给）：只丢目标栏目的坐标，栏外坐标逐值保留，**包括自动
+   *   坐标**。自动坐标不是「重算一次必然一样」的派生值：真实项目里它可能来自更早版本的排布，
+   *   或素材被删、被拖走后留下的既有位置；顺手把它们丢给重算，就等于「整理当前栏目」时把别的
+   *   栏目重新规整成规范槽位，与「其他栏目不变」相反。
+   * - **全局重算**（`rederive`：关系图首次就绪那一次）：丢全部自动坐标、手动卡原地不动，
+   *   由重算把自动槽位补齐。
+   */
+  const keepsPosition = (
+    position: ProjectResourceCanvasLayout['positions'][number],
+  ) =>
+    organizeSections !== undefined
+      ? !dropPosition(position)
+      : policy === 'preserve' || position.manuallyPlaced;
+  const nextSource = {
     ...source,
-    positions: source.positions.filter((position) => position.manuallyPlaced),
+    positions: source.positions.filter(keepsPosition),
   };
   const reconciled = reconcileResourceCanvasLayout(
-    manualSource,
+    nextSource,
     resources,
     topology,
   );
@@ -487,29 +558,29 @@ export function useProjectResourceCanvasLayout({
   }, []);
 
   const rebuildOptimisticLayout = useCallback(
-    (scopeEpoch: number, policy: AutomaticPositionPolicy) => {
+    (
+      scopeEpoch: number,
+      policy: AutomaticPositionPolicy,
+      organizeSections?: readonly ProjectResourceCanvasCategory[] | null,
+    ) => {
       const scope = scopeRef.current;
       if (scope.epoch !== scopeEpoch) {
-        return;
+        return null;
       }
       let next = reconcileLayout(
         persistedLayoutRef.current,
         resourcesRef.current,
         policy,
         topologyRef.current,
+        organizeSections,
       ).layout;
       for (const intent of writeQueueRef.current) {
         if (intent.scopeEpoch === scopeEpoch && intent.kind === 'manual') {
-          next = moveResourceCanvasPosition(
-            next,
-            intent.resourceId,
-            intent.section,
-            intent.x,
-            intent.y,
-          );
+          next = applyResourceCanvasPositionWrites(next, intent.positions);
         }
       }
       applyLayout(next);
+      return next;
     },
     [applyLayout],
   );
@@ -542,7 +613,7 @@ export function useProjectResourceCanvasLayout({
         scopeEpoch,
         resourceSignature: signature,
         conflictRetries,
-        rederive: false,
+        rederive: null,
       });
     }
     if (mountedRef.current) {
@@ -573,6 +644,10 @@ export function useProjectResourceCanvasLayout({
       return;
     }
 
+    const organizeSections =
+      intent.kind === 'resources' && intent.rederive?.kind === 'organize'
+        ? intent.rederive.sections
+        : undefined;
     const writePolicy =
       intent.kind === 'manual'
         ? MANUAL_WRITE_AUTOMATIC_POSITION_POLICY
@@ -584,41 +659,38 @@ export function useProjectResourceCanvasLayout({
       resourcesRef.current,
       writePolicy,
       topologyRef.current,
+      organizeSections,
     );
-    if (intent.kind === 'resources' && !reconciled.changed) {
-      removeWriteIntent(intent);
-      rebuildOptimisticLayout(scope.epoch, writePolicy);
-      void Promise.resolve().then(() => pumpWritesRef.current());
-      return;
-    }
+    /**
+     * 坐标真的没变就不落盘：`changed` 门对整理/自动同步是老口径，这一条补给它的是手动
+     * 一笔（多选拖动或撤销恢复）。判据含 `manuallyPlaced`——撤销整理恢复的正是"坐标相同、
+     * 但必须从自动标记回到手动标记"的那一批卡，那种情况必须照写。
+     */
+    const manualCandidate =
+      intent.kind === 'manual'
+        ? applyResourceCanvasPositionWrites(
+            reconciled.layout,
+            intent.positions,
+          )
+        : null;
+    const manualWritesAnything =
+      manualCandidate !== null &&
+      !automaticCoordinatesMatch(reconciled.layout, manualCandidate);
     if (
-      intent.kind === 'manual' &&
-      !reconciled.layout.positions.some(
-        (position) =>
-          position.resourceId === intent.resourceId &&
-          position.section === intent.section,
-      )
+      (intent.kind === 'resources' && !reconciled.changed) ||
+      (intent.kind === 'manual' && !manualWritesAnything)
     ) {
       removeWriteIntent(intent);
-      rebuildOptimisticLayout(scope.epoch, writePolicy);
+      rebuildOptimisticLayout(scope.epoch, writePolicy, organizeSections);
       void Promise.resolve().then(() => pumpWritesRef.current());
       return;
     }
-    const candidate =
-      intent.kind === 'manual'
-        ? moveResourceCanvasPosition(
-            reconciled.layout,
-            intent.resourceId,
-            intent.section,
-            intent.x,
-            intent.y,
-          )
-        : reconciled.layout;
+    const candidate = manualCandidate ?? reconciled.layout;
     const invoke = window.__TAURI__?.core?.invoke;
     if (!invoke) {
       persistedLayoutRef.current = candidate;
       removeWriteIntent(intent);
-      rebuildOptimisticLayout(scope.epoch, writePolicy);
+      rebuildOptimisticLayout(scope.epoch, writePolicy, organizeSections);
       const hasQueuedWrite = writeQueueRef.current.some(
         (queued) => queued.scopeEpoch === scope.epoch,
       );
@@ -637,7 +709,7 @@ export function useProjectResourceCanvasLayout({
       !layoutCoordinatesAreSafe(candidate)
     ) {
       removeWriteIntent(intent);
-      rebuildOptimisticLayout(scope.epoch, writePolicy);
+      rebuildOptimisticLayout(scope.epoch, writePolicy, organizeSections);
       if (intent.kind === 'manual') {
         redragRequiredScopeEpochRef.current = null;
       }
@@ -700,7 +772,8 @@ export function useProjectResourceCanvasLayout({
             redragRequiredScopeEpochRef.current = null;
             setNotice('布局已保存');
           } else if (intent.rederive) {
-            // 显式整理复用同一条提示：用户按了按钮，就必须看到"这次重算真的落盘了"。
+            // 显式整理与关系图首次就绪复用同一条提示：用户按了按钮，就必须看到
+            // "这次重算真的落盘了"。
             setNotice('布局已保存');
           }
           if (needsResourceSync) {
@@ -734,7 +807,11 @@ export function useProjectResourceCanvasLayout({
             setNotice('布局已在其他窗口更新');
           }
         }
-        rebuildOptimisticLayout(currentScope.epoch, writePolicy);
+        rebuildOptimisticLayout(
+          currentScope.epoch,
+          writePolicy,
+          organizeSections,
+        );
       })
       .catch((error: unknown) => {
         const currentScope = scopeRef.current;
@@ -747,7 +824,11 @@ export function useProjectResourceCanvasLayout({
           `[resource-canvas-layout] 布局保存失败：${describeResourceCanvasLayoutFailure(error)}`,
         );
         removeWriteIntent(intent);
-        rebuildOptimisticLayout(currentScope.epoch, writePolicy);
+        rebuildOptimisticLayout(
+          currentScope.epoch,
+          writePolicy,
+          organizeSections,
+        );
         if (intent.kind === 'manual') {
           redragRequiredScopeEpochRef.current = null;
         }
@@ -969,14 +1050,19 @@ export function useProjectResourceCanvasLayout({
     return () => window.clearTimeout(timeout);
   }, [notice]);
 
-  const commitPosition = useCallback(
-    (
-      resourceId: string,
-      section: ProjectResourceCanvasCategory,
-      x: number,
-      y: number,
-    ) => {
+  /**
+   * 手动坐标的批量写入口：多选拖动与撤销/重做都只调用一次，整批卡排成**一笔** CAS。
+   *
+   * 队列里同一张卡（`resourceId + section`）的重复写入就地覆盖——最后落点赢，同一次操作
+   * 里的中间态不需要逐笔排队；在途那笔之后的新写入仍排在它后面（沿用既有顺序语义）。
+   * 乐观视图按同一批写入立即更新，失败/冲突仍走既有 `notice` 与恢复分支。
+   */
+  const commitPositions = useCallback(
+    (writes: readonly ResourceCanvasPositionWrite[]) => {
       const scope = scopeRef.current;
+      if (writes.length === 0) {
+        return;
+      }
       if (
         scope.key !== scopeKey ||
         !initializationReady ||
@@ -988,38 +1074,38 @@ export function useProjectResourceCanvasLayout({
         (intent): intent is ManualLayoutWriteIntent =>
           intent.kind === 'manual' &&
           intent.scopeEpoch === scope.epoch &&
-          intent.resourceId === resourceId &&
-          intent.section === section &&
           intent !== activeWriteIntentRef.current,
       );
       if (queuedIntent) {
-        queuedIntent.x = x;
-        queuedIntent.y = y;
+        mergeResourceCanvasPositionWrites(queuedIntent.positions, writes);
       } else {
         writeQueueRef.current.push({
           kind: 'manual',
           scopeEpoch: scope.epoch,
-          resourceId,
-          section,
-          x,
-          y,
+          positions: [...writes],
         });
       }
-      applyLayout(
-        moveResourceCanvasPosition(
-          layoutRef.current,
-          resourceId,
-          section,
-          x,
-          y,
-        ),
-      );
+      applyLayout(applyResourceCanvasPositionWrites(layoutRef.current, writes));
       setSaving(true);
       pumpWritesRef.current();
     },
     [applyLayout, initializationReady, scopeKey],
   );
 
+  /** 单卡手动落点的既有入口：等价于一笔只含这张卡、且标记手动摆放的批量写入。 */
+  const commitPosition = useCallback(
+    (
+      resourceId: string,
+      section: ProjectResourceCanvasCategory,
+      x: number,
+      y: number,
+    ) =>
+      commitPositions([
+        { resourceId, section, x, y, manuallyPlaced: true },
+      ]),
+    [commitPositions],
+  );
+
   /**
    * 显式「整理画布」：丢掉全部自动坐标、按当前资源与拓扑重算一次；坐标确有变化时写回
    * sidecar（沿用既有 `changed` 门），画布本身先乐观按重算结果显示。
@@ -1041,19 +1127,20 @@ export function useProjectResourceCanvasLayout({
       (intent): intent is ResourceLayoutWriteIntent =>
         intent.kind === 'resources' &&
         intent.scopeEpoch === scope.epoch &&
-        intent.rederive &&
+        intent.rederive !== null &&
         intent !== activeWriteIntentRef.current,
     );
     if (queued) {
       queued.resourceSignature = resourceSignatureRef.current;
       queued.conflictRetries = 0;
+      queued.rederive = { kind: 'automatic' };
     } else {
       writeQueueRef.current.push({
         kind: 'resources',
         scopeEpoch: scope.epoch,
         resourceSignature: resourceSignatureRef.current,
         conflictRetries: 0,
-        rederive: true,
+        rederive: { kind: 'automatic' },
       });
     }
     // 乐观视图：立刻把重算结果显示出来，别让用户以为按钮没反应。
@@ -1062,6 +1149,65 @@ export function useProjectResourceCanvasLayout({
     pumpWritesRef.current();
   }, [initializationReady, rebuildOptimisticLayout, scopeKey]);
 
+  /**
+   * 显式「整理画布」：重排给定栏目内的**全部**素材（含手动摆放过的卡），结果一律落成自动
+   * 坐标；`sections` 为 `null` 表示「所有资源」页——当前项目全部可展示素材。
+   *
+   * 与自动同步、关系图首次就绪共用同一条写队列与 CAS 写链，只是重算前的取舍不同；可见反馈
+   * 继续由既有 `notice` / `saving` 承担。历史快照与撤销由调用方（工作台）在按下时先记一笔，
+   * 本 hook 不新增业务状态。
+   *
+   * 返回 `false` 表示这一按在画面上什么都不会变（已经整齐、也没有需要转成自动的手动标记）：
+   * 既不排队写、也不给调用方记历史的理由——否则"连按两下"会压进一条什么都不会做的撤销点，
+   * 用户按一次撤销看起来毫无反应。
+   */
+  const organizeNow = useCallback(
+    (sections: readonly ProjectResourceCanvasCategory[] | null) => {
+      const scope = scopeRef.current;
+      if (
+        scope.key !== scopeKey ||
+        !initializationReady ||
+        initializedScopeEpochRef.current !== scope.epoch
+      ) {
+        return false;
+      }
+      if (sections !== null && sections.length === 0) {
+        return false;
+      }
+      // 先按同一套重算看结果：与当前画面逐值相同（含手动标记）就什么都不做。
+      const previous = layoutRef.current;
+      const next = rebuildOptimisticLayout(scope.epoch, 'rederive', sections);
+      if (!next || positionsEqual(previous.positions, next.positions)) {
+        return false;
+      }
+      const queued = writeQueueRef.current.find(
+        (intent): intent is ResourceLayoutWriteIntent =>
+          intent.kind === 'resources' &&
+          intent.scopeEpoch === scope.epoch &&
+          intent.rederive !== null &&
+          intent !== activeWriteIntentRef.current,
+      );
+      if (queued) {
+        queued.resourceSignature = resourceSignatureRef.current;
+        queued.conflictRetries = 0;
+        queued.rederive = { kind: 'organize', sections };
+      } else {
+        writeQueueRef.current.push({
+          kind: 'resources',
+          scopeEpoch: scope.epoch,
+          resourceSignature: resourceSignatureRef.current,
+          conflictRetries: 0,
+          rederive: { kind: 'organize', sections },
+        });
+      }
+      // 乐观视图已经在上面的重算里落到画布上（筛选、可见性都不参与，重算的是全量资源）。
+      setSaving(true);
+      pumpWritesRef.current();
+      return true;
+    },
+    [initializationReady, rebuildOptimisticLayout, scopeKey],
+  );
+
   const scopeMatches =
     initializationReady &&
     scopeRef.current.key === scopeKey &&
@@ -1093,6 +1239,29 @@ export function useProjectResourceCanvasLayout({
     readReport,
     scopeIdentity: scopeKey,
     commitPosition,
+    commitPositions,
     rederiveNow,
+    organizeNow,
   };
 }
+
+/**
+ * 合并同一张卡的重复手动写入：`resourceId + section` 是队列内的合并键，后来的写入覆盖先前
+ * 的坐标与手动标记。不同卡各自保留，因此一次多选拖动始终只是**一笔**待写。
+ */
+function mergeResourceCanvasPositionWrites(
+  target: ResourceCanvasPositionWrite[],
+  writes: readonly ResourceCanvasPositionWrite[],
+) {
+  for (const write of writes) {
+    const index = target.findIndex(
+      (entry) =>
+        entry.resourceId === write.resourceId && entry.section === write.section,
+    );
+    if (index >= 0) {
+      target[index] = write;
+    } else {
+      target.push(write);
+    }
+  }
+}
diff --git a/apps/ai-game-creator-shell/tests/resourceCanvasHistoryModel.test.ts b/apps/ai-game-creator-shell/tests/resourceCanvasHistoryModel.test.ts
index 851426e14..8445385dc 100644
--- a/apps/ai-game-creator-shell/tests/resourceCanvasHistoryModel.test.ts
+++ b/apps/ai-game-creator-shell/tests/resourceCanvasHistoryModel.test.ts
@@ -10,6 +10,7 @@ import {
   pushResourceCanvasHistory,
   redoResourceCanvasHistory,
   resolveResourceCanvasRestoreEntries,
+  resourceCanvasSnapshotsEqual,
   undoResourceCanvasHistory,
 } from '../src/features/resource-canvas/resourceCanvasHistoryModel';
 
@@ -155,6 +156,54 @@ describe('resource canvas history model', () => {
     expect(restore.map((entry) => entry.resourceId)).toEqual(['asset:b']);
   });
 
+  it('坐标完全相同但手动标记不同，仍算两次不同的布局', () => {
+    const manual = captureResourceCanvasSnapshot(
+      positions([['asset:a', 10, 20, true]]),
+    );
+    const automatic = captureResourceCanvasSnapshot(
+      positions([['asset:a', 10, 20, false]]),
+    );
+
+    expect(resourceCanvasSnapshotsEqual(manual, automatic)).toBe(false);
+    const history = pushResourceCanvasHistory(createResourceCanvasHistory(), {
+      label: '整理画布',
+      snapshot: manual,
+    });
+    expect(
+      pushResourceCanvasHistory(history, {
+        label: '整理画布',
+        snapshot: automatic,
+      }).undoStack,
+    ).toHaveLength(2);
+  });
+
+  it('坐标一致但手动标记不同时，撤销仍然回写这条标记', () => {
+    const snapshot = captureResourceCanvasSnapshot(
+      positions([
+        ['asset:a', 10, 20, true],
+        ['asset:b', 30, 40, false],
+      ]),
+    );
+    const restore = resolveResourceCanvasRestoreEntries(
+      snapshot,
+      positions([
+        // 整理画布之后：坐标没变，但标记从手动变成了自动。
+        ['asset:a', 10, 20, false],
+        ['asset:b', 30, 40, false],
+      ]),
+    );
+
+    expect(restore).toEqual([
+      {
+        resourceId: 'asset:a',
+        section: 'document',
+        x: 10,
+        y: 20,
+        manuallyPlaced: true,
+      },
+    ]);
+  });
+
   it('快照里不存在的资源不会在撤销时被新建出来', () => {
     const snapshot = captureResourceCanvasSnapshot(
       positions([['asset:deleted', 10, 20]]),
diff --git a/apps/ai-game-creator-shell/tests/resourceCanvasManualLayout.test.tsx b/apps/ai-game-creator-shell/tests/resourceCanvasManualLayout.test.tsx
index e1de7b91e..dff9a10a1 100644
--- a/apps/ai-game-creator-shell/tests/resourceCanvasManualLayout.test.tsx
+++ b/apps/ai-game-creator-shell/tests/resourceCanvasManualLayout.test.tsx
@@ -340,13 +340,28 @@ afterEach(() => {
   vi.restoreAllMocks();
 });
 
+const POINTER_WORKBENCH_PROJECT_ID = 'pointer-workbench';
+const POINTER_WORKBENCH_PATH = '/tmp/pointer-workbench';
+
 async function mountPointerWorkbench(
   target: 'main' | 'character' | 'all' = 'character',
+  options: {
+    assets?: AssetFixture[];
+    /** 每个排序模式一份持久化坐标：`{mode}` 传具体模式名（`dependency` / `type`）。 */
+    layoutByMode?: Record<string, ProjectResourceCanvasPosition[]>;
+  } = {},
 ) {
-  const projectId = 'pointer-workbench';
-  const projectPath = '/tmp/pointer-workbench';
+  const projectId = POINTER_WORKBENCH_PROJECT_ID;
+  const projectPath = POINTER_WORKBENCH_PATH;
+  const layoutByScope = Object.fromEntries(
+    Object.entries(options.layoutByMode ?? {}).map(([mode, positions]) => [
+      `${projectPath}|${mode}`,
+      positions,
+    ]),
+  );
   const tauri = installLayoutTauri({
     projectIdsByPath: { [projectPath]: projectId },
+    layoutByScope,
   });
   render(
     <LayoutWorkbench
@@ -354,7 +369,7 @@ async function mountPointerWorkbench(
         {
           projectId,
           projectPath,
-          assets: [
+          assets: options.assets ?? [
             pngAsset('pointer-a', 'a.png'),
             pngAsset('pointer-b', 'b.png'),
           ],
@@ -990,7 +1005,7 @@ describe('资源画布手动重排口径', () => {
     expect(tauri.unexpectedCommands).toEqual([]);
   });
 
-  it('「整理画布」按 rederive 重算自动坐标、保留手动坐标，并给出一次可见反馈', async () => {
+  it('「整理画布」重排当前栏目全部素材（含手动卡）成自动坐标，一次撤销恢复坐标与手动标记', async () => {
     const projectPath = '/tmp/manual-rederive-button-project';
     const tauri = installLayoutTauri({
       projectIdsByPath: {
@@ -1048,16 +1063,17 @@ describe('资源画布手动重排口径', () => {
         expect.objectContaining({
           resourceId: 'asset:asset-art-b',
           section: 'character',
-          x: 0,
+          x: 196,
           y: 0,
           manuallyPlaced: false,
         }),
+        // 手动摆放过的卡也在整理范围内：坐标重算、手动标记转成自动。
         expect.objectContaining({
           resourceId: 'asset:asset-art-a',
           section: 'character',
-          x: 600,
-          y: 40,
-          manuallyPlaced: true,
+          x: 0,
+          y: 0,
+          manuallyPlaced: false,
         }),
       ]),
     );
@@ -1068,6 +1084,28 @@ describe('资源画布手动重排口径', () => {
     fireEvent.click(screen.getByRole('button', { name: '整理画布' }));
     await settleFocusChain();
     expect(typeWrites(tauri)).toHaveLength(1);
+
+    // 一次撤销还原整理前的坐标**与手动标记**：整次整理只是一笔可撤销操作。
+    fireEvent.keyDown(window, { key: 'z', ctrlKey: true });
+    await waitFor(() => expect(typeWrites(tauri)).toHaveLength(2));
+    expect(typeWrites(tauri)[1]!.positions).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          resourceId: 'asset:asset-art-a',
+          section: 'character',
+          x: 600,
+          y: 40,
+          manuallyPlaced: true,
+        }),
+        expect.objectContaining({
+          resourceId: 'asset:asset-art-b',
+          section: 'character',
+          x: 800,
+          y: 800,
+          manuallyPlaced: false,
+        }),
+      ]),
+    );
   });
 
   it('「整理画布」不属于「资源排列方式」这组模式切换，而是一枚资源动作按钮', async () => {
@@ -1225,3 +1263,565 @@ describe('资源画布手动重排口径', () => {
     expect(single).not.toBe(doubled);
   });
 });
+
+/**
+ * 多选批量移动、整理范围与取消/切项目边界的画布级验收。
+ *
+ * 口径：拖动已选卡按统一位移移动整个选择集；拖动未选卡保持单选；松手一次提交、一次撤销；
+ * 取消/失焦/切项目不留下半截位移；整理只作用于当前栏目（筛选不缩小集合），其他栏目不变。
+ */
+describe('资源画布多选拖动与整理范围', () => {
+  function writePositionsById(write: LayoutWrite) {
+    return new Map(
+      write.positions.map((position) => [position.resourceId, position]),
+    );
+  }
+
+  function cardIn(manager: HTMLElement, resourceId: string) {
+    return manager.querySelector<HTMLElement>(
+      `.is-expanded .game-resource-card[data-resource-card-id="${resourceId}"]`,
+    )!;
+  }
+
+  /**
+   * type 侧的持久化坐标：两张角色卡摆在互为上下的相对位置上，整理后槽位可预测
+   * （第一槽 0,0 / 第二槽 196,0）。
+   */
+  const twoCharacterCards: ProjectResourceCanvasPosition[] = [
+    {
+      resourceId: 'asset:pointer-a',
+      section: 'character',
+      x: 0,
+      y: 0,
+      manuallyPlaced: false,
+    },
+    {
+      resourceId: 'asset:pointer-b',
+      section: 'character',
+      x: 400,
+      y: 300,
+      manuallyPlaced: false,
+    },
+  ];
+
+  async function selectTwoCharacterCards(
+    manager: HTMLElement,
+    tauri: FakeTauri,
+  ) {
+    // 打开角色与对象栏目页并切到「按类型」：type 侧坐标可预测，写入也走同一套写队列。
+    fireEvent.click(screen.getByRole('button', { name: '按类型' }));
+    const cardA = cardIn(manager, 'asset:pointer-a');
+    const cardB = cardIn(manager, 'asset:pointer-b');
+    fireEvent.click(cardA);
+    fireEvent.click(cardB, { shiftKey: true });
+    await waitFor(() =>
+      expect(new Set(selectedResourceIdsInDom())).toEqual(
+        new Set(['asset:pointer-a', 'asset:pointer-b']),
+      ),
+    );
+    expect(typeWrites(tauri)).toEqual([]);
+    return { cardA, cardB };
+  }
+
+  it('拖动已选卡整批等位移、一笔提交、一次撤销，多选保持', async () => {
+    const { manager, viewport, tauri } = await mountPointerWorkbench('character', {
+      layoutByMode: { type: twoCharacterCards },
+    });
+    const { cardA, cardB } = await selectTwoCharacterCards(manager, tauri);
+    const scale = viewport()[2]!;
+    expect(scale).toBeGreaterThan(0);
+
+    fireEvent.pointerDown(cardB, {
+      pointerId: 41,
+      button: 0,
+      clientX: 100,
+      clientY: 100,
+    });
+    fireEvent.pointerMove(cardB, {
+      pointerId: 41,
+      buttons: 1,
+      clientX: 180,
+      clientY: 140,
+    });
+    fireEvent.pointerUp(cardB, {
+      pointerId: 41,
+      button: 0,
+      clientX: 180,
+      clientY: 140,
+    });
+
+    // 松手只提交一笔：整批卡在同一次 CAS 里落盘。
+    await waitFor(() => expect(typeWrites(tauri)).toHaveLength(1));
+    const after = writePositionsById(typeWrites(tauri)[0]!);
+    const deltaX = Math.round(80 / scale);
+    const deltaY = Math.round(40 / scale);
+    expect(after.get('asset:pointer-a')).toEqual({
+      resourceId: 'asset:pointer-a',
+      section: 'character',
+      x: 0 + deltaX,
+      y: 0 + deltaY,
+      manuallyPlaced: true,
+    });
+    expect(after.get('asset:pointer-b')).toEqual({
+      resourceId: 'asset:pointer-b',
+      section: 'character',
+      x: Math.round(400 + 80 / scale),
+      y: Math.round(300 + 40 / scale),
+      manuallyPlaced: true,
+    });
+    // 相对位置保持原样（等位移）。
+    expect(
+      after.get('asset:pointer-b')!.x - after.get('asset:pointer-a')!.x,
+    ).toBe(400);
+    expect(
+      after.get('asset:pointer-b')!.y - after.get('asset:pointer-a')!.y,
+    ).toBe(300);
+    // 拖动已选卡不丢多选。
+    expect(new Set(selectedResourceIdsInDom())).toEqual(
+      new Set(['asset:pointer-a', 'asset:pointer-b']),
+    );
+
+    // 一次撤销把整批带回拖动前的坐标。
+    fireEvent.keyDown(window, { key: 'z', ctrlKey: true });
+    await waitFor(() => expect(typeWrites(tauri)).toHaveLength(2));
+    const restored = writePositionsById(typeWrites(tauri)[1]!);
+    expect(restored.get('asset:pointer-a')).toMatchObject({
+      x: 0,
+      y: 0,
+      manuallyPlaced: false,
+    });
+    expect(restored.get('asset:pointer-b')).toMatchObject({
+      x: 400,
+      y: 300,
+      manuallyPlaced: false,
+    });
+  });
+
+  it('不同缩放下多选位移按 scale 换算', async () => {
+    const { manager, viewport, tauri } = await mountPointerWorkbench('character', {
+      layoutByMode: { type: twoCharacterCards },
+    });
+    const { cardB } = await selectTwoCharacterCards(manager, tauri);
+
+    const before = viewport()[2]!;
+    fireEvent.click(screen.getByRole('button', { name: '放大画布' }));
+    fireEvent.click(screen.getByRole('button', { name: '放大画布' }));
+    const scale = viewport()[2]!;
+    expect(scale).toBeGreaterThan(before);
+
+    fireEvent.pointerDown(cardB, {
+      pointerId: 42,
+      button: 0,
+      clientX: 100,
+      clientY: 100,
+    });
+    fireEvent.pointerMove(cardB, {
+      pointerId: 42,
+      buttons: 1,
+      clientX: 200,
+      clientY: 150,
+    });
+    fireEvent.pointerUp(cardB, {
+      pointerId: 42,
+      button: 0,
+      clientX: 200,
+      clientY: 150,
+    });
+
+    await waitFor(() => expect(typeWrites(tauri)).toHaveLength(1));
+    const after = writePositionsById(typeWrites(tauri)[0]!);
+    expect(after.get('asset:pointer-a')).toMatchObject({
+      x: Math.round(100 / scale),
+      y: Math.round(50 / scale),
+    });
+    expect(after.get('asset:pointer-b')).toMatchObject({
+      x: Math.round(400 + 100 / scale),
+      y: Math.round(300 + 50 / scale),
+    });
+    // 屏幕位移相同、坐标位移被 scale 收窄：不是按像素直接落盘。
+    expect(
+      after.get('asset:pointer-a')!.x - after.get('asset:pointer-a')!.y,
+    ).not.toBe(50);
+  });
+
+  it('拖动未选中的卡保持单选语义：只有它自己动', async () => {
+    const { manager, viewport, tauri } = await mountPointerWorkbench('character', {
+      layoutByMode: { type: twoCharacterCards },
+    });
+    fireEvent.click(screen.getByRole('button', { name: '按类型' }));
+    const cardA = cardIn(manager, 'asset:pointer-a');
+    const cardB = cardIn(manager, 'asset:pointer-b');
+    fireEvent.click(cardA);
+    expect(selectedResourceIdsInDom()).toEqual(['asset:pointer-a']);
+    const scale = viewport()[2]!;
+
+    fireEvent.pointerDown(cardB, {
+      pointerId: 43,
+      button: 0,
+      clientX: 100,
+      clientY: 100,
+    });
+    fireEvent.pointerMove(cardB, {
+      pointerId: 43,
+      buttons: 1,
+      clientX: 180,
+      clientY: 120,
+    });
+    fireEvent.pointerUp(cardB, {
+      pointerId: 43,
+      button: 0,
+      clientX: 180,
+      clientY: 120,
+    });
+
+    await waitFor(() => expect(typeWrites(tauri)).toHaveLength(1));
+    const after = writePositionsById(typeWrites(tauri)[0]!);
+    expect(after.get('asset:pointer-a')).toMatchObject({ x: 0, y: 0 });
+    expect(after.get('asset:pointer-b')).toMatchObject({
+      x: Math.round(400 + 80 / scale),
+      y: Math.round(300 + 20 / scale),
+    });
+  });
+
+  it.each(['cancel', 'capture', 'blur'] as const)(
+    '%s 取消多选拖动：不落盘、坐标回到拖动前、选择保留',
+    async (reason) => {
+      const { manager, tauri } = await mountPointerWorkbench('character', {
+        layoutByMode: { type: twoCharacterCards },
+      });
+      const { cardB } = await selectTwoCharacterCards(manager, tauri);
+      const cardARoot = cardIn(manager, 'asset:pointer-a');
+
+      fireEvent.pointerDown(cardB, {
+        pointerId: 44,
+        button: 0,
+        clientX: 100,
+        clientY: 100,
+      });
+      fireEvent.pointerMove(cardB, {
+        pointerId: 44,
+        buttons: 1,
+        clientX: 260,
+        clientY: 220,
+      });
+      // 拖动中整批卡先跟指针走。
+      expect(cardIn(manager, 'asset:pointer-b').className).toContain(
+        'is-dragging',
+      );
+      expect(cardARoot.className).toContain('is-dragging');
+
+      if (reason === 'cancel') {
+        fireEvent.pointerCancel(cardB, { pointerId: 44 });
+      } else if (reason === 'capture') {
+        fireEvent.lostPointerCapture(cardB, { pointerId: 44 });
+      } else {
+        act(() => window.dispatchEvent(new Event('blur')));
+      }
+      await settleFocusChain();
+
+      expect(typeWrites(tauri)).toEqual([]);
+      // 预览已丢掉：卡片回到拖动前的位置（不再带拖动态）。
+      expect(cardIn(manager, 'asset:pointer-b').className).not.toContain(
+        'is-dragging',
+      );
+      expect(cardARoot.className).not.toContain('is-dragging');
+      expect(new Set(selectedResourceIdsInDom())).toEqual(
+        new Set(['asset:pointer-a', 'asset:pointer-b']),
+      );
+    },
+  );
+
+  it('整理只重排当前栏目，其他栏目坐标与手动标记不变', async () => {
+    const { manager, tauri } = await mountPointerWorkbench('character', {
+      assets: [
+        pngAsset('pointer-a', 'a.png'),
+        pngAsset('pointer-b', 'b.png'),
+        { ...pngAsset('scene-c', 'scene-c.png'), category: 'scene', kind: 'scene' },
+      ],
+      layoutByMode: {
+        type: [
+          ...twoCharacterCards,
+          {
+            resourceId: 'asset:scene-c',
+            section: 'scene',
+            x: 30,
+            y: 60,
+            manuallyPlaced: true,
+          },
+        ],
+      },
+    });
+    fireEvent.click(screen.getByRole('button', { name: '按类型' }));
+    await waitFor(() =>
+      expect(cardIn(manager, 'asset:pointer-b')).not.toBeNull(),
+    );
+    await settleFocusChain();
+
+    fireEvent.click(screen.getByRole('button', { name: '整理画布' }));
+
+    await waitFor(() => expect(typeWrites(tauri)).toHaveLength(1));
+    const after = writePositionsById(typeWrites(tauri)[0]!);
+    // 当前栏目：两张角色卡一起重算成自动坐标。
+    expect(after.get('asset:pointer-a')).toMatchObject({
+      x: 0,
+      y: 0,
+      manuallyPlaced: false,
+    });
+    expect(after.get('asset:pointer-b')).toMatchObject({
+      x: 196,
+      y: 0,
+      manuallyPlaced: false,
+    });
+    // 其他栏目：坐标与手动标记逐值不动。
+    expect(after.get('asset:scene-c')).toEqual({
+      resourceId: 'asset:scene-c',
+      section: 'scene',
+      x: 30,
+      y: 60,
+      manuallyPlaced: true,
+    });
+  });
+
+  it('筛选不缩小整理集合：被搜索隐藏的同栏目素材同样参与重排', async () => {
+    const { manager, tauri } = await mountPointerWorkbench('character', {
+      layoutByMode: { type: twoCharacterCards },
+    });
+    fireEvent.click(screen.getByRole('button', { name: '按类型' }));
+    await waitFor(() =>
+      expect(cardIn(manager, 'asset:pointer-b')).not.toBeNull(),
+    );
+    const search = openResourceFilterPanel();
+    fireEvent.change(search, { target: { value: 'a.png' } });
+    // 被搜索挡住的第二张卡在画布上不可交互（宿主机标记 aria-hidden），但仍在当前栏目里。
+    const hiddenCardHost = () =>
+      cardIn(manager, 'asset:pointer-b').closest(
+        '.game-resource-book-scene-card',
+      )!;
+    await waitFor(() =>
+      expect(hiddenCardHost().getAttribute('aria-hidden')).toBe('true'),
+    );
+
+    fireEvent.click(screen.getByRole('button', { name: '整理画布' }));
+
+    await waitFor(() => expect(typeWrites(tauri)).toHaveLength(1));
+    const after = writePositionsById(typeWrites(tauri)[0]!);
+    expect(after.get('asset:pointer-a')).toMatchObject({
+      x: 0,
+      y: 0,
+      manuallyPlaced: false,
+    });
+    expect(after.get('asset:pointer-b')).toMatchObject({
+      x: 196,
+      y: 0,
+      manuallyPlaced: false,
+    });
+  });
+
+  it('「所有资源」页整理全部栏目的可展示素材，手动坐标一并重算且只写一笔', async () => {
+    const { manager, tauri } = await mountPointerWorkbench('all', {
+      assets: [
+        pngAsset('pointer-a', 'a.png'),
+        pngAsset('pointer-b', 'b.png'),
+        {
+          ...pngAsset('scene-c', 'scene-c.png'),
+          category: 'scene',
+          kind: 'scene',
+        },
+        { ...markdownAsset('doc-d', 'd.md'), category: 'document' },
+      ],
+      layoutByMode: {
+        type: [
+          {
+            resourceId: 'asset:pointer-a',
+            section: 'character',
+            x: 500,
+            y: 500,
+            manuallyPlaced: true,
+          },
+          {
+            resourceId: 'asset:pointer-b',
+            section: 'character',
+            x: 400,
+            y: 300,
+            manuallyPlaced: false,
+          },
+          {
+            resourceId: 'asset:scene-c',
+            section: 'scene',
+            x: 30,
+            y: 60,
+            manuallyPlaced: true,
+          },
+          {
+            resourceId: 'asset:doc-d',
+            section: 'document',
+            x: 700,
+            y: 700,
+            manuallyPlaced: false,
+          },
+        ],
+      },
+    });
+    fireEvent.click(screen.getByRole('button', { name: '按类型' }));
+    await waitFor(() =>
+      expect(cardIn(manager, 'asset:pointer-b')).not.toBeNull(),
+    );
+    await settleFocusChain();
+    // 读盘那一次「归并 / 规范化」写回与本次要验的整理是两回事，先等它落地再记账。
+    const writesBeforeOrganize = typeWrites(tauri).length;
+
+    fireEvent.click(screen.getByRole('button', { name: '整理画布' }));
+
+    // 「所有资源」＝ 当前项目全部可展示素材，一次整理仍然只写一笔。
+    await waitFor(() =>
+      expect(typeWrites(tauri)).toHaveLength(writesBeforeOrganize + 1),
+    );
+    const after = writePositionsById(typeWrites(tauri).at(-1)!);
+    // 每个栏目各自重算成自动槽位：同栏目第二张卡落在 196,0，跨栏目互不影响。
+    expect(after.get('asset:pointer-a')).toMatchObject({
+      section: 'character',
+      x: 0,
+      y: 0,
+      manuallyPlaced: false,
+    });
+    expect(after.get('asset:pointer-b')).toMatchObject({
+      section: 'character',
+      x: 196,
+      y: 0,
+      manuallyPlaced: false,
+    });
+    expect(after.get('asset:scene-c')).toMatchObject({
+      section: 'scene',
+      x: 0,
+      y: 0,
+      manuallyPlaced: false,
+    });
+    expect(after.get('asset:doc-d')).toMatchObject({
+      section: 'document',
+      x: 0,
+      y: 0,
+      manuallyPlaced: false,
+    });
+  });
+
+  it('切项目清空选择并丢弃进行中的拖动，不把位移写进新项目', async () => {
+    const projectPathA = '/tmp/multi-drag-project-a';
+    const projectPathB = '/tmp/multi-drag-project-b';
+    const tauri = installLayoutTauri({
+      projectIdsByPath: {
+        [projectPathA]: 'multi-drag-project-a',
+        [projectPathB]: 'multi-drag-project-b',
+      },
+      layoutByScope: {
+        [`${projectPathA}|type`]: twoCharacterCards,
+        [`${projectPathB}|type`]: [
+          {
+            resourceId: 'asset:project-b-1',
+            section: 'document',
+            x: 10,
+            y: 20,
+            manuallyPlaced: false,
+          },
+        ],
+      },
+    });
+    render(
+      <LayoutWorkbench
+        projects={[
+          {
+            projectId: 'multi-drag-project-a',
+            projectPath: '/tmp/multi-drag-project-a',
+            assets: [
+              pngAsset('pointer-a', 'a.png'),
+              pngAsset('pointer-b', 'b.png'),
+            ],
+          },
+          {
+            projectId: 'multi-drag-project-b',
+            projectPath: '/tmp/multi-drag-project-b',
+            assets: [
+              { ...markdownAsset('project-b-1', 'b-1.md'), kind: 'document' },
+            ],
+          },
+        ]}
+      />,
+    );
+    await settleFocusChain();
+    const manager = document.querySelector<HTMLElement>(
+      '.game-resource-book-manager',
+    )!;
+    vi.spyOn(manager, 'getBoundingClientRect').mockReturnValue({
+      x: 0,
+      y: 0,
+      left: 0,
+      top: 0,
+      right: 800,
+      bottom: 600,
+      width: 800,
+      height: 600,
+      toJSON: () => ({}),
+    } as DOMRect);
+    act(() => window.dispatchEvent(new Event('resize')));
+    fireEvent.click(screen.getByRole('button', { name: '按类型' }));
+    fireEvent.click(screen.getByRole('button', { name: '打开角色与对象' }));
+    await waitFor(() =>
+      expect(cardIn(manager, 'asset:pointer-b')).not.toBeNull(),
+    );
+    const cardA = cardIn(manager, 'asset:pointer-a');
+    const cardB = cardIn(manager, 'asset:pointer-b');
+    fireEvent.click(cardA);
+    fireEvent.click(cardB, { shiftKey: true });
+    await waitFor(() =>
+      expect(selectedResourceIdsInDom()).toHaveLength(2),
+    );
+
+    fireEvent.pointerDown(cardB, {
+      pointerId: 45,
+      button: 0,
+      clientX: 100,
+      clientY: 100,
+    });
+    fireEvent.pointerMove(cardB, {
+      pointerId: 45,
+      buttons: 1,
+      clientX: 300,
+      clientY: 240,
+    });
+
+    fireEvent.click(screen.getByRole('button', { name: '测试：切换项目' }));
+    await waitFor(() =>
+      expect(
+        tauri.layoutReads.some(
+          (read) => read.projectPath === projectPathB,
+        ),
+      ).toBe(true),
+    );
+    // 松手发生在切项目之后：位移不写进新项目。
+    fireEvent.pointerUp(cardB, {
+      pointerId: 45,
+      button: 0,
+      clientX: 300,
+      clientY: 240,
+    });
+    await settleFocusChain();
+
+    // 两个项目都没有留下拖动落点：没有任何一笔手动坐标。
+    for (const projectPath of [projectPathA, projectPathB]) {
+      const manualWrites = tauri.layoutWrites
+        .filter((write) => write.projectPath === projectPath)
+        .flatMap((write) => write.positions)
+        .filter((position) => position.manuallyPlaced);
+      expect(manualWrites).toEqual([]);
+    }
+    // 两个项目的 type 侧坐标逐值保持原样（拖动没有落盘，也没有跨项目串写）。
+    expect(
+      tauri.layoutWrites.filter(
+        (write) =>
+          write.mode === 'type' &&
+          (write.projectPath === projectPathA ||
+            write.projectPath === projectPathB),
+      ),
+    ).toEqual([]);
+    await waitFor(() => expect(selectedResourceIdsInDom()).toEqual([]));
+  });
+});
diff --git a/apps/ai-game-creator-shell/tests/useProjectResourceCanvasLayout.test.ts b/apps/ai-game-creator-shell/tests/useProjectResourceCanvasLayout.test.ts
index f00f6357b..54062db15 100644
--- a/apps/ai-game-creator-shell/tests/useProjectResourceCanvasLayout.test.ts
+++ b/apps/ai-game-creator-shell/tests/useProjectResourceCanvasLayout.test.ts
@@ -1546,3 +1546,375 @@ describe('布局落盘 / 读盘失败的原因不再被吞掉', () => {
     expect(logged[0]).not.toContain('\n');
   });
 });
+
+/**
+ * 「整理画布」与批量坐标写入的 hook 级口径。
+ *
+ * 整理只作用于目标栏目：栏内**全部**素材（含手动摆放过的卡）一起重算成自动坐标，其他栏目
+ * 逐值不动；整次整理仍是一笔 CAS。手动写入支持一次多张卡（含手动标记），因此多选拖动与
+ * 撤销恢复都不会退化成"每卡一笔"。
+ */
+describe('资源画布整理与批量坐标写入', () => {
+  function characterResource(id: string): ResourceCanvasItem {
+    return { ...resource(id), category: 'character' };
+  }
+
+  function typeLayoutHarness(initialPositions: ProjectResourceCanvasPosition[]) {
+    const updates: ProjectResourceCanvasPosition[][] = [];
+    const invoke = vi.fn(
+      async (command: string, args?: Record<string, unknown>) => {
+        if (command === 'read_local_project_resource_canvas_layout') {
+          return persistedLayout('type', 7, structuredClone(initialPositions));
+        }
+        if (command === 'update_local_project_resource_canvas_layout') {
+          const positions = structuredClone(
+            args?.positions as ProjectResourceCanvasPosition[],
+          );
+          updates.push(positions);
+          return {
+            status: 'updated',
+            layout: persistedLayout('type', 8, positions),
+          };
+        }
+        throw new Error(`unexpected invoke ${command}`);
+      },
+    );
+    window.__TAURI__ = { core: { invoke } };
+    return { invoke, updates };
+  }
+
+  /**
+   * 等读盘之后的协调写回彻底落地再清空记账：打开项目那次"归并 / 补位"写回与本次要验的
+   * 整理、多选写入是两回事，混在一起数笔数会把既有口径算成本次行为。
+   */
+  async function settleInitialWrites(
+    result: { current: { settled: boolean } },
+    updates: ProjectResourceCanvasPosition[][],
+  ) {
+    await waitFor(() => expect(result.current.settled).toBe(true));
+    updates.length = 0;
+  }
+
+  it('整理栏目时连手动坐标一起重算，其他栏目逐值不动', async () => {
+    const documentA = resource('resource-doc-a');
+    const documentB = { ...resource('resource-doc-b'), dependencyDepth: 1 };
+    const characterA = characterResource('resource-char-a');
+    const { updates } = typeLayoutHarness([
+      position('resource-doc-a', 600, 40),
+      automaticPosition('resource-doc-b', 900, 900),
+      { ...position('resource-char-a', 777, 55), section: 'character' },
+    ]);
+
+    const { result } = renderHook(() =>
+      useProjectResourceCanvasLayout({
+        projectPath,
+        projectId,
+        mode: 'type',
+        resources: [documentA, documentB, characterA],
+      }),
+    );
+    await settleInitialWrites(result, updates);
+
+    act(() => result.current.organizeNow(['document']));
+
+    await waitFor(() => expect(updates).toHaveLength(1));
+    expect(updates[0]).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          resourceId: 'resource-doc-a',
+          section: 'document',
+          x: 0,
+          y: 0,
+          manuallyPlaced: false,
+        }),
+        expect.objectContaining({
+          resourceId: 'resource-doc-b',
+          section: 'document',
+          x: 196,
+          y: 0,
+          manuallyPlaced: false,
+        }),
+        // 其他栏目：手动坐标与手动标记原样保留。
+        expect.objectContaining({
+          resourceId: 'resource-char-a',
+          section: 'character',
+          x: 777,
+          y: 55,
+          manuallyPlaced: true,
+        }),
+      ]),
+    );
+  });
+
+  it('整理不重排其他栏目的自动坐标：栏外坐标逐值原样保留', async () => {
+    const documentA = resource('resource-doc-a');
+    /**
+     * 其他栏目的自动卡故意放在「非规范槽位」上：这类坐标在真实项目里来自更早版本的排布、
+     * 或素材被删后留下的既有位置。整理当前栏目只允许丢**目标栏目**的坐标，因此这些卡
+     * 必须逐值保留，而不是被丢进重算后按空栏目规整回 (0,0)。
+     */
+    const characterA = characterResource('resource-char-auto-a');
+    const characterB = characterResource('resource-char-auto-b');
+    const { updates } = typeLayoutHarness([
+      position('resource-doc-a', 600, 40),
+      { ...automaticPosition('resource-char-auto-a', 900, 900), section: 'character' },
+      { ...automaticPosition('resource-char-auto-b', 1100, 940), section: 'character' },
+    ]);
+
+    const { result } = renderHook(() =>
+      useProjectResourceCanvasLayout({
+        projectPath,
+        projectId,
+        mode: 'type',
+        resources: [documentA, characterA, characterB],
+      }),
+    );
+    await settleInitialWrites(result, updates);
+
+    act(() => result.current.organizeNow(['document']));
+
+    await waitFor(() => expect(updates).toHaveLength(1));
+    expect(updates[0]).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          resourceId: 'resource-doc-a',
+          x: 0,
+          y: 0,
+          manuallyPlaced: false,
+        }),
+        expect.objectContaining({
+          resourceId: 'resource-char-auto-a',
+          section: 'character',
+          x: 900,
+          y: 900,
+          manuallyPlaced: false,
+        }),
+        expect.objectContaining({
+          resourceId: 'resource-char-auto-b',
+          section: 'character',
+          x: 1100,
+          y: 940,
+          manuallyPlaced: false,
+        }),
+      ]),
+    );
+  });
+
+  it('「所有资源」范围（null）整理全部栏目，不留下手动标记', async () => {
+    const documentA = resource('resource-doc-a');
+    const characterA = characterResource('resource-char-a');
+    const { updates } = typeLayoutHarness([
+      position('resource-doc-a', 600, 40),
+      { ...automaticPosition('resource-char-a', 900, 900), section: 'character' },
+    ]);
+
+    const { result } = renderHook(() =>
+      useProjectResourceCanvasLayout({
+        projectPath,
+        projectId,
+        mode: 'type',
+        resources: [documentA, characterA],
+      }),
+    );
+    await settleInitialWrites(result, updates);
+
+    act(() => result.current.organizeNow(null));
+
+    await waitFor(() => expect(updates).toHaveLength(1));
+    expect(updates[0]).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          resourceId: 'resource-doc-a',
+          section: 'document',
+          x: 0,
+          y: 0,
+          manuallyPlaced: false,
+        }),
+        expect.objectContaining({
+          resourceId: 'resource-char-a',
+          section: 'character',
+          x: 0,
+          y: 0,
+          manuallyPlaced: false,
+        }),
+      ]),
+    );
+  });
+
+  it('没有可整理栏目时不产生任何写入', async () => {
+    const documentA = resource('resource-doc-a');
+    const { updates } = typeLayoutHarness([position('resource-doc-a', 600, 40)]);
+
+    const { result } = renderHook(() =>
+      useProjectResourceCanvasLayout({
+        projectPath,
+        projectId,
+        mode: 'type',
+        resources: [documentA],
+      }),
+    );
+    await settleInitialWrites(result, updates);
+
+    await act(async () => {
+      result.current.organizeNow([]);
+      await Promise.resolve();
+    });
+
+    expect(updates).toEqual([]);
+    expect(result.current.saving).toBe(false);
+  });
+
+  it('批量手动写入只排一笔 CAS，并按下发的标记落盘', async () => {
+    const documentA = resource('resource-doc-a');
+    const documentB = resource('resource-doc-b');
+    const { invoke, updates } = typeLayoutHarness([
+      automaticPosition('resource-doc-a', 10, 20),
+      automaticPosition('resource-doc-b', 30, 40),
+    ]);
+
+    const { result } = renderHook(() =>
+      useProjectResourceCanvasLayout({
+        projectPath,
+        projectId,
+        mode: 'type',
+        resources: [documentA, documentB],
+      }),
+    );
+    await settleInitialWrites(result, updates);
+
+    await act(async () => {
+      result.current.commitPositions([
+        {
+          resourceId: 'resource-doc-a',
+          section: 'document',
+          x: 110,
+          y: 30,
+          manuallyPlaced: true,
+        },
+        {
+          resourceId: 'resource-doc-b',
+          section: 'document',
+          x: 210,
+          y: 60,
+          manuallyPlaced: false,
+        },
+      ]);
+      await Promise.resolve();
+    });
+
+    await waitFor(() => expect(updates).toHaveLength(1));
+    expect(
+      invoke.mock.calls.filter(
+        ([command]) =>
+          command === 'update_local_project_resource_canvas_layout',
+      ),
+    ).toHaveLength(1);
+    expect(updates[0]).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          resourceId: 'resource-doc-a',
+          x: 110,
+          y: 30,
+          manuallyPlaced: true,
+        }),
+        expect.objectContaining({
+          resourceId: 'resource-doc-b',
+          x: 210,
+          y: 60,
+          manuallyPlaced: false,
+        }),
+      ]),
+    );
+  });
+
+  it('只有手动标记变化（撤销整理）时仍然落盘，完全没变化时不写', async () => {
+    const documentA = resource('resource-doc-a');
+    const { updates } = typeLayoutHarness([
+      automaticPosition('resource-doc-a', 10, 20),
+    ]);
+
+    const { result } = renderHook(() =>
+      useProjectResourceCanvasLayout({
+        projectPath,
+        projectId,
+        mode: 'type',
+        resources: [documentA],
+      }),
+    );
+    await settleInitialWrites(result, updates);
+
+    await act(async () => {
+      result.current.commitPositions([
+        {
+          resourceId: 'resource-doc-a',
+          section: 'document',
+          x: 10,
+          y: 20,
+          manuallyPlaced: false,
+        },
+      ]);
+      await Promise.resolve();
+    });
+    // 坐标与标记都没变：不产生无意义的一笔。
+    expect(updates).toEqual([]);
+
+    await act(async () => {
+      result.current.commitPositions([
+        {
+          resourceId: 'resource-doc-a',
+          section: 'document',
+          x: 10,
+          y: 20,
+          manuallyPlaced: true,
+        },
+      ]);
+      await Promise.resolve();
+    });
+    await waitFor(() => expect(updates).toHaveLength(1));
+    expect(updates[0]?.[0]).toMatchObject({
+      resourceId: 'resource-doc-a',
+      x: 10,
+      y: 20,
+      manuallyPlaced: true,
+    });
+  });
+
+  it('整理写入失败时保留失败提示，不伪报保存成功', async () => {
+    vi.spyOn(console, 'warn').mockImplementation(() => undefined);
+    const documentA = resource('resource-doc-a');
+    const invoke = vi.fn(async (command: string) => {
+      if (command === 'read_local_project_resource_canvas_layout') {
+        return persistedLayout('type', 7, [
+          position('resource-doc-a', 600, 40),
+        ]);
+      }
+      if (command === 'update_local_project_resource_canvas_layout') {
+        throw new Error('layout write rejected');
+      }
+      throw new Error(`unexpected invoke ${command}`);
+    });
+    window.__TAURI__ = { core: { invoke } };
+
+    const { result } = renderHook(() =>
+      useProjectResourceCanvasLayout({
+        projectPath,
+        projectId,
+        mode: 'type',
+        resources: [documentA],
+      }),
+    );
+    await waitFor(() => expect(result.current.ready).toBe(true));
+
+    act(() => result.current.organizeNow(['document']));
+
+    await waitFor(() =>
+      expect(result.current.notice).toBe('布局保存失败，已保留当前会话布局'),
+    );
+    expect(
+      invoke.mock.calls.filter(
+        ([command]) =>
+          command === 'update_local_project_resource_canvas_layout',
+      ),
+    ).toHaveLength(1);
+  });
+});