Merge pull request 'release: wiki 目錄頁專用存取庫、HASH 完整 40 碼、閘門依 CLI 分流' (#74) from develop into master

Reviewed-on: #74
Reviewed-by: 系統管理員 <1+admin@noreply.localhost>

.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "jsc-hooks",
-  "version": "0.3.7",
+  "version": "0.3.8",
   "description": "跨 CLI hooks：STE100 語言強制、工時計時、技能用量記錄、SDLC 模型鎖、版本前置檢查、註解範圍守門、繁中編碼守門、部署後強制重啟、寫入與提交閘門",
   "skills": "./skills",
   "author": {

.codex-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "hooks": "./hooks/codex-hooks.json",
   "name": "jsc-hooks",
-  "version": "0.3.7",
+  "version": "0.3.8",
   "description": "跨 CLI hooks：STE100 語言強制、工時計時、技能用量記錄、SDLC 模型鎖、版本前置檢查、註解範圍守門、繁中編碼守門、部署後強制重啟、寫入與提交閘門",
   "skills": "./skills",
   "jsc": {

README.md

@@ -33,7 +33,7 @@ Marketplace 統一為 `jsc`（https://gitea.jsc.idv.tw/plugins/meta.git），安
 | `hooks/skill-usage.sh` | PostToolUse(Skill) | 記錄技能使用與呼叫鏈到 `$JSC_HOME/usage/*.jsonl`，供 `jsc-log:stats` 統計 |
 | `hooks/comment-scope.sh` | UserPromptSubmit、PostToolUse(Write、Edit、MultiEdit)、codex `notify`、kiro `userPromptSubmit`、`tools/jsc-wrap.sh` 收尾 | 程式碼註解不得夾帶文件相關資訊與審查流程痕跡，共三種模式。`prompt`：在每次提示注入規則摘要（禁止項與白名單各一行），五個 CLI 都接得到。無參數：寫檔後的逐檔掃描，從 stdin JSON 取 `file_path`（或環境變數 `JSC_CHANGED_FILE`），只有 claude 的 PostToolUse 接得上。`sweep [dir]`：掃整個 git 工作區這次改過的所有檔案，給沒有 post-tool hook 的四個 CLI 用，找不到 git 就安靜 exit 0。掃描時機每個 CLI 不同——claude 逐檔即時（PostToolUse）、codex 每輪結束（`notify`）、kiro 每輪提示送出時（`userPromptSubmit`，掃的是上一輪寫的檔）、copilot 與 antigravity 只有工作階段結束時由 `tools/jsc-wrap.sh` 收尾掃一次。兩種掃描模式都只看 `git diff HEAD` 的新增行、不翻舊帳，命中就把警告與最多三行證據送到 stderr 並以 exit 2 交回模型就地修正（不擋寫入，檔案已經寫好了）。markdown、純文字、資料檔與二進位檔一律跳過。只實作可用樣式判定的項目，專案代號、客戶名稱這類判不出來的交給 `/jsc-review:code-review`。規則正文的唯一來源在 `jsc-review` 的 `references/comment-scope.md`，本存取庫不留副本。逃生門 `JSC_COMMENT_SCOPE=off` |
 | `hooks/lang-guard.sh` | UserPromptSubmit、PostToolUse(Write、Edit、MultiEdit)、codex `notify`、kiro `userPromptSubmit`、`tools/jsc-wrap.sh` 收尾 | 所有非程式碼輸出一律繁體中文、UTF-8、無亂碼、無簡體字，共三種模式。`prompt`：在每次提示注入規則摘要（適用範圍與自我檢查各一行），五個 CLI 都接得到。無參數：寫檔後的逐檔掃描，從 stdin JSON 取 `file_path`（或環境變數 `JSC_CHANGED_FILE`），只有 claude 的 PostToolUse 接得上。`sweep [dir]`：掃整個 git 工作區這次改過的所有檔案，給沒有 post-tool hook 的四個 CLI 用，找不到 git 就安靜 exit 0。接線位置與掃描時機跟 `comment-scope.sh` 完全一樣，見下面那張表。偵測三項：簡體字（字表在 `hooks/simplified.txt`，讀不到就安靜跳過這一項）、亂碼（U+FFFD 替代字元與雙重編碼殘骸）、非 UTF-8 編碼（用 `iconv` 判定，沒有 `iconv` 就跳過）。三項都掃整個檔案、不只掃註解行，`.md` 與純文字檔照掃——那些正是「非程式碼輸出」的主場，這兩點跟 `comment-scope.sh` 刻意不同。掃描深度仍只看 `git diff HEAD` 的新增行、不翻舊帳，命中就把警告與最多三行證據送到 stderr 並以 exit 2 交回模型就地修正（不擋寫入）。二進位檔（只認 NUL 位元組）與 `*.lock`、`*.min.js`、`*.map` 這類產生檔跳過；`hooks/simplified.txt`、`hooks/ste100-guard.sh`、`hooks/lang-guard.sh` 也跳過，那三份檔案裡的簡體字與亂碼樣本是被討論的對象，不是被使用。規則正文的唯一來源在 `jsc-meta` 的 `references/ste100.md`。逃生門 `JSC_LANG_GUARD=off` |
-| `hooks/sdlc-gate.sh` | UserPromptSubmit、PreToolUse(Skill) | SDLC 階段能力標籤閘門與模型鎖：`lock {stage}` 由 jsc-sdlc 階段技能呼叫，從可驗證來源讀出模型 id，比對該階段必要標籤（`$JSC_HOME/model-tags.tsv`），不符就拒絕上鎖；來源優先序為 transcript、hook stdin JSON、Codex 本機 session 記錄，最後才接受 `JSC_MODEL` 人工覆寫，且回報會標明人工覆寫；`check` 在模型不符時以 exit 2 擋下該輪提示（其他 hook 一律 exit 0，此處是刻意例外）；`report` 印出階段、必要標籤、模型 id、模型來源與判定結果；`unlock` 為逃生門。另含工作包 PR 閘門：`wp-lock {owner}/{repo} {index} [{工作包代號}]` 記下一筆未結清的工作包 PR、`wp-unlock {owner}/{repo} {index}` 結清那一筆（檔案不存在也算成功）、`wp-claim {owner}/{repo} {工作包代號} [{PR 編號}] [{分析頁頁名}]` 記下這個存取庫目前領取哪一包、`wp-unclaim {owner}/{repo}` 交回、`wp-report` 印出所有未結清、`wp-check {prompt｜skill}` 為 hook 模式。狀態檔一個工作包一支，在 `$JSC_HOME/wp/{owner}-{repo}-{index}.pr`，**刻意不綁 session**——PR 沒合併時換一個工作階段照樣要擋；一個工作包一支鎖檔是為了讓好幾個互不相依的工作包能同時記在案，不會互相覆蓋掉對方的鎖。`wp-check prompt` 只注入提醒、絕不擋提示（擋了連「去修那支 PR」的對話都送不出去）；`wp-check skill` 在有未結清 PR 時以 exit 2 擋下 `analyze` 與 `maintain`，但一律放行 `implement`（結清 PR 正是 implement 的步驟，擋它會鎖死流程），也放行 `plan`，只注入提醒（plan 是純邏輯階段、不碰程式碼，而這道閘門只知道「有 PR 未合併」、判不出跟新計畫有沒有關聯；放棄的是在製品上限，`analyze` 與 `maintain` 兩道仍在，上限晚一個階段才生效）——這一層是整個存取庫共用的粗粒度提醒，「某個候選工作包能不能挑」的細粒度判斷在 `jsc-sdlc/tools/wp-gate.sh check-deps`，不是這裡。另外會比對歸屬：未結清的 PR 不屬於目前領取的工作包時，`prompt` 多注入一行「那幾支交給領取它的工作階段」，`skill` 在擋下 `analyze`、`maintain` 時一併點名，`plan` 與 `implement` 仍放行但收到同一則提醒。逃生門 `JSC_WP_GATE=off`。這道閘門只讀檔案、不打網路，PR 的真實合併狀態由 `jsc-sdlc/tools/wp-gate.sh` 查證 |
+| `hooks/sdlc-gate.sh` | UserPromptSubmit、PreToolUse(Skill) | SDLC 階段能力標籤閘門與模型鎖：`lock {stage}` 由 jsc-sdlc 階段技能呼叫，從可驗證來源讀出模型 id，比對該階段必要標籤（`$JSC_HOME/model-tags.tsv`），不符就拒絕上鎖。**來源依 CLI 分流**，一支 CLI 只讀自己的紀錄：claude 讀 transcript 與 hook stdin JSON，codex 讀 hook stdin JSON 與自己的 session 記錄，copilot、antigravity、kiro 本機沒有可讀的模型紀錄，判不出 CLI 時不採用任何自動來源；所有 CLI 最後都接受 `JSC_MODEL` 人工覆寫，且回報會標明人工覆寫。政策是 **fail-closed**：不知道能力就擋下，三種情形一律擋——判不出 CLI、判不出模型、模型不在能力標籤表上；每一則擋下的訊息都會印出兩條逃生門（設 `JSC_MODEL`，或執行 `sdlc-gate.sh unlock {狀態檔}`）。`check` 在上述任一情形以 exit 2 擋下該輪提示（其他 hook 一律 exit 0，此處是刻意例外）；`report` 印出階段、必要標籤、模型 id、模型來源與判定結果；`unlock` 為逃生門，不帶參數清這個工作階段的新舊兩份，帶參數只清指定的那一支。階段鎖狀態檔是 `$JSC_HOME/sessions/{CLI 代號}-{sid}.stage`，舊路徑 `$JSC_HOME/sessions/{sid}.stage` 仍讀得到。另含工作包 PR 閘門：`wp-lock {owner}/{repo} {index} [{工作包代號}]` 記下一筆未結清的工作包 PR、`wp-unlock {owner}/{repo} {index}` 結清那一筆（檔案不存在也算成功）、`wp-claim {owner}/{repo} {工作包代號} [{PR 編號}] [{分析頁頁名}]` 記下這個存取庫目前領取哪一包、`wp-unclaim {owner}/{repo}` 交回、`wp-report` 印出所有未結清、`wp-check {prompt｜skill}` 為 hook 模式。狀態檔一個工作包一支，在 `$JSC_HOME/wp/{owner}-{repo}-{index}.pr`，**刻意不綁 session**——PR 沒合併時換一個工作階段照樣要擋；一個工作包一支鎖檔是為了讓好幾個互不相依的工作包能同時記在案，不會互相覆蓋掉對方的鎖。`wp-check prompt` 只注入提醒、絕不擋提示（擋了連「去修那支 PR」的對話都送不出去）；`wp-check skill` 在有未結清 PR 時以 exit 2 擋下 `analyze` 與 `maintain`，但一律放行 `implement`（結清 PR 正是 implement 的步驟，擋它會鎖死流程），也放行 `plan`，只注入提醒（plan 是純邏輯階段、不碰程式碼，而這道閘門只知道「有 PR 未合併」、判不出跟新計畫有沒有關聯；放棄的是在製品上限，`analyze` 與 `maintain` 兩道仍在，上限晚一個階段才生效）——這一層是整個存取庫共用的粗粒度提醒，「某個候選工作包能不能挑」的細粒度判斷在 `jsc-sdlc/tools/wp-gate.sh check-deps`，不是這裡。另外會比對歸屬：未結清的 PR 不屬於目前領取的工作包時，`prompt` 多注入一行「那幾支交給領取它的工作階段」，`skill` 在擋下 `analyze`、`maintain` 時一併點名，`plan` 與 `implement` 仍放行但收到同一則提醒。逃生門 `JSC_WP_GATE=off`。這道閘門只讀檔案、不打網路，PR 的真實合併狀態由 `jsc-sdlc/tools/wp-gate.sh` 查證 |
 | `hooks/write-guard.sh` | PreToolUse(Write、Edit、MultiEdit)、PreToolUse(Bash) | 寫入與提交閘門，共三種擋人模式，目前只接在 claude 上；codex、copilot、antigravity 三支已經有可用的 pre-tool hook（見上面「各 CLI 的 pre-tool 接線位置」），只是這三種模式還沒接過去，kiro 則是本來就擋不下來。另有一個不接 hook 的 `release` 解除模式。`stage`：`sdlc-gate.sh` 的階段鎖鎖在 `plan` 或 `analyze` 時，以 exit 2 擋下 `Write`、`Edit`、`MultiEdit`——那兩個階段的產出是計畫頁與分析頁，不是檔案。階段鎖狀態檔沿用 `sdlc-gate.sh` 那一份，這裡只讀不寫。`review`：目前技能是 `jsc-review:code-review` 或 `jsc-review:api-doc` 時擋下寫入，那兩支只回報發現、不改程式碼。技能名先讀環境變數，取不到才讀 `skill-usage.sh` 記下的那一份；沒有「技能結束」事件可讀，所以紀錄超過 `JSC_WRITE_GUARD_TTL` 秒就當那支技能早已跑完。`jsc-review:comment-cleanup` **刻意不擋**：它本來就要改檔，只是限定僅註解行，而精確判定要解析工具參數裡整份新內容再逐語言判斷哪幾行是註解，判錯會擋掉合法的清理，代價比漏擋大，所以那條界線留給技能內文與後續審查。`commit`：擋下「同一道指令把全部變更一次加進索引再提交」，也擋下含簡體字、亂碼或非 UTF-8 編碼的提交訊息（判定整段轉呼叫 `lang-guard.sh`，字表仍是 `hooks/simplified.txt`，這裡不留第二份樣式）。跨兩次工具呼叫的 `git add -A` 不擋：那要記跨呼叫狀態，而被擋下的人沒有辦法讓那個狀態自己消失，閘門會把解除自己的路徑一起鎖掉。`release`：刪掉 `review` 模式認人用的那份紀錄，一律 exit 0，由 `jsc-review:code-review` 與 `jsc-review:api-doc` 在收尾時各呼叫一次。有這個模式是因為那份紀錄記的是「最近一次載入的技能」不是「還在跑的技能」——稽核收尾後呼叫端本來就要動手改，那時紀錄仍寫著稽核技能，TTL 內每一次寫入都被擋，解除路徑只剩逃生門或空等；閘門不得把解除自己的路徑一起鎖掉。逃生門 `JSC_WRITE_GUARD=off`（`release` 不受它影響，清紀錄擋不到任何人） |
 
 Claude 由 `hooks/hooks.json` 自動接線九支 hook；其他 CLI 用 `hooks-install` 技能接線、改裝包裝啟動器，或降級為規則檔。寫進使用者設定的長期命令一律指向 `$JSC_HOME/current/jsc-hooks`，不指向帶版號的 plugin 快取目錄，也不指向開發存取庫。
@@ -157,7 +157,8 @@ Claude 由 `hooks/hooks.json` 自動接線九支 hook；其他 CLI 用 `hooks-in
 | `$JSC_HOME/errors/scan-state/{CLI 代號}-*.offset` | 有 | 正確 | 原生日誌位置與格式依 CLI 不同，掃描位移不能共用。 |
 | `$JSC_HOME/usage/scan-state/{CLI 代號}-*.offset` | 有 | 正確 | 離線回填逐 CLI 掃不同日誌，位移檔以 CLI 前綴隔離。 |
 | `$JSC_HOME/usage/skills.jsonl`、`$JSC_HOME/usage/chains.jsonl` | 每筆有 `cli` 欄位 | 正確 | 統計要能跨 CLI 彙整，也要能用欄位篩選。 |
-| `$JSC_HOME/sessions/` | 以 session id 分 | 正確 | 工作階段 id 由 CLI 或包裝器提供，實質上分離；同 id 才代表同一工作階段。 |
+| `$JSC_HOME/sessions/{CLI 代號}-{sid}.stage` | 有 | 正確 | session id 判不出時會退回 `default`，不分 CLI 就會共用同一支 `default.stage`，一支上的階段鎖會擋到另一支——那不只擋提示，`write-guard.sh` 的 `stage` 模式還會連寫檔一起擋。用檔名前綴不用子目錄，是因為外部工具以單層的 `sessions/*.stage` 盤點階段鎖。舊路徑 `$JSC_HOME/sessions/{sid}.stage` 只作往後相容的讀取，`unlock` 會一併清掉。 |
+| `$JSC_HOME/sessions/` 的其餘檔案（`.start`、`.end`、`.lastskill`） | 以 session id 分 | 正確 | 工作階段 id 由 CLI 或包裝器提供，實質上分離；同 id 才代表同一工作階段。 |
 | `$JSC_HOME/restart-required.d/{CLI 代號}` | 有 | 正確 | 重啟只清當前 CLI，那一支沒有重啟就不能被另一支解除。 |
 | `$JSC_HOME/wp/` | 無 | 正確 | 工作包 PR 狀態屬於存取庫與 PR，不屬於 CLI；換 CLI 也要看到同一支未結清 PR。 |
 | `$JSC_HOME/model-tags.tsv`、`$JSC_HOME/models.conf`、`$JSC_HOME/html-styles.conf` | 無 | 正確 | 這些是全機共用設定，不是檢查紀錄。 |
@@ -168,8 +169,8 @@ Claude 由 `hooks/hooks.json` 自動接線九支 hook；其他 CLI 用 `hooks-in
 | --- | --- |
 | `tools/jsc-wrap.sh` | 沒有完整 hook 系統的 CLI 的包裝啟動器：匯出 `JSC_CLI`、`JSC_SESSION_ID`，前後接 `session-timer.sh`，結束時自動跑 `scan-logs.sh` 回填，再依序跑一次 `comment-scope.sh sweep` 與 `lang-guard.sh sweep` 掃整個 git 工作區的註解範圍與繁中編碼（copilot 與 antigravity 沒有任何逐輪事件，整個工作階段只有這裡掃得到）。兩次收尾掃描一律不影響結束碼：包裝器原樣回傳 CLI 自己的結束碼，`sweep` 命中只把警告印到 stderr。`JSC_CLI` 存 CLI 代號，實際執行的是對應的執行檔（antigravity 是 agy、kiro 是 kiro-cli） |
 | `tools/scan-logs.sh` | 離線回填：解析 copilot、antigravity、codex 的原生日誌，把技能用量與階段界線補進 `$JSC_HOME`，重掃不重複 |
-| `tools/report-error.sh` | 失敗回報流程：把一筆 hook 或工具異常寫成 wiki 的 `ERROR_{HASH}`，並在 `ERROR_CONTENTS` 附上一列索引。目錄頁一律先讀回舊頁再附加新列、整頁寫回，不整頁覆蓋：只有 `wiki-get` 回 4（頁面真的不存在）才用範本建新頁，回 7（金鑰失效）或 8（其他 API 失敗）代表舊內容未知，放棄目錄頁寫入並以 exit 4 回報，免得拿範本蓋掉所有既有列。wiki 位置由 `jsc-gitea` 的 `gitea.sh wiki-repo ERROR` 解析，解析不出來就安靜降級。由操作者手動執行，或由 `hooks-install` 在 `wire-cli.sh` 回報 `status=failed` 時執行；**不接在失敗的 hook 上自動觸發**（hook 一律安靜 exit 0，自我回報會疊出迴圈） |
+| `tools/report-error.sh` | 失敗回報流程：把一筆 hook 或工具異常寫成 wiki 的 `ERROR_{HASH}`，並在 `ERROR_CONTENTS` 附上一列索引。目錄頁一律先讀回舊頁再附加新列、整頁寫回，不整頁覆蓋：只有 `wiki-get` 回 4（頁面真的不存在）才用範本建新頁，回 7（金鑰失效）或 8（其他 API 失敗）代表舊內容未知，放棄目錄頁寫入並以 exit 4 回報，免得拿範本蓋掉所有既有列。目錄頁指向異常頁的連結用 `gitea.sh wiki-url` 的絕對網址，跨存取庫的 `[[頁名]]` 解不開。網址在異常頁寫成功之後才取：頁名的 hash 帶時間戳，每次回報都是全新的頁，寫進去之前查一定是 404，先查就只拿得到空字串。取不到網址時只印頁名，原因走 stderr，結束碼照舊回 0。wiki 位置分兩次解析：異常頁走 `jsc-gitea` 的 `gitea.sh wiki-repo ERROR`，目錄頁走 `gitea.sh wiki-repo CONTENTS`，兩者是兩個不同的存取庫。異常頁的存取庫解不出來就整支安靜降級；只有目錄頁的存取庫解不出來，就只寫異常頁、跳過目錄頁更新，仍回 exit 0。由操作者手動執行，或由 `hooks-install` 在 `wire-cli.sh` 回報 `status=failed` 時執行；**不接在失敗的 hook 上自動觸發**（hook 一律安靜 exit 0，自我回報會疊出迴圈） |
-| `tools/wire-cli.sh` | 單一 CLI 的 hook 生命週期，共四個用法。`{cli}` 是接線：先建立或更新 `$JSC_HOME/current/jsc-hooks` 指向目前這版 plugin，接著把對應的設定編輯、包裝別名安裝、hook 檔建立成穩定路徑，皆以 `<!-- jsc-hooks -->`（或 `# jsc-hooks`）標記整段重寫，重跑等同先移除再重裝；寫完每個檔案會重讀驗證位置正確才回報成功（codex 的 `notify` 必須是根層鍵、`.codex-plugin/plugin.json` 的 matcher 必須是 `Bash`、copilot 必須是小寫 `skill` 且沒有第二種大小寫的事件名、antigravity 的 matcher 必須帶錨點 `^view_file$` 且有 `PreInvocation`、kiro 的 agent JSON 必須成對且 `hooks`、`resources`、`tools` 在最上層並含兩層 `skill://` glob），也會確認寫入路徑能解到既有腳本。matcher 本身要單獨驗：鍵在、matcher 卻錯的形態最難查，回報會說接好了，實際一次都不會被叫用。檔案系統不能建立 symlink 時，會明確回報並退回目前根目錄，不會靜默寫出壞路徑。`status=wired\|degraded\|skipped\|failed` 回報接線結果。`purge {cli}` 是移除：把該 CLI 的**所有** hook 清掉，含非 jsc 的第三方項目，動到的檔案先原樣備份到 `$JSC_HOME/backup/hooks/{cli}/{yyyyMMdd_HHmmss}/`，備份失敗就不移除；移除標記段落時會先去掉標記行前後空白，所以縮排或尾端補空白的 jsc 區塊一樣會移除；移除後重讀驗證，驗不過自動還原備份，以 `status=purged\|skipped\|failed` 回報。`smoke {cli}` 是執行期冒煙測試：九支 hook 的每個接線模式各跑一次，非零退出即為錯誤，另外把五支 CLI 的真實負載各餵進 `skill-name.sh` 一次驗技能名解析、四種阻擋形態各驗一次 `deny.sh`，再把那些負載直接餵進 `restart-gate.sh` 驗「解析→判定→輸出形態」整條串得起來（含 fail-open、豁免放行與 kiro 的注入路徑）——前兩組分開看都會顯示正常，中間接不上照樣是全程放行，那正是先前三支 CLI 失效的樣子；另外用一份暫時的 `$JSC_HOME` 狀態檔把工作包歸屬、部署後重啟閘門與寫入提交閘門的每條判定路徑各跑一次並比對結束碼，再用一份暫時的 `HOME`（假的 `installed_plugins.json` 與各 plugin 的 manifest）把 `version-guard.sh` 相依版本檢查的每條路徑跑一次——相依落後的擋人與訊息內容、相等與超前的放行、豁免技能在相依落後時照樣放行、四種 fail-open、逃生門，另加一條回歸：多行縮排的 manifest，`jsc.requires` 的最後一個鍵也要解得到。驗的是判定結果本身，不只是腳本跑得完（例外有四個：`sdlc-gate.sh check` 的 exit 2 是階段鎖的設計行為，`comment-scope.sh`、`lang-guard.sh` 掃描模式與 `write-guard.sh` 三種模式的 exit 2 是命中違規的設計行為——`sweep` 在髒工作區本來就會回 2，`write-guard.sh` 在機器剛好鎖在 `plan` 階段時也會回 2，都不算 hook 壞掉），以 `status=ok\|failed` 回報。**結果行數由腳本自己數、自己斷言**：`status=` 之後緊接一行 `lines<TAB>{數量}`，那是其後 `[jsc]` 結果行的實際條數，與腳本內逐類宣告的預期條數比對，不符就回非零。判定路徑增減時只改腳本裡的預期值，散文一律引用這一行，不另外抄一份數字。`status {cli}` 是唯讀盤點：只讀設定檔判斷段落與 matcher 對不對，不寫檔也不執行 hook，claude、codex、copilot、antigravity 回 `wired`，kiro 回 `degraded` 並在 `reason` 講明那是 CLI 限制；每個接線點印一行 `item<TAB>{項目}<TAB>{路徑}<TAB>{present\|missing\|unverified}`，也會把帶版號快取路徑、開發存取庫路徑與不存在的腳本列為缺項。狀態有三格不是兩格：`unverified` 是「這一項驗不了」，只有 `missing` 才算缺項——`kiro-cli agent validate` 在沒登入時印的是環境問題，不是這個檔案的問題，報 `present` 會讓沒驗到的東西看起來像通過，報 `missing` 會把沒登入算成接線缺漏；`status claude` 讀 Claude Code 實際載入的 `installed_plugins.json`，不再檢查目前腳本旁邊那份 `hooks.json`。體檢類技能（`/jsc-cli:doctor`）只能用這個子命令，另外三個都會動到環境；那道限制另有程式層把關，`JSC_READONLY=1` 之下只准 `status` 與 `smoke`，`purge` 與接線一律以 exit 6 拒絕並回報 `status=readonly`，環境不會被動到 |
+| `tools/wire-cli.sh` | 單一 CLI 的 hook 生命週期，共四個用法。`{cli}` 是接線：先建立或更新 `$JSC_HOME/current/jsc-hooks` 指向目前這版 plugin，接著把對應的設定編輯、包裝別名安裝、hook 檔建立成穩定路徑，皆以 `<!-- jsc-hooks -->`（或 `# jsc-hooks`）標記整段重寫，重跑等同先移除再重裝；寫完每個檔案會重讀驗證位置正確才回報成功（codex 的 `notify` 必須是根層鍵、`.codex-plugin/plugin.json` 的 matcher 必須是 `Bash`、copilot 必須是小寫 `skill` 且沒有第二種大小寫的事件名、antigravity 的 matcher 必須帶錨點 `^view_file$` 且有 `PreInvocation`、kiro 的 agent JSON 必須成對且 `hooks`、`resources`、`tools` 在最上層並含兩層 `skill://` glob），也會確認寫入路徑能解到既有腳本。matcher 本身要單獨驗：鍵在、matcher 卻錯的形態最難查，回報會說接好了，實際一次都不會被叫用。檔案系統不能建立 symlink 時，會明確回報並退回目前根目錄，不會靜默寫出壞路徑。`status=wired\|degraded\|skipped\|failed` 回報接線結果。`purge {cli}` 是移除：把該 CLI 的**所有** hook 清掉，含非 jsc 的第三方項目，動到的檔案先原樣備份到 `$JSC_HOME/backup/hooks/{cli}/{yyyyMMdd_HHmmss}/`，備份失敗就不移除；移除標記段落時會先去掉標記行前後空白，所以縮排或尾端補空白的 jsc 區塊一樣會移除；移除後重讀驗證，驗不過自動還原備份，以 `status=purged\|skipped\|failed` 回報。`smoke {cli}` 是執行期冒煙測試：九支 hook 的每個接線模式各跑一次，非零退出即為錯誤，另外把五支 CLI 的真實負載各餵進 `skill-name.sh` 一次驗技能名解析、四種阻擋形態各驗一次 `deny.sh`，再把那些負載直接餵進 `restart-gate.sh` 驗「解析→判定→輸出形態」整條串得起來（含 fail-open、豁免放行與 kiro 的注入路徑）——前兩組分開看都會顯示正常，中間接不上照樣是全程放行，那正是先前三支 CLI 失效的樣子；另外用一份暫時的 `$JSC_HOME` 狀態檔把模型來源與階段鎖、工作包歸屬、部署後重啟閘門與寫入提交閘門的每條判定路徑各跑一次並比對結束碼（模型來源的每個案例各自指定 CLI 代號，不跟著這一輪接線的 CLI 走——偵測鏈已依 CLI 分流；「不知道能力就擋下」的三種情形連訊息裡的逃生門一起驗，只比結束碼的話訊息漏掉逃生門也是綠燈），再用一份暫時的 `HOME`（假的 `installed_plugins.json` 與各 plugin 的 manifest）把 `version-guard.sh` 相依版本檢查的每條路徑跑一次——相依落後的擋人與訊息內容、相等與超前的放行、豁免技能在相依落後時照樣放行、四種 fail-open、逃生門，另加一條回歸：多行縮排的 manifest，`jsc.requires` 的最後一個鍵也要解得到。驗的是判定結果本身，不只是腳本跑得完（例外有四個：`sdlc-gate.sh check` 的 exit 2 是階段鎖的設計行為，`comment-scope.sh`、`lang-guard.sh` 掃描模式與 `write-guard.sh` 三種模式的 exit 2 是命中違規的設計行為——`sweep` 在髒工作區本來就會回 2，`write-guard.sh` 在機器剛好鎖在 `plan` 階段時也會回 2，都不算 hook 壞掉），以 `status=ok\|failed` 回報。**結果行數由腳本自己數、自己斷言**：`status=` 之後緊接一行 `lines<TAB>{數量}`，那是其後 `[jsc]` 結果行的實際條數，與腳本內逐類宣告的預期條數比對，不符就回非零。判定路徑增減時只改腳本裡的預期值，散文一律引用這一行，不另外抄一份數字。`status {cli}` 是唯讀盤點：只讀設定檔判斷段落與 matcher 對不對，不寫檔也不執行 hook，claude、codex、copilot、antigravity 回 `wired`，kiro 回 `degraded` 並在 `reason` 講明那是 CLI 限制；每個接線點印一行 `item<TAB>{項目}<TAB>{路徑}<TAB>{present\|missing\|unverified}`，也會把帶版號快取路徑、開發存取庫路徑與不存在的腳本列為缺項。狀態有三格不是兩格：`unverified` 是「這一項驗不了」，只有 `missing` 才算缺項——`kiro-cli agent validate` 在沒登入時印的是環境問題，不是這個檔案的問題，報 `present` 會讓沒驗到的東西看起來像通過，報 `missing` 會把沒登入算成接線缺漏；`status claude` 讀 Claude Code 實際載入的 `installed_plugins.json`，不再檢查目前腳本旁邊那份 `hooks.json`。體檢類技能（`/jsc-cli:doctor`）只能用這個子命令，另外三個都會動到環境；那道限制另有程式層把關，`JSC_READONLY=1` 之下只准 `status` 與 `smoke`，`purge` 與接線一律以 exit 6 拒絕並回報 `status=readonly`，環境不會被動到 |
 | `tools/scan-hook-errors.sh` | 掃 CLI 原生紀錄找 hook 的執行期錯誤（接線寫對、跑起來出錯）。只有 claude 有 hook 結果紀錄，掃 `~/.claude/projects/**/*.jsonl` 的 `hook_non_blocking_error` 與非空 `hookErrors`；codex、copilot、antigravity、kiro 沒有等價紀錄，一律回報 `unavailable` 並指向 `wire-cli.sh smoke {cli}`。每筆錯誤附加一行 JSON 到 `$JSC_HOME/errors/hooks.jsonl`，`jsc` 欄位標明是不是 jsc 自己的 hook（第三方 hook 的錯誤只回報，不由 jsc 修正）；去重與 `scan-logs.sh` 同法，重掃只讀新增段落，以 `status=clean\|errors\|unavailable` 回報 |
 
 ## 失敗回報範本
@@ -180,7 +181,7 @@ Claude 由 `hooks/hooks.json` 自動接線九支 hook；其他 CLI 用 `hooks-in
 | 範本 | 用途 |
 | --- | --- |
 | `templates/error-page.md` | 單筆 hook 異常頁 `ERROR_{HASH}`，記錄當次失敗的觸發條件、錯誤摘要與處理結果。 |
-| `templates/error-contents.md` | 異常目錄 `ERROR_CONTENTS`，彙整所有異常頁，方便先看最新問題再往下追。 |
+| `templates/error-contents.md` | 異常目錄 `ERROR_CONTENTS`，彙整所有異常頁，方便先看最新問題再往下追。落在目錄專用存取庫，一律 upsert 附加，連結用絕對網址。 |
 
 ## Skills 目錄
 
@@ -203,7 +204,8 @@ Claude 由 `hooks/hooks.json` 自動接線九支 hook；其他 CLI 用 `hooks-in
 | 變數 | 用途 | 未設定時 |
 | --- | --- | --- |
 | `JSC_HOME` | Hook 資料目錄 | 預設 `~/.jsc` |
-| `JSC_WIKI_REPO_ERROR` | `ERROR_CONTENTS`、`ERROR_{HASH}` 所在的 `{owner}/{repo}` | 退回 `JSC_WIKI_REPO` |
+| `JSC_WIKI_REPO_ERROR` | 異常內容頁 `ERROR_{HASH}` 所在的 `{owner}/{repo}` | 退回 `JSC_WIKI_REPO`；還是解不出來就整支 `tools/report-error.sh` 安靜降級，不寫 wiki |
+| `JSC_WIKI_REPO_CONTENTS` | 目錄頁 `ERROR_CONTENTS` 所在的 `{owner}/{repo}`。目錄頁與內容頁分屬兩個不同的存取庫，各解各的 | 退回 `JSC_WIKI_REPO`；還是解不出來就只寫內容頁、跳過目錄頁更新，`tools/report-error.sh` 仍回 exit 0 |
 | `JSC_WIKI_REPO` | 未逐類設定時的共用 wiki `{owner}/{repo}` | `tools/report-error.sh` 安靜降級，不寫 wiki |
 | `COPILOT_HOME` | copilot 的設定根目錄，`hooks/jsc-hooks.json` 與指引檔都寫在它底下 | 預設 `~/.copilot` |
 | `KIRO_HOME` | kiro 的設定根目錄，`agents/jsc.json`、`settings/cli.json` 與 `resources` 的 `skill://` glob 都由它推導 | 預設 `~/.kiro` |
@@ -225,7 +227,7 @@ Claude 由 `hooks/hooks.json` 自動接線九支 hook；其他 CLI 用 `hooks-in
 | `JSC_CHANGED_FILE` | 非 Claude CLI 要掃描的檔案路徑，代替 stdin JSON 的 `file_path`，供 `comment-scope.sh` 與 `lang-guard.sh` 使用 | 安靜降級，不掃描 |
 | `JSC_TOOL_COMMAND` | 非 Claude CLI 要判定的 Bash 指令字串，代替 stdin JSON 的 `command`，供 `write-guard.sh commit` 使用 | 安靜降級，不判定 |
 | `JSC_CLI` / `JSC_SESSION_ID` / `JSC_SKILL` / `JSC_TOOL_NAME` | 非 Claude CLI 接線時由 `tools/jsc-wrap.sh` 或接線設定提供，代替 stdin JSON 的 `session_id`、技能名與 `tool_name`（`hooks/skill-name.sh` 也收沒有前綴的 `SKILL`，而且環境變數蓋過負載解析；`write-guard.sh` 也收 `TOOL_NAME`）。`version-guard.sh` 與 `restart-gate.sh` 已經不篩工具名——五支 CLI 的工具名各不相同（`Skill`、`Bash`、`skill`、`view_file`），拿 Claude 那一個當通用條件會把另外四支整批擋在判定之外 | 安靜降級：`JSC_CLI` 取不到就當查不到 CLI，技能名取不到就由負載解析，兩邊都空就放行 |
-| `JSC_MODEL` | `sdlc-gate.sh` 找不到 transcript、hook stdin JSON 與 Codex 本機 session 記錄時的人工覆寫模型 id；回報會標明 `人工覆寫:JSC_MODEL` | 找不到可驗證模型來源時拒絕 `lock`，並列出已檢查來源與修復建議 |
+| `JSC_MODEL` | `sdlc-gate.sh` 在當前 CLI 自己的模型來源都失敗時的人工覆寫模型 id，五支 CLI 都適用；回報會標明 `人工覆寫:JSC_MODEL` | 找不到可驗證模型來源時 `lock` 拒絕、`check` 擋下該輪提示，並列出已檢查來源與兩條逃生門 |
 
 ## 相關 domain
 

hooks/comment-scope.sh

@@ -81,7 +81,13 @@ scan_file() { # $1=檔案路徑；命中就把報告印到 stdout 並回傳 1，
     hit '(^|[^[:alnum:]_/])#[0-9]+'                                             '議題編號（#123）'
     hit '(^|[^[:alnum:]_])![0-9]+'                                              'PR、MR 編號（!45）'
     hit '[A-Z]{2,6}-[0-9]{1,6}'                                                 '工作包、故事、驗收、測試案例、變更單、議題編號（前綴加流水號）'
-    hit '(QUESTION|PLAN|ANALYZE|DELIVER|MAINTAIN|REPO|LOG|LEARN|ERROR|CHECK|REPORT|SKILLSET|TOOLING|MONITOR)_([A-Z0-9]{8}|CONTENTS)' 'jsc wiki 頁面編號'
+    # 頁名樣式：十五種頁型，尾段是 CONTENTS（目錄頁）、40 碼大寫十六進位（內容頁），
+    # 或尚未遷移的舊頁編號。舊頁那兩條要留著，不然舊頁編號會漏偵測。
+    # 舊頁為什麼有 H 開頭這一條：舊的短碼演算法只要首碼落在 0-9ABC 就改寫成 H 加原前 7 碼，
+    # 十六個十六進位首碼有十三個會命中，所以既有舊頁名大多是 H 開頭，只收 [0-9A-F]{8} 會漏掉。
+    # 這條式子在別處另有兩份各自獨立的定義，稽核時才比對一致。刻意不共用函式：hook 要能
+    # 自足執行，執行期相依別的 plugin 路徑，那條路徑一缺，整支 hook 就掃不動了。
+    hit '(QUESTION|PLAN|ANALYZE|DELIVER|MAINTAIN|REPO|LOG|LEARN|ERROR|CHECK|REPORT|SKILLSET|TOOLING|MONITOR|CONTENTS)_(CONTENTS|[0-9A-F]{8}|H[0-9A-F]{7}|[0-9A-F]{40})' 'jsc wiki 頁面編號'
     hit '(todo|TODO|待辦)[[:space:]]*#?[0-9]+'                                  'TDD 待辦編號'
     hit '([Ss]print|里程碑|[Mm]ilestone)[[:space:]]*[0-9]+'                     'Sprint、里程碑編號'
     hit '(^|[^[:alnum:].])v[0-9]+\.[0-9]+|版本[[:space:]]*v?[0-9]+\.[0-9]+'     '版本號'

hooks/lib.sh

@@ -2,8 +2,9 @@
 # lib.sh — jsc hooks 共用函式。所有 hook 腳本 source 此檔。
 # 輸入相容：Claude 式 stdin JSON、或環境變數（codex/copilot/antigravity/kiro 接線時設定）。
 # 缺資料時安靜降級，hook 預設 exit 0，不可中斷宿主 CLI。
-# 唯一例外：sdlc-gate.sh check 在「SDLC 階段鎖存在且模型不符」時會 exit 2 擋下該輪提示；
+# 唯一例外：sdlc-gate.sh check 在「SDLC 階段鎖存在，而且不知道目前模型的能力」時會 exit 2
-# 其餘情況（無鎖、資料不足無法判定）仍照舊 exit 0。
+# 擋下該輪提示。不知道能力有三種：判不出是哪一支 CLI、判不出模型、模型不在能力標籤表上。
+# 這是刻意的 fail-closed——放行等於閘門不存在。沒有階段鎖時仍照舊 exit 0。
 #
 # 結束碼：不適用。本檔是被 source 的共用函式庫，不是可執行入口，內部一次 exit 都沒有。
 #   載入成功回 0（最後一行是函式定義）；拿 `sh lib.sh` 直接跑也只是定義完函式回 0，不做事。
@@ -31,12 +32,58 @@ json_str() { # $1=欄位名
 }
 
 # 目前 session id：stdin JSON > 環境變數 > 固定值
+#
+# 環境變數這一段的順序：
+#   JSC_SESSION_ID           jsc 自己的指定值（tools/jsc-wrap.sh 會設），人工指定優先於偵測。
+#   CLAUDE_CODE_SESSION_ID   claude 實際匯出的名字，實測確認過。
+#   CLAUDE_SESSION_ID        只留作往後相容，排在實測名之後。這個名字在目前的 claude 上並不
+#                            存在，兩個都設到的話，該信的是實測看得到的那一個；只設到這一個
+#                            的版本仍然退得下來，所以留著不會有損失。
+# 為什麼這一條要修：退路鏈原本只找 CLAUDE_SESSION_ID，那個名字取不到值，於是沒有 stdin 的
+# 執行路徑（技能以 Bash 呼叫 sdlc-gate.sh lock）一律退回 default，而 hook 有 stdin、拿得到
+# 真正的 id。同一個工作階段的兩條路徑因此算出兩支不同的狀態檔，階段鎖上了也永遠對不上。
+# 這裡只補退路鏈的變數名，不動取值順序以外的行為：其他 CLI 的變數名沒有實測過，猜一個填進來
+# 只會多一個錯誤來源。
 session_id() {
   sid=$(json_str session_id)
-  [ -n "$sid" ] || sid="${JSC_SESSION_ID:-${CLAUDE_SESSION_ID:-default}}"
+  [ -n "$sid" ] || sid="${JSC_SESSION_ID:-${CLAUDE_CODE_SESSION_ID:-${CLAUDE_SESSION_ID:-default}}}"
   printf '%s' "$sid"
 }
 
+# 階段鎖狀態檔名要用的 CLI 代號。這個值直接拼進檔名，所以不像代號的字元一律換掉；
+# 帶斜線或空白的值會把檔案寫到別的地方去，理由與 restart-gate.sh 的做法相同。
+stage_state_cli() {
+  cli_name | sed 's/[^A-Za-z0-9._-]/_/g'
+}
+
+# 階段鎖狀態檔的舊路徑：$JSC_HOME/sessions/{sid}.stage。只作往後相容的讀取來源，
+# 以及 unlock 的清除對象，新的寫入一律不走這裡。
+stage_state_legacy_file() {
+  printf '%s/sessions/%s.stage' "$JSC_HOME" "$(session_id)"
+}
+
+# 階段鎖狀態檔（寫入用）：$JSC_HOME/sessions/{cli}-{sid}.stage。
+# 為什麼要帶 CLI 代號：session_id() 判不出工作階段時會退回 default，各 CLI 於是共用同一支
+# default.stage，一支上的階段鎖就會擋到另一支。那不只擋提示——write-guard.sh 的 stage 模式
+# 在 plan 或 analyze 持鎖時連 Write、Edit、MultiEdit 一起擋掉。
+# 為什麼用檔名前綴而不是子目錄：外部工具以單層的 sessions/*.stage 盤點階段鎖，改成子目錄
+# 會讓每一支鎖從那些盤點裡整批消失；前綴照樣列得到，只是多一段代號。
+stage_state_file() {
+  printf '%s/sessions/%s-%s.stage' "$JSC_HOME" "$(stage_state_cli)" "$(session_id)"
+}
+
+# 階段鎖狀態檔（讀取用）：新路徑優先，沒有才回舊路徑。舊檔記的是實際工作，只讀不搬也不刪。
+# 兩邊都沒有時回新路徑，讓呼叫端一律用「檔案在不在」判斷有沒有鎖。
+stage_state_read_file() {
+  _sf=$(stage_state_file)
+  if [ -f "$_sf" ]; then
+    printf '%s' "$_sf"
+  else
+    _so=$(stage_state_legacy_file)
+    if [ -f "$_so" ]; then printf '%s' "$_so"; else printf '%s' "$_sf"; fi
+  fi
+}
+
 MODEL_SOURCE_CHECKS=""
 
 model_checked() {
@@ -75,9 +122,17 @@ codex_session_file() { # $1=CODEX_HOME $2=session id
     find "$ch/sessions" -type f -name "*$sid*.jsonl" 2>/dev/null | sort | tail -n 1
     return 0
   fi
-  files=$(find "$ch/sessions" -type f -name '*.jsonl' 2>/dev/null)
+  # 全樹最新的一支。原本寫成 `xargs ls -t | head -n 1`，那是錯的：xargs 會依參數長度分批，
-  [ -n "$files" ] || return 1
+  # ls -t 只在自己那一批裡排序，取到的是「第一批裡最新的」而不是全域最新。改成讓 find 一併
-  printf '%s\n' "$files" | xargs ls -t 2>/dev/null | head -n 1
+  # 印出修改時間，所有檔案在同一輪比較，批次邊界就影響不到結果。
+  newest=$(find "$ch/sessions" -type f -name '*.jsonl' -printf '%T@\t%p\n' 2>/dev/null \
+    | sort -rn | head -n 1 | cut -f2-)
+  # find 沒有 -printf（非 GNU）時退回路徑排序。codex 的 session 依「年/月/日」分目錄，
+  # 檔名又以 ISO 時間開頭，字典序等同時間序，仍然是全域比較，不會被分批切斷。
+  [ -n "$newest" ] || newest=$(find "$ch/sessions" -type f -name '*.jsonl' 2>/dev/null \
+    | sort | tail -n 1)
+  [ -n "$newest" ] || return 1
+  printf '%s\n' "$newest"
 }
 
 codex_model() {
@@ -98,28 +153,57 @@ codex_model() {
   return 1
 }
 
+# 目前模型的判定。輸出單行「{模型 id}<TAB>{來源}<TAB>{已檢查來源}」，判不出時前兩欄留空。
+#
+# 偵測鏈依 CLI 分流：一支 CLI 只讀自己的紀錄。兩個理由。
+#   一是正確性：跨過去讀別支的紀錄，拿到的是別支的模型，用它判定這一支等於沒有判準。
+#   二是速度：別支的 session 目錄可能有上千個檔案，每一輪 hook 都掃一次會把宿主 CLI 拖住。
+# 判不出是哪一支 CLI 時不猜任何來源——不知道是誰，就不知道該讀誰的紀錄。
+# JSC_MODEL 這個人工覆寫對所有 CLI 都保留，而且一律排在最後：可驗證的紀錄優先於人工宣告。
 current_model_report() {
   MODEL_SOURCE_CHECKS=""
+  _mcli=$(cli_name)
+  model_checked "JSC_CLI:$_mcli"
 
-  tp=$(json_str transcript_path)
+  case "$_mcli" in
-  [ -n "$tp" ] || tp="${JSC_TRANSCRIPT_PATH:-}"
+    claude)
-  model_checked "transcript_path:${tp:-未提供}"
+      # transcript 是 claude 自己寫下的執行紀錄，也是唯一逐輪更新的來源。
-  if [ -n "$tp" ] && [ -f "$tp" ]; then
+      tp=$(json_str transcript_path)
-    m=$(transcript_model)
+      [ -n "$tp" ] || tp="${JSC_TRANSCRIPT_PATH:-}"
-    [ -n "$m" ] && { printf '%s\t%s\t%s\n' "$(model_clean "$m")" "transcript:$tp" "$MODEL_SOURCE_CHECKS"; return 0; }
+      model_checked "transcript_path:${tp:-未提供}"
-  fi
+      if [ -n "$tp" ] && [ -f "$tp" ]; then
+        m=$(transcript_model)
+        [ -n "$m" ] && { printf '%s\t%s\t%s\n' "$(model_clean "$m")" "transcript:$tp" "$MODEL_SOURCE_CHECKS"; return 0; }
+      fi
 
-  model_checked "hook-stdin:model/model_id/model_slug/modelName/current_model/currentModel"
+      model_checked "hook-stdin:model/model_id/model_slug/modelName/current_model/currentModel"
-  m=$(json_model_value "$STDIN_JSON")
+      m=$(json_model_value "$STDIN_JSON")
-  [ -n "$m" ] && { printf '%s\t%s\t%s\n' "$(model_clean "$m")" "hook-stdin" "$MODEL_SOURCE_CHECKS"; return 0; }
+      [ -n "$m" ] && { printf '%s\t%s\t%s\n' "$(model_clean "$m")" "hook-stdin" "$MODEL_SOURCE_CHECKS"; return 0; }
+      ;;
+    codex)
+      # hook 負載是這一輪由 codex 自己餵進來的，不是別支 CLI 的紀錄，所以照收；
+      # 而且它反映當下這一輪，比落在檔案裡的紀錄新，排在 session 記錄前面。
+      model_checked "hook-stdin:model/model_id/model_slug/modelName/current_model/currentModel"
+      m=$(json_model_value "$STDIN_JSON")
+      [ -n "$m" ] && { printf '%s\t%s\t%s\n' "$(model_clean "$m")" "hook-stdin" "$MODEL_SOURCE_CHECKS"; return 0; }
 
-  model_checked "codex:${CODEX_HOME:-$HOME/.codex}、~/.codex/sessions、history.jsonl、session_index.jsonl"
+      model_checked "codex:${CODEX_HOME:-$HOME/.codex}/sessions、history.jsonl、session_index.jsonl"
-  cm=$(codex_model 2>/dev/null || true)
+      cm=$(codex_model 2>/dev/null || true)
-  if [ -n "$cm" ]; then
+      if [ -n "$cm" ]; then
-    m=$(printf '%s' "$cm" | cut -f1)
+        m=$(printf '%s' "$cm" | cut -f1)
-    src=$(printf '%s' "$cm" | cut -f2)
+        src=$(printf '%s' "$cm" | cut -f2)
-    [ -n "$m" ] && { printf '%s\t%s\t%s\n' "$(model_clean "$m")" "$src" "$MODEL_SOURCE_CHECKS"; return 0; }
+        [ -n "$m" ] && { printf '%s\t%s\t%s\n' "$(model_clean "$m")" "$src" "$MODEL_SOURCE_CHECKS"; return 0; }
-  fi
+      fi
+      ;;
+    copilot|antigravity|kiro)
+      # 這三支由 tools/jsc-wrap.sh 包起來跑，只餵得到環境變數：沒有 transcript、沒有 hook
+      # 負載，本機也沒有可讀的模型紀錄。這裡如實記成「沒有來源」，不去翻別支 CLI 的檔案。
+      model_checked "$_mcli：本機沒有可讀的模型紀錄，只認 JSC_MODEL"
+      ;;
+    *)
+      model_checked "未知 CLI：判不出是哪一支，不採用任何自動來源"
+      ;;
+  esac
 
   model_checked "JSC_MODEL"
   if [ -n "${JSC_MODEL:-}" ]; then
@@ -130,10 +214,18 @@ current_model_report() {
   printf '\t\t%s\n' "$MODEL_SOURCE_CHECKS"
 }
 
-# 目前 CLI 名稱：環境變數 > 依 stdin 特徵猜測 > unknown
+# 目前 CLI 名稱：環境變數 > 依環境特徵判斷 > unknown
+#
+# claude 的判準有三個，任一個成立就算。理由與 session_id() 那條退路鏈同源：CLAUDE_PLUGIN_ROOT
+# 只有 plugin 接線的 hook 執行環境才有，技能以 Bash 工具呼叫腳本時並不存在，於是同一個工作
+# 階段的兩條路徑一條認得出 claude、一條回 unknown，狀態檔名跟著分岔。CLAUDECODE 與
+# CLAUDE_CODE_SESSION_ID 兩者在工具呼叫的環境裡都看得到（實測確認），補上去兩條路徑才算得出
+# 同一個代號。只補 claude 這一支：其他 CLI 的環境特徵沒有實測過，猜一個填進來只會多一個
+# 錯誤來源，那幾支本來就由接線設定明確帶 JSC_CLI。
 cli_name() {
   if [ -n "${JSC_CLI:-}" ]; then printf '%s' "$JSC_CLI"
-  elif [ -n "${CLAUDE_PLUGIN_ROOT:-}" ]; then printf 'claude'
+  elif [ -n "${CLAUDE_PLUGIN_ROOT:-}" ] || [ -n "${CLAUDECODE:-}" ] \
+    || [ -n "${CLAUDE_CODE_SESSION_ID:-}" ]; then printf 'claude'
   else printf 'unknown'; fi
 }
 

hooks/sdlc-gate.sh

@@ -3,18 +3,37 @@
 #
 # 判準是階段的「能力標籤」，不是模型名稱：
 #   - 標籤資料讀 $JSC_HOME/model-tags.tsv，由 jsc-cli/tools/model-tags.sh sync 產生。
-#   - 目前模型 id 取自可驗證紀錄。優先讀 transcript，其次讀 hook stdin JSON 與 Codex 本機
+#   - 目前模型 id 取自可驗證紀錄，而且只讀屬於當前 CLI 的那一份（判定鏈見 lib.sh 的
-#     session 記錄。只有這些來源都失敗時，才接受 JSC_MODEL 這個人工覆寫。
+#     current_model_report）。claude 讀 transcript 與 hook stdin，codex 讀 hook stdin 與
+#     自己的 session 記錄，其餘 CLI 本機沒有可讀的紀錄。只有這些來源都失敗時，才接受
+#     JSC_MODEL 這個人工覆寫。
 #   - 不採用對話內容裡模型自稱的 id。自我回報無法驗證，等同沒有閘門。
 #   - 鎖存的是「階段的必要標籤」，不是「上鎖那一刻的模型」。鎖當時的模型只留作記錄，
 #     否則用不合格的模型起跑就會把自己鎖成合格，閘門永遠通過。
 #
-# 狀態檔：$JSC_HOME/sessions/{sid}.stage，單行「{stage}<TAB>{必要標籤}<TAB>{上鎖時的模型}<TAB>{模型來源}」。
+# 政策是 fail-closed：不知道能力就擋下，知道才比對能力標籤。不知道能力有三種，一律擋下——
+# 判不出是哪一支 CLI、判不出目前模型、模型判得出來但不在能力標籤表上。放行任何一種，用不
+# 合格的模型跑階段就查不出來，閘門形同虛設。代價是被擋住的人可能不知道怎麼脫困，所以每一則
+# 擋下的訊息都要帶逃生門：設 JSC_MODEL 人工指明模型，或執行本檔的 unlock 解除該階段的鎖。
+#
+# 狀態檔：$JSC_HOME/sessions/{cli}-{sid}.stage，單行
+# 「{stage}<TAB>{必要標籤}<TAB>{上鎖時的模型}<TAB>{模型來源}」。
+# 檔名帶 CLI 代號的理由見 lib.sh 的 stage_state_file：session id 判不出時會退回 default，
+# 不分 CLI 就會共用同一支 default.stage，一支上的鎖擋到另一支。舊路徑
+# $JSC_HOME/sessions/{sid}.stage 仍讀得到（往後相容），unlock 也會一併清掉，
+# 但新的寫入一律走新路徑。
 #
 # 用法：
 #   sdlc-gate.sh lock {stage}  階段閘門：比對實際模型與該階段必要標籤，通過才上鎖。
 #                              exit 0 = 通過並已上鎖；exit 1 = 未通過，呼叫端必須停止流程。
-#   sdlc-gate.sh unlock        移除狀態檔（被擋住又確定要放行時的逃生門）。
+#   sdlc-gate.sh unlock [{狀態檔}]
+#                              移除狀態檔（被擋住又確定要放行時的逃生門）。不帶參數時清掉這個
+#                              工作階段的新舊兩份；帶參數時清掉指定的那一份。
+#                              為什麼要收參數：hook 拿得到 stdin 的 session id 與 JSC_CLI，
+#                              手動執行拿不到，兩邊算出來的檔名可能不同，逃生門就按不到真正
+#                              擋人的那一支。所以擋人訊息會把實際讀到的路徑一起印出來，
+#                              照抄就解得開。參數只收 sessions 目錄底下的 .stage 檔，
+#                              避免這個逃生門變成任意刪檔的工具。
 #   sdlc-gate.sh check         hook 模式（UserPromptSubmit）：模型不符即擋下該輪提示。
 #   sdlc-gate.sh report        印出 {sid} {stage} {必要標籤} {模型 id} {模型來源} {判定}；無鎖不印。
 #
@@ -39,9 +58,10 @@
 # 結束碼（一個子命令一列）：
 #   lock              0=通過並已上鎖 1=未通過，呼叫端必須停止流程（階段名不合法、讀不到該
 #                     階段的必要標籤、判定不出目前模型、模型不在標籤表上、缺標籤、寫不進狀態檔）
-#   unlock            0=永遠成功，狀態檔不存在也算
+#   unlock            0=永遠成功，狀態檔不存在也算；不帶參數時新舊兩種路徑都會清掉
-#   check             0=放行 2=擋下該輪提示。安靜放行：沒有階段鎖、舊格式狀態檔讀不出必要標籤、
+#                     2=參數不是 sessions 目錄底下的 .stage 檔
-#                     必要標籤是 any、判定不出目前模型（只提醒不擋）
+#   check             0=放行 2=擋下該輪提示。安靜放行只剩三種：沒有階段鎖、舊格式狀態檔讀不出
+#                     必要標籤、必要標籤是 any。判定不出目前模型改為擋下，見上面的 fail-closed
 #   report            0=永遠成功，無鎖就不印
 #   wp-lock           0=已記下 2=存取庫不是 {owner}/{repo}、PR 編號不是數字、寫不進狀態檔
 #   wp-unlock         0=已結清，狀態檔不存在也算 2=存取庫或 PR 編號格式錯誤
@@ -112,7 +132,9 @@ case "${1:-}" in
   *) read_stdin ;;
 esac
 sid=$(session_id)
-state="$JSC_HOME/sessions/$sid.stage"
+# 讀寫兩條路徑分開：寫入一律走帶 CLI 代號的新路徑，讀取則允許退回舊路徑（往後相容）。
+state=$(stage_state_read_file)
+state_new=$(stage_state_file)
 TAGS_TSV="$JSC_HOME/model-tags.tsv"
 STAGES="plan analyze implement maintain"
 
@@ -182,8 +204,33 @@ model_verdict() { # $1=stage $2=req $3=model
   [ -z "$miss" ] && printf 'pass' || printf 'fail:%s' "$miss"
 }
 
-model_fail_message() { # $1=stage $2=checked
+# 逃生門說明。被擋住的人多半不熟這套東西，訊息要讓他照著做就脫困，所以兩條路都寫成
-  echo "[jsc][SDLC 閘門][ERR]：判定不出目前實際使用的模型，無法驗證是否符合階段「$1」。已檢查來源：${2:-無}。請確認 hook stdin 帶有 transcript_path 或 model 欄位、Codex session 記錄可讀，或明確設定 JSC_MODEL 作為人工覆寫後重跑。本次不進行任何工作。" >&2
+# 可以照抄的指令，而且把「可以填什麼」一併列出來。
+gate_escape_hint() { # $1=必要標籤 $2=擋人的那一支狀態檔（可省略）
+  _ok=$(eligible_models "$1")
+  echo "逃生門二選一："
+  echo "  1. 人工指明模型：設環境變數 JSC_MODEL={模型 id} 之後重來一次。標籤表上合格的模型 id：${_ok:-（表上沒有合格模型，請先補表）}。"
+  # 路徑照抄進指令裡：手動執行時算出來的檔名跟 hook 算出來的可能不同，不點名就解不到那一支。
+  if [ -n "${2:-}" ]; then
+    echo "  2. 解除這個階段的鎖：執行 sh $0 unlock $2。解除之後這道閘門就不再擋。"
+  else
+    echo "  2. 解除這個階段的鎖：執行 sh $0 unlock。解除之後這道閘門就不再擋。"
+  fi
+}
+
+# 判不出 CLI 時追加一句。這是「不知道能力」的第一種，成因與修法都跟另外兩種不同：
+# 不知道是哪一支 CLI，就不知道該讀誰的模型紀錄，接線設定要把代號帶上。
+gate_cli_hint() {
+  [ "$(cli_name)" = unknown ] || return 0
+  echo "另外：目前判不出是哪一支 CLI（環境變數 JSC_CLI 沒有設），所以連該讀哪一份模型紀錄都不知道。接線設定應以 JSC_CLI={CLI 代號} 帶上。"
+}
+
+model_fail_message() { # $1=stage $2=checked $3=必要標籤
+  {
+    echo "[jsc][SDLC 閘門][ERR]：判定不出目前實際使用的模型，無法驗證是否符合階段「$1」（需要 ${3:-未知}）。已檢查來源：${2:-無}。本次不進行任何工作。"
+    gate_cli_hint
+    gate_escape_hint "${3:-any}"
+  } >&2
 }
 
 # --- 工作包 PR 閘門（狀態檔：$JSC_HOME/wp/{owner}-{repo}-{index}.pr，一個工作包一支） ---
@@ -291,14 +338,17 @@ case "${1:-check}" in
     src=$(printf '%s' "$info" | cut -f2)
     checked=$(printf '%s' "$info" | cut -f3-)
     if [ -z "$cur" ]; then
-      model_fail_message "$stage" "$checked"
+      model_fail_message "$stage" "$checked" "$req"
       exit 1
     fi
 
     if [ "$req" != "any" ]; then
       have=$(model_tags "$cur")
       if [ -z "$have" ]; then
-        echo "[jsc][SDLC 閘門][ERR]：模型「$cur」不在能力標籤表上，無法判定是否夠格跑階段「$stage」（需要 $req）。請把該模型補進 jsc-cli/references/model-tags.md 後執行 model-tags.sh sync，本次不進行任何工作。" >&2
+        {
+          echo "[jsc][SDLC 閘門][ERR]：模型「$cur」（來源 ${src:-未知}）不在能力標籤表上，無法判定是否夠格跑階段「$stage」（需要 $req）。請把該模型補進 jsc-cli/references/model-tags.md 後執行 model-tags.sh sync，本次不進行任何工作。"
+          gate_escape_hint "$req"
+        } >&2
         exit 1
       fi
       miss=$(missing_tags "$req" "$have")
@@ -309,13 +359,29 @@ case "${1:-check}" in
       fi
     fi
 
-    printf '%s\t%s\t%s\t%s\n' "$stage" "$req" "$cur" "$src" > "$state" 2>/dev/null || {
+    printf '%s\t%s\t%s\t%s\n' "$stage" "$req" "$cur" "$src" > "$state_new" 2>/dev/null || {
-      echo "[jsc][SDLC 閘門][ERR]：寫不進狀態檔 $state，階段鎖未生效。" >&2; exit 1; }
+      echo "[jsc][SDLC 閘門][ERR]：寫不進狀態檔 $state_new，階段鎖未生效。" >&2; exit 1; }
     echo "[jsc][SDLC 閘門][OK]：階段「$stage」通過（需要 $req，目前模型 $cur，來源 $src），已上鎖。"
     exit 0 ;;
 
   unlock)
-    rm -f "$state" 2>/dev/null || true
+    target="${2:-}"
+    if [ -n "$target" ]; then
+      # 只認「上一層目錄叫 sessions、副檔名是 .stage」的路徑：逃生門不該順便變成任意刪檔的
+      # 工具。判準刻意不寫成「必須在這支行程算出來的 $JSC_HOME 底下」——擋人的是 hook，
+      # 解鎖的是人在殼層手動執行，兩邊的 JSC_HOME 未必相同，綁上去就會把照抄訊息的人擋掉，
+      # 那正是這個逃生門要避免的事。
+      case "$target" in
+        */sessions/*.stage) ;;
+        *)
+          echo "[jsc][SDLC 閘門][ERR]：unlock 的參數只收 sessions 目錄底下的 .stage 檔，收到「$target」。不帶參數則清掉這個工作階段自己那一份。" >&2
+          exit 2 ;;
+      esac
+      rm -f "$target" 2>/dev/null || true
+      exit 0
+    fi
+    # 新舊兩種路徑都要清。只清新的話，舊格式的鎖永遠解不開，被它擋住的人就沒有逃生門。
+    rm -f "$state_new" "$(stage_state_legacy_file)" 2>/dev/null || true
     exit 0 ;;
 
   check)
@@ -330,15 +396,24 @@ case "${1:-check}" in
     cur=$(printf '%s' "$info" | cut -f1)
     src=$(printf '%s' "$info" | cut -f2)
     checked=$(printf '%s' "$info" | cut -f3-)
-    # 判定不出模型時只提醒，不擋——否則使用者會被鎖在無法送出提示的狀態。
+    # 判定不出模型就擋下。這是刻意改成 fail-closed：放行等於「換一支讀不到紀錄的 CLI
+    # 就能繞過閘門」，閘門形同虛設。原本只提醒不擋，怕的是把人鎖在送不出提示的狀態——
+    # 那個風險是真的，所以訊息一定要把兩條逃生門寫清楚，照著做就能脫困。
     if [ -z "$cur" ]; then
-      echo "[jsc] SDLC 階段「${stage}」需要標籤「${req}」，但判定不出目前模型。已檢查來源：${checked:-無}。請確認 transcript、Codex session 記錄，或設定 JSC_MODEL 人工覆寫。"
+      {
-      exit 0
+        echo "[jsc][SDLC 閘門][ERR]：SDLC 階段「${stage}」需要能力標籤「${req}」，但判定不出目前用的是哪個模型，也就無法確認夠不夠格。已檢查來源：${checked:-無}。本輪提示已擋下。"
+        gate_cli_hint
+        gate_escape_hint "$req" "$state"
+      } >&2
+      exit 2
     fi
 
     have=$(model_tags "$cur")
     if [ -z "$have" ]; then
-      echo "[jsc][SDLC 閘門][ERR]：模型「${cur}」（來源 ${src:-未知}）不在能力標籤表上，無法確認是否夠格跑階段「${stage}」（需要 ${req}）。請補進 jsc-cli/references/model-tags.md 並執行 model-tags.sh sync；確定要放行請執行 jsc-hooks/hooks/sdlc-gate.sh unlock。本輪提示已擋下。" >&2
+      {
+        echo "[jsc][SDLC 閘門][ERR]：模型「${cur}」（來源 ${src:-未知}）不在能力標籤表上，無法確認是否夠格跑階段「${stage}」（需要 ${req}）。請補進 jsc-cli/references/model-tags.md 並執行 model-tags.sh sync。本輪提示已擋下。"
+        gate_escape_hint "$req" "$state"
+      } >&2
       exit 2
     fi
 
@@ -346,7 +421,10 @@ case "${1:-check}" in
     [ -z "$miss" ] && exit 0
 
     ok=$(eligible_models "$req")
-    echo "[jsc][SDLC 閘門][ERR]：SDLC 階段「${stage}」需要標籤「${req}」，目前模型「${cur}」（來源 ${src:-未知}）缺少「${miss}」。請切換到下列任一模型後重送：${ok:-（表上無合格模型，請補表）}。要結束本階段的鎖請執行 jsc-hooks/hooks/sdlc-gate.sh unlock。本輪提示已擋下。" >&2
+    {
+      echo "[jsc][SDLC 閘門][ERR]：SDLC 階段「${stage}」需要標籤「${req}」，目前模型「${cur}」（來源 ${src:-未知}）缺少「${miss}」。請切換到下列任一模型後重送：${ok:-（表上無合格模型，請補表）}。本輪提示已擋下。"
+      echo "要結束本階段的鎖請執行：sh $0 unlock $state"
+    } >&2
     exit 2 ;;
 
   report)

hooks/write-guard.sh

@@ -24,10 +24,12 @@
 #
 # --- stage 模式 ---
 #
-# 階段鎖狀態檔沿用 sdlc-gate.sh 那一份（$JSC_HOME/sessions/{sid}.stage，單行
+# 階段鎖狀態檔沿用 sdlc-gate.sh 那一份（$JSC_HOME/sessions/{cli}-{sid}.stage，單行
 # 「{階段}<TAB>{必要標籤}<TAB>{上鎖時的模型}」），這裡只讀不寫：判準與格式留在 sdlc-gate.sh，
-# 兩邊各存一份就會漂移。plan 與 analyze 是純邏輯階段，產出是 wiki 頁不是程式碼，所以那兩個
+# 兩邊各存一份就會漂移。路徑一律取自 lib.sh 的 stage_state_read_file，連「新路徑優先、舊路徑
-# 階段鎖著時 Write、Edit、MultiEdit 一律擋下；implement 與 maintain 本來就要寫檔，放行。
+# 往後相容」這條規則也不在這裡抄第二份。plan 與 analyze 是純邏輯階段，產出是 wiki 頁不是
+# 程式碼，所以那兩個階段鎖著時 Write、Edit、MultiEdit 一律擋下；implement 與 maintain
+# 本來就要寫檔，放行。
 #
 # --- review 模式 ---
 #
@@ -124,16 +126,18 @@ write_tool_or_exit() {
 # ── stage：plan 與 analyze 階段鎖存在時擋下寫檔
 if [ "$mode" = stage ]; then
   write_tool_or_exit
-  state="$JSC_HOME/sessions/$(session_id).stage"
+  state=$(stage_state_read_file)
   [ -f "$state" ] && [ -r "$state" ] || exit 0
   stage=$(cut -f1 "$state" 2>/dev/null | head -n1)
   case "$stage" in
     plan|analyze) ;;
     *) exit 0 ;;   # implement 與 maintain 本來就要寫檔；讀不出階段也放行
   esac
+  # 解除指令帶上實際讀到的狀態檔路徑：擋人的是 hook，解鎖的是人在殼層手動執行，兩邊算出來
+  # 的檔名未必相同，不點名就會解到別的地方去。
   deny "目前鎖在 SDLC「$stage」階段，這個階段只產出計畫或分析頁，不寫檔案。本次寫入已擋下。" \
 "改法：把結論寫進該階段的 wiki 頁；真的要動程式碼請先進入 implement 階段。
-解除階段鎖：jsc-hooks/hooks/sdlc-gate.sh unlock"
+解除階段鎖：sh $HERE/sdlc-gate.sh unlock $state"
 fi
 
 # ── review：稽核類技能執行中擋下寫檔

plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "jsc-hooks",
-  "version": "0.3.7",
+  "version": "0.3.8",
   "description": "跨 CLI hooks：STE100 語言強制、工時計時、技能用量記錄、SDLC 模型鎖、版本前置檢查、註解範圍守門、繁中編碼守門、部署後強制重啟、寫入與提交閘門",
   "skills": "./skills/",
   "jsc": {

references/behaviors.md

@@ -7,10 +7,10 @@
 | 項目 | 內容 |
 | --- | --- |
 | 觸發時機 | 裝好或更新完 jsc 技能組之後，要把九支 hook 接線到每一支已安裝的 CLI 時用；`jsc-cli:deploy` 收尾會把偵測到的 CLI 清單交給它。不用於撰寫新的 hook，也不用於單獨修一支壞掉的 hook，那是 `jsc-hooks:repair` 的事 |
-| 關鍵步驟 | 取得 CLI 清單（呼叫端交來的優先，沒有才自己跑 `detect-clis.sh`）、第一支 CLI 單獨跑完整條管線（它負責更新共用的 `$JSC_HOME/current/jsc-hooks` 連結）、其餘 CLI 一支一個 sub agent 並行、每支 CLI 依序走 purge、接線、status、smoke、scan 五道關卡、讀每道關卡自己印的第一行判定、任一關卡出錯就寫 `ERROR_{HASH}` 並轉給 `jsc-hooks:repair`、逐 CLI 回報五道關卡的結果 |
+| 關鍵步驟 | 取得 CLI 清單（呼叫端交來的優先，沒有才自己跑 `detect-clis.sh`）、第一支 CLI 單獨跑完整條管線（它負責更新共用的 `$JSC_HOME/current/jsc-hooks` 連結）、其餘 CLI 一支一個 sub agent 並行、每支 CLI 依序走 purge、接線、status、smoke、scan 五道關卡、讀每道關卡自己印的第一行判定、任一關卡出錯就寫 `ERROR_{HASH}` 並轉給 `jsc-hooks:repair`（異常頁與索引目錄頁分屬兩個存取庫，各自解析；只解不出目錄頁的存取庫時異常頁照寫、索引跳過，回報要講明那一頁沒被索引）、逐 CLI 回報五道關卡的結果 |
 | 外部呼叫 | `tools/wire-cli.sh purge`、`tools/wire-cli.sh {cli}`、`tools/wire-cli.sh status`、`tools/wire-cli.sh smoke`、`tools/scan-hook-errors.sh`、`tools/report-error.sh`、`jsc-cli/tools/detect-clis.sh`、`jsc-hooks:repair` 技能、`jsc-gitea:wiki`（寫 `ERROR_{HASH}` 時經 `report-error.sh`）；接線腳本內部另呼叫 `hooks/skill-name.sh` 與 `hooks/deny.sh` 做冒煙斷言 |
 | 完成條件 | 每一支偵測到的 CLI 都有五道關卡各一行判定，沒有任何一道回結束碼 2，smoke 的 `lines` 條數與它自己的斷言相符，claude、codex、copilot、antigravity 回 `wired` 而 kiro 回 `degraded`（CLI 擋不下技能叫用），四支非 claude 的執行期錯誤掃描一律據實回 `unavailable`，各 CLI 的形狀與觸發驗證等級分開寫進回報（codex、antigravity、kiro 形狀實證，copilot 形狀未證；kiro 觸發部分實證，其餘未驗證），而且每一筆錯誤都帶一個 `ERROR_{HASH}` 結果與一條對 `develop` 的修正 PR 連結 |
-| 可驗證跡象 | 各 CLI 的設定檔多出 jsc 段落：codex 的 `config.toml` 標記段落、`hooks/codex-hooks.json`（從 `hooks/hooks.json` 推導，matcher `Skill` 換成 `Bash`）與 `.codex-plugin/plugin.json` 指過去的 `hooks` 路徑字串、copilot 的 `~/.copilot/settings.json` 頂層 `hooks` 鍵（matcher `skill`，合併不覆寫，`enabledPlugins` 與第三方條目原樣保留）與 `$COPILOT_HOME` 底下的指引檔、antigravity 的 `~/.gemini/config/hooks.json` 的 `jsc` 段落（`PreToolUse` 為 Grouped、matcher `^view_file$`，`PreInvocation` 維持 Flat）、kiro 的 `~/.kiro/agents/jsc.json`（`hooks` 為 `agentSpawn`、`userPromptSubmit`、`stop` 三個合法事件加 `timeout_ms`、兩層 `skill://` glob 的 `resources`、明列的 `tools`，並通過 `kiro-cli agent validate`）與 `~/.kiro/settings/cli.json` 的 `chat.defaultAgent=jsc`；四支非 claude 的接線命令都以 `JSC_CLI={代號}` 前綴自帶 CLI 代號，缺了它兩道閘門解不出技能名、一律安靜放行，所以 `status` 把它列成單獨一項；另有 `$JSC_HOME/current/jsc-hooks` 符號連結建立或更新、`$JSC_HOME/backup/hooks/{cli}/{時間戳}/` 留下 purge 前的備份、出錯時 wiki 多一頁 `ERROR_{HASH}` 並在 `ERROR_CONTENTS` 補一列、修正路徑留下一條對 `develop` 的 PR |
+| 可驗證跡象 | 各 CLI 的設定檔多出 jsc 段落：codex 的 `config.toml` 標記段落、`hooks/codex-hooks.json`（從 `hooks/hooks.json` 推導，matcher `Skill` 換成 `Bash`）與 `.codex-plugin/plugin.json` 指過去的 `hooks` 路徑字串、copilot 的 `~/.copilot/settings.json` 頂層 `hooks` 鍵（matcher `skill`，合併不覆寫，`enabledPlugins` 與第三方條目原樣保留）與 `$COPILOT_HOME` 底下的指引檔、antigravity 的 `~/.gemini/config/hooks.json` 的 `jsc` 段落（`PreToolUse` 為 Grouped、matcher `^view_file$`，`PreInvocation` 維持 Flat）、kiro 的 `~/.kiro/agents/jsc.json`（`hooks` 為 `agentSpawn`、`userPromptSubmit`、`stop` 三個合法事件加 `timeout_ms`、兩層 `skill://` glob 的 `resources`、明列的 `tools`，並通過 `kiro-cli agent validate`）與 `~/.kiro/settings/cli.json` 的 `chat.defaultAgent=jsc`；四支非 claude 的接線命令都以 `JSC_CLI={代號}` 前綴自帶 CLI 代號，缺了它兩道閘門解不出技能名、一律安靜放行，所以 `status` 把它列成單獨一項；另有 `$JSC_HOME/current/jsc-hooks` 符號連結建立或更新、`$JSC_HOME/backup/hooks/{cli}/{時間戳}/` 留下 purge 前的備份、出錯時 wiki 多一頁 `ERROR_{HASH}`（落在 `JSC_WIKI_REPO_ERROR` 解出的存取庫）並在索引目錄頁補一列（落在 `JSC_WIKI_REPO_CONTENTS` 解出的另一個存取庫，那一列指向異常頁的連結是絕對網址）、修正路徑留下一條對 `develop` 的 PR |
 
 ## repair
 

skills/hooks-install/SKILL.md

@@ -75,7 +75,7 @@ The detailed flow **MUST run as a sub agent**; the main agent only reports the s
    5. `tools/scan-hook-errors.sh --cli {cli}` — only claude keeps hook results in its native records and can answer `clean` or `errors`; codex, copilot, antigravity and kiro answer `unavailable`, and their runtime evidence comes from the smoke stage alone. Exit 0 covers both `clean` and `unavailable`, exit 1 is `errors` and every entry with `jsc=true` goes to step 3, exit 2 is a bad CLI name.
 
    Done when every detected CLI has exactly one verdict line per stage, no stage exited 2, the smoke stage's `lines` count matches its own assertion, the four non-claude CLIs are reported as `unavailable` rather than clean on the scan stage, and antigravity and kiro carry the note that their hook firing is unverified.
-3. For each error — a failed purge, a failed wiring, an `unwired` status, a failed smoke, or a scanned error with `jsc=true` — run `tools/report-error.sh --hook {script name} --exit {code} --summary "{reason}" --cli {cli}` with the script's `[jsc]` output on stdin, then hand the failure to `jsc-hooks:repair`, which **MUST run as a sub agent** and must finish by opening a PR against `develop`. Aborting the remaining installs here is allowed as long as the repair starts. Exit 0 with an `ERROR_{HASH}` page name and URL on stdout means the page was written; exit 0 with empty output means `JSC_WIKI_REPO_ERROR` and `JSC_WIKI_REPO` are both unset, so carry that reason into step 4 instead; exit 2 means the call itself was malformed — `--hook` or `--summary` is missing — so fix the arguments and rerun the same call; exit 4 means the wiki record did not land, so report the failure text and still start the repair — a page that could not be written is no reason to leave a broken hook wired. Exit 4 covers two cases, and the report has to say which: a failed write, or the script refusing to write the error directory page because it could not read the old one back. That directory is appended to, never overwritten: every row on it is somebody else's error report, so the script reads the page, adds this run's row, and writes the whole page. Only a genuine 404 (`wiki-get` exit 4) means the page is not there yet and lets it build one from the template. An invalid key (exit 7) or any other API failure (exit 8) leaves the old rows unknown, so it skips the directory write and names the code instead — writing a fresh template over a directory it never read would erase every earlier report, with no merge and no backup behind it. A scanned error with `jsc=false` belongs to a third-party hook: report it and leave it alone. Skip this step when every CLI passed all five stages. Done when every error carries one `ERROR_{HASH}` result — a page name and URL, or the recorded reason no page was written — and one repair PR URL against `develop`.
+3. For each error — a failed purge, a failed wiring, an `unwired` status, a failed smoke, or a scanned error with `jsc=true` — run `tools/report-error.sh --hook {script name} --exit {code} --summary "{reason}" --cli {cli}` with the script's `[jsc]` output on stdin, then hand the failure to `jsc-hooks:repair`, which **MUST run as a sub agent** and must finish by opening a PR against `develop`. Aborting the remaining installs here is allowed as long as the repair starts. The error page and the error directory page live in two different wiki repos, resolved separately: the page through `wiki-repo ERROR`, the directory through `wiki-repo CONTENTS`. Exit 0 with an `ERROR_{HASH}` page name and URL on stdout means the page was written; the same exit 0 with a `[jsc]` line on stderr still means the page landed, and that line says what is missing — either the directory repo would not resolve, so nothing indexes the page, or the page URL could not be read back, so the page name comes out on its own — carry that note into step 4. Exit 0 with no output at all means the run ended on one of the quiet-degradation reasons listed in the script's own header — no `gitea.sh` on the path, the error page's wiki repo unresolved, the hash not computed, or a temp file not created — so no page was written at all and that reason goes into step 4 instead; exit 2 means the call itself was malformed — `--hook` or `--summary` is missing — so fix the arguments and rerun the same call; exit 4 means the wiki record did not land, so report the failure text and still start the repair — a page that could not be written is no reason to leave a broken hook wired. Exit 4 covers two cases, and the report has to say which: a failed write, or the script refusing to write the error directory page because it could not read the old one back. That directory is appended to, never overwritten: every row on it is somebody else's error report, so the script reads the page, adds this run's row, and writes the whole page. Only a genuine 404 (`wiki-get` exit 4) means the page is not there yet and lets it build one from the template. An invalid key (exit 7) or any other API failure (exit 8) leaves the old rows unknown, so it skips the directory write and names the code instead — writing a fresh template over a directory it never read would erase every earlier report, with no merge and no backup behind it. A scanned error with `jsc=false` belongs to a third-party hook: report it and leave it alone. Skip this step when every CLI passed all five stages. Done when every error carries one `ERROR_{HASH}` result — a page name with its URL, a page name plus the reason the URL is missing, or the recorded reason no page was written — and one repair PR URL against `develop`.
 4. Report five results per CLI — purge, wiring, status, smoke, scan — each with the reason its script printed, plus the smoke `lines` count, any `ERROR_{HASH}` page name and every repair PR URL. Done when every detected CLI appears with one verdict per stage and every repair has a PR against `develop`.
 
 ## Notes

templates/error-contents.md

@@ -2,10 +2,14 @@
 
 > 由 `jsc-hooks` 的失敗回報流程維護。新異常附加在文末，查問題時先看最新一筆。
 >
-> 寫入語意：一列代表一次 hook 異常回報。寫入前先讀回整頁，同一筆異常已經有列就更新那一列，沒有才在文末附加一列，最後整頁寫回。禁止整頁覆蓋，也不得改動別人的列。
+> 存放位置：本頁落在 `JSC_WIKI_REPO_CONTENTS` 解出的目錄專用存取庫，與異常頁的存取庫是兩個不同的存取庫。
+>
+> 寫入語意：一列代表一次 hook 異常回報。寫入前先讀回整頁，同一筆異常已經有列就更新那一列，沒有才在文末附加一列，最後整頁寫回。一律 upsert 附加，禁止整頁覆蓋，也不得改動別人的列。
+>
+> 連結寫法：指向異常頁的連結一律用 `gitea.sh wiki-url` 產出的絕對網址。跨存取庫的 `[[頁名]]` 解不開，只會留下死連結。
 
 ## 異常清單
 
 | 時間 | 頁名 | 存取庫名稱 | 觸發 hook | 退出碼 | 摘要 |
 | --- | --- | --- | --- | --- | --- |
-| {yyyy-MM-dd HH:mm:ss} | [[{error title}|ERROR_{HASH}]] | {owner}/{repo} | {hook_name} | {exit_code} | {error_summary} |
+| {yyyy-MM-dd HH:mm:ss} | [{error title}]({error url}) | {owner}/{repo} | {hook_name} | {exit_code} | {error_summary} |

tools/report-error.sh

@@ -12,13 +12,20 @@
 #   相關輸出（stdout／stderr 摘要）由標準輸入讀入，可省略。
 #
 # 輸出:
-#   成功印出「{頁名} {網址}」一行。
+#   成功印出「{頁名} {網址}」一行。網址在異常頁寫成功之後才取，頁名的 hash 帶時間戳，
-#   wiki 位置解析不出來（JSC_WIKI_REPO_ERROR 與 JSC_WIKI_REPO 都沒設，或找不到
+#   每次都是全新的頁，寫之前查一定是 404。取不到網址時只印頁名，原因走 stderr，仍然 exit 0。
-#   gitea.sh）時安靜降級：不輸出、exit 0。回報失敗不該再變成一次失敗。
+#   下列四種情形安靜降級：不寫任何頁、不輸出任何內容、exit 0。回報失敗不該再變成一次失敗。
+#     1. 找不到 gitea.sh
+#     2. 解析不出異常頁的 wiki 存取庫（JSC_WIKI_REPO_ERROR 與 JSC_WIKI_REPO 都沒設）
+#     3. 算不出 HASH（hash-id 失敗或回空字串）
+#     4. 建不出暫存檔（mktemp 失敗）
+#   異常頁與目錄頁分屬兩個存取庫，各解各的：解不出異常頁的存取庫就整支降級；解得出
+#   異常頁、只解不出目錄頁的存取庫，就只寫異常頁、跳過目錄頁更新，印出頁名，仍然 exit 0。
+#   一份寫得成的異常紀錄，不該因為目錄頁沒地方放就整份丟掉。
 #   寫入 wiki 失敗才以 exit 4 回報，訊息走 stderr。
 #
-# 結束碼: 0=已寫入 wiki 並印出「{頁名} {網址}」，或安靜降級（找不到 gitea.sh、解析不出
+# 結束碼: 0=已寫入異常頁並印出頁名（取得網址就一併印出），或以上列四種安靜降級原因之一
-#           wiki 存取庫、算不出 HASH、建不出暫存檔）——回報失敗不該再變成一次失敗
+#           結束、沒有寫出任何頁也沒有任何輸出——回報失敗不該再變成一次失敗
 #         2=用法錯誤（缺 --hook 或 --summary）
 #         4=寫入 wiki 失敗（異常頁與索引目錄頁，任一支寫不進去就算），或目錄頁的舊內容
 #           讀不回來（wiki-get 回 7 金鑰失效、8 其他 API 失敗）而放棄寫入；訊息走 stderr。
@@ -27,8 +34,10 @@
 #   就地結束並回 2，跟用法錯誤同碼；分不出是哪一種時，先確認 hooks/lib.sh 在不在。
 #
 # 頁名:
-#   ERROR_{HASH}，HASH 取「{owner}/{repo} {hook} {時間}」的 SHA-1 前 8 碼（共用 hash 規則）。
+#   ERROR_{HASH}，HASH 取「{owner}/{repo} {hook} {時間}」的 SHA-1 完整 40 碼大寫十六進位
+#   （共用 hash 規則）。三段以空白相連當 hash 輸入。
 #   時間放進 hash：同一種失敗再發生時要另開新頁，不覆寫舊紀錄。
+#   索引目錄頁的頁名固定，不帶 HASH。
 #
 # 誰來呼叫:
 #   由操作者手動執行，或由技能步驟執行（`jsc-hooks:hooks-install` 在 wire-cli.sh 回報
@@ -63,12 +72,19 @@ if [ -z "$hook" ] || [ -z "$summary" ]; then
 fi
 
 gsh=$(jsc_gitea_sh) || exit 0
+# 異常頁與索引目錄頁落在兩個不同的存取庫，各解各的：異常頁走自己的型別，目錄頁走目錄專用
+# 型別。異常頁的存取庫解不出來就整支降級，連異常都沒地方寫，做下去也沒意義。
 wrepo=$(sh "$gsh" wiki-repo ERROR 2>/dev/null) || exit 0
 [ -n "$wrepo" ] || exit 0
+# 目錄頁的存取庫解不出來不算失敗：異常頁照寫，只跳過目錄頁更新，仍然 exit 0。
+# 一份寫得成的異常紀錄，不該因為索引沒地方放就整份丟掉。
+crepo=$(sh "$gsh" wiki-repo CONTENTS 2>/dev/null || true)
 
 # 存取庫名稱未指定就取工作目錄的 origin（只用來標記異常屬於哪個存取庫）
 if [ -z "$repo" ]; then
   origin=$(git config --get remote.origin.url 2>/dev/null || true)
+  # 尾綴的 .git 在這裡剝掉：hash 工具刻意不做輸入正規化，同一份輸入要算出同一個 HASH，
+  # 正規化就是呼叫端的責任。帶不帶 .git 會算出兩個不同的頁，同一個存取庫就分裂成兩份紀錄。
   repo=$(printf '%s' "$origin" \
     | sed -n 's#.*[/:]\([^/]*\)/\([^/]*\)$#\1/\2#p' | sed 's/\.git$//')
 fi
@@ -116,12 +132,41 @@ fill '{HASH}' "$hash" < "$ROOT/templates/error-page.md" \
   | fill '{stdout / stderr 摘要}' "$detail" \
   | fill '{yyyyMMdd}_{HHmmss}' "$ticket_ts" > "$tmp_page"
 
-row=$(printf '| %s | [[%s|%s]] | %s | %s | %s | %s |' \
+# 異常頁先寫，網址後取。頁名的 hash 帶時間戳，每次回報都是一個全新的頁，寫進去之前查網址
-  "$ts" "$hook 異常 $ts" "$page" "$repo" "$hook" "$code" "$summary")
+# 一定是 404，拿到的必然是空字串；目錄頁那一列會變成沒有連結的死字，stdout 也少一半。
+if ! sh "$gsh" wiki-put "$wrepo" "$page" "$tmp_page" >/dev/null 2>&1; then
+  echo "[jsc] 寫入 $page 失敗（$wrepo）。" >&2
+  exit 4
+fi
+
+# 目錄頁與異常頁分屬兩個存取庫，wiki 的 [[頁名]] 只在同一個存取庫內解得開，跨庫一律解成
+# 死連結。所以目錄頁指向異常頁的連結一律用絕對網址。
+# 網址取不到不算失敗：異常頁已經寫成功了，只是這一列少一條連結。這裡把原因記下來走 stderr，
+# 結束碼照舊——安靜降級仍是 exit 0，回報失敗不該再變成一次失敗。
+url=$(sh "$gsh" wiki-url "$wrepo" "$page" 2>/dev/null)
+url_code=$?
+url_note=''
+if [ "$url_code" -ne 0 ]; then
+  url=''
+  case "$url_code" in
+    4) url_note='頁面查不到（wiki-url 回 4），寫入後尚未生效' ;;
+    5) url_note='回應裡沒有 html_url（wiki-url 回 5）' ;;
+    7) url_note='金鑰失效或權限不足（wiki-url 回 7）' ;;
+    *) url_note="wiki-url 結束碼 $url_code" ;;
+  esac
+  echo "[jsc] 取不到 $page 的網址：$url_note。目錄頁那一列與輸出只留頁名。" >&2
+fi
+
+emit() { # 異常頁已經寫成功，頁名一定要印；網址取不到就只印頁名，不印一個空欄位
+  if [ -n "$url" ]; then printf '%s %s\n' "$page" "$url"; else printf '%s\n' "$page"; fi
+}
+
+row=$(printf '| %s | [%s](%s) | %s | %s | %s | %s |' \
+  "$ts" "$hook 異常 $ts" "$url" "$repo" "$hook" "$code" "$summary")
 
 build_contents() { # 用範本建一份全新的目錄頁；只有確定舊頁不存在時才可以呼叫
   fill '{yyyy-MM-dd HH:mm:ss}' "$ts" < "$ROOT/templates/error-contents.md" \
-    | fill '{HASH}' "$hash" \
+    | fill '{error url}' "$url" \
     | fill '{error title}' "$hook 異常 $ts" \
     | fill '{owner}/{repo}' "$repo" \
     | fill '{hook_name}' "$hook" \
@@ -129,6 +174,12 @@ build_contents() { # 用範本建一份全新的目錄頁；只有確定舊頁
     | fill '{error_summary}' "$summary" > "$tmp_list"
 }
 
+if [ -z "$crepo" ]; then
+  echo "[jsc] 目錄頁的 wiki 存取庫解不出來，只寫異常頁，跳過目錄；$page 已建立（$wrepo）。" >&2
+  emit
+  exit 0
+fi
+
 # 異常目錄頁一律附加，不整頁覆蓋。頁上每一列都是別人回報的異常，本腳本沒有從別處讀過
 # 那些列，所以先把舊頁讀回來、把新列附在文末（最新一筆在最後），再整頁寫回。
 # 這個語意完全靠「讀得回舊內容」撐著，因此依 wiki-get 的結束碼分流：
@@ -138,27 +189,19 @@ build_contents() { # 用範本建一份全新的目錄頁；只有確定舊頁
 #   8 → 其他 API 失敗，舊內容一樣未知，處置同 7
 # 為什麼 7 與 8 不能當成「頁面不存在」：拿範本蓋掉一份讀不回來的目錄頁，等於刪光所有既有
 # 列，而 wiki-put 不做合併、也不留備份，蓋掉就救不回來。
-sh "$gsh" wiki-get "$wrepo" ERROR_CONTENTS > "$tmp_list" 2>/dev/null
+sh "$gsh" wiki-get "$crepo" ERROR_CONTENTS > "$tmp_list" 2>/dev/null
 get_code=$?
-contents_skip=''
 case "$get_code" in
   0) if [ -s "$tmp_list" ]; then printf '%s\n' "$row" >> "$tmp_list"; else build_contents; fi ;;
   4) build_contents ;;
-  *) contents_skip=$get_code ;;
+  *)
+    echo "[jsc] 讀取目錄頁失敗（$crepo，wiki-get 結束碼 $get_code），舊內容未知，不寫目錄頁；$page 已建立。" >&2
+    exit 4 ;;
 esac
 
-if ! sh "$gsh" wiki-put "$wrepo" "$page" "$tmp_page" >/dev/null 2>&1; then
+if ! sh "$gsh" wiki-put "$crepo" ERROR_CONTENTS "$tmp_list" >/dev/null 2>&1; then
-  echo "[jsc] 寫入 $page 失敗（$wrepo）。" >&2
+  echo "[jsc] 寫入目錄頁失敗（$crepo），$page 已建立。" >&2
-  exit 4
-fi
-if [ -n "$contents_skip" ]; then
-  echo "[jsc] 讀取 ERROR_CONTENTS 失敗（$wrepo，wiki-get 結束碼 $contents_skip），舊內容未知，不寫目錄頁；$page 已建立。" >&2
-  exit 4
-fi
-if ! sh "$gsh" wiki-put "$wrepo" ERROR_CONTENTS "$tmp_list" >/dev/null 2>&1; then
-  echo "[jsc] 寫入 ERROR_CONTENTS 失敗（$wrepo），$page 已建立。" >&2
   exit 4
 fi
 
-url=$(sh "$gsh" wiki-url "$wrepo" "$page" 2>/dev/null || true)
+emit
-printf '%s %s\n' "$page" "$url"

tools/wire-cli.sh

@@ -1354,7 +1354,8 @@ if [ "$action" = smoke ]; then
   # 那一類會讓總數永遠對不上，斷言也就形同虛設。
   #   hook 模式    九支 hook 的每個接線模式各一條。sdlc-gate.sh、comment-scope.sh、
   #                lang-guard.sh 與 write-guard.sh 各有多個模式，所以比 hook 支數多
-  #   模型來源     sdlc-gate.sh lock 取模型代號的四條來源判定路徑
+  #   模型與階段鎖 sdlc-gate.sh 取模型代號的四條來源判定路徑，加上「不知道能力就擋下」的
+  #                三種情形、check 的 fail-closed，以及階段鎖狀態檔的 CLI 區隔與舊格式相容
   #   工作包       sdlc-gate.sh wp-check skill 的歸屬判定路徑
   #   重啟閘門     restart-gate.sh 的判定、清除路徑與狀態檔範圍檢查
   #   寫入閘門     write-guard.sh 三種擋人模式與 release 解除模式的判定路徑
@@ -1364,7 +1365,7 @@ if [ "$action" = smoke ]; then
   #   跨 CLI 貫通  restart-gate.sh 吃五支 CLI 的真實負載，驗判定與輸出形態串得起來
   #   接線形狀     每支 CLI 要寫出去的內容真的產出來一次，驗結構本身（正反案例各一組）
   SMOKE_EXPECT_HOOK=17
-  SMOKE_EXPECT_MODEL=4
+  SMOKE_EXPECT_MODEL=12
   SMOKE_EXPECT_WP=6
   SMOKE_EXPECT_RS=16
   SMOKE_EXPECT_WG=21
@@ -1424,8 +1425,11 @@ if [ "$action" = smoke ]; then
   smoke_one sdlc-gate.sh "wp-check prompt"
   smoke_one sdlc-gate.sh "wp-check skill"
 
-  smoke_model_case() { # $1=情境 $2=來源模式 $3=預期來源片段
+  # 第四個參數是這個案例要用的 CLI 代號，不跟著這一輪接線的 $cli 走：模型偵測鏈已經依 CLI
-    _name="$1"; _mode="$2"; _want="$3"
+  # 分流，transcript 只有 claude 讀得到、codex session 記錄只有 codex 讀得到。拿 $cli 去跑
+  # 每一個案例，換一支 CLI 冒煙就會有一半的案例本來就不該命中，測的東西跟著變。
+  smoke_model_case() { # $1=情境 $2=來源模式 $3=預期來源片段 $4=案例用的 CLI 代號
+    _name="$1"; _mode="$2"; _want="$3"; _mcli="$4"
     # 先計數再開工：底下建不出暫存目錄那條路徑也會印一條結果行，計數放在後面就會漏掉它。
     smoke_n_model=$((smoke_n_model + 1))
     _home=$(mktemp -d 2>/dev/null) || {
@@ -1446,11 +1450,11 @@ if [ "$action" = smoke ]; then
       override) _json='{"session_id":"smoke-model-override"}'; _env="JSC_MODEL=gpt-5.x" ;;
     esac
     if [ "$_mode" = override ]; then
-      _out=$(printf '%s' "$_json" | JSC_HOME="$_home" CODEX_HOME="$_home/codex" JSC_CLI="$cli" JSC_MODEL="gpt-5.x" sh "$HOOKS/sdlc-gate.sh" lock plan 2>&1); _rc=$?
+      _out=$(printf '%s' "$_json" | JSC_HOME="$_home" CODEX_HOME="$_home/codex" JSC_CLI="$_mcli" JSC_MODEL="gpt-5.x" sh "$HOOKS/sdlc-gate.sh" lock plan 2>&1); _rc=$?
     else
-      _out=$(printf '%s' "$_json" | JSC_HOME="$_home" CODEX_HOME="$_home/codex" JSC_CLI="$cli" sh "$HOOKS/sdlc-gate.sh" lock plan 2>&1); _rc=$?
+      _out=$(printf '%s' "$_json" | JSC_HOME="$_home" CODEX_HOME="$_home/codex" JSC_CLI="$_mcli" sh "$HOOKS/sdlc-gate.sh" lock plan 2>&1); _rc=$?
     fi
-    _rep=$(JSC_HOME="$_home" CODEX_HOME="$_home/codex" JSC_CLI="$cli" \
+    _rep=$(JSC_HOME="$_home" CODEX_HOME="$_home/codex" JSC_CLI="$_mcli" \
       sh "$HOOKS/sdlc-gate.sh" report </dev/null 2>/dev/null)
     if [ "$_rc" -eq 0 ] && printf '%s\n%s' "$_out" "$_rep" | grep -qF "$_want"; then
       printf '[jsc] sdlc-gate.sh model（%s）：exit 0，來源含 %s，與預期相同。\n' "$_name" "$_want" >> "$smoke_out"
@@ -1461,10 +1465,117 @@ if [ "$action" = smoke ]; then
     fi
     rm -rf "$_home"
   }
-  smoke_model_case "transcript 實查" transcript "transcript:"
+  smoke_model_case "transcript 實查" transcript "transcript:" claude
-  smoke_model_case "Codex session 記錄" codex "codex-session:"
+  smoke_model_case "Codex session 記錄" codex "codex-session:" codex
-  smoke_model_case "stdin model 欄位" stdin "hook-stdin"
+  smoke_model_case "stdin model 欄位" stdin "hook-stdin" claude
-  smoke_model_case "JSC_MODEL 人工覆寫" override "人工覆寫:JSC_MODEL"
+  # 人工覆寫對每一支 CLI 都保留，所以這一條照這一輪接線的 CLI 跑。
+  smoke_model_case "JSC_MODEL 人工覆寫" override "人工覆寫:JSC_MODEL" "$cli"
+
+  # 「不知道能力就擋下」的三種情形。判定結果與訊息一起驗：只比結束碼的話，訊息漏掉逃生門
+  # 一樣是綠燈，而被擋住的人就真的出不來了——那才是這道 fail-closed 真正的風險。
+  smoke_model_deny_case() { # $1=情境 $2=案例用的 CLI 代號 $3=JSC_MODEL 值 $4=預期訊息片段
+    smoke_n_model=$((smoke_n_model + 1))
+    _home=$(mktemp -d 2>/dev/null) || {
+      smoke_fails=$((smoke_fails + 1))
+      printf '[jsc] sdlc-gate.sh model（%s）：建不出暫存目錄，擋人判定沒驗到。\n' "$1" >> "$smoke_out"
+      return
+    }
+    mkdir -p "$_home/sessions" "$_home/codex/sessions/2026/08/28" 2>/dev/null
+    printf 'stage\tplan\treasoning-max\nmodel\tgpt-5.x\treasoning-max,reasoning-high,coding\n' > "$_home/model-tags.tsv"
+    # codex 的 session 記錄照樣擺著：claude 情境要驗的正是「明明有這一份，也不去讀」。
+    printf '{"type":"turn_context","payload":{"model":"gpt-5.x"}}\n' \
+      > "$_home/codex/sessions/2026/08/28/rollout-2026-08-28T00-00-00-smoke-deny.jsonl"
+    # claude 的三個環境特徵一併清空：JSC_CLI 是空字串時 cli_name() 會退去看它們，只要有一個
+    # 留著繼承來的值，「判不出 CLI」那一條就會被測成 claude。三個要一起清，漏一個等於沒清。
+    _out=$(printf '{"session_id":"smoke-model-deny"}' \
+      | env JSC_HOME="$_home" CODEX_HOME="$_home/codex" JSC_CLI="$2" \
+        CLAUDE_PLUGIN_ROOT="" CLAUDECODE="" CLAUDE_CODE_SESSION_ID="" \
+        JSC_MODEL="$3" sh "$HOOKS/sdlc-gate.sh" lock plan 2>&1); _rc=$?
+    if [ "$_rc" -eq 1 ] && printf '%s' "$_out" | grep -qF "$4" \
+       && printf '%s' "$_out" | grep -qF 'JSC_MODEL={模型 id}'; then
+      printf '[jsc] sdlc-gate.sh model（%s）：exit 1，擋下且訊息帶得出逃生門，與預期相同。\n' "$1" >> "$smoke_out"
+    else
+      smoke_fails=$((smoke_fails + 1))
+      printf '[jsc] sdlc-gate.sh model（%s）：exit %s，預期 exit 1 且訊息含「%s」與逃生門，能力閘門壞了：%s\n' \
+        "$1" "$_rc" "$4" "$(printf '%s' "$_out" | tr '\n' ' ' | cut -c1-200)" >> "$smoke_out"
+    fi
+    rm -rf "$_home"
+  }
+  smoke_model_deny_case "claude 情境不去讀 codex 紀錄" claude "" "判定不出目前實際使用的模型"
+  smoke_model_deny_case "判不出是哪一支 CLI" "" "" "判不出是哪一支 CLI"
+  smoke_model_deny_case "模型不在能力標籤表上" claude "mystery-model-not-listed" "不在能力標籤表上"
+
+  # check 的 fail-closed：階段鎖在、判不出模型，要 exit 2 擋下該輪提示並帶出逃生門。
+  # 這一條原本是「只提醒不擋」，改成擋下之後逃生門就是唯一的出路，所以訊息一起驗。
+  smoke_n_model=$((smoke_n_model + 1))
+  if ck_home=$(mktemp -d 2>/dev/null) && mkdir -p "$ck_home/sessions" 2>/dev/null; then
+    printf 'stage\tplan\treasoning-max\nmodel\tgpt-5.x\treasoning-max,coding\n' > "$ck_home/model-tags.tsv"
+    printf 'plan\treasoning-max\tgpt-5.x\tsmoke\n' > "$ck_home/sessions/claude-smoke-check.stage"
+    ck_out=$(printf '{"session_id":"smoke-check"}' \
+      | env JSC_HOME="$ck_home" JSC_CLI=claude CLAUDE_PLUGIN_ROOT="" JSC_MODEL="" \
+        JSC_SESSION_ID=smoke-check sh "$HOOKS/sdlc-gate.sh" check 2>&1); ck_rc=$?
+    if [ "$ck_rc" -eq 2 ] && printf '%s' "$ck_out" | grep -qF 'JSC_MODEL={模型 id}' \
+       && printf '%s' "$ck_out" | grep -qF 'unlock'; then
+      printf '[jsc] sdlc-gate.sh check（判不出模型時擋下）：exit 2，兩條逃生門都印出來，與預期相同。\n' >> "$smoke_out"
+    else
+      smoke_fails=$((smoke_fails + 1))
+      printf '[jsc] sdlc-gate.sh check（判不出模型時擋下）：exit %s，預期 exit 2 且訊息含 JSC_MODEL 與 unlock 兩條逃生門，輸出：%s\n' \
+        "$ck_rc" "$(printf '%s' "$ck_out" | tr '\n' ' ' | cut -c1-200)" >> "$smoke_out"
+    fi
+    rm -rf "$ck_home"
+  else
+    smoke_fails=$((smoke_fails + 1))
+    printf '[jsc] sdlc-gate.sh check（判不出模型時擋下）：建不出暫存目錄，沒驗到。\n' >> "$smoke_out"
+  fi
+
+  # 階段鎖狀態檔的 CLI 區隔：兩支 CLI 各上一次鎖，兩份狀態檔要分得開，解鎖也只解自己那一份。
+  # session id 判不出時會退回 default，不分 CLI 就會共用同一支檔案，一支上的鎖擋到另一支。
+  smoke_st_case() { # $1=情境 $2=條件成立就通過（已求值的結果字串 ok 或其他）
+    smoke_n_model=$((smoke_n_model + 1))
+    if [ "$2" = ok ]; then
+      printf '[jsc] sdlc-gate.sh 階段鎖（%s）：與預期相同。\n' "$1" >> "$smoke_out"
+    else
+      smoke_fails=$((smoke_fails + 1))
+      printf '[jsc] sdlc-gate.sh 階段鎖（%s）：不如預期，狀態檔的 CLI 區隔壞了。\n' "$1" >> "$smoke_out"
+    fi
+  }
+  if st_home=$(mktemp -d 2>/dev/null) && mkdir -p "$st_home/sessions" 2>/dev/null; then
+    printf 'stage\tplan\treasoning-max\nstage\timplement\tcoding\nmodel\tgpt-5.x\treasoning-max,coding\n' \
+      > "$st_home/model-tags.tsv"
+    # 兩支各上一次鎖，而且刻意上不同的階段：檔名分開之外，內容也要各記各的。
+    # 不寫成迴圈是為了不動到腳本的位置參數——這一段跑在函式外，set -- 會蓋掉整支腳本的 $@。
+    env JSC_HOME="$st_home" JSC_CLI=claude CLAUDE_PLUGIN_ROOT="" JSC_MODEL=gpt-5.x \
+      JSC_SESSION_ID=smoke-stage sh "$HOOKS/sdlc-gate.sh" lock plan </dev/null >/dev/null 2>&1
+    env JSC_HOME="$st_home" JSC_CLI=codex CLAUDE_PLUGIN_ROOT="" JSC_MODEL=gpt-5.x \
+      JSC_SESSION_ID=smoke-stage sh "$HOOKS/sdlc-gate.sh" lock implement </dev/null >/dev/null 2>&1
+    st_a="$st_home/sessions/claude-smoke-stage.stage"
+    st_b="$st_home/sessions/codex-smoke-stage.stage"
+    st_r=bad; { [ -f "$st_a" ] && [ -f "$st_b" ]; } && st_r=ok
+    smoke_st_case "兩支 CLI 各寫出自己那一份" "$st_r"
+    st_r=bad
+    [ "$(cut -f1 "$st_a" 2>/dev/null)" = plan ] \
+      && [ "$(cut -f1 "$st_b" 2>/dev/null)" = implement ] && st_r=ok
+    smoke_st_case "兩份互不覆蓋，各自記自己的階段" "$st_r"
+    env JSC_HOME="$st_home" JSC_CLI=claude CLAUDE_PLUGIN_ROOT="" \
+      JSC_SESSION_ID=smoke-stage sh "$HOOKS/sdlc-gate.sh" unlock </dev/null >/dev/null 2>&1
+    st_r=bad; { [ ! -f "$st_a" ] && [ -f "$st_b" ]; } && st_r=ok
+    smoke_st_case "解鎖只解自己那一份" "$st_r"
+    # 舊格式 sessions/{sid}.stage 的往後相容：新路徑沒有時要讀得到它，unlock 也要清得掉。
+    rm -f "$st_b"
+    printf 'plan\treasoning-max\tgpt-5.x\tsmoke\n' > "$st_home/sessions/smoke-legacy.stage"
+    st_out=$(env JSC_HOME="$st_home" JSC_CLI=claude CLAUDE_PLUGIN_ROOT="" JSC_MODEL=gpt-5.x \
+      JSC_SESSION_ID=smoke-legacy sh "$HOOKS/sdlc-gate.sh" report </dev/null 2>/dev/null)
+    st_r=bad; printf '%s' "$st_out" | grep -qF 'smoke-legacy plan reasoning-max' && st_r=ok
+    smoke_st_case "舊格式狀態檔仍讀得到" "$st_r"
+    rm -rf "$st_home"
+  else
+    smoke_fails=$((smoke_fails + 4))
+    printf '[jsc] sdlc-gate.sh 階段鎖：建不出暫存目錄，狀態檔的 CLI 區隔沒驗到。\n' >> "$smoke_out"
+    printf '[jsc] sdlc-gate.sh 階段鎖：同上，兩份互不覆蓋沒驗到。\n' >> "$smoke_out"
+    printf '[jsc] sdlc-gate.sh 階段鎖：同上，解鎖範圍沒驗到。\n' >> "$smoke_out"
+    printf '[jsc] sdlc-gate.sh 階段鎖：同上，舊格式相容沒驗到。\n' >> "$smoke_out"
+    smoke_n_model=$((smoke_n_model + 4))
+  fi
 
   # 工作包歸屬判定（wp-check 的第二段）：上面兩支清空技能名，只走得到「沒有未結清 PR」與
   # 「取不到技能名」兩條捷徑，歸屬比對整段都沒跑到。這裡自備一份暫時的 $JSC_HOME 狀態檔，
@@ -1650,6 +1761,8 @@ if [ "$action" = smoke ]; then
     wg_state="$wg_home/sessions/smoke-write.stage"
     wg_last="$wg_home/sessions/smoke-write.lastskill"
     # stage：階段鎖狀態檔的格式沿用 sdlc-gate.sh 那一份，這裡照樣寫三欄。
+    # 檔名刻意用舊格式的 sessions/{sid}.stage，順帶把 write-guard 這一側的往後相容也蓋到：
+    # 新路徑不存在時要退回舊路徑讀得出來，否則既有的鎖會在換路徑那一刻整批失效。
     smoke_wg_case "沒有階段鎖" stage 0
     printf 'plan\treasoning-max\tsmoke\n' > "$wg_state"
     smoke_wg_case "階段鎖 plan" stage 2
@@ -2061,7 +2174,7 @@ if [ "$action" = smoke ]; then
   [ "$smoke_n_hook" = "$SMOKE_EXPECT_HOOK" ] \
     || smoke_mismatch="${smoke_mismatch}hook 模式 $smoke_n_hook 條（預期 $SMOKE_EXPECT_HOOK）；"
   [ "$smoke_n_model" = "$SMOKE_EXPECT_MODEL" ] \
-    || smoke_mismatch="${smoke_mismatch}模型來源 $smoke_n_model 條（預期 $SMOKE_EXPECT_MODEL）；"
+    || smoke_mismatch="${smoke_mismatch}模型與階段鎖 $smoke_n_model 條（預期 $SMOKE_EXPECT_MODEL）；"
   [ "$smoke_n_wp" = "$SMOKE_EXPECT_WP" ] \
     || smoke_mismatch="${smoke_mismatch}工作包 $smoke_n_wp 條（預期 $SMOKE_EXPECT_WP）；"
   [ "$smoke_n_rs" = "$SMOKE_EXPECT_RS" ] \
@@ -2081,7 +2194,7 @@ if [ "$action" = smoke ]; then
   [ "$smoke_lines" = "$smoke_total" ] \
     || smoke_mismatch="${smoke_mismatch}結果行數 $smoke_lines 行（預期 $smoke_total）；"
 
-  smoke_breakdown="hook 模式 $SMOKE_EXPECT_HOOK 條、模型來源 $SMOKE_EXPECT_MODEL 條、工作包 $SMOKE_EXPECT_WP 條、重啟閘門 $SMOKE_EXPECT_RS 條、寫入閘門 $SMOKE_EXPECT_WG 條、相依版本 $SMOKE_EXPECT_VG 條、技能名解析 $SMOKE_EXPECT_SN 條、阻擋形態 $SMOKE_EXPECT_DN 條、跨 CLI 貫通 $SMOKE_EXPECT_CX 條、接線形狀 $SMOKE_EXPECT_SH 條"
+  smoke_breakdown="hook 模式 $SMOKE_EXPECT_HOOK 條、模型與階段鎖 $SMOKE_EXPECT_MODEL 條、工作包 $SMOKE_EXPECT_WP 條、重啟閘門 $SMOKE_EXPECT_RS 條、寫入閘門 $SMOKE_EXPECT_WG 條、相依版本 $SMOKE_EXPECT_VG 條、技能名解析 $SMOKE_EXPECT_SN 條、阻擋形態 $SMOKE_EXPECT_DN 條、跨 CLI 貫通 $SMOKE_EXPECT_CX 條、接線形狀 $SMOKE_EXPECT_SH 條"
   if [ -n "$smoke_mismatch" ]; then
     printf 'status=failed reason=%s\n' "冒煙結果行數與預期不符：${smoke_mismatch}判定路徑有增減時要一併改腳本裡的預期條數"
     printf 'lines\t%s\n' "$smoke_lines"
@@ -2092,7 +2205,7 @@ if [ "$action" = smoke ]; then
   fi
 
   if [ "$smoke_fails" -eq 0 ]; then
-    printf 'status=ok reason=%s\n' "九支 hook 的每個接線模式都跑得完，模型來源、工作包歸屬、部署後重啟閘門、寫入提交閘門、相依版本檢查、五支 CLI 的技能名解析、四種阻擋形態、跨 CLI 貫通與各 CLI 的接線形狀的每條路徑也各走過一次（$smoke_breakdown），沒有執行期錯誤"
+    printf 'status=ok reason=%s\n' "九支 hook 的每個接線模式都跑得完，模型與階段鎖、工作包歸屬、部署後重啟閘門、寫入提交閘門、相依版本檢查、五支 CLI 的技能名解析、四種阻擋形態、跨 CLI 貫通與各 CLI 的接線形狀的每條路徑也各走過一次（$smoke_breakdown），沒有執行期錯誤"
     printf 'lines\t%s\n' "$smoke_lines"
     cat "$smoke_out"; rm -f "$smoke_out"; exit 0
   fi