lantern-harness 0.1.1 → 0.1.2

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # 版本日志
 
+## [0.1.2] - 2026-10-18
+
+### 变更
+
+- 升级命令由 `lantern install [版本]` 改为 `lantern update` / `lantern update <版本>`，帮助与文档同步；`lantern install` 保留为兼容别名
+- ACP `initialize` 的版本号改为读 `package.json`，不再随发版手改
+
+### 修复
+
+- 重新 `lantern init` 换了数据目录后，空间列表与「当前空间」仍指向上一个数据目录里的空间：注册表改为按池根分区（每条空间记 `root`，激活项记 `activeByRoot`），列表只看当前数据目录；旧版全局 `activeId` 与无 `root` 的条目在读取时按路径推断归属，向后兼容
+- `lantern web` / `lantern status` 把生效的空间目录标成「当前空间」，不再和数据目录混为一谈
+
 ## [0.1.1] - 2026-10-18
 
 ### 变更
@@ -151,5 +163,6 @@ Lantern Harness 首个版本：AI 工作台。一份进程里隔离多套项目
 - 开发服忽略打开内容库目录与空间元数据目录导致的整页热更新
 - 文档与 CLI 统一 pnpm 优先：安装 / 卸载 / 版本列表优先调用 pnpm（未安装则回退 npm）；README、安装手册、操作手册与贡献约定的开发命令改为 pnpm
 
+[0.1.2]: https://www.npmjs.com/package/lantern-harness/v/0.1.2
 [0.1.1]: https://www.npmjs.com/package/lantern-harness/v/0.1.1
 [0.1.0]: https://www.npmjs.com/package/lantern-harness/v/0.1.0

package/README.md

@@ -28,7 +28,7 @@ AI 工作台：对话与插件工具、需求 / 用例 / 知识 / 提示词内
 npx lantern-harness
 ```
 
-执行后会安装全局短命令 `lantern`，之后用 `lantern init` / `lantern web` 操作即可。升级用 `lantern install`。
+执行后会安装全局短命令 `lantern`，之后用 `lantern init` / `lantern web` 操作即可。升级用 `lantern update`。
 
 2、 初始化数据空间（首次必做；可再次执行以更换数据空间）：
 
@@ -61,9 +61,9 @@ lantern logs           # 查看服务日志
 lantern doctor         # 检查运行环境与配置是否正常
 lantern help           # 显示操作命令列表
 lantern version        # 显示当前版本号
-lantern list           # 显示可安装的版本列表
-lantern install        # 安装/更新到最新版本
-lantern install 0.1.x  # 安装/更新到指定版本
+lantern list           # 显示可用版本列表
+lantern update         # 更新到最新版本
+lantern update 0.1.x   # 更新到指定版本
 lantern uninstall      # 卸载本机 lantern 命令（保留数据空间）
 lantern wipe           # 删除当前数据空间（需确认；不可恢复）
 lantern space list     # 列出全部数据空间与当前项

package/builtin/session/lh-spaces.mjs

@@ -37,6 +37,7 @@ import {
   resolveSpace,
   sanitizeSpaceName,
   setActiveSpace,
+  setRegistryRoot,
   spaceSize,
 } from '../../cli/spaces.mjs';
 import { loadRunState, saveRunState } from '../../cli/user-config.mjs';
@@ -212,6 +213,8 @@ export function lhSpacesPlugin() {
     configureServer(server) {
       // 首次进入确定基准根；已切换过的空间不会被覆盖
       ensureSpaceContext(server.config.root);
+      // 注册表按池根分区：先告诉它当前是哪个数据目录，才能只认自己的空间与激活项
+      setRegistryRoot(getBaseRoot());
       // 新进程里 activeRoot 默认是公共空间：按注册表回到用户上次选的空间
       syncActiveRoot();
 

package/cli/acp-server.mjs

@@ -13,10 +13,24 @@
  * - session/update  { sessionId, toolCall: { name, status, args?, result? } }
  */
 import readline from 'node:readline';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
 import { headlessAsk, loadHeadlessSettings } from './headless.mjs';
 
 const PROTOCOL_VERSION = 1;
 
+/** 与 package.json 保持同源，避免发版时漏改 */
+const SERVER_VERSION = (() => {
+  try {
+    const pkg = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', 'package.json');
+    return JSON.parse(fs.readFileSync(pkg, 'utf8')).version || '0.0.0';
+  } catch {
+    return '0.0.0';
+  }
+})();
+
 function send(msg) {
   process.stdout.write(`${JSON.stringify(msg)}\n`);
 }
@@ -74,7 +88,7 @@ export async function runAcpServer(opts) {
           protocolVersion: PROTOCOL_VERSION,
           serverInfo: {
             name: 'lantern-harness-acp',
-            version: '0.1.1',
+            version: SERVER_VERSION,
           },
           capabilities: {
             sessions: true,

package/cli/lantern.mjs

@@ -36,6 +36,7 @@ import {
   createSpace,
   discoverSpaces,
   exportSpaceToZip,
+  forgetRegistryRoot,
   importSpaceFromZip,
   listSpaces,
   PUBLIC_SPACE_LABEL,
@@ -43,6 +44,7 @@ import {
   renameSpace,
   resolveSpace,
   setActiveSpace,
+  setRegistryRoot,
 } from './spaces.mjs';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
@@ -143,8 +145,9 @@ function printHelp() {
   lantern doctor            检查运行环境与配置
   lantern help              显示本帮助
   lantern version           显示当前版本号
-  lantern list              显示可安装的版本列表
-  lantern install [版本]    安装/更新（默认 latest）
+  lantern list              显示可用版本列表
+  lantern update            更新到最新版本
+  lantern update <版本>     更新到指定版本
   lantern uninstall         卸载本机 lantern（保留数据空间）
   lantern wipe              删除当前数据空间（需确认）
 
@@ -205,6 +208,7 @@ function requireDataRoot(dirOverride) {
   if (dirOverride) {
     const dataRoot = path.resolve(dirOverride);
     if (!fs.existsSync(dataRoot)) fs.mkdirSync(dataRoot, { recursive: true });
+    setRegistryRoot(dataRoot);
     return dataRoot;
   }
   const result = resolveConfiguredDataRoot();
@@ -212,6 +216,8 @@ function requireDataRoot(dirOverride) {
     printDataRootUnavailable(result);
     process.exit(1);
   }
+  // 注册表按池根分区：换过数据空间后，只认这个目录下的空间
+  setRegistryRoot(result.dataRoot);
   return result.dataRoot;
 }
 
@@ -239,6 +245,8 @@ async function cmdInit() {
   }
   prepareSpacesRoot(spacesRoot);
   saveUserConfig({ dataRoot: spacesRoot, host: '127.0.0.1', port: 4321 });
+  // 换数据目录后注册表要按新池根分区，别把上一个目录的空间与激活项带过来
+  setRegistryRoot(spacesRoot);
   console.log('');
   console.log('数据目录已关联：');
   console.log(`  ${spacesRoot}`);
@@ -267,7 +275,7 @@ async function runForegroundServer(dataRoot) {
   console.log('');
   console.log('Lantern Harness 已启动');
   console.log(`  地址：${url}`);
-  console.log(`  数据空间：${root}`);
+  console.log(`  当前空间：${root}`);
   console.log('  按 Ctrl+C 停止');
   console.log('');
 }
@@ -278,7 +286,7 @@ function cmdStart({ foreground = false, dir = null } = {}) {
   if (alive) {
     console.log(`服务已在运行（pid ${alive.pid}）`);
     console.log(`  地址：${alive.url}`);
-    console.log(`  数据空间：${alive.dataRoot}`);
+    console.log(`  当前空间：${alive.dataRoot}`);
     return;
   }
 
@@ -311,7 +319,7 @@ function cmdStart({ foreground = false, dir = null } = {}) {
       console.log('');
       console.log('Lantern Harness 已在后台启动');
       console.log(`  地址：${state.url}`);
-      console.log(`  数据空间：${state.dataRoot}`);
+      console.log(`  当前空间：${state.dataRoot}`);
       console.log(`  日志：${logPath}`);
       console.log('  停止：lantern stop');
       console.log('');
@@ -388,6 +396,7 @@ function cmdStatus() {
   if (run) {
     console.log(`状态：运行中（pid ${run.pid}）`);
     console.log(`地址：${run.url}`);
+    console.log(`当前空间：${run.dataRoot}`);
   } else {
     console.log('状态：未运行');
   }
@@ -510,10 +519,10 @@ function cmdList() {
   }
 }
 
-function cmdInstall(version) {
+function cmdUpdate(version) {
   const pm = getPackageManager();
   const spec = version ? `${PKG_NAME}@${version}` : `${PKG_NAME}@latest`;
-  console.log(`正在安装 ${spec} …`);
+  console.log(version ? `正在更新到 ${spec} …` : `正在更新到最新版本（${spec}）…`);
   const r = spawnSync(pm, pmGlobalArgs(pm, 'install', spec), {
     stdio: 'inherit',
     shell: process.platform === 'win32',
@@ -526,8 +535,12 @@ function cmdInstall(version) {
 /** CLI 里的「基准根」：与网页端一致 —— 已记住的数据空间 */
 function spaceBaseRoot() {
   const result = resolveConfiguredDataRoot();
-  if (result.ok) return result.dataRoot;
+  if (result.ok) {
+    setRegistryRoot(result.dataRoot);
+    return result.dataRoot;
+  }
   // 尚未 init 时，池根退化到当前目录，保证 space 命令本身可用
+  setRegistryRoot(process.cwd());
   return process.cwd();
 }
 
@@ -823,6 +836,7 @@ async function cmdWipe() {
   if (run) cmdStop();
 
   fs.rmSync(resolved, { recursive: true, force: true });
+  forgetRegistryRoot(resolved);
   clearDataRootFromConfig();
   console.log('数据空间已删除，配置中的关联已清除。');
   console.log('如需继续使用，请使用 lantern init 初始化或选择已有数据空间。');
@@ -933,8 +947,10 @@ async function main() {
       case 'list':
         cmdList();
         break;
+      case 'update':
+      // 旧文档 / 老脚本里的 install 仍可用，输出与 update 一致
       case 'install':
-        cmdInstall(args[0]);
+        cmdUpdate(args[0]);
         break;
       case 'uninstall':
         cmdUninstall();

package/cli/spaces.mjs

@@ -3,6 +3,11 @@
  *
  * 文件位置：`~/.config/lantern-harness/spaces.json`（与 CLI 的 config.json 同目录）
  *
+ * 一份文件里按「池根」分区：每个空间条目记着自己属于哪个数据目录（`root`），
+ * 激活项也按池根分别记录（`activeByRoot`）。`lantern init` 换了数据空间之后，
+ * 列表只看新池根下的空间，不会把上一个数据目录里的空间一并列出来。
+ * 旧版全局 `activeId` / 无 `root` 的条目在读取时按路径推断归属，向后兼容。
+ *
  * 「公共空间」是内建虚拟项，不入库：用户数据目录下直接是 `公共空间/`，源码仓库则在 `空间池/公共空间/`。
  * 新建空间会自动归进同一层（与公共空间同级）。界面路径隐去「空间池」。
  * 与自定义空间同构，因此可以整体拷贝 / 备份。
@@ -81,6 +86,46 @@ export function getSpacesPath() {
   return path.join(getUserConfigDir(), 'spaces.json');
 }
 
+/** 当前池根：由 CLI / 服务端在知道数据目录后告知，供无 baseRoot 参数的调用（激活项）使用 */
+let registryRoot = '';
+
+/** @param {string} [root] */
+export function setRegistryRoot(root) {
+  if (root) registryRoot = path.resolve(root);
+  return registryRoot;
+}
+
+/** 条目所属池根：优先读登记值，其次按路径推断（`<根>/空间池/<名称>` 或 `<根>/<名称>`） */
+function inferEntryRoot(p) {
+  const abs = path.resolve(String(p || ''));
+  const marker = `${path.sep}${SPACE_POOL_DIR}${path.sep}`;
+  const idx = abs.lastIndexOf(marker);
+  return idx > 0 ? abs.slice(0, idx) : '';
+}
+
+function sameRoot(a, b) {
+  if (!a || !b) return false;
+  return path.resolve(a) === path.resolve(b);
+}
+
+/** abs 是否落在 dir 内（含 dir 本身） */
+function isInsideDir(abs, dir) {
+  if (!abs || !dir) return false;
+  const rel = path.relative(path.resolve(dir), path.resolve(abs));
+  return rel === '' || (!rel.startsWith('..') && !path.isAbsolute(rel));
+}
+
+function rootKey(root) {
+  const abs = root || registryRoot;
+  return abs ? path.resolve(abs) : '';
+}
+
+function activeIdForRoot(reg, root) {
+  const key = rootKey(root);
+  const id = key ? reg.activeByRoot?.[key] : '';
+  return String(id || PUBLIC_SPACE_ID);
+}
+
 /**
  * 新建空间的默认父目录：与公共空间同级（用户数据目录 = 选中的文件夹；源码仓库 = 空间池）。
  * @param {string} [baseRoot] 池根；缺省用 cwd
@@ -89,6 +134,13 @@ export function defaultManagedParent(baseRoot) {
   return poolPath(baseRoot || process.cwd());
 }
 
+/** 登记条目时推导它属于哪个池根：优先用调用方给的池根，其次从父目录反推 */
+function resolveEntryRoot(baseRoot, parent) {
+  return path.resolve(
+    baseRoot || inferEntryRoot(parent) || parent || registryRoot || process.cwd(),
+  );
+}
+
 /**
  * 注册表里的绝对路径失效时（整个仓库/数据目录被改名或搬移）按清单身份在新池根下重定位。
  * 只认清单 id / 名称都对得上的目录，避免把同名但无关的文件夹当成原空间。
@@ -120,16 +172,36 @@ function rebaseMissingSpacePath(abs, root, pool, entry) {
 
 /**
  * 按当前池布局改写注册表路径：用户目录把 `空间池/X` 抬到 `X`；源码仓库把误摊的 `X` 收回 `空间池/X`。
+ *
+ * 只改写「属于本池根」的条目。其它池根的条目原样保留 —— 除非它登记的池根已经不存在
+ * （整个数据目录被改名 / 搬移），这时按清单身份把它接到当前池根下，继续可用。
  * @param {string} [baseRoot]
  */
 export function relocateSpaceRegistryPaths(baseRoot) {
-  const root = path.resolve(baseRoot || process.cwd());
+  const root = path.resolve(baseRoot || registryRoot || process.cwd());
   const pool = poolPath(root);
   const nestedPrefix = path.join(root, SPACE_POOL_DIR);
-  const reg = loadSpacesRegistry();
+  const reg = loadSpacesRegistry(root);
   let dirty = false;
   for (const s of reg.spaces) {
     const abs = path.resolve(s.path);
+    const own = s.root ? path.resolve(s.root) : root;
+    if (!sameRoot(own, root)) {
+      // 别的数据空间：池根还在就不要动，否则换空间时会串台
+      if (isDir(own)) continue;
+      // 池根整个被改名 / 搬走：按清单身份接到当前池根
+      let next = isDir(abs) ? null : rebaseMissingSpacePath(abs, root, pool, s);
+      if (!next && s.external) {
+        const byName = path.resolve(pool, s.name);
+        if (byName !== abs && isDir(byName)) next = byName;
+      }
+      if (next) {
+        s.path = next;
+        s.root = root;
+        dirty = true;
+      }
+      continue;
+    }
     let next = null;
     if (!isDir(abs)) {
       // 旧根被改名 / 搬走：先按清单身份找回来
@@ -176,34 +248,63 @@ function newSpaceId() {
 
 function emptyRegistry() {
   // managedParent 不再落进注册表：它由池根推导，存下来只会在换机器后变成死路径
-  return { activeId: PUBLIC_SPACE_ID, spaces: [] };
+  return { activeId: PUBLIC_SPACE_ID, activeByRoot: {}, spaces: [] };
 }
 
 /**
  * 读取注册表；任何损坏都退回空注册表（宁可重置元数据，也不能让服务起不来）。
  *
  * 不再读取/推断 `managedParent`：空间位置一律由池根推导（见 `defaultManagedParent`）。
- * @returns {{ activeId: string, spaces: Array<{id:string,name:string,path:string,createdAt:number}> }}
+ * 条目缺 `root` 时按路径推断；推断不出来的（老版本的外部纳入）归到当前池根，保持旧行为。
+ * @param {string} [root] 当前池根；缺省用 `setRegistryRoot` 记下的值
+ * @returns {{ activeId: string, activeByRoot: Record<string, string>, spaces: Array<{id:string,name:string,path:string,createdAt:number,root:string}> }}
  */
-export function loadSpacesRegistry() {
+export function loadSpacesRegistry(root) {
   const fp = getSpacesPath();
   if (!fs.existsSync(fp)) return emptyRegistry();
+  const cur = rootKey(root);
   try {
     const raw = JSON.parse(fs.readFileSync(fp, 'utf8'));
     if (!raw || typeof raw !== 'object') return emptyRegistry();
     const spaces = Array.isArray(raw.spaces)
       ? raw.spaces
-          .map((it) => ({
-            id: String(it?.id || '').trim(),
-            name: String(it?.name || '').trim(),
-            path: path.resolve(String(it?.path || '')),
-            createdAt: Number(it?.createdAt) || 0,
-            // 用户手工确认纳入的文件夹：不写 space.json，保持目录原样
-            ...(it?.external === true ? { external: true } : {}),
-          }))
+          .map((it) => {
+            const abs = path.resolve(String(it?.path || ''));
+            // 归属推断：登记值 → 路径里的「空间池」段 → 当前池根内（老版本的外部纳入）
+            // 都不成立时留空：不属于任何池根，不会被任何数据目录列出来
+            const own =
+              String(it?.root || '').trim() ||
+              inferEntryRoot(abs) ||
+              (cur && isInsideDir(abs, cur) ? cur : '');
+            return {
+              id: String(it?.id || '').trim(),
+              name: String(it?.name || '').trim(),
+              path: abs,
+              createdAt: Number(it?.createdAt) || 0,
+              // 用户手工确认纳入的文件夹：不写 space.json，保持目录原样
+              ...(it?.external === true ? { external: true } : {}),
+              ...(own ? { root: path.resolve(own) } : {}),
+            };
+          })
           .filter((it) => it.id && it.name && it.path && it.path !== path.sep)
       : [];
-    return { activeId: String(raw.activeId || PUBLIC_SPACE_ID), spaces };
+    const activeByRoot = {};
+    const rawActive = raw.activeByRoot;
+    if (rawActive && typeof rawActive === 'object' && !Array.isArray(rawActive)) {
+      for (const [k, v] of Object.entries(rawActive)) {
+        const key = String(k || '').trim();
+        const id = String(v || '').trim();
+        if (!key || !id) continue;
+        activeByRoot[path.resolve(key)] = id;
+      }
+    }
+    // 旧版只有一个全局 activeId：归到它所属空间的那个池根，别让它跨数据目录生效
+    const legacyActive = String(raw.activeId || PUBLIC_SPACE_ID);
+    if (legacyActive !== PUBLIC_SPACE_ID) {
+      const owner = spaces.find((s) => s.id === legacyActive && s.root);
+      if (owner?.root && !activeByRoot[owner.root]) activeByRoot[owner.root] = legacyActive;
+    }
+    return { activeId: legacyActive, activeByRoot, spaces };
   } catch {
     return emptyRegistry();
   }
@@ -212,9 +313,17 @@ export function loadSpacesRegistry() {
 export function saveSpacesRegistry(reg) {
   const dir = getUserConfigDir();
   fs.mkdirSync(dir, { recursive: true });
+  const spaces = Array.isArray(reg.spaces) ? reg.spaces : [];
+  const activeByRoot = { ...(reg.activeByRoot || {}) };
+  for (const [k, v] of Object.entries(activeByRoot)) {
+    if (!k || !v) delete activeByRoot[k];
+  }
+  // activeId 只作旧版本兼容：写当前池根的激活项，读代码以 activeByRoot 为准
+  const cur = rootKey();
   const next = {
-    activeId: String(reg.activeId || PUBLIC_SPACE_ID),
-    spaces: Array.isArray(reg.spaces) ? reg.spaces : [],
+    activeId: String((cur && activeByRoot[cur]) || reg.activeId || PUBLIC_SPACE_ID),
+    activeByRoot,
+    spaces,
   };
   fs.writeFileSync(getSpacesPath(), `${JSON.stringify(next, null, 2)}\n`, 'utf8');
   return next;
@@ -376,8 +485,9 @@ function hasKnownContentDir(abs) {
  * @param {{ managedParent?: string, baseRoot?: string, adopt?: string[] }} [opts]
  */
 export function discoverSpaces(opts = {}) {
-  const reg = loadSpacesRegistry();
+  const reg = loadSpacesRegistry(opts.baseRoot);
   const parent = path.resolve(opts.managedParent || defaultManagedParent(opts.baseRoot));
+  const ownerRoot = resolveEntryRoot(opts.baseRoot, parent);
   const added = [];
   const backfilled = [];
   const skipped = [];
@@ -428,6 +538,7 @@ export function discoverSpaces(opts = {}) {
       name: clean.name,
       path: abs,
       createdAt: Date.now(),
+      root: ownerRoot,
       external: true,
     };
     reg.spaces.push(entry);
@@ -500,6 +611,7 @@ export function discoverSpaces(opts = {}) {
       name: clean.name,
       path: abs,
       createdAt: (read.ok ? read.manifest.createdAt : 0) || Date.now(),
+      root: ownerRoot,
     };
     reg.spaces.push(entry);
     usedIds.add(id);
@@ -524,10 +636,14 @@ export function discoverSpaces(opts = {}) {
  * @param {string} baseRoot 池根
  */
 export function listSpaces(baseRoot) {
-  relocateSpaceRegistryPaths(baseRoot);
-  const reg = loadSpacesRegistry();
+  const root = path.resolve(baseRoot);
+  setRegistryRoot(root);
+  relocateSpaceRegistryPaths(root);
+  const reg = loadSpacesRegistry(root);
+  // 只列本池根下的空间：换数据目录后不会串到上一个数据目录
+  const mine = reg.spaces.filter((s) => sameRoot(s.root, root));
   // 公共空间也是选中文件夹里的一个目录，与自定义空间同构
-  const publicRoot = path.resolve(publicSpacePath(baseRoot));
+  const publicRoot = path.resolve(publicSpacePath(root));
   const all = [
     {
       id: PUBLIC_SPACE_ID,
@@ -536,16 +652,17 @@ export function listSpaces(baseRoot) {
       createdAt: 0,
       isPublic: true,
     },
-    ...reg.spaces.map((s) => ({ ...s, isPublic: false })),
+    ...mine.map((s) => ({ ...s, isPublic: false })),
   ];
+  const activeId = activeIdForRoot(reg, root);
   return {
-    baseRoot: path.resolve(baseRoot),
-    managedParent: defaultManagedParent(baseRoot),
-    activeId: reg.activeId,
+    baseRoot: root,
+    managedParent: defaultManagedParent(root),
+    activeId,
     spaces: all.map((s) => ({
       ...s,
       exists: isDir(s.path),
-      isActive: s.id === reg.activeId,
+      isActive: s.id === activeId,
     })),
   };
 }
@@ -573,10 +690,11 @@ export function createSpace({ name, managedParent, baseRoot }) {
   const clean = sanitizeSpaceName(name);
   if (!clean.ok) return { ok: false, error: clean.error };
 
+  const parent = path.resolve(managedParent || defaultManagedParent(baseRoot));
+  setRegistryRoot(baseRoot || inferEntryRoot(parent));
   const reg = loadSpacesRegistry();
   if (nameTaken(reg, clean.name)) return { ok: false, error: `已存在同名空间「${clean.name}」` };
 
-  const parent = path.resolve(managedParent || defaultManagedParent(baseRoot));
   const dir = path.join(parent, clean.name);
 
   // 目录可能已存在（例如用户手工建过）：不能贸然复用，否则会把无关内容当成数据空间
@@ -588,7 +706,13 @@ export function createSpace({ name, managedParent, baseRoot }) {
     return { ok: false, error: `创建目录失败：${e instanceof Error ? e.message : String(e)}` };
   }
 
-  const entry = { id: newSpaceId(), name: clean.name, path: dir, createdAt: Date.now() };
+  const entry = {
+    id: newSpaceId(),
+    name: clean.name,
+    path: dir,
+    createdAt: Date.now(),
+    root: resolveEntryRoot(baseRoot, parent),
+  };
   try {
     writeSpaceManifest(dir, entry);
   } catch (e) {
@@ -667,7 +791,13 @@ export function copySpace(id, nextName, baseRoot) {
     return { ok: false, error: `复制失败：${e instanceof Error ? e.message : String(e)}` };
   }
 
-  const entry = { id: newSpaceId(), name: clean.name, path: dir, createdAt: Date.now() };
+  const entry = {
+    id: newSpaceId(),
+    name: clean.name,
+    path: dir,
+    createdAt: Date.now(),
+    root: resolveEntryRoot(baseRoot, parent),
+  };
   try {
     // 拷贝继承的是源空间的清单（含源 id），必须改写成新身份
     writeSpaceManifest(dir, entry);
@@ -691,6 +821,9 @@ export function removeSpace({ id, purge = false, baseRoot }) {
 
   const reg = loadSpacesRegistry();
   reg.spaces = reg.spaces.filter((s) => s.id !== space.id);
+  for (const [key, val] of Object.entries(reg.activeByRoot || {})) {
+    if (val === space.id) delete reg.activeByRoot[key];
+  }
   if (reg.activeId === space.id) reg.activeId = PUBLIC_SPACE_ID;
   saveSpacesRegistry(reg);
 
@@ -744,16 +877,35 @@ export function assertLooksLikeSpace(dir, managedParent) {
   return { ok: true };
 }
 
-/** 设置当前空间（持久化，重启后沿用） */
+/** 设置当前空间（按池根分别持久化，重启后沿用） */
 export function setActiveSpace(id) {
   const reg = loadSpacesRegistry();
-  reg.activeId = String(id || PUBLIC_SPACE_ID);
+  const wanted = String(id || PUBLIC_SPACE_ID);
+  const owner = reg.spaces.find((s) => s.id === wanted);
+  const key = rootKey() || owner?.root || '';
+  if (key) {
+    if (!reg.activeByRoot) reg.activeByRoot = {};
+    reg.activeByRoot[path.resolve(key)] = wanted;
+  }
+  reg.activeId = wanted;
   saveSpacesRegistry(reg);
-  return reg.activeId;
+  return wanted;
 }
 
 export function getActiveSpaceId() {
-  return loadSpacesRegistry().activeId;
+  const reg = loadSpacesRegistry();
+  const key = rootKey();
+  if (!key) return String(reg.activeId || PUBLIC_SPACE_ID);
+  return String(reg.activeByRoot?.[key] || PUBLIC_SPACE_ID);
+}
+
+/** 忘掉某个池根的全部登记（`lantern wipe` 删掉数据目录后调用，避免留下死路径） */
+export function forgetRegistryRoot(root) {
+  const key = path.resolve(root);
+  const reg = loadSpacesRegistry(key);
+  reg.spaces = reg.spaces.filter((s) => !sameRoot(s.root, key));
+  if (reg.activeByRoot) delete reg.activeByRoot[key];
+  saveSpacesRegistry(reg);
 }
 
 // ── 文件系统工具 ──────────────────────────────────────────────
@@ -925,10 +1077,11 @@ export async function importSpaceFromZip({ zipFile, name, managedParent, baseRoo
   const clean = sanitizeSpaceName(name ?? manifest?.name ?? fallbackName);
   if (!clean.ok) return { ok: false, error: clean.error };
 
+  const parent = path.resolve(managedParent || defaultManagedParent(baseRoot));
+  setRegistryRoot(baseRoot || inferEntryRoot(parent));
   const reg = loadSpacesRegistry();
   if (nameTaken(reg, clean.name)) return { ok: false, error: `已存在同名空间「${clean.name}」` };
 
-  const parent = path.resolve(managedParent || defaultManagedParent(baseRoot));
   const dir = path.join(parent, clean.name);
   if (fs.existsSync(dir)) return { ok: false, error: `目录已存在：${dir}` };
 
@@ -952,6 +1105,7 @@ export async function importSpaceFromZip({ zipFile, name, managedParent, baseRoo
     name: clean.name,
     path: dir,
     createdAt: Date.now(),
+    root: resolveEntryRoot(baseRoot, parent),
   };
   writeSpaceManifest(dir, entry);