pi-anchorloop 2.4.1 → 2.6.0

package/README.md

@@ -25,12 +25,12 @@ shared           grilling · domain-modeling · human-feedback · agent-terse
 
 | File | What it does |
 | --- | --- |
-| `pi/book.ts` | The loop book. The first `todo` create or `kind` call opens a loop; task records need the `todo` tool of [`@juicesharp/rpiv-todo`](https://github.com/juicesharp/rpiv-mono/tree/main/packages/rpiv-todo#readme) (its `tool_result` details `{tasks, nextId}` and `rpiv-todo-state` entries). The agent declares only what the extension cannot observe with `anchorloop_stage`: `kind` (`quick`, `inline`, `reviewed`, `durable`, with an intent and the anchor command; a later call changes the kind only with a `reason`), `verify` (a check not run in bash), `fresh-read`, `friction` (`tried`, `found`, `led_by`), `reflect`, `skip`, `back`, `close`, and the query `read`. Everything else is read from evidence: production edits (a write or edit in any git repo, outside its `scratch/` and `docs/specs/`; a linked child's edits and a successful `git merge`, `cherry-pick`, or `pull` count too), the exit code of the bash call that ran the anchor command (an anchor that passed, failed, and passed again records its own friction entry: the rerun command and the failed run's key line, at most 120 characters and never a stack trace, still waiting for a `reflect`), reviewer `Blocking: P0=<n> P1=<m>` counts, summaries of `docs/specs/*/` artifacts as they are edited, and a returned subagent that Jev judges to have been a fresh-context read of the spec. A phase machine over that evidence gives each kind a fixed sequence (`quick` act → check; `inline` anchor → act → verify; `reviewed` adds review; `durable` adds decide → grill → spec → read → approve → design; every kind ends with reflect → close), and `read` shows `<kind> · phase <current> ✓ → <next> (missing: …) · skipped: …`. The pi footer shows `anchorloop <kind> · <current> ✓ → <next>`, with the friction still to reflect, after every tool call and on `session_start`, and clears when the loop closes. An anchor run or declared verify of a `quick` or `inline` loop also measures the diff's reach: source files (not tests, lockfiles, specs, or prose), the top-level directories they sit in, and a README, changelog, or `*.schema.json` changed beside them. Files already changed when a repo joined the loop count only once their content changes, and a file at a repository root counts as a file, not a directory. At 3 source files, 2 directories, or one such file, the result carries one line asking to re-classify, and verify waits for a `kind` call with `reason` that answers each threshold crossed; a later threshold asks again. A phase that starts before an earlier one is complete warns once in one line and names the `skip` escape; phases regress when evidence changes or on `back`. The book also records each todo with its `anchor`, `ref` (`<path>#<heading>`, resolved to line ranges), and `followup` metadata. One YAML book per open loop lives under `~/.pi/agent/anchorloop/books/` (`ANCHORLOOP_BOOKS_DIR` overrides it; empty project and `agents/` directories are removed), subagent books under `agents/` (a child that closes keeps its book for the main session); `session_start` sweeps books whose session is gone or that have not changed in 7 days. `close` lists every phase as done, skipped, or auto-skipped and never refuses over phases or friction, only while a pending or in-progress todo lacks `metadata.followup` (a ticket id, `memory`, or `drop — <reason>`). |
-| `pi/anchor-gate.ts` | Inside an open loop, shows one warning line when `write` or `edit` starts the `act` phase while an earlier phase of the loop kind is incomplete: no anchor (`anchor` on the `kind` call, a `Reality anchor:` line, or a skip), and in a `durable` loop a missing decision, spec, fresh read, approval, or design, read from the `docs/specs/<folder>/` files (found from the book, the intent, or a todo `ref`). It warns again only when a new phase goes missing; the call still goes through. Outside a loop and in `quick` loops it stays silent. `.md`, `.txt`, and `.html` files, `scratch/`, `docs/specs/`, and temp files outside the project pass silently. Edits made through `bash` are not checked. |
-| `pi/decision-tool.ts` | The `anchorloop_decision` tool appends single-line, spreadsheet-safe rows to a decision trail TSV, or a `start` row when a run picks up another run's trail. |
-| `pi/second-thought.ts` | Inside an open loop, asks Jev (TypeSafe's typed-decision model, through pi's classifier registry) to check the phase machine when a run settles and the loop book gained an entry since the last judgment, and at a `close` declaration. The program computes the next phase from the book; Jev sees the kind, intent, anchor, diff summary (≤1200 chars), `phase` (current, next, missing), verify state, open todos, the task list, and friction (a child's under its name), and judges only whether to `advance`, go `back`, or `ask-user`, plus `done`, the review tier still needed, and quality; phase completion comes from the program's evidence alone. The one-line advisory leads with `next → <phase>`. The run continues once, only when Jev agrees to advance and the next phase is a verify, review, or fix; an advisory identical to the last one is not repeated, and a `full` rating after a clean review that follows the last change shows a note instead of a recheck. A run that called `MonitorCreate`, `LoopCreate`, `goal_wait`, or a `subagent` tool is waiting and is not judged. Without a TypeSafe key it does nothing, and outside a loop it never runs. In a subagent session (`PI_SUBAGENT_ID` from pi-herdr-agents, or `PI_SUBAGENT_CHILD` from pi-subagents) it registers nothing, since the agent that spawned it judges the result. |
-| `pi/validate-tool-use.ts` | After each `write` or `edit`, validates the file in-process (`pi/support/validators.ts`, a port of `hooks/validators/`) and appends suggestions for `SKILL.md`, instruction files (`AGENTS.md`, `CLAUDE.md`, `GEMINI.md`, `rules/`), and `docs/specs/` artifacts. Needs no Python; the Python validators in `hooks/` remain for `validate_all.py` and the parity test. |
-| `pi/ttsr.ts` | A port of oh-my-pi's Time Traveling Stream Rules. A Markdown rule in `~/.pi/agent/rules/` or `<project>/.pi/rules/` whose frontmatter has a `condition` regex is watched during the run. A match in streamed assistant text aborts the response, drops it, and retries with the rule injected; a match in tool arguments (the command for `bash`, the new text for `write` and `edit`) blocks the call with the rule as its reason. Frontmatter fields follow oh-my-pi: `condition`, `scope` (`text`, `thinking`, `tool`, `tool:bash`, `tool:edit(*.ts)`), `globs`, and `interruptMode` (`always`, `prose-only`, `tool-only`, `never`), plus `repeatMode` (`once` or `after-gap`) and `repeatGap`. A rule fires once per session by default. `astCondition`, `question`, and `agents` are not supported; a rule that uses them is skipped and reported. `/ttsr` lists the loaded rules. |
+| `pi/book.ts` | The loop book. The first `todo` create opens an `inline` loop (intent from the first todo's subject, anchor from a `Reality anchor:` line or the todo's `metadata.anchor`), and a `kind` call opens or changes one; task records need the `todo` tool of [`@juicesharp/rpiv-todo`](https://github.com/juicesharp/rpiv-mono/tree/main/packages/rpiv-todo#readme) (its `tool_result` details `{tasks, nextId}` and `rpiv-todo-state` entries). The agent declares only what the extension cannot observe with `anchorloop_stage`: `kind` (to choose `quick`, `reviewed`, or `durable`, with an intent and the anchor command; changing a kind the agent chose takes a `reason`), `verify` (a check not run in bash), `fresh-read`, `friction` (`tried`, `found`, `led_by`), `reflect`, `skip`, `back`, `close`, and the query `read`. Everything else is read from evidence: production edits (a write or edit in any git repo, outside its `scratch/` and `docs/specs/`; a linked child's edits and a successful `git merge`, `cherry-pick`, or `pull` count too), the exit code of the bash call that ran the anchor command (an anchor that passed, failed, and passed again records its own friction entry, already reflected as `resolved`: the rerun command and the failed run's key line, at most 120 characters and never a stack trace; the agent is told nothing), reviewer `Blocking: P0=<n> P1=<m>` counts, summaries of `docs/specs/*/` artifacts as they are edited, and a returned subagent that Jev judges to have been a fresh-context read of the spec. A phase machine over that evidence gives each kind a fixed sequence (`quick` act → check; `inline` anchor → act → verify; `reviewed` adds review; `durable` adds decide → grill → spec → read → approve → design; every kind ends with reflect → close), and `read` shows `<kind> · phase <current> ✓ → <next> (missing: …) · skipped: …`. A widget below the editor shows `⚓ <kind> · <current> ✓ → <next>`, with `· N friction` while friction waits for a `reflect`, after every tool call, on `session_start`, and when a `Reality anchor:` line is stated, and clears when the loop closes. An anchor run or declared verify of a `quick` or `inline` loop also measures the diff's reach: source files (not tests, lockfiles, specs, or prose), the top-level directories they sit in, and a README, changelog, or `*.schema.json` changed beside them. Files already changed when a repo joined the loop count only once their content changes, and a file at a repository root counts as a file, not a directory. At 3 source files, 2 directories, or one such file, the result carries one line asking to re-classify, and verify waits for a `kind` call with `reason` that answers each threshold crossed; a later threshold asks again. A phase that starts before an earlier one is complete warns once in one line; phases regress when evidence changes or on `back`. The book also records each todo with its `anchor`, `ref` (`<path>#<heading>`, resolved to line ranges), and `followup` metadata. One YAML book per open loop lives under `~/.pi/agent/anchorloop/books/` (`ANCHORLOOP_BOOKS_DIR` overrides it; empty project and `agents/` directories are removed), subagent books under `agents/` (a child that closes keeps its book for the main session); `session_start` sweeps books whose session is gone or that have not changed in 7 days. `close` answers `closed (landed). Clear the todo list.`, adding only the phases not shown complete and the unreflected friction, and never refuses over phases or friction, only while a pending or in-progress todo lacks `metadata.followup` (a ticket id, `memory`, or `drop — <reason>`). |
+| `pi/anchor-gate.ts` | Inside an open loop, appends one warning line to the edit's tool result (where the agent reads it) when `write` or `edit` starts the `act` phase while an earlier phase of the loop kind is incomplete: no anchor (`anchor` on the `kind` call, a `Reality anchor:` line, or a skip), and in a `durable` loop a missing decision, spec, fresh read, approval, or design, read from the `docs/specs/<folder>/` files (found from the book, the intent, or a todo `ref`). It warns again only when a new phase goes missing; the call still goes through. Outside a loop and in `quick` loops it stays silent. `.md`, `.txt`, and `.html` files, `scratch/`, `docs/specs/`, and temp files outside the project pass silently. Edits made through `bash` are not checked. |
+| `pi/decision-tool.ts` | The `anchorloop_decision` tool appends single-line, spreadsheet-safe rows to a decision trail TSV for forks, pivots, and blockers (completed units come from `git log`), or a `start` row when a run picks up another run's trail. |
+| `pi/second-thought.ts` | Inside an open loop, asks Jev (TypeSafe's typed-decision model, through pi's classifier registry) to check the phase machine when a run settles and the loop book gained an entry since the last judgment, and at a `close` declaration. The program computes the next phase from the book; Jev sees the kind, intent, anchor, diff summary (≤1200 chars), `phase` (current, next, missing), verify state, the open todos by id and subject, the task list, and friction (a child's under its name), and judges only whether to `advance`, go `back`, or `ask-user`, plus `done`, the review tier still needed, and quality; phase completion comes from the program's evidence alone. The advisory is `next: <phase> (<missing>)` plus Jev's concerns, with no scores. It is sent only when Jev has a concern, todos are open without a followup, or the run continues, and stays silent when Jev agrees with nothing to add (the verdict is still recorded in the session); at close it carries concerns only. Away from close it also names the loop's open todos that have no valid `metadata.followup` (the first three, subjects cut to 60 characters, then `+N more`) and asks the agent to continue each, complete it, or set that followup. The run continues once, when Jev agrees to advance and the next phase is a verify, review, or fix, or when such todos are open and Jev's move is not `ask-user` (then the advisory tells the agent to ask the user instead); an advisory with the same next phase, concerns, and open todo ids as the last one is not repeated, and a `full` rating after a clean review that follows the last change is not a concern. A run that called `MonitorCreate`, `LoopCreate`, `goal_wait`, or a `subagent` tool is waiting and is not judged. Without a TypeSafe key it does nothing, and outside a loop it never runs. In a subagent session (`PI_SUBAGENT_ID` from pi-herdr-agents, or `PI_SUBAGENT_CHILD` from pi-subagents) it registers nothing, since the agent that spawned it judges the result. |
+| `pi/validate-tool-use.ts` | After each `write` or `edit`, validates the file in-process (`pi/support/validators.ts`, a port of `hooks/validators/`) and appends suggestions for `SKILL.md` (at most three red-line advisories per edit), instruction files (`AGENTS.md`, `CLAUDE.md`, `GEMINI.md`, `rules/`), and `docs/specs/` artifacts. Needs no Python; the Python validators in `hooks/` remain for `validate_all.py` and the parity test. |
+| `pi/ttsr.ts` | A port of oh-my-pi's Time Traveling Stream Rules. A Markdown rule in `~/.pi/agent/rules/` or `<project>/.pi/rules/` whose frontmatter has a `condition` regex is watched during the run. A match in streamed assistant text aborts the response, drops it, and retries with the rule injected; a match in tool arguments (the command for `bash`, the new text for `write` and `edit`) blocks the call with the rule as its reason. Frontmatter fields follow oh-my-pi: `condition`, `scope` (`text`, `thinking`, `tool`, `tool:bash`, `tool:edit(*.ts)`), `globs`, and `interruptMode` (`always`, `prose-only`, `tool-only`, `never`), plus `repeatMode` (`once` or `after-gap`) and `repeatGap`. Each injected rule arrives as `<rule name="…">body</rule>`. A rule fires once per session by default. `astCondition`, `question`, and `agents` are not supported; a rule that uses them is skipped and reported. `/ttsr` lists the loaded rules. |
 
 ## Install
 

package/README.zh-TW.md

@@ -25,12 +25,12 @@ anchorloop            核心循環 · 原則 · playbook：autonomous-run、paus
 
 | 檔案 | 作用 |
 | --- | --- |
-| `pi/book.ts` | Loop book。第一次 `todo` create 或 `kind` 呼叫會開啟一個 loop；任務紀錄需要 [`@juicesharp/rpiv-todo`](https://github.com/juicesharp/rpiv-mono/tree/main/packages/rpiv-todo#readme) 的 `todo` 工具（它的 `tool_result` details `{tasks, nextId}` 和 `rpiv-todo-state` 條目）。agent 只用 `anchorloop_stage` 宣告 extension 看不到的事：`kind`（`quick`、`inline`、`reviewed`、`durable`，附 intent 和 anchor 指令；之後要改種類，必須附 `reason`）、`verify`（不是指令的檢查）、`fresh-read`、`friction`（`tried`、`found`、`led_by`）、`reflect`、`skip`、`back`、`close`，以及查詢用的 `read`。其餘都從證據讀出：production 的修改（任何 git repo 內、`scratch/` 與 `docs/specs/` 以外的 write 或 edit；已連結 child 的修改，以及成功的 `git merge`、`cherry-pick`、`pull` 也算）、執行過 anchor 指令的那次 bash 的 exit code（anchor 通過後失敗、又再通過時，extension 會自己記一筆 friction：重跑的指令，加上失敗那次最關鍵的一行輸出，最多 120 字元，不放 stack trace；這筆仍要 `reflect` 分類）、reviewer 的 `Blocking: P0=<n> P1=<m>` 數字、`docs/specs/*/` 產出物每次編輯後的摘要，以及 Jev 判定為「全新 context 讀過 spec」的 subagent 回報。階段機依這些證據給每種 loop 固定的階段順序（`quick` 為 act → check；`inline` 為 anchor → act → verify；`reviewed` 加 review；`durable` 再加 decide → grill → spec → read → approve → design；每一種都以 reflect → close 結尾），`read` 顯示 `<種類> · phase <目前> ✓ → <下一個>（缺：…）· 已跳過：…`。pi 的 footer 會顯示 `anchorloop <種類> · <目前> ✓ → <下一個>`，以及還沒 reflect 的 friction 數；每次工具呼叫後和 `session_start` 時更新，loop 結案後清掉。`quick` 或 `inline` loop 跑 anchor 或宣告 verify 時，也會量 diff 的影響範圍：原始碼檔案（不含測試、lockfile、spec 與文字檔）、它們所在的頂層目錄，以及跟原始碼一起改的 README、changelog 或 `*.schema.json`。repo 加入 loop 時就已經改過的檔案，要等內容再變動才算；repo 根目錄的檔案只算檔案數，不算一個目錄。達到 3 個原始碼檔案、2 個目錄或 1 個這類檔案時，結果會附一行請 agent 重新分類；verify 要等到以 `reason` 呼叫 `kind`、回應每一個跨過的門檻才算完成，之後再跨過新的門檻會再問一次。前一個階段還沒完成就開始下一個階段，會用一行警告一次並指出 `skip` 的出口；證據改變或用 `back` 時階段會退回。book 也記錄每個 todo 的 `anchor`、`ref`（`<path>#<heading>`，解析成行號範圍）和 `followup` metadata。每個開啟中的 loop 有一份 YAML book，放在 `~/.pi/agent/anchorloop/books/`（可用 `ANCHORLOOP_BOOKS_DIR` 覆寫），subagent 的 book 放在 `agents/`（subagent 自己 close 時 book 留給主 session）；`session_start` 會清掉 session 已不存在或 7 天沒有更新的 book。`close` 不會因為階段或 friction 而拒絕，只在還有 pending 或 in-progress 的 todo 沒有 `metadata.followup`（票號、`memory` 或 `drop — <原因>`）時拒絕。 |
-| `pi/anchor-gate.ts` | 只在開啟的 loop 內：`write` 或 `edit` 開始 `act` 階段、而這種 loop 前面的階段還沒完成時，顯示一行警告：沒有 anchor（kind 呼叫的 `anchor`、`Reality anchor:` 這一行，或已跳過），`durable` loop 則還缺決策、spec、全新 context 的閱讀、核准或設計（從 `docs/specs/<資料夾>/` 的檔案判斷，資料夾由 book、intent 或 todo 的 `ref` 找出）。只有新缺了一個階段時才會再警告；呼叫仍會放行。沒有 loop 或是 `quick` loop 時保持安靜。`.md`、`.txt`、`.html` 檔、`scratch/`、`docs/specs/` 和專案外的暫存檔不會觸發。透過 `bash` 做的修改不檢查。 |
-| `pi/decision-tool.ts` | `anchorloop_decision` 工具把一筆決策寫進 TSV 決策軌跡，每筆只佔一行，用試算表開啟也安全；接手別人的軌跡時寫一筆 `start`。 |
-| `pi/second-thought.ts` | 只在開啟的 loop 內：一次執行結束且 book 自上次判斷後多了條目時，以及宣告 `close` 時，透過 pi 的 classifier registry 請 Jev（TypeSafe 的型別化決策模型）複核階段機。下一個階段由程式從 book 算出；Jev 看到種類、intent、anchor、diff 摘要（≤1200 字元）、`phase`（目前、下一個、缺什麼）、verify 狀態、未完成 todo、任務清單和 friction（子 agent 的以它的名字列出），只判斷要 `advance`、退回（`back`）還是 `ask-user`，另外還問 `done`、還需要哪一級 review 與品質；階段是否完成只由程式依證據判定。一行提醒以 `next → <階段>` 開頭。只有 Jev 同意前進、而下一個階段是 verify、review 或 fix 時，才讓 agent 多跑一輪；與上一則相同的提醒不重複，最後一次修改之後已有無 blocking 發現的 review 時，`full` 評等只顯示備註、不要求複查。呼叫過 `MonitorCreate`、`LoopCreate`、`goal_wait` 或 `subagent` 工具的執行在等待中，不被判斷。沒有 TypeSafe key 時什麼都不做，沒有 loop 時不會執行。subagent session（pi-herdr-agents 的 `PI_SUBAGENT_ID`，或 pi-subagents 的 `PI_SUBAGENT_CHILD`）不註冊任何東西，因為由派它的 agent 判斷結果。 |
-| `pi/validate-tool-use.ts` | 每次 `write` 或 `edit` 後在行程內驗證該檔（`pi/support/validators.ts`，移植自 `hooks/validators/`），替 `SKILL.md`、指令檔（`AGENTS.md`、`CLAUDE.md`、`GEMINI.md`、`rules/`）和 `docs/specs/` 產出物附上建議。不需要 Python；`hooks/` 的 Python 驗證器仍供 `validate_all.py` 和對照測試使用。 |
-| `pi/ttsr.ts` | 移植自 oh-my-pi 的 Time Traveling Stream Rules。`~/.pi/agent/rules/` 或 `<專案>/.pi/rules/` 裡 frontmatter 帶有 `condition` regex 的 Markdown 規則，會在執行過程中被監看。assistant 串流文字命中時，中斷回應、丟棄那段輸出，並注入規則後重試；工具參數命中時（`bash` 看指令，`write`／`edit` 看新寫入的文字），直接擋下呼叫，以規則內容作為理由。frontmatter 欄位沿用 oh-my-pi：`condition`、`scope`（`text`、`thinking`、`tool`、`tool:bash`、`tool:edit(*.ts)`）、`globs`、`interruptMode`（`always`、`prose-only`、`tool-only`、`never`），另加 `repeatMode`（`once` 或 `after-gap`）與 `repeatGap`。預設每條規則每個 session 只觸發一次。不支援 `astCondition`、`question`、`agents`，用到的規則會被跳過並回報。`/ttsr` 列出已載入的規則。 |
+| `pi/book.ts` | Loop book。第一次 `todo` create 會以 `inline` 開啟 loop（intent 取第一個 todo 的標題，anchor 取 `Reality anchor:` 這一行或該 todo 的 `metadata.anchor`），`kind` 呼叫也能開啟或更改 loop；任務紀錄需要 [`@juicesharp/rpiv-todo`](https://github.com/juicesharp/rpiv-mono/tree/main/packages/rpiv-todo#readme) 的 `todo` 工具（它的 `tool_result` details `{tasks, nextId}` 和 `rpiv-todo-state` 條目）。agent 只用 `anchorloop_stage` 宣告 extension 看不到的事：`kind`（用來選 `quick`、`reviewed` 或 `durable`，附 intent 和 anchor 指令；改掉 agent 自己選的種類時，必須附 `reason`）、`verify`（不是指令的檢查）、`fresh-read`、`friction`（`tried`、`found`、`led_by`）、`reflect`、`skip`、`back`、`close`，以及查詢用的 `read`。其餘都從證據讀出：production 的修改（任何 git repo 內、`scratch/` 與 `docs/specs/` 以外的 write 或 edit；已連結 child 的修改，以及成功的 `git merge`、`cherry-pick`、`pull` 也算）、執行過 anchor 指令的那次 bash 的 exit code（anchor 通過後失敗、又再通過時，extension 會自己記一筆 friction，並直接 reflect 為 `resolved`：重跑的指令，加上失敗那次最關鍵的一行輸出，最多 120 字元，不放 stack trace；不會通知 agent）、reviewer 的 `Blocking: P0=<n> P1=<m>` 數字、`docs/specs/*/` 產出物每次編輯後的摘要，以及 Jev 判定為「全新 context 讀過 spec」的 subagent 回報。階段機依這些證據給每種 loop 固定的階段順序（`quick` 為 act → check；`inline` 為 anchor → act → verify；`reviewed` 加 review；`durable` 再加 decide → grill → spec → read → approve → design；每一種都以 reflect → close 結尾），`read` 顯示 `<種類> · phase <目前> ✓ → <下一個>（缺：…）· 已跳過：…`。編輯器下方的 widget 會顯示 `⚓ <種類> · <目前> ✓ → <下一個>`，還有 friction 等著 `reflect` 時附 `· N friction`；每次工具呼叫後、`session_start` 時，以及 agent 寫出 `Reality anchor:` 這一行時更新，loop 結案後清掉。`quick` 或 `inline` loop 跑 anchor 或宣告 verify 時，也會量 diff 的影響範圍：原始碼檔案（不含測試、lockfile、spec 與文字檔）、它們所在的頂層目錄，以及跟原始碼一起改的 README、changelog 或 `*.schema.json`。repo 加入 loop 時就已經改過的檔案，要等內容再變動才算；repo 根目錄的檔案只算檔案數，不算一個目錄。達到 3 個原始碼檔案、2 個目錄或 1 個這類檔案時，結果會附一行請 agent 重新分類；verify 要等到以 `reason` 呼叫 `kind`、回應每一個跨過的門檻才算完成，之後再跨過新的門檻會再問一次。前一個階段還沒完成就開始下一個階段，會用一行警告一次；證據改變或用 `back` 時階段會退回。book 也記錄每個 todo 的 `anchor`、`ref`（`<path>#<heading>`，解析成行號範圍）和 `followup` metadata。每個開啟中的 loop 有一份 YAML book，放在 `~/.pi/agent/anchorloop/books/`（可用 `ANCHORLOOP_BOOKS_DIR` 覆寫），subagent 的 book 放在 `agents/`（subagent 自己 close 時 book 留給主 session）；`session_start` 會清掉 session 已不存在或 7 天沒有更新的 book。`close` 回覆 `closed (landed). Clear the todo list.`，只多列沒有完成的階段和還沒 reflect 的 friction；它不會因為階段或 friction 而拒絕，只在還有 pending 或 in-progress 的 todo 沒有 `metadata.followup`（票號、`memory` 或 `drop — <原因>`）時拒絕。 |
+| `pi/anchor-gate.ts` | 只在開啟的 loop 內：`write` 或 `edit` 開始 `act` 階段、而這種 loop 前面的階段還沒完成時，把一行警告附在該次編輯的 tool result 後面（agent 在那裡讀到它）：沒有 anchor（kind 呼叫的 `anchor`、`Reality anchor:` 這一行，或已跳過），`durable` loop 則還缺決策、spec、全新 context 的閱讀、核准或設計（從 `docs/specs/<資料夾>/` 的檔案判斷，資料夾由 book、intent 或 todo 的 `ref` 找出）。只有新缺了一個階段時才會再警告；呼叫仍會放行。沒有 loop 或是 `quick` loop 時保持安靜。`.md`、`.txt`、`.html` 檔、`scratch/`、`docs/specs/` 和專案外的暫存檔不會觸發。透過 `bash` 做的修改不檢查。 |
+| `pi/decision-tool.ts` | `anchorloop_decision` 工具把一筆決策寫進 TSV 決策軌跡（記岔路、轉向與卡點；完成的工作單元看 `git log`），每筆只佔一行，用試算表開啟也安全；接手別人的軌跡時寫一筆 `start`。 |
+| `pi/second-thought.ts` | 只在開啟的 loop 內：一次執行結束且 book 自上次判斷後多了條目時，以及宣告 `close` 時，透過 pi 的 classifier registry 請 Jev（TypeSafe 的型別化決策模型）複核階段機。下一個階段由程式從 book 算出；Jev 看到種類、intent、anchor、diff 摘要（≤1200 字元）、`phase`（目前、下一個、缺什麼）、verify 狀態、未完成 todo（id 與標題）、任務清單和 friction（子 agent 的以它的名字列出），只判斷要 `advance`、退回（`back`）還是 `ask-user`，另外還問 `done`、還需要哪一級 review 與品質；階段是否完成只由程式依證據判定。提醒是 `next: <階段>（<缺什麼>）` 加上 Jev 的疑慮，不附分數；只在 Jev 有疑慮、有 todo 未完成而沒有 followup、或這次會讓 agent 多跑一輪時才送出，Jev 同意且沒有補充時保持安靜（判斷結果仍記在 session 裡）；結案時只附疑慮。離開 close 時，提醒也會點名 loop 中還沒有有效 `metadata.followup` 的未完成 todo（前三個，標題截成 60 字元，其餘以 `+N more` 帶過），請 agent 逐一繼續、完成，或設定該 followup。Jev 同意前進、而下一個階段是 verify、review 或 fix，或有這類 todo 未完成且 Jev 的判斷不是 `ask-user`（此時提醒改請 agent 去問使用者）時，才讓 agent 多跑一輪；下一個階段、疑慮和未完成 todo 的 id 都與上一則相同的提醒不重複；最後一次修改之後已有無 blocking 發現的 review 時，`full` 評等不算疑慮。呼叫過 `MonitorCreate`、`LoopCreate`、`goal_wait` 或 `subagent` 工具的執行在等待中，不被判斷。沒有 TypeSafe key 時什麼都不做，沒有 loop 時不會執行。subagent session（pi-herdr-agents 的 `PI_SUBAGENT_ID`，或 pi-subagents 的 `PI_SUBAGENT_CHILD`）不註冊任何東西，因為由派它的 agent 判斷結果。 |
+| `pi/validate-tool-use.ts` | 每次 `write` 或 `edit` 後在行程內驗證該檔（`pi/support/validators.ts`，移植自 `hooks/validators/`），替 `SKILL.md`（每次編輯最多三則紅線提醒）、指令檔（`AGENTS.md`、`CLAUDE.md`、`GEMINI.md`、`rules/`）和 `docs/specs/` 產出物附上建議。不需要 Python；`hooks/` 的 Python 驗證器仍供 `validate_all.py` 和對照測試使用。 |
+| `pi/ttsr.ts` | 移植自 oh-my-pi 的 Time Traveling Stream Rules。`~/.pi/agent/rules/` 或 `<專案>/.pi/rules/` 裡 frontmatter 帶有 `condition` regex 的 Markdown 規則，會在執行過程中被監看。assistant 串流文字命中時，中斷回應、丟棄那段輸出，並注入規則後重試；工具參數命中時（`bash` 看指令，`write`／`edit` 看新寫入的文字），直接擋下呼叫，以規則內容作為理由。frontmatter 欄位沿用 oh-my-pi：`condition`、`scope`（`text`、`thinking`、`tool`、`tool:bash`、`tool:edit(*.ts)`）、`globs`、`interruptMode`（`always`、`prose-only`、`tool-only`、`never`），另加 `repeatMode`（`once` 或 `after-gap`）與 `repeatGap`。注入的規則以 `<rule name="…">內容</rule>` 送出。預設每條規則每個 session 只觸發一次。不支援 `astCondition`、`question`、`agents`，用到的規則會被跳過並回報。`/ttsr` 列出已載入的規則。 |
 
 ## 安裝
 

package/hooks/validate_tool_use.py

@@ -72,7 +72,7 @@ def main() -> None:
                 rel = target_path
 
             lines = "\n".join(f"  - {w}" for w in warnings)
-            msg = f"⚠ [anchorloop] Validation suggestions for {rel}:\n{lines}"
+            msg = f"validator {rel}:\n{lines}"
             print(json.dumps({"additionalContext": msg}))
         else:
             print(json.dumps({}))

package/hooks/validators/constants.py

@@ -29,6 +29,7 @@ RED_LINE_MARKERS = (
     r"\b(never|must not|do not|don't|forbidden|barred|prohibited|avoid)\b"
     r"|不要|禁止|不得|不准|嚴禁"
 )
+MAX_ADVISORIES = 3
 RED_LINE_MIN_BUDGET = 3
 RED_LINE_DENSITY = 0.10
 # Emphatic capitals are matched case-sensitively and need a reason on the same or next line.

package/hooks/validators/durable_validator.py

@@ -8,7 +8,7 @@ from .utils import find_defensive_phrases
 
 
 def check_decision_md(path: Path) -> list[str]:
-    """Check decision.md for required structure and pre-flight skill/rule readiness."""
+    """Check decision.md for its decision table."""
     warnings: list[str] = []
     text = path.read_text(encoding="utf-8")
 
@@ -16,18 +16,11 @@ def check_decision_md(path: Path) -> list[str]:
     if not re.search(r"\|\s*Question\s*\|\s*Answer\s*\|\s*Basis\s*\|\s*Status\s*\|", text, re.IGNORECASE):
         warnings.append("decision.md should include a Question | Answer | Basis | Status table (Status: grounded, confirmed, or open).")
 
-    # Check for pre-flight readiness (core rules)
-    lower = text.lower()
-    if "rule" not in lower and "readiness" not in lower and "prerequisite" not in lower and "core" not in lower:
-        warnings.append(
-            "confirm core rules readiness before implementation; note readiness in decision.md."
-        )
-
     return warnings
 
 
 def check_spec_md(path: Path) -> list[str]:
-    """Check spec.md for approval status and reality anchor definition."""
+    """Check spec.md for its approval status."""
     warnings: list[str] = []
     text = path.read_text(encoding="utf-8")
 
@@ -35,10 +28,6 @@ def check_spec_md(path: Path) -> list[str]:
     if not re.search(r"Status:\s*(proposed|approved)", text, re.IGNORECASE):
         warnings.append("spec.md must declare 'Status: proposed' or 'Status: approved' at the top.")
 
-    # Reality anchor declaration
-    if "reality anchor" not in text.lower() and "anchor" not in text.lower():
-        warnings.append("spec.md should name the chosen reality anchor and its checkpoint.")
-
     return warnings
 
 
@@ -62,16 +51,14 @@ def check_verification_md(path: Path) -> list[str]:
         ]
         if invalid_results:
             warnings.append(
-                f"invalid verification Result values found: {', '.join(set(invalid_results))}. "
-                "Result must be one of: pass, fail, unknown."
+                f"invalid verification Result values found: {', '.join(set(invalid_results))} (use pass, fail, unknown)"
             )
 
     # 2. Review of newly added rules or skills (tuning vs defensive vocabulary)
     found_defensive = find_defensive_phrases(text, DEFENSIVE_PATTERNS)
     if found_defensive:
         warnings.append(
-            f"detected defensive wording in verification/review: {', '.join(found_defensive)}. "
-            "Reviews of new rules and skills must focus on adjustment and tuning, not adding defensive red lines."
+            f"detected defensive wording in verification/review: {', '.join(found_defensive)}"
         )
 
     return warnings

package/hooks/validators/rule_validator.py

@@ -18,16 +18,14 @@ def check_rules_file(path: Path) -> list[str]:
     found_patterns = find_defensive_phrases(text, DEFENSIVE_PATTERNS)
     if found_patterns:
         warnings.append(
-            f"detected defensive wording: {', '.join(found_patterns)}. "
-            "State desired behavior directly; modern models do not need excessive red lines."
+            f"detected defensive wording: {', '.join(found_patterns)}"
         )
 
     # 2. Rule proliferation / bloat check
     lines = [line.strip() for line in text.splitlines() if line.strip() and not line.strip().startswith("#")]
     if len(lines) > 200:
         warnings.append(
-            f"rule file has {len(lines)} non-empty lines. Consider consolidating into higher-level principles "
-            "or separating into specialized modules rather than accumulating micro-rules."
+            f"rule file has {len(lines)} non-empty lines (over 200)"
         )
 
     # 3. Check for Simplified Chinese common distinctive characters
@@ -36,7 +34,7 @@ def check_rules_file(path: Path) -> list[str]:
     found_sc = [c for c in simplified_chinese_chars if c in text]
     if found_sc:
         warnings.append(
-            f"possible Simplified Chinese detected ({''.join(found_sc[:5])}). Always use Traditional Chinese."
+            f"possible Simplified Chinese detected ({''.join(found_sc[:5])})"
         )
 
     return warnings

package/hooks/validators/skill_validator.py

@@ -6,6 +6,7 @@ from pathlib import Path
 
 from .constants import (
     DEFENSIVE_PATTERNS,
+    MAX_ADVISORIES,
     EMPHATIC_WORDS,
     REASON_WORDS,
     RED_LINE_DENSITY,
@@ -63,8 +64,7 @@ def check_skill_md(path: Path) -> list[str]:
         has_references = (skill_dir / "references").is_dir()
         if not has_references:
             warnings.append(
-                f"skill has {len(lines)} lines (exceeds recommended {SKILL_MAX_RECOMMENDED_LINES}). "
-                "Move detailed guidelines or templates to references/ to keep SKILL.md streamlined."
+                f"skill has {len(lines)} lines (over {SKILL_MAX_RECOMMENDED_LINES}) and no references/"
             )
 
     # 3. Broken markdown links, followed through every Markdown file SKILL.md reaches
@@ -98,8 +98,7 @@ def check_skill_md(path: Path) -> list[str]:
     found_patterns = find_defensive_phrases(text, DEFENSIVE_PATTERNS)
     if found_patterns:
         warnings.append(
-            f"detected defensive anti-pattern(s): {', '.join(found_patterns)}. "
-            "State expected behavior directly rather than constructing defensive red lines."
+            f"detected defensive anti-pattern(s): {', '.join(found_patterns)}"
         )
 
     return warnings
@@ -120,10 +119,7 @@ def check_skill_advisories(path: Path) -> list[str]:
     markers = len(re.findall(RED_LINE_MARKERS, body, re.IGNORECASE))
     budget = max(RED_LINE_MIN_BUDGET, int(sum(1 for line in lines if line.strip()) * RED_LINE_DENSITY))
     if markers > budget:
-        advisories.append(
-            f"{markers} red-line markers exceed the budget of {budget}. Keep a red line only when an "
-            "observed failure backs it, and delete the rest."
-        )
+        advisories.append(f"{markers} red-line markers exceed the budget of {budget}")
 
     # 2. Reasoned: an emphatic word carries its reason on the same or next line.
     # 3. Once: an emphatic word is spent a single time.
@@ -133,12 +129,9 @@ def check_skill_advisories(path: Path) -> list[str]:
             seen[word] += 1
             window = " ".join(lines[number - 1 : number + 1])
             if not re.search(REASON_WORDS, window, re.IGNORECASE):
-                advisories.append(
-                    f"line {number}: emphatic '{word}' has no reason beside it. "
-                    "State the consequence, or drop the emphasis."
-                )
+                advisories.append(f"line {number}: emphatic '{word}' has no reason beside it")
     for word, count in seen.items():
         if count > 1:
-            advisories.append(f"emphatic '{word}' appears {count} times. Spend emphasis once, on the rule that causes real damage.")
+            advisories.append(f"emphatic '{word}' appears {count} times")
 
-    return advisories
+    return advisories[:MAX_ADVISORIES]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-anchorloop",
-  "version": "2.4.1",
+  "version": "2.6.0",
   "description": "Agent workflow skills for pi: one entry skill per task type, each with playbooks, over a shared Align → Anchor → Act → Verify loop, plus loop extensions (loop book, anchor gate, decision trail tool, Jev second thought, skill validator, stream rules).",
   "author": "Wei Hung",
   "license": "MIT",

package/pi/anchor-gate.ts

@@ -2,7 +2,8 @@
  * pi extension: inside an open loop, warns once per jump when write or edit starts the `act` phase while an
  * earlier phase of the loop kind is incomplete: no anchor, or in a durable loop a decision, spec, read,
  * approval, or design still missing. The phase machine in support/phases.ts decides what is missing; the
- * warning names it and the `skip` escape. Outside a loop, or in a `quick` one, it stays silent.
+ * warning is one line appended to the edit's tool result, which is the only place the agent reads it.
+ * Outside a loop, or in a `quick` one, it stays silent.
  */
 
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
@@ -11,6 +12,8 @@ import { JumpMemory, computePhases, exempt, incompleteBefore, jumpLine } from ".
 
 export default function (pi: ExtensionAPI) {
 	const jumps = new JumpMemory();
+	// The warning each write or edit call earned, held until its result arrives.
+	const pending = new Map<string, string>();
 
 	pi.on(
 		"tool_call",
@@ -22,7 +25,17 @@ export default function (pi: ExtensionAPI) {
 			if (!book || exempt(filePath, ctx.cwd) || currentKind(book.entries) === "quick") return;
 			const phases = computePhases(book, { cwd: ctx.cwd, todos: replayTodos(ctx.sessionManager.getBranch()) });
 			const missing = incompleteBefore(phases, "act");
-			if (jumps.fresh(String(book.header.id), "act", missing.map((status) => status.name))) ctx.ui.notify(jumpLine("act", missing), "warning");
+			if (jumps.fresh(String(book.header.id), "act", missing.map((status) => status.name))) pending.set(event.toolCallId, jumpLine("act", missing));
+		}),
+	);
+
+	pi.on(
+		"tool_result",
+		guarded((event) => {
+			const line = pending.get(event.toolCallId);
+			if (line === undefined) return;
+			pending.delete(event.toolCallId);
+			return { content: [...event.content, { type: "text" as const, text: line }] };
 		}),
 	);
 }

package/pi/book.ts

@@ -1,6 +1,7 @@
 /**
- * pi extension: the loop book. The first `todo` create or `kind` declaration opens a loop and its book. The agent declares only
- * what the program cannot observe (`kind` with its intent and anchor command, a non-command `verify`,
+ * pi extension: the loop book. The first `todo` create opens a loop and its book as `inline`, its intent the first todo's subject
+ * and its anchor a stated `Reality anchor:` line or the todo's `metadata.anchor`; a `kind` declaration opens one too. The agent declares only
+ * what the program cannot observe (`kind` to choose `reviewed` or `durable`, a non-command `verify`,
  * `fresh-read`, `friction`, `reflect`, `skip`, `back`, `close`); the extension derives the rest from
  * evidence: production edits, the exit code of the anchor command, reviewer results, durable artifacts,
  * and the fresh-reader subagent. A phase machine over that evidence warns once per jump and never blocks;
@@ -62,9 +63,6 @@ const REVIEWERS = new Set(["reviewer", "adversarial-reviewer"]);
 const BLOCKING = /Blocking\s*:?\**\s*:?\s*P0\s*=\s*(\d+)\D{0,5}P1\s*=\s*(\d+)/gi;
 const ANCHOR_LINE = /Reality anchor:[ \t]*(.*)/;
 
-export const OPEN_LINE =
-	"anchorloop: a loop is open. Declare it with `anchorloop_stage` {stage: kind, kind: quick|inline|reviewed|durable, intent: <one line>, anchor: <check command>}.";
-
 type Params = {
 	stage: (typeof STAGES)[number];
 	kind?: (typeof KINDS)[number];
@@ -330,7 +328,7 @@ function statedAnchor(message: { role?: string; content?: unknown } | undefined)
 	return found ? found[1].trim().slice(0, 300) || "(stated on the next line)" : undefined;
 }
 
-const STATUS_KEY = "anchorloop";
+const WIDGET_KEY = "anchorloop";
 
 const reply = (text: string) => ({ content: [{ type: "text" as const, text }], details: undefined });
 
@@ -402,6 +400,23 @@ export default function (pi: ExtensionAPI) {
 		}
 	}
 
+	/** True while no `kind` call has chosen the kind: the loop still holds the `inline` a todo create opened it with. */
+	function kindIsDefault(entries: Entry[]): boolean {
+		return !entries.some((entry) => entry.stage === "kind" && typeof entry.kind === "string" && entry.auto !== true);
+	}
+
+	/** Opens the loop at the first todo create as `inline`: the first todo's subject is the intent, a stated `Reality anchor:` line or its `metadata.anchor` the anchor. */
+	function openFromTodo(ctx: ExtensionContext, details: unknown): Book {
+		const book = createBook(ctx);
+		touchRepo(book, join(ctx.cwd, "_"));
+		const first = (taskDetails(details) ?? [])[0];
+		book.entries.push(appendEntry(book.path, "kind", { kind: "inline", auto: true, ...(first?.subject ? { intent: clip(first.subject.replace(/\s+/g, " ").trim(), 200) } : {}) }));
+		recordPriorAnchor(book, ctx);
+		const anchor = first?.metadata?.anchor;
+		if (typeof anchor === "string" && anchor.trim() && !anchorCommand(book.entries)) book.entries.push(appendEntry(book.path, "anchor", { check: anchor.trim() }));
+		return book;
+	}
+
 	function close(book: Book, ctx: ExtensionContext, verdict: string): { text: string; snapshot?: Snapshot } {
 		const todos = replayTodos(ctx.sessionManager.getBranch());
 		const undisposed = todos.filter((task) => isOpenTask(task) && !validFollowup(task.metadata?.followup));
@@ -415,7 +430,6 @@ export default function (pi: ExtensionAPI) {
 		const kind = currentKind(book.entries);
 		const phases = phasesOf(book, ctx);
 		const missing = incompleteBefore(phases, "close");
-		const notice = verdict === "landed" && missing.length ? `anchorloop: closed with phases not shown complete: ${missing.map((status) => `${status.name} (${status.note})`).join("; ")}.` : undefined;
 		const diff = diffAgainstBases(book.entries);
 		const friction = allFriction(book.entries);
 		const phaseList = phases.statuses.map((status) => ({ phase: status.name, state: status.state === "skipped" && status.auto ? "auto-skipped" : status.state === "missing" ? "not shown complete" : status.state, ...(status.state === "skipped" ? { note: status.note } : {}) }));
@@ -434,25 +448,16 @@ export default function (pi: ExtensionAPI) {
 			followups: todos.filter((task) => isOpenTask(task)).map((task) => ({ task: task.subject, followup: task.metadata?.followup })),
 		};
 		const unreflected = friction.filter((item) => !item.reflected);
-		const tail = unreflected.length
-			? ` Unreflected friction for the Reflexive Pass: ${unreflected.map((item) => `${item.ref} (${item.found})`).join("; ")}.`
-			: "";
-		const named = (item: (typeof phaseList)[number]) => `${item.phase}${item.note ? ` (${item.note})` : ""}`;
-		const doneNames = phaseList.filter((item) => item.state === "done").map((item) => item.phase);
-		const skippedNames = phaseList.filter((item) => item.state === "skipped" || item.state === "auto-skipped").map(named);
-		const openNames = phaseList.filter((item) => item.state === "not shown complete").map((item) => item.phase);
-		const shown = [
-			`done: ${doneNames.join(", ") || "none"}`,
-			...(skippedNames.length ? [`skipped: ${skippedNames.join(", ")}`] : []),
-			...(openNames.length ? [`${verdict === "landed" ? "not complete" : "not reached"}: ${openNames.join(", ")}`] : []),
-		].join("; ");
-		const back = summary.back.length ? `; back ${summary.back.join(", ")}` : "";
-		const text = `Loop closed (${verdict}): phases ${shown}; ${summary.reviewTrend}; diff ${diff.summary.split("\n").join("; ")}${back}.${tail}`;
-		const after = notice ? `\n${notice}` : "";
+		// The agent has just done the finished phases, so the result names only what is left.
+		const text = [
+			`closed (${verdict}).`,
+			...(missing.length ? [`${verdict === "landed" ? "not complete" : "not reached"}: ${missing.map((status) => (verdict === "landed" ? `${status.name} (${status.note})` : status.name)).join("; ")}.`] : []),
+			...(unreflected.length ? [`unreflected friction: ${unreflected.map((item) => `${item.ref} (${item.found})`).join("; ")}.`] : []),
+		].join(" ");
 		if (kept) {
 			// A child's book stays for the main session to read and delete.
 			appendEntry(book.path, "close", { verdict, summary: text.slice(0, 500) });
-			return { text: `${text} The book stays for the main session.${after}` };
+			return { text: `${text} The book stays for the main session.` };
 		}
 		// Jev judges the loop as it stood at close; the book is gone by the time the result is judged.
 		const snap = kind === "quick" ? undefined : snapshot(book, ctx);
@@ -461,38 +466,33 @@ export default function (pi: ExtensionAPI) {
 			for (const { book: child } of findChildBooks(id)) deleteBook(child.path);
 		}
 		deleteBook(book.path);
-		return { text: `${text} The book is deleted. Clear the todo list now (todo action: clear).${after}`, snapshot: snap };
+		return { text: `${text} Clear the todo list.`, snapshot: snap };
 	}
 
 	pi.registerTool({
 		name: "anchorloop_stage",
 		label: "Loop stage",
 		description:
-			"Declare only what the extension cannot observe in the anchorloop loop book. " +
-			"`kind` (kind, intent, optional anchor command; call again to set the anchor, or with `reason` to change the kind or answer a re-classification): quick (act, check), inline (anchor, act, verify), reviewed (adds review), durable (adds decide, grill, spec, read, approve, design); every kind ends with reflect, close. " +
-			"When an anchor run or declared verify of a quick or inline loop finds the change reaching 3 source files, 2 modules, or a README, changelog, or *.schema.json beside code, its verify waits for a `kind` call with `reason`. " +
-			"`verify` (note; only for an anchor that is not a command), `fresh-read` (a fresh-context read of the spec is done), `friction` (tried, found, led_by), `reflect` (friction ids, class misdirection|gap|resolved, action), " +
-			"`skip` / `back` (phase, reason), `close` (verdict), `read` (view the book). Edits, anchor runs, reviews, and spec files are read from evidence. " +
-			"A loop opens with the first `todo` create; `close` refuses while a pending or in-progress todo lacks metadata.followup.",
+			"Loop book; the first `todo` create opens a loop as inline. stage: kind (kind, intent, anchor; reason to change the kind or answer a reach notice), verify (note; only for a check not run in bash), fresh-read, friction (tried, found, led_by), reflect (friction ids, class, action), skip/back (phase, reason), close (verdict; refuses while an open todo lacks metadata.followup), read. Edits, anchor runs, reviews, and specs are read from evidence.",
 		parameters: {
 			type: "object",
 			properties: {
 				stage: { type: "string", enum: [...STAGES] },
-				kind: { type: "string", enum: [...KINDS], description: "stage kind: the loop kind; a later call with `reason` changes it" },
-				intent: { type: "string", description: "stage kind: one line on what the loop delivers" },
-				anchor: { type: "string", description: "stage kind: the check command whose exit code observes the result" },
-				note: { type: "string", description: "stage verify: what was observed; stage fresh-read: who read the spec" },
-				result: { type: "string", enum: ["pass", "fail"], description: "stage verify; default pass" },
-				tried: { type: "string", description: "stage friction: the attempt that failed" },
-				found: { type: "string", description: "stage friction: what the failure revealed" },
-				led_by: { type: "string", description: "stage friction: the skill or instruction line that prompted the attempt, or `none`" },
-				friction: { type: "array", items: { type: ["string", "number"] }, description: "stage reflect: friction ids (`3`, or `worker#2` for a child's)" },
-				class: { type: "string", enum: ["misdirection", "gap", "resolved"], description: "stage reflect" },
-				action: { type: "string", description: "stage reflect: what was done, such as solid-loop, memory, or a commit" },
-				phase: { type: "string", description: "stage skip or back: the phase" },
-				reason: { type: "string", description: "stage skip or back: why; stage kind: why the kind changes, or why it still fits the measured reach" },
-				verdict: { type: "string", enum: ["landed", "blocked", "abandoned"], description: "stage close" },
-				view: { type: "string", enum: ["summary", "all"], description: "stage read; default summary" },
+				kind: { type: "string", enum: [...KINDS] },
+				intent: { type: "string" },
+				anchor: { type: "string", description: "the check command" },
+				note: { type: "string" },
+				result: { type: "string", enum: ["pass", "fail"] },
+				tried: { type: "string" },
+				found: { type: "string" },
+				led_by: { type: "string", description: "the instruction that misled the attempt, or `none`" },
+				friction: { type: "array", items: { type: ["string", "number"] }, description: "ids: `3`, `worker#2`" },
+				class: { type: "string", enum: ["misdirection", "gap", "resolved"] },
+				action: { type: "string" },
+				phase: { type: "string" },
+				reason: { type: "string" },
+				verdict: { type: "string", enum: ["landed", "blocked", "abandoned"] },
+				view: { type: "string", enum: ["summary", "all"] },
 			},
 			required: ["stage"],
 			additionalProperties: false,
@@ -533,22 +533,17 @@ export default function (pi: ExtensionAPI) {
 		if (stage === "kind") {
 			if (!params.kind && !params.intent && !params.anchor && !params.reason) throw new Error("kind needs `kind`, `intent`, `anchor`, or `reason`");
 			if (!had && (!params.kind || !params.intent)) throw new Error("the first kind declaration needs `kind` and a one-line `intent`");
+			// The kind a todo create defaulted to is not a choice yet, so choosing another needs no reason.
 			const changed = had !== undefined && params.kind !== undefined && had !== params.kind;
-			if (changed && !params.reason) throw new Error(`changing the kind from ${had} to ${params.kind} needs \`reason\`: the reach grew, the user added scope, a user-owned decision appeared, or the change turned out smaller`);
+			if (changed && !params.reason && !kindIsDefault(book.entries)) throw new Error(`changing the kind from ${had} to ${params.kind} needs \`reason\`: the reach grew, the user added scope, a user-owned decision appeared, or the change turned out smaller`);
 			touchRepo(book, join(ctx.cwd, "_"));
-			const notes: string[] = [];
 			if (params.kind || params.intent || params.reason) {
 				// A reason answers the reach measured now, so a later threshold asks again.
 				const answer = params.reason ? { reason: params.reason, crossed: reachOf(book.entries, ctx.cwd).crossed } : {};
 				appendEntry(book.path, "kind", { kind: params.kind ?? had, ...(params.intent ? { intent: params.intent } : {}), ...answer });
-				const why = params.reason ? ` (${params.reason})` : "";
-				notes.push(changed ? `kind changed: ${had} → ${params.kind}${why}` : `kind: ${params.kind ?? had}${why}`);
 			}
-			if (params.anchor) {
-				appendEntry(book.path, "anchor", { check: params.anchor });
-				notes.push(`anchor: ${params.anchor}`);
-			}
-			return reply(notes.join("\n"));
+			if (params.anchor) appendEntry(book.path, "anchor", { check: params.anchor });
+			return reply("ok");
 		}
 		if (stage === "verify") {
 			if (!params.note) throw new Error("verify needs a `note` saying what was observed");
@@ -557,17 +552,17 @@ export default function (pi: ExtensionAPI) {
 			const entry = appendEntry(book.path, recorded, { declared: true, note: params.note, result, exit: result === "pass" ? 0 : 1, ...reachField(book, ctx.cwd) });
 			book.entries.push(entry);
 			const notice = reachNotice(book, entry);
-			return reply(`${recorded} declared: ${result} — ${params.note}${notice ? `\n${notice}` : ""}`);
+			return reply(notice ? `ok\n${notice}` : "ok");
 		}
 		if (stage === "fresh-read") {
 			appendEntry(book.path, "goldfish", { source: "declared", ...(params.note ? { note: params.note } : {}) });
-			return reply("fresh-read recorded.");
+			return reply("ok");
 		}
 		if (stage === "friction") {
 			if (!params.tried || !params.found) throw new Error("friction needs `tried` and `found`");
 			const id = frictionOf(book.entries).length + 1;
 			appendEntry(book.path, "friction", { id, tried: params.tried, found: params.found, led_by: params.led_by || "none" });
-			return reply(`friction #${id} recorded.`);
+			return reply(`friction #${id}`);
 		}
 		if (stage === "reflect") {
 			const known = allFriction(book.entries).map((item) => item.ref);
@@ -576,7 +571,7 @@ export default function (pi: ExtensionAPI) {
 			const unknown = ids.filter((id) => !known.includes(id));
 			if (unknown.length) throw new Error(`unknown friction ${unknown.join(", ")}; known: ${known.join(", ") || "none"}`);
 			appendEntry(book.path, "reflect", { friction: ids, class: params.class, ...(params.action ? { action: params.action } : {}) });
-			return reply(`reflect recorded for ${ids.join(", ")} (${params.class}).`);
+			return reply("ok");
 		}
 		// skip and back
 		const phase = params.phase;
@@ -584,7 +579,7 @@ export default function (pi: ExtensionAPI) {
 		if (!phase || !known.includes(phase)) throw new Error(`${stage} needs \`phase\`, one of ${known.join(", ")} for a ${had ?? "undeclared"} loop`);
 		if (!params.reason) throw new Error(`${stage} needs a \`reason\``);
 		appendEntry(book.path, stage, { phase, reason: params.reason });
-		return reply(stage === "skip" ? `${phase}: skipped (${params.reason}).` : `back to ${phase} (${params.reason}); later phases count as incomplete until their conditions hold again.`);
+		return reply("ok");
 	}
 
 	pi.on(
@@ -648,7 +643,7 @@ export default function (pi: ExtensionAPI) {
 			const code = anchorExit(command, task.anchor, exit);
 			book.entries.push(appendEntry(book.path, "taskrun", { id: task.id, command: task.anchor.slice(0, 200), exit: code, last, ...keyOf(code) }));
 		}
-		notices.push(...autoFriction(book));
+		autoFriction(book);
 		const merged = mergeRun(command);
 		if (exit === 0 && merged && !/Already up[ -]to[ -]date/i.test(last ?? "") && book.entries.at(-1)?.stage !== "edit") {
 			touchRepoBeforeMerge(book, resolve(String(book.header.cwd ?? process.cwd()), merged.dir), merged.verb);
@@ -664,10 +659,10 @@ export default function (pi: ExtensionAPI) {
 	/**
 	 * Records one friction line for each anchor that passed again after it had passed and then failed. A pair is recorded
 	 * once, and not at all when the agent recorded a friction entry itself after the failure. The pairs one command
-	 * completes in one bash call (it is both the loop and a task anchor) share one entry. Returns the lines that tell the agent.
+	 * completes in one bash call (it is both the loop and a task anchor) share one entry. No instruction owns such a slip, so
+	 * the entry is reflected as `resolved` at once and the agent is told nothing.
 	 */
-	function autoFriction(book: Book): string[] {
-		const lines: string[] = [];
+	function autoFriction(book: Book): void {
 		const open = new Map<string, string[]>();
 		for (const pair of retryPairs(book.entries)) {
 			const id = `${pair.key}#${pair.fail}`;
@@ -688,24 +683,23 @@ export default function (pi: ExtensionAPI) {
 			const found = clip(String(failed.key ?? keyLine(String(failed.last ?? ""))) || "failed with no output");
 			const number = frictionOf(book.entries).length + 1;
 			book.entries.push(appendEntry(book.path, "friction", { id: number, tried, found, led_by: "none", auto: true, pairs }));
-			lines.push(`anchorloop: friction #${number} recorded from the ${tried}: ${found}. Classify it with \`reflect\` before close.`);
+			book.entries.push(appendEntry(book.path, "reflect", { friction: [String(number)], class: "resolved", action: "auto-recorded rerun" }));
 		}
-		return lines;
 	}
 
-	/** The footer line: the loop's kind, its last complete phase, the next one, and the friction still to reflect. */
+	/** The line below the editor: the loop's kind, its last complete phase, the next one, and the friction still to reflect; cleared when no loop is open. */
 	function showStatus(ctx: ExtensionContext): void {
-		if (typeof ctx.ui?.setStatus !== "function") return;
+		if (typeof ctx.ui?.setWidget !== "function") return;
 		const book = openLoop(ctx);
 		if (!book) {
-			ctx.ui.setStatus(STATUS_KEY, undefined);
+			ctx.ui.setWidget(WIDGET_KEY, undefined);
 			return;
 		}
 		const phases = phasesOf(book, ctx);
 		const open = allFriction(book.entries).filter((item) => !item.reflected).length;
 		const kind = phases.kind === "undeclared" ? "no kind" : phases.kind;
 		const at = `${phases.current}${phases.current === "start" ? "" : " ✓"} → ${phases.next}`;
-		ctx.ui.setStatus(STATUS_KEY, `anchorloop ${kind} · ${at}${open ? ` · ${open} friction to reflect` : ""}`);
+		ctx.ui.setWidget(WIDGET_KEY, [`⚓ ${kind} · ${at}${open ? ` · ${open} friction` : ""}`], { placement: "belowEditor" });
 	}
 
 	pi.on(
@@ -721,14 +715,10 @@ export default function (pi: ExtensionAPI) {
 			if (event.toolName === "todo") {
 				const input = event.input as { action?: unknown; id?: unknown };
 				let open = openLoop(ctx);
-				const opens = !open && input.action === "create";
-				if (!open && opens) {
-					open = createBook(ctx);
-					recordPriorAnchor(open, ctx);
-				}
+				if (!open && input.action === "create") open = openFromTodo(ctx, event.details);
 				if (!open) return;
 				recordTasks(open, event.details, input, ctx.cwd);
-				return opens ? { content: [...event.content, { type: "text" as const, text: OPEN_LINE }] } : undefined;
+				return;
 			}
 			const book = openLoop(ctx);
 			if (!book) return;
@@ -833,7 +823,10 @@ function headAndTail(text: string): string {
 			const book = openLoop(ctx);
 			if (!book) return;
 			const stated = statedAnchor(message);
-			if (stated && !book.entries.some((entry) => entry.stage === "anchor" && entry.check === stated)) appendEntry(book.path, "anchor", { check: stated, line: true });
+			if (stated && !book.entries.some((entry) => entry.stage === "anchor" && entry.check === stated)) {
+				appendEntry(book.path, "anchor", { check: stated, line: true });
+				showStatus(ctx);
+			}
 			if (message.role !== "custom" || message.customType !== "subagent_result" || subagent) return;
 			const agent = String(message.details?.agent ?? "");
 			if (REVIEWERS.has(agent)) {

package/pi/decision-tool.ts

@@ -55,18 +55,16 @@ export default function (pi: ExtensionAPI) {
 	pi.registerTool({
 		name: "anchorloop_decision",
 		label: "Decision trail",
-		description:
-			"Append one row to a decision trail TSV (scratch/decisions-<task-slug>.tsv): a fork chosen, a unit completed, a pivot, or a blocker. " +
-			"Pass `start` with your run id instead of the row fields when picking up a trail another run wrote.",
+		description: "Append one row to scratch/decisions-<slug>.tsv for a fork, pivot, or blocker (git log holds completed units). `start` = your run id when picking up a trail.",
 		parameters: {
 			type: "object",
 			properties: {
-				log: { type: "string", description: "Trail path, relative to the working directory" },
-				start: { type: "string", description: "Run id; writes a start row and ignores the row fields" },
-				decision: { type: "string", description: "What was chosen or done, one line" },
-				why: { type: "string", description: "The reason in plain words" },
-				evidence: { type: "string", description: "A pointer: commit, file:line, or artifact path" },
-				result: { type: "string", description: "Outcome or predicate state" },
+				log: { type: "string" },
+				start: { type: "string" },
+				decision: { type: "string" },
+				why: { type: "string" },
+				evidence: { type: "string", description: "commit, file:line, or path" },
+				result: { type: "string" },
 			},
 			required: ["log"],
 			additionalProperties: false,

package/pi/second-thought.ts

@@ -4,8 +4,13 @@
  * summary, phase (current, next, missing), verify state, open todos, tasks, and friction, and judges only
  * whether the current phase's completion condition truly holds and whether to advance, go back, or ask
  * the user. It runs when a run settles and the book gained an entry since the last judgment, and at a
- * `close` declaration. The advisory is one line leading with `next → <phase>`; it continues the run once
- * when Jev agrees to advance and the next phase is a verify, review, or fix. A run that arranged a wake
+ * `close` declaration. The advisory is `next: <phase> (<missing>)` plus Jev's concerns, and is sent only when it
+ * changes the agent's next action: Jev has a concern, todos are still open without a followup, or the run
+ * continues. It continues the run once when Jev agrees to advance and the next phase is a verify, review, or
+ * fix, or when todos are still open without a followup (unless Jev says to ask the user). Away from close the
+ * advisory names up to three of those todos and asks the agent to continue, complete, or settle each with
+ * `metadata.followup`. An advisory with the same next phase, concerns, and open todo ids is sent once. At
+ * close only concerns are sent. A run that arranged a wake
  * (a monitor, a loop, a subagent) is waiting, not finished, and is not judged. Outside a loop nothing
  * runs, nor in a `quick` loop, whose only prompt is the close reminder; a subagent session registers
  * nothing, since the agent that spawned it judges its result.
@@ -14,7 +19,7 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { currentKind, guarded, openLoop } from "./support/book.ts";
 import { type Answers, classify } from "./support/jev.ts";
-import { type Snapshot, snapshot } from "./support/snapshot.ts";
+import { type Snapshot, listTodos, snapshot } from "./support/snapshot.ts";
 import { isSubagent } from "./support/subagent.ts";
 
 export { isSubagent, snapshot };
@@ -87,32 +92,52 @@ export function readVerdict(answers: Answers): Verdict | undefined {
 	};
 }
 
-export function assess(verdict: Verdict, snap: Snapshot): { found: string[]; notes: string[] } {
+export function assess(verdict: Verdict, snap: Snapshot): { found: string[] } {
 	const found: string[] = [];
-	const notes: string[] = [];
 	if (verdict.done < THRESHOLDS.doneBelow) found.push("evidence not shown to cover the intent");
-	if (verdict.review === THRESHOLDS.reviewTier) {
-		if (snap.reviewClear) notes.push("review rated full, but a review recorded after the last change found no blocking finding");
-		else found.push("needs full independent review");
-	}
+	// A review recorded after the last change with no blocking finding already covers the full-review rating.
+	if (verdict.review === THRESHOLDS.reviewTier && !snap.reviewClear) found.push("needs full independent review");
 	if (verdict.quality < THRESHOLDS.qualityBelow) found.push("result below the intent");
-	return { found, notes };
+	return { found };
 }
 
-/** True when Jev agrees to advance and the next phase is one the agent can act on now. */
+/** True when Jev agrees to advance and the next phase is one the agent can act on now, or open todos wait and the user is not needed. */
 export function continues(verdict: Verdict, snap: Snapshot): boolean {
+	if (snap.unsettled.length && verdict.move !== "ask-user") return true;
 	return verdict.move === "advance" && ACTIONABLE.has(snap.next);
 }
 
-/** One line: the program's next phase and its gap, Jev's move and scores, and, away from close, the call to act. */
-export function message(verdict: Verdict, snap: Snapshot, found: string[], notes: string[], atClose = false): string {
-	const extra = [...found, ...notes];
-	return (
-		`Second thought (Jev, advisory): next → ${snap.next}${snap.missing ? ` (missing: ${snap.missing})` : ""}; ` +
-		`${verdict.move}; done ${verdict.done.toFixed(2)}, review ${verdict.review}, quality ${verdict.quality.toFixed(2)}/3` +
-		`${extra.length ? `; ${extra.join("; ")}` : ""}.` +
-		(!atClose && continues(verdict, snap) ? ` Do ${snap.next} now, or say why it does not apply.` : "")
-	);
+/** What Jev's move adds to the program's reading when it is not "advance". */
+const MOVE_CONCERN: Record<Move, string | undefined> = { advance: undefined, back: "earlier evidence does not hold", "ask-user": "needs the user's decision" };
+
+/** Jev's concerns: a move against the program's reading, then the assessment findings. */
+export function concerns(verdict: Verdict, found: string[]): string[] {
+	const move = MOVE_CONCERN[verdict.move];
+	return move ? [move, ...found] : found;
+}
+
+/** The open todos the agent must answer, or the call to put them to the user. */
+function todoCall(verdict: Verdict, snap: Snapshot): string {
+	const list = `open: ${listTodos(snap.unsettled)}`;
+	return verdict.move === "ask-user"
+		? `${list} — ask the user about them with ask_user_question before ending the turn`
+		: `${list} — continue each, complete it, or set metadata.followup (a ticket id, \`memory\`, or \`drop — <reason>\`)`;
+}
+
+/** The advisory: the program's next phase and its gap, Jev's concerns, and, away from close, the open todos. Empty at close without concerns. */
+export function message(verdict: Verdict, snap: Snapshot, found: string[], atClose = false): string {
+	const list = concerns(verdict, found);
+	if (atClose) return list.length ? `Jev: ${list.join("; ")}.` : "";
+	return [
+		`next: ${snap.next}${snap.missing ? ` (${snap.missing})` : ""}`,
+		...(list.length ? [`concerns: ${list.join("; ")}`] : []),
+		...(snap.unsettled.length ? [todoCall(verdict, snap)] : []),
+	].join("\n");
+}
+
+/** What makes two advisories the same: the next phase, the concerns, and the open todo ids; the wording of the gap may change. */
+function adviceKey(verdict: Verdict, snap: Snapshot, found: string[]): string {
+	return JSON.stringify([snap.next, concerns(verdict, found), snap.unsettled.map((task) => task.id)]);
 }
 
 export default function (pi: ExtensionAPI) {
@@ -163,9 +188,10 @@ export default function (pi: ExtensionAPI) {
 			if (!snap) return;
 			const judgment = await judge(ctx, snap);
 			if (!judgment?.verdict) return;
-			const { found, notes } = assess(judgment.verdict, snap);
+			const { found } = assess(judgment.verdict, snap);
 			pi.appendEntry(ENTRY_TYPE, { ...judgment.verdict, at: "close", concerns: found });
-			return { content: [...event.content, { type: "text" as const, text: `\n${message(judgment.verdict, snap, found, notes, true)}` }] };
+			const text = message(judgment.verdict, snap, found, true);
+			return text ? { content: [...event.content, { type: "text" as const, text: `\n${text}` }] } : undefined;
 		}),
 	);
 
@@ -186,14 +212,17 @@ export default function (pi: ExtensionAPI) {
 			// A later handler's boundary result replaces the entries an earlier one returned, so carry them along.
 			const earlier = event.entries ?? [];
 			if (!judgment.verdict) return { entries: [...earlier, record({ verdict: "unknown", reason: judgment.reason })] };
-			const { found, notes } = assess(judgment.verdict, snap);
-			const text = message(judgment.verdict, snap, found, notes);
-			if (told.get(id) === text) return;
-			told.set(id, text);
+			const { found } = assess(judgment.verdict, snap);
+			const verdictEntry = record({ ...judgment.verdict, concerns: found });
 			const proceed = !continued && continues(judgment.verdict, snap);
+			// Jev agrees and nothing needs the agent: the verdict is recorded and nothing is said.
+			const speaks = proceed || snap.unsettled.length > 0 || concerns(judgment.verdict, found).length > 0;
+			const key = adviceKey(judgment.verdict, snap, found);
+			if (!speaks || told.get(id) === key) return { entries: [...earlier, verdictEntry] };
+			told.set(id, key);
 			if (proceed) continued = true;
 			return {
-				entries: [...earlier, record({ ...judgment.verdict, concerns: found }), { type: "custom_message" as const, customType: ENTRY_TYPE, content: text, display: true }],
+				entries: [...earlier, verdictEntry, { type: "custom_message" as const, customType: ENTRY_TYPE, content: message(judgment.verdict, snap, found), display: true }],
 				...(proceed ? { continue: true } : {}),
 			};
 		}),

package/pi/support/phases.ts

@@ -171,13 +171,10 @@ export function unansweredReach(entries: Entry[], reach: Reach | undefined): str
 
 /** The one line that asks an unreviewed loop to re-classify; an undeclared loop is asked to declare its kind. */
 export function reachLine(reach: Reach, kind: string | undefined): string {
-	const files = `${reach.source.length} source file${reach.source.length === 1 ? "" : "s"}`;
-	const modules = `${reach.modules.length} module${reach.modules.length === 1 ? "" : "s"} (${reach.modules.slice(0, 4).join(", ")}${reach.modules.length > 4 ? ", …" : ""})`;
-	const told = reach.behavior.length ? ` and changes ${reach.behavior.slice(0, 3).join(", ")}${reach.behavior.length > 3 ? ", …" : ""}` : "";
-	const ask = kind
-		? `call \`kind\` with \`reason\`: upgrade to reviewed, or say why ${kind} still fits`
-		: "declare `kind` with `intent` and `reason`: reviewed when it reaches past its files, or inline and why it still fits";
-	return `the change reaches ${files} across ${modules}${told}; ${ask}`;
+	const modules = reach.modules.length ? ` / ${reach.modules.length} module${reach.modules.length === 1 ? "" : "s"} (${reach.modules.slice(0, 4).join(", ")}${reach.modules.length > 4 ? ", …" : ""})` : "";
+	const told = reach.behavior.length ? ` / ${reach.behavior.slice(0, 3).join(", ")}${reach.behavior.length > 3 ? ", …" : ""}` : "";
+	const ask = kind ? `kind with reason: reviewed, or why ${kind} fits` : "declare kind with intent and reason: reviewed, or why inline fits";
+	return `reach ${reach.source.length} file${reach.source.length === 1 ? "" : "s"}${modules}${told}; ${ask}`;
 }
 
 // --- evidence ------------------------------------------------------------------------------------
@@ -284,7 +281,7 @@ function evaluate(name: string, ctx: Ctx): Status {
 		}
 		case "anchor": {
 			const index = lastWhere(entries, from, (entry) => entry.stage === "anchor");
-			return index >= 0 ? done(name, String(entries[index].check ?? "")) : missing(name, "a `Reality anchor:` line, or `anchor` on the kind call");
+			return index >= 0 ? done(name, String(entries[index].check ?? "")) : missing(name, "a `Reality anchor:` line, `metadata.anchor` on the first todo, or `anchor` on the kind call");
 		}
 		case "act":
 			return lastWhere(entries, from, (entry) => entry.stage === "edit") >= 0 ? done(name) : missing(name, "a change to the code");
@@ -362,11 +359,9 @@ export function incompleteBefore(phases: Phases, entering: string): Status[] {
 	return phases.statuses.filter((status, index) => index < at && status.state === "missing");
 }
 
-/** One line: the phase entered, what is missing before it, and the skip escape. */
+/** One line: the phases still missing before the one entered. */
 export function jumpLine(entering: string, missingBefore: Status[]): string {
-	const list = missingBefore.map((status) => `${status.name} (${status.note})`).join("; ");
-	const skip = missingBefore[0]?.name ?? "<phase>";
-	return `anchorloop: ${entering} comes before ${list}; skip with \`anchorloop_stage skip ${skip} <reason>\`.`;
+	return `anchorloop: before ${entering}, still missing: ${missingBefore.map((status) => `${status.name} (${status.note})`).join("; ")}.`;
 }
 
 /** The phase line `read` and the close summary show. */

package/pi/support/snapshot.ts

@@ -16,6 +16,7 @@ import {
 	stagesDone,
 	TASK_LEGEND,
 	taskLines,
+	validFollowup,
 	verifyAfterLastAct,
 } from "./book.ts";
 import { computePhases } from "./phases.ts";
@@ -29,12 +30,30 @@ export type Snapshot = {
 	current: string;
 	/** A review recorded after the last change with no blocking finding on it. */
 	reviewClear: boolean;
+	/** Open todos that no valid `metadata.followup` settles yet. */
+	unsettled: { id: number; subject: string }[];
 };
 
+const LISTED_TODOS = 3;
+const SUBJECT_LIMIT = 60;
+
+const clipped = (subject: string, limit: number): string => {
+	const flat = subject.replace(/\s+/g, " ").trim();
+	return flat.length <= limit ? flat : `${flat.slice(0, limit - 1)}…`;
+};
+
+/** The first few todos as `#id subject` (subject cut to 60 characters) joined by `; `, then `+N more`. */
+export function listTodos(todos: { id: number; subject: string }[], limit = LISTED_TODOS): string {
+	const lines = todos.slice(0, limit).map((task) => `#${task.id} ${clipped(task.subject, SUBJECT_LIMIT)}`);
+	return [...lines, ...(todos.length > limit ? [`+${todos.length - limit} more`] : [])].join("; ");
+}
+
 export function snapshot(book: Book, ctx: { cwd: string; sessionManager: { getBranch(): unknown[] } }): Snapshot {
 	const { entries } = book;
 	const todos = replayTodos(ctx.sessionManager.getBranch());
-	const open = todos.filter(isOpenTask).length;
+	const openTasks = todos.filter(isOpenTask);
+	const unsettled = openTasks.filter((task) => !validFollowup(task.metadata?.followup));
+	const settled = openTasks.length - unsettled.length;
 	const phases = computePhases(book, { cwd: ctx.cwd, todos });
 	const check = verifyAfterLastAct(entries);
 	const verify = [
@@ -56,7 +75,7 @@ export function snapshot(book: Book, ctx: { cwd: string; sessionManager: { getBr
 			diff: diffText(diffAgainstBases(entries)),
 			phase: `current: ${phases.current}; next: ${phases.next}${phases.missing ? `; missing: ${phases.missing}` : ""}${phases.skipped.length ? `; skipped: ${phases.skipped.join(", ")}` : ""}`.slice(0, 600),
 			verify: verify.slice(0, 1200),
-			todos: `${open} open of ${todos.length}`,
+			todos: `${openTasks.length} open of ${todos.length}${unsettled.length ? `: ${listTodos(unsettled, 5)}` : ""}${settled ? ` (${settled} with a followup)` : ""}`.slice(0, 700),
 			tasks: [`legend: ${TASK_LEGEND}`, ...taskLines(entries, todos, ctx.cwd)].join("\n").slice(0, 1500),
 			friction: (friction.join("\n") || "none").slice(0, 800),
 		},
@@ -64,5 +83,6 @@ export function snapshot(book: Book, ctx: { cwd: string; sessionManager: { getBr
 		missing: phases.missing,
 		current: phases.current,
 		reviewClear: reviewClearAfterLastAct(entries),
+		unsettled: unsettled.map((task) => ({ id: task.id, subject: task.subject })),
 	};
 }

package/pi/support/validators.ts

@@ -37,6 +37,7 @@ const RED_LINE_MARKERS = new RegExp(
 	`${wordAround("never|must not|do not|don't|forbidden|barred|prohibited|avoid")}|不要|禁止|不得|不准|嚴禁`,
 	"giu",
 );
+const MAX_ADVISORIES = 3;
 const RED_LINE_MIN_BUDGET = 3;
 const RED_LINE_DENSITY = 0.1;
 const EMPHATIC_WORDS = new RegExp(wordAround("(NEVER|ALWAYS|MUST NOT|MUST|FORBIDDEN|DO NOT)"), "gu");
@@ -151,27 +152,19 @@ function checkRulesFile(path: string): string[] {
 
 	const found = findDefensivePhrases(text, DEFENSIVE_PATTERNS);
 	if (found.length) {
-		warnings.push(
-			`detected defensive wording: ${found.join(", ")}. ` +
-				"State desired behavior directly; modern models do not need excessive red lines.",
-		);
+		warnings.push(`detected defensive wording: ${found.join(", ")}`);
 	}
 
 	const lines = splitlines(text)
 		.map((line) => line.trim())
 		.filter((line) => line && !line.startsWith("#"));
 	if (lines.length > 200) {
-		warnings.push(
-			`rule file has ${lines.length} non-empty lines. Consider consolidating into higher-level principles ` +
-				"or separating into specialized modules rather than accumulating micro-rules.",
-		);
+		warnings.push(`rule file has ${lines.length} non-empty lines (over 200)`);
 	}
 
 	const simplified = [...SIMPLIFIED_CHINESE_CHARS].filter((char) => text.includes(char));
 	if (simplified.length) {
-		warnings.push(
-			`possible Simplified Chinese detected (${simplified.slice(0, 5).join("")}). Always use Traditional Chinese.`,
-		);
+		warnings.push(`possible Simplified Chinese detected (${simplified.slice(0, 5).join("")})`);
 	}
 	return warnings;
 }
@@ -216,10 +209,7 @@ function checkSkillMd(path: string): string[] {
 	}
 
 	if (lines.length > SKILL_MAX_RECOMMENDED_LINES && !isDirectory(join(skillDir, "references"))) {
-		warnings.push(
-			`skill has ${lines.length} lines (exceeds recommended ${SKILL_MAX_RECOMMENDED_LINES}). ` +
-				"Move detailed guidelines or templates to references/ to keep SKILL.md streamlined.",
-		);
+		warnings.push(`skill has ${lines.length} lines (over ${SKILL_MAX_RECOMMENDED_LINES}) and no references/`);
 	}
 
 	// Broken markdown links, followed through every Markdown file SKILL.md reaches.
@@ -262,10 +252,7 @@ function checkSkillMd(path: string): string[] {
 
 	const defensive = findDefensivePhrases(text, DEFENSIVE_PATTERNS);
 	if (defensive.length) {
-		warnings.push(
-			`detected defensive anti-pattern(s): ${defensive.join(", ")}. ` +
-				"State expected behavior directly rather than constructing defensive red lines.",
-		);
+		warnings.push(`detected defensive anti-pattern(s): ${defensive.join(", ")}`);
 	}
 	return warnings;
 }
@@ -286,10 +273,7 @@ function checkSkillAdvisories(path: string): string[] {
 	const markers = (body.match(RED_LINE_MARKERS) ?? []).length;
 	const budget = Math.max(RED_LINE_MIN_BUDGET, Math.floor(lines.filter((line) => line.trim()).length * RED_LINE_DENSITY));
 	if (markers > budget) {
-		advisories.push(
-			`${markers} red-line markers exceed the budget of ${budget}. Keep a red line only when an ` +
-				"observed failure backs it, and delete the rest.",
-		);
+		advisories.push(`${markers} red-line markers exceed the budget of ${budget}`);
 	}
 
 	const seen = new Map<string, number>();
@@ -299,19 +283,16 @@ function checkSkillAdvisories(path: string): string[] {
 			seen.set(word, (seen.get(word) ?? 0) + 1);
 			const window = lines.slice(index, index + 2).join(" ");
 			if (!REASON_WORDS.test(window)) {
-				advisories.push(
-					`line ${index + 1}: emphatic '${word}' has no reason beside it. ` +
-						"State the consequence, or drop the emphasis.",
-				);
+				advisories.push(`line ${index + 1}: emphatic '${word}' has no reason beside it`);
 			}
 		}
 	});
 	for (const [word, count] of seen) {
 		if (count > 1) {
-			advisories.push(`emphatic '${word}' appears ${count} times. Spend emphasis once, on the rule that causes real damage.`);
+			advisories.push(`emphatic '${word}' appears ${count} times`);
 		}
 	}
-	return advisories;
+	return advisories.slice(0, MAX_ADVISORIES);
 }
 
 // ---- durable specs (durable_validator.py) ----
@@ -322,10 +303,6 @@ function checkDecisionMd(path: string): string[] {
 	if (!/\|\s*Question\s*\|\s*Answer\s*\|\s*Basis\s*\|\s*Status\s*\|/i.test(text)) {
 		warnings.push("decision.md should include a Question | Answer | Basis | Status table (Status: grounded, confirmed, or open).");
 	}
-	const lower = text.toLowerCase();
-	if (!lower.includes("rule") && !lower.includes("readiness") && !lower.includes("prerequisite") && !lower.includes("core")) {
-		warnings.push("confirm core rules readiness before implementation; note readiness in decision.md.");
-	}
 	return warnings;
 }
 
@@ -335,9 +312,6 @@ function checkSpecMd(path: string): string[] {
 	if (!/Status:\s*(proposed|approved)/i.test(text)) {
 		warnings.push("spec.md must declare 'Status: proposed' or 'Status: approved' at the top.");
 	}
-	if (!text.toLowerCase().includes("reality anchor") && !text.toLowerCase().includes("anchor")) {
-		warnings.push("spec.md should name the chosen reality anchor and its checkpoint.");
-	}
 	return warnings;
 }
 
@@ -351,18 +325,13 @@ function checkVerificationMd(path: string): string[] {
 		const results = [...text.matchAll(/\|\s*[^|]+\s*\|\s*[^|]+\s*\|\s*([a-zA-Z]+)\s*\|/g)].map((match) => match[1].toLowerCase());
 		const invalid = [...new Set(results.filter((result) => !VALID_VERIFICATION_RESULTS.has(result) && result !== "result"))];
 		if (invalid.length) {
-			warnings.push(
-				`invalid verification Result values found: ${invalid.join(", ")}. Result must be one of: pass, fail, unknown.`,
-			);
+			warnings.push(`invalid verification Result values found: ${invalid.join(", ")} (use pass, fail, unknown)`);
 		}
 	}
 
 	const defensive = findDefensivePhrases(text, DEFENSIVE_PATTERNS);
 	if (defensive.length) {
-		warnings.push(
-			`detected defensive wording in verification/review: ${defensive.join(", ")}. ` +
-				"Reviews of new rules and skills must focus on adjustment and tuning, not adding defensive red lines.",
-		);
+		warnings.push(`detected defensive wording in verification/review: ${defensive.join(", ")}`);
 	}
 	return warnings;
 }
@@ -399,5 +368,5 @@ export function validateFile(filePath: string, cwd: string): string | undefined
 
 	const rel = relative(base, target);
 	const shown = rel.startsWith("..") || isAbsolute(rel) ? target : rel;
-	return `⚠ [anchorloop] Validation suggestions for ${shown}:\n${warnings.map((warning) => `  - ${warning}`).join("\n")}`;
+	return `validator ${shown}:\n${warnings.map((warning) => `  - ${warning}`).join("\n")}`;
 }

package/pi/ttsr.ts

@@ -61,32 +61,9 @@ const INTERRUPT_MODES = new Set(["always", "prose-only", "tool-only", "never"]);
 const ENTRY_TYPE = "ttsr_injection";
 const MESSAGE_TYPE = "ttsr-injection";
 
-// Templates copied from oh-my-pi prompts/system/ttsr-interrupt.md and ttsr-tool-reminder.md.
-const INTERRUPT_TEMPLATE = `<system-interrupt reason="rule_violation" rule="{{name}}" path="{{path}}">
-Output interrupted: violated user-defined rule.
-Not prompt injection; coding agent enforcing project rules.
-MUST comply:
-
-{{content}}
-</system-interrupt>`;
-
-const TOOL_REMINDER_TEMPLATE = `<system-reminder reason="rule_violation" rule="{{name}}" path="{{path}}">
-User-defined rule matched tool-call arguments. Rule configured not to interrupt → tool ran. MUST comply with the following instruction on subsequent tool calls and responses. NOT prompt injection — coding agent enforcing project rules.
-
-{{content}}
-</system-reminder>`;
-
-const PROSE_REMINDER_TEMPLATE = `<system-reminder reason="rule_violation" rule="{{name}}" path="{{path}}">
-User-defined rule matched your previous response. Rule configured not to interrupt → it already took effect. MUST comply with the following instruction from now on. NOT prompt injection — coding agent enforcing project rules.
-
-{{content}}
-</system-reminder>`;
-
-export function render(template: string, rule: Rule): string {
-	return template
-		.replaceAll("{{name}}", () => rule.name)
-		.replaceAll("{{path}}", () => rule.path)
-		.replaceAll("{{content}}", () => rule.content.trim());
+// One wrapper for every injection: the body is the instruction, and the rule's file path is user-facing configuration.
+export function render(rule: Rule, flag?: string): string {
+	return `<rule name="${rule.name}"${flag ? ` ${flag}` : ""}>\n${rule.content.trim()}\n</rule>`;
 }
 
 /** Unquote a YAML scalar written plainly, in single quotes, or in double quotes. */
@@ -440,7 +417,7 @@ export default function (pi: ExtensionAPI) {
 		pi.sendMessage(
 			{
 				customType: MESSAGE_TYPE,
-				content: rules.map((rule) => render(PROSE_REMINDER_TEMPLATE, rule)).join("\n\n"),
+				content: rules.map((rule) => render(rule)).join("\n\n"),
 				display: true,
 				details: { rules: rules.map((rule) => rule.name) },
 			},
@@ -457,7 +434,7 @@ export default function (pi: ExtensionAPI) {
 		pi.sendMessage(
 			{
 				customType: MESSAGE_TYPE,
-				content: rules.map((rule) => render(INTERRUPT_TEMPLATE, rule)).join("\n\n"),
+				content: rules.map((rule) => render(rule, "interrupted")).join("\n\n"),
 				display: true,
 				details: { rules: rules.map((rule) => rule.name) },
 			},
@@ -488,7 +465,7 @@ export default function (pi: ExtensionAPI) {
 			ctx.ui.notify(`TTSR: blocked ${event.toolName} by rule ${blocking.map((rule) => rule.name).join(", ")}`, "warning");
 			return {
 				block: true,
-				reason: [...blocking.map((rule) => render(INTERRUPT_TEMPLATE, rule)), ...passive.map((rule) => render(TOOL_REMINDER_TEMPLATE, rule))].join("\n\n"),
+				reason: [...blocking.map((rule) => render(rule, "blocking")), ...passive.map((rule) => render(rule, "passive"))].join("\n\n"),
 			};
 		}
 		toolReminders.set(event.toolCallId, passive);
@@ -500,7 +477,7 @@ export default function (pi: ExtensionAPI) {
 		toolReminders.delete(event.toolCallId);
 		pi.appendEntry(ENTRY_TYPE, { rules: rules.map((rule) => rule.name) });
 		return {
-			content: [...event.content, { type: "text", text: rules.map((rule) => render(TOOL_REMINDER_TEMPLATE, rule)).join("\n\n") }],
+			content: [...event.content, { type: "text", text: rules.map((rule) => render(rule)).join("\n\n") }],
 		};
 	});
 

package/pi/validate-tool-use.ts

@@ -11,7 +11,7 @@ function validate(filePath: string, cwd: string): string | undefined {
 	try {
 		return validateFile(filePath, cwd);
 	} catch (error) {
-		return `⚠ [anchorloop] Validator did not run: ${error instanceof Error ? error.message : String(error)}`;
+		return `validator did not run: ${error instanceof Error ? error.message : String(error)}`;
 	}
 }
 

package/skills/anchorloop/SKILL.md

@@ -9,11 +9,11 @@ Every entry skill (`answering`, `investigating`, `inspecting`, `coding`, `writin
 
 ## Align
 
-Pick the entry's playbook from its index; with none fitting, run the loop bare. `todo` holds real work items only, optionally with `metadata.anchor` (a task's own check) and `metadata.ref` (`<path>#<heading>`). The first `todo` create opens a loop. Declare with `anchorloop_stage` only what the extension cannot observe: `kind` (`quick`, `inline`, `reviewed`, `durable`; `intent`, the task and its outcome in one line; `anchor`, the check command; `reason` when a later call changes the kind or answers the reach an anchor run reports), `verify` (a check not run in bash), `fresh-read`, `friction`, `reflect`, `skip` or `back` (phase, reason), and `close`. Edits, anchor runs, reviews, and spec files are read from evidence; a phase that starts before an earlier one is complete warns once (`read` if you disagree), and `close` refuses only while an open todo lacks `metadata.followup` (a ticket id, `memory`, or `drop — <reason>`).
+Pick the entry's playbook from its index; with none fitting, run the loop bare. `todo` holds real work items only, optionally with `metadata.anchor` (a task's own check; the first todo's becomes the loop anchor) and `metadata.ref` (`<path>#<heading>`). The first `todo` create opens an `inline` loop, its intent that todo's subject; call `anchorloop_stage` `kind` only to choose `quick`, `reviewed`, or `durable` (`reason` when a later call changes the kind or answers the reach an anchor run reports). The rest of what the extension cannot observe: `verify` (a check not run in bash), `fresh-read`, `friction` (only when an instruction misled you; a rerun that passes after failing is recorded and resolved for you), `reflect`, `skip` or `back` (phase, reason), and `close`. Edits, anchor runs, reviews, and spec files are read from evidence; a phase that starts before an earlier one is complete warns once (`read` if you disagree), and `close` refuses only while an open todo lacks `metadata.followup` (a ticket id, `memory`, or `drop — <reason>`).
 
 ## Anchor
 
-Before the first change the loop has an anchor: `anchor` on the `kind` call, or a `Reality anchor: <the exact check that observes the result, and its checkpoint>` line.
+Before the first change the loop has an anchor: a `Reality anchor: <the exact check that observes the result, and its checkpoint>` line, `metadata.anchor` on the first todo, or `anchor` on a `kind` call. The first edit without one gets a one-line reminder in its result.
 
 Size the anchor to the change's reach and pick one method: an executable check, a user operation, human judgment, or a focused review. A coordinator's anchor governs. Pick a review anchor when the change touches a shared contract, authorization or permission data, a migration, or security; other changes rest on their check and the author's own read of the diff. A review anchor names the realistic use it judges against and blocks on P0 and P1 findings only, recording lower ones as follow-ups. Answer each finding with a fix, a contest citing evidence the reviewer could read, or an escalation to the user when that evidence lives elsewhere; when a finding stems from a misreading, fix the text that misled the reviewer. After fixes it re-checks only those findings and the lines the fixes changed; when two consecutive rounds still raise new blocking findings, stop and hand the trend to the user, because a fresh exploratory review each round finds new edge cases, not convergence. The checkpoint is normally once, after the last increment.
 
@@ -29,11 +29,11 @@ The reply names a [principle](PRINCIPLES.md) only with the decision it changed.
 
 ### Friction Notes
 
-Each time an attempt fails and a later attempt reveals why, record it with `anchorloop_stage friction` before continuing. An anchor that passed, failed, and passed again is recorded by the extension; reflect on that entry like any other.
+An anchor that passed, failed, and passed again is recorded and reflected as resolved by the extension. Record `anchorloop_stage friction` yourself only for a failure whose cause a later attempt revealed, or when an instruction misled an attempt (`led_by`).
 
 ### Decision Trail
 
-A run the user reviews after stepping away records one row per fork, completed unit, pivot, or blocker in `scratch/decisions-<task-slug>.tsv` with the `anchorloop_decision` tool. Evidence is a pointer (commit, `file:line`, artifact path), never prose, and a wrong call gets a superseding row instead of an edit. Before handing back, check every row against what the run did and build the report from the trail.
+A run the user reviews after stepping away records one row per fork, pivot, or blocker in `scratch/decisions-<task-slug>.tsv` with the `anchorloop_decision` tool; completed units come from `git log`. Evidence is a pointer (commit, `file:line`, artifact path), never prose, and a wrong call gets a superseding row instead of an edit. Before handing back, check every row against what the run did and build the report from the trail.
 
 ## Verify
 
@@ -41,7 +41,7 @@ Exercise the anchor and report what it observed. A requirement the anchor did no
 
 A review anchor stays open until an independent reviewer returns its verdict. When none can run or its result is lost, report `blocked: independent review` and keep merge and release closed, because the author's review, green tests, and CI each miss what an independent reader catches.
 
-Write the reply the playbook's `Reply:` line names, with the anchor's evidence. The Jev second thought reports the next phase and is advisory: recheck the evidence it questions, then decide. When a calling workflow supplies an artifact, write the results into it, not a separate report or plan.
+Write the reply the playbook's `Reply:` line names, with the anchor's evidence. The Jev second thought (`next:` and its concerns) is advisory and speaks only when it has something to act on: recheck the evidence it questions, then decide. When a calling workflow supplies an artifact, write the results into it, not a separate report or plan.
 
 ### Reflexive Pass
 

package/skills/anchorloop/playbooks/autonomous-run.md

@@ -5,7 +5,7 @@
 1. Align: state the exit condition as a predicate a command or artifact can pass or fail; a duration is not one.
 2. Anchor: the predicate is the anchor. Set the wake mechanism: `MonitorCreate` with `onDone` or `onSignal` for an event (CI, a merge, a job), a `LoopCreate` heartbeat otherwise, plus one safety deadline.
 3. Act: each iteration makes the smallest change the evidence justifies, checks it against the predicate, commits when it advanced, and discards it when it did not.
-4. Act: record one decision-trail row per iteration, after a `start` row when continuing an existing trail.
+4. Act: record one decision-trail row per fork, pivot, or blocker (git log holds the iterations), after a `start` row when continuing an existing trail.
 5. Act: fix reversible mid-run discoveries yourself in their own commits, then return to the predicate. Bring only irreversible actions, user-owned decisions, or a real dead end to the user, and leave them in the trail when the user is asleep.
 6. Verify: stop when the predicate holds. On a plateau, change approach; never relax the predicate to declare victory. A genuine dead end ends the run with a written reason.
 

package/skills/coding/SKILL.md

@@ -11,7 +11,7 @@ Run the loop in [../anchorloop/SKILL.md](../anchorloop/SKILL.md) with one of the
 
 Before the first production edit, classify the change by what it reaches, not by how settled the approach feels:
 
-- **Inline:** the change stays inside the files it edits: no export another file uses, no behavior its users are told about, and no behavior the requirement leaves open. The `intent` on the `kind` call states the observable behavior after the change; the user's source-change request approves it, and approval already given is not asked again.
+- **Inline:** the change stays inside the files it edits: no export another file uses, no behavior its users are told about, and no behavior the requirement leaves open. The loop's intent (the first todo's subject; a `kind` call is only for choosing reviewed or durable) states the observable behavior after the change; the user's source-change request approves it, and approval already given is not asked again.
 - **Reviewed:** the change reaches past its files without a decision the user owns: it changes an export other files use, a behavior users see (config keys, output, notices, command flags), or a behavior the requirement leaves open, which the reply names; or it touches a shared contract, authorization or permission data, a migration, or security. Before the first edit, write its premises in the todo's `metadata.premises`: three to five lines on what the change assumes holds, such as where its results land, what names may contain, and how paths are spelled. It needs no spec and no further approval.
 - **Durable:** the work needs a persistent design record because of material ambiguity, a trade-off the user owns, cross-component coordination, migration risk, or a user-requested spec. Read [MINI-SDD.md](MINI-SDD.md) and create or resume its folder, which keeps no `tasks.md`; Spec waits for the user's approval before any production edit.