lantern-harness 0.1.2 → 0.1.3

package/CHANGELOG.md

@@ -1,5 +1,65 @@
 # 版本日志
 
+## [0.1.3] - 2026-10-18
+
+新增「待办与效率」两个插件（任务管理 / 待办事项）并把提示词管理改为内置常开项；空间管理弹窗重做为单层卡片式流程，空间复制不再串数据。
+
+### 新增
+
+#### 待办与效率
+
+- 新插件分类「待办与效率」，内建两个独立插件，数据按空间隔离：任务存 `<空间>/.lantern/local/tasks.json`，待办存 `<空间>/.lantern/local/todos.json`，切换空间看到各自的数据
+- 任务管理：任务池 / 进行中 / 已完成 / 已关闭四态，顶部六张统计卡片（全部 / 任务池 / 进行中 / 已完成 / 已关闭 / 需要紧急）；行内改状态与紧急程度、点日期弹卡片日历、任务周期自动计算；「待办数量」「完成进度」按待办里的「所属任务」实时汇总；右侧抽屉可改名称 / 日期 / 备注并查看已关联待办
+- 待办事项：飞书多维表格样式的列表，按状态分组（进行中 / 待开始 / 已延期 / 已完成 / 已取消）、组标题可折叠，分组方式还可切为「按紧急程度」或「不分组」
+- 待办行内直接改名称 / 状态 / 紧急程度 / 所属任务 / 开始与截止日期 / 备注；状态下拉与紧急程度用颜色胶囊区分，不显示对钩；备注与名称超长省略号显示
+- 每个分组底部「+ 新增记录」：展开一行填完即保存（回车或点空白处），没填任何内容时点空白处自动收起，Esc 放弃；顶部「新建待办」从右侧滑出详情抽屉
+- **结束日期改为只读派生值**：状态改为「已完成 / 已取消」时自动记为当天，之后再改其它字段不会刷新；状态改回「待开始 / 进行中」时清空并显示「待办未完成」；表格、抽屉、AI 工具改状态都按同一规则处理
+- 待办的「所属任务」下拉不出已关闭的任务；待办关联任务时把任务从「任务池 / 已完成」拉回「进行中」（已关闭的不动），打开待办页时也会对既有未完成待办做一次同样对齐
+- 新建待办 / 任务的开始日期、截止日期默认当天
+- 列宽可拖：鼠标移到表头字段右边缘左右拖动即可，宽度按页面记在浏览器本地；宽屏下保持紧凑间距，深色主题下表格、胶囊、日历均已适配
+- 工作台「+」→「计划」下面新增「待办」「任务」手动入口（对应插件关闭时该入口隐藏）：复用新增前的确认卡片，待办分两页（第一页字段、第二页选所属任务并只读展示任务的名称 / 状态 / 紧急程度 / 起止日期，选中后自动带日期与紧急程度到第一页）；手动入口的最后一个按钮是「提交」，AI 触发的仍是「确认新增」；点「取消」或卡片外面只播收起动画，不写入数据
+- 工作台「回合」右侧新增「待办」Tab：默认「全部待办」，按 已逾期 / 今天截止 / 接下来 / 没有截止日期 / 已完成 分桶，也可只看未完成或已完成；每行显示名称、紧急程度、截止日期、剩余天数与所属任务，点左侧圆圈标记完成，右上角跳转完整待办页，停留时每 15 秒自动刷新
+- AI 工具：`todo_add` / `todo_list` / `todo_update` / `todo_delete`、`task_add` / `task_list` / `task_update` / `task_delete`，写入前统一弹确认卡片
+
+#### 空间管理
+
+- 空间管理弹窗重做为单层卡片：默认展示全部空间，「+ 新增空间」直接在弹窗内展开，点击取消回到全部空间；新建空间不再二次弹窗，去掉了无用的「完成」按钮
+- 新增「编辑空间」：可改名称、提示词要求与默认提示词；公共空间名称为锁定状态；保存后当前空间的默认提示词立即生效
+- 新建与编辑共用「提示词要求」输入框：回车触发生成，Shift+回车换行，随内容自动增高
+- 每个空间都补齐「提示词管理 / 默认提示词」，缺失时按包内种子补一份；空间里另存一份「提示词要求」（`.lantern/config/space-brief.json`），便于之后重新生成
+- 空间复制补齐收尾：复制品的工作区注册表改指新目录（此前新空间打开时「工作区」仍停在源空间）；跳过会话检索 sqlite（含 WAL / shm）与 spill 等可重建缓存；仍有会话在运行时拒绝复制并提示先停止
+- 重命名当前空间后服务端数据根同步指向新目录，不再需要重启或手动切换空间
+- 外部纳入的空间在已有 `.lantern` 元数据时「删除数据」按真实删除处理，不再只移出列表留下空壳
+
+#### 插件与导航
+
+- 提示词管理改为**内置常开项**：每个空间都需要默认提示词，插件页显示「内置」且不提供开关；入口固定到侧栏「帮助中心」上方，不参与分组与手动排序
+- 侧栏新增「任务管理」「待办事项」入口，随插件开关显示 / 隐藏；「全局插件」文档补上 `todos` / `tasks`
+- 菜单三点弹窗里的「选择分组」改为「加入分组」
+- 提示词管理页移除「在会话中打开」按钮
+- 新增通用组件：列宽拖拽、卡片式日期选择（去掉原生日历图标，底部「清除 / 今天」）、新增前确认卡片、工作台待办 Tab；`SelectDropdown` 支持自定义触发器与选项前缀、无边框样式、菜单最小宽度
+
+### 变更
+
+- 新建空间默认开启「提示词管理」，侧栏默认是「我的工作台」「提示词管理」「帮助中心」；其余插件仍默认关闭
+- 空间固有内容不再受插件开关影响：提示词管理目录与默认提示词始终存在，旧版本铺出的空壳目录照旧收起
+- 待办抽屉里的「任务结束日期」改称「结束日期」，由日期选择器改为只读文本
+- 版本日志页：没有导语的版本会按小节自动生成一句概览，不再只剩标题
+
+### 修复
+
+- 菜单排序列表里不再出现已关闭插件的条目
+- 编辑空间时不再出现 notfound；新建空间取消后正确回到全部空间列表；新建按钮不可点时有明确的禁用鼠标状态
+- 无数据时待办 / 任务页只保留右上角新建按钮，仍可正常新建
+- 创建确认卡片点卡片外面关闭时带退场动画且不落库，同时修掉该组件的 Fast Refresh 报错
+- 工作台「待办」Tab 在插件关闭时自动退回「对话」，不会停在空白页
+
+### 文档
+
+- 操作手册补「任务管理」「待办事项」两节（字段、分组、内联新增、结束日期规则、任务关联），以及工作台「+」手动新增、确认卡片两页流程与待办 Tab
+- 操作手册补空间管理的新建 / 编辑、复制空间的注意事项（会话运行中不可复制）与删除外部空间的判定
+- 安装手册去掉框架版本信息，首次进入的默认插件表与侧栏说明按「提示词管理内置常开」更新；README 功能表与「全局插件」规格同步补上 `todos` / `tasks`
+
 ## [0.1.2] - 2026-10-18
 
 ### 变更
@@ -163,6 +223,7 @@ Lantern Harness 首个版本：AI 工作台。一份进程里隔离多套项目
 - 开发服忽略打开内容库目录与空间元数据目录导致的整页热更新
 - 文档与 CLI 统一 pnpm 优先：安装 / 卸载 / 版本列表优先调用 pnpm（未安装则回退 npm）；README、安装手册、操作手册与贡献约定的开发命令改为 pnpm
 
+[0.1.3]: https://www.npmjs.com/package/lantern-harness/v/0.1.3
 [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

@@ -8,11 +8,11 @@ AI 工作台：对话与插件工具、需求 / 用例 / 知识 / 提示词内
 
 ## 功能
 
-| 模块      | 说明                                                                                                                                         |
-| --------- | -------------------------------------------------------------------------------------------------------------------------------------------- |
-| AI 工作台 | 多轮对话，流式输出，BYOK（自带密钥）直连模型；默认提示词按空间可改，可按插件挂载工具                                                         |
-| 会话记忆  | 五轨记忆（用户档案 / 全局事实 / 项目关键 / 项目日志 / 每日），待确认队列与工作台「记忆」Tab                                                  |
-| 插件库    | 内置能力开关：内容库（需求 / 用例 / 提示词 / 知识库 / 模板）、生成能力、记忆与检索、开发工具；开启后侧栏出现对应入口，也可让模型推荐能力建议 |
+| 模块      | 说明                                                                                                                                                     |
+| --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| AI 工作台 | 多轮对话，流式输出，BYOK（自带密钥）直连模型；默认提示词按空间可改，可按插件挂载工具                                                                     |
+| 会话记忆  | 五轨记忆（用户档案 / 全局事实 / 项目关键 / 项目日志 / 每日），待确认队列与工作台「记忆」Tab                                                              |
+| 插件库    | 内置能力开关：内容库（需求 / 用例 / 提示词 / 知识库 / 模板）、生成能力、记忆与检索、任务与待办、开发工具；开启后侧栏出现对应入口，也可让模型推荐能力建议 |
 
 模型配置（BYOK）、内容目录约定、插件用法见 **[操作手册](https://lantern.yychuiyan.com/docs/manual/)**。
 
@@ -76,7 +76,7 @@ lantern acp            # 以 ACP 子集供外部编排驱动无 UI Agent
 
 4、 插件默认值：
 
-新建空间的插件全部默认关闭，侧栏只有「我的工作台」「帮助中心」。所有扩展插件（内容库、生成能力、知识库检索、会话记忆、插件开发）都要在「插件」页按分类手动开启；由「插件开发」新增的插件同样默认关闭。
+新建空间默认开启「提示词管理」（每个空间都要有默认提示词，属于内置常开项），侧栏为「我的工作台」「提示词管理」「帮助中心」。其余扩展插件（其它内容库、生成能力、知识库检索、会话记忆、任务管理 / 待办事项、插件开发）都要在「插件」页按分类手动开启；由「插件开发」新增的插件同样默认关闭。
 
 ### 方式二：源码启动
 

package/builtin/session/lh-spaces.mjs

@@ -15,8 +15,12 @@ import os from 'node:os';
 import path from 'node:path';
 
 import {
+  ensureSpaceSystemPrompt,
   prepareExternalSpaceDir,
   prepareSpaceDir,
+  readSpaceBrief,
+  readSpaceSystemPrompt,
+  writeSpaceBrief,
   writeSpaceSystemPrompt,
 } from '../../cli/data-root.mjs';
 import {
@@ -207,6 +211,21 @@ function syncActiveRoot() {
   return { ok: true, id: activeId, changed: true };
 }
 
+/** 重命名的是当前空间时，把服务的数据根指到新目录（否则后续读写仍指向旧路径） */
+function retargetActiveRoot(space) {
+  if (!space || getActiveSpaceId() !== space.id) return;
+  try {
+    const nextRoot = prepareSpaceDir(space.path);
+    if (path.resolve(nextRoot) === path.resolve(getDataRoot())) return;
+    setActiveRoot(nextRoot);
+    closeAllBashSessions();
+    closeAllPwshSessions();
+    syncRunState(nextRoot);
+  } catch {
+    // 名称已改；路径对齐失败时下次切换空间会自愈
+  }
+}
+
 export function lhSpacesPlugin() {
   return {
     name: 'lh-spaces',
@@ -257,6 +276,8 @@ export function lhSpacesPlugin() {
             try {
               prepareSpaceDir(created.space.path);
               if (promptText.trim()) writeSpaceSystemPrompt(created.space.path, promptText);
+              const brief = typeof body.promptBrief === 'string' ? body.promptBrief.trim() : '';
+              if (brief) writeSpaceBrief(created.space.path, brief);
             } catch (e) {
               return sendJson(res, 500, {
                 ok: false,
@@ -280,11 +301,92 @@ export function lhSpacesPlugin() {
             const body = await readJson(req);
             const out = renameSpace(body.id, body.name, getBaseRoot());
             if (!out.ok) return sendJson(res, 400, { ok: false, error: out.error });
+            retargetActiveRoot(out.space);
             return sendJson(res, 200, { ok: true, space: out.space });
           }
 
+          // 空间详情：名称 / 提示词要求 / 默认提示词，供管理面板编辑
+          if (url === `${PREFIX}/detail` && req.method === 'GET') {
+            const q = new URLSearchParams(req.url.split('?')[1] ?? '');
+            const resolved = resolveSpace(q.get('id') ?? '', getBaseRoot());
+            if (!resolved.ok) return sendJson(res, 404, { ok: false, error: resolved.error });
+            const space = resolved.space;
+            // 外部纳入的空间不铺骨架；托管空间补齐默认提示词文件
+            if (!space.external) {
+              try {
+                prepareSpaceDir(space.path);
+              } catch {
+                // 目录暂时不可写时仍然返回已有内容
+              }
+            }
+            return sendJson(res, 200, {
+              ok: true,
+              space,
+              brief: readSpaceBrief(space.path),
+              systemPrompt: readSpaceSystemPrompt(space.path),
+            });
+          }
+
+          // 保存空间名称 / 提示词要求 / 默认提示词
+          if (url === `${PREFIX}/update` && req.method === 'POST') {
+            const body = await readJson(req);
+            const resolved = resolveSpace(body.id, getBaseRoot());
+            if (!resolved.ok) return sendJson(res, 404, { ok: false, error: resolved.error });
+            let space = resolved.space;
+
+            const nextName = typeof body.name === 'string' ? body.name.trim() : '';
+            if (nextName && nextName !== space.name) {
+              if (space.isPublic) {
+                return sendJson(res, 400, {
+                  ok: false,
+                  error: `${PUBLIC_SPACE_NAME}不支持重命名`,
+                });
+              }
+              const renamed = renameSpace(space.id, nextName, getBaseRoot());
+              if (!renamed.ok) return sendJson(res, 400, { ok: false, error: renamed.error });
+              space = renamed.space;
+              retargetActiveRoot(space);
+            }
+
+            if (typeof body.brief === 'string') {
+              if (body.brief.length > 20_000) {
+                return sendJson(res, 400, { ok: false, error: '提示词要求过长' });
+              }
+              writeSpaceBrief(space.path, body.brief);
+            }
+
+            if (typeof body.systemPrompt === 'string' && body.systemPrompt.trim()) {
+              if (body.systemPrompt.length > 80_000) {
+                return sendJson(res, 400, { ok: false, error: '默认提示词过长' });
+              }
+              try {
+                if (!space.external) ensureSpaceSystemPrompt(space.path);
+                writeSpaceSystemPrompt(space.path, body.systemPrompt);
+              } catch (e) {
+                return sendJson(res, 500, {
+                  ok: false,
+                  error: e instanceof Error ? e.message : String(e),
+                });
+              }
+            }
+
+            return sendJson(res, 200, {
+              ok: true,
+              space,
+              brief: readSpaceBrief(space.path),
+              systemPrompt: readSpaceSystemPrompt(space.path),
+            });
+          }
+
           if (url === `${PREFIX}/copy` && req.method === 'POST') {
             const body = await readJson(req);
+            // 复制是逐文件拷贝：会话在跑时源空间仍在写，拷出来可能半份
+            if (hasRunningSessions()) {
+              return sendJson(res, 409, {
+                ok: false,
+                error: '仍有会话在运行，请先停止后再复制空间',
+              });
+            }
             const out = copySpace(body.id, body.name, getBaseRoot());
             if (!out.ok) return sendJson(res, 400, { ok: false, error: out.error });
             return sendJson(res, 200, { ok: true, space: out.space });

package/cli/data-root.mjs

@@ -202,13 +202,16 @@ export function prepareSpaceDir(spaceDir) {
     fs.copyFileSync(PKG_DEFAULTS, destDefaults);
   }
 
-  // 内容目录按插件开关懒建：插件全关的新空间就是一个干净目录，
-  // 不会先铺出「用例管理 / 知识库管理」这类用户还没启用的入口。
+  // 内容目录按插件开关懒建：插件全关的新空间就是一个干净目录（提示词管理例外，
+  // 它承载每个空间必备的「默认提示词」），不会先铺出「用例管理 / 知识库管理」这类入口。
   for (const { dirName, legacyDirNames } of Object.values(DOC_ROOT_DIRS)) {
     // 必须先迁移：一旦先建出中文目录，旧目录里的文件就再也不会被搬过来
     migrateLegacyRoot(root, legacyDirNames, dirName);
     const dir = resolveContentRoot(root, dirName).abs;
-    const enabled = isContentRootEnabled(root, dirName);
+    // 提示词管理是空间的固有部分：每个空间都有「默认提示词」，不受插件开关影响。
+    // 新建空间 / npm 安装后首次启动都要把它铺出来，否则提示词页无内容可显示。
+    const alwaysOn = dirName === DOC_ROOT_DIRS.prompts.dirName;
+    const enabled = alwaysOn || isContentRootEnabled(root, dirName);
     // 旧版本会给所有内容目录铺一个只有 .gitkeep 的空壳：插件没启用就收掉，
     // 让升级后的数据空间和全新安装保持一致（有真实内容的目录绝不动）
     if (!enabled && isDir(dir) && onlyPlaceholders(dir)) {
@@ -224,6 +227,12 @@ export function prepareSpaceDir(spaceDir) {
 
   // 种子只补进已存在的目录（种子晚于建目录，这样「目录已存在」不会阻止种子落位）
   seedSpaceDir(root);
+  // 提示词是空间固有内容：种子缺失或旧空间没铺过时也补一份默认提示词
+  try {
+    ensureSpaceSystemPrompt(root);
+  } catch {
+    // 只读 / 权限异常时不阻断空间准备，提示词页会回退到空内容
+  }
 
   // 新建空间：种子不算「用户搬进来的内容」，别让它触发插件自动开启
   if (freshSpace) markNavRootsDetected(root);
@@ -374,6 +383,74 @@ export function seedSpaceDir(spaceDir) {
   return planted;
 }
 
+/**
+ * 确保空间有「提示词管理」目录与「默认提示词」文件（缺失时用包内种子补上）。
+ * 幂等：提示词页、空间管理编辑面板都靠它拿到当前空间的默认提示词。
+ * @param {string} spaceDir
+ * @returns {string} 默认提示词文件的绝对路径
+ */
+export function ensureSpaceSystemPrompt(spaceDir) {
+  const root = path.resolve(spaceDir);
+  const dir = resolveContentRoot(root, DOC_ROOT_DIRS.prompts.dirName).abs;
+  fs.mkdirSync(dir, { recursive: true });
+  const dest = path.join(dir, SPACE_SYSTEM_PROMPT_FILE);
+  if (!fs.existsSync(dest)) {
+    const seed = path.join(PKG_SEEDS, DOC_ROOT_DIRS.prompts.dirName, SPACE_SYSTEM_PROMPT_FILE);
+    try {
+      if (fs.existsSync(seed)) {
+        const buf = fs.readFileSync(seed);
+        fs.writeFileSync(dest, buf);
+      }
+    } catch {
+      // 种子只是初始内容：失败不阻断读取，前台会显示空提示词
+    }
+  }
+  return dest;
+}
+
+/** 读取空间默认提示词正文（缺失时返回空串，不改动磁盘） */
+export function readSpaceSystemPrompt(spaceDir) {
+  try {
+    const fp = path.join(
+      resolveContentRoot(path.resolve(spaceDir), DOC_ROOT_DIRS.prompts.dirName).abs,
+      SPACE_SYSTEM_PROMPT_FILE,
+    );
+    if (!fs.existsSync(fp)) return '';
+    return fs.readFileSync(fp, 'utf8').replace(/\r\n/g, '\n').trim();
+  } catch {
+    return '';
+  }
+}
+
+/** 空间的「提示词要求」：跟着空间走的小段描述，存 `.lantern/config/space-brief.json` */
+export function readSpaceBrief(spaceDir) {
+  try {
+    const raw = JSON.parse(
+      fs.readFileSync(spaceConfigFile(path.resolve(spaceDir), 'space-brief.json'), 'utf8'),
+    );
+    return typeof raw?.brief === 'string' ? raw.brief : '';
+  } catch {
+    return '';
+  }
+}
+
+/**
+ * 写入空间「提示词要求」（允许写空串，用于清空）。
+ * @param {string} spaceDir
+ * @param {string} brief
+ * @returns {boolean}
+ */
+export function writeSpaceBrief(spaceDir, brief) {
+  try {
+    const dest = spaceConfigFile(path.resolve(spaceDir), 'space-brief.json');
+    fs.mkdirSync(path.dirname(dest), { recursive: true });
+    fs.writeFileSync(dest, `${JSON.stringify({ brief: String(brief ?? '') }, null, 2)}\n`, 'utf8');
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 /**
  * 把生成/手写的提示词写成该空间的默认提示词（覆盖种子，不覆盖空串）。
  * @param {string} spaceDir

package/cli/lantern.mjs

@@ -320,8 +320,9 @@ function cmdStart({ foreground = false, dir = null } = {}) {
       console.log('Lantern Harness 已在后台启动');
       console.log(`  地址：${state.url}`);
       console.log(`  当前空间：${state.dataRoot}`);
-      console.log(`  日志：${logPath}`);
       console.log('  停止：lantern stop');
+      console.log('  更新：lantern update');
+      console.log('  更多命令：lantern help');
       console.log('');
       return;
     }

package/cli/server.mjs

@@ -16,6 +16,8 @@ import { lhSpillPlugin } from '../builtin/session/lh-spill.mjs';
 import { lhKbPlugin } from '../lh-plugins/lh-kb.mjs';
 import { lhMemoryPlugin } from '../lh-plugins/lh-memory.mjs';
 import { lhResourcesPlugin } from '../lh-plugins/lh-resources.mjs';
+import { lhTodosPlugin } from '../lh-plugins/lh-todos.mjs';
+import { lhTasksPlugin } from '../lh-plugins/lh-tasks.mjs';
 import { lhWebPlugin } from '../builtin/session/lh-web.mjs';
 import { tbSessionRunsPlugin } from '../builtin/session/session-runs.mjs';
 import { lhSpacesPlugin } from '../builtin/session/lh-spaces.mjs';
@@ -48,6 +50,8 @@ function attachPlugins(app, dataRoot) {
   const plugins = [
     tbSessionRunsPlugin(),
     lhSpacesPlugin(),
+    lhTodosPlugin(),
+    lhTasksPlugin(),
     lhNavGroupsPlugin(),
     lhConfigPlugin(),
     lhResourcesPlugin(),

package/cli/spaces.mjs

@@ -791,6 +791,10 @@ export function copySpace(id, nextName, baseRoot) {
     return { ok: false, error: `复制失败：${e instanceof Error ? e.message : String(e)}` };
   }
 
+  // 复制品里的工作区注册表还指着源空间的绝对路径，必须改指新目录，
+  // 否则新空间打开时「工作区」停在被复制的那个空间上。
+  retargetCopiedWorkspaces(dir, resolved.space.path);
+
   const entry = {
     id: newSpaceId(),
     name: clean.name,
@@ -809,6 +813,69 @@ export function copySpace(id, nextName, baseRoot) {
   return { ok: true, space: entry };
 }
 
+/**
+ * 把复制品里的工作区注册表改指新目录。
+ *
+ * 源空间的 `workspaces.json` 记的是源目录的绝对路径（`active` 与 `ws_project` 条目）；
+ * 直接拷过来后，源目录仍真实存在，`ensureWorkspaceRegistry` 的「父目录 / 不存在」清理都不会命中，
+ * 于是新空间的工作区停在源空间上。这里把指向源目录的条目改名到新目录，其余条目保持不动。
+ */
+function retargetCopiedWorkspaces(newDir, sourceDir) {
+  const fp = path.join(newDir, LOCAL_REL, 'workspaces.json');
+  const target = path.resolve(newDir);
+  const source = path.resolve(sourceDir);
+  const folderName = (abs) => path.basename(abs) || abs;
+  let raw;
+  try {
+    raw = JSON.parse(fs.readFileSync(fp, 'utf8'));
+  } catch {
+    // 源空间没有工作区注册表（或已损坏）：不补，首次打开会按空间根自建
+    return;
+  }
+  if (!raw || typeof raw !== 'object') return;
+
+  const items = (Array.isArray(raw.items) ? raw.items : []).map((it) => {
+    const p = String(it?.path ?? '');
+    if (!p || path.resolve(p) !== source) return it;
+    return {
+      ...it,
+      id: 'ws_project',
+      path: target,
+      name: folderName(target),
+      addedAt: Number(it?.addedAt) || 0,
+    };
+  });
+
+  // 复制品必须有自己的根工作区（源注册表里没有源目录条目时补一条）
+  if (!items.some((it) => path.resolve(String(it?.path ?? '')) === target)) {
+    items.unshift({ id: 'ws_project', path: target, name: folderName(target), addedAt: 0 });
+  }
+
+  const activeRaw = String(raw.active ?? '');
+  const active =
+    !activeRaw || path.resolve(activeRaw) === source ? target : path.resolve(activeRaw);
+
+  try {
+    fs.writeFileSync(
+      fp,
+      `${JSON.stringify(
+        {
+          active,
+          // 插件开发借用包根是临时态，不跟着复制
+          activeHarness: false,
+          items,
+          updatedAt: Date.now(),
+        },
+        null,
+        2,
+      )}\n`,
+      'utf8',
+    );
+  } catch {
+    // 写不进去不影响空间可用性，下次打开会按空间根自愈
+  }
+}
+
 /**
  * 从列表移除空间。
  * @param {{ id: string, purge?: boolean, baseRoot: string }} opts purge=true 时连磁盘数据一起删
@@ -830,8 +897,11 @@ export function removeSpace({ id, purge = false, baseRoot }) {
   if (!purge) return { ok: true, purged: false, space };
 
   // 用户手工纳入的外部文件夹：没有空间元数据就不是我们铺的目录，
-  // 只移出列表，绝不代删（那可能是他自己的资料文件夹）
-  if (space.external && !resolveManifestPath(space.path)) {
+  // 只移出列表，绝不代删（那可能是他自己的资料文件夹）。
+  // 例外：目录里已经有 `.lantern` 元数据（会话 / 配置 / 记忆），说明确实被本应用
+  // 当成数据空间用过——用户点「删除数据」后还留着空壳只会让人以为没删掉。
+  const hasLanternMeta = fs.existsSync(spaceMetaDir(space.path));
+  if (space.external && !resolveManifestPath(space.path) && !hasLanternMeta) {
     return {
       ok: true,
       purged: false,
@@ -917,8 +987,21 @@ export function forgetRegistryRoot(root) {
  */
 const COPY_SKIP_DIRS = new Set(['node_modules', '.git', '.astro', 'dist']);
 
-/** 递归复制目录（跳过 .DS_Store 与构建/版本控制目录，保留符号链接本身而非解引用） */
-export function copyDirSync(from, to) {
+/**
+ * 复制空间时额外跳过的「派生缓存」（相对空间根，posix 路径）。
+ *
+ * 这些都能从源数据重建，且复制时若正好被服务进程写着，拷过来只可能是半份 / 不一致的：
+ * 会话检索索引用 sqlite（可能带 WAL / shm），spill 只是工具结果的溢出缓存。
+ */
+const COPY_SKIP_LOCAL_FILES = new Set([
+  `${LOCAL_REL}/session-query.sqlite`,
+  `${LOCAL_REL}/session-query.sqlite-wal`,
+  `${LOCAL_REL}/session-query.sqlite-shm`,
+]);
+const COPY_SKIP_LOCAL_DIRS = new Set([`${LOCAL_REL}/spill`]);
+
+/** 递归复制目录（跳过 .DS_Store、构建/版本控制目录与派生缓存，保留符号链接本身而非解引用） */
+export function copyDirSync(from, to, rel = '') {
   const src = path.resolve(from);
   const dest = path.resolve(to);
 
@@ -931,14 +1014,17 @@ export function copyDirSync(from, to) {
   for (const ent of fs.readdirSync(src, { withFileTypes: true })) {
     if (ent.name === '.DS_Store') continue;
     if (ent.isDirectory() && COPY_SKIP_DIRS.has(ent.name)) continue;
+    const nextRel = rel ? `${rel}/${ent.name}` : ent.name;
     const s = path.join(src, ent.name);
     const d = path.join(dest, ent.name);
     if (ent.isSymbolicLink()) {
       const link = fs.readlinkSync(s);
       fs.symlinkSync(link, d);
     } else if (ent.isDirectory()) {
-      copyDirSync(s, d);
+      if (COPY_SKIP_LOCAL_DIRS.has(nextRel)) continue;
+      copyDirSync(s, d, nextRel);
     } else {
+      if (COPY_SKIP_LOCAL_FILES.has(nextRel)) continue;
       fs.copyFileSync(s, d);
     }
   }

package/config/app.defaults.json

@@ -16,7 +16,7 @@
   "plugins": {
     "cases": false,
     "caseGen": false,
-    "prompts": false,
+    "prompts": true,
     "promptGen": false,
     "knowledgeLib": false,
     "knowledgeGen": false,
@@ -24,6 +24,8 @@
     "templates": false,
     "knowledge": false,
     "memory": false,
-    "pluginDev": false
+    "pluginDev": false,
+    "todos": false,
+    "tasks": false
   }
 }