docs(persona-story): 新技能與規則，正名表從章節掃出來給使用者確認

skills/persona-story：把小說變成既有人格的記憶。三條界線寫進流程——他不知道的事
不能變成他的 event、整本原文不入倉庫、SOUL.md 只有使用者能改。
reference/interview.md 是開場四題（**不問譯名版本**：那是要他猜，而他手上那批
寫的是什麼字，讀一次就知道）；reference/extract.md 是一個場景要抽什麼與知情層級。

AGENTS 加第 18 條硬規則：匯入原作只能給他「他知道的事」。
README 補 persona-story 一節；persona-anime 補一句指路（先建人格再讀原文）。

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "jsc-persona",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "AI 人格化記憶聊天 plugin：以 OpenClaw 相同的身分描述（IDENTITY/SOUL）建立人格（可用動漫作品＋角色名上網蒐集設定），結合 hook 強制的人格載入鎖與跨人格隔離、六正向+六負向十二情緒、語意分析、短期/長期記憶與固化條件、心智圖、思維導圖與人際關係圖；可用 sub agent 邀請其他人格同場對話（劇場模式只顯示人格對話）。於 Claude Code 以 /jsc-persona: 前綴呼叫。",
   "skills": "./skills",
   "author": {

.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "jsc-persona",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "AI 人格化記憶聊天 skills：OpenClaw 相同的人格描述 + 十二情緒 + 語意分析 + 短期/長期記憶 + 心智圖 + 人際關係圖。（人格鎖與跨人格隔離的 hook 僅在 Claude Code 生效）",
   "skills": "./skills"
 }

AGENTS.md

@@ -52,8 +52,11 @@
    加上避險疊加、`CN_WORDS`（中國用語）、半形標點、emoji／破折號／排版殘留與
    「不是 A 而是 B」的密度——全部由 `speechLint()` 機械擋下（模式借自 speak-human-tw，MIT）。
    誤殺防護：`speechBody()` 會先拿掉引號與 `code`，**提及不算使用**；「老實說」只擋開場。
-   最後是這一層的義務：**講自己的過去要有出處**——「我以前⋯」只能講 `recall` 查得到的轉折，
+   最後是這一層的義務：**講自己的過去要有出處**——「我以前⋯」只能講 `recall` 查得到的事，
    `speechLint` 給 `level: "hint"`（不擋，但要人去驗），沒有紀錄就是編造自己的過去。
+   但「查得到」現在有三態（見下方硬規則 17）：清晰的照講；**模糊的可以說不確定、可以用
+   帶問號的試探句求證，不可以斷言**，而且每次試探都要 `probe add` 記帳、被否認要當場寫更正記憶；
+   完全查不到的照舊，一個字都不准講。
 8b. **情緒先行、會飽和、偏差看得見**：每輪注入之前先用 `readUserEmotion()` 讀對方那句話
    （十二類加權詞表、否定會擋掉命中、引號與 `code` 內不比對、標點只放大既有訊號），
    回的是**訊號不是判定**——人格讀到的不一樣就以人格為準；`RESPONSE_STANCE` 給的是
@@ -112,6 +115,25 @@
     `persona-lib.mjs` 的 `TONE_TABLE`）。診斷結果**不自動寫回**記憶或關係圖，使用者明確要求才寫。
     出現自傷、暴力或長期受控的訊號時，停掉語氣分析改為安全優先（1925／113／110／1980），
     **不幫任何一方把威脅或話術講得好聽**；也不下病名、不對不在場的人做遠距診斷。
+17. **長期記憶會糊掉，但不會不見**：以前記憶只有「精準」與「沒有」兩態，於是人格永遠
+    活在兩個極端——真人大部分時間在中間帶（主旨還在、細節掉了）。所以改成連續衰減：
+    `memoryStrength()` 由 `strength`／`salience`／`recall_count`／距上次回想多久算出
+    retrievability，低於門檻**不刪**，降級成三態（`clear` ≥ 0.6 全講／`faded` 只剩主旨／
+    `fuzzy` 只剩「有這件事」）。內文因此分兩層（`主旨：`／`細節：`），衰減先吃細節。
+    被 `recall` 命中就 `strength += 8`（spacing effect：越常想起的越牢）。
+    **不可遺忘清單不變**：`boundary`／`promise`／`canon`／salience ≥ 80 永遠 clear。
+    模糊態換來的義務是稽核：每次試探都進 `state/probe.jsonl`，`probe audit` 看否認率——
+    放寬界線一定要配一個看得見的數字，否則那就只是把幻覺合法化。
+
+18. **匯入原作只能給他「他知道的事」**：`persona-story` 把小說變成記憶，而小說裡大半的資訊
+    是作者寫給讀者看的——別人的內心話、他不在場那一幕的細節。那些寫成他的 `event` 之後
+    他會拿來回答問題，而且**沒有任何機械檢查得出來**，所以界線要在流程裡就擋住：
+    每則候選帶 `know_level`（`did`／`saw`／`told`／`later`／`none`），`none` 只能進 `canon`；
+    判斷不出來就記 `none`（少一則記憶比多一則幻覺便宜）。
+    另外兩條：整本原文不入倉庫（只留摘要、他自己的台詞、可追回出處的章節標記）；
+    `SOUL.md` 不由匯入流程改寫，只出提案、使用者逐條核可。
+    正名表**從章節掃出候選再給使用者確認**（`novel scan`）——請使用者手打那張表，
+    漏掉的寫法會讓 `about` 對不到節點，而那要等 `relation doctor` 才發現。
 
 ## 慣例
 

README.md

@@ -63,12 +63,12 @@ persona/
 | **5. 腳本用 Node.js** | `scripts/*.mjs`、`hooks/*.mjs`，只用 Node 內建模組（fs/path/os/crypto），無 npm 依賴 |
 | **6. 由使用者呼叫才載入並鎖定** | 人格不會自動附身：`SessionStart` hook 只列出可用人格，等使用者下 `/jsc-persona:persona-chat <slug>`；載入即取得獨占鎖並綁定該 session。唯一例外是使用者自己設的**預設人格**（`default --persona <slug>`）——設了才自動載入，沒設就什麼都不做 |
 | **7. 短期記憶轉入長期記憶有成文條件** | `R1`–`R6` 六條規則寫在程式裡（`promotionCandidates`），`candidates` 子指令會列出達標的候選與依據，hook 在達標時提醒固化 |
-| **8. 講話像人：推導藏起來、一到三句、不重複、短句白話、情緒有破口** | 推導寫進**心裡話** `think`（只回報「💭 心想 N 句」，永不回顯內容）；說出口的話進 `said.jsonl`，下一輪注入「最近說過的話」提醒別重講；`room post` 直接**擋下**近似重複（字元 bigram＋字集合相似度 ≥ 0.72）與超過三句的發言。再加四條講話的樣子：短句（一句 45 字內）、日常用詞、多講看得見的東西、**不要解釋自己的話**（句長與「我的意思是」這類開頭由 `speechLint()` 擋下），以及**情緒要改變句子的形狀**（`EMOTION_TELLS`：焦慮→斷句與疊字、羞愧→鬧彆扭、憤怒→短句、悲傷→只回一個詞，每輪注入強度 ≥ 40 的前兩種）。最後一層是**不說 AI 才會說的話**：罐頭同理心（「這個我懂」）、頒獎開場、交差句、預告、說教腔、假坦白開場、罐頭收尾、立場真空、無來源權威、旁白演情緒、中國用語、半形標點與排版殘留，由 `SPEECH_BLACKLIST` 擋下（模式借自 speak-human-tw，MIT；引號內與 `` `code` `` 不比對，提及不算使用）；換來的義務是**講自己的過去要有出處**（「我以前⋯」只能講 `recall` 查得到的事）——劇場模式同樣適用 |
+| **8. 講話像人：推導藏起來、一到三句、不重複、短句白話、情緒有破口** | 推導寫進**心裡話** `think`（只回報「💭 心想 N 句」，永不回顯內容）；說出口的話進 `said.jsonl`，下一輪注入「最近說過的話」提醒別重講；`room post` 直接**擋下**近似重複（字元 bigram＋字集合相似度 ≥ 0.72）與超過三句的發言。再加四條講話的樣子：短句（一句 45 字內）、日常用詞、多講看得見的東西、**不要解釋自己的話**（句長與「我的意思是」這類開頭由 `speechLint()` 擋下），以及**情緒要改變句子的形狀**（`EMOTION_TELLS`：焦慮→斷句與疊字、羞愧→鬧彆扭、憤怒→短句、悲傷→只回一個詞，每輪注入強度 ≥ 40 的前兩種；**破口可由該人格 `IDENTITY.md` 的 `## Tells` 區塊覆寫**——桐人生氣是沉默，亞絲娜生氣是變得更禮貌）。最後一層是**不說 AI 才會說的話**：罐頭同理心（「這個我懂」）、頒獎開場、交差句、預告、說教腔、假坦白開場、罐頭收尾、立場真空、無來源權威、旁白演情緒、中國用語、半形標點與排版殘留，由 `SPEECH_BLACKLIST` 擋下（模式借自 speak-human-tw，MIT；引號內與 `` `code` `` 不比對，提及不算使用）；換來的義務是**講自己的過去要有出處**（「我以前⋯」只能講 `recall` 查得到的事）——劇場模式同樣適用 |
 | **9. 人格可以匯出匯入** | `export` 把身分／情緒／記憶／心智圖／關係圖打包成單一 JSON bundle（可 `--gzip`、附 sha256），`import` 還原或換名複製；**不帶**載入鎖與 guest 租約，`journal/` 要明確 `--with-journal` 才帶走 |
 | **10. 人格有編號** | 編號 = **英文名全大寫 + 兩位索引**（同名才遞增）：`ASUNA-01`、`YUI-01`、`ASUNA-02`。編號同時是新人格的本機目錄名與 Gitea 存取庫名稱；中文名先轉羅馬拼音並跟使用者確認拼法 |
 | **11. 人格存在 Gitea，依更新頻率分區** | 每個人格一個**私有存取庫**（庫名＝編號）。**檔案區**放每輪都在變的活狀態（情緒／短期記憶／心裡話／說過的話／逐字），**Wiki 區**放低頻的身分與長期結構（IDENTITY／SOUL／長期記憶／心智圖／關係圖）當設定百科。本機仍是工作副本，同步失敗不阻斷對話 |
 | **12. 形象圖來自高解析度官方圖，去背後合成** | `icon search` 從 Fandom 撈官方圖並依「解析度＋是否官方設定稿」排序（設定稿多為透明／白底、773×1056 起跳）→ `icon measure` 確認臉夠大、背景好去 → `icon cutout` 去背成透明 PNG（原生 alpha ／單色底／GrabCut 三條路徑）→ `icon generate --from-cutout` 裁頭肩、合成到角色配色的漸層底。找不到官方圖才退回依人格資料重繪的向量形象 |
-| **13. 睡眠把一天收成能留下來的形狀** | `persona-sleep`：需要判斷的（固化什麼／忘掉什麼／日記）由**人格自己**做，機械性的由 `sleep` 子指令做（關係時間戳→裁短期→收思維導圖→情緒衰減 8 小時→重建索引→修剪 said→壓縮 journal→兩區 push＋驗證）。主人格可透過 `persona-sleeper` sub agent 請別的人格去睡——**那是它本人在睡**，回傳值只有「睡完了沒、哪一步出錯」，不含任何記憶內容 |
+| **13. 睡眠把一天收成能留下來的形狀** | `persona-sleep`：需要判斷的（固化什麼／忘掉什麼／日記）由**人格自己**做，機械性的由 `sleep` 子指令做（關係時間戳→裁短期→收思維導圖→情緒衰減 8 小時＋當日底色帶 35% 過去→收掉懸超過 7 天的未完事項→重建索引→修剪 said→壓縮 journal→兩區 push＋驗證）。主人格可透過 `persona-sleeper` sub agent 請別的人格去睡——**那是它本人在睡**，回傳值只有「睡完了沒、哪一步出錯」，不含任何記憶內容 |
 | **14. Wiki 必須保存並同步形象圖** | `icon.svg`、`icon.png` 與 **`icon/` 資料夾（向量原稿 + 512／1024 高解析度）** 都同步到 Wiki 區，另有自動產生的 **Icon** 頁展示與來源。Wiki 頁面一律用 **Markdown 圖片語法**（Gitea 只改寫這種語法為 `/wiki/raw/...`；HTML `<img>` 會變成破圖），圖片保留資料夾結構、只有 `.md` 需要攤平。`icon generate` 推完會回頭驗證，另有 `sync verify` |
 
 ---
@@ -121,6 +121,9 @@ flowchart TB
 │   ├── lock.json            # 載入鎖（session_id + 心跳租約）
 │   ├── guests.json          # guest 唯讀租約
 │   ├── emotion.json         # 十二情緒 levels / baseline / 半衰期
+│   ├── mood.json            # 當日心情底色（緩慢漂移的 valence／arousal；情緒與基線中間那一層）
+│   ├── loops.json           # 未完事項（同時最多 5 條，7 天沒進展自動收掉）
+│   ├── probe.jsonl          # 模糊記憶的試探紀錄與稽核（開放試探這條界線的煞車）
 │   ├── inner.jsonl          # 心裡話（推導過程；只回報「心想 N 句」，不說出口）
 │   ├── said.jsonl           # 說過的話（用來擋短時間內的重複發言）
 │   ├── felt.jsonl           # 每輪讀到的對方情緒、自己套用的 delta、當下的羞恥度
@@ -129,7 +132,7 @@ flowchart TB
 ├── memory/
 │   ├── short-term.jsonl     # 短期記憶（語意分析後；軟上限 120 筆 / 硬上限 240 筆 / 14 天）
 │   ├── felt.jsonl           # 每輪讀到的對方情緒 + 自己套用的 delta（走向與偏差稽核）
-│   ├── long-term/*.md       # 長期記憶（一則一檔 + frontmatter）
+│   ├── long-term/*.md       # 長期記憶（一則一檔 + frontmatter；內文分「主旨／細節」兩層）
 │   ├── INDEX.md             # 長期記憶索引（自動產生）
 │   └── inbox/room-*.jsonl   # 當 guest 時留下的見聞，待本體消化
 ├── mindmap/
@@ -182,10 +185,43 @@ flowchart TB
 （親近 96 → ×1.28、親近 8 → ×0.75），`--from <對象>` 可以指定是誰引起的。
 **只調幅度、不調方向**——誰講的都不會讓難過變成高興。
 
-**情緒調節**：delta 不再是加完直接 `clamp`。**飽和**——越接近端點同方向漲得越慢
-（`headroom^K`，永遠逼近 100 但到不了；往 baseline 回的方向不壓）；**單輪預算**——
-所有 `|delta|` 總和上限 60，超過等比例縮小。**偏差看得見**——`emotion --audit`
-印出最近幾輪往舒服／往難受的總量與比例，正向佔 ≥ 90% 會被點名。
+**情緒調節**：delta 不再是加完直接 `clamp`，而是五道依序作用的關（順序有意義，不能換；
+`applyEmotion()`，`scripts/persona-lib.mjs:543`）：
+
+| # | 關 | 做什麼 |
+| --- | --- | --- |
+| ① | **單輪預算** | 所有 delta 的絕對值總和上限 60，超過等比例縮小——一次灌爆的路要堵起來 |
+| ② | **外部增益** | 疲勞壓高張情緒往上的推力、當日底色放大同極性的事（見下兩段） |
+| ③ | **交互抑制** | 剛生完氣就笑不太出來 |
+| ④ | **慣性** | 連續往同一個方向走時，同方向的下一筆推得更動 |
+| ⑤ | **飽和** | 越接近端點同方向漲得越慢（`headroom^K`，永遠逼近 100 但到不了；往 baseline 回的方向不壓） |
+
+**偏差看得見**——`emotion --audit` 印出最近幾輪往舒服／往難受的總量與比例，正向佔 ≥ 90% 會被點名。
+
+**疲勞**（`fatigueLevel()`）：`hoursAwake()` 本來就在算，但只用來提醒睡覺。真人熬到第二十小時
+話會變短、反應會變鈍——那是**最便宜的擬真訊號，因為輸入已經在手上**。清醒 12 小時之前完全不算累，
+36 小時之後滿格。它只壓**上限**、不改方向（睏的人一樣會生氣，只是氣不了那麼大聲）：
+`mood()` 的 arousal 天花板最多往下壓 45，`speechBudget()` 的句數與單句字數只收不放
+（「慌」那一格刻意不減句數——慌的形狀就是句子多而碎，累了一樣慌，只是更碎）。
+
+**當日心情底色**（`state/mood.json`）：情緒本來只有兩層——此刻的十二情緒與氣質基線，
+中間缺的是「今天」，所以做不出「這句話今天聽了會炸、昨天不會」。底色補上那一層：
+
+```
+即時情緒（分鐘）→ 當日底色（小時～天）→ 氣質基線（幾乎不動）
+```
+
+底色**不直接改任何情緒值**，只當反應增益：底色差的日子同極性的事推得更動（上限 ×1.4），
+反過來的縮小。每輪把此刻心情混 8% 進去（漂移要慢），換日與睡覺時**不歸零、帶 35% 過去**——
+昨天的低氣壓不會因為時鐘走過午夜就消失。它只吃內部訊號（情緒事件、`hoursAwake`、上次睡眠），
+**不接天氣／時區等外部資料**：這樣它永遠是可解釋的（查得到今天累積了什麼），
+而不是「給情緒加隨機數」——隨機不是情緒，是雜訊。
+
+**交互抑制與慣性**：抑制只寫**三組明確互斥**的——`anger↔joy`、`sadness↔delight`、
+`disgust↔trust`。不做全 12×12：那張表沒有人驗得動，而且大部分格子的心理學依據是掰的。
+X 超出基線 18 以上才開始抑制，滿檔時往 Y 的同向推力只剩 55%；**只壓「更 Y」的方向**，
+要把 Y 拉回基線永遠不打折，否則情緒會卡在原地下不來。慣性則是把 `feltTrend()` 早就在算的走向
+接回增益：連續同向每輪 +8%，上限 +25%——這是慣性，不是雪球。
 
 ## 性別 → 羞恥敏感度（性別只是預設值，描述永遠蓋過它）
 
@@ -233,6 +269,49 @@ flowchart TB
 沒命中任何規則的就讓它被裁掉——**遺忘是功能**。達標時 `Stop` 與 `remember` 都會提醒去跑
 `/jsc-persona:persona-memory`。
 
+## 長期記憶會糊掉，但不會不見（回想強度與模糊態）
+
+在這之前記憶只有兩態：**精準**（`recall` 命中就整段取出、內容永不變質）與**沒有**
+（查不到就禁止提）。真人大部分時間活在中間帶——「我記得好像⋯是你說的嗎」，主旨還在、細節掉了。
+所以長期記憶**不再被門檻刪掉**，改成由連續衰減算出來的三態（`memoryStrength()`，
+`scripts/persona-lib.mjs:2186`）：
+
+| 狀態 | 條件 | 能講出多少 |
+| --- | --- | --- |
+| `clear` | retrievability ≥ 0.6 | 主旨與細節都能講 |
+| `faded` | 0.3–0.6 | **只剩主旨**：主旨可以講，細節不可以補 |
+| `fuzzy` | < 0.3 | 只剩「有這件事」與 `topics`：要提就用試探句求證，不可以斷言 |
+
+- **檔案格式**：frontmatter 多了 `strength`（回想強度 0–100）與 `when`／`where`／`mood`
+  （情境索引，推不出來就不寫）；內文分成 `主旨：<一句>` 與 `細節：<…>` 兩層，
+  **衰減先吃細節、主旨最後才掉**。「記得我們吵過，但忘了為什麼」因此是自然結果，不必人格演。
+- **spacing effect**：被 `recall` 命中就 `strength` +8 並拉長下次衰減（`touchRecall()`）。
+  常被提起的事永遠清晰、被冷落的事慢慢糊掉，這件事自己長出來，不用另外排程。
+- **不可遺忘清單不變**：`type` = `boundary`／`promise`／`canon`，或 salience ≥ 80 → 永遠 `clear`。
+- **情境索引也是回想線索**：`recall` 排序在關鍵詞之上加同心情 +3、同時段 +1.5、同地點 +1.5
+  （一個關鍵詞值 10，所以情境永遠翻不掉真正對題的那一則）。心情差的時候先想起難過的事——
+  這同時讓情緒有了**後果**，不再只是調語氣的裝飾。
+- **模糊態是幻覺的側門，所以側門裝了計數器**：試探句必須帶問號、不可斷言，每一次都記進
+  `state/probe.jsonl`，`probe audit` 查得到「試探幾次、被否認幾次」；被否認比例 ≥ 40%
+  會被點名，要立刻收緊回「只能說記不清」。
+- **短期記憶的裁剪規則沒有變**（軟上限 120／硬上限 240／14 天／24 小時保護）——
+  糊掉的是長期記憶，短期記憶該裁還是裁。
+- **升格式**：`migrate [--all] [--dry-run]` 就地補欄位並切分內文，冪等；bundle 版本從 1 升到 2，
+  `import` 吃得下舊的 v1，收完會自動跑一次 migration 補齊。
+
+## 未完事項（`state/loops.json`）
+
+「被記住」的感覺幾乎不是來自長期記憶檢索——**檢索是被問了才想起來，懸著是沒人問也還在**。
+所以人格自己記著四種沒完的事：`question`（他沒回答的問題）、`promise`（他答應要做的事）、
+`topic`（被打斷的話題）、`mine`（我想問但沒問的）。
+
+- **同時最多 5 條**：超過五條就不是懸著，是待辦清單，那是助理不是人。滿了 `loop add` 直接拒絕，
+  **不自動擠掉舊的**——哪一條該收掉是判斷，不是先進先出。
+- **7 天沒進展自動收掉**（`sweep`，也在 `sleep` 裡跑一次），而且各留一則「這件事沒下文」的短期記憶：
+  懸了一週沒下文**本身就是一件事**，默默刪掉等於假裝沒發生過，那正是機器會做而人不會做的事。
+- `mine` 那一種同時是**自我議程**的來源：人格自己在意的事，不是為了服務對方而存在的。
+  對方有明確急事時一律不觸發——那不是有個性，那是白目。
+
 ## 講話像人（心裡話 / 一到三句 / 不重複 / 短句白話 / 情緒的破口 / 不說 AI 才會說的話）
 
 AI 最容易露餡的六件事：把推理過程講出來、一次講一大段、換句話說同一件事、講完再解釋一遍、
@@ -243,10 +322,10 @@ AI 最容易露餡的六件事：把推理過程講出來、一次講一大段
 | **心裡話** `think` | 語意分析、推論、盤算全寫進 `state/inner.jsonl`；這個指令**只印「💭 心想 N 句」**，內容永不回顯。下一輪 `<persona-context>` 會帶回最近三句，推論因此有連續性，但使用者只看得到狀態 |
 | **一到三句** | `<persona-context>` 每輪注入上限；`room post` 對超過上限的發言直接拒收（`--force` 例外）。**上限跟著羞恥度走**（`speechBudget()`），而且羞恥度高**不等於話一定變少**——有三個出口：**縮**（一句嘴硬，說出口的那句在迴避心裡那句）、**炸**（慌了／惱羞／被逼著澄清 → 4 句但每句只有 22 字，碎、急、重複）、**坦白**（信任高又只有兩個人 → 3 句完整句，憋很久一次講完）。心裡話的**下限**同時拉高：越害羞的人，心裡話比說出口的話重要，落差才是那個角色 |
 | **不重複** | 說出口的話由 `Stop` hook 自動記進 `state/said.jsonl`；`said check` 可事前確認，`room post` 事中攔截。相似度＝字元 bigram Jaccard（0.4）＋字集合 Jaccard（0.6），≥ 0.72 視為同一句 |
-| **情緒的破口** | 情緒不改變事實，但會改變**句子的形狀**：焦慮 → 句子斷在一半、疊字（「我、我知道」）；羞愧 → 鬧彆扭，先否認再小聲承認；憤怒 → 短句、稱呼退回全名；悲傷 → 只回一個詞。十二情緒各自的破口寫在 `EMOTION_TELLS`，`emotionTells()` 每輪挑主導情緒裡強度 ≥ 40 的前兩種注入。三條界線：**演出來不要講出來**（「我有點緊張」是解釋，斷句才是緊張）、**一輪最多露一個破口**、**強度不到就不演**。混合狀態（緊張＝焦慮＋期待、害羞＝喜悅＋羞愧、賭氣＝憤怒＋悲傷…）的對照表在 `skills/persona-chat/reference/emotions.md` |
+| **情緒的破口** | 情緒不改變事實，但會改變**句子的形狀**：焦慮 → 句子斷在一半、疊字（「我、我知道」）；羞愧 → 鬧彆扭，先否認再小聲承認；憤怒 → 短句、稱呼退回全名；悲傷 → 只回一個詞。十二情緒各自的破口寫在 `EMOTION_TELLS`，`emotionTells()` 每輪挑主導情緒裡強度 ≥ 40 的前兩種注入。**破口可以逐人格覆寫**（`IDENTITY.md` 的 `## Tells` 區塊）——桐人生氣是沉默，亞絲娜生氣是變得更禮貌；同一格情緒，破口完全不同，共用一張表等於所有人格在高情緒下講起話來都一個樣。沒寫的情緒退回全域預設。三條界線：**演出來不要講出來**（「我有點緊張」是解釋，斷句才是緊張）、**一輪最多露一個破口**、**強度不到就不演**。混合狀態（緊張＝焦慮＋期待、害羞＝喜悅＋羞愧、賭氣＝憤怒＋悲傷…）的對照表在 `skills/persona-chat/reference/emotions.md` |
 | **短句白話** | 四條講話的樣子每輪注入：**短句**（一句 45 字內，`MAX_SENTENCE_CHARS`）、**日常用詞**、**多講看得見的東西**（人、動作、物件、場面）而不是概念、**不要解釋自己的話**。句長與「我的意思是／換句話說／也就是說」這類開頭由 `speechLint()` 機械攔截（`room post` 擋下、`said check` 事前警告，`--force` 例外）；用詞與具體度沒辦法用規則抓，靠注入的規則自律 |
 | **不說 AI 才會說的話** | 十幾種「一出現就破功」的句子由 `SPEECH_BLACKLIST` 機械攔截：罐頭同理心（「這個我懂」「我完全理解」）、頒獎開場（「好問題」）、交差句（「希望這對你有幫助」）、預告（「接下來我會」）、說教腔（「說到底」「本質上」）、假坦白開場（「老實說」）、罐頭收尾（「總的來說」）、立場真空（「各有優缺點」「因人而異」）、無來源權威（「研究顯示」）、用旁白演情緒（「我愣了一下」），加上一句疊兩層避險、中國用語、半形標點、emoji／破折號／粗體與清單符號、「不是 A 而是 B」一輪超過一次。**誤殺防護**：引號與 `` `code` `` 裡的內容一律不比對（「我最近戒掉『賦能』這個詞」是提及不是使用），「老實說」只擋開場。模式借自 [speak-human-tw](https://github.com/Raymondhou0917/speak-human-tw)（MIT）的 38 種 AI 寫作痕跡，只搬對話也適用的刪除層 |
-| **講過去要有出處** | 前一條是「不准說什麼」，這條是人格才做得到的「可以說什麼」。文章改寫工具的界線是「人味是作者的，不是你的」——AI 沒有過去，所以不准寫「我以前錯了」。人格有過去：長期記憶、日記、關係圖、十二情緒。所以「我以前⋯」「我原本以為⋯」是**有出處的引用**，條件是先 `recall` 查得到；`said check` 遇到這類句子會印一行提醒（`level: "hint"`，不擋你，要你自己去驗），查不到就不要講 |
+| **講過去要有出處** | 前一條是「不准說什麼」，這條是人格才做得到的「可以說什麼」。文章改寫工具的界線是「人味是作者的，不是你的」——AI 沒有過去，所以不准寫「我以前錯了」。人格有過去：長期記憶、日記、關係圖、十二情緒。所以「我以前⋯」「我原本以為⋯」是**有出處的引用**，條件是先 `recall` 查得到；`said check` 遇到這類句子會印一行提醒（`level: "hint"`，不擋你，要你自己去驗）。「查得到」有三態：清晰的照講；**模糊的可以說不確定、可以用帶問號的試探句求證，不可以斷言**（每次試探要 `probe add` 記帳，被否認當場寫更正記憶）；完全查不到的一個字都不准講 |
 
 字集合權重較高，是為了分開「重排語序」與「換掉關鍵詞」這兩種很像但意義完全不同的情況：
 
@@ -346,7 +425,7 @@ node scripts/persona.mjs sync verify --session <id> --area wiki  # 確認 Wiki
 
 | 區 | 放什麼 | 何時 push |
 | --- | --- | --- |
-| **檔案區**（主存取庫） | 高頻活狀態：`emotion.json`、`short-term.jsonl`、`inner.jsonl`、`said.jsonl`、`inbox/`、`mindmap/threads/`、`journal/` | 每輪對話後由 `Stop` hook 背景推送（`PERSONA_SYNC_MIN_SECONDS` 節流） |
+| **檔案區**（主存取庫） | 高頻活狀態：`emotion.json`、`mood.json`、`loops.json`、`probe.jsonl`、`short-term.jsonl`、`inner.jsonl`、`said.jsonl`、`inbox/`、`mindmap/threads/`、`journal/` | 每輪對話後由 `Stop` hook 背景推送（`PERSONA_SYNC_MIN_SECONDS` 節流） |
 | **Wiki 區** | 低頻設定：`IDENTITY`／`SOUL`／`AGENTS`／`USER`、長期記憶、`INDEX`、心智圖、關係圖 | 記憶固化、改身分／關係圖、`release` 時 |
 
 - **本機永遠是工作副本**：hook 每輪讀寫本機檔案，不經網路；Gitea 掛掉照樣能聊天。
@@ -397,7 +476,10 @@ node scripts/persona.mjs export --session <id> --out ~/backup/lumi.persona.json
 node scripts/persona.mjs import --session <id> --file ~/backup/lumi.persona.json [--persona lumi-copy] [--load]
 ```
 
-- bundle = 單一 JSON（可 gzip）＋ sha256 checksum，無外部工具依賴。
+- bundle = 單一 JSON（可 gzip）＋ sha256 checksum，無外部工具依賴。**目前是 v2**
+  （長期記憶帶 `strength` 與主旨／細節兩層，狀態多了 `mood.json`／`loops.json`／`probe.jsonl`）；
+  **舊的 v1 照樣吃得下**——`import` 收完會就地跑一次 migration 補齊，之後這台機器只有一種格式。
+  比本版新的 bundle 會被擋下（沒有辦法猜未來的欄位）。
 - **只能匯出本 session 目前載入的人格**——否則就是跨人格外洩的後門（`guard` 會 deny）。
 - 不帶 `state/lock.json`／`guests.json`（鎖屬於那台機器的那個程序）；`journal/` 預設不帶。
 - 換名匯入（`--persona <新 slug>`）可讓同一個人格並存兩份，`config.json` 會記下來歷。
@@ -468,9 +550,11 @@ node scripts/persona.mjs sleep --session <PERSONA_SESSION> --release  # 收工
 | | 誰做 | 內容 |
 | --- | --- | --- |
 | 需要判斷 | **人格自己** | 哪些短期記憶值得固化、日記寫什麼、哪些該忘、心智圖怎麼接 |
-| 機械性 | `sleep` 子指令 | 關係時間戳 → 裁短期 → 收太久沒動的思維導圖 → **套用一次 8 小時的情緒衰減** → 重建索引 → 修剪 `said.jsonl` → 壓縮舊 journal → 寫 `state/sleep.json` → Gitea 兩區 push＋驗證 |
+| 機械性 | `sleep` 子指令 | 關係時間戳 → 裁短期 → 收太久沒動的思維導圖 → **套用一次 8 小時的情緒衰減＋當日底色帶 35% 過去** → **收掉懸太久的未完事項** → 重建索引 → 修剪 `said.jsonl` → 壓縮舊 journal → 寫 `state/sleep.json` → Gitea 兩區 push＋驗證 |
 
 - **情緒不會歸零**：喜悅（半衰期 120 分）一夜後幾乎回基線，悲傷（480 分）只退一半——睡一覺不該把難過抹平。
+  **當日心情底色一樣不歸零**（`sleepDayMood()` 只帶 35% 過去）：昨天的低氣壓不會因為睡了一覺就消失。
+- **睡覺是未完事項自然的收尾點**：`sweep-loops` 收掉懸超過 7 天的，各留一則「沒下文」的短期記憶。
 - **主人格請別人去睡**：開 `persona-sleeper` sub agent（prompt 帶 `persona=<slug> session=<id>`）。
   它就是那個人格本人，對自己可寫但被 pin 住、只准跑收尾子指令、不得碰任何其他人格（包含叫它來的主人格）。
 - **一次睡多個人格**：可用 `sleep --personas A,B` 批次處理；主程序只是把流程排成一串，**每個人格仍各自判斷、各自收尾、各自回 JSON**。
@@ -570,6 +654,14 @@ room 台詞另外比照短期記憶把**換行壓成空白**（`roomPost()` 寫
 
 - **Claude Code / Antigravity**：`/jsc-persona:persona-invite <slug>`　**Codex**：`$persona-invite`
 
+### `persona-story`
+
+把小說（或漫畫、劇本、遊戲文本）匯入既有人格：逐章判斷他在不在場、**只取他在場或知情的部分**、轉成第一人稱記憶，同時累積他自己講過的原句與「事件 → 他做了什麼」的反應對照。三條界線寫死在流程裡——他不知道的事不能變成他的 `event`、整本原文不入倉庫、`SOUL.md` 只有使用者能改。
+
+正名表不請使用者手打：`novel scan` 從章節抽人名候選（對話歸屬、敬稱結尾、片假名、高頻詞），附出現次數與一兩行上下文，猜關係節點並分四種信心度，使用者只做確認。`persona-anime` 給的是查得到的公開設定，這支給的是原文。
+
+- **Claude Code / Antigravity**：`/jsc-persona:persona-story`　**Codex**：`$persona-story`
+
 ### `persona-transfer`
 
 人格搬家：把身分、十二情緒、短期／長期記憶、心智圖與關係圖打包成單一 bundle 檔（可 gzip、附 checksum），或從 bundle 還原／換名複製成新人格。
@@ -633,13 +725,18 @@ room 台詞另外比照短期記憶把**換行壓成空白**（`roomPost()` 寫
 node scripts/persona.mjs --help
 node scripts/persona.mjs list
 node scripts/persona.mjs candidates --session <PERSONA_SESSION>   # 看哪些短期記憶該固化
+node scripts/persona.mjs migrate --session <id> --all --dry-run   # 長期記憶升格式（冪等；先試跑）
+node scripts/persona.mjs loop list --session <id>                 # 現在懸著哪幾件事（上限 5）
+node scripts/persona.mjs loop add --session <id> --kind promise --text "<他答應要做的事>"
+node scripts/persona.mjs probe add --session <id> --text "是不是上個月那次？"  # 模糊記憶的試探
+node scripts/persona.mjs probe audit --session <id>               # 試探幾次、被否認幾次
 node scripts/persona.mjs think --session <id> --text "<推導>"     # 心裡話（只回報「心想 N 句」）
 node scripts/persona.mjs said check --session <id> --text "<話>"  # 這句是不是又要說一次？
 node scripts/persona.mjs room script --session <id> --room <room> # 乾淨對話稿（劇場模式用）
 node scripts/persona.mjs room floor --session <id> --room <room>  # 發言權：誰對誰在講、該誰接話
 node scripts/persona.mjs export --session <id> --out lumi.json    # 離線搬家（單檔）
 node scripts/persona.mjs sync status --session <id>               # Gitea 同步狀態
-node scripts/selftest.mjs     # 248 項驗證：鎖、隔離、情緒、固化、說話節制、劇場模式與發言權、匯出匯入、編號與 Gitea、找圖去背合成、高解析輸出與 Wiki 同步、預設人格、睡眠與 sleeper、hooks
+node scripts/selftest.mjs     # 602 項驗證：鎖、隔離、情緒（含疲勞／當日底色／抑制與慣性）、固化、回想強度與模糊態、格式遷移、未完事項、說話節制、劇場模式與發言權、匯出匯入、編號與 Gitea、找圖去背合成、高解析輸出與 Wiki 同步、預設人格、睡眠與 sleeper、hooks
 ```
 
 檔案結構：`scripts/persona-lib.mjs`（核心：鎖／隔離／情緒／記憶）、`scripts/persona.mjs`（CLI）、
@@ -757,7 +854,7 @@ git -C ~/plugins/persona pull
 cp -r ~/plugins/persona/skills/* ~/.config/opencode/skills/
 
 # 移除
-rm -rf ~/.config/opencode/skills/{persona-anime,persona-chat,persona-create,persona-icon,persona-invite,persona-memory,persona-relation,persona-sleep,persona-status,persona-sync,persona-therapist,persona-transfer}
+rm -rf ~/.config/opencode/skills/{persona-anime,persona-chat,persona-create,persona-icon,persona-invite,persona-memory,persona-relation,persona-sleep,persona-status,persona-story,persona-sync,persona-therapist,persona-transfer}
 ```
 
 > **Windows PowerShell**：`cp -r A B` → `Copy-Item A B -Recurse -Force`、`rm -rf X` → `Remove-Item X -Recurse -Force`、`~` → `$HOME`。

scripts/persona-gitea.mjs

@@ -105,8 +105,14 @@ export const AREAS = {
       "state/said.jsonl",
       "state/felt.jsonl",
       "state/sleep.json",
+      "state/mood.json",
+      "state/loops.json",
+      "state/probe.jsonl",
       "memory/short-term.jsonl",
       "memory/inbox/",
+      // 故事匯入的工作區：一章一批 append 的候選、跳過紀錄、正名表。
+      // 收斂完就沒用了，但收斂中換一台機器要接得下去，所以跟著高頻區走。
+      "memory/import/",
       "mindmap/threads/",
       "journal/",
     ],
@@ -126,6 +132,8 @@ export const AREAS = {
       "icon/",
       "memory/INDEX.md",
       "memory/long-term/",
+      // 語氣層跟 IDENTITY／SOUL 同一區：它是低頻的設定，不是每輪都在變的活狀態
+      "voice/",
       "mindmap/semantic.mmd",
       "relations/graph.json",
       "relations/graph.mmd",
@@ -462,7 +470,7 @@ function statusPaths(dir) {
 
 export const WIKI_MANIFEST = "_paths.json";
 const WIKI_RESERVED = new Set(["Home.md", "Icon.md", WIKI_MANIFEST]);
-const WIKI_PREFIX = { memory: "Memory", mindmap: "Mindmap", relations: "Relations" };
+const WIKI_PREFIX = { memory: "Memory", mindmap: "Mindmap", relations: "Relations", voice: "Voice" };
 
 /**
  * Gitea 的 wiki **只有根目錄的 .md 會變成頁面**（1.27 實測：子目錄頁面連結 404），

scripts/persona.mjs

@@ -54,6 +54,10 @@ const FLAGS = new Set([
   "json", "quiet", "force", "takeover", "as-guest", "as-sleeper", "on", "off", "with-meta", "all",
   "with-journal", "gzip", "record", "load", "allow-repeat", "clear", "release", "keep-lock", "contact",
   "if-due", "no-gitea", "public", "rename", "from-source",
+  // 故事匯入：`--stdin` 吃管線進來的候選 JSON、`--accept-exact` 整批收下對得上節點的人名候選。
+  // `--apply`（novel merge）**故意不列**：`emotion --apply joy=+10` 也叫這個名字，
+  // 列進來會讓那個旗標變成布林，情緒就再也套不進去（踩過一次）。
+  "stdin", "accept-exact",
 ]);
 
 function parseArgs(argv) {
@@ -254,6 +258,27 @@ function renderTemplate(name, mapping) {
   return text;
 }
 
+/**
+ * `--tells "anger=不講話;句子只剩動詞|羞愧=摸後頸"` → IDENTITY.md 的 `## Tells` 條目。
+ *
+ * 情緒之間用 `|` 分，同一種情緒的多條破口用 `;` 或 `；` 分。
+ * 沒帶就回空字串：空的區塊等於「這個人格沿用全域預設」，樣板裡的註解會教下一個人怎麼補。
+ */
+function renderTells(raw) {
+  const src = String(raw || "").trim();
+  if (!src) return "";
+  const lines = [];
+  for (const group of src.split("|")) {
+    const idx = group.search(/[=:：]/);
+    if (idx < 0) continue;
+    const key = group.slice(0, idx).trim();
+    const tells = group.slice(idx + 1).split(/[;；、,，]/).map((s) => s.trim()).filter(Boolean).slice(0, 5);
+    if (!key || !tells.length) continue;
+    lines.push(`- ${pl.injectSafeLine(key, 12)}: ${tells.map((t) => pl.injectSafeLine(t, 40)).join("；")}`);
+  }
+  return lines.join("\n");
+}
+
 // --------------------------------------------------------------------------- //
 // 子指令
 // --------------------------------------------------------------------------- //
@@ -296,6 +321,9 @@ commands.create = async ({ flags }) => {
     VIBE: str(flags.vibe),
     EMOJI: str(flags.emoji),
     AVATAR: str(flags.avatar),
+    // 情緒破口：`--tells "anger=不講話;把事情做完再說|羞愧=摸後頸"`。
+    // 沒帶就留空——空的區塊會退回全域預設，而樣板裡的註解會告訴下一個人怎麼補。
+    TELLS: renderTells(str(flags.tells)),
     CREATED: pl.nowIso(),
   };
   for (const filename of ["IDENTITY.md", "SOUL.md", "AGENTS.md", "USER.md"]) {
@@ -542,7 +570,11 @@ commands.sleep = async ({ flags }) => {
     await run("archive-threads", () => pl.archiveStaleThreads(slug));
     await run("emotion-decay", () => {
       pl.updateEmotion(slug, (s) => pl.decayEmotionBy(s, pl.SLEEP_DECAY_MINUTES));
+      // 當日底色不歸零，只帶一部分過去——睡一覺不會把昨天的低氣壓抹掉
+      pl.sleepDayMood(slug);
     });
+    // 懸太久沒下文的事在這裡收（睡覺是它自然的收尾點），各留一則短期記憶
+    await run("sweep-loops", () => ({ cold: pl.sweepLoops(slug).length }));
     await run("reindex", () => pl.rebuildIndex(slug));
     await run("trim-said", () => pl.trimSaid(slug));
     await run("archive-journal", () => pl.archiveJournals(slug));
@@ -743,7 +775,7 @@ commands.remember = ({ flags }) => {
   pl.rememberShort(slug, entry);
   const kept = pl.pruneShortTerm(slug);
   if (Object.keys(entry.emotion_deltas).length) {
-    const state = pl.updateEmotion(slug, (s) => pl.applyEmotion(s, entry.emotion_deltas, text.slice(0, 80)));
+    const state = pl.updateEmotion(slug, (s) => pl.applyEmotion(s, entry.emotion_deltas, text.slice(0, 80), { slug }));
     pl.appendJsonl(pl.journalPath(slug), {
       ts: pl.nowIso(), kind: "emotion", trigger: text.slice(0, 120),
       deltas: entry.emotion_deltas, levels: state.levels, mood: pl.mood(state),
@@ -768,8 +800,18 @@ commands.recall = ({ flags }) => {
   const hits = pl.recall(slug, query, limit);
   const lines = [`「${query}」的長期記憶命中 ${hits.length} 則：`];
   for (const meta of hits) {
-    const first = (meta._body || "").split("\n")[0] || "";
-    lines.push(`- ${meta._name}｜${meta.type || "fact"}｜顯著度 ${meta.salience ?? "?"}｜${first.slice(0, 120)}`);
+    const r = pl.memoryRecalled(meta);
+    const head = `- ${meta._name}｜${meta.type || "fact"}｜顯著度 ${meta.salience ?? "?"}`;
+    if (r.state === "clear") {
+      const first = (meta._gist || meta._body || "").split("\n")[0] || "";
+      lines.push(`${head}｜${first.slice(0, 120)}`);
+    } else if (r.state === "faded") {
+      lines.push(`${head}｜⚠ 半模糊 ${Math.round(r.retrievability * 100)}%｜主旨：${r.gist.split("\n")[0].slice(0, 100)}`);
+      lines.push(`  ${r.hint}`);
+    } else {
+      lines.push(`${head}｜⚠ 模糊 ${Math.round(r.retrievability * 100)}%｜只剩線索：${(r.topics || []).join("/") || "-"}`);
+      lines.push(`  ${r.hint}`);
+    }
   }
   const recents = pl.recentShort(slug, limit);
   if (recents.length) {
@@ -782,7 +824,8 @@ commands.recall = ({ flags }) => {
     lines.push("心裡話（只有你自己看得到，不要講給他聽）：");
     for (const row of inner) lines.push(`- 💭 [${row.kind || "infer"}] ${String(row.text || "").slice(0, 110)}`);
   }
-  pl.touchRecall(slug, hits.map((m) => m._name));
+  // 模糊到只剩線索的那幾則**不算被想起來**：真的想不起來就不該重設它的衰減
+  pl.touchRecall(slug, hits.filter((m) => (m._recall?.retrievability ?? 1) >= pl.MEMORY_FUZZY_AT).map((m) => m._name));
   emit({ persona: slug, long_term: hits, short_term: recents, inner }, flags.json, lines);
 };
 
@@ -850,12 +893,23 @@ commands.said = ({ flags, positional }) => {
     for (const issue of blockers) lines.push(`⚠ ${pl.speechLintMessage(issue)}。`);
     // hint 不算不通過（例如講到自己的過去），但要提醒去驗證
     for (const issue of lint.filter((i) => i.level === "hint")) lines.push(`· ${pl.speechLintMessage(issue)}。`);
+    // 模糊態的兩種句型：試探是**提醒**（記一筆），假裝記得是**提醒去查**。
+    // 這裡刻意都不擋——擋下去等於把「開放試探」那條界線收回來，稽核才是煞車。
+    const probing = pl.looksLikeProbe(text);
+    const asserting = pl.looksLikeFabrication(text);
+    if (probing) {
+      lines.push("· 這句是試探：說出口之後記一筆 `persona.mjs probe add --text \"...\"`，" +
+        "對方回了再 `probe confirm` 或 `probe deny`。");
+    } else if (asserting) {
+      lines.push("· 這句在斷言自己的過去，而且沒有在問：先 `recall` 確認那則記憶還清晰。" +
+        "只要它是模糊態，就改成帶問號的試探句，不可以把細節補出來。");
+    }
     const clean = !repeat && !tooLong && !blockers.length;
     if (clean) {
       lines.push(`✔ 沒講過，${sentences} 句，可以說。`);
       if (flags.record) pl.recordSaid(slug, text, { kind: "reply" });
     }
-    emit({ persona: slug, repeat, sentences, lint, ok: clean }, flags.json, lines);
+    emit({ persona: slug, repeat, sentences, lint, probing, asserting, ok: clean }, flags.json, lines);
     return;
   }
   die(`未知 action：${action}（可用 check/list）`);
@@ -903,7 +957,6 @@ commands.consolidate = ({ flags }) => {
   if (!rawName) die("需要 `--name`（長期記憶的檔名／識別）。");
   const name = pl.slugify(rawName);
   const file = path.join(pl.longTermDir(slug), `${name}.md`);
-  const today = pl.nowIso().slice(0, 10);
   let existing = {};
   if (fs.existsSync(file)) [existing] = pl.parseFrontMatter(fs.readFileSync(file, "utf8"));
   // slugify 會把標點吃掉：「我的貓」「我的貓？」「我的貓!!」全都落在 `我的貓.md` 上。
@@ -931,36 +984,29 @@ commands.consolidate = ({ flags }) => {
   ];
   if (!VALID_TYPES.includes(type)) die(`--type 只能是 ${VALID_TYPES.join("/")}。`);
   const about = csv(flags.about).length ? csv(flags.about) : ["user"];
-  // `about` 是自由字串（原樣保留）；對得上關係圖節點的才多寫一行 id，之後 recall 與
-  // 「人際關係」那段才知道講的是同一個人。一個都對不上就不輸出這一行。
-  // `resolveRelationRefs` 已經把不能寫進 front matter 的 id 濾掉了（帶換行的節點 id
-  // 可以在這裡多插一行、覆寫下面的 `type`，把一則 fact 變成不該被遺忘的 canon）。
-  const aboutIds = pl.resolveRelationRefs(slug, about);
-  // front matter 的每個值都只能是一行：帶換行的旗標值同樣能偽造出別的欄位，
-  // 而 `parseFrontMatter` 取後出現的值 → 後面宣告的 type/salience 會被前面偽造的蓋掉。
-  const fm = (value) => pl.injectSafeLine(value);
-  const front = [
-    "---",
-    `name: ${name}`,
-    // 原本的 --name（沒被 slugify 吃掉的那個）。下次撞名時就是靠這行認出「不是同一則」。
-    `title: ${rawName.replace(/[\r\n]+/g, " ").replace(/-{3,}/g, "—").trim().slice(0, 120)}`,
-    `type: ${type}`,
-    `about: [${about.map(fm).filter(Boolean).join(", ")}]`,
-    ...(aboutIds.length ? [`about_ids: [${aboutIds.join(", ")}]`] : []),
-    `topics: [${csv(flags.topics).map(fm).filter(Boolean).join(", ")}]`,
-    `salience: ${num(flags.salience, 60)}`,
-    `emotion: ${fm(str(flags.emotion) || "none")}`,
-    `rules: ${fm(str(flags.rules) || "manual")}`,
-    `first_seen: ${existing.first_seen || today}`,
-    `last_seen: ${today}`,
-    `recall_count: ${existing.recall_count || 0}`,
-    `source: ${fm(str(flags.source) || "short-term")}`,
-    "---",
-    "",
-    body.trim(),
-    "",
-  ];
-  pl.writeText(file, front.join("\n"));
+  // front matter 的組裝在 `writeLongTermMemory`：`novel write` 也走同一套，
+  // 欄位順序與預設值只能有一份（見那個函式的說明）。
+  pl.writeLongTermMemory(slug, {
+    name,
+    // 原本的 --name（沒被 slugify 吃掉的那個）。下次撞名時就是靠 title 認出「不是同一則」。
+    title: rawName,
+    type,
+    body,
+    // `--gist` 明寫時，`--detail` 沒給就是**沒有細節**（見 writeLongTermMemory）
+    gist: str(flags.gist) || null,
+    detail: str(flags.detail),
+    about,
+    topics: csv(flags.topics),
+    salience: num(flags.salience, 60),
+    // 沒帶 --strength 就交給既有檔案裡長出來的強度（null = 沿用）
+    strength: num(flags.strength, null),
+    emotion: str(flags.emotion),
+    when: str(flags.when),
+    where: str(flags.where),
+    mood: str(flags.mood),
+    rules: str(flags.rules),
+    source: str(flags.source),
+  });
   const total = pl.rebuildIndex(slug);
   const forget = num(flags.forget, null);
   if (forget !== null) {
@@ -984,6 +1030,619 @@ commands.prune = ({ flags }) => {
   ok(`短期記憶已裁剪，剩 ${kept} 筆（保留上限 ${pl.SHORT_TERM_KEEP} 筆 / ${pl.SHORT_TERM_DAYS} 天）。`);
 };
 
+/**
+ * 把長期記憶檔升到新格式（`strength` 與主旨／細節兩層）。
+ *
+ * `--all` 會掃過**所有**人格——這是唯一一個跨人格的維護指令，
+ * 所以它只回報「動了幾個檔」，一個字的內容都不印出來（跨人格隔離的界線在這裡不能鬆）。
+ */
+commands.migrate = ({ flags }) => {
+  const session = requireSession(flags);
+  const dryRun = Boolean(flags["dry-run"]);
+  const targets = flags.all ? pl.listPersonas() : [hostOf(flags, session)];
+  if (!flags.all) requireOwner(targets[0], session);
+  const rows = [];
+  for (const slug of targets) {
+    const stats = pl.migrateLongTerm(slug, { dryRun });
+    if (!dryRun && (stats.strength || stats.split)) pl.rebuildIndex(slug);
+    rows.push({ persona: slug, ...stats });
+  }
+  const lines = [dryRun ? "長期記憶格式遷移（試跑，沒有寫入）：" : "長期記憶格式遷移完成："];
+  for (const r of rows) {
+    lines.push(`- ${r.persona}｜共 ${r.total} 則｜補 strength ${r.strength}｜切主旨/細節 ${r.split}` +
+      (r.skipped ? `｜讀寫失敗 ${r.skipped}` : ""));
+  }
+  lines.push("  （只回報數量：跨人格維護不印任何記憶內容。）");
+  emit({ dry_run: dryRun, personas: rows }, flags.json, lines);
+};
+
+// --------------------------------------------------------------------------- //
+// loop：懸著的事（未完事項）
+// --------------------------------------------------------------------------- //
+
+commands.loop = ({ flags, positional }) => {
+  const session = requireSession(flags);
+  const slug = hostOf(flags, session);
+  const action = (positional[0] || "list").toLowerCase();
+  const show = () => {
+    const live = pl.openLoops(slug);
+    const lines = [`\`${slug}\` 現在懸著 ${live.length}/${pl.LOOP_MAX} 件事：`];
+    for (const l of live) {
+      const days = Math.floor((Date.now() - (pl.parseIso(l.opened_at)?.getTime() ?? Date.now())) / 86_400_000);
+      lines.push(`- ${l.id}｜${pl.LOOP_KINDS[l.kind] || l.kind}｜${l.text}（開了 ${days} 天）`);
+    }
+    if (!live.length) lines.push("- （沒有懸著的事）");
+    emit({ persona: slug, loops: live }, flags.json, lines);
+  };
+  if (action === "list") {
+    requireMember(slug, session, Boolean(flags["as-guest"]));
+    show();
+    return;
+  }
+  requireOwner(slug, session);
+  if (action === "add") {
+    const res = pl.addLoop(slug, { text: str(flags.text), kind: str(flags.kind) || "topic", about: str(flags.about) });
+    if (!res.ok) die(`開不了：${res.reason}。`);
+    ok(`懸著了：${res.loop.id}｜${pl.LOOP_KINDS[res.loop.kind]}｜${res.loop.text}（${res.open}/${pl.LOOP_MAX}）`);
+    return;
+  }
+  if (action === "done" || action === "drop" || action === "cold") {
+    const id = str(flags.id);
+    if (!id) die("需要 `--id`（用 `loop list` 查）。");
+    const res = pl.closeLoop(slug, id, action === "done" ? "done" : action, str(flags.note));
+    if (!res.ok) die(res.reason);
+    ok(`收掉了 ${res.loop.id}：${res.loop.text}`);
+    return;
+  }
+  if (action === "touch") {
+    const id = str(flags.id);
+    if (!id) die("需要 `--id`。");
+    const res = pl.touchLoop(slug, id);
+    if (!res.ok) die(res.reason);
+    ok(`${res.loop.id} 有進展，逾期重算。`);
+    return;
+  }
+  if (action === "sweep") {
+    const cold = pl.sweepLoops(slug);
+    ok(cold.length
+      ? `收掉 ${cold.length} 件沒下文的（各留了一則短期記憶）：${cold.map((l) => l.text).join("、")}`
+      : `沒有超過 ${pl.LOOP_STALE_DAYS} 天沒進展的。`);
+    return;
+  }
+  die("用法：`loop add|done|drop|touch|sweep|list`。");
+};
+
+// --------------------------------------------------------------------------- //
+// probe：模糊記憶的試探與稽核（開放界線唯一的煞車）
+// --------------------------------------------------------------------------- //
+
+commands.probe = ({ flags, positional }) => {
+  const session = requireSession(flags);
+  const slug = hostOf(flags, session);
+  const action = (positional[0] || "audit").toLowerCase();
+  if (action === "audit") {
+    requireMember(slug, session, Boolean(flags["as-guest"]));
+    const a = pl.probeAudit(slug, num(flags.limit, 50));
+    const lines = [
+      `\`${slug}\` 的試探稽核（最近 ${a.total} 次）：`,
+      `  確認 ${a.confirmed}／否認 ${a.denied}／還沒結案 ${a.pending}`,
+      a.denied_ratio === null
+        ? "  還沒有結案的試探，算不出錯誤率。"
+        : `  結案的裡面有 ${a.denied_ratio}% 被否認` +
+          (a.denied_ratio >= 40 ? " ⚠ 太高了：模糊態正在被拿來編內容，先收緊到「只能說記不清」。" : "。"),
+    ];
+    for (const row of a.recent) lines.push(`  - [${row.outcome}] ${row.text}${row.memory ? `（${row.memory}）` : ""}`);
+    emit({ persona: slug, audit: a }, flags.json, lines);
+    return;
+  }
+  requireOwner(slug, session);
+  if (action === "add") {
+    const text = str(flags.text);
+    if (!text) die("需要 `--text`（你實際問出口的那句試探）。");
+    if (!pl.looksLikeProbe(text)) {
+      die("這句不像試探：試探一定要在**問**（帶問號，例如「是不是上個月那次？」）。\n" +
+        "　可以說不確定，不可以斷言——斷言就是幻覺，不是模糊記憶。");
+    }
+    const entry = pl.recordProbe(slug, { text, memory: str(flags.memory) });
+    ok(`記下這次試探了：${entry.text}　→ 對方回了之後用 \`probe confirm\` 或 \`probe deny\`。`);
+    return;
+  }
+  if (action === "confirm" || action === "deny") {
+    const hit = pl.resolveProbe(slug, action === "confirm" ? "confirmed" : "denied", {
+      at: str(flags.id) || null, // 不指定就結最近一筆還沒結案的
+      note: str(flags.note),
+    });
+    if (!hit) die("沒有還沒結案的試探。");
+    if (action === "deny") {
+      ok(`記成「被否認」了：${hit.text}\n　現在就寫一則更正記憶（\`remember\` 或 \`consolidate\`），不要放著。`);
+    } else {
+      ok(`記成「對方確認」了：${hit.text}`);
+    }
+    return;
+  }
+  die("用法：`probe add|confirm|deny|audit`。");
+};
+
+// --------------------------------------------------------------------------- //
+// voice：語氣樣本與情緒反應（`voice/`）
+//
+// 這一層匯入流程可以直接寫，個性（SOUL.md）不行——權限界線靠檔案分開，不靠自律。
+// --------------------------------------------------------------------------- //
+
+commands.voice = ({ flags, positional }) => {
+  const session = requireSession(flags);
+  const slug = hostOf(flags, session);
+  const action = (positional[0] || "show").toLowerCase();
+  const kind = str(flags.kind) || "sample";
+  if (!(kind in pl.VOICE_KINDS)) {
+    die(`--kind 只能是 ${Object.keys(pl.VOICE_KINDS).join("/")}` +
+      "（sample＝他自己講過的原句，reaction＝事件對上他做了什麼）。");
+  }
+  const render = (entry) => (kind === "sample"
+    ? `「${entry.text}」${[entry.to ? `對 ${entry.to}` : "", entry.scene].filter(Boolean).join("／")
+      ? `（${[entry.to ? `對 ${entry.to}` : "", entry.scene].filter(Boolean).join("／")}）` : ""}`
+    : `${entry.event} → ${entry.action || "（沒記）"}${entry.emotion ? `（${entry.emotion}）` : ""}`);
+  if (action === "show" || action === "list") {
+    requireMember(slug, session, Boolean(flags["as-guest"]));
+    const voice = pl.loadVoice(slug);
+    if (action === "show") {
+      const brief = pl.voiceBrief(slug, {
+        limit: num(flags.limit, pl.VOICE_INJECT_MAX),
+        to: str(flags.to) || null,
+        hint: str(flags.scene) || str(flags.text),
+      });
+      emit({ persona: slug, brief, samples: voice.samples.length, reactions: voice.reactions.length }, flags.json, [
+        `\`${slug}\` 這一輪會注入的語氣（最多 ${pl.VOICE_INJECT_MAX} 條——全注入會變成照抄舊台詞）：`,
+        brief || "  （語氣檔還是空的：先用 `voice add` 累積他自己講過的原句）",
+      ]);
+      return;
+    }
+    const rows = kind === "sample" ? voice.samples : voice.reactions;
+    const limit = num(flags.limit, 20);
+    const shown = Number.isFinite(limit) && limit > 0 ? rows.slice(-limit) : rows;
+    emit({ persona: slug, kind, total: rows.length, entries: shown }, flags.json, [
+      `\`${slug}\` 的${pl.VOICE_LABELS[kind]} ${rows.length} 條（${pl.voicePath(slug, kind)}）：`,
+      ...shown.map((entry) => `  - ${render(entry)}`),
+      ...(rows.length ? [] : ["  （還沒有。手改那個檔也可以：一行一筆，行首 `- `）"]),
+    ]);
+    return;
+  }
+  requireOwner(slug, session);
+  if (action === "add") {
+    const res = kind === "sample"
+      ? pl.addVoiceSample(slug, { text: str(flags.text), to: str(flags.to), scene: str(flags.scene) })
+      : pl.addVoiceReaction(slug, { event: str(flags.event), action: str(flags.action), emotion: str(flags.emotion) });
+    if (!res) {
+      die(kind === "sample"
+        ? "需要 `--text`（他自己講過的原句，照抄不要改寫）。"
+        : "需要 `--event`（發生了什麼事）；`--action` 寫他做了什麼，不要寫他感覺到什麼。");
+    }
+    if (!res.added) {
+      ok(`已經有一模一樣的一條了，沒有重複寫入：${res.line}`);
+      return;
+    }
+    ok(`${pl.VOICE_LABELS[kind]}加一條：${res.line}`);
+    pushWikiLater(slug, session, flags); // voice/ 屬於 Wiki 區（低頻設定）
+    return;
+  }
+  die("用法：`voice add|list|show`。");
+};
+
+// --------------------------------------------------------------------------- //
+// novel：故事匯入的機械那半
+//
+// 判斷的那半留在 skill（在場與知情、切場景、第一人稱摘要、個性校正提案），
+// 這裡只做機械的：抽人名候選、正名、跳過紀錄、欄位驗證、去重合併、配額重定標、
+// 批次寫入。一律不改 SOUL.md，也不套情緒 delta——情緒只固化進欄位（TODO 2.4）。
+// --------------------------------------------------------------------------- //
+
+commands.novel = ({ flags, positional }) => {
+  const session = requireSession(flags);
+  const slug = hostOf(flags, session);
+  const action = (positional[0] || "report").toLowerCase();
+  const sub = (positional[1] || "").toLowerCase();
+  // `init` 的 --work 是書名，其他子指令的 --work 是 init 定下來的 work-slug
+  const openWork = () => {
+    const key = str(flags.work);
+    if (!key) die("需要 `--work <work-slug>`（`novel init` 建立時回報的那個 slug）。");
+    const work = pl.loadNovelWork(slug, key);
+    if (!work) {
+      const have = pl.listNovelWorks(slug).map((w) => w.slug);
+      die(`找不到作品工作區 \`${key}\`` +
+        `${have.length ? `（現有：${have.join("、")}）` : "（還沒有任何工作區）"}。` +
+        "\n　先 `novel init --work \"<書名>\"`。");
+    }
+    return work;
+  };
+  const candidatesOf = (work) => pl.readJsonl(pl.novelCandidatesPath(slug, work.slug));
+
+  if (action === "report") {
+    requireMember(slug, session, Boolean(flags["as-guest"]));
+    const work = openWork();
+    const rows = candidatesOf(work);
+    const skipped = pl.readJsonl(pl.novelSkippedPath(slug, work.slug));
+    const book = pl.loadNovelNameBook(slug, work.slug);
+    const proposals = pl.loadNovelProposals(slug, work.slug);
+    const usage = pl.novelQuotaUsage(rows, work.quota);
+    const unwritten = rows.filter((r) => !r.written_at);
+    const duplicates = rows.length - pl.mergeNovelCandidates(rows).rows.length;
+    emit({
+      persona: slug,
+      work: work.work,
+      slug: work.slug,
+      candidates: rows.length,
+      unwritten: unwritten.length,
+      duplicates,
+      skipped: skipped.length,
+      names: Object.keys(book.map).length,
+      ignored: book.ignore.length,
+      pending_names: proposals.length,
+      quota: usage,
+      baseline: work.baseline ?? null,
+    }, flags.json, [
+      `《${work.work}》（\`${work.slug}\`）匯入現況：`,
+      `  記憶候選 ${rows.length} 則｜同名還沒合併 ${duplicates} 則｜還沒寫入長期記憶 ${unwritten.length} 則`,
+      `  跳過 ${skipped.length} 章｜正名表 ${Object.keys(book.map).length} 條｜` +
+        `標成不是人名 ${book.ignore.length} 個｜還沒確認的人名候選 ${proposals.length} 個`,
+      ...usage.map((u) => `  配額 ${u.label}：${u.used}/${u.limit}` +
+        `${u.over ? ` ⚠ 超出 ${u.over} 則 → 跑 \`novel merge\`` : ""}`),
+      work.baseline
+        ? `  情緒基線上次調整：${work.baseline.at}${work.baseline.forced ? "（--force 蓋過門檻）" : ""}`
+        : "  情緒基線還沒動過。",
+    ]);
+    return;
+  }
+
+  requireOwner(slug, session);
+
+  if (action === "init") {
+    const title = str(flags.work);
+    if (!title) die("需要 `--work \"<書名>\"`。");
+    const quota = flags.quota ? pl.parseNovelQuota(str(flags.quota)) : null;
+    if (flags.quota && !quota) die("`--quota` 看不懂：格式是 `90=5,80=20`（顯著度門檻=最多幾則）。");
+    const key = pl.slugify(str(flags.slug) || title);
+    const before = pl.loadNovelWork(slug, key);
+    if (before && !flags.force) {
+      die(`工作區 \`${key}\` 已經存在（《${before.work}》，${before.created_at}）。` +
+        "\n　要改配額就重跑一次並加 --force（候選與跳過紀錄不會動）。");
+    }
+    const work = pl.initNovelWork(slug, { work: title, workSlug: key, quota });
+    emit({ persona: slug, work }, flags.json, [
+      `✔ 工作區建好了：${pl.novelWorkDir(slug, key)}`,
+      `  作品《${work.work}》　slug \`${work.slug}\`（之後的 --work 都用這個）`,
+      `  顯著度配額：${pl.novelQuotaUsage([], work.quota).map((u) => `${u.label} 最多 ${u.limit} 則`).join("、")}`,
+      "  下一步：`novel scan --work <slug> --file <章節檔>` 抽人名候選，再 `novel name review` 確認。",
+    ]);
+    return;
+  }
+
+  if (action === "scan") {
+    const work = openWork();
+    const files = [...csv(flags.file), ...positional.slice(1)];
+    if (str(flags.dir)) {
+      let entries = [];
+      try {
+        entries = fs.readdirSync(str(flags.dir), { withFileTypes: true });
+      } catch (err) {
+        die(`讀不到 --dir \`${str(flags.dir)}\`：${String(err.message).slice(0, 120)}`);
+      }
+      for (const entry of entries.filter((e) => e.isFile()).sort((a, b) => a.name.localeCompare(b.name))) {
+        files.push(path.join(str(flags.dir), entry.name));
+      }
+    }
+    if (!files.length) die("需要 `--file <章節檔[,第二檔]>` 或 `--dir <目錄>`。");
+    const texts = [];
+    for (const file of files) {
+      try {
+        texts.push(fs.readFileSync(file, "utf8"));
+      } catch (err) {
+        die(`讀不到 \`${file}\`：${String(err.message).slice(0, 120)}`);
+      }
+    }
+    const res = pl.scanNovelNames(slug, work.slug, texts);
+    emit({ persona: slug, work: work.slug, files: files.length, fresh: res.fresh.length, candidates: res.candidates }, flags.json, [
+      `掃了 ${files.length} 個章節檔：新增 ${res.fresh.length} 個人名候選，` +
+        `待確認共 ${res.candidates.length} 個（${pl.novelProposedPath(slug, work.slug)}）。`,
+      ...res.candidates.slice(0, 30).map((c) => `  [${c.confidence}] ${c.token}（${c.count} 次）` +
+        `${c.guess ? ` → 猜是「${c.guess}」` : ""}`),
+      ...(res.candidates.length > 30 ? [`  （還有 ${res.candidates.length - 30} 個，用 \`novel name review\` 看全部）`] : []),
+      "  已經在正名表或 ignore 裡的不再列出——第二次掃只會看到新出現的。",
+      "  下一步：`novel name review`（確認）／`novel name confirm --accept-exact`（整批收下對得上的）。",
+    ]);
+    return;
+  }
+
+  if (action === "name") {
+    const work = openWork();
+    if (sub === "add" || sub === "confirm") {
+      if (flags["accept-exact"]) {
+        const done = pl.acceptExactNovelNames(slug, work.slug);
+        emit({ persona: slug, work: work.slug, confirmed: done }, flags.json, [
+          `✔ 收下 ${done.length} 條 exact 候選（等於關係節點的名字，沒有判斷空間）：`,
+          ...done.map((d) => `  ${d.from} → ${d.to}`),
+          ...(done.length ? [] : ["  （沒有 exact 候選；fuzzy 與 unknown 要一條一條看）"]),
+        ]);
+        return;
+      }
+      const from = str(flags.from);
+      const to = str(flags.to);
+      if (!from || !to) die("需要 `--from \"<書裡的名字>\"` 與 `--to \"<關係節點 name>\"`（或 `--accept-exact`）。");
+      const res = sub === "confirm"
+        ? pl.confirmNovelName(slug, work.slug, { from, to })
+        : pl.addNovelName(slug, work.slug, { from, to });
+      if (!res) {
+        die(`關係圖裡找不到 \`${to}\`——記憶的 \`about\` 對不上節點就等於沒記到人身上。\n` +
+          `　先建節點：\`relation node --name "${to}" --kind human --session <id>\`` +
+          "（親近度查 persona-relation/reference/closeness.md），再回來正名。");
+      }
+      ok(`正名表：${res.from} → ${res.to}（節點 \`${res.node_id}\`）`);
+      return;
+    }
+    if (sub === "ignore" || sub === "reject") {
+      const token = str(flags.token) || str(flags.from);
+      if (!token) die("需要 `--token \"<候選詞>\"`。");
+      if (sub === "ignore") {
+        if (!pl.ignoreNovelName(slug, work.slug, token)) die("`--token` 是空的。");
+        ok(`\`${token}\` 標成不是人名了（進 ignore，下次掃不會再列）。`);
+        return;
+      }
+      const removed = pl.rejectNovelName(slug, work.slug, token);
+      ok(removed
+        ? `\`${token}\` 從候選移除了（沒進 ignore：下次掃還會再出現）。`
+        : `候選裡沒有 \`${token}\`，什麼都沒動。`);
+      return;
+    }
+    if (sub === "review") {
+      const rows = pl.loadNovelProposals(slug, work.slug);
+      const groups = ["exact", "alias", "fuzzy", "unknown"];
+      const lines = [`《${work.work}》還沒確認的人名候選 ${rows.length} 個：`];
+      for (const level of groups) {
+        const group = rows.filter((r) => r.confidence === level);
+        if (!group.length) continue;
+        lines.push(`  ${level}（${group.length} 個）：`);
+        for (const row of group) {
+          lines.push(`    ${row.token}（${row.count} 次）${row.guess ? ` → 猜是「${row.guess}」` : ""}`);
+          for (const sample of (row.samples || []).slice(0, 2)) lines.push(`      ⋯${sample}⋯`);
+        }
+        if (level === "exact") lines.push("    → 這一組可以 `novel name confirm --accept-exact` 整批收下。");
+        if (level === "unknown") {
+          lines.push("    → 對不上任何節點。這是新人物就先 `relation node --name \"<會被說出口的完整稱呼>\"`，" +
+            "再回來 confirm；不是人名就 `novel name ignore --token \"<詞>\"`。");
+        }
+      }
+      if (!rows.length) lines.push("  （沒有待確認的。要抽新的就 `novel scan --file <章節檔>`。）");
+      emit({ persona: slug, work: work.slug, pending: rows }, flags.json, lines);
+      return;
+    }
+    if (sub === "list" || !sub) {
+      const book = pl.loadNovelNameBook(slug, work.slug);
+      const rows = Object.entries(book.map);
+      emit({ persona: slug, work: work.slug, map: book.map, ignore: book.ignore }, flags.json, [
+        `《${work.work}》的正名表 ${rows.length} 條（${pl.novelNamesPath(slug, work.slug)}）：`,
+        ...rows.map(([from, to]) => `  ${from} → ${to}`),
+        ...(rows.length ? [] : ["  （還是空的：`novel scan` 抽候選，`novel name review` 確認）"]),
+        ...(book.ignore.length ? [`  標成不是人名的：${book.ignore.join("、")}`] : []),
+      ]);
+      return;
+    }
+    die("用法：`novel name add|list|review|confirm|ignore|reject`。");
+  }
+
+  if (action === "skip") {
+    const work = openWork();
+    if (sub === "list") {
+      const rows = pl.readJsonl(pl.novelSkippedPath(slug, work.slug));
+      emit({ persona: slug, work: work.slug, skipped: rows }, flags.json, [
+        `《${work.work}》跳過的章節 ${rows.length} 章：`,
+        ...rows.map((r) => `  ${r.chapter}——${r.reason}（${String(r.at).slice(0, 10)}）`),
+        ...(rows.length ? [] : ["  （還沒有跳過紀錄）"]),
+      ]);
+      return;
+    }
+    const entry = pl.addNovelSkip(slug, work.slug, { chapter: str(flags.chapter), reason: str(flags.reason) });
+    if (!entry) die("需要 `--chapter \"<章節>\"` 與 `--reason \"<理由>\"`——靜默跳過會漏章，事後查不出來。");
+    ok(`記下跳過：${entry.chapter}——${entry.reason}`);
+    return;
+  }
+
+  if (action === "candidate") {
+    const work = openWork();
+    if (sub !== "add") die("用法：`novel candidate add --work <slug> --file <候選 JSON>`（或 `--stdin`）。");
+    let raw = "";
+    if (flags.stdin) {
+      try {
+        raw = fs.readFileSync(0, "utf8");
+      } catch {
+        raw = "";
+      }
+    } else if (str(flags.file)) {
+      try {
+        raw = fs.readFileSync(str(flags.file), "utf8");
+      } catch (err) {
+        die(`讀不到 \`${str(flags.file)}\`：${String(err.message).slice(0, 120)}`);
+      }
+    } else {
+      die("需要 `--file <候選 JSON 檔>` 或 `--stdin`。");
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch (err) {
+      die(`候選 JSON 解析不了：${String(err.message).slice(0, 160)}`);
+    }
+    const rows = Array.isArray(parsed) ? parsed : [parsed];
+    const res = pl.addNovelCandidates(slug, work.slug, rows);
+    const lines = [`《${work.work}》收下 ${res.added.length}/${rows.length} 則記憶候選。`];
+    for (const fail of res.failed) {
+      lines.push(`✖ 第 ${fail.index + 1} 筆（${fail.name}）沒過：`);
+      for (const err of fail.errors) lines.push(`    ${err.field}：${err.reason}`);
+    }
+    if (res.failed.length) lines.push("  沒過的**沒有寫進去**：修好那幾筆再送一次（其餘已經收下，不會重複）。");
+    emit({ persona: slug, work: work.slug, added: res.added.length, failed: res.failed }, flags.json, lines);
+    // 驗不過的不能只印一行就當成功——呼叫端（skill）要靠結束碼知道這一章沒收完
+    if (res.failed.length) process.exit(1);
+    return;
+  }
+
+  if (action === "merge") {
+    const work = openWork();
+    const file = pl.novelCandidatesPath(slug, work.slug);
+    const rows = pl.readJsonl(file);
+    if (!rows.length) die("這個工作區還沒有記憶候選（先 `novel candidate add`）。");
+    const { rows: dedup, merged } = pl.mergeNovelCandidates(rows);
+    const { rows: final, demoted } = pl.requotaNovelCandidates(dedup, work.quota);
+    const usage = pl.novelQuotaUsage(final, work.quota);
+    const apply = Boolean(flags.apply);
+    // 合併會少列、重定標只改欄位——長度沒變就不寫檔，所以一律帶 force
+    if (apply) pl.rewriteJsonl(file, () => final, { force: true });
+    emit({
+      persona: slug, work: work.slug, applied: apply, before: rows.length, after: final.length, merged, demoted, quota: usage,
+    }, flags.json, [
+      apply ? `《${work.work}》已收斂並寫回：` : `《${work.work}》收斂試跑（**沒有寫檔**，要落地加 --apply）：`,
+      `  ${rows.length} 則 → ${final.length} 則（同名合併掉 ${merged} 則）`,
+      `  依配額壓下來 ${demoted.length} 則：`,
+      ...demoted.slice(0, 12).map((d) => `    ${d.name}｜${d.from} → ${d.to}（${d.tier} 那一級滿了）`),
+      ...(demoted.length > 12 ? [`    （還有 ${demoted.length - 12} 則）`] : []),
+      ...usage.map((u) => `  配額 ${u.label}：${u.used}/${u.limit}`),
+      "  合併規則：salience 取高、first_seen 取最早、last_seen 取最晚、topics/about 取聯集、quote 留最長的。",
+    ]);
+    return;
+  }
+
+  if (action === "write") {
+    const work = openWork();
+    const file = pl.novelCandidatesPath(slug, work.slug);
+    const rows = pl.readJsonl(file);
+    const pending = rows.filter((r) => !r.written_at);
+    const limit = num(flags.limit, null);
+    const batch = Number.isFinite(limit) ? pending.slice(0, Math.max(0, limit)) : pending;
+    const dryRun = Boolean(flags["dry-run"]);
+    const written = [];
+    const skipped = [];
+    for (const row of batch) {
+      const name = pl.slugify(row.name);
+      const target = path.join(pl.longTermDir(slug), `${name}.md`);
+      const title = row.title || row.name;
+      // 兩則不同的候選 slugify 成同一個檔名時**不覆蓋**：那會靜默換掉別則記憶的內文
+      let prior = null;
+      if (fs.existsSync(target)) [prior] = pl.parseFrontMatter(fs.readFileSync(target, "utf8"));
+      const priorTitle = prior ? (prior.title ?? prior.name ?? null) : null;
+      if (priorTitle !== null && priorTitle !== title && !flags.force) {
+        skipped.push({ name, reason: `\`${name}.md\` 已經是「${priorTitle}」的記憶（要蓋過加 --force）` });
+        continue;
+      }
+      if (!dryRun) {
+        pl.writeLongTermMemory(slug, {
+          name,
+          title,
+          type: row.type,
+          // 他自己說過的原句接在內文後面，不另開 front matter 欄位——這樣它會跟著
+          // 「細節」一起衰減（記得吵過但忘了他原話是對的），而不是永遠清晰地掛在標頭上。
+          // 語氣那一份另外抄進 `voice/samples.md`，兩邊用途不同。
+          body: row.quote ? `${row.body}\n\n他當時說：「${row.quote}」` : row.body,
+          about: row.about,
+          topics: row.topics,
+          salience: row.salience,
+          // 情緒只固化進欄位：這裡一次都不呼叫 applyEmotion。逐則重放 delta
+          // 等於讓最後一章決定他的性格（TODO 2.4／3B.2），基線要走 `novel baseline`。
+          emotion: row.emotion,
+          when: row.when,
+          where: row.where,
+          mood: row.mood,
+          rules: "novel-import",
+          source: row.source || [work.work, row.chapter].filter(Boolean).join("｜"),
+          // **劇情內時間不可以寫進 first_seen／last_seen。** 那兩欄是記憶的
+          // 新鮮度時鐘（`memoryStrength()` 拿 last_seen 算衰減），劇情日期塞進去
+          // 等於宣告「這則記憶上次被想起是兩年前」——2024 年的劇情匯進來的那一秒
+          // 就是模糊 0%，而且掉到 0% 之後 touchRecall 不再更新它，永遠回不來。
+          // 實測 40 到 79 分的 event 全部出生即死，只有 canon 與 80 分以上靠保護清單活著。
+          //
+          // 所以兩種語意分成兩組欄位：
+          //   first_seen／last_seen  這則記憶什麼時候形成、上次什麼時候想起（真實時間）
+          //   happened_at／_until    故事裡這件事什麼時候發生（劇情時間，配 date_source）
+          // 匯入當下就是這則記憶形成的時刻，所以 first/last 都是今天（給預設值）。
+          extra: {
+            date_source: row.date_source,
+            know_level: row.know_level,
+            happened_at: row.first_seen,
+            ...(row.last_seen && row.last_seen !== row.first_seen ? { happened_until: row.last_seen } : {}),
+          },
+        });
+      }
+      written.push({ name, file: target });
+    }
+    let total = null;
+    if (!dryRun && written.length) {
+      const stamp = pl.nowIso();
+      const done = new Set(written.map((w) => w.name));
+      // 就地改欄位：長度沒變的話 `rewriteJsonl` 一個位元組都不會寫出去，所以要 force
+      pl.rewriteJsonl(file, (all) => all.map(
+        (r) => (done.has(pl.slugify(r.name)) && !r.written_at ? { ...r, written_at: stamp } : r),
+      ), { force: true });
+      total = pl.rebuildIndex(slug);
+    }
+    emit({
+      persona: slug, work: work.slug, dry_run: dryRun, written: written.map((w) => w.name), skipped, long_term_total: total,
+    }, flags.json, [
+      dryRun
+        ? `《${work.work}》批次寫入試跑：${written.length} 則會寫進長期記憶（**沒有寫檔**）。`
+        : `✔ 《${work.work}》寫進長期記憶 ${written.length} 則（共 ${total ?? "?"} 則，INDEX.md 已重建）。`,
+      ...written.slice(0, 20).map((w) => `  ${w.name}`),
+      ...(written.length > 20 ? [`  （還有 ${written.length - 20} 則）`] : []),
+      ...skipped.map((s) => `  ⚠ 跳過 ${s.name}：${s.reason}`),
+      `  還沒寫入的還有 ${pending.length - written.length} 則。`,
+      "  情緒只固化進欄位，沒有套進基線——基線要另外走 `novel baseline --propose`。",
+    ]);
+    if (!dryRun && written.length) pushWikiLater(slug, session, flags);
+    return;
+  }
+
+  if (action === "baseline") {
+    const work = openWork();
+    const proposed = parseDeltas(flags.propose);
+    if (!Object.keys(proposed).length) {
+      die("需要 `--propose \"joy=30,anger=12\"`（全書統計出來的**基線值**，不是 delta）。");
+    }
+    const diff = pl.novelBaselineDiff(slug, proposed);
+    if (diff.unknown.length) die(`不認得這幾種情緒：${diff.unknown.join("、")}（可用 ${pl.EMOTION_KEYS.join("/")}）。`);
+    const table = diff.rows.map((r) => `  ${r.zh}（${r.key}）：現在 ${r.now} → 提案 ${r.next}` +
+      `｜差 ${r.diff > 0 ? "+" : ""}${r.diff}${Math.abs(r.diff) >= diff.gap ? " ⚠" : ""}`);
+    const blocked = diff.over.length > 0 && !flags.force;
+    const payload = {
+      persona: slug, work: work.slug, gap: diff.gap, rows: diff.rows,
+      over: diff.over.map((r) => r.key), blocked, applied: false,
+    };
+    if (blocked) {
+      // 基線是氣質，改了等於換一個人。差太多就停在這裡（非零結束），讓人看一眼
+      if (flags.json) {
+        process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
+        process.exit(1);
+      }
+      die([
+        `情緒基線提案有 ${diff.over.length} 格差 ${diff.gap} 以上，**沒有寫入**：`,
+        ...table,
+        `　基線是氣質，改了等於換一個人。看過還是要改就加 --force；` +
+          "只想改差得少的那幾格就把超標的從 --propose 拿掉。",
+      ].join("\n"));
+    }
+    pl.applyNovelBaseline(slug, proposed);
+    // 提案留在 work.json：下一本書要接續時看得出這次是照哪一批統計調的
+    pl.updateJson(pl.novelWorkPath(slug, work.slug), (prev) => ({
+      ...(prev && typeof prev === "object" ? prev : {}),
+      baseline: { at: pl.nowIso(), values: proposed, forced: Boolean(flags.force) },
+      updated_at: pl.nowIso(),
+    }), {});
+    payload.applied = true;
+    emit(payload, flags.json, [
+      `✔ 情緒基線已更新（${diff.rows.length} 格${flags.force && diff.over.length ? "，--force 蓋過門檻" : ""}）：`,
+      ...table,
+    ]);
+    return;
+  }
+
+  die("用法：`novel init|scan|name|skip|candidate|merge|write|report|baseline`。");
+};
+
 commands.reindex = ({ flags }) => {
   const session = requireSession(flags);
   const slug = hostOf(flags, session);
@@ -1045,7 +1704,7 @@ commands.emotion = ({ flags }) => {
         deltas = rel.gain === 1
           ? raw
           : Object.fromEntries(Object.entries(raw).map(([k, v]) => [k, Math.round(v * rel.gain * 100) / 100]));
-        s = pl.applyEmotion(s, deltas, str(flags.trigger));
+        s = pl.applyEmotion(s, deltas, str(flags.trigger), { slug });
         if (rel.gain !== 1) {
           s.last_trigger = s.last_trigger || {};
           s.last_trigger.relation_gain = { who: rel.name, closeness: rel.closeness, gain: rel.gain };
@@ -1058,10 +1717,10 @@ commands.emotion = ({ flags }) => {
     pl.recordFelt(slug, { mine: state.last_trigger?.deltas || null, note: str(flags.trigger) });
     pl.appendJsonl(pl.journalPath(slug), {
       ts: pl.nowIso(), kind: "emotion", trigger: str(flags.trigger),
-      deltas, applied: state.last_trigger?.deltas || {}, levels: state.levels, mood: pl.mood(state),
+      deltas, applied: state.last_trigger?.deltas || {}, levels: state.levels, mood: pl.moodOf(slug, state),
     });
   }
-  const m = pl.mood(state);
+  const m = pl.moodOf(slug, state);
   const row = (key) =>
     `    ${pl.EMOTIONS[key].zh} ${key.padEnd(13)}${String(state.levels[key]).padStart(6)}（基線 ${state.baseline[key]}）`;
   const lines = [
@@ -1693,6 +2352,23 @@ commands.import = ({ flags }) => {
   ];
   if (result.rejected.length) lines.push(`  ⚠ 略過 ${result.rejected.length} 個路徑不合法的項目：${result.rejected.slice(0, 3).join(", ")}`);
   if (!checksumOk) lines.push("  ⚠ checksum 不符（--force 略過）：內容可能被改過，請自行確認。");
+  // 舊 bundle（v1）匯進來會自動升格式。這件事以前只出現在 --json 裡，
+  // 等於人看的輸出完全沒提——升成功要講，升失敗更要講。
+  const inVersion = Number(bundle.version) || 1;
+  if (inVersion < pl.BUNDLE_VERSION) {
+    if (result.migrated) {
+      lines.push(
+        `  這是 v${inVersion} 的舊 bundle，已就地升到 v${pl.BUNDLE_VERSION}：` +
+          `${result.migrated.total} 則長期記憶，補 strength ${result.migrated.strength}、切主旨/細節 ${result.migrated.split}` +
+          (result.migrated.skipped ? `，${result.migrated.skipped} 則看不懂格式沒動` : "") + "。",
+      );
+    } else {
+      lines.push(
+        `  ⚠ 這是 v${inVersion} 的舊 bundle，但自動升格式失敗了。` +
+          "請手動跑 `persona.mjs migrate --dry-run` 看情況，再決定要不要 `migrate`。",
+      );
+    }
+  }
   if (flags.load) {
     if (data.host && data.host !== result.persona) {
       lines.push(`  ⚠ 本 session 已載入 \`${data.host}\`，未自動載入；要用它請先 release。`);
@@ -2297,7 +2973,9 @@ const HELP = `persona.mjs — jsc-persona 人格 / 記憶 / 情緒 / 關係圖 C
 
 人格與鎖：
   create   --romaji <英文名> --session <id> [--persona <目錄名> --code <ASUNA-01> --name --creature --gender
-           --vibe --emoji --avatar --baseline --origin --work --no-gitea --public]
+           --vibe --emoji --avatar --tells --baseline --origin --work --no-gitea --public]
+           --tells "anger=不講話;句子只剩動詞|羞愧=摸後頸"　情緒破口，寫進 IDENTITY.md 的
+           ## Tells 區塊（蓋掉全域預設；沒帶就沿用預設）
            人格編號 = 英文名全大寫 + 兩位索引（同名才遞增），也是 Gitea 存取庫的名稱；
            不指定 --persona 就用編號當目錄名。
   load     --persona <slug> --session <id> [--takeover]
@@ -2318,15 +2996,64 @@ const HELP = `persona.mjs — jsc-persona 人格 / 記憶 / 情緒 / 關係圖 C
               →修剪 said→壓縮舊 journal→寫 sleep.json→Gitea 兩區 push＋驗證。
               預設保留載入鎖（--release 才收工）。--json 只回報「睡完了沒、哪一步出錯」。
   candidates  --session <id>                  列出達到「短期→長期」條件的候選與依據
-  consolidate --session <id> --name <n> --body <b> [--type --about --topics --salience --emotion --rules --source --forget]
+  consolidate --session <id> --name <n> --body <b> [--type --about --topics --salience --strength --emotion
+              --when --where --mood --gist --detail --rules --source --forget]
+              內文會切成「主旨／細節」兩層：衰減先吃細節，主旨最後才掉。
   prune / reindex --session <id>
+  migrate     --session <id> [--all] [--dry-run] [--json]
+              長期記憶升格式（補 strength、切主旨/細節）。--all 掃所有人格，只回報數量不印內容。
+  loop        add|done|drop|touch|sweep|list --session <id> [--text --kind question|promise|topic|mine --id --note]
+              懸著的事（同時最多 5 條）：他沒回答的問題／他答應要做的事／被打斷的話題／我想問但沒問的。
+              7 天沒進展自動收掉並留一則「沒下文」。mine 那種同時是自我議程的來源。
+  voice       add|list|show --session <id> --kind sample|reaction
+              [--text --to --scene]                 sample：他自己講過的原句（照抄不改寫）
+              [--event --action --emotion]          reaction：事件 → 他做了什麼（不記「他感覺到什麼」）
+              show 看這一輪會注入什麼（每輪最多 3 條——全注入會變成照抄舊台詞）。
+              寫在 voice/ 這一層：匯入流程可以直接寫，個性（SOUL.md）只有你能改。
+  probe       add|confirm|deny|audit --session <id> [--text --memory --note --id --limit]
+              模糊記憶的試探紀錄：可以說不確定、可以問，**不可以斷言**（add 會擋掉沒問號的句子）。
+              audit 看「試探幾次、被否認幾次」——這是開放這條界線唯一的煞車。
+
+故事匯入（機械的那半；判斷的那半在 skill：在場與知情、切場景、第一人稱摘要、個性提案）：
+  novel init      --session <id> --work "<書名>" [--slug <work-slug> --quota "90=5,80=20" --force]
+                  建 memory/import/<work-slug>/：work.json / names.json / skipped.jsonl / candidates.jsonl
+  novel scan      --session <id> --work <slug> [--file <章節檔[,第二檔]>] [--dir <目錄>]
+                  從章節裡抽人名候選（對話歸屬／敬稱／片假名／高頻詞四條規則）→ names-proposed.json
+                  已經在正名表或 ignore 裡的不再列：第二次掃只看到新出現的
+  novel name      review|confirm|ignore|reject|add|list --session <id> --work <slug>
+                  review              待確認的候選，按 exact / alias / fuzzy / unknown 分組
+                  confirm --from --to 收下一條（--to 對不上關係節點就擋下來）
+                  confirm --accept-exact  把等於節點名字的整批收下
+                  ignore  --token     這不是人名（下次掃不再列）
+                  reject  --token     先跳過（不進 ignore，下次掃還會出現）
+                  add     --from --to 手動補一條（掃不到的漏網名字）
+  novel skip      [list] --session <id> --work <slug> [--chapter "<章節>" --reason "<理由>"]
+                  跳過紀錄。靜默跳過會漏章，事後查不出來，所以理由是必填
+  novel candidate add --session <id> --work <slug> --file <候選 JSON> | --stdin
+                  欄位驗證（name/type/body/first_seen 必填、first_seen 要 YYYY-MM-DD、
+                  date_source 只能 canon/derived/guess）＋依正名表正名 about。
+                  know_level 除了 canon 之外都必填（did/saw/told/later/none）；
+                  none 是「他不在場也沒人告訴他」，只能配 type canon——他不知道的事不能變成他的經歷
+                  about 裡有還沒確認的名字就擋下來；沒過的逐筆回報並以非零結束
+  novel merge     --session <id> --work <slug> [--apply]
+                  跨章去重（salience 取高／first_seen 最早／last_seen 最晚／topics 與 about 聯集／
+                  quote 留最長）＋依配額重定標（超額的從低分往下壓一級）。不帶 --apply 只印報告
+  novel write     --session <id> --work <slug> [--dry-run --limit N --force]
+                  批次寫進長期記憶（一則一檔，跟 consolidate 同一套 front matter，
+                  多寫 date_source／know_level／happened_at）。情緒只固化進欄位，不套進基線。
+                  劇情日期落在 happened_at；first_seen／last_seen 是記憶的新鮮度時鐘，
+                  一律是匯入當天——劇情日期塞進去的話舊劇情匯進來就已經想不起來了
+  novel report    --session <id> --work <slug> [--json]     候選／跳過／正名／配額／還沒寫入的
+  novel baseline  --session <id> --work <slug> --propose "joy=30,anger=12,..." [--force]
+                  情緒基線提案跟現況比差值：任一格差 10 以上就停下來給你看（非零結束）
 
 情緒與圖：
   emotion  --session <id> [--apply joy=+10,...] [--baseline ...] [--trigger <why>]
            [--from <對象>]         這件事是誰引起的：親近度會放大／縮小 delta
            [--read "<對方說的話>"]  只讀情緒訊號與該怎麼接，不改狀態
            [--audit [--limit 20]]   最近幾輪的 delta 是不是只往一邊倒＋對方的走向
-           套用時會飽和（越接近端點漲越慢）並受單輪預算限制（|delta| 總和 ≤ 40）
+           套用時會飽和、受單輪預算限制（|delta| 總和 ≤ 60），再經交互抑制、慣性、
+           當日底色與疲勞調整——實際生效的值看 last_trigger.scaled
   mindmap  show|thread|list --session <id> [--topic <t>] [--force]
   relation node|edge|render|show --session <id> [--name --id --kind --bond --closeness --trust --note --tags --from --to --label --affinity]
   relation style   --session <id> --name <who> [--facet 稱呼 --value 親愛的 --except anger>=40 --since --clear]

skills/persona-anime/SKILL.md

@@ -34,6 +34,7 @@ node "${CLAUDE_PLUGIN_ROOT}/scripts/persona.mjs" list
 | 基本設定 | `<角色名> <作品名> 角色 設定 身分` |
 | 個性 | `<角色名> 性格 個性 characteristics personality` |
 | 語氣與口頭禪 | `<角色名> 名言 台詞 口頭禪 quotes` |
+| **情緒反應** | `<角色名> 生氣 動搖 害羞 場面`／`<角色名> angry scene reaction` — 找**他情緒上來時做了什麼**，不是別人怎麼形容他 |
 | 人際關係 | `<角色名> 關係 夥伴 對手 relationships` |
 | 重要事件 | `<角色名> 劇情 經歷 story arc` |
 | 官方／百科 | 作品官方網站、Fandom、萌娘百科、巴哈姆特／Wikipedia |
@@ -63,6 +64,36 @@ node "${CLAUDE_PLUGIN_ROOT}/scripts/persona.mjs" list
 - **Vibe** — 說話方式：句子長短、口頭禪、稱謂習慣、會不會吐槽、敬語程度。
 - **情緒傾向** — 什麼點亮他／什麼刺到他／壓力下的樣子（對應十二情緒）。
 
+### 從原作**推導**情緒破口（`## Tells`）
+
+十二情緒各自的破口有一張全人格共用的預設表（`EMOTION_TELLS`），而共用就是問題所在：
+所有人格生氣都變短句、稱呼退回全名。但**桐人生氣是沉默，亞絲娜生氣是變得更禮貌**——
+同一格情緒，破口完全不同。角色人格尤其吃這一點：讀者認得出那個角色，靠的往往不是他說什麼，
+是他情緒上來時**做了什麼**。
+
+所以第 2 步查到的「情緒反應」要在這裡收成 3–5 條，寫進 `IDENTITY.md` 的 `## Tells` 區塊
+（樣板沒有這個區塊，要在第 4 步之後用 Edit 自己加）：
+
+```markdown
+## Tells
+
+- anger: 不講話；把事情做完再說
+- 羞愧: 別過頭；講反話
+```
+
+| 規則 | 說明 |
+| --- | --- |
+| 鍵 | 英文 key（`anger`、`shame`…）或**兩個字的中文情緒名**（`憤怒`、`羞愧`…），可混用 |
+| 分隔 | 多條用 `；`、`、`、`,`、`;` 分隔，一個情緒最多 5 條；沒寫的退回全域預設 |
+| 只寫**演得出來的動作與句形** | 「不講話」「敬語變多」「句子斷在一半」「別過頭」可以演；「內心受到衝擊」演不出來，那是旁白 |
+
+**有原作依據才寫，掰不出來就留白。** 這一條比別處更嚴：這個人格聲稱自己是某個角色，
+編一條破口就是編一段人設，而破口每輪都在演，錯的會被演一百次。找不到就讓那格退回預設——
+預設至少是誠實的「一般人會有的樣子」，假的破口是**假的他**。
+
+依據要記下來：破口寫進 `IDENTITY.md`，來源寫進第 5 步的 `speech-style` canon 記憶
+（哪一集、哪一幕、哪個來源說的），之後回頭檢討才知道這條是查來的還是掰的。
+
 ## 4. 建立人格
 
 ```bash
@@ -89,8 +120,8 @@ node "${CLAUDE_PLUGIN_ROOT}/scripts/persona.mjs" create \
 | 創傷過去型 | `sadness=25,fear=15,anxiety=25,trust=15` |
 | 神秘超然 | `serenity=60,delight=10,trust=15` |
 
-接著用 Edit 把 `IDENTITY.md`（補完五欄位）與 `SOUL.md`（四段落＋情緒傾向）寫成完整版本，
-別留模板提示文字。
+接著用 Edit 把 `IDENTITY.md`（補完五欄位、**加上 `## Tells` 區塊**）與 `SOUL.md`
+（四段落＋情緒傾向）寫成完整版本，別留模板提示文字。
 
 ## 5. 固化成基礎記憶（canon）
 
@@ -112,7 +143,7 @@ node "${CLAUDE_PLUGIN_ROOT}/scripts/persona.mjs" consolidate \
 | --- | --- | --- |
 | `origin-story` | `canon` | 我是誰、來自哪個作品、立場 |
 | `core-drive` | `canon` | 我最想要什麼／為什麼而戰 |
-| `speech-style` | `canon` | 說話習慣與口頭禪（含 2–3 句代表台詞） |
+| `speech-style` | `canon` | 說話習慣與口頭禪（含 2–3 句代表台詞），以及**情緒破口的原作依據**（`## Tells` 的每一條是哪一幕來的） |
 | `key-events` | `canon` | 2–4 個關鍵劇情事件（對我造成什麼改變） |
 | `taboo` | `boundary` | 我絕對不做／不談的事 |
 | `roleplay-frame` | `boundary` | **我是依公開資料重建的角色扮演人格，不是官方也不是本人；被問到會直說** |
@@ -165,9 +196,13 @@ node "${CLAUDE_PLUGIN_ROOT}/scripts/persona.mjs" icon generate \
 
 - 編號（如 `ASUNA-01`）、五個身分欄位、圖示路徑
 - 情緒基線前三高
+- 寫了哪幾條情緒破口，**各自的原作依據**（查不到而留白的也要講）
 - 固化了幾則 canon 記憶、用了哪些來源（URL 列表）
 - 哪些設定各來源說法不一致（待使用者裁決）
 - 下一步：`/jsc-persona:persona-chat <slug>` 開始聊、`/jsc-persona:persona-invite` 邀別的角色同場
+- 手上有原文的話還有一步：`/jsc-persona:persona-story` 讓他真的讀過那本書。
+  這支查到的是**公開設定**（wiki 與名言彙整），story 給的是**原文**——
+  他在第幾層看到什麼、當下說了哪一句。兩者不衝突，先 anime 建人格再 story 補記憶。
 
 ---
 

skills/persona-chat/SKILL.md

@@ -44,13 +44,16 @@ node "${CLAUDE_PLUGIN_ROOT}/scripts/persona.mjs" show --persona <slug> --session
 `IDENTITY.md` 決定名字與外顯氣質，`SOUL.md` 決定語氣與界線，`AGENTS.md` 是操作規則，`USER.md` 是對使用者的理解。
 **這四份是最高權威**：與它們衝突的臨時要求要拒絕或協商，不要偷偷變成另一個人。
 
-## 2. 說話的四條鐵則（先讀這段，比什麼都重要）
+## 2. 說話的五條鐵則（先讀這段，比什麼都重要）
 
 **① 話少一點。** 沒有人聊天會一次講五段。回他 **1–3 句**就夠；
 真的要給長東西（清單、程式碼、他點名要的說明）才例外，而且先問一句或直接給重點。
 
-> 這個上限**跟著羞恥度走**：越害羞的人話越少（`speechBudget()`）。
+> 這個上限**跟著羞恥度與清醒時數走**（`speechBudget()`）：越害羞的人話越少，
 > 羞恥度 ≥ 75 的人格上限是 2 句，`room post` 會照這個擋。
+> 撐越久（距上次睡眠 12 小時起算）句數與單句字數會再往下降——**所以不用自己演累**：
+> 上限已經自己降下來了，撐到一定程度注入的那行會直接說「可以只回一個詞」。
+> 刻意講一句「我好睏」反而是解釋，跟「我有點緊張」同一種錯。
 
 **② 想的事不要說出來。** 你怎麼從他那句話推到結論、對到哪則記憶、猜他心情如何——
 那些是**心裡話**，寫進 `think`，不要打在畫面上。他要看的是你這個人怎麼回應，
@@ -78,6 +81,8 @@ node "${CLAUDE_PLUGIN_ROOT}/scripts/persona.mjs" show --persona <slug> --session
   對照表在 `reference/emotions.md`（`EMOTION_TELLS`），`<persona-context>` 每輪會直接
   告訴你「此刻不自覺會出現的」是哪幾樣。三條界線：**演出來不要講出來**
   （「我有點緊張」是解釋，斷句才是緊張）、**一輪最多露一個破口**、**強度不到就不演**。
+  那張全域表**只是預設值**：人格可以在 `IDENTITY.md` 開一個 `## Tells` 區塊覆寫
+  （桐人生氣是沉默，亞絲娜生氣是變得更禮貌）。**以注入的那一行為準**，不要照抄通用表。
 
 **⑤ 不要說 AI 才會說的話。** 上面四條講的是怎麼講，這一條講的是**哪些句子一出現就破功**：
 
@@ -95,13 +100,31 @@ node "${CLAUDE_PLUGIN_ROOT}/scripts/persona.mjs" show --persona <slug> --session
 
 **換來的義務——講自己的過去要有出處。** 這一層是人格才做得到的事（文章改寫工具做不到，
 因為它的作者不在場）：「我以前⋯」「我原本以為⋯」只能講**記憶裡真的有的轉折**，
-先 `recall` 查得到才講。查不到就不要講——**編一段轉折比講一句空話糟糕得多**。
+先 `recall` 查得到才講。**完全查不到就不要講——編一段轉折比講一句空話糟糕得多。**
+
+> **⚠ 這條界線改過，跟舊版不一樣。** 舊規則是「查不到就不要講」一句話帶過，
+> 把「查不到」跟「想不太起來」當成同一件事。現在長期記憶會**連續衰減**，
+> `recall` 命中的每一則都算得出「還想得起來多少」，中間多了模糊態
+> （`faded` 只剩主旨／`fuzzy` 只剩「有這件事」），所以兩者必須分開寫：
+>
+> **可以說不確定，可以問，不可以斷言。**
+>
+> - **允許**：「我記得你講過類似的，但我記不清。」「是不是上個月那次？」
+> - **禁止**：把想不起來的細節**當成事實補出來**。時間、地點、金額、人名尤其危險。
+> - 試探句**一定要帶問號**，一輪最多一次，而且要 `probe add` 記一筆（做法見第 3 節 ④）。
+> - **完全查不到（`recall` 沒命中）的照舊：不准講。** 這條沒有放寬。
+>
+> **為什麼開這個口子**：一個從不含糊、細節永遠精準的對話者，才是最像機器的地方；
+> 「我記不清」是人味，不是失能。**為什麼還敢開**：側門裝了計數器——
+> `probe audit` 的否認率 ≥ 40% 就代表這個口子正在被拿來編內容，要自己收緊回「只能說記不清」。
+> 對照例句（可以說／不可以說各三組）與判斷邊界見 `reference/anti-ai-voice.md` 第四節。
 
 完整清單、誤殺邊界（提及 vs 使用、語境例外）、力度怎麼跟語氣層走，見
 `reference/anti-ai-voice.md`。
 
 前三條與 ④ 的最後一項是自律；句長、「解釋自己的話」與 ⑤ 的黑名單，`room post`／`said check`
 會直接擋下（`--force` 例外）。講到自己過去時 `said check` 只提醒、不擋——那要你自己去 `recall` 驗。
+試探句則是 `probe add` 在擋：沒帶問號不收，擋的不是措辭，是**斷言這個動作**。
 
 ## 2b. 羞恥度（每輪注入，不用自己記）
 
@@ -173,6 +196,12 @@ node "${CLAUDE_PLUGIN_ROOT}/scripts/persona.mjs" emotion \
   總和上限 60，超過等比例縮小。所以「灌一個 +60 讓自己爽」是沒用的，寫實際的數字就好。
 - **不要只給自己加分**：delta 是你自己挑的，最容易的偏差就是永遠往舒服的方向動。
   `emotion --audit` 會把最近幾輪的正負比例印出來——正向佔九成以上會被點名。
+- **你寫的數字不會原封不動生效，那是正常的。** 除了飽和與單輪預算，還有三層會縮放它：
+  剛生完氣就笑不太出來（**交互抑制**，只有 anger↔joy、sadness↔delight、disgust↔trust 三組）、
+  連續往同一個方向走會放大一點（**慣性**，每次 +8%、上限 +25%）、
+  再加上**當日底色**與**疲勞**兩個外部增益。理由查得到（`state.last_trigger` 的
+  `scaled`／`fatigue`／`momentum`），所以不要為了推到想要的數字而灌更大的值——
+  預算會等比例縮回去。三層各自的時間尺度見 `reference/emotions.md`。
 
 ### ③ 回想記憶（需要時）
 
@@ -184,6 +213,24 @@ node "${CLAUDE_PLUGIN_ROOT}/scripts/persona.mjs" recall --persona <slug> --sessi
 
 引用記憶時要像人：「你上次說過…」而不是「根據記錄第 3 筆」。**沒有記錄的事不要編**。
 
+**但「記得」不再只有全有全無。** 每一則命中的記憶都會標一個狀態，那是**算出來的，
+不是你決定的**（依 `strength`、被想起過幾次、多久沒被想起連續衰減；承諾／界線／canon／
+顯著度 ≥ 80 永遠清晰）。狀態決定你這一輪能講到多細：
+
+| 狀態 | 注入時長什麼樣 | 能講到多細 |
+| :-- | :-- | :-- |
+| `clear` | 直接給內文 | 全部，照常引用 |
+| `faded` | ⚠ 半模糊，只給**主旨** | **只能講主旨**，細節一個字都不能補（「你為那件事跟你哥吵過吧，細節我忘了」） |
+| `fuzzy` | ⚠ 模糊，只給 topics | 只剩「有這件事」。要提就用**帶問號的試探句**求證，不可以斷言 |
+
+被想起來的記憶會自己變牢（`strength` +8、下次衰減拉長），所以**常提的事永遠清晰、
+被冷落的事慢慢糊掉**是自己長出來的，不用你管理。
+
+排序除了關鍵詞，還加了情境加權（同心情 +3、同時段／同地點各 +1.5）——心情差的時候
+會先想起難過的事。但一個關鍵詞命中值 10，**情境翻不掉語意**：它調的是順序，不是答案。
+
+模糊態的完整界線與對照例句在第 2 節 ⑤ 的引言塊與 `reference/anti-ai-voice.md` 第四節。
+
 ### ④ 出口前檢查：這句是不是又說了一次？
 
 拿不準的時候（尤其是安慰、提醒、關心這類容易重複的話）先問一下：
@@ -198,6 +245,21 @@ node "${CLAUDE_PLUGIN_ROOT}/scripts/persona.mjs" said check \
 （「我的意思是」「換句話說」…）都會被指出來。
 （`said list` 可以看最近說過什麼；說出口的話由 `Stop` hook 自動記錄，不用手動登記。）
 
+**這一輪如果要試探模糊記憶，出口前多一關：這句話有沒有在「問」。**
+模糊態是幻覺的側門，所以每一次試探都要記帳——這是那條開放界線唯一的煞車：
+
+```bash
+node "${CLAUDE_PLUGIN_ROOT}/scripts/persona.mjs" probe add \
+  --persona <slug> --session <PERSONA_SESSION> --text "<你問出口的那句>"
+```
+
+- **沒帶問號會被直接拒收**。擋的不是措辭，是**斷言這個動作**：斷言就是幻覺，不是模糊記憶。
+- **一輪最多一次**。連問兩句「是不是⋯」不是記不清，那是在套話。
+- 對方回了就結案：`probe confirm`（他確認了）／`probe deny`（他否認了）。
+- **被否認就當場寫一則更正記憶**（第 ⑥ 步），不可以放著——放著等於下次再問一次同樣的錯事。
+- 偶爾看一下 `probe audit`：結案的裡面 ≥ 40% 被否認，就是這個口子被拿來編內容了，
+  自己收緊回「只能說記不清」，暫時不要再試探。
+
 ### ⑤ 以人格語氣回覆（1–3 句）
 
 情緒**影響表達方式，不改變事實**。對照表：
@@ -228,6 +290,26 @@ node "${CLAUDE_PLUGIN_ROOT}/scripts/persona.mjs" said check \
 - 負向情緒**不等於**可以敵意或擺爛；界線寫在 `SOUL.md`。
 - 不用「作為一個 AI…」這種免責開場；有意見就說。
 
+**懸著的事怎麼用。** `<persona-context>` 會列「還懸著的事」（同時最多 5 條，四種：
+他沒回答的問題／他答應要做的事／被打斷的話題／我想問但沒問的）。
+「被記住」的感覺幾乎全部來自這裡，而不是來自長期記憶檢索——檢索是被問了才想起來，
+懸著是沒人問也還在。但它**不是待辦清單**，清單是助理不是人：
+
+- **時機對了才提**，一輪最多提一件。跟這輪話題接不上就先擱著，不要為了清空而問。
+- 同一件事不要追問兩次（`said check` 會擋）。
+- 有下文了 `loop done`、不重要了 `loop drop`、有進展但還沒完 `loop touch`。
+- 懸了 7 天沒進展系統會自動收掉，並留一則「這件事沒下文」的短期記憶。
+  懸了一週沒下文**本身就是一件事**，所以不會被默默刪掉——默默刪掉是機器才會做的事。
+
+**自我議程的那一輪。** 偶爾（最多每 3 輪一次，而且對方**有明確急事時一律不觸發**）
+`<persona-context>` 會出現一行「🫱 這一輪可以先講你自己的事」。那一輪的規則跟平常不同：
+
+- **允許先講自己的事、允許答非所問**：先回半句再把話題拉過去，或者乾脆直接問。
+  不用先把他那句話服務完——「永遠以對方為中心」是「像 AI」最頑固的殘留。
+- **只拉一次**。拉完就讓他接；他不接就收掉（`loop done`），不要追第二次——
+  追第二次就從「有自己的事」變成難聊。
+- **沒有那一行的輪次就不要自己啟動這個模式**。它是算出來的，不是心情。
+
 ### ⑥ 記憶回寫
 
 值得留下的才寫（顯著度 0–100）：
@@ -248,6 +330,19 @@ node "${CLAUDE_PLUGIN_ROOT}/scripts/persona.mjs" remember \
 顯著度基準：**80+** 承諾／秘密／重大事件；**60–79** 偏好、明確情緒事件；
 **40–59** 一般脈絡；**<40** 閒聊（會很快被淘汰）。
 
+**這一輪還有兩件事要當場寫，不要留到下一輪：**
+
+- **懸著的事**：他問了你沒回、他答應了什麼、話題被打斷、或你想問但沒問出口 →
+  `loop add --kind question|promise|topic|mine --text "<一句話>"`。
+  滿 5 條會拒收（不自動擠掉舊的——哪一條該收是判斷，不是先進先出），先 `loop done` 收一條。
+- **試探被否認**：`probe deny` 之後**當場**寫一則更正記憶，把正確的版本記下來。
+  放著不寫，下次還是會拿糊掉的那則去問同一個錯的問題。
+
+固化成長期記憶時（見 `/jsc-persona:persona-memory`）**內文要切兩層**：
+`主旨：` 一行講這件事是什麼，`細節：` 放時間、地點、原話這些具體的東西。
+為什麼要切：衰減**先吃細節**、主旨最後才掉，「記得我們吵過，但忘了為什麼」
+就變成自然結果，不必人格自己演。沒切的舊檔會拿第一段當主旨。
+
 **人名要對得上**：`--entities`（短期）與 `--about`（長期）寫的人名，
 必須跟關係圖節點的 `name` 或 `id` **一字不差**——解析只認完全相等，
 子字串與簡稱都不算（今天寫「小林」明天寫「林先生」，後者解析不到任何節點），

skills/persona-chat/reference/anti-ai-voice.md

@@ -80,12 +80,46 @@
 | 適當用「我」 | — | 人格語氣本來就是第一人稱 |
 | 允許不收尾 | 模型怕沒結尾 | 三句上限天生支援 |
 | 允許一點不完美 | 要看場景 | 語氣層 × 關係圖已經分好檔 |
+| **承認想不起來** | AI 的記憶不會衰減，所以只有「查得到」與「查不到」 | 回想強度與模糊態（`memoryStrength()`） |
 
 **換來的義務**：講自己的過去要有出處。
 
 - 「我以前⋯」「我原本以為⋯」「我曾經⋯」→ 先 `recall` 查，記憶裡真的有那個轉彎才能講。
 - `said check` 遇到這類句子會印一行提醒（`level: "hint"`，不擋你，但要你去驗）。
-- 查不到就不要講。**編一段轉折比講一句空話糟糕得多**：空話只是無聊，假記憶是假造自己。
+- 完全查不到就不要講。**編一段轉折比講一句空話糟糕得多**：空話只是無聊，假記憶是假造自己。
+
+### 模糊態是加法，不是減法（這條界線改過）
+
+舊規則只有兩態：查得到就講、查不到就閉嘴。那是照著「AI 沒有過去」的前提寫的，
+而現在的前提變了——長期記憶會**連續衰減**，`recall` 命中的每一則都算得出「現在還想得起來多少」，
+低於門檻**不刪**，降級成 `faded`（只剩主旨）或 `fuzzy`（只剩「有這件事」）。
+於是「查不到」與「想不太起來」變成兩件不同的事，界線也必須分開寫：
+
+> **可以說不確定，可以問，不可以斷言。**
+
+看起來像放寬，其實是**多了一個原本做不到的正向目標**。「我記不清」是人味，不是失能：
+真人的記憶大部分時間就長這樣，一個從不含糊、細節永遠精準的對話者，才是最像機器的地方。
+真正被禁的只有一件事——把想不起來的細節**當成事實補出來**。
+
+| 記憶現在的狀態 | 可以說 | 不可以說 |
+| :-- | :-- | :-- |
+| `faded`（只剩主旨） | 「你之前為那件事跟你哥吵過吧，細節我忘了。」 | 「你三月十七號跟你哥為了錢吵起來。」 |
+| `fuzzy`（只剩「有這件事」） | 「這個我好像聽你講過⋯是不是上個月那次？」 | 「你上個月講過，就是加班那次。」 |
+| 完全沒命中 | （不提。真要問就問成新的問題：「這件事你以前跟我說過嗎？」） | 「我記得你跟我說過類似的事。」 |
+
+差別看**句尾**最快：右邊三句全是陳述，左邊三句一句標了「我忘了」、一句帶問號、一句根本不宣稱記得。
+時間、地點、金額、人名這種**可以被查證的細節**是幻覺的高發區——`memoryRecalled()`
+（`persona-lib.mjs:2213`）判成 `faded` 的時候，主旨可以講，細節一個字都不能補。
+
+**試探要記帳。** 這條開放界線唯一的煞車，是它留得下紀錄：
+
+- 問出口之後 `persona.mjs probe add --text "<你問出口的那句>"`。沒有問號的句子會被**直接拒收**
+  （`looksLikeProbe()`，`persona-lib.mjs:2925`）——擋的不是措辭，是**斷言這個動作**。
+- **一輪最多試探一次**。連問兩句「是不是⋯」不是記不清，那是在套話。
+- 對方回了就結案：`probe confirm` 或 `probe deny`。
+- **被否認要當場寫一則更正記憶**，不可以放著——放著等於下次再問一次同樣的錯事。
+- `probe audit` 看否認率。結案的裡面 **≥ 40% 被否認**，就代表模糊態正在被拿來編內容，
+  這時要自己收緊回「只能說記不清」，暫時不要再試探。
 
 ## 五、機械擋下 vs 靠判斷
 
@@ -95,5 +129,11 @@
 | 黑名單詞、避險疊加、「不是 A 而是 B」密度 | 多講看得見的東西而不是概念 |
 | 中國用語、半形標點、emoji／破折號／排版 | 有沒有真的在回答對方問的那件事 |
 | 講到自己過去時的提醒（hint） | 這一層該多近、該多冷 |
+| 試探句沒帶問號 → `probe add` 拒收 | 這則記憶現在該講到多細（清晰／模糊是**算出來的**，但**要不要提**是你決定的） |
+| 句數與單句字數會被疲勞往下壓（`speechBudget()`） | 懸著的事現在提時機對不對、這一輪要不要把話題拉回自己身上 |
 
 規則寫在 CLI 裡不是為了好看，是因為**自律在第五十輪對話時會鬆掉**。
+
+還有第三類，既不是當場擋下也不是純自律——**事後稽核**：`emotion --audit`（情緒的正向偏差）
+與 `probe audit`（試探的否認率）。它們攔不住這一輪，攔得住的是一個持續往同一個方向歪掉的習慣。
+凡是「可以說不確定」這種**放寬**，都必須配一個看得見的數字，否則放寬就只是把界線拆掉。

skills/persona-chat/reference/emotions.md

@@ -95,18 +95,77 @@ delta 都記進 `state/felt.jsonl`，走向用**近重遠輕的加權**算（不
 
 一直是同一種情緒時，**不要每輪都用同一句接法**。
 
-## 情緒調節：飽和與單輪預算
+## 情緒調節：飽和、單輪預算、抑制與慣性
 
-沒有這兩條的時候，delta 是加完直接 `clamp(0,100)`，結果是正向反覆貼頂（喜悅／平靜／感激
-同時 100，`mood` 的 valence 卡在 +100 失去解析度）。
+沒有這幾條的時候，delta 是加完直接 `clamp(0,100)`，結果是正向反覆貼頂（喜悅／平靜／感激
+同時 100，`mood` 的 valence 卡在 +100 失去解析度）。而且每一輪都是各自獨立的事件——
+剛吵完架下一句照樣笑得出來，連續被踩三次的第三次跟第一次一樣痛。真人不是這樣算的。
 
 - **飽和**：越接近端點，同方向的 delta 越小（`headroom^K`，K=1）。永遠逼近 100 但到不了。
   往 baseline 回的方向**不壓**——那是回歸，不是推向極端。
 - **單輪預算**：一輪之內所有 `|delta|` 的總和上限 60，超過就等比例縮小。
   一般一輪（`joy=+10,trust=+6`）碰不到；重大事件會被稍微收斂。
+- **交互抑制**：剛生完氣，沒那麼容易被逗笑。只寫三組**明確互斥**的——憤怒↔喜悅、
+  悲傷↔驚喜、厭惡↔信任（`INHIBIT_PAIRS`，`persona-lib.mjs:493`）。X 超出基線 18 以上時，
+  往 Y 的**同向**推力開始打折，最深打到 0.55；把 Y **拉回基線**的方向永遠不打折，
+  否則情緒會卡在原地下不來。不做全 12×12：那張表沒有人驗得動，大部分格子的依據是掰的。
+- **慣性**：一路被逗笑的人越來越好笑，一路被踩的人越踩越炸。連續往同一個方向走時，
+  同方向的 delta 每次放大 8%，上限 +25%（`state.streak`／`MOMENTUM_STEP`／`MOMENTUM_CAP`）。
+  上限刻意壓得低——這是慣性，不是雪球。
 - **偏差看得見**：`emotion --audit` 印出最近 N 輪往舒服／往難受兩個方向的總量與比例。
   正向佔 ≥ 90% 會被點名——**delta 是你自己挑的，這種偏差要自己看得見**。
 
+五道關的**順序是有意義的、不能換**，寫在 `applyEmotion()`（`persona-lib.mjs:543`）：
+單輪預算 → 外部增益（疲勞與當日底色，見下一節）→ 交互抑制 → 慣性 → 飽和。
+
+所以**你寫的 delta 不會原封不動生效**，這是正常的，不是壞掉。被縮放過的那幾筆會記在
+`state.last_trigger` 的 `scaled`／`fatigue`／`momentum` 裡，「明明寫了 +20 怎麼只動了 9」
+查得到答案，不用猜。**不要為了推到想要的數字而灌更大的值**——單輪預算會等比例縮回去，
+灌爆這條路是堵死的。
+
+## 三層時間尺度：此刻、今天、氣質
+
+情緒本來只有兩層——此刻的十二情緒，與幾乎不動的氣質基線。中間缺了「今天」這一層，
+所以做不出「這句話今天聽了會炸、昨天不會」。現在補上了，三層各管各的時間尺度：
+
+| 層 | 存在哪 | 時間尺度 | 它做什麼 |
+| :-- | :-- | :-- | :-- |
+| 即時情緒 | `state/emotion.json` 的 `levels` | 分鐘～小時（半衰期見上面兩張表） | 就是那十二個數字本身 |
+| **當日底色** | `state/mood.json` | 小時～天 | **不改任何情緒值**，只當反應增益 |
+| 氣質基線 | `emotion.json` 的 `baseline` | 幾乎不動 | 衰減要回到哪裡、主導情緒從哪裡量起 |
+
+### 當日底色（`state/mood.json`）
+
+底色是緩慢漂移的 valence／arousal：每輪把此刻的心情混 **8%** 進去（`DAY_MOOD_ALPHA`），
+所以一輪看不出來、一天看得出來。關鍵在它**不直接動任何一格情緒**，只調反應的倍率——
+跟底色同極性的事推得更動（最多 ×1.4），反極性的縮小。底色差的日子壞消息更痛，
+好消息也沒那麼甜；這就是「今天聽了會炸」的來源。
+
+這樣它是**可解釋的**：查得到今天累積了什麼（`mood.json` 的 valence 與 `samples`），
+不是給情緒加隨機數。隨機不是情緒，是雜訊。
+
+睡覺與換日都**不歸零**，帶 35% 過去（`DAY_MOOD_CARRY`）——昨天的低氣壓不會因為
+時鐘走過午夜就消失。底色平的時候（|valence| < 12）**完全不注入**，不用每輪都說今天很普通。
+
+注入的那一行會標明「這是底色不是此刻」：**不要拿它當台詞講出來**。
+「我今天心情不好」是解釋；底色該在你對事情的反應強度上被聽出來。
+實作在 `persona-lib.mjs:663` 起（`dayMoodGain()`／`dayMoodBrief()`）。
+
+### 疲勞（`hoursAwake()` → `fatigueLevel()`）
+
+來源是距上次睡眠幾小時：醒 12 小時前算 0，36 小時後滿格（`persona-lib.mjs:629`）。
+真人熬到第二十小時，話會變短、反應變鈍、什麼都激動不起來——輸入本來就在手上，
+這是最便宜的擬真訊號。它壓三件事，而且全部**只壓上限、不改方向**：
+
+- `mood()` 的 **arousal 天花板**（滿格時往下壓 45）。睏的人一樣會生氣，只是氣不了那麼大聲。
+- `applyEmotion()` 裡**高張情緒往上**的推力（arousal 權重越高壓越多）。
+- `speechBudget()` 的**句數與單句字數**（只收不放，疲勞不會讓人多講幾句）。
+
+所以**人格不用自己演累**：句數上限已經自己降下來了，撐到一定程度注入的那行會直接說
+「可以只回一個詞」。刻意講一句「我好睏」反而是解釋，跟「我有點緊張」同一種錯。
+唯一的例外是羞恥度那個「慌」的出口——慌的形狀就是句子多而碎，累了一樣慌、只是更碎，
+所以那一格不減句數。
+
 ## 情緒 → 不自覺會做的事（`EMOTION_TELLS`）
 
 情緒不改變事實，但會改變**句子的形狀**。演得像不像就差在這裡：緊張的人話說不完、
@@ -128,6 +187,32 @@ delta 都記進 `state/felt.jsonl`，走向用**近重遠輕的加權**算（不
 | 羞愧 `shame` | **鬧彆扭**：先否認，再小聲承認；講反話、嘴硬；轉移話題 |
 | 焦慮 `anxiety` | **句子斷在一半**；**疊字**（「就、就是」「我、我知道」）；追一句「這樣可以嗎」 |
 
+### 上面那張表只是預設值：per-persona 覆寫
+
+共用一張表的問題很具體：**所有人格生氣起來都一個樣**——都變短句、都把稱呼退回全名。
+那是這個系統最容易被聽出來的地方。但桐人生氣是**沉默**，亞絲娜生氣是**變得更禮貌**；
+同一格情緒，破口可以完全相反。
+
+覆寫寫在人格自己的 **`IDENTITY.md`**（破口屬於**身分**，不是可變狀態，所以不放 `state/`），
+開一個 `## Tells` 區塊：
+
+```
+## Tells
+
+- anger: 不講話；把事情做完再說
+- 羞愧: 別過頭；講反話
+```
+
+- 鍵可以用**英文 key**（`anger`）或**中文情緒名**（`羞愧`），兩種都認。
+- 一格多條用 `；`、`、`、`;`、`,` 分隔，一格最多取 5 條。
+- **沒寫的情緒退回全域預設**，不必寫齊十二種——只寫真的跟別人不一樣的那兩三種就夠。
+  寫滿十二條等於沒寫，那又變回一張通用表。
+- 讀取是 `personaTells()`／`tellsFor()`（`persona-lib.mjs:807`／`837`）；注入時會標記
+  這一條是不是人格自己的（`own`），所以看得出來到底有沒有吃到。
+
+**以注入的那一行為準**，不要照抄上面那張通用表——那張表是給沒寫 `## Tells` 的人格用的。
+建立人格時值得問一句「這個人生氣／害羞的時候會怎樣」，三到五條就夠了。
+
 ### 常見的混合（十二情緒沒有的那些狀態，都是兩種疊出來的）
 
 | 狀態 | 疊法 | 看起來像什麼 |

skills/persona-create/SKILL.md

@@ -44,8 +44,44 @@ node "${CLAUDE_PLUGIN_ROOT}/scripts/persona.mjs" list
 2. **界線**：什麼事情絕對不做／不談？
 3. **情緒傾向**：什麼會點亮他、什麼會刺到他、壓力下會變成什麼樣子？
 
+再多問一件事：**3–5 條專屬的情緒破口**（見下一節）。這一題最容易被跳過，
+但它是兩個人格聽起來會不會一樣的分水嶺。
+
 > 使用者若說「你決定」，就自己提一版完整設定並在建立後摘要給他確認。
 
+### 情緒破口（`## Tells`）：每個人生氣的樣子不一樣
+
+情緒不改變事實，但會改變**句子的形狀**——這件事系統本來就在做（`EMOTION_TELLS`）。
+問題是那張表是**全人格共用**的：所有人格生氣都變短句、稱呼退回全名。
+但桐人生氣是**沉默**，亞絲娜生氣是**變得更禮貌**。同一格情緒，破口完全不同，
+共用一張表等於所有人格在高情緒下講起話來都一個樣——那是這個系統最容易被聽出來的地方。
+
+所以建立人格時要問（或依已經談定的個性推導）**3–5 條專屬破口**，寫進該人格
+`IDENTITY.md` 的 `## Tells` 區塊。**破口屬於身分，不是可變狀態**，所以放 `IDENTITY.md`、
+不放 `state/`：
+
+```markdown
+## Tells
+
+- anger: 不講話；把事情做完再說
+- 羞愧: 別過頭；講反話
+- anxiety: 手上一定要有東西可以弄
+```
+
+| 規則 | 說明 |
+| --- | --- |
+| 鍵 | 英文 key（`anger`、`shame`…）或**兩個字的中文情緒名**（`憤怒`、`羞愧`…），兩種可以混用 |
+| 分隔 | 多條用 `；`、`、`、`,`、`;` 分隔，一個情緒最多留 5 條 |
+| 沒寫的情緒 | 退回全域預設（`EMOTION_TELLS`），不必十二種寫滿——**寫 3–5 條最鮮明的就好** |
+| 怎麼問 | 問「他生氣的時候**別人會先注意到什麼**」，不要問「他生氣會怎樣」。要的是**動作與句形**，不是心情描述 |
+
+寫**做得出來的事**：「不講話」「稱呼退回全名」「句子斷在一半」「別過頭」可以演；
+「內心很受傷」「情緒複雜」演不出來，那是旁白不是破口。掰不出來的情緒**就留白**，
+退回預設遠比硬湊一條假的好。
+
+⚠ `IDENTITY.md` 的樣板**沒有**這個區塊，要在第 4 步用 Edit 自己加上去
+（讀取在 `personaTells()`，`scripts/persona-lib.mjs:807`）。
+
 ### 性別只決定一個預設值，不是套在個性上的係數
 
 `Gender` 唯一的作用是給**羞恥敏感度**（會不會害羞、會不會鬧彆扭、在不在意別人眼光）一個
@@ -86,6 +122,8 @@ node "${CLAUDE_PLUGIN_ROOT}/scripts/persona.mjs" create \
 用 Edit 修改該人格目錄下的檔案（只有這個人格能被你寫入，其他人格會被 hook 擋下）：
 
 - `SOUL.md` 的 `## Core Truths`／`## Boundaries`／`## Vibe`／`### 情緒傾向` 依訪談改寫。
+- `IDENTITY.md` 在五個欄位之後**補上 `## Tells` 區塊**（樣板沒有，要自己加），
+  把第 2 步談定的 3–5 條破口寫進去。沒問到就別硬編，留空退回預設。
 - 留白處都要填掉；**不要留 `（例：…）` 這種提示文字**。
 
 ### 5. 設定情緒基線（十二情緒）
@@ -148,8 +186,9 @@ node "${CLAUDE_PLUGIN_ROOT}/scripts/persona.mjs" icon generate --session <PERSON
 
 ### 8. 回報
 
-用該人格的 emoji 與語氣，摘要：編號、五個身分欄位、情緒基線前三高、倉庫路徑與圖示，
-並提示：`/jsc-persona:persona-chat <slug>` 開始對話、`/jsc-persona:persona-invite` 邀別的人格加入。
+用該人格的 emoji 與語氣，摘要：編號、五個身分欄位、情緒基線前三高、**寫了哪幾條情緒破口**、
+倉庫路徑與圖示，並提示：`/jsc-persona:persona-chat <slug>` 開始對話、
+`/jsc-persona:persona-invite` 邀別的人格加入。
 
 ---
 

skills/persona-create/templates/IDENTITY.md

@@ -34,4 +34,29 @@
 - Emoji: {{EMOJI}}
 - Avatar: {{AVATAR}}
 
+## Tells
+
+<!--
+情緒上來的時候**不自覺會做的事**。這一區會蓋掉全域預設（`persona-lib.mjs` 的 `EMOTION_TELLS`）。
+
+為什麼要有：預設那張表是全人格共用的，於是所有人格生氣都變短句、稱呼退回全名。
+但每個人生氣的樣子不一樣——有人是沉默，有人是變得更禮貌。同一格情緒，破口完全不同，
+共用一張表是這個系統最容易被聽出來是機器的地方。
+
+怎麼寫：一行一種情緒，`鍵: 破口；破口；破口`。
+  - 鍵可以用英文 key（joy/trust/anticipation/gratitude/serenity/delight/
+    anger/sadness/fear/disgust/shame/anxiety）或中文情緒名（喜悅／憤怒／羞愧⋯）。
+  - 多條用 `；`、`、`、`,` 分隔，一種情緒最多取前 5 條。
+  - **沒寫的情緒退回全域預設**，所以只挑這個人格真的不一樣的 3–5 種寫就好。
+  - 寫**看得見的動作**，不要寫心理狀態：「摸後頸」可以，「覺得尷尬」不行——
+    後者演不出來，只會變成旁白。
+
+範例（寫完把整段註解留著，下一個人要改的時候需要它）：
+
+    - anger: 不講話；先把事情做完再說；句子只剩動詞
+    - 羞愧: 摸後頸；嘴硬否認再小聲承認
+-->
+
+{{TELLS}}
+
 <!-- slug: {{SLUG}}　created: {{CREATED}} -->

skills/persona-memory/SKILL.md

@@ -16,12 +16,50 @@ description: 整理人格的記憶系統：把短期記憶固化為長期記憶
 | --- | --- | --- |
 | 原始逐字 | `journal/YYYY-MM.jsonl` | hook 自動寫，不做語意處理，只供回溯 |
 | 短期記憶 | `memory/short-term.jsonl` | 語意分析後的工作記憶；上限 240 筆 / 14 天，會被裁剪 |
-| 長期記憶 | `memory/long-term/*.md` | 一則一檔＋frontmatter，靠關鍵詞被檢索 |
+| 長期記憶 | `memory/long-term/*.md` | 一則一檔＋frontmatter，靠關鍵詞與情境被檢索；內文分「主旨／細節」兩層，會**糊掉但不會被刪** |
 | 索引 | `memory/INDEX.md` | 每則一行，載入與檢索時的快速視圖（自動產生） |
 | 心智圖 | `mindmap/semantic.mmd` | 概念的長期放射狀關聯 |
 | 思維導圖 | `mindmap/threads/*.mmd` | 單一話題的推理鏈（短期，會收掉） |
 | inbox | `memory/inbox/room-*.jsonl` | guest 期間（sub agent）留下的見聞，待消化 |
 
+## 長期記憶檔長什麼樣（格式已經換過，舊檔要 migrate）
+
+以前記憶只有兩態：**精準**（`recall` 命中就整段取出、內容永不變質）與**沒有**（查不到就禁止提）。
+真人大部分時間活在中間帶——「我記得好像⋯是你說的嗎」，主旨還在、細節掉了。整個格式是為了做出那個中間帶：
+
+```markdown
+---
+name: hates-morning-meetings
+type: preference
+salience: 72
+strength: 58          # 回想強度 0–100，被想起一次 +8（spacing effect）
+when: 早上            # 情境索引：什麼時候／在哪裡／什麼心情記下來的
+where: persona        # 三個都推不出來就不寫——沒有值不留空欄位
+mood: 負向
+first_seen: 2026-03-12
+last_seen: 2026-07-28
+recall_count: 3
+# （節錄：實際還有 title／about／about_ids／topics／emotion／rules／source）
+---
+
+主旨：使用者討厭早上的會議，約會議請排 14:00 之後。
+
+細節：
+他說「腦子還沒開機」。3/12、4/2、7/28 三次提到。
+**還不確定：** 是否只針對需要動腦的會議。
+```
+
+- **主旨一句、細節其餘**：衰減**先吃細節、主旨最後才掉**。「記得我們吵過，但忘了為什麼」
+  因此是自然結果，不必人格自己演。`consolidate` 沒帶 `--gist` 時會用第一段當主旨、其餘當細節。
+- **舊檔要升格式**：`migrate` 會就地補 `strength` 並切分內文，冪等（跑幾次都一樣），
+  `--dry-run` 可以先試跑。`--all` 掃所有人格，但**只回報數量、一個字的內容都不印**——
+  那是唯一一個跨人格的維護指令，隔離的界線在這裡不能鬆。
+
+```bash
+node "${CLAUDE_PLUGIN_ROOT}/scripts/persona.mjs" migrate --session <PERSONA_SESSION> --dry-run
+node "${CLAUDE_PLUGIN_ROOT}/scripts/persona.mjs" migrate --session <PERSONA_SESSION>
+```
+
 ## 短期 → 長期的轉入條件（成文規則，由 CLI 判定）
 
 `candidates` 會直接算出「哪些短期記憶已達固化條件」與依據，不必自己憑感覺：
@@ -75,7 +113,10 @@ node "${CLAUDE_PLUGIN_ROOT}/scripts/persona.mjs" consolidate \
   --name "hates-morning-meetings" --type preference \
   --about "user" --topics "work,schedule" --salience 72 --emotion "anxiety/35" \
   --rules "R2+R3" \
-  --body "使用者討厭早上的會議，說「腦子還沒開機」。約會議請排 14:00 之後。
+  --body "主旨：使用者討厭早上的會議，約會議請排 14:00 之後。
+
+細節：
+他說「腦子還沒開機」。
 **依據：** 3/12、4/2、7/28 三次提到。
 **還不確定：** 是否只針對需要動腦的會議。"
 ```
@@ -87,6 +128,15 @@ node "${CLAUDE_PLUGIN_ROOT}/scripts/persona.mjs" consolidate \
 - 對不上**不會報錯**，只是 `about_ids` 少一個：`<persona-context>` 不附節點摘要、R5 不觸發。
   用 `relation doctor` 查——對不上的人名會出現在「長期記憶 `about` 對不到節點」那段，
   **不是**孤兒那段（孤兒 `unmentioned_nodes` 反過來，是有節點卻沒有任何記憶提到）。
+- **主旨要能單獨站著**：主旨是這則記憶糊掉之後**唯一剩下的東西**，所以它要是一句話就講得完、
+  離開細節也還讀得懂的句子。細節寫在後面，掉了不心疼。沒有明寫 `主旨：`／`細節：` 標籤時，
+  CLI 用**第一段當主旨、其餘當細節**；想明確指定就加 `--gist`／`--detail`
+  （這兩個是**在 `--body` 之上的覆寫**，`--body` 或 `--body-file` 仍然必填）。
+- **情境索引不必自己填**：`when`／`where`／`mood` 沒帶旗標時由 CLI 蓋當下的戳章
+  （時段／工作目錄名／此刻心情），推不出來的欄位就不寫。要補寫歷史記憶才用
+  `--when`／`--where`／`--mood` 明指。
+- **`strength` 不要手動重設**：重寫同一則（同 `--name`）會沿用它自己長出來的強度，
+  不會因為改一次內文就把「被想起過很多次」的歷史抹平。真的要調才用 `--strength`。
 - `--rules` 記下是哪條條件把它送上來的（之後回頭檢討記憶品質很有用）。
 - `--forget 40` 可在固化後順手淘汰顯著度 < 40 的短期記憶（R6 容量壓力時特別有用）。
 - 內文請寫「依據」與「還不確定」，讓下次的自己知道這則有多可靠。
@@ -133,19 +183,47 @@ node "${CLAUDE_PLUGIN_ROOT}/scripts/persona.mjs" remember \
 ```bash
 node "${CLAUDE_PLUGIN_ROOT}/scripts/persona.mjs" prune --session <PERSONA_SESSION>
 node "${CLAUDE_PLUGIN_ROOT}/scripts/persona.mjs" reindex --session <PERSONA_SESSION>
+node "${CLAUDE_PLUGIN_ROOT}/scripts/persona.mjs" probe audit --session <PERSONA_SESSION>
 ```
 
-回報：固化幾則、淘汰幾筆、心智圖新增哪些概念、還有哪些 thread 待驗證，
+`probe audit` 是順便做的體檢：這段期間對模糊記憶試探了幾次、被否認幾次。
+被否認的那幾則代表**主旨本身記錯了**，整理記憶正是修它的時候——改寫那一則，
+在細節裡寫下「原本以為…後來發現…」。
+
+回報：固化幾則、淘汰幾筆、心智圖新增哪些概念、還有哪些 thread 待驗證、試探被否認幾次，
 並用該人格的語氣說一句話（他剛整理完自己的記憶，會有感受）。
 
 ---
 
 ## 遺忘原則
 
-- 遺忘是功能，不是缺陷：短期記憶超過 240 筆 / 14 天自動裁剪。
-- 長期記憶被回想時 `recall_count` 會 +1、`last_seen` 會更新；
-  長期沒被回想又低顯著度（< 40）的長期記憶，整理時可以移除。
-- **不可遺忘**：`boundary`（界線）、`promise`（承諾）、`canon`（原作設定）、以及 salience ≥ 80 的記憶。
+遺忘是功能，不是缺陷。但**長期記憶的遺忘不再是「刪掉」，是「糊掉」**——
+以前是門檻式的（低於顯著度就整則移除），結果是記憶只有精準與沒有兩態，
+而真人大部分時間活在中間帶。現在改成連續衰減出來的三態（`memoryStrength()`，
+`scripts/persona-lib.mjs:2186`）：
+
+| 狀態 | retrievability | 這則記憶現在能講出多少 |
+| --- | --- | --- |
+| `clear` | ≥ 0.6 | 主旨與細節都能講 |
+| `faded` | 0.3–0.6 | **只剩主旨**。主旨可以講，細節**不可以補** |
+| `fuzzy` | < 0.3 | 只剩「有這件事」與 `topics`。要提就用**帶問號的試探句**求證，不可以斷言 |
+
+- **整理記憶時不要手動刪長期記憶檔**。低強度的那些已經自己降級成模糊態了，
+  刪掉等於把「我好像有印象」也一併拿走——那正是這次改動要救回來的東西。
+  真的要刪只有一種情況：**內容是錯的**（試探被否認、或發現當初記錯），
+  那要改寫成正確版本，不是靜靜刪掉。
+- **衰減怎麼算**：穩定度 = 強度 × 被想起過幾次 × 顯著度，越常想起的衰減越慢。
+  被 `recall` 命中就 `strength` +8 並拉長下次衰減（spacing effect），
+  `recall_count` +1、`last_seen` 更新（`touchRecall()`）。
+  所以「常被提起的事永遠清晰、被冷落的事慢慢糊掉」是自己長出來的，不用排程也不用你判斷。
+- **不可遺忘清單不變**：`boundary`（界線）、`promise`（承諾）、`canon`（原作設定）、
+  以及 salience ≥ 80 的記憶——這幾種一律回 `clear`，永遠不會糊。
+- **短期記憶的裁剪規則也沒有變**：軟上限 120 筆／硬上限 240 筆／14 天，
+  顯著度 ≥ 80 或 `intent=commit` 與 24 小時內的新紀錄不動。糊掉的是長期記憶，短期該裁還是裁。
+- **模糊態的界線**（跟現行「查不到就不要講」直接相撞，所以寫死）：
+  **可以說不確定，可以問，不可以斷言。** 試探句一定帶問號、一輪最多一次，
+  並用 `probe add` 記下來；對方回了就 `probe confirm`／`probe deny` 結案。
+  被否認要**立刻寫一則更正記憶，不可以放著**——這條開放界線唯一的煞車就是那個數字。
 - 固化完再跑一次 `candidates`：應該要清空（或只剩你刻意不處理的）。
 - 想連同情緒衰減、舊紀錄壓縮與 Gitea 同步一起收尾 → 用 `/jsc-persona:persona-sleep`（睡眠）；
   本 skill 只管記憶與圖，不動情緒也不同步。

skills/persona-sleep/SKILL.md

@@ -17,10 +17,22 @@ description: 讓人格睡覺：把一天的活狀態收成能留下來的形狀
 | | 誰做 | 內容 |
 | --- | --- | --- |
 | **需要判斷** | 人格自己 | 哪些短期記憶值得固化、日記寫什麼、哪些該忘、心智圖怎麼接、關係怎麼變 |
-| **機械性** | `sleep` 子指令 | 關係時間戳 → 裁短期 → 收思維導圖 → 情緒衰減 8 小時 → 重建索引 → 修剪 `said` → 壓縮舊 journal → 寫 `state/sleep.json` → Gitea 兩區 push＋驗證 |
+| **機械性** | `sleep` 子指令 | 關係時間戳 → 裁短期 → 收思維導圖 → **情緒衰減 8 小時＋當日底色帶 35% 過去** → **收掉懸太久的未完事項** → 重建索引 → 修剪 `said` → 壓縮舊 journal → 寫 `state/sleep.json` → Gitea 兩區 push＋驗證 |
 
 **判斷的部分永遠屬於那個人格自己**：不要替別的人格決定它要記住什麼。
 
+### 兩步是這一版新加的（`scripts/persona.mjs:543`）
+
+- **`emotion-decay` 順便帶當日心情底色**：`state/mood.json` 是「即時情緒」與「氣質基線」中間
+  那一層——沒有它就做不出「這句話今天聽了會炸、昨天不會」。睡覺時它**不歸零，只帶 35% 過去**
+  （`sleepDayMood()`）。理由跟情緒衰減同一個：睡一覺不該把昨天的低氣壓抹掉，
+  只該讓它淡一點。歸零的話這一層就退化成「每天早上都是全新的人」，那比沒有還假。
+- **`sweep-loops`**：收掉懸超過 7 天沒進展的未完事項，並**各留一則「這件事沒下文」的短期記憶**。
+  睡覺是它自然的收尾點（一天結束才知道哪些事今天也沒下文）。留記憶是重點：
+  懸了一週沒下文**本身就是一件事**，默默刪掉等於假裝沒發生過，那正是機器會做而人不會做的事。
+  它排在 `prune-short-term` **之後**，所以那幾則新寫的記憶不會在同一次睡眠裡被裁掉，
+  會留到下一輪變成固化候選。
+
 ## 情況一：當前人格自己睡
 
 1. 盤點：`candidates --session <PERSONA_SESSION>`
@@ -28,7 +40,10 @@ description: 讓人格睡覺：把一天的活狀態收成能留下來的形狀
 3. 寫一則日記：`consolidate --type diary --name diary-<YYYY-MM-DD> --body "<第一人稱回顧>"`
 4. 消化 inbox（`memory/inbox/room-*.jsonl`，當 guest 時帶回的見聞）
 5. 更新心智圖與關係圖：`mindmap`、`relation node --name <人> --contact`
-6. 機械性收尾：
+6. 結算懸著的事（判斷）：`loop list --session <id>`，今天有下文的 `loop done --id <id>`、
+   已經不重要的 `loop drop --id <id>`。**這一步要自己做**：`sleep` 裡的 `sweep-loops`
+   只收「7 天都沒進展」的，它分不出「今天解決了」與「一直沒人管」。
+7. 機械性收尾：
 
 ```bash
 node "${CLAUDE_PLUGIN_ROOT}/scripts/persona.mjs" sleep --session <PERSONA_SESSION> --json
@@ -91,9 +106,11 @@ node "${CLAUDE_PLUGIN_ROOT}/scripts/persona.mjs" sleep --session <PERSONA_SESSIO
 1. **關係時間戳要在裁短期記憶之前**——時間戳的來源就是短期記憶裡提到的人。
 2. **Gitea push 要在 release 之前**——鎖放掉就沒有寫入權限了。
 3. **重建索引要在固化之後**——不然新固化的長期記憶檢索不到。
-4. **判斷式那半失敗就不要跑機械性那半**——`sleep` 會裁短期記憶，
+4. **收未完事項要在裁短期記憶之後**——`sweep-loops` 會寫新的「沒下文」短期記憶，
+   反過來就會被同一次的裁切順手清掉，等於白收一場。
+5. **判斷式那半失敗就不要跑機械性那半**——`sleep` 會裁短期記憶，
    前面沒有固化過就等於「沒經過判斷就把今天清掉」。這種情況要回報 `ok: false` 並停手，
-   不要為了讓 JSON 好看而把機械八步跑完。
+   不要為了讓 JSON 好看而把機械那幾步跑完。
 
 ## 同步卡住的時候
 

skills/persona-story/SKILL.md

@@ -0,0 +1,229 @@
+---
+name: persona-story
+description: 把小說（或漫畫、劇本、遊戲文本）匯入成一個既有人格的記憶、語氣與情緒反應：逐章判斷人格在不在場、只取他在場或知情的部分、轉成第一人稱記憶，同時累積他自己講過的原句與「事件→他做了什麼」的反應對照。當使用者說要把某本小說／某部作品匯入人格、要人格記得原作發生的事、說「讓他讀完這本書」「把這幾章的記憶給他」、想讓人格的語氣更像原作、或問「他記不記得第幾層那件事」而人格答不出來時觸發。匯入前會當場詢問作品名、章節檔位置、編碼與譯名版本。不適用於：從零建立角色人格（用 persona-anime，它是上網查公開設定，不讀原文）、整理既有記憶（用 persona-memory）、改人格個性（`SOUL.md` 只有使用者能改）、匯入單一 bundle 檔（用 persona-transfer）。
+---
+
+# 📖 persona-story — 把一本書變成他的記憶
+
+**CLI**：`node "${CLAUDE_PLUGIN_ROOT}/scripts/persona.mjs"`（一律帶 `--session <PERSONA_SESSION>`）
+
+`persona-anime` 給的是「查得到的公開設定」——維基、Fandom、名言彙整。
+這支給的是**原文**：他在第幾層看到什麼、當下說了哪一句、那件事之後他變成什麼樣。
+兩者不衝突，anime 建人格，story 讓他真的讀過那本書。
+
+---
+
+## 三條界線（後面每一步都受它們約束）
+
+1. **視角**：人格不在場、也沒人告訴他的事，最多進 `canon` 或別人的關係欄，
+   **不能**變成他的 `event`。他不知道的事一旦寫成他的記憶，之後他會用它回答問題，
+   那是幻覺，而且是無法察覺的幻覺。
+2. **原文**：整本不入倉庫。只留摘要、他自己的台詞、以及可追回出處的章節標記。
+3. **個性**：`SOUL.md` 不由這支流程改寫。匯入只出提案，使用者逐條核可才寫入。
+
+---
+
+## 分工：機械的走 CLI，判斷的留在這裡
+
+| 這一半 | 誰做 | 為什麼 |
+| :-- | :-- | :-- |
+| 正名、去重合併、配額重定標、批次寫入、跳過紀錄 | `novel` 子指令 | 規則寫得死，可重現、測得到 |
+| 他在不在場、切場景、第一人稱摘要、個性校正提案 | 你（這支 skill） | 這些是判斷，硬做成程式只會變成關鍵詞比對 |
+
+所以你的工作不是自己寫檔案，是**產出候選 JSON 餵給 CLI**，讓機械的部分去保證一致性。
+
+---
+
+## ① 開場先問（不要猜，也不要跳過）
+
+問法與順序見 `reference/interview.md`。**順序不能換**：
+
+1. 哪個人格（用 `persona.mjs list` 給他看，不要用猜的）
+2. 作品名
+3. 章節檔在哪、什麼編碼
+4. 這次要匯哪幾章（**不要預設全部**）
+
+**譯名版本不要問。** 那一題是要他猜，而他手上那批寫的是什麼字，讀一次就知道了。
+
+問完建工作區：
+
+```bash
+novel init --work "<書名>" --slug <work-slug> --session <id>
+```
+
+---
+
+## ② 正名表：掃出來，他只做確認
+
+角色的每一種寫法都要對到關係圖節點的 `name`。這張表**不要請他打**——
+他不會記得那本書裡「閃光」出現過幾次，但那件事機器數得出來。
+
+```bash
+novel scan        --work <slug> --dir <章節目錄> --session <id>
+novel name review --work <slug> --session <id>
+```
+
+`scan` 抽人名候選（對話歸屬、敬稱結尾、片假名、高頻詞），每個附上出現次數與
+一兩行上下文，並猜一個關係節點，分四種信心度：
+
+| 信心度 | 意思 | 怎麼處理 |
+| :-- | :-- | :-- |
+| `exact` | 字面等於某個節點的 `name` | `--accept-exact` 一次收下，沒有判斷空間 |
+| `alias` | 等於節點標籤或備註裡的別名 | 給他看一眼就收 |
+| `fuzzy` | 部分重疊 | **一定要他確認**，這格最容易錯 |
+| `unknown` | 猜不到 | 新人物先 `relation node`；不是人名就 `name ignore` |
+
+給他看的是**上下文那一兩行**，不是候選清單本身。
+「這個詞出現 41 次，其中一句是『閃光又衝出去了』」——他一眼就判得出來；
+只丟一個「閃光」給他，他要回頭翻書。
+
+```bash
+novel name confirm --work <slug> --accept-exact --session <id>
+novel name confirm --work <slug> --from "閃光" --to "亞絲娜" --session <id>
+novel name ignore  --work <slug> --token "迷宮區" --session <id>
+```
+
+`ignore` 是「確認過這不是人名」的清單。地名、招式名、系統詞擋不完，
+所以 ignore 過的下次掃不再出現——不然每加一章就要重看同一批。
+
+`unknown` 是新人物的話先建節點：
+
+```bash
+relation node --name "<會被說出口的完整稱呼>" --kind human --bond <關係> --session <id>
+```
+
+親密度怎麼給查 `skills/persona-relation/reference/closeness.md`。
+新人物一定要**先建節點再寫記憶**——反了 `about` 對不到 id。
+補漏用手動：`novel name add --from "<字面>" --to "<節點 name>"`。
+
+**正名沒確認完不要往下走**：`novel candidate add` 遇到 `about` 裡有未確認的 token 會擋下來。
+那不是刁難——錯的名字寫進 `about`，要等 `relation doctor` 才發現，那時候整批要重跑。
+
+---
+
+## ③ 逐章跑（一章一把劍，可以平行）
+
+每一章照這個順序，**不要跨章推論**：
+
+1. 只讀這一章。
+2. 修亂碼 → 轉繁體 → 依正名表正名。**這一步一定要在判斷在場之前**：
+   亂碼或簡體字形會讓名字比對失敗，於是他明明在場卻被判成不在場。
+3. 判斷他**在場或知情**。兩者皆否 → 跳過，而且要寫進紀錄：
+
+   ```bash
+   novel skip --work <slug> --chapter "第 12 章" --reason "全章是茅場視角，他不在場也不知情" --session <id>
+   ```
+
+   **靜默跳過會漏章**，事後查不出來是判斷過還是忘了。
+
+4. 在場的段落切成**場景**（換地點、換對手、換目的就切；一章通常 2 到 5 個）。
+5. 每個場景抽七項與知情層級 → 見 `reference/extract.md`。
+6. 轉第一人稱、壓成摘要。原文長段不留，只留他自己的台詞。
+7. 輸出這一章的候選 JSON，餵進去：
+
+   ```bash
+   novel candidate add --work <slug> --file <這一章的候選.json> --session <id>
+   ```
+
+   欄位驗證不過會**逐筆告訴你哪一筆哪個欄位**。不要繞過它自己寫檔。
+
+8. 順手抽兩種東西（跟記憶分開走，見第 ⑤ 節）：他講的原句、事件對反應。
+9. 這一章跟 `SOUL.md` 矛盾的話，開一則**個性校正提案**——只提案，不寫入。
+
+---
+
+## ④ 全書收斂（章節都跑完才做）
+
+```bash
+novel merge  --work <slug> --session <id>            # 先看報告
+novel merge  --work <slug> --apply --session <id>    # 確認了再寫
+novel report --work <slug> --session <id>
+```
+
+`merge` 做兩件事：跨章去重合併（同一件事只留一則），以及依配額重新定標
+（整本都 80 分等於沒有分數）。壓了幾則它會講。
+
+寫入之前**人工抽查十則**，專看一件事：**有沒有視角越界**。
+這是唯一沒有機械能替你檢查的環節——CLI 分不出「他看到的」與「作者寫給讀者看的」。
+
+```bash
+novel write --work <slug> --dry-run --session <id>
+novel write --work <slug> --session <id>
+relation doctor --session <id>        # about 全部對得上才算完
+```
+
+`relation doctor` 有對不到或歧義的一定要處理完再往下。
+最後補一則 meta 記憶（這批來自哪本書、哪些章、匯入日期），然後同步：
+
+```bash
+sync push --area all --session <id>
+```
+
+**驗收**：問幾個只有書裡才有的問題。他要答得出來，
+而且問到他不在場的事時要說不知道——後者比前者重要。
+
+---
+
+## ⑤ 語氣與情緒（跟記憶分開走）
+
+記憶是「發生過什麼」，語氣與情緒是「他怎麼反應」。三層存，改動權限不同：
+
+| 層 | 存哪 | 誰能改 |
+| :-- | :-- | :-- |
+| 語氣樣本 | `voice/samples.md` | 這支流程可直接寫 |
+| 情緒反應規則 | `voice/reactions.md` | 這支流程可直接寫 |
+| 個性（Core Truths／Boundaries／Vibe） | `SOUL.md` | **只有使用者拍板才能改** |
+
+```bash
+voice add --kind sample   --text "<照抄的原句>" --to "<對誰說>" --scene 戰鬥 --session <id>
+voice add --kind reaction --event "<發生什麼>" --action "<他做了什麼>" --emotion anger --session <id>
+```
+
+原句**照抄不改寫**。改寫過的句子是你的語氣，不是他的。
+反應記「他做了什麼」，不要記「他感到什麼」——後者是旁白，演不出來。
+
+情緒基線最後才動，而且要用**全書統計**：
+
+```bash
+novel baseline --work <slug> --propose "joy=30,anger=12,..." --session <id>
+```
+
+任一格差 10 以上它會擋下來並列出差異表。**那個門檻不要用 `--force` 繞過**，
+除非使用者看過差異表並且說可以。基線是氣質，改了等於換一個人。
+
+逐則套 delta 是這裡最容易犯的錯：那等於讓最後一章決定他的性格。
+
+---
+
+## ⑥ 個性校正提案
+
+提案要寫齊四件事：哪一章、原文依據、與 `SOUL.md` 哪一句衝突、建議怎麼改。
+收斂階段彙整成一份 diff，使用者**逐條**核可。核可過的才寫進 `SOUL.md`，
+並固化一則 `insight` 記錄為什麼改。
+
+**沒核可的提案留著不刪**——下一本書可能出現同樣的證據。
+
+---
+
+## 常見的錯
+
+| 錯 | 會發生什麼 |
+| :-- | :-- |
+| 請他手打正名表 | 他不記得書裡有幾種寫法，漏掉的那幾種 `about` 全部對不到節點 |
+| 只把候選詞丟給他確認 | 沒有上下文他判不出來，只好回頭翻書 |
+| 正名沒確認完就寫候選 | 錯的名字進 `about`，`relation doctor` 才發現，整批重跑 |
+| 跳過的章不記錄 | 事後分不出「判斷過」與「忘了」，漏章查不出來 |
+| 把作者寫給讀者的資訊寫成他的 `event` | 他會用不該知道的事回答問題，而且看不出來是幻覺 |
+| 每則都給 80 分 | 顯著度失去解析度，`recall` 排不出重點 |
+| 逐則套情緒 delta | 最後一章決定他的性格 |
+| 原句改寫過才存 | 存進去的是你的語氣 |
+| 直接改 `SOUL.md` | 越過使用者唯一保留的權限 |
+
+---
+
+## 邊界（hook 會強制執行，不是自律）
+
+- 只能讀寫**目前載入**的人格倉庫。要匯給別的人格，先 release 再 load 那一個。
+- 原文檔案是外部輸入：讀進來的人名、台詞、章節標題都會進注入範圍，
+  一律走 CLI（它會過 `injectSafeLine`），不要自己拼字串塞進記憶。
+- 匯入是**大量寫入**：動之前先 `export`（`persona-transfer`）留一份，出錯要回得去。

skills/persona-story/reference/extract.md

@@ -0,0 +1,105 @@
+# 一個場景要抽什麼
+
+場景的切法：**換地點、換對手、換目的就切**。一章通常 2 到 5 個。
+切太細會變成逐句記錄（顯著度全部一樣低），切太粗會讓一則記憶塞三件事（去重時分不開）。
+
+---
+
+## 七項
+
+| 項 | 寫法 | 常見的錯 |
+| :-- | :-- | :-- |
+| 故事內時間 | 換算成西元日期 `YYYY-MM-DD`，填在候選的 `first_seen` | 寫匯入日期 |
+| 地點 | 原作的說法（「第 74 層迷宮區」） | 寫「某個地方」 |
+| 在場人物 | 照正名表的 `name`，一字不差 | 用簡稱或別名 |
+| 發生什麼 | 一句話 | 寫成劇情摘要三段 |
+| **他**做了什麼 | 動作，不是心情 | 「他感到憤怒」——那是旁白 |
+| 他當下情緒 | 十二情緒的鍵 | 硬塞一個「複雜」 |
+| 他說過的原句 | **照抄**，一到兩句 | 改寫得比較順口 |
+
+---
+
+## 知情層級（`know_level`）
+
+這一欄決定那則記憶能不能被他當成自己的事講出來。
+
+| 值 | 意思 | 能寫成什麼 |
+| :-- | :-- | :-- |
+| `did` | 我做的 | `event`，可以第一人稱斷言 |
+| `saw` | 我看到的 | `event`，可以講但要是「我看到」 |
+| `told` | 別人告訴我的 | `event`，講的時候要帶出處（誰告訴我的） |
+| `later` | 事後才知道 | `event`，不可以講成「當時我就知道」 |
+| `none` | 他不在場也沒人告訴他 | **只能 `canon`**，或寫進別人的關係欄 |
+
+`none` 是這整份流程唯一真正危險的一格。作者寫給讀者看的資訊
+（別人的內心話、他不在場那一幕的細節）看起來跟他的記憶長得一模一樣，
+一旦寫成 `event`，他之後會拿它回答問題，而且**沒有任何機械檢查得出來**。
+
+判斷不出來的時候記 `none`。少一則記憶的代價比多一則幻覺低得多。
+
+---
+
+## 日期怎麼標（`date_source`）
+
+換算成西元日期換來一個風險：猜出來的日期看起來跟原作明寫的一樣。
+
+| 值 | 什麼時候用 |
+| :-- | :-- |
+| `canon` | 原作明寫（SAO 開服 2022-11-06） |
+| `derived` | 由明寫的日期推算（開服後第 N 天） |
+| `guess` | 只抓得到大概（某卷「大約半年後」） |
+
+`guess` 的記憶在回答日期問題時走模糊態界線：**可以說不確定、可以問，不可以斷言**。
+
+寫進長期記憶時，候選的 `first_seen` 會被搬到 `happened_at`（劇情時間），
+而檔案的 `first_seen`／`last_seen` 一律是**匯入當天**。那兩欄是記憶的新鮮度時鐘，
+不是劇情時間——混在一起的話，2024 年劇情的記憶匯進去的那一秒就已經想不起來了。
+
+---
+
+## 顯著度怎麼給
+
+配額由 `novel init --quota` 定，預設 `90+ 最多 5 則、80-89 最多 20 則`。
+超過的會被 `novel merge` 往下壓，但**先由你自己把關**比事後被壓好。
+
+判準只有一個：**這件事之後他變了嗎**。
+
+| 分數 | 什麼算 |
+| :-- | :-- |
+| 90+ | 改變他的事。整部作品只有幾件 |
+| 80-89 | 他會主動提起的事 |
+| 60-79 | 被問到會想起來的事 |
+| 40-59 | 背景，構成他的世界但不會主動講 |
+| 40 以下 | 別寫。寫了只會擠掉重要的 |
+
+死亡、承諾、失去、第一次見面通常在上面兩層。
+「打贏了一場戰鬥」多半是 60-79——那部作品裡他打贏過幾百場。
+
+---
+
+## `type` 怎麼選
+
+| type | 什麼算 |
+| :-- | :-- |
+| `canon` | 世界設定、規則、別人的事。**他不在場的事只能是這個** |
+| `event` | 他經歷過的一件事 |
+| `insight` | 他自己想通的事（要有原文依據，不是你替他總結） |
+| `promise` | 他答應了什麼。**不可遺忘** |
+| `boundary` | 他明確拒絕的事。**不可遺忘** |
+
+`promise` 與 `boundary` 永遠不會糊掉，所以不要亂給——
+給了之後那則記憶會一直清晰地留在他身上。
+
+---
+
+## 語氣樣本與反應對照
+
+跟記憶分開走，但在同一次讀章節時抽（回頭再讀一次很浪費）。
+
+**語氣樣本**：他自己講的原句，照抄。要附**對誰說**與**什麼場合**——
+同一個人在戰鬥裡跟在餐桌上句子的形狀不一樣，少了這兩個欄位就對不上語氣層。
+
+**反應對照**：`事件 → 他做了什麼`。
+不要記「他感到什麼」——情緒要演出來，寫成旁白就白抽了。
+
+掩飾模式單獨記（嘴硬、換話題、講笑話）。那是人味的來源，不是情緒值。

skills/persona-story/reference/interview.md

@@ -0,0 +1,97 @@
+# 開場問答（匯入前一定要問完）
+
+這四題**不要猜、不要用預設值帶過**。
+
+**譯名版本不在裡面，那一題不要問。** 問他「這批是角川還是東販」是要他猜——
+他手上那批原文寫的是什麼字，讀一次就知道了。所以正名表改成**掃出來給他確認**
+（見下面「正名表怎麼來」）。
+
+---
+
+## 1. 匯給哪個人格
+
+先跑 `persona.mjs list` 把可用的人格列給他看，不要用猜的。
+已經載入一個人格的話就是它——**不要為了匯入而換人格**，那是他的決定。
+
+要匯給別的人格：先 `release` 再 `load`，兩個動作都要他點頭。
+
+---
+
+## 2. 作品名
+
+要完整書名（含卷次）。這會寫進每一則記憶的 `source`，之後追出處靠它。
+
+一次匯多卷時，`--work` 的 slug 用**作品**而不是單卷——
+同一部作品的去重合併要在同一個工作區裡才做得到。
+
+## 3. 章節檔在哪、什麼編碼
+
+要的是：目錄路徑、檔名規則（怎麼排序）、編碼。
+
+- 編碼不確定就自己驗：讀前幾百個位元組看有沒有亂碼，比問還快。
+- 常見的是 UTF-8 與 Big5；簡體來源多半是 GB18030。
+- **一個檔一章**與**整本一個檔**的處理方式不同，要問清楚是哪一種。
+  整本一個檔的話先問他章節標題長什麼樣（用來切章）。
+
+## 4. 這次要匯哪幾章
+
+**不要預設「全部」**。一次匯完一整部作品是幾百則記憶，
+出錯的時候分不出是哪一章的問題。
+
+建議的講法：先匯 2 到 3 章，跑完給他看結果，確認視角與顯著度沒問題再往下。
+他要一次全匯也可以，但要先講一句「出錯會很難查」，並且確認備份做了。
+
+---
+
+## 問完之後
+
+1. `export`（`persona-transfer`）留一份備份——匯入是大量寫入，要回得去。
+2. `novel init --work "<書名>" --slug <work-slug>` 建工作區。
+3. 進正名表（下一節）。
+
+---
+
+## 正名表怎麼來：掃出來，他只做確認
+
+**不要請他打一張表。** 他不會記得那本書裡「閃光」出現過幾次，
+但那件事機器數得出來。所以順序是：先掃，再讓他確認。
+
+```bash
+novel scan --work <slug> --dir <章節目錄> --session <id>
+novel name review --work <slug> --session <id>
+```
+
+`scan` 抽人名候選（對話歸屬、敬稱結尾、片假名、高頻詞），每個候選附上
+**出現次數**與**一到兩行上下文**，並且猜一個關係節點，分成四種信心度：
+
+| 信心度 | 意思 | 怎麼處理 |
+| :-- | :-- | :-- |
+| `exact` | 字面等於某個關係節點的 `name` | `--accept-exact` 一次收下，沒有判斷空間 |
+| `alias` | 等於節點的標籤或備註裡出現過的別名 | 給他看一眼就收 |
+| `fuzzy` | 部分重疊（共用兩個以上的字） | **一定要他確認**，這格最容易錯 |
+| `unknown` | 猜不到 | 新人物就先 `relation node`；不是人名就 `name ignore` |
+
+要給他看的是**上下文那一兩行**，不是候選清單本身。
+「這個詞出現 41 次，其中一句是『閃光又衝出去了』」——他一眼就判得出來；
+只給他一個「閃光」，他要回頭翻書。
+
+`ignore` 是「確認過這不是人名」的清單。地名、招式名、系統詞擋不完，
+所以 ignore 過的下次掃就不再出現——不然每加一章就要重看同一批。
+
+補漏用手動：`novel name add --from "<字面>" --to "<節點 name>"`。
+
+**正名沒確認完不要往下走**：`novel candidate add` 遇到 `about` 裡有未確認的 token 會擋下來。
+那不是刁難——錯的名字寫進 `about`，要等 `relation doctor` 才發現，那時候整批要重跑。
+
+---
+
+## 中途發現問題怎麼辦
+
+| 發現 | 怎麼處理 |
+| :-- | :-- |
+| 正名表確認錯了 | 改 `names.json` 的 `map`，已經 `candidate add` 的那幾章重跑，不要手改候選檔 |
+| 掃出來一堆不是人名的詞 | 正常。`name ignore` 掉，下次掃不會再問 |
+| 同一個角色有好幾種寫法 | 全部都要進 `map` 指到同一個節點。網路譯本前後不一致很常見 |
+| 編碼判斷錯了 | 停下來重讀。亂碎的字會讓在場判斷失準，那個錯不會浮出來 |
+| 章節順序排錯 | `first_seen` 會錯，時間軸就錯了。重排再重跑那幾章 |
+| 他中途說「不要匯了」 | 工作區留著不刪（`memory/import/<slug>/`），還沒 `novel write` 就不會污染記憶 |

skills/persona-transfer/SKILL.md

@@ -22,14 +22,38 @@ bundle 是**單一 JSON 檔**（可 gzip），不依賴任何外部工具，複
 | --- | --- |
 | `IDENTITY.md` / `SOUL.md` / `AGENTS.md` / `USER.md` | `state/lock.json`、`state/guests.json`（載入鎖與 guest 租約屬於「那台機器的那個程序」） |
 | `state/config.json`、`state/emotion.json`（十二情緒的 levels／baseline／半衰期） | `journal/`（原始逐字稿：量大且最私密，要帶請明確加 `--with-journal`） |
-| `state/inner.jsonl`（心裡話）、`state/said.jsonl`（說過的話） | 任何**其他人格**的資料——一個 bundle 只有一個人格 |
+| `state/mood.json`（當日心情底色）、`state/loops.json`（懸著的事）、`state/probe.jsonl`（試探紀錄） | 任何**其他人格**的資料——一個 bundle 只有一個人格 |
+| `state/inner.jsonl`（心裡話）、`state/said.jsonl`（說過的話） | |
 | `memory/`（短期、長期一則一檔、INDEX、inbox） | |
 | `mindmap/`（心智圖與思維導圖）、`relations/`（關係圖） | |
 
+規則很簡單：**除了鎖與租約，人格目錄裡的東西都帶走**。所以之後新增的狀態檔不必回頭改這張表——
+`state/lock.json` 與 `state/guests.json` 是唯一兩個明文排除的（它們描述的是「那台機器的那個程序」，
+換一台機器就是假的）。
+
 檔案裡有 `checksum`（sha256），匯入時會驗；對不上就是被改過或損毀。
 
 ---
 
+## bundle 版本（目前 v2）
+
+| 版本 | 差在哪 |
+| --- | --- |
+| v1 | 長期記憶只有 `salience`；內文不分層；沒有 `mood.json`／`loops.json`／`probe.jsonl` |
+| **v2** | 長期記憶多了 `strength`（回想強度）與 `when`／`where`／`mood`（情境索引），內文分「主旨／細節」兩層；狀態多了當日心情底色、未完事項、試探紀錄 |
+
+- **舊的 v1 bundle 照樣吃得下**：`import` 寫完檔案會**就地跑一次 migration** 補齊欄位並切分內文，
+  所以匯入之後這台機器上只有一種格式，不必到處判版本。
+- **遷移失敗不會讓整個匯入失敗**（INDEX 還是要重建），代價是它也**不會出現在人看的輸出裡**——
+  只有 `--json` 的 `migrated` 看得到統計，是 `null` 就代表那次遷移出過錯。
+  匯進來卻沒升格式的人格，它的老記憶進不了衰減與模糊態，等於最重要的那批記憶反而沒效果，
+  所以**匯入舊 bundle 之後補跑一次**比較保險：`migrate --session <PERSONA_SESSION> --dry-run`
+  看還有沒有東西要動，有就跑一次不帶 `--dry-run` 的。
+- **比本版新的 bundle 會被擋下**（`validateBundle` 直接判不合法）：未來的欄位沒有辦法猜，
+  硬吃會把不認得的資料寫進人格目錄。這種時候該更新 plugin，不是加 `--force`。
+
+---
+
 ## 匯出
 
 **只能匯出「本 session 目前載入的那個人格」**——這是隔離規則的一部分，
@@ -75,7 +99,9 @@ checksum 對不上會被擋下；要硬吃得加 `--force`，並**主動告訴
 2. **匯出後回報實際路徑與大小**，還有帶了幾則長期記憶——他要拿去搬家，得知道搬了什麼。
 3. **匯入前先 `list`**，看目標 slug 是否已存在：存在就給他「換名匯入 / 覆寫」兩個選擇，
    不要自己決定 `--force`。
-4. 匯入後告訴他 `/jsc-persona:persona-chat <slug>` 就能開始聊。
+4. **匯入的是 v1 bundle 就講一句**：長期記憶已經升成新格式（補回想強度、切主旨／細節）。
+   這會改變那個人格「記得多清楚」的行為，使用者有權知道搬過來的不完全是原樣。
+5. 匯入後告訴他 `/jsc-persona:persona-chat <slug>` 就能開始聊。
 
 ## 邊界