@michengai/dsh-codex-ui 0.2.101 → 0.2.102

package/{dist → lib}/index.mjs

@@ -1,10 +1,10 @@
 import { spawn } from "node:child_process";
 import { existsSync } from "node:fs";
-import { mkdir, readFile, rename, rm, unlink, writeFile } from "node:fs/promises";
+import { lstat, mkdir, open, readFile, realpath, rename, rm, unlink, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
-import { basename, dirname, isAbsolute, join, resolve, sep, win32 } from "node:path";
+import { basename, dirname, isAbsolute, join, relative, resolve, sep, win32 } from "node:path";
 import { fileURLToPath } from "node:url";
-import { randomUUID } from "node:crypto";
+import { randomBytes, randomUUID } from "node:crypto";
 //#region src/dependencies.ts
 const SUITE_PACKAGE = "@michengai/dsh-codex-suite";
 const SUITE_MEMBER_PACKAGES = [
@@ -820,11 +820,26 @@ function requireService(ctx, key, method) {
 }
 /** 在唯一的宿主边界校验服务能力；宿主 API 变更时立即失败，不会静默返回 503。 */
 function hostServices(ctx) {
+	const emit = ctx.emit;
 	return {
 		webServer: requireService(ctx, "webServer", "register"),
 		agents: requireService(ctx, "agents", "get"),
+		sessions: requireService(ctx, "sessions", "get"),
+		sessionPersistence: requireService(ctx, "sessionPersistence", "list"),
 		tools: requireService(ctx, "tools", "schemas"),
-		workspaceRegistry: requireService(ctx, "workspaceRegistry", "list")
+		workspaceRegistry: requireService(ctx, "workspaceRegistry", "list"),
+		sessionProjectionCache: ctx.get("sessionProjectionCache"),
+		emit: (event, ...args) => {
+			emit.call(ctx, event, ...args);
+		},
+		logger: {
+			warn: (message) => {
+				ctx.logger.warn("%s", message);
+			},
+			info: (message) => {
+				ctx.logger.info("%s", message);
+			}
+		}
 	};
 }
 //#endregion
@@ -1046,6 +1061,409 @@ var ForegroundExplorer = class {
 	}
 };
 //#endregion
+//#region src/session-migration.ts
+var SessionMoveError = class extends Error {
+	code;
+	constructor(code, message, options) {
+		super(message, options);
+		this.code = code;
+		this.name = "SessionMoveError";
+	}
+};
+const movingSessions = /* @__PURE__ */ new Set();
+function rawSessionIds(workspace) {
+	return Array.isArray(workspace.record?.sessionIds) ? workspace.record.sessionIds : workspace.sessionIds;
+}
+function validIdentifier(value) {
+	return value.length > 0 && value.length <= 512 && !/[\u0000-\u001f\u007f]/.test(value);
+}
+async function pathExists(path) {
+	try {
+		await lstat(path);
+		return true;
+	} catch (error) {
+		if (error.code === "ENOENT") return false;
+		throw error;
+	}
+}
+async function writeTemporaryFile(finalPath, data) {
+	const temporaryPath = `${finalPath}.${randomBytes(6).toString("hex")}.tmp`;
+	const handle = await open(temporaryPath, "wx", 384);
+	try {
+		await handle.writeFile(data);
+		await handle.sync();
+	} finally {
+		await handle.close();
+	}
+	return temporaryPath;
+}
+async function encodeSessionArtifact(headerLine, body, zstd) {
+	if (!zstd) return Buffer.from(`${headerLine}\n${body}`, "utf8");
+	const { zstdCompress } = await import("node:zlib");
+	if (typeof zstdCompress !== "function") throw new SessionMoveError("session-move/zstd-unavailable", "当前 Node.js 运行时不支持 Zstd 会话迁移。");
+	const compress = (data) => new Promise((resolvePromise, rejectPromise) => {
+		zstdCompress(data, (error, output) => {
+			if (error === null) resolvePromise(output);
+			else rejectPromise(error);
+		});
+	});
+	const headerFrame = await compress(Buffer.from(`${headerLine}\n`, "utf8"));
+	if (body === "") return headerFrame;
+	const bodyFrame = await compress(Buffer.from(body, "utf8"));
+	return Buffer.concat([headerFrame, bodyFrame]);
+}
+var ArtifactDirectoryMove = class {
+	oldArtifact;
+	newArtifact;
+	directoryMoved = false;
+	backupCreated = false;
+	published = false;
+	temporaryPath;
+	oldDirectory;
+	newDirectory;
+	movedOldArtifact;
+	backupArtifact;
+	constructor(oldArtifact, newArtifact) {
+		this.oldArtifact = oldArtifact;
+		this.newArtifact = newArtifact;
+		this.oldDirectory = dirname(oldArtifact);
+		this.newDirectory = dirname(newArtifact);
+		const relativeArtifact = relative(this.oldDirectory, oldArtifact);
+		if (relativeArtifact.startsWith("..") || resolve(this.oldDirectory, relativeArtifact) !== resolve(oldArtifact)) throw new SessionMoveError("session-move/path-invalid", "会话工件路径无效。");
+		this.movedOldArtifact = join(this.newDirectory, relativeArtifact);
+		this.backupArtifact = join(this.newDirectory, `${basename(oldArtifact)}.${randomBytes(6).toString("hex")}.dcu-backup`);
+	}
+	async publish(bytes) {
+		if (resolve(this.oldDirectory).toLowerCase() === resolve(this.newDirectory).toLowerCase()) throw new SessionMoveError("session-move/path-conflict", "源项目和目标项目使用了相同的会话目录。");
+		if (await pathExists(this.newDirectory)) throw new SessionMoveError("session-move/destination-occupied", "目标项目已经存在同名会话工件。");
+		try {
+			await mkdir(dirname(this.newDirectory), { recursive: true });
+			await rename(this.oldDirectory, this.newDirectory);
+			this.directoryMoved = true;
+			await rename(this.movedOldArtifact, this.backupArtifact);
+			this.backupCreated = true;
+			this.temporaryPath = await writeTemporaryFile(this.newArtifact, bytes);
+			await rename(this.temporaryPath, this.newArtifact);
+			this.temporaryPath = void 0;
+			this.published = true;
+		} catch (error) {
+			try {
+				await this.rollback();
+			} catch (rollbackError) {
+				throw new SessionMoveError("session-move/rollback-failed", "迁移会话工件失败，且自动回滚未完整完成。", { cause: rollbackError });
+			}
+			if (error instanceof SessionMoveError) throw error;
+			throw new SessionMoveError("session-move/artifact-failed", "迁移会话工件失败，原会话已恢复。", { cause: error });
+		}
+	}
+	async rollback() {
+		const failures = [];
+		if (this.temporaryPath !== void 0) {
+			try {
+				await rm(this.temporaryPath, { force: true });
+			} catch (error) {
+				failures.push(error);
+			}
+			this.temporaryPath = void 0;
+		}
+		if (this.published) try {
+			await rm(this.newArtifact, { force: true });
+			this.published = false;
+		} catch (error) {
+			failures.push(error);
+		}
+		if (this.backupCreated) try {
+			await rename(this.backupArtifact, this.movedOldArtifact);
+			this.backupCreated = false;
+		} catch (error) {
+			failures.push(error);
+		}
+		if (this.directoryMoved) try {
+			await mkdir(dirname(this.oldDirectory), { recursive: true });
+			await rename(this.newDirectory, this.oldDirectory);
+			this.directoryMoved = false;
+		} catch (error) {
+			failures.push(error);
+		}
+		if (failures.length > 0) throw new AggregateError(failures, "会话工件回滚失败");
+	}
+	async commit(logger) {
+		if (!this.backupCreated) return;
+		try {
+			await rm(this.backupArtifact, { force: true });
+			this.backupCreated = false;
+		} catch (error) {
+			logger?.warn(`会话迁移成功，但旧工件备份清理失败：${String(error)}`);
+		}
+	}
+};
+function workspaceSnapshots(workspaces, sessionId) {
+	return workspaces.map((workspace) => {
+		const ids = [...rawSessionIds(workspace)];
+		const index = ids.indexOf(sessionId);
+		return {
+			workspace,
+			contained: index >= 0,
+			beforeId: index >= 0 ? ids[index + 1] : void 0
+		};
+	});
+}
+async function restoreWorkspaceSnapshots(snapshots, sessionId) {
+	for (const snapshot of snapshots) if (!snapshot.contained && rawSessionIds(snapshot.workspace).includes(sessionId)) await snapshot.workspace.detachSession(sessionId);
+	for (const snapshot of snapshots) {
+		if (!snapshot.contained) continue;
+		if (!rawSessionIds(snapshot.workspace).includes(sessionId)) await snapshot.workspace.attachSession(sessionId);
+		const currentIds = rawSessionIds(snapshot.workspace);
+		const beforeId = snapshot.beforeId !== void 0 && currentIds.includes(snapshot.beforeId) ? snapshot.beforeId : void 0;
+		await snapshot.workspace.insertSessionBefore(sessionId, beforeId);
+	}
+}
+async function enterStoredSession(services, sessionId, stored) {
+	const preparation = services.sessionPersistence.prepare === void 0 ? void 0 : await services.sessionPersistence.prepare(sessionId);
+	const session = preparation?.session ?? services.sessions.prepare(sessionId, {
+		seedSource: "persistence",
+		seed: stored.events,
+		meta: stored.meta,
+		inheritedEventCount: stored.inheritedEventCount
+	});
+	const detach = services.sessions.enter(session);
+	try {
+		services.sessions.announce?.(session);
+	} catch (error) {
+		detach();
+		preparation?.[Symbol.dispose]();
+		throw error;
+	}
+	return {
+		detach,
+		releasePreparation: () => {
+			preparation?.[Symbol.dispose]();
+		}
+	};
+}
+function detachOriginalEntry(store, sessionId, entry) {
+	if (store === void 0 || entry === void 0 || store.get(sessionId) !== entry) return;
+	if (entry.detach === void 0) throw new SessionMoveError("session-move/service-unavailable", "宿主无法安全释放原会话入口。");
+	entry.detach();
+	if (store.get(sessionId) === entry) throw new SessionMoveError("session-move/quiesce-failed", "原会话入口未能完整释放。");
+}
+async function rollbackMove(services, sessionId, transaction, snapshots, originalStored, originalEntry, enteredPlaceholder) {
+	const failures = [];
+	try {
+		enteredPlaceholder?.detach();
+	} catch (error) {
+		failures.push(error);
+	}
+	try {
+		enteredPlaceholder?.releasePreparation();
+	} catch (error) {
+		failures.push(error);
+	}
+	try {
+		await transaction.rollback();
+	} catch (error) {
+		failures.push(error);
+	}
+	let restored;
+	try {
+		if (services.sessions.get(sessionId) === void 0) restored = await enterStoredSession(services, sessionId, originalStored);
+		await restoreWorkspaceSnapshots(snapshots, sessionId);
+	} catch (error) {
+		failures.push(error);
+	} finally {
+		try {
+			if (originalEntry === void 0) restored?.detach();
+			restored?.releasePreparation();
+		} catch (error) {
+			failures.push(error);
+		}
+	}
+	if (failures.length > 0) throw new AggregateError(failures, "会话迁移回滚失败");
+}
+async function moveAccounting(target, snapshots, sessionId) {
+	for (const snapshot of snapshots) if (snapshot.workspace.id !== target.id && snapshot.contained) await snapshot.workspace.detachSession(sessionId);
+	await target.attachSession(sessionId);
+}
+/**
+* 把持久化会话完整迁移到目标项目。整个会话目录一起移动，任何提交前失败都会恢复原工件和项目顺序。
+*/
+async function moveSessionToWorkspace(services, sessionId, targetWorkspaceId, options = {}) {
+	if (!validIdentifier(sessionId) || !validIdentifier(targetWorkspaceId)) throw new SessionMoveError("session-move/invalid-request", "会话或目标项目标识无效。");
+	if (movingSessions.has(sessionId)) throw new SessionMoveError("session-move/busy", "该会话正在移动，请稍后重试。");
+	movingSessions.add(sessionId);
+	try {
+		const workspaces = services.workspaceRegistry.list();
+		const target = workspaces.find((workspace) => workspace.id === targetWorkspaceId);
+		if (target === void 0) throw new SessionMoveError("session-move/workspace-not-found", "目标项目不存在。");
+		const snapshots = workspaceSnapshots(workspaces, sessionId);
+		const targetSnapshot = snapshots.find((snapshot) => snapshot.workspace.id === target.id);
+		const sources = snapshots.filter((snapshot) => snapshot.contained && snapshot.workspace.id !== target.id);
+		if (sources.length > 1 || targetSnapshot?.contained === true && sources.length > 0) throw new SessionMoveError("session-move/accounting-invalid", "会话当前的项目归属不一致，无法安全移动。");
+		const persistedHeader = (await services.sessionPersistence.list()).find((header) => header.id === sessionId);
+		if (persistedHeader === void 0) throw new SessionMoveError("session-move/session-not-found", "该会话没有可迁移的持久化记录。");
+		if (persistedHeader.origin === "subagent") throw new SessionMoveError("session-move/subagent-unsupported", "子代理会话不能移动到其他项目。");
+		const targetPath = await realpath(target.path);
+		let currentPath;
+		if (persistedHeader.cwd !== void 0) try {
+			currentPath = await realpath(persistedHeader.cwd);
+		} catch {
+			currentPath = void 0;
+		}
+		if (currentPath === targetPath && targetSnapshot?.contained === true && sources.length === 0) return {
+			sessionId,
+			moved: false,
+			fromWorkspaceIds: [target.id],
+			toWorkspaceId: target.id,
+			toWorkspaceTitle: target.title || target.id
+		};
+		const liveSession = services.sessions.get(sessionId);
+		const originalEntry = services.sessions.store?.get(sessionId);
+		if (liveSession !== void 0 && (services.sessions.store === void 0 || originalEntry === void 0)) throw new SessionMoveError("session-move/service-unavailable", "宿主无法提供可恢复的会话入口，暂时不能移动活跃会话。");
+		if (currentPath === targetPath) {
+			const stored = liveSession === void 0 ? await services.sessionPersistence.loadStored(sessionId) : void 0;
+			if (liveSession === void 0 && stored === void 0) throw new SessionMoveError("session-move/session-not-found", "读取会话持久化记录失败。");
+			let enteredPlaceholder;
+			try {
+				if (stored !== void 0) enteredPlaceholder = await enterStoredSession(services, sessionId, stored);
+				await moveAccounting(target, snapshots, sessionId);
+			} catch (error) {
+				try {
+					await restoreWorkspaceSnapshots(snapshots, sessionId);
+				} catch (rollbackError) {
+					throw new SessionMoveError("session-move/rollback-failed", "恢复项目归属失败。", { cause: rollbackError });
+				}
+				throw new SessionMoveError("session-move/accounting-failed", "更新项目归属失败，原会话已恢复。", { cause: error });
+			} finally {
+				enteredPlaceholder?.detach();
+				enteredPlaceholder?.releasePreparation();
+			}
+			return {
+				sessionId,
+				moved: true,
+				fromWorkspaceIds: sources.map((snapshot) => snapshot.workspace.id),
+				toWorkspaceId: target.id,
+				toWorkspaceTitle: target.title || target.id
+			};
+		}
+		const agent = services.agents.get(sessionId);
+		try {
+			if (agent !== void 0) {
+				agent.cancel({ kind: "disposed" });
+				await agent.whenIdle?.();
+			}
+			if (liveSession !== void 0) await services.sessions.flush(liveSession);
+		} catch (error) {
+			throw new SessionMoveError("session-move/quiesce-failed", "会话仍在运行，暂时无法移动。", { cause: error });
+		}
+		const raw = await services.sessionPersistence.readRaw(sessionId);
+		const originalStored = await services.sessionPersistence.loadStored(sessionId);
+		if (raw === void 0 || originalStored === void 0) throw new SessionMoveError("session-move/session-not-found", "读取会话持久化记录失败。");
+		const newlineIndex = raw.content.indexOf("\n");
+		const headerText = newlineIndex < 0 ? raw.content : raw.content.slice(0, newlineIndex);
+		const body = newlineIndex < 0 ? "" : raw.content.slice(newlineIndex + 1);
+		let header;
+		try {
+			header = JSON.parse(headerText);
+		} catch (error) {
+			throw new SessionMoveError("session-move/artifact-invalid", "会话工件头部无法解析。", { cause: error });
+		}
+		if (header.id !== sessionId) throw new SessionMoveError("session-move/artifact-invalid", "会话工件标识与请求不一致。");
+		const targetHeader = {
+			...header,
+			cwd: targetPath
+		};
+		const targetMeta = {
+			...raw.meta,
+			cwd: targetPath
+		};
+		const oldLocation = services.sessionPersistence.locate(raw.meta);
+		const newLocation = services.sessionPersistence.locate(targetMeta);
+		if (oldLocation === void 0 || newLocation === void 0) throw new SessionMoveError("session-move/path-invalid", "宿主无法定位会话工件。");
+		const bytes = await (options.encodeArtifact ?? encodeSessionArtifact)(JSON.stringify(targetHeader), body, newLocation.path.endsWith(".zstd"));
+		const transaction = new ArtifactDirectoryMove(oldLocation.path, newLocation.path);
+		try {
+			await agent?.scope?.dispose?.();
+			services.agents.store?.delete(sessionId);
+			detachOriginalEntry(services.sessions.store, sessionId, originalEntry);
+		} catch (error) {
+			if (originalEntry !== void 0 && services.sessions.get(sessionId) === void 0) try {
+				(await enterStoredSession(services, sessionId, originalStored)).releasePreparation();
+			} catch (restoreError) {
+				throw new SessionMoveError("session-move/rollback-failed", "恢复原会话入口失败。", { cause: restoreError });
+			}
+			throw new SessionMoveError("session-move/quiesce-failed", "会话仍在运行，暂时无法移动。", { cause: error });
+		}
+		let enteredPlaceholder;
+		try {
+			await transaction.publish(bytes);
+			const movedStored = await services.sessionPersistence.loadStored(sessionId);
+			if (movedStored === void 0 || movedStored.meta.cwd !== targetPath) throw new SessionMoveError("session-move/validation-failed", "迁移后的会话工件校验失败。");
+			enteredPlaceholder = await enterStoredSession(services, sessionId, movedStored);
+			try {
+				await moveAccounting(target, snapshots, sessionId);
+			} catch (error) {
+				throw new SessionMoveError("session-move/accounting-failed", "更新项目归属失败。", { cause: error });
+			}
+			enteredPlaceholder.detach();
+			enteredPlaceholder.releasePreparation();
+			enteredPlaceholder = void 0;
+			await transaction.commit(services.logger);
+		} catch (error) {
+			try {
+				await rollbackMove(services, sessionId, transaction, snapshots, originalStored, originalEntry, enteredPlaceholder);
+			} catch (rollbackError) {
+				throw new SessionMoveError("session-move/rollback-failed", "会话移动失败，且自动回滚未完整完成。", { cause: rollbackError });
+			}
+			if (error instanceof SessionMoveError) throw error;
+			throw new SessionMoveError("session-move/failed", "会话移动失败，原会话已恢复。", { cause: error });
+		}
+		try {
+			await services.sessionProjectionCache?.coldSnapshot?.(sessionId);
+		} catch (error) {
+			services.logger?.warn(`会话已移动，但投影缓存刷新失败：${String(error)}`);
+		}
+		services.logger?.info?.(`会话 ${sessionId} 已移动到项目 ${target.id}`);
+		return {
+			sessionId,
+			moved: true,
+			fromWorkspaceIds: sources.map((snapshot) => snapshot.workspace.id),
+			toWorkspaceId: target.id,
+			toWorkspaceTitle: target.title || target.id
+		};
+	} finally {
+		movingSessions.delete(sessionId);
+	}
+}
+/** 对持久化分组做严格校验，避免一个项目同时出现在多个分组。 */
+function parseWorkspaceGroups(value) {
+	if (!Array.isArray(value) || value.length > 100) return void 0;
+	const groupIds = /* @__PURE__ */ new Set();
+	const groupTitles = /* @__PURE__ */ new Set();
+	const workspaceIds = /* @__PURE__ */ new Set();
+	const groups = [];
+	for (const valueGroup of value) {
+		if (valueGroup === null || typeof valueGroup !== "object") return void 0;
+		const group = valueGroup;
+		const id = typeof group.id === "string" ? group.id.trim() : "";
+		const title = typeof group.title === "string" ? group.title.trim() : "";
+		if (id === "" || id.length > 128 || title === "" || title.length > 80) return void 0;
+		if (groupIds.has(id) || groupTitles.has(title.toLocaleLowerCase())) return void 0;
+		if (!Array.isArray(group.workspaceIds) || group.workspaceIds.length > 1e3) return void 0;
+		const normalizedIds = [...new Set(group.workspaceIds)];
+		if (!normalizedIds.every((workspaceId) => typeof workspaceId === "string" && workspaceId.trim() !== "" && workspaceId.length <= 256)) return void 0;
+		if (normalizedIds.some((workspaceId) => workspaceIds.has(workspaceId))) return void 0;
+		groupIds.add(id);
+		groupTitles.add(title.toLocaleLowerCase());
+		normalizedIds.forEach((workspaceId) => workspaceIds.add(workspaceId));
+		groups.push({
+			id,
+			title,
+			workspaceIds: normalizedIds
+		});
+	}
+	return groups;
+}
+//#endregion
 //#region src/workspace-preferences.ts
 const WORKSPACE_PREFERENCES_FILE = ".dsh-codex-ui-preferences.json";
 /** Desktop 和普通 DSH Web 共用 Profile；服务换端口或重启后目录仍保持稳定。 */
@@ -1061,11 +1479,19 @@ function parsePinnedWorkspaceIds(value) {
 function parseWorkspacePreferences(value) {
 	if (value === null || typeof value !== "object") return void 0;
 	const record = value;
-	if (record.version !== 1) return void 0;
 	const pinnedWorkspaceIds = parsePinnedWorkspaceIds(record.pinnedWorkspaceIds);
-	return pinnedWorkspaceIds === void 0 ? void 0 : {
-		version: 1,
-		pinnedWorkspaceIds
+	if (pinnedWorkspaceIds === void 0) return void 0;
+	if (record.version === 1) return {
+		version: 2,
+		pinnedWorkspaceIds,
+		workspaceGroups: []
+	};
+	if (record.version !== 2) return void 0;
+	const workspaceGroups = parseWorkspaceGroups(record.workspaceGroups);
+	return workspaceGroups === void 0 ? void 0 : {
+		version: 2,
+		pinnedWorkspaceIds,
+		workspaceGroups
 	};
 }
 async function readWorkspacePreferences(path = workspacePreferencesPath()) {
@@ -1078,8 +1504,9 @@ async function readWorkspacePreferences(path = workspacePreferencesPath()) {
 		};
 	} catch (error) {
 		if (error.code === "ENOENT") return {
-			version: 1,
+			version: 2,
 			pinnedWorkspaceIds: [],
+			workspaceGroups: [],
 			exists: false
 		};
 		throw error;
@@ -1090,16 +1517,18 @@ function temporaryPath(path) {
 }
 let writeQueue = Promise.resolve();
 /** 串行、原子保存，避免快速拖动排序产生乱序或半截 JSON。 */
-function writeWorkspacePreferences(pinnedWorkspaceIds, path = workspacePreferencesPath()) {
+function writeWorkspacePreferences(pinnedWorkspaceIds, workspaceGroups = [], path = workspacePreferencesPath()) {
 	const normalized = parsePinnedWorkspaceIds([...pinnedWorkspaceIds]);
-	if (normalized === void 0) return Promise.reject(/* @__PURE__ */ new Error("置顶工作区数据无效。"));
+	const normalizedGroups = parseWorkspaceGroups([...workspaceGroups]);
+	if (normalized === void 0 || normalizedGroups === void 0) return Promise.reject(/* @__PURE__ */ new Error("工作区偏好数据无效。"));
 	const task = writeQueue.catch(() => void 0).then(async () => {
 		await mkdir(dirname(path), { recursive: true });
 		const temporary = temporaryPath(path);
 		try {
 			await writeFile(temporary, `${JSON.stringify({
-				version: 1,
-				pinnedWorkspaceIds: normalized
+				version: 2,
+				pinnedWorkspaceIds: normalized,
+				workspaceGroups: normalizedGroups
 			}, void 0, 2)}\n`, "utf8");
 			await rename(temporary, path);
 		} finally {
@@ -1115,6 +1544,7 @@ const connectorsEndpoint = "/api/michengai/codex-ui/connectors";
 const dependenciesEndpoint = "/api/michengai/codex-ui/dependencies";
 const explorerEndpoint = "/api/michengai/codex-ui/open-in-explorer";
 const preferencesEndpoint = "/api/michengai/codex-ui/preferences";
+const sessionMoveEndpoint = "/api/michengai/codex-ui/session-move";
 const maxPreferencesBodyBytes = 32768;
 function headerValue(headers, name) {
 	const value = headers[name];
@@ -1169,8 +1599,37 @@ const inject = [
 	"webServer",
 	"agents",
 	"tools",
-	"workspaceRegistry"
+	"workspaceRegistry",
+	"sessions",
+	"sessionPersistence"
 ];
+function sessionMoveStatus(error) {
+	if (!(error instanceof SessionMoveError)) return 500;
+	if (error.code === "session-move/invalid-request") return 400;
+	if (error.code === "session-move/session-not-found" || error.code === "session-move/workspace-not-found") return 404;
+	if (error.code === "session-move/service-unavailable") return 503;
+	if (error.code === "session-move/zstd-unavailable") return 501;
+	if (error.code === "session-move/busy" || error.code === "session-move/subagent-unsupported" || error.code === "session-move/accounting-invalid" || error.code === "session-move/destination-occupied") return 409;
+	return 500;
+}
+function publicSessionMoveError(error) {
+	const code = error instanceof SessionMoveError ? error.code : "session-move/failed";
+	return {
+		code,
+		error: {
+			"session-move/invalid-request": "会话或目标项目标识无效。",
+			"session-move/session-not-found": "该会话没有可迁移的持久化记录。",
+			"session-move/workspace-not-found": "目标项目不存在。",
+			"session-move/service-unavailable": "宿主暂时无法安全移动活跃会话。",
+			"session-move/subagent-unsupported": "子代理会话不能移动到其他项目。",
+			"session-move/busy": "该会话正在移动，请稍后重试。",
+			"session-move/accounting-invalid": "会话当前的项目归属不一致，无法安全移动。",
+			"session-move/destination-occupied": "目标项目已经存在同名会话工件。",
+			"session-move/zstd-unavailable": "当前运行环境不支持该会话的存储格式。",
+			"session-move/rollback-failed": "移动失败，自动恢复未完整完成，请查看服务端日志。"
+		}[code] ?? "暂时无法移动该会话，请稍后重试。"
+	};
+}
 /** 提供不泄露地址、命令和凭证的连接器目录。 */
 function apply(ctx) {
 	const host = hostServices(ctx);
@@ -1337,23 +1796,27 @@ function apply(ctx) {
 							return;
 						}
 						const body = JSON.parse(await readRequestBody(request));
-						const pinnedWorkspaceIds = body !== null && typeof body === "object" ? parsePinnedWorkspaceIds(body.pinnedWorkspaceIds) : void 0;
-						if (pinnedWorkspaceIds === void 0) {
+						const record = body !== null && typeof body === "object" ? body : void 0;
+						const pinnedWorkspaceIds = record === void 0 ? void 0 : parsePinnedWorkspaceIds(record.pinnedWorkspaceIds);
+						const existing = await readWorkspacePreferences();
+						const workspaceGroups = record === void 0 ? void 0 : "workspaceGroups" in record ? parseWorkspaceGroups(record.workspaceGroups) : existing.workspaceGroups;
+						if (pinnedWorkspaceIds === void 0 || workspaceGroups === void 0) {
 							response.writeHead(400, {
 								"content-type": "application/json; charset=utf-8",
 								"cache-control": "no-store"
 							});
-							response.end(JSON.stringify({ error: "置顶偏好格式无效。" }));
+							response.end(JSON.stringify({ error: "工作区偏好格式无效。" }));
 							return;
 						}
-						await writeWorkspacePreferences(pinnedWorkspaceIds);
+						await writeWorkspacePreferences(pinnedWorkspaceIds, workspaceGroups);
 						response.writeHead(200, {
 							"content-type": "application/json; charset=utf-8",
 							"cache-control": "no-store"
 						});
 						response.end(JSON.stringify({
-							version: 1,
+							version: 2,
 							pinnedWorkspaceIds,
+							workspaceGroups,
 							exists: true
 						}));
 						return;
@@ -1386,6 +1849,79 @@ function apply(ctx) {
 				}
 			}
 		});
+		const disposeSessionMove = host.webServer.register({
+			kind: "exact",
+			path: sessionMoveEndpoint,
+			handler: async (request, response) => {
+				if (request.method !== "POST") {
+					response.writeHead(405, { allow: "POST" });
+					response.end();
+					return;
+				}
+				if (crossSiteRequest(request)) {
+					response.writeHead(403, {
+						"content-type": "application/json; charset=utf-8",
+						"cache-control": "no-store"
+					});
+					response.end(JSON.stringify({
+						ok: false,
+						code: "session-move/cross-site",
+						error: "已拒绝跨站请求。"
+					}));
+					return;
+				}
+				try {
+					const body = JSON.parse(await readRequestBody(request));
+					const record = body !== null && typeof body === "object" ? body : void 0;
+					const sessionId = typeof record?.sessionId === "string" ? record.sessionId.trim() : "";
+					const targetWorkspaceId = typeof record?.targetWorkspaceId === "string" ? record.targetWorkspaceId.trim() : "";
+					const result = await moveSessionToWorkspace(host, sessionId, targetWorkspaceId);
+					response.writeHead(200, {
+						"content-type": "application/json; charset=utf-8",
+						"cache-control": "no-store"
+					});
+					response.end(JSON.stringify({
+						ok: true,
+						result
+					}));
+				} catch (error) {
+					if (error instanceof RequestBodyTooLargeError) {
+						response.writeHead(413, {
+							"content-type": "application/json; charset=utf-8",
+							"cache-control": "no-store"
+						});
+						response.end(JSON.stringify({
+							ok: false,
+							code: "session-move/invalid-request",
+							error: "请求体过大。"
+						}));
+						return;
+					}
+					if (error instanceof SyntaxError) {
+						response.writeHead(400, {
+							"content-type": "application/json; charset=utf-8",
+							"cache-control": "no-store"
+						});
+						response.end(JSON.stringify({
+							ok: false,
+							code: "session-move/invalid-request",
+							error: "请求格式无效。"
+						}));
+						return;
+					}
+					ctx.logger.warn("session move failed: %s", error);
+					const payload = publicSessionMoveError(error);
+					response.writeHead(sessionMoveStatus(error), {
+						"content-type": "application/json; charset=utf-8",
+						"cache-control": "no-store"
+					});
+					response.end(JSON.stringify({
+						ok: false,
+						...payload
+					}));
+				}
+			}
+		});
 		const disposeExplorer = host.webServer.register({
 			kind: "exact",
 			path: explorerEndpoint,
@@ -1456,6 +1992,7 @@ function apply(ctx) {
 			disposeDependencies();
 			disposeExplorer();
 			disposePreferences();
+			disposeSessionMove();
 		};
 	}, "michengai-codex-ui: catalogs");
 }