dsh-workspace-mover 2.1.1 → 2.3.0

package/client/client.js

@@ -20,7 +20,7 @@ window.__ModuleLoader__.load({
 				confirmTitle: "跨工作区移动会话",
 				target: "目标工作区",
 				session: "会话",
-				hint: "将物理搬移原始会话档案并改写归属；历史记录原样保留，不产生副本。",
+				hint: "将物理搬移原始会话档案并改写归属，历史记录原样保留。",
 				move: "移动",
 				cancel: "取消",
 				moving: "正在移动…",
@@ -28,7 +28,6 @@ window.__ModuleLoader__.load({
 				rolledBack: "已自动回滚：{msg}",
 				failed: "移动失败：{msg}",
 				noTarget: "无法识别目标工作区（侧边栏结构变化？）",
-				ungroupedUnsupported: "暂不支持移动到「未分组」",
 				staleList: "工作区列表与侧边栏不一致，请重试",
 				restartHint: "缓存失效失败：归属可能需要重启 Harness 后才刷新",
 				rescueSection: "会话修复",
@@ -53,11 +52,18 @@ window.__ModuleLoader__.load({
 				stalePath: "路径失效",
 				ungroupedBadge: "未归组",
 				unreadable: "无法读取",
+				unsupportedFormat: "当前格式不受支持",
+				layoutUnknown: "存储布局未知",
+				corruptData: "档案数据损坏或无法解析",
 				ghostsTitle: "名单里有、但文件已不在的记录",
 				ghostsHelp: "侧边栏的分组名单里记着这些会话，但对应的记录文件已经不在磁盘上（通常是被手动删除的）。一般不影响使用；重启 Harness 后通常会自动清理。",
 				helpPath: "会话原来的文件夹被移动、改名或删除，所以侧边栏看不到它。选择一个分组，历史会原样迁移过去，会话 ID 保持不变。",
 				helpUnreg: "会话文件完好，只是还没有归属到任何工作区分组。点击按钮即可归入匹配的分组，文件不会移动。",
 				pickTarget: "请先在下拉框选择要移入的分组",
+				idUnresolved: "无法识别要移动的会话（侧边栏结构或标题有变化），已取消本次移动。请刷新页面后重试。",
+				idUnresolvedPartial: "有 {n} 行无法识别，将被跳过——本次只移动能确认身份的会话。",
+				batchTooMany: "单次最多移动 {max} 个会话（本次 {n} 个）",
+				dragPayloadBad: "无法读取拖拽内容（宿主版本变化？），已取消本次移动",
 				relinkBtn: "移入该分组",
 				attachBtn: "归入分组",
 				relinked: "✓ 已迁入「{title}」，历史原样保留",
@@ -91,13 +97,13 @@ window.__ModuleLoader__.load({
 		batchUndoPartial: "；{n} 个未能撤回（可重试）",
 				pickHint: "已选 {n} 个会话 · Ctrl+点击行可多选 · 拖到目标工作区标题行批量移动 · Esc 清空",
 				pickCleared: "已清空多选",
-				pickEscHint: "按 Esc 清空多选（输入框聚焦时无效）",
 				groupMoveTitle: "把「{title}」的会话移到…",
 				groupMoveHint: "整组会话将真迁移到目标分组；运行中的会话会被跳过并在结果中说明。",
 				groupMoveEmpty: "这个分组下没有可移动的会话。",
 				openFolderMenu: "打开文件夹",
 				archivedCaption: "已归档的会话",
 				archivedHelp: "这些会话被官方「归档」后从侧边栏消失，但文件和分组归属都还在。点「恢复」回到原来的分组，或选「恢复到…」换一个分组；恢复不会动文件。",
+				archiveTruncated: "注意：扫描只解析了最新 {parsed} / {total} 个会话档案，较旧的归档会话可能不在此列表中。",
 				restoreBtn: "恢复",
 				restoreToBtn: "恢复到…",
 				restorePickTitle: "把「{title}」恢复到…",
@@ -121,12 +127,20 @@ window.__ModuleLoader__.load({
 				purgeAllBtn: "清空回收站",
 				purgeAllConfirm: "彻底删除回收站里的全部 {n} 个会话？此操作不可撤销。",
 				purgedMsg: "✓ 已彻底删除 {n} 项",
+				purgeBackupsToo: "这个会话还有 {n} 份迁移备份。一并删除吗？\n\n（会话已不存在，这些备份不会再被用到；保留则可在备份列表里单独恢复或清理。）",
+				purgeBackupsDone: "（含 {n} 份备份）",
 				backupsCaption: "备份",
-				backupsHelp: "每次迁移前自动生成的字节级备份都在这里。可以把会话恢复回备份时的原位置（若那里没有同 id 会话），或恢复到任意其他分组。",
-				backupMeta: "{n} 份 · {size} · {range}",
+				backupsHelp: "这里列出迁移恢复快照。相同会话内容只保留一份物理快照，但每次迁移仍会记录历史；可恢复到原位置或任意其他分组。",
+				backupMeta: "{n} 个快照 · {size} · {range}",
 				backupDeleteBtn: "删除备份",
 				backupDeleteConfirm: "删除「{title}」的 {n} 份备份？删除后无法再从备份恢复。",
 				backupDeletedMsg: "✓ 已删除 {n} 份备份",
+				backupOrphanBadge: "孤儿",
+				backupOrphanHelp: "这个会话的档案已经不存在了（通常是被彻底删除）。这些备份不会被任何操作再引用，可以安全清理。",
+				backupOrphanSummary: "孤儿备份：{n} 组 · {size}（会话已不存在）",
+				backupOrphanCleanup: "清理孤儿备份",
+				backupOrphanConfirm: "删除 {n} 组孤儿备份（{size}）？这些会话已不存在，删除后无法从备份恢复。",
+				backupOrphanPartial: "✓ 已删除 {n} 份，{f} 组失败（可重试）",
 				residentRefuse: "该会话当前没有焦点也可能仍驻留在 Harness 内存中（归档只隐藏，不会卸载）。DSH 0.1.5 没有公开的按 ID 卸载接口，请重启 Harness 释放常驻会话后再删除。",
 				sessionBusy: "该会话正在处理中（可能有迁移 / 还原 / 删除操作尚未完成），请稍后再试。",
 				contextStale: "插件上下文已失效（客户端热重载导致）。请刷新页面（或重启应用）后重试，功能会自动恢复。",
@@ -145,7 +159,13 @@ window.__ModuleLoader__.load({
 				doctorDataBackups: "备份目录",
 				doctorDataHistory: "移动历史",
 				doctorDataTasks: "任务记录",
+				doctorDataMigrations: "迁移队列",
 				doctorRecovery: "恢复记录",
+				doctorDataLayout: "存储布局",
+				doctorStorageAdapter: "存储适配器",
+				adapterFilesystemFallback: "当前 DSH 未提供原始档案路径接口，使用文件路径适配器；存储布局自检通过后可迁移。",
+				adapterOfficialHandle: "官方会话接口可用，但未提供原始档案路径，当前无法迁移档案目录。",
+				adapterUnavailable: "当前持久化服务缺少可用接口。",
 				doctorWorkspaces: "工作区路径",
 				repairAllBtn: "一键修复",
 				repairAllDone: "✓ 已修复 {n} · 跳过 {s} · 失败 {f}",
@@ -153,6 +173,39 @@ window.__ModuleLoader__.load({
 				filterPh: "筛选：标题 / 会话 ID / 路径…",
 				tasksCaption: "迁移任务",
 				tasksHelp: "批量迁移的持久化记录：完成 / 失败逐项可查。失败项可一键重试——按会话当前位置重新迁移，不会用记录里的旧路径；清除记录不影响已迁移的会话。",
+				queueCaption: "等待迁移",
+				queueHelp: "运行中的会话不会触碰文件；会话空闲后自动尝试，失败项可以重试或取消。",
+				queueRetryBtn: "重试",
+				queueRetryAllBtn: "重试全部失败项",
+				queueCancelBtn: "取消",
+				queueRetryDone: "✓ 已重新尝试迁移",
+				queueRetryAllDone: "✓ 已逐项重试 {n} 个失败任务",
+				queueCancelled: "✓ 已取消迁移任务",
+				queuedMove: "已排队：会话空闲后自动迁移",
+				batchQueuedTail: "；{n} 个会话已排队等待空闲",
+				previewStatus: "预览状态",
+				previewSource: "来源",
+				previewTarget: "目标路径",
+				previewBackup: "本次新增备份",
+				previewBackupReused: "复用已有快照，不新增磁盘占用",
+				previewBackupHelp: "迁移前保存恢复快照，用于失败回滚和备份恢复；相同会话内容会复用已有快照，主档案仍只移动一份。",
+				previewSameWorkspace: "会话已在目标工作区，无需移动。",
+				previewSelfHeal: "档案已在目标工作区，将补齐归属记录。",
+				previewRunning: "会话正在运行，将排队等待空闲。",
+				previewNoPhysicalPath: "当前 DSH 未提供原始档案路径，无法迁移档案目录。",
+				previewSourceMissing: "来源会话档案缺失或无法读取。",
+				previewCollision: "目标工作区已有同 ID 档案，已阻止覆盖。",
+				previewGenerations: "发现多个格式代际，选择 v{n} 并保留旧文件。",
+				previewDescendants: "已选择 {n} 个后代会话。",
+				forkMode: "分支范围",
+				forkCurrentOnly: "仅当前会话",
+				forkIncludeDescendants: "包含所有后代分支",
+				forkHint: "默认只迁移当前会话；选择后代分支会逐项迁移并独立记录结果。",
+				previewWarning: "提示",
+				previewSafe: "可安全移动",
+				previewQueued: "会进入空闲队列",
+				previewBlocked: "当前不可移动",
+				previewWarningState: "需要确认",
 				taskRetryBtn: "重试失败项",
 				taskRetryDone: "✓ 重试完成：成功 {n} · 失败 {f}",
 				taskForgetBtn: "清除记录",
@@ -167,7 +220,7 @@ window.__ModuleLoader__.load({
 				confirmTitle: "Move session across workspaces",
 				target: "Target workspace",
 				session: "Session",
-				hint: "Physically relocates the original session archive; history stays intact, no copy is made.",
+				hint: "Physically relocates the original session archive and updates its workspace; history stays intact.",
 				move: "Move",
 				cancel: "Cancel",
 				moving: "Moving…",
@@ -175,7 +228,6 @@ window.__ModuleLoader__.load({
 				rolledBack: "Rolled back automatically: {msg}",
 				failed: "Move failed: {msg}",
 				noTarget: "Cannot resolve target workspace (sidebar layout changed?)",
-				ungroupedUnsupported: "Moving to \"Ungrouped\" is not supported yet",
 				staleList: "Workspace list out of sync with the sidebar; try again",
 				restartHint: "Cache invalidation failed: grouping may need a harness restart",
 				rescueSection: "Session Repair",
@@ -200,11 +252,18 @@ window.__ModuleLoader__.load({
 				stalePath: "Stale path",
 				ungroupedBadge: "Ungrouped",
 				unreadable: "Unreadable",
+				unsupportedFormat: "Unsupported format",
+				layoutUnknown: "Unknown storage layout",
+				corruptData: "Archive data is damaged or cannot be parsed",
 				ghostsTitle: "Listed in groups but missing on disk",
 				ghostsHelp: "These sessions are still recorded in group rosters, but their files are gone from disk (usually deleted by hand). Harmless in general; a harness restart normally cleans them up.",
 				helpPath: "The folder this session lived in was moved, renamed or deleted, so the sidebar cannot show it. Pick a group — history moves over as-is and the session ID stays the same.",
 				helpUnreg: "The session file is fine but no workspace claims it yet. Click to file it into the matching group; files are not moved.",
 				pickTarget: "Pick a target group in the dropdown first",
+				idUnresolved: "Could not identify the session to move (sidebar structure or titles changed); this move was cancelled. Refresh the page and try again.",
+				idUnresolvedPartial: "{n} row(s) could not be identified and will be skipped — this move only carries the sessions whose identity was confirmed.",
+				batchTooMany: "At most {max} sessions per move (this one had {n})",
+				dragPayloadBad: "Could not read the dragged content (host version change?); this move was cancelled",
 				relinkBtn: "Move there",
 				attachBtn: "File into group",
 				relinked: "✓ Moved into \"{title}\"; history preserved as-is",
@@ -238,13 +297,13 @@ window.__ModuleLoader__.load({
 		batchUndoPartial: "; {n} not undone (retry available)",
 				pickHint: "{n} sessions picked · Ctrl+click rows to multi-select · drag onto a workspace header to move in bulk · Esc to clear",
 				pickCleared: "Selection cleared",
-				pickEscHint: "Press Esc to clear the multi-selection (not while typing in the composer)",
 				groupMoveTitle: "Move sessions of \"{title}\" to…",
 				groupMoveHint: "The whole group will be truly moved to the target; running sessions are skipped and noted in the result.",
 				groupMoveEmpty: "No movable sessions in this group.",
 				openFolderMenu: "Open folder",
 				archivedCaption: "Archived sessions",
 				archivedHelp: "These sessions were hidden by the official \"archive\" action, but their files and group membership are intact. \"Restore\" sends them back to the original group, or \"Restore to…\" picks another one; restoring never touches files.",
+				archiveTruncated: "Note: the scan parsed only the newest {parsed} of {total} session archives, so older archived sessions may be missing from this list.",
 				restoreBtn: "Restore",
 				restoreToBtn: "Restore to…",
 				restorePickTitle: "Restore \"{title}\" to…",
@@ -268,12 +327,20 @@ window.__ModuleLoader__.load({
 				purgeAllBtn: "Empty recycle bin",
 				purgeAllConfirm: "Purge all {n} sessions in the recycle bin? This cannot be undone.",
 				purgedMsg: "✓ Purged {n} item(s)",
+				purgeBackupsToo: "This session still has {n} migration backup copy(ies). Delete them too?\n\n(The session no longer exists, so those backups will not be used again; keeping them lets you restore or clean them separately from the backup list.)",
+				purgeBackupsDone: " (including {n} backup copy(ies))",
 				backupsCaption: "Backups",
-				backupsHelp: "Every move creates a byte-level backup first; they are all listed here. Restore a session back to where the backup was taken (if no session with the same id lives there), or into any other group.",
-				backupMeta: "{n} copies · {size} · {range}",
+				backupsHelp: "Migration recovery snapshots are listed here. Identical session content keeps one physical snapshot while every move remains in history; restore to the original location or any other group.",
+				backupMeta: "{n} snapshots · {size} · {range}",
 				backupDeleteBtn: "Delete backups",
 				backupDeleteConfirm: "Delete the {n} backup copies of \"{title}\"? They cannot be restored from afterwards.",
 				backupDeletedMsg: "✓ Deleted {n} backup copy(ies)",
+				backupOrphanBadge: "Orphan",
+				backupOrphanHelp: "This session's archive no longer exists (usually purged). These backups are no longer referenced by any operation and can be cleaned safely.",
+				backupOrphanSummary: "Orphan backups: {n} group(s) · {size} (session no longer exists)",
+				backupOrphanCleanup: "Clean orphan backups",
+				backupOrphanConfirm: "Delete {n} orphan backup group(s) ({size})? Those sessions no longer exist, so they cannot be restored from these backups afterwards.",
+				backupOrphanPartial: "✓ Deleted {n}; {f} group(s) failed (retry available)",
 				residentRefuse: "This session may remain resident in harness memory even when it is not focused (archiving hides it but does not unload it). DSH 0.1.5 exposes no public unload-by-ID API; restart the harness to release it, then delete it again.",
 				sessionBusy: "This session is busy: a move / restore / delete is still in flight. Try again in a moment.",
 				contextStale: "The plugin context went stale (client-side hot reload). Refresh the page (or restart the app) and the features will work again.",
@@ -292,7 +359,13 @@ window.__ModuleLoader__.load({
 				doctorDataBackups: "Backups",
 				doctorDataHistory: "Move history",
 				doctorDataTasks: "Task records",
+				doctorDataMigrations: "Migration queue",
 				doctorRecovery: "Recovery records",
+				doctorDataLayout: "Storage layout",
+				doctorStorageAdapter: "Storage adapter",
+				adapterFilesystemFallback: "This DSH build has no public raw archive path API. The filesystem adapter is active; migration is available when the storage layout check passes.",
+				adapterOfficialHandle: "Official session APIs are available without a raw archive path; archive directory migration is unavailable.",
+				adapterUnavailable: "The persistence provider does not expose enough usable APIs.",
 				doctorWorkspaces: "Workspace paths",
 				repairAllBtn: "Fix all",
 				repairAllDone: "✓ Fixed {n} · skipped {s} · failed {f}",
@@ -300,6 +373,39 @@ window.__ModuleLoader__.load({
 				filterPh: "Filter: title / session id / path…",
 				tasksCaption: "Move tasks",
 				tasksHelp: "Persistent records of bulk moves: every done / failed item is inspectable. Failed items can be retried in one click — retried from where each session currently lives, never from a stale recorded path; clearing a record never touches moved sessions.",
+				queueCaption: "Waiting migrations",
+				queueHelp: "Running sessions are never touched. The migration is retried automatically after the session becomes idle; failed items can be retried or cancelled.",
+				queueRetryBtn: "Retry",
+				queueRetryAllBtn: "Retry all failed",
+				queueCancelBtn: "Cancel",
+				queueRetryDone: "✓ Migration retried",
+				queueRetryAllDone: "✓ Retried {n} failed migration(s) independently",
+				queueCancelled: "✓ Migration cancelled",
+				queuedMove: "Queued: it will move automatically when the session is idle",
+				batchQueuedTail: "; {n} session(s) queued until idle",
+				previewStatus: "Preview status",
+				previewSource: "Source",
+				previewTarget: "Target path",
+				previewBackup: "New backup bytes",
+				previewBackupReused: "Reusing an existing snapshot; no new disk space",
+				previewBackupHelp: "A recovery snapshot is saved before migration for rollback and restoration. Identical session content reuses an existing snapshot while the primary archive still moves only once.",
+				previewSameWorkspace: "The session is already in the target workspace; no move is needed.",
+				previewSelfHeal: "The archive is already in the target workspace; its membership will be repaired.",
+				previewRunning: "The session is running and will wait until idle.",
+				previewNoPhysicalPath: "This DSH build exposes no raw archive path; archive directory migration is unavailable.",
+				previewSourceMissing: "The source session archive is missing or unreadable.",
+				previewCollision: "The target already contains an archive with this ID; overwriting is blocked.",
+				previewGenerations: "Multiple format generations found; v{n} is selected and older files are preserved.",
+				previewDescendants: "{n} descendant sessions selected.",
+				forkMode: "Fork scope",
+				forkCurrentOnly: "Current session only",
+				forkIncludeDescendants: "Include descendants",
+				forkHint: "Only the current session moves by default. Descendants are migrated independently and reported one by one.",
+				previewWarning: "Note",
+				previewSafe: "Safe to move",
+				previewQueued: "Will wait until idle",
+				previewBlocked: "Cannot move now",
+				previewWarningState: "Review before moving",
 				taskRetryBtn: "Retry failed",
 				taskRetryDone: "✓ Retry finished: {n} succeeded · {f} failed",
 				taskForgetBtn: "Clear record",
@@ -312,6 +418,18 @@ window.__ModuleLoader__.load({
 			}
 		};
 		const lang = (navigator.language || "en").toLowerCase().startsWith("zh") ? "zh" : "en";
+		// 词条漂移防护：新增文案只补一种语言时，缺失的那一侧会静默回退成 key
+		//（界面上直接显示 idUnresolved 这样的标识符）。启动时对账一次并告警。
+		(() => {
+			const keysOf = (l) => new Set(Object.keys(STRINGS[l] ?? {}));
+			const zhKeys = keysOf("zh");
+			const enKeys = keysOf("en");
+			const onlyZh = [...zhKeys].filter((k) => !enKeys.has(k));
+			const onlyEn = [...enKeys].filter((k) => !zhKeys.has(k));
+			if (onlyZh.length || onlyEn.length) {
+				console.warn("[workspace-mover] i18n key drift — missing in en:", onlyZh, "missing in zh:", onlyEn);
+			}
+		})();
 		const t = (key, vars) => {
 			let s = STRINGS[lang][key] ?? key;
 			for (const [k, v] of Object.entries(vars ?? {})) s = s.replaceAll(`{${k}}`, String(v));
@@ -323,6 +441,28 @@ window.__ModuleLoader__.load({
 			const raw = String(err?.message ?? err);
 			return /inactive context/.test(raw) ? t("contextStale") : raw;
 		};
+		const diagnosticText = (raw) => {
+			const text = String(raw ?? "");
+			const keys = {
+				'official session handles are available only for metadata; physical JSONL path adapter is active': 'adapterFilesystemFallback',
+				'public raw-byte path API is unavailable; physical JSONL path adapter is active': 'adapterFilesystemFallback',
+				'provider exposes public list/stat/open APIs but no public raw-byte path; physical moves are unavailable': 'adapterOfficialHandle',
+				'provider does not expose enough public persistence APIs': 'adapterUnavailable',
+				'physical move uses the JSONL path fallback; official raw-byte path API is unavailable': 'adapterFilesystemFallback',
+				'session is currently running and will wait for idle': 'previewRunning',
+				'provider exposes public handles but no physical raw-byte path; this version cannot relocate the archive directory': 'previewNoPhysicalPath',
+				'source session archive is missing or unreadable': 'previewSourceMissing',
+				'target workspace already contains an archive with this session id': 'previewCollision',
+				'session already belongs to the target workspace': 'previewSameWorkspace',
+				'session archive is already at target; workspace membership will be repaired': 'previewSelfHeal'
+			};
+			if (keys[text]) return t(keys[text]);
+			const generations = /^multiple generations found; v(\d+) is selected and older files are preserved$/.exec(text);
+			if (generations) return t('previewGenerations', { n: generations[1] });
+			const descendants = /^(\d+) descendant session\(s\) selected$/.exec(text);
+			if (descendants) return t('previewDescendants', { n: descendants[1] });
+			return text;
+		};
 
 		function ensureStyle() {
 			if (document.getElementById(STYLE_ID)) return;
@@ -346,6 +486,7 @@ window.__ModuleLoader__.load({
 .wsm-row{font-size:13px;line-height:20px;margin:6px 0;word-break:break-all}
 .wsm-label{color:var(--dsw-alias-label-secondary,#777)}
 .wsm-hint{font-size:12px;color:var(--dsw-alias-label-tertiary,#999);margin-top:10px;line-height:17px}
+.wsm-preview{font-size:12px;line-height:18px;white-space:pre-wrap;word-break:break-word;margin-top:10px;padding:8px 10px;border:1px solid var(--dsw-alias-border-l2,rgba(0,0,0,.12));border-radius:8px;background:var(--dsw-alias-bg-layer-1,#fafafa);color:var(--dsw-alias-label-secondary,#666)}
 .wsm-actions{display:flex;gap:8px;justify-content:flex-end;margin-top:16px}
 .wsm-btn{appearance:none;border:1px solid var(--dsw-alias-border-l2,rgba(0,0,0,.15));background:transparent;color:var(--dsw-alias-label-primary,#111);
  border-radius:8px;padding:6px 14px;font-size:13px;cursor:pointer}
@@ -510,15 +651,21 @@ window.__ModuleLoader__.load({
 				}
 			}
 
+			/** 弹窗实例计数：为 aria-labelledby 生成稳定且唯一的关联 id。 */
+			let overlaySeq = 0;
+
 			function injectOverlay() {
+				const uid = `wsm-title-${++overlaySeq}`;
 				const overlay = document.createElement("div");
 				overlay.className = "wsm-overlay";
 				overlay.innerHTML = `
-<div class="wsm-card" role="dialog" aria-modal="true">
-  <div class="wsm-title"></div>
+<div class="wsm-card" role="dialog" aria-modal="true" aria-labelledby="${uid}">
+  <div class="wsm-title" id="${uid}"></div>
   <div class="wsm-row"><span class="wsm-label"></span> <b class="wsm-session"></b></div>
   <div class="wsm-row"><span class="wsm-label"></span> <b class="wsm-target"></b></div>
+  <div class="wsm-row wsm-fork-row" hidden><span class="wsm-label"></span> <select class="wsm-select wsm-fork-mode"></select></div>
   <div class="wsm-hint"></div>
+  <div class="wsm-preview" hidden></div>
   <div class="wsm-actions">
     <button class="wsm-btn wsm-cancel"></button>
     <button class="wsm-btn primary wsm-ok"></button>
@@ -532,24 +679,139 @@ window.__ModuleLoader__.load({
 				return overlay;
 			}
 
-			function confirmMove({ sessionId, sessionTitle, workspace, batchCount }) {
+			/**
+			 * 挂载弹窗并补齐可达性：焦点进入弹窗、Tab 在弹窗内循环、
+			 * 背景点击关闭。`onKey` 是各调用方自己的 Escape 处理（用于释放监听器）。
+			 * 必须**先 append 再 focus**——未挂到文档上的元素在浏览器里无法聚焦。
+			 */
+			function openDialog(overlay, close) {
+				overlay.addEventListener("click", (e) => { if (e.target === overlay) close(null); });
+				document.body.appendChild(overlay);
+				const card = overlay.querySelector(".wsm-card");
+				const focusables = [...card.querySelectorAll("button:not(:disabled)")];
+				(focusables.find((b) => b.classList.contains("primary")) ?? focusables[0] ?? card)?.focus?.();
+				overlay.addEventListener("keydown", (e) => {
+					if (e.key !== "Tab" || focusables.length === 0) return;
+					const at = focusables.indexOf(document.activeElement);
+					const next = e.shiftKey
+						? (at <= 0 ? focusables.length - 1 : at - 1)
+						: (at === -1 || at === focusables.length - 1 ? 0 : at + 1);
+					// 自管焦点：避免 Tab 跑到弹窗背后的侧边栏/输入框
+					focusables[next]?.focus?.();
+				});
+			}
+
+			function formatPreviewBytes(value) {
+				const n = Number(value);
+				if (!Number.isFinite(n) || n <= 0) return "0 B";
+				const units = ["B", "KB", "MB", "GB"];
+				const at = Math.min(Math.floor(Math.log(n) / Math.log(1024)), units.length - 1);
+				return `${(n / (1024 ** at)).toFixed(at === 0 ? 0 : 1)} ${units[at]}`;
+			}
+
+			function confirmMove({ sessionId, sessionTitle, workspace, workspaces, loadPreview, batchCount, unresolvedCount, preview }) {
 				return new Promise((resolve) => {
 					const overlay = injectOverlay();
 					const okBtn = overlay.querySelector(".wsm-ok");
+					let selectedWorkspace = workspace;
+					let previewRequest = 0;
+					let closed = false;
 					overlay.querySelector(".wsm-title").textContent = batchCount ? t("batchConfirmTitle") : t("confirmTitle");
 					overlay.querySelector(".wsm-session").textContent = batchCount
 						? t("scannedN", { n: batchCount })
 						: (sessionTitle || t("unnamedSession"));
 					overlay.querySelector(".wsm-target").textContent = `${workspace.title}（${workspace.path}）`;
-					overlay.querySelector(".wsm-hint").textContent = batchCount ? t("batchHint", { count: batchCount }) : t("hint");
+					let targetSelect = null;
+					if (Array.isArray(workspaces) && typeof loadPreview === 'function') {
+						targetSelect = document.createElement('select');
+						targetSelect.className = 'wsm-select wsm-target-select';
+						targetSelect.setAttribute('aria-label', t('target'));
+						for (const item of workspaces) {
+							const option = document.createElement('option');
+							option.value = item.workspaceId;
+							option.textContent = `${item.title} (${item.path})`;
+							targetSelect.append(option);
+						}
+						targetSelect.value = workspace.workspaceId;
+						overlay.querySelector('.wsm-target').textContent = '';
+						overlay.querySelector('.wsm-target').append(targetSelect);
+					}
+					const forkRow = overlay.querySelector(".wsm-fork-row");
+					const forkMode = overlay.querySelector(".wsm-fork-mode");
+					forkRow.hidden = false;
+					forkRow.querySelector(".wsm-label").textContent = t("forkMode") + "：";
+					for (const [label, value] of [[t("forkCurrentOnly"), "current-only"], [t("forkIncludeDescendants"), "include-descendants"]]) {
+						const option = document.createElement("option");
+						option.value = value;
+						option.textContent = label;
+						forkMode.append(option);
+					}
+					forkMode.value = "current-only";
+					const hint = overlay.querySelector(".wsm-hint");
+					hint.textContent = `${batchCount ? t("batchHint", { count: batchCount }) : t("hint")} ${t("previewBackupHelp")} ${t("forkHint")}`;
+					function renderPreview(plan) {
+						preview = plan;
+						if (!preview) return;
+						const statusLabels = {
+							safe: t("previewSafe"),
+							queued: t("previewQueued"),
+							blocked: t("previewBlocked"),
+							warning: t("previewWarningState")
+						};
+						const source = preview.source?.title || preview.source?.cwd || "—";
+						const target = preview.target?.path || selectedWorkspace.path || "—";
+						const warnings = Array.isArray(preview.warnings) ? preview.warnings.filter(Boolean).map(diagnosticText) : [];
+						const previewBox = overlay.querySelector(".wsm-preview");
+						previewBox.hidden = false;
+						previewBox.textContent = [
+							`${t("previewStatus")}: ${statusLabels[preview.status] || preview.status || "—"}`,
+							`${t("previewSource")}: ${source}`,
+							`${t("previewTarget")}: ${target}`,
+							`${t("previewBackup")}: ${formatPreviewBytes(preview.estimatedBackupBytes)}${preview.backup?.reused ? ` (${t("previewBackupReused")})` : ""}`,
+							warnings.length ? `${t("previewWarning")}: ${warnings.join("; ")}` : ""
+						].filter(Boolean).join("\n");
+						okBtn.disabled = preview.status === "blocked";
+					}
+					renderPreview(preview);
+					async function refreshPreview() {
+						const request = ++previewRequest;
+						selectedWorkspace = workspaces.find((item) => item.workspaceId === targetSelect.value);
+						okBtn.disabled = true;
+						const box = overlay.querySelector('.wsm-preview');
+						box.hidden = false;
+						box.textContent = t('doctorChecking');
+						try {
+							const plan = await loadPreview(selectedWorkspace.workspaceId, forkMode.value || 'current-only');
+							if (!closed && request === previewRequest) renderPreview(plan);
+						} catch (err) {
+							if (!closed && request === previewRequest) box.textContent = t('failed', { msg: errMsg(err) });
+						}
+					}
+					if (targetSelect) {
+						targetSelect.addEventListener('change', () => void refreshPreview());
+						forkMode.addEventListener('change', () => void refreshPreview());
+					}
+					// 有行无法识别时必须如实说明——用户点"确认"之前要知道这次只搬走了一部分。
+					if (unresolvedCount > 0) {
+						const warn = document.createElement("div");
+						warn.className = "wsm-hint";
+						warn.textContent = t("idUnresolvedPartial", { n: unresolvedCount });
+						hint.after(warn);
+					}
 					okBtn.textContent = batchCount ? t("batchMove") : t("move");
-					const close = (value) => { overlay.remove(); document.removeEventListener("keydown", onKey); resolve(value); };
-					const onKey = (e) => { if (e.key === "Escape") close(null); };
 					document.addEventListener("keydown", onKey);
-					overlay.addEventListener("click", (e) => { if (e.target === overlay) close(null); });
+					function onKey(e) { if (e.key === "Escape") close(null); }
+					function close(value) {
+						closed = true;
+						overlay.remove();
+						document.removeEventListener("keydown", onKey);
+						resolve(value);
+					}
 					overlay.querySelector(".wsm-cancel").addEventListener("click", () => close(null));
-					okBtn.addEventListener("click", () => close(true));
-					document.body.appendChild(overlay);
+					okBtn.addEventListener("click", () => {
+						if (!okBtn.disabled) close({ mode: forkMode.value || "current-only", targetWorkspaceId: selectedWorkspace.workspaceId });
+					});
+					openDialog(overlay, close);
 				});
 			}
 
@@ -577,14 +839,17 @@ window.__ModuleLoader__.load({
 					okBtn.disabled = true;
 					const select = overlay.querySelector("select.wsm-select");
 					select.addEventListener("change", () => { okBtn.disabled = !select.value; });
-					const close = (value) => { overlay.remove(); document.removeEventListener("keydown", onKey); resolve(value); };
-					const onKey = (e) => { if (e.key === "Escape") close(null); };
 					document.addEventListener("keydown", onKey);
-					overlay.addEventListener("click", (e) => { if (e.target === overlay) close(null); });
+					function onKey(e) { if (e.key === "Escape") close(null); }
+					function close(value) {
+						overlay.remove();
+						document.removeEventListener("keydown", onKey);
+						resolve(value);
+					}
 					overlay.querySelector(".wsm-cancel").addEventListener("click", () => close(null));
 					okBtn.addEventListener("click", () => close(select.value || null));
-					document.body.appendChild(overlay);
-					select.focus();
+					openDialog(overlay, close);
+					okBtn.focus();
 				});
 			}
 
@@ -612,14 +877,17 @@ window.__ModuleLoader__.load({
 					okBtn.disabled = true;
 					const select = overlay.querySelector("select.wsm-select");
 					select.addEventListener("change", () => { okBtn.disabled = !select.value; });
-					const close = (value) => { overlay.remove(); document.removeEventListener("keydown", onKey); resolve(value); };
-					const onKey = (e) => { if (e.key === "Escape") close(null); };
 					document.addEventListener("keydown", onKey);
-					overlay.addEventListener("click", (e) => { if (e.target === overlay) close(null); });
+					function onKey(e) { if (e.key === "Escape") close(null); }
+					function close(value) {
+						overlay.remove();
+						document.removeEventListener("keydown", onKey);
+						resolve(value);
+					}
 					overlay.querySelector(".wsm-cancel").addEventListener("click", () => close(null));
 					okBtn.addEventListener("click", () => close(select.value || null));
-					document.body.appendChild(overlay);
 					if (select.value) okBtn.disabled = false;
+					openDialog(overlay, close);
 					select.focus();
 				});
 			}
@@ -670,6 +938,7 @@ window.__ModuleLoader__.load({
 			const [trash, setTrash] = useState(null);
 			const [backups, setBackups] = useState(null);
 			const [tasks, setTasks] = useState(null);
+			const [migrations, setMigrations] = useState(null);
 			const [doctor, setDoctor] = useState(null);
 			const [query, setQuery] = useState("");
 
@@ -691,7 +960,7 @@ window.__ModuleLoader__.load({
 			const runScan = async () => {
 				setBusy(true);
 				try {
-					const [s, w, h, a, ar, tr, bp, tk] = await Promise.all([call("mover.scan"), call("mover.workspaces"), call("mover.history"), call("mover.ws.audit"), call("mover.archived"), call("mover.trash.list"), call("mover.backups.list"), call("mover.tasks.list")]);
+					const [s, w, h, a, ar, tr, bp, tk, mq] = await Promise.all([call("mover.scan"), call("mover.workspaces"), call("mover.history"), call("mover.ws.audit"), call("mover.archived"), call("mover.trash.list"), call("mover.backups.list"), call("mover.tasks.list"), call("mover.migrations.list")]);
 					setScan(s);
 					setWorkspaces(w.items ?? []);
 					setHistory(h.items ?? []);
@@ -700,6 +969,7 @@ window.__ModuleLoader__.load({
 					setTrash(tr);
 					setBackups(bp);
 					setTasks(tk);
+					setMigrations(mq);
 				} catch (err) {
 					setNote(t("failed", { msg: errMsg(err) }));
 				} finally {
@@ -1028,11 +1298,18 @@ window.__ModuleLoader__.load({
 
 			const purgeOne = async (item) => {
 				if (!window.confirm(t("purgeConfirm", { title: item.title || t("unnamedSession") }))) return;
+				// 彻底删除不可撤销：顺便问一句要不要把该会话的迁移备份也清掉
+				//（这些备份此刻已无还原对象，留着只会变成孤儿字节）。
+				const purgeBackups = item.backupCount > 0
+					? window.confirm(t("purgeBackupsToo", { n: item.backupCount }))
+					: false;
 				setBusy(true);
 				setNote("");
 				try {
-					const res = await call("mover.trash.purge", { sessionId: item.sessionId });
-					setNote(t("purgedMsg", { n: res?.purged ?? 1 }));
+					const res = await call("mover.trash.purge", { sessionId: item.sessionId, purgeBackups });
+					let msg = t("purgedMsg", { n: res?.purged ?? 1 });
+					if ((res?.backupsDeleted ?? 0) > 0) msg += t("purgeBackupsDone", { n: res.backupsDeleted });
+					setNote(msg);
 					await runScan();
 				} catch (err) {
 					failNote(err);
@@ -1110,6 +1387,29 @@ window.__ModuleLoader__.load({
 				}
 			};
 
+			/**
+			 * 清理全部孤儿备份组的字节。孤儿 = 会话档案已不存在，这些备份不会被
+			 * 任何操作再引用；逐组调用既有端点，不新增 RPC 面。
+			 */
+			const backupDeleteOrphans = async () => {
+				const orphans = (backupItems ?? []).filter((it) => it.orphan);
+				if (orphans.length === 0) return;
+				if (!window.confirm(t("backupOrphanConfirm", { n: orphans.length, size: fmtBytes(backups?.orphanBytes ?? 0) }))) return;
+				setBusy(true);
+				setNote("");
+				let deleted = 0;
+				let failed = 0;
+				for (const item of orphans) {
+					try {
+						const res = await call("mover.backups.deleteOne", { sessionId: item.sessionId });
+						deleted += res?.deleted ?? 0;
+					} catch { failed++; }
+				}
+				setNote(failed > 0 ? t("backupOrphanPartial", { n: deleted, f: failed }) : t("backupDeletedMsg", { n: deleted }));
+				setBusy(false);
+				await runScan();
+			};
+
 			// 一键修复：可自动修复项（挂错归位 / 未记账补账）逐项处理，只动记账不搬文件
 			const repairAll = async () => {
 				setBusy(true);
@@ -1171,6 +1471,50 @@ window.__ModuleLoader__.load({
 				}
 			};
 
+			const migrationRetry = async (task) => {
+				setBusy(true);
+				setNote("");
+				try {
+					await call("mover.migrations.retry", { taskId: task.id });
+					setNote(t("queueRetryDone"));
+					refreshWorkspaces();
+					await runScan();
+				} catch (err) {
+					failNote(err);
+				} finally {
+					setBusy(false);
+				}
+			};
+
+			const migrationRetryAll = async (taskIds) => {
+				setBusy(true);
+				setNote("");
+				try {
+					const result = await call("mover.migrations.retry", { taskIds });
+					setNote(t("queueRetryAllDone", { n: result.retried ?? 0 }));
+					refreshWorkspaces();
+					await runScan();
+				} catch (err) {
+					failNote(err);
+				} finally {
+					setBusy(false);
+				}
+			};
+
+			const migrationCancel = async (task) => {
+				setBusy(true);
+				setNote("");
+				try {
+					await call("mover.migrations.cancel", { taskId: task.id });
+					setNote(t("queueCancelled"));
+					await runScan();
+				} catch (err) {
+					failNote(err);
+				} finally {
+					setBusy(false);
+				}
+			};
+
 			// 数据保护：按时间清理回收站与备份（dryRun 先出数字，确认后才真删）
 			const dataCleanup = async () => {
 				setBusy(true);
@@ -1199,11 +1543,17 @@ window.__ModuleLoader__.load({
 			const orphaned = items.filter((it) => it.status === "orphaned");
 			const unregistered = items.filter((it) => it.status === "unregistered");
 			const misfiled = items.filter((it) => it.status === "misfiled");
+			const unreadable = items.filter((it) => it.status === "unreadable");
 			const brokenWorkspaces = (audit?.items ?? []).filter((it) => it.status !== "ok");
 			const emptyWorkspaces = workspaces.filter((w) => (w.rawSessionCount ?? 0) === 0);
 			const archivedItems = archived?.items ?? [];
-			const trashItems = trash?.items ?? [];
 			const backupItems = backups?.items ?? [];
+			// 回收站条目补上"该会话还有几份迁移备份"：彻底删除时顺带清理它们。
+			const backupCountById = new Map(backupItems.map((it) => [String(it.sessionId), it.count]));
+			const trashItems = (trash?.items ?? []).map((it) => ({
+				...it,
+				backupCount: backupCountById.get(String(it.sessionId)) ?? 0
+			}));
 			const taskItems = tasks?.items ?? [];
 			// 面板筛选：标题 / 会话 ID / 路径 / 归属分组，命中任一即保留
 			const q = query.trim().toLowerCase();
@@ -1214,10 +1564,14 @@ window.__ModuleLoader__.load({
 			const orphanedV = orphaned.filter(matchesQuery);
 			const unregisteredV = unregistered.filter(matchesQuery);
 			const misfiledV = misfiled.filter(matchesQuery);
+			const unreadableV = unreadable.filter(matchesQuery);
 			const archivedV = archivedItems.filter(matchesQuery);
 			const trashV = trashItems.filter(matchesQuery);
 			const backupV = backupItems.filter(matchesQuery);
 			const taskV = taskItems.filter((it) => matchesQuery({ ...it, title: null, cwd: it.targetPath }));
+			const migrationItems = migrations?.items ?? [];
+			const migrationV = migrationItems.filter((it) => !["done", "cancelled"].includes(it.state)).filter((it) => matchesQuery({ ...it, cwd: it.targetWorkspaceId }));
+			const failedMigrationIds = migrationV.filter((it) => it.state === "failed").map((it) => it.id);
 			const capCount = (shown, total) => (q ? `${shown}/${total}` : `${total}`);
 			const counts = scan?.counts ?? {};
 			const summaryParts = [
@@ -1249,7 +1603,7 @@ window.__ModuleLoader__.load({
 					doctor.checks.map((c) => h("div", { className: "wsm-item", key: c.id },
 						h("span", { className: "wsm-badge" + (c.state === "fail" ? " err" : c.state === "warn" ? " warn" : "") },
 							c.state === "pass" ? "✓" : c.state === "warn" ? "⚠" : "✗"),
-						h("span", { className: "wsm-cwd", title: c.detail }, t(`doctor${c.id.split("-").map((w) => w[0].toUpperCase() + w.slice(1)).join("")}`) + (c.detail ? ` — ${c.detail}` : ""))
+						h("span", { className: "wsm-cwd", title: diagnosticText(c.detail), style: { whiteSpace: "normal", overflow: "visible", overflowWrap: "anywhere" } }, t(`doctor${c.id.split("-").map((w) => w[0].toUpperCase() + w.slice(1)).join("")}`) + (c.detail ? ` — ${diagnosticText(c.detail)}` : ""))
 					))
 				) : null,
 				brokenWorkspaces.length > 0 ? h(Caption, { text: t("wsSection"), help: t("wsHelp") }) : null,
@@ -1322,7 +1676,27 @@ window.__ModuleLoader__.load({
 							);
 						})
 					) : null,
+				unreadable.length > 0 ? h(Caption, { text: `${t("unreadable")} (${capCount(unreadableV.length, unreadable.length)})` }) : null,
+				unreadableV.length > 0 ? h("div", { className: "wsm-list" },
+					unreadableV.map((it) => {
+						const labels = {
+							unsupported: t("unsupportedFormat"),
+							"layout-unknown": t("layoutUnknown"),
+							"corrupt-data": t("corruptData")
+						};
+						return h("div", { className: "wsm-item", key: it.sessionId },
+							h("span", { className: "wsm-badge err" }, t("unreadable")),
+							h("span", { className: "wsm-mono" }, it.sessionId),
+							h("span", { className: "wsm-cwd", title: it.diagnosticDetail ?? "" },
+								`${labels[it.diagnostic] ?? t("layoutUnknown")}${it.diagnosticDetail ? ` — ${it.diagnosticDetail}` : ""}`)
+						);
+					})
+				) : null,
 				archivedItems.length > 0 ? h(Caption, { text: `${t("archivedCaption")} (${capCount(archivedV.length, archivedItems.length)})`, help: t("archivedHelp") }) : null,
+				// 扫描只解析最新 400 条档案，而归档会话通常很旧：大库上这里可能不是全部。
+				archived?.truncated && archivedV.length > 0
+					? h("div", { className: "wsm-note" }, t("archiveTruncated", { parsed: archived.scannedParsed ?? 0, total: archived.scannedTotal ?? 0 }))
+					: null,
 				archivedV.length > 0 ? h("div", { className: "wsm-list" },
 					archivedV.map((it) => h("div", { className: "wsm-item", key: it.sessionId },
 						h("span", { className: "wsm-mono" }, it.title || t("unnamedSession")),
@@ -1387,9 +1761,17 @@ window.__ModuleLoader__.load({
 					})) : h("div", { className: "wsm-note" }, t("historyEmpty"))
 				),
 				backupItems.length > 0 ? h(Caption, { text: `${t("backupsCaption")} (${capCount(backupV.length, backupItems.length)})`, help: t("backupsHelp") }) : null,
+				// 孤儿备份：会话已不存在，这些字节不会被任何操作再引用，只能手动清。
+				backups?.orphanGroups > 0
+					? h("div", { className: "wsm-scanrow" },
+						h("span", { style: { fontSize: "12.5px", color: "var(--dsw-alias-label-secondary,#666)" } },
+							t("backupOrphanSummary", { n: backups.orphanGroups, size: fmtBytes(backups.orphanBytes ?? 0) })),
+						h("button", { className: "wsm-btn small", disabled: busy, onClick: () => void backupDeleteOrphans() }, t("backupOrphanCleanup")))
+					: null,
 				backupV.length > 0 ? h("div", { className: "wsm-list" },
 					backupV.map((it) => h("div", { className: "wsm-item", key: it.sessionId },
 						h("span", { className: "wsm-mono" }, it.title || t("unnamedSession")),
+						it.orphan ? h("span", { className: "wsm-badge warn", title: t("backupOrphanHelp") }, t("backupOrphanBadge")) : null,
 						h("span", { className: "wsm-cwd", title: it.cwd ?? "" }, t("backupMeta", { n: it.count, size: fmtBytes(it.totalBytes), range: fmtRange(it) })),
 						h("button", { className: "wsm-btn small primary", disabled: busy, onClick: () => void backupRestore(it) }, t("restoreBtn")),
 						h("button", { className: "wsm-btn small", disabled: busy, onClick: () => void backupDelete(it) }, t("backupDeleteBtn"))
@@ -1406,6 +1788,22 @@ window.__ModuleLoader__.load({
 						h("button", { className: "wsm-btn small", disabled: busy, onClick: () => void taskForget(it) }, t("taskForgetBtn"))
 					))
 				) : null,
+				migrationV.length > 0 ? h(Caption, { text: `${t("queueCaption")} (${capCount(migrationV.length, migrationItems.filter((it) => !["done", "cancelled"].includes(it.state)).length)})`, help: t("queueHelp") }) : null,
+				failedMigrationIds.length > 1 ? h("div", { className: "wsm-scanrow" },
+					h("button", { className: "wsm-btn small primary", disabled: busy, onClick: () => void migrationRetryAll(failedMigrationIds) }, t("queueRetryAllBtn"))) : null,
+				migrationV.length > 0 ? h("div", { className: "wsm-list" },
+					migrationV.map((it) => h("div", { className: "wsm-item", key: it.id },
+						h("span", { className: "wsm-mono", title: it.sessionId }, it.title || shortId(it.sessionId)),
+						h("span", { className: `wsm-badge ${it.state === "failed" ? "err" : "warn"}` }, it.state),
+						h("span", { className: "wsm-cwd", title: it.lastError ?? "" }, it.lastError || `${t("previewTarget")}: ${it.targetWorkspaceId}`),
+						!["done", "cancelled", "retrying"].includes(it.state)
+							? h("button", { className: "wsm-btn small primary", disabled: busy, onClick: () => void migrationRetry(it) }, t("queueRetryBtn"))
+							: null,
+						!["done", "cancelled", "retrying"].includes(it.state)
+							? h("button", { className: "wsm-btn small", disabled: busy, onClick: () => void migrationCancel(it) }, t("queueCancelBtn"))
+							: null
+					))
+				) : null,
 				scan && (scan.recoveryCount ?? 0) > 0
 					? h("div", { className: "wsm-note", style: { color: "var(--dsw-alias-state-error-primary,#dc2626)", marginTop: "10px" } }, t("recoveryNote", { n: scan.recoveryCount }))
 					: null,
@@ -1441,7 +1839,13 @@ window.__ModuleLoader__.load({
 		// slots：设置页「会话救援」面板需要；未注入时访问 ctx.slots 会被宿主拒绝
 		var inject = ["connection", "slots"];
 
+		// 同一 bundle 被重复装载时（宿主热重载/重组）防止叠加实例。
+		// 前一个实例在 teardown 里把它复位，因此"装载→卸载→再装载"仍能正常工作。
+		let applied = false;
+
 		function apply(ctx) {
+			if (applied) return;
+			applied = true;
 			// 在 apply（上下文必然活跃）时立即捕获 connection 服务实例本身，而不是持有 ctx
 			// 做惰性访问：桌面版会在热重载 / 客户端重组时废弃本插件的旧 fiber，此后
 			// ctx.connection 会抛 "cannot get required service 'connection' in inactive context"
@@ -1459,6 +1863,16 @@ window.__ModuleLoader__.load({
 			let dragging = null; // {el, els, id, target} —— id/target 在 drop 阶段解析
 			let wsCache = null; // {items, at}
 
+			// 统一登记本插件挂到 document / window 上的监听器与 observer。
+			// 必须成对释放：桌面版热重载会废弃旧 fiber 并重新装载客户端半，
+			// 不释放就会叠加第二份监听器——重复确认框、重复 RPC，
+			// 两份闭包还会互相擦掉对方的多选高亮。
+			const disposers = [];
+			const listen = (type, fn, options) => {
+				document.addEventListener(type, fn, options);
+				disposers.push(() => document.removeEventListener(type, fn, options));
+			};
+
 			ensureStyle();
 
 			// 状态仅作诊断：不硬性禁用拖拽（避免启动期竞态导致永久失效）。
@@ -1466,8 +1880,8 @@ window.__ModuleLoader__.load({
 				console.warn("[workspace-mover] status probe failed (will retry per move):", err);
 			});
 
-			async function fetchWorkspaces() {
-				if (wsCache && Date.now() - wsCache.at < 3000) return wsCache.items;
+			async function fetchWorkspaces(fresh = false) {
+				if (!fresh && wsCache && Date.now() - wsCache.at < 3000) return wsCache.items;
 				const res = await rpcCall("mover.workspaces");
 				if (!res?.ok) throw new Error(res?.error?.message ?? "workspace list unavailable");
 				wsCache = { items: res.value.items, at: Date.now() };
@@ -1480,9 +1894,9 @@ window.__ModuleLoader__.load({
 
 			//#region 插件自建多选（宿主侧边栏没有多选模型）
 			// Ctrl/Cmd+点击加入/移出、Shift+点击组内范围选择；拖动任一选中行 = 整批拖动。
-			// 选中集存行元素（判定同步、零延迟）；会话 id 在点击/投放时经「分组对齐 +
-			// 标题消歧」解析：组内 DOM 行顺序对齐 workspace.sessionIds 顺序，行文本与
-			// mover.scan 的标题贪心匹配——躲开隐藏空白会话造成的纯序错位，失配退化为顺序。
+			// 选中集存行元素（判定同步、零延迟）；会话 id 在点击/投放时解析：
+			// 优先走权威通道 rowSessionId（React fiber 上的 node.id），不可用时退化为
+			// 「组内对齐 + 标题匹配」——且**匹配不上就不猜**，无法确认的行会被跳过并告知用户。
 			let pickBadge = null;
 			const pickedRows = new Set();
 			let lastPickedRow = null;
@@ -1550,7 +1964,7 @@ window.__ModuleLoader__.load({
 			 */
 			function rowSessionId(rowEl) {
 				try {
-					const fiberKey = Object.keys(rowEl).find((k) => k.startsWith("__reactFiber$"));
+					const fiberKey = Object.getOwnPropertyNames(rowEl).find((k) => k.startsWith("__reactFiber$"));
 					if (!fiberKey) return null;
 					for (let fiber = rowEl[fiberKey]; fiber; fiber = fiber.return) {
 						const node = fiber.memoizedProps?.node;
@@ -1564,35 +1978,48 @@ window.__ModuleLoader__.load({
 			}
 
 			/**
-			 * 把一组会话行对齐到 workspace.sessionIds：两指针顺序消费 + 行文本与
-			 * scan 标题贪心匹配。仅作 rowSessionId 不可用时的兜底（官方隐藏空白/
-			 * 归档会话时可能错位，v0.6.x 的"移错会话"即源于此）。结果缓存进
-			 * row.dataset.wsmId；返回 row→id 映射。
+			 * 把一组会话行对齐到 ws.sessionIds。仅在权威通道（rowSessionId）不可用时使用。
+			 *
+			 * 关键安全约定：**匹配不上就不猜**。旧实现在标题匹配失败时直接取
+			 * `remaining` 里的下一个 id，而官方侧边栏会隐藏空白/归档行，于是整组错位一格、
+			 * 批量拖拽会搬走另一组合法会话。现在无法确定的行一律计入 unresolved，
+			 * 由调用方决定跳过还是中止。
+			 *
+			 * 返回 { map, unresolved }；map 为 row → id。
 			 */
 			async function mapGroupRows(ws, groupRows) {
 				const titleOf = new Map();
 				try {
 					const scan = await fetchScan();
 					for (const it of scan.items ?? []) titleOf.set(String(it.sessionId), String(it.title ?? "").replace(/\s+/g, " ").trim());
-				} catch { /* scan 不可用时退化为纯顺序对齐 */ }
+				} catch { /* scan 不可用时无法按标题匹配，只能精确匹配或放弃 */ }
 				const remaining = (ws.sessionIds ?? []).map(String);
 				const out = new Map();
+				const unresolved = [];
 				for (const row of groupRows) {
-					if (remaining.length === 0) break;
+					if (remaining.length === 0) { unresolved.push(row); continue; }
 					const text = (row.textContent ?? "").replace(/\s+/g, " ").trim();
 					let hit = -1;
 					if (text && text !== t("unnamedSession")) {
-						hit = remaining.findIndex((id) => { const tt = titleOf.get(id); return tt && tt.length > 0 && (tt === text || text.includes(tt) || tt.includes(text)); });
+						// 先精确，再"标题被行文本包含"（行文本通常更短，只带徽章/时间）
+						hit = remaining.findIndex((id) => titleOf.get(id) === text);
+						if (hit < 0) {
+							hit = remaining.findIndex((id) => {
+								const tt = titleOf.get(id);
+								return tt && tt.length > 0 && text.includes(tt);
+							});
+						}
 					}
-					if (hit < 0) hit = 0;
+					if (hit < 0) { unresolved.push(row); continue; }
 					const id = remaining.splice(hit, 1)[0];
+					if (id === undefined) { unresolved.push(row); continue; }
 					row.dataset.wsmId = id;
 					out.set(row, id);
 				}
-				return out;
+				return { map: out, unresolved };
 			}
 
-			/** 解析单个行元素（含所在组）的会话 id；权威走 rowSessionId，失败退回组内对齐。 */
+			/** 解析单个行元素（含所在组）的会话 id；权威走 rowSessionId，失败退回组内对齐（不猜）。 */
 			async function resolveRowId(rowEl) {
 				const authoritative = rowSessionId(rowEl);
 				if (authoritative) return authoritative;
@@ -1607,12 +2034,12 @@ window.__ModuleLoader__.load({
 				if (!header) return null;
 				const ws = resolveWorkspace(header, items);
 				if (!ws) return null;
-				const mapping = await mapGroupRows(ws, groupSessionRows(header));
-				return mapping.get(rowEl) ?? null;
+				const { map } = await mapGroupRows(ws, groupSessionRows(header));
+				return map.get(rowEl) ?? null;
 			}
 
 			// Ctrl/Cmd+点击：加入/移出；Shift+点击：组内范围选择。普通点击不干预。
-			document.addEventListener("click", async (e) => {
+			listen("click", async (e) => {
 			const row = sessionRow(e.target);
 			if (!row) return;
 			const meta = e.ctrlKey || e.metaKey;
@@ -1632,9 +2059,9 @@ window.__ModuleLoader__.load({
 						return null;
 					})();
 					const ws = header ? resolveWorkspace(header, items) : null;
-					if (!ws) return void toast(t("noTarget"), true);
+					if (!ws) return void toast(t("staleList"), true);
 					const groupRows = groupSessionRows(header);
-					const mapping = await mapGroupRows(ws, groupRows);
+					const { map: mapping } = await mapGroupRows(ws, groupRows);
 				if (meta) {
 					if (pickedRows.has(row)) pickedRows.delete(row);
 					else if (mapping.has(row) || rowSessionId(row)) {
@@ -1664,9 +2091,13 @@ window.__ModuleLoader__.load({
 				}
 			}, true);
 
-			// Esc 清空多选；不消费事件，输入框聚焦时也照常清空（官方输入的取消行为不受影响）
-			document.addEventListener("keydown", (e) => {
+			// Esc 清空多选：输入框聚焦时不清空（与 pickHint 的文案一致），
+			// 也不消费事件——官方输入的取消行为不受影响。
+			listen("keydown", (e) => {
 				if (e.key !== "Escape" || pickedRows.size === 0) return;
+				const el = document.activeElement;
+				const tag = el?.tagName?.toLowerCase?.();
+				if (el?.isContentEditable || tag === "input" || tag === "textarea" || tag === "select") return;
 				clearSelection();
 			});
 			//#endregion
@@ -1677,10 +2108,15 @@ window.__ModuleLoader__.load({
 			}
 
 			function headerText(rowEl) {
+				const ownText = (node) => {
+					if (node !== rowEl && node?.getAttribute?.('role') === 'treeitem') return '';
+					if (node?.nodeType === 3) return node.textContent ?? node._text ?? '';
+					return [...(node?.childNodes ?? [])].map(ownText).join(' ');
+				};
 				return normalizeHeaderText([
 					rowEl?.getAttribute?.("aria-label"),
 					rowEl?.getAttribute?.("title"),
-					rowEl?.textContent
+					ownText(rowEl)
 				].filter(Boolean).join(" "));
 			}
 
@@ -1693,30 +2129,60 @@ window.__ModuleLoader__.load({
 					.filter((el) => el.offsetParent !== null && !isUngroupedHeader(el));
 			}
 
-			function headerIndex(rowEl) {
-				return visibleWorkspaceHeaders().indexOf(rowEl);
+			/** 行标题文本是否命中某个注册表工作区的 title 或 path（大小写不敏感）。 */
+			function headerMatchesWorkspace(text, item) {
+				const lower = String(text ?? "").toLocaleLowerCase();
+				const title = normalizeHeaderText(item?.title).toLocaleLowerCase();
+				const path = normalizeHeaderText(item?.path).toLocaleLowerCase();
+				return Boolean((title && lower.includes(title)) || (path && lower.includes(path)));
 			}
 
+			/**
+			 * 行元素 → 注册表工作区。
+			 * 只用**可自证**的凭据：标题/路径命中，或标题与路径同时为空时的序号等价
+			 * （两者都无值意味着该实体没有可显示的标识，序号是唯一可用信息）。
+			 * 官方侧边栏会隐藏目录已失效的分组，而 registry.list() 仍包含它们——
+			 * 因此「DOM 第 i 项 = 注册表第 i 项」是错的，绝不能作为无条件兜底，
+			 * 否则侧边栏少显示一项就会把会话搬进相邻分组。
+			 */
 			function resolveWorkspace(rowEl, items) {
 				const list = Array.isArray(items) ? items : [];
-				if (!rowEl || isUngroupedHeader(rowEl)) return null;
+				if (!rowEl) return null;
+				// Read the rendered identity first: React may retain old fiber props after updates.
+				const rowKey = rowEl.getAttribute?.('data-row-key');
+				if (rowKey?.startsWith('workspace:')) {
+					return list.find((item) => `workspace:${item.workspaceId}` === rowKey) ?? null;
+				}
+				if (isUngroupedHeader(rowEl)) return null;
+				// DSH 0.2 ProjectRowItem carries the actual workspace ID in group props.
+				// Prefer identity over visible text, which can contain nested session titles.
+				try {
+					const fiberKey = Object.getOwnPropertyNames(rowEl).find((key) => key.startsWith('__reactFiber$'));
+					for (let fiber = fiberKey ? rowEl[fiberKey] : null; fiber; fiber = fiber.return) {
+						const group = fiber.memoizedProps?.group;
+						if (group && Object.hasOwn(group, 'workspaceId')) {
+							return list.find((item) => item.workspaceId === group.workspaceId) ?? null;
+						}
+					}
+				} catch { /* Older clients can use unique text evidence below. */ }
 				const text = headerText(rowEl);
-				const lowerText = text.toLocaleLowerCase();
-				const byText = list.find((item) => {
-					const title = normalizeHeaderText(item.title);
-					const path = normalizeHeaderText(item.path);
-					return (title && lowerText.includes(title.toLocaleLowerCase()))
-						|| (path && lowerText.includes(path.toLocaleLowerCase()));
-				});
-				if (byText) return byText;
-				const idx = headerIndex(rowEl);
-				const byIndex = idx >= 0 && idx < list.length ? list[idx] : null;
-				return byIndex;
+				const byText = list.filter((item) => headerMatchesWorkspace(text, item));
+				if (byText.length === 1) return byText[0];
+				if (byText.length > 1) {
+					const labels = [rowEl.getAttribute?.('aria-label'), rowEl.getAttribute?.('title'), text]
+						.map((value) => normalizeHeaderText(value).toLocaleLowerCase()).filter(Boolean);
+					const exact = byText.filter((item) => [item.title, item.path].some((value) =>
+						value && labels.includes(normalizeHeaderText(value).toLocaleLowerCase())));
+					return exact.length === 1 ? exact[0] : null;
+				}
+				const unidentifiable = list.filter((item) => !normalizeHeaderText(item?.title) && !normalizeHeaderText(item?.path));
+				if (unidentifiable.length === 1) return unidentifiable[0];
+				return null;
 			}
 
 			// dragstart：只做「元素判定」——拖起已多选的行 = 整批拖动，否则单选。
 			// id 一律留到 drop 阶段解析（dataTransfer 只携带拖起这一行的 id）。
-			document.addEventListener("dragstart", (e) => {
+			listen("dragstart", (e) => {
 				try {
 					const row = sessionRow(e.target);
 					if (!row) { dragging = null; return; }
@@ -1726,11 +2192,11 @@ window.__ModuleLoader__.load({
 				} catch { dragging = null; }
 			});
 
-			document.addEventListener("dragover", (e) => {
+			listen("dragover", (e) => {
 				clearHints();
 				if (!dragging) return;
 				const header = headerRow(e.target);
-				if (!header || isUngroupedHeader(header)) return;
+				if (!header || isUngroupedHeader(header)) { dragging.target = null; return; }
 				e.preventDefault(); // 允许在此投放（没有它 drop 根本不会触发）
 				header.classList.add("wsm-drop-hint");
 				if (!dragging.target || dragging.target.header !== header) {
@@ -1743,12 +2209,12 @@ window.__ModuleLoader__.load({
 				}
 			}, true);
 
-			document.addEventListener("drop", async (e) => {
+			listen("drop", async (e) => {
 				const current = dragging;
 				dragging = null;
 				clearHints();
 				if (!current) return;
-				const header = headerRow(e.target) ?? current.target?.header;
+				const header = headerRow(e.target);
 				if (!header || isUngroupedHeader(header)) return;
 				// 只拦截「拖到某个工作区标题行」的场景；其余交还官方逻辑
 				e.preventDefault();
@@ -1766,33 +2232,33 @@ window.__ModuleLoader__.load({
 					draggedId = candidates.map((value) => String(value).trim().split(/[\r\n]/)[0]).find(Boolean) || null;
 				} catch { draggedId = null; }
 				if (!draggedId) {
-					return void toast(t("failed", { msg: "unrecognized drag payload: empty" }), true);
+					return void toast(t("failed", { msg: t("dragPayloadBad") }), true);
 				}
 
 				let workspace = null;
+				let workspaceItems = [];
 				try {
-					let items = await fetchWorkspaces();
+					let items = await fetchWorkspaces(true);
+					workspaceItems = items;
 					workspace = resolveWorkspace(header, items);
-					if (!workspace && current.target?.workspaceId) {
-						workspace = items.find((item) => String(item.workspaceId) === String(current.target.workspaceId)) ?? null;
-					}
 					if (!workspace) {
 						wsCache = null;
 						items = await fetchWorkspaces();
+						workspaceItems = items;
 						workspace = resolveWorkspace(header, items);
-						if (!workspace && current.target?.workspaceId) {
-							workspace = items.find((item) => String(item.workspaceId) === String(current.target.workspaceId)) ?? null;
-						}
 					}
 				} catch (err) {
 					return void toast(t("failed", { msg: errMsg(err) }), true);
 				}
-				if (!workspace) return void toast(t("noTarget"), true);
+				if (!workspace) return void toast(t("staleList"), true);
 
 				// ---- 组装移动清单：拖起行必有 id；多选行逐个经分组对齐解析 ----
+				// 解析不出 id 的行**绝不猜测**（见 mapGroupRows 的安全约定）：
+				// 要么整体中止，要么在确认框里如实说明跳过了几行。
 				const picked = (current.els ?? [current.el]).filter((el) => el?.isConnected);
 				const sessions = [];
 				const seen = new Set();
+				let unresolvedCount = 0;
 				const push = (id, title) => {
 					const key = String(id);
 					if (!key || seen.has(key)) return;
@@ -1802,30 +2268,61 @@ window.__ModuleLoader__.load({
 				if (picked.length > 1) {
 					for (const el of picked) {
 						if (el === current.el) continue; // 拖起行用 dataTransfer 的权威 id
-						try { push(await resolveRowId(el), rowTitle(el, "")); } catch { /* 解析失败跳过 */ }
+						try {
+							const id = await resolveRowId(el);
+							if (id) push(id, rowTitle(el, ""));
+							else unresolvedCount += 1;
+						} catch { unresolvedCount += 1; }
 					}
 				}
 				// 权威 id 放首位；若某选中行被误映射到同一 id 会被去重吞掉
+				const beforePush = sessions.length;
 				push(draggedId, rowTitle(current.el, draggedId));
+				if (sessions.length === beforePush) unresolvedCount += 1; // 连拖起行都没解析出来
+
+				if (unresolvedCount > 0 && sessions.length === 0) {
+					return void toast(t("idUnresolved"), true);
+				}
 
 				if (sessions.length > 50) {
-					return void toast(t("failed", { msg: `too many sessions in one batch (max 50, got ${sessions.length})` }), true);
+					return void toast(t("failed", { msg: t("batchTooMany", { max: 50, n: sessions.length }) }), true);
 				}
 
 				// ---- 单选：原有确认与 mover.move 路径 ----
 				if (sessions.length === 1) {
 					const { sessionId, sessionTitle } = sessions[0];
-					const confirmed = await confirmMove({ sessionId, sessionTitle, workspace });
-					if (!confirmed) return;
+					let preview = null;
 					try {
-						const res = await rpcCall("mover.move", { sessionId, sessionTitle, targetWorkspaceId: workspace.workspaceId });
+						const res = await rpcCall("mover.preview", { sessionId, targetWorkspaceId: workspace.workspaceId });
+						if (res?.ok) preview = res.value;
+					} catch (err) {
+						console.debug("[workspace-mover] preview unavailable:", err?.message ?? err);
+					}
+					const choice = await confirmMove({ sessionId, sessionTitle, workspace, workspaces: workspaceItems, unresolvedCount, preview,
+						loadPreview: async (targetWorkspaceId, mode) => {
+							const res = await rpcCall('mover.preview', { sessionId, targetWorkspaceId, mode });
+							if (!res?.ok || !res.value?.status) throw new Error(res?.error?.message ?? 'preview unavailable');
+							return res.value;
+						}
+					});
+					if (!choice) return;
+					workspace = workspaceItems.find((item) => item.workspaceId === choice.targetWorkspaceId);
+					try {
+						const res = await rpcCall("mover.move", { sessionId, sessionTitle, targetWorkspaceId: workspace.workspaceId, mode: choice.mode });
 						if (res?.ok) {
-							await reconcileWorkspaceProjection(ctx, workspace.workspaceId, [sessionId]);
-							toast(res.value?.attached ? t("selfHealed") : t("done", { title: workspace.title }));
-							scheduleRecencyFix(ctx, workspace.workspaceId, [sessionId]);
+							wsCache = null;
+							scanCache = null;
+							const movedIds = (res.value?.results ?? []).filter((item) => item?.ok).map((item) => item.sessionId).filter(Boolean);
+							await reconcileWorkspaceProjection(ctx, workspace.workspaceId, movedIds.length > 0 ? movedIds : [sessionId]);
+							toast(res.value?.queued ? t("queuedMove") : (res.value?.attached ? t("selfHealed") : t("done", { title: workspace.title })));
+							scheduleRecencyFix(ctx, workspace.workspaceId, movedIds.length > 0 ? movedIds : [sessionId]);
 							if (res.value?.restartHint) setTimeout(() => toast(t("restartHint"), true), 1200);
 						} else {
 							const msg = res?.error?.message ?? "unknown";
+							if (res?.error?.code === "busy") {
+								toast(t("queuedMove"));
+								return;
+							}
 							const rolled = res?.error?.code === "rollback-failed" || /roll/i.test(msg);
 							const text = (rolled ? t("rolledBack", { msg }) : t("failed", { msg }));
 							toast(text, true);
@@ -1837,21 +2334,41 @@ window.__ModuleLoader__.load({
 				}
 
 				// ---- 多选：批量确认 + mover.moveMany（逐条独立备份回滚）----
-				const confirmed = await confirmMove({ workspace, batchCount: sessions.length });
-				if (!confirmed) return;
+				let preview = null;
+				try {
+					const plans = (await Promise.all(sessions.map(async (item) => {
+						const res = await rpcCall("mover.preview", { sessionId: item.sessionId, targetWorkspaceId: workspace.workspaceId });
+						return res?.ok ? res.value : null;
+					}))).filter(Boolean);
+					const blocked = plans.filter((item) => item.status === "blocked").length;
+					const queued = plans.filter((item) => item.status === "queued").length;
+					const warnings = plans.flatMap((item) => item.warnings ?? []).filter(Boolean);
+					preview = {
+						...plans[0],
+						status: blocked === plans.length && plans.length > 0 ? "blocked" : (blocked > 0 || queued > 0 ? "warning" : "safe"),
+						source: { title: t("scannedN", { n: sessions.length }) },
+						estimatedBackupBytes: plans.reduce((sum, item) => sum + Number(item.estimatedBackupBytes || 0), 0),
+						warnings: [...new Set([...(blocked ? [`${blocked} blocked`] : []), ...(queued ? [`${queued} queued`] : []), ...warnings])]
+					};
+				} catch (err) {
+					console.debug("[workspace-mover] batch preview unavailable:", err?.message ?? err);
+				}
+				const choice = await confirmMove({ workspace, batchCount: sessions.length, unresolvedCount, preview });
+				if (!choice) return;
 				try {
-					const res = await rpcCall("mover.moveMany", { sessions, targetWorkspaceId: workspace.workspaceId });
+					const res = await rpcCall("mover.moveMany", { sessions, targetWorkspaceId: workspace.workspaceId, mode: choice.mode });
 					if (!res?.ok) {
 						const msg = res?.error?.message ?? "unknown";
 						const rolled = res?.error?.code === "rollback-failed" || /roll/i.test(msg);
 						return void toast((rolled ? t("rolledBack", { msg }) : t("failed", { msg })), true);
 					}
-					const { movedCount, attachedCount, failedCount } = res.value ?? {};
+					const { movedCount, attachedCount, failedCount, queuedCount } = res.value ?? {};
 					const okCount = (movedCount ?? 0) + (attachedCount ?? 0);
 					const movedIds = (res.value?.results ?? []).filter((item) => item?.ok).map((item) => item.sessionId).filter(Boolean);
 					await reconcileWorkspaceProjection(ctx, workspace.workspaceId, movedIds);
 					let message = t("batchDone", { n: okCount });
 					if ((failedCount ?? 0) > 0) message += t("batchFailTail", { n: failedCount });
+					if ((queuedCount ?? 0) > 0) message += t("batchQueuedTail", { n: queuedCount });
 					toast(message);
 					clearSelection(true);
 					scheduleRecencyFix(ctx, workspace.workspaceId, sessions.map((s) => s.sessionId));
@@ -1860,7 +2377,7 @@ window.__ModuleLoader__.load({
 				}
 			}, true);
 
-			document.addEventListener("dragend", () => { dragging = null; clearHints(); });
+			listen("dragend", () => { dragging = null; clearHints(); });
 
 			// 整组迁移 + 分组合并：入口在官方组标题的「⋯」菜单（注入「整组迁移…」项）。
 			// 不再拦截浏览器右键——官方菜单同样在右键/⋯按钮打开，拦截会与之冲突。
@@ -1912,7 +2429,7 @@ window.__ModuleLoader__.load({
 			// 记录「⋯」按钮点击所在的标题行（标题行内唯一带 aria-label 的按钮），
 			// 随后出现的菜单 portal 即属于这个分组；1 秒内未出现菜单则作废。
 			let menuHeaderRow = null;
-			document.addEventListener("click", (e) => {
+			listen("click", (e) => {
 				const header = headerRow(e.target);
 				if (!header) return;
 				const btn = e.target.closest?.("button[aria-label]");
@@ -1947,7 +2464,7 @@ window.__ModuleLoader__.load({
 					try {
 						const list = await fetchWorkspaces();
 						const ws = resolveWorkspace(header, list);
-						if (!ws) return void toast(t("noTarget"), true);
+						if (!ws) return void toast(t("staleList"), true);
 						const res = await rpcCall("mover.openFolder", { workspaceId: ws.workspaceId, path: ws.path });
 						if (!res?.ok) toast(t("failed", { msg: res?.error?.message ?? "open failed" }), true);
 					} catch (err) {
@@ -1980,8 +2497,10 @@ window.__ModuleLoader__.load({
 				}
 			});
 			menuObserver.observe(document.body, { childList: true, subtree: true });
+			disposers.push(() => { try { menuObserver.disconnect(); } catch { /* ignore */ } });
 
 			// 诊断句柄：控制台用 window.__wsmDebug 检查「最近更新」排序修复通道（排障用）
+			const priorDebug = window.__wsmDebug;
 			try {
 				window.__wsmDebug = {
 					view: () => { const v = resolveViewStore(ctx); return v ? v.getSnapshot() : null; },
@@ -1994,6 +2513,19 @@ window.__ModuleLoader__.load({
 			} catch { /* ignore */ }
 
 			registerRescuePanel(ctx, rpcCall);
+
+			// teardown：宿主废弃本 fiber（桌面版热重载 / 客户端重组）时释放全部监听器。
+			// 没有这一步，重新装载会叠加第二份监听器，且旧闭包连同 pickedRows /
+			// dragging / 缓存永远不会被回收。
+			if (typeof ctx.effect === "function") {
+				ctx.effect(() => () => {
+					applied = false;
+					for (const dispose of disposers.splice(0)) {
+						try { dispose(); } catch { /* 单个失败不影响其余 */ }
+					}
+					try { if (window.__wsmDebug && priorDebug === undefined) delete window.__wsmDebug; } catch { /* ignore */ }
+				}, "workspace-mover: client listeners");
+			}
 		}
 
 		module.exports = { inject, apply };