sync: collector/ 同步自 inkstone/arcrun-rag@d129f8b（桌面小幫手 0.18.48）

sync: collector/ 同步自 inkstone/arcrun-rag@1c31ac2（桌面小幫手 0.18.46）
sync: collector/ 同步自 inkstone/arcrun-rag@740c55c（桌面小幫手 0.18.44）
2026-08-28 09:16:44 +08:00 · 2026-08-28 05:07:35 +08:00 · 2026-08-28 03:46:42 +08:00 · 2026-08-28 01:48:25 +08:00 · 2026-08-27 21:30:21 +08:00
50 changed files with 3845 additions and 235 deletions
@@ -47,6 +47,51 @@

 ---

+## 0.18.48（2026-08-28）
+
+- 🔴 **資料夾那一列不再是一整排字**：以前每個資料夾後面掛著「補送中」「資料夾結構」「移除」三個詞，底下再壓一句長說明，七個資料夾就是七段文字。現在那一列只剩三個圖示，同步好了就是一個打勾，滑過去才會告訴你細節。
+- **打勾是真的**：以前只要沒有錯誤訊息就顯示「自動同步中」，連空資料夾、連小幫手還沒回報的資料夾都一樣。現在那個記號直接對應「這個資料夾裡幾份進去了／總共幾份」，數字對不上就不會給你打勾。
+- **一次連線失敗不再讓知識庫版本消失**：以前只要有一輪沒問到，畫面就說「目前連不上這個知識庫，查不到版本」——即使它下一秒就通了。現在問不到只影響「有沒有新版可更新」，你原本的版本號還在。
+
+
+## 0.18.47（2026-08-28）
+
+- 這一版你不會看到任何不一樣：收檔、整理、同步、畫面全部跟上一版相同，不必特地更新。改的是我們自己出貨前的自我檢查。以前每次重新編譯程式，就會多出兩顆二十幾 MB 的編譯結果混進原始碼裡，害那道檢查誤判成「程式又被改過了」而擋下出貨——實際上一行程式都沒動。現在編譯出來的東西不再混進去，那道檢查量到的就真的只有程式本身。
+
+## 0.18.46（2026-08-28）
+
+- 修好上一版帶進來的問題：雲端只是回得慢，卻被講成「沒有回應」，還害後面的檔被跳過。上一版我替每一種請求設了時間上限，其中「送出一份筆記」給了 60 秒——但實際量出來它本來就要 33 到 57 秒。結果尾巴被剪掉，兩份檔判成失敗，接著整個帳號被判定沒回應，**後面 9 份檔一份都沒送**。這一版把上限依實測值放寬（送知識的請求 5 分鐘、只登記結構的 3 分鐘），並且只有在**連續**等不到回覆時才會暫停該帳號——中間只要成功過一次就重新計算。
+- 訊息也改了：只要這一輪它成功回應過，就不會再說「沒有回應」，而是說「回得太慢」。以前那句話會讓你去查網路、去重裝，全都白費。
+
+## 0.18.45（2026-08-28）
+
+- 資料夾結構現在幾秒內就會更新，不用等整輪同步跑完。以前這棵樹是**排在所有雲端工作的最後**才寫下來的，而一輪同步實測要十幾分鐘到好幾小時（每一次跟雲端說話就要 24〜33 秒，檔案越多輪越久）——所以你看到的是「小幫手開著、沒有錯誤訊息、資料夾結構永遠停在上一版」。那不是卡住，是這一輪還沒輪到寫它。現在它一掃完就先寫，該送上雲端的照舊。
+- 這一版沒有改收什麼檔、也沒有改整理的方式。只改了「畫面上的東西什麼時候更新」。
+
+## 0.18.44（2026-08-28）
+
+- 一個帳號沒有回應，不會再讓整台機器的同步停下來。以前只要有一發請求卡住，後面所有知識庫帳號、所有資料夾就一起停在那裡，畫面上什麼都不動也沒有錯誤訊息（實測卡了 39 分鐘）。現在等不到回覆的那個帳號這一輪先跳過，其他資料夾照常跑完。
+- 等待不再是靜默的。哪個知識庫、正在做哪件事、已經等了多久，會寫在畫面與紀錄裡。
+- 資料夾結構每一輪都會重新整理。以前雲端一沒回應，你看到的資料夾樹就永遠停在上一次。
+- 被跳過的檔案不算失敗。雲端沒有回應是知識庫那邊的狀況，不會被記成這個檔的失敗次數，也不會因此被停掉自動重試。
+
+## 0.18.43（2026-08-28）
+
+- 🔴 **小幫手不再把自己整理出來的筆記當成新資料再整理一次**：以前它整理完一份文件、把筆記寫進資料夾之後，下一輪掃描又會把那些筆記當成「新來的檔案」再整理一遍，整理出來的東西又變成下一輪的材料——一輪接一輪停不下來。你會看到資料夾裡冒出越來越多名字奇怪的檔（像是同一個詞被括號包起來重複一次），每一輪都白白用掉一次當天的整理額度，知識庫裡也被塞進一堆「筆記的筆記」。現在它認得出哪些檔是自己寫的，一律跳過。
+- **已經被繁殖出來的那些檔要自己刪**：這次的修正只保證不再繼續長，**不會回頭清掉先前多出來的檔**——那些檔跟你自己的東西混在同一個資料夾裡，我們寧可不替你決定刪哪一個。名字裡有重複括號的（例如「換柱（換柱）」）就是這次多出來的，可以直接刪掉。
+- 🔴 **裝過開發範本的資料夾，現在分得出「空白樣板」與「你真的寫過的東西」**：以前只要路徑在 `system-dev/` 底下就整批不收，於是同一個資料夾裡**你自己的筆記與現成的知識卡也一起被丟掉**（實測：一個桌面資料夾底下有 9 張整理好的卡，一張都沒上去）。現在改成逐個檔比對——**內容和安裝時鋪下去的原版一模一樣**（你還沒動過）才不收；你寫過一個字、或那個檔根本不是範本鋪的，就是你的知識，照收。
+- **這個分辨不看資料夾叫什麼名字**：換個名字裝、裝在別的位置，答案都一樣；反過來，一個剛好也叫 `system-dev` 但裡面是你自己東西的資料夾，不會再被誤殺。
+- 🔴 **資料夾樹現在真的是「所有的資料夾」**：以前有幾種資料夾我們決定不收，而「不收」的做法是**連走都不走進去**——結果是那個資料夾底下有哪幾層、哪些子資料夾，你在小幫手與知識庫網頁上**一個都看不到**，樹到那一節就斷了。（實測：桌面上一個資料夾實際有 12 層資料夾，畫面上只有 3 個。）現在每一層都會列出來，跟你在檔案總管裡看到的一樣。
+- **不收的那一層，照樣告訴你「底下有幾個檔、我收了幾個、為什麼沒收」**：以前這種資料夾要嘛不存在，要嘛顯示一個我們自己編的 `0 / 0`。現在數字是真的（例如「0 / 9」），旁邊寫著原因（例如「這是開發範本鋪下來的檔，不是你寫的東西」）——你先看得到那裡有東西，才輪得到決定要不要收它。
+- **收檔範圍一個字都沒有放寬**：這一版只改「看得到什麼」，沒有改「收什麼」。原本不收的檔案現在仍然不收。
+- 🔴 **把整理好的卡片放在資料夾裡，不會再被小幫手自己攪亂**：如果你把整理過的知識卡放在 `system-dev/wiki/cards/` 這種位置，小幫手替它們整理出來的新卡片會**被舊版的「卡片歸位」動作硬拖出來、改成別的檔名**——接著它連自己一秒前寫的卡都找不到，那批文件於是一份都上不去；被拖出來的卡又被當成你的新文件再整理一次，檔案愈長愈多（`某某（某某）`、`某某（某某）（某某）`…）。（實測：一個資料夾裡因此多出 70 個沒人要的檔案，9 份現成的卡一份也沒進到雲端。）現在那批卡片放在哪裡就留在哪裡。
+
+## 0.18.42（2026-08-27）
+
+- 🔴 **問 AI「這份資料的原文在哪」，現在答得出你走得到的位置**：以前它會回一個像 `../某某檔.pdf` 的東西——那是程式自己擺放檔案的相對位置，你拿著它打不開任何檔案；原稿如果放在子資料夾裡，連是哪一層都看不出來。現在每張卡的「出處」寫的是**哪一台電腦 › 哪一個知識庫 › 庫內哪一個路徑**（例如 `youlinhsieh@Leo-MBA › youlinhsieh-test1 › 會議紀錄/2026/某某.md`），照著三格走就找得到那個檔。
+- **以前已經整理過的筆記也會一起換掉，不用重新整理一次**：小幫手會把本機既有的卡片改成新寫法並重新送上去一次，**不會再花一次 AI 額度、內容其餘一個字都不動**；每個資料夾只做一次，做完就不再重複。
+- **刻意不寫完整的電腦路徑**：卡片會被別台電腦上的 AI 讀到，而完整路徑只在原本那台成立——寫了反而給你一個看起來精確、實際上打不開的答案。
+
 ## 0.18.41（2026-08-27）

 - 🔴 **不叫「docs」的文件夾，現在也認得出來**：以前只有名字剛好叫 `docs`／`doc`／`documentation` 的資料夾會被讀，一個放滿 PDF、Word、筆記的資料夾只要名字不一樣（例如一個舊專案的存檔夾），就整個被當成程式碼跳過，畫面上也不會說為什麼。現在只要一個資料夾裡完全沒有程式碼、有看得懂的文件，不管叫什麼名字都會被收進來——你不用先學會「哪個按鈕可以救回一個資料夾」，大部分情況它一開始就是對的。
@@ -0,0 +1,118 @@
+// cardloop_test.go — 「卡片自我繁殖」迴歸網（inkstone/Arcrun#134 → comment 5025）。
+//
+// 🔴 2026-08-28 在 leo 的 `~/Desktop/youlinhsieh-test1` 實測到的現象：
+// 一份 20 KB 的劇本原稿，`.wiki/` 只落了 4 張卡；而 `system-dev/wiki/cards/` 底下
+// 卻在 20 分鐘內從 9 個檔長到 55 個，出現 `arcrun-換柱（arcrun-換柱）.md`
+// 這種第三代檔名。那不是萃取品質問題，是**產物被自己的整理程序拖回原稿區**：
+//
+//	① 萃取寫 `<node>/.wiki/換柱.md`（隱藏目錄，Scan 整棵跳過 ⇒ 不會被當原稿）
+//	② MigrateCardNames 每輪自動跑，遞迴掃 `system-dev/wiki/cards/`——
+//	   **它沒有跳過隱藏目錄**，於是把 `cards/.wiki/換柱.md`
+//	   「歸位」成 `cards/arcrun-換柱.md`
+//	③ 那個位置 Scan 看得見 ⇒ 下一輪當成新原稿再萃一次 ⇒ 回到 ①
+//
+// 每一圈都燒一次 Workers AI 額度、往雲端推一批「卡片的卡片」，而且不會停。
+//
+// 四支測試各釘住迴圈的一個環節（tidy 自動路／tidy 手動路／收檔判準／claude 路），
+// 缺一個就會復發。
+package collector
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+// TestMigrateCardNamesLeavesWikiDirAlone：`.wiki/` 是卡片的家，不是「位置不對的舊卡」。
+// MigrateCardNames 一個檔都不准動它——動了就等於把產物送回原稿區（迴圈的第②環）。
+func TestMigrateCardNamesLeavesWikiDirAlone(t *testing.T) {
+	root := t.TempDir()
+
+	// 卡片產物區底下的 `.wiki/`：萃取正常的落點。
+	wikiDir := filepath.Join(root, filepath.FromSlash(cardsRelDir), wikiRelDir)
+	if err := os.MkdirAll(wikiDir, 0o755); err != nil {
+		t.Fatal(err)
+	}
+	card := filepath.Join(wikiDir, "換柱.md")
+	if err := os.WriteFile(card, []byte("# 換柱\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	mig := MigrateCardNames(root)
+
+	if _, err := os.Stat(card); err != nil {
+		t.Fatalf("`.wiki/` 裡的卡被搬走了（MigrateCardNames 回報 Moved=%d）——"+
+			"它下一輪就會被當成新原稿再萃一次，迴圈就是這樣長出來的", mig.Moved)
+	}
+	dragged := filepath.Join(root, filepath.FromSlash(cardsRelDir), MarkName("換柱.md"))
+	if _, err := os.Stat(dragged); err == nil {
+		t.Fatalf("卡片被拖回原稿區：%s", dragged)
+	}
+	if mig.Moved != 0 {
+		t.Fatalf("Moved = %d，期望 0（`.wiki/` 不該有任何東西被搬）", mig.Moved)
+	}
+}
+
+// TestTidyLeavesWikiDirAlone：手動 `collector tidy --apply` 走的是另一條路，同樣不准碰。
+func TestTidyLeavesWikiDirAlone(t *testing.T) {
+	root := t.TempDir()
+	wikiDir := filepath.Join(root, filepath.FromSlash(cardsRelDir), wikiRelDir)
+	if err := os.MkdirAll(wikiDir, 0o755); err != nil {
+		t.Fatal(err)
+	}
+	card := filepath.Join(wikiDir, "官架子.md")
+	if err := os.WriteFile(card, []byte("# 官架子\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	rep, err := Tidy(root, true)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := os.Stat(card); err != nil {
+		t.Fatalf("tidy --apply 搬走了 `.wiki/` 裡的卡；報告列了 %d 項", len(rep.Items))
+	}
+	for _, it := range rep.Items {
+		if it.Kind == TidyKindCard && filepath.Base(filepath.Dir(it.Rel)) == wikiRelDir {
+			t.Fatalf("tidy 把 `.wiki/` 裡的卡列成待整理項：%s → %s", it.Rel, it.To)
+		}
+	}
+}
+
+// TestMachineOwnedCardsAreNotIngestedAsSource：curated-wiki 模式收的是「他自己寫的 wiki」，
+// 但 `system-dev/wiki/cards/arcrun-*.md` 是 **daemon 上一版親手產的卡**
+// （檔名帶 MachineMark 就是它的身分證）。把自己的產物當原稿再萃一次
+// ＝迴圈的第③環，也是這次「卡片的卡片」的第一代來源。
+func TestMachineOwnedCardsAreNotIngestedAsSource(t *testing.T) {
+	plan := IngestPlan{Mode: IngestCuratedWiki, WikiRelDir: "system-dev/wiki"}
+
+	userCard := "system-dev/wiki/cards/我自己寫的.md"
+	if !plan.KeepsFile(userCard) {
+		t.Fatalf("使用者自己寫的卡被排除了：%s（curated-wiki 要收的就是這個）", userCard)
+	}
+
+	machineCard := "system-dev/wiki/cards/" + MarkName("換柱.md")
+	if plan.KeepsFile(machineCard) {
+		t.Fatalf("daemon 自己產的卡被當成原稿收進去：%s——"+
+			"它會被再萃一次，產出「卡片的卡片」", machineCard)
+	}
+}
+
+// TestSnapshotCardsIgnoresWikiDir：claude 路的同一個洞。
+// snapshotCards → diffCards → enforceCardMarks 會把「這一輪新出現的卡」歸位到
+// cardRelFor（搬出 `.wiki/`、加前綴）。`.wiki/` 不進快照，就沒有東西可以被搬。
+func TestSnapshotCardsIgnoresWikiDir(t *testing.T) {
+	root := t.TempDir()
+	wikiDir := filepath.Join(root, filepath.FromSlash(cardsRelDir), wikiRelDir)
+	if err := os.MkdirAll(wikiDir, 0o755); err != nil {
+		t.Fatal(err)
+	}
+	before := snapshotCards(root)
+	if err := os.WriteFile(filepath.Join(wikiDir, "Pixel手機.md"), []byte("# Pixel手機\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	changed := diffCards(before, snapshotCards(root))
+	if len(changed) != 0 {
+		t.Fatalf("`.wiki/` 裡的新卡進了快照差集：%v——enforceCardMarks 會把它搬出隱藏目錄", changed)
+	}
+}
@@ -0,0 +1,68 @@
+// cardloop_vs_existing_wiki_test.go — `#134`（別把自己的卡當原稿）與 `#180`（現成的卡要收）
+// 在同一個路徑上要求相反答案，這一支把**分界線本身**釘住。
+//
+// 🔴 這不是普通的迴歸網，是一條**有爭議的分界**：兩張票的驗收條件互斥——
+//
+//	#134 cardloop_test.go　`system-dev/wiki/cards/arcrun-換柱.md`　　　　　　　　**不准收**
+//	#180 template_not_knowledge_test.go　`system-dev/wiki/cards/arcrun-火星座標_短片劇本_v1.md`　**必須收**
+//
+// 同一個目錄、同一個前綴 ⇒ **靠名字分不開**。現行分界是「**模式**」：
+// curated-wiki（接一個開發 repo，`cardsRelDir` 與他的 wiki 結構性重疊）擋；
+// 其餘（一般資料夾／筆記庫）收。理由與出處寫在 `ingestplan.go` 的 KeepsFile。
+//
+// ⚠️ 這條分界是收工方的假設，**leo 還沒裁**。要改分界，連這支一起改，
+// 並在 `inkstone/Arcrun#180` 留言說明改成什麼、為什麼——不要只改 code。
+package collector
+
+import "testing"
+
+func TestKeepsFile_機器產的卡在哪一種模式下才擋(t *testing.T) {
+	const machineCard = "system-dev/wiki/cards/" + MachineMark + "火星座標_短片劇本_v1.md"
+	const userCard = "system-dev/wiki/cards/我自己寫的.md"
+	const liveProduct = "system-dev/wiki/cards/.wiki/換柱.md"
+
+	// ① 接開發 repo（curated-wiki）：舊版 daemon 寫在他 wiki 裡的卡不當原稿（#134）
+	repo := IngestPlan{Mode: IngestCuratedWiki, WikiRelDir: "system-dev/wiki"}
+	if repo.KeepsFile(machineCard) {
+		t.Errorf("curated-wiki 仍該擋 %s（#134 第③環）", machineCard)
+	}
+	if !repo.KeepsFile(userCard) {
+		t.Errorf("使用者自己寫的卡被擋了：%s", userCard)
+	}
+
+	// ② 一般資料夾／筆記庫：leo 的 youlinhsieh-test1 就是這一種，那 9 張卡要收（#180）
+	for _, m := range []IngestMode{IngestAll, ""} {
+		plain := IngestPlan{Mode: m}
+		if !plain.KeepsFile(machineCard) {
+			t.Errorf("mode=%q 沒收 %s——#180 驗收第 3 條（那 9 張卡的內容要進得了雲端）就不成立",
+				string(m), machineCard)
+		}
+	}
+
+	// ②之二 `arcrun-` 是人也會用的命名習慣：**卡片產物區以外的檔一律照收**。
+	//    實測 leo 的 youlinhsieh-test1 根層就有三個他自己寫的（其中一個檔名裡寫著「請勿刪」），
+	//    只看前綴的話它們會被排進「下架」——不是不收而已，是把雲端已經有的撤掉。
+	//    （curated-wiki 只讀那份 wiki，所以根層的檔本來就不收——那是模式的範圍，
+	//     不是前綴造成的；這裡分別用兩種模式各檢一格，才不會把兩件事混在一起。）
+	plainAll := IngestPlan{Mode: IngestAll}
+	for _, rel := range []string{
+		MachineMark + "複驗用-請勿刪-20260827c.md",
+		MachineMark + "1457驗收-20260827.md",
+	} {
+		if !plainAll.KeepsFile(rel) {
+			t.Errorf("mode=all 把使用者自己命名的根層檔擋掉了：%s", rel)
+		}
+	}
+	if !repo.KeepsFile("system-dev/wiki/" + MachineMark + "我放在wiki根的筆記.md") {
+		t.Error("curated-wiki 把卡片產物區**以外**、帶前綴的檔擋掉了")
+	}
+
+	// ③ 不管哪一種模式，**這一版正在維護的產物**（住在 `.wiki/`）永遠不是原稿。
+	//    這一條才是關掉「卡片的卡片」迴圈的那道閘，前綴不是。
+	for _, m := range []IngestMode{IngestCuratedWiki, IngestDocsOnly, IngestAll, ""} {
+		p := IngestPlan{Mode: m, WikiRelDir: "system-dev/wiki"}
+		if p.KeepsFile(liveProduct) {
+			t.Errorf("mode=%q 把 `.wiki/` 裡的產物當原稿收了：%s", string(m), liveProduct)
+		}
+	}
+}
@@ -30,6 +30,7 @@ package collector

 import (
 	"encoding/json"
+	"errors"
 	"fmt"
 	"io"
 	"net/http"
@@ -98,7 +99,15 @@ func cloudCardPresent(cfg *DirectConfig, library, relPath string) (present bool,
 	if strings.TrimSpace(library) != "" {
 		q.Set("library", library)
 	}
-	req, err := http.NewRequest(http.MethodGet, base+"/kbdb/entries?"+q.Encode(), nil)
+	// #153：對帳一輪可能連打 cloudAuditBatch（20）發。「一發卡住」的代價在這裡
+	// 會被乘上批次大小 ⇒ 20 秒的 client 逾時最壞就是 400 秒，而這期間畫面一個字
+	// 都不會說。掛上等待閘：等到超時就記帳，同一個帳號連續等不到就整輪不再問。
+	gate := cfg.openGate(stepCloudAudit)
+	defer gate.release()
+	if note := gate.blocked(); note != "" {
+		return false, false, errors.New(note)
+	}
+	req, err := http.NewRequestWithContext(gate.ctx, http.MethodGet, base+"/kbdb/entries?"+q.Encode(), nil)
 	if err != nil {
 		return false, false, err
 	}
@@ -106,8 +115,9 @@ func cloudCardPresent(cfg *DirectConfig, library, relPath string) (present bool,
 	req.Header.Set("X-Arcrun-API-Key", cfg.APIKey)
 	resp, err := cloudAuditHTTP.Do(req)
 	if err != nil {
-		return false, false, err
+		return false, false, gate.record(err)
 	}
+	gate.ok()
 	defer resp.Body.Close()
 	body, rerr := io.ReadAll(io.LimitReader(resp.Body, 8192))
 	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
@@ -16,3 +16,17 @@ dist-msix/
 # Python 匯入快取（daemon-version.py 被 import 時產生）。可重現的產物，且綁 Python 版本
 # （檔名帶 cpython-314）⇒ 不進版控。2026-08-18 D95 第三輪：第一輪搬檔時誤把一顆帶了進來。
 __pycache__/
+
+# 🔴 `go build ./...` 在本目錄留下的執行檔（inkstone/arcrun-rag#158，2026-08-28）。
+#   Go 對「單一 main 套件」會把成品寫成**目錄名**，所以任何人在這裡跑一次 go build
+#   就會生出 `arcrun-app` 這顆 20 MB 的二進位。它一路被追蹤到 2026-08-28 為止。
+#
+#   為什麼非拿掉不可（實測，不是推論）：這顆檔案**在版本指紋的涵蓋範圍內**
+#   （`daemon-version.py` 的 `scan_source()` 走 `git ls-files -co --exclude-standard`）
+#   ⇒ 只是重編一次、一行原始碼都沒改，指紋就從 1325784830f592ff 變成 eba122f83317b67d
+#   ⇒ 出貨線的 `daemon-source-check` 判「0.18.46 打包之後，1 個檔案變動過」而擋下。
+#   **把編譯產物算進「原始碼指紋」，那個指紋就量不到它宣稱要量的東西。**
+#
+#   ⚠️ 錨在本目錄（開頭的 `/`）：不要寫成 `arcrun-app`，那會連子目錄裡同名的東西一起蓋掉。
+#   打包腳本要的產物在 `build/bin/`（早就 ignore），不是這一顆——三支腳本都沒引用它。
+/arcrun-app
@@ -1,28 +1,29 @@
 {
 "_algo": 4,
- "version": "0.18.41",
- "fingerprint": "8033de0cdec3537b",
+ "version": "0.18.48",
+ "fingerprint": "a440a58a629f960c",
 "files": {
-  ".gitignore": "4d56952b0fb13bf8f9b6c13a6d4c34a075bac3af447636a1df4335d7576e2f97",
-  "CHANGELOG.md": "7f8a82a8a89483c09b76ed23773f8ef4dc56dae398e558130d40de4ddbdea107",
+  ".gitignore": "c7a98c44ecc882a174720e43dabd4c04d7cf2503586426dcccaa213d5a27df38",
+  "CHANGELOG.md": "51b85dc1e96ce190a8652df8a696bd664229b1c5bcb6cf695ced905dc5956d1b",
  "DAEMON_LINE": "d5019abbdc8a5f2919e9e3510391891cd7fbdf0765bf16ec83caa779f370116d",
  "README.md": "9d92cac236b20a0b183eea3e7f5e39ad492f05192c4ea602eb11c3d09967327f",
+  "cardloop_test.go": "fdf09b62650c328f5d8075d964a0ca2dada5f8d9a271202768472998b45e31a8",
+  "cardloop_vs_existing_wiki_test.go": "1fc42120114902571f61f65a56dc561bd2d858096c25303ce564a891a7a2511d",
  "check-standalone.sh": "65fbce096326791c2f103a51e76d0ad79e9e510e2a7700b49ac2d2d81f73c853",
  "cleanup.go": "59a45672f7f73d73833685846148ba20f71d5b3f42340be5a74a10437be267fc",
  "cleanup_cli.go": "5dc41aac30f39757658d7bc95ab727ecc799b8242fd752edcedbb8423935fbf0",
  "cleanup_test.go": "23d627a12ec476bb8898847185a1464cb78e2186278299ff13c84a3d54af63c0",
-  "cloud_audit.go": "a51f5c6eafaa75ce282b307e8dd2986f0b316a3c24282bed0856002819dd86e2",
+  "cloud_audit.go": "e3dbf32785e3d6643a6d62c298c4ece2680d8f00c1148f6d55285dd670d9cf51",
  "cloud_audit_test.go": "1790837e8a5726d62258436937f9c474f7abd03e6229832fdbd40f8cd7aa756a",
  "cloud_latest.go": "c2ad7f87bbd55247540eb924ac3be5deadbc4488b504770a5127a01c748f0e0f",
  "cloud_latest_test.go": "703963b65da91ae0c4638b9ad676ca7f12a474c635e903a5d988e4980b3888aa",
  "cloud_version.go": "eebc2552e09e199928e82607bebf90daef36b5721ec9b8a098304c10dbec46f9",
  "cloud_version_test.go": "66c004de1f0a3958851f22a22367065f13b3381ac7d936ae54d812c26a0b9fb6",
-  "cmd/arcrun-app/.gitignore": "7502ba597654ebb3463535bdfb51c271abad666a67c7ac8ab36deca1a72615f8",
+  "cmd/arcrun-app/.gitignore": "91248524c8b00d155960f42ad6707ce36bd91ff44f66289eec45972d3915ad37",
  "cmd/arcrun-app/README.md": "23e53fdf53fcd96b6d8d7a121eb91d3242d11b69d655770473b745c49bb387b9",
-  "cmd/arcrun-app/app.go": "274129ed77c4f4194f6b2007cb47e4ffe536b15b6450fe89b14fbb31e6a16395",
+  "cmd/arcrun-app/app.go": "098e6a01aa0a298248ae9cc96275b209e5b8c9669325ba691c46383470216698",
  "cmd/arcrun-app/apps.go": "0df6da9d55adbdec500fbb01005a305287d1dbf796b7e463f2b2f222626b4c96",
  "cmd/arcrun-app/apps_test.go": "0e2f137f8b49f421e869ab3192ca12c8bb756029d8730487ccc44733aaf7f96c",
-  "cmd/arcrun-app/arcrun-app": "e2bdf54a15d69860df05820274a80d7497b7d62a4e8ba219f72f30b543456b79",
  "cmd/arcrun-app/assets/store/README.md": "a9028a727947c5038ca938c664b18e4851ae3bf0e6d8838c82aedea43d02ded2",
  "cmd/arcrun-app/assets/store/Square150x150Logo.png": "27942d943096ba23f036b030726e905f6df6123428cd7d8ec687ce5b11e42db1",
  "cmd/arcrun-app/assets/store/Square310x310Logo.png": "f610d521767347974fcd68006055d06c5366e99c247d31a2b9221bae34d67798",
@@ -70,10 +71,12 @@
  "cmd/arcrun-app/diagnostics_export.go": "19328a384d653a24c557f5ee7497d62f1c1eaeba37976819b07e44f002b8862b",
  "cmd/arcrun-app/diagnostics_export_test.go": "00fbd5a436a82652d28f9974d29dcbaf57a432ec0df05bf491e6f9755bbff00b",
  "cmd/arcrun-app/diagnostics_stage_manual_test.go": "e1c9fe6b8d6d6e39c74efec5c8874bf4a7922cf5b03789e49c40ef24231d1f00",
-  "cmd/arcrun-app/dist/Arcrun-v0.18.3.dmg": "bfe9282ca591b62390e53e439a9f97ed71e6c7c7ece2dd61e10b75e77b0ae991",
  "cmd/arcrun-app/dock_darwin.go": "25f07f57eea6dbacdc4eaf652ad56b83b4641ec6392f6a4a4943b67f3f24156a",
  "cmd/arcrun-app/dock_other.go": "b5f7bb020ec20c9ed27436b5be15aa16798a180d1bf200b4158c5bdbfe3e6be7",
  "cmd/arcrun-app/firstrun_test.go": "90d74db3e6a7b77617d50559a181229c0e720c20ead35b9554cb72e5212c7303",
+  "cmd/arcrun-app/folder_badge.go": "ee2b3a62fc7424816268267e573be5b59174d1fcc3a492dded6b9b220506b1a5",
+  "cmd/arcrun-app/folder_badge_fixture_test.go": "38c74b7571f60d24c3d1b337e79f38df153b589f3cd911cfbaf8369e4759ba18",
+  "cmd/arcrun-app/folder_badge_test.go": "61377b6cbf51be32ee5b4fdc40724afd9a040e1041886c96f364d480bdd02801",
  "cmd/arcrun-app/freshinstall_e2e_test.go": "59d8c8c75365f7821f838baca9abd93f167bebd0998779a54c5fe33e390e7331",
  "cmd/arcrun-app/frontend/index.html": "3cbf1ec22539e0e0ad7e8e86b1857cf752e042ecfd52e816f7d2bdcd7cf99a91",
  "cmd/arcrun-app/frontend/package-lock.json": "a4020582cf3fb5f2413451d5d5498a54ceadae153d28e3f59f81f6a7b2c97caa",
@@ -88,8 +91,8 @@
  "cmd/arcrun-app/frontend/src/assets/fonts/OFL.txt": "8656c2a27357b3140047a39b27e3cd928256544ad8a004ef77087f761358208c",
  "cmd/arcrun-app/frontend/src/assets/fonts/nunito-v16-latin-regular.woff2": "06f3af3fe52542d40ad9bc14ec03e04deaabd09ec369221cc8f536db1c72bf55",
  "cmd/arcrun-app/frontend/src/assets/images/logo-universal.png": "157a874acd3363634747287c0b01034e9f1eec838a4cf39827dfea789e730494",
-  "cmd/arcrun-app/frontend/src/main.js": "277390ab8bf4114c797aa32b2cdae151e86a63681c612c424e73c308c446234e",
-  "cmd/arcrun-app/frontend/src/style.css": "4fb87b139100b826c02c71a69599da2c4e8b93d3f7855c2a9b10e6677fecfbb2",
+  "cmd/arcrun-app/frontend/src/main.js": "327877a5bb79b79589e09b902e7002e33d275a413451ff90f230bb2e92418b52",
+  "cmd/arcrun-app/frontend/src/style.css": "2cc59ab0be7668f2b8e2e42f655beb506a91f2d31414e0a40dbab33fffc8349a",
  "cmd/arcrun-app/gen-icons.py": "df5b3b33e500fc564badfc8bd2a9ca6a43f7d7e3b31111c41e3b322137c4c96c",
  "cmd/arcrun-app/go.mod": "8b9e57bcfd44886d1ec06480e033af706ff3fed470786c57074900dd48ecf86f",
  "cmd/arcrun-app/go.sum": "bc4453654c203e5af251c5a3061616cb0ceeb1b6a78a02ace2ca85524d217256",
@@ -111,7 +114,6 @@
  "cmd/arcrun-app/upgrade_repair_test.go": "65413d0b07b6c011de2af2783247d0f602a680a199229b52a77e176626c8ef26",
  "cmd/arcrun-app/wails.json": "a6448229972e3194026f6a407a427a5601ce6f5deb43d1fb7c5b5226512d8bc5",
  "cmd/collector/main.go": "fd04291f6cd4833f00593a0580baeaa231875da6d26636fca4f51090f0a80c80",
-  "collector": "ef769ff086a4da691b4bd646de4efb6957204efa829545e43cbcb99bf9503b70",
  "convert.go": "fb3b52354b94f527ccffa5600620749a5fa6009834530aac04b7d141bb3e3b4b",
  "convert_docx.go": "5d4f459ff866c86ee78424503e1c9a410e1dbfd0ece40d63a603b94b61b7ddaf",
  "convert_pdf.go": "e4955008f9bf9e458304fa0baa087ae7a37ac52e9fb66df3e99f22a4c513b9b1",
@@ -121,8 +123,8 @@
  "convert_table.go": "5313b96e4d85d65e6c3c8b51e7c0e25aee11a47fdbda534fe8432fbea87836c5",
  "convert_table_test.go": "d0371b7566ef3152f9dd42f9f990e0dffa1c50a0c8e874a28415fa2e4c188394",
  "convert_test.go": "04f3fa30d1be5f910c0e0be3308ced2963191ab030a9eaccd986ef581fcd4e18",
-  "convert_wiring_test.go": "09e97bf32ace245b55acc7d65ee5c0bb7fd84f8fb1aab61f603f9e9d18b22f13",
-  "direct.go": "edea1388f4305d71b7738f131ed8513ac5de7b8d04db7d98f603d70ea80bf53c",
+  "convert_wiring_test.go": "3389817e596341369a3fc102846bf5b081cee668e86ebf4830eb633978de652b",
+  "direct.go": "ba19086aa177884405c038a8841cd5b6b2ef2bf2043d18a708ff7e6c6c9ca45f",
  "direct_extract_test.go": "317d0057d2d368fabc406351a7477f72e074d2b8c8459b1dc021febdf16902f4",
  "direct_multi_test.go": "a76593fef26231e18b7402f6f7376624d2471f8a719b3ce08fc4a0f5a3d3cf1e",
  "direct_pacing.go": "b54838ce85f72ecd2d3388fa7cf89050c87fb10bd67dca07cd18d49568a8837c",
@@ -131,43 +133,47 @@
  "direct_retire_test.go": "fbff728362313c546c1fc01cc74094672e22a8171d4bc0329ce1b3d118c82b3c",
  "direct_sync_now_test.go": "dc7a6e3d5646a470e889d30f0224cdb86be832b8cf85ffef8629e42ec577622b",
  "direct_t182_test.go": "1c64a9d0f41b98504e10a20a96f28e8a47cced4923171ef40dc800b861d0275b",
-  "extract.go": "76c40068d378d6036e330bb56e41caec2f80b9b219352586744194df560c8147",
-  "extract_gemma.go": "9d127fa467b8c760ec46180123ec0fdadd4336290555687f16baf0b80b24c6f2",
-  "extract_gemma_test.go": "1fae16cc43e3de9728b88ea7151da9c836bf32cb5bead2805fbadc5e788fbab8",
+  "extract.go": "b6b5212ab5107c53da17bf677ac54b040f2f78674b902c8b5750a3befa4a1f23",
+  "extract_gemma.go": "53483c6ea3992759abbae45562bfc418d4df1728b44fa87b3bd30324d28fc4f4",
+  "extract_gemma_test.go": "439f12c1c6fb534b31f983305a4d7898ef66dfcbe697714be08a6b571e4e57c0",
  "extract_test.go": "63560ecca929c6507d93b3f52988bb7ce2cd6137140eb373c520eac5ee052c76",
-  "extract_workersai.go": "d8f192472883e7a7f5d034d9b0e0d8be46f284bef2c500f934ec740379efffde",
-  "extract_workersai_test.go": "188822f4c44ee5bf3b1400e1475af314ad831296538a68c5e1006341ba63765e",
-  "folderindex.go": "f3dd186fd7e882ff293b3f8aa6b2582b018290ee5f14bbdc02a7ac131834fd69",
+  "extract_workersai.go": "8300691e1a41df4096d316686efbd0016e8df4d482be55b8ce4388b53bd9e1c5",
+  "extract_workersai_test.go": "8850e7128f03ecb4754a4663281800dc73d556fab1d80367924b58bae3dd8ec3",
+  "folder_progress_wiring_test.go": "c5a4575395f1cee5d1c0ee58728a034113534a3f0d456e4e0d23563da840d314",
+  "folderindex.go": "575a56fc7763ad82aef14fc5e0e1df39d351f0903babe6251bf2df990e358089",
  "folderindex_helpers_test.go": "2cf17b70c396225f728e8e160cfc75d7bdc76ac1ce8e574d1450b020050c0734",
  "folderindex_test.go": "a5319eb1e92473cb5c32d3beddb7889997556227824de300dd39953b43beab70",
  "foldershape.go": "b1b237f5674674efdc9bdea849b63c571a014e64bec33af42fb7c4769fa7582b",
-  "foldertree.go": "8b3de4fde32e538b3a6a9440f6fb89e5737391a2499668b961a933509b36fa17",
+  "foldertree.go": "c12461137d6c177db8e1e2f5c7446bcbd6bfd567f044cc07e11e883cc71892dd",
+  "foldertree_live_test.go": "ace96ffdf7670a69761973e810fb6548c7036d2768141e09db515313df1e9a50",
  "foldertree_local_test.go": "ce919dc2a21ec96716e3d43a7f493367346e212243b4ab22c2d960fc26408f3a",
+  "foldertree_publish_test.go": "104b26ffac1fc78a4c9b061aba3e2167c7d71ea469073537c3d86e3896debdea",
  "foldertree_test.go": "f8b8cdf1ef9d7d1c80cabb086fc9b4f2162b91a47d6d78bde2632b07672c0b88",
+  "foldertree_traversal_test.go": "b9a3ce5c784b7601e628b1299596b3572ca787e654cd2ee20b973d053bab84aa",
  "go.mod": "05dacc224af2a6797db86689435f83537efb433ffba521467b95d1099f5e12db",
  "go.sum": "a9c92957ca368462aab32a82a6f51c9586ea07478a7967012986d757e9969ab3",
  "grounding.go": "7152771ab1bb152946209f8e94e52bdf2facc6192b7a8ca018e37fed4557e9c0",
  "grounding_test.go": "46f5fd98297caf45b5db494f69363f2544e1cfa5634ce24fe25ca6a87ae296d2",
  "ignorerules.go": "e6923d0fe35e377e75cfe2364a10624ca40aa6d28efe48ea725036769a48ea14",
  "ignorerules_test.go": "19675a03539e92e7fd58a46ce8105875cc5aaa42f53615348de775b6d90dbf16",
-  "ingestplan.go": "0c78c96c3218b8ca3f15bceb3e99c087f055bbd4d2e6024fee6268e3efc46e94",
+  "ingestplan.go": "f32cd7a740fc291a6b54e2804e0bdf0d50770962414fafe92b015ddf0c6fcddf",
  "ingestplan_test.go": "baf57a5edc99482842c16d1ea28d1ad6afe7a236a56fc42dac8d007341b578be",
  "ingestplan_wiring_test.go": "4e5d25dace8a181418ed5857423ef1efeacdd98b7ff42b94a71c4e5fd7012e89",
-  "inventory.go": "d0ba0be3e2af8df3cc6dffac5b75816b9c2a0a12f6d2eff1a786d8584ca77622",
+  "inventory.go": "707b2b74dccbd082d56793a558bb28ce0f8812d458b221d8b2d6b084b752af50",
  "inventory_test.go": "16e0f83a09d61dc4cded032fd493d30bfc747c38116b871fb02b2f0bf2b0216a",
  "lint.go": "63af1289978a02c9722ac8bb934a916b9e4e65cffcfec0749eb07590496960f3",
  "lint_test.go": "2f57a04b9d697fba2d078eb08f49d2fec1640c7e3c61a60bc3821d2bb0798153",
  "machineid.go": "d4224e684ecfbafe2efc7e0b95377f9e669ee1256a442aa72ce2cab3b219fc56",
  "machineid_test.go": "5b54ac62ee1fb28b8f0a873888aeddb844af0aa74472bfb849573cfc6691a290",
-  "machinemark.go": "b93464c2ee89a73c0e0da38bcce5dc1ba6c1deba2fc483f28c6021c3ffdee4a0",
+  "machinemark.go": "592a39597fd011e8b1603318eaedf452aa58fca0639244a80218aa9a0ac6dbf5",
  "main.go": "fe2f69739f3ee92713f8aaca925068ecf97b33d476eee826fc1e0d5def8f0d10",
-  "manifest.go": "61a9403a3da46f270ce6a1610b9307fd19b794521b71a7a8f22cea36a6ea35cd",
+  "manifest.go": "c6b6fbdd5cc6963345048aa1b0a32f61b7b0b5b84616a15827aea290bd3758e1",
  "manifest_extractedby_test.go": "8019fe35675a1e801b7bda829ee1d647de32db03c029b1c651f71573e644c69e",
  "manifest_retry_test.go": "e6b4a321ccddfeed8cdbfabe6d031d5a9c59a33b47baf0b6d21150fa8406748a",
  "multiaccount_connected_test.go": "ba1817b73a5dd0dd5d300750e54d5c53bd82a75ef6e43caeddfcb2303d64ff66",
  "probe_real_manual_test.go": "6170cd7d41b6e099ad93e229f55e5f9d64d509412969f9bf162788ae8e787aef",
-  "probe_workersai.go": "4667c7edeb75a7f69d99bdb9141c8d55325d3b99aecc9a661a4080c91ef517fd",
-  "progress.go": "c2c86ecfea5a8227eb40018c55d48f26c4f2de1b8775fde9acd231cba8b7bb37",
+  "probe_workersai.go": "2d12d7e83f13a83f7dca0f4f6ea1ff0041db70b4f47d86f940c2fac80cab6980",
+  "progress.go": "98380d3c374570f3182200484b9b2b6a093d41531433b80eb78a92cf94dec69a",
  "progress_test.go": "21258889ad7680da2d6cf8812accda7e6a1aca6c6fd604394ec4363c2ed902bb",
  "progress_wiring_test.go": "d1d144269539825ef4a4d9ffca5c49b021cb27cecea7d280309f3f935460b3cd",
  "quota.go": "034a2a682b66606e9ab531a251e5157109c9a66ddca6e3ffcecc8fcd10dc0aa3",
@@ -176,22 +182,27 @@
  "repoguard_test.go": "ce0316a59af944c3cf391961653fe82294fd45e728d35b4b7fcd99b2b20e7b5c",
  "safewrite.go": "d5dd09ffe894fb9fb94656a4bb50d246bd8c65ab21a7ad81463f43dfdacc8a57",
  "safewrite_test.go": "2980f0f86f78fb265403e31d4cba6da43f4dbc16e7c4711cfccba23175578358",
-  "scan.go": "d26b74e46204697a573ed24ee427c06878349611fcaf3c35df295b826b690525",
+  "scan.go": "546329b883228687a60d48419c19113a6208f0f5ea18a0d3ba0fc401ab3c0974",
  "scan_carry_lasterror_test.go": "6fa542422fb3e00b5ec4355b5db8df7086361b2dacefd67755d75c0ddfa55575",
  "scan_dedup_scale_test.go": "573b3c78bec86614bf4d2f99b7c3c3157f92c24af73cae7290428fc7f43f0362",
  "scan_dedup_test.go": "580ec58596ca54aa3d29b417e7d098fd2e3455fd39bf10e7da02d453c0786df0",
  "scan_skipped_test.go": "983ecabb5d93388a501836d15dd445789b7f3028a7f3b966e04425ad4d5bfd9c",
  "scan_test.go": "d0e472686ff41da2421bfd45b63099fd75877e6fc72f26dfdd1a07dc64c9f0cd",
+  "sourcerepair.go": "bdb1a4b64d028a9df42a7b9258a431e01f1be8871c490b92011d0c6ee5e53b79",
+  "sourcerepair_live_test.go": "2a7f5d6fada420a7f55fa52b87361842755c68c1cb58f8c3fd0153341f709a0a",
+  "sourcerepair_test.go": "2a1ddddaad8ac7adc36350859e2d742c0fea12b99370a4d4831d390db1cc6720",
+  "stallguard.go": "13be8ae905492054d516f466856bc6949b16e1af6ea32068f94b21635799bdc6",
+  "stallguard_test.go": "678b82a8448d1394a0a85d4af1f133c980f5ff0dcb54953b0fcf1671d186147f",
  "supervisor/hidewindow_other.go": "291b4ecb0783ff3e813c68b5464161d9af2f84d31c773c7f1f710f218bb5d610",
  "supervisor/hidewindow_windows.go": "29796dbe90ecb35e6f1451dacf956d42928c6a393271befc5c7f6863d5315fb3",
-  "supervisor/supervisor.go": "cb17332ce5a7190627839e624895c56b508635edbd2c29758f794d5c3bb39388",
+  "supervisor/supervisor.go": "f79b32e92e67058a056dc749a6182573eefcbbc9bc7b2cd5a997f4e8066a004e",
  "supervisor/supervisor_test.go": "f5582d54c55065fbc834fe96754df9c8cd6efe9f88f30208bbce84ddea08fea7",
-  "sync_status.go": "59e8e2c81ec5a1cbd46e852bd7c794c4179c76ac62561f21550a41afb9e2be2d",
-  "sync_status_test.go": "9314b354679f0c5090257cf6918185c33b74102bfac0acb655c3e97b81a247b3",
+  "sync_status.go": "799d3481c361647c9cf1ae40ac4c550d6690a87f843c514f8b830d811e7bba1f",
+  "sync_status_test.go": "73bbc83c9e8fc18575895a7b7b5feab7a76d41f05a74d74bbbdbf98b045ccfa2",
  "t52_library_test.go": "14188d0afdad0f9aa16d19a74ea28c45c3d18fcfeabc5deb6fb0466d05778a51",
  "template_install.go": "d0aa0098e431696a63ef8d3714c124591b8ba193ccd5a8359a4ea03e397ee358",
  "template_install_test.go": "e2d096a80c52ab10fd1a9e26cab2a9621cc2017df8c0c5726aaa450a00375566",
-  "template_not_knowledge_test.go": "d25e84a13fb97351cd3a579178a5e24cb266309bdc9d526ff7bec442071df3ab",
+  "template_not_knowledge_test.go": "59c272068d308defd1fb19aedfc5b311bb64d2fc58e958e78b98d9f7ba27b6f1",
  "templatefs/.claude/VERSION": "04d659518a1793d5396007fcabdc9211a8c1db8406bf4e0fa8069171fdb06518",
  "templatefs/.claude/commands/issue-handle.md": "2010f4e418dbb51e928873019c30602b79ff4dbf79509cb412884616f10a0e01",
  "templatefs/.claude/commands/rag-extract-file.md": "33e8f10fbde076452a5a304cb153982603b238ffe1805e0faf7b7fbed246298e",
@@ -229,6 +240,7 @@
  "templatefs/system-dev/wiki/status.md": "ef03d670e48847c94954db93469bcb9d0bf38860a155fb0847c3e16d3411b839",
  "templatefs/system-dev/workflows/tasks-project-sync.local.sh": "7a611abc8b597d7c047e1b73c4a19c011ba1719f6688351b677b4feee0a4d4fe",
  "templatefs/system-dev/workflows/tasks-project-sync.yaml": "e8c7dd78d338e64219ad0eb7aae27aec02b6ac2ad962f309145055a87f1cd5db",
+  "templateuntouched.go": "74e6c0dda22228ac65cc841ce83460d81026134d41b4b16c528bf7ce760db26f",
  "testdata/grounding/card-access-paraphrase.md": "2bbf4427b1ea2c5b73995b135752f60c4978f2c9121647c4a0aa7b42d6063570",
  "testdata/grounding/card-delivery-paraphrase.md": "727f6d09cb4ebb0e8248988bb9872573d4339f2256e6723a588eceb04aa4fd42",
  "testdata/grounding/card-geek6688-faithful.md": "7b7200aa2d142720cde51c45b7266e32a5b9f278a808a115c2546443903f09f8",
@@ -236,21 +248,23 @@
  "testdata/grounding/source-access-en.md": "a1c28715a06940b0bb512cd2220aa6431bf47c1ae84da314f4a076ed6d21c906",
  "testdata/grounding/source-delivery-zh.md": "80732bee124312b791609fe499b274f81cdaa12916b30fc21bc309c41ad1ac86",
  "testdata/grounding/source-requirements.md": "5fd1115db5009aee98667634a9a374ee66460a2cb53c3819065080f2f47506f3",
-  "tidy.go": "e0b104866a11d0ce25ac80ca536a644900907d1ec6231f95e132843d88be5d0a",
+  "tidy.go": "aee6d6caebe45721d714f2954a45e453a3521b44d7edafe1b7bd15ece6d98a47",
  "tidy_test.go": "80fd37d7abf9f9fd075006da42aea73a3843c49f969e62623687519102dfe3ea",
+  "tidy_wiki_untouched_test.go": "4a42be32c770abdf9d29ee3489a1421447cac82557a4dafcf2f23e1cadc1d0c5",
  "trigger.go": "f689f701bef08401f5d47f5b3d783d24a88fc9a9426fe41bdbbb3f9b152ab405",
  "trigger_test.go": "0c2482d18cea0568cd2a0f5eae5b02a0984b9b2bc83461eb882c630d6381ca02",
  "triggeroutcome.go": "25832326ecb3694d8a3a0f8a115ce8df6327b70ff61b0bec1357d57e53e81836",
-  "triggeroutcome_test.go": "fc429ea5da193e6250b10f7d87690c293c21a0b4db763eedbc04fac9e1995e96",
+  "triggeroutcome_test.go": "0f736ba4125cf3da8e736791400a8091d0372fc0a4d252c4a1b293a4483d7720",
  "upload.go": "a41bb459eac8f6c114be567a2d7c53bbdb11b0e31f0bda4b78776502664273cb",
  "upload_test.go": "f97d2f3bf2213e6fff94b77b7120aa4e4f23f58c7e413c0416f02be387f2cb91",
  "upstream_error_visible_test.go": "6b72c903594b3eba47cfdeb40654f1f5c341757f79dfbc5c05351cd5b99c9368",
  "vault.go": "91d61613d37da5c16b24e08c70d59cf4c9cde9375737573d65921949087f1465",
-  "vault_footprint_test.go": "e3909a160675f4d750c4ad0ed608c0e8872e38bc5c125b6389c6b1e5f1b4afdb",
+  "vault_footprint_test.go": "fcfc18b90b038f16fd12c5533aff66acf40ee44b28fd4972880d8ebed807e3b1",
  "vault_subdir_test.go": "ecdd3221342e6b922ae29a7f873c4c599bd22bfb716b0a5044ba2f11a1e08d32",
  "vault_test.go": "f7ba916d0ec4fc69ea7cc3832ebca0aee83e00f4ae93077038519d06817b4c21",
  "verify-60.sh": "323347b19a366d5bcf8ddb65c9800dde32027d0170675f90e0ea46d6d1fcadc4",
-  "wikishape.go": "b6e55f1d006c4eb4bec37448d82d56e70ad7f577d7f97dc5bb00480cc1de7f23",
-  "wikishape_test.go": "910d019d13302e8cab0978fd15d201f96db2a533751779f2707f6d90ac3e148e"
+  "wikishape.go": "75901acc73abaa9b9340f13c110d90e1972207326acf8fc9ea9d6912b88524c1",
+  "wikishape_origin_test.go": "83310bb8476fb2af0eee1d7924cfc02695f280ffeeae63e5fbd7c70d4a8b0543",
+  "wikishape_test.go": "1727392a92f16b9e0b7666d752cbdd49bdf37edf310cb841cbb90f8b1a4939a5"
 }
 }
@@ -11,5 +11,12 @@
 "0.18.38": "7add5da65c671548",
 "0.18.39": "316426f50e886003",
 "0.18.40": "a4485965c128ef9d",
- "0.18.41": "8033de0cdec3537b"
+ "0.18.41": "8033de0cdec3537b",
+ "0.18.42": "43e0c6ac08233f07",
+ "0.18.43": "34f17e1e6a190eaa",
+ "0.18.44": "19e26497ae609682",
+ "0.18.45": "dc05513103f93306",
+ "0.18.46": "1325784830f592ff",
+ "0.18.47": "0decb0810da46a3f",
+ "0.18.48": "a440a58a629f960c"
 }
@@ -122,6 +122,10 @@ type syncStatus struct {
 	// arcrun-rag#140：雲端上找不到、正在自動補送的資料夾（key＝資料夾路徑）。
 	// 同上：形狀定義在 collector/sync_status.go，這裡原樣接住。
 	Resync map[string]collector.ResyncStatus `json:"resync,omitempty"`
+	// arcrun-rag#159：逐個看守資料夾的同步現況（key＝資料夾路徑）。
+	// 同上：形狀定義在 collector/progress.go／sync_status.go，這裡原樣接住。
+	// 這是資料夾那一列打不打勾的**唯一**依據（見 folder_badge.go）。
+	FolderProgress map[string]collector.SyncProgress `json:"folder_progress,omitempty"`
 }

 type skippedDoc struct {
@@ -247,7 +251,20 @@ type UIFolder struct {
 	// arcrun-rag#140：雲端上找不到先前送過的檔案（知識庫被重裝／清空過），正在自動補送。
 	// 🔴 這張票的病有一半是「**沒有任何地方會說話**」——檔案在資料夾裡、AI 卻查不到，
 	//    而且查不出為什麼。所以補送不能靜悄悄地跑，這一行就是那句話的落點。
-	ResyncNote string `json:"resyncNote,omitempty"` // 一句人話（沒事＝空字串，前端不畫）
+	//
+	// ⚠️ 2026-08-28（arcrun-rag#159）**這一行不再畫在畫面上**——leo：「補送中是什麼
+	//    意思？不要發明奇怪狀態」。同步狀態改由下面 Sync/SyncTip 那一格的圖示表達，
+	//    而它算的是真的份數（見 folder_badge.go）。這個欄位留著給診斷檔與 status.json，
+	//    #140 的「不能靜悄悄地重送」由圖示接手：補送中的檔在 manifest 裡就是還沒送成功，
+	//    圖示本來就不會打勾。
+	ResyncNote string `json:"resyncNote,omitempty"`
+
+	// arcrun-rag#159：這一列的同步狀態圖示。Sync 是機器代碼（ok／working／trouble／
+	// unknown），SyncTip 是滑過去看得到的一句短話。判準與文案都在 folder_badge.go
+	// ——**寫在 Go 這一側**，因為「打勾是不是真的」要能被測試守著，
+	// 而前端只負責把代碼換成一個圖示。
+	Sync    string `json:"sync"`
+	SyncTip string `json:"syncTip"`
 }
 type UIAccount struct {
 	Name    string     `json:"name"`
@@ -257,7 +274,11 @@ type UIAccount struct {
 	// 連結」）——一個使用者可能連著不只一個知識庫，之前只有小幫手自己的版本會提示更新，
 	// 每個知識庫各自的雲端版本完全沒有畫面。判準與 portal 版本卡同一套
 	// （collector.EvalCloudUpdate，不是 t103 的相容底線），這裡只翻成人話，不重新判斷。
-	CloudVerKnown  bool   `json:"cloudVerKnown"`            // false＝查不到（連不上／還沒查過），前端要老實說「查不到」
+	CloudVerKnown  bool   `json:"cloudVerKnown"`            // false＝**從來沒查到過**這台的版本（不是「這一輪連不上」，見 direct.go #159）
+	// arcrun-rag#159：這一輪 /health 通不通。與 CloudVerKnown 是兩件事——
+	// 版本是事實（查到過就一直知道），可達性是當下狀態（會抽風）。
+	// 前端拿它把版本號調淡並在 tooltip 說明，**不拿它把版本抹掉**。
+	CloudVerFresh bool `json:"cloudVerFresh"`
 	CloudVerStale  bool   `json:"cloudVerStale"`            // true＝有新版可更新
 	CloudVerMine   string `json:"cloudVerMine,omitempty"`   // 這個知識庫目前的版本（可能連 Known=false 時也有值）
 	CloudVerLatest string `json:"cloudVerLatest,omitempty"` // 已知的最新版
@@ -518,6 +539,10 @@ func (a *App) GetState() UIState {
 			if rs, ok := sync.Resync[f]; ok {
 				uf.ResyncNote = rs.Note
 			}
+			// #159：這一列打不打勾。key 與 collector 寫入時同一把（資料夾絕對路徑）。
+			// 查不到＝collector 還沒回報過這個資料夾 ⇒ folderBadge 回 unknown，不猜。
+			fp, known := sync.FolderProgress[f]
+			uf.Sync, uf.SyncTip = folderBadge(fp, known)
 			ui.Folders = append(ui.Folders, uf)
 		}
 		// 收回中的資料夾照樣列出來，只是標成「收回中」——不然按下移除之後它立刻消失，
@@ -533,6 +558,7 @@ func (a *App) GetState() UIState {
 		// t215：per-account 雲端版本狀態——key 與 Host 同一套算法（shortHost），
 		// 對應 collector 寫入 status.json 時用的 instanceHostOf（兩者對一般 https URL 同值）。
 		if accSt, ok := sync.AccountDetails[ui.Host]; ok {
+			ui.CloudVerFresh = accSt.CloudCheckOK
 			ui.CloudVerKnown = accSt.CloudUpdateKnown
 			ui.CloudVerStale = accSt.CloudUpdateStale
 			ui.CloudVerMine = accSt.CloudVersion
@@ -0,0 +1,82 @@
+// folder_badge.go — 資料夾那一列的**同步狀態圖示**（`inkstone/arcrun-rag#159`）。
+//
+// leo 2026-08-28 原話：
+//
+//	「補送中是什麼意思？**不要發明奇怪狀態**⋯⋯他要知道的是『**我的資料夾是否同步了**』，
+//	 **有同步打勾就好**」
+//	「產生 GUI 就是要讓人減少讀字降低負擔，你在 GUI 寫這麼多字剛好違背它的原理」
+//
+// ── 這支檔存在的理由 ─────────────────────────────────────────────────────
+// 在這之前，那一列的標籤是這樣算的（frontend/src/main.js:545）：
+//
+//	<span class="tag">${f.resyncNote ? '補送中' : '自動同步中'}</span>
+//
+// 也就是說它量的**不是同步狀態**，是「#140 那句補送說明是不是空字串」。
+// 於是 2026-08-28 leo 的畫面上七列有六列寫「補送中」——連 `youlinhsieh-test1`
+// （實測 `pending=0`、`repaired=2`，補送早就做完了）也照樣標補送中。
+// ⇒ **標籤跟事實脫鉤**，而不是措辭不好聽。
+//
+// 現在改成從 `collector.SyncProgress` 算——那是 `(*Manifest).Progress()` 的原件，
+// 與首頁大數字、診斷檔用的是同一個函式。**畫面上打的勾，跟首頁的數字同源。**
+//
+// ── 三種狀態，沒有第四種 ─────────────────────────────────────────────────
+//
+//	✅ ok       Done == Total     每一份我認得的檔都送進知識庫了，而且送上去之後沒再改過
+//	🔄 working  還沒送完，但沒有出錯的跡象
+//	⚠️ trouble  已經放棄自動重試（Stuck），或**一份都還沒成功而且每一份都失敗過**
+//
+// 🔴 第三種的第二個條件是 leo 那句「Geek6688 很久沒碰了也顯示補送中？」逼出來的。
+// 實查他機器上的 manifest（2026-08-28）：`geek6688-test1` 的 14 份**每一份的
+// fail_count 都大於 0**（7 與 3），錯誤是雲端回 `HTTP 500 Node post_block failed:
+// Too many subrequests`，`done=0`。
+// ⇒ 這不是「排隊中」，是「一直在撞牆」。標成同步中＝叫他等一件正在壞掉的事。
+// ⇒ 但**單看「有檔案在重試」不夠**：`pms` 有 110 份待處理、其中只有 4 份在重試、
+// 已經送成功 23 份——那是健康的積壓，標警告就變成新的噪音（實測 9 個資料夾裡
+// 會有 7 個亮警告，等於回到 leo 抱怨的「滿畫面都是狀態」）。
+// **所以第二個條件要求 `Done == 0`：一份都沒成功、而且全都在失敗，才叫撞牆。**
+//
+// 🔴 剛加進來、還沒開始送的資料夾（Failing == 0）落在 working，不會誤報警告。
+package main
+
+import (
+	"fmt"
+
+	collector "arcrun-rag/collector"
+)
+
+// 資料夾狀態的機器代碼。前端只認這三個字串，圖示與顏色由 CSS 決定
+// ——狀態名不進畫面，畫面上只有一個圖示（GUI 的目的是讓人少讀字）。
+const (
+	folderSyncOK      = "ok"
+	folderSyncWorking = "working"
+	folderSyncTrouble = "trouble"
+	// folderSyncUnknown＝collector 還沒回報過這個資料夾（剛加進來、第一輪還沒跑完）。
+	// **不能落到 ok**——那會是「還沒查就打勾」，正是這張票的紅線。
+	folderSyncUnknown = "unknown"
+)
+
+// folderBadge 把一個資料夾的同步現況翻成「一個狀態代碼＋一句短提示」。
+//
+// known＝status.json 裡有沒有這個資料夾的紀錄。沒有就是 unknown，不猜。
+//
+// 提示句刻意短：它住在 tooltip 裡，而 leo 的紅線是「**不要把長句子搬進 tooltip
+// 裡繼續長**」。要看細節的人有診斷檔（疑難排解那張卡），不是靠這一行。
+func folderBadge(p collector.SyncProgress, known bool) (state, tip string) {
+	if !known {
+		return folderSyncUnknown, "還在確認這個資料夾"
+	}
+	switch {
+	case p.Total == 0:
+		// 資料夾是空的、或裡面沒有我讀得了的檔。**不是「同步好了」**，
+		// 所以不打勾——打勾要對應「東西真的在知識庫裡」。
+		return folderSyncUnknown, "還沒有可整理的檔案"
+	case p.Done == p.Total:
+		return folderSyncOK, fmt.Sprintf("已同步 · %d 份", p.Done)
+	case p.Stuck > 0:
+		return folderSyncTrouble, fmt.Sprintf("%d 份一直送不上去", p.Stuck)
+	case p.Done == 0 && p.Failing > 0:
+		return folderSyncTrouble, fmt.Sprintf("%d 份都還沒送成功", p.Failing)
+	default:
+		return folderSyncWorking, fmt.Sprintf("同步中 · 還有 %d 份", p.Total-p.Done)
+	}
+}
@@ -0,0 +1,78 @@
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"sort"
+	"testing"
+
+	collector "arcrun-rag/collector"
+)
+
+// TestDumpBadgeFixture 拿**這台機器上真的 status.json**跑一次 folderBadge，
+// 把結果印出來／落成畫面驗收要用的 fixture（`inkstone/arcrun-rag#159`）。
+//
+// 🔴 為什麼不用手寫 fixture：驗收要貼的是「改後的實際畫面」，而畫面上的圖示
+// 必須是**真的那個函式**算出來的。手抄一份 fixture 就是第二套實作，
+// 貼出來的截圖也就不再是證據。
+//
+// 預設跳過（要真機資料才有意義）：`DUMP_BADGE_FIXTURE=1 go test -run TestDumpBadgeFixture`
+func TestDumpBadgeFixture(t *testing.T) {
+	if os.Getenv("DUMP_BADGE_FIXTURE") == "" {
+		t.Skip("設 DUMP_BADGE_FIXTURE=1 才跑（要讀這台機器真的 status.json）")
+	}
+	home, _ := os.UserHomeDir()
+	dir := filepath.Join(home, ".arcrun-rag")
+
+	var st struct {
+		FolderProgress map[string]collector.SyncProgress `json:"folder_progress"`
+		Resync         map[string]collector.ResyncStatus `json:"resync"`
+	}
+	b, err := os.ReadFile(filepath.Join(dir, "status.json"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := json.Unmarshal(b, &st); err != nil {
+		t.Fatal(err)
+	}
+
+	// status.json 還沒有 folder_progress（那台跑的是舊版）⇒ 從 manifest 現算，
+	// 用的仍是 (*Manifest).Progress() 本尊，不是另一套數法。
+	if len(st.FolderProgress) == 0 {
+		st.FolderProgress = map[string]collector.SyncProgress{}
+		ms, _ := filepath.Glob(filepath.Join(dir, "manifest-official-*.json"))
+		for _, mp := range ms {
+			m, err := collector.LoadManifest(mp, "")
+			if err != nil || m == nil || m.Root == "" {
+				continue
+			}
+			st.FolderProgress[m.Root] = m.Progress()
+		}
+	}
+
+	roots := make([]string, 0, len(st.FolderProgress))
+	for r := range st.FolderProgress {
+		roots = append(roots, r)
+	}
+	sort.Strings(roots)
+	out := []map[string]any{}
+	for _, r := range roots {
+		p := st.FolderProgress[r]
+		state, tip := folderBadge(p, true)
+		fmt.Printf("%-56s total=%-5d done=%-5d pending=%-5d stuck=%-3d failing=%-4d  → %-8s %s\n",
+			filepath.Base(r), p.Total, p.Done, p.Pending, p.Stuck, p.Failing, state, tip)
+		out = append(out, map[string]any{
+			"path": r, "sync": state, "syncTip": tip,
+			"resyncNote": st.Resync[r].Note,
+		})
+	}
+	if dest := os.Getenv("BADGE_FIXTURE_OUT"); dest != "" {
+		j, _ := json.MarshalIndent(out, "", "  ")
+		if err := os.WriteFile(dest, j, 0o644); err != nil {
+			t.Fatal(err)
+		}
+		t.Logf("fixture 寫到 %s", dest)
+	}
+}
@@ -0,0 +1,110 @@
+package main
+
+import (
+	"strings"
+	"testing"
+
+	collector "arcrun-rag/collector"
+)
+
+// TestFolderBadge 守住「打勾是真的」這條紅線（`inkstone/arcrun-rag#159`）。
+//
+// leo 的紅線原文：「打勾要是**真的**：說得出『打勾』的判準是什麼，
+// **不能是『沒有錯誤就打勾』**」。
+// ⇒ 下面每一格都在問同一件事：**這個狀態對應得上 manifest 裡的哪個事實？**
+func TestFolderBadge(t *testing.T) {
+	cases := []struct {
+		name  string
+		p     collector.SyncProgress
+		known bool
+		want  string
+	}{
+		{
+			// 打勾的唯一判準：認得的檔**每一份**都送上去了，而且送上去之後沒再改過
+			// （Done 的定義見 progress.go：IngestedHash != "" && == ContentHash）。
+			name:  "全部送完才打勾",
+			p:     collector.SyncProgress{Total: 19, Done: 19},
+			known: true,
+			want:  folderSyncOK,
+		},
+		{
+			name:  "差一份就不准打勾",
+			p:     collector.SyncProgress{Total: 19, Done: 18, Pending: 1},
+			known: true,
+			want:  folderSyncWorking,
+		},
+		{
+			// 🔴 「沒有錯誤就打勾」的反例：沒有任何失敗，但也還沒送完。
+			name:  "零錯誤但沒送完＝同步中，不是打勾",
+			p:     collector.SyncProgress{Total: 133, Done: 23, Pending: 110},
+			known: true,
+			want:  folderSyncWorking,
+		},
+		{
+			// leo 2026-08-28 桌面實測值：geek6688-test1（14 份全在重試、一份都沒成功，
+			// 雲端回 HTTP 500 Too many subrequests）。這是「不再標成進行中」的那一格。
+			name:  "一份都沒成功而且全都在重試＝警告",
+			p:     collector.SyncProgress{Total: 14, Done: 0, Pending: 14, Failing: 14},
+			known: true,
+			want:  folderSyncTrouble,
+		},
+		{
+			// 對照組：健康的積壓不准亮警告，不然畫面又變回「滿滿都是狀態」。
+			// 實測值取自 pms（110 待處理裡只有 4 份在重試，已經成功 23 份）。
+			name:  "有成功過的積壓＝同步中，不亮警告",
+			p:     collector.SyncProgress{Total: 133, Done: 23, Pending: 110, Failing: 4},
+			known: true,
+			want:  folderSyncWorking,
+		},
+		{
+			// 剛加進來、還沒開始送：一份都沒成功，但也還沒失敗過 ⇒ 不准嚇人。
+			name:  "剛加進來還沒送＝同步中",
+			p:     collector.SyncProgress{Total: 20, Done: 0, Pending: 20},
+			known: true,
+			want:  folderSyncWorking,
+		},
+		{
+			// 已放棄自動重試＝**不會自己好**，就算大多數都送成功了也要講。
+			name:  "有放棄重試的就亮警告",
+			p:     collector.SyncProgress{Total: 4184, Done: 817, Pending: 3342, Stuck: 25, Failing: 95},
+			known: true,
+			want:  folderSyncTrouble,
+		},
+		{
+			// 空資料夾不准打勾——打勾要對應「東西真的在知識庫裡」。
+			name:  "沒有可整理的檔案不打勾",
+			p:     collector.SyncProgress{},
+			known: true,
+			want:  folderSyncUnknown,
+		},
+		{
+			// 🔴 collector 還沒回報 ⇒ 零值。舊寫法會讓它看起來「什麼問題都沒有」，
+			//    在這裡它必須是 unknown，不能落到 ok。
+			name:  "還沒回報過不准打勾",
+			p:     collector.SyncProgress{},
+			known: false,
+			want:  folderSyncUnknown,
+		},
+	}
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			got, tip := folderBadge(c.p, c.known)
+			if got != c.want {
+				t.Fatalf("folderBadge(%+v, known=%v) = %q，預期 %q", c.p, c.known, got, c.want)
+			}
+			if strings.TrimSpace(tip) == "" {
+				t.Fatalf("每個狀態都要講得出自己是什麼（leo 驗收條件 3），但 tip 是空的")
+			}
+			// 紅線：提示句是**產品文案**，不准出現狀態碼／技術詞；也不准長成一段說明
+			// （leo：「不要把長句子搬進 tooltip 裡繼續長」）。
+			for _, bad := range []string{"HTTP", "500", "error", "token", "manifest", "pending", "stuck"} {
+				if strings.Contains(strings.ToLower(tip), strings.ToLower(bad)) {
+					t.Fatalf("提示句出現技術詞 %q：%q", bad, tip)
+				}
+			}
+			if n := len([]rune(tip)); n > 20 {
+				t.Fatalf("提示句 %d 字，太長了（上限 20）：%q", n, tip)
+			}
+		})
+	}
+}
@@ -166,25 +166,39 @@ function cardKbVersions(s) {
    </div>`;
 }

-// kbVersionLine：單一知識庫的版本判定文案，首頁卡與各庫頁共用同一份翻譯，
-// 不讓兩處各寫各的文字（那樣才真的會出現「兩處講不同的話」）。
+// kbVersionLine：單一知識庫的版本，首頁卡與各庫頁共用同一份（不讓兩處各寫各的）。
 //
-// 三種情況都要照實講（cloud_version.go 記過的坑：把「查不到」呈現成「一切正常」）：
-//   ① Known 且落後 → 紅字＋按鈕，按下去帶 email 開 install 頁（同 portal 版本卡的預填做法）
-//   ② Known 且已最新 → 淡字「已是最新版」
-//   ③ 不 Known → 照原因分兩句：連不上這個知識庫／查得到目前版本但暫時查不到最新版
+// 🔴 `inkstone/arcrun-rag#159`（leo 2026-08-28）：「**GUI 是國際通用，圖形指示，
+//    不限語文**，所以任何出現文字都要謹慎，文字表示『我的設計不夠好所以要靠文字來補』」
+//    ⇒ 這一行以前是三句話（「有新版可更新（目前 x → 最新 y）」「已是最新版（x）」
+//      「目前連不上這個知識庫，查不到版本」）。現在只剩**版本號與圖示**：
+//
+//        1.4.60          ✅     已是最新
+//        1.4.46 → 1.4.58 ⬆️     有新版（按鈕，按下去帶 email 開安裝頁）
+//        ○                      從來沒查到過這台的版本
+//
+//    說明都收進 title（滑過去才出現），版面上一個字都不佔。
+//
+// 🔴 「這一輪連不上」**不再抹掉版本號**（見 collector/direct.go 那段註解）：
+//    版本查到過就是事實，抽風的是網路。連不上時版本號調淡，滑過去講得出來。
 function kbVersionLine(a) {
+  const dim = a.cloudVerFresh ? '' : ' dim';
+  const tip = a.cloudVerFresh ? '' : '上次查到的版本（現在暫時連不上）';
  if (!a.cloudVerKnown) {
-    const detail = a.cloudVerMine
-      ? `已知版本 ${esc(a.cloudVerMine)}，暫時查不到最新版本（稍後會自動再查）`
-      : '目前連不上這個知識庫，查不到版本';
-    return `<span class="d">${detail}</span>`;
+    // 分得出「沒查到這台的版本」與「查到了但暫時不知道最新版是多少」——
+    // 前者連版本號都沒有，後者有版本號可以顯示。
+    if (!a.cloudVerMine) {
+      return `<span class="kbv unknown" role="img" title="還沒查到這個知識庫的版本">○</span>`;
+    }
+    return `<span class="kbv${dim}" title="${esc(tip || '暫時查不到最新版本，稍後自動再查')}">${esc(a.cloudVerMine)}</span>`;
  }
  if (a.cloudVerStale) {
-    return `<span class="warn">有新版可更新（目前 ${esc(a.cloudVerMine)} → 最新 ${esc(a.cloudVerLatest)}）</span>
-      <button class="ghost" data-updatekb="${esc(a.email || '')}">前往安裝頁更新</button>`;
+    return `<span class="kbv${dim}" title="${esc(tip)}">${esc(a.cloudVerMine)} → ${esc(a.cloudVerLatest)}</span>
+      <button class="ico" data-updatekb="${esc(a.email || '')}"
+        title="前往安裝頁更新這個知識庫" aria-label="前往安裝頁更新這個知識庫">⬆️</button>`;
  }
-  return `<span class="d">已是最新版（${esc(a.cloudVerMine)}）</span>`;
+  return `<span class="kbv${dim}" title="${esc(tip)}">${esc(a.cloudVerMine)}</span>
+    <span class="fstat ok" role="img" title="已是最新版" aria-label="已是最新版">✅</span>`;
 }

 // installURLFor：與 portal 版本卡同一個做法——落後才需要按，按下去帶 email 讓安裝頁
@@ -320,7 +334,18 @@ function cardSkipped(k) {
 // data：path → 樹（undefined＝還沒問、null＝問過但小幫手還沒回報）
 // open：path → 這個資料夾的樹展開了沒
 // nodes：path → { 節點路徑: 展開了沒 }（沒有紀錄＝用預設，見 nodeIsOpen）
-const treeState = { data: {}, open: {}, nodes: {} };
+// why：path → { 節點路徑: 這一列的「為什麼」被點開了沒 }（arcrun-rag#159）
+const treeState = { data: {}, open: {}, nodes: {}, why: {} };
+
+// ── 資料夾那一列的狀態圖示（`inkstone/arcrun-rag#159`）────────────────────
+//
+// leo 2026-08-28：「補送中、資料夾結構、移除，**變成 3 個 emoticon 就好，
+// 畫面上都是字壓力很大**」「他要知道的是『我的資料夾是否同步了』，**有同步打勾就好**」
+//
+// 🔴 這裡**只做代碼→圖示的對照**，一個判斷都不做。
+//    「該不該打勾」住在 Go 那一側（cmd/arcrun-app/folder_badge.go，有測試守著）——
+//    前端自己判斷就會變成第二套判準，遲早跟後端說的不一樣。
+const SYNC_ICON = { ok: '✅', working: '🔄', trouble: '⚠️', unknown: '○' };

 // 資料夾路徑當不了 DOM id（含空白、斜線、中文）⇒ 折成一個穩定的短碼。
 function treeBoxId(path) {
@@ -331,7 +356,12 @@ function treeBoxId(path) {

 // 子樹合計：小幫手送的每個數字都只算「這一層直接放的檔」（存兩套遲早對不起來），
 // 所以要顯示「這個資料夾底下總共」就得在這裡疊一次。
-// 🔴 skipped 的節點整棵不計：沒走進去就是不知道裡面有幾個檔，加 0 會讓分母說謊。
+// 🔴 **沒走進去**的節點整棵不計：不知道裡面有幾個檔，加 0 會讓分母說謊。
+// 分辨方法（inkstone/Arcrun#180 之後）：`skipped` 已經改成「這一層的檔不收」，
+// 而**走進去過的節點 total_files 是真的**——所以只有 `total_files === 0` 的
+// skipped 節點才是「真的沒走進去」，那種才不計。
+// 走進去過的（例如 `system-dev/wiki` 6 個範本檔全排除）要照算，
+// 不然 leo 要的「知道資料夾下有幾個檔案被萃」在合計上又變回 0。
 // （與 portal 的 rollupTree 同一套算法——兩邊看到的數字必須是同一個。）
 function rollupTree(nodes) {
  const byPath = {}, kids = {};
@@ -339,7 +369,7 @@ function rollupTree(nodes) {
  const sums = {};
  function walk(n) {
    const acc = { total: 0, synced: 0, pending: 0, unsupported: 0, excluded: 0 };
-    if (!n.skipped) {
+    if (!n.skipped || n.total_files > 0) {
      acc.total = n.total_files; acc.synced = n.synced_files; acc.pending = n.pending_files;
      acc.unsupported = n.unsupported_files; acc.excluded = n.excluded_files;
    }
@@ -385,13 +415,12 @@ function renderFolderTree(path) {
  //    （指定了空資料夾，它就該在畫面上存在），前者是「再等一下」。
  //    兩者講同一句話，等於拿我們自己編的答案回答使用者。
  if (tree === null) {
-    box.innerHTML = `<div class="ftmsg">同步小幫手還沒掃到這個資料夾的結構。
-      第一次同步跑完之後就會出現——檔案多的話要等久一點，按上面的「立刻同步」可以催它。</div>`;
+    box.innerHTML = `<div class="ftmsg">還沒掃到這個資料夾，第一次同步跑完就會出現。</div>`;
    return;
  }
  const nodes = tree.nodes || [];
  if (!nodes.length) {
-    box.innerHTML = `<div class="ftmsg">這個資料夾目前沒有任何內容（指定了就會在這裡，等你放東西進去）。</div>`;
+    box.innerHTML = `<div class="ftmsg">這個資料夾目前是空的。</div>`;
    return;
  }
  const r = rollupTree(nodes);
@@ -416,19 +445,37 @@ function renderFolderTree(path) {
      + `<span class="tw">${kids.length ? '<i></i>' : ''}</span>`
      + `<span class="ic">${kids.length && open ? '📂' : '📁'}</span>`
      + `<span class="nm">${esc(n.name || '（未命名）')}</span>`;
-    if (n.skipped) {
-      // 🔴 整棵沒走進去 ⇒ 不准顯示 0/0（那會是我們自己編的數字），改講理由。
-      const why = n.skip_reason || '（小幫手沒說明理由）';
-      row += `<span class="skip">整個資料夾未收</span>`
-        + `<span class="why" title="${esc(why)}">${esc(why)}</span>`;
-    } else {
-      const full = s.total > 0 && s.synced === s.total;
-      row += `<span class="num${full ? ' full' : ''}">${s.synced} / ${s.total}</span>`;
-      const why = gapWhy(s);
-      if (why) row += `<span class="why" title="${esc(why)}">${esc(why)}</span>`;
-    }
-    if (kids.length && !open) row += `<span class="why">…還有 ${kids.length} 個子資料夾</span>`;
+    // ── 一列只有：三角形 ＋ 資料夾名 ＋ `X / Y`（`inkstone/arcrun-rag#159`）──
+    //
+    // leo 2026-08-28：「**上下廢話刪除**，**產生 GUI 就是要讓人減少讀字降低負擔，
+    // 你在 GUI 寫這麼多字剛好違背它的原理**」——他的截圖上同一句
+    // 「這是安裝範本時鋪下來的空白樣板…」**在一棵樹裡出現了 5 次**。
+    //
+    // 🔴 **「收起來」不等於「刪掉」**（本票紅線）：那些理由是使用者要救回被跳過的
+    //    資料夾時的線索（`inkstone/arcrun-rag#136`）。所以理由沒有被拿掉，
+    //    只是**不再預設佔畫面**——點那個數字就展開這一列自己的理由。
+    //    🔴 也**不塞進 tooltip**（同一條紅線：「不要把長句子搬進 tooltip 裡繼續長」），
+    //    tooltip 只有「點一下看原因」這種操作提示。
+    let why = n.skipped
+      ? (n.skip_reason || '（小幫手沒說明理由）')
+      : gapWhy(s);
+    // 收檔策略那句話（原本掛在樹的上方，leo 圈掉了）改掛在**根那一列**——
+    // 它講的就是這個監看根，點根的數字就看得到，資訊沒有消失。
+    if (n.parent === '-' && tree.reason) why = why ? `${tree.reason}（${why}）` : tree.reason;
+    // 整棵沒走進去（#180 之後：skipped 且 total_files 為 0）⇒ 不准顯示 0/0，
+    // 那會是我們自己編的數字。用「—」表示「這個數字我沒有」。
+    const noCount = n.skipped && n.total_files === 0;
+    const full = !noCount && s.total > 0 && s.synced === s.total;
+    const shown = noCount ? '—' : `${s.synced} / ${s.total}`;
+    row += `<span class="num${full ? ' full' : ''}${why ? ' hasWhy' : ''}"`
+      + (why
+        ? ` data-twhy="${esc(n.path)}" data-twroot="${esc(path)}" role="button" tabindex="0" title="點一下看原因"`
+        : '')
+      + `>${shown}</span>`;
    html += row + `</div>`;
+    if (why && (treeState.why[path] || {})[n.path]) {
+      html += `<div class="ftwhy" style="padding-left:${indent + 21}px">${esc(why)}</div>`;
+    }
    if (open) kids.forEach(emit);
  }
  (r.kids['-'] || []).forEach(emit);
@@ -437,17 +484,22 @@ function renderFolderTree(path) {
  nodes.forEach((n) => { seen[n.path] = true; });
  nodes.forEach((n) => { if (n.parent !== '-' && !seen[n.parent]) emit(n); });

+  // 🔴 樹的上方與下方**什麼都不留**（`inkstone/arcrun-rag#159`，leo 在截圖上圈了三處）：
+  //    ① 上方的「全部展開／全部收合 ＋ 這是一般資料夾或筆記庫…」整條拿掉
+  //    ② 下方的「數字是『已同步 / 這個資料夾底下總共』…」整段拿掉
+  //    ③ 下方的補送說明拿掉（狀態改由資料夾那一列的圖示表達）
+  //    leo 原話：「**上下廢話刪除，只留乾淨 Tree**」。
+  //
+  //    收檔策略那句話（tree.reason）沒有消失——它跟每一列的理由走同一條路：
+  //    點根那一列的數字就看得到（emit() 裡的 hasWhy）。
+  //
+  //    **唯一的例外是截斷警告**：它只在樹真的不完整時才出現，而不講就是讓畫面
+  //    宣稱「這是全部」——那是說謊，不是廢話。
  let foot = '';
  if (tree.truncated) {
-    foot += `<div class="ftmsg">資料夾太多，只顯示前 ${nodes.length} 個（實際有 ${tree.total_nodes} 個）。</div>`;
+    foot = `<div class="ftmsg">只顯示前 ${nodes.length} 個資料夾（實際有 ${tree.total_nodes} 個）。</div>`;
  }
-  foot += `<div class="ftmsg">數字是「已同步 / 這個資料夾底下總共」。兩者不相等是正常的——
-    差額是還讀不了的格式、不在收檔範圍的檔案（程式碼等），或還在處理中。</div>`;
-  box.innerHTML = `<div class="fthead">`
-    + `<button class="ghost" data-texpand="${esc(path)}">全部展開</button>`
-    + `<button class="ghost" data-tcollapse="${esc(path)}">全部收合</button>`
-    + (tree.reason ? `<span class="why">${esc(tree.reason)}</span>` : '')
-    + `</div><div class="ftbody">${html}</div>${foot}`;
+  box.innerHTML = `<div class="ftbody">${html}</div>${foot}`;
  wireTree();
 }

@@ -456,8 +508,13 @@ function renderFolderTree(path) {
 async function toggleFolderTree(path) {
  treeState.open[path] = !treeState.open[path];
  const box = $(treeBoxId(path));
+  // #159：那顆按鈕現在只有一個 CSS 畫的三角形（沒有文字），轉向由 class 決定。
  const btn = document.querySelector(`[data-tree="${cssq(path)}"]`);
-  if (btn) btn.textContent = (treeState.open[path] ? '▾ ' : '▸ ') + '資料夾結構';
+  if (btn) {
+    btn.setAttribute('aria-expanded', String(!!treeState.open[path]));
+    const row = btn.closest('.folder');
+    if (row) row.classList.toggle('open', !!treeState.open[path]);
+  }
  if (!box) return;
  box.style.display = treeState.open[path] ? '' : 'none';
  if (!treeState.open[path]) return;
@@ -476,16 +533,6 @@ async function toggleFolderTree(path) {
 // 屬性選擇器要跳脫引號——資料夾路徑什麼字元都可能有。
 function cssq(s) { return String(s).replace(/["\\]/g, '\\$&'); }

-function setAllTreeNodes(path, open) {
-  const tree = treeState.data[path];
-  if (!tree) return;
-  const st = {};
-  (tree.nodes || []).forEach((n) => { st[n.path] = open; });
-  if (!open) st[''] = true; // 全部收合時根自己留著，不然整棵消失、看起來像壞了
-  treeState.nodes[path] = st;
-  renderFolderTree(path);
-}
-
 function wireTree() {
  document.querySelectorAll('[data-tnode]').forEach((el) => {
    const toggle = () => {
@@ -499,11 +546,19 @@ function wireTree() {
    el.onclick = toggle;
    el.onkeydown = (e) => { if (e.key === 'Enter' || e.key === ' ') { e.preventDefault(); toggle(); } };
  });
-  document.querySelectorAll('[data-texpand]').forEach((el) => {
-    el.onclick = () => setAllTreeNodes(el.dataset.texpand, true);
-  });
-  document.querySelectorAll('[data-tcollapse]').forEach((el) => {
-    el.onclick = () => setAllTreeNodes(el.dataset.tcollapse, false);
+  // #159：點數字＝展開這一列自己的「為什麼」。理由沒有被刪掉，只是不再預設佔畫面。
+  // stopPropagation：這個數字常常長在「整列可點＝展開子資料夾」的列上，
+  // 不擋住的話點原因會順便把子資料夾收掉。
+  document.querySelectorAll('[data-twhy]').forEach((el) => {
+    const toggle = (e) => {
+      e.stopPropagation();
+      const root = el.dataset.twroot, np = el.dataset.twhy;
+      const st = treeState.why[root] || (treeState.why[root] = {});
+      st[np] = !st[np];
+      renderFolderTree(root);
+    };
+    el.onclick = toggle;
+    el.onkeydown = (e) => { if (e.key === 'Enter' || e.key === ' ') { e.preventDefault(); toggle(e); } };
  });
 }

@@ -529,14 +584,17 @@ function pageLib(s, idx) {
          : `正在從雲端收回…${f.retireRemaining ? `還有 ${f.retireRemaining} 份` : ''}`}</span>
      </div>
      ${f.retireError ? `<div class="d folder-note">${esc(f.retireError)}</div>` : ''}` : `
-      <div class="folder">
+      <div class="folder${treeState.open[f.path] ? ' open' : ''}">
+        <button class="tw" data-tree="${esc(f.path)}" aria-expanded="${!!treeState.open[f.path]}"
+          title="展開這個資料夾" aria-label="展開或收合這個資料夾的內容"><i></i></button>
        <span class="path" title="${esc(f.path)}">${esc(f.path)}</span>
-        <span class="tag">${f.resyncNote ? '補送中' : '自動同步中'}</span>
-        <button class="ghost" data-tree="${esc(f.path)}">${treeState.open[f.path] ? '▾' : '▸'} 資料夾結構</button>
-        <button class="ghost" data-rm="${esc(f.path)}" data-acc="${f.accIdx}">移除</button>
+        <span class="fstat ${esc(f.sync || 'unknown')}" role="img"
+          title="${esc(f.syncTip || '')}" aria-label="${esc(f.syncTip || '')}"
+          >${SYNC_ICON[f.sync] || SYNC_ICON.unknown}</span>
+        <button class="ico" data-rm="${esc(f.path)}" data-acc="${f.accIdx}"
+          title="移除這個資料夾" aria-label="移除這個資料夾並從知識庫收回">🗑</button>
      </div>
-      <div class="ftbox" id="${treeBoxId(f.path)}"${treeState.open[f.path] ? '' : ' style="display:none"'}></div>
-      ${f.resyncNote ? `<div class="d folder-note">${esc(f.resyncNote)}</div>` : ''}`).join('')
+      <div class="ftbox" id="${treeBoxId(f.path)}"${treeState.open[f.path] ? '' : ' style="display:none"'}></div>`).join('')
      || `<div class="empty"><div class="t">這個知識庫還沒有資料夾</div>
           <div class="d">按右上的「加入資料夾」，選一個要自動整理的資料夾。</div></div>`}`;
 }
@@ -144,6 +144,41 @@ button.ghost:hover { color: var(--err); background: transparent; }
 .folder .tag.retiring { color: rgba(var(--ink-rgb), .5); }
 .folder-note { margin: -3px 0 9px; padding: 0 15px; font-size: 12.5px; }

+/* ══ arcrun-rag#159：那一列只剩「三角形 ＋ 路徑 ＋ 兩個圖示」══════════════
+   leo 2026-08-28：「補送中、資料夾結構、移除，**變成 3 個 emoticon 就好，
+   畫面上都是字壓力很大**」「**展開三角形按鈕放資料夾上**」
+   ⇒ 三角形移到列首（跟樹裡面的展開鈕同一個造型，使用者只要學一次）。 */
+.folder > .tw {
+  flex: none; width: 22px; height: 22px; padding: 0; border: none; background: none;
+  display: inline-flex; align-items: center; justify-content: center;
+}
+.folder > .tw:hover { background: none; }
+/* 三角形用 CSS 畫，不用 ▸▾ 字元——理由同樹裡那顆（見 .ftrow .tw i）：
+   那兩個字在 Windows 的中文字型裡是全形，大小與位置每台機器都不一樣。 */
+.folder > .tw i {
+  display: block; width: 0; height: 0;
+  border-left: 6px solid rgba(var(--ink-rgb), .5);
+  border-top: 5px solid transparent; border-bottom: 5px solid transparent;
+  transition: transform .12s;
+}
+.folder.open > .tw i { transform: rotate(90deg); }
+.folder > .tw:hover i { border-left-color: var(--amber); }
+/* 狀態圖示。**一個字都沒有**——說明住在 title/aria-label 裡，滑過去才出現。 */
+.folder .fstat { flex: none; font-size: 14px; line-height: 1; cursor: default; }
+/* 🔴 視覺層級要對得上意思：**只有需要你出手的那一格才准大聲**。
+   「同步中」是常態、不需要任何人做什麼 ⇒ 壓到跟灰階一樣安靜；
+   ⚠️ 維持原色，因為它是唯一一個「你可能要看一下」的狀態。
+   （不壓的話 🔄 的藍色會比 ⚠️ 還跳，畫面就在對使用者喊錯的東西。） */
+.folder .fstat.working { filter: grayscale(.85); opacity: .5; }
+/* 還沒回報過的那一格刻意做得很淡：它不是「沒問題」，是「還不知道」。 */
+.folder .fstat.unknown { color: rgba(var(--ink-rgb), .3); font-size: 12px; }
+/* 圖示按鈕（移除）：跟三角形同一個量級，hover 才變紅——不預設嚷嚷。 */
+.folder .ico {
+  flex: none; padding: 4px 6px; border: none; background: none;
+  font-size: 14px; line-height: 1; filter: grayscale(1); opacity: .7;
+}
+.folder .ico:hover { background: none; filter: none; opacity: 1; }
+
 .big-num { font-size: 26px; font-weight: 600; letter-spacing: .01em; }
 .kv { display: flex; gap: 26px; margin-top: 4px; }
 .kv .k { font-size: 12.5px; color: rgba(var(--ink-rgb), .45); }
@@ -299,6 +334,14 @@ input[type=text], input[type=password] {
 .kbrow .nm { font-size: 14px; font-weight: 600; flex: none; }
 .kbrow .right { display: flex; align-items: center; gap: 10px; font-size: 13px; }
 .kbver { margin-bottom: 14px; font-size: 13.5px; display: flex; align-items: center; gap: 10px; }
+/* arcrun-rag#159：版本那一格只有**數字與圖示**，說明收進 title。
+   等寬字讓 `1.4.46 → 1.4.58` 這種對照掃視時對得齊。 */
+.kbv { font-family: ui-monospace, Menlo, monospace; font-size: 12.5px; color: rgba(var(--ink-rgb), .7); }
+/* 這一輪連不上 ⇒ 版本號調淡表示「這是上次查到的」。**不是把它抹掉**——
+   版本查到過就是事實，抽風的是網路（見 collector/direct.go #159 那段）。 */
+.kbv.dim { opacity: .45; }
+/* 從來沒查到過：一個很淡的圈，跟資料夾那一列的 unknown 同一個語彙。 */
+.kbv.unknown { font-family: inherit; color: rgba(var(--ink-rgb), .3); }
 .warn { color: var(--err); font-size: 13px; }
 #side .nav .dot.warn {
  width: 7px; height: 7px; border-radius: 50%; flex: none;
@@ -432,12 +475,10 @@ input[type=text], input[type=password] {
  margin: -3px 0 9px; padding: 8px 10px 6px;
  background: var(--well); border-radius: 10px;
 }
-.fthead {
-  display: flex; align-items: center; gap: 8px; flex-wrap: wrap;
-  padding-bottom: 7px; margin-bottom: 5px;
-  border-bottom: 1px solid rgba(var(--ink-rgb), .08);
-}
-.fthead button { padding: 4px 9px; font-size: 12px; }
+/* 🔴 arcrun-rag#159：`.fthead`（全部展開／全部收合＋收檔策略那句話）**整條移除**。
+   leo 2026-08-28 在截圖上圈掉它：「上下廢話刪除，只留乾淨 Tree」
+   「產生 GUI 就是要讓人減少讀字降低負擔，你在 GUI 寫這麼多字剛好違背它的原理」。
+   收檔策略那句話沒有被刪掉——它改掛在根那一列的數字上，點一下就看得到。 */
 /* 樹本體：檔案總管那種「緊湊但點得到」的密度。
   overflow-x 讓很深的樹自己捲，不去撐破右側版面。 */
 .ftbody { overflow-x: auto; padding: 1px 0; }
@@ -474,6 +515,19 @@ input[type=text], input[type=password] {
 }
 /* 全部同步完＝這一格沒有待辦，用完整墨色讓它從灰階裡浮出來（不另發明「成功色」）。 */
 .ftrow .num.full { color: var(--ink); }
+/* #159：這一列有「為什麼」可以看時，數字自己就是那顆按鈕（畫面上不多一個字、
+   也不多一顆按鈕）。虛線底線是唯一的提示——**它不是裝飾，是可點的告示**。 */
+.ftrow .num.hasWhy {
+  cursor: pointer;
+  border-bottom: 1px dotted rgba(var(--ink-rgb), .35);
+}
+.ftrow .num.hasWhy:hover { color: var(--ink); border-bottom-color: var(--amber); }
+.ftrow .num.hasWhy:focus-visible { outline: 2px solid var(--amber); outline-offset: 1px; }
+/* 點開之後那一行理由。預設不存在——這就是「收起來不等於刪掉」的落點。 */
+.ftwhy {
+  font-size: 12px; line-height: 1.6; padding: 1px 4px 4px;
+  color: rgba(var(--ink-rgb), .55); white-space: normal; max-width: 46em;
+}
 /* 🔴 選擇器**不要**綁在 .ftrow 底下：頁首那句「為什麼只收這些」也用同一個 class，
   綁死就只有樹裡面吃得到樣式、頁首那句會掉回 16px 的內文級——實撞過一次，
   畫面上那句話比整棵樹都大聲，喧賓奪主。 */
@@ -484,12 +538,6 @@ input[type=text], input[type=password] {
  font-size: 12px; color: rgba(var(--ink-rgb), .45);
  flex: 0 1 auto; min-width: 0; overflow: hidden; text-overflow: ellipsis;
 }
-.fthead .why { flex: 1; min-width: 0; line-height: 1.6; }
-/* 整棵沒走進去：語氣是告知不是錯誤，所以不用 --err。 */
-.ftrow .skip {
-  font-size: 11.5px; color: rgba(var(--ink-rgb), .5);
-  border: 1px solid rgba(var(--ink-rgb), .18); border-radius: 5px; padding: 0 5px;
-}
 .ftmsg {
  padding: 6px 2px 2px; font-size: 12px; line-height: 1.65;
  color: rgba(var(--ink-rgb), .45);
@@ -67,7 +67,7 @@ func TestWiring_docx轉檔發生在送LLM之前(t *testing.T) {
 	writeDocx(t, filepath.Join(dir, rel), `<w:p><w:r><w:t>維修費用 350,000 元</w:t></w:r></w:p>`)

 	// 空 API key → 函式最前面就擋下，證明不了轉檔。給假 key 讓它走到轉檔那一步。
-	_, err := ExtractWithGemma("fake-key-for-test", "", dir, rel)
+	_, err := ExtractWithGemma("fake-key-for-test", "", dir, rel, testOrigin())
 	if err == nil {
 		t.Fatal("用假 key 不該成功")
 	}
@@ -90,7 +90,7 @@ func TestWiring_抽不出文字要明確失敗不靜默(t *testing.T) {
 	rel := "空的.docx"
 	writeDocx(t, filepath.Join(dir, rel), `<w:p><w:r><w:t>   </w:t></w:r></w:p>`)

-	_, err := ExtractWithGemma("fake-key-for-test", "", dir, rel)
+	_, err := ExtractWithGemma("fake-key-for-test", "", dir, rel, testOrigin())
 	if err == nil {
 		t.Fatal("抽不出文字應該失敗")
 	}
@@ -109,7 +109,7 @@ func TestWiring_未支援格式與無文字要能區分(t *testing.T) {
 	rel := "簡報.ppt"
 	os.WriteFile(filepath.Join(dir, rel), []byte("\xD0\xCF\x11\xE0\xA1\xB1\x1A\xE1fake"), 0o644)

-	_, err := ExtractWithGemma("fake-key-for-test", "", dir, rel)
+	_, err := ExtractWithGemma("fake-key-for-test", "", dir, rel, testOrigin())
 	if err == nil {
 		t.Fatal("未支援格式應該失敗")
 	}
@@ -127,7 +127,7 @@ func TestWiring_md不受轉檔層影響(t *testing.T) {
 	rel := "筆記.md"
 	os.WriteFile(filepath.Join(dir, rel), []byte("# 標題\n\n內容"), 0o644)

-	_, err := ExtractWithGemma("fake-key-for-test", "", dir, rel)
+	_, err := ExtractWithGemma("fake-key-for-test", "", dir, rel, testOrigin())
 	if err == nil {
 		t.Fatal("假 key 不該成功")
 	}
@@ -114,6 +114,12 @@ type DirectConfig struct {
 	// 所以改名不會讓庫裡憑空多出一台機器。
 	MachineLabel string `json:"machine_label,omitempty"`

+	// guard＝這一輪的「等待閘」（見 stallguard.go）。RunDirectOnce 每輪換一份新的；
+	// makeAccountSubConfig 的 `sub := *c` 會把這個**指標**一起帶過去，所以同一輪的
+	// 所有帳號、所有資料夾共用同一份紀錄——斷路器要跨得了資料夾才擋得住「一發卡住
+	// 就整輪停擺」。不落 config 檔（它是這一次執行的狀態，不是使用者設定）。
+	guard *roundGuard
+
 	// machine＝解析好的機器身分快取（不落 config 檔：ID 的家是 machine.json，
 	// 這裡只是這一輪的記憶體副本。makeAccountSubConfig 的 `sub := *c` 會一起複製，
 	// 所以多帳號同一輪只解析一次、每個帳號送出的值必然一致）。
@@ -467,7 +473,11 @@ func (c *DirectConfig) migrateManifestIfNeeded(absRoot, newPath string) {
 	}
 }

-// directHTTP 是 direct 模式共用的 HTTP client（萃取 workflow 可能同步跑 LLM，放寬 timeout）。
+// directHTTP 是 direct 模式共用的 HTTP client。
+//
+// 🔴 這把 Timeout 是**最後一道**保險，不是每一發的上限（`inkstone/arcrun-rag#153`）：
+// 真正生效的上限由呼叫端的 callStep 帶進 context（見 stallguard.go），因為
+// 「送一份筆記」跟「請雲端同步跑完 AI 萃取」本來就不該共用同一個數字。
 var directHTTP = &http.Client{Timeout: 300 * time.Second}

 // triggerURL 組出 named-webhook 觸發完整 URL。
@@ -505,12 +515,23 @@ func countsAsDocument(r DirectResult) bool {
 }

 // postJSON POST 一個 JSON body 到 url，回傳 HTTP 狀態碼與回應片段。非 2xx 視為錯誤。
-func (c *DirectConfig) postJSON(url string, body any) (int, string, error) {
+//
+// step 講的是「這一發在做什麼」（`inkstone/arcrun-rag#153`）：它決定這一發自己的
+// 上限，也決定卡住時畫面與日誌上那句話怎麼寫。同一個網址在不同地方是不同的事
+//（收卡那條路，可能是使用者剛存的新檔，也可能是在補修舊筆記的出處）——
+// 所以 step 由呼叫端給，不從網址反推，反推出來的名字會說謊。
+func (c *DirectConfig) postJSON(step callStep, url string, body any) (int, string, error) {
 	data, err := json.Marshal(body)
 	if err != nil {
 		return 0, "", err
 	}
-	req, err := http.NewRequest(http.MethodPost, url, bytes.NewReader(data))
+	gate := c.openGate(step)
+	defer gate.release() // context 要活到下面讀完回應為止，所以是 defer 不是就地釋放
+	// 這一輪已經判定這個帳號沒有回應 ⇒ 連打都不打，立刻回頭讓其他資料夾繼續。
+	if note := gate.blocked(); note != "" {
+		return 0, "", errors.New(note)
+	}
+	req, err := http.NewRequestWithContext(gate.ctx, http.MethodPost, url, bytes.NewReader(data))
 	if err != nil {
 		return 0, "", err
 	}
@@ -518,8 +539,9 @@ func (c *DirectConfig) postJSON(url string, body any) (int, string, error) {
 	req.Header.Set("X-Arcrun-API-Key", c.APIKey)
 	resp, err := directHTTP.Do(req)
 	if err != nil {
-		return 0, "", err
+		return 0, "", gate.record(err)
 	}
+	gate.ok() // #153：回來了就把「連續逾時」的計數歸零——否則「連續」兩個字是假的
 	defer resp.Body.Close()
 	// 🔴 讀 64KB 而不是 1KB：觸發端點的回應是一層外殼包著工作流的輸出，
 	// 而**失敗的證據住在殼裡面**（見 triggeroutcome.go）。1KB 會把 JSON 切斷 ⇒
@@ -611,6 +633,12 @@ func RunDirectOnce(cfg *DirectConfig, dryRun bool) ([]DirectResult, int, *Trigge
 	var lastPayload *TriggerPayload
 	now := time.Now() // 2026-08-07 pacing task：整輪共用同一個時間點（排序/冷卻判斷一致、好測試）

+	// 🔴 `inkstone/arcrun-rag#153`：這一輪的「等待閘」。每輪換一份新的——斷路器只管
+	// 這一輪，下一輪一律從零開始重新試（同步是 level-triggered 的，沒有什麼要記住）。
+	// 指標會隨 makeAccountSubConfig 的 `sub := *c` 傳給每個帳號、每個資料夾，
+	// 所以「這個帳號沒有回應」這件事跨得了資料夾——那正是本票要修的那條線。
+	cfg.guard = newRoundGuard()
+
 	// 2026-08-07：提早載入上一輪 status（原本只在函式尾端載入做 CarryForwardActivity）。
 	// 額度冷卻與「今天已萃幾份」是**跨輪持續的狀態**（quotaState 見 quota.go），
 	// 要在處理帳號之前就知道上一輪冷卻到什麼時候、今天已經算到幾份。
@@ -714,6 +742,10 @@ func RunDirectOnce(cfg *DirectConfig, dryRun bool) ([]DirectResult, int, *Trigge
 	folderTrees := map[string]FolderTree{}
 	var knownRoots []string

+	// `inkstone/arcrun-rag#159`：每個看守資料夾這一輪的同步現況（key＝資料夾路徑）。
+	// 值是 (*Manifest).Progress() 的原件——與 totalProgress 同一個來源，只是沒有累加。
+	folderProgress := map[string]SyncProgress{}
+
 	// t210：跨帳號、跨資料夾累加的總量進度（見 rootProgress 註解）。
 	var totalProgress SyncProgress
 	var stuckReasons []string
@@ -740,8 +772,28 @@ func RunDirectOnce(cfg *DirectConfig, dryRun bool) ([]DirectResult, int, *Trigge

 		// t103：per-account 雲端版本偵測
 		cloudVer, cloudOK := fetchCloudVersion(accCfg.CypherURL)
+		// 🔴 `inkstone/arcrun-rag#159`：**一次探測失敗 ≠ 這台知識庫連不上。**
+		//
+		// leo 2026-08-28 的畫面上，`youlin.hsieh.dev` 那行紅字寫「目前連不上這個
+		// 知識庫，查不到版本」——而同一台機器上 curl 打同一支 /health 是 HTTP 200
+		// 亞秒回應。實查當下 status.json：**三個帳號全部** `cloud_check_ok=false`、
+		// 錯誤都是 `dial tcp: ... no such host`，而剛開的 Go 行程（cgo 與純 Go
+		// 兩種 resolver 都試過）解得出來、GET 也 200。
+		// ⇒ 那是這台機器當下的 DNS 抽風，不是知識庫掛了。
+		//
+		// 舊寫法把「這一輪沒查到」直接呈現成「查不到版本」，於是**一次抽風就抹掉
+		// 我們早就知道的事實**。改成：查不到就沿用上一輪查到的版本
+		//（同 CarryForwardActivity 的理由），只有**從來沒查到過**才是真的不知道。
+		// CloudCheckOK 仍照實記這一輪的可達性——那是另一件事，不混在一起。
+		if strings.TrimSpace(cloudVer) == "" {
+			if prevAcc, ok := prevStatus.AccountDetails[accHost]; ok {
+				cloudVer = prevAcc.CloudVersion
+			}
+		}
 		// t215：這個帳號要不要更新——與 portal 版本卡同一套判準（見檔頭）。
-		cloudUpd := EvalCloudUpdate(cloudVer, cloudOK, latestRelease, latestOK)
+		// 第二個參數傳「我們知不知道它的版本」而不是「這一輪連不連得上」：
+		// 版本是**事實**，可達性是**當下狀態**，兩者不是同一個問題。
+		cloudUpd := EvalCloudUpdate(cloudVer, strings.TrimSpace(cloudVer) != "", latestRelease, latestOK)
 		accSt := AccountSyncStatus{
 			LastSync:         time.Now().Format(time.RFC3339),
 			CloudVersion:     cloudVer,
@@ -757,7 +809,7 @@ func RunDirectOnce(cfg *DirectConfig, dryRun bool) ([]DirectResult, int, *Trigge
 		// 更新進度不同步），一個帳號通了不代表另一個也通。
 		// 只在走 workers-ai 這條路時掃；選了 Gemini 的人不需要知道這件事。
 		if accCfg.Extractor == "workers-ai" {
-			state := ProbeWorkersAI(accCfg.CypherURL, accCfg.APIKey)
+			state := accCfg.probeWorkersAI()
 			accSt.CloudAIReady = state.Ready
 			accSt.CloudAINote = state.Note
 			if !state.Ready && state.Note != "" {
@@ -833,6 +885,10 @@ func RunDirectOnce(cfg *DirectConfig, dryRun bool) ([]DirectResult, int, *Trigge
 				skippedOtherNames = append(skippedOtherNames, p.SkippedOtherNames...)
 				// #104：這一根用了什麼策略、少收了什麼 —— 以前到這裡就被丟掉了
 				// （只有 CLI 的 stderr 講得出來，App 走的這條路一個字都不說）。
+				// #159：這一根的同步現況。與 folderPlans 同一個「掃成了才記」的閘——
+				// 掃壞的那輪 rootProgress 是零值，記下去畫面會把它讀成「0 份、已同步」
+				// ＝拿我們自己編的答案打勾。沒記的根由下面的沿用機制補上一輪的。
+				folderProgress[root] = rp.Progress
 				folderPlans[root] = FolderPlanStatus{
 					Mode:             string(p.Plan.Mode),
 					Reason:           p.Plan.Reason,
@@ -896,6 +952,8 @@ func RunDirectOnce(cfg *DirectConfig, dryRun bool) ([]DirectResult, int, *Trigge
 			AccountDetails: accountDetails,
 			Retiring:       retiring, // arcrun-rag#46：移除並收回中的資料夾進度
 			Resync:         resync,   // arcrun-rag#140：雲端上找不到、正在自動補送的資料夾
+			// #153：這一輪等太久的事。空＝沒有人在等，畫面上不佔位置。
+			Stalls: cfg.guard.Stalls(),
 		}
 		// G-6.2：把「讀不了的檔」寫進狀態檔，App 首頁才有東西可以講。
 		// 排序＝畫面每輪穩定（map 迭代順序隨機，不排的話清單會自己跳動）。
@@ -922,6 +980,21 @@ func RunDirectOnce(cfg *DirectConfig, dryRun bool) ([]DirectResult, int, *Trigge
 		if len(folderPlans) > 0 {
 			st.FolderPlans = folderPlans
 		}
+		// #159：逐資料夾的同步現況。這一輪沒掃成的根**沿用上一輪**
+		// （同 MergeFolderTreeStore ② 的理由：畫面不該因為一輪掃壞就說「沒有狀態」）；
+		// 已經不在看守清單上的根自然消失——folderProgress 的 key 只可能來自本輪的
+		// knownRoots，移除掉的資料夾不會被沿用回來。
+		for _, root := range knownRoots {
+			if _, ok := folderProgress[root]; ok {
+				continue
+			}
+			if prev, ok := prevStatus.FolderProgress[root]; ok {
+				folderProgress[root] = prev
+			}
+		}
+		if len(folderProgress) > 0 {
+			st.FolderProgress = folderProgress
+		}
 		st.SkippedDocCount = len(skippedSeen)
 		for _, sf := range skippedSeen {
 			st.SkippedDocs = append(st.SkippedDocs, sf)
@@ -969,8 +1042,7 @@ func RunDirectOnce(cfg *DirectConfig, dryRun bool) ([]DirectResult, int, *Trigge
 					//    使用者才看得到「為什麼」而不只是「幾份」。
 					// 2026-08-07：額度冷卻的 skip 訊息（quotaState.noticeNow().Combined()）
 					// 用「會自動恢復」當識別字——同樣要讓使用者看得到原因，不是只看到「幾份」。
-					if strings.Contains(r.Error, "後重試") || strings.Contains(r.Error, "已暫停自動重試") ||
-						strings.Contains(r.Error, "會自動恢復") {
+					if explainsWhySkipped(r.Error) {
 						st.Failures = append(st.Failures, ExtractFail{
 							Path:  r.Path,
 							Error: shortError(r.Error),
@@ -1109,11 +1181,17 @@ func drainPendingTakedowns(
 		}
 		return results, exit
 	}
+	// #153：同一條撤除路徑服務兩件事，而使用者眼中它們不是同一件——
+	// 「我刪了一個檔」跟「我把整個資料夾收回來」卡住時該說的話不一樣。
+	step := stepTakedown
+	if resultType == "folder_takedown" {
+		step = stepRetire
+	}
 	for oldPath, pageName := range m.PendingTakedowns {
 		pace()
 		res := DirectResult{Type: resultType, Path: oldPath}
 		mach := cfg.machineIdentity()
-		status, _, perr := cfg.postJSON(cfg.triggerURL(cfg.RemovedWF), map[string]any{
+		status, _, perr := cfg.postJSON(step, cfg.triggerURL(cfg.RemovedWF), map[string]any{
 			"page_name":     pageName,
 			"path":          oldPath,
 			"library":       cfg.libraryFor(absRoot),
@@ -1391,6 +1469,26 @@ func runDirectOnceRoot(cfg *DirectConfig, root string, dryRun bool, qs *quotaSta
 		saveManifest() // 拔掉的章與對帳時間當下就落盤（斷點續傳同款）
 	}

+	// 🔴 既有卡片的「### 出處」就地修正（`inkstone/Arcrun#167`）——一次性、修完蓋章。
+	// 舊卡的出處寫的是 `../<檔名>`（daemon 自己的目錄結構），AI 照著答、使用者走不到。
+	// 修產生端只治得了新卡，票上寫死「不能只修新的」⇒ 這裡把本機既有的卡重畫那一塊
+	// 並原樣重推（零 LLM，workflow 進門先刪同名舊 blocks ⇒ 取代不疊加）。見 sourcerepair.go。
+	if sr := repairCardSourceBlocks(cfg, absRoot, m, dryRun, false, runNow); sr != nil {
+		if sr.Repushed > 0 {
+			results = append(results, DirectResult{
+				Type: "resync", Path: absRoot, Status: "noticed",
+				Error: fmt.Sprintf("已修好 %d 份筆記的「原文位置」寫法（從前寫的是程式內部路徑，現在會告訴你在哪台機器、哪個知識庫、庫內哪一個檔）", sr.Repushed),
+			})
+		}
+		if sr.Err != "" {
+			results = append(results, DirectResult{
+				Type: "resync", Path: absRoot, Status: "noticed",
+				Error: "更新「原文位置」時有一份沒成功（不影響同步，稍後自動再試）：" + sr.Err,
+			})
+		}
+		saveManifest()
+	}
+
 	// 2026-08-07 task 3：Scan() 會把 removed 的路徑從 m.Entries 整批拿掉（rebuild 語意，
 	// 見 scan.go 步驟 7）——但那只是「偵測到不見了」，不代表下架 POST 已經成功。
 	// 沒有這份快照的話，本輪只要有任何一個 added/modified 事件先觸發了下面的
@@ -1427,6 +1525,29 @@ func runDirectOnceRoot(cfg *DirectConfig, root string, dryRun bool, qs *quotaSta

 	now := runNow.Unix()

+	// 🔴 `inkstone/arcrun-rag#153` 第二輪：**樹算出來就立刻落地本機，排在所有雲端呼叫之前。**
+	//
+	// 為什麼非搬到這裡不可（2026-08-28 用 `ARCRUN_TRACE=1` 量出來的，不是推測）：
+	// 對一個**健康**的雲端實例，每一發呼叫實測 24〜33 秒
+	//（資料夾總覽 26.3s／目錄索引 24.0・24.1・23.5s／送出一份筆記 33.2・44.6s）。
+	// 一個 12 層、10 個檔的資料夾，一輪就是十幾分鐘；leo 真正的設定是三個帳號、
+	// 好幾千個檔，一輪是好幾小時。**沒有任何一發超過 300 秒，所以逾時與斷路器都不會動**
+	// ——這不是卡住，是這一輪還沒輪到寫它。
+	//
+	// 而這棵樹是**純本機、秒級**算出來的（就在上面那次 Scan 的產物上），
+	// 它沒有理由排在十幾分鐘的雲端佇列後面。搬到這裡之後，使用者的資料夾結構
+	// 在開跑幾秒內就是對的，即使這一輪還要再跑一小時。
+	//
+	// 內容一個位元都沒變：BuildFolderTree 吃的是 payload.DirStats／m.Entries／
+	// payload.AllExcludedDirs／plan，而從 Scan() 到這裡之間**沒有任何東西動過 m.Entries**
+	//（動它的是下面「removed 暫時放回」那段，本來就在原位置之後）。
+	// 送上雲端那一發（syncFolderTree）**維持在原來的位置**，用的就是這一棵。
+	tree := BuildFolderTree(absRoot, cfg.libraryFor(absRoot), payload.DirStats, m.Entries,
+		payload.AllExcludedDirs, plan, runNow)
+	if !dryRun {
+		PublishFolderTreeNow(cfg.Manifest, root, tree, runNow)
+	}
+
 	// 結構先行（InkStoneCo#43，2026-08-15）：掃描一結束（純本機、免費、秒級）就先把
 	// 「這個資料夾有哪些檔案／最近改了什麼」送上知識庫，**不等 LLM 萃取、不受額度影響**
 	// ——走 rag_ingest_card（零 LLM 的機械收口），所以刻意放在：
@@ -1462,8 +1583,6 @@ func runDirectOnceRoot(cfg *DirectConfig, root string, dryRun bool, qs *quotaSta
 	// 再加第四個**只屬於它**的：**空資料夾一個事件都不會有**（arcrun-rag#106 的情境本身），
 	// 所以它不能被任何「有事件才做」的閘擋住——分子分母都由現況算出，靜止時
 	// 內容雜湊自然擋住重送，不需要事件當第二道閘。
-	tree := BuildFolderTree(absRoot, cfg.libraryFor(absRoot), payload.DirStats, m.Entries,
-		payload.AllExcludedDirs, plan, runNow)
 	if treeRes := syncFolderTree(cfg, absRoot, m, tree, dryRun, runNow); treeRes != nil {
 		results = append(results, *treeRes)
 		if treeRes.Status != "planned" {
@@ -1547,6 +1666,18 @@ func runDirectOnceRoot(cfg *DirectConfig, root string, dryRun bool, qs *quotaSta
 				results = append(results, res)
 				continue
 			}
+			// 🔴 #153：這個**帳號**這一輪已經被判定沒有回應 ⇒ 連試都不試。
+			// 與上面的額度冷卻同一層、同一個理由：這不是這個檔的問題，
+			// 記進它的病歷（FailCount／退避階梯）會讓一次雲端沒回應，
+			// 變成一整批檔案「已放棄自動重試」——那是把別人的停機算在使用者頭上。
+			// 沒有這道閘的話，一個沒有回應的帳號會讓這一輪繼續逐檔去撞，
+			// 每撞一次就是一個 Budget，25 個檔就是幾十分鐘。
+			if note := cfg.unreachableNote(); note != "" {
+				res.Status = "skipped"
+				res.Error = note
+				results = append(results, res)
+				continue
+			}
 			// 🔴 t195 止血點：這個檔剛失敗過且還在退避窗口內 → 這輪跳過。
 			//   沒有這道閘時的實測災情：`小果被AFTEE詐貸.pdf` 因雲端 401 失敗，
 			//   每輪重掃又被當成新檔 ⇒ **1387 輪、跨 11 小時**，且它排在佇列前面，
@@ -1578,6 +1709,15 @@ func runDirectOnceRoot(cfg *DirectConfig, root string, dryRun bool, qs *quotaSta
 			pace() // 2026-08-07：每次要觸發雲端（萃取／POST）之前先節流一下
 			if cfg.Extractor != "" {
 				// 四步定稿：本地萃卡 → 每張卡 POST rag_ingest_card（原文不出機）
+				// 🔴 `inkstone/Arcrun#167`：卡片的「### 出處」要寫得出「哪台機器 ／
+				//    哪個庫 ／ 庫內什麼路徑」，所以萃卡前先把這三件備好交給塑形層。
+				//    三件與下面 cardBody 送雲端的 machine/library/path 是**同一組值**
+				//    ——卡上寫的與雲端存的從此對得起來（不再各說各話）。
+				cardOrigin := SourceOrigin{
+					MachineLabel: cfg.machineIdentity().Label,
+					Library:      cfg.libraryFor(absRoot),
+					LibraryPath:  ev.Path,
+				}
 				var cards []string
 				var xerr error
 				switch cfg.Extractor {
@@ -1590,9 +1730,24 @@ func runDirectOnceRoot(cfg *DirectConfig, root string, dryRun bool, qs *quotaSta
 					// ⇒ 探測在 RunDirectOnce（ProbeWorkersAI），結果寫進 status.json，
 					//   托盤那行「狀態：」直接告訴用戶該做什麼。
 					// 靜默退回會讓用戶**永遠不知道自己的雲端還沒更新**——正是要避免的黑箱。
-					cards, xerr = ExtractWithWorkersAI(cfg.CypherURL, cfg.APIKey, absRoot, ev.Path)
+					// #153：萃取也是一發會等很久的網路呼叫，而 workers-ai 打的正是
+					// **使用者自己的那台雲端實例**——跟上面那些收口是同一台。
+					// 它有自己的 client timeout，但沒有人在數「這個帳號已經連續幾發
+					// 等不到回覆」⇒ 漏掉這一格的話，單輪上限 25 個檔會變成 25 次
+					// 各自的等待，同一輪照樣走不完。
+					//
+					// 🔴 gemma 那條**刻意不掛**：它打的是 Google，不是使用者的知識庫。
+					// 掛上去的話，Google 慢會被算成「你的知識庫沒有回應」——
+					// 誤導的訊息比沒有訊息更貴（會害人往錯的方向查）。
+					xgate := cfg.openGate(stepExtractDoc)
+					cards, xerr = ExtractWithWorkersAI(cfg.CypherURL, cfg.APIKey, absRoot, ev.Path, cardOrigin)
+					xgate.release()
+					if xerr == nil {
+						xgate.ok()
+					}
+					xerr = xgate.record(xerr) // 只有「等到超時」會被記帳，其餘錯誤原樣往下走
 				case "gemma":
-					cards, xerr = ExtractWithGemma(cfg.GeminiAPIKey, cfg.LLMModel, absRoot, ev.Path)
+					cards, xerr = ExtractWithGemma(cfg.GeminiAPIKey, cfg.LLMModel, absRoot, ev.Path, cardOrigin)
 				default:
 					// t176：claude 路先不支援（RunDirectOnce 開頭已正規化）。
 					// 走到這裡代表 config 有沒見過的值——誠實報錯，不要靜默跳過（禁假綠）。
@@ -1671,7 +1826,7 @@ func runDirectOnceRoot(cfg *DirectConfig, root string, dryRun bool, qs *quotaSta
 						cardBody["quality"] = "low"
 						cardBody["quality_warnings"] = warns
 					}
-					status, _, perr := cfg.postJSON(cfg.triggerURL(cfg.CardIngestWF), cardBody)
+					status, _, perr := cfg.postJSON(stepIngestCard, cfg.triggerURL(cfg.CardIngestWF), cardBody)
 					res.HTTPStatus = status
 					if perr != nil {
 						res.Status, res.Error = "failed", perr.Error()
@@ -1714,7 +1869,7 @@ func runDirectOnceRoot(cfg *DirectConfig, root string, dryRun bool, qs *quotaSta
 			// ⚠️ 雲端這支 workflow 本輪**沒有跟著改**（youlin stage 上根本沒部署它，
 			// 現役是 rag_ingest_card）——它會忽略這兩個欄位，行為與從前一字不差。
 			machDirect := cfg.machineIdentity()
-			status, _, perr := cfg.postJSON(cfg.triggerURL(cfg.IngestWF), map[string]any{
+			status, _, perr := cfg.postJSON(stepIngestDoc, cfg.triggerURL(cfg.IngestWF), map[string]any{
 				"page_name":     pageNameOf(ev.Path),
 				"path":          ev.Path,
 				"content":       string(content),
@@ -1751,7 +1906,7 @@ func runDirectOnceRoot(cfg *DirectConfig, root string, dryRun bool, qs *quotaSta
 			// 連坐殺掉 B 機器同名檔」，而多補一維會改變既有的撤除命中範圍——
 			// 那是另一件事，要另外驗（本輪不驗的不做）。
 			machRm := cfg.machineIdentity()
-			status, _, perr := cfg.postJSON(cfg.triggerURL(cfg.RemovedWF), map[string]any{
+			status, _, perr := cfg.postJSON(stepTakedown, cfg.triggerURL(cfg.RemovedWF), map[string]any{
 				"page_name":     pageNameOf(ev.Path),
 				"path":          ev.Path,
 				"machine":       machRm.ID,
@@ -1890,20 +2045,22 @@ func runDirect(args []string) int {
 		//    ⇒ 開工前先印一筆 `phase:"start"`，托盤收到就顯示「同步中…」，
 		//      收到 `phase:"done"` 再切回「看守中」。
 		//    形狀相容：兩筆都有 `at`，舊版托盤只會多算一次 round，不會壞掉。
-		startOut, _ := json.MarshalIndent(struct {
+		//
+		// 🔴 #153：這兩筆改走 printJSONLine——「還在等」的播報跑在另一條 goroutine 上，
+		// 而 done 那筆可能有幾十 KB。共用同一把鎖，兩邊才不會把彼此的 JSON 切成兩半
+		//（切壞一次，supervisor 的 decoder 就再也讀不到這個行程的任何一筆，見 stallguard.go）。
+		printJSONLine(struct {
 			At    string `json:"at"`
 			Phase string `json:"phase"`
-		}{time.Now().Format(time.RFC3339), "start"}, "", "  ")
-		fmt.Println(string(startOut))
+		}{time.Now().Format(time.RFC3339), "start"})

 		results, exit, _ := RunDirectOnce(cfg, *dryRun)
-		out, _ := json.MarshalIndent(struct {
+		printJSONLine(struct {
 			At      string         `json:"at"`
 			Phase   string         `json:"phase"`
 			Folders []string       `json:"folders"`
 			Results []DirectResult `json:"results"`
-		}{time.Now().Format(time.RFC3339), "done", cfg.Folders(), results}, "", "  ")
-		fmt.Println(string(out))
+		}{time.Now().Format(time.RFC3339), "done", cfg.Folders(), results})
 		return exit
 	}

@@ -123,7 +123,22 @@ func snapshotCards(absRoot string) map[string]fileState {
 	for _, relDir := range []string{cardsRelDir, vaultCardsRelDir} {
 		base := filepath.Join(absRoot, filepath.FromSlash(relDir))
 		_ = filepath.Walk(base, func(p string, info os.FileInfo, err error) error {
-			if err != nil || info.IsDir() || filepath.Ext(p) != ".md" {
+			if err != nil {
+				return nil
+			}
+			// 🔴 inkstone/Arcrun#134（2026-08-28）：`.wiki/` 整棵跳過。
+			// 那是規範定的卡片正式落點，不是「位置不對的卡」——而 enforceCardMarks
+			// 會把這裡掃到的**新**檔搬去 cardRelFor（搬出隱藏目錄、加 arcrun- 前綴），
+			// 也就是把產物送回 Scan 看得見的地方，下一輪被當新原稿再萃一次。
+			// 829da02 的 `before[rel]` 只擋得住「本來就在的檔」，擋不住這一輪剛寫的卡。
+			// 與 tidy.go collectCardItems 同一個洞，兩支都補才堵得住。
+			if info.IsDir() {
+				if p != base && strings.HasPrefix(info.Name(), ".") {
+					return filepath.SkipDir
+				}
+				return nil
+			}
+			if filepath.Ext(p) != ".md" {
 				return nil
 			}
 			rel, rerr := filepath.Rel(absRoot, p)
@@ -88,7 +88,7 @@ func cleanGemmaCard(text, pageName string) string {

 // ExtractWithGemma 讀原稿 → 呼 Gemini 萃卡 → 卡片落地 system-dev/wiki/cards/。
 // 回傳產出的卡片相對路徑（單檔一卡）。
-func ExtractWithGemma(apiKey, model, absRoot, relPath string) ([]string, error) {
+func ExtractWithGemma(apiKey, model, absRoot, relPath string, origin SourceOrigin) ([]string, error) {
 	if apiKey == "" {
 		return nil, fmt.Errorf("gemma 萃取路需要 gemini_api_key（config）")
 	}
@@ -171,7 +171,7 @@ func ExtractWithGemma(apiKey, model, absRoot, relPath string) ([]string, error)
 	if perr != nil {
 		return nil, perr
 	}
-	cards, berr := BuildWikiDoc(absRoot, relPath, srcText, ex, time.Now())
+	cards, berr := BuildWikiDoc(absRoot, relPath, srcText, ex, origin, time.Now())
 	if berr != nil {
 		return nil, berr
 	}
@@ -44,7 +44,7 @@ func TestExtractWithGemmaThinkingModel(t *testing.T) {
 			}},
 		})
 	})()
-	cards, err := ExtractWithGemma("k123", "gemma-test", root, "會議記錄.md")
+	cards, err := ExtractWithGemma("k123", "gemma-test", root, "會議記錄.md", testOrigin())
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -79,14 +79,14 @@ func TestExtractWithGemmaThoughtOnly(t *testing.T) {
 			}},
 		})
 	})()
-	if _, err := ExtractWithGemma("k", "m", root, "x.md"); err == nil {
+	if _, err := ExtractWithGemma("k", "m", root, "x.md", testOrigin()); err == nil {
 		t.Fatal("thought-only 應報錯")
 	}
 }

 // 缺 key＝引導訊息。
 func TestExtractWithGemmaNoKey(t *testing.T) {
-	if _, err := ExtractWithGemma("", "m", t.TempDir(), "x.md"); err == nil {
+	if _, err := ExtractWithGemma("", "m", t.TempDir(), "x.md", testOrigin()); err == nil {
 		t.Fatal("缺 key 應報錯")
 	}
 }
@@ -124,7 +124,7 @@ func TestExtractWithGemma_VaultDoesNotGainPages(t *testing.T) {

 	pagesBefore := countMD(t, filepath.Join(root, "pages")) + countMD(t, filepath.Join(root, "journals")) + countTopLevelMD(t, root)

-	cards, err := ExtractWithGemma("k123", "gemma-test", root, srcRel)
+	cards, err := ExtractWithGemma("k123", "gemma-test", root, srcRel, testOrigin())
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -181,7 +181,7 @@ func TestExtractWithGemma_VaultExistingCardNotClobbered(t *testing.T) {
 		})
 	})()

-	_, err := ExtractWithGemma("k123", "gemma-test", root, srcRel)
+	_, err := ExtractWithGemma("k123", "gemma-test", root, srcRel, testOrigin())
 	if err == nil {
 		t.Fatal("目標位置被別人佔用時應報錯，不得無聲覆蓋")
 	}
@@ -63,7 +63,8 @@ var workersAIHTTP = &http.Client{Timeout: 90 * time.Second}
 //	{"error":{"message":"This model's maximum context length is 131000 tokens…
 //
 // ⇒ 兩個錯：①明知一定會失敗還是送出去（每次燒一份額度、拖住整個佇列）
-//           ②失敗的理由沒有翻成人話（#104 的紅線：不要讓他猜）。
+//
+//	②失敗的理由沒有翻成人話（#104 的紅線：不要讓他猜）。
 //
 // 300,000 這個數字怎麼來的：實測那份 401,526 位元組的檔，上游回報
 // 「prompt contains at least 122,xxx tokens」，而可用輸入是
@@ -94,7 +95,7 @@ func tooBigForWorkersAI(srcText, relPath string) string {
 // ExtractWithWorkersAI 讀原稿 → 送自己雲端的 /portal/daemon/extract 萃卡 → 卡片落地。
 // cypherURL/apiKey 用的是 daemon 既有的連線憑證（送卡片上雲時同一把，見 direct.go）。
 // 回傳產出的卡片相對路徑（單檔一卡），與 ExtractWithGemma 契約一致。
-func ExtractWithWorkersAI(cypherURL, apiKey, absRoot, relPath string) ([]string, error) {
+func ExtractWithWorkersAI(cypherURL, apiKey, absRoot, relPath string, origin SourceOrigin) ([]string, error) {
 	if strings.TrimSpace(cypherURL) == "" {
 		return nil, fmt.Errorf("workers-ai 萃取路需要 cypher_url（config）")
 	}
@@ -183,7 +184,7 @@ func ExtractWithWorkersAI(cypherURL, apiKey, absRoot, relPath string) ([]string,
 		if perr != nil {
 			return nil, perr
 		}
-		cards, berr := BuildWikiDoc(absRoot, relPath, srcText, ex, time.Now())
+		cards, berr := BuildWikiDoc(absRoot, relPath, srcText, ex, origin, time.Now())
 		if berr != nil {
 			return nil, berr
 		}
@@ -201,6 +202,17 @@ func ExtractWithWorkersAI(cypherURL, apiKey, absRoot, relPath string) ([]string,
 	// vault 落隱藏目錄，且**檔名一律帶 arcrun- 前綴**（第二輪：光換目錄擋不住撞名，
 	// 因為 Logseq 的頁名是 basename）。落地前先查目標存不存在、不無條件覆蓋（safeWriteCard）。
 	cardRel := cardRelFor(absRoot, pageName)
+	// 🔴 inkstone/Arcrun#180（2026-08-28）：**不准把萃取結果寫回原稿自己身上。**
+	// 舊制的落點是 `system-dev/wiki/cards/arcrun-<頁名>.md`，而 `MarkName` 是冪等的
+	// ⇒ 原稿本來就住在那裡、名字本來就帶前綴時（leo 的 9 張現成卡正是這一種），
+	// 算出來的目的地**就是原稿自己**。真寫下去＝原稿被自己的摘要蓋掉（safeWriteCard
+	// 會留一份 `.bak-*`，但下一輪內容又變了 ⇒ 每輪重萃、每輪燒一次額度）。
+	// 這條路只在**舊雲端**（回 `card` 而不是 `output`）才走得到，所以平常撞不到；
+	// #180 讓 `system-dev/` 收得到之後就撞得到了。誠實報錯，不要靜默略過。
+	if cardRel == filepath.ToSlash(relPath) {
+		return nil, fmt.Errorf("這份檔案本身就在卡片產物區、而且已經帶著我們的標記（%s）"+
+			"——整理它會蓋掉它自己。請把它移到別的資料夾，或更新你的知識庫到新版", relPath)
+	}
 	dest := filepath.Join(absRoot, filepath.FromSlash(cardRel))
 	if err := safeWriteCard(absRoot, dest, []byte(card)); err != nil {
 		return nil, err
@@ -45,7 +45,7 @@ func TestExtractWithWorkersAI_VaultRedirectsAndDoesNotClobber(t *testing.T) {
 	})
 	defer closeFn()

-	cards, err := ExtractWithWorkersAI(url, "key123", root, srcRel)
+	cards, err := ExtractWithWorkersAI(url, "key123", root, srcRel, testOrigin())
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -94,7 +94,7 @@ func TestExtractWithWorkersAI_NonVaultUnchanged(t *testing.T) {
 	})
 	defer closeFn()

-	cards, err := ExtractWithWorkersAI(url, "key123", root, srcRel)
+	cards, err := ExtractWithWorkersAI(url, "key123", root, srcRel, testOrigin())
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -131,7 +131,7 @@ func TestExtractWithWorkersAI_SendsSharedPrompt(t *testing.T) {
 	})
 	defer closeFn()

-	if _, err := ExtractWithWorkersAI(url, "key123", root, srcName); err != nil {
+	if _, err := ExtractWithWorkersAI(url, "key123", root, srcName, testOrigin()); err != nil {
 		t.Fatal(err)
 	}
 	srcText, err := ConvertToText(srcName, []byte(srcBody))
@@ -181,7 +181,7 @@ func TestExtractWorkersAIAndGemmaProduceIdenticalWiki(t *testing.T) {
 		t.Fatal(err)
 	}
 	undo := gemmaCardStub(t, fixture)
-	cardsG, errG := ExtractWithGemma("k-test", "", rootG, srcName)
+	cardsG, errG := ExtractWithGemma("k-test", "", rootG, srcName, testOrigin())
 	undo()
 	if errG != nil {
 		t.Fatal(errG)
@@ -195,7 +195,7 @@ func TestExtractWorkersAIAndGemmaProduceIdenticalWiki(t *testing.T) {
 	url, closeFn := workersAIStub(t, func(w http.ResponseWriter, r *http.Request) {
 		_ = json.NewEncoder(w).Encode(map[string]any{"success": true, "output": fixture})
 	})
-	cardsW, errW := ExtractWithWorkersAI(url, "key123", rootW, srcName)
+	cardsW, errW := ExtractWithWorkersAI(url, "key123", rootW, srcName, testOrigin())
 	closeFn()
 	if errW != nil {
 		t.Fatal(errW)
@@ -0,0 +1,138 @@
+package collector
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"path/filepath"
+	"testing"
+	"time"
+)
+
+// TestFolderProgressLandsInStatus 守住 `inkstone/arcrun-rag#159` 的接線：
+// **逐資料夾的同步現況真的會寫進 status.json**，而且是每個根各一份。
+//
+// 為什麼要有這一條：小幫手畫面上那個打勾完全靠這個欄位。它沒寫出來的話，
+// 前端拿不到資料 ⇒ 每一列都會落到 unknown ⇒ 使用者又回到「看不出同步了沒」。
+func TestFolderProgressLandsInStatus(t *testing.T) {
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusOK)
+		_, _ = w.Write([]byte(`{"ok":true}`))
+	}))
+	defer srv.Close()
+
+	base := t.TempDir()
+	rootA := filepath.Join(base, "A")
+	rootB := filepath.Join(base, "B")
+	for _, d := range []string{rootA, rootB} {
+		if err := os.MkdirAll(d, 0o755); err != nil {
+			t.Fatal(err)
+		}
+	}
+	_ = os.WriteFile(filepath.Join(rootA, "a1.md"), []byte("# A1"), 0o644)
+	_ = os.WriteFile(filepath.Join(rootA, "a2.md"), []byte("# A2"), 0o644)
+	_ = os.WriteFile(filepath.Join(rootB, "b1.md"), []byte("# B1"), 0o644)
+
+	cfg := &DirectConfig{
+		Manifest:   filepath.Join(base, "manifest.json"),
+		Accounts:   []AccountConfig{{CypherURL: srv.URL, Namespace: "ns", WatchFolders: []string{rootA, rootB}}},
+		MaxRemoved: DefaultMaxRemovedRatio,
+	}
+	RunDirectOnce(cfg, false)
+
+	st, err := LoadSyncStatus(StatusFilePath(cfg.Manifest))
+	if err != nil {
+		t.Fatalf("讀不到 status.json：%v", err)
+	}
+	if len(st.FolderProgress) != 2 {
+		t.Fatalf("folder_progress 應該每個看守資料夾各一份（2），got %d：%+v",
+			len(st.FolderProgress), st.FolderProgress)
+	}
+	if got := st.FolderProgress[rootA].Total; got != 2 {
+		t.Errorf("A 的分母應為 2，got %d", got)
+	}
+	if got := st.FolderProgress[rootB].Total; got != 1 {
+		t.Errorf("B 的分母應為 1，got %d", got)
+	}
+	// 🔴 逐資料夾加起來要等於首頁那行總量——它們本來就是同一組數字被切開，
+	//    對不起來就代表有人另算了一套（那正是這張票要拔掉的病）。
+	var sum SyncProgress
+	for _, p := range st.FolderProgress {
+		sum = sum.Add(p)
+	}
+	if sum.Total != st.Progress.Total-st.Progress.Unreadable {
+		t.Errorf("逐資料夾合計 %d ≠ 首頁總量 %d（扣掉沒進 manifest 的 %d）",
+			sum.Total, st.Progress.Total, st.Progress.Unreadable)
+	}
+}
+
+// TestCloudVersionSurvivesOneFailedProbe 守住票的追加條件 6：
+// **「連不上」的判準不能是「這一輪解析失敗」。**
+//
+// leo 2026-08-28 畫面上寫「目前連不上這個知識庫，查不到版本」，
+// 而同一台機器 curl 打同一支 /health 是 HTTP 200——那是機器當下 DNS 抽風。
+// 一次探測失敗不准抹掉我們已經知道的版本。
+func TestCloudVersionSurvivesOneFailedProbe(t *testing.T) {
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusOK)
+		_, _ = w.Write([]byte(`{"ok":true}`))
+	}))
+	defer srv.Close()
+
+	base := t.TempDir()
+	root := filepath.Join(base, "R")
+	if err := os.MkdirAll(root, 0o755); err != nil {
+		t.Fatal(err)
+	}
+	_ = os.WriteFile(filepath.Join(root, "r.md"), []byte("# R"), 0o644)
+
+	cfg := &DirectConfig{
+		Manifest:   filepath.Join(base, "manifest.json"),
+		Accounts:   []AccountConfig{{CypherURL: srv.URL, Namespace: "ns", WatchFolders: []string{root}}},
+		MaxRemoved: DefaultMaxRemovedRatio,
+	}
+
+	orig := fetchCloudVersion
+	defer func() { fetchCloudVersion = orig }()
+	// 「最新版是多少」也要釘住，否則這條測試會依賴 install.arcrun.dev 通不通
+	// ——那樣測的就不是我們要測的東西了（而且 CI 離線就紅）。
+	origLatest := fetchLatestCloudReleaseRaw
+	fetchLatestCloudReleaseRaw = func() (string, bool) { return "1.4.58", true }
+	latestMu.Lock()
+	latestFetched = time.Time{} // 清掉節流快取，讓 stub 這一輪真的生效
+	latestMu.Unlock()
+	defer func() {
+		fetchLatestCloudReleaseRaw = origLatest
+		latestMu.Lock()
+		latestFetched = time.Time{}
+		latestMu.Unlock()
+	}()
+
+	// 第一輪：查得到版本。
+	fetchCloudVersion = func(string) (string, bool) { return "1.4.60", true }
+	RunDirectOnce(cfg, false)
+
+	// 第二輪：探測失敗（模擬 DNS 抽風）。
+	fetchCloudVersion = func(string) (string, bool) { return "", false }
+	RunDirectOnce(cfg, false)
+
+	st, err := LoadSyncStatus(StatusFilePath(cfg.Manifest))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(st.AccountDetails) != 1 {
+		t.Fatalf("應該只有一個帳號，got %d", len(st.AccountDetails))
+	}
+	for host, acc := range st.AccountDetails {
+		if acc.CloudVersion != "1.4.60" {
+			t.Errorf("%s：一次探測失敗就把版本抹掉了（got %q，應沿用 1.4.60）", host, acc.CloudVersion)
+		}
+		if !acc.CloudUpdateKnown {
+			t.Errorf("%s：版本明明還知道，卻標成「查不到」", host)
+		}
+		// 可達性是另一件事，要照實記——不准為了讓畫面好看就說連得上。
+		if acc.CloudCheckOK {
+			t.Errorf("%s：這一輪明明沒連上，cloud_check_ok 卻是 true", host)
+		}
+	}
+}
@@ -318,7 +318,7 @@ func syncFolderCards(cfg *DirectConfig, absRoot string, m *Manifest, hasEvents,
 			continue
 		}
 		pace()
-		status, _, err := cfg.postJSON(cfg.triggerURL(wf), map[string]any{
+		status, _, err := cfg.postJSON(stepFolderCard, cfg.triggerURL(wf), map[string]any{
 			"page_name":     c.Page,
 			"path":          c.Path,
 			"card_content":  c.Content,
@@ -58,7 +58,22 @@ const (
 	//
 	// 🔴 **超過不准安靜地截掉**——`FolderTree.Truncated` 會被送上去、由畫面講出來
 	//（同 #104「排除規則要看得見」那條紅線：安靜地少講與講一個 0，對使用者是同一件事）。
-	MaxFolderTreeNodes = 300
+	//
+	// 🔴 2026-08-28（inkstone/Arcrun#180）從 300 提到 2000。leo 的規格是
+	// 「**雲端看到所有的 folder**」，而剪枝拿掉之後節點會變多——300 會讓「看得到全部」
+	// 在大資料夾上靜默失效（`Truncated` 雖然誠實，但那是在說「我做不到你要的事」）。
+	//
+	// **實測（本次改動後，同一台機器）**：
+	//
+	//	youlinhsieh-test1   12 個節點（地端 `find -type d` 非隱藏 12）
+	//	youlinhsieh-test2   13（地端 13）
+	//	pms                 53（地端 360——差額是 node_modules／dist／.gitignore 宣告的，
+	//	                    那幾種仍然剪枝，但節點與理由都在）
+	//	InkStoneCo          62（地端 14,923，同上）
+	//
+	// ⇒ 真實資料夾離 300 都還很遠；2000 是留給「一個沒有 .gitignore 的大筆記庫」的餘裕。
+	// 一棵樹在收端是一把 KV、整棵覆寫，2000 個節點約 400 KB，離 KV 的 25 MB 很遠。
+	MaxFolderTreeNodes = 2000

 	// folderTreeRetryDelay：整棵樹送失敗後，同一份內容多久才准再試。
 	// 理由同 inventory.go：積壓時每輪都有事件，沒有退避就是每 5 秒撞一次（t195 教訓）。
@@ -106,8 +121,18 @@ type FolderNode struct {
 	// ExcludedFiles＝收檔策略決定不收的（leo 講的「程式碼」多半落在這裡，見 ingestplan.go）。
 	ExcludedFiles int `json:"excluded_files"`

-	// Skipped＝這整棵子樹被剪掉了（沒有走進去），所以上面的數字**全部是 0 而且不是事實**。
-	// 🔴 畫面看到 Skipped 必須改講 SkipReason，不准顯示 `0/0`——那會是我們自己編的數字。
+	// Skipped＝**這一層的檔案這次一個都不收**。SkipReason 說得出為什麼。
+	//
+	// 🔴 2026-08-28（inkstone/Arcrun#180）語意收窄了一格，因為 leo 推翻了原本的做法：
+	// 以前 Skipped 同時代表「整棵沒走進去」⇒ 數字全是 0 而且不是事實 ⇒ **底下一個
+	// 子節點都不會生**。leo 的原話：「**所有的 system-dev 都可以展開，因為就算沒有
+	// 可萃的它也有下層**」「我要的就是雲端看到**所有的 folder** 像 tree 一樣呈現」。
+	// ⇒ 現在絕大多數 Skipped 節點是**走進去了、數字是真的、子節點也都在**，
+	//   只是這一層的檔不收（範本檔、非本次收檔範圍…）。
+	//
+	// 仍然有數字是 0 而且不是事實的那一種——真的沒走進去的（`node_modules` 這類，
+	// 見 IngestPlan.SkipsDirWhy 剩下的五條）。**分辨方法：那種節點沒有子節點。**
+	// 畫面看到 Skipped 一律改講 SkipReason，不要只顯示分子分母。
 	Skipped bool `json:"skipped,omitempty"`
 	// SkipReason＝一句話講給使用者聽的「為什麼整個沒收」（原文來自 IngestPlan.SkipsDirWhy）。
 	SkipReason string `json:"skip_reason,omitempty"`
@@ -162,6 +187,14 @@ func BuildFolderTree(absRoot, library string, dirs map[string]*dirStat, entries
 		n.TotalFiles = st.total
 		n.UnsupportedFiles = st.unsupported
 		n.ExcludedFiles = st.excluded
+		// #180：這一層走進去了、數字是真的，但**一個檔都沒收** ⇒ 照樣要講得出為什麼。
+		// 以前這種節點根本不存在（整棵被剪掉），現在存在了，就不能只給一個沒有解釋的
+		// `0 / 6`——那對使用者跟「安靜地少收」是同一件事。
+		// 🔴 子節點與真實數字都留著（leo 2026-08-28：「跳過的節點仍要展得開」）。
+		if st.total > 0 && st.excluded == st.total && st.excludeWhy != "" {
+			n.Skipped = true
+			n.SkipReason = st.excludeWhy
+		}
 	}

 	// 分子：manifest 現況。已送達且送上去之後沒再改過＝已同步，其餘＝還在路上。
@@ -322,7 +355,7 @@ func syncFolderTree(cfg *DirectConfig, absRoot string, m *Manifest, tree FolderT
 		"sync_token":   h,
 		"nodes":        tree.Nodes,
 	}
-	status, _, err := cfg.postJSON(cfg.folderTreeURL(), body)
+	status, _, err := cfg.postJSON(stepFolderTree, cfg.folderTreeURL(), body)
 	res.HTTPStatus = status
 	if err != nil {
 		res.Status = "failed"
@@ -445,3 +478,38 @@ func MergeFolderTreeStore(prev FolderTreeStore, fresh map[string]FolderTree, kno
 	}
 	return out
 }
+
+// PublishFolderTreeNow 把**這一個根**剛算好的樹立刻寫進本機快照，不等整輪跑完。
+//
+// 🔴 為什麼要有它（`inkstone/arcrun-rag#153` 第二輪，2026-08-28 實測）：
+// 一輪同步是**一條線**走完的，而對一個健康的雲端實例，每一發呼叫實測要 24〜33 秒
+// （`ARCRUN_TRACE=1` 量的：資料夾總覽 26.3s、目錄索引 24.0/24.1/23.5s、
+//  送出一份筆記 33.2/44.6s）。一個 12 層、10 個檔的資料夾，一輪就是**十幾分鐘**；
+// leo 真正的設定是三個帳號、好幾千個檔，一輪是**好幾小時**。
+//
+// 而 `folder-trees.json` 從前**只在整輪的最後**才落地
+// ⇒ 使用者看到的是「小幫手開著、沒有錯誤、什麼都不動，資料夾結構永遠停在上一版」。
+// **那不是卡住，是這一輪還沒輪到寫它。**
+//
+// 樹本身是**純本機、秒級**算出來的（BuildFolderTree 在掃描一結束就有答案），
+// 它沒有任何理由要排在十幾分鐘的雲端佇列後面等。
+//
+// 與收工時那次 SaveFolderTreeStore 的分工：
+//   - 這裡：只**更新這一個根**，不刪任何東西（還不知道整輪看守哪些根）。
+//   - 收工：跑完整的 MergeFolderTreeStore，該刪的（已不看守的根）在那時才刪。
+// 兩次都是冪等的覆蓋，先寫一次不會讓收工那次結果不同。
+//
+// 失敗一律吞掉：快照是給畫面看的，寫不進去不該擋住同步本體。
+func PublishFolderTreeNow(manifestPath, root string, tree FolderTree, now time.Time) {
+	if manifestPath == "" || root == "" || len(tree.Nodes) == 0 {
+		return // 沒算出東西就別覆蓋上一輪的好資料（同 MergeFolderTreeStore 規則②）
+	}
+	path := FolderTreeStorePath(manifestPath)
+	store, _ := LoadFolderTreeStore(path) // 讀不到＝沒有上一輪，零值可用
+	if store.Trees == nil {
+		store.Trees = map[string]FolderTree{}
+	}
+	store.Trees[root] = tree
+	store.UpdatedAt = now.UTC().Format(time.RFC3339)
+	_ = SaveFolderTreeStore(path, store)
+}
@@ -0,0 +1,116 @@
+package collector
+
+// foldertree_live_test.go — 對**真實的監看資料夾**跑一次樹，用 leo 給的機械判準對帳
+//（`inkstone/Arcrun#180`，leo 2026-08-28：
+// 「就在桌面，你為什麼沒看？最簡單的方式就像 terminal tree 一樣把被同步資料夾下的
+// 所有 folder 都遍歷後印出來」）。
+//
+// 🔴 為什麼 fixture 不夠（同 sourcerepair_live_test.go 的理由）：
+// `foldertree_traversal_test.go` 用的是我們自己擺出來的形狀——它證明得了邏輯，
+// 證明不了「**leo 桌面上那個資料夾**現在到底展不展得開」。
+// 這張票的現象是他螢幕上的數字，對帳就要拿他螢幕上那個資料夾來對。
+//
+// 只讀磁碟、不碰網路、不寫 manifest，所以沒有「打錯實例」的風險；
+// 仍然預設 skip，因為路徑是機器專屬的。
+//
+//	LIVE_TREE_ROOTS="/Users/x/Desktop/youlinhsieh-test1,/Users/x/Desktop/youlinhsieh-test2" \
+//	go test -run TestLiveFolderTreeMatchesDisk -v ./
+//
+// 判準（leo 原話）：**`find <root> -type d` 數出幾個目錄，雲端的樹就該有幾個節點**
+//（收不收是另一回事，`skip_reason` 照標）。
+// 例外只有一種且必須說得出口：**真的沒走進去**的那幾類（gitignore／工具產物／
+// 建置目錄／worktree／巢狀 repo）——它們仍然佔一個節點，但底下不生子節點，
+// 所以本測試把它們的子樹從地端這一側也扣掉，兩邊才是同一個問題的兩個答案。
+
+import (
+	"io/fs"
+	"os"
+	"path/filepath"
+	"sort"
+	"strings"
+	"testing"
+	"time"
+)
+
+// diskDirsExcludingPrunedSubtrees＝地端目錄清單，但「真的沒走進去」的那幾類只算它自己。
+func diskDirsExcludingPrunedSubtrees(t *testing.T, root string, plan IngestPlan) []string {
+	t.Helper()
+	var out []string
+	err := filepath.WalkDir(root, func(p string, d fs.DirEntry, err error) error {
+		if err != nil || !d.IsDir() {
+			return err //nolint:nilerr // 讀不到的目錄交給 WalkDir 自己回報
+		}
+		if p == root {
+			out = append(out, "")
+			return nil
+		}
+		if strings.HasPrefix(d.Name(), ".") {
+			return filepath.SkipDir
+		}
+		rel, _ := filepath.Rel(root, p)
+		rel = filepath.ToSlash(rel)
+		out = append(out, rel)
+		if skip, _ := plan.SkipsDirWhy(rel, p); skip {
+			return filepath.SkipDir // 節點留著（上一行已經 append），子樹不算
+		}
+		return nil
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	sort.Strings(out)
+	return out
+}
+
+func TestLiveFolderTreeMatchesDisk(t *testing.T) {
+	raw := strings.TrimSpace(os.Getenv("LIVE_TREE_ROOTS"))
+	if raw == "" {
+		t.Skip("設 LIVE_TREE_ROOTS=<資料夾,資料夾> 才跑（路徑是機器專屬的）")
+	}
+	for _, root := range strings.Split(raw, ",") {
+		root = strings.TrimSpace(root)
+		if root == "" {
+			continue
+		}
+		t.Run(filepath.Base(root), func(t *testing.T) {
+			plan := PlanIngest(root)
+			m := &Manifest{Entries: map[string]*ManifestEntry{}}
+			p, err := Scan(root, m, ScanOptions{Plan: plan})
+			if err != nil {
+				t.Fatal(err)
+			}
+			tree := BuildFolderTree(root, "live", p.DirStats, m.Entries, p.AllExcludedDirs, plan, time.Now())
+
+			onTree := map[string]FolderNode{}
+			for _, n := range tree.Nodes {
+				onTree[n.Path] = n
+			}
+			want := diskDirsExcludingPrunedSubtrees(t, root, plan)
+
+			t.Logf("收檔策略：%s — %s", plan.Mode, plan.Reason)
+			t.Logf("地端目錄 %d（扣掉沒走進去的子樹）／樹上節點 %d／truncated=%v",
+				len(want), tree.TotalNodes, tree.Truncated)
+			for _, n := range tree.Nodes {
+				t.Logf("  %-46s tot=%-4d sync=%-4d excl=%-4d skipped=%v %s",
+					"'"+n.Path+"'", n.TotalFiles, n.SyncedFiles, n.ExcludedFiles, n.Skipped, n.SkipReason)
+			}
+
+			var missing []string
+			for _, w := range want {
+				if _, ok := onTree[w]; !ok {
+					missing = append(missing, w)
+				}
+			}
+			if len(missing) > 0 {
+				t.Fatalf("地端有、樹上沒有的資料夾（「不收」又被實作成「不走進去」了）：%v", missing)
+			}
+			if tree.TotalNodes != len(want) {
+				t.Fatalf("樹上節點 %d ≠ 地端資料夾 %d", tree.TotalNodes, len(want))
+			}
+			if tree.Truncated {
+				t.Fatalf("被截斷了——MaxFolderTreeNodes=%d 不夠這個資料夾用，不准靜默截斷",
+					MaxFolderTreeNodes)
+			}
+		})
+	}
+}
@@ -0,0 +1,187 @@
+// foldertree_publish_test.go — 「畫面有沒有跟上」的網（`inkstone/arcrun-rag#153` 第二輪）。
+//
+// 🔴 這裡測的判準跟 stallguard_test.go **刻意不一樣**，因為第一輪測錯了東西：
+// 那一輪的網問的是「**有沒有發出警告**」，而總管 2026-08-28 端到端實測打回來的正是
+// 「閘在跑、警告會發，**但主流程仍然沒走下去**」。
+//
+//	stallguard_test.go        端點**不回應**時 → 這一輪要跳過它、要有話說
+//	foldertree_publish_test   端點**回應但很慢**時 → 畫面要的東西**不准排在後面等**
+//
+// 為什麼第二種才是使用者真正撞到的（`ARCRUN_TRACE=1` 實測，健康的 youlin 實例）：
+// 每一發雲端呼叫 24〜33 秒，**沒有一發接近 300 秒** ⇒ 逾時不會觸發、斷路器不會跳、
+// 播報也大多不會響（門檻 30 秒）。一輪就這樣安靜地跑十幾分鐘到幾小時，
+// 而 `folder-trees.json` 從前**只在整輪的最後**才落地。
+// 使用者看到的是「小幫手開著、沒有錯誤、資料夾結構永遠停在上一版」。
+package collector
+
+import (
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"path/filepath"
+	"sync/atomic"
+	"testing"
+	"time"
+)
+
+// slowButHealthyServer＝**會回應、只是慢**。這是本檔的主角，不是黑洞。
+func slowButHealthyServer(t *testing.T, delay time.Duration, hits *int64) *httptest.Server {
+	t.Helper()
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		atomic.AddInt64(hits, 1)
+		select {
+		case <-time.After(delay):
+		case <-r.Context().Done():
+			return
+		}
+		_ = json.NewEncoder(w).Encode(map[string]any{"success": true})
+	}))
+	t.Cleanup(srv.Close)
+	return srv
+}
+
+// 🔴 本票第二輪的核心：**雲端每一發都很慢（但都會回來）時，資料夾結構仍然要在
+// 這一輪還在跑的時候就已經寫好**。
+//
+// 這條會抓到的回歸：把樹的落地搬回「整輪最後」——那時它會等到所有雲端呼叫跑完，
+// 使用者的畫面就又回到「永遠停在上一版」。
+func TestFolderTreeLandsWhileTheRoundIsStillRunning(t *testing.T) {
+	origFetch := fetchCloudVersion
+	fetchCloudVersion = func(string) (string, bool) { return "", false }
+	defer func() { fetchCloudVersion = origFetch }()
+
+	// 每一發 400ms——遠低於任何逾時（所以斷路器不會跳，正是實測的形狀），
+	// 但夠多發就足以把一輪拖長。
+	var hits int64
+	slow := slowButHealthyServer(t, 400*time.Millisecond, &hits)
+
+	// 多層資料夾＋多個檔：讓「雲端呼叫的總時間」明顯大於「算一棵樹的時間」。
+	root := t.TempDir()
+	for _, d := range []string{"a", "b", "c", "d", "e", "a/a1", "b/b1"} {
+		if err := os.MkdirAll(filepath.Join(root, d), 0o755); err != nil {
+			t.Fatal(err)
+		}
+		if err := os.WriteFile(filepath.Join(root, d, "n.md"), []byte("# n\n內容"), 0o644); err != nil {
+			t.Fatal(err)
+		}
+	}
+	if err := os.WriteFile(filepath.Join(root, "top.md"), []byte("# top\n內容"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	manifestPath := filepath.Join(t.TempDir(), "m.json")
+	treePath := FolderTreeStorePath(manifestPath)
+	cfg := &DirectConfig{
+		Manifest: manifestPath,
+		Accounts: []AccountConfig{{CypherURL: slow.URL, Namespace: "n", APIKey: "k",
+			WatchFolders: []string{root}}},
+		Library: "kb", MaxRemoved: DefaultMaxRemovedRatio,
+		CardIngestWF: "rag_ingest_card", IngestWF: "rag_ingest_direct", RemovedWF: "rag_takedown_direct",
+		ForceSync: true,
+	}
+
+	roundDone := make(chan time.Duration, 1)
+	start := time.Now()
+	go func() {
+		RunDirectOnce(cfg, false)
+		roundDone <- time.Since(start)
+	}()
+
+	// 一邊等這一輪跑，一邊盯著快照什麼時候出現。
+	var treeAt time.Duration
+	var roundAt time.Duration
+	poll := time.NewTicker(20 * time.Millisecond)
+	defer poll.Stop()
+	deadline := time.After(60 * time.Second)
+watch:
+	for {
+		select {
+		case roundAt = <-roundDone:
+			break watch
+		case <-deadline:
+			t.Fatalf("🔴 60 秒內這一輪還沒跑完（雲端每一發只有 400ms，這不該發生）")
+		case <-poll.C:
+			if treeAt == 0 {
+				if _, err := os.Stat(treePath); err == nil {
+					treeAt = time.Since(start)
+				}
+			}
+		}
+	}
+
+	if treeAt == 0 {
+		t.Fatalf("🔴 整輪跑完（%v）之前，folder-trees.json 一次都沒出現過——"+
+			"畫面上的資料夾結構會一直停在上一版", roundAt)
+	}
+	t.Logf("樹落地於 %v／整輪跑完於 %v／雲端被打了 %d 次", treeAt, roundAt, atomic.LoadInt64(&hits))
+
+	// 🔴 判準：樹要在**這一輪還早**的時候就落地，不是跟著整輪一起結束。
+	// 用比例而不是絕對秒數——CI 機器快慢不同，但「排在雲端佇列前面」這個性質不變。
+	if treeAt > roundAt/2 {
+		t.Fatalf("🔴 樹落地於 %v，而整輪 %v——它還是排在雲端呼叫後面等。\n"+
+			"本票第二輪的病就是這個：不是卡住，是這一輪還沒輪到寫它。", treeAt, roundAt)
+	}
+
+	// 內容也要對：使用者看到的節點數要等於地端真的有幾個資料夾。
+	store, err := LoadFolderTreeStore(treePath)
+	if err != nil {
+		t.Fatalf("讀不回快照：%v", err)
+	}
+	tree, ok := store.Trees[root]
+	if !ok {
+		t.Fatalf("快照裡沒有這個根：%+v", store.Trees)
+	}
+	// 根 ＋ a b c d e a/a1 b/b1 ＝ 8
+	if tree.TotalNodes != 8 || len(tree.Nodes) != 8 {
+		t.Fatalf("🔴 節點數不對：TotalNodes=%d len(Nodes)=%d，want 8（根＋7 個子資料夾）",
+			tree.TotalNodes, len(tree.Nodes))
+	}
+}
+
+// 收工那一次的合併語意不准被「提早落地」破壞：
+// 已經不看守的根，仍然要在整輪結束時被清掉（不然使用者移除了資料夾還看得到它）。
+func TestEarlyPublishStillLetsTheFinalMergeDropUnwatchedRoots(t *testing.T) {
+	origFetch := fetchCloudVersion
+	fetchCloudVersion = func(string) (string, bool) { return "", false }
+	defer func() { fetchCloudVersion = origFetch }()
+
+	var hits int64
+	srv := slowButHealthyServer(t, time.Millisecond, &hits)
+
+	root := t.TempDir()
+	if err := os.WriteFile(filepath.Join(root, "n.md"), []byte("# n\n內容"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	manifestPath := filepath.Join(t.TempDir(), "m.json")
+	treePath := FolderTreeStorePath(manifestPath)
+
+	// 先塞一棵「已經不看守」的舊樹進快照。
+	if err := SaveFolderTreeStore(treePath, FolderTreeStore{
+		UpdatedAt: "2026-08-01T00:00:00Z",
+		Trees:     map[string]FolderTree{"/已經移除的資料夾": sampleTree("/已經移除的資料夾", 1, 1)},
+	}); err != nil {
+		t.Fatal(err)
+	}
+
+	cfg := &DirectConfig{
+		Manifest: manifestPath,
+		Accounts: []AccountConfig{{CypherURL: srv.URL, Namespace: "n", APIKey: "k",
+			WatchFolders: []string{root}}},
+		Library: "kb", MaxRemoved: DefaultMaxRemovedRatio,
+		CardIngestWF: "rag_ingest_card", IngestWF: "rag_ingest_direct", RemovedWF: "rag_takedown_direct",
+		ForceSync: true,
+	}
+	RunDirectOnce(cfg, false)
+
+	store, err := LoadFolderTreeStore(treePath)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, still := store.Trees["/已經移除的資料夾"]; still {
+		t.Fatalf("🔴 已經不看守的根還留在快照裡——使用者移除完還看得到它：%+v", store.Trees)
+	}
+	if _, ok := store.Trees[root]; !ok {
+		t.Fatalf("正在看守的那棵反而不見了：%+v", store.Trees)
+	}
+}
@@ -0,0 +1,169 @@
+// foldertree_traversal_test.go — 「雲端的樹要看得到所有的 folder」的迴歸網
+// （inkstone/Arcrun#180，leo 2026-08-28）。
+//
+// leo 給的判準是機械的，本檔就照它寫：
+//
+//	find <root> -type d ｜ wc -l   ==   樹的 total_nodes
+//	（實測差距：youlinhsieh-test1 地端 12 個目錄，雲端的樹只有 3 個節點）
+//
+// 🔴 這一組釘死的是「**展開 ≠ 收檔**」：收不收是另一個判斷，
+// 不准再用「不走進去」來實作「不收」——那會讓使用者連自己有哪些子資料夾都看不到。
+package collector
+
+import (
+	"io/fs"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+)
+
+// countLocalDirs＝`find <root> -type d -not -path '*/.*'` 的 Go 版（含根自己）。
+func countLocalDirs(t *testing.T, root string) int {
+	t.Helper()
+	n := 0
+	err := filepath.WalkDir(root, func(p string, d fs.DirEntry, err error) error {
+		if err != nil || !d.IsDir() {
+			return err
+		}
+		if p != root && strings.HasPrefix(d.Name(), ".") {
+			return filepath.SkipDir
+		}
+		n++
+		return nil
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	return n
+}
+
+func treeOf(t *testing.T, root string) FolderTree {
+	t.Helper()
+	m := &Manifest{Entries: map[string]*ManifestEntry{}}
+	plan := PlanIngest(root)
+	p, err := Scan(root, m, ScanOptions{Plan: plan})
+	if err != nil {
+		t.Fatal(err)
+	}
+	return BuildFolderTree(root, "lib", p.DirStats, m.Entries, p.AllExcludedDirs, plan, time.Now())
+}
+
+func write(t *testing.T, path, body string) {
+	t.Helper()
+	if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(path, []byte(body), 0o644); err != nil {
+		t.Fatal(err)
+	}
+}
+
+// 這棵樹照著 leo 貼的 `youlinhsieh-test1` 真實形狀擺：
+// 一個「一般資料夾」（mode=all），底下一整棵 system-dev——以前整棵被剪掉。
+func fixtureLikeTest1(t *testing.T) string {
+	t.Helper()
+	root := t.TempDir()
+	// 範本鋪下去的那幾個，內容一律從內嵌快照原樣取——判準是「內容逐字相同」
+	// （templateuntouched.go），自己捏一段假字串會被正確地判成「使用者寫的」。
+	snap := func(rel string) string {
+		data, err := templateFS.ReadFile(templateFSRoot + "/" + rel)
+		if err != nil {
+			t.Fatalf("快照裡沒有 %s：%v", rel, err)
+		}
+		return string(data)
+	}
+	write(t, filepath.Join(root, "火星座標_短片劇本_v1.md"), "# 火星座標\n")
+	write(t, filepath.Join(root, "scripts", "sdd-active-check.sh"), snap("scripts/sdd-active-check.sh"))
+	write(t, filepath.Join(root, "system-dev", "VERSION"), snap("system-dev/VERSION"))
+	write(t, filepath.Join(root, "system-dev", "wiki", "status.md"), snap("system-dev/wiki/status.md"))
+	// 快照裡沒有的真內容——leo 要的那 9 張卡就是這一種
+	write(t, filepath.Join(root, "system-dev", "wiki", "cards", "arcrun-火星座標_短片劇本_v1.md"), "# 卡\n")
+	write(t, filepath.Join(root, "system-dev", "docs", "3-specs", "TEMPLATE-sdd", "design.md"), snap("system-dev/docs/3-specs/TEMPLATE-sdd/design.md"))
+	write(t, filepath.Join(root, "system-dev", "workflows", "tasks-project-sync.yaml"), snap("system-dev/workflows/tasks-project-sync.yaml"))
+	return root
+}
+
+func TestFolderTree_地端有幾個資料夾樹上就要有幾個節點(t *testing.T) {
+	root := fixtureLikeTest1(t)
+	want := countLocalDirs(t, root) // 根＋scripts＋system-dev＋wiki＋cards＋docs＋3-specs＋TEMPLATE-sdd＋workflows ＝ 9
+	tree := treeOf(t, root)
+	if tree.TotalNodes != want {
+		var got []string
+		for _, n := range tree.Nodes {
+			got = append(got, n.Path)
+		}
+		t.Fatalf("樹的節點數 %d ≠ 地端資料夾數 %d\n樹上有：%v", tree.TotalNodes, want, got)
+	}
+	if tree.Truncated {
+		t.Fatalf("這麼小的一棵樹不該被截斷")
+	}
+}
+
+func TestFolderTree_不收的那一層仍然展得開而且說得出理由(t *testing.T) {
+	root := fixtureLikeTest1(t)
+	tree := treeOf(t, root)
+	byPath := map[string]FolderNode{}
+	for _, n := range tree.Nodes {
+		byPath[n.Path] = n
+	}
+
+	// ① system-dev 底下每一層都在（以前整棵不存在）
+	for _, want := range []string{
+		"system-dev", "system-dev/wiki", "system-dev/wiki/cards",
+		"system-dev/docs", "system-dev/docs/3-specs",
+		"system-dev/docs/3-specs/TEMPLATE-sdd", "system-dev/workflows",
+	} {
+		if _, ok := byPath[want]; !ok {
+			t.Fatalf("樹上少了 %q——「不收」又被實作成「不走進去」了", want)
+		}
+	}
+
+	// ② 數字是真的：cards 底下實際有 1 個檔，不是我們編的 0；
+	//    而且它是真內容 ⇒ 要被收（leo：「cards 在 system-dev 下…所以不允許跳過它」）
+	if got := byPath["system-dev/wiki/cards"]; got.TotalFiles != 1 || got.ExcludedFiles != 0 {
+		t.Fatalf("cards：total=%d excluded=%d，期望 1／0（走進去了要數真的，而且真內容要收）",
+			got.TotalFiles, got.ExcludedFiles)
+	}
+
+	// ③ 一個檔都沒收的那幾層（全是範本空殼），理由要講得出來
+	for _, p := range []string{"system-dev/wiki", "scripts", "system-dev/workflows"} {
+		n := byPath[p]
+		if n.ExcludedFiles != n.TotalFiles || n.TotalFiles == 0 {
+			t.Fatalf("%s 期望「全部排除」，實際 total=%d excluded=%d", p, n.TotalFiles, n.ExcludedFiles)
+		}
+		if !n.Skipped || n.SkipReason == "" {
+			t.Fatalf("%s 一個檔都沒收，卻沒有講理由（skipped=%v reason=%q）", p, n.Skipped, n.SkipReason)
+		}
+	}
+
+	// ④ 收檔範圍沒有跟著放寬——範本檔仍然不是知識
+	if n := byPath[""]; n.SyncedFiles+n.PendingFiles == 0 {
+		t.Fatalf("根層那份真文件應該還是要收")
+	}
+}
+
+// 剪枝只剩「走進去也沒有意義」的那幾種，而且仍然留節點＋理由。
+func TestFolderTree_依賴目錄仍然剪枝但看得見(t *testing.T) {
+	root := t.TempDir()
+	write(t, filepath.Join(root, "筆記.md"), "# 筆記\n")
+	write(t, filepath.Join(root, "node_modules", "left-pad", "index.js"), "module.exports=1\n")
+	tree := treeOf(t, root)
+
+	var nm *FolderNode
+	for i := range tree.Nodes {
+		if tree.Nodes[i].Path == "node_modules" {
+			nm = &tree.Nodes[i]
+		}
+		if strings.HasPrefix(tree.Nodes[i].Path, "node_modules/") {
+			t.Fatalf("不該走進 node_modules，卻生出了 %q", tree.Nodes[i].Path)
+		}
+	}
+	if nm == nil {
+		t.Fatal("node_modules 剪掉了就更該列出來——安靜地少收與講一個 0 是同一件事")
+	}
+	if !nm.Skipped || nm.SkipReason == "" {
+		t.Fatalf("node_modules 沒有理由：skipped=%v reason=%q", nm.Skipped, nm.SkipReason)
+	}
+}
@@ -160,15 +160,30 @@ var toolOwnedFileNames = map[string]bool{
 	"Gemfile.lock": true, "poetry.lock": true, "pnpm-workspace.yaml": true,
 }

-// templateOwnedDirNames＝system-dev-template 鋪出來的產物區，任何深度都不當原稿
-// （daemon-beta task 2，2026-08-06，原始出處 commit b4fee43）。
+// 🔴 這裡以前有第四張表：`templateOwnedDirNames = {"system-dev": true}`
+// ——「目錄名等於 system-dev ⇒ 任何深度、所有模式，整棵剪掉」。
+// **inkstone/Arcrun#180（leo 2026-08-28）把它拿掉了，但不是放行，是換成分辨。**
 //
-// 🔴 這一條以前是 direct.go 自己手捏的第二張表（`SkipDirNames{"system-dev": true}`），
-// 而 #104 的排除清單在這裡——**兩張表分居兩處，於是 2026-08-16 讀源碼的人只看到其中一張，
-// 把「清單根本沒接上」當成了真兇**（實際上兩張都有接上，見 direct.go 的 `Plan: plan`）。
-// 收成同一個地方，就不會再有第二張表可以漏看。
-// curated-wiki 模式要收的正是 `system-dev/wiki` ⇒ 那條路由 onPathTo 放行。
-var templateOwnedDirNames = map[string]bool{"system-dev": true}
+// leo 的原話：「**cards 在 system-dev 下，wiki 就在裡面，所以不允許跳過它**，
+// 而且**所有的 system-dev 都可以展開，因為就算沒有可萃的它也有下層**。」
+//
+// 實據（`~/Desktop/youlinhsieh-test1`）：
+//
+//	system-dev/wiki/        ← 6 個範本空殼（Jul 28 同一秒鋪下來的）
+//	system-dev/wiki/cards/  ← 9 張真的卡（火星座標／Leo-Hsieh-填答／小果被AFTEE詐貸…）
+//
+// 一張名字表沒有辦法分辨這兩層——它只看得到「這個目錄叫 system-dev」，
+// 於是把空殼和真內容一起丟掉，而且**連底下有哪些子資料夾都沒生出來**
+// （地端 find 有 13 個目錄，雲端的樹只有 3 個節點）。
+//
+// 換掉的是問題本身：
+//
+//	舊：這個目錄叫什麼名字？                      ⇒ 整棵剪掉
+//	新：這一個檔，和安裝器鋪下去的原版一不一樣？   ⇒ 逐檔決定（templateuntouched.go）
+//
+// 空殼與原版逐字相同 ⇒ 照舊不收（紅線①：不准變成放行）；
+// 使用者寫過、或安裝器根本沒鋪過的檔（那 9 張卡）⇒ 收。
+// 而目錄一律照走 ⇒ 樹長得出來（紅線②：展開 ≠ 收檔）。

 // projectManifestFiles＝「有人在這一層跑建置工具」的佐證檔。
 //
@@ -463,13 +478,23 @@ func dirQualifiesAsAutoDoc(absDir string) bool {

 // SkipsDir 回答「走訪時要不要整棵跳過這個目錄」。relSlash 是相對監看根的路徑。
 //
-// 三類跳過，全模式適用：
-//  1. noise（依賴／建置產物／範本）——名字判準，見 noiseDirNames
-//  2. linked worktree——`.git` 是檔案。#104 實據裡的 `.claude/worktrees/…` 與
-//     `products/arcrun-rag-wt60ship` 全是這一種：主 repo 的第二份簽出，收了就是重複
-//  3. 巢狀 repo（自己有 `.git` 的子目錄）——那是別的專案，見 otherWikiDirs 的說明
+// 🔴 **「不走進去」與「不收這裡的檔」是兩件事**（inkstone/Arcrun#180 紅線②，
+// leo 2026-08-28：「所有的 system-dev 都可以展開，**因為就算沒有可萃的它也有下層**」）。
+// 這支只回答前者，而且**只剩「走進去也沒有意義」的那幾種**：
 //
-// 再加上模式限定的：curated-wiki 只走那一份 wiki 的路；docs-only 只走文件目錄的路。
+//  1. 使用者自己宣告不要的（`.gitignore`）
+//  2. 工具產生的（別人的套件、快取、建置產物）——名字本身就不是人話
+//  3. 泛用名的建置目錄（旁邊擺著產生它的專案檔才算）
+//  4. linked worktree——同一個 repo 的第二份簽出，整棵是重複的
+//  5. 巢狀 repo——那是另一個獨立專案，要收請自己加進看守清單
+//
+// 這五種每一種都是「裡面長什麼樣不必知道」，剪掉不會讓使用者少看到自己的東西
+// （而且 `node_modules` 這種走進去就是幾萬個節點，畫面反而看不了）。
+//
+// **拿掉的是「收檔範圍」那幾條**：以前 curated-wiki 只走那份 wiki 的路、docs-only 只走
+// 文件區、範本目錄整棵剪掉——那三條講的是「要不要**收**」，卻長在剪枝上，
+// 於是樹在那一節就斷了（實測：地端 13 個目錄，雲端的樹只有 3 個節點）。
+// 它們搬去 CollectsDirWhy，只影響收檔，不影響走訪。
 // （隱藏目錄由 Scan 自己擋，那條規則比本檔更早存在，不搬過來。）
 func (p IngestPlan) SkipsDir(relSlash, absPath string) bool {
 	skip, _ := p.SkipsDirWhy(relSlash, absPath)
@@ -496,10 +521,6 @@ func (p IngestPlan) SkipsDirWhy(relSlash, absPath string) (bool, string) {
 	if ambiguousBuildDirNames[name] && looksGenerated(absPath) {
 		return true, "這是建置工具產生的目錄（旁邊就是產生它的專案檔）"
 	}
-	// ④ template 鋪出來的產物區（任何深度）。curated-wiki 要收的那條路例外。
-	if templateOwnedDirNames[name] && !(p.Mode == IngestCuratedWiki && onPathTo(relSlash, p.WikiRelDir)) {
-		return true, "這是開發範本鋪出來的目錄，不是你的知識"
-	}
 	if IsLinkedWorktree(absPath) {
 		return true, "這是同一個專案的第二份簽出（git worktree），內容與主資料夾重複"
 	}
@@ -507,21 +528,31 @@ func (p IngestPlan) SkipsDirWhy(relSlash, absPath string) (bool, string) {
 	if IsRepoRoot(absPath) {
 		return true, "這是另一個獨立的專案，要收請把它自己加進看守清單"
 	}
+	return false, ""
+}
+
+// CollectsDirWhy 回答「這一層的檔案，這次收不收」——**走訪照走，只影響收檔**。
+//
+// 回 (false, 理由) ＝ 這一層的檔不收，理由講給使用者聽；(true, "") ＝ 照收檔規則走。
+//
+// 這裡裝的正是從剪枝搬過來的那幾條收檔範圍：curated-wiki 只讀那份整理好的 wiki、
+// docs-only 只讀文件區。**它們是好的判斷，錯的只是它們以前長在剪枝上**
+// ——把「不收」實作成「不走進去」，代價是使用者連自己有哪些子資料夾都看不到。
+func (p IngestPlan) CollectsDirWhy(relSlash string) (bool, string) {
 	switch p.Mode {
 	case IngestCuratedWiki:
-		// 只有「通往那份 wiki 的路」與「那份 wiki 底下」要走。
 		if !onPathTo(relSlash, p.WikiRelDir) {
-			return true, "這次只讀你整理好的 " + p.WikiRelDir
+			return false, "這次只讀你整理好的 " + p.WikiRelDir
 		}
 	case IngestDocsOnly:
 		for _, d := range p.DocRelDirs {
 			if onPathTo(relSlash, d) {
-				return false, ""
+				return true, ""
 			}
 		}
-		return true, "這是一個開發專案，這次只讀文件區，不讀程式碼"
+		return false, "這是一個開發專案，這次只讀文件區，不讀程式碼"
 	}
-	return false, ""
+	return true, ""
 }

 // KeepsFile 回答「這個檔要不要收」。relSlash 是相對監看根的路徑。
@@ -539,6 +570,56 @@ func (p IngestPlan) KeepsFile(relSlash string) bool {
 	if toolOwnedFileNames[filepath.Base(relSlash)] {
 		return false
 	}
+	// 🔴 inkstone/Arcrun#134（2026-08-28 實測）：**我們自己產的卡不是原稿。**
+	//
+	// curated-wiki 模式收的是「他親手整理的 `system-dev/wiki/`」，而那個目錄底下
+	// 同時住著 daemon 上一版寫進去的卡（`cards/arcrun-*.md`，帶 MachineMark）。
+	// 少了這一問，daemon 會把自己 8/4 產的卡當成新原稿再萃一次，得到「卡片的卡片」
+	// ——實測 `youlinhsieh-test1` 一輪長出 10 份第二代文件卡（`arcrun-換柱`、
+	// `arcrun-官架子`…），而它們又會變成第三代的原稿。
+	//
+	// 判準用 IsMachineOwnedRel 而不是「在不在某個目錄」：那支是規約的完整判準
+	// （帶 MachineMark 前綴 ∪ 路徑上有 `.arcrun-rag/` 或 `.wiki/`），
+	// 而使用者自己寫的卡不帶前綴 ⇒ 照收不誤，curated-wiki 的規格（#104 第二層，
+	// 「那份 wiki 是他寫的，正是他要我們讀的」）不受影響。
+	if InMachineOwnedDir(relSlash) {
+		return false
+	}
+	// 🔴 inkstone/Arcrun#180（2026-08-28）把上面那一問**收窄成只在 curated-wiki 生效**，
+	// 因為 #134 與 #180 的迴歸網在同一個路徑上要求相反的答案：
+	//
+	//	#134 cardloop_test.go：`system-dev/wiki/cards/arcrun-換柱.md`        **不准收**
+	//	#180 template_not_knowledge_test.go：`system-dev/wiki/cards/arcrun-火星座標_短片劇本_v1.md` **必須收**
+	//
+	// 同一個目錄、同一個前綴 ⇒ **靠名字分不開**，實測 #151 併入後四種模式全部回 false，
+	// leo 的那 9 張卡一張都收不到（而他 08-14 的原話是「這些庫都早就萃好了⋯⋯直接 ingest」，
+	// #180 票上第 3 條驗收就是「那 9 張卡的內容進得了雲端」）。
+	//
+	// 收窄的依據是 #134 自己寫下的理由——它整段講的是 curated-wiki：
+	// 「curated-wiki 模式收的是『他親手整理的 system-dev/wiki/』，而那個目錄底下
+	//   同時住著 daemon 上一版寫進去的卡」。**接一個開發 repo 時那個重疊是結構性的**
+	//（`cardsRelDir` 就等於 `system-dev/wiki/cards`）⇒ 該擋。
+	// 一般資料夾／筆記庫（mode=all）沒有那個結構性重疊，而 leo 對這一種明確表過態。
+	//
+	// 🔴 **這一格是我的假設，不是 leo 的裁決**：兩張票的驗收互斥，需要他選一邊。
+	//    假設寫在這裡與 PR／票上，錯了打回即可（`inkstone/Arcrun#180`）。
+	// 迴圈安不安全：#134 三個環裡真正關掉迴圈的是 tidy／snapshotCards 那兩個
+	//（產物只落 `.wiki/`，上面那一問就擋得住）。實測 4 輪 mode=all 收這 9 張卡，
+	// `system-dev/wiki/cards/` 從頭到尾維持 9 個檔、沒有第二代。
+	//
+	// 🔴 第二格收窄：**再加一問「在不在卡片產物區」**。
+	// `IsMarked` 只看 basename 前綴，而 `arcrun-` 是這個專案的人也會用的命名習慣——
+	// 實測 leo 的 `youlinhsieh-test1` **根層**就有三個他自己寫的檔中招：
+	//	`arcrun-1457驗收-20260827.md`／`arcrun-md-test.md`／
+	//	`arcrun-複驗用-請勿刪-20260827c.md`（檔名裡就寫著「請勿刪」）
+	// 對照組實跑（#151 原樣、dry-run）：這三個連同那 9 張卡共 **12 個檔被排進「下架」**
+	// ——不是不收而已，是**把雲端已經有的內容撤掉**。
+	// #134 要擋的是「daemon 寫在他 wiki 裡的卡」，那些卡一律住在卡片產物區
+	//（`system-dev/wiki/cards/`／`.arcrun-rag/wiki/cards/`，`cardRelFor` 的落點），
+	// 所以多這一問不會放過任何一個它要擋的東西，卻救回使用者自己命名的檔。
+	if p.Mode == IngestCuratedWiki && IsMarked(filepath.Base(relSlash)) && isUnderCardDir(relSlash) {
+		return false
+	}
 	switch p.Mode {
 	case IngestCuratedWiki:
 		return strings.HasPrefix(relSlash, p.WikiRelDir+"/")
@@ -274,7 +274,7 @@ func syncInventory(cfg *DirectConfig, absRoot string, m *Manifest, hasEvents, dr
 	// 只帶 library ⇒ 兩台機器上同名的資料夾會生出一模一樣的鍵，後同步的那台會把
 	// 前一台的總覽卡蓋掉。這裡與逐檔卡走同一組欄位，不另開一種。
 	mach := cfg.machineIdentity()
-	status, _, err := cfg.postJSON(cfg.triggerURL(wf), map[string]any{
+	status, _, err := cfg.postJSON(stepInventory, cfg.triggerURL(wf), map[string]any{
 		"page_name":     page,
 		"path":          res.Path,
 		"card_content":  card,
@@ -83,9 +83,25 @@ func UnmarkName(base string) string {
 // ⚠️ 例外只有這兩個目錄。監看根底下**其他任何位置**的新檔，一律得帶前綴——
 // 想在別處寫一個「名字不能改」的檔時，先想清楚那個檔為什麼不能住進這兩個目錄。
 func IsMachineOwnedRel(relSlash string) bool {
-	if IsMarked(pathBase(relSlash)) {
-		return true
-	}
+	return IsMarked(pathBase(relSlash)) || InMachineOwnedDir(relSlash)
+}
+
+// InMachineOwnedDir 只回答上面那兩條路的**第二條**：這個路徑上有沒有一層是
+// `.arcrun-rag/` 或 `.wiki/`。
+//
+// 🔴 為什麼要把它單獨切出來（inkstone/Arcrun#180 ↔ #134，2026-08-28）：
+// 兩條路的**證據強度不一樣**，而收檔判準需要分得開它們——
+//
+//	目錄（本函式）＝**位置**證明它是產物。`.wiki/` 是這一版寫卡的唯一落點，
+//	                任何時候走到那裡的東西都是我們此刻正在維護的產物 ⇒ 鐵證。
+//	前綴（IsMarked）＝**歷史**說某一版的 daemon 寫過它。它不保證「現在還是產物」：
+//	                leo 的 `youlinhsieh-test1` 底下那 9 張 `cards/arcrun-*.md`
+//	                是 8/4 舊版寫的，而他 08-14 明講「這些庫都早就萃好了⋯⋯直接 ingest」
+//	                ——對他而言那就是他的知識。
+//
+// ⇒ 要「絕不把產物當原稿」時用本函式；要「連歷史產物都不碰」時才用 IsMachineOwnedRel。
+// 規約本身（每個新檔都要帶標記）沒有變，vault_footprint_test.go 仍然用完整判準。
+func InMachineOwnedDir(relSlash string) bool {
 	for _, seg := range strings.Split(relSlash, "/") {
 		if seg == workspaceRelDir || seg == wikiRelDir {
 			return true
@@ -107,6 +107,13 @@ type Manifest struct {
 	// 雲端一壞就是每 5 秒撞一次。內容變了（雜湊不同）視同新卡，立即可再試。
 	InventoryFailHash  string `json:"inventory_fail_hash,omitempty"`
 	InventoryNextRetry int64  `json:"inventory_next_retry,omitempty"`
+	// SourceOriginRepairedAt＝這個監看根的「### 出處」已全部改成
+	// 「機器 › 知識庫 › 庫內路徑」的時間（unix 秒，0＝還沒修過）。
+	// 🔴 `inkstone/Arcrun#167`：舊卡寫的是 `../<檔名>`（daemon 的內部目錄結構），
+	//    AI 照著答，使用者走不到那個檔。修產生端只治得了新卡，既有的要就地重推
+	//    （見 sourcerepair.go）。這一格的存在是為了**修完就不再每輪掃全庫**——
+	//    沒有它，這個修復會變成一個永遠在跑的背景工作。
+	SourceOriginRepairedAt int64 `json:"source_origin_repaired_at,omitempty"`

 	// PendingTakedowns＝改名／搬移後「舊路徑」在雲端知識庫裡還沒下架成功的待辦清單
 	// （key=舊相對路徑，value=該路徑當時導出的頁名）。InkStoneCo#44 ⑩：
@@ -23,6 +23,7 @@ package collector

 import (
 	"bytes"
+	"context"
 	"encoding/json"
 	"fmt"
 	"net/http"
@@ -31,6 +32,10 @@ import (
 )

 // probeHTTP 探測用短逾時：只是要知道 route 在不在，不等 LLM 生成。
+//
+// 🔴 `inkstone/arcrun-rag#153`：這把 20 秒是保險，真正的上限由呼叫端帶進來的
+// context 決定。探測是**每輪、每個帳號的第一發**——它撞到不回應的端點時，
+// 後面所有帳號都還沒開始，所以它也是最早能認出「這個帳號今天不回應」的位置。
 var probeHTTP = &http.Client{Timeout: 20 * time.Second}

 // CloudAIState 是「某個雲端實例的 Workers AI 萃取能力」探測結果。
@@ -47,25 +52,27 @@ type CloudAIState struct {
 //     ⇒ 算通。這樣探測不會真的燒 LLM 額度，也不會產生垃圾卡片。
 //   - 401 代表 route 在、只是金鑰不對 ⇒ route 存在，同樣算「雲端有這功能」，
 //     金鑰問題由既有的連線流程去報，不混在這裡講。
-func ProbeWorkersAI(cypherURL, apiKey string) CloudAIState {
+func ProbeWorkersAI(ctx context.Context, cypherURL, apiKey string) (CloudAIState, error) {
 	base := strings.TrimSuffix(strings.TrimSpace(cypherURL), "/")
 	if base == "" {
-		return CloudAIState{Ready: false, Note: "還沒連上知識庫"}
+		return CloudAIState{Ready: false, Note: "還沒連上知識庫"}, nil
 	}

 	body, _ := json.Marshal(map[string]string{"page_name": "", "text": ""})
-	req, err := http.NewRequest(http.MethodPost, base+"/portal/daemon/extract", bytes.NewReader(body))
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, base+"/portal/daemon/extract", bytes.NewReader(body))
 	if err != nil {
-		return CloudAIState{Ready: false, Note: "雲端 AI 狀態查不到"}
+		return CloudAIState{Ready: false, Note: "雲端 AI 狀態查不到"}, nil
 	}
 	req.Header.Set("Content-Type", "application/json")
 	req.Header.Set("X-Arcrun-API-Key", strings.TrimSpace(apiKey))

 	resp, err := probeHTTP.Do(req)
 	if err != nil {
+		// #153：錯誤原件一起回去，呼叫端才分得出「等到超時」與「立刻連不上」——
+		// 前者要記進斷路器，後者不該（不然一次斷網就把帳號判成停機）。
 		// 連不上（離線／網路問題）≠ 雲端沒裝。講「查不到」而不是「還沒通」，
 		// 免得把網路問題誤報成「你沒更新」讓用戶白跑一趟。
-		return CloudAIState{Ready: false, Note: "連不上你的知識庫，雲端 AI 狀態查不到"}
+		return CloudAIState{Ready: false, Note: "連不上你的知識庫，雲端 AI 狀態查不到"}, err
 	}
 	defer resp.Body.Close()

@@ -74,14 +81,38 @@ func ProbeWorkersAI(cypherURL, apiKey string) CloudAIState {
 		return CloudAIState{
 			Ready: false,
 			Note:  "雲端 AI 還沒通 ⇒ 你的知識庫是舊版，請到 portal 按「立即更新」重裝一次",
-		}
+		}, nil
 	case resp.StatusCode < 500:
 		// 200/400/401… 都代表這條 route 存在＝雲端有這個功能。
-		return CloudAIState{Ready: true}
+		return CloudAIState{Ready: true}, nil
 	default:
 		return CloudAIState{
 			Ready: false,
 			Note:  fmt.Sprintf("雲端 AI 暫時有狀況（HTTP %d），稍後會自動再試", resp.StatusCode),
-		}
+		}, nil
 	}
 }
+
+// probeWorkersAI＝帶「等待閘」的探測（`inkstone/arcrun-rag#153`）。
+//
+// 為什麼這一發特別重要：它是每輪、每個帳號的**第一發**。撞到不回應的端點時，
+// 後面的資料夾一件都還沒開始 ⇒ 這裡認出來，整個帳號的其餘工作就都省下來了。
+// 反過來說，漏掉這一發的話，前面所有的閘都白裝——2026-08-28 第一版就是這樣：
+// 斷路器跳了，可是一輪還是要 20 秒，因為那 20 秒全花在這一發上。
+func (c *DirectConfig) probeWorkersAI() CloudAIState {
+	if note := c.unreachableNote(); note != "" {
+		return CloudAIState{Ready: false, Note: note}
+	}
+	gate := c.openGate(stepProbeAI)
+	state, err := ProbeWorkersAI(gate.ctx, c.CypherURL, c.APIKey)
+	gate.release()
+	if err == nil {
+		gate.ok()
+	}
+	if perr := gate.record(err); perr != nil {
+		// 等到超時 ⇒ 講的是「沒有回應」，不是「你的雲端沒裝好」。
+		// 把等待誤報成「你沒更新」會害使用者白跑一趟去按重裝。
+		return CloudAIState{Ready: false, Note: perr.Error()}
+	}
+	return state
+}
@@ -37,6 +37,16 @@ type SyncProgress struct {
 	Pending    int `json:"pending"`    // 還沒送，會自動接著做（含退避等待中的）
 	Stuck      int `json:"stuck"`      // 連續失敗達上限、已暫停自動重試——**不會自己好**
 	Unreadable int `json:"unreadable"` // 格式讀不了，根本沒進 manifest（由呼叫端補進來）
+	// Failing＝Pending 裡「最近一次已經送失敗過、正在退避等重試」的份數
+	// （`inkstone/arcrun-rag#159`）。**它是 Pending 的子集合，不進不變式**——
+	// 加總永遠只算 Total == Done+Pending+Stuck+Unreadable。
+	//
+	// 🔴 為什麼要分出來：Pending 同時裝著兩種完全不同的處境——「還沒輪到」與
+	// 「一直送不上去」。混在一起時畫面只能講「同步中」，而 2026-08-28 leo 桌面上
+	// geek6688-test1 的 14 份**每一份都在失敗重試**（雲端回 HTTP 500 Too many
+	// subrequests，fail_count 是 7 與 3），講「同步中」等於叫他等一件正在壞掉的事。
+	// 分出來，畫面才判斷得出該不該示警（見 arcrun-app/folder_badge.go）。
+	Failing int `json:"failing"`
 }

 // Add 把另一個資料夾／帳號的進度累加進來——首頁與診斷檔講的都是總量。
@@ -47,6 +57,7 @@ func (p SyncProgress) Add(o SyncProgress) SyncProgress {
 		Pending:    p.Pending + o.Pending,
 		Stuck:      p.Stuck + o.Stuck,
 		Unreadable: p.Unreadable + o.Unreadable,
+		Failing:    p.Failing + o.Failing,
 	}
 }

@@ -69,6 +80,11 @@ func (m *Manifest) Progress() SyncProgress {
 			p.Stuck++
 		default:
 			p.Pending++
+			if e.FailCount > 0 {
+				// #159：還在排隊，但**已經失敗過**——退避等下一次重試。
+				// 與 Pending 並存（子集合），不影響上面的不變式。
+				p.Failing++
+			}
 		}
 	}
 	return p
@@ -164,6 +164,10 @@ type dirStat struct {
 	supported   int // 通過所有閘、進了 manifest 的（＝分子的候選）
 	unsupported int // 副檔名還讀不了的（docLikeExt 與其他）
 	excluded    int // 收檔策略／範本身分決定不收的（程式碼多半落這裡）
+	// excludeWhy＝這一層的檔被排除的理由（產品文案，第一個排除的檔說了算）。
+	// #180：以前不收就是「不走進去」，理由掛在被剪掉的目錄上；現在走進去了，
+	// 理由得跟著檔案的排除一起記下來，不然畫面只剩一個沒有解釋的 `0/6`。
+	excludeWhy string
 }

 // MaxExcludedDirsListed：最多逐筆列幾個被跳過的目錄。超過的只反映在 ExcludedDirCount
@@ -360,10 +364,19 @@ func Scan(root string, m *Manifest, opts ScanOptions) (*TriggerPayload, error) {
 			if p != root && opts.SkipDirNames[name] {
 				return filepath.SkipDir // 名單目錄（呼叫端自訂）整棵跳過
 			}
-			// #104：依策略整棵跳過（使用者的 .gitignore／依賴／建置產物／範本／
-			// worktree／巢狀 repo／以及非本次策略要收的區域）。
+			// #104：依策略整棵剪掉（使用者的 .gitignore／依賴／建置產物／
+			// worktree／巢狀 repo）。
 			// 🔴 每一次剪枝都要留下「哪一個、為什麼」——票上的紅線是排除規則要看得見，
 			//    而 2026-08-16 實測發現原本整棵剪掉的部分完全沒有被記錄。
+			//
+			// 🔴 inkstone/Arcrun#180（leo 2026-08-28）：**「不收」不准再實作成「不走進去」。**
+			//    leo 原話：「我要的就是雲端看到**所有的 folder** 像 tree 一樣呈現，去遍歷就好了」
+			//    「所有的 system-dev 都可以展開，**因為就算沒有可萃的它也有下層**」。
+			//    實測差距：`youlinhsieh-test1` 地端 `find -type d` 有 13 個目錄，
+			//    雲端的樹只有 3 個節點——樹在 `system-dev` 那一節就斷了。
+			//    ⇒ 收檔範圍那幾條（curated-wiki 只走 wiki／docs-only 只走文件區／
+			//      範本目錄）已從 SkipsDirWhy 搬到 CollectsDirWhy：**走訪照走、節點照生、
+			//      數字照算**，只是標明「這一層我不收」。
 			if p != root {
 				if rel, ok := relOf(); ok {
 					if skip, why := opts.Plan.SkipsDirWhy(rel, p); skip {
@@ -375,6 +388,11 @@ func Scan(root string, m *Manifest, opts ScanOptions) (*TriggerPayload, error) {
 					if _, ok := dirStats[rel]; !ok {
 						dirStats[rel] = &dirStat{}
 					}
+					// #180：走進來了，但這一層的檔這次不收 ⇒ 節點照生、子節點照長，
+					// 只是把理由掛上去（畫面仍然講得出「為什麼這裡沒收」）。
+					if collect, why := opts.Plan.CollectsDirWhy(rel); !collect {
+						excludedDirs = append(excludedDirs, ExcludedDir{Path: rel, Reason: why})
+					}
 				}
 			}
 			return nil
@@ -390,6 +408,13 @@ func Scan(root string, m *Manifest, opts ScanOptions) (*TriggerPayload, error) {
 			s := statOf(rel)
 			s.total++
 			s.excluded++
+			if s.excludeWhy == "" {
+				if _, why := opts.Plan.CollectsDirWhy(folderOfRel(rel)); why != "" {
+					s.excludeWhy = why
+				} else {
+					s.excludeWhy = "這一層的檔案不在這次的收檔範圍裡"
+				}
+			}
 			return nil
 		}
 		if abs, aerr := filepath.Abs(p); aerr == nil && opts.SkipPaths[abs] {
@@ -406,16 +431,33 @@ func Scan(root string, m *Manifest, opts ScanOptions) (*TriggerPayload, error) {
 		//    · 我們代裝 template 的資料夾（沒有 `.git`）⇒ 那些檔是**我們鋪的**，照舊不收
 		//    · 使用者自己的 repo（有 `.git`）⇒ 那份 wiki 是**他寫的**，正是他要我們讀的
 		//    判準只有 PlanIngest 一個地方，見 ingestplan.go。
+		//
+		// 🔴 inkstone/Arcrun#180：**不收照舊，但不准再從畫面上消失。**
+		//    leo 要的是「知道資料夾下有幾個檔案被萃」——以前這裡直接 `return nil`，
+		//    那些檔連分母都沒進去，於是 `system-dev/wiki`（實際 6 個檔）在樹上是 `0/0`、
+		//    `scripts`（實際 1 個檔）也是 `0/0`。**兩個 0 都是我們自己編的數字。**
+		//    現在照樣不收，但算進 total／excluded，使用者看得到「這裡有 6 個，我一個都沒收」。
+		//
+		// 🔴 inkstone/Arcrun#180 驗收條件 2／3：判準從**路徑前綴**換成**內容**
+		//    （templateuntouched.go）。舊的 `TemplateOwns` 把 `system-dev/` 整棵當範本，
+		//    分不出同一棵樹底下的兩種東西——`system-dev/wiki/status.md`（安裝器鋪的空殼）
+		//    與 `system-dev/wiki/cards/*.md`（9 張真的卡）於是一起被丟掉。
+		//    現在逐檔比對：和快照逐字相同＝空殼，不收；其餘照常判斷。
 		if rel, rerr := filepath.Rel(root, p); rerr == nil {
 			relSlash := filepath.ToSlash(rel)
-			if TemplateOwns(relSlash) && !opts.Plan.OverridesTemplateOwned(relSlash) {
+			if TemplateUntouched(relSlash, p) {
+				s := statOf(relSlash)
+				s.total++
+				s.excluded++
+				if s.excludeWhy == "" {
+					s.excludeWhy = "這是安裝範本時鋪下來的空白樣板，你還沒在上面寫過東西"
+				}
 				return nil
 			}
 		}
 		ext := strings.ToLower(filepath.Ext(name))
-		// #44 線 A：走到這裡的都是「使用者自己的、看得見的」檔——上面三道
-		// （隱藏檔／SkipPaths 的機器檔／TemplateOwns 我們自己鋪的範本）刻意不算進分母，
-		// 理由與 scan.go 既有註解同一條：**我們自己鋪的東西不該佔用他的注意力**。
+		// #44 線 A：走到這裡的都是「使用者自己的、看得見的」檔（隱藏檔與 SkipPaths 的
+		// 機器檔刻意不算進分母：**我們自己寫的東西不該佔用他的注意力**）。
 		if rel, ok := relOf(); ok {
 			s := statOf(rel)
 			s.total++
@@ -0,0 +1,213 @@
+// sourcerepair.go — 既有卡片的「### 出處」就地修正（`inkstone/Arcrun#167`）。
+//
+// 病（leo 2026-08-27 用 n8n 實測抓到）：卡片內文的「### 出處」寫的是 `../<檔名>`，
+// 那是**卡片檔相對於原檔**的內部目錄結構。它被當成知識內容存進 KBDB，於是任何
+// 接上 MCP 的 AI 問「原文在哪」都照著答——而使用者拿著 `../小果被AFTEE詐貸.pdf`
+// 走不到任何地方。原稿在子資料夾時更慘：資料夾整段被弄丟。
+//
+// 修在產生端（wikishape.go 的 renderSourceLine）只治得了**新卡**。
+// 票上寫死了「不能只修新的」⇒ 這支檔是對**既有資料**的處置。
+//
+// 為什麼是「就地修 + 重推」而不是「重萃」（三選一的取捨）：
+//
+//	重萃    每份檔要再燒一次 AI 額度，而且模型每次判斷不同 ⇒ 使用者眼前的卡會無故變樣。
+//	        出處那一塊**根本不是模型寫的**（它是機械組裝的），為它重萃是白花錢。
+//	留著    票上明文禁止。
+//	就地修  ✅ 卡片檔在本機還在 ⇒ 重畫那一塊、原樣重推。零 LLM、內容其餘一字不動。
+//
+// 重推為什麼是安全的：`rag_ingest_card` 進門先刪同 page_name＋同 source_path 的舊
+// blocks／triplets 再寫（見該 workflow 的 list_old_blocks／pick_stale）⇒ 同一張卡
+// 推第二次是取代，不是疊加。
+//
+// 三條自我約束：
+//   - **一次只修一批**（sourceRepairBatch）：巨量資料夾不該一輪湧完。
+//   - **修完蓋章就不再跑**（Manifest.SourceOriginRepairedAt）：不是每輪掃一次全庫。
+//   - **推失敗不蓋章**：下一輪繼續，但也不重推已經成功的（章是逐檔記在 wiki manifest 上）。
+package collector
+
+import (
+	"os"
+	"path"
+	"path/filepath"
+	"strings"
+	"time"
+)
+
+// sourceRepairBatch＝單輪最多修幾份文件（含重推）。
+// 與 cloudAuditBatch 同一個精神：積壓再多也不該一輪湧完。
+const sourceRepairBatch = 20
+
+// legacySourceMark＝舊形出處的指紋。只認這一個字面，認不到就不動它
+//（已經是新形的、或使用者自己手改過的，一律不碰）。
+const legacySourceMark = "- `../"
+
+// sourceHeading＝出處那一塊的標題行。
+const sourceHeading = "### 出處"
+
+type sourceRepairResult struct {
+	Scanned  int    // 這一輪看過幾份文件
+	Rewrote  int    // 本機卡片被重畫的份數
+	Repushed int    // 成功重推上雲的份數
+	Err      string // 最後一個錯誤（原文照留，leo 2026-08-06 的原則）
+	Done     bool   // 這個監看根已經全部處理完
+}
+
+// hasLegacySourceLine 回答「這張卡的出處還是舊形嗎」。
+func hasLegacySourceLine(card string) bool {
+	i := strings.Index(card, sourceHeading)
+	if i < 0 {
+		return false
+	}
+	return strings.Contains(card[i:], legacySourceMark)
+}
+
+// rewriteSourceBlock 把卡片裡的「### 出處」整塊換成新形。
+// 找不到那一塊＝不是本塑形層產的卡，原樣回傳（不亂加東西）。
+func rewriteSourceBlock(card string, o SourceOrigin, cardName string) string {
+	i := strings.Index(card, sourceHeading)
+	if i < 0 {
+		return card
+	}
+	rest := card[i+len(sourceHeading):]
+	// 區塊結束＝下一個標題行或檔尾。出處是「## 關聯」的最後一個 H3，
+	// 實務上就是檔尾，但仍照界線處理（之後有人在它後面加段落也不會被吃掉）。
+	end := len(card)
+	for off := 0; ; {
+		nl := strings.Index(rest[off:], "\n")
+		if nl < 0 {
+			break
+		}
+		off += nl + 1
+		line := rest[off:]
+		if j := strings.Index(line, "\n"); j >= 0 {
+			line = line[:j]
+		}
+		if strings.HasPrefix(line, "#") {
+			end = i + len(sourceHeading) + off
+			break
+		}
+	}
+	var b strings.Builder
+	renderSourceLine(&b, o, cardName)
+	return card[:i] + b.String() + card[end:]
+}
+
+// cardNameOfFile 從卡片相對路徑取卡名（＝檔名去副檔名；BuildWikiDoc 的落點規則）。
+func cardNameOfFile(rel string) string {
+	return strings.TrimSuffix(path.Base(filepath.ToSlash(rel)), ".md")
+}
+
+// repairCardSourceBlocks 掃一個監看根的 wiki manifest，把還是舊形出處的卡就地修好，
+// 並把**文件卡**（唯一上雲的那張）原樣重推一次。
+//
+// dryRun 時只看不改（與整條 direct 路徑的 --dry-run 語意一致）。
+// force＝不看「本機卡是不是還是舊形」，一律重推一次。
+// 這是給**手動補救**用的（雲端被清空過、或某一輪推到一半被中斷 ⇒ 本機新形、雲端舊形
+// ⇒ 常規判準會判「不用修」而永遠不補推）。daemon 常規路徑一律 false。
+func repairCardSourceBlocks(cfg *DirectConfig, absRoot string, m *Manifest, dryRun, force bool, now time.Time) *sourceRepairResult {
+	if m == nil || (!force && m.SourceOriginRepairedAt > 0) {
+		return nil // 這個根已經修完，不再每輪掃
+	}
+	wm := loadWikiManifest(absRoot)
+	if len(wm.Docs) == 0 {
+		if !dryRun {
+			m.SourceOriginRepairedAt = now.Unix() // 沒有 .wiki 產物＝沒東西可修，蓋章收工
+		}
+		return nil
+	}
+	mach := cfg.machineIdentity()
+	library := cfg.libraryFor(absRoot)
+
+	res := &sourceRepairResult{}
+	remaining := 0
+	for di := range wm.Docs {
+		d := &wm.Docs[di]
+		if len(d.Cards) == 0 {
+			continue
+		}
+		libPath := path.Join(nodeFromKey(d.Node), filepath.ToSlash(d.Path))
+		// 這一份的卡有沒有舊形出處？先看文件卡（第一張），它就是上雲的那張。
+		docAbs := filepath.Join(absRoot, filepath.FromSlash(d.Cards[0]))
+		body, rerr := os.ReadFile(docAbs)
+		if rerr != nil {
+			continue // 卡不見了（使用者刪過／被搬走）＝不是這支檔的題目
+		}
+		// 🔴 判準只看**文件卡**（＝唯一上雲的那張），而且它是「已修好**且已推上去**」的
+		// 唯一憑據。實撞（2026-08-27，第一輪跑到一半被中斷）：先改本機再推，被中斷之後
+		// 本機已是新形、雲端還是舊的 ⇒ 下一輪看本機判「不用修」⇒ **那份永遠不會補推**。
+		// 所以順序是**先推、推成功才寫本機**——推失敗的話本機留著舊形，下一輪自然重試。
+		if !force && !hasLegacySourceLine(string(body)) {
+			// 文件卡已是新形（代表也推過了）；概念卡只落本機、不上雲，順手補齊即可。
+			for _, c := range d.Cards[1:] {
+				abs := filepath.Join(absRoot, filepath.FromSlash(c))
+				raw, e := os.ReadFile(abs)
+				if e != nil || !hasLegacySourceLine(string(raw)) {
+					continue
+				}
+				fixed := rewriteSourceBlock(string(raw), SourceOrigin{
+					MachineLabel: mach.Label, Library: library, LibraryPath: libPath,
+				}, cardNameOfFile(c))
+				if werr := writeWikiFile(absRoot, abs, []byte(fixed)); werr != nil {
+					res.Err = werr.Error()
+				}
+			}
+			continue
+		}
+		res.Scanned++
+		if res.Scanned > sourceRepairBatch {
+			remaining++
+			continue
+		}
+		if dryRun {
+			continue
+		}
+		origin := SourceOrigin{MachineLabel: mach.Label, Library: library, LibraryPath: libPath}
+		docCard := rewriteSourceBlock(string(body), origin, cardNameOfFile(d.Cards[0]))
+
+		// ① 先重推（零 LLM）。欄位與 direct.go 送新卡時逐欄一致，
+		//    workflow 進門會先刪同 page_name＋同 source_path 的舊 blocks ⇒ 取代不疊加。
+		status, _, perr := cfg.postJSON(stepRepairOrigin, cfg.triggerURL(cfg.CardIngestWF), map[string]any{
+			"page_name":     pageNameOf(libPath),
+			"path":          libPath,
+			"card_content":  docCard,
+			"library":       library,
+			"machine":       mach.ID,
+			"machine_label": mach.Label,
+		})
+		if perr != nil || status < 200 || status >= 300 {
+			if perr != nil {
+				res.Err = perr.Error()
+			} else {
+				res.Err = "重推知識庫失敗（HTTP " + itoa(status) + "）"
+			}
+			remaining++ // 這一份沒推成功 ⇒ 本機不動（留著舊形當重試訊號）、這個根不能蓋章
+			continue
+		}
+
+		// ② 推成功了才寫本機（文件卡＋概念卡）。
+		for _, c := range d.Cards {
+			abs := filepath.Join(absRoot, filepath.FromSlash(c))
+			raw, e := os.ReadFile(abs)
+			if e != nil {
+				continue
+			}
+			fixed := rewriteSourceBlock(string(raw), origin, cardNameOfFile(c))
+			if fixed == string(raw) {
+				continue
+			}
+			if werr := writeWikiFile(absRoot, abs, []byte(fixed)); werr != nil {
+				res.Err = werr.Error()
+			}
+		}
+		res.Rewrote++
+		res.Repushed++
+	}
+	if !dryRun && remaining == 0 {
+		m.SourceOriginRepairedAt = now.Unix()
+		res.Done = true
+	}
+	if res.Scanned == 0 && res.Rewrote == 0 {
+		return nil
+	}
+	return res
+}
@@ -0,0 +1,67 @@
+package collector
+
+// sourcerepair_live_test.go — 對**真實實例**跑一次既有資料修復（`inkstone/Arcrun#167`）。
+//
+// 🔴 為什麼留在 repo 裡而不是用完就丟（同 probe_real_manual_test.go 的理由）：
+// 這一票的驗收條件是「**MCP client 問『原文在哪』拿到的答案能不能走到那個檔**」——
+// 那不是 fixture 答得出來的。下一個人要重跑存量修復（換機器、換庫、雲端重裝過）
+// 就跑這一支，不必再從頭想一次怎麼推。
+//
+// 預設 skip，不進 CI。它會**真的寫進知識庫**，所以要明講打的是哪個實例：
+//
+//	LIVE_REPAIR=1 \
+//	LIVE_CYPHER=https://arcrun-cypher-executor.youlin-hsieh-dev.workers.dev \
+//	LIVE_NS=<namespace> \
+//	LIVE_ROOTS="/Users/x/Desktop/youlinhsieh-test1" \
+//	# 加 LIVE_FORCE=1 ＝不看本機是不是已經新形，一律重推（雲端被清空、或上一輪中斷過時用）
+//	go test -run TestLiveRepairSourceBlocks -v ./
+//
+// 🔴 紅線：LIVE_CYPHER 只准指測試實例。本測試不讀 config.json（那份含多個帳號，
+// 誤跑會打到不該打的實例）——實例位址一律由呼叫者當場指名。
+
+import (
+	"os"
+	"strings"
+	"testing"
+	"time"
+)
+
+func TestLiveRepairSourceBlocks(t *testing.T) {
+	if os.Getenv("LIVE_REPAIR") == "" {
+		t.Skip("設 LIVE_REPAIR=1 才跑（會真的寫進知識庫）")
+	}
+	cypher := strings.TrimSpace(os.Getenv("LIVE_CYPHER"))
+	ns := strings.TrimSpace(os.Getenv("LIVE_NS"))
+	roots := strings.Split(os.Getenv("LIVE_ROOTS"), ",")
+	if cypher == "" || ns == "" || len(roots) == 0 {
+		t.Fatal("需要 LIVE_CYPHER / LIVE_NS / LIVE_ROOTS")
+	}
+	if strings.Contains(cypher, "leo21c") {
+		t.Fatal("紅線：不准打 leo21c")
+	}
+	for _, root := range roots {
+		root = strings.TrimSpace(root)
+		if root == "" {
+			continue
+		}
+		cfg := &DirectConfig{
+			CypherURL: strings.TrimSuffix(cypher, "/"), Namespace: ns, APIKey: ns,
+			CardIngestWF: "rag_ingest_card",
+			MachineLabel: os.Getenv("LIVE_MACHINE_LABEL"),
+			Manifest:     os.Getenv("LIVE_MANIFEST"), // 空＝機器身分不落檔，只在記憶體鑄
+		}
+		// 用一份**丟棄式**的 Manifest：修復的蓋章不寫進正在跑的 daemon 的帳本，
+		// 免得跟它搶同一個檔（daemon 之後自己會再跑一次，重推是取代不是疊加）。
+		m := &Manifest{Root: root, Entries: map[string]*ManifestEntry{}}
+		res := repairCardSourceBlocks(cfg, root, m, false, os.Getenv("LIVE_FORCE") != "", time.Now())
+		if res == nil {
+			t.Logf("%s：沒有需要修的卡", root)
+			continue
+		}
+		t.Logf("%s：掃 %d 份、本機重畫 %d 份、重推 %d 份、err=%q",
+			root, res.Scanned, res.Rewrote, res.Repushed, res.Err)
+		if res.Err != "" {
+			t.Errorf("%s 有失敗：%s", root, res.Err)
+		}
+	}
+}
@@ -0,0 +1,140 @@
+package collector
+
+import (
+	"encoding/json"
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+)
+
+const legacyCard = `---
+tags: [測試]
+gloss: 測試卡
+created: 2026-08-01
+updated: 2026-08-01
+---
+# 小果被AFTEE詐貸
+
+← [[00-INDEX]]
+
+## 摘要
+一段摘要。
+
+## 重點
+- 一條重點
+
+## 實體
+- **小果**（人物）— 當事人
+
+## 關聯
+### 內文知識關係
+- 小果 >` + `> 被詐貸 >` + `> AFTEE
+### 卡片關係
+- [[小果被AFTEE詐貸]] >` + `> 整理出 >` + `> [[貸款爭議]]
+### 出處
+- ` + "`../小果被AFTEE詐貸.pdf`" + ` >` + `> 提及 >` + `> 小果被AFTEE詐貸
+`
+
+// TestRepairCardSourceBlocks 驗既有資料的處置：舊形出處就地改寫＋原樣重推。
+// 這是票 `inkstone/Arcrun#167` 驗收條件「不能只修新的」的機械閘。
+func TestRepairCardSourceBlocks(t *testing.T) {
+	root := t.TempDir()
+	cardRel := "子資料夾/.wiki/小果被AFTEE詐貸.md"
+	if err := os.MkdirAll(filepath.Join(root, "子資料夾", ".wiki"), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(root, filepath.FromSlash(cardRel)), []byte(legacyCard), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	wm := &wikiManifest{Version: 1, Docs: []wikiDoc{{
+		Node: "子資料夾", Path: "小果被AFTEE詐貸.pdf", Status: "extracted",
+		Card: "小果被AFTEE詐貸", Cards: []string{cardRel},
+	}}}
+	if err := saveWikiManifest(root, wm); err != nil {
+		t.Fatal(err)
+	}
+
+	var got map[string]any
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		b, _ := io.ReadAll(r.Body)
+		_ = json.Unmarshal(b, &got)
+		w.Header().Set("Content-Type", "application/json")
+		_, _ = w.Write([]byte(`{"success":true}`))
+	}))
+	defer srv.Close()
+
+	cfg := &DirectConfig{
+		CypherURL: srv.URL, APIKey: "k", Namespace: "ns",
+		CardIngestWF: "rag_ingest_card",
+		MachineLabel: "教育部 Leo 的 Mac",
+	}
+	m := &Manifest{Root: root, Entries: map[string]*ManifestEntry{}}
+
+	res := repairCardSourceBlocks(cfg, root, m, false, false, time.Now())
+	if res == nil || res.Repushed != 1 {
+		t.Fatalf("沒有重推：%+v", res)
+	}
+
+	// ① 本機卡不再有內部相對路徑，且定位得到子資料夾。
+	fixed, err := os.ReadFile(filepath.Join(root, filepath.FromSlash(cardRel)))
+	if err != nil {
+		t.Fatal(err)
+	}
+	card := string(fixed)
+	if strings.Contains(card, "../") {
+		t.Fatalf("本機卡仍帶 `../`：\n%s", card)
+	}
+	if !strings.Contains(card, "子資料夾/小果被AFTEE詐貸.pdf") {
+		t.Fatalf("本機卡的出處定位不到子資料夾：\n%s", card)
+	}
+	if !strings.Contains(card, "教育部 Leo 的 Mac") {
+		t.Fatalf("本機卡的出處沒有機器標記：\n%s", card)
+	}
+	// ② 出處以外一字不動（重萃會讓內容變樣，就地修不會）。
+	if !strings.Contains(card, "## 摘要\n一段摘要。") || !strings.Contains(card, "- **小果**（人物）— 當事人") {
+		t.Fatalf("出處以外的內容被動到了：\n%s", card)
+	}
+
+	// ③ 送上雲的 payload 與 direct.go 送新卡時同一組欄位，且路徑是**庫內完整路徑**。
+	if got["path"] != "子資料夾/小果被AFTEE詐貸.pdf" {
+		t.Fatalf("重推的 path 不對：%v", got["path"])
+	}
+	if got["page_name"] != "小果被AFTEE詐貸" {
+		t.Fatalf("重推的 page_name 不對：%v", got["page_name"])
+	}
+	if s, _ := got["card_content"].(string); strings.Contains(s, "../") {
+		t.Fatalf("送上雲的卡片內容仍帶 `../`：\n%s", s)
+	}
+
+	// ④ 修完蓋章 ⇒ 不會每輪重掃、更不會每輪重推。
+	if m.SourceOriginRepairedAt == 0 {
+		t.Fatal("修完沒蓋章，會變成每輪都跑的背景工作")
+	}
+	got = nil
+	if again := repairCardSourceBlocks(cfg, root, m, false, false, time.Now()); again != nil {
+		t.Fatalf("蓋章後又跑了一次：%+v", again)
+	}
+	if got != nil {
+		t.Fatal("蓋章後又重推了一次")
+	}
+}
+
+// TestRewriteSourceBlockLeavesNewShapeAlone：已經是新形的卡不該被再動一次
+//（避免「每輪都改一點」讓使用者的檔案 mtime 無故跳動）。
+func TestRewriteSourceBlockLeavesNewShapeAlone(t *testing.T) {
+	o := SourceOrigin{MachineLabel: "m", Library: "kb", LibraryPath: "a/b.md"}
+	var b strings.Builder
+	renderSourceLine(&b, o, "卡")
+	card := "## 關聯\n### 卡片關係\n" + b.String()
+	if hasLegacySourceLine(card) {
+		t.Fatalf("新形被誤判成舊形：\n%s", card)
+	}
+	if rewriteSourceBlock(card, o, "卡") != card {
+		t.Fatal("新形卡被重寫了")
+	}
+}
@@ -0,0 +1,411 @@
+// stallguard.go — 一發等不到回覆的請求，不可以讓整台機器的同步停下來
+// （`inkstone/arcrun-rag#153`）。
+//
+// 一輪同步是**一條線**走完的：帳號 → 看守資料夾 → 一件件事。整條線上每一發
+// HTTP 都是同步的，所以只要其中一發停在那裡不回來，它後面的所有帳號、所有
+// 資料夾就一起停擺——而且是**安靜地**停擺：日誌只有開工那一行，畫面上的
+// 資料夾結構永遠停在上一版，沒有任何錯誤訊息。
+//
+// 為什麼不是「把 300 秒調小」：那只改變**卡多久**，沒改變「一發卡住就全停」。
+// 一個階段可以連續打二十發（見 sourcerepair.go 的 sourceRepairBatch），
+// 每發都等到超時的話，60 秒的上限一樣會把一輪拖成二十分鐘。
+//
+// 這支檔把「等待」變成三件有邊界、會說話的事：
+//
+//	① **每一發自己的上限**——按「這一發實際上在做什麼」給（會同步跑 AI 萃取的
+//	   那一發本來就慢，機械收口的那些不該也享有五分鐘），而且用 context 帶進
+//	   請求裡，不是只靠 client 那一把套用全部的總閘。
+//	② **同一個帳號連續等不到回覆 ⇒ 這一輪不再打它**（斷路器）。一發卡住的代價
+//	   從「整輪停擺」降成「這個帳號這一輪跳過」，其他帳號、其他資料夾照常跑完。
+//	③ **等待要有話說**——超過 stallNoticeEvery 就往 stdout 播一句
+//	   「哪個帳號、哪件事、等了多久」，並在收工時寫進 status.json。
+//	   靜默的等待跟當掉對使用者是同一件事。
+//
+// 🔴 播報用 `phase:"waiting"`，**不能沿用既有的兩種**：supervisor 把任何
+// 非 `start` 的 JSON 值都當成「一輪跑完了」（supervisor.go 的 decode 迴圈），
+// 沿用會讓托盤在同步途中跳回「看守中」——正是 t191 修掉的那個病。
+package collector
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"net"
+	"os"
+	"sync"
+	"time"
+)
+
+// callStep 描述「這一發網路呼叫在做什麼」。
+//
+// Name 會出現在日誌與畫面上，所以它是**產品文案**：講使用者認得的那件事，
+// 不出現 workflow 名、狀態碼、模型名。
+type callStep struct {
+	Name   string
+	Budget time.Duration
+}
+
+// 🔴 **每一個數字都是量出來的，不是推出來的**（2026-08-28 第三輪的教訓）。
+//
+// 第一輪我用「零 LLM 的機械收口應該很快」這個**推論**給了 60 秒，結果實測分佈是：
+//
+//	送出一份筆記   33.2 39.9 42.4 43.2 43.3 43.5 43.6 44.2 44.6 44.6
+//	              45.5 53.1 53.3 53.6 54.5 54.8 57.3 ← 真實尾巴到 57 秒
+//	              60.0 60.0 60.0 ← **這三個是我自己的上限把它剪斷**，不是雲端的耗時
+//
+// 後果不是「多等一下」：那 2 個被剪斷的檔判成 failed，斷路器跟著跳，
+// **後面 9 個檔全部被跳過**，而畫面對使用者說的是「知識庫現在沒有回應」
+// ——它一路都在回應，只是慢。**我的推論把一台健康的機器講成壞掉的。**
+//
+// ⇒ 判準改成：**上限只用來擋「真的不回來」，不用來表達「我認為它該多快」。**
+// 每一格都給實測最大值的數倍餘裕；要調它，先去量（`ARCRUN_TRACE=1`）。
+const (
+	// writeBudget＝任何會把知識寫進雲端的呼叫（收卡／直送萃取／萃取／修出處／下架／收回）。
+	// 實測最大 57.3 秒（送出一份筆記）⇒ 300 秒 ≈ 5 倍餘裕。
+	// 這也正是改版前 directHTTP 用的數字——事實證明它本來就沒選錯。
+	writeBudget = 300 * time.Second
+	// registerBudget＝只寫登記簿、不產生知識的呼叫（資料夾總覽／目錄索引／資料夾結構）。
+	// 實測 1.8〜26.3 秒 ⇒ 180 秒 ≈ 7 倍餘裕。
+	registerBudget = 180 * time.Second
+	// probeBudget＝「這台還活著嗎」的唯讀探問。實測 0.0〜1 秒。
+	// 它短是因為**它問的就是活著沒**，不是因為我覺得它該多快。
+	probeBudget = 20 * time.Second
+)
+
+var (
+	stepIngestDoc    = callStep{"整理一份文件", writeBudget}
+	stepIngestCard   = callStep{"送出一份筆記", writeBudget}
+	stepExtractDoc   = callStep{"請雲端讀一份文件", writeBudget}
+	stepRepairOrigin = callStep{"更新舊筆記的原文位置", writeBudget}
+	stepTakedown     = callStep{"把刪掉的檔案從雲端下架", writeBudget}
+	stepRetire       = callStep{"收回這個資料夾在雲端的資料", writeBudget}
+	stepFolderTree   = callStep{"回報資料夾結構", registerBudget}
+	stepInventory    = callStep{"送出資料夾總覽", registerBudget}
+	stepFolderCard   = callStep{"送出目錄索引", registerBudget}
+	// stepProbeAI＝每輪每個帳號的第一發（探測雲端 AI 通了沒）。它同時是最早
+	// 能認出「這個帳號今天不回應」的位置——認出來，這個帳號其餘的工作就都省了。
+	stepProbeAI = callStep{"確認雲端 AI 可不可以用", probeBudget}
+	// stepCloudAudit＝跟雲端核對「先前送過的檔案還在不在」。唯讀查詢，
+	// 一輪可能連打 cloudAuditBatch 發——正是「一發卡住的代價會被乘上批次大小」的例子。
+	stepCloudAudit = callStep{"跟雲端核對哪些檔案還在", probeBudget}
+)
+
+// stallNoticeEvery＝等多久開口說一次「還在等」。變數而非常數：測試要把它調快。
+var stallNoticeEvery = 30 * time.Second
+
+// stallStrikesBeforeSkip＝同一個帳號連續幾發等到超時，就這一輪不再打它。
+//
+// 為什麼是 2 而不是 1：一次偶發的逾時不該讓整個帳號這一輪停手。
+// 為什麼不是更多：每多一次就是多等一個 Budget，而這正是本票要砍掉的成本。
+var stallStrikesBeforeSkip = 2
+
+// StalledCall＝這一輪「等太久」的一件事，寫進 status.json 讓畫面講得出
+// 「哪個帳號、哪件事、等了多久」。
+type StalledCall struct {
+	Account   string `json:"account"`        // 知識庫網址的主機名（使用者在畫面上看得到的那個）
+	Step      string `json:"step"`           // 白話的「哪件事」
+	WaitedSec int    `json:"waited_sec"`     // 等了幾秒
+	Skipped   bool   `json:"skipped"`        // 這一輪之後不再打這個帳號
+	Note      string `json:"note,omitempty"` // 給使用者看的一句話
+}
+
+// accountStall＝某個帳號在這一輪的「等待帳」。
+type accountStall struct {
+	strikes int
+	answered bool   // 這一輪它**成功回應過** ⇒ 不准說它「沒有回應」
+	skip     string // 非空＝這一輪不再打它，內容是給使用者看的理由
+}
+
+// roundGuard 一輪一份，掛在 DirectConfig 上。
+// makeAccountSubConfig 的 `sub := *c` 會把這個**指標**一起帶過去
+// ⇒ 同一輪所有帳號、所有資料夾寫進同一份紀錄，斷路器才跨得了資料夾。
+type roundGuard struct {
+	mu       sync.Mutex
+	accounts map[string]*accountStall
+	stalls   []StalledCall
+	// announce＝把「還在等」播出去。測試會換掉它（預設寫 stdout）。
+	announce func(StalledCall)
+}
+
+func newRoundGuard() *roundGuard {
+	return &roundGuard{accounts: map[string]*accountStall{}, announce: announceStall}
+}
+
+// stdoutMu 保護 stdout 上的「一個 JSON 值」不被另一條 goroutine 插進去切成兩半。
+//
+// 🔴 為什麼非有不可：播報是在**另一條 goroutine** 上跑的，而每輪結束那筆
+// `phase:"done"` 可能有幾十 KB（results 逐筆展開）——超過管線的原子寫入大小之後，
+// 兩邊就會交錯。而 supervisor 的 json.Decoder 一旦讀到壞掉的值就
+// `io.Copy(io.Discard)` 跳出迴圈（supervisor.go）⇒ **那個行程接下來所有的
+// start／done 都不會再被看到**，托盤從此停在錯的狀態。
+// 機率很小，代價是整條狀態線靜默死掉——這種比例的東西要用鎖解決，不是賭。
+var stdoutMu sync.Mutex
+
+// printJSONLine 把一個值印成 stdout 上完整的一行（與播報共用同一把鎖）。
+func printJSONLine(v any) {
+	line, err := json.MarshalIndent(v, "", "  ")
+	if err != nil {
+		return
+	}
+	stdoutMu.Lock()
+	defer stdoutMu.Unlock()
+	_, _ = os.Stdout.Write(append(line, '\n'))
+}
+
+// announceStall 把一句「還在等」印成 stdout 上的一個 JSON 值。
+// 一次寫完整一個值：supervisor 那邊是 json.Decoder 逐值解，寫一半會炸掉整條線。
+func announceStall(s StalledCall) {
+	line, err := json.Marshal(struct {
+		At    string `json:"at"`
+		Phase string `json:"phase"`
+		StalledCall
+	}{time.Now().Format(time.RFC3339), "waiting", s})
+	if err != nil {
+		return // 播不出去也不能擋住本體
+	}
+	stdoutMu.Lock()
+	defer stdoutMu.Unlock()
+	_, _ = os.Stdout.Write(append(line, '\n'))
+}
+
+// skipReason 回「這個帳號這一輪已經被判定沒有回應」的白話理由；空＝照常打。
+func (g *roundGuard) skipReason(host string) string {
+	if g == nil {
+		return ""
+	}
+	g.mu.Lock()
+	defer g.mu.Unlock()
+	if a := g.accounts[host]; a != nil {
+		return a.skip
+	}
+	return ""
+}
+
+// Stalls 回這一輪等太久的清單（順序＝發生順序）。
+func (g *roundGuard) Stalls() []StalledCall {
+	if g == nil {
+		return nil
+	}
+	g.mu.Lock()
+	defer g.mu.Unlock()
+	return append([]StalledCall(nil), g.stalls...)
+}
+
+// succeeded 記一發「成功回來了」。
+//
+// 🔴 沒有這個函式的話，`strikes` 只增不減 ⇒ **一輪裡任意兩發逾時就會跳閘**，
+// 而訊息上寫的是「**連續** 2 件事都等不到回覆」——那兩個字就是假的。
+// 2026-08-28 實撞：一輪成功送出 8 份筆記、中間兩發被我自己過短的上限剪斷，
+// 斷路器就跳了，後面 9 個檔全被跳過。
+func (g *roundGuard) succeeded(host string) {
+	if g == nil {
+		return
+	}
+	g.mu.Lock()
+	defer g.mu.Unlock()
+	a := g.accounts[host]
+	if a == nil {
+		a = &accountStall{}
+		g.accounts[host] = a
+	}
+	a.answered = true
+	if a.skip == "" {
+		a.strikes = 0 // 已經跳閘就不再回頭；沒跳閘的話，成功一次就重新計數
+	}
+}
+
+// strike 記一發「等到超時」，必要時讓這個帳號這一輪停手。回傳給使用者看的那句話。
+func (g *roundGuard) strike(host string, step callStep, waited time.Duration) string {
+	g.mu.Lock()
+	a := g.accounts[host]
+	if a == nil {
+		a = &accountStall{}
+		g.accounts[host] = a
+	}
+	a.strikes++
+	// 🔴 **它這一輪回應過的話，就不准說它「沒有回應」。**
+	// 2026-08-28 實撞：youlin 一路都在回應（成功送出 8 份筆記），只是慢，
+	// 而畫面對使用者說「知識庫現在沒有回應」——那是把一台健康的機器講成壞掉的。
+	// 使用者會照著這句話去查網路、去重裝，全都白費。
+	how := "沒有回應"
+	if a.answered {
+		how = "回得太慢"
+	}
+	tripped := a.strikes >= stallStrikesBeforeSkip && a.skip == ""
+	if tripped {
+		a.skip = fmt.Sprintf(
+			"知識庫「%s」現在%s（連續 %d 件事都等不到回覆），這一輪先跳過它；"+
+				"其他資料夾照常同步，稍後會自動恢復。",
+			host, how, a.strikes)
+	}
+	// 🔴 結尾那句「稍後會自動恢復」不是修辭，它是 explainsWhySkipped 認得的識別字
+	// （sync_status.go）。少了它，這些被跳過的檔會**連一句原因都沒有地從畫面消失**。
+	// 有測試守著（TestSkipMessagesAlwaysExplainThemselves），改措辭前先看那條。
+	note := fmt.Sprintf("「%s」等了 %d 秒，知識庫「%s」%s；這一輪先跳過，"+
+		"其他資料夾照常同步，稍後會自動恢復。",
+		step.Name, int(waited.Seconds()), host, how)
+	g.stalls = append(g.stalls, StalledCall{
+		Account: host, Step: step.Name, WaitedSec: int(waited.Seconds()),
+		Skipped: tripped, Note: note,
+	})
+	announce, skip := g.announce, a.skip
+	g.mu.Unlock()
+
+	if announce != nil {
+		announce(StalledCall{Account: host, Step: step.Name,
+			WaitedSec: int(waited.Seconds()), Skipped: tripped, Note: note})
+	}
+	// 🔴 把連線池裡那條可能已經死掉的連線丟掉。
+	// 實撞的形狀（2026-08-28）：行程活著、CPU 0%、`lsof` 一條 TCP 都沒有，
+	// 而堆疊停在 HTTP/2 的 roundTrip——連線在作業系統那層已經沒了，
+	// 連線池裡的殼卻還在，後面每一發都會被指派到同一個殼上、一發一發地等到超時。
+	// 丟掉之後下一發會重新建立連線，而不是繼續排在一條死掉的連線後面。
+	directHTTP.CloseIdleConnections()
+
+	if skip != "" {
+		return skip
+	}
+	return note
+}
+
+// unreachableNote 回「這個帳號這一輪已經被判定沒有回應」的白話理由；空＝照常打。
+//
+// 呼叫端用它在**打之前**就掉頭，而不是打下去等到超時再說——那正是「一發卡住
+// 就整輪停擺」的成本來源：不掉頭的話，一個沒有回應的帳號會讓這一輪的每一件事
+// 各自再等一個 Budget。
+func (c *DirectConfig) unreachableNote() string {
+	return c.guard.skipReason(instanceHostOf(c.CypherURL))
+}
+
+// callGate＝一發網路呼叫的閘。用法（三行，缺一不可）：
+//
+//	gate := cfg.openGate(stepXxx)
+//	defer gate.release()                     // 停掉播報、放掉 context
+//	if note := gate.blocked(); note != "" { … 這一輪不再打這個帳號 … }
+//	… 真的去打 …
+//	if err != nil { return gate.record(err) } // 逾時才會被記帳，其餘原樣回
+type callGate struct {
+	g       *roundGuard
+	host    string
+	step    callStep
+	started time.Time
+	ctx     context.Context
+	cancel  context.CancelFunc
+	stop    chan struct{}
+	once    sync.Once
+	skip    string
+	// notice＝多久播報一次。**在 openGate 就抄成自己的一份**，播報那條 goroutine
+	// 不再去讀套件層的變數——那條 goroutine 的生命週期比呼叫端長一點點，
+	// 讀共用變數就是一個真的資料競爭（-race 抓到的）。
+	notice time.Duration
+}
+
+// openGate 開一發呼叫的閘。guard 為 nil（測試直接呼叫低層函式）時仍回一個可用的
+// 閘：有 context deadline、不記帳、不播報——「沒裝 guard」不該變成「沒有上限」。
+func (c *DirectConfig) openGate(step callStep) *callGate {
+	host := instanceHostOf(c.CypherURL)
+	gate := &callGate{g: c.guard, host: host, step: step, started: time.Now(),
+		stop: make(chan struct{}), notice: stallNoticeEvery}
+	if c.guard != nil {
+		gate.skip = c.guard.skipReason(host)
+	}
+	gate.ctx, gate.cancel = context.WithTimeout(context.Background(), step.Budget)
+	if gate.skip != "" {
+		return gate // 已經跳閘：不必播報，呼叫端會立刻回頭
+	}
+	go gate.keepTalking()
+	return gate
+}
+
+// keepTalking 在等待期間每隔 stallNoticeEvery 播一句「還在等」。
+// 這是本票驗收條件②：卡住的那一發要有話說，而不是靜默。
+func (gate *callGate) keepTalking() {
+	if gate.g == nil {
+		return
+	}
+	t := time.NewTicker(gate.notice)
+	defer t.Stop()
+	for {
+		select {
+		case <-gate.stop:
+			return
+		case now := <-t.C:
+			waited := int(now.Sub(gate.started).Seconds())
+			gate.g.mu.Lock()
+			announce := gate.g.announce
+			gate.g.mu.Unlock()
+			if announce != nil {
+				announce(StalledCall{
+					Account: gate.host, Step: gate.step.Name, WaitedSec: waited,
+					Note: fmt.Sprintf("還在等知識庫「%s」回覆「%s」，已經等了 %d 秒。",
+						gate.host, gate.step.Name, waited),
+				})
+			}
+		}
+	}
+}
+
+// blocked 回「這一輪已經不打這個帳號了」的理由；空＝可以打。
+func (gate *callGate) blocked() string { return gate.skip }
+
+// traceCalls＝把每一發的「哪件事／打誰／花了多久」印到 stderr（`ARCRUN_TRACE=1` 開）。
+//
+// 🔴 為什麼要留這個：2026-08-28 第一次修完之後，端到端症狀還在，而現場能拿到的只有
+// 一張 SIGQUIT 堆疊——堆疊只說得出「此刻卡在哪一發」，**說不出「這一輪的時間花到哪去了」**。
+// 兩個人為此各自推測了一輪。有這一行就不必推測：跑一次，時間分佈直接列出來。
+var traceCalls = os.Getenv("ARCRUN_TRACE") != ""
+
+func (gate *callGate) trace(outcome string) {
+	if !traceCalls {
+		return
+	}
+	fmt.Fprintf(os.Stderr, "[trace] %7.1fs  %-22s %-8s %s\n",
+		time.Since(gate.started).Seconds(), gate.step.Name, outcome, gate.host)
+}
+
+// release 停掉播報並放掉 context。**一定要 defer**：context 活到呼叫端讀完回應
+// 之後才釋放，所以不能在讀 body 之前呼叫。
+func (gate *callGate) release() {
+	gate.once.Do(func() { close(gate.stop); gate.trace("done") })
+	gate.cancel()
+}
+
+// ok 記一發成功（見 roundGuard.succeeded）。與 record 成對，兩者呼叫端都要顧到。
+func (gate *callGate) ok() { gate.g.succeeded(gate.host) }
+
+// record 記一發失敗。只有「等到超時」才進帳（連線被拒之類的錯是**很快**回來的，
+// 不是本票要修的病，記進去只會讓正常的斷網把帳號誤判成沒有回應）。
+// 回傳要交給呼叫端的錯誤：逾時換成白話，其餘原樣。
+//
+// 可以在 release 之後呼叫——它不碰 context。
+func (gate *callGate) record(err error) error {
+	if err == nil || !isStallError(err) {
+		return err
+	}
+	waited := time.Since(gate.started)
+	if gate.g == nil {
+		return fmt.Errorf("「%s」等了 %d 秒，知識庫「%s」沒有回應；稍後會自動恢復。",
+			gate.step.Name, int(waited.Seconds()), gate.host)
+	}
+	return errors.New(gate.g.strike(gate.host, gate.step, waited))
+}
+
+// isStallError 回答「這個錯誤是**等到超時**嗎」。
+//
+// 三種都要認得：我們自己的 context deadline、client.Timeout 包出來的
+// `*url.Error{Timeout:true}`、以及被 `%w` 包過好幾層之後的同一個東西
+//（萃取那條路會加上「連不上你的知識庫：」再包一層）。
+func isStallError(err error) bool {
+	if err == nil {
+		return false
+	}
+	if errors.Is(err, context.DeadlineExceeded) {
+		return true
+	}
+	var ne net.Error
+	if errors.As(err, &ne) && ne.Timeout() {
+		return true
+	}
+	return false
+}
@@ -0,0 +1,427 @@
+// stallguard_test.go — 「一發卡住就整輪停擺」這個形狀的網（`inkstone/arcrun-rag#153`）。
+//
+// 🔴 這裡測的**不是**「逾時設多久」。把 300 秒調小照樣過不了這幾條，因為病不在
+// 那個數字上：一個階段可以連續打二十發，每發都等到超時的話，上限設多小都會把
+// 一輪拖垮。這幾條驗的是**執行模型**：
+//
+//	① 一個帳號的端點不回應 ⇒ 另一個帳號、另一個資料夾照樣跑完一輪（驗收條件①）
+//	② 卡住的那一發要有話說：哪個帳號、哪件事、等了多久（驗收條件②）
+//	③ 一輪跑完 folder-trees.json 真的被重寫（驗收條件③）——這是使用者眼中
+//	   「畫面永遠停在上一版」的那一格
+package collector
+
+import (
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"path/filepath"
+	"strings"
+	"sync"
+	"testing"
+	"time"
+)
+
+// stallTestTimings 把等待相關的旋鈕調成測試尺度，回傳復原函式。
+// 調的是「等多久算久」，不是「有沒有上限」——上限的存在本身才是被測的東西。
+func stallTestTimings(t *testing.T, budget, notice time.Duration) {
+	t.Helper()
+	oldPlain, oldLLM := stepIngestCard, stepIngestDoc
+	oldRepair, oldTree, oldInv, oldCard := stepRepairOrigin, stepFolderTree, stepInventory, stepFolderCard
+	oldExtract, oldTakedown, oldRetire := stepExtractDoc, stepTakedown, stepRetire
+	oldProbe, oldAudit := stepProbeAI, stepCloudAudit
+	oldNotice := stallNoticeEvery
+	// 🔴 **每一個** step 都要調到——漏掉一個，那一個就是新的瓶頸。
+	// 這不是測試的細節，是本票的形狀本身：2026-08-28 第一版就是這樣，斷路器
+	// 明明跳了，一輪還是要 20 秒，因為漏掉了每輪第一發的探測。
+	for _, s := range []*callStep{
+		&stepIngestCard, &stepIngestDoc, &stepRepairOrigin, &stepFolderTree,
+		&stepInventory, &stepFolderCard, &stepExtractDoc, &stepTakedown, &stepRetire,
+		&stepProbeAI, &stepCloudAudit,
+	} {
+		s.Budget = budget
+	}
+	stallNoticeEvery = notice
+	t.Cleanup(func() {
+		stepIngestCard, stepIngestDoc = oldPlain, oldLLM
+		stepRepairOrigin, stepFolderTree, stepInventory, stepFolderCard = oldRepair, oldTree, oldInv, oldCard
+		stepExtractDoc, stepTakedown, stepRetire = oldExtract, oldTakedown, oldRetire
+		stepProbeAI, stepCloudAudit = oldProbe, oldAudit
+		stallNoticeEvery = oldNotice
+	})
+}
+
+// 一個永遠不回應的知識庫（把請求放進黑洞，直到測試結束）。
+func blackHoleServer(t *testing.T) *httptest.Server {
+	t.Helper()
+	done := make(chan struct{})
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		select {
+		case <-done:
+		case <-r.Context().Done(): // 呼叫端自己放棄了＝正是我們要的行為
+		}
+	}))
+	t.Cleanup(func() { close(done); srv.Close() })
+	return srv
+}
+
+// 一個正常回應的知識庫，順便數它被打過幾次。
+func countingServer(t *testing.T, hits *int) *httptest.Server {
+	t.Helper()
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		*hits++
+		_ = json.NewEncoder(w).Encode(map[string]any{"success": true})
+	}))
+	t.Cleanup(srv.Close)
+	return srv
+}
+
+// ① 一個帳號的端點不回應，另一個帳號照樣跑完一輪；而且整輪的時間有上限。
+//
+// 沒有這道閘之前的行為：第一個帳號的第一發 POST 停在那裡不回來，
+// 第二個帳號一次都不會被碰到，folder-trees.json 也永遠不會被重寫。
+func TestOneDeadAccountDoesNotStopTheRound(t *testing.T) {
+	stallTestTimings(t, 300*time.Millisecond, 50*time.Millisecond)
+
+	origFetch := fetchCloudVersion
+	fetchCloudVersion = func(string) (string, bool) { return "", false }
+	defer func() { fetchCloudVersion = origFetch }()
+
+	dead := blackHoleServer(t)
+	liveHits := 0
+	live := countingServer(t, &liveHits)
+
+	deadRoot, liveRoot := t.TempDir(), t.TempDir()
+	for _, r := range []string{deadRoot, liveRoot} {
+		if err := os.WriteFile(filepath.Join(r, "note.md"), []byte("# 一份筆記\n內容"), 0o644); err != nil {
+			t.Fatal(err)
+		}
+	}
+
+	manifestPath := filepath.Join(t.TempDir(), "m.json")
+	cfg := &DirectConfig{
+		Manifest: manifestPath,
+		Accounts: []AccountConfig{
+			{CypherURL: dead.URL, Namespace: "dead", APIKey: "k", WatchFolders: []string{deadRoot}},
+			{CypherURL: live.URL, Namespace: "live", APIKey: "k", WatchFolders: []string{liveRoot}},
+		},
+		Library: "kb", MaxRemoved: DefaultMaxRemovedRatio,
+		// 萃取那條路不是這條測試的題目：這裡驗的是「不回應的端點會不會把整輪鎖住」。
+		// 空 Extractor＝走原文直送（rag_ingest_direct），一樣是打同一批端點。
+		CardIngestWF: "rag_ingest_card", IngestWF: "rag_ingest_direct", RemovedWF: "rag_takedown_direct",
+		ForceSync: true,
+	}
+
+	start := time.Now()
+	results, _, _ := RunDirectOnce(cfg, false)
+	elapsed := time.Since(start)
+
+	// 🔴 核心：一輪要跑得完，而且時間跟「壞掉的那個帳號有幾件事要做」無關。
+	// 上限抓得寬（真實情境下每發 300ms × 斷路器 2 次 ＋ 活著那邊的工作），
+	// 但遠小於「每一發都各等一次」的量級——沒有斷路器時這裡會是好幾秒起跳。
+	if elapsed > 5*time.Second {
+		t.Fatalf("🔴 一輪花了 %v——一發等不到回覆就把整輪拖住了，正是本票要修的形狀", elapsed)
+	}
+
+	// 活著的那個帳號真的被服務到了（不是「兩個都被跳過所以很快」）。
+	if liveHits == 0 {
+		t.Fatalf("🔴 活著的帳號一次都沒被打到——壞掉的那個把整輪吃光了\nresults=%+v", results)
+	}
+
+	// 斷路器要真的跳過：同一個帳號不該被逐檔、逐階段各等一次。
+	stalls := cfg.guard.Stalls()
+	if len(stalls) == 0 {
+		t.Fatalf("🔴 等了那麼久卻一句話都沒說——使用者會看到「開著、沒錯誤、不動」")
+	}
+	tripped := false
+	for _, s := range stalls {
+		if s.Skipped {
+			tripped = true
+		}
+	}
+	if !tripped {
+		t.Fatalf("🔴 沒有任何一筆標成「這一輪跳過這個帳號」，斷路器沒生效：%+v", stalls)
+	}
+	if len(stalls) > 4 {
+		t.Fatalf("🔴 等了 %d 次才停手——斷路器該在 %d 次就跳，不然一輪還是會被拖垮：%+v",
+			len(stalls), stallStrikesBeforeSkip, stalls)
+	}
+}
+
+// ② 卡住的那一發要講得出「哪個帳號、哪件事、等了多久」。
+func TestStallSaysWhichAccountWhichStepHowLong(t *testing.T) {
+	stallTestTimings(t, 300*time.Millisecond, 50*time.Millisecond)
+
+	dead := blackHoleServer(t)
+	// 🔴 播報會從**兩條** goroutine 進來（等待期間那條、以及記帳時呼叫端那條），
+	// 所以收集它的地方自己要上鎖——這不是測試的潔癖，是 -race 抓出來的真實併發。
+	var mu sync.Mutex
+	var said []StalledCall
+	g := newRoundGuard()
+	g.announce = func(s StalledCall) { mu.Lock(); said = append(said, s); mu.Unlock() }
+
+	cfg := &DirectConfig{CypherURL: dead.URL, Namespace: "n", APIKey: "k", guard: g}
+	_, _, err := cfg.postJSON(stepRepairOrigin, dead.URL+"/x", map[string]any{"a": 1})
+	if err == nil {
+		t.Fatal("端點不回應卻回了 nil error")
+	}
+
+	// 播報：等待期間就要開口，不是等到最後才說。
+	mu.Lock()
+	saidCount := len(said)
+	mu.Unlock()
+	if saidCount == 0 {
+		t.Fatal("🔴 等待期間一句話都沒播——靜默的等待跟當掉對使用者是同一件事")
+	}
+	host := instanceHostOf(dead.URL)
+	mu.Lock()
+	snapshot := append([]StalledCall(nil), said...)
+	mu.Unlock()
+	for _, s := range snapshot {
+		if s.Account != host {
+			t.Fatalf("沒講是哪個帳號：%+v（want %s）", s, host)
+		}
+		if s.Step != stepRepairOrigin.Name {
+			t.Fatalf("沒講是哪件事：%+v（want %s）", s, stepRepairOrigin.Name)
+		}
+	}
+	// 交給呼叫端的錯誤是產品文案：講哪件事、等多久、他會怎樣，不出現狀態碼／內部名詞。
+	msg := err.Error()
+	if !strings.Contains(msg, stepRepairOrigin.Name) {
+		t.Fatalf("錯誤訊息沒講是哪件事：%s", msg)
+	}
+	// 🔴 不再寫死「會自動恢復」這幾個字——改用產生端與消費端**共用**的那個判準。
+	// 寫死字串正是第三輪的病：我改了措辭，兩邊就對不上了（見 explainsWhySkipped）。
+	if !explainsWhySkipped(msg) {
+		t.Fatalf("🔴 這句話不會被 status.json 收進失敗清單 ⇒ 畫面上會沒有原因：%s", msg)
+	}
+	for _, banned := range []string{"context deadline", "HTTP", "timeout", "Client.Timeout"} {
+		if strings.Contains(msg, banned) {
+			t.Fatalf("🔴 錯誤訊息漏出內部語彙「%s」：%s", banned, msg)
+		}
+	}
+}
+
+// ②之二：等太久的事要寫進 status.json，畫面才有東西可以講。
+func TestStallsLandInStatusJSON(t *testing.T) {
+	stallTestTimings(t, 200*time.Millisecond, 50*time.Millisecond)
+
+	origFetch := fetchCloudVersion
+	fetchCloudVersion = func(string) (string, bool) { return "", false }
+	defer func() { fetchCloudVersion = origFetch }()
+
+	dead := blackHoleServer(t)
+	root := t.TempDir()
+	if err := os.WriteFile(filepath.Join(root, "note.md"), []byte("# 一份筆記\n內容"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	manifestPath := filepath.Join(t.TempDir(), "m.json")
+	cfg := &DirectConfig{
+		Manifest: manifestPath,
+		Accounts: []AccountConfig{{CypherURL: dead.URL, Namespace: "n", APIKey: "k",
+			WatchFolders: []string{root}}},
+		Library: "kb", MaxRemoved: DefaultMaxRemovedRatio,
+		CardIngestWF: "rag_ingest_card", IngestWF: "rag_ingest_direct", RemovedWF: "rag_takedown_direct",
+		ForceSync: true,
+	}
+	RunDirectOnce(cfg, false)
+
+	st, err := LoadSyncStatus(StatusFilePath(manifestPath))
+	if err != nil {
+		t.Fatalf("讀 status.json 失敗：%v", err)
+	}
+	if len(st.Stalls) == 0 {
+		t.Fatal("🔴 status.json 沒有 stalls——畫面上就只剩「開著、沒錯誤、什麼都不動」")
+	}
+	s := st.Stalls[0]
+	if s.Account == "" || s.Step == "" || s.Note == "" {
+		t.Fatalf("三件事要講齊（哪個帳號／哪件事／人話）：%+v", s)
+	}
+}
+
+// ③ 一輪跑完，folder-trees.json 真的被重寫——即使雲端那邊完全不回應。
+//
+// 這一格就是使用者實際撞到的症狀：畫面上的資料夾結構永遠停在上一版。
+// 樹是**本機算出來的**，不該因為送不上雲端就連本機那份都不寫。
+func TestFolderTreeStoreRewrittenEvenWhenCloudNeverAnswers(t *testing.T) {
+	stallTestTimings(t, 200*time.Millisecond, 50*time.Millisecond)
+
+	origFetch := fetchCloudVersion
+	fetchCloudVersion = func(string) (string, bool) { return "", false }
+	defer func() { fetchCloudVersion = origFetch }()
+
+	dead := blackHoleServer(t)
+	root := t.TempDir()
+	for _, d := range []string{"a", "b", "c"} {
+		if err := os.MkdirAll(filepath.Join(root, d), 0o755); err != nil {
+			t.Fatal(err)
+		}
+		if err := os.WriteFile(filepath.Join(root, d, "n.md"), []byte("# n\n內容"), 0o644); err != nil {
+			t.Fatal(err)
+		}
+	}
+	manifestPath := filepath.Join(t.TempDir(), "m.json")
+	cfg := &DirectConfig{
+		Manifest: manifestPath,
+		Accounts: []AccountConfig{{CypherURL: dead.URL, Namespace: "n", APIKey: "k",
+			WatchFolders: []string{root}}},
+		Library: "kb", MaxRemoved: DefaultMaxRemovedRatio,
+		CardIngestWF: "rag_ingest_card", IngestWF: "rag_ingest_direct", RemovedWF: "rag_takedown_direct",
+		ForceSync: true,
+	}
+	RunDirectOnce(cfg, false)
+
+	treePath := FolderTreeStorePath(manifestPath)
+	store, err := LoadFolderTreeStore(treePath)
+	if err != nil {
+		t.Fatalf("🔴 一輪跑完卻沒有 folder-trees.json：%v", err)
+	}
+	tree, ok := store.Trees[root]
+	if !ok {
+		t.Fatalf("快照裡沒有這個根：%+v", store.Trees)
+	}
+	if len(tree.Nodes) < 4 { // 根 + a/b/c
+		t.Fatalf("🔴 樹只有 %d 個節點（該有根＋三個子資料夾）：%+v", len(tree.Nodes), tree.Nodes)
+	}
+
+	// 再跑一輪，mtime 要往前走——「畫面永遠停在上一版」的反面就是這一格。
+	before, err := os.Stat(treePath)
+	if err != nil {
+		t.Fatal(err)
+	}
+	time.Sleep(20 * time.Millisecond)
+	RunDirectOnce(cfg, false)
+	after, err := os.Stat(treePath)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !after.ModTime().After(before.ModTime()) {
+		t.Fatalf("🔴 第二輪沒有重寫 folder-trees.json（%v → %v）", before.ModTime(), after.ModTime())
+	}
+}
+
+// 連線被拒（很快就回來的錯）不該被當成「等太久」——
+// 把它記進斷路器的話，正常的斷網會讓帳號被誤判成沒有回應。
+func TestFastFailureIsNotCountedAsStall(t *testing.T) {
+	stallTestTimings(t, 2*time.Second, 50*time.Millisecond)
+
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {}))
+	url := srv.URL
+	srv.Close() // 關掉 ⇒ 連線立刻被拒
+
+	g := newRoundGuard()
+	g.announce = func(StalledCall) {}
+	cfg := &DirectConfig{CypherURL: url, Namespace: "n", APIKey: "k", guard: g}
+	if _, _, err := cfg.postJSON(stepIngestCard, url+"/x", map[string]any{}); err == nil {
+		t.Fatal("連不上卻回 nil error")
+	}
+	if len(g.Stalls()) != 0 {
+		t.Fatalf("🔴 立刻失敗被記成「等太久」：%+v", g.Stalls())
+	}
+	if g.skipReason(instanceHostOf(url)) != "" {
+		t.Fatal("🔴 一次連線被拒就把整個帳號停掉了——那是把斷網懲罰成停機")
+	}
+}
+
+// 沒裝 guard（低層函式被單獨呼叫）時仍然要有上限——
+// 「沒裝閘」不可以等於「沒有上限」，那是這條線最初出事的樣子。
+func TestGateAlwaysHasADeadlineEvenWithoutGuard(t *testing.T) {
+	stallTestTimings(t, 200*time.Millisecond, 50*time.Millisecond)
+
+	dead := blackHoleServer(t)
+	cfg := &DirectConfig{CypherURL: dead.URL, Namespace: "n", APIKey: "k"} // guard == nil
+	start := time.Now()
+	_, _, err := cfg.postJSON(stepIngestCard, dead.URL+"/x", map[string]any{})
+	if err == nil {
+		t.Fatal("端點不回應卻回了 nil error")
+	}
+	if el := time.Since(start); el > 2*time.Second {
+		t.Fatalf("🔴 沒有 guard 就沒有上限了（等了 %v）", el)
+	}
+}
+
+// 🔴 慢但**成功**的雲端，不准被講成「沒有回應」，也不准害後面的檔被跳過。
+//
+// 這一條是 2026-08-28 第三輪的實撞：`送出一份筆記` 實測 33〜57 秒，而我第一輪
+// 憑「零 LLM 應該很快」的**推論**給了 60 秒上限 ⇒ 尾巴被剪斷 2 發 ⇒ 斷路器跳 ⇒
+// **後面 9 個檔全被跳過**，畫面還對使用者說「知識庫現在沒有回應」。
+// 那台知識庫一路都在回應（同一輪成功送出 8 份筆記），只是慢。
+func TestSlowButSucceedingCloudIsNotCalledUnresponsive(t *testing.T) {
+	// 上限給 2 秒，伺服器每發 300ms——**遠低於上限**，就是「慢但會成功」。
+	stallTestTimings(t, 2*time.Second, 50*time.Millisecond)
+
+	origFetch := fetchCloudVersion
+	fetchCloudVersion = func(string) (string, bool) { return "", false }
+	defer func() { fetchCloudVersion = origFetch }()
+
+	var hits int64
+	slow := slowButHealthyServer(t, 300*time.Millisecond, &hits)
+
+	root := t.TempDir()
+	for i := range [8]struct{}{} {
+		name := filepath.Join(root, "note"+string(rune('a'+i))+".md")
+		if err := os.WriteFile(name, []byte("# 筆記\n內容"), 0o644); err != nil {
+			t.Fatal(err)
+		}
+	}
+	manifestPath := filepath.Join(t.TempDir(), "m.json")
+	cfg := &DirectConfig{
+		Manifest: manifestPath,
+		Accounts: []AccountConfig{{CypherURL: slow.URL, Namespace: "n", APIKey: "k",
+			WatchFolders: []string{root}}},
+		Library: "kb", MaxRemoved: DefaultMaxRemovedRatio,
+		CardIngestWF: "rag_ingest_card", IngestWF: "rag_ingest_direct", RemovedWF: "rag_takedown_direct",
+		ForceSync: true,
+	}
+	results, _, _ := RunDirectOnce(cfg, false)
+
+	// ① 斷路器不准跳：它一路都在回應。
+	if note := cfg.unreachableNote(); note != "" {
+		t.Fatalf("🔴 慢但成功的雲端被判成不能打了：%s", note)
+	}
+	for _, s := range cfg.guard.Stalls() {
+		if s.Skipped {
+			t.Fatalf("🔴 有一筆標成「這一輪跳過該帳號」：%+v", s)
+		}
+	}
+
+	// ② 一個檔都不准被「帳號沒回應」這個理由跳過。
+	skipped := 0
+	for _, r := range results {
+		if r.Status == "skipped" && (strings.Contains(r.Error, "沒有回應") ||
+			strings.Contains(r.Error, "回得太慢")) {
+			skipped++
+		}
+	}
+	if skipped > 0 {
+		t.Fatalf("🔴 有 %d 個檔因為「帳號沒回應」被跳過，但雲端每一發都成功了", skipped)
+	}
+
+	// ③ 就算真的有一發逾時，只要它這一輪回應過，措辭就不准是「沒有回應」。
+	g := newRoundGuard()
+	g.announce = func(StalledCall) {}
+	g.succeeded("h")
+	msg := g.strike("h", stepIngestCard, 3*time.Second)
+	if strings.Contains(msg, "沒有回應") {
+		t.Fatalf("🔴 它回應過，卻還是說「沒有回應」：%s", msg)
+	}
+	if !strings.Contains(msg, "回得太慢") {
+		t.Fatalf("措辭應該是「回得太慢」：%s", msg)
+	}
+}
+
+// 「連續」兩個字必須是真的：成功一次就把計數歸零。
+func TestStrikesAreActuallyConsecutive(t *testing.T) {
+	g := newRoundGuard()
+	g.announce = func(StalledCall) {}
+	g.strike("h", stepIngestCard, time.Second) // 第 1 次逾時
+	g.succeeded("h")                           // 中間成功了一次
+	g.strike("h", stepIngestCard, time.Second) // 又逾時一次 ⇒ 這是「第 1 次連續」
+	if r := g.skipReason("h"); r != "" {
+		t.Fatalf("🔴 中間成功過，卻仍然跳閘了——訊息裡的「連續」是假的：%s", r)
+	}
+	g.strike("h", stepIngestCard, time.Second) // 真的連續第 2 次 ⇒ 才該跳
+	if g.skipReason("h") == "" {
+		t.Fatal("真的連續兩次逾時了，該跳閘卻沒跳")
+	}
+}
@@ -14,6 +14,7 @@ import (
 	"bufio"
 	"context"
 	"encoding/json"
+	"fmt"
 	"io"
 	"os"
 	"os/exec"
@@ -46,12 +47,23 @@ type Status struct {
 	Rounds      int       // 累計掃描輪數
 	Restarts    int       // 累計重起次數
 	LastError   string    // 最近一次錯誤（stderr 末行 / 退出原因）
+	// Waiting＝正在等某一發雲端回覆的白話說明（`inkstone/arcrun-rag#153`）。
+	// 空＝沒有人在等。它不是錯誤——所以不寫進 LastError（那一格會被診斷檔
+	// 當成「出事了」帶出去，見 diagnostics_export.go 的 engineLastErrorFor）。
+	Waiting string
 }

 // round 對應 collector direct 每輪印到 stdout 的 JSON（見 direct.go runOne）。
 type round struct {
 	At    string `json:"at"`
 	Phase string `json:"phase"` // t191："start"（開工）／"done"（跑完）；舊版沒有此欄＝空
+	// `inkstone/arcrun-rag#153`："waiting"＝這一發等太久了，還沒跑完。
+	// 🔴 它**不是**一輪的結束：下面的 decode 迴圈把任何非 start 的值都當成
+	// 「跑完了」，不特別認得它的話，托盤會在同步途中跳回「看守中」——
+	// 正是 t191 修掉的那個病（「看起來好像就做完了」）。
+	Account   string `json:"account,omitempty"`    // 哪個知識庫帳號
+	Step      string `json:"step,omitempty"`       // 哪件事（白話）
+	WaitedSec int    `json:"waited_sec,omitempty"` // 等了幾秒

 	Folder  string            `json:"folder"`
 	Results []json.RawMessage `json:"results"`
@@ -327,11 +339,21 @@ func (s *Supervisor) runOnce(ctx context.Context) error {
 		at := parseAt(r.At)
 		if r.Phase == "start" {
 			// t191：開工 → 顯示「同步中…」。不累加 Rounds（那是「完成幾輪」）。
-			s.setState(func(st *Status) { st.State = StateSyncing })
+			s.setState(func(st *Status) { st.State = StateSyncing; st.Waiting = "" })
+			continue
+		}
+		if r.Phase == "waiting" {
+			// #153：還在等某一發回覆 ⇒ 仍在同步中，**不算跑完一輪**。
+			// 把「哪個帳號、哪件事、等了多久」留在狀態上，托盤才講得出來
+			// ——不然使用者看到的就是「開著、沒有錯誤、什麼都不動」。
+			note := fmt.Sprintf("正在等「%s」回覆「%s」，已經等了 %d 秒",
+				r.Account, r.Step, r.WaitedSec)
+			s.setState(func(st *Status) { st.State = StateSyncing; st.Waiting = note })
 			continue
 		}
 		s.setState(func(st *Status) {
 			st.State = StateWatching
+			st.Waiting = "" // 跑完了＝沒有人在等，別讓上一輪的等待訊息留在畫面上
 			st.Rounds++
 			if !at.IsZero() {
 				st.LastRoundAt = at
@@ -6,6 +6,7 @@ import (
 	"encoding/json"
 	"os"
 	"path/filepath"
+	"strings"
 )

 // AccountSyncStatus 彙總單一帳號的每輪同步結果（t104 多帳號看守）。
@@ -104,6 +105,23 @@ type SyncStatus struct {
 	// 與 Retiring 同族的現況快照，見 ResyncStatus 註解。
 	Resync map[string]ResyncStatus `json:"resync,omitempty"`

+	// FolderProgress＝**逐個看守資料夾**的同步現況（key＝資料夾路徑，`inkstone/arcrun-rag#159`）。
+	//
+	// 🔴 為什麼要有：小幫手畫面上每個資料夾都要能一眼看出「同步了沒」，而在這之前
+	// 那一格唯一的資料來源是 #140 的補送說明——**它只在有補送的時候才有值**，
+	// 於是畫面只好拿「有沒有那句話」當狀態。2026-08-28 leo 看到七列有六列寫「補送中」，
+	// 連 pending 已經是 0 的也照樣寫（實測 youlinhsieh-test1：pending=0／repaired=2，
+	// 畫面仍標補送中）——那個標籤量的根本不是同步狀態。
+	//
+	// 🔴 **不另算一套**：值就是 (*Manifest).Progress() 的原件，與首頁那行大數字、
+	// 診斷檔用同一個函式。逐資料夾加起來會等於首頁總量，因為它們本來就是同一組
+	// 數字被切開，不是兩份實作。
+	//
+	// 與 FolderPlans 同族的現況快照；某一輪那個根沒掃成（payload 為 nil）時**沿用
+	// 上一輪**，不要讓使用者看到昨天還好好的資料夾突然沒有狀態
+	// （同 MergeFolderTreeStore ② 的理由）。
+	FolderProgress map[string]SyncProgress `json:"folder_progress,omitempty"`
+
 	// 🔴 G-6.2「不准安靜地略過」（2026-08-06）：副檔名不在 allowedExt 的檔案，
 	// 以前在 scan.go 的白名單閘就 `return nil` 蒸發了——沒事件、沒紀錄、沒畫面。
 	// 使用者丟一份 .doc 進資料夾，得到的回應是**完全的沉默**。
@@ -140,6 +158,17 @@ type SyncStatus struct {
 	// 不會被清成 0（現況快照，不是本輪計數）。
 	Progress         SyncProgress     `json:"progress"`
 	FailureBreakdown FailureBreakdown `json:"failure_breakdown"`
+
+	// Stalls＝這一輪「等太久」的事（`inkstone/arcrun-rag#153`）。
+	//
+	// 為什麼要有這一格：2026-08-28 實撞的畫面是**小幫手開著、沒有錯誤訊息、
+	// 什麼都不動**——同步停在一發等不到回覆的請求上，而使用者看得到的每一個
+	// 數字都還是上一輪的。**靜默的等待跟當掉對使用者是同一件事**，
+	// 所以「哪個帳號、哪件事、等了多久」要有地方講。
+	//
+	// 與 SkippedDocs 同族：每輪重算的現況快照，不進 CarryForwardActivity
+	//（上一輪等太久不代表這一輪也在等，帶下來就會變成一個永遠擦不掉的警告）。
+	Stalls []StalledCall `json:"stalls,omitempty"`
 }

 // FolderPlanStatus＝某個看守資料夾這一輪用了什麼收檔策略、據此少收了什麼
@@ -227,3 +256,28 @@ func LoadSyncStatus(path string) (SyncStatus, error) {
 func SyncNowSignalPath(manifestPath string) string {
 	return filepath.Join(filepath.Dir(manifestPath), "sync-now")
 }
+
+// explainsWhySkipped 回答：「這一則 `skipped` 的訊息，講得出**為什麼**嗎？」
+// 講得出 ⇒ 收進 status.json 的失敗清單，畫面才有原因可講；講不出 ⇒ 不佔畫面。
+//
+// 🔴 為什麼要抽成具名函式（`inkstone/arcrun-rag#153` 第三輪，2026-08-28 差點實撞）：
+// 這個判準本來是**寫死在 direct.go 裡的三個字串比對**，而產生那些訊息的地方在別的檔。
+// 我改了斷路器的措辭（「會自動恢復」→「稍後會自動再試」），兩邊當場對不上——
+// 後果不是報錯，是**那 9 個被跳過的檔會連一句原因都沒有地從畫面上消失**，
+// 正是這個 repo 一再修的「安靜地略過」。
+//
+// 抽成一個函式解不掉「字串比對很脆」這件事，但它解掉了**兩邊會各自漂走**：
+// 現在只有一個地方定義「講得出原因」，而且有測試守著（sync_status_test.go）。
+// 新增訊息時，讓它通過這個函式，或把新的識別字加在這裡——不要在別處另開一張表。
+func explainsWhySkipped(msg string) bool {
+	for _, mark := range []string{
+		"後重試",     // 退避中：「上次失敗（第 N 次），X 後重試」
+		"已暫停自動重試", // 連續失敗到上限
+		"會自動恢復",   // 額度冷卻／帳號暫時打不通，之後自己會好
+	} {
+		if strings.Contains(msg, mark) {
+			return true
+		}
+	}
+	return false
+}
@@ -5,7 +5,9 @@ import (
 	"os"
 	"path/filepath"
 	"runtime"
+	"strings"
 	"testing"
+	"time"
 )

 // ── FindClaudeBin fallback（t92）──────────────────────────────────────────────
@@ -268,3 +270,46 @@ func TestCarryForwardActivity(t *testing.T) {
 		}
 	})
 }
+
+// 🔴 產生訊息的那一端，和決定「這則訊息要不要上畫面」的那一端，必須永遠對得上。
+//
+// 2026-08-28 第三輪差點實撞：我改了斷路器的措辭，判準沒跟著改 ⇒ 那 9 個被跳過的檔
+// 會**連一句原因都沒有地從畫面消失**。不會報錯、不會有紅字，就是安靜地不見。
+// 這條網把兩端綁在一起：斷路器講的每一種話，都要能被 explainsWhySkipped 認得。
+func TestSkipMessagesAlwaysExplainThemselves(t *testing.T) {
+	g := newRoundGuard()
+	g.announce = func(StalledCall) {}
+
+	// ① 從沒回應過的帳號（措辭：沒有回應）
+	first := g.strike("dead.example", stepIngestCard, 60*time.Second)
+	// ② 連續第二次 ⇒ 跳閘，這句會被貼在每一個被跳過的檔上
+	tripped := g.strike("dead.example", stepIngestCard, 60*time.Second)
+	// ③ 回應過、只是慢的帳號（措辭：回得太慢）
+	g.succeeded("slow.example")
+	slow := g.strike("slow.example", stepIngestCard, 60*time.Second)
+
+	for name, msg := range map[string]string{
+		"第一次逾時":   first,
+		"跳閘（貼在被跳過的檔上）": tripped,
+		"回得太慢":    slow,
+	} {
+		if msg == "" {
+			t.Fatalf("%s：訊息是空的", name)
+		}
+		if !explainsWhySkipped(msg) {
+			t.Fatalf("🔴 %s 的訊息不會被 status.json 收進失敗清單 ⇒ "+
+				"畫面上那些檔會沒有任何原因地消失。\n訊息：%s", name, msg)
+		}
+		// 產品文案：不准漏出內部語彙
+		for _, banned := range []string{"HTTP", "context", "timeout", "goroutine", "token"} {
+			if strings.Contains(msg, banned) {
+				t.Fatalf("🔴 %s 漏出內部語彙「%s」：%s", name, banned, msg)
+			}
+		}
+	}
+
+	// 反面：一句不講原因的話，不該被收進去（不然畫面會被噪音塞滿）
+	if explainsWhySkipped("跳過") {
+		t.Fatal("不講原因的訊息不該被當成「講得出原因」")
+	}
+}
@@ -27,10 +27,21 @@ func TestTemplateFilesAreNotKnowledge(t *testing.T) {
 			t.Fatal(err)
 		}
 	}
-	// template 的東西（**沒有隱藏**）
-	write("CLAUDE.md", "開發用設定")
-	write("scripts/sdd-active-check.sh", "#!/bin/sh")
-	write("system-dev/wiki/status.md", "開發用 wiki")
+	// template 的東西（**沒有隱藏**）。
+	// 🔴 2026-08-28（inkstone/Arcrun#180）：內容改成從內嵌快照原樣鋪出來，
+	//    不再自己捏一段假字串——判準已經從「路徑前綴」換成「內容與原版逐字相同」
+	//    （templateuntouched.go），假內容就不是範本空殼，那是使用者寫的東西。
+	//    這也讓這支測試更貼近它要守的事故：**daemon 自己鋪下去的那份**不該被自己吃掉。
+	fromSnapshot := func(rel string) string {
+		data, err := templateFS.ReadFile(templateFSRoot + "/" + rel)
+		if err != nil {
+			t.Fatalf("內嵌範本快照裡沒有 %s：%v", rel, err)
+		}
+		return string(data)
+	}
+	write("CLAUDE.md", fromSnapshot("CLAUDE.md"))
+	write("scripts/sdd-active-check.sh", fromSnapshot("scripts/sdd-active-check.sh"))
+	write("system-dev/wiki/status.md", fromSnapshot("system-dev/wiki/status.md"))
 	// 使用者真正的內容
 	write("我的筆記.md", "這是我要搜尋的東西")

@@ -58,3 +69,85 @@ func TestTemplateFilesAreNotKnowledge(t *testing.T) {
 			res.SkippedOther, res.SkippedOtherNames)
 	}
 }
+
+// TestTemplateShellVsRealContent 釘住 inkstone/Arcrun#180（leo 2026-08-28）新增的那半題：
+//
+//	「**cards 在 system-dev 下，wiki 就在裡面，所以不允許跳過它**」
+//
+// 同一棵 `system-dev/` 底下並存兩種東西（`youlinhsieh-test1` 實況）：
+//
+//	system-dev/wiki/status.md    ← 安裝器鋪的空殼，逐字等於快照 ⇒ 不是知識
+//	system-dev/wiki/cards/*.md   ← 使用者資料夾裡真的卡        ⇒ 是知識
+//
+// 舊的路徑前綴判準把兩者一起丟掉。這支釘的就是「分辨得出來」，
+// 而且釘的是**兩個方向**——放行與誤殺都會紅。
+func TestTemplateShellVsRealContent(t *testing.T) {
+	root := t.TempDir()
+	write := func(rel, body string) {
+		p := filepath.Join(root, filepath.FromSlash(rel))
+		if err := os.MkdirAll(filepath.Dir(p), 0o755); err != nil {
+			t.Fatal(err)
+		}
+		if err := os.WriteFile(p, []byte(body), 0o644); err != nil {
+			t.Fatal(err)
+		}
+	}
+	shell, err := templateFS.ReadFile(templateFSRoot + "/system-dev/wiki/status.md")
+	if err != nil {
+		t.Fatal(err)
+	}
+	// ① 原封不動的空殼
+	write("system-dev/wiki/status.md", string(shell))
+	// ② 同一個路徑的另一個檔，但使用者寫過（只差一行）
+	write("system-dev/wiki/mistakes.md", string(shell)+"\n2026-08-28：我自己寫的一條。\n")
+	// ③ 快照裡根本沒有的真內容——那 9 張卡就是這一種
+	write("system-dev/wiki/cards/arcrun-火星座標_短片劇本_v1.md", "# 火星座標\n這是一張真的卡。\n")
+
+	m := &Manifest{Entries: map[string]*ManifestEntry{}}
+	res, err := Scan(root, m, ScanOptions{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	got := map[string]bool{}
+	for _, e := range res.Events {
+		got[e.Path] = true
+	}
+	if got["system-dev/wiki/status.md"] {
+		t.Error("原封不動的範本空殼被當成知識收了——紅線①「不准變成放行」")
+	}
+	if !got["system-dev/wiki/mistakes.md"] {
+		t.Error("使用者只要寫過一個字就是他的知識，卻被當成範本丟掉")
+	}
+	if !got["system-dev/wiki/cards/arcrun-火星座標_短片劇本_v1.md"] {
+		t.Error("system-dev 底下真的卡沒被收——leo：「cards 在 system-dev 下…所以不允許跳過它」")
+	}
+}
+
+// 判準不看名字：同一份範本鋪在叫別的名字的資料夾裡，一樣認得出來；
+// 而一個剛好也叫 system-dev、裡面是使用者東西的資料夾，不該再被誤殺。
+func TestTemplateShell_判準不看資料夾名字(t *testing.T) {
+	shell, err := templateFS.ReadFile(templateFSRoot + "/system-dev/wiki/status.md")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if TemplateUntouched("我的專案筆記/wiki/status.md", "/nonexistent") {
+		t.Error("快照裡沒有這個相對路徑，不該回 true")
+	}
+	root := t.TempDir()
+	p := filepath.Join(root, "system-dev", "wiki", "status.md")
+	if err := os.MkdirAll(filepath.Dir(p), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(p, []byte("這個資料夾剛好也叫 system-dev，但裡面是我的東西"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	if TemplateUntouched("system-dev/wiki/status.md", p) {
+		t.Error("名字一樣但內容不一樣，判準不該只看名字")
+	}
+	if err := os.WriteFile(p, shell, 0o644); err != nil {
+		t.Fatal(err)
+	}
+	if !TemplateUntouched("system-dev/wiki/status.md", p) {
+		t.Error("內容逐字等於快照，應該認得出是空殼")
+	}
+}
@@ -0,0 +1,87 @@
+// templateuntouched.go — 「範本空殼」與「真內容」怎麼分辨
+// （inkstone/Arcrun#180 驗收條件 2 與 3，leo 2026-08-28）。
+//
+// ── 題目 ─────────────────────────────────────────────────────────────────────
+//
+// leo 原話：「**cards 在 system-dev 下，wiki 就在裡面，所以不允許跳過它**」
+//
+// 實據（`~/Desktop/youlinhsieh-test1`，同一棵 `system-dev/` 底下兩種東西並存）：
+//
+//	system-dev/wiki/status.md      ← 安裝器鋪的空殼，內容是「（初始化後填入）」
+//	system-dev/wiki/cards/*.md     ← 9 張真的卡（火星座標／Leo-Hsieh-填答／小果被AFTEE詐貸…）
+//
+// 舊判準是**路徑前綴**（`TemplateOwns`：`system-dev/` 與 `scripts/` 整棵不是知識），
+// 它分不出這兩層——把空殼和真內容一起丟掉。
+//
+// 🔴 而修法不准是「把 system-dev 放行」（票上紅線①）：那會讓所有裝過 template 的 repo
+// 開始收一堆一模一樣的空殼，變成另一個方向的錯。**要的是分辨。**
+//
+// ── 判準 ─────────────────────────────────────────────────────────────────────
+//
+// daemon **自己就是那個安裝器**（template_install.go 的 `//go:embed all:templatefs`
+// 把整份範本快照打進二進位）⇒ 原版就在手上，可以逐字比對，不必猜：
+//
+//	快照裡有同名檔，**且 sha256 逐字相同**  ⇒ 空殼：安裝器鋪的，他一個字都沒動 ⇒ 不收
+//	快照裡沒有，或內容不一樣                ⇒ 他寫的／他放的            ⇒ 照常判斷
+//
+// **為什麼它不會再誤殺一份現成的 wiki**：範本的 `status.md` 寫的是「（初始化後填入）」，
+// **使用者只要寫過一個字，雜湊就對不上，判斷立刻翻面**。
+// 判準不看名字、不看深度、不看模式 ⇒ 換個資料夾名、換個安裝位置，答案都一樣
+// （這也是紅線：不准用白名單，「下一個叫別的名字的資料夾照樣中」）。
+//
+// ⚠️ 這支只回答「是不是原封不動的範本」。**其餘的收檔判斷一條都沒有動**
+// （副檔名白名單、`.gitignore`、模式範圍、隱藏檔）——它只取代 `TemplateOwns`
+// 在掃描時的那一格。tidy.go 仍然用 `TemplateOwns`：它問的是另一題
+// （「哪些是範本殘留、該搬進收容處」），不是「這是不是知識」。
+package collector
+
+import (
+	"crypto/sha256"
+	"encoding/hex"
+	"io/fs"
+	"os"
+	"path/filepath"
+	"sync"
+)
+
+// templateSnapshotHashes：內嵌範本快照裡每個檔的 sha256（key＝斜線相對路徑）。
+// 只算一次——快照是編譯期就固定的東西，執行期不會變。
+var templateSnapshotHashes = sync.OnceValue(func() map[string]string {
+	out := map[string]string{}
+	_ = fs.WalkDir(templateFS, templateFSRoot, func(p string, d fs.DirEntry, err error) error {
+		if err != nil || d.IsDir() {
+			return nil
+		}
+		rel, rerr := filepath.Rel(templateFSRoot, p)
+		if rerr != nil {
+			return nil
+		}
+		data, rerr := templateFS.ReadFile(p)
+		if rerr != nil {
+			return nil
+		}
+		sum := sha256.Sum256(data)
+		out[filepath.ToSlash(rel)] = hex.EncodeToString(sum[:])
+		return nil
+	})
+	return out
+})
+
+// TemplateUntouched 回答「這個檔是不是安裝器鋪下去、而且使用者一個字都沒動過的空殼」。
+//
+// relSlash＝相對監看根的路徑（斜線分隔）；absPath＝那個檔在磁碟上的位置。
+//
+// 🔴 讀不到檔一律回 false——**認不出來就不要排除**。誤留一份空殼只是雜訊，
+// 誤丟一份使用者的知識是資料遺失，兩邊的代價不對等（同 cleanup.go 的規矩②）。
+func TemplateUntouched(relSlash, absPath string) bool {
+	want, ok := templateSnapshotHashes()[filepath.ToSlash(relSlash)]
+	if !ok {
+		return false // 快照裡沒有這個路徑 ⇒ 不是安裝器鋪的
+	}
+	data, err := os.ReadFile(absPath)
+	if err != nil {
+		return false
+	}
+	sum := sha256.Sum256(data)
+	return hex.EncodeToString(sum[:]) == want
+}
@@ -119,7 +119,37 @@ func collectCardItems(absRoot string) []TidyItem {
 	for _, relDir := range cardDirsToScan() {
 		base := filepath.Join(absRoot, filepath.FromSlash(relDir))
 		_ = filepath.WalkDir(base, func(p string, d fs.DirEntry, err error) error {
-			if err != nil || d.IsDir() {
+			if err != nil {
+				return nil
+			}
+			// 🔴 inkstone/Arcrun#134（2026-08-28 實測）：**隱藏目錄整棵跳過。**
+			//
+			// `<node>/.wiki/` 是規範定的卡片正式落點（machinemark.go 例外 ③），
+			// 而卡片產物區 `system-dev/wiki/cards/` 底下也會長出一個。少了這一行，
+			// 這支就把 `cards/.wiki/換柱.md`「歸位」成 `cards/arcrun-換柱.md`
+			// ——把**產物搬回 Scan 看得見的地方**，於是下一輪它被當成新原稿再萃一次，
+			// 產出「卡片的卡片」，再被搬出來⋯⋯迴圈不會停。
+			// 實測 `youlinhsieh-test1`：`cards/` 20 分鐘內從 9 個檔長到 55 個，
+			// 出現 `arcrun-換柱（arcrun-換柱）.md` 這種第三代檔名。
+			//
+			// `collectTemplateItems` 同一輪（f71e5a2）就寫了同一行同一個理由
+			// （「收容處自己就在 `.arcrun-rag/` 底下，不跳過的話第二次跑會把
+			// 搬過去的東西再搬一次」）——這支漏掉了。當時 `.wiki/` 還不存在
+			// （2026-08-15 才隨 ef5e6c5 進來），所以不是被否決，是沒人回來補。
+			//
+			// 📌 `inkstone/Arcrun#180` 從**另一面**撞到同一個洞，兩件事一起記著：
+			//   · #134 看到的是「產物被搬出去 ⇒ 下一輪再萃 ⇒ 卡萃卡」
+			//   · #180 看到的是「萃取端**讀不到自己一秒前寫的卡**」——
+			//     8 份文件全部 `讀卡片失敗：open …/.wiki/結晶管線.md: no such file`，
+			//     於是 `system-dev/wiki/cards/` 底下那 9 張現成的卡一張都上不了雲端。
+			//   ⇒ 同一行修好兩個症狀。
+			// ⚠️ 只跳**子**目錄（`p != base`）：`.arcrun-rag/wiki/cards` 是 base 自己，
+			//    #60 第三輪正是把卡搬進那裡——連 base 一起跳掉等於把上一輪的修復關掉。
+			//    `TestMigrateCardNames_收容處自己仍然掃得到` 守這一格。
+			if d.IsDir() {
+				if p != base && strings.HasPrefix(d.Name(), ".") {
+					return filepath.SkipDir
+				}
 				return nil
 			}
 			name := d.Name()
@@ -0,0 +1,79 @@
+// tidy_wiki_untouched_test.go — 舊制的「卡片歸位」不准動新制 `.wiki/` 裡的卡
+// （inkstone/Arcrun#180，2026-08-28 實撞）。
+//
+// 為什麼需要這一張網：`MigrateCardNames` 是 **daemon 每輪自動跑**的（direct.go
+// runDirectOnceRoot 開頭），而它掃的目錄與新制卡的家在某些資料夾上**完全重疊**——
+// 使用者把整理好的卡放在 `system-dev/wiki/cards/`，那些卡自己就是原稿，
+// 萃出來的新卡於是落在 `system-dev/wiki/cards/.wiki/`。
+//
+// 兩條規則撞上的當下沒有人會看到錯誤訊息：舊制默默把卡搬走並改名，
+// 萃取端下一步才報「讀卡片失敗」，而那句話指向的是**它自己一秒前寫出來的檔**。
+// ⇒ 這種 bug 只有機械網抓得到，靠讀程式碼讀不出來（本票就是這樣被繞了三輪）。
+package collector
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func mustWriteFile(t *testing.T, root, rel, body string) {
+	t.Helper()
+	p := filepath.Join(root, filepath.FromSlash(rel))
+	if err := os.MkdirAll(filepath.Dir(p), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(p, []byte(body), 0o644); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestMigrateCardNames_不准把新制wiki裡的卡拖出來(t *testing.T) {
+	root := t.TempDir()
+	// leo 的 youlinhsieh-test1 的形狀：整理好的卡住在 system-dev/wiki/cards/，
+	// 它們自己被當原稿萃過一輪，新卡落在同一層的 .wiki/。
+	mustWriteFile(t, root, "system-dev/wiki/cards/arcrun-火星座標_短片劇本_v1.md", "# 火星座標\n")
+	mustWriteFile(t, root, "system-dev/wiki/cards/.wiki/火星座標_短片劇本_v1.md", "# 火星座標\n")
+	mustWriteFile(t, root, "system-dev/wiki/cards/.wiki/官架子.md", "# 官架子\n")
+	mustWriteFile(t, root, "system-dev/wiki/cards/.wiki/00-INDEX.md", "# 00-INDEX\n")
+	mustWriteFile(t, root, "system-dev/wiki/cards/.wiki/.gitignore", "*\n")
+
+	MigrateCardNames(root)
+
+	for _, rel := range []string{
+		"system-dev/wiki/cards/.wiki/火星座標_短片劇本_v1.md",
+		"system-dev/wiki/cards/.wiki/官架子.md",
+		"system-dev/wiki/cards/.wiki/00-INDEX.md",
+		"system-dev/wiki/cards/.wiki/.gitignore",
+	} {
+		if _, err := os.Stat(filepath.Join(root, filepath.FromSlash(rel))); err != nil {
+			t.Errorf("%s 不見了——舊制的歸位又走進 .wiki/ 了：%v", rel, err)
+		}
+	}
+	// 反面：不准在上一層生出帶前綴的複本（那正是「卡萃卡」增生的起點）。
+	for _, rel := range []string{
+		"system-dev/wiki/cards/arcrun-官架子.md",
+		"system-dev/wiki/cards/arcrun-00-INDEX.md",
+		"system-dev/wiki/cards/arcrun-.gitignore",
+	} {
+		if _, err := os.Stat(filepath.Join(root, filepath.FromSlash(rel))); err == nil {
+			t.Errorf("多出了 %s——`.wiki/` 裡的東西被拖出來改名了", rel)
+		}
+	}
+}
+
+// 上一輪（#60 第三輪）的修復不准被這次的「跳過點開頭目錄」關掉：
+// `.arcrun-rag/wiki/cards/` 這個**收容處自己**是隱藏路徑，它仍然要被掃到。
+func TestMigrateCardNames_收容處自己仍然掃得到(t *testing.T) {
+	root := t.TempDir()
+	mustWriteFile(t, root, ".arcrun-rag/wiki/cards/沒帶標記的舊卡.md", "# 舊卡\n")
+
+	mig := MigrateCardNames(root)
+
+	if mig.Moved != 1 {
+		t.Fatalf("收容處裡沒帶標記的舊卡應該仍然被認出來（#60 第三輪的行為），實際 moved=%d", mig.Moved)
+	}
+	if _, err := os.Stat(filepath.Join(root, ".arcrun-rag/wiki/cards/沒帶標記的舊卡.md")); err == nil {
+		t.Fatal("它應該已經歸位了，原位置不該還在")
+	}
+}
@@ -148,7 +148,7 @@ func TestExtractWithWorkersAI_太大的檔一個請求都不送(t *testing.T) {
 	}))
 	defer srv.Close()

-	_, err := ExtractWithWorkersAI(srv.URL, "k", root, "巨檔.md")
+	_, err := ExtractWithWorkersAI(srv.URL, "k", root, "巨檔.md", testOrigin())
 	if err == nil {
 		t.Fatal("太大的檔應該直接失敗")
 	}
@@ -344,7 +344,7 @@ func TestVaultFootprint_ForeignWikiFileNotClobbered(t *testing.T) {
 	}

 	defer gemmaCardStub(t, cardFixture("會議記錄", "專案"))()
-	if _, err := ExtractWithGemma("k-test", "gemma-test", root, srcRel); err == nil {
+	if _, err := ExtractWithGemma("k-test", "gemma-test", root, srcRel, testOrigin()); err == nil {
 		t.Fatal("目標被佔用時應報錯，不得無聲覆蓋")
 	}
 	data, _ := os.ReadFile(filepath.Join(cardDir, "會議記錄.md"))
@@ -386,13 +386,93 @@ func entityFallback(ents []WikiEntity, selfName, selfGloss string) []WikiEntity
 	return []WikiEntity{{Name: selfName, Type: "概念", Desc: firstNonEmpty(selfGloss, "本卡描述的概念")}}
 }

-func renderSourceLine(b *strings.Builder, srcRel, cardName string) {
+// SourceOrigin＝「這份原稿實際在哪裡」的三件式：哪台機器 ／ 哪個庫 ／ 庫內什麼路徑。
+//
+// 🔴 為什麼要有這個型別（`inkstone/Arcrun#167`，leo 2026-08-27 用 n8n 實測抓到）：
+// 從前「### 出處」寫的是 `../<檔名>`——那是**卡片檔相對於原檔**的路徑，
+// 也就是 daemon 自己的目錄結構（卡在 `<node>/.wiki/`，原檔在上一層）。
+// 它有兩個要命的地方：
+//
+//	① 它是**內部結構**，卻被寫進知識內容 ⇒ 任何讀到那塊的 AI 都照著答，
+//	   而使用者拿著 `../小果被AFTEE詐貸.pdf` 走不到任何地方。
+//	② 原稿在子資料夾時，`../<檔名>` 把**資料夾整段弄丟了**
+//	   （實據：`system-dev/wiki/trees/2026-08-17-today.md` 的出處只剩
+//	   `../2026-08-17-today.md`）⇒ 連「同一個庫裡是哪一份」都定位不到。
+//
+// 三件式是**同一份 metadata 早就在送的那三格**（library／machine／source_path，
+// 見 direct.go 的 cardBody 與 rag_ingest_card 的 post_block）——
+// 這裡不是新增資料，是把已經有的東西寫成人看得懂的樣子。
+//
+// 🔴 為什麼**不寫絕對路徑**（票上要求說明判斷）：卡會離開這台機器（上雲、被別台的
+// AI 讀到），而絕對路徑只在鑄它的那台成立。給了它，跨機器問「原文在哪」拿到的
+// 會是一個**看起來最精確、實際上打不開**的答案——那正是 `../` 這枚坑的同一個形狀。
+// 「機器 ＋ 庫 ＋ 庫內路徑」才是三台機器上都成立的座標：認出機器 → 打開那個庫的
+// 資料夾 → 走庫內路徑。絕對路徑該由**知道監看根在哪的那一端**（daemon／portal）
+// 現場組，不該固化進知識內容。
+type SourceOrigin struct {
+	// MachineLabel＝人看得懂的機器稱呼（daemon 的 machine.json / config 的 machine_label）。
+	MachineLabel string
+	// Library＝這份原稿所屬的知識庫名（＝監看根，daemon 的 libraryFor）。
+	Library string
+	// LibraryPath＝**庫內**相對路徑，含子資料夾，一律 forward slash。
+	// 與 metadata 的 source_path 同一個值 ⇒ 卡上寫的與雲端存的對得起來。
+	LibraryPath string
+}
+
+// unknownOriginMark＝三件式缺格時的誠實標記。
+// 寧可讓使用者看到「（未知）」，也不要給一個看起來精確、實際上走不到的路徑
+// ——那正是 `../` 這枚坑的形狀。
+const unknownOriginMark = "（未知）"
+
+// originSep＝三件式之間的分隔符，與 portal 的來源顯示同一種
+//（`youlinhsieh@Leo-MBA › rt-lib › 檔名 第 4 段`）⇒ 使用者在兩個地方看到同一種形狀。
+const originSep = " › "
+
+// Human 回一句「這份原文在哪」：`機器 › 知識庫 › 庫內路徑`。
+func (o SourceOrigin) Human() string {
+	mach := strings.TrimSpace(o.MachineLabel)
+	if mach == "" {
+		mach = "機器" + unknownOriginMark
+	}
+	lib := strings.TrimSpace(o.Library)
+	if lib == "" {
+		lib = "知識庫" + unknownOriginMark
+	}
+	return mach + originSep + lib + originSep + o.pathOrUnknown()
+}
+
+// Ref 回三元組主詞用的那個字串＝`庫名/庫內路徑`。
+// 庫名未知時退回純庫內路徑——**任何情況下都不帶 `../`**。
+func (o SourceOrigin) Ref() string {
+	lib := strings.TrimSpace(o.Library)
+	if lib == "" {
+		return o.pathOrUnknown()
+	}
+	return lib + "/" + o.pathOrUnknown()
+}
+
+func (o SourceOrigin) pathOrUnknown() string {
+	p := strings.TrimSpace(filepath.ToSlash(o.LibraryPath))
+	p = strings.TrimPrefix(p, "./")
+	if p == "" {
+		return "庫內路徑" + unknownOriginMark
+	}
+	return p
+}
+
+// renderSourceLine 寫「### 出處」那一塊：**先一行人話位置，再一行三元組**。
+//
+// 人話那行刻意不含 `>>`：`## 關聯` 段的解析（`rag_ingest_card` 的 parse_card）
+// 只把含兩個 `>>` 的行收成三元組 ⇒ 它進得了知識內容、進不了圖，
+// 正好是我們要的（給人讀的句子不該變成一條邊）。
+func renderSourceLine(b *strings.Builder, o SourceOrigin, cardName string) {
 	b.WriteString("### 出處\n")
-	b.WriteString("- `" + srcRel + "`" + triSep + "提及" + triSep + cardName + "\n")
+	b.WriteString("- 原文位置（機器" + originSep + "知識庫" + originSep + "庫內路徑）：`" + o.Human() + "`\n")
+	b.WriteString("- `" + o.Ref() + "`" + triSep + "提及" + triSep + cardName + "\n")
 }

 // renderDocCard 文件卡（＝這份文件的 hub）：重點是判斷句、行內連到概念卡。
-func renderDocCard(d *wikiDoc, ex *DocExtract, conceptNames []string, srcRel string) string {
+func renderDocCard(d *wikiDoc, ex *DocExtract, conceptNames []string, origin SourceOrigin) string {
 	allowed := map[string]bool{"00-INDEX": true, d.Card: true}
 	for _, c := range conceptNames {
 		allowed[c] = true
@@ -442,12 +522,12 @@ func renderDocCard(d *wikiDoc, ex *DocExtract, conceptNames []string, srcRel str
 	for _, c := range conceptNames {
 		b.WriteString("- [[" + d.Card + "]]" + triSep + "整理出" + triSep + "[[" + c + "]]\n")
 	}
-	renderSourceLine(&b, srcRel, d.Card)
+	renderSourceLine(&b, origin, d.Card)
 	return b.String()
 }

 // renderConceptCard 原子概念卡。extraRels＝機械補上的反向邊（雙向連結保證）。
-func renderConceptCard(c WikiConcept, cardName, docCard, srcRel, created, updated string,
+func renderConceptCard(c WikiConcept, cardName, docCard string, origin SourceOrigin, created, updated string,
 	allowed map[string]bool, extraRels []string) string {
 	var b strings.Builder
 	renderFrontmatter(&b, cleanTags(c.Tags), firstNonEmpty(sanitizeProse(c.Gloss, map[string]bool{}), cardName), created, updated)
@@ -497,7 +577,7 @@ func renderConceptCard(c WikiConcept, cardName, docCard, srcRel, created, update
 	for _, line := range extraRels {
 		b.WriteString(line + "\n")
 	}
-	renderSourceLine(&b, srcRel, cardName)
+	renderSourceLine(&b, origin, cardName)
 	return b.String()
 }

@@ -525,7 +605,7 @@ func writeWikiFile(absRoot, dest string, content []byte) error {
 // BuildWikiDoc 把一份文件的萃取結果落成規範形的 `.wiki/` 產物。
 // 回傳本次產出的卡（相對監看根、文件卡在第一個）。
 // ex.NoConcept 為真（或概念數 0）時不產卡，改走「標空」路徑（回傳空清單）。
-func BuildWikiDoc(absRoot, relPath, srcText string, ex *DocExtract, now time.Time) ([]string, error) {
+func BuildWikiDoc(absRoot, relPath, srcText string, ex *DocExtract, origin SourceOrigin, now time.Time) ([]string, error) {
 	if ex == nil {
 		return nil, fmt.Errorf("BuildWikiDoc: 沒有萃取結果")
 	}
@@ -651,7 +731,6 @@ func BuildWikiDoc(absRoot, relPath, srcText string, ex *DocExtract, now time.Tim
 	}

 	// 渲染＋寫檔（先清掉這份文件上一輪產的、這一輪不再存在的卡）。
-	srcRel := "../" + base
 	var newCards []string
 	rel := func(cardName string) string {
 		return filepath.ToSlash(filepath.Join(nodeFromKey(nodeKey), wikiRelDir, cardName+".md"))
@@ -684,14 +763,14 @@ func BuildWikiDoc(absRoot, relPath, srcText string, ex *DocExtract, now time.Tim
 		return r, writeWikiFile(absRoot, destAbs, []byte(content))
 	}

-	docRel, err := writeCard(docCard, renderDocCard(&entry, ex, conceptNames, srcRel))
+	docRel, err := writeCard(docCard, renderDocCard(&entry, ex, conceptNames, origin))
 	if err != nil {
 		return nil, err
 	}
 	newCards = append(newCards, docRel)
 	for i, c := range concepts {
 		name := conceptNames[i]
-		content := renderConceptCard(c, name, docCard, srcRel, created, todayOf(now), allowed, extraRels[name])
+		content := renderConceptCard(c, name, docCard, origin, created, todayOf(now), allowed, extraRels[name])
 		r, werr := writeCard(name, content)
 		if werr != nil {
 			return nil, werr
@@ -0,0 +1,123 @@
+package collector
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+)
+
+// testOrigin＝測試用的三件式（機器／庫／庫內路徑）。
+// 內容不重要，重要的是**每個呼叫端都必須交出它**——`inkstone/Arcrun#167` 的教訓是
+// 「出處寫的是什麼」不能靠預設值，得由知道自己在哪一台、哪個庫的那一端說出來。
+func testOrigin() SourceOrigin {
+	return SourceOrigin{MachineLabel: "test@Machine", Library: "test-lib", LibraryPath: "測試文件.md"}
+}
+
+// wsOrigin＝wikishape 測試用：庫名／機器固定，庫內路徑跟著受測的 relPath 走
+//（子資料夾的檔要驗「資料夾沒被弄丟」，所以這一格不能寫死）。
+func wsOrigin(relPath string) SourceOrigin {
+	return SourceOrigin{MachineLabel: "test@Machine", Library: "test-lib", LibraryPath: relPath}
+}
+
+// TestSourceOriginNeverEmitsInternalPath 是 `inkstone/Arcrun#167` 的迴歸閘。
+//
+// leo 2026-08-27 用 n8n 實測：問「原文 wiki 的位置在哪裏？」，AI 照著卡片內文答
+// `../小果被AFTEE詐貸.pdf`——**使用者拿著它走不到任何地方**。
+// 這裡把那個形狀鎖死：不管三件式缺哪一格，輸出都不准出現 `../`。
+func TestSourceOriginNeverEmitsInternalPath(t *testing.T) {
+	cases := []struct {
+		name   string
+		origin SourceOrigin
+		want   []string
+	}{
+		{
+			"三件齊全",
+			SourceOrigin{MachineLabel: "youlinhsieh@Leo-MBA", Library: "youlinhsieh-test1", LibraryPath: "小果被AFTEE詐貸.pdf"},
+			[]string{"youlinhsieh@Leo-MBA › youlinhsieh-test1 › 小果被AFTEE詐貸.pdf", "`youlinhsieh-test1/小果被AFTEE詐貸.pdf`"},
+		},
+		{
+			// 🔴 票上的驗收條件三：子資料夾裡的檔要定位得到。
+			// 舊寫法 `../<檔名>` 會把整段資料夾弄丟（實據：inkstoneco 庫的
+			// system-dev/wiki/trees/2026-08-17-today.md 出處只剩 `../2026-08-17-today.md`）。
+			"子資料夾不准被弄丟",
+			SourceOrigin{MachineLabel: "youlinhsieh@Leo-MBA", Library: "inkstoneco", LibraryPath: "system-dev/wiki/trees/2026-08-17-today.md"},
+			[]string{"inkstoneco › system-dev/wiki/trees/2026-08-17-today.md", "`inkstoneco/system-dev/wiki/trees/2026-08-17-today.md`"},
+		},
+		{
+			"機器未知也要誠實，不得退回相對路徑",
+			SourceOrigin{Library: "kb", LibraryPath: "a/b.md"},
+			[]string{"機器（未知） › kb › a/b.md"},
+		},
+		{
+			"庫未知",
+			SourceOrigin{MachineLabel: "m", LibraryPath: "a/b.md"},
+			[]string{"m › 知識庫（未知） › a/b.md", "`a/b.md`"},
+		},
+		{
+			"路徑未知",
+			SourceOrigin{MachineLabel: "m", Library: "kb"},
+			[]string{"m › kb › 庫內路徑（未知）"},
+		},
+	}
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			var b strings.Builder
+			renderSourceLine(&b, c.origin, "某卡")
+			got := b.String()
+			if strings.Contains(got, "../") {
+				t.Fatalf("出處帶內部相對路徑：\n%s", got)
+			}
+			for _, w := range c.want {
+				if !strings.Contains(got, w) {
+					t.Fatalf("出處少了「%s」：\n%s", w, got)
+				}
+			}
+			// 人話那行不准變成三元組（`## 關聯` 的解析只收含兩個分隔符的行）。
+			human := strings.Split(strings.TrimSpace(got), "\n")[1]
+			if strings.Contains(human, triSep) {
+				t.Fatalf("人話位置那行含三元組分隔符，會被當成一條邊：%s", human)
+			}
+		})
+	}
+}
+
+// TestBuildWikiDocSourceLocatesSubfolderDoc 走完整落地路徑（不是只測 renderer）：
+// 子資料夾裡的原稿，產出的文件卡與概念卡都要寫得出「庫內完整路徑」。
+func TestBuildWikiDocSourceLocatesSubfolderDoc(t *testing.T) {
+	root := t.TempDir()
+	rel := "專案/會議/週會.md"
+	if err := os.MkdirAll(filepath.Join(root, "專案", "會議"), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	src := "# 週會\n\n甲和乙討論了進度。\n"
+	if err := os.WriteFile(filepath.Join(root, filepath.FromSlash(rel)), []byte(src), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	ex := &DocExtract{
+		Gloss: "週會記錄", Summary: "甲乙討論進度", Points: []string{"討論了進度"},
+		Concepts: []WikiConcept{{Name: "進度", Gloss: "專案進度", Summary: "專案進度的討論"}},
+	}
+	origin := SourceOrigin{MachineLabel: "youlinhsieh@Leo-MBA", Library: "inkstoneco", LibraryPath: rel}
+	cards, err := BuildWikiDoc(root, rel, src, ex, origin, time.Date(2026, 8, 27, 0, 0, 0, 0, time.UTC))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(cards) == 0 {
+		t.Fatal("沒產出卡")
+	}
+	for _, c := range cards {
+		body, rerr := os.ReadFile(filepath.Join(root, filepath.FromSlash(c)))
+		if rerr != nil {
+			t.Fatal(rerr)
+		}
+		card := string(body)
+		if strings.Contains(card, "../") {
+			t.Fatalf("%s 仍帶 `../`：\n%s", c, card)
+		}
+		if !strings.Contains(card, "inkstoneco › 專案/會議/週會.md") {
+			t.Fatalf("%s 的出處定位不到子資料夾：\n%s", c, card)
+		}
+	}
+}
@@ -40,7 +40,7 @@ func TestBuildWikiDoc_CardShapeMatchesSpec(t *testing.T) {
 	src := "# 測試文件\n\n內文若干"
 	mustWrite(t, filepath.Join(root, "測試文件.md"), src)

-	cards, err := BuildWikiDoc(root, "測試文件.md", src, wsExtract(), wsNow)
+	cards, err := BuildWikiDoc(root, "測試文件.md", src, wsExtract(), wsOrigin("測試文件.md"), wsNow)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -58,9 +58,16 @@ func TestBuildWikiDoc_CardShapeMatchesSpec(t *testing.T) {
 			t.Fatalf("文件卡缺「%s」：\n%s", want, doc)
 		}
 	}
-	// 出處路徑相對 .wiki，真的指得到原稿（lint「出處路徑指不到原稿」項）
-	if !strings.Contains(doc, "`../測試文件.md`") {
-		t.Fatalf("出處路徑不對：\n%s", doc)
+	// 🔴 `inkstone/Arcrun#167`：出處寫的是「哪台機器／哪個庫／庫內什麼路徑」，
+	// **不再是 `../`**（那是卡片檔相對原檔的內部結構，使用者拿著它走不到任何地方）。
+	if !strings.Contains(doc, "`test@Machine \u203a test-lib \u203a 測試文件.md`") {
+		t.Fatalf("出處沒寫成「機器 › 庫 › 庫內路徑」：\n%s", doc)
+	}
+	if !strings.Contains(doc, "`test-lib/測試文件.md`"+triSep+"提及") {
+		t.Fatalf("出處三元組主詞不是庫內定位：\n%s", doc)
+	}
+	if strings.Contains(doc, "../") {
+		t.Fatalf("出處仍帶內部相對路徑 `../`：\n%s", doc)
 	}
 	ca := mustRead(t, filepath.Join(root, ".wiki", "概念甲.md"))
 	for _, want := range []string{
@@ -84,7 +91,7 @@ func TestBuildWikiDoc_EdgesAreBidirectional(t *testing.T) {
 	root := t.TempDir()
 	src := "# 測試文件\n內文"
 	mustWrite(t, filepath.Join(root, "測試文件.md"), src)
-	if _, err := BuildWikiDoc(root, "測試文件.md", src, wsExtract(), wsNow); err != nil {
+	if _, err := BuildWikiDoc(root, "測試文件.md", src, wsExtract(), wsOrigin("測試文件.md"), wsNow); err != nil {
 		t.Fatal(err)
 	}
 	cb := mustRead(t, filepath.Join(root, ".wiki", "概念乙.md"))
@@ -100,7 +107,7 @@ func TestBuildWikiDoc_LinksClosedAndIndexishFixed(t *testing.T) {
 	mustWrite(t, filepath.Join(root, "文件.md"), src)
 	ex := wsExtract()
 	ex.Points = []string{"[[概念甲]] — 這行是 index 式，要被改寫", "這裡提到 [[不存在的卡]] 應拆殼"}
-	if _, err := BuildWikiDoc(root, "文件.md", src, ex, wsNow); err != nil {
+	if _, err := BuildWikiDoc(root, "文件.md", src, ex, wsOrigin("文件.md"), wsNow); err != nil {
 		t.Fatal(err)
 	}
 	doc := mustRead(t, filepath.Join(root, ".wiki", "文件.md"))
@@ -117,7 +124,7 @@ func TestMarkDocNoConcept_ListedOnIndex(t *testing.T) {
 	root := t.TempDir()
 	mustWrite(t, filepath.Join(root, "發票.txt"), "金額 100")
 	ex := &DocExtract{NoConcept: true, Reason: "純紀錄（發票），沒有可獨立成立的判斷"}
-	cards, err := BuildWikiDoc(root, "發票.txt", "金額 100", ex, wsNow)
+	cards, err := BuildWikiDoc(root, "發票.txt", "金額 100", ex, wsOrigin("發票.txt"), wsNow)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -139,7 +146,7 @@ func TestBuildWikiDoc_NestedNodeAndAncestors(t *testing.T) {
 	src := "# 週會決議\n內容"
 	mustWrite(t, filepath.Join(root, rel, "週會.md"), src)

-	if _, err := BuildWikiDoc(root, "專案/會議/週會.md", src, wsExtract(), wsNow); err != nil {
+	if _, err := BuildWikiDoc(root, "專案/會議/週會.md", src, wsExtract(), wsOrigin("專案/會議/週會.md"), wsNow); err != nil {
 		t.Fatal(err)
 	}
 	if _, err := os.Stat(filepath.Join(root, "專案", "會議", ".wiki", "週會決議.md")); err != nil {
@@ -173,14 +180,14 @@ func TestBuildWikiDoc_ReextractCleansOldCards(t *testing.T) {
 	root := t.TempDir()
 	src := "# 文件\n內文"
 	mustWrite(t, filepath.Join(root, "文件.md"), src)
-	if _, err := BuildWikiDoc(root, "文件.md", src, wsExtract(), wsNow); err != nil {
+	if _, err := BuildWikiDoc(root, "文件.md", src, wsExtract(), wsOrigin("文件.md"), wsNow); err != nil {
 		t.Fatal(err)
 	}
 	// 第二輪：概念換名
 	ex2 := wsExtract()
 	ex2.Concepts = []WikiConcept{{Name: "全新概念", Gloss: "新的一句話", Summary: "新摘要", Points: []string{"新判斷"}}}
 	ex2.Points = []string{"重點換成 [[全新概念]] 了"}
-	if _, err := BuildWikiDoc(root, "文件.md", src, ex2, wsNow.Add(24*time.Hour)); err != nil {
+	if _, err := BuildWikiDoc(root, "文件.md", src, ex2, wsOrigin("文件.md"), wsNow.Add(24*time.Hour)); err != nil {
 		t.Fatal(err)
 	}
 	if _, err := os.Stat(filepath.Join(root, ".wiki", "概念甲.md")); !os.IsNotExist(err) {
@@ -201,7 +208,7 @@ func TestRemoveWikiDoc_CleansEverything(t *testing.T) {
 	root := t.TempDir()
 	src := "# 文件\n內文"
 	mustWrite(t, filepath.Join(root, "文件.md"), src)
-	if _, err := BuildWikiDoc(root, "文件.md", src, wsExtract(), wsNow); err != nil {
+	if _, err := BuildWikiDoc(root, "文件.md", src, wsExtract(), wsOrigin("文件.md"), wsNow); err != nil {
 		t.Fatal(err)
 	}
 	if err := RemoveWikiDoc(root, "文件.md"); err != nil {
@@ -230,10 +237,10 @@ func TestBuildWikiDoc_SameConceptFromTwoDocsDisambiguated(t *testing.T) {
 			Points:   []string{"重點連到 [[迭代]]"},
 			Concepts: []WikiConcept{{Name: "迭代", Gloss: "同名概念", Summary: "摘要", Points: []string{"判斷"}}}}
 	}
-	if _, err := BuildWikiDoc(root, "a.md", srcA, ex(), wsNow); err != nil {
+	if _, err := BuildWikiDoc(root, "a.md", srcA, ex(), wsOrigin("a.md"), wsNow); err != nil {
 		t.Fatal(err)
 	}
-	if _, err := BuildWikiDoc(root, "b.md", srcB, ex(), wsNow); err != nil {
+	if _, err := BuildWikiDoc(root, "b.md", srcB, ex(), wsOrigin("b.md"), wsNow); err != nil {
 		t.Fatal(err)
 	}
 	first := mustRead(t, filepath.Join(root, ".wiki", "迭代.md"))
@@ -255,7 +262,7 @@ func TestNodeIndex_FiveFieldsPerDocLine(t *testing.T) {
 	root := t.TempDir()
 	src := "# 測試文件\n內文"
 	mustWrite(t, filepath.Join(root, "測試文件.md"), src)
-	if _, err := BuildWikiDoc(root, "測試文件.md", src, wsExtract(), wsNow); err != nil {
+	if _, err := BuildWikiDoc(root, "測試文件.md", src, wsExtract(), wsOrigin("測試文件.md"), wsNow); err != nil {
 		t.Fatal(err)
 	}
 	idx := mustRead(t, filepath.Join(root, ".wiki", "00-INDEX.md"))
Author	SHA1	Message	Date
Leo	3cc8788e9d	sync: collector/ 同步自 inkstone/arcrun-rag@d129f8b（桌面小幫手 0.18.48）	2026-08-28 09:16:44 +08:00
Leo	e8800d18ef	sync: collector/ 同步自 inkstone/arcrun-rag@1c31ac2（桌面小幫手 0.18.46）	2026-08-28 05:07:35 +08:00
Leo	80877af60c	sync: collector/ 同步自 inkstone/arcrun-rag@740c55c（桌面小幫手 0.18.44）	2026-08-28 03:46:42 +08:00
Leo	ef5fe1df6f	sync: collector/ 同步自 inkstone/arcrun-rag@4982b50（桌面小幫手 0.18.43）	2026-08-28 01:48:25 +08:00
Leo	3d1cb83110	sync: collector/ 同步自 inkstone/arcrun-rag@7c21a3a（桌面小幫手 0.18.42）	2026-08-27 21:30:21 +08:00