@ssamurias/dsh-fish 0.9.0 → 0.9.2

package/lib/status.js

@@ -44,7 +44,7 @@ function dayMarker(text, prefix, dk) {
  * @param {{events:Array, config:object, now?:Date}} input
  * @returns {{phase:string, label:string, detail:string, since:string, minutesAgo:number|null,
  *            plannedWakeAt:string|null, nextWakeAt:string|null, awake:boolean,
- *            today:{wakes:number,idleWakes:number,browsed:number,said:number,comments:number,dairies:number},
+ *            today:{wakes:number,idleWakes:number,browsed:number,said:number,chat:number,comments:number,dairies:number},
  *            timeline:Array<{at:string,kind:string,text:string,idle?:boolean}>}}
  */
 export function deriveStatus({ events = [], config = {}, now = new Date() } = {}) {
@@ -71,9 +71,17 @@ export function deriveStatus({ events = [], config = {}, now = new Date() } = {}
     if (Number.isFinite(at)) plannedWakeAt = at
   }
 
+  // 2026-11-06（0.9.1 反馈）：`quiet:` 是「落点到了，但没有可出的事件」，
+  // 不是「今天不会醒了」——quiet 之后冷却到期还会真醒（11-05 就是这样）。
+  // 所以它能解释「为什么没醒」，但不能用「今天」这种封死的说法。
+  const quietToday = today.some(({ e }) => e?.type === 'meta' && String(textOf(e) ?? '').startsWith(`quiet:${dk}`))
+
   // ---- 把今天切成"醒来块"：每个 wake: 是起点，动作挂到它下面 ----
   const blocks = []
-  const counts = { wakes: 0, idleWakes: 0, browsed: 0, said: 0, comments: 0, dairies: 0 }
+  // chat（issue #32）：对话里她说的那些行。它们**不是**她在这一轮里主动做的事——
+  // 一次叫醒正好撞上他连说几十句，时间线 40 条会被这些行占满，`idleWakes` 也会被
+  // 一句「嗯」清零。所以单列一个计数，不进 said、不算 done、时间线上折叠成一行。
+  const counts = { wakes: 0, idleWakes: 0, browsed: 0, said: 0, chat: 0, comments: 0, dairies: 0 }
   let cur = null
   const orphan = { at: today[0]?.t ?? nowMs, actions: [], wake: null }
 
@@ -120,7 +128,10 @@ export function deriveStatus({ events = [], config = {}, now = new Date() } = {}
         continue
       }
       if (dayMarker(text, 'quiet', dk) !== null) {
-        push(t, 'quiet', '醒了，但今天没有该问的事')
+        // 没有 wake: 就没有「醒」这回事。旧文案「醒了，但今天没有该问的事」
+        // 会在时间线上凭空多出一次醒来，还和状态卡「还没醒」互相打脸。
+        // 「暂时」也不用「今天」：quiet 不封当天，冷却到期后她照样会醒。
+        push(t, 'quiet', '到点了，暂时没有可出的事件')
         continue
       }
       if (dayMarker(text, 'unrecorded', dk) !== null) continue
@@ -128,6 +139,25 @@ export function deriveStatus({ events = [], config = {}, now = new Date() } = {}
     }
     // 她的发言
     if (e?.type === 'utterance' || e?.type === 'narration' || e?.type === 'revise') {
+      // issue #32：`flags: ['uncommitted']` 是 turns.js 在她**答他的话**时打的标
+      // （settle 写进来的对话行，不是她自己认下的判断）。这类行以前混在 said 里：
+      // 一次 wake 加 45 句聊天，时间线 40 条全是「说了：…」，`idleWakes` 也从 1 变 0。
+      // 现在单列成 chat，只在时间线上折成一行「聊了 N 句」。
+      const isChat = Array.isArray(e?.flags) && e.flags.includes('uncommitted')
+      if (isChat) {
+        const last = cur ?? orphan
+        const prev = last.actions[last.actions.length - 1]
+        // 连续多句合进同一条，别让一次长对话把时间线刷成弹幕。
+        if (prev && prev.kind === 'chat') {
+          prev.n += 1
+          prev.at = t
+          prev.text = `聊了 ${prev.n} 句`
+        } else {
+          push(t, 'chat', '聊了 1 句', { n: 1 })
+        }
+        counts.chat += 1
+        continue
+      }
       counts.said += 1
       const one = text.replace(/\s+/g, ' ').slice(0, 60)
       push(t, 'say', one ? `说了：「${one}${text.length > 60 ? '…' : ''}」` : '说了点什么')
@@ -143,10 +173,14 @@ export function deriveStatus({ events = [], config = {}, now = new Date() } = {}
 
   // ---- 醒着但什么也没做的块，记成 idle ----
   for (const b of blocks) {
-    const done = b.actions.filter((a) => a.kind !== 'quiet' && a.kind !== 'fail')
+    // issue #32：chat 跟 quiet/fail 一样不算「做了什么」——聊天是她答他的话，
+    // 不是这一轮她自己起的动作。否则他在她醒着时随便接一句，这次 wake 就不算发呆了。
+    const done = b.actions.filter((a) => a.kind !== 'quiet' && a.kind !== 'fail' && a.kind !== 'chat')
     b.idle = done.length === 0
   }
-  counts.idleWakes = blocks.filter((b) => b.idle).length
+  // 只有真醒过的块才算「醒着但没做」：没有 wake: 的那块（quiet / 他说话时插的几句）
+  // 根本不是一次醒来。以前它被算进 idleWakes，于是 wakes=0 而 idleWakes=1。
+  counts.idleWakes = blocks.filter((b) => b.wake !== null && b.idle).length
 
   // ---- 当前状态 ----
   const lastAct = today.length ? today[today.length - 1] : null
@@ -170,6 +204,10 @@ export function deriveStatus({ events = [], config = {}, now = new Date() } = {}
   } else if (recent && lastKind === 'say') {
     phase = 'talking'; label = '在想怎么回你'
     detail = activeBlock.actions[activeBlock.actions.length - 1].text
+  } else if (recent && lastKind === 'chat') {
+    // 刚跟他聊过几句：还是「在说话」，只是这些行不算她主动做的事（issue #32）。
+    phase = 'talking'; label = '在想怎么回你'
+    detail = ''
   } else if (recent && lastKind === 'diary') {
     phase = 'writing'; label = '在写日记'
     detail = ''
@@ -191,7 +229,9 @@ export function deriveStatus({ events = [], config = {}, now = new Date() } = {}
     const mins = plannedWakeAt ? Math.round((plannedWakeAt - nowMs) / 60_000) : null
     detail = plannedWakeAt && plannedWakeAt > nowMs
       ? `约 ${new Date(plannedWakeAt).toTimeString().slice(0, 5)} 会睡醒${mins !== null && mins >= 0 ? `（还有 ${mins} 分钟）` : ''}`
-      : '今天已经到点，但还没醒'
+      : (quietToday
+        ? '到点了，暂时没有可出的事件，还没醒'
+        : '今天已经到点，但还没醒')
   } else {
     phase = 'asleep'; label = '沉在水底'
     detail = plannedWakeAt && plannedWakeAt > nowMs
@@ -213,6 +253,16 @@ export function deriveStatus({ events = [], config = {}, now = new Date() } = {}
   const timeline = []
   for (const b of blocks) {
     const hhmm = new Date(b.at).toTimeString().slice(0, 5)
+    // 没有 wake: 的块不属于任何一次醒来（orphan）。以前拿当天第一条事件的时间
+    // 当块头，于是一天没醒过也会冒出「06:15 醒了，在发呆」（0.9.1 反馈）。
+    // 这些动作照原样列出来就好，别替她补一句「醒了」。
+    if (b.wake === null) {
+      for (const a of b.actions) {
+        const h2 = new Date(a.at).toTimeString().slice(0, 5)
+        timeline.push({ at: new Date(a.at).toISOString(), kind: a.kind, text: `${h2} ${a.text}` })
+      }
+      continue
+    }
     if (b.idle) {
       timeline.push({ at: new Date(b.at).toISOString(), kind: 'idle', text: `${hhmm} 醒了，在发呆`, idle: true })
       // 「醒来失败」「没有该问的事」正是这一块为什么什么都没做的原因，必须留下来，

package/lib/store.js

@@ -14,6 +14,7 @@
  * API 全部 async：原子写用「写 tmp → rename」，避免断电留半行。
  */
 
+import { randomBytes } from 'node:crypto'
 import { promises as fs } from 'node:fs'
 import { dirname, join } from 'node:path'
 import { validateEvent, EVENT_SCHEMA_VERSION } from './schema.js'
@@ -89,7 +90,8 @@ const RENAME_RETRY = new Set(['EPERM', 'EACCES', 'EBUSY', 'ENOTEMPTY'])
 
 export async function writeAtomic(file, text, mode) {
   await ensureDir(dirname(file))
-  const tmp = `${file}.${process.pid}.${Date.now()}.tmp`
+  // 随机后缀：同一进程同一毫秒的两次写不能共用一个临时文件，否则内容会交错，写出坏 JSON
+  const tmp = `${file}.${process.pid}.${Date.now()}.${randomBytes(4).toString('hex')}.tmp`
   await fs.writeFile(tmp, text, 'utf8')
   if (mode) await fs.chmod(tmp, mode).catch(() => {})
   for (let i = 0; i < RENAME_WAIT.length; i++) {
@@ -107,9 +109,19 @@ export async function writeAtomic(file, text, mode) {
   }
 }
 
+// issue #38：手改过的 JSON 常带 UTF-8 BOM（PowerShell 5.1 的
+// `Set-Content -Encoding UTF8`、记事本「带 BOM 的 UTF-8」都会写）。
+// `JSON.parse` 见到 BOM 直接抛 SyntaxError，于是**内容完好的文件**被下面的
+// 坏文件分支改名成 `.corrupt.<时间>`，config.json 退回全默认、owner.json 变 null、
+// home.json 直接新建一条会话——用户以为自己的改动丢了。
+// 只剥开头这一个字符；不动其余内容，也不改行号之外的任何字节。
+function stripBom(text) {
+  return typeof text === 'string' && text.charCodeAt(0) === 0xfeff ? text.slice(1) : text
+}
+
 export async function readJson(file, fallback = null) {
   try {
-    return JSON.parse(await fs.readFile(file, 'utf8'))
+    return JSON.parse(stripBom(await fs.readFile(file, 'utf8')))
   } catch (err) {
     if (err.code === 'ENOENT') return fallback
     // 坏文件不静默吞：留证据，返回 fallback 让上层能用

package/lib/tenant.js

@@ -62,6 +62,18 @@ export async function withFileLock(file, fn, { ttl = LOCK_TTL_MS, timeout = 8_00
       await fh.writeFile(JSON.stringify({ pid: process.pid, at: Date.now() }))
       break
     } catch (err) {
+      // issue #37：Windows 上文件正在被删除时，`open(file,'wx')` 返回 EPERM 而不是
+      // EEXIST。以前这会直接抛出去，ensureTalkSession 接住就返回「建会话的锁没拿到」，
+      // 这一次换会话就此失败；`test/tenant.test.mjs` 那条偶发红也是同一个原因。
+      //
+      // 注意**不能并进下面的 EEXIST 分支**：那里 stat 失败就判 stale 然后 continue，
+      // 不看 timeout，真的是权限错误时会死循环。EPERM 走独立分支、受 timeout 约束。
+      // 只认 win32：POSIX 上 EPERM 通常是真没权限，重试没有意义，照样抛。
+      if (err?.code === 'EPERM' && process.platform === 'win32') {
+        if (Date.now() - started > timeout) throw err
+        await new Promise((r) => setTimeout(r, wait))
+        continue
+      }
       if (err?.code !== 'EEXIST') throw err
       // 锁文件的 mtime 太老 = 上一任进程死在临界区里了（没来得及 unlink），直接接管。
       let stale = false

package/lib/turns.js

@@ -54,12 +54,17 @@ import { refreshSelfDoc } from './selfdoc.js'
 import { growthDay, stageOf } from './derive.js'
 import { hearTurn } from './hear.js'
 import { stripToolMarkup, hasToolMarkup } from './markup.js'
+import { clearWakeSectionFor } from './identity.js'
 
 /**
  * 我们自己 prompt 进去的消息，rpcId 会带这些前缀。
  * 只是"多一道保险"：真正的判据是 clientTimeZone（见 classifyMessage）。
+ *
+ * `carry` 是换会话前请她留话那条（home.js 的 `carry-ask-`）。少了它，那条
+ * 消息会掉进 `kind === 'user'` 且没有 clientTimeZone 的 `unknown` 分支：不进
+ * 轮数（行为正确），但每换一次会话就往日志里多一行「认不出来源」（2026-11-06）。
  */
-const PLUGIN_RPC = /^(wake|say|boot|report|letter|sleep|nudge|probe|turn|sys)[-_]/i
+const PLUGIN_RPC = /^(wake|say|boot|report|letter|sleep|nudge|probe|turn|sys|carry)[-_]/i
 
 /**
  * 宿主/我们这边自己拼的、**确定不是人打的** source.kind。
@@ -236,6 +241,9 @@ function cut(s) {
   return t.length > TURN_TEXT_MAX ? t.slice(0, TURN_TEXT_MAX) + '…' : t
 }
 
+/** 已经挂过观察者的宿主上下文（同一进程只挂一次，见 registerTurns） */
+const TURNS_BOUND = new WeakSet()
+
 /**
  * 注册"侧栏轮数"观察者。
  *
@@ -248,6 +256,30 @@ export function registerTurns(ctx, deps = {}) {
   const log = deps.log ?? (() => {})
   if (typeof ctx?.on !== 'function') return () => {}
 
+  /**
+   * 2026-11-06（外部日志：被占用的实例照样往共享事件流里写 `seen:`）。
+   *
+   * 观测者以前是**无条件**写盘的：它看到「他来过」就 appendEvent，从不过问这个
+   * 家是不是自己的。于是同一个数据目录被两个实例开着时，只读那一侧也在写——
+   * 日志里那三条同一毫秒的 `seen:` 就是两个写者各写一遍。
+   *
+   * 这里和工具侧用同一道闸（tenant.js 的 guardWrite）：房主身份 ok===false 时
+   * 一句都不写。tenant 是**活引用**（占用权丢了会原地改写成 ok:false），
+   * 所以必须在每次写之前现查，不能在注册时查一次就完。
+   */
+  const tenant = deps.tenant ?? null
+  const writable = () => !(tenant && tenant.ok === false)
+
+  /**
+   * 同一份宿主上下文只挂一次。
+   *
+   * 2026-11-06：插件被同一个进程加载两遍时（两个入口 / bundles 里重复），
+   * 两个观察者各有各的节流记忆，同一条人话会写出两条同一毫秒的 `seen:`——
+   * 记账行一重复，事件流就再也不能当证据用。第二次注册直接交白卷。
+   */
+  if (TURNS_BOUND.has(ctx)) return () => {}
+  TURNS_BOUND.add(ctx)
+
   /** 正在等 turn/end 的那一轮：{ sessionId, msgs:[], sinceId, at } */
   let pending = null
   /** 正在异步认来源的那条人话（见 takeTurnEnd：事件跟得太紧时要等它） */
@@ -285,6 +317,8 @@ export function registerTurns(ctx, deps = {}) {
    * 非 HER_TYPES 的类型，写成 tool 会被 schema 悄悄拒掉。
    */
   async function markSeen() {
+    // 2026-11-06：写盘之前先过所有权闸门（被占用的实例一条都不许写）。
+    if (!writable()) return
     lastSeenAt = Date.now()
     await appendEvent(
       { type: 'meta', text: `seen:${new Date(lastSeenAt).toISOString()}` },
@@ -297,6 +331,16 @@ export function registerTurns(ctx, deps = {}) {
 
   /** 收到真人消息：只认"她住的那个会话"，并把这一轮开始前的事件 id 记下来 */
   async function onHuman(sessionId, data) {
+    if (!writable()) return
+    // 2026-11-06（用户报「叫醒之后她就不说话了」）：他一开口，上一次叫醒留下的
+    // 「处境」当场作废。
+    //
+    // 处境原本只该出现在**她自己醒的那一轮**里，靠 turn/end 撤。但 turn/end 不是
+    // 一定能认到（监听按会话挂、重启会丢、两个渠道挨得近时也会错号），那一段
+    // 「这一轮是你自己的，不用回应任何人；不想说就什么都别写」就留在 system prompt
+    // 里，接下来他说的每一句都带着它——她就只思考、不开口，而且连续多轮都这样。
+    // 人真的说话了，这段就不该还在；清得比 turn/end 早一步也不会出错。
+    try { clearWakeSectionFor(sessionId) } catch { /* ignore */ }
     const home = await homeStatus(root)
     if (!home.sessionId) return
     if (home.sessionId !== sessionId) {
@@ -381,7 +425,7 @@ export function registerTurns(ctx, deps = {}) {
 
   /** turn/end：结账 */
   async function settle(p) {
-    if (stopped) return
+    if (stopped || !writable()) return
     if (busy) {
       log('turns · 上一轮还没结完，这次不记')
       return
@@ -576,6 +620,7 @@ export function registerTurns(ctx, deps = {}) {
   return () => {
     stopped = true
     pending = null
+    TURNS_BOUND.delete(ctx)
     try {
       if (typeof off === 'function') off()
     } catch {

package/lib/upgrade.js

@@ -64,7 +64,10 @@ export function compareVersion(a, b) {
 
 async function readJson(file) {
   try {
-    return JSON.parse(await readFile(file, 'utf8'))
+    // issue #38：手改过的 package.json / 配置文件可能带 UTF-8 BOM。
+    // 这里以前直接 parse，BOM 会让内容完好的文件读成 null（升级自检于是当作没装）。
+    const text = await readFile(file, 'utf8')
+    return JSON.parse(text.charCodeAt(0) === 0xfeff ? text.slice(1) : text)
   } catch {
     return null
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ssamurias/dsh-fish",
-  "version": "0.9.0",
+  "version": "0.9.2",
   "description": "养一条会自己长大的鱼：没有人格设置，通过事件流长大。她可以自己刷 B 站、会写日记给你看，四个阶段完成后才会开始有立场。状态库在 ~/.dsh-fish，不能删除记录。",
   "type": "module",
   "main": "lib/index.js",
@@ -19,6 +19,7 @@
     "AGENTS.md",
     "CHANGELOG.md",
     "RELEASE-NOTES-*.md",
+    "RELEASE.md",
     "scripts"
   ],
   "scripts": {

package/scripts/fix-legacy-link.mjs

@@ -1,12 +1,17 @@
 #!/usr/bin/env node
 /**
- * 把老的 `link:` / `file:` 安装迁移到新包名（@ssamurias/dsh-fish）。
+ * 把老的 `dsh-fish` 安装收拾到新包名（@ssamurias/dsh-fish）。
  *
  * 为什么需要它：0.8.10 起插件包名从 `dsh-fish` 改成 `@ssamurias/dsh-fish`，
  * 插件自带 cordis.patch.yml 里的条目名也跟着变成完整包名；而老 profile 的
  * node_modules 里只有裸名链接 `dsh-fish` → 条目 import 失败 → **宿主直接启动崩溃**。
  * 升级前跑一遍这个脚本就能避免；已经崩了也能跑（它只改 profile 文件，不需要应用启动）。
  *
+ * 0.9.1 修（issue #43）：原来只认 `link:` / `file:` 两种依赖写法。可是按更新说明用
+ * `dsh plugin add "@ssamurias/dsh-fish@0.9.0"` 升级的人，profile 里留下的是**版本号**，
+ * 脚本一句「没有老依赖，跳过」就退出 0 —— 旧键 `dsh-fish` 与旧 bundles 条目原封不动，
+ * 下次 pnpm 清理时两条 fish 打架。现在三种写法都收拾：源码目录、tgz、版本号/远端。
+ *
  * 用法（先关掉 DeepSeek Harness）：
  *   node scripts/fix-legacy-link.mjs            # 预览
  *   node scripts/fix-legacy-link.mjs --write    # 真的改
@@ -15,31 +20,14 @@
 import fs from 'node:fs'
 import path from 'node:path'
 import os from 'node:os'
+import { fileURLToPath } from 'node:url'
 
-const NEW = '@ssamurias/dsh-fish'
-const LEGACY = 'dsh-fish'
-const args = process.argv.slice(2)
-const WRITE = args.includes('--write')
-const pIdx = args.indexOf('--profile')
-const onlyProfile = pIdx >= 0 ? args[pIdx + 1] : ''
-
-const stamp = new Date().toISOString().slice(0, 10).replace(/-/g, '')
-const profilesRoot = path.join(os.homedir(), '.dsh', 'profiles')
+export const NEW = '@ssamurias/dsh-fish'
+export const LEGACY = 'dsh-fish'
 
-function profileDirs() {
-  if (onlyProfile) return [path.resolve(onlyProfile)]
-  try {
-    return fs
-      .readdirSync(profilesRoot, { withFileTypes: true })
-      .filter((d) => d.isDirectory())
-      .map((d) => path.join(profilesRoot, d.name))
-      .filter((p) => fs.existsSync(path.join(p, 'package.json')))
-  } catch {
-    return []
-  }
-}
+const SPEC_FIELDS = ['dependencies', 'devDependencies', 'optionalDependencies']
 
-function readJson(p) {
+export function readJson(p) {
   try {
     return JSON.parse(fs.readFileSync(p, 'utf8'))
   } catch {
@@ -47,101 +35,220 @@ function readJson(p) {
   }
 }
 
-function specOf(pkg) {
-  for (const field of ['dependencies', 'devDependencies', 'optionalDependencies']) {
+/** profile 里那条老依赖：字段名 + 原样的 spec。没有就 null。 */
+export function specOf(pkg) {
+  for (const field of SPEC_FIELDS) {
     const spec = pkg?.[field]?.[LEGACY]
-    if (typeof spec === 'string' && /^(link:|file:)/.test(spec)) return { field, spec }
+    if (typeof spec === 'string' && spec.trim()) return { field, spec: spec.trim() }
   }
   return null
 }
 
-function targetOf(profileDir, spec) {
-  const raw = spec.replace(/^(link:|file:)/, '').trim()
+/**
+ * 这条 spec 指向什么？
+ *   dir     —— `link:` / `file:` 指向目录（源码目录安装），要建 junction
+ *   tarball —— `file:` 指向 .tgz（0.8.x 的临时包装法），只清账、不建链接
+ *   spec    —— 版本号 / `^1.2.3` / `github:...`，只清账
+ */
+export function specKind(spec) {
+  const s = String(spec ?? '').trim()
+  if (!/^(link:|file:)/i.test(s)) return 'spec'
+  return /\.(tgz|tar\.gz)$/i.test(s) ? 'tarball' : 'dir'
+}
+
+export function targetOf(profileDir, spec) {
+  const raw = String(spec).replace(/^(link:|file:)/i, '').trim()
   if (!raw) return ''
   if (/^[A-Za-z]:[\\/]/.test(raw) || path.isAbsolute(raw)) return path.resolve(raw)
   return path.resolve(profileDir, raw)
 }
 
-function linkName(profileDir, name) {
+export function linkName(profileDir, name) {
   return path.join(profileDir, 'node_modules', ...name.split('/'))
 }
 
-let touched = 0
-for (const dir of profileDirs()) {
-  const pkgPath = path.join(dir, 'package.json')
+export function bundlesOf(pkg) {
+  const prof = pkg?.dsh?.profile ?? (pkg?.dsh && Array.isArray(pkg.dsh.bundles) ? pkg.dsh : null)
+  return prof && Array.isArray(prof.bundles) ? prof.bundles : null
+}
+
+/** 把老依赖从依赖表里清掉；新包名已经在装的话顺手对齐 bundles。 */
+export function cleanDepKey(pkg, found, newName) {
+  const done = []
+  delete pkg[found.field][LEGACY]
+  done.push(`删掉 ${found.field}["${LEGACY}"]`)
+  const deps = { ...(pkg.dependencies ?? {}), ...(pkg.devDependencies ?? {}) }
+  if (deps[newName]) {
+    const bundles = bundlesOf(pkg)
+    if (bundles && !bundles.includes(newName)) {
+      bundles.push(newName)
+      done.push(`bundles 补上 ${newName}`)
+    }
+  }
+  return done
+}
+
+export function dropLegacyBundle(pkg, newName) {
+  const bundles = bundlesOf(pkg)
+  if (!bundles) return []
+  let n = 0
+  for (let i = bundles.length - 1; i >= 0; i -= 1) {
+    if (bundles[i] === LEGACY) {
+      bundles.splice(i, 1)
+      n += 1
+    }
+  }
+  const done = n ? [`bundles 删掉 ${LEGACY} ×${n}`] : []
+  if (newName && !bundles.includes(newName)) {
+    bundles.push(newName)
+    done.push(`bundles 补上 ${newName}`)
+  }
+  return done
+}
+
+export function retireOldLink(profileDir, tag, done = []) {
+  const oldLink = linkName(profileDir, LEGACY)
+  if (!fs.existsSync(oldLink)) return done
+  const off = `${oldLink}.disabled-${tag}`
+  try {
+    fs.renameSync(oldLink, off)
+    done.push(`node_modules/${LEGACY} 改名停用`)
+  } catch (e) {
+    done.push(`node_modules/${LEGACY} 改名失败：${e?.code ?? e?.message ?? e}`)
+  }
+  return done
+}
+
+/**
+ * 收拾一个 profile。返回 { changed, done, notes }。
+ * `write=false` 时只算要做什么，不落盘。
+ */
+export function migrateOne(profileDir, { write = false, log = (s) => console.log(s), tag = '' } = {}) {
+  const pkgPath = path.join(profileDir, 'package.json')
   const pkg = readJson(pkgPath)
-  if (!pkg) continue
+  const notes = []
+  const done = []
+  if (!pkg) {
+    log(`- ${profileDir}: 没有 package.json，跳过`)
+    return { changed: false, done, notes }
+  }
   const found = specOf(pkg)
   if (!found) {
-    console.log(`- ${dir}: 没有老的 ${LEGACY} link/file 依赖，跳过`)
-    continue
+    log(`- ${profileDir}: 没有老的 ${LEGACY} 依赖，跳过`)
+    return { changed: false, done, notes }
   }
-  const target = targetOf(dir, found.spec)
-  const srcPkg = readJson(path.join(target, 'package.json'))
-  const srcName = String(srcPkg?.name ?? '')
-  console.log(`\n== ${dir}`)
-  console.log(`   依赖: ${found.field}["${LEGACY}"] = ${found.spec}`)
-  console.log(`   源目录: ${target}`)
-  console.log(`   源包名: ${srcName || '(读不到)'}`)
-  if (!srcName || srcName === LEGACY) {
-    console.log('   → 源目录还是老名字，这次迁移用不上（等你更新到 0.8.10 再跑）')
-    continue
+  const kind = specKind(found.spec)
+  const how = kind === 'dir' ? '源码目录' : kind === 'tarball' ? 'tgz 包' : '版本号/远端'
+  log(`\n== ${profileDir}`)
+  log(`   老依赖: ${found.field}["${LEGACY}"] = ${found.spec}（${how}）`)
+
+  let newName = NEW
+  let target = ''
+  if (kind === 'dir') {
+    target = targetOf(profileDir, found.spec)
+    const srcPkg = readJson(path.join(target, 'package.json'))
+    const srcName = String(srcPkg?.name ?? '')
+    log(`   源目录: ${target}`)
+    log(`   源包名: ${srcName || '(读不到)'}`)
+    if (!srcName) notes.push('源目录读不到 package.json，这条按"只清账"处理')
+    else if (srcName !== LEGACY && srcName !== NEW) log(`   ! 源包名是 ${srcName}，脚本按它迁移`)
+    if (srcName && srcName !== LEGACY) newName = srcName
   }
-  if (srcName !== NEW) console.log(`   ! 源包名是 ${srcName}，脚本按它迁移`)
-  const newName = srcName === LEGACY ? NEW : srcName
 
-  if (!WRITE) {
-    console.log(`   [预览] 会：建立 node_modules/${newName} → 源目录；把依赖键改成 ${newName}；删掉 ${LEGACY} 键与链接`)
-    continue
+  if (!write) {
+    if (kind === 'dir' && target) {
+      log(`   [预览] 会：建 node_modules/${newName} → 源目录；把依赖键改成 ${newName}；删掉 ${LEGACY} 键与链接`)
+    } else {
+      log(`   [预览] 会：删掉 ${found.field}["${LEGACY}"]；bundles 里去掉 ${LEGACY}；旧 node_modules/${LEGACY} 改名停用`)
+    }
+    return { changed: true, done, notes }
   }
 
-  // 1) 备份
-  const bak = `${pkgPath}.bak-fishrename-${stamp}`
+  const bak = `${pkgPath}.bak-fishrename-${tag || 'now'}`
   fs.copyFileSync(pkgPath, bak)
-  console.log(`   备份: ${bak}`)
-
-  // 2) 建新名链接（Junction 在 Windows 不需要管理员权限）
-  const newLink = linkName(dir, newName)
-  fs.mkdirSync(path.dirname(newLink), { recursive: true })
-  if (!fs.existsSync(newLink)) {
-    try {
-      fs.symlinkSync(target, newLink, 'junction')
-      console.log(`   建链: ${newLink} -> ${target}`)
-    } catch (e) {
-      console.log(`   ! 建链失败: ${e.message}（可手动 New-Item -ItemType Junction）`)
+  log(`   备份: ${bak}`)
+
+  if (kind === 'dir' && target) {
+    const newLink = linkName(profileDir, newName)
+    fs.mkdirSync(path.dirname(newLink), { recursive: true })
+    if (!fs.existsSync(newLink)) {
+      try {
+        fs.symlinkSync(target, newLink, 'junction')
+        done.push(`建链 node_modules/${newName} → ${target}`)
+      } catch (e) {
+        done.push(`建链失败：${e?.message ?? e}（可手动 New-Item -ItemType Junction）`)
+      }
+    } else {
+      done.push(`链接已存在：${newName}`)
     }
-  } else {
-    console.log(`   链接已存在: ${newLink}`)
   }
 
-  // 3) 改依赖键
   delete pkg[found.field][LEGACY]
-  pkg.dependencies = pkg.dependencies || {}
-  pkg.dependencies[newName] = found.spec
-  // bundles 跟着改
-  const bundles = pkg?.dsh?.profile?.bundles
-  if (Array.isArray(bundles)) {
-    pkg.dsh.profile.bundles = Array.from(new Set(bundles.map((b) => (b === LEGACY ? newName : b))))
-  }
-  fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n', 'utf8')
-  console.log(`   依赖改为 ${found.field}["${newName}"]，bundles 已对齐`)
-
-  // 4) 老链接改名停用（不删，留着能回滚）
-  const oldLink = linkName(dir, LEGACY)
-  if (fs.existsSync(oldLink)) {
-    const off = `${oldLink}.disabled-${stamp}`
-    try {
-      fs.renameSync(oldLink, off)
-      console.log(`   老链接停用: ${off}`)
-    } catch (e) {
-      console.log(`   ! 老链接改名失败: ${e.message}`)
+  const deps = { ...(pkg.dependencies ?? {}), ...(pkg.devDependencies ?? {}) }
+  if (deps[newName]) {
+    // 新包名已经在依赖里（plugin add 装好了）：只把 bundles 对齐，不动依赖表。
+    done.push(`删掉 ${found.field}["${LEGACY}"]`)
+    done.push(...dropLegacyBundle(pkg, newName))
+  } else if (kind === 'dir') {
+    // 源码目录：把依赖键改名指向同一条 spec。
+    pkg.dependencies = pkg.dependencies ?? {}
+    pkg.dependencies[newName] = found.spec
+    done.push(`依赖改为 ${found.field}["${newName}"]`)
+    const bundles = bundlesOf(pkg)
+    if (bundles) {
+      for (let i = 0; i < bundles.length; i += 1) if (bundles[i] === LEGACY) bundles[i] = newName
+      if (!bundles.includes(newName)) bundles.push(newName)
+      done.push(`bundles 对齐 ${newName}`)
     }
+  } else {
+    done.push(`删掉 ${found.field}["${LEGACY}"]`)
+    done.push(...dropLegacyBundle(pkg, ''))
+    notes.push('新包名不在依赖里：只清账，装不装得上取决于这次 add 是否成功')
+  }
+  retireOldLink(profileDir, tag || 'now', done)
+
+  fs.writeFileSync(pkgPath, `${JSON.stringify(pkg, null, 2)}\n`, 'utf8')
+  done.push('写入 package.json')
+  return { changed: true, done, notes }
+}
+
+export function profileDirs(onlyProfile = '') {
+  if (onlyProfile) return [path.resolve(onlyProfile)]
+  const profilesRoot = path.join(os.homedir(), '.dsh', 'profiles')
+  try {
+    return fs
+      .readdirSync(profilesRoot, { withFileTypes: true })
+      .filter((d) => d.isDirectory())
+      .map((d) => path.join(profilesRoot, d.name))
+      .filter((p) => fs.existsSync(path.join(p, 'package.json')))
+  } catch {
+    return []
   }
-  touched++
 }
 
-if (!WRITE) {
-  console.log('\n这是预览。确认无误后加 --write 再跑一次（记得先关应用）。')
-} else {
-  console.log(`\n改完 ${touched} 个 profile。现在启动 DeepSeek Harness。`)
+function main() {
+  const args = process.argv.slice(2)
+  const write = args.includes('--write')
+  const pIdx = args.indexOf('--profile')
+  const onlyProfile = pIdx >= 0 ? args[pIdx + 1] : ''
+  const tag = new Date().toISOString().replace(/[-:T]/g, '').slice(0, 14)
+  let touched = 0
+  for (const dir of profileDirs(onlyProfile)) {
+    const r = migrateOne(dir, { write, tag })
+    for (const n of r.notes) console.log(`   注: ${n}`)
+    for (const d of r.done) console.log(`   · ${d}`)
+    if (write && r.changed) touched += 1
+  }
+  if (!write) console.log('\n这是预览。确认无误后加 --write 再跑一次（记得先关应用）。')
+  else console.log(`\n改完 ${touched} 个 profile。现在启动 DeepSeek Harness。`)
 }
+
+const invokedDirectly = (() => {
+  try {
+    return Boolean(process.argv[1]) && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)
+  } catch {
+    return false
+  }
+})()
+
+if (invokedDirectly) main()