test(testhealth): 替身竞态加锁 + 墙钟断言硬度（M33）

四处测试健康债务，只改 *_test.go，不动生产代码、不降并发：

- channelbridge：stubChatter / stubSessions 的跨 goroutine 字段一律经 mu 访问
  （Run/GetOrCreate 在车道 worker 上写、测试 goroutine 读，两者无 happens-before；
  负向断言「等一会儿再看循环有没有被驱动」尤其如此）。读写走访问器，Messages()
  返回副本；t.Parallel 与并发度不变。
- plugins/tools/io：claimProbeTimeout 2s（真实时间预算）→ 60s，并由 claimProbeWait
  按 t.Deadline 收缩。探针只等 goroutine 被调度（无时间语义），放大余量把
  「机器快慢」从断言里去掉，死锁仍以断言失败暴露。
- backthink：TestSelfWakeGate_WindowExpiry 窗口 120ms → 6s（给 waitFor 的 4s 上界
  留 2s 余量），到期等待改为按首次受理时刻推算 window+250ms，不再盲睡 3×窗口。
  另修 TestSelfWakeStatus_MatchesReceiptAndTracksPendingSlot：worker 先 take 再进
  Think，卡 Think 并不占待跑槽 —— 改为「上一轮把 worker 占住再断言 Pending」。
- memory：墙钟实测用例显式给闸 5s 预算（measureGateBudget），不再因默认 150ms
  超时 fail-open 打炸「每轮都真扫真判」前置断言；并把 GateFailed 纳入该断言。

internal/services/backthink/selfwake_status_test.go

@@ -18,10 +18,19 @@ import (
 // 过期记录）⇒ 本用例在 `Used != receipt.Used` 处变红。
 func TestSelfWakeStatus_MatchesReceiptAndTracksPendingSlot(t *testing.T) {
 	t.Parallel()
-	// worker 卡住 ⇒ 排进去的那一轮不会把槽取走，`pending` 因此可确定地断言。
+	// 让自排轮卡在 Think 里：worker 因此**忙**着，后面排进去的那一轮不会被取走，
+	// `pending` 才能确定地断言。
+	//
+	// 🔴 卡住 Think 只能让 Running 恒真，**不足以**占住待跑槽：worker 是先 take（把槽取空）
+	// 再进 Think 的。旧写法只卡 Think 就断言「排一轮后 Pending=true」，实际是在赌
+	// 「WakeNow 返回得比 worker 取槽快」—— -race 下 worker 常常先跑赢，Pending 已经是
+	// false（本轮实测 3/3 必红）。因此这里改成：第一轮先让 worker 忙起来，第二轮才断言
+	// 待跑槽被占用 —— 断言口径（快照如实报告待跑槽）一字未改，只是把它放到可确定的相位上。
 	w := newWakeThinker()
 	w.holdSelfWake = make(chan struct{})
 	b, _ := startSelfWake(t, Config{SelfWakeLimit: 2, SelfWakeWindow: time.Hour}, w)
+	// 放行卡住的那一轮，好让 Stop 的 t.Cleanup 能排空 worker。
+	defer close(w.holdSelfWake)
 
 	// 启动即有一轮启动轮在跑（tickLoop 上的 TickImmediately），但它不占自排槽。
 	before := mustStatus(t, b)
@@ -54,21 +63,38 @@ func TestSelfWakeStatus_MatchesReceiptAndTracksPendingSlot(t *testing.T) {
 	if !receipt.Accepted {
 		t.Fatalf("收据 = %+v, want Accepted", receipt)
 	}
+	// 等这一轮真的被 worker 取走并卡进 Think（= 槽已空、worker 已忙）：这是下一段的**前置件**，
+	// 等不到说明 worker 没被调度（那是另一个失败，由此处明确报出）。
+	w.waitFor(t, 2, 5*time.Second)
 	after := mustStatus(t, b)
 	if after.Used != receipt.Used || after.Used != 1 {
 		t.Fatalf("快照 Used = %d, 收据 Used = %d, want 1（同一口径）", after.Used, receipt.Used)
 	}
-	if !after.Pending {
-		t.Fatalf("排入后待跑槽应报告占用：%+v", after)
+
+	// worker 正忙 ⇒ 这一轮留在待跑槽里：快照必须如实报告 Pending。
+	pending, err := b.WakeNow(ownerCtx(), SelfWakeRequest{Reason: "占住待跑槽"})
+	if err != nil {
+		t.Fatalf("WakeNow 占槽: %v", err)
+	}
+	if !pending.Accepted {
+		t.Fatalf("收据 = %+v, want Accepted（worker 正忙，槽是空的）", pending)
+	}
+	occupied := mustStatus(t, b)
+	if !occupied.Pending {
+		t.Fatalf("排入后待跑槽应报告占用：%+v", occupied)
+	}
+	if occupied.Used != pending.Used || occupied.Used != 2 {
+		t.Fatalf("快照 Used = %d, 收据 Used = %d, want 2（同一口径，槽满=额度用尽）",
+			occupied.Used, pending.Used)
 	}
 
-	// 第二次撞上满槽 ⇒ 合并（不消耗额度），快照的 Used 不得变。
+	// 撞上满槽 ⇒ 合并（不消耗额度），快照的 Used 不得变。
 	if _, err := b.WakeNow(ownerCtx(), SelfWakeRequest{Reason: "再排一轮"}); err != nil {
 		t.Fatalf("WakeNow 合并: %v", err)
 	}
 	merged := mustStatus(t, b)
-	if merged.Used != 1 {
-		t.Fatalf("合并后 Used = %d, want 1（合并不额外占额度）", merged.Used)
+	if merged.Used != 2 {
+		t.Fatalf("合并后 Used = %d, want 2（合并不额外占额度，停在 Limit）", merged.Used)
 	}
 	if merged.Limit != 2 {
 		t.Fatalf("合并后 Limit = %d, want 2", merged.Limit)

internal/services/backthink/selfwake_test.go

@@ -480,23 +480,43 @@ func TestWakeNow_ZeroLimitFallsBackToDefault(t *testing.T) {
 }
 
 // TestSelfWakeGate_WindowExpiry 覆盖「窗口过期后额度回来」。session.RateLimiter 内部
-// 用 time.Now()（design/12 §N C.5 已登记的取舍：不为自排再自造第二套滑窗），因此这里
-// 用极小窗口 + 真实短等，只取下界判断（等过窗口必放行），不依赖上界精度。
+// 用 time.Now()（design/12 §N C.5 已登记的取舍：不为自排再自造第二套滑窗），因此窗口
+// **无法注入假时钟** —— 这里只能把余量放大到与真实机器负载相称，断言口径不变：
+// 窗口内第二次必被拒、等过窗口必放行且 Used 回到 1。
+//
+// 为什么是 6s（旧值 120ms）：
+//   - 「窗口内第二次」这条断言要求「第一次受理 → worker 真的进入两轮（waitFor）→ 第二次
+//     调用」整段落在窗口内；waitFor 那一段是纯调度等待，73 个测试包并行抢核时会被拉长，
+//     120ms 一被拉长就必红（本轮其他证人实测红；本机 12 核上 30~60 次带载复跑未复现，
+//     所以这里按**余量**加固而不是拿复现驱动）。窗口取 6s ⇒ 给 waitFor 的 4s 上界留下
+//     2s 余量：哪怕 waitFor 用满上界，也仍在窗口内，失败点因此只会是「worker 没被调度」
+//     而不是一条含义被负载改写的窗口断言。
+//   - 到期等待不再是盲睡 3×窗口（放大后那是 18s 白等）：以**第一次受理时刻**为基准，
+//     等到「窗口 + 250ms 结算余量」，既保留「等过窗口必放行」的下界语义，又不浪费墙钟。
 func TestSelfWakeGate_WindowExpiry(t *testing.T) {
 	t.Parallel()
-	const window = 120 * time.Millisecond
+	const (
+		window = 6 * time.Second
+		// scheduleWait 是「worker 已被调度」这个前置件的上界，必须小于 window。
+		scheduleWait = 4 * time.Second
+		// expirySettle 是窗口到期后的结算余量（RateLimiter 用 t.After(cutoff) 严格比较）。
+		expirySettle = 250 * time.Millisecond
+	)
 	w := newWakeThinker()
 	b, _ := startSelfWake(t, Config{SelfWakeLimit: 1, SelfWakeWindow: window}, w)
 
+	firstAt := time.Now()
 	if got, err := b.WakeNow(ownerCtx(), SelfWakeRequest{Reason: "第一次"}); err != nil || !got.Accepted {
 		t.Fatalf("第一次收据 = %+v err = %v, want 排上", got, err)
 	}
-	w.waitFor(t, 2, 3*time.Second)
+	w.waitFor(t, 2, scheduleWait)
 	if got, err := b.WakeNow(ownerCtx(), SelfWakeRequest{Reason: "窗口内第二次"}); err != nil || got.Accepted {
 		t.Fatalf("窗口内第二次收据 = %+v err = %v, want 被上限拒绝", got, err)
 	}
 
-	time.Sleep(3 * window)
+	if wait := window + expirySettle - time.Since(firstAt); wait > 0 {
+		time.Sleep(wait)
+	}
 	got, err := b.WakeNow(ownerCtx(), SelfWakeRequest{Reason: "窗口过了"})
 	if err != nil {
 		t.Fatalf("窗口过后 WakeNow: %v", err)