dsh-workspace-mover 2.4.1 → 2.4.2

package/docs/compatibility/immediate-migration-2026-10-26.md

@@ -0,0 +1,68 @@
+# 2.4.2 即时迁移与标题修复验收
+
+正式版本：2.4.2。验收候选：2.4.2-rc.4；正式版仅调整版本和发布文档，运行逻辑相同。
+
+## 人工验收结论（2026-10-26）
+
+用户在 DSH Desktop 0.2.1-rc.2 / Windows 上确认：
+
+- 空闲会话拖动后立即出现在目标工作区，标题正常。
+- rc.4 修复后不切换会话即可继续发送，未再出现“会话不可用”。
+- 运行中拖动选择取消：任务继续、会话不移动。
+- 明确选择停止任务并迁移：任务停止，迁移后可在当前界面继续发送。
+- 彻底退出重启后标题、历史、归属正常，继续发送成功。
+
+证据来源：维护者在本次验收会话中先确认“一切正常”，随后按最后三项测试回复“都成功。进入发布流程和issue解决流程”。这是维护者本机验收，不代表原报告者已在旧版 DSH 复测。
+
+
+用户已在 rc.2 确认迁移后立即显示在目标工作区，且未出现未命名会话；随后发现当前输入框显示“会话不可用”，手动切走再切回才恢复。rc.3 尝试同步重新打开，但用户复验仍不可用，并出现重新连接失败提示。rc.4 改为等待引用释放后打开，用户随后确认通过。
+
+## 迁移后的当前对话
+
+官方 SessionController 在 dispose 时发布 api-session/removed；客户端 Session.handleRemoved 将 removed 置为 true，后续 added 事件只更新列表，并不清除此标记。因此后端已恢复的 Agent 对应的旧界面仍不可用。rc.3 在迁移 RPC 结束后检查仍选中的会话，仅在 removed 时通过 uiWorkspace.clearMain/openSession 释放旧视图并重新打开，等待新会话打开。失败回滚也执行同样检查；用户切换到其他会话或插件卸载后不主动跳转。不改宿主文件或私有 removed 字段。
+
+rc.3 漏掉了延迟释放：clearMain 仅立即释放主视图引用，React Provider 的其他引用要等界面更新才释放，立刻 openSession 会重新持有 removed 的旧对象。rc.4 用 sessions.retainInfo 观察旧 binding 的实际退出后再打开；最多等待 3 秒，插件卸载会取消等待。等待期间用户选了其他会话则不重新打开。
+
+新增已安装客户端验证：执行 Desktop 内的真实 ClientSessions / SessionManager / Session 代码，使用真实 Cordis，替换界面 store 和未使用的传输边界。确认 added 不清除 removed、双引用下同步重新取得旧对象、延迟释放最后引用后才能取得 removed=false 的新对象。该验证不运行 React 界面，不能替代 Desktop 复验。
+
+若其他界面仍持有旧会话引用，或重新打开失败，明确提示彻底退出并重启，不重复执行物理迁移。自动回归覆盖成功、回滚、连接报错、用户切换、正常界面和插件卸载；完整 Desktop 界面、草稿及预设保持情况仍需实际验收。
+
+## 行为
+
+- 插件观察官方 agents.create/resume，保留返回的生命周期 dispose；不修改持久化 writer、不可变 Session header 或安装文件。
+- 空闲且已接入生命周期的会话：锁定迁移操作，阻止新请求及后台恢复，等待官方 dispose 排空并关闭 writer，真实搬移档案，通过官方 SessionController.resolveAgent 重新按宿主预设加载。
+- 运行中会话：弹窗明确显示“停止任务并迁移”；取消不调用迁移。状态在确认后发生变化时，后端返回 stop-required，不擅自停止。
+- 放行操作使用 AsyncLocalStorage 限定为当前迁移的恢复调用，不放行其他并发恢复。旧 Agent 引用在替换后拒绝发送。
+- 迁移失败沿用文件和工作区归属回滚，并请求宿主从原位置重新加载。若重新加载失败，明确返回错误，不伪称全部成功。
+- 热更新前已打开、没有保留生命周期句柄的会话不强行释放。完全重启一次后重新打开会话即可接入；未知后端仍保留原安全检查。
+- 拖动迁移不自动创建 pending。历史 API 的排队能力和已有队列保持兼容；没有明确停止授权的后台任务不取消正在运行的 Agent。
+- 活跃子代理迁移暂不支持；不能在其父任务仍持有生命周期时单独卸载。
+
+## Issue #10：标题
+
+原实现调用底层 table.update，但已安装宿主的缓存表使用 get/put。现在以完整 identity/rows 读取并写回，在 attachSession 发布新归属之前对齐 identity.cwd；保留 title 行，移除旧 workingDirectory 行。attach 失败恢复原 identity/rows。
+
+本机“标题保留测试”归档后，标题仍保存在新版 per-record 投影缓存中；修复面板原来只读取旧 session_projcache.json 汇总文件，因此误显示“未命名会话”。现在扫描、归档、预览和备份列表按内存缓存、新版单记录文件、旧版汇总、档案标题的顺序读取。回归测试覆盖新旧缓存共存、内存更新和损坏缓存降级。
+
+报告者 DSH 0.2.0-rc.2 环境尚未直接复现；这是发现并修复的具体代码缺陷，不声称已完成该环境验收。
+
+## 自动验证
+
+- 常规套件包含即时迁移的 DOM 确认/取消、无自动排队、生命周期并发拒绝和卸载恢复检查。
+- test/live-migration.test.mjs 的可选集成项使用从本机 Desktop 提取的 DSH 0.2.1-rc.2、真实 Cordis、SessionStore、AgentRegistry、AgentLoop、JSONL/Zstd writer 和原生文件锁。
+- 检查真实 Agent 创建、释放、物理迁移、目标路径恢复、继续追加、失败回滚后恢复原路径，以及运行中拒绝/明确停止后迁移。
+- 集成测试的 SessionController 入口使用精简实现调用真实 agents.resume；没有启动完整 Desktop、加载真实用户预设或调用在线模型。实际预设、权限与模型恢复依赖下面的 Desktop 人工验收。
+- DSH_TEST_NODE_MODULES 指向已有 runtime/node_modules，运行 npm run test:installed-host；未配置时明确 skip。
+- rc.2 本机 Windows / Node 22.23.2：npm run check 通过，319 项通过、1 项真实宿主可选测试按预期 skip；单独配置真实宿主后 npm run test:installed-host 的 3 项全部通过。rc.3 增补当前对话重新打开的回归检查。跨平台 CI 尚未运行。
+- rc.3：npm run check 通过，325 项通过、1 项可选测试跳过；语法、打包预检和 git diff --check 通过。新增的 6 项界面回归使用 DOM 与宿主服务替身，尚不能替代 Desktop 人工复验。
+- rc.4：npm run check 通过，327 项通过、2 项宿主可选测试跳过；配置真实宿主后 npm run test:installed-host 的 4 项全部通过，包括上述客户端引用释放复现。语法、打包预检和 git diff --check 通过。Desktop 人工复验通过，见本文开头。
+
+## Desktop 验收
+
+1. 保存正在做的工作，从应用菜单或托盘彻底退出 DSH，再启动。自检版本应为 2.4.2-rc.4。
+2. 新建测试会话并命名“标题保留测试”，发送一句消息，等回复结束。拖到 B，确认后应直接显示在 B，无 pending、无需重启。
+3. 不切换到其他会话，在 B 当前界面直接连续发两条消息，确认输入框可用、正常回复，模型/预设/权限及未发送草稿保持预期，有效工作目录为 B。
+4. 让另一个测试会话执行可随时停止的任务，生成回复期间拖动。先取消，原任务继续；再次拖动选择“停止任务并迁移”，确认任务停止后会话出现在 B，可继续发送。
+5. 重启后标题、历史、归属和工作目录仍正确。分别检查手动标题和自动生成标题，并在归档后检查设置中的会话修复列表标题。若异常，保留测试会话，不重复强行搬移。
+
+发布后在 issue #10 说明修复及升级步骤，并邀请原报告者在 DSH 0.2.0-rc.2 复测；待其确认后关闭。

package/lib/index.js

@@ -36,6 +36,7 @@ import { join, dirname, basename, relative, resolve, isAbsolute } from 'node:pat
 import { homedir } from 'node:os';
 import { spawn } from 'node:child_process';
 import { Config, POLICY_FIELDS, buildConfig, attachConfig } from './config.js';
+import { installLifecycle, lifecycleFor, withReleasedSession } from './lifecycle.js';
 
 const name = 'workspace-mover';
 // 只声明真正必需的两个服务。cordis 把 inject 里的**每一项**都当必需：任一缺失，
@@ -913,7 +914,9 @@ async function moveSessionEntry(ctx, payload = {}, hooks = {}) {
 		`workspace:${targetWorkspaceId}`
 	);
 	try {
-		return await moveSession(ctx, { ...payload, sessionId, targetWorkspaceId }, hooks);
+		if (!ctx.workspaceRegistry?.get(targetWorkspaceId)) throw new Error(`unknown workspace '${targetWorkspaceId}'`);
+		return await withReleasedSession(ctx, sessionId, payload.stopRunning === true,
+			() => moveSession(ctx, { ...payload, sessionId, targetWorkspaceId }, hooks));
 	} finally {
 		release();
 	}
@@ -955,7 +958,7 @@ async function moveSession(ctx, { sessionId, targetWorkspaceId, sessionTitle, re
 	const sourceCwd = meta.cwd;
 	const title = typeof sessionTitle === 'string' && sessionTitle.trim()
 		? sessionTitle.trim()
-		: (typeof meta.title === 'string' && meta.title.trim() ? meta.title.trim() : '未命名会话');
+		: readSessionTitle(ctx, sessionId, readProjectionTitles().get(String(sessionId)) ?? meta.title ?? '未命名会话');
 	if (sourceCwd === undefined) throw new Error('session header carries no cwd');
 	if (samePath(sourceCwd, targetPath)) {
 		// 磁盘头已指向目标：若目标工作区还没记账它（历史遗留的未归组会话），
@@ -1129,7 +1132,11 @@ async function moveSession(ctx, { sessionId, targetWorkspaceId, sessionTitle, re
 	// 才会读取 header 并经 mutate 发出 domain/changed。不能直接预置
 	// target.record.sessionIds，否则 attach 变成 no-op，WorkspaceFeed 不会推送目标
 	// 工作区的更新帧，浏览器就会暂时把会话显示在“未分组”。
+	const originalProjection = captureProjection(ctx, sessionId);
 	try {
+		// Listings can read the title during attach: align BEFORE publishing the
+		// new header, otherwise the host rejects the old cwd-bound checkpoint.
+		await realignProjectionIdentity(ctx, sessionId, targetPath);
 		await target.attachSession(sessionId);
 	} catch (err) {
 		// Roll back original bytes and reattach the source workspace.
@@ -1142,6 +1149,7 @@ async function moveSession(ctx, { sessionId, targetWorkspaceId, sessionTitle, re
 				throw new Error(`physical rollback could not move the target directory: ${relocateErr?.message ?? relocateErr}`);
 			}
 			await storage.replace(sourceLocation, original);
+			await writeProjection(ctx, String(sessionId), originalProjection, sourceCwd, true);
 			for (const e of allOwners) {
 				try { if (!rawRecordSessionIds(e).includes(String(sessionId))) await e.attachSession?.(sessionId); } catch { /* ignore */ }
 			}
@@ -1400,6 +1408,26 @@ function readProjectionTitles() {
 	return map;
 }
 
+/** Current hosts use per-record checkpoints; legacy aggregate files can remain
+ * on disk after an upgrade and must never override a current title. */
+function readSessionTitle(ctx, sessionId, fallback = null) {
+	const titleOf = (record) => {
+		const title = record?.rows?.title?.val;
+		return typeof title === 'string' && title.trim() ? title.trim() : null;
+	};
+	const live = titleOf(captureProjection(ctx, sessionId));
+	if (live) return live;
+	try {
+		const id = validId(String(sessionId), 'sessionId');
+		if (/[\\/:]/.test(id) || id === '.' || id === '..') return fallback;
+		const base = process.env.DSH_HOME ?? join(homedir(), '.dsh');
+		const document = JSON.parse(readFileSync(join(base, 'storages', 'session_projcache', 'sessions', `${id}.json`), 'utf8'));
+		const current = titleOf(document?.record);
+		if (current) return current;
+	} catch { /* Cache absence/corruption must not prevent session rescue. */ }
+	return fallback;
+}
+
 /**
  * 扫描存储根下的全部会话档案并分类：
  * - orphaned    头部 cwd 指向的目录已不存在（项目文件夹被移动/改名/删除，官方讨论 #3012）
@@ -1504,8 +1532,8 @@ async function scanSessions(ctx) {
 			: 'misfiled'; // 记账方存在但不是 cwd 匹配的分组
 		items.push({
 			sessionId,
-			title: projectionTitles.get(sessionId)
-				?? (typeof header?.title === 'string' && header.title.trim() ? header.title.trim() : '未命名会话'),
+			title: readSessionTitle(ctx, sessionId, projectionTitles.get(sessionId)
+				?? (typeof header?.title === 'string' && header.title.trim() ? header.title.trim() : '未命名会话')),
 			cwd,
 			status,
 			targetWorkspaceId: matching?.id ?? null,
@@ -1615,12 +1643,8 @@ function invalidateFileReferenceSearches(ctx, stalePath) {
  */
 async function realignProjectionIdentity(ctx, sessionId, nextCwd) {
 	try {
-		const table = peekService(ctx, 'sessionProjectionCache')?.table;
-		if (typeof table?.update !== 'function') return;
-		await table.update(String(sessionId), (rec) =>
-			rec?.identity ? { ...rec, identity: { ...rec.identity, cwd: nextCwd },
-				rows: Object.fromEntries(Object.entries(rec.rows ?? {}).filter(([key]) => key !== 'workingDirectory')) } : rec
-		);
+		const record = captureProjection(ctx, sessionId);
+		await writeProjection(ctx, String(sessionId), record, nextCwd);
 	} catch (err) {
 		ctx.logger?.warn?.(`workspace-mover: projection identity alignment failed for ${sessionId}: ${err?.message ?? err}`);
 	}
@@ -1999,13 +2023,16 @@ async function inspectMovePlan(ctx, { sessionId, targetWorkspaceId, mode = 'curr
 	const repairMembership = sameWorkspace && !rawRecordSessionIds(target).includes(id);
 	let backupPlan = { reused: false, estimatedBytes: 0 };
 	let status = 'safe';
+	const liveMigration = Boolean(lifecycleFor(ctx, id));
 	if (running) {
-		status = 'queued';
-		warnings.push('session is currently running and will wait for idle');
+		status = 'warning';
+		warnings.push('session is running; moving requires explicit stop confirmation');
 	}
 	try { assertNoResidentWriter(ctx, id); } catch (err) {
-		status = 'queued';
-		warnings.push(err.message);
+		if (!liveMigration) {
+			status = 'queued';
+			warnings.push(err.message);
+		}
 	}
 	if (adapter.mode === 'filesystem-fallback') warnings.push('physical move uses the JSONL path fallback; official raw-byte path API is unavailable');
 	if (!adapter.capabilities.physicalPath) {
@@ -2054,10 +2081,11 @@ async function inspectMovePlan(ctx, { sessionId, targetWorkspaceId, mode = 'curr
 		status,
 		canMove: status === 'safe' || status === 'warning' || status === 'queued',
 		sessionId: id,
-		title: readProjectionTitles().get(id) ?? meta.title ?? null,
+		title: readSessionTitle(ctx, id, readProjectionTitles().get(id) ?? meta.title ?? null),
 		source,
 		target: targetInfo,
 		running,
+		liveMigration,
 		branches: { available: true, count: branches.relations.length, mode, sessionIds: branches.ids, relations: branches.relations },
 		estimatedBackupBytes: sameWorkspace ? 0 : backupPlan.estimatedBytes,
 		backup: sameWorkspace ? { reused: false, estimatedBytes: 0 } : backupPlan,
@@ -2067,7 +2095,7 @@ async function inspectMovePlan(ctx, { sessionId, targetWorkspaceId, mode = 'curr
 }
 
 /** 批量迁移入口：逐会话复用 moveSession（各自独立备份/回滚，单条失败不牵连其余）；历史聚合成一条。 */
-async function moveManySessions(ctx, { sessions, targetWorkspaceId, mode = 'current-only' } = {}) {
+async function moveManySessions(ctx, { sessions, targetWorkspaceId, mode = 'current-only', stopRunning = false, allowQueue = true } = {}) {
 	if (!Array.isArray(sessions) || sessions.length === 0) throw new Error('sessions must be a non-empty array');
 	if (sessions.length > batchLimit()) throw new Error(`too many sessions in one batch (max ${batchLimit()}, got ${sessions.length})`);
 	if (typeof targetWorkspaceId !== 'string' || targetWorkspaceId.length === 0) throw new Error('targetWorkspaceId required');
@@ -2113,7 +2141,8 @@ async function moveManySessions(ctx, { sessions, targetWorkspaceId, mode = 'curr
 				sessionId,
 				targetWorkspaceId,
 				sessionTitle: typeof item.sessionTitle === 'string' ? item.sessionTitle : undefined,
-				recordHistory: false
+				recordHistory: false,
+				stopRunning
 			});
 			if (result.attached) attachedCount += 1; else movedCount += 1;
 			let sourceWorkspaceId = null;
@@ -2123,7 +2152,7 @@ async function moveManySessions(ctx, { sessions, targetWorkspaceId, mode = 'curr
 			moved.push({ sessionId, title: result.title, fromCwd: result.from.cwd, sourceWorkspaceId, backup: result.backup ?? null });
 			results.push({ sessionId, ok: true, moved: result.moved, to: result.to.cwd, title: result.title });
 		} catch (err) {
-			if (isBusyError(err)) {
+			if (allowQueue && isBusyError(err)) {
 				const queued = createOrReuseMigration(ctx, {
 					sessionId,
 					targetWorkspaceId,
@@ -3196,14 +3225,14 @@ async function dropProjection(ctx, sessionId) {
 	}
 }
 
-async function writeProjection(ctx, sessionId, record, cwd) {
+async function writeProjection(ctx, sessionId, record, cwd, preserveWorkingDirectory = false) {
 	try {
 		const table = projectionTable(ctx);
 		if (!table || typeof table.put !== 'function' || !record?.identity || !record?.rows) return;
 		// 注意：table 是底层 KvTable，put(key, value) 两参——value 必须是完整 {identity, rows}；
 		// 服务层的 put(id, identity, rows) 三参签名在这里不可用（会整条写坏，域重开时崩）。
 		await table.put(String(sessionId), { identity: { ...record.identity, cwd },
-			rows: Object.fromEntries(Object.entries(record.rows).filter(([key]) => key !== 'workingDirectory')) });
+			rows: preserveWorkingDirectory ? record.rows : Object.fromEntries(Object.entries(record.rows).filter(([key]) => key !== 'workingDirectory')) });
 	} catch (err) {
 		ctx.logger?.warn?.(`workspace-mover: projection restore failed for ${sessionId} (title will rebuild lazily): ${err?.message ?? err}`);
 	}
@@ -3537,7 +3566,7 @@ async function listBackups(ctx) {
 		const { id, ts } = parsed;
 		let sizeBytes = 0;
 		try { sizeBytes = statSync(join(dir, name)).size; } catch { continue; }
-		const g = groups.get(id) ?? { sessionId: id, title: titles.get(id) ?? null, count: 0, totalBytes: 0, oldest: Number(ts), newest: Number(ts), files: [] };
+		const g = groups.get(id) ?? { sessionId: id, title: readSessionTitle(ctx, id, titles.get(id) ?? null), count: 0, totalBytes: 0, oldest: Number(ts), newest: Number(ts), files: [] };
 		g.count++;
 		g.totalBytes += sizeBytes;
 		g.oldest = Math.min(g.oldest, Number(ts));
@@ -4177,6 +4206,7 @@ async function runDoctor(ctx, agentToolsState) {
 
 export function apply(ctx) {
 	const logger = ctx.logger ?? console;
+	ctx.inject?.(['agents'], (owner) => installLifecycle(ctx, owner));
 	const dispatchRef = { fn: null }; // agent 工具在调用期才用到 dispatch，挂载时序无关
 	const agentToolsState = { registered: false };
 	const mount = (owner) => {
@@ -4271,15 +4301,15 @@ export function apply(ctx) {
 							return ok(await moveManySessions(ctx, {
 								sessions: [{ sessionId, sessionTitle: payload?.sessionTitle }],
 								targetWorkspaceId,
-								mode: 'include-descendants'
+								mode: 'include-descendants', stopRunning: payload?.stopRunning === true, allowQueue: payload?.allowQueue !== false
 							}));
 						}
-						const result = await moveSessionEntry(ctx, { sessionId, targetWorkspaceId, sessionTitle: payload?.sessionTitle });
+						const result = await moveSessionEntry(ctx, { sessionId, targetWorkspaceId, sessionTitle: payload?.sessionTitle, stopRunning: payload?.stopRunning === true });
 						logger.info?.(`workspace-mover: moved ${sessionId} -> ${result.to.cwd}`);
 						return ok(result);
 					} catch (err) {
 						logger.warn?.(`workspace-mover: MOVE FAILED sessionId=${payload?.sessionId} target=${payload?.targetWorkspaceId}: ${err?.message ?? err}`);
-						if (isBusyError(err) && typeof payload?.sessionId === 'string' && typeof payload?.targetWorkspaceId === 'string') {
+						if (payload?.allowQueue !== false && isBusyError(err) && typeof payload?.sessionId === 'string' && typeof payload?.targetWorkspaceId === 'string') {
 							const queued = createOrReuseMigration(ctx, {
 								sessionId: payload.sessionId,
 								targetWorkspaceId: payload.targetWorkspaceId,

package/lib/lifecycle.js

@@ -0,0 +1,104 @@
+// Retain the public create/resume disposer. Never close a borrowed persistence
+// writer or rewrite an immutable live Session header.
+import { AsyncLocalStorage } from 'node:async_hooks';
+const migrationContext = new AsyncLocalStorage();
+const original = Symbol.for('cordis.original');
+const runtimes = new WeakMap();
+const raw = (value) => value?.[original] ?? value;
+
+function blocked() {
+	const error = new Error('This session is being migrated; retry after migration completes.');
+	error.code = 'migration-in-progress';
+	return error;
+}
+
+export function installLifecycle(ctx, owner) {
+	const agents = raw(owner.agents);
+	if (!agents || runtimes.has(agents)) return;
+	const runtime = { handles: new Map(), moving: new Set() };
+	runtimes.set(agents, runtime);
+	const restore = [];
+	for (const method of ['create', 'resume']) {
+		const fn = agents[method];
+		if (typeof fn !== 'function') continue;
+		const wrapped = async function (options, ...args) {
+			const id = options?.resumeSessionId ?? options?.sessionId;
+			if (runtime.moving.has(id) && migrationContext.getStore() !== runtime) throw blocked();
+			const handle = await Reflect.apply(fn, this, [options, ...args]);
+			const agent = raw(handle?.agent);
+			if (agent && typeof handle.dispose === 'function') {
+				const guards = [];
+				runtime.handles.set(agent.id, { handle, agent, guards });
+				// Requests that already resolved the old Agent must also be refused
+				// while its lifecycle is draining or after it has been replaced.
+				for (const entry of ['send', 'runMaintenance']) {
+					const action = agent[entry];
+					if (typeof action !== 'function') continue;
+					const guarded = function (...params) {
+						if (runtime.moving.has(agent.id) || raw(agents.get(agent.id)) !== agent) throw blocked();
+						return Reflect.apply(action, this, params);
+					};
+					agent[entry] = guarded;
+					guards.push(() => { if (agent[entry] === guarded) agent[entry] = action; });
+				}
+			}
+			return handle;
+		};
+		agents[method] = wrapped;
+		restore.push(() => { if (agents[method] === wrapped) agents[method] = fn; });
+	}
+	owner.on?.('agent/disposed', ({ agent }) => {
+		if (runtime.handles.get(agent.id)?.agent === raw(agent)) runtime.handles.delete(agent.id);
+	});
+	owner.effect(() => () => {
+		for (const entry of runtime.handles.values()) for (const undo of entry.guards) undo();
+		runtime.handles.clear();
+		for (const undo of restore.reverse()) undo();
+		runtimes.delete(agents);
+	}, 'workspace-mover: restore lifecycle observers');
+}
+
+export function lifecycleFor(ctx, id) {
+	const agents = raw(typeof ctx.get === 'function' ? ctx.get('agents') : ctx.agents);
+	const runtime = agents && runtimes.get(agents);
+	const entry = runtime?.handles.get(id);
+	return entry && raw(agents.get(id)) === entry.agent ? { ...entry, runtime, agents } : null;
+}
+
+export async function withReleasedSession(ctx, id, stopRunning, operation) {
+	const owned = lifecycleFor(ctx, id);
+	if (!owned) return operation();
+	const { handle, agent, runtime } = owned;
+	if (agent.status === 'running' && !stopRunning) {
+		const error = new Error('Session is running. Confirm stop and move, or cancel migration.');
+		error.code = 'stop-required';
+		throw error;
+	}
+	if (agent.session.header?.parentSession || agent.session.header?.origin === 'subagent') {
+		throw new Error('Live subagent migration is unsupported; stop its owning task first.');
+	}
+	runtime.moving.add(id);
+	let result;
+	let failure;
+	try {
+		await handle.dispose(); // owns cancel → drain → close → unregister
+		result = await operation();
+	} catch (error) {
+		failure = error;
+	} finally {
+		runtime.handles.delete(id);
+		try {
+			const controller = ctx.get?.('sessionController');
+			if (typeof controller?.resolveAgent === 'function') {
+				const restored = await migrationContext.run(runtime, () => controller.resolveAgent(id));
+				if (restored?.error) throw restored.error;
+			}
+		} catch (error) {
+			failure = new Error(`${failure ? failure.message : 'Files migrated successfully'}; session reload failed: ${error.message}`, { cause: error });
+		} finally {
+			runtime.moving.delete(id);
+		}
+	}
+	if (failure) throw failure;
+	return result;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-workspace-mover",
-  "version": "2.4.1",
+  "version": "2.4.2",
   "description": "在 DSH 侧边栏安全迁移会话：真迁移原始档案，支持失联会话恢复、移动历史、一键撤回和 agent 工具。",
   "type": "module",
   "main": "lib/index.js",
@@ -21,10 +21,11 @@
     "docs/compatibility",
     "docs/media",
     "LICENSE"
-  ],  "scripts": {
-    "test": "node --test test/core.test.mjs test/e2e-sandbox.test.mjs test/policy.test.mjs test/client-dom.test.mjs test/traffic-badge.test.mjs test/release-downloads.test.mjs test/workspace-tools.test.mjs test/host-services.test.mjs",
-    "test:installed-host": "node --test test/installed-host.test.mjs",
-    "check:syntax": "node --check lib/index.js && node --check client/client.js",
+  ],
+  "scripts": {
+    "test": "node --test test/core.test.mjs test/e2e-sandbox.test.mjs test/policy.test.mjs test/client-dom.test.mjs test/traffic-badge.test.mjs test/release-downloads.test.mjs test/workspace-tools.test.mjs test/host-services.test.mjs test/live-migration.test.mjs",
+    "test:installed-host": "node --test test/installed-host.test.mjs test/live-migration.test.mjs",
+    "check:syntax": "node --check lib/index.js && node --check client/client.js && node --check lib/lifecycle.js",
     "check:pack": "npm pack --dry-run",
     "check": "npm run check:syntax && npm test && npm run check:pack"
   },

package/test/client-dom.test.mjs

@@ -566,7 +566,7 @@ test('拖拽跨组移动：经权威 fiber 通道解析出正确 sessionId', asy
   assert.equal(calls[0].payload.targetWorkspaceId, 'wid-b');
 });
 
-test('迁移标题使用权威预览，不包含侧边栏时间；驻留队列提示可能需重启', async () => {
+test('即时迁移使用权威标题，不包含侧边栏时间，不启用排队', async () => {
   resetDom();
   mount();
   const row = sessionRow('测试刚刚', 'session-aaa');
@@ -575,22 +575,114 @@ test('迁移标题使用权威预览，不包含侧边栏时间；驻留队列
   const prior = rpcResponder;
   setResponder((endpoint, payload) => endpoint === 'mover.preview' ? {
     ok: true, value: {
-      title: '测试', status: 'queued', source: { cwd: 'C:/proj-alpha' },
+      title: '测试', status: 'safe', liveMigration: true, source: { cwd: 'C:/proj-alpha' },
       target: { path: 'C:/proj-beta' }, estimatedBackupBytes: 0,
-      warnings: ['resident writer; restart required']
+      warnings: []
     }
   } : prior(endpoint, payload));
   attach(beta);
   await dragDrop(row, beta, 'session-aaa', { confirm: false });
   const overlay = doc._body.querySelector('.wsm-overlay');
   assert.equal(overlay.querySelector('.wsm-session').textContent, '测试');
-  assert.match(overlay.querySelector('.wsm-preview').textContent, /可能需重启/);
+  assert.doesNotMatch(overlay.querySelector('.wsm-preview').textContent, /可能需重启/);
   assert.doesNotMatch(overlay.querySelector('.wsm-preview').textContent, /进入空闲队列/);
   dispatch({ type: 'click', target: overlay.querySelector('.wsm-ok') });
   await new Promise((resolve) => setTimeout(resolve, 0));
   assert.equal(moveCalls()[0].payload.sessionTitle, '测试');
+  assert.equal(moveCalls()[0].payload.allowQueue, false);
 });
 
+for (const outcome of ['success', 'render-release', 'navigation-during-release', 'rollback', 'transport-error', 'navigated', 'healthy', 'unloaded']) {
+  test(`migration reconnects the removed current conversation via host navigation: ${outcome}`, async () => {
+    resetDom(); mount();
+    const row = sessionRow('标题保留测试', 'session-aaa');
+    const beta = header('proj-beta');
+    fixture({ rows: [row] });
+    attach(beta);
+    let selected = 'session-aaa';
+    let removed = false;
+    const releaseListeners = new Set();
+    let binding;
+    const navigation = [];
+    const ui = {
+      selection: { getSnapshot: () => ({ sessionId: selected }) },
+      clearMain() {
+        navigation.push('release'); selected = undefined;
+        const release = () => {
+          binding = undefined;
+          if (outcome === 'navigation-during-release') selected = 'session-other';
+          for (const listener of releaseListeners) listener();
+        };
+        if (outcome === 'render-release' || outcome === 'navigation-during-release') setTimeout(release, 0);
+        else release();
+      },
+      openSession(id) {
+        assert.equal(binding, undefined, 'must wait for Provider reference release before retaining again');
+        navigation.push(id); selected = id; removed = false; binding = { session };
+      }
+    };
+    const session = {
+      getSnapshot: () => ({ removed }),
+      async open() { navigation.push('ready'); }
+    };
+    binding = { session };
+    const sessions = { binding: () => binding, retainInfo: () => ({
+      subscribe(listener) { releaseListeners.add(listener); return () => releaseListeners.delete(listener); }
+    }) };
+    ctx.get = (key) => ({ uiWorkspace: ui, sessions })[key];
+    const prior = rpcResponder;
+    setResponder((endpoint, payload) => {
+      if (endpoint !== 'mover.move') return prior(endpoint, payload);
+      removed = outcome !== 'healthy';
+      if (outcome === 'navigated') selected = 'session-other';
+      if (outcome === 'unloaded') unmount();
+      if (outcome === 'transport-error') throw new Error('Connection lost after release');
+      if (outcome === 'rollback') return { ok: false, error: { code: 'move-failed', message: 'rolled back cleanly' } };
+      return prior(endpoint, payload);
+    });
+    await dragDrop(row, beta, 'session-aaa');
+    await new Promise((resolve) => setTimeout(resolve, 10));
+    assert.equal(moveCalls().length, 1, 'never repeats the physical migration');
+    if (['navigated', 'healthy', 'unloaded'].includes(outcome)) {
+      assert.deepEqual(navigation, []);
+    } else if (outcome === 'navigation-during-release') {
+      assert.deepEqual(navigation, ['release']);
+      assert.equal(selected, 'session-other');
+    } else {
+      assert.deepEqual(navigation, ['release', 'session-aaa', 'ready']);
+      assert.equal(removed, false, 'new view can accept messages without manually switching');
+    }
+    assert.equal(releaseListeners.size, 0, 'retention observer is released');
+    if (outcome === 'success') {
+      const text = doc._body.querySelector('.wsm-toast')?.textContent;
+      assert.match(text, /重启应用/);
+      assert.doesNotMatch(text, /刷新页面/);
+    }
+    if (outcome === 'rollback') assert.match(doc._body.querySelector('.wsm-toast')?.textContent, /rolled back cleanly/);
+  });
+}
+
+for (const approve of [false, true]) {
+  test(`运行中拖动会话：${approve ? '明确停止后迁移' : '取消不执行'}`, async () => {
+    resetDom(); mount();
+    const row = sessionRow('运行中', 'session-aaa');
+    const beta = header('proj-beta');
+    fixture({ rows: [row] });
+    const prior = rpcResponder;
+    setResponder((endpoint, payload) => endpoint === 'mover.preview' ? { ok: true, value: {
+      status: 'warning', running: true, liveMigration: true, warnings: ['session is running; moving requires explicit stop confirmation']
+    } } : prior(endpoint, payload));
+    attach(beta);
+    await dragDrop(row, beta, 'session-aaa', { confirm: false });
+    const overlay = doc._body.querySelector('.wsm-overlay');
+    assert.equal(overlay.querySelector('.wsm-ok').textContent, '停止任务并迁移');
+    dispatch({ type: 'click', target: overlay.querySelector(approve ? '.wsm-ok' : '.wsm-cancel') });
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    assert.equal(moveCalls().length, approve ? 1 : 0);
+    if (approve) assert.equal(moveCalls()[0].payload.stopRunning, true);
+  });
+}
+
 test('兜底映射错配时不得把错配 id 当成真实会话移动（P2 回归）', async () => {
   resetDom();
   mount();

package/test/e2e-sandbox.test.mjs

@@ -62,13 +62,18 @@ for (const compression of ['none', 'zstd']) {
     writeFileSync(src, original);
     const projections = { identity: { cwd: A }, rows: { workingDirectory: { val: A }, title: { val: 'Keep title' } } };
     let updated;
-    ctx.get = (key) => key === 'sessionProjectionCache' ? { table: { async update(id, fn) { updated = fn(projections); } } } : undefined;
+    let cached = projections;
+    ctx.get = (key) => key === 'sessionProjectionCache' ? { table: {
+      get() { return cached; }, async put(id, value) { cached = updated = value; }
+    } } : undefined;
     entityA.record.sessionIds.push('session-aaa');
     entityB.failAttach = true;
     const failure = await call('mover.move', { sessionId: 'session-aaa', targetWorkspaceId: 'wid-b' });
     assert.equal(failure.ok, false);
     assert.match(failure.error.message, /rolled back cleanly/);
     assert.deepEqual(readFileSync(src), original);
+    assert.equal(cached.identity.cwd, A, 'failed attach restores the title identity');
+    assert.deepEqual(cached.rows, projections.rows, 'rollback restores every original projection row');
     entityB.failAttach = false;
     const moved = await call('mover.move', { sessionId: 'session-aaa', targetWorkspaceId: 'wid-b' });
     assert.equal(moved.ok, true, JSON.stringify(moved));
@@ -1437,6 +1442,46 @@ test('mover.archived 列出归档会话：归属取自原始记账，cwd 挂错
   assert.equal(bbb.suggestedTitle, 'wid-b');
 });
 
+test('current per-record and live titles override legacy titles across repair, archive, preview and backups', async () => {
+  apply(ctx);
+  const id = 'session-aaa';
+  writeFileSync(artifactPath(root, A, id), makeArtifact({ type: 'session', id, cwd: A }));
+  const storage = join(root, 'storages');
+  const checkpoint = join(storage, 'session_projcache', 'sessions', `${id}.json`);
+  mkdirSync(dirname(checkpoint), { recursive: true });
+  writeFileSync(join(storage, 'session_projcache.json'), JSON.stringify({ tables: {
+    sessions: { [id]: { rows: { title: { val: 'Outdated title' } } } }
+  } }), 'utf8');
+  writeFileSync(checkpoint, JSON.stringify({ version: 7, record: {
+    identity: { cwd: A }, rows: { title: { val: '标题保留测试' } }
+  } }), 'utf8');
+  entityA.record.sessionIds.push(id);
+  sharedIndex.sessionPaths.set(id, A);
+  ctx.workspaceRegistry.archivedSessionIds = [id];
+  stashBackup(id, readFileSync(artifactPath(root, A, id)));
+  const titles = async () => {
+    const scan = await call('mover.scan');
+    const archived = await call('mover.archived');
+    const preview = await call('mover.preview', { sessionId: id, targetWorkspaceId: 'wid-b' });
+    const backups = await call('mover.backups.list');
+    for (const result of [scan, archived, preview, backups]) assert.equal(result.ok, true, JSON.stringify(result));
+    return [scan.value.items.find((item) => item.sessionId === id).title,
+      archived.value.items.find((item) => item.sessionId === id).title,
+      preview.value.title, backups.value.items.find((item) => item.sessionId === id).title];
+  };
+  assert.deepEqual(await titles(), Array(4).fill('标题保留测试'));
+  ctx.get = (key) => key === 'sessionProjectionCache' ? { table: {
+    get: () => ({ rows: { title: { val: 'Latest live title' } } })
+  } } : undefined;
+  assert.deepEqual(await titles(), Array(4).fill('Latest live title'));
+  ctx.get = () => undefined;
+  writeFileSync(checkpoint, '{broken', 'utf8');
+  assert.deepEqual(await titles(), Array(4).fill('Outdated title'));
+  rmSync(join(storage, 'session_projcache.json'));
+  const scan = await call('mover.scan');
+  assert.equal(scan.value.items.find((item) => item.sessionId === id).title, '未命名会话');
+});
+
 test('mover.unarchive 取消归档：归档集移除、账本不动、无迁移', async () => {
   apply(ctx);
   entityA.record.sessionIds.push('session-aaa');