@a9i5k4/dsh-auto-memory 0.1.23 → 0.1.24

package/lib/index.js

@@ -39,7 +39,7 @@ const SECTION_ORDER = 10000
 const NOTICES_URL = 'https://raw.githubusercontent.com/Aik358/dsh-auto-memory/main/notices.json'
 
 /** Model-facing announcement (tools + engine). */
-export const GUIDANCE = '本机已安装 dsh-auto-memory 插件（集中式自动记忆 + 外部记忆继承）：三层本地记忆（用户级 ~/.dsh/memory/MEMORY.md、项目笔记与每日日志 .dsh-memory/）+ 会话自动注入 + 每日反思 + 其他 AI 工具记忆接入。能力：memory_log 追加今日日志（append-only，完成实质性工作后必须调用）；memory_note 更新项目笔记；memory_user 更新用户级规则；memory_recall 检索本地记忆 + 外部记忆（AI 助手/CodeBuddy/Claude Code/Codex 历史会话与画像）+ 历史 DSH 会话；memory_external 查看/接入外部记忆源；memory_maintain 归档 30 天前日志；memory_reflect 保存每日反思；memory_status 查看状态；memory_consolidate 让 AI 读日志发散提炼长期要点固化进笔记。自动沉淀：每轮对话结束插件自动评估本轮内容并写今日日志/升格长期记忆（寒暄轮跳过，可在设置关闭），无需你手动调 memory_log。主动性纪律：任务开始遇到不熟悉的代码/领域/历史决策时，先 memory_recall 检索本机全部 AI 工具历史，不凭空猜测；新工作区主动探索历史。限制：记忆文件为明文 Markdown；不存密钥除非用户明确要求；外部会话检索为关键词级（非语义）；GUI 侧边栏「记忆」面板（含「接续」页签）与设置页可查看/配置/接入。用户提到「记忆 / 昨天做了什么 / 之前怎么做的 / 每日反思 / 接续 / 其他 AI 的记忆」时即指本插件，请据此协作。'
+export const GUIDANCE = '本机已安装 dsh-auto-memory 插件（集中式自动记忆 + 外部记忆继承）：三层本地记忆（用户级 ~/.dsh/memory/MEMORY.md、项目笔记与每日日志 .dsh-memory/）+ 会话自动注入 + 每日反思 + 其他 AI 工具记忆接入。能力：memory_log 追加今日日志（append-only，完成实质性工作后必须调用）；memory_note 更新项目笔记；memory_user 更新用户级规则；memory_recall 检索本地记忆 + 外部记忆（WorkBuddy/CodeBuddy/Claude Code/Codex 历史会话与画像）+ 历史 DSH 会话；memory_external 查看/接入外部记忆源；memory_maintain 归档 30 天前日志；memory_reflect 保存每日反思；memory_status 查看状态；memory_consolidate 让 AI 读日志发散提炼长期要点固化进笔记。自动沉淀：每轮对话结束插件自动评估本轮内容并写今日日志/升格长期记忆（寒暄轮跳过，间隔与每日额度可在设置页「自动化」分组调整），无需你手动调 memory_log。主动性纪律：任务开始遇到不熟悉的代码/领域/历史决策时，先 memory_recall 检索本机全部 AI 工具历史，不凭空猜测；新工作区主动探索历史。限制：记忆文件为明文 Markdown；不存密钥除非用户明确要求；外部会话检索为关键词级（非语义）；GUI 侧边栏「记忆」面板（含「接续」页签，可查看来源内容、从记忆 prompt 移除已导入段落）与设置页可查看/配置/接入。用户提到「记忆 / 昨天做了什么 / 之前怎么做的 / 每日反思 / 接续 / 其他 AI 的记忆」时即指本插件，请据此协作。'
 
 /** Route family. */
 export const API = {
@@ -59,7 +59,9 @@ export const API = {
   'reflect-auto': '/api/dsh-auto-memory/reflect-auto',
   note: '/api/dsh-auto-memory/note',
   external: '/api/dsh-auto-memory/external',
+  'external-view': '/api/dsh-auto-memory/external-view',
   'external-import': '/api/dsh-auto-memory/external-import',
+  'external-remove': '/api/dsh-auto-memory/external-remove',
   calendar: '/api/dsh-auto-memory/calendar',
   summarize: '/api/dsh-auto-memory/summarize',
   greet: '/api/dsh-auto-memory/greet',
@@ -78,13 +80,13 @@ const DEFAULT_CONFIG = {
   /** 注入总预算(字符)。 */
   injectBudgetChars: 2400,
   /** 注入的最近日志天数。 */
-  recentDaysInjected: 3,
+  recentDaysInjected: 1,
   /** 每轮对话结束自动沉淀记忆(subagent 判断+提炼,有 API 成本;默认开)。 */
   autoConsolidate: true,
   /** 自动沉淀内容门槛:本轮 user+assistant 文本总字符数低于此值视为寒暄,跳过。 */
   autoConsolidateMinChars: 240,
-  /** 自动沉淀冷却分钟:避免连续短轮反复调用 subagent。 */
-  autoConsolidateCooldownMinutes: 5,
+  /** 自动沉淀冷却分钟:避免连续短轮反复调用 subagent。默认 30;非工作时间(22:00-08:00)自动翻倍。 */
+  autoConsolidateCooldownMinutes: 30,
   /** 自动沉淀每日最多调用次数(跨插件实例应只保留一个实例)。 */
   autoConsolidateDailyMax: 8,
   /** 暂离阈值(分钟):距上次活动超过该值视为暂离,回归时自动弹出记忆窗口并欢迎。默认 60。 */
@@ -175,6 +177,7 @@ class MemoryEngine {
     this._autoCallDate = ''
     this._autoCallCount = 0
     this._lastConsolidateStartedAt = 0
+    this._smartRecallFlight = undefined
     this._budgets = undefined // 每日写入预算:用户级4000/项目级3000字/天(所有会话共享,跨天重置)
     this.autoStats = { count: 0, lastAt: 0, lastText: '', lastDate: '' } // 自动沉淀统计(GUI 即时反馈)
     this.external = new ExternalMemory(this)
@@ -733,18 +736,22 @@ class MemoryEngine {
       part('最近 ' + s.recentLogs.length + ' 天工作日志(尾部)', recent, sub)
     }
     if (s.latestReflection) {
-      part('最近反思 ' + s.latestReflectionDate + '(前一天工作精华)', s.latestReflection, sub)
+      part('最近反思 ' + s.latestReflectionDate + '(前一天工作精华)', reflectionDigest(s.latestReflection), sub)
     }
-    part('用户级记忆 ~/.dsh/memory/MEMORY.md — 跨项目,必须遵守', s.userText, sub)
-    part('项目长期笔记 ' + cfg.projectMemoryDir + '/MEMORY.md', s.notesText, sub)
+    // 敏感段落(凭据/token/密钥等)不注入 prompt,避免密钥暴露给模型
+    part('用户级记忆 ~/.dsh/memory/MEMORY.md — 跨项目,必须遵守', stripSensitiveSections(s.userText), sub)
+    part('项目长期笔记 ' + (s.notesPath || (cfg.projectMemoryDir + '/MEMORY.md')), stripSensitiveSections(s.notesText), sub)
     // 外部记忆摘要(其他 AI 工具遗产)
     if (this.external.cache && this.external.cache.length) {
       const extBudget = Math.max(Number(cfg.externalInjectionChars) || 1400, 200)
       const ext = this.external.cache
         .filter((x) => x.kind !== 'sessions')
-        .map((x) => '· ' + x.name + '(' + x.tool + '): ' + truncateHead(x.content, 500))
+        .map((x) => {
+          const paths = (x.files || []).map((f) => f.path).slice(0, 2).join(' ; ')
+          return '· ' + x.name + '(' + x.tool + '): 绝对路径 ' + (paths || '(未知)')
+        })
         .slice(0, 3)
-      if (ext.length) lines.push('\n[外部记忆 — 其他 AI 工具遗产,可继承]\n' + ext.join('\n'))
+      if (ext.length) lines.push('\n[外部记忆 — 其他 AI 工具遗产,可继承(内容按需读取,不整段注入)]\n' + ext.join('\n') + '\n需要这些记忆时:直接读取上述绝对路径文件(你有文件读取能力),或用 memory_recall 按需检索;不要凭空猜测其内容。')
       const sess = this.external.cache.filter((x) => x.kind === 'sessions')
       if (sess.length) {
         lines.push('· 历史会话索引: ' + sess.map((x) => x.name + ' ' + x.files.length + ' 个').join(', ') + ' —— 需要时用 memory_recall 检索。')
@@ -755,7 +762,7 @@ class MemoryEngine {
       const calEntries = this.parseCalendar(this.state.calendarText).filter((en) => !en.done && en.date >= todayStr()).slice(0, 10)
       if (calEntries.length) {
         const calLines = calEntries.map((en) => '· ' + en.date + ' ' + en.time + ' | ' + en.quadrant + ' | ' + en.title).join('\n')
-        lines.push('\n[日历与日程(未完成)]\n' + calLines + '\n主动关注这些安排:对话中若提及相关时间点,主动用 calendar_add 补充新事项、calendar_done 标记完成;回复正文中向用户转述日历变更。')
+        lines.push('\n[日历与日程(未完成)]\n' + calLines + '\n主动关注这些安排:对话中若提及相关时间点,主动用 calendar_add 补充新事项、calendar_done 标记完成、calendar_remove 删除过期事项;回复正文中向用户转述日历变更。')
       }
     }
     // 暂离回来提示:距上次活动>1小时,要求 agent 在回复开头写欢迎语并提示打开记忆窗口
@@ -775,7 +782,7 @@ class MemoryEngine {
     lines.push('思维链=本轮推理(用完即焚);铭文=落盘的记忆文件(跨会话永久)。你的记忆更新必须落在铭文层——显式调用工具写盘,不能只"想过"。')
     lines.push('本提醒由框架在每一轮对话开始时重新注入(记忆动态快照变化即刷新,衰减期只有一轮):读写只走工具、路径写死、每轮结束框架自动评估沉淀兜底——记忆无法被绕过,也不依赖自觉。')
     lines.push('\n[记忆写入纪律 — 必须遵守]')
-    lines.push('- 会话开始:若任务与历史工作/历史决策相关,先回顾以上记忆;**遇到不熟悉的代码、领域或项目时,主动调用 memory_recall 检索本机所有 AI 工具的历史记忆(AI 助手/CodeBuddy/Claude Code/Codex 会话),不要凭空猜测**。')
+    lines.push('- 会话开始:若任务与历史工作/历史决策相关,先回顾以上记忆;**遇到不熟悉的代码、领域或项目时,主动调用 memory_recall 检索本机所有 AI 工具的历史记忆(WorkBuddy/CodeBuddy/Claude Code/Codex 会话),或直接读取外部记忆标注的绝对路径文件,不要凭空猜测**。')
     lines.push('- 新工作区(无历史日志/笔记):主动用 memory_recall 探索本机历史,判断该项目是否曾在其他 AI 工具中工作过;也可调用 memory_external 查看并接入外部记忆;检索时在正文中说明"我先查一下之前的记录"。')
     lines.push('- 完成实质性工作后立即调用 memory_log 追加今日日志(append-only,绝不覆盖):建/改应用、修 bug、写文档、重构、技术选型、用户约定或偏好。')
     lines.push('- progress 与 memory 一起写:写日志的同时,把有跨会话长期价值的内容一并写入记忆——跨项目规则 → memory_user,仅本项目 → memory_note;两者在同一轮完成,互不冲突、不遗漏。')
@@ -786,6 +793,7 @@ class MemoryEngine {
     lines.push('- 定期调用 memory_maintain 做 30 天蒸馏:AI 提炼旧日志要点进项目笔记,原文保底归档;不存密钥,除非用户明确要求。')
     lines.push('- 自动沉淀:每轮对话结束,插件会自动评估本轮内容,把有记录价值的写进今日日志([自动沉淀] 标记),有长期价值的升格到项目笔记/用户级记忆,寒暄轮自动跳过。你仍须按上方纪律转述自己的显式记忆操作;也可调用 memory_consolidate 让 AI 读日志发散提炼长期要点。')
     lines.push('- 记忆仅作补充,不替代正常回复与交付物。')
+    lines.push('- 注入上下文只含精简记忆(最近1天日志/反思精华/路径索引);**需要某天完整日志、反思全文或记忆文件全文时,调用 memory_read 按需读取(kind=log/reflection/user/notes/calendar),不要要求用户粘贴**。')
     return lines.join('\n')
   }
 
@@ -979,10 +987,21 @@ class MemoryEngine {
     return hits.slice(0, limit)
   }
 
-  /** 智能检索:AI 发散关键词 → 扫描三层记忆 → AI 综合答案。 */
+  /** 智能检索单飞入口：同一时间只允许一个请求，避免慢 subagent 堆积。 */
   async smartRecall(query, agent) {
+    if (this._smartRecallFlight) return this._smartRecallFlight
+    const flight = this._smartRecallCore(query, agent)
+    this._smartRecallFlight = flight
+    try { return await flight } finally { if (this._smartRecallFlight === flight) this._smartRecallFlight = undefined }
+  }
+
+  /** 智能检索：先本地命中，再用 subagent 扩展关键词和综合答案。 */
+  async _smartRecallCore(query, agent) {
     const q = String(query || '').trim()
     if (!q) return { answer: '检索内容为空。', keywords: [], hits: [] }
+    // 先用用户原句拆词，确保 subagent 不可用时也能快速返回本地命中。
+    const baseKeywords = q.toLowerCase().split(/[\s,，。:：;；/|()[\]{}]+/).filter((x) => x.length >= 2).slice(0, 8)
+    let localHits = await this.collectHits(baseKeywords, 14)
     // 第一轮:AI 把自然语言转成关键词
     const kwPrompt = [
       '你是记忆检索助手。用户想从记忆里查找信息,请把用户的自然语言描述转换成 3-6 个检索关键词(短词/短语,每行一个):',
@@ -991,11 +1010,12 @@ class MemoryEngine {
       '',
       '用户查询: ' + q,
     ].join('\n')
-    const kwText = await this.withTimeout(this.runSubagent(kwPrompt, 'auto-memory-smart-kw', agent), 8000, '')
+    const kwText = await this.withTimeout(this.runSubagent(kwPrompt, 'auto-memory-smart-kw', agent, 7000), 8000, '')
     const keywords = (kwText || '').split('\n').map((l) => l.trim().replace(/^[-•\d.\s]+/, '')).filter((l) => l && l.length <= 24).slice(0, 6)
     if (!keywords.length) keywords.push(q.slice(0, 20))
     // 扫描三层记忆
-    const hits = await this.collectHits(keywords.map((k) => k.toLowerCase()), 14)
+    const hits = await this.collectHits(Array.from(new Set(keywords.map((k) => k.toLowerCase()).concat(baseKeywords))), 14)
+    if (!hits.length && localHits.length) localHits = hits
     let answer = ''
     if (!hits.length) {
       answer = '没找到与"' + q + '"直接相关的记忆记录。可以换个说法,或试试普通关键词检索。'
@@ -1015,7 +1035,7 @@ class MemoryEngine {
         '命中片段:',
         hitText,
       ].join('\n')
-      answer = await this.withTimeout(this.runSubagent(ansPrompt, 'auto-memory-smart-ans', agent), 15000, '')
+      answer = await this.withTimeout(this.runSubagent(ansPrompt, 'auto-memory-smart-ans', agent, 12000), 15000, '')
       if (!answer) answer = '已检索到 ' + hits.length + ' 条相关记录,但 AI 综合失败(可能对话繁忙),请看下方命中明细。'
     }
     return { answer, keywords, hits: hits.map((h) => ({ where: h.where, line: h.line })) }
@@ -1088,66 +1108,48 @@ class MemoryEngine {
         const raw = await this.readTextSafe(cacheFile)
         if (raw) {
           const j = JSON.parse(raw)
-          if (j && Array.isArray(j.workspaces)) return { workspaces: j.workspaces, cached: true, generatedAt: j.generatedAt }
+          if (j && Array.isArray(j.workspaces) && j.graph && Array.isArray(j.graph.topics) && Array.isArray(j.graph.links)) return { workspaces: j.workspaces, graph: j.graph, cached: true, generatedAt: j.generatedAt }
         }
       } catch (e) {}
     }
     const cwds = await this.discoverWorkspaces()
-    const workspaces = []
-    for (const cwd of cwds.slice(0, 8)) {
+    const records = (await Promise.all(cwds.slice(0, 8).map(async (cwd) => {
       const mem = await this.readWorkspaceMemory(cwd)
-      if (!mem || (!mem.logs.length && !mem.notes)) continue
+      if (!mem || (!mem.logs.length && !mem.notes)) return null
       const name = String(cwd).split(/[\\/]/).filter(Boolean).pop() || cwd
-      let summary = ''
-      let items = []
-      if (mem.logs.length || mem.notes) {
-        const logText = mem.logs.map((l) => '[' + l.date + '] ' + l.text).join('\n')
-        const prompt = [
-          '你是用户的记忆管家。下面是某个工作区的近期记忆(最近5天日志+项目笔记),请:',
-          '1. 写一段 40-100 字的小总结:这个工作区在做什么、最近进展与主要成果,口语化一点。',
-          '2. 列出 2-5 条细分总结(每条 15-40 字),按日期或主题归纳(如"8-14: 发布 v0.1.9"、"进行中: 扩展框架")。',
-          '输出格式(严格遵守,不要多余文字):',
-          '[SUMMARY]',
-          '<小总结>',
-          '[ITEM]',
-          '<细分1>',
-          '[ITEM]',
-          '<细分2>',
-          '',
-          '工作区: ' + name,
-          '',
-          '近期日志:',
-          logText.slice(0, 6000) || '(无)',
-          '',
-          '项目笔记:',
-          mem.notes || '(无)',
-        ].join('\n')
-        const text = await this.withTimeout(this.runSubagent(prompt, 'auto-memory-ws-summary', agent), 30000, '')
-        let cur = null
-        for (const raw of String(text || '').split('\n')) {
-          const l = raw.trim()
-          if (!l) continue
-          if (l.startsWith('[SUMMARY]')) { cur = 'summary'; continue }
-          if (l.startsWith('[ITEM]')) { cur = 'item'; continue }
-          if (cur === 'summary' && l) summary += (summary ? '\n' : '') + l
-          else if (cur === 'item' && l && items.length < 6) items.push(l.slice(0, 120))
-        }
+      const logText = mem.logs.map((l) => '[' + l.date + '] ' + l.text).join('\n')
+      const fallbackItems = mem.logs.flatMap((l) => l.text.split('\n').filter((x) => x.trim().startsWith('- ')).map((x) => x.trim().replace(/^- /, '').slice(0, 120))).slice(-5)
+      return { path: cwd, name, input: { name, logs: logText.slice(0, 5200) || '(无)', notes: mem.notes || '(无)' }, fallbackItems, logCount: fallbackItems.length, dateRange: mem.logs.length ? (mem.logs[mem.logs.length - 1].date + ' ~ ' + mem.logs[0].date) : '' }
+    }))).filter(Boolean)
+    const fallback = records.map((r) => ({ path: r.path, name: r.name, summary: '', items: r.fallbackItems, graphTopics: r.fallbackItems.slice(0, 4).map((label) => ({ label, detail: '' })), logCount: r.logCount, dateRange: r.dateRange }))
+    let workspaces = fallback
+    let graph = { topics: [], links: [] }
+    const prompt = [
+      '你是跨工作区记忆架构师。请根据输入一次性总结每个工作区，并生成可渲染的思维导图语义。',
+      '只输出严格 JSON，不要 Markdown：{"workspaces":[{"name":"工作区名","summary":"40-100字","items":["15-40字主题"]}],"graph":{"topics":[{"workspace":"工作区名","label":"主题","detail":"一句话"}],"links":[{"from":"工作区名","to":"工作区名","label":"共享主题"}]}}。',
+      '每个工作区最多 5 条 items 和 4 个 topics；links 只保留真实关联。不要改变工作区名称。',
+      JSON.stringify(records.map((r) => r.input)).slice(0, 22000),
+    ].join('\n')
+    const text = await this.withTimeout(this.runSubagent(prompt, 'auto-memory-ws-map', agent, 30000), 35000, '')
+    try {
+      const match = String(text || '').match(/\{[\s\S]*\}/)
+      const parsed = match ? JSON.parse(match[0]) : null
+      if (parsed && Array.isArray(parsed.workspaces) && parsed.graph && Array.isArray(parsed.graph.topics) && Array.isArray(parsed.graph.links)) {
+        workspaces = records.map((r) => {
+          const ai = parsed.workspaces.find((x) => x && x.name === r.name) || {}
+          const items = Array.isArray(ai.items) ? ai.items.map((x) => String(x).slice(0, 120)).slice(0, 5) : r.fallbackItems
+          return { path: r.path, name: r.name, summary: String(ai.summary || '').slice(0, 600), items, graphTopics: [], logCount: r.logCount, dateRange: r.dateRange }
+        })
+        graph = { topics: parsed.graph.topics.slice(0, 32).filter((x) => x && typeof x.workspace === 'string' && typeof x.label === 'string'), links: parsed.graph.links.slice(0, 24).filter((x) => x && typeof x.from === 'string' && typeof x.to === 'string') }
       }
-      workspaces.push({
-        path: cwd,
-        name,
-        summary,
-        items,
-        logCount: mem.logs.reduce((a, l) => a + (l.text.split('\n').filter((x) => x.trim().startsWith('- ')).length), 0),
-        dateRange: mem.logs.length ? (mem.logs[mem.logs.length - 1].date + ' ~ ' + mem.logs[0].date) : '',
-      })
-    }
-    const result = { workspaces, generatedAt: Date.now() }
+    } catch (e) { diag('workspace graph JSON parse failed: ' + (e && e.message ? e.message : e)) }
+    for (const ws of workspaces) ws.graphTopics = graph.topics.filter((x) => x.workspace === ws.name).map((x) => ({ label: String(x.label).slice(0, 42), detail: String(x.detail || '').slice(0, 100) })).slice(0, 4)
+    const result = { workspaces, graph, generatedAt: Date.now() }
     try {
       await mkdir(path.dirname(cacheFile), { recursive: true })
       await writeFile(cacheFile, JSON.stringify(result, null, 2), 'utf8')
     } catch (e) {}
-    return { workspaces, cached: false, generatedAt: result.generatedAt }
+    return { workspaces, graph, cached: false, generatedAt: result.generatedAt }
   }
 
   // ---------- 调试中心(为提 issue 提供诊断信息) ----------
@@ -1205,7 +1207,7 @@ class MemoryEngine {
       autoConsolidate: {
         enabled: this.config.autoConsolidate !== false,
         minChars: Math.max(Number(this.config.autoConsolidateMinChars) || 240, 80),
-        cooldownMinutes: Math.max(Number(this.config.autoConsolidateCooldownMinutes) || 5, 1),
+        cooldownMinutes: Math.max(Number(this.config.autoConsolidateCooldownMinutes) || 30, 1),
         dailyMax: Math.max(Number(this.config.autoConsolidateDailyMax) || 8, 1),
         callCountToday: this._autoCallCount || 0,
         consolidating: !!this._consolidating,
@@ -1375,21 +1377,18 @@ class MemoryEngine {
         }
       } catch (e) {}
     }
+    const paths = await this.resolvePaths(agent)
+    const sourceFile = period === '昨天'
+      ? (this.state.recentLogs[0] ? path.join(paths.projectDir, this.state.recentLogs[0].date + '.md') : '')
+      : paths.logPath
     const prompt = [
-      '你是一个温暖、细腻的生活助理。请阅读用户某时段的原始工作记录,做两件事:',
+      '你是一个温暖、细腻的生活助理。请使用文件读取工具读取下面的绝对路径，不要要求用户粘贴内容：',
+      sourceFile || '(文件不可用)',
+      '从文件中只筛选“' + period + '”时段的工作条目（昨天则读取整份昨天日志），共有约 ' + items.length + ' 条候选记录。',
       '1. 写一段生活化总结(80-160字),像朋友聊天:概括完成的事、是否收尾、可能的烦恼(温和带过,看不出就跳过);不要列表、不要小标题、不要"总结:"前缀。',
-      '2. 把原始记录归纳成若干项"工作"(3-6项),每项给简短标题(8-16字),并列出该工作的细点(每项2-4条,每条20-40字,从原始记录提炼精简,不要逐字复制长句)。',
+      '2. 把原始记录归纳成若干项“工作”(3-6项),每项给简短标题(8-16字),并列出细点(每项2-4条)。',
       '输出格式(严格遵守,不要多余文字):',
-      '[SUMMARY]',
-      '<生活化总结>',
-      '[WORK] <工作标题1>',
-      '- <细点1>',
-      '- <细点2>',
-      '[WORK] <工作标题2>',
-      '- <细点1>',
-      '',
-      '用户时段工作记录(' + period + '):',
-      items.map((x) => '- ' + x).join('\n'),
+      '[SUMMARY]', '<生活化总结>', '[WORK] <工作标题1>', '- <细点1>', '- <细点2>',
     ].join('\n')
     const text = await this.runSubagent(prompt, 'auto-memory-summarize', agent)
     if (!text) return { summary: '', works: [], cached: false, generatedAt: Date.now() }
@@ -1523,7 +1522,7 @@ class MemoryEngine {
   }
 
   /** 调用 DSH subagent 发散/提炼一段文本(90s 超时,结果取 text 块;parent 用最近 agent)。 */
-  async runSubagent(text, label, agent) {
+  async runSubagent(text, label, agent, timeoutMs) {
     const subagents = this._subagents
     if (!subagents) return ''
     // parent 必须是完整 agent 对象(captureDelegatedPolicyOverrides 读 parent.ctx/parent.session);路由调用用缓存的最近 agent
@@ -1540,10 +1539,11 @@ class MemoryEngine {
       if (Array.isArray(registered) && registered.length && !registered.includes('spawn')) providerName = registered[0]
     } catch (e2) {}
     const controller = new AbortController()
-    const timer = setTimeout(() => controller.abort(label + ' timeout'), 90000)
+    const timer = setTimeout(() => controller.abort(label + ' timeout'), Math.max(Number(timeoutMs) || 90000, 1000))
+    let run
     try {
       // prompt 必须是 block 数组(createUserMessage 校验 content.some)
-      const run = await subagents.start(providerName, {
+      run = await subagents.start(providerName, {
         label,
         prompt: [{ type: 'text', text }],
         signal: controller.signal,
@@ -1559,6 +1559,9 @@ class MemoryEngine {
       return ''
     } finally {
       clearTimeout(timer)
+      if (controller.signal.aborted && run && typeof run.dispose === 'function') {
+        try { await run.dispose() } catch (e2) {}
+      }
     }
   }
 
@@ -1577,6 +1580,10 @@ class MemoryEngine {
   /** 每轮对话结束自动沉淀:取本轮 user+assistant 消息 → subagent 判断/提炼 → 写今日日志+升格。 */
   async consolidateTurn(turn, agent) {
     const why = (reason) => diag('consolidate skip: ' + reason + ' (turn=' + JSON.stringify(turn) + ' agentId=' + ((agent && (agent.id || (agent.session && agent.session.id))) || '?') + ')')
+    // 声明提到函数级:异步 IIFE 与 try 块各自作用域,块内 let 在外面不可见(曾导致 userText is not defined)
+    let userText = ''
+    let assistantText = ''
+    try {
     if (this._consolidating) { why('_consolidating busy'); return }
     if (!this.configLoaded) { try { await this.loadConfig() } catch (e) {} }
     if (this.config.autoConsolidate === false) { why('config.autoConsolidate=false'); return }
@@ -1586,7 +1593,10 @@ class MemoryEngine {
     const minChars = Math.max(Number(this.config.autoConsolidateMinChars) || 240, 80)
     const today = this.memToday()
     if (this._autoCallDate !== today) { this._autoCallDate = today; this._autoCallCount = 0 }
-    const cooldownMs = Math.max(Number(this.config.autoConsolidateCooldownMinutes) || 5, 1) * 60000
+    // 间隔(默认30分钟);非工作时间(22:00-08:00)自动翻倍,避免短时间耗尽每日额度
+    const baseCooldown = Math.max(Number(this.config.autoConsolidateCooldownMinutes) || 30, 1)
+    const hourNow = new Date().getHours()
+    const cooldownMs = baseCooldown * 60000 * ((hourNow >= 22 || hourNow < 8) ? 2 : 1)
     const dailyMax = Math.max(Number(this.config.autoConsolidateDailyMax) || 8, 1)
     if (this._autoCallCount >= dailyMax) { why('daily subagent cap=' + dailyMax); return }
     if (this._lastConsolidateStartedAt && Date.now() - this._lastConsolidateStartedAt < cooldownMs) { why('cooldown'); return }
@@ -1599,8 +1609,6 @@ class MemoryEngine {
     // 取本轮最后一条 user + 最后一条 assistant(模型可见消息序列)
     const messages = extractSessionMessages(agent)
     if (messages.length < 2) { why('messages<2 got=' + messages.length + ' seqs=' + ((agent.session.surface && agent.session.surface.nodes && (Array.isArray(agent.session.surface.nodes) ? agent.session.surface.nodes.length : 'set')) || 'none') + ' events=' + ((agent.session.events && agent.session.events.length) || 'none')); return }
-    let userText = ''
-    let assistantText = ''
     for (const m of messages) {
       if (m.role === 'user') userText = m.text
       else if (m.role === 'assistant' && m.text) assistantText = m.text
@@ -1611,6 +1619,7 @@ class MemoryEngine {
     this._lastConsolidateStartedAt = Date.now()
     this._autoCallCount++
     diag('consolidate subagent start count=' + this._autoCallCount + '/' + dailyMax + ' inputChars=' + Math.min(combined.length, 6000))
+    } catch (e) { diag('consolidate pre-flight error: ' + (e && (e.stack || e.message) || e)); return }
     this._consolidating = (async () => {
       try {
         await this.refresh(agent)
@@ -1645,7 +1654,8 @@ class MemoryEngine {
           '今日日志已有内容(避免重复记录):',
           logTail || '(空)',
         ].join('\n')
-        const text = await this.runSubagent(prompt, 'auto-memory-consolidate', agent)
+        // 超时兜底:subagent 挂起(如会话收尾期)时 40s 后放弃并走重试队列,避免 _consolidating 永久占用导致后续轮次全部 skip busy
+        const text = await this.withTimeout(this.runSubagent(prompt, 'auto-memory-consolidate', agent), 40000, '')
         if (!text) {
           diag('consolidate: subagent returned empty text (queued for retry)')
           // subagent 失败(返回空):入重试队列,由后台轮询兜底重试
@@ -1931,6 +1941,8 @@ class MemoryEngine {
         notes: this.state.notesText.length,
         log: this.state.logText.length,
       },
+      userText: this.state.userText.slice(0, 20000),
+      userTextTruncated: this.state.userText.length > 20000,
       todayEntries,
       latestReflectionDate: this.state.latestReflectionDate,
       pendingReflection: this.state.pendingReflection ? this.state.pendingReflection.date : undefined,
@@ -2133,9 +2145,9 @@ class ExternalMemory {
       }
 
       // —— 用户级/画像类 markdown ——
-      await pushMd('workbuddy-user', 'AI 助手用户记忆', 'AI 助手', 'user', [path.join(home, '.workbuddy', 'MEMORY.md')])
+      await pushMd('workbuddy-user', 'WorkBuddy 用户记忆', 'WorkBuddy', 'user', [path.join(home, '.workbuddy', 'MEMORY.md')])
       const wbProfiles = await globOne(path.join(home, '.workbuddy', 'memory'), /_memory\.md$/, 3)
-      await pushMd('workbuddy-profile', 'AI 助手云端画像', 'AI 助手', 'profile', wbProfiles)
+      await pushMd('workbuddy-profile', 'WorkBuddy 云端画像', 'WorkBuddy', 'profile', wbProfiles)
       const cbMems = await globOne(path.join(home, '.codebuddy', 'memery'), /_memery\.md$/, 3)
       await pushMd('codebuddy-memory', 'CodeBuddy 记忆画像', 'CodeBuddy', 'profile', cbMems)
       await pushMd('claude-global', 'Claude Code 全局记忆', 'Claude Code', 'user', [path.join(home, '.claude', 'CLAUDE.md')])
@@ -2147,7 +2159,7 @@ class ExternalMemory {
       const cursorRules = await globOne(path.join(ws, '.cursor', 'rules'), /\.(mdc|md)$/, 10)
       await pushMd('project-conventions', '项目约定(CLAUDE.md 等)', '项目文件', 'project', [...conventions, ...cursorRules])
       // —— 会话类 ——
-      await pushSessions('workbuddy-sessions', 'AI 助手历史会话', 'AI 助手', path.join(home, '.workbuddy', 'projects'))
+      await pushSessions('workbuddy-sessions', 'WorkBuddy 历史会话', 'WorkBuddy', path.join(home, '.workbuddy', 'projects'))
       await pushSessions('claude-sessions', 'Claude Code 历史会话', 'Claude Code', path.join(home, '.claude', 'projects'))
       await pushSessions('codex-sessions', 'Codex 历史会话', 'Codex', path.join(home, '.codex', 'sessions'))
 
@@ -2250,18 +2262,108 @@ class ExternalMemory {
     return '已接入项目笔记(' + src.name + ', ' + src.content.length + ' 字符)'
   }
 
+  /** 检查某源是否已接入用户级/项目笔记。 */
+  async importStatus(sourceId, engine, agent) {
+    const srcs = await this.discover(false)
+    const src = srcs.find((s) => s.id === sourceId)
+    if (!src || src.kind === 'sessions') return { imported: false, locations: [] }
+    const marker = '## 来自 ' + src.tool + '(' + src.name + ')'
+    const p = await engine.resolvePaths(agent)
+    const userText = engine.state.userText || (await engine.readTextSafe(p.userFile)) || ''
+    const notesText = engine.state.notesText || (await engine.readTextSafe(p.notesPath)) || ''
+    const locations = []
+    if (userText.includes(marker)) locations.push(p.userFile)
+    if (notesText.includes(marker)) locations.push(p.notesPath)
+    return { imported: locations.length > 0, locations }
+  }
+
+  /** 移除某源已接入到用户级/项目笔记的内容段(target 可选 'user'|'project',缺省全部)。 */
+  async removeImported(sourceId, engine, agent, target) {
+    const srcs = await this.discover(false)
+    const src = srcs.find((s) => s.id === sourceId)
+    if (!src || src.kind === 'sessions') return '该来源无已接入内容可移除。'
+    const marker = '## 来自 ' + src.tool + '(' + src.name + ')'
+    const p = await engine.resolvePaths(agent)
+    let removed = 0
+    const candidates = []
+    if (target !== 'project') candidates.push({ file: p.userFile, field: 'userText', label: '用户级记忆' })
+    if (target !== 'user') candidates.push({ file: p.notesPath, field: 'notesText', label: '项目笔记' })
+    for (const t of candidates) {
+      const text = (engine.state[t.field] || (await engine.readTextSafe(t.file))) || ''
+      if (!text.includes(marker)) continue
+      const cleaned = stripImportedSection(text, marker)
+      if (cleaned === text) continue
+      await engine.writeFull(t.file, cleaned)
+      engine.state[t.field] = cleaned
+      engine.state.loadedAt = Date.now()
+      removed++
+    }
+    return removed ? '已从 ' + src.name + ' 移除已接入内容(' + (removed === 2 ? '用户级记忆 + 项目笔记' : '1 处') + ')' : '该来源尚未接入' + (target ? (target === 'user' ? '用户级记忆' : '项目笔记') : '任何记忆') + '。'
+  }
+
   /** 简化状态视图(UI 用)。 */
   async summarize() {
     const srcs = await this.discover(false)
-    return srcs.map((s) => ({
-      id: s.id, name: s.name, tool: s.tool, kind: s.kind,
-      fileCount: s.files.length, size: s.size, mtime: s.mtime,
-      preview: s.kind === 'sessions' ? '' : truncateHead(s.content, 240),
-      enabled: this.enabled(s.id),
-    }))
+    const p = await this.engine.resolvePaths(undefined)
+    const out = []
+    for (const s of srcs) {
+      const base = {
+        id: s.id, name: s.name, tool: s.tool, kind: s.kind,
+        fileCount: s.files.length, size: s.size, mtime: s.mtime,
+        preview: s.kind === 'sessions' ? '' : truncateHead(s.content, 240),
+        enabled: this.enabled(s.id),
+      }
+      if (s.kind !== 'sessions') {
+        try {
+          const st = await this.importStatus(s.id, this.engine)
+          base.importedUser = (st.locations || []).some((f) => f !== p.notesPath)
+          base.importedNotes = (st.locations || []).some((f) => f === p.notesPath)
+        } catch (e) {}
+      }
+      out.push(base)
+    }
+    return out
   }
 }
 
+/** 删除文件中以 marker 开头的 ## 段落(到下一个 ## 标题或文件尾)。 */
+function stripImportedSection(text, marker) {
+  const lines = String(text || '').split('\n')
+  const out = []
+  let skipping = false
+  for (const line of lines) {
+    if (/^## /.test(line)) {
+      if (line.startsWith(marker)) { skipping = true; continue }
+      skipping = false
+    }
+    if (!skipping) out.push(line)
+  }
+  let body = out.join('\n').replace(/\n{3,}/g, '\n\n').trim()
+  return body ? body + '\n' : ''
+}
+
+/** 反思精华:只取「成果回顾」段落(约500字),省去长文;无该段则截取头部。 */
+function reflectionDigest(text) {
+  const t = String(text || '')
+  const m = t.match(/^##\s*成果回顾[\s\S]*?(?=^##\s|\n##\s)/m)
+  if (m && m[0]) return m[0].trim().slice(0, 500)
+  return truncateHead(t, 350)
+}
+
+/** 注入前过滤:跳过标题含敏感词的 ## 段落(凭据/token/密钥等),防止密钥暴露给模型。 */
+function stripSensitiveSections(text) {
+  const lines = String(text || '').split('\n')
+  const out = []
+  let skip = false
+  for (const line of lines) {
+    if (/^## /.test(line)) {
+      skip = /敏感|凭据|令牌|口令|token|密钥|secret|password|credential|pat\b|api\s*key/i.test(line)
+    }
+    if (!skip) out.push(line)
+  }
+  return out.join('\n').replace(/\n{3,}/g, '\n\n').trim()
+}
+
 /** 从 session 提取消息。surface 不是完整可靠的 user 来源,因此失败时回退完整事件日志。 */
 function messageOfEvent(ev) {
   if (!ev) return null
@@ -2287,18 +2389,13 @@ function extractSessionMessages(agent) {
   try {
     const session = agent && agent.session
     if (!session) return []
-    const events = session.events || []
-    const seqs = []
-    try {
-      const nodes = session.surface && session.surface.nodes
-      if (Array.isArray(nodes)) seqs.push(...nodes)
-      else if (nodes instanceof Set) seqs.push(...Array.from(nodes))
-    } catch (e) {}
-    // surface 可能遗漏刚提交的 user/message;追加完整事件序列并去重。
-    for (let i = 0; i < events.length; i++) if (!seqs.includes(i)) seqs.push(i)
+    // 只读 events 数组(截断尾部),绝不访问 session.surface.nodes:
+    // 该访问会触发惰性投影,长会话(上万事件)时同步遍历阻塞主线程 → 窗口卡死/超时。
+    const eventsRaw = session.events || []
+    const events = eventsRaw.length > 2000 ? eventsRaw.slice(-2000) : eventsRaw
     const out = []
-    for (const seq of seqs) {
-      const ev = events[seq]
+    for (let i = 0; i < events.length; i++) {
+      const ev = events[i]
       const msg = messageOfEvent(ev)
       if (!msg || !msg.role || !Array.isArray(msg.content)) continue
       out.push({ role: msg.role, text: textOfContent(msg.content), sourceKind: msg.source && msg.source.kind })
@@ -2354,6 +2451,18 @@ function extractJsonText(line) {
  * Mount the memory engine: routes, tools, prompt section, reflection hooks.
  */
 export function apply(ctx, config) {
+  // 进程级诊断:退出/未捕获异常时留痕,便于下次崩溃后定位(只记录不阻止退出)
+  try {
+    process.on('uncaughtException', (err) => { console.error('[dsh-auto-memory] uncaughtException:', err && (err.stack || err.message) || err) })
+    process.on('exit', (code) => { console.log('[dsh-auto-memory] process exit code=' + code) })
+  } catch (e) {}
+  // 全局兜底:任何未捕获的异步异常只记录不崩溃(插件进程崩溃会连带 dsh web 一起退出)
+  try {
+    if (!process._dshAutoMemoryRejectionGuard) {
+      process._dshAutoMemoryRejectionGuard = true
+      process.on('unhandledRejection', (reason) => { console.error('[dsh-auto-memory] unhandledRejection guard:', reason && (reason.stack || reason.message) || reason) })
+    }
+  } catch (e) {}
   const engine = new MemoryEngine()
   const sessionQuery = ctx.get('sessionQuery')
   engine._sessionQuery = sessionQuery
@@ -2385,7 +2494,12 @@ export function apply(ctx, config) {
       const agent = (payload && payload.agent) || engine._lastAgent
       const hasAgent = !!(agent && agent.session)
       diag('turn-stopping fired: turn=' + JSON.stringify(payload && payload.turn) + ' hasAgent=' + hasAgent + ' payloadKeys=' + (payload ? Object.keys(payload).join(',') : 'null') + ' _lastAgent=' + !!(engine._lastAgent && engine._lastAgent.session))
-      if (hasAgent) void engine.consolidateTurn(payload.turn, agent)
+      if (hasAgent) {
+        // 延迟到 turn-stopping 收尾完成后再启动 subagent,避免与 DSH 会话收尾竞争导致进程级崩溃
+        setTimeout(() => {
+          void engine.consolidateTurn(payload.turn, agent).catch((e) => console.error('[dsh-auto-memory] consolidateTurn unhandled', e && (e.stack || e.message) || e))
+        }, 600)
+      }
     } catch (e) { diag('turn-stopping handler error: ' + (e && e.message)) }
   })
   // 注入层保障:systemPrompt section.text 是同步函数不能 await,state 异步加载会导致首轮注入为空。
@@ -2488,6 +2602,29 @@ export function apply(ctx, config) {
       return '已更新用户级记忆: ' + p.userFile + '\n追加内容:\n' + content + (acct.compacted ? '\n(已自动压缩旧内容腾出空间)' : '')
     }),
 
+    defineTool('memory_read', '按需读取记忆文件完整内容(某日日志/反思全文、用户级记忆、项目笔记、日历),注入上下文只含精简摘要,需要细节时用本工具,不要要求用户粘贴。', {
+      kind: { type: 'string', enum: ['log', 'reflection', 'user', 'notes', 'calendar'], required: true, description: '读取类型: log=某日日志, reflection=某日反思, user=用户级记忆, notes=项目笔记, calendar=日历。' },
+      date: { type: 'string', description: '日期 YYYY-MM-DD(仅 log/reflection 需要,缺省今天)。' },
+    }, async (args, exec) => {
+      const kind = String(args.kind || '')
+      const date = /^\d{4}-\d{2}-\d{2}$/.test(String(args.date || '')) ? String(args.date) : engine.memToday()
+      const pp = await engine.resolvePaths(exec.agent)
+      let file = ''
+      let label = ''
+      if (kind === 'log') { file = path.join(pp.projectDir, date + '.md'); label = date + ' 日志' }
+      else if (kind === 'reflection') { file = path.join(pp.reflectDir, date + '.md'); label = date + ' 反思' }
+      else if (kind === 'user') { file = pp.userFile; label = '用户级记忆' }
+      else if (kind === 'notes') { file = pp.notesPath; label = '项目笔记' }
+      else if (kind === 'calendar') { file = pp.calendarPath; label = '日历' }
+      else return 'memory_read: kind 无效(可选 log/reflection/user/notes/calendar)。'
+      const text = await engine.readTextSafe(file)
+      if (!text) return '未找到' + label + '文件: ' + file
+      const cap = 8000
+      return text.length > cap
+        ? label + '(' + file + ') 内容过长,显示前 ' + cap + ' 字符:\n' + text.slice(0, cap) + '\n...(如需更多,用 memory_recall 检索关键词)'
+        : label + '(' + file + '):\n' + text
+    }),
+
     defineTool('memory_recall', '检索记忆:本地记忆文件(当前工作区 + 其他所有工作区的每日日志、项目笔记、用户级记忆、反思)关键词匹配 + 历史 DSH 会话全文检索(如部署启用)。开发/排查中不懂的、用户提到过去的做法/讨论/决定而当前上下文没有时调用——跨工作区的记忆也能检索到(结果标注来源工作区)。查询必须自包含。**检索后必须在本轮回复正文中向用户转述:检索了什么、找到什么(或没找到)**。', {
       query: { type: 'string', required: true, description: '检索关键词或自包含描述。' },
       limit: { type: 'integer', description: '最多返回条数,缺省 8。' },
@@ -2540,8 +2677,10 @@ export function apply(ctx, config) {
       time: { type: 'string', description: '时间 HH:MM,无则 --:--。' },
       quadrant: { type: 'string', enum: ['重要紧急', '重要不紧急', '紧急不重要', '不重要不紧急'], description: '四象限分类,缺省重要不紧急。' },
       title: { type: 'string', required: true, description: '事项标题。' },
+      location: { type: 'string', description: '地点，可选。' },
+      reminder: { type: 'string', description: '提醒内容或提前量说明，可选。' },
       note: { type: 'string', description: '备注/来源,如"来自对话:用户说周五交报告"。' },
-    }, async (args, exec) => engine.calendarAdd({ date: args.date, time: args.time, quadrant: args.quadrant, title: args.title, note: args.note }, exec.agent)),
+    }, async (args, exec) => engine.calendarAdd({ date: args.date, time: args.time, quadrant: args.quadrant, title: args.title, note: [args.location ? '地点: ' + args.location : '', args.reminder ? '提醒: ' + args.reminder : '', args.note || ''].filter(Boolean).join(' | ') }, exec.agent)),
 
     defineTool('calendar_list', '列出日历条目(可按日期过滤、含完成状态)。用于查看已有安排、回答"我最近有什么安排"等问题。', {
       date: { type: 'string', description: '过滤日期 YYYY-MM-DD,缺省全部(近 60 天)。' },
@@ -2652,8 +2791,9 @@ export function apply(ctx, config) {
         const body = await readJsonBody(req)
         if (!body || typeof body.query !== 'string') return writeJson(res, 400, { error: 'invalid body' })
         try {
-          await engine.refresh(undefined)
-          writeJson(res, 200, await engine.smartRecall(body.query))
+          // 检索只刷新已加载状态；不要等待全局 refresh 队列，否则 GUI 会像卡死。
+          if (!engine.configLoaded) await engine.loadConfig()
+          writeJson(res, 200, await engine.smartRecall(body.query, engine._lastAgent))
         } catch (e) { writeJson(res, 500, { error: String(e && e.message ? e.message : e) }) }
       },
     },
@@ -2665,7 +2805,7 @@ export function apply(ctx, config) {
         if ((req.method || 'POST') !== 'POST') return writeJson(res, 405, { error: 'method not allowed' })
         const body = await readJsonBody(req).catch(() => ({}))
         try {
-          writeJson(res, 200, await engine.workspaceOverview(undefined, !!(body && body.force)))
+          writeJson(res, 200, await engine.workspaceOverview(engine._lastAgent, !!(body && body.force)))
         } catch (e) { writeJson(res, 500, { error: String(e && e.message ? e.message : e) }) }
       },
     },
@@ -2814,6 +2954,40 @@ export function apply(ctx, config) {
         try { writeJson(res, 200, { sources: await engine.external.summarize() }) } catch (e) { writeJson(res, 500, { error: String(e && e.message ? e.message : e) }) }
       },
     },
+    {
+      kind: 'exact',
+      path: API['external-view'],
+      handler: async (req, res) => {
+        if (!isLoopbackRequest(req)) return writeJson(res, 403, { error: 'forbidden: loopback-only' })
+        if ((req.method || 'GET') !== 'GET') return writeJson(res, 405, { error: 'method not allowed' })
+        try {
+          const url = new URL(req.url || '/', 'http://localhost')
+          const id = String(url.searchParams.get('source') || '')
+          const sources = await engine.external.discover(false)
+          const src = sources.find((s) => s.id === id)
+          if (!src) return writeJson(res, 404, { error: 'source not found' })
+          const content = src.kind === 'sessions'
+            ? '这是会话类来源，含 ' + src.files.length + ' 个可检索会话文件。请在“检索”页输入关键词，或让 AI 调用 memory_recall 按需取回。'
+            : src.content.slice(0, 16000)
+          const status = await engine.external.importStatus(src.id, engine)
+          writeJson(res, 200, { id: src.id, name: src.name, tool: src.tool, kind: src.kind, content, truncated: src.kind !== 'sessions' && src.content.length > content.length, imported: status.imported, locations: status.locations })
+        } catch (e) { writeJson(res, 500, { error: String(e && e.message ? e.message : e) }) }
+      },
+    },
+    {
+      kind: 'exact',
+      path: API['external-remove'],
+      handler: async (req, res) => {
+        if (!isLoopbackRequest(req)) return writeJson(res, 403, { error: 'forbidden: loopback-only' })
+        if ((req.method || 'POST') !== 'POST') return writeJson(res, 405, { error: 'method not allowed' })
+        const body = await readJsonBody(req)
+        if (!body || typeof body.source !== 'string') return writeJson(res, 400, { error: 'invalid body' })
+        try {
+          const result = await engine.external.removeImported(body.source, engine, undefined, body.target === 'user' ? 'user' : body.target === 'project' ? 'project' : undefined)
+          writeJson(res, 200, { result })
+        } catch (e) { writeJson(res, 500, { error: String(e && e.message ? e.message : e) }) }
+      },
+    },
     {
       kind: 'exact',
       path: API['external-import'],