docs(assistant): 被權限擋下的指令，回報要帶完整指令列

實測踩到一輪：它報「寫入監控頁失敗——系統的核准機制擋下這個寫入指令，重試
一次仍被擋下，不是 Gitea 回傳的錯誤碼」，然後照規則中止、釋放鎖、不寫心跳。
中止的行為完全正確，寫不成頁就不該假裝跑完。

但那一輪沒說是哪一支工具、哪一條指令。事後把明顯的嫌疑一個一個排除——那一支
腳本實測在無人值守下放行、暫存檔路徑落在檔案規則的範圍內、條目也帶著寫入
確認旗標——真正被擋的那一條始終沒找到。那一輪到現在還是原因不明。

問題在於「擋下」不是工具回的錯誤：沒有結束碼、沒有 stderr、工具自己的日誌上
也沒有痕跡。指令字面是唯一的證據，也是唯一能拿去對允許清單的東西，而清單
比對的是還沒展開的指令字面。所以少了那一行，事後就只能猜。

兩處都加：寫監控頁那一步的失敗分流加一條，界線那一段再加一條通則，涵蓋整輪
任何一次被擋。要求含環境變數前綴——那算指令字面的一部分，今天量過。

三份 manifest 版號從 0.2.9 升到 0.3.1。原本寫 0.2.10，同步 manifest 那一支
把它正規化掉了——那一支不收兩位數的修訂號。

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "jsc-assist",
-  "version": "0.2.6",
+  "version": "0.3.1",
   "description": "助理：事件收攏、健康巡檢與待辦簿（MONITOR_{HASH} wiki 頁）",
   "skills": "./skills",
   "author": {

.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "jsc-assist",
-  "version": "0.2.6",
+  "version": "0.3.1",
   "description": "助理：事件收攏、健康巡檢與待辦簿（MONITOR_{HASH} wiki 頁）",
   "skills": "./skills",
   "jsc": {

plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "jsc-assist",
-  "version": "0.2.6",
+  "version": "0.3.1",
   "description": "助理：事件收攏、健康巡檢與待辦簿（MONITOR_{HASH} wiki 頁）",
   "skills": "./skills/",
   "jsc": {

skills/assistant/SKILL.md

@@ -71,7 +71,7 @@ Every tool below is addressed through `{CURRENT}/{plugin}`, with `{CURRENT}` sta
 
 | What it does | Path to run |
 | --- | --- |
-| one patrol round | `{CURRENT}/jsc-assist/tools/patrol.sh` |
+| one patrol round, and joining the monitor page's three blocks | `{CURRENT}/jsc-assist/tools/patrol.sh` |
 | the system scheduler | `{CURRENT}/jsc-assist/tools/schedule.sh` |
 | the task book, the only writer there is | `{CURRENT}/jsc-assist/tools/tasks.sh` |
 | the built-in check items, reconciled against the delegation list | `{CURRENT}/jsc-assist/tools/seed-tasks.sh` |
@@ -303,6 +303,7 @@ The delegation list holds one row per jsc skill and records whether that skill c
 The six limits in `AGENTS.md`「助理的界線」 hold for all four operations. Four of them need saying out loud here:
 
 - **This skill never judges a gate.** It maintains the heartbeat and prints what the heartbeat says. Whether a stale heartbeat blocks a skill call is decided by a hook, synchronously and offline; nothing in this skill blocks or waves through anything. 界線 2.
+- **A command the permission layer refuses is reported with its full command line, wherever in the round it happened.** A refusal is not an error the tool returned: there is no exit code, no stderr, and nothing in the tool's own log. The command text is the only evidence, and it is the only thing that can be checked against the allow list — which matches the text as written, before the shell expands anything. So quote the line verbatim, prefix included, and name the step that submitted it. 界線 1 says a round never asks; this is what makes a refused round diagnosable instead of merely reported. One round wrote 「the write was refused」 and named neither the command nor the tool: every obvious suspect was ruled out afterwards and the real one was never found, so that round is still unexplained.
 - **A patrol round asks nothing.** It runs from cron with nobody present, so there is no one to answer and a question hangs the round. Every branch in the patrol steps below resolves without a question: a missing source is recorded as missing, an ambiguous result is recorded verbatim, and a round that cannot proceed aborts and reports. Never call `jsc-ask:ask` from `patrol`. A command that is not on the allow list is a question too — the permission prompt is one, and it is the one nobody sees — which is why step 0 hands that round its root instead of letting it resolve one. 界線 1.
 - **A patrol round rewrites the monitor page as three fixed blocks.** Read the old page back first; keep 本頁基本資料 as it stands, replace 最新一輪 whole, put this round's row on top of the summary table and cut it to 24; then put the whole page. The directory page is a separate write in a separate wiki repo, and `wiki-contents.sh` does it: that page keeps one H2 block per machine, and this machine's block is the only one that is updated. A page that could not be read is a page that does not get written — the summary table only survives if the old one came back. 界線 4.
 - **A patrol round reports; it never acts on what it found.** The 待人處理 rows name an entry point for a human. The patrol does not run that entry point, does not fix a hook, does not update a plugin and does not touch a repository. 界線 3 and 界線 6.
@@ -346,7 +347,7 @@ That property holds only while nothing fakes a heartbeat. **`write` is called by
 
 One round: read five sources, record the result, then beat. Everything before the heartbeat is read-only except the round's own scratch files. Ask nobody anything.
 
-1. **Collect.** Run `{CURRENT}/jsc-assist/tools/patrol.sh collect --trigger 排程` (use `--trigger 手動` when a person asked for this round). That is the same split step 0 branched on: 排程 is the unattended round that read its root out of the invocation text, 手動 the round somebody asked for. Judge the exit code by the patrol.sh table. Exit 4 stands the round down — report the holder and its age from the printed `lock=busy` line, and stop; write no page and no heartbeat. Exit 5 and 6 stop the round the same way, with the code and the stderr text. Exit 0, 1 and 3 all carry on to step 2. Record `round=`, `lock_broken=`, `hash=`, `page=`, `verdict=`, `failed_sources=`, `warn_sources=`, `pending=`, every `item=` line, and the file paths `latest_file=`, `summary_file=`, `summary_row_file=`, `newpage_file=` and `contents_file=`. Completion condition: the round id, the page name and the five file paths are recorded, or the stand-down or the failure was reported and the round stopped.
+1. **Collect.** Run `{CURRENT}/jsc-assist/tools/patrol.sh collect --trigger 排程` (use `--trigger 手動` when a person asked for this round). That is the same split step 0 branched on: 排程 is the unattended round that read its root out of the invocation text, 手動 the round somebody asked for. Judge the exit code by the patrol.sh table. Exit 4 stands the round down — report the holder and its age from the printed `lock=busy` line, and stop; write no page and no heartbeat. Exit 5 and 6 stop the round the same way, with the code and the stderr text. Exit 0, 1 and 3 all carry on to step 2. Record `round=`, `lock_broken=`, `hash=`, `page=`, `verdict=`, `failed_sources=`, `warn_sources=`, `pending=`, every `item=` line, and the file paths `latest_file=`, `summary_file=`, `summary_row_file=`, `newpage_file=`, `contents_file=` and `due_rows_file=` — that last one is what step 5 has to be given, and an empty value there means the judging step produced no list, so step 5 has nothing to act on and says so rather than falling back to anything. Completion condition: the round id, the page name and the five file paths are recorded, or the stand-down or the failure was reported and the round stopped.
 
    **The status event lines come out of the same call.** `collect` drained the stream and rotated it (see 「The status event stream」 above), so record `events_total=`, `events_bad=`, `events_unpaired=`, `events_running=`, `events_rotated=` and `events_file=` alongside the rest, and read `item=D-11` for whether that source was readable at all. The 執行狀態事件 subsection of `latest_file` already carries the two detail tables — the non-`ok` events and the starts with no matching end — so never rebuild either by hand and never call `report-status.sh` yourself: a second `drain` this round would either return exit 3 or eat events that then reach no page at all.
 
@@ -356,15 +357,21 @@ One round: read five sources, record the result, then beat. Everything before th
 
 3. **Rebuild `MONITOR_{HASH}` from its three blocks.** Hand it to `jsc-gitea:wiki` with page type `MONITOR`, so the repo is the one `gitea.sh wiki-repo MONITOR` resolves — `JSC_WIKI_REPO_MONITOR`, then `JSC_WIKI_REPO`, then exit 3. This is the content page and it stays in that repo; only the directory page of step 4 moved to the `CONTENTS` repo, and neither chain ever falls back to the other. Read the page back first, then build the new body out of what came back plus this round's files, in this order and with nothing else on the page:
 
+   **The three blocks are joined by `{CURRENT}/jsc-assist/tools/patrol.sh rebuild --old {the file the old page was read into}`, never by hand.** It prints `rebuilt_file=` — put that file. It also prints `old_format=`, `blocks=`, `summary_rows=` and `old_rows_kept=`; carry those into the report. Exit 6 means an argument was rejected or the old-page file is not there, exit 5 a scratch file could not be written; both take step 3's abort row.
+
+   Joining them by hand is what this replaces, and the reason is worth keeping. The join is a fixed shape, so leaving it to the caller meant a fresh agent picked its own tools for it every round: one round reached for `awk`, was refused by the permission gate twice, worked around it because somebody was there to watch, and said in its own report that the same refusal would hang an unattended round — with the round lock already taken. The scratch directory had accumulated 124 files by then, named `newpage.md`, `new-page.md`, `new_page.md`, `page-new.md` and so on: the same join, redone every round, under a different set of names. **A step with one correct shape does not belong in a prompt.** What the script joins:
+
    | Block | Where it comes from |
    | --- | --- |
-   | 本頁基本資料 | the old page, byte for byte from its heading to the line before 最新一輪. Never rewritten, never re-derived |
+   | 本頁基本資料 | the old page, byte for byte from its heading to the line before 最新一輪. Never rewritten, never re-derived — the script does not even normalise its trailing blank lines |
    | 最新一輪 | the whole content of `latest_file`, replacing the old block entirely |
    | 近 24 輪摘要 | `summary_file`, which already holds the heading, the five-column table header (`巡檢時間`、`本輪判定`、`各項成敗`、`待人處理`、`警示來源`) and this round's row; then the old table's data rows in their old order underneath, cut so the table holds at most 24 rows |
 
+   An old-format page — per-round sections stacked up, no 最新一輪 heading — is detected by the script itself, which keeps the basic-data block, drops the stacked sections, starts the table with this round's row, and prints `old_format=yes converted=1`. Report that the page was converted.
+
    **Verify the page's links before the write.** List every link the rebuilt body carries — the ones the latest-round block brought in, and any that survived in the block carried over from the old page — and run `{CURRENT}/jsc-gitea/tools/link-check.sh` over the whole list. Exit 0 is the only result that permits the write. On exit 1 report the `DEAD` lines verbatim, then run `{CURRENT}/jsc-assist/tools/patrol.sh abort --round {round}` and stop: a round that writes a dead link records a false trail nobody can follow back. Exits 2, 3 and 7 take the same abort, each reported by the rule B table above. A body carrying no link at all needs no call — say so in the report rather than claiming a check that never ran.
 
-   Put the whole page. An old-format page — per-round sections stacked up, no summary table — has no rows to carry over: keep its `本頁基本資料` block, drop the stacked sections, let the table start with this round's row, and say in the report that the page was converted. Only exit 4 from the read permits creating the page instead, and then the body is the whole content of `newpage_file`, which already carries all three blocks. Exit 7 and exit 8 mean the old content is unknown: create nothing, write nothing — rebuilding a page from an unknown original throws the summary table away. On any write failure — including exit 3 with no wiki repo configured for `MONITOR`, which the patrol cannot ask about — run `{CURRENT}/jsc-assist/tools/patrol.sh abort --round {round}`, report the code, and stop. **No record, no heartbeat**, and that verdict belongs to this step alone: the round's result lives on this page, so a repo this step cannot resolve leaves the round with nowhere to be recorded. Step 4 is judged on its own terms. Completion condition: `link-check.sh` exited 0 over the body's links or the body carried none, the put or the create returned success, and the page holds exactly three blocks with the summary table at 24 rows or fewer and this round's row on top, or the abort ran and the round was reported as unrecorded with its exit code.
+   Put the whole page. Only exit 4 from the read permits creating the page instead, and then the body is the whole content of `newpage_file`, which already carries all three blocks. Exit 7 and exit 8 mean the old content is unknown: create nothing, write nothing — rebuilding a page from an unknown original throws the summary table away. On any write failure — including exit 3 with no wiki repo configured for `MONITOR`, which the patrol cannot ask about — run `{CURRENT}/jsc-assist/tools/patrol.sh abort --round {round}`, report the code, and stop. **When the write did not fail but was refused — the permission layer stopped the command before it ran — the report MUST carry the command line verbatim, exactly as it was submitted.** A refusal has no exit code and no stderr from the tool, so the command text is the only thing that can be held against the allow list, and the allow list matches the text as written. A report that says only 「the write was refused」 cannot be acted on: this happened, and the round that hit it named neither the command nor the tool, so every obvious suspect had to be ruled out one at a time and the actual one was never found. Quote the whole line — the environment-variable prefix included, since that counts as part of what the rule is matched against — and say which step submitted it. **No record, no heartbeat**, and that verdict belongs to this step alone: the round's result lives on this page, so a repo this step cannot resolve leaves the round with nowhere to be recorded. Step 4 is judged on its own terms. Completion condition: `link-check.sh` exited 0 over the body's links or the body carried none, the put or the create returned success, and the page holds exactly three blocks with the summary table at 24 rows or fewer and this round's row on top, or the abort ran and the round was reported as unrecorded with its exit code.
 
 4. **Update this machine's block in `MONITOR_CONTENTS`, through `jsc-gitea/tools/wiki-contents.sh`.** That page is a directory every machine writes to, and it lives in the repo `gitea.sh wiki-repo CONTENTS` resolves — `JSC_WIKI_REPO_CONTENTS`, then `JSC_WIKI_REPO`, then exit 3, and never a fallback to `JSC_WIKI_REPO_MONITOR`. The page carries no table: it is an H1, a `>` preamble, and then one H2 block per machine — the heading is that machine's monitor page name, and the fields are one `- {name}：{value}` bullet each underneath. The script owns the read-match-write of one block, so never read this page and rebuild it by hand, never write it through `jsc-gitea:wiki`, and never rebuild it the way step 3 rebuilds the content page — every other block here belongs to a machine that is not this one, and one careless whole-page write deletes their records.
 
@@ -392,7 +399,7 @@ One round: read five sources, record the result, then beat. Everything before th
 
    Completion condition: `link-check.sh` exited 0 over the block's URL and the script exited 0 with exactly one `## MONITOR_{HASH}` block on the page carrying this round's values, or exit 3 from the upsert or a non-zero `link-check.sh` was reported as an unwritten directory entry and the round carried on, or one of the other non-zero codes — `wiki-url`'s included — was reported after the abort ran.
 
-5. **Run the built-in check items that are due.** Run `{CURRENT}/jsc-assist/tools/run-due.sh run --root {CURRENT}`. This is the one step of the round that changes something outside the round's own files, and it is deliberately narrow: it runs only the entries whose `action` is a command and whose `spec_key` is set, so a reminder, a skill name and anything a person entered by hand are all left alone. Judge the exit code by the run-due.sh table, and keep every `done=`, `failed=`, `held=`, `skip=`, `write_failed=`, `target_ok=` and `target_fail=` line plus the summary counts for the report. **No exit code from this step stops the round.** Exit 1 means an entry's command failed and that entry now carries one more failure — that is a finding, not a broken round; exit 4 means a write-back failed, so the same entry will run again next round, which is worth saying out loud; exit 2, 5 and 6 mean nothing ran, and the round still has a result to record. Completion condition: the exit code and the summary counts are recorded, and step 6 was reached whatever that code was.
+5. **Run the built-in check items that are due.** Run `{CURRENT}/jsc-assist/tools/run-due.sh run --root {CURRENT} --rows {the `due_rows_file=` step 1 printed}`. **That path is not optional and there is no default.** The judging step writes its output into the directory whoever called it chose, so a default would point somewhere else — and it did: the tool shipped with one, and every round read a file a person had left behind by running the judge by hand. That file sat on this machine for 67 hours while each round acted on it, one round even running an entry that had already been removed. Nothing looked wrong, because the stale list had been correct when it was written and its contents happened not to change. Passing the path makes each round say which round's data it is acting on; the tool also refuses a list older than the heartbeat TTL, because a list older than that cannot describe this round. This is the one step of the round that changes something outside the round's own files, and it is deliberately narrow: it runs only the entries whose `action` is a command and whose `spec_key` is set, so a reminder, a skill name and anything a person entered by hand are all left alone. Judge the exit code by the run-due.sh table, and keep every `done=`, `failed=`, `held=`, `skip=`, `write_failed=`, `target_ok=` and `target_fail=` line plus the summary counts for the report. **`cli_missing=` is the one to read carefully.** It names the CLIs the scheduled entry recorded at install time that this round could not detect, and it is the only place that gap shows: every target that was detected still ran, still passed, and the round still reports "all of them ran", because without that comparison nothing knows how many there should have been. One round reported four CLIs all passing on a machine with five installed. The usual cause is a CLI whose executable sits in a directory that expires — one here lives under a process-numbered multishell path — while the entry's `PATH` was snapshotted at install time. Report the named CLIs, say that a clean pass is not the same as a full pass, and name re-running the schedule install as what refreshes the snapshot. **No exit code from this step stops the round.** Exit 1 means an entry's command failed and that entry now carries one more failure — that is a finding, not a broken round; exit 4 means a write-back failed, so the same entry will run again next round, which is worth saying out loud; exit 2, 5 and 6 mean nothing ran, and the round still has a result to record. Completion condition: the exit code and the summary counts are recorded, and step 6 was reached whatever that code was.
 
 6. **Write the heartbeat.** Run `{CURRENT}/jsc-assist/tools/patrol.sh finish --round {round}`. This is the last step for a reason: it is the only thing that turns a fresh heartbeat into a true statement. Judge the exit code by the patrol.sh table — 2, 4 and 5 all mean the round is recorded but unproven, and each has its own report line there. Completion condition: `finish` exited 0, or the failure was reported as "recorded but no heartbeat" with its code.
 

tools/patrol.sh

@@ -205,6 +205,7 @@ WARN=0
 DUE_STATUS=fail
 DUE_RC=0
 DUE_MD=''
+DUE_ROWS=''
 DUE_NOTE=''
 DUE_TASKS=''
 DUE_EVENTS=''
@@ -237,6 +238,7 @@ usage() {
 usage: patrol.sh collect [--out 目錄] [--trigger 排程|事件|手動]
        patrol.sh finish  --round 輪次代號 [--out 目錄] [--dry-run]
        patrol.sh abort   --round 輪次代號 [--out 目錄]
+       patrol.sh rebuild --old 舊頁檔 [--out 目錄]
 EOF
   exit 6
 }
@@ -911,6 +913,11 @@ due_scan() {
   JSC_HOME="$JSC_HOME" sh "$_due" scan --out "$RD/due" >"$RD/due.out" 2>"$RD/due.err" </dev/null || _rc=$?
   DUE_RC="$_rc"
   DUE_MD=$(sed -n 's/^due_file=//p' "$RD/due.out" 2>/dev/null | head -n1)
+  # 機器可讀的那一份也要轉出去。判到期與執行是兩支腳本，中間靠這個檔案交棒；不轉出去
+  # 呼叫端就只能靠預設路徑猜，而那個預設指向的是上一次有人手動跑 scan 留下的檔案。
+  # 實測踩過：那份舊清單在機器上放了六小時，執行那一支每一輪都對它動手，跑的是一筆已經
+  # 被移除的待辦，而且看起來完全正常——舊清單當時是對的，內容剛好沒變。
+  DUE_ROWS=$(sed -n 's/^rows_file=//p' "$RD/due.out" 2>/dev/null | head -n1)
   DUE_TASKS=$(sed -n 's/^tasks_due=//p' "$RD/due.out" 2>/dev/null | head -n1)
   DUE_EVENTS=$(sed -n 's/^events_new=//p' "$RD/due.out" 2>/dev/null | head -n1)
   case "$_rc" in
@@ -1078,7 +1085,7 @@ compose() {
 CMD="${1:-}"
 [ -n "$CMD" ] || usage
 shift
-case "$CMD" in collect|finish|abort) ;; *) usage ;; esac
+case "$CMD" in collect|finish|abort|rebuild) ;; *) usage ;; esac
 
 OUT=''
 while [ "$#" -gt 0 ]; do
@@ -1087,9 +1094,11 @@ while [ "$#" -gt 0 ]; do
     --trigger) [ "$#" -ge 2 ] || usage; TRIGGER="$2"; shift 2 ;;
     --round) [ "$#" -ge 2 ] || usage; ROUND="$2"; shift 2 ;;
     --dry-run) DRYRUN=1; shift ;;
+    --old) [ "$#" -ge 2 ] || usage; OLD_PAGE="$2"; shift 2 ;;
     *) usage ;;
   esac
 done
+OLD_PAGE="${OLD_PAGE:-}"
 [ -n "$OUT" ] && RD="$OUT"
 
 case "$CMD" in
@@ -1154,6 +1163,7 @@ case "$CMD" in
     printf 'due_status=%s\n' "$DUE_STATUS"
     printf 'due_rc=%s\n' "$DUE_RC"
     printf 'due_file=%s\n' "$DUE_MD"
+    printf 'due_rows_file=%s\n' "${DUE_ROWS:-}"
     printf 'pending=%s\n' "$PEND_COUNT"
     printf 'events_total=%s\n' "$EV_TOTAL"
     printf 'events_bad=%s\n' "$EV_BAD"
@@ -1204,4 +1214,54 @@ case "$CMD" in
     printf 'heartbeat=not-written\n'
     lock_release
     exit 0 ;;
+
+  # 拿舊頁重組出要寫回去的整頁。三塊的接法固定，所以由這一支做完，呼叫端只要「讀回舊頁、
+  # 叫這一支、把結果寫回去」三步。
+  #
+  # 為什麼要有這個子命令：接三塊這件事本來留給呼叫端，而呼叫端是一個代理人，於是它每一輪
+  # 臨場挑工具——實測某一輪挑了 awk，兩次都被權限擋掉；那一輪有人在場所以它改用別的方式繞
+  # 過去了，並且自己指出無人值守那一輪遇到同一個擋法會直接卡住，而鎖在第一步就取走了。
+  # 更根本的是暫存目錄實測累積了 124 個檔案，名字是 newpage.md、new-page.md、new_page.md、
+  # page-new.md 這種——同一件事每輪重做一次，每輪換一組檔名。規格說那裡只該有五個檔案。
+  # 接法寫死在這裡之後，那一步不再需要任何通用文字工具，也就沒有東西可以被擋。
+  rebuild)
+    [ -n "$OLD_PAGE" ] || usage
+    [ -f "$OLD_PAGE" ] || die 6 "舊頁檔讀不到：$OLD_PAGE。這一支不自己讀 wiki，舊頁要由呼叫端先取下來。"
+    for _f in "$RD/latest.md" "$RD/summary.md"; do
+      [ -f "$_f" ] || die 6 "$_f 不在。rebuild 要接的是同一輪 collect 產出的那幾塊，先跑 collect。"
+    done
+    _out="$RD/rebuilt.md"
+    # 舊頁那一塊「本頁基本資料」原樣留著，從它的標題到「最新一輪」前一行為止。整頁沒有
+    # 「最新一輪」那個標題時視為舊格式：基本資料留著、堆疊的各輪小節丟掉，摘要表從本輪開始。
+    if grep -q '^## 最新一輪' "$OLD_PAGE" 2>/dev/null; then
+      awk '/^## 最新一輪/{exit} {print}' "$OLD_PAGE" >"$RD/rb-head.md" 2>/dev/null         || die 5 "暫存檔寫不進去：$RD/rb-head.md。"
+      printf 'old_format=no\n'
+    else
+      awk '/^## /{n++} n<=1{print}' "$OLD_PAGE" >"$RD/rb-head.md" 2>/dev/null         || die 5 "暫存檔寫不進去：$RD/rb-head.md。"
+      printf 'old_format=yes converted=1\n'
+    fi
+    # 舊表的資料列照原順序留在本輪那一列底下，整張表截到 24 列。摘要那一塊已經含標題、
+    # 表頭與本輪那一列，所以這裡只補舊列。
+    awk '/^## 近 24 輪摘要/{f=1;next} f && /^\| 2/{print}' "$OLD_PAGE" >"$RD/rb-rows.md" 2>/dev/null       || die 5 "暫存檔寫不進去：$RD/rb-rows.md。"
+    _new_rows=$(awk '/^\| 2/{n++} END{print n+0}' "$RD/summary.md")
+    _keep=$((24 - _new_rows))
+    [ "$_keep" -lt 0 ] && _keep=0
+    # 基本資料那一塊逐字照抄，連尾端空行都不動——技能本文寫的是「逐字保留」，剝掉再補一個
+    # 雖然內容沒少，那句話就變成假的了。只在它沒有以空行收尾時補一個分隔，免得下一塊的
+    # 標題黏在表格最後一列後面。
+    _tail=$(awk 'END{print (NF==0 ? "blank" : "text")}' "$RD/rb-head.md" 2>/dev/null)
+    {
+      cat "$RD/rb-head.md"
+      [ "$_tail" = "blank" ] || printf '\n'
+      cat "$RD/latest.md"
+      printf '\n'
+      cat "$RD/summary.md"
+      [ "$_keep" -gt 0 ] && head -n "$_keep" "$RD/rb-rows.md"
+    } >"$_out" 2>/dev/null || die 5 "暫存檔寫不進去：$_out。"
+    printf 'rebuilt_file=%s\n' "$_out"
+    printf 'blocks=%s summary_rows=%s old_rows_kept=%s\n' \
+      "$(grep -c '^## ' "$_out")" \
+      "$(awk '/^## 近 24 輪摘要/{f=1;next} f && /^\| 2/{n++} END{print n+0}' "$_out")" \
+      "$([ "$_keep" -gt 0 ] && awk 'END{print NR+0}' "$RD/rb-rows.md" | awk -v k="$_keep" '{print ($1<k?$1:k)}' || echo 0)"
+    exit 0 ;;
 esac

tools/run-due.sh

@@ -95,7 +95,19 @@ case "$JSC_HOME_RESOLVED" in
   /*) ;;
   *) die 6 'JSC_HOME 與 HOME 都解不出絕對路徑，找不到助理狀態目錄。' ;;
 esac
-[ -n "$ROWS" ] || ROWS="$JSC_HOME_RESOLVED/assistant/due/rows.txt"
+# --rows 沒有預設值，一律要指定。
+#
+# 原本有預設，指向助理狀態目錄底下那一份。那個預設是這一支上線之後最嚴重的一個缺陷：
+# 判到期那一支是被巡檢用 --out 叫的，輸出寫進那一輪自己的暫存目錄，跟這個預設不是同一個
+# 位置。於是這一支每一輪讀的都是「上一次有人手動跑 scan 留下的那一份」。實測那份清單在
+# 機器上放了六小時，這一支每一輪都對它動手，還跑了一筆已經被移除的待辦。
+# 而它看起來完全正常——那份舊清單產生的當下是對的，內容剛好沒變。**錯了六小時才顯形。**
+#
+# 所以不留預設。少帶這個選項就回用法錯誤，吵一次總比安靜地對舊資料動手好。呼叫端要拿
+# collect 印的 due_rows_file= 餵進來，那是同一輪產生的那一份。
+if [ -z "$ROWS" ]; then
+  die 6 '沒有帶 --rows。這一支不猜到期清單的位置：判到期那一支的輸出寫在叫它的人指定的目錄裡，猜一個預設就會讀到別人留下的舊檔案，而舊檔案讀起來跟新的一模一樣。請把 collect 印的 due_rows_file= 餵進來。'
+fi
 
 [ -f "$ROWS" ] || die 2 "到期清單讀不到：$ROWS。請先跑 due.sh scan——沒跑過判定，跟「都沒到期」不是同一件事。"
 
@@ -121,6 +133,26 @@ find_tool() { # $1=domain $2=相對路徑
   return 1
 }
 
+# 清單太舊就拒跑。判到期與執行之間隔著呼叫端，那一段有可能斷掉——collect 失敗了而那一輪
+# 照樣往下走，或呼叫端餵進上一輪的路徑。兩種都會讓這一支對著一份不描述現況的清單動手，
+# 而那正是它上線之後六小時裡在做的事。
+# 門檻取心跳的過期門檻：那是這台機器認定「一輪跑完的紀錄還算新鮮」的長度，一份比它還舊的
+# 到期清單本來就不可能是這一輪產生的。讀不到門檻就退回 300 秒，跟心跳那一支的預設一致。
+_ttl=''
+if _hb=$(find_tool hooks hooks/heartbeat.sh 2>/dev/null); then
+  _ttl=$("$_hb" report 2>/dev/null | sed -n 's/.*[[:space:]]ttl=\([0-9]*\).*/\1/p' | head -n1)
+fi
+case "${_ttl:-}" in
+  ''|*[!0-9]*) _ttl=300 ;;
+esac
+_mtime=$(date -r "$ROWS" +%s 2>/dev/null) || _mtime=''
+if [ -n "$_mtime" ]; then
+  _age=$((NOW - _mtime))
+  if [ "$_age" -gt "$_ttl" ]; then
+    die 2 "到期清單是 $_age 秒前產生的，超過門檻 $_ttl 秒，這一支不對它動手：$ROWS。一份比心跳門檻還舊的清單不可能描述這一輪，照著跑會動到已經不存在的待辦。請確認判到期那一步這一輪真的跑成功了，再把它印的路徑餵進來。"
+  fi
+fi
+
 TASKS_SH="$HERE/tasks.sh"
 [ -f "$TASKS_SH" ] || TASKS_SH=$(find_tool assist tools/tasks.sh) \
   || die 2 '找不到 tasks.sh，成敗沒有地方回寫。待辦簿只有一個寫入者，缺了它這一輪不該跑。'
@@ -137,6 +169,23 @@ if _det=$(find_tool cli tools/detect-clis.sh); then
 fi
 N_CLI=$(awk 'END{print NR+0}' "$CLIS")
 
+# 跟排程條目安裝當下記下的那一份比對。少了哪一支要點名，不是只印個數字。
+#
+# 為什麼要比：偵測那一支純看 PATH，分不出「裝了但執行檔不在 PATH 上」。而條目帶的 PATH 是
+# 安裝當下拍的，其中某些 CLI 裝在會過期的目錄底下——實測有一支裝在帶行程編號的多殼層目錄，
+# 重開機之後那條路徑就不在了。
+# 沒有基準的後果不是報錯，是安靜地少做一支：這一輪照樣把偵測到的每一支都跑過、照樣全部
+# 成功、照樣回報「都跑過了」。實測那一輪報「對 4 支 CLI 都跑過，全部成功」，而機器上裝了
+# 5 支——報告讀起來完全正常。
+# 只報不修：那條路徑本質上是暫時的，真正的解法是那支 CLI 該裝在穩定位置，或者重跑一次
+# 排程安裝重新拍一份快照。兩件都不是這一支該替人決定的。
+CLI_MISSING=''
+if [ -n "${JSC_ASSIST_CLIS:-}" ]; then
+  for _want in $JSC_ASSIST_CLIS; do
+    grep -qxF "$_want" "$CLIS" 2>/dev/null || CLI_MISSING="${CLI_MISSING:+$CLI_MISSING、}$_want"
+  done
+fi
+
 # {repo} 的代入來源還沒做出來。這裡不猜一個掃描規則頂替：猜錯就是在整台機器上跑指令，
 # 而那一輪沒有人看得到它跑到哪裡去了。
 REPO_READY=0
@@ -313,10 +362,11 @@ while IFS="$TAB" read -r c_id c_verdict c_state c_kind c_action c_trigger c_recu
   fi
 done <"$ROWS"
 
-printf 'mode=%s rows=%s root=%s due=%s ran=%s ok=%s failed=%s held=%s skipped=%s write_failed=%s clis=%s\n' \
+printf 'mode=%s rows=%s root=%s due=%s ran=%s ok=%s failed=%s held=%s skipped=%s write_failed=%s clis=%s cli_missing=%s\n' \
   "$([ "$DRYRUN" -eq 1 ] && echo plan || echo run)" "$ROWS" "${ROOT:--}" \
-  "$N_DUE" "$N_RUN" "$N_OK" "$N_FAIL" "$N_HELD" "$N_SKIP" "$N_WRITE_BAD" "$N_CLI"
+  "$N_DUE" "$N_RUN" "$N_OK" "$N_FAIL" "$N_HELD" "$N_SKIP" "$N_WRITE_BAD" "$N_CLI" "${CLI_MISSING:--}"
 
+[ -n "$CLI_MISSING" ] && warn "排程條目記著這台機器有 $JSC_ASSIST_CLIS，但這一輪只偵測到 $N_CLI 支，少了：$CLI_MISSING。帶 {cli} 代入點的那幾筆這一輪少跑了那幾支，而且**全部成功也不代表全部跑過**。成因通常是那支 CLI 裝在會過期的目錄底下（例如帶行程編號的多殼層目錄），條目帶的 PATH 是安裝當下拍的，那條路徑現在不在了。重跑一次 schedule.sh install patrol 會重新拍一份快照；那支 CLI 反覆消失就要考慮把它裝到穩定位置。"
 [ "$N_HELD" -gt 0 ] && note "有 $N_HELD 筆代不出目標或指令形狀不對，這一輪跳過，逐筆印在上面的 held= 那幾行。**那幾筆的執行紀錄與失敗次數一個字都沒動**——代不出目標不是那一筆做錯了什麼，記成失敗會讓一個沒有人修得動的計數一路往上爬。"
 [ "$N_SKIP" -gt 0 ] && note "有 $N_SKIP 筆這一批不跑：動作是只提醒的、動作是技能名的、還有不是內建項的，逐筆印在上面的 skip= 那幾行。"
 [ "$RC_WRITE" -ne 0 ] && warn "有 $N_WRITE_BAD 筆的回寫失敗。指令跑過了，但待辦簿沒記到，下一輪會再跑一次同一筆，逐筆印在上面的 write_failed= 那幾行，各自帶了 tasks.sh 的結束碼。"

tools/schedule.sh

@@ -381,6 +381,29 @@ cli_path() {
   printf '%s' "${_dirs:+$_dirs:}/usr/bin:/bin"
 }
 
+# 條目要記下安裝當下偵測到哪幾支 CLI，作為往後每一輪的參照基準。
+#
+# 為什麼需要這個基準：偵測那一支純看 PATH，分不出「裝了但執行檔不在 PATH 上」。而條目帶的
+# PATH 是安裝當下拍的，其中某些 CLI 裝在會過期的目錄底下——這台機器實測就有一支裝在帶行程
+# 編號的多殼層目錄，重開機之後那條路徑就不在了。
+# 少了基準的後果不是報錯，是安靜地少做一支：那一輪照樣把偵測到的每一支都跑過、照樣全部
+# 成功、照樣回報「都跑過了」，因為它不知道該有幾支。實測那一輪報「對 4 支 CLI 都跑過，
+# 全部成功」，而機器上裝了 5 支。
+# 記下來之後，讀的那一邊才有東西可比，也才答得出「該不該重跑一次 install」。
+# 判法照 cli_path() 那一套：逐支用 command -v 試，不叫外部腳本。兩個理由——這一支在 install
+# 那一刻本來就已經用同一套判過一次（為了組 PATH），再叫一支等於同一件事兩套實作；而且那一支
+# 只看 PATH，跟這裡拿得到的資訊一樣多，多繞一層沒有換到任何東西。
+cli_codes() {
+  _codes=''
+  for _pair in claude:claude codex:codex copilot:copilot antigravity:agy kiro:kiro-cli; do
+    _code=${_pair%%:*}; _bin=${_pair#*:}
+    _abs=$(command -v "$_bin" 2>/dev/null) || continue
+    case "$_abs" in /*) ;; *) continue ;; esac
+    _codes="${_codes:+$_codes }$_code"
+  done
+  printf '%s' "$_codes"
+}
+
 # 條目的指令前綴：固定三個旗標，加上這一刻的環境快照。沒設定的變數直接跳過，不寫空值——
 # 寫 NAME='' 進去，讀的人分不出是「刻意設成空」還是「安裝時忘了設」。
 # JSC_GITEA_CONFIRM=yes 是必要的：寫入確認只認 tty，排程那一輪沒有 tty，不帶這個旗標監控頁
@@ -392,7 +415,7 @@ cli_path() {
 # 中止的唯一證據」。不設這個變數，兩半就都落在 CLI 自己給的代號上。
 # 2026-09-04 實測：一台機器累積了 91 筆假中止，其中 90 筆是同一支被每輪叫用的技能。
 env_prefix() { # 順便把快照到的變數名稱寫進 $1，供輸出列出名稱（只有名稱，不含值）
-  _p="PATH=$(shq "$(cli_path)") JSC_CLI=cron JSC_GITEA_CONFIRM=yes"
+  _p="PATH=$(shq "$(cli_path)") JSC_ASSIST_CLIS=$(shq "$(cli_codes)") JSC_CLI=cron JSC_GITEA_CONFIRM=yes"
   _names=''
   for _n in $(snapshot_names); do
     eval "_v=\${$_n:-}"
@@ -494,7 +517,7 @@ trap 'rm -rf "$TMPD"' EXIT
 # 巡檢指令與環境快照在這裡就解出來。放進 cron_entry 再解的話，那支是在命令替換的子行程裡
 # 跑，判不出 CLI 時 die 只結束子行程，主流程會帶著空指令繼續往下裝。
 PATROL_RESOLVED=''
-ENV_PREFIX="PATH=$(shq "$(cli_path)") JSC_CLI=cron JSC_GITEA_CONFIRM=yes"
+ENV_PREFIX="PATH=$(shq "$(cli_path)") JSC_ASSIST_CLIS=$(shq "$(cli_codes)") JSC_CLI=cron JSC_GITEA_CONFIRM=yes"
 SNAPSHOT_NAMES=''
 case "$CMD:$JOBS" in
   install:*patrol*)