devlog-tracker 0.32.0 → 0.33.0

package/README.md

@@ -2,7 +2,7 @@
 
 *English | [繁體中文](README.zh-TW.md)*
 
-**Version** 0.32.0
+**Version** 0.33.0
 
 Maintains a `.devlog/devlog.md` in your project, turning each conversation round's requests, decisions, and outcomes into a permanent record. A conversation disappears the moment you `/clear` or switch sessions; this file fills that gap so work can pause and resume. Nothing is touched until you explicitly run `/devlog-tracker:start` — installing the plugin alone doesn't create or modify any files.
 
@@ -90,7 +90,7 @@ bash "$DEVLOG_TRACKER_ROOT/core/scripts/segment-watch-set.sh" 600
 bash "$DEVLOG_TRACKER_ROOT/core/scripts/checkpoint-set.sh" 20
 bash "$DEVLOG_TRACKER_ROOT/core/scripts/report-devlog.sh" --json
 bash "$DEVLOG_TRACKER_ROOT/core/scripts/timeline-devlog.sh"
-# pause / span-open / span-close / compact / keep-move / clean / resume / pr / promote: see commands/*.md
+# pause / span-open / span-close / compact / keep-move / keep-all / clean / resume / pr / promote: see commands/*.md
 ```
 
 ## Quick start
@@ -115,7 +115,8 @@ The table below uses the plugin's `/devlog-tracker:*` namespace; `npx init --cla
 | `/devlog-tracker:continue` | Reads `.devlog/devlog.md`, checks the last round's Handoff "Workspace" section, then continues per its next step. Use this after `/clear` to resume. See [`docs/design/continue.md`](docs/design/continue.md). |
 | `/devlog-tracker:pause` | Pauses enforced recording; history files are untouched, and you can `start` again later. |
 | `/devlog-tracker:compact` | A script moves older `DONE` rounds into `devlog.archive.md` (Checkpoints and unfinished rounds stay in the main file). |
-| `/devlog-tracker:keep` | Scans the whole file, groups it by topic, lists suggestions at once, then — after confirmation — moves each section out into its own `devlog.<name>.md` (leaving a `## Kept index` pointer line with a one-sentence topic description in the main file); can also extract a single section or merge everything into one history file. Not the same as compact. See [`docs/design/keep.md`](docs/design/keep.md). |
+| `/devlog-tracker:keep` | Scans the current branch's main file (to reorganize every devlog at once, use `keep-all`), groups it by topic, lists suggestions at once, then — after confirmation — moves each section out into its own `devlog.<name>.md` (leaving a `## Kept index` pointer line with a one-sentence topic description in the main file); can also extract a single section or merge everything into one history file. Not the same as compact. See [`docs/design/keep.md`](docs/design/keep.md). |
+| `/devlog-tracker:keep-all` | Reorganizes **every** devlog, not just the current branch's: the current main file, every other branch's `devlog.<branch>.md`, `devlog.archive.md`, and all files earlier `keep`/`keep-all` runs produced. Claude regroups their Rounds by topic across files (one topic spread over main, a feature branch and the archive ends up in one file), lists every proposed file at once, and after confirmation one script run writes them all or nothing. Existing kept files are broken up and rebuilt; each branch's unfinished tail (Rounds after its last `DONE`) and the open Round never move; branch files are never deleted. Every touched file is backed up to `.devlog/.keep-all-backup/<timestamp>/` first. Needs Node ≥18. See [`docs/design/keep-all.md`](docs/design/keep-all.md). |
 | `/devlog-tracker:overview` | Reads all kept `devlog.<name>.md` files and merges them into a cross-topic overview, plus a list of candidate rules that look like they belong in `CLAUDE.md`. Read-only — no workspace check, no confirmation, no writes. See the Kept index section of [`docs/design/keep.md`](docs/design/keep.md). |
 | `/devlog-tracker:promote` | Picks rule candidates from kept files, lessons files and Checkpoint `### 決策` sections, lists them numbered, and — only for the ones you choose — appends them to a managed `<!-- devlog-tracker:rules:begin/end -->` block in `CLAUDE.md` (or `AGENTS.md` when `CLAUDE.md` is just `@AGENTS.md`, or on Codex-only projects). Append-only, exact duplicates skipped; `init` never rewrites this block. |
 | `/devlog-tracker:search <keyword>` | Case-insensitive string search across `devlog.md`/`devlog.archive.md`/kept `devlog.<name>.md`/`devlog.lessons.<topic>.md`; Claude answers in its own words from the hits (with file/heading/line as evidence). Read-only — no workspace check, no confirmation, no writes. |
@@ -233,7 +234,7 @@ When Claude ends a turn with a plain-text question and the next message is the a
 
 #### Per-branch devlog files
 
-Switching branches within the same working directory automatically splits the main file by the checked-out branch: `main`/`master` keeps using `.devlog/devlog.md`, while other branches each use `.devlog/devlog.<branch>.md` (slashes converted to `-`). A separate `git worktree` (a different directory) already has its own independent `.devlog/` and is unaffected by this mechanism. The first time a branch is detected without its own file, only the unfinished tail of `devlog.md` (the Rounds after the last `DONE`, plus `handoff.md`) is cut into that branch's file; `main`'s own history, project summary, Checkpoints, and Kept/Lessons indexes stay in `devlog.md`. If the last Round is already `DONE`, or the branch checked out doesn't contain the current `main` tip (an older branch), nothing moves and the branch starts with an empty file. See [`docs/design/branch-scoped-devlog.md`](docs/design/branch-scoped-devlog.md).
+Switching branches within the same working directory automatically splits the main file by the checked-out branch: `main`/`master` keeps using `.devlog/devlog.md`, while other branches each use `.devlog/devlog.<branch>.md` (slashes converted to `-`). A separate `git worktree` (a different directory) already has its own independent `.devlog/` and is unaffected by this mechanism. The first time a branch is detected without its own file, only the unfinished tail of `devlog.md` (the Rounds after the last `DONE`, plus `handoff.md`) is cut into that branch's file; `main`'s own history, project summary, Checkpoints, and Kept/Lessons indexes stay in `devlog.md`. If the last Round is already `DONE`, or the branch checked out doesn't contain the current `main` tip (an older branch), nothing moves and the branch starts with an empty file. A branch file's first line is an origin marker, `<!-- devlog-origin: branch=<raw branch name> -->` (invisible when rendered), recording the real branch name that the sanitized filename can't carry; `/devlog-tracker:keep-all` uses it to tell branch files from kept files and to report whether the branch is still active, merged or deleted. Files created before this marker existed are left as they are. See [`docs/design/branch-scoped-devlog.md`](docs/design/branch-scoped-devlog.md).
 
 #### Lessons Mode (off by default, not automatic)
 

package/README.zh-TW.md

@@ -2,7 +2,7 @@
 
 *[English](README.md) | 繁體中文*
 
-**版本** 0.32.0
+**版本** 0.33.0
 
 在專案中維護一份 `.devlog/devlog.md`，把每一輪對話的請求、決策與結果寫成永久紀錄。對話一 `/clear` 或換 session 就沒了；這份檔案取代那個缺口，讓工作可以中斷再接。沒下過 `/devlog-tracker:start` 時，裝著也不會動任何檔案。
 
@@ -90,7 +90,7 @@ bash "$DEVLOG_TRACKER_ROOT/core/scripts/segment-watch-set.sh" 600
 bash "$DEVLOG_TRACKER_ROOT/core/scripts/checkpoint-set.sh" 20
 bash "$DEVLOG_TRACKER_ROOT/core/scripts/report-devlog.sh" --json
 bash "$DEVLOG_TRACKER_ROOT/core/scripts/timeline-devlog.sh"
-# pause / span-open / span-close / compact / keep-move / clean / resume / pr / promote：見 commands/*.md
+# pause / span-open / span-close / compact / keep-move / keep-all / clean / resume / pr / promote：見 commands/*.md
 ```
 
 ## 快速開始
@@ -115,7 +115,8 @@ $devlog-start           # npx init --codex
 | `/devlog-tracker:continue` | 讀 `.devlog/devlog.md`，核對最後一輪 Handoff「工作區」後再依下一步接著做。`/clear` 之後要接續用這個。細節見 [`docs/design/continue.md`](docs/design/continue.md)。 |
 | `/devlog-tracker:pause` | 暫停強制記錄，歷史檔不動，之後可再 `start`。 |
 | `/devlog-tracker:compact` | 腳本把較舊的 `DONE` 輪次搬到 `devlog.archive.md`（Checkpoint 與未完成輪留在主檔）。 |
-| `/devlog-tracker:keep` | 掃全檔分主題，一次列出建議，確認後把各段各自搬走成 `devlog.<name>.md`（並在主檔留一個 `## Kept 索引` 指標行，含一句主題描述）；也可抽出一段或合併成全部歷史一檔。不是 compact。細節見 [`docs/design/keep.md`](docs/design/keep.md)。 |
+| `/devlog-tracker:keep` | 掃目前分支的主檔分主題（要一次整理所有 devlog 用 `keep-all`），一次列出建議，確認後把各段各自搬走成 `devlog.<name>.md`（並在主檔留一個 `## Kept 索引` 指標行，含一句主題描述）；也可抽出一段或合併成全部歷史一檔。不是 compact。細節見 [`docs/design/keep.md`](docs/design/keep.md)。 |
+| `/devlog-tracker:keep-all` | 整理**所有** devlog，不只目前分支：目前的主檔、其他分支的 `devlog.<branch>.md`、`devlog.archive.md`，以及先前 `keep`／`keep-all` 產生的所有具名檔。Claude 跨檔依主題重新分段（同一個主題散在 main、feature 分支與 archive 的片段會合回同一檔），一次列出所有建議檔案，確認後由一支腳本整批寫入，全有或全無。既有的具名檔會被拆開重組；各分支未完成的尾巴（最後一個 `DONE` 之後的 Round）與開著的那一輪不會被搬，分支檔也不會被刪。動手前會先把所有會動到的檔備份到 `.devlog/.keep-all-backup/<時間戳>/`。需要 Node ≥18。細節見 [`docs/design/keep-all.md`](docs/design/keep-all.md)。 |
 | `/devlog-tracker:overview` | 讀完所有已 keep 的 `devlog.<name>.md`，整合成跨主題總覽，並列出看起來該進 `CLAUDE.md` 的規範候選。純讀取，不核對工作區、不等確認、不寫檔。細節見 [`docs/design/keep.md`](docs/design/keep.md) Kept index。 |
 | `/devlog-tracker:promote` | 從已 keep 的檔、lessons 檔與 Checkpoint 的 `### 決策` 挑出規範候選並編號列出；只有你選定的才追加到 `CLAUDE.md`（`CLAUDE.md` 只有 `@AGENTS.md` 或只裝 Codex 時改寫 `AGENTS.md`）的 `<!-- devlog-tracker:rules:begin/end -->` 受管區塊。只追加、一字不差的重複會跳過；`init` 不會覆寫這個區塊。 |
 | `/devlog-tracker:search <關鍵字>` | 在 `devlog.md`／`devlog.archive.md`／已 keep 的 `devlog.<name>.md`／`devlog.lessons.<topic>.md` 裡做不分大小寫的字串搜尋；Claude 讀完命中後用自己的話回答（必要時附檔名／標題／行號）。純讀取，不核對工作區、不等確認、不寫檔。 |
@@ -233,7 +234,7 @@ Claude 用純文字結尾提出問題、下一則訊息才拿到答案時，不
 
 #### 分支各自的 devlog 檔
 
-同一個工作目錄裡切換分支時，主檔會依目前 checkout 的分支自動分開：`main`／`master` 繼續用 `.devlog/devlog.md`，其他分支各自用 `.devlog/devlog.<branch>.md`（斜線轉成 `-`）。另開一個 `git worktree`（不同目錄）本來就有自己獨立的 `.devlog/`，不受這個機制影響。第一次在某分支偵測到還沒有專屬檔案時，只會把 `devlog.md` 裡還沒完成的尾巴（最後一個 `DONE` 之後的 Round，連同 `handoff.md`）剪到該分支的檔案；`main` 自己的歷史、專案摘要、Checkpoint、Kept／Lessons 索引都留在 `devlog.md`。最後一輪已經是 `DONE`，或切到的是不含目前 `main` 最新 commit 的舊分支時，什麼都不搬，新分支從空檔開始。細節見 [`docs/design/branch-scoped-devlog.md`](docs/design/branch-scoped-devlog.md)。
+同一個工作目錄裡切換分支時，主檔會依目前 checkout 的分支自動分開：`main`／`master` 繼續用 `.devlog/devlog.md`，其他分支各自用 `.devlog/devlog.<branch>.md`（斜線轉成 `-`）。另開一個 `git worktree`（不同目錄）本來就有自己獨立的 `.devlog/`，不受這個機制影響。第一次在某分支偵測到還沒有專屬檔案時，只會把 `devlog.md` 裡還沒完成的尾巴（最後一個 `DONE` 之後的 Round，連同 `handoff.md`）剪到該分支的檔案；`main` 自己的歷史、專案摘要、Checkpoint、Kept／Lessons 索引都留在 `devlog.md`。最後一輪已經是 `DONE`，或切到的是不含目前 `main` 最新 commit 的舊分支時，什麼都不搬，新分支從空檔開始。分支檔的第一行是 origin 標記 `<!-- devlog-origin: branch=<原始分支名> -->`（渲染時看不到），記下檔名轉換後已經還原不回來的真實分支名；`/devlog-tracker:keep-all` 靠它分辨分支檔與具名檔，並回報該分支還在開發、已合併或已刪除。這個標記出現前就存在的舊檔維持原樣。細節見 [`docs/design/branch-scoped-devlog.md`](docs/design/branch-scoped-devlog.md)。
 
 #### Lessons Mode（預設關閉，不自動）
 

package/cli/agents-md.js

@@ -23,6 +23,7 @@ function codexBlock() {
 | 歸檔 / compact | \`commands/compact.md\` |
 | 清空重編 / clean（不可復原，先問使用者確認） | \`commands/clean.md\` |
 | 保存主題 / keep、接續具名檔 / resume、跨主題總覽 / overview | \`commands/keep.md\`、\`commands/resume.md\`、\`commands/overview.md\` |
+| 整理所有 devlog（跨分支檔、archive、既有 keep 檔重新分主題） / keep-all | \`commands/keep-all.md\` |
 | 沉澱規範寫進 CLAUDE.md／AGENTS.md / promote | \`commands/promote.md\` |
 | 搜尋 / search | \`commands/search.md\` |
 | 統計 / report、HTML 時間軸 / timeline | \`commands/report.md\`、\`commands/timeline.md\` |

package/cli/platforms/claude.js

@@ -22,6 +22,7 @@ function claudeBlock() {
 | 歸檔 / compact | \`commands/compact.md\` |
 | 清空重編 / clean（不可復原，先問使用者確認） | \`commands/clean.md\` |
 | 保存主題 / keep、接續具名檔 / resume、跨主題總覽 / overview | \`commands/keep.md\`、\`commands/resume.md\`、\`commands/overview.md\` |
+| 整理所有 devlog（跨分支檔、archive、既有 keep 檔重新分主題） / keep-all | \`commands/keep-all.md\` |
 | 沉澱規範寫進 CLAUDE.md／AGENTS.md / promote | \`commands/promote.md\` |
 | 統計 / report、HTML 時間軸 / timeline | \`commands/report.md\`、\`commands/timeline.md\` |
 | 產生 PR 描述 / pr | \`commands/pr.md\` |

package/commands/keep-all.md

@@ -0,0 +1,93 @@
+---
+description: 整理所有 devlog：跨主檔、所有分支檔、archive 與既有 keep 檔，依主題重新分成 devlog.<name>.md
+---
+
+請執行 devlog keep-all（整理全部 devlog）。這是使用者主動執行 `/devlog-tracker:keep-all` 時才做的事，不要自動觸發。
+
+跟 `/devlog-tracker:keep` 的差別：keep 只整理目前分支的主檔；keep-all 一次看 `.devlog/` 裡**所有** devlog 檔——目前分支的主檔、其他分支的 `devlog.<branch>.md`、`devlog.archive.md`，以及先前 keep／keep-all 產生的具名檔——跨檔依主題重新分段。既有的具名檔會被拆開重組，所以一個主題散在 main、feature 分支與 archive 的片段可以合回同一個檔。設計見 `docs/design/keep-all.md`。
+
+確認之前不要寫任何檔。
+
+先決定 plugin 根目錄（有 `DEVLOG_TRACKER_ROOT` 用它；否則用 `CLAUDE_PLUGIN_ROOT`；兩者都空就用含 `.claude-plugin/plugin.json` 的本 plugin 根目錄），並記下目前已確認的專案根目錄絕對路徑（後面兩次呼叫都用同一個值，不要用 `$(pwd)` 重新推）。
+
+## 1. 掃描
+
+```bash
+PLUGIN_ROOT="${DEVLOG_TRACKER_ROOT:-${CLAUDE_PLUGIN_ROOT:-}}"
+DEVLOG_PROJECT_DIR="<專案根目錄絕對路徑>" bash "${PLUGIN_ROOT}/core/scripts/keep-all.sh" --scan
+```
+
+- `NO_NODE`：告知 keep-all 需要 Node.js（可改用 `/devlog-tracker:keep` 整理目前分支），結束。
+- `NOTHING`：告知目前沒有可整理的 Round，不要建立任何檔，結束。
+- 否則輸出是：
+  - `FINGERPRINT=<fp> COUNT=<n>`：記下這兩個值，步驟 4 原樣帶回。
+  - `SOURCE file=… kind=…`：每個來源檔。`kind` 由腳本判定，不要自己依檔名猜：
+    - `current`：目前分支的主檔
+    - `branch`：其他分支的主檔；`origin` 是分支名，`state` 是 `active`（還在開發）／`merged`（已合併進 main）／`gone`（本地分支已刪）／`unknown`／`n/a`
+    - `archive`：`devlog.archive.md`
+    - `kept`：既有的具名檔（第一行是 `# Kept log`）
+  - `ROUND id=… file=… round=… line=… ts=… status=… movable=0|1`：每個 Round 一行，`id` 是依時間排序的全域編號（不同檔的 Round 編號會重複，一律用 `id` 指稱）。`movable=0` 的是目前開著的 Round，或其他分支最後一個 `DONE` 之後還沒完成的尾巴——這些不能搬，也不要列進任何段落。
+
+## 2. 讀檔、分主題
+
+讀完每個 `SOURCE` 檔（至少讀 `movable=1` 的 Round 所在範圍）。依 `### User Input` 與 `### Summary` 的主題，把 `movable=1` 的 Round 分成主題段落：
+
+- 一段是一組 `id`，**可以跨檔、可以不連續**——同一主題在 main、分支與 archive 的片段應該放進同一段。
+- `kind=kept` 來源的 Round **全部都必須**分進某一段（它們先前已被判定值得留），可以跟其他主題合併或拆開重組。
+- 其他來源的瑣碎 Round（只有確認、閒聊、重複）可以不收，留在原檔。判斷標準同 `/devlog-tracker:keep` 步驟 2。
+- 每段產生建議 `<name>`（小寫 ASCII kebab-case，2–4 段，只反映主題，不加日期），以及一句這段在做什麼的描述（純文字、不換行、不含 tab 與反引號；步驟 4 原樣寫進索引）。同一批兩段撞名時，較晚的加 `-2`／`-3`。既有 kept 檔的名稱若仍貼切可以沿用——它會被這次整理取代。
+
+## 3. 一次列出，然後停下來等
+
+```
+掃到 N 段主題：
+  1. <一句描述>　→ devlog.<name>.md
+     <來源檔> Round <編號…>（#<id…>）、<來源檔> Round <編號…>（#<id…>，分支 <origin> <state>）
+  2. ...
+會被重整並刪除的既有 keep 檔：<檔名，逗號分隔，或「無」>
+可搬但偏瑣碎、留在原檔：<來源檔與 Round，或「無」>
+不能搬、保持原樣：<各分支未完成尾巴與開著的 Round，或「無」>
+
+回覆：
+  採用 → 全部照上面寫入
+  改第 N 段檔名 <name> / 移除第 N 段 / 第 N 段併入第 M 段
+  摘要第 N 段 → 搬完後把該段敘事改寫得更精簡
+  取消
+```
+
+同一則回覆可以合併多條修改；`N` 一律對應原始編號。使用者用文字要求把某些 Round 換段，照做後重新列一次再等。然後停止，使用者回覆前不要寫任何檔。
+
+- 取消 → 不改檔，結束。
+- `移除第 N 段`：該段若含 `kind=kept` 的 Round，拒絕並說明只能 `併入`；其餘 Round 留在原檔。
+- `第 N 段併入第 M 段`：合併 id，沿用第 M 段的檔名與描述。
+- 檔名規則同 `/devlog-tracker:keep` 步驟 4（`devlog.` 前綴與 `.md` 後綴會剝掉；不可為空、`archive`、`lessons.*`，不可含 `/`、`\`、`..`，最多 64 字元）；目標檔已存在（且不是這次會被整理掉的 kept 檔）時改建議 `-2`。
+
+## 4. 寫計畫並執行（整批一次，全有或全無）
+
+把確認後的段落寫到 `.devlog/.keep-all-plan.tsv`，一段一行，三欄以 tab 分隔：
+
+```
+<name>	<描述>	<id 清單，例如 3-8,20,24-25>
+```
+
+然後：
+
+```bash
+DEVLOG_PROJECT_DIR="<專案根目錄絕對路徑>" bash "${PLUGIN_ROOT}/core/scripts/keep-all.sh" \
+  --apply "<專案根目錄絕對路徑>/.devlog/.keep-all-plan.tsv" --fingerprint <fp> --count <n>
+```
+
+`<fp>`／`<n>` 用步驟 1 的值。不要自己搬檔、刪檔或改索引——腳本是唯一的實作：驗證計畫、把所有會動到的檔備份到 `.devlog/.keep-all-backup/<時間戳>/`、組好新檔、改寫來源、刪除被整理掉的 kept 檔與清空的 archive、重建 `## Kept 索引`（新索引行寫在目前分支的主檔）。分支檔與目前主檔即使搬空也不會被刪。
+
+- exit 1：原樣顯示 stderr，不要自行重試或手動補做。驗證錯誤時不會寫任何檔；fingerprint 不符代表掃描後檔案被改過，回到步驟 1 重新掃描。
+- 成功後刪除 `.devlog/.keep-all-plan.tsv`。
+
+## 5. 選配：摘要
+
+只對使用者標記「摘要第 N 段」的段落做，規則同 `/devlog-tracker:keep` 步驟 5.5（只改寫 `### Summary`、`### Reply`、`#### 決策`、`#### 現況` 的敘事；標題、`### User Input`、`#### 工作區`、`#### 檔案`、`#### 完成條件`、`#### 下一步`、`### Status` 一律不動；用 Edit 不用 Write）。
+
+## 6. 回報
+
+依 stdout 回報：每個 `KEPT=<路徑> ROUNDS=<n>`、每個 `DELETED=<路徑>`、`BACKUP=<目錄>`（出錯時可從這裡還原），以及哪幾段套用了摘要。
+
+若 `.devlog/.round-open` 存在：在開著的那一輪補上 `### Summary` / `### Handoff` / `### Status` 再結束（Stop hook 仍會檢查）。

package/commands/keep.md

@@ -4,6 +4,8 @@ description: 掃描整份 devlog.md，把值得留名的主題段落一次分別
 
 請執行 devlog keep（具名搬走）。這是使用者主動執行 `/devlog-tracker:keep` 時才做的事，不要自動觸發。
 
+這個指令只整理**目前分支的主檔**（`devlog.md` 或 `devlog.<branch>.md`）。要一次整理所有 devlog——其他分支的檔、`devlog.archive.md`、既有的 keep 檔——用 `/devlog-tracker:keep-all`（`commands/keep-all.md`）。
+
 確認之前不要寫任何檔。若這一輪本身是開著的 Round，永遠不要把它搬走，這一輪結束前仍要補 `### Summary` / `### Handoff` / `### Status`（若沒有開著的 Round，見步驟 1 第 2 點）。
 
 ## 1. 讀檔、找出開著的 Round

package/core/scripts/devlog-md.sh

@@ -169,13 +169,30 @@ devlog_round_segments_body() {
   ' "$1"
 }
 
+# The first line of a branch-scoped devlog file: records which branch (or
+# detached worktree dir) it belongs to, since the sanitized filename can't
+# be mapped back. $1 is DEVLOG_ORIGIN ("branch=feat/x"). An HTML comment,
+# so it neither renders nor parses as a `## ` block.
+devlog_origin_line() {
+  printf '<!-- devlog-origin: %s -->\n' "$1"
+}
+
+# Prints the origin ("branch=feat/x") if line 1 of $1 is an origin marker.
+devlog_origin_of() {
+  [ -f "$1" ] || return 0
+  sed -n '1s/^<!-- devlog-origin: \(.*\) -->$/\1/p' "$1"
+}
+
 devlog_merge_round_current() {
   # Appends $2's content onto $1 (one blank line separator, matching the
   # existing "\n## Round N" append convention) and removes $2. No-op if $2
-  # is absent or empty — nothing to merge.
+  # is absent or empty — nothing to merge. When $1 doesn't exist yet and
+  # DEVLOG_ORIGIN is set (a branch file being created), its origin marker
+  # goes first.
   local devlog="$1" current="$2"
   [ -s "$current" ] || return 0
   {
+    [ -s "$devlog" ] || [ -z "${DEVLOG_ORIGIN:-}" ] || devlog_origin_line "$DEVLOG_ORIGIN"
     printf '\n'
     cat "$current"
   } >> "$devlog" 2>/dev/null || return 1

package/core/scripts/devlog-path.sh

@@ -21,12 +21,14 @@ _devlog_sanitize_name() {
 # whose Status is DONE. Nothing moves when the last round is DONE, when
 # there are no rounds, or when HEAD doesn't contain the local main/master
 # tip (an older branch being checked out, not one just forked from the
-# work in progress). The project header, Checkpoints, and Kept/Lessons
+# work in progress). When $6 (an origin like "branch=feat/x") is given,
+# the branch file starts with its origin marker. The project header,
+# Checkpoints, and Kept/Lessons
 # indexes always stay in $2. When rounds move, $4 (handoff.md) moves to
 # $5 too, since it snapshots that same unfinished work. Caller holds the
 # devlog lock.
 _devlog_migrate_unfinished_tail() {
-  local dir="$1" src="$2" dst="$3" src_handoff="$4" dst_handoff="$5"
+  local dir="$1" src="$2" dst="$3" src_handoff="$4" dst_handoff="$5" origin="${6:-}"
   [ -s "$src" ] || return 0
 
   # Cheap early exit first: until the branch file exists, every hook
@@ -71,7 +73,10 @@ _devlog_migrate_unfinished_tail() {
       print moved ? "M" $0 : "K" $0
     }
   ' "$src" > "$src.split" 2>/dev/null || { rm -f "$src.split"; return 0; }
-  sed -n 's/^M//p' "$src.split" | awk "$drop_trailing_blanks" > "$dst.tmp" 2>/dev/null
+  {
+    [ -z "$origin" ] || { devlog_origin_line "$origin"; printf '\n'; }
+    sed -n 's/^M//p' "$src.split" | awk "$drop_trailing_blanks"
+  } > "$dst.tmp" 2>/dev/null
   sed -n 's/^K//p' "$src.split" | awk "$drop_trailing_blanks" > "$src.tmp" 2>/dev/null
   rm -f "$src.split"
 
@@ -94,14 +99,18 @@ _devlog_migrate_unfinished_tail() {
 # time a branch resolves to a file that doesn't exist yet, only
 # devlog.md's unfinished tail is cut into it (see
 # _devlog_migrate_unfinished_tail); main's own history stays in devlog.md.
+# Also sets DEVLOG_ORIGIN ("branch=<raw name>" / "detached=<dir>", empty
+# for devlog.md): the first line written into a new branch file records it
+# as an origin marker (docs/design/keep-all.md "Origin marker").
 devlog_resolve_paths() {
   local dir="${1:-.}"
   DEVLOG_DIR="$dir/.devlog"
   DEVLOG_FILE="$DEVLOG_DIR/devlog.md"
   # shellcheck disable=SC2034 # consumed by callers (e.g. enforce-devlog.sh), not used in this file
   HANDOFF_FILE="$DEVLOG_DIR/handoff.md"
+  DEVLOG_ORIGIN=""
 
-  local branch raw name
+  local branch raw name origin
   branch="$(git -C "$dir" rev-parse --abbrev-ref HEAD 2>/dev/null || echo '')"
 
   case "$branch" in
@@ -110,9 +119,11 @@ devlog_resolve_paths() {
       ;;
     HEAD)
       raw="$(basename "$(cd "$dir" 2>/dev/null && pwd)" 2>/dev/null || echo '')"
+      origin="detached=$raw"
       ;;
     *)
       raw="$branch"
+      origin="branch=$raw"
       ;;
   esac
   [ -n "$raw" ] || return 0
@@ -139,10 +150,11 @@ devlog_resolve_paths() {
   if [ -f "$DEVLOG_DIR/.enabled" ] && [ ! -f "$resolved" ] && [ -s "$DEVLOG_FILE" ]; then
     devlog_lock_acquire
     [ -f "$resolved" ] || _devlog_migrate_unfinished_tail \
-      "$dir" "$DEVLOG_FILE" "$resolved" "$HANDOFF_FILE" "$resolved_handoff"
+      "$dir" "$DEVLOG_FILE" "$resolved" "$HANDOFF_FILE" "$resolved_handoff" "$origin"
     devlog_lock_release
   fi
   DEVLOG_FILE="$resolved"
   # shellcheck disable=SC2034 # consumed by callers (e.g. enforce-devlog.sh), not used in this file
   HANDOFF_FILE="$resolved_handoff"
+  DEVLOG_ORIGIN="$origin"
 }

package/core/scripts/keep-all.js

@@ -0,0 +1,454 @@
+'use strict';
+// /devlog-tracker:keep-all (docs/design/keep-all.md): scan every devlog file
+// in .devlog/ and, after the user confirms a plan, move Rounds from any of
+// them into topic files in one all-or-nothing run. keep-all.sh resolves
+// paths, holds the devlog lock and calls this; the functions are exported
+// for keep-all.test.js.
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const { spawnSync } = require('child_process');
+
+const FENCE = /^[ \t]*```/;
+const ORIGIN = /^<!-- devlog-origin: (branch|detached)=(.*) -->$/;
+const KEPT_HEAD = '# Kept log';
+
+// Splits a devlog file into `## ` blocks, ignoring headings inside ```
+// fences (same rule as devlog-md.sh). Lines before the first block are the
+// prefix (project summary, origin marker, kept provenance header).
+function parseBlocks(text) {
+  const lines = text.replace(/\n$/, '').split('\n');
+  if (text === '') lines.length = 0;
+  const starts = [];
+  let fence = false;
+  lines.forEach((line, i) => {
+    if (FENCE.test(line)) { fence = !fence; return; }
+    if (!fence && line.startsWith('## ')) starts.push(i);
+  });
+  const blocks = starts.map((start, k) => {
+    const end = k + 1 < starts.length ? starts[k + 1] - 1 : lines.length - 1;
+    const heading = lines[start];
+    const m = heading.match(/^## Round (\d+)/);
+    const block = { start, end, heading, round: m ? Number(m[1]) : null, ts: '', status: '' };
+    if (m) {
+      const t = heading.match(/ — (.*)$/);
+      block.ts = t ? t[1].trim() : '';
+      block.status = roundStatus(lines.slice(start, end + 1));
+    }
+    return block;
+  });
+  return { lines, blocks, firstBlock: starts.length ? starts[0] : lines.length };
+}
+
+function roundStatus(lines) {
+  let fence = false, inStatus = false, value = '';
+  for (const line of lines) {
+    if (FENCE.test(line)) { fence = !fence; continue; }
+    if (fence) continue;
+    if (/^### Status\s*$/.test(line)) { inStatus = true; value = ''; continue; }
+    if (/^### /.test(line)) { inStatus = false; continue; }
+    if (inStatus && line.trim() !== '') value = line.trim();
+  }
+  return value;
+}
+
+function tsKey(ts) {
+  const iso = ts.replace(/([+-]\d\d)(\d\d)$/, '$1:$2');
+  const t = Date.parse(iso);
+  return Number.isNaN(t) ? Infinity : t;
+}
+
+function git(projectDir, args) {
+  const r = spawnSync('git', ['-C', projectDir, ...args], { encoding: 'utf8' });
+  return r.status === 0 ? r.stdout.trim() : null;
+}
+
+function branchState(projectDir, name) {
+  if (git(projectDir, ['show-ref', '--verify', '--quiet', `refs/heads/${name}`]) === null) {
+    return git(projectDir, ['rev-parse', '--git-dir']) === null ? 'unknown' : 'gone';
+  }
+  const base = (git(projectDir, ['for-each-ref', '--format=%(refname:short)', 'refs/heads/']) || '')
+    .split('\n').find(b => /^(main|master)$/i.test(b));
+  if (!base || base === name) return 'active';
+  return git(projectDir, ['merge-base', '--is-ancestor', name, base]) === null ? 'active' : 'merged';
+}
+
+function classify(file, text, c) {
+  if (/^devlog\.lessons\..*\.md$/.test(file)) return null;
+  if (file === c.current) return 'current';
+  if (file === 'devlog.archive.md') return 'archive';
+  if (text.split('\n', 1)[0] === KEPT_HEAD) return 'kept';
+  return 'branch';
+}
+
+function describeOrigin(src, text, c) {
+  if (src.kind !== 'current' && src.kind !== 'branch') return;
+  const m = text.split('\n', 1)[0].match(ORIGIN);
+  if (m) {
+    src.origin = m[2]; src.originFrom = 'marker';
+    src.state = m[1] === 'branch' ? branchState(c.projectDir, m[2]) : 'n/a';
+  } else if (src.file === 'devlog.md') {
+    src.origin = 'main'; src.originFrom = 'default'; src.state = 'n/a';
+  } else if (src.kind === 'current' && c.origin) {
+    const [kind, name] = [c.origin.slice(0, c.origin.indexOf('=')), c.origin.slice(c.origin.indexOf('=') + 1)];
+    src.origin = name; src.originFrom = 'env';
+    src.state = kind === 'branch' ? branchState(c.projectDir, name) : 'n/a';
+  } else {
+    src.origin = src.file.replace(/^devlog\./, '').replace(/\.md$/, '');
+    src.originFrom = 'filename';
+    const st = branchState(c.projectDir, src.origin);
+    src.state = st === 'gone' ? 'unknown' : st;
+  }
+}
+
+function sha(s) {
+  return crypto.createHash('sha1').update(s).digest('hex');
+}
+
+function scan(c) {
+  const files = fs.existsSync(c.devlogDir)
+    ? fs.readdirSync(c.devlogDir).filter(f => /^devlog.*\.md$/.test(f)).sort()
+    : [];
+  const sources = [];
+  const rounds = [];
+  files.forEach((file, order) => {
+    const text = fs.readFileSync(path.join(c.devlogDir, file), 'utf8');
+    const kind = classify(file, text, c);
+    if (!kind) return;
+    const parsed = parseBlocks(text);
+    const src = { file, kind, text, parsed };
+    describeOrigin(src, text, c);
+    sources.push(src);
+    const rb = parsed.blocks.filter(b => b.round !== null);
+    let lastDone = -1;
+    rb.forEach((b, i) => { if (b.status === 'DONE') lastDone = i; });
+    rb.forEach((b, i) => {
+      let movable = true;
+      if (kind === 'current' && String(b.round) === String(c.open)) movable = false;
+      if (kind === 'branch' && i > lastDone) movable = false;
+      rounds.push({
+        file, kind, order, block: b, round: b.round, ts: b.ts, status: b.status, movable,
+        line: b.start + 1, text: parsed.lines.slice(b.start, b.end + 1).join('\n'),
+      });
+    });
+  });
+  rounds.sort((a, b) => tsKey(a.ts) - tsKey(b.ts) || a.order - b.order || a.line - b.line);
+  rounds.forEach((r, i) => { r.id = i + 1; });
+  return { sources, rounds, fingerprint: fingerprint(sources, rounds, rounds.length) };
+}
+
+// Covers the scanned Rounds and every non-current source, not whole files:
+// between scan and apply, Stop merges the proposal turn's Round into the
+// current file (and may create it), which must not invalidate the plan.
+function fingerprint(sources, rounds, count) {
+  const parts = sources.filter(s => s.kind !== 'current').map(s => `S ${s.file} ${s.kind}`);
+  for (const r of rounds.slice(0, count)) parts.push(`R ${r.file} ${r.block.heading} ${r.movable} ${sha(r.text)}`);
+  return sha(parts.join('\n')).slice(0, 16);
+}
+
+function formatScan(s) {
+  if (!s.rounds.some(r => r.movable)) return 'NOTHING\n';
+  const out = [`FINGERPRINT=${s.fingerprint} COUNT=${s.rounds.length}`];
+  for (const src of s.sources) {
+    let line = `SOURCE file=${src.file} kind=${src.kind}`;
+    if (src.origin !== undefined) line += ` origin=${src.origin} origin_from=${src.originFrom} state=${src.state}`;
+    out.push(line);
+  }
+  for (const r of s.rounds) {
+    out.push(`ROUND id=${r.id} file=${r.file} round=${r.round} line=${r.line} ts=${r.ts || '-'} status=${r.status || '-'} movable=${r.movable ? 1 : 0}`);
+  }
+  return out.join('\n') + '\n';
+}
+
+function normalizeName(raw) {
+  if (raw === 'devlog.md') return null;
+  let n = raw.trim();
+  if (n.startsWith('devlog.')) n = n.slice(7);
+  if (n.endsWith('.md')) n = n.slice(0, -3);
+  n = n.replace(/\s/g, '-').replace(/-+/g, '-').replace(/^-|-$/g, '');
+  if (!n || n === 'archive' || /^lessons\./.test(n) || /[/\\]|\.\./.test(n) || n.length > 64) return null;
+  return n;
+}
+
+function parsePlan(planText) {
+  const segs = [];
+  for (const line of planText.split('\n')) {
+    if (line.trim() === '') continue;
+    const [name = '', desc = '', ids = ''] = line.split('\t');
+    const list = [];
+    for (const part of ids.split(',').map(p => p.trim()).filter(Boolean)) {
+      const m = part.match(/^(\d+)(?:-(\d+))?$/);
+      if (!m) throw new Error(`id 清單格式錯誤：${part}`);
+      const a = Number(m[1]), b = m[2] ? Number(m[2]) : a;
+      if (a > b) throw new Error(`id 範圍起點大於終點：${part}`);
+      for (let i = a; i <= b; i++) list.push(i);
+    }
+    segs.push({ rawName: name.trim(), desc: desc.replace(/[\r\n]+/g, ' ').trim(), ids: list });
+  }
+  if (!segs.length) throw new Error('計畫是空的');
+  return segs;
+}
+
+function trimBlank(lines) {
+  let a = 0, b = lines.length;
+  while (a < b && lines[a].trim() === '') a++;
+  while (b > a && lines[b - 1].trim() === '') b--;
+  return lines.slice(a, b);
+}
+
+function joinPieces(pieces) {
+  const kept = pieces.map(trimBlank).filter(p => p.length);
+  return kept.map(p => p.join('\n')).join('\n\n') + (kept.length ? '\n' : '');
+}
+
+function ranges(nums) {
+  const s = [...nums].sort((a, b) => a - b);
+  const out = [];
+  for (let i = 0; i < s.length; i++) {
+    let j = i;
+    while (j + 1 < s.length && s[j + 1] === s[j] + 1) j++;
+    out.push(i === j ? `${s[i]}` : `${s[i]}-${s[j]}`);
+    i = j;
+  }
+  return out.join(', ');
+}
+
+function nowIso() {
+  const d = new Date();
+  const pad = n => String(Math.abs(n)).padStart(2, '0');
+  const off = -d.getTimezoneOffset();
+  return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}T${pad(d.getHours())}:` +
+    `${pad(d.getMinutes())}:${pad(d.getSeconds())}${off >= 0 ? '+' : '-'}${pad(Math.trunc(off / 60))}:${pad(off % 60)}`;
+}
+
+// Kept files begin with "# Kept log", then blank / "- key: value" lines.
+function keptHeaderEnd(lines, firstBlock) {
+  let i = 1;
+  while (i < firstBlock && (lines[i].trim() === '' || lines[i].startsWith('- '))) i++;
+  return i;
+}
+
+function apply(c, planText, expected, count) {
+  const s = scan(c);
+  if (s.rounds.length < count || fingerprint(s.sources, s.rounds, count) !== expected) {
+    throw new Error('fingerprint 不符：scan 之後 devlog 檔已被改動，請重新執行 keep-all');
+  }
+  const segs = parsePlan(planText);
+  const byId = new Map(s.rounds.slice(0, count).map(r => [r.id, r]));
+  const owner = new Map();
+  const errors = [];
+  const consumed = new Set(s.sources.filter(x => x.kind === 'kept' && x.parsed.blocks.some(b => b.round !== null)).map(x => x.file));
+
+  segs.forEach((seg, i) => {
+    seg.name = normalizeName(seg.rawName);
+    if (!seg.name) { errors.push(`第 ${i + 1} 段檔名無效：${seg.rawName}`); return; }
+    seg.file = `devlog.${seg.name}.md`;
+    if (segs.findIndex(o => o.file === seg.file) !== i) errors.push(`第 ${i + 1} 段檔名與其他段重複：${seg.file}`);
+    if (fs.existsSync(path.join(c.devlogDir, seg.file)) && !consumed.has(seg.file)) {
+      errors.push(`第 ${i + 1} 段目標檔已存在：${seg.file}`);
+    }
+    if (!seg.ids.length) errors.push(`第 ${i + 1} 段沒有任何 Round`);
+    for (const id of seg.ids) {
+      const r = byId.get(id);
+      if (!r) errors.push(`#${id} 不存在`);
+      else if (!r.movable) errors.push(`#${id}（${r.file} Round ${r.round}）不可搬`);
+      else if (owner.has(id)) errors.push(`#${id} 重複出現在兩段`);
+      else owner.set(id, seg);
+    }
+  });
+  for (const r of byId.values()) {
+    if (r.kind === 'kept' && !owner.has(r.id)) errors.push(`#${r.id}（${r.file} Round ${r.round}）是既有 kept 檔的 Round，必須分進某一段`);
+  }
+  if (errors.length) throw new Error(errors.join('\n'));
+
+  // Assign every block of every source: moved Rounds to their segment,
+  // Checkpoints (any block, for kept files) along with the Round before them.
+  const pieces = new Map(segs.map(seg => [seg, []])); // seg -> [{id, sub, lines}]
+  const prefixes = new Map(segs.map(seg => [seg, []]));
+  const rewritten = new Map(); // file -> new text | null (delete)
+  const movedFromCurrent = new Set();
+
+  for (const src of s.sources) {
+    const { lines, blocks, firstBlock } = src.parsed;
+    const roundOf = new Map(s.rounds.filter(r => r.file === src.file).map(r => [r.block, r]));
+    const stay = [];
+    let prev = null; // last Round block's {seg, id}
+    let pendingKept = []; // kept-file blocks before the first Round
+    let touched = false;
+    blocks.forEach((b, k) => {
+      const blines = lines.slice(b.start, b.end + 1);
+      const r = roundOf.get(b);
+      if (r) {
+        const seg = owner.get(r.id);
+        prev = seg ? { seg, id: r.id, sub: 0 } : null;
+        if (seg) {
+          touched = true;
+          pieces.get(seg).push({ id: r.id, sub: 0, lines: blines });
+          if (src.kind === 'current') movedFromCurrent.add(r.round);
+          for (const p of pendingKept) pieces.get(seg).push({ id: r.id, sub: -1 + p.k / 1e6, lines: p.lines });
+          pendingKept = [];
+        } else stay.push(blines);
+        return;
+      }
+      const follows = src.kind === 'kept' || b.heading.startsWith('## Checkpoint');
+      if (follows && prev) {
+        prev.sub += 1;
+        pieces.get(prev.seg).push({ id: prev.id, sub: prev.sub, lines: blines });
+        touched = true;
+      } else if (src.kind === 'kept' && !prev) {
+        pendingKept.push({ k, lines: blines });
+      } else {
+        stay.push(blines);
+      }
+    });
+
+    if (src.kind === 'kept' && consumed.has(src.file)) {
+      const first = s.rounds.find(r => r.file === src.file);
+      const hEnd = keptHeaderEnd(lines, firstBlock);
+      prefixes.get(owner.get(first.id)).push({ id: first.id, lines: lines.slice(hEnd, firstBlock) });
+      rewritten.set(src.file, null);
+      continue;
+    }
+    if (!touched) continue;
+    const text = joinPieces([lines.slice(0, firstBlock), ...stay]);
+    const left = stay.length && parseBlocks(text).blocks.some(b => b.round !== null);
+    rewritten.set(src.file, src.kind === 'archive' && !left && trimBlank(lines.slice(0, firstBlock)).length === 0 ? null : text);
+  }
+
+  // Kept index: drop lines pointing at deleted kept files everywhere, add
+  // the new files to the current file's index.
+  const deletedKept = [...consumed].filter(f => !segs.some(seg => seg.file === f));
+  const reused = [...consumed].filter(f => segs.some(seg => seg.file === f));
+  const staleIndex = new Set([...deletedKept, ...reused]);
+  const keptAt = nowIso();
+  const newIndex = segs.map(seg => {
+    const n = pieces.get(seg).filter(p => p.sub === 0).length;
+    return `- \`${seg.file}\`：keep-all，${n} 輪，kept_at ${keptAt}${seg.desc ? `，${seg.desc}` : ''}`;
+  });
+  for (const src of s.sources) {
+    if (rewritten.get(src.file) === null) continue;
+    const base = rewritten.has(src.file) ? rewritten.get(src.file) : src.text;
+    const updated = rewriteIndex(base, staleIndex, src.kind === 'current' ? newIndex : []);
+    if (updated !== base) rewritten.set(src.file, updated);
+  }
+  if (!s.sources.some(x => x.kind === 'current')) {
+    const head = c.origin ? `<!-- devlog-origin: ${c.origin} -->\n` : '';
+    rewritten.set(c.current, rewriteIndex(head, staleIndex, newIndex));
+  }
+
+  // Build targets.
+  const targets = new Map();
+  for (const seg of segs) {
+    const ps = pieces.get(seg).sort((a, b) => a.id - b.id || a.sub - b.sub);
+    const perFile = new Map();
+    for (const id of seg.ids) {
+      const r = byId.get(id);
+      if (!perFile.has(r.file)) perFile.set(r.file, []);
+      perFile.get(r.file).push(r.round);
+    }
+    const header = ['# Kept log', '', '- source: keep-all',
+      ...[...perFile].map(([f, ns]) => `- rounds: ${f} ${ranges(ns)}`), `- kept_at: ${keptAt}`];
+    const pre = prefixes.get(seg).sort((a, b) => a.id - b.id).map(p => p.lines);
+    targets.set(seg.file, joinPieces([header, ...pre, ...ps.map(p => p.lines)]));
+  }
+
+  // Verify: every moved Round lands exactly once, none stays behind.
+  const movedCount = owner.size;
+  let inTargets = 0;
+  for (const text of targets.values()) inTargets += parseBlocks(text).blocks.filter(b => b.round !== null).length;
+  let before = 0, after = 0;
+  for (const src of s.sources) {
+    if (!rewritten.has(src.file)) continue;
+    before += src.parsed.blocks.filter(b => b.round !== null).length;
+    const t = rewritten.get(src.file);
+    if (t !== null) after += parseBlocks(t).blocks.filter(b => b.round !== null).length;
+  }
+  if (inTargets !== movedCount || before - after !== movedCount) {
+    throw new Error(`搬移驗證失敗：預期 ${movedCount} 輪，目標檔 ${inTargets} 輪，來源減少 ${before - after} 輪；未寫入任何檔`);
+  }
+
+  // Backup, then commit: targets first, then rewritten sources, then deletions.
+  const stamp = keptAt.slice(0, 19).replace(/[-:]/g, '').replace('T', '-');
+  const backup = path.join(c.devlogDir, '.keep-all-backup', stamp);
+  fs.mkdirSync(backup, { recursive: true });
+  for (const file of rewritten.keys()) {
+    const p = path.join(c.devlogDir, file);
+    if (fs.existsSync(p)) fs.copyFileSync(p, path.join(backup, file));
+  }
+  const out = [];
+  try {
+    const writeAtomic = (file, text) => {
+      const p = path.join(c.devlogDir, file);
+      fs.writeFileSync(`${p}.keep-all.tmp`, text);
+      fs.renameSync(`${p}.keep-all.tmp`, p);
+    };
+    for (const [file, text] of targets) {
+      writeAtomic(file, text);
+      out.push(`KEPT=${path.join(c.devlogDir, file)} ROUNDS=${pieces.get(segs.find(x => x.file === file)).filter(p => p.sub === 0).length}`);
+    }
+    for (const [file, text] of rewritten) {
+      if (text === null) {
+        if (targets.has(file)) continue; // reused name: already replaced
+        fs.rmSync(path.join(c.devlogDir, file), { force: true });
+        out.push(`DELETED=${path.join(c.devlogDir, file)}`);
+      } else writeAtomic(file, text);
+    }
+  } catch (e) {
+    throw new Error(`寫入途中失敗：${e.message}\n原始檔備份在 ${backup}`);
+  }
+
+  const span = path.join(c.devlogDir, '.span-open');
+  if (fs.existsSync(span)) {
+    const m = fs.readFileSync(span, 'utf8').match(/"round"\s*:\s*(\d+)/);
+    if (m && movedFromCurrent.has(Number(m[1]))) fs.rmSync(span, { force: true });
+  }
+  out.push(`BACKUP=${backup}`);
+  return out.join('\n') + '\n';
+}
+
+// Removes index lines naming a file in `stale`, appends `add` to the
+// `## Kept 索引` block (created at the end if missing). A block left
+// with no lines is dropped.
+function rewriteIndex(text, stale, add) {
+  const { lines, blocks, firstBlock } = parseBlocks(text);
+  const idx = blocks.find(b => b.heading.startsWith('## Kept 索引'));
+  const named = l => stale.has((l.match(/`(devlog\.[^`]+\.md)`/) || [])[1]);
+  if (!idx) return add.length ? joinPieces([lines, ['## Kept 索引', ...add]]) : text;
+  const body = lines.slice(idx.start + 1, idx.end + 1);
+  if (!add.length && !body.some(named)) return text;
+  const kept = [...trimBlank(body.filter(l => !named(l))), ...add];
+  const pieces = [lines.slice(0, firstBlock)];
+  for (const b of blocks) {
+    if (b !== idx) pieces.push(lines.slice(b.start, b.end + 1));
+    else if (kept.length) pieces.push(['## Kept 索引', ...kept]);
+  }
+  return joinPieces(pieces);
+}
+
+function main(argv) {
+  const opts = {};
+  for (let i = 0; i < argv.length; i++) {
+    const k = argv[i];
+    if (k === '--scan') opts.scan = true;
+    else if (['--dir', '--project', '--current', '--open', '--origin', '--apply', '--fingerprint', '--count'].includes(k)) opts[k.slice(2)] = argv[++i] ?? '';
+    else { process.stderr.write(`未知參數：${k}\n`); return 2; }
+  }
+  const c = { devlogDir: opts.dir, projectDir: opts.project, current: opts.current, open: opts.open || '', origin: opts.origin || '' };
+  try {
+    if (opts.scan) { process.stdout.write(formatScan(scan(c))); return 0; }
+    if (opts.apply) {
+      const plan = fs.readFileSync(opts.apply, 'utf8');
+      process.stdout.write(apply(c, plan, opts.fingerprint || '', Number(opts.count || 0)));
+      return 0;
+    }
+    process.stderr.write('需要 --scan 或 --apply\n');
+    return 2;
+  } catch (e) {
+    process.stderr.write(`${e.message}\n`);
+    return 1;
+  }
+}
+
+module.exports = { parseBlocks, scan, apply, formatScan, normalizeName, parsePlan };
+
+if (require.main === module) process.exitCode = main(process.argv.slice(2));

package/core/scripts/keep-all.sh

@@ -0,0 +1,30 @@
+#!/usr/bin/env bash
+# /devlog-tracker:keep-all (docs/design/keep-all.md). Resolves the current
+# branch's devlog, holds the devlog lock, and hands off to keep-all.js:
+#   keep-all.sh --scan
+#   keep-all.sh --apply <plan.tsv> --fingerprint <fp> --count <n>
+set -uo pipefail
+
+_src="${BASH_SOURCE[0]}"
+SCRIPT_DIR="$(cd "${_src%/*}" && pwd)"
+
+# Checked before sourcing anything: Claude plugin users may not have Node.
+command -v node >/dev/null 2>&1 || { echo "NO_NODE"; exit 0; }
+
+# shellcheck source=devlog-path.sh
+. "$SCRIPT_DIR/devlog-path.sh"
+# shellcheck source=json-field.sh
+. "$SCRIPT_DIR/json-field.sh"
+
+PROJECT_DIR="${DEVLOG_PROJECT_DIR:-${CLAUDE_PROJECT_DIR:-.}}"
+devlog_resolve_paths "$PROJECT_DIR"
+[ -d "$DEVLOG_DIR" ] || { echo "NOTHING"; exit 0; }
+
+OPEN=""
+[ ! -f "$DEVLOG_DIR/.round-open" ] || OPEN="$(json_int_get "$DEVLOG_DIR/.round-open" round)"
+
+devlog_lock_acquire
+trap 'devlog_lock_release' EXIT
+node "$SCRIPT_DIR/keep-all.js" "$@" \
+  --dir "$DEVLOG_DIR" --project "$PROJECT_DIR" --current "${DEVLOG_FILE##*/}" \
+  --open "$OPEN" --origin "${DEVLOG_ORIGIN:-}"

package/core/scripts/keep-all.test.js

@@ -0,0 +1,210 @@
+'use strict';
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { parseBlocks, scan, apply, formatScan } = require('./keep-all');
+
+function round(n, ts, status, body = `round ${n} body`) {
+  return `## Round ${n} — ${ts}\n\n### Summary\n${body}\n\n### Status\n${status}\n`;
+}
+
+function setup(files) {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'keep-all-'));
+  const devlogDir = path.join(dir, '.devlog');
+  fs.mkdirSync(devlogDir);
+  for (const [name, text] of Object.entries(files)) fs.writeFileSync(path.join(devlogDir, name), text);
+  return devlogDir;
+}
+
+function ctx(devlogDir, extra = {}) {
+  return { devlogDir, projectDir: path.dirname(devlogDir), current: 'devlog.md', open: '', origin: '', ...extra };
+}
+
+const read = (d, f) => fs.readFileSync(path.join(d, f), 'utf8');
+const exists = (d, f) => fs.existsSync(path.join(d, f));
+
+function idsOf(result, file, rounds) {
+  return result.rounds.filter(r => r.file === file && rounds.includes(r.round)).map(r => r.id);
+}
+
+test('parseBlocks is fence-aware and reads round number, timestamp and status', () => {
+  const text = '# head\n\n' + round(1, '2026-09-01T10:00:00+0800', 'DONE',
+    '```\n## Round 99 — fake\n```') + '\n## Checkpoint — x\n\ncp\n';
+  const { blocks, firstBlock } = parseBlocks(text);
+  assert.equal(firstBlock, 2);
+  assert.equal(blocks.length, 2);
+  assert.equal(blocks[0].round, 1);
+  assert.equal(blocks[0].status, 'DONE');
+  assert.equal(blocks[0].ts, '2026-09-01T10:00:00+0800');
+  assert.equal(blocks[1].round, null);
+});
+
+test('scan classifies sources and marks what is movable', () => {
+  const d = setup({
+    'devlog.md': '# proj\n\n' + round(1, '2026-09-01T10:00:00+0800', 'DONE') + '\n' +
+      round(2, '2026-09-01T11:00:00+0800', 'DONE') + '\n' + round(3, '2026-09-05T10:00:00+0800', 'IN_PROGRESS'),
+    'devlog.feat-x.md': '<!-- devlog-origin: branch=feat/x -->\n\n' +
+      round(1, '2026-09-02T10:00:00+0800', 'DONE') + '\n' + round(2, '2026-09-02T11:00:00+0800', 'IN_PROGRESS'),
+    'devlog.legacy.md': round(1, '2026-09-03T10:00:00+0800', 'DONE'),
+    'devlog.archive.md': round(1, '2026-08-01T10:00:00+0800', 'DONE'),
+    'devlog.topic.md': '# Kept log\n\n- source: `.devlog/devlog.md`\n- rounds: 5-5\n- kept_at: x\n\n' +
+      round(5, '2026-08-15T10:00:00+0800', 'DONE'),
+    'devlog.lessons.git.md': '# lessons\n',
+  });
+  const r = scan(ctx(d, { open: '3' }));
+  const kind = Object.fromEntries(r.sources.map(s => [s.file, s.kind]));
+  assert.deepEqual(kind, {
+    'devlog.archive.md': 'archive', 'devlog.feat-x.md': 'branch', 'devlog.legacy.md': 'branch',
+    'devlog.md': 'current', 'devlog.topic.md': 'kept',
+  });
+  const fx = r.sources.find(s => s.file === 'devlog.feat-x.md');
+  assert.equal(fx.origin, 'feat/x');
+  assert.equal(fx.originFrom, 'marker');
+  assert.equal(r.sources.find(s => s.file === 'devlog.legacy.md').originFrom, 'filename');
+  // global ids ordered by timestamp
+  assert.deepEqual(r.rounds.map(x => `${x.file}:${x.round}`), [
+    'devlog.archive.md:1', 'devlog.topic.md:5', 'devlog.md:1', 'devlog.md:2',
+    'devlog.feat-x.md:1', 'devlog.feat-x.md:2', 'devlog.legacy.md:1', 'devlog.md:3',
+  ]);
+  const mov = x => r.rounds.find(y => `${y.file}:${y.round}` === x).movable;
+  assert.equal(mov('devlog.md:3'), false, 'open round');
+  assert.equal(mov('devlog.feat-x.md:2'), false, 'branch unfinished tail');
+  assert.equal(mov('devlog.feat-x.md:1'), true);
+  assert.match(formatScan(r), /^FINGERPRINT=\S+ COUNT=8\n/);
+});
+
+test('scan reports NOTHING when no round is movable', () => {
+  const d = setup({ 'devlog.md': round(1, '2026-09-01T10:00:00+0800', 'IN_PROGRESS') });
+  const r = scan(ctx(d, { open: '1' }));
+  assert.equal(formatScan(r), 'NOTHING\n');
+});
+
+function world() {
+  return setup({
+    'devlog.md': '# proj\n\n' + round(1, '2026-09-01T10:00:00+0800', 'DONE') +
+      '\n## Checkpoint — Round 1-1\n\ncp one\n\n' + round(2, '2026-09-01T11:00:00+0800', 'DONE') +
+      '\n## Kept 索引\n- `devlog.topic.md`：Round 5-5，kept_at x\n- `devlog.other.md`：Round 9-9，kept_at x\n',
+    'devlog.feat-x.md': '<!-- devlog-origin: branch=feat/x -->\n\n' +
+      round(1, '2026-09-02T10:00:00+0800', 'DONE') + '\n' + round(2, '2026-09-02T11:00:00+0800', 'IN_PROGRESS'),
+    'devlog.archive.md': round(1, '2026-08-01T10:00:00+0800', 'DONE'),
+    'devlog.topic.md': '# Kept log\n\n- source: `.devlog/devlog.md`\n- rounds: 5-5\n- kept_at: x\n\nold summary\n\n' +
+      round(5, '2026-08-15T10:00:00+0800', 'DONE'),
+    'devlog.other.md': '# Kept log\n\n- rounds: 9-9\n\n' + round(9, '2026-08-20T10:00:00+0800', 'DONE'),
+  });
+}
+
+test('apply moves a cross-file topic into one file in time order and consumes kept files', () => {
+  const d = world();
+  const c = ctx(d);
+  const s = scan(c);
+  const a = [...idsOf(s, 'devlog.archive.md', [1]), ...idsOf(s, 'devlog.topic.md', [5]), ...idsOf(s, 'devlog.feat-x.md', [1])];
+  const b = [...idsOf(s, 'devlog.other.md', [9]), ...idsOf(s, 'devlog.md', [1])];
+  const plan = `alpha\tfirst topic\t${a.join(',')}\nbeta\t\t${b.join(',')}\n`;
+  const out = apply(c, plan, s.fingerprint, s.rounds.length);
+
+  const alpha = read(d, 'devlog.alpha.md');
+  assert.match(alpha, /^# Kept log\n\n- source: keep-all\n/);
+  assert.match(alpha, /- rounds: devlog\.archive\.md 1\n/);
+  assert.match(alpha, /old summary/, 'kept file summary travels with its first round');
+  const order = [...alpha.matchAll(/^## Round (\d+) — (\S+)/gm)].map(m => m[2]);
+  assert.deepEqual(order, ['2026-08-01T10:00:00+0800', '2026-08-15T10:00:00+0800', '2026-09-02T10:00:00+0800']);
+
+  const beta = read(d, 'devlog.beta.md');
+  assert.match(beta, /## Round 1 — 2026-09-01T10:00:00\+0800[\s\S]*## Checkpoint — Round 1-1/, 'checkpoint follows its round');
+
+  assert.ok(!exists(d, 'devlog.topic.md') && !exists(d, 'devlog.other.md'), 'kept sources deleted');
+  assert.ok(!exists(d, 'devlog.archive.md'), 'empty archive deleted');
+  const main = read(d, 'devlog.md');
+  assert.match(main, /^# proj\n/);
+  assert.ok(!/Round 1 —/.test(main) && /Round 2 —/.test(main));
+  assert.ok(!/Checkpoint/.test(main));
+  assert.ok(!/devlog\.topic\.md|devlog\.other\.md/.test(main), 'ghost index lines removed');
+  assert.match(main, /- `devlog\.alpha\.md`：keep-all，3 輪，kept_at \S+，first topic\n/);
+  assert.match(main, /- `devlog\.beta\.md`：keep-all，2 輪，kept_at \S+\n/);
+
+  const fx = read(d, 'devlog.feat-x.md');
+  assert.match(fx, /^<!-- devlog-origin: branch=feat\/x -->\n/);
+  assert.ok(!/Round 1 —/.test(fx) && /Round 2 —/.test(fx));
+
+  assert.match(out, /^KEPT=.*devlog\.alpha\.md ROUNDS=3$/m);
+  assert.match(out, /^DELETED=.*devlog\.topic\.md$/m);
+  const backup = out.match(/^BACKUP=(.*)$/m)[1];
+  assert.ok(fs.existsSync(path.join(backup, 'devlog.topic.md')));
+  assert.ok(fs.existsSync(path.join(backup, 'devlog.md')));
+});
+
+test('apply may reuse the name of a kept file it consumes', () => {
+  const d = world();
+  const c = ctx(d);
+  const s = scan(c);
+  const all = [...idsOf(s, 'devlog.topic.md', [5]), ...idsOf(s, 'devlog.other.md', [9])];
+  apply(c, `topic\t\t${all.join(',')}\n`, s.fingerprint, s.rounds.length);
+  assert.match(read(d, 'devlog.topic.md'), /- source: keep-all/);
+  assert.match(read(d, 'devlog.md'), /- `devlog\.topic\.md`：keep-all，2 輪/);
+});
+
+function snapshot(d) {
+  return Object.fromEntries(fs.readdirSync(d).map(f => [f, fs.readFileSync(path.join(d, f), 'utf8')]));
+}
+
+for (const [label, planFor, pattern] of [
+  ['uncovered kept round', s => `a\t\t${idsOf(s, 'devlog.topic.md', [5])}\n`, /devlog\.other\.md/],
+  ['id in two segments', s => {
+    const k = [...idsOf(s, 'devlog.topic.md', [5]), ...idsOf(s, 'devlog.other.md', [9])].join(',');
+    return `a\t\t${k}\nb\t\t${idsOf(s, 'devlog.topic.md', [5])}\n`;
+  }, /重複/],
+  ['unmovable round', s => {
+    const k = [...idsOf(s, 'devlog.topic.md', [5]), ...idsOf(s, 'devlog.other.md', [9])].join(',');
+    return `a\t\t${k},${idsOf(s, 'devlog.feat-x.md', [2])}\n`;
+  }, /不可搬/],
+  ['collision with an existing branch file', s => {
+    const k = [...idsOf(s, 'devlog.topic.md', [5]), ...idsOf(s, 'devlog.other.md', [9])].join(',');
+    return `feat-x\t\t${k}\n`;
+  }, /已存在/],
+  ['reserved name', s => {
+    const k = [...idsOf(s, 'devlog.topic.md', [5]), ...idsOf(s, 'devlog.other.md', [9])].join(',');
+    return `archive\t\t${k}\n`;
+  }, /檔名無效/],
+]) {
+  test(`apply rejects ${label} and writes nothing`, () => {
+    const d = world();
+    const c = ctx(d);
+    const s = scan(c);
+    const before = snapshot(d);
+    assert.throws(() => apply(c, planFor(s), s.fingerprint, s.rounds.length), pattern);
+    assert.deepEqual(snapshot(d), before);
+  });
+}
+
+test('apply refuses when a scanned round changed, but tolerates a newly appended round', () => {
+  const d = world();
+  const c = ctx(d);
+  const s = scan(c);
+  const k = [...idsOf(s, 'devlog.topic.md', [5]), ...idsOf(s, 'devlog.other.md', [9])].join(',');
+  fs.appendFileSync(path.join(d, 'devlog.md'), '\n' + round(3, '2026-09-10T10:00:00+0800', 'DONE'));
+  const d2 = world();
+  const c2 = ctx(d2);
+  const s2 = scan(c2);
+  fs.writeFileSync(path.join(d2, 'devlog.archive.md'), round(1, '2026-08-01T10:00:00+0800', 'DONE', 'edited'));
+  const before = snapshot(d2);
+  assert.throws(() => apply(c2, `a\t\t${k}\n`, s2.fingerprint, s2.rounds.length), /fingerprint/);
+  assert.deepEqual(snapshot(d2), before);
+  apply(c, `a\t\t${k}\n`, s.fingerprint, s.rounds.length);
+  assert.match(read(d, 'devlog.md'), /Round 3 —/);
+});
+
+test('apply clears .span-open only when its round moved out of current', () => {
+  const d = world();
+  fs.writeFileSync(path.join(d, '.span-open'), '{"round": 1, "ticks": 0}\n');
+  const c = ctx(d);
+  const s = scan(c);
+  const k = [...idsOf(s, 'devlog.topic.md', [5]), ...idsOf(s, 'devlog.other.md', [9]), ...idsOf(s, 'devlog.md', [2])].join(',');
+  apply(c, `a\t\t${k}\n`, s.fingerprint, s.rounds.length);
+  assert.ok(exists(d, '.span-open'));
+  const s2 = scan(c);
+  const k2 = [...s2.rounds.filter(r => r.file === 'devlog.a.md').map(r => r.id), ...idsOf(s2, 'devlog.md', [1])];
+  apply(c, `b\t\t${k2.join(',')}\n`, s2.fingerprint, s2.rounds.length);
+  assert.ok(!exists(d, '.span-open'));
+});

package/core/scripts/keep-move.sh

@@ -97,12 +97,18 @@ while IFS="$(printf '\t')" read -r start heading; do
   esac
 done < "$H2"
 
+# A branch file's origin marker (line 1) is the file's identity, not part
+# of the project summary: it never moves, even on full keep.
+MARKER=0
+[ -z "$(devlog_origin_of "$MAIN")" ] || MARKER=1
+
 KEPT_AT="$(date -Iseconds 2>/dev/null || date '+%Y-%m-%dT%H:%M:%S%z')"
 {
   printf '# Kept log\n\n- source: `.devlog/devlog.md`\n- rounds: %s-%s\n- kept_at: %s\n\n' \
     "$FROM" "$TO" "$KEPT_AT"
-  awk -v selected="$MOVE_BLOCKS" -v full="$FULL" -v first_round="$FIRST_ROUND" '
+  awk -v selected="$MOVE_BLOCKS" -v full="$FULL" -v first_round="$FIRST_ROUND" -v marker="$MARKER" '
     BEGIN { while ((getline n < selected) > 0) move[n] = 1 }
+    marker && NR == 1 { next }
     /^[ \t]*```/ { fence = !fence }
     !fence && /^## / { moving = (NR in move) }
     full && NR < first_round { print; next }
@@ -115,8 +121,9 @@ while read -r start round; do
   grep -Fqx "$heading" "$TARGET" || { echo "具名檔驗證失敗" >&2; exit 1; }
 done < "$MOVE_ROUNDS"
 
-awk -v selected="$MOVE_BLOCKS" -v full="$FULL" -v first_round="$FIRST_ROUND" -v open="$OPEN" '
+awk -v selected="$MOVE_BLOCKS" -v full="$FULL" -v first_round="$FIRST_ROUND" -v open="$OPEN" -v marker="$MARKER" '
   BEGIN { while ((getline n < selected) > 0) move[n] = 1 }
+  marker && NR == 1 { print; next }
   /^[ \t]*```/ { fence = !fence }
   !fence && /^## / { moving = (NR in move) }
   full && NR < first_round { next }

package/core/scripts/round-start.sh

@@ -95,7 +95,7 @@ case "$PROMPT" in
     ;;
 esac
 case "$CMD_NAME" in
-  devlog-tracker:checkpoint|devlog-tracker:clean|devlog-tracker:compact|devlog-tracker:keep|devlog-tracker:lessons|devlog-tracker:lessons-drift|devlog-tracker:lessons-off|devlog-tracker:lessons-on|devlog-tracker:overview|devlog-tracker:pause|devlog-tracker:report|devlog-tracker:search|devlog-tracker:segment-watch|devlog-tracker:span|devlog-tracker:start|devlog-tracker:status|devlog-tracker:timeline)
+  devlog-tracker:checkpoint|devlog-tracker:clean|devlog-tracker:compact|devlog-tracker:keep|devlog-tracker:keep-all|devlog-tracker:lessons|devlog-tracker:lessons-drift|devlog-tracker:lessons-off|devlog-tracker:lessons-on|devlog-tracker:overview|devlog-tracker:pause|devlog-tracker:report|devlog-tracker:search|devlog-tracker:segment-watch|devlog-tracker:span|devlog-tracker:start|devlog-tracker:status|devlog-tracker:timeline)
     exit 0
     ;;
 esac

package/core/scripts/tests/test-devlog-path.sh

@@ -203,6 +203,65 @@ else
   FAIL=1
 fi
 
+# --- origin marker: DEVLOG_ORIGIN reflects the raw branch / detached dir ----
+devlog_resolve_paths "$MAINREPO"
+[ -z "$DEVLOG_ORIGIN" ] \
+  && echo "PASS: main has no DEVLOG_ORIGIN" \
+  || { echo "FAIL: main DEVLOG_ORIGIN=$DEVLOG_ORIGIN"; FAIL=1; }
+devlog_resolve_paths "$NONGIT"
+[ -z "$DEVLOG_ORIGIN" ] \
+  && echo "PASS: non-git has no DEVLOG_ORIGIN" \
+  || { echo "FAIL: non-git DEVLOG_ORIGIN=$DEVLOG_ORIGIN"; FAIL=1; }
+devlog_resolve_paths "$SLASHREPO"
+[ "$DEVLOG_ORIGIN" = "branch=feature/foo" ] \
+  && echo "PASS: DEVLOG_ORIGIN keeps the raw (unsanitized) branch name" \
+  || { echo "FAIL: slash DEVLOG_ORIGIN=$DEVLOG_ORIGIN"; FAIL=1; }
+devlog_resolve_paths "$DETACHEDREPO"
+[ "$DEVLOG_ORIGIN" = "detached=detached-repo" ] \
+  && echo "PASS: detached DEVLOG_ORIGIN names the worktree dir" \
+  || { echo "FAIL: detached DEVLOG_ORIGIN=$DEVLOG_ORIGIN"; FAIL=1; }
+
+# --- origin marker: written as line 1 when the tail migrates -------------
+MARKREPO="$TMP/markrepo"
+mig_repo "$MARKREPO"
+write_main_devlog "$MARKREPO/.devlog/devlog.md" 1:DONE 2:IN_PROGRESS
+git -C "$MARKREPO" checkout -q -b feat/mark
+devlog_resolve_paths "$MARKREPO"
+if [ "$(head -n 1 "$DEVLOG_FILE")" = "<!-- devlog-origin: branch=feat/mark -->" ] \
+  && [ "$(devlog_list_round_starts "$DEVLOG_FILE" | awk '{print $2}' | tr '\n' ' ')" = "2 " ] \
+  && ! grep -q "devlog-origin" "$MARKREPO/.devlog/devlog.md"; then
+  echo "PASS: migrated branch file starts with its origin marker"
+else
+  echo "FAIL: migrated marker"; cat "$DEVLOG_FILE" 2>/dev/null; FAIL=1
+fi
+
+# --- origin marker: first merge into a missing branch file writes it -----
+MERGEREPO="$TMP/mergerepo"
+mig_repo "$MERGEREPO"
+git -C "$MERGEREPO" checkout -q -b feat/merge
+devlog_resolve_paths "$MERGEREPO"
+printf '## Round 1 — t\n\n### Status\nDONE\n' > "$TMP/rc1.md"
+devlog_merge_round_current "$DEVLOG_FILE" "$TMP/rc1.md"
+printf '## Round 2 — t\n\n### Status\nDONE\n' > "$TMP/rc2.md"
+devlog_merge_round_current "$DEVLOG_FILE" "$TMP/rc2.md"
+if [ "$(head -n 1 "$DEVLOG_FILE")" = "<!-- devlog-origin: branch=feat/merge -->" ] \
+  && [ "$(grep -c "devlog-origin" "$DEVLOG_FILE")" = 1 ] \
+  && [ "$(devlog_list_round_starts "$DEVLOG_FILE" | awk '{print $2}' | tr '\n' ' ')" = "1 2 " ]; then
+  echo "PASS: first merge into a new branch file writes the marker once"
+else
+  echo "FAIL: merge marker"; cat "$DEVLOG_FILE" 2>/dev/null; FAIL=1
+fi
+
+# --- origin marker: devlog.md never gets one -----------------------------
+MAINMERGE="$TMP/mainmerge"
+mig_repo "$MAINMERGE"
+devlog_resolve_paths "$MAINMERGE"
+printf '## Round 1 — t\n\n### Status\nDONE\n' > "$TMP/rc3.md"
+devlog_merge_round_current "$DEVLOG_FILE" "$TMP/rc3.md"
+! grep -q "devlog-origin" "$DEVLOG_FILE" \
+  && echo "PASS: devlog.md gets no origin marker" \
+  || { echo "FAIL: devlog.md got a marker"; FAIL=1; }
+
 # --- HANDOFF_FILE mirrors DEVLOG_FILE naming (no rename migration) --------
 devlog_resolve_paths "$NONGIT"
 [ "$HANDOFF_FILE" = "$NONGIT/.devlog/handoff.md" ] \

package/core/scripts/tests/test-keep-all.sh

@@ -0,0 +1,56 @@
+#!/usr/bin/env bash
+# End-to-end check of keep-all.sh in a real git repo: branch-state
+# reporting, current-file resolution, and a full scan → apply cycle.
+# keep-all.js's own rules are covered by core/scripts/keep-all.test.js.
+set -uo pipefail
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+TMP="$(mktemp -d)"
+trap 'rm -rf "$TMP"' EXIT
+FAIL=0
+check() { if eval "$2"; then echo "PASS: $1"; else echo "FAIL: $1"; FAIL=1; fi; }
+round() { printf '## Round %s — %s\n\n### Status\n%s\n\n' "$1" "$2" "$3"; }
+
+command -v node >/dev/null 2>&1 || { echo "SKIP: node not installed"; exit 0; }
+
+R="$TMP/repo"
+mkdir -p "$R/.devlog"
+git -C "$R" init -q
+git -C "$R" -c user.email=t@t.t -c user.name=t commit -q --allow-empty -m init
+git -C "$R" branch -M main
+git -C "$R" branch feat/merged
+git -C "$R" checkout -q -b feat/live
+git -C "$R" -c user.email=t@t.t -c user.name=t commit -q --allow-empty -m live
+export DEVLOG_PROJECT_DIR="$R"
+
+{ printf '# proj\n\n'; round 1 2026-09-01T10:00:00+0800 DONE; } > "$R/.devlog/devlog.md"
+{ printf '<!-- devlog-origin: branch=feat/live -->\n\n'; round 1 2026-09-02T10:00:00+0800 DONE; round 2 2026-09-02T11:00:00+0800 IN_PROGRESS; } > "$R/.devlog/devlog.feat-live.md"
+{ printf '<!-- devlog-origin: branch=feat/merged -->\n\n'; round 1 2026-09-03T10:00:00+0800 DONE; } > "$R/.devlog/devlog.feat-merged.md"
+{ printf '<!-- devlog-origin: branch=feat/deleted -->\n\n'; round 1 2026-09-04T10:00:00+0800 DONE; } > "$R/.devlog/devlog.feat-deleted.md"
+printf '{"round": 2, "opened_at": "now"}\n' > "$R/.devlog/.round-open"
+
+OUT="$(bash "$SCRIPT_DIR/keep-all.sh" --scan)"
+check "current file is the checked-out branch's" 'grep -q "^SOURCE file=devlog.feat-live.md kind=current origin=feat/live origin_from=marker state=active" <<<"$OUT"'
+check "devlog.md off main is a branch source" 'grep -q "^SOURCE file=devlog.md kind=branch origin=main" <<<"$OUT"'
+check "merged branch reported" 'grep -q "file=devlog.feat-merged.md kind=branch origin=feat/merged origin_from=marker state=merged" <<<"$OUT"'
+check "deleted branch reported" 'grep -q "file=devlog.feat-deleted.md kind=branch origin=feat/deleted origin_from=marker state=gone" <<<"$OUT"'
+check "open round not movable" 'grep -q "file=devlog.feat-live.md round=2 .* movable=0" <<<"$OUT"'
+
+FP="$(sed -n 's/^FINGERPRINT=\([^ ]*\) COUNT=.*/\1/p' <<<"$OUT")"
+COUNT="$(sed -n 's/^FINGERPRINT=[^ ]* COUNT=\(.*\)/\1/p' <<<"$OUT")"
+ID_MERGED="$(sed -n 's/^ROUND id=\([0-9]*\) file=devlog.feat-merged.md .*/\1/p' <<<"$OUT")"
+ID_DELETED="$(sed -n 's/^ROUND id=\([0-9]*\) file=devlog.feat-deleted.md .*/\1/p' <<<"$OUT")"
+printf 'old-branches\told branch work\t%s,%s\n' "$ID_MERGED" "$ID_DELETED" > "$TMP/plan.tsv"
+APPLY="$(bash "$SCRIPT_DIR/keep-all.sh" --apply "$TMP/plan.tsv" --fingerprint "$FP" --count "$COUNT")"
+if [ $? -eq 0 ]; then echo "PASS: apply exits 0"; else echo "FAIL: apply exits 0"; FAIL=1; fi
+[ -f "$R/.devlog/devlog.old-branches.md" ] && grep -q "^KEPT=.*devlog.old-branches.md ROUNDS=2" <<<"$APPLY" \
+  && echo "PASS: named file written" || { echo "FAIL: named file written"; FAIL=1; }
+check "branch files keep their marker and are not deleted" '[ "$(head -n 1 "$R/.devlog/devlog.feat-merged.md")" = "<!-- devlog-origin: branch=feat/merged -->" ]'
+check "index written to the current branch file" 'grep -q "devlog.old-branches.md\`：keep-all，2 輪" "$R/.devlog/devlog.feat-live.md"'
+check "lock released" '[ ! -e "$R/.devlog/.lock" ] && [ ! -d "$R/.devlog/.lock.d" ]'
+
+bash "$SCRIPT_DIR/keep-all.sh" --apply "$TMP/plan.tsv" --fingerprint "$FP" --count "$COUNT" >/dev/null 2>"$TMP/err"
+if [ $? -eq 1 ] && grep -q fingerprint "$TMP/err"; then echo "PASS: stale fingerprint rejected"
+else echo "FAIL: stale fingerprint rejected"; FAIL=1; fi
+
+if [ "$FAIL" -eq 0 ]; then echo "All checks passed."; exit 0
+else echo "Some checks FAILED."; exit 1; fi

package/core/scripts/tests/test-keep-move.sh

@@ -123,5 +123,17 @@ case "$LINE_NO_DESC" in
   *) echo "FAIL: index line for no-desc missing: $LINE_NO_DESC"; FAIL=1 ;;
 esac
 
+MARK="$TMP/marker"
+mkdir -p "$MARK/.devlog"
+export CLAUDE_PROJECT_DIR="$MARK"
+printf '<!-- devlog-origin: branch=feat/x -->\n# project\n\n' > "$MARK/.devlog/devlog.md"
+make_round "$MARK/.devlog/devlog.md" 1 DONE
+make_round "$MARK/.devlog/devlog.md" 2 IN_PROGRESS
+printf '%s\n' '{"round": 2, "opened_at": "now"}' > "$MARK/.devlog/.round-open"
+bash "$SCRIPT_DIR/keep-move.sh" --from 1 --to 1 --name all >/dev/null
+assert_eq "full keep leaves origin marker on line 1" "<!-- devlog-origin: branch=feat/x -->" "$(head -n 1 "$MARK/.devlog/devlog.md")"
+grep -q 'devlog-origin' "$MARK/.devlog/devlog.all.md" && { echo "FAIL: marker copied into kept file"; FAIL=1; } || echo "PASS: kept file has no origin marker"
+grep -q '^# project' "$MARK/.devlog/devlog.all.md" && echo "PASS: project summary still moves on full keep" || { echo "FAIL: summary not moved"; FAIL=1; }
+
 if [ "$FAIL" -eq 0 ]; then echo "All checks passed."; exit 0
 else echo "Some checks FAILED."; exit 1; fi

package/core/scripts/tests/test-round-start.sh

@@ -664,8 +664,8 @@ else
 fi
 rm -f "$DEVLOG_DIR/.checkpoint-state"
 
-# --- 19b: report / timeline are admin (read-side) commands too -------------
-for ADMIN_CMD in report timeline; do
+# --- 19b: report / timeline / keep-all are admin commands too -------------
+for ADMIN_CMD in report timeline keep-all; do
   rm -f "$DEVLOG_DIR/.round-current.md" "$DEVLOG_DIR/.round-open"
   printf '{"prompt":"<command-name>/devlog-tracker:%s</command-name>"}' "$ADMIN_CMD" | bash "$SCRIPT_DIR/round-start.sh"
   assert_file_absent "admin $ADMIN_CMD: no .round-current.md" "$DEVLOG_DIR/.round-current.md"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "devlog-tracker",
-  "version": "0.32.0",
+  "version": "0.33.0",
   "description": "npx installer for devlog-tracker's Claude Code, Cursor and Codex adapters.",
   "bin": {
     "devlog-tracker": "bin/devlog-tracker.js"

package/skills/devlog-tracker/SKILL.md

@@ -70,9 +70,10 @@ Summary/Handoff」——後面這句要整句刪掉，不是縮短。
 ## 檔案位置
 
 - 主檔：`.devlog/devlog.md`——在 `main`／`master` 分支上工作時使用
-- 分支主檔：`.devlog/devlog.<branch>.md`——在同一個 worktree 裡切換到其他分支時，主檔會依目前 checkout 的分支自動分開（斜線轉成 `-`）；detached HEAD 退回用 worktree 目錄名。另開一個 `git worktree`（不同目錄）本來就有自己獨立的 `.devlog/`，不受這個機制影響。第一次在某分支偵測到還沒有專屬檔案時，只會把 `devlog.md` 裡還沒完成的尾巴（最後一個 `DONE` 之後的 Round，連同 `handoff.md`）剪到該分支的檔案；`main` 自己的歷史、專案摘要、Checkpoint、Kept／Lessons 索引都留在 `devlog.md`。最後一輪已經是 `DONE`，或切到的是不含目前 `main` 最新 commit 的舊分支時，什麼都不搬，新分支從空檔開始。細節見 `docs/design/branch-scoped-devlog.md`。
+- 分支主檔：`.devlog/devlog.<branch>.md`——在同一個 worktree 裡切換到其他分支時，主檔會依目前 checkout 的分支自動分開（斜線轉成 `-`）；detached HEAD 退回用 worktree 目錄名。另開一個 `git worktree`（不同目錄）本來就有自己獨立的 `.devlog/`，不受這個機制影響。第一次在某分支偵測到還沒有專屬檔案時，只會把 `devlog.md` 裡還沒完成的尾巴（最後一個 `DONE` 之後的 Round，連同 `handoff.md`）剪到該分支的檔案；`main` 自己的歷史、專案摘要、Checkpoint、Kept／Lessons 索引都留在 `devlog.md`。最後一輪已經是 `DONE`，或切到的是不含目前 `main` 最新 commit 的舊分支時，什麼都不搬，新分支從空檔開始。分支檔第一行是 origin 標記 `<!-- devlog-origin: branch=<原始分支名> -->`（detached HEAD 是 `detached=<目錄名>`），由 hook 在建立分支檔時寫入；不要刪改這一行。細節見 `docs/design/branch-scoped-devlog.md`。
 - 歸檔：`.devlog/devlog.archive.md`
-- 具名保存：`.devlog/devlog.<name>.md`（`/devlog-tracker:keep` 搬走的主題檔；SessionStart 不讀這些檔）
+- 具名保存：`.devlog/devlog.<name>.md`（`/devlog-tracker:keep`／`keep-all` 搬走的主題檔，第一行是 `# Kept log`；SessionStart 不讀這些檔）
+- keep-all 備份：`.devlog/.keep-all-backup/<時間戳>/`（`/devlog-tracker:keep-all` 動手前的原始檔複本）
 - 當輪暫存：`.devlog/.round-current.md`（目前開著的那一輪，Claude 該讀寫的是這個檔，不是 `devlog.md`；
   收尾或中斷時由 hook 自動合併回 `devlog.md` 並清空，設計見 `docs/design/round-current-split.md`）
 - Session Handoff 快照：`.devlog/handoff.md`（`main`／`master`）；其他分支 `.devlog/handoff.<branch>.md`。
@@ -314,7 +315,7 @@ Stop hook 會檢查最後一個 Round 是否同時有 `### Summary`、`### Reply
 ### devlog-tracker 自己的管理指令不記錄
 
 這一輪如果是使用者直接呼叫 devlog-tracker 自己的純管理指令——`/devlog-tracker:checkpoint`、
-`clean`、`compact`、`keep`、`lessons`、`lessons-drift`、`lessons-off`、`lessons-on`、
+`clean`、`compact`、`keep`、`keep-all`、`lessons`、`lessons-drift`、`lessons-off`、`lessons-on`、
 `overview`、`pause`、`report`、`search`、`segment-watch`、`span`、`start`、`status`、`timeline`——`round-start.sh`
 會整輪直接放行，不開 Round、不動任何計數器，等於這個 tick 沒發生過；不用、也不會被
 Stop hook 要求補寫 Summary／Reply／Handoff。這些指令本身就是在操作 devlog 系統，不是開發
@@ -425,6 +426,15 @@ hook 會要求補一段。
 讓「哪個主題被搬去哪個檔」不用翻完整份 `devlog.md` 或憑印象猜檔名
 （`docs/design/devlog-as-ssot-assessment.md` Phase 3）。
 
+## 整理所有 devlog：`/devlog-tracker:keep-all`
+
+keep 只整理目前分支的主檔；keep-all 一次整理 `.devlog/` 裡**所有** devlog 檔：目前分支的
+主檔、其他分支的 `devlog.<branch>.md`、`devlog.archive.md`，以及既有的具名檔。Round 依時間
+拿到全域編號，Claude 跨檔依主題重新分段、一次列出建議，確認後 `core/scripts/keep-all.sh`
+整批執行（全有或全無，先備份到 `.devlog/.keep-all-backup/`）。既有 kept 檔的 Round 必須全部
+重新分配；各分支最後一個 `DONE` 之後的未完成尾巴與開著的那一輪不搬；分支檔搬空也不刪。
+新索引行寫進目前分支主檔的 `## Kept 索引`。需要 Node。步驟見 `commands/keep-all.md`。不要自動觸發。
+
 ## 接續具名保存：`/devlog-tracker:resume <name>`
 
 需要重啟具名主題時，用 resume 讀取 `.devlog/devlog.<name>.md` 的最後一輪與

package/skills/devlog-tracker/references/contract.md

@@ -60,6 +60,7 @@
 | 接續上一題 | `commands/continue.md` |
 | 暫停／狀態／壓縮／清空 | `commands/pause.md`／`status.md`／`compact.md`／`clean.md` |
 | 具名保存／接續／總覽 | `commands/keep.md`／`resume.md`／`overview.md` |
+| 整理所有 devlog（跨分支檔、archive、既有 keep 檔） | `commands/keep-all.md` |
 | Span／Checkpoint／Segment／Lessons | `commands/span.md`／`checkpoint.md`／`segment-watch.md`／`lessons*.md` |
 | 協定與跨指令行為 | `SKILL.md`（本層不重抄步驟） |