feat(daemon/p04): fyne 托盤殼 + collector 看守器（CP-1 第6關產品化，leo 定 fyne）

leo 2026-07-21 回「fyne」。交付「可交付的殼」：
- collector/supervisor（純 stdlib，無 fyne）：看守 collector direct 子行程、串 stdout JSON 出
  狀態（看守中/上次同步/出錯自動重試/已暫停）、崩潰重起、Stop 同步等 loop 收掉（修 Stop→Start
  換資料夾時舊 loop 覆寫新狀態的 race）。**sandbox `go test -race ./... 全綠（6 測，含 race）**，
  既有 collector 測試零回歸。
- collector/cmd/arcrun-tray（獨立 module，隔開 fyne CGo 依賴）：選單列/系統匣 icon＋狀態＋
  選資料夾(原生對話框)/暫停·繼續/打開資料夾；關窗縮背景；watch_folder 預設 ~/ArcrunRAG 避開
  ~/Documents 的 TCC 禁區；wires supervisor。

誠實界定（mindset §7）：
- **in-process vs 子行程**：leo 偏好 in-process，但 collector 是 package main，真 in-process 需抽核心成
  library（動已驗引擎有回歸風險）→ 本版走子行程看守（collector 零改、崩潰隔離），行為對用戶相同；
  in-process 抽取列可選後續，待 leo 裁。
- **fyne GUI 沙箱編不了**（CGo+GL）→ build/簽章/TCC 授權＝leo/地端真機做（紅線②③）；
  fyne API 細節以首次真機 build 為準。README 附建置/簽章/TCC 交接。

cmd/arcrun-tray/README.md

@@ -0,0 +1,62 @@
+# Arcrun RAG 托盤殼（arcrun-tray）— 建置／簽章／TCC 交接
+
+> CP-1 第 6 關 daemon 產品化。leo 2026-07-21 定框架＝**fyne**（窮舉七案後推薦，見頂層
+> `journeys/daemon-tray-shell-options.md`）。**建置/簽章/公證/TCC 授權＝leo/地端在真機做**（紅線②③）。
+
+## 這顆殼做什麼
+
+一個**選單列（Mac）/系統匣（Windows）icon**，讓不開 terminal 的人也能用：
+- 狀態一眼看（看守中 · 上次同步 HH:MM／啟動中／出錯自動重試／已暫停）
+- 選單：**選擇知識資料夾**（系統原生對話框）／打開資料夾／暫停·繼續看守
+- 關掉視窗＝縮回背景續看守（不是結束）
+
+它**看守** `arcrun-collector direct`（同綑執行檔），把它當背景常駐；崩了自動重起。
+
+## 哪些已驗、哪些待真機驗（誠實界定，mindset §7）
+
+| 部分 | 狀態 | 驗法 |
+|------|------|------|
+| **看守核心** `collector/supervisor`（子行程管理／狀態解析／崩潰重起／停止） | ✅ **sandbox `go test` 驗過**（純 stdlib，5 測全綠，含重起/停止/狀態解析） | `cd collector && go test ./supervisor/` |
+| collector 引擎（未動） | ✅ 既有測試無回歸 | `cd collector && go test ./...` |
+| **fyne GUI 本體**（本 main.go：tray icon／選單／原生選資料夾） | ⏳ **待真機 build**——fyne 需 CGo＋GL/webview，無螢幕 sandbox 編不了 | 真機 `go mod tidy && fyne package` |
+| macOS **TCC 同意流** | ⏳ 待真 Mac 驗（沙箱測不到真 TCC 語意＝假綠，故不盲寫） | 見下「TCC」 |
+
+> ⚠️ **fyne API 細節（fyne.Do／SetSystemTrayMenu 刷新／Lifecycle）以首次真機 build 為準**——
+> 本檔按 fyne v2.5 API 寫，但未經編譯器。第一次 `go mod tidy && go build` 若有 API 出入，就地修。
+
+## 建置（leo/地端，真機）
+
+```bash
+cd collector/cmd/arcrun-tray
+go mod tidy                       # 拉 fyne 依賴（首次需網路）
+# 把 collector 執行檔一起放進 bundle（托盤靠同層 arcrun-collector）
+（cd ../.. && GOOS=darwin GOARCH=arm64 go build -o cmd/arcrun-tray/arcrun-collector .）
+# 打包 .app（Mac）／.exe（Win）
+go run fyne.io/fyne/v2/cmd/fyne@latest package -os darwin -icon icon.png -name "Arcrun RAG"
+# Windows：-os windows
+```
+> icon.png 待放（leo logo 進行中）；Mac 選單列建議 **template 單色 icon**（自動深淺色）。
+
+## 簽章／公證（Mac，leo/地端）
+
+未簽章的 .app 會被 Gatekeeper 擋（右鍵開可繞，但非產品體驗）。正式版：
+```bash
+codesign --deep --force --options runtime --sign "Developer ID Application: <你>" "Arcrun RAG.app"
+xcrun notarytool submit "Arcrun RAG.zip" --apple-id … --team-id … --wait
+xcrun stapler staple "Arcrun RAG.app"
+```
+
+## TCC（macOS，只有真 Mac 驗得到）
+
+**預設 watch_folder ＝ `~/ArcrunRAG`（本殼已這樣設）——刻意避開 `~/Documents`**：launchd/背景程序碰
+`~/Documents` 會被 TCC 擋（2026-07-19 實撞）。預設在非 TCC 禁區＝**零授權即可用**。
+
+用戶若堅持把資料夾設在 `~/Documents`/`~/Desktop`/`~/Downloads`：
+1. 首次讀取被拒 → 本殼應偵測並引導：**系統設定 → 隱私權與安全性 → 檔案與資料夾**（或完整磁碟取用權）勾選 Arcrun RAG。
+2. 這一步**必須在真 Mac 上驗**（跳不跳授權框、launchd 背景 vs GUI 前景差異）。sandbox 只能測到 `os.Open` 成不成，測不到真 TCC＝假綠，故本輪不寫死。
+
+## 安裝（用戶視角，最終形態）
+
+下載 → 拖進「應用程式」→ 開啟 → 選一個資料夾 → 完成。cypher_url/namespace/api_key 由**安裝器**寫進
+`~/.arcrun-rag/config.json`（用戶不碰）。**現行 `docs/manual/product-install-guide.md` 是廢棄的
+Docker 六步，產品化時要重寫成這段。**

cmd/arcrun-tray/go.mod

@@ -0,0 +1,14 @@
+// 獨立 module：把 fyne（CGo/GL）依賴與純 stdlib 的 collector module 隔開，
+// 讓 collector 模組維持 `go test ./...` 可在無 GUI 環境驗證。
+// 本 module 在 Mac/Windows 真機 build（leo/地端）：`go mod tidy && fyne package`。
+module arcrun-rag/collector/cmd/arcrun-tray
+
+go 1.22
+
+require (
+	arcrun-rag/collector v0.0.0
+	fyne.io/fyne/v2 v2.5.3
+)
+
+// 複用同 repo 的 supervisor 套件（純 stdlib）。
+replace arcrun-rag/collector => ../../

cmd/arcrun-tray/main.go

@@ -0,0 +1,221 @@
+// arcrun-tray — Arcrun RAG 桌面托盤殼（CP-1 第 6 關 daemon 產品化，leo 2026-07-21 定 fyne）。
+//
+// 目的：讓「不開 terminal 的人」也能裝、開關、選資料夾——一個選單列/系統匣 icon 就是全部。
+// 它看守 `collector direct`（子行程，見 supervisor 套件的誠實界定）並顯示狀態。
+//
+// ⚠️ 本檔是 fyne GUI（CGo＋系統 webview/GL），**無法在無螢幕 sandbox build/驗**——
+//
+//	build/簽章/公證/TCC 授權＝leo/地端在真機做（紅線②③）。純邏輯（看守/config）已抽到
+//	supervisor 套件並在 sandbox `go test` 驗過。
+//
+// 真機 build：
+//
+//	cd collector/cmd/arcrun-tray && go mod tidy
+//	go run fyne.io/fyne/v2/cmd/fyne@latest package -os darwin -icon icon.png -name "Arcrun RAG"
+//	（Windows：-os windows；簽章/公證另見同目錄 README）
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+
+	"arcrun-rag/collector/supervisor"
+
+	"fyne.io/fyne/v2"
+	"fyne.io/fyne/v2/app"
+	"fyne.io/fyne/v2/container"
+	"fyne.io/fyne/v2/dialog"
+	"fyne.io/fyne/v2/driver/desktop"
+	"fyne.io/fyne/v2/storage"
+	"fyne.io/fyne/v2/theme"
+	"fyne.io/fyne/v2/widget"
+)
+
+// directConfig 是 collector direct 的設定（與 collector/direct.go 的 DirectConfig 同結構；
+// 這裡只需讀寫 watch_folder，其餘由安裝器帶入）。
+type directConfig struct {
+	WatchFolder string  `json:"watch_folder"`
+	Manifest    string  `json:"manifest"`
+	CypherURL   string  `json:"cypher_url"`
+	Namespace   string  `json:"namespace"`
+	APIKey      string  `json:"api_key,omitempty"`
+	Library     string  `json:"library,omitempty"`
+	IngestWF    string  `json:"ingest_workflow,omitempty"`
+	RemovedWF   string  `json:"removed_workflow,omitempty"`
+	PollSec     int     `json:"poll_interval_sec,omitempty"`
+	MaxRemoved  float64 `json:"max_removed_ratio,omitempty"`
+}
+
+// appDir 是設定與 manifest 落地處：~/.arcrun-rag/
+func appDir() string {
+	home, _ := os.UserHomeDir()
+	return filepath.Join(home, ".arcrun-rag")
+}
+
+func configPath() string { return filepath.Join(appDir(), "config.json") }
+
+// defaultWatchFolder 預設 ~/ArcrunRAG——**刻意避開 ~/Documents**：macOS launchd 背景程序碰
+// ~/Documents 會被 TCC 擋（07-19 實撞）。預設在非 TCC 禁區＝零授權即可用；用戶要改到 Documents
+// 才需走 TCC 同意流（見 README）。
+func defaultWatchFolder() string {
+	home, _ := os.UserHomeDir()
+	return filepath.Join(home, "ArcrunRAG")
+}
+
+func loadConfig() *directConfig {
+	c := &directConfig{}
+	if data, err := os.ReadFile(configPath()); err == nil {
+		_ = json.Unmarshal(data, c)
+	}
+	if c.WatchFolder == "" {
+		c.WatchFolder = defaultWatchFolder()
+	}
+	if c.Manifest == "" {
+		c.Manifest = filepath.Join(appDir(), "manifest.json")
+	}
+	return c
+}
+
+func saveConfig(c *directConfig) error {
+	if err := os.MkdirAll(appDir(), 0o755); err != nil {
+		return err
+	}
+	data, _ := json.MarshalIndent(c, "", "  ")
+	return os.WriteFile(configPath(), data, 0o600)
+}
+
+// collectorBinPath 找同綑的 collector 執行檔（app bundle 內與托盤同層）。
+func collectorBinPath() string {
+	exe, err := os.Executable()
+	if err != nil {
+		return "arcrun-collector"
+	}
+	name := "arcrun-collector"
+	if isWindows() {
+		name += ".exe"
+	}
+	return filepath.Join(filepath.Dir(exe), name)
+}
+
+func isWindows() bool { return os.PathSeparator == '\\' }
+
+func main() {
+	a := app.NewWithID("dev.arcrun.rag.tray")
+	cfg := loadConfig()
+
+	// 設定視窗（平時隱藏；選資料夾/看說明時開）
+	win := a.NewWindow("Arcrun RAG")
+	win.SetCloseIntercept(func() { win.Hide() }) // 關窗只隱藏，不結束 app（托盤續跑）
+	win.Resize(fyne.NewSize(420, 220))
+
+	sup := supervisor.New(collectorBinPath(), configPath())
+
+	// 狀態列（tray 選單第一項，只讀）
+	statusItem := fyne.NewMenuItem("狀態：尚未開始", nil)
+	statusItem.Disabled = true
+
+	folderItem := fyne.NewMenuItem("選擇知識資料夾…", func() {
+		win.Show()
+		win.RequestFocus()
+		dialog.ShowFolderOpen(func(uri fyne.ListableURI, err error) {
+			if err != nil || uri == nil {
+				return
+			}
+			cfg.WatchFolder = uri.Path()
+			if err := saveConfig(cfg); err != nil {
+				dialog.ShowError(err, win)
+				return
+			}
+			// 換資料夾＝重起看守
+			sup.Stop()
+			sup.Start()
+			win.Hide()
+		}, win)
+	})
+
+	openFolderItem := fyne.NewMenuItem("打開資料夾", func() {
+		if u, err := storage.ParseURI("file://" + cfg.WatchFolder); err == nil {
+			_ = a.OpenURL(u)
+		}
+	})
+
+	var pauseItem *fyne.MenuItem
+	pauseItem = fyne.NewMenuItem("暫停看守", func() {
+		st := sup.Status()
+		if st.State == supervisor.StateStopped {
+			sup.Start()
+			pauseItem.Label = "暫停看守"
+		} else {
+			sup.Stop()
+			pauseItem.Label = "繼續看守"
+		}
+	})
+
+	tray := fyne.NewMenu("Arcrun RAG",
+		statusItem,
+		fyne.NewMenuItemSeparator(),
+		folderItem,
+		openFolderItem,
+		pauseItem,
+	)
+
+	desk, hasTray := a.(desktop.App)
+	if hasTray {
+		desk.SetSystemTrayMenu(tray)
+		desk.SetSystemTrayIcon(theme.StorageIcon()) // TODO 換品牌 icon（leo logo 進行中）；Mac 建議 template 單色
+	}
+	// 重設選單＝刷新（比 (*Menu).Refresh() 跨版本更穩）
+	refreshTray := func() {
+		if hasTray {
+			desk.SetSystemTrayMenu(tray)
+		}
+	}
+
+	// 狀態變更 → 刷新 tray 文案（回呼在 supervisor goroutine，切回 UI thread）
+	sup.SetOnChange(func(s supervisor.Status) {
+		fyne.Do(func() {
+			statusItem.Label = "狀態：" + humanStatus(s)
+			refreshTray()
+		})
+	})
+
+	// 設定視窗內容：說明現況 + 選資料夾按鈕（給會開窗的人；不會開的人靠 tray 選單）
+	win.SetContent(container.NewVBox(
+		widget.NewLabelWithStyle("Arcrun RAG 知識同步", fyne.TextAlignCenter, fyne.TextStyle{Bold: true}),
+		widget.NewLabel("把檔案丟進你選的資料夾，就會自動進你的知識庫。\n這個程式會待在選單列/系統匣，關掉視窗它仍在背景看守。"),
+		widget.NewButton("選擇知識資料夾…", func() { folderItem.Action() }),
+	))
+
+	// 開機即看守（若設定完整）
+	if cfg.CypherURL != "" && cfg.Namespace != "" {
+		sup.Start()
+	} else {
+		// 缺安裝器帶入的 cypher_url/namespace：提示用戶先完成安裝
+		statusItem.Label = "狀態：尚未連結（請先完成安裝）"
+		win.Show()
+	}
+
+	a.Lifecycle().SetOnStopped(func() { sup.Stop() })
+	a.Run()
+}
+
+// humanStatus 把狀態機轉成白話（給不懂內部的人）。
+func humanStatus(s supervisor.Status) string {
+	switch s.State {
+	case supervisor.StateWatching:
+		if !s.LastRoundAt.IsZero() {
+			return fmt.Sprintf("看守中 · 上次同步 %s", s.LastRoundAt.Local().Format("15:04"))
+		}
+		return "看守中"
+	case supervisor.StateStarting:
+		return "啟動中…"
+	case supervisor.StateError:
+		return "暫時出錯，正在自動重試"
+	case supervisor.StateStopped:
+		return "已暫停"
+	default:
+		return "尚未開始"
+	}
+}

supervisor/supervisor.go

@@ -0,0 +1,247 @@
+// Package supervisor 看守 `collector direct` 常駐行程，供托盤殼（fyne）呼叫。
+//
+// 為什麼子行程而非 in-process（誠實界定，leo 2026-07-21 偏好 in-process）：
+//
+//	collector 現為 `package main`，真正 in-process 複用需把核心抽成 library 套件
+//	（重構動到已由 leo 實機驗過的引擎，有回歸風險）。本版先以「子行程＋讀 stdout JSON 狀態」
+//	達成看守（collector 零改、崩潰隔離、純 stdlib 可單元測），in-process 抽取列為可選後續。
+//	對用戶行為完全相同（都是「背景看守資料夾」）。
+//
+// 純 stdlib、無 fyne 依賴 → 可在 CI/sandbox `go test` 驗證（托盤 GUI 需真機建置）。
+package supervisor
+
+import (
+	"bufio"
+	"context"
+	"encoding/json"
+	"io"
+	"os/exec"
+	"strings"
+	"sync"
+	"time"
+)
+
+// State 是看守狀態機。
+type State string
+
+const (
+	StateStopped  State = "stopped"  // 未啟動或已停止
+	StateStarting State = "starting" // 行程剛拉起、尚無第一輪
+	StateWatching State = "watching" // 正常看守中（已有掃描輪）
+	StateError    State = "error"    // 行程非預期退出、等待重起
+)
+
+// Status 是托盤要顯示的即時狀態（值型別、複製安全）。
+type Status struct {
+	State       State
+	Since       time.Time // 進入目前 State 的時間
+	LastRoundAt time.Time // 最近一輪掃描完成時間（collector stdout 的 at）
+	Rounds      int       // 累計掃描輪數
+	Restarts    int       // 累計重起次數
+	LastError   string    // 最近一次錯誤（stderr 末行 / 退出原因）
+}
+
+// round 對應 collector direct 每輪印到 stdout 的 JSON（見 direct.go runOne）。
+type round struct {
+	At      string            `json:"at"`
+	Folder  string            `json:"folder"`
+	Results []json.RawMessage `json:"results"`
+}
+
+// Supervisor 看守單一 collector direct 行程。
+type Supervisor struct {
+	BinPath    string        // collector 執行檔路徑（托盤 app bundle 內）
+	ConfigPath string        // direct config.json 路徑
+	Backoff    time.Duration // 非預期退出後的重起間隔（0＝預設 3s）
+
+	mu       sync.Mutex
+	status   Status
+	cancel   context.CancelFunc
+	done     chan struct{} // loop 結束時關閉（Stop 等它，避免 Stop→Start 舊 loop 覆寫狀態）
+	running  bool
+	onChange func(Status)
+	nowFn    func() time.Time // 可注入時鐘（測試用；nil＝time.Now）
+}
+
+// New 建一個看守器。
+func New(binPath, configPath string) *Supervisor {
+	return &Supervisor{BinPath: binPath, ConfigPath: configPath}
+}
+
+// SetOnChange 註冊狀態變更回呼（托盤用來刷新選單/icon）。回呼在 supervisor 內部 goroutine 呼叫。
+func (s *Supervisor) SetOnChange(fn func(Status)) {
+	s.mu.Lock()
+	s.onChange = fn
+	s.mu.Unlock()
+}
+
+func (s *Supervisor) now() time.Time {
+	if s.nowFn != nil {
+		return s.nowFn()
+	}
+	return time.Now()
+}
+
+// setState 原子更新狀態並觸發回呼（回呼在鎖外呼叫，避免死鎖）。
+func (s *Supervisor) setState(mut func(*Status)) {
+	s.mu.Lock()
+	prev := s.status.State
+	mut(&s.status)
+	if s.status.State != prev {
+		s.status.Since = s.now()
+	}
+	snap := s.status
+	cb := s.onChange
+	s.mu.Unlock()
+	if cb != nil {
+		cb(snap)
+	}
+}
+
+// Status 回傳目前狀態快照。
+func (s *Supervisor) Status() Status {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	return s.status
+}
+
+// Start 啟動看守（非阻塞）。已在跑則忽略。崩潰自動重起，直到 Stop。
+func (s *Supervisor) Start() {
+	s.mu.Lock()
+	if s.running {
+		s.mu.Unlock()
+		return
+	}
+	ctx, cancel := context.WithCancel(context.Background())
+	done := make(chan struct{})
+	s.cancel = cancel
+	s.done = done
+	s.running = true
+	s.mu.Unlock()
+	go func() {
+		defer close(done)
+		s.loop(ctx)
+	}()
+}
+
+// Stop 停止看守，**等目前 loop 完全收掉才回**——這樣 Stop→Start（如換資料夾）不會被舊 loop
+// 的 setState(stopped) 覆寫新狀態。冪等；未在跑時直接回。
+func (s *Supervisor) Stop() {
+	s.mu.Lock()
+	if !s.running {
+		s.mu.Unlock()
+		return
+	}
+	cancel := s.cancel
+	done := s.done
+	s.running = false
+	s.mu.Unlock()
+	if cancel != nil {
+		cancel()
+	}
+	if done != nil {
+		<-done // 等 loop goroutine 真的結束
+	}
+	s.setState(func(st *Status) { st.State = StateStopped })
+}
+
+func (s *Supervisor) backoff() time.Duration {
+	if s.Backoff > 0 {
+		return s.Backoff
+	}
+	return 3 * time.Second
+}
+
+// loop 是看守主迴圈：拉起行程→串流 stdout 更新狀態→退出即重起（除非取消）。
+func (s *Supervisor) loop(ctx context.Context) {
+	for {
+		if ctx.Err() != nil {
+			return
+		}
+		s.setState(func(st *Status) { st.State = StateStarting })
+		err := s.runOnce(ctx)
+		if ctx.Err() != nil { // 被 Stop 取消＝正常收工
+			s.setState(func(st *Status) { st.State = StateStopped })
+			return
+		}
+		// 非預期退出：記錯、重起計數、退避後再拉
+		msg := "行程結束"
+		if err != nil {
+			msg = err.Error()
+		}
+		s.setState(func(st *Status) {
+			st.State = StateError
+			st.LastError = msg
+			st.Restarts++
+		})
+		select {
+		case <-ctx.Done():
+			s.setState(func(st *Status) { st.State = StateStopped })
+			return
+		case <-time.After(s.backoff()):
+		}
+	}
+}
+
+// runOnce 跑一次 collector direct 行程，串流其 stdout JSON 更新狀態，回傳退出原因。
+func (s *Supervisor) runOnce(ctx context.Context) error {
+	cmd := exec.CommandContext(ctx, s.BinPath, "direct", "--config", s.ConfigPath)
+	stdout, err := cmd.StdoutPipe()
+	if err != nil {
+		return err
+	}
+	stderr, err := cmd.StderrPipe()
+	if err != nil {
+		return err
+	}
+	if err := cmd.Start(); err != nil {
+		return err
+	}
+
+	// stderr：留末行當錯誤脈絡
+	go func() {
+		sc := bufio.NewScanner(stderr)
+		for sc.Scan() {
+			line := strings.TrimSpace(sc.Text())
+			if line == "" {
+				continue
+			}
+			s.mu.Lock()
+			s.status.LastError = line
+			s.mu.Unlock()
+		}
+	}()
+
+	// stdout：用 json.Decoder 逐個 JSON 值解（容忍 MarshalIndent 的多行）
+	dec := json.NewDecoder(stdout)
+	for {
+		var r round
+		if derr := dec.Decode(&r); derr != nil {
+			if derr == io.EOF {
+				break
+			}
+			// 非 JSON 雜訊：吞掉剩餘、跳出（行程仍由 Wait 收）
+			io.Copy(io.Discard, stdout)
+			break
+		}
+		at := parseAt(r.At)
+		s.setState(func(st *Status) {
+			st.State = StateWatching
+			st.Rounds++
+			if !at.IsZero() {
+				st.LastRoundAt = at
+			}
+		})
+	}
+	return cmd.Wait()
+}
+
+func parseAt(s string) time.Time {
+	if s == "" {
+		return time.Time{}
+	}
+	if t, err := time.Parse(time.RFC3339, s); err == nil {
+		return t
+	}
+	return time.Time{}
+}

supervisor/supervisor_test.go

@@ -0,0 +1,122 @@
+package supervisor
+
+import (
+	"os"
+	"path/filepath"
+	"runtime"
+	"sync/atomic"
+	"testing"
+	"time"
+)
+
+// fakeCollector 寫一個假的 collector 執行檔（shell 腳本）：忽略參數、印 n 輪 JSON。
+// stayAlive=true → 印完 sleep（模擬常駐 daemon，狀態維持 watching）；false → 印完即退出（觸發重起）。
+func fakeCollector(t *testing.T, rounds int, stayAlive bool) string {
+	t.Helper()
+	if runtime.GOOS == "windows" {
+		t.Skip("fake collector script 走 POSIX shell；Windows 測略過（supervisor 邏輯與平台無關）")
+	}
+	dir := t.TempDir()
+	p := filepath.Join(dir, "fake-collector.sh")
+	body := "#!/bin/sh\n"
+	for i := 0; i < rounds; i++ {
+		body += "printf '{\"at\":\"2026-07-21T00:00:0" + itoa(i) + "Z\",\"folder\":\"/tmp/kb\",\"results\":[]}\\n'\n"
+	}
+	if stayAlive {
+		body += "sleep 2\n"
+	}
+	if err := os.WriteFile(p, []byte(body), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	return p
+}
+
+func itoa(i int) string { return string(rune('0' + i)) }
+
+func waitFor(t *testing.T, d time.Duration, cond func() bool, msg string) {
+	t.Helper()
+	deadline := time.Now().Add(d)
+	for time.Now().Before(deadline) {
+		if cond() {
+			return
+		}
+		time.Sleep(5 * time.Millisecond)
+	}
+	t.Fatalf("timeout waiting for: %s", msg)
+}
+
+func TestSupervisorParsesRoundsAndWatches(t *testing.T) {
+	bin := fakeCollector(t, 2, true)
+	s := New(bin, "cfg.json")
+	s.Backoff = 20 * time.Millisecond
+	s.Start()
+	defer s.Stop()
+
+	waitFor(t, 2*time.Second, func() bool { return s.Status().Rounds >= 2 }, "2 rounds parsed")
+	st := s.Status()
+	if st.State != StateWatching {
+		t.Fatalf("expected watching, got %q", st.State)
+	}
+	if st.LastRoundAt.IsZero() {
+		t.Fatal("LastRoundAt should be parsed from stdout 'at'")
+	}
+	if st.LastRoundAt.Year() != 2026 {
+		t.Fatalf("LastRoundAt parse wrong: %v", st.LastRoundAt)
+	}
+}
+
+func TestSupervisorRestartsOnExit(t *testing.T) {
+	bin := fakeCollector(t, 1, false)
+	s := New(bin, "cfg.json")
+	s.Backoff = 20 * time.Millisecond
+	s.Start()
+	defer s.Stop()
+
+	// 假 collector 印一輪就退出 → supervisor 視為非預期退出 → 重起
+	waitFor(t, 2*time.Second, func() bool { return s.Status().Restarts >= 2 }, "restarts accumulate")
+}
+
+func TestSupervisorStop(t *testing.T) {
+	bin := fakeCollector(t, 1, false)
+	s := New(bin, "cfg.json")
+	s.Backoff = 20 * time.Millisecond
+	s.Start()
+	waitFor(t, 2*time.Second, func() bool { return s.Status().Restarts >= 1 }, "running")
+	s.Stop()
+	waitFor(t, 2*time.Second, func() bool { return s.Status().State == StateStopped }, "stopped after Stop()")
+	// Stop 後不應再累加重起
+	r := s.Status().Restarts
+	time.Sleep(120 * time.Millisecond)
+	if s.Status().Restarts != r {
+		t.Fatalf("restarts kept growing after Stop: %d → %d", r, s.Status().Restarts)
+	}
+}
+
+// 換資料夾＝Stop 緊接 Start；舊 loop 的 setState(stopped) 不可覆寫新 loop 的狀態。
+func TestSupervisorStopThenStartNotLeftStopped(t *testing.T) {
+	bin := fakeCollector(t, 2, true) // stayAlive → 新 loop 進 watching
+	s := New(bin, "cfg.json")
+	s.Backoff = 20 * time.Millisecond
+	s.Start()
+	waitFor(t, 2*time.Second, func() bool { return s.Status().State == StateWatching }, "first watching")
+	s.Stop()  // 同步等舊 loop 收掉
+	s.Start() // 立刻重起（模擬換資料夾）
+	defer s.Stop()
+	waitFor(t, 2*time.Second, func() bool { return s.Status().State == StateWatching }, "watching again after Stop→Start")
+	// 稍等，確認不會被舊 loop 尾巴改回 stopped
+	time.Sleep(100 * time.Millisecond)
+	if got := s.Status().State; got != StateWatching {
+		t.Fatalf("Stop→Start left state=%q (舊 loop 覆寫了新狀態)", got)
+	}
+}
+
+func TestSupervisorOnChangeFires(t *testing.T) {
+	bin := fakeCollector(t, 2, true)
+	s := New(bin, "cfg.json")
+	s.Backoff = 20 * time.Millisecond
+	var calls int32
+	s.SetOnChange(func(Status) { atomic.AddInt32(&calls, 1) })
+	s.Start()
+	defer s.Stop()
+	waitFor(t, 2*time.Second, func() bool { return atomic.LoadInt32(&calls) > 0 }, "onChange fired")
+}