@kylecheng3146/agent-ops 0.10.2 → 0.11.0

package/docs/zh-TW/spec/acceptance-and-evidence.md

@@ -12,10 +12,11 @@
 
 - `behavioral`：指定 red checks 在 baseline 都因斷言失敗，candidate 的必要 checks 全部通過。`invariant`：candidate 的必要 checks 通過，baseline 原本 PASS 有效。`review-only`：兩輪 fresh review 對照原始目標驗收，不宣稱機械證明。
 - repo 授權的 `verification.acceptanceRunners` 定義 argv、setup、產品與 test build。task 提供穩定 check IDs 與明列且已 commit 的 test／fixture／helper；兩側各自安裝並 build 其版本，再覆蓋 candidate 材料。task 不能改 runner 命令。
-- generic runner 輸出的 check IDs 必須恰好等於共用相同 runner、baseline 與材料之 criteria 所要求的 `checkIds` 聯集；多出的列為 UNKNOWN。若 runner 固定輸出整套 checks，就綁定完整輸出集合，並將 `redCheckIds` 限於實際回歸斷言。
+- generic runner 必須輸出共用相同 runner、baseline 與材料之 criteria 所要求的每個 `checkId`，且各恰好一次；缺少或重複為 UNKNOWN。其他列會被忽略，因此 binding 可以只列 red checks。未要求的列若失敗，runner 的 exit code 仍與 PASS 彙總矛盾，candidate 會成為 UNKNOWN，絕不會 green。
 - fixture、collection、build、timeout、取消、輸出截斷、缺少或重複 ID、retry、skip MUST NOT 算 red 或 green。完整 execution artifacts 以摘要綁定契約、材料與 commits。
 - 原生 Jest JSON 與 Vitest task errors 無法完整區分 test-call 斷言與 hook／fixture cleanup。除非已 review 的 repo collector 提供明確斷言分類，失敗列 MUST 保持 UNKNOWN；AssertionError 名稱、matcher 資料與 pass 的 hook 狀態都不足。green 需要明確的單次 attempt 證據：attempts、Jest invocations，或 Vitest retryCount 與 repeatCount 兩者。原生 Vitest JSON 省略這些 counters，不能單獨提供機械證明。pytest 每個 nodeid 必須有一組依序的 setup／call／teardown；Rust protocol 必須提供 attempts。缺 metadata MUST NOT 預設為一次成功。
-- baseline 固定為建立 commit；finding pin 使用被 FAIL 的 candidate。revise／replan 保留原始目標、全部映射要求與先前契約／證據。新契約必須重新取證並取得兩輪 fresh review。
+- baseline 為建立 commit；finding pin 使用被 FAIL 的 candidate。`task revise --baseline <ref>` 會一次把所有 typed criterion 的 baseline（以及 task 的建立 commit）移到 HEAD 的某個祖先 commit，例如 task 開在錯的分支時，並使其驗證失效。revise／replan 保留原始目標、全部映射要求與先前契約／證據。
+- verification evidence 只綁定 criteria 的 execution hash。只改 surface 或 origin 的 revise 會保留它；改 criteria 或設定則使其失效。0.11 之前的證據綁定完整 contract hash，契約未變時仍相符。每個新契約都需要兩輪 fresh review。
 - `task pin-finding` 驗證已保存 report 的 digest／index 來源。recurrence 明確引用既有 pin。第六條回傳 replan 義務且不修改狀態；映射後必須保留 pin 與全部要求。
 - reviewer packet 包含原始目標、修訂歷史、coverage 與 verifier 材料，審查斷言本身與明確的 fallback 理由。機械 green 不會省略必要 policy commands 或任一 fresh review。
 
@@ -47,7 +48,7 @@ English source version: 2026-10-20. Revalidate: when the English specification c
 
 每個新 task MUST 在寫驗收條件前記錄變更還會影響哪些位置（surface audit）；discovery 找到未分類位置時，review MUST NOT 執行。
 
-- Trigger: 建立 task（`task create`、run plan，或 DEBUG task 第一次修復之前）、修訂 surface，或審查 task。
+- Trigger: 建立 task（`task create`，含 `--debug`，或 run plan）、修訂 surface，或審查 task。
 - Action: 以記錄下來的固定字串查詢或 `n/a: 理由` 搜尋四個軸向，把每個命中分類為 included、excluded（glob + 理由）或 UNKNOWN，每列 surface 都寫出可觀察的 `behavior`，並宣告每個共享契約為 compatible 或 breaking。以 `task create|revise --surface-file <json>` 提交。
 - Evidence: surface 存在 task 上、綁進 contract hash 並保留修訂歷史，review 前以 `git grep -F` 重放，並以 `surface-coverage` 條件交給兩位 reviewer。
 - Positive: `diff token 命中三個複製貼上的同類頁面；review 前 audit 已把它們連同行為列入 included。`
@@ -83,7 +84,8 @@ English source version: 2026-10-20. Revalidate: when the English specification c
   至多 128 筆。Reviewer 會看到每筆排除與其命中數，若它隱藏了先前
   `SURFACE_UNCLASSIFIED` 阻擋所列的檔案則會標示出來。
   結果以 HEAD、base、diff、查詢集合與 config hash 快取。
-- Review 以 NOT_RUN 回報：`SURFACE_MISSING`（沒有或無法解析的 surface；非 DEBUG
+- `verify` 在驗證後執行同一個 gate，並以建議性質的輸出列印結果（`Surface: PASS`，或錯誤碼與未分類路徑），讓 surface 在 review 前修好；只有 review 會強制。
+- Review 以 NOT_RUN 回報：`SURFACE_MISSING`（沒有或無法解析的 surface；
   task 建立時也會拒絕）、`SURFACE_UNCLASSIFIED`、`SURFACE_QUERY_TOO_BROAD`（單一
   記錄查詢超過 200 個檔案）、`SURFACE_EXCLUSION_TOO_BROAD`（單一 glob 超過 10 個
   檔案，或包含 diff 內的檔案）、`SURFACE_DISMISSAL_TOO_BROAD`（超過 128 筆排除）、
@@ -100,17 +102,15 @@ English source version: 2026-10-20. Revalidate: when the English specification c
 
 ## EVIDENCE-ESCAPE-001
 
-每個 DEBUG 修復 MUST 在 review 前宣告 bug 的來源；宣告的逃逸 MUST 以機械方式連結、標記並記錄。
+bug 修復在已知來源時 SHOULD 宣告 bug 的來源；宣告的逃逸 MUST 以機械方式連結、標記並記錄。此宣告屬建議性質（advisory），絕不阻擋 finish。
 
-- Trigger: DEBUG 假設已確認，或一般 task 修復一個通過了先前關卡的 bug。
-- Action: 以 `task debug --debug-action origin --payload-file <json>` 宣告 `origin`：`{"kind": "escape-of", "commit": "<commit>", "label": "<label>"}`（可選 `"receipt"`），或 `{"kind": "pre-existing" | "external", "reason": "..."}`。一般 task 可用 `task create|revise --escape-of <commit> --escape-label <label> [--escape-receipt <id>]` 選擇加入。把 `.agent-ops-escapes/<task-id>.json` 記錄與修復一起 commit。
-- Evidence: `origin` 綁進 task contract hash；本規則上線後建立的 DEBUG task 沒有它時，finish、`task complete` 與 completion gate 以 `ESCAPE_ORIGIN_MISSING` 拒絕；兩位 reviewer 在 `escape-label` 條件下收到連結狀態、標記、事實與 residual risks。
-- Positive: `假設已確認；origin escape-of 864dbbe2 label surface；重放把漏掉的頁面標為 surface-unseen；記錄與修復一起 commit。`
-- Negative: `DEBUG 修復沒有 origin 就 finish，或把 surface-excluded 的漏網改標成 review，理由是 reviewer「應該注意到」。`
+- Trigger: DEBUG task（`task create --debug`）或任何 task 修復一個通過了先前關卡的 bug，且已知其來源。
+- Action: 以 `task create|revise --escape-of <commit> --escape-label <label> [--escape-receipt <id>]` 宣告 `origin`，DEBUG 與一般 task 相同。0.10 `task debug` 記錄的 `pre-existing` 與 `external` origin（附 `reason`）仍可讀取；未宣告的 origin 另行計數。把 `.agent-ops-escapes/<task-id>.json` 記錄與修復一起 commit。
+- Evidence: `origin` 綁進 task contract hash；兩位 reviewer 在 `escape-label` 條件下收到連結狀態、標記、事實與 residual risks。沒有 origin 的 task 仍可 finish；0.10 標記 `originRequired` 的 task 不再被拒絕（`ESCAPE_ORIGIN_MISSING` 已於 0.11.0 移除）。
+- Positive: `回歸在 baseline 為紅、修復後為綠；origin escape-of 864dbbe2 label surface；重放把漏掉的頁面標為 surface-unseen；記錄與修復一起 commit。`
+- Negative: `把 surface-excluded 的漏網改標成 review，理由是 reviewer「應該注意到」。`
 
-- 宣告必須在假設確認之後（否則 `ESCAPE_ORIGIN_EARLY`），並計入 DEBUG 預算。它是一次
-  contract revision：重新 verify、以新證據重新記錄已確認的假設，然後 review。重新宣告會
-  取代記錄。輸出會列出修復所改或刪行的 `git blame` 提示 commit；blame 只是提示，因為遺漏
+- 宣告是一次 contract revision：重新 verify，然後 review。重新宣告會取代記錄。輸出會列出修復所改或刪行的 `git blame` 提示 commit；blame 只是提示，因為遺漏
   型 bug 存在於沒人寫過的行。
 - finish receipt 留在本機 Git common directory。Schema 2 記錄 target..candidate 的每個
   commit 與逐檔 diff fingerprint（去掉 blob id 與 hunk 位置，squash merge 後仍相同）；
@@ -134,13 +134,13 @@ English source version: 2026-10-20. Revalidate: when the English specification c
 
 ## EVIDENCE-ESCAPE-002
 
-surface 逃逸 MUST 在修復 finish 前變成已證明、受追蹤的規則；學到的規則 MUST 只能收緊 surface gate。
+surface 逃逸 SHOULD 變成已證明、受追蹤的規則；學到的規則 MUST 只能收緊 surface gate。此證明屬建議性質，絕不阻擋 finish。
 
 - Trigger: 已宣告的 escape-of origin（EVIDENCE-ESCAPE-001），或以 `task create --escape-of <commit> --escape-label <label> --escape-fix <fix-commit>` 回填的過去逃逸。
-- Action: 標記為 `surface`、`surface-unseen` 或 `surface-excluded` 時，commit 一條規則 `.agent-ops-escapes/rules/<rule-id>.json`，形狀為 `{"id", "escape", "label", "trigger": {"paths", "tokens"}, "expand": {"paths", "queries"}, "noExclude"}`，並重新宣告 origin。`criteria` 或 `verify` 以 `--escape-promote <runnerId:checkId>`（DEBUG payload `"promote"`）指名修復 task 由紅轉綠的 check。其他標記記錄為 lesson。
-- Evidence: finish、`task complete` 與 completion gate 會重跑證明，並以 `ESCAPE_RULE_UNPROVEN`、`ESCAPE_RULE_TOO_BROAD` 或 `SURFACE_BUDGET_EXCEEDED` 拒絕；ledger 記錄保存證明用規則、其內容 hash 與回測的 fires、commits 與比率。
+- Action: 標記為 `surface`、`surface-unseen` 或 `surface-excluded` 時，commit 一條規則 `.agent-ops-escapes/rules/<rule-id>.json`，形狀為 `{"id", "escape", "label", "trigger": {"paths", "tokens"}, "expand": {"paths", "queries"}, "noExclude"}`，並重新宣告 origin。`criteria` 或 `verify` 以 `--escape-promote <runnerId:checkId>`（origin 欄位 `"promote"`）指名修復 task 由紅轉綠的 check。其他標記記錄為 lesson。
+- Evidence: 宣告 origin 時執行證明，失敗時印出 `ESCAPE_RULE_UNPROVEN`、`ESCAPE_RULE_TOO_BROAD` 或 `SURFACE_BUDGET_EXCEEDED`；自 0.11.0 起 finish 不再因此拒絕。ledger 記錄保存證明用規則、其內容 hash 與回測的 fires、commits 與比率。
 - Positive: `逃逸 surface-unseen；規則 image-size-siblings 在被逃逸 commit 上觸發，其查詢在該 commit 命中兩個漏掉的兄弟頁面，且在最近 200 個 commit 中只觸發 2 次。`
-- Negative: `規則從未在被逃逸 commit 上觸發就 finish surface 逃逸，或新增可排除路徑的規則欄位。`
+- Negative: `規則從未在被逃逸 commit 上觸發卻把 surface 逃逸報為已證明，或新增可排除路徑的規則欄位。`
 
 - 規則只含資料且不需要 trust：trigger 與 expand 變成 argv `git grep -F` 查詢與路徑
   glob，絕不經過 shell 或 regex。嚴格 schema 沒有任何能移除查詢、新增排除或放寬關卡的
@@ -203,7 +203,7 @@ surface 逃逸 MUST 在修復 finish 前變成已證明、受追蹤的規則；
 
 既有 task 檔案仍可直接讀取，不需資料格式遷移。缺少 config baseline、使用任意文字證據，或含有未完成但已封存子任務的舊任務，必須重建並完成驗證與審查。重複執行 complete 也會重新驗證證據；舊的 completed 狀態本身不夠。Runtime 呼叫端必須提供 `TaskServiceOptions.completion`；缺少此 repository context 時，complete 會拒絕執行，但仍可讀取任務。
 
-Commit 前，verify、review、complete 使用預設 worktree scope。Commit 後，三個命令都使用相同的 `--base <git-ref>`，為已提交範圍重新產生證據；runtime 呼叫端使用 `TaskServiceOptions.completion.base`。Base 模式要求 worktree 乾淨。沒有 worktree 變更又未指定 base 時，complete 會回傳 `TASK_COMPLETION_SCOPE_REQUIRED`。agy Stop gate 仍檢查 worktree scope 的證據：請在 commit 前完成並停止，或由使用者檢查已完成的 base-scope 任務後，核准一次性的 Stop permit。
+Commit 前，verify、review、complete 使用預設 worktree scope。Commit 後，三個命令都使用相同的 `--base <git-ref>`，為已提交範圍重新產生證據。未指定 `--base` 且 worktree 乾淨時，verify 與 review 自動選擇：session worktree 使用與目標分支的 merge-base（finish rebase 後會跟著移動），其他情況使用 task 的建立 commit（須為 HEAD 的祖先）。Base 模式的 source fingerprint 忽略 escape ledger 的 task 記錄（`.agent-ops-escapes/task-*.json`；rules 仍納入 fingerprint），因此 commit ledger 不會使驗證與 review 失效；0.10 計算的 fingerprint 不同，升級後需重新 verify 一次；runtime 呼叫端使用 `TaskServiceOptions.completion.base`。Base 模式要求 worktree 乾淨。沒有 worktree 變更又未指定 base 時，complete 會回傳 `TASK_COMPLETION_SCOPE_REQUIRED`。agy Stop gate 仍檢查 worktree scope 的證據：請在 commit 前完成並停止，或由使用者檢查已完成的 base-scope 任務後，核准一次性的 Stop permit。
 
 這項機制強制的是 toolkit 的完成命令，無法阻止 host 直接用自然語言宣稱完成，也無法阻止具有相同檔案權限的 process 直接改寫 task／evidence 檔案；它不會鎖住 Git 或其他來源檔案寫入者。
 

package/docs/zh-TW/spec/harness-adapters.md

@@ -101,14 +101,11 @@ Runtime-failure 處理中，只有 `command-policy` 為 fail-closed。當已安
 OpenCode `tool.execute.before` plugin 可在其支援的 Bash surface 上 throw 文件化的
 denial 或 unavailable-runtime error。Codex 維持 `unknown` 且絕不輸出 denial。
 Fixture test 只斷言這些 wire 與 plugin shape；它們不證明 host 會實際遵守 denial。
-`SessionStart` 與一般 `Stop` failure 維持 fail-open。active DEBUG Stop 故障則
-針對 task/config 重新載入一次，再明確回報 UNKNOWN／未完成並保留原狀態，才允許非成功停止。
-
-Codex DEBUG lifecycle 語意於 2026-10-11 依[官方 hook 文件](https://learn.chatgpt.com/docs/hooks#stop)
-重新檢查：Stop 的 `decision: "block"` 加 `reason` 會排程續跑；`continue: false`
-會停止。`stop_hook_active` 表示已經續跑過，不能繞過 DEBUG 檢查。
-原生 `Interrupt` 暫停採三秒 timeout，不得阻擋或重啟人類中斷。
-此 DEBUG 專用政策不會啟用 Codex 的一般 completion gate 或 optional Stop verifier。
+`SessionStart` 與 `Stop` failure 維持 fail-open。
+
+自 0.11.0 起沒有 DEBUG 專用 hook：prompt 不會開 DEBUG task，Stop 不會因 DEBUG 擋住
+session，Codex `Interrupt` 不再註冊（舊安裝殘留的註冊在 `update` 前為 no-op）。Codex
+仍沒有一般 completion gate 或 optional Stop verifier。
 Codex 另以每個原生 hook 的精確定義保存信任。更新受管理 hook 後，必須在 `/hooks`
 審核新增或變更的定義；agent-ops repository trust 不會啟用尚未審核的原生 hook。
 
@@ -169,6 +166,8 @@ unknown）、有界且遮蔽敏感資料的原始診斷、sealed proof（`record
 僅表示紀錄存在，不代表驗證通過）、cleanup 狀態、能否 resume 與具體修復方式。
 相同 cleanup blocker 保留原始 cause。Trust、native identity、generation 與 denial
 仍 fail-closed；sealed proof 不得抹除 native 或組織的明確拒絕。
+`run status` 與 `run logs` 的 JSON `state` 省略 event 歷史與 goal 全文，保留
+`eventCount` 與 `goalHash`，讓重複輪詢維持精簡；event 本身由 `run logs` 回傳。
 
 人工 resume 已寫入 receipt 的 integration，必須先驗證原 sealed proof、receipt
 digest 與 transaction、owner/generation、candidate/target ancestry 及 Git note。

package/docs/zh-TW/spec/loop-engineering.md

@@ -11,7 +11,7 @@
 - Negative: 只因 native goal completion 就把 run 標為 complete。
 
 - macOS supervisor 在啟動 goal 前保存 Claude／Codex native 身份。同 host writers 使用獨立 worktrees 與目前 generation lease；coordinator 計入最多兩個 writer。依賴以固定交付提供，child baseline 在依賴 commits 進入 checkout 後建立。
-- 新 run 不設總時間上限（`budget.limitMs: null`），仍以 active intervals 聯集記錄 setup、verify、review、整合的消耗。舊有限 run 僅在下次人工 resume 升級，保留舊上限、intervals、消耗、usage epochs 與 blocker 歷史；讀取或安裝不會升級或喚醒舊 run。單次命令／review timeout、provider quota、DEBUG 預算、無進度與 pause/stop 控制保持獨立有效。明確指定 --time-budget 會被拒絕。缺少計數維持 UNKNOWN，partial usage 不算完整成本。
+- 新 run 不設總時間上限（`budget.limitMs: null`），仍以 active intervals 聯集記錄 setup、verify、review、整合的消耗。舊有限 run 僅在下次人工 resume 升級，保留舊上限、intervals、消耗、usage epochs 與 blocker 歷史；讀取或安裝不會升級或喚醒舊 run。單次命令／review timeout、provider quota、無進度與 pause/stop 控制保持獨立有效。明確指定 --time-budget 會被拒絕。缺少計數維持 UNKNOWN，partial usage 不算完整成本。
 - 實質疑問暫停並要求明確回答。修復保留目標與失敗紀錄；連續兩次相同失敗且無進展停止該 worker 及其依賴，獨立 task 仍可執行。review findings 在下次 final gate 前必須有回歸 pin 或記錄 review-only fallback。
 - native completion 僅是觀察。完成必須有必要驗證、兩輪 fresh review、完成的 task state、綁定 target 的 receipt。整合在移動 target 前封存 candidate，記錄 task、receipt、note、cleanup 進度；恢復驗證封存證據，不重做成功的 target mutation。不一致的 target 維持 blocked。
 - Stop 先保存禁止續跑，再確認受管 process group 死亡。crash recovery 不得取代仍存活或身份不明的 writer。dirty checkout、版本漂移、restart storm 保留現場。重開機／login 改變必須明確 resume；不修改全域 host policy。
@@ -24,9 +24,14 @@
 - 當次人工 resume 的初始恢復 MAY 忽略啟用前收到、且 native 更新秒數嚴格早於該次 resume 的本執行緒 Codex 額度快照。自動重啟、未知／同秒／未來時間、時鐘倒退，以及啟用開始後收到的所有額度事件仍有效。Native 啟用 MUST 確認 goal 為 active，才能啟動或轉向 turn。人工 resume 可解除衍生的 `RUN_POLICY_DISABLED` task 阻擋，但保留 ID、耗用、歷史及其他產品失敗。
 - 收斂判斷比較實際 per-check 狀態及未解除的 finding pins；source fingerprint、時間或診斷文字本身不能算進展。
 
-`jobs=1` 時，child MUST 等 coordinator 程序確認死亡後才執行。coordinator 保留
-task 與 native session identity，在 child 交付後以新 generation 接續。native
-註冊、恢復與啟動 MUST 都限制最多一個 active agent；僅扣除 task slot 不足以符合。
+不論 `jobs` 為何，coordinator MUST 只在規劃完 child 後送出明確的 `action=wait`
+request 才讓出；supervisor 不會停止仍在規劃的 coordinator。wait 會確認 coordinator
+程序死亡、釋出其 slot 並捨棄其 native thread，使 coordinator 在 child 工作期間
+不再輪詢 `run status`。恢復流程讓等待中的 coordinator 保持停止；所有 child 皆為
+delivered、complete 或 blocked 後，才以新 generation 在全新 native session 中接續，
+instructions 會列出每個 child 的狀態與交付 commit。`jobs=1` 時，child MUST 等該
+程序確認死亡後才執行。native 註冊、恢復與啟動 MUST 都限制最多 `jobs` 個 active
+agent；僅扣除 task slot 不足以符合。
 
 English source version: 2026-07-23. Revalidate: when the English specification changes.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kylecheng3146/agent-ops",
-  "version": "0.10.2",
+  "version": "0.11.0",
   "description": "Evidence-driven development loops for agy, Codex, Claude Code, and opencode",
   "type": "module",
   "license": "SEE LICENSE IN LICENSE",

package/schemas/config.schema.json

@@ -282,27 +282,7 @@
         },
         "debug": {
           "type": "object",
-          "additionalProperties": false,
-          "required": [
-            "enabled",
-            "budgetMs",
-            "maxRounds"
-          ],
-          "properties": {
-            "enabled": {
-              "type": "boolean"
-            },
-            "budgetMs": {
-              "type": "integer",
-              "minimum": 1,
-              "maximum": 86400000
-            },
-            "maxRounds": {
-              "type": "integer",
-              "minimum": 1,
-              "maximum": 100
-            }
-          }
+          "description": "Pre-0.11 DEBUG budget settings; accepted, ignored and dropped by update."
         }
       }
     },

package/dist/packages/cli/src/debug-intake.js

@@ -1,245 +0,0 @@
-import { join } from "node:path";
-import { TaskService } from "../../../runtime/src/task/service.js";
-import { FileTaskStore } from "../../../runtime/src/task/store.js";
-import { calculateConfigHash } from "../../../runtime/src/config/hash.js";
-import { evaluateGuardrail } from "../../../runtime/src/guardrails/evaluate.js";
-import { isDebugIssue } from "../../../runtime/src/task/debug-intake.js";
-import { ensureSessionWorktree, readWorktreeRecord, sessionWorktreeName } from "../../../runtime/src/parallel/service.js";
-import { listWorktrees, resumeWorktree } from "../../../runtime/src/parallel/manage.js";
-import { collectChangeSurface } from "../../../runtime/src/verify/change-surface.js";
-import { calculateSourceFingerprint } from "../../../runtime/src/verify/source-fingerprint.js";
-import { AgentOpsError } from "../../../runtime/src/fs/paths.js";
-import { loadEffectiveConfig } from "./context.js";
-import { gitRunner, worktreeDependencies } from "./parallel-deps.js";
-const foregroundClockSupported = (host) => host !== "opencode";
-function nativeSessionId(input) {
-    const fromInput = [input.session_id, input.sessionId, input.conversationId, input.thread_id, input.threadId]
-        .find((value) => typeof value === "string" && value.length > 0);
-    return fromInput ?? [process.env.AGENT_OPS_SESSION_ID, process.env.CODEX_THREAD_ID]
-        .find((value) => value !== undefined && value.length > 0);
-}
-/** Start only an already attached DEBUG issue; native hooks never create work. */
-export async function startDebugSession(root, sessionId, host) {
-    if (!foregroundClockSupported(host) || sessionId.length === 0)
-        return;
-    const config = (await loadEffectiveConfig(root, "project")).config;
-    const saved = await readWorktreeRecord(join(root, ".worktrees", sessionWorktreeName(sessionId)));
-    const contextRoot = saved?.mainRoot === root && saved.sessionId === sessionId ? saved.path : root;
-    const contextConfig = contextRoot === root ? config : (await loadEffectiveConfig(contextRoot, "project")).config;
-    const tasks = new TaskService(new FileTaskStore(join(contextRoot, ".agent-ops/tasks/state.json"), contextRoot), { completion: { root: contextRoot, gitRunner: gitRunner(contextRoot), loadConfig: async () => contextConfig } });
-    const attached = await tasks.status({ sessionId }).catch(() => null);
-    if (attached?.status === "active" && attached.task.debug !== undefined)
-        await tasks.debugService().foregroundStart(attached.task.id, sessionId);
-}
-export async function routeDebugPrompt(root, input, host = "claude") {
-    if (typeof input !== "object" || input === null || Array.isArray(input))
-        return null;
-    const fields = input;
-    if (typeof fields.prompt !== "string")
-        return null;
-    const continuation = /^(?:繼續|继续|continue)[。.!！]?$/iu.test(fields.prompt.trim());
-    const debugIssue = isDebugIssue(fields.prompt);
-    const config = (await loadEffectiveConfig(root, "project")).config;
-    if (config.features.debug?.enabled !== true)
-        return null;
-    if (evaluateGuardrail({ kind: "content", content: fields.prompt, scope: root }).action === "block")
-        return null;
-    const session = nativeSessionId(fields);
-    if (session === undefined) {
-        if (!debugIssue && !continuation)
-            return null;
-        return "DEBUG intake unsupported: this hook has no reliable native session identity. Use task create --debug --goal with the original issue in the native conversation.";
-    }
-    const saved = await readWorktreeRecord(join(root, ".worktrees", sessionWorktreeName(session)));
-    const contextRoot = saved?.mainRoot === root && saved.sessionId === session ? saved.path : root;
-    const contextConfig = contextRoot === root ? config : (await loadEffectiveConfig(contextRoot, "project")).config;
-    const original = new TaskService(new FileTaskStore(join(contextRoot, ".agent-ops/tasks/state.json"), contextRoot), { completion: { root: contextRoot, gitRunner: gitRunner(contextRoot), loadConfig: async () => contextConfig } });
-    const attached = await original.status({ sessionId: session }).catch(() => null);
-    if (attached?.status === "active" && attached.task.debug !== undefined) {
-        await original.debugService().syncNativeControl(attached.task.id, session);
-        const control = (await original.debugService().root(attached.task.id)).debug.control;
-        if (control?.paused === true)
-            return `DEBUG original issue ${attached.task.id} is paused by the human. Preserve its task, evidence and remaining budget; stop after saving progress. Only a native human continue event resumes it.`;
-        if (continuation) {
-            let message = `DEBUG continue preserved original issue ${attached.task.id}: native user event did not extend time; other limits remain authoritative.`;
-            try {
-                await original.debugService().extend(attached.task.id, session, "latest");
-                message = `DEBUG original issue ${attached.task.id}: native human time grant applied once; other limits remain authoritative.`;
-            }
-            catch (error) {
-                message = `DEBUG continue preserved original issue ${attached.task.id}: ${error instanceof Error ? error.message : "Native user approval unavailable"}`;
-            }
-            if (foregroundClockSupported(host)) {
-                try {
-                    await original.debugService().foregroundStart(attached.task.id, session);
-                }
-                catch (error) {
-                    message += ` Foreground clock unavailable: ${error instanceof Error ? error.message : "host lifecycle is unsupported"}`;
-                }
-            }
-            else
-                message += " Foreground clock unsupported on this host; preserve the issue and use a host with a trustworthy end-of-turn signal.";
-            if (control?.mode === "diagnose")
-                message += " Diagnosis-only scope remains active; continue discriminating evidence without product repairs until a proven diagnosis or runtime blocker. Only a native human resume repair event restores the full loop.";
-            return message;
-        }
-        if (foregroundClockSupported(host)) {
-            try {
-                await original.debugService().foregroundStart(attached.task.id, session);
-            }
-            catch (error) {
-                return `DEBUG original issue ${attached.task.id}: foreground clock unavailable: ${error instanceof Error ? error.message : "host lifecycle is unsupported"}`;
-            }
-        }
-        if (control?.mode === "diagnose")
-            return `DEBUG original issue ${attached.task.id}: diagnosis only. Continue reproduction and hypothesis evidence until a supported diagnosis or a runtime blocker. Do not repair product behavior. A failure to reproduce is not a stop condition; a human resume repair event restores the full loop.`;
-        if (!debugIssue)
-            return null;
-        return `Continue original DEBUG issue ${attached.task.id}; retain its existing budget, evidence and hypotheses.`;
-    }
-    if (!debugIssue && !continuation)
-        return null;
-    if (continuation) {
-        if (attached?.status !== "active" || attached.task.debug === undefined)
-            return null;
-        try {
-            await original.debugService().extend(attached.task.id, session, "latest");
-            return `DEBUG original issue ${attached.task.id}: native human time grant applied once; other limits remain authoritative.`;
-        }
-        catch (error) {
-            return `DEBUG continue preserved original issue ${attached.task.id}: ${error instanceof Error ? error.message : "Native user approval unavailable"}`;
-        }
-    }
-    if (attached?.status === "active")
-        return attached.task.debug === undefined ? null : `Continue original DEBUG issue ${attached.task.id}; retain its existing budget, evidence and hypotheses.`;
-    // Another session's worktree may already hold this issue; reusing it keeps
-    // its consumed budget and rounds instead of starting a fresh task.
-    const holders = await listWorktrees(worktreeDependencies(), root).catch(() => []);
-    for (const { record: held } of holders) {
-        if (held.sessionId === session)
-            continue;
-        const heldConfig = (await loadEffectiveConfig(held.path, "project").catch(() => null))?.config;
-        if (heldConfig === undefined)
-            continue;
-        const issue = await new TaskService(new FileTaskStore(join(held.path, ".agent-ops/tasks/state.json"), held.path), { completion: { root: held.path, gitRunner: gitRunner(held.path), loadConfig: async () => heldConfig } }).activeDebugRoot(fields.prompt).catch(() => null);
-        if (issue === null)
-            continue;
-        try {
-            await resumeWorktree(worktreeDependencies(), { cwd: root, name: held.name, sessionId: session });
-        }
-        catch (error) {
-            return `DEBUG original issue ${issue.task.id} is still active in ${held.path}; a new task would reset its budget. ${error instanceof Error ? error.message : "Resume needs confirmation."} After the user confirms, run agent-ops worktree resume ${held.name} --session ${session}.`;
-        }
-        return `Continue original DEBUG issue ${issue.task.id} in ${held.path}; its budget, rounds and evidence are preserved.`;
-    }
-    await original.assertDebugBaseline();
-    const record = config.worktree?.mode === "auto" && await readWorktreeRecord(root) === null ?
-        await ensureSessionWorktree(worktreeDependencies(), { cwd: root, sessionId: session }) : null;
-    const path = record?.path ?? root;
-    const effective = (await loadEffectiveConfig(path, "project")).config;
-    const tasks = new TaskService(new FileTaskStore(join(path, ".agent-ops/tasks/state.json"), path), { completion: { root: path, gitRunner: gitRunner(path), loadConfig: async () => effective } });
-    const existing = await tasks.status({ sessionId: session }).catch(() => null);
-    if (existing?.status === "active")
-        return existing.task.debug === undefined ? null : `Continue original DEBUG issue ${existing.task.id}.`;
-    const held = await tasks.activeDebugRoot(fields.prompt);
-    if (held !== null) {
-        await tasks.attach(session, held.task.id);
-        let message = `Continue original DEBUG issue ${held.task.id}; its budget, rounds and evidence are preserved.`;
-        if (foregroundClockSupported(host)) {
-            try {
-                await tasks.debugService().foregroundStart(held.task.id, session);
-            }
-            catch (error) {
-                message += ` Foreground clock unavailable: ${error instanceof Error ? error.message : "host lifecycle is unsupported"}`;
-            }
-        }
-        return message;
-    }
-    const ids = effective.verification.commands.filter(c => c.required).map(c => c.id);
-    const baseline = (await gitRunner(path).run(["rev-parse", "--verify", "HEAD"])).stdout.toString().trim();
-    const criteria = ["issue-regression", "related-checks"].map(id => ({ id, description: id === "issue-regression" ? "Reproduce and fix the original reported issue with relevant regression evidence." : "Pass necessary related checks and two fresh independent reviews.", verifierIds: ids,
-        acceptance: { mode: "review-only", baselineCommit: baseline, bindings: [], reviewOnlyReason: "Provisional investigation intake only. Identify and revise to executable original-issue regression before debug success; this criterion cannot prove reproduction." } }));
-    const created = await tasks.create({ title: fields.prompt.split("\n")[0].slice(0, 160), goal: fields.prompt, intent: "Investigate and fix the original issue through authoritative task debug evidence.", debug: { facts: ["User-reported symptom is unverified."], unknowns: ["Baseline reproduction", "Root cause", "Relevant regression and related checks"] }, criteria, sessionId: session, policyConfigHash: calculateConfigHash(effective), requireSurface: true });
-    let clockNote = "";
-    if (foregroundClockSupported(host)) {
-        try {
-            await tasks.debugService().foregroundStart(created.task.id, session);
-        }
-        catch (error) {
-            return `DEBUG issue ${created.task.id} created in ${path}, but its foreground clock is unavailable: ${error instanceof Error ? error.message : "host lifecycle is unsupported"}. Preserve the issue and do not claim timed completion.`;
-        }
-    }
-    else
-        clockNote = " Native foreground timing is unsupported on this host; controlled operations remain evidence-timed and do not claim a complete active-time budget.";
-    return `DEBUG issue ${created.task.id} created in ${path}. Preserve the original goal. Investigate, record falsifiable hypotheses, revise provisional criteria to relevant behavioral regression, add the surface audit (task revise --surface-file) before the first repair, repair, declare the origin (task debug --debug-action origin) once a hypothesis is confirmed, verify, obtain two fresh independent reviews, then finish. A clean HEAD baseline is fixed automatically; do not ask permission for it or offer diagnosis-only as a fallback. Failure to reproduce alone is not a stop condition: continue discriminating checks within the budget. Defaults: 60 active minutes / 5 material repair candidates. No user-authored debug plan is required.${clockNote}`;
-}
-export async function interruptDebugSession(root, sessionId, nativeInput) {
-    const saved = await readWorktreeRecord(join(root, ".worktrees", sessionWorktreeName(sessionId)));
-    const path = saved?.mainRoot === root && saved.sessionId === sessionId ? saved.path : root;
-    const tasks = new TaskService(new FileTaskStore(join(path, ".agent-ops/tasks/state.json"), path), { completion: { root: path, gitRunner: gitRunner(path), loadConfig: async () => (await loadEffectiveConfig(path, "project")).config } });
-    const attached = await tasks.status({ sessionId }).catch(error => {
-        if (error instanceof AgentOpsError && error.code === "TASK_SESSION_UNATTACHED")
-            return null;
-        throw error;
-    });
-    if (attached?.status === "active" && attached.task.debug !== undefined)
-        await tasks.debugService().interrupt(attached.task.id, sessionId, nativeInput);
-}
-/** Close only the task attached to a native host's verified session. */
-export async function closeDebugSession(root, sessionId, host = "claude") {
-    if (!foregroundClockSupported(host))
-        return;
-    if (sessionId.length === 0)
-        return;
-    const saved = await readWorktreeRecord(join(root, ".worktrees", sessionWorktreeName(sessionId)));
-    const contextRoot = saved?.mainRoot === root && saved.sessionId === sessionId ? saved.path : root;
-    const tasks = new TaskService(new FileTaskStore(join(contextRoot, ".agent-ops/tasks/state.json"), contextRoot), { completion: { root: contextRoot, gitRunner: gitRunner(contextRoot), loadConfig: async () => (await loadEffectiveConfig(contextRoot, "project")).config } });
-    const attached = await tasks.status({ sessionId }).catch(() => null);
-    if (attached?.status === "active" && attached.task.debug !== undefined)
-        await tasks.debugService().foregroundStop(attached.task.id, sessionId);
-}
-/**
- * Without the completion gate, an active DEBUG issue still cannot end a turn
- * unless a current runtime stop checkpoint exists. Sessions without one pass.
- */
-export function debugStopGate(root, rootConfig) {
-    return { handle: async (event) => {
-            if (event.event !== "stop" || event.sessionId === undefined || event.sessionId.length === 0 ||
-                event.terminationReason !== "model_stop" || event.fullyIdle !== true)
-                return null;
-            const sessionId = event.sessionId;
-            const evaluate = async (attempt) => {
-                const saved = await readWorktreeRecord(join(root, ".worktrees", sessionWorktreeName(sessionId))).catch(() => null);
-                const contextRoot = saved?.mainRoot === root && saved.sessionId === sessionId ? saved.path : root;
-                const config = contextRoot === root && attempt === 0 ? rootConfig : (await loadEffectiveConfig(contextRoot, "project")).config;
-                const runner = gitRunner(contextRoot);
-                const tasks = new TaskService(new FileTaskStore(join(contextRoot, ".agent-ops/tasks/state.json"), contextRoot), { completion: { root: contextRoot, gitRunner: runner, loadConfig: async () => config } });
-                const attached = await tasks.status({ sessionId }).catch(error => {
-                    if (error instanceof AgentOpsError && error.code === "TASK_SESSION_UNATTACHED")
-                        return null;
-                    throw error;
-                });
-                if (attached?.status !== "active" || attached.task.debug === undefined)
-                    return null;
-                await tasks.debugService().prepareStop(attached.task.id, sessionId);
-                const surface = await collectChangeSurface(runner);
-                const fingerprint = await calculateSourceFingerprint(contextRoot, { mode: "worktree", changedFiles: surface.paths }, runner);
-                return await tasks.debugService().validCheckpoint(attached.task.id, sessionId, fingerprint)
-                    ? { action: "continue", status: "UNKNOWN", code: "COMPLETION_GATE_TASK_DEBUG_STOPPED", remedy: "Original issue remains active with a runtime-bound non-success checkpoint." }
-                    : { action: "block", status: "FAIL", code: "COMPLETION_GATE_TASK_DEBUG_ACTIVE", remedy: "Continue the original DEBUG investigation, repair, verification and review loop. Failure to reproduce and an arbitrary checkpoint do not permit stopping. Preserve the task and budgets; record a current runtime stop checkpoint only for a proven blocker or exhausted limits." };
-            };
-            // Reload the task/config once for a transient gate fault; never rewrite bad evidence.
-            for (let attempt = 0; attempt < 2; attempt++) {
-                try {
-                    return await evaluate(attempt);
-                }
-                catch (error) {
-                    if (attempt === 0)
-                        continue;
-                    const code = error instanceof AgentOpsError ? error.code : "IO_ERROR";
-                    return { action: "continue", status: "UNKNOWN", code: "TASK_DEBUG_GATE_UNAVAILABLE", remedy: `DEBUG remains incomplete: gate ${code} failed after one targeted reload. Preserve the original task, evidence and budgets; run agent-ops doctor and restore readable task/config evidence before resuming. No completion is attested.` };
-                }
-            }
-            return null;
-        } };
-}

package/dist/runtime/src/task/debug-intake.js

@@ -1,15 +0,0 @@
-/** Conservative intake only; the existing native Agent reasons about the issue. */
-export function isDebugIssue(prompt) {
-    if (prompt.length === 0 || prompt.length > 64 * 1024 || prompt.includes("\0"))
-        return false;
-    // Harness-injected turns (subagent hand-backs, task notifications) are not a human report.
-    if (/^\s*<(?:agent-message|task-notification|teammate-message)\b/u.test(prompt))
-        return false;
-    const value = prompt.normalize("NFKC").toLowerCase();
-    if (/\b(?:explain|describe|what is|how does|refactor|feature|implement|design)\b|說明|解释|解釋|重構|新增功能|設計|實作功能/u.test(value))
-        return false;
-    return /\b(?:bug|error|fail(?:s|ed|ure)?|exception|crash|regression|500)\b|錯誤|错误|失敗|失败|異常|异常|問題|问题|回傳\s*500/u.test(value) &&
-        /\b(?:fix|debug|investigate|reproduce|diagnose|resolve|repair)\b|修復|修复|調查|调查|重現|重现|診斷|诊断|查明|找出原因|解決|解决/u.test(value);
-}
-/** One issue or cause in different spacing or case is still the same one. */
-export const sameDebugText = (left, right) => left.normalize("NFKC").trim().replace(/\s+/gu, " ").toLowerCase() === right.normalize("NFKC").trim().replace(/\s+/gu, " ").toLowerCase();

package/dist/runtime/src/task/debug-state.js

@@ -1,135 +0,0 @@
-import { canonicalJson } from "../config/hash.js";
-import { sha256 } from "../fs/hash.js";
-import { AgentOpsError } from "../fs/paths.js";
-export const DEBUG_DEFAULTS = { enabled: true, budgetMs: 60 * 60_000, maxRounds: 5 };
-export const DEBUG_EXTENSION_MS = 20 * 60_000;
-const object = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
-const text = (v) => typeof v === "string" && v.length > 0 && v.length <= 4096 && !v.includes("\0");
-const hash = (v) => typeof v === "string" && /^[a-f0-9]{64}$/u.test(v);
-const integer = (v) => Number.isSafeInteger(v) && v >= 0;
-const strings = (v) => Array.isArray(v) && v.length <= 128 && v.every(text) && new Set(v).size === v.length;
-const exact = (v, names) => object(v) && Object.keys(v).length === names.length && names.every(k => Object.hasOwn(v, k));
-const statuses = ["proposed", "investigating", "confirmed", "rejected", "inconclusive"];
-export const debugCauses = ["budget", "iterations", "strategy-required", "stagnation", "environment", "permission", "user-pause", "diagnosed"];
-export function validDebugSettings(v) {
-    return exact(v, ["enabled", "budgetMs", "maxRounds"]) && typeof v.enabled === "boolean" &&
-        integer(v.budgetMs) && v.budgetMs > 0 && v.budgetMs <= 86_400_000 &&
-        integer(v.maxRounds) && v.maxRounds > 0 && v.maxRounds <= 100;
-}
-export function validDebugIntake(v) {
-    return exact(v, ["rootTaskId", "facts", "unknowns"]) && text(v.rootTaskId) && strings(v.facts) && strings(v.unknowns);
-}
-export function validDebugState(v) {
-    const baseKeys = ["schemaVersion", "rootTaskId", "ownerRoot", "baselineCommit", "budgetMs", "maxRounds", "consumedMs", "regressionChecks", "hypotheses", "receipts", "strategy", "grants", "operation", "checkpoint"];
-    if (!object(v) || Object.keys(v).some(k => !baseKeys.includes(k) && k !== "foreground" && k !== "control") || !baseKeys.every(k => Object.hasOwn(v, k)) ||
-        v.schemaVersion !== 1 || !text(v.rootTaskId) || !text(v.ownerRoot) || typeof v.baselineCommit !== "string" || !/^(?:[a-f0-9]{40}|[a-f0-9]{64})$/u.test(v.baselineCommit) ||
-        !validDebugSettings({ enabled: true, budgetMs: v.budgetMs, maxRounds: v.maxRounds }) || !integer(v.consumedMs) || !strings(v.regressionChecks) ||
-        !Array.isArray(v.hypotheses) || v.hypotheses.length > 32 || !Array.isArray(v.receipts) || v.receipts.length > 256 ||
-        !Array.isArray(v.grants) || v.grants.length > 128)
-        return false;
-    if (Object.hasOwn(v, "control") && (!exact(v.control, ["mode", "paused", "sessionId", "eventId", "sourceDigest", "timestamp"]) ||
-        !["full", "diagnose"].includes(String(v.control.mode)) || typeof v.control.paused !== "boolean" || !text(v.control.sessionId) ||
-        v.control.sessionId.length > 256 || !hash(v.control.eventId) || !hash(v.control.sourceDigest) || !integer(v.control.timestamp)))
-        return false;
-    for (const h of v.hypotheses) {
-        if (!exact(h, ["id", "statement", "method", "expected", "checkId", "expectedStatus", "status", "supporting", "opposing", "actual", "history"]) ||
-            ![h.id, h.statement, h.method, h.expected, h.checkId].every(text) || !["PASS", "FAIL"].includes(String(h.expectedStatus)) || !statuses.includes(String(h.status)) ||
-            !strings(h.supporting) || !strings(h.opposing) || typeof h.actual !== "string" || h.actual.length > 4096 ||
-            !Array.isArray(h.history) || h.history.length > 128 || h.history.some(entry => !exact(entry, ["status", "actual", "references", "reason"]) ||
-            !statuses.includes(String(entry.status)) || typeof entry.actual !== "string" || entry.actual.length > 4096 || !strings(entry.references) || !text(entry.reason)))
-            return false;
-    }
-    if (new Set(v.hypotheses.map(h => h.id)).size !== v.hypotheses.length)
-        return false;
-    for (const r of v.receipts)
-        if (!exact(r, ["id", "taskId", "kind", "contractHash", "configHash", "sourceFingerprint", "productDigest", "durationMs", "finishedAt", "round", "progress", "references", "outcome", "cause"]) ||
-            !text(r.id) || !text(r.taskId) || !["investigate", "verify", "review"].includes(String(r.kind)) ||
-            ![r.contractHash, r.configHash, r.sourceFingerprint, r.productDigest].every(hash) || !integer(r.durationMs) || !integer(r.finishedAt) || typeof r.round !== "boolean" ||
-            !strings(r.progress) || !strings(r.references) || !["PASS", "FAIL", "UNKNOWN"].includes(String(r.outcome)) || ![null, "environment", "permission"].includes(r.cause))
-            return false;
-    if (new Set(v.receipts.map(r => r.id)).size !== v.receipts.length || v.receipts.filter(r => r.round).length > v.maxRounds)
-        return false;
-    for (const g of v.grants)
-        if (!(exact(g, ["eventId", "sessionId", "sourceDigest", "grantedMs"]) || (exact(g, ["eventId", "sessionId", "sourceDigest", "grantedMs", "spentAtGrantMs"]) && integer(g.spentAtGrantMs))) || !text(g.eventId) || !text(g.sessionId) || !hash(g.sourceDigest) || (g.grantedMs !== DEBUG_EXTENSION_MS && g.grantedMs !== null))
-            return false;
-    if (new Set(v.grants.map(g => g.eventId)).size !== v.grants.length)
-        return false;
-    if (v.strategy !== null && (!exact(v.strategy, ["from", "to", "reason", "references", "afterRound"]) ||
-        ![v.strategy.from, v.strategy.to, v.strategy.reason].every(text) || v.strategy.from === v.strategy.to ||
-        !strings(v.strategy.references) || !integer(v.strategy.afterRound) || v.strategy.afterRound < 2))
-        return false;
-    if (v.foreground !== undefined && v.foreground !== null && (!exact(v.foreground, ["sessionId", "startedAt"]) || !text(v.foreground.sessionId) || v.foreground.sessionId.length > 256 || !integer(v.foreground.startedAt)))
-        return false;
-    if (v.operation !== null && (!((exact(v.operation, ["id", "startedAt", "taskId", "contractHash", "configHash", "sourceFingerprint", "productDigest", "kind"])) ||
-        exact(v.operation, ["id", "startedAt", "taskId", "contractHash", "configHash", "sourceFingerprint", "productDigest", "kind", "processId", "processIdentity"])) ||
-        !text(v.operation.id) || !integer(v.operation.startedAt) || !text(v.operation.taskId) ||
-        ![v.operation.contractHash, v.operation.configHash, v.operation.sourceFingerprint, v.operation.productDigest].every(hash) ||
-        !["investigate", "verify", "review"].includes(String(v.operation.kind)) ||
-        (Object.hasOwn(v.operation, "processId") && (!integer(v.operation.processId) || v.operation.processId < 1)) ||
-        (Object.hasOwn(v.operation, "processIdentity") && (!text(v.operation.processIdentity) || v.operation.processIdentity.length > 256))))
-        return false;
-    if (v.checkpoint !== null && (!exact(v.checkpoint, ["taskId", "sessionId", "root", "sourceFingerprint", "contractHash", "configHash", "cause", "receiptId"]) ||
-        ![v.checkpoint.taskId, v.checkpoint.sessionId, v.checkpoint.root, v.checkpoint.receiptId].every(text) ||
-        ![v.checkpoint.sourceFingerprint, v.checkpoint.contractHash, v.checkpoint.configHash].every(hash) || (v.checkpoint.cause !== null && !debugCauses.includes(v.checkpoint.cause))))
-        return false;
-    return true;
-}
-export function createDebugState(rootTaskId, baselineCommit, settings = DEBUG_DEFAULTS, ownerRoot = ".") {
-    return { schemaVersion: 1, rootTaskId, ownerRoot, baselineCommit, budgetMs: settings.budgetMs, maxRounds: settings.maxRounds, consumedMs: 0, regressionChecks: [],
-        hypotheses: [], receipts: [], strategy: null, grants: [], foreground: null, operation: null, checkpoint: null };
-}
-export function debugRounds(state) { return state.receipts.filter(r => r.round).length; }
-export function debugSpentMs(state, now = Date.now()) {
-    const starts = [state.foreground?.startedAt, state.operation?.startedAt].filter((startedAt) => startedAt !== undefined);
-    const active = starts.length === 0 ? 0 : Math.max(0, now - Math.min(...starts));
-    return state.consumedMs + active;
-}
-export function debugRemainingMs(state, now = Date.now()) {
-    if (state.grants.some(g => g.grantedMs === null))
-        return Number.POSITIVE_INFINITY;
-    const limit = state.grants.reduce((n, g) => Math.max(n, g.spentAtGrantMs ?? n) + (g.grantedMs ?? 0), state.budgetMs);
-    return Math.max(0, limit - debugSpentMs(state, now));
-}
-export function debugStopCause(state, now = Date.now()) {
-    if (state.control?.paused === true)
-        return "user-pause";
-    if (debugRemainingMs(state, now) === 0)
-        return "budget";
-    if (debugRounds(state) >= state.maxRounds)
-        return "iterations";
-    const rounds = state.receipts.filter(r => r.round);
-    const since = rounds.slice(state.strategy?.afterRound ?? 0);
-    let stagnant = 0;
-    for (const round of [...since].reverse()) {
-        if (round.progress.length > 0)
-            break;
-        stagnant++;
-    }
-    if (stagnant >= 2)
-        return state.strategy === null ? "strategy-required" : "stagnation";
-    return state.receipts.at(-1)?.cause ?? null;
-}
-/** Only reviewed reasoning/proof belongs in the digest; operations and clocks do not. */
-export function debugProofDigest(state) {
-    return sha256(canonicalJson({ rootTaskId: state.rootTaskId, baselineCommit: state.baselineCommit, regressionChecks: state.regressionChecks, hypotheses: state.hypotheses,
-        strategy: state.strategy, proof: state.receipts.filter(r => r.kind === "verify").map(r => ({ taskId: r.taskId, contractHash: r.contractHash,
-            configHash: r.configHash, sourceFingerprint: r.sourceFingerprint, productDigest: r.productDigest, references: r.references, outcome: r.outcome })) }));
-}
-export function assertDebugState(value) {
-    if (!validDebugState(value))
-        throw new AgentOpsError("TASK_DEBUG_STATE_INVALID", "Debug state must be strict, bounded and root-bound.");
-}
-export async function loadDebugProof(root, rootTaskId) {
-    const { FileTaskStore } = await import("./store.js");
-    const { join } = await import("node:path");
-    const record = (await new FileTaskStore(join(root, ".agent-ops/tasks/state.json"), root).read()).tasks.find(r => r.task.id === rootTaskId);
-    if (record?.debug === undefined || record.task.debug?.rootTaskId !== rootTaskId)
-        throw new AgentOpsError("TASK_DEBUG_ROOT_MISMATCH", "Original issue proof is unavailable; do not reset its limits.");
-    if (record.debug.ownerRoot !== root) {
-        const owned = (await new FileTaskStore(join(record.debug.ownerRoot, ".agent-ops/tasks/state.json"), record.debug.ownerRoot).read()).tasks.find(r => r.task.id === rootTaskId);
-        if (owned?.debug === undefined || owned.debug.ownerRoot !== record.debug.ownerRoot || owned.task.goal !== record.task.goal)
-            throw new AgentOpsError("TASK_DEBUG_ROOT_MISMATCH", "Original owned issue state is unavailable; do not recreate its budget.");
-        return owned.debug;
-    }
-    return record.debug;
-}