devrites 5.7.2 → 5.9.0

package/pack/generated/pi/skills/rite-build/reference/checkpoint.md

@@ -1,28 +1,46 @@
-# Checkpoint: proven slices land as local WIP commits
+# Checkpoint: land local WIP only after the check loop is green
 
-A slice's source never stays uncommitted after its gates are green: at RECORD
-the orchestrator commits the proven slice as a local `WIP`, so the working
-tree stays clean and the work survives a crash or compaction.
+The wright does not commit onto the control/primary branch. Independent review
+and fail-on-red proof run first; a red or gap finding dispatches another wright.
+Only when that loop is green does the orchestrator land the local unpushed
+`WIP(<slug>):` commit. Same rule for `/rite-build`, `/rite-prove`, `/rite-polish`,
+`/rite-review`, and `/rite-autocomplete`. Never push. `.devrites/CHECKPOINT` is
+not a gate.
 
-## The checkpoint commit: orchestrator, at RECORD, after gates are green
-A checkpoint records a **proven** slice only after its gates are green. Stage the exact
-slice-owned candidate paths from the manifest, passing each literal path separately.
+## When (and when not)
+
+- **Do:** after Independent Build review (or the phase's independent validators)
+  and fail-on-red proof are green, with no open Critical/Important and no repair
+  wright still in flight. Serial: git recipe below (skip empty index) or isolated
+  FF of a matching `transfer_commit`. Parallel: `devrites-engine parallel
+  integrate --apply-to-control` (no second control `git commit`).
+- **Do not:** when a wright returns; before review/proof; with red/gap findings;
+  fast-forward an isolated transfer onto control before those checks.
+
+A native-worktree `transfer_commit` is transport on the worker branch only.
+
+## The commit
+Stage the exact candidate paths from the manifest, each as its own argv.
 Never stage `touched-files.md`, a directory, glob, unrelated path, or user change.
-Verify the staged set, then commit locally with a `[devrites-context]` body:
+Verify the staged set, then commit locally.
+
+Subject: `WIP(<slug>):` plus an imperative summary of the change (from the
+goal). Never a slice id, `SLICE-###`, a slice number, or "this slice"
+(`WIP(admin-report): add CSV export for usage rows`, not `SLICE-003` or
+`complete slice 3`). Product source, tests, comments, and filenames omit the
+same marks; they stay in `.devrites/` only.
 
 ```bash
-git commit -m "WIP(<slug>): <slice>" -m "$(cat <<'BODY'
+git commit -m "WIP(<slug>): <imperative summary>" -m "$(cat <<'BODY'
 [devrites-context]
-decisions: <one-line delta this slice added to decisions.md>
-remaining: <pending slices — count or names>
-dead-ends: <approaches ruled out this slice, if any>
+decisions: <one-line delta this work added to decisions.md>
+remaining: <pending count>
+dead-ends: <approaches ruled out, if any>
 BODY
 )"
 ```
 
-When host reconciliation already landed the isolated transfer commit, nothing
-is staged and the step no-ops. **Local-only:** never push a checkpoint or let
-scratch work trigger CI.
+**Local-only:** never push or let scratch work trigger CI.
 
 ## Restore
 After a crash, a fresh session may read the last `WIP(<slug>)` body as crash context.
@@ -36,9 +54,3 @@ WIP commits are scratch and never reach shared history. `/rite-ship` folds them
 one atomic feature commit before the Conventional-Commit ladder: see the collapse step in
 [git-ship.md](../../rite-ship/reference/git-ship.md). Result: one clean commit, bisect
 stays green.
-
-## Autocomplete
-Checkpoints are unconditional; `/rite-autocomplete` needs no sentinel arming.
-Each wright returns after one slice; HITL stops, while explicit `.devrites/AFK`
-lets the controlling Build root chain another green slice only under its cap
-and pause rules.

package/pack/generated/pi/skills/rite-build/reference/one-slice-cycle.md

@@ -17,16 +17,17 @@ DISPATCH  → hand the slice contract to devrites-slice-wright (fresh context).
    ORIENT    → load only the files this slice touches; learn the project's idiom; reuse-first
    (RED)     → if behavior change: write the failing test first
    IMPLEMENT → smallest complete version; match conventions; devrites-frontend-craft for UI
-   VERIFY    → writer-safe tests/types/lint; return code + tests
+   VERIFY    → writer-safe tests/types/lint; return code + tests (no control-branch commit)
 (DOUBT)   → orchestrator, on return: devrites-doubt each non-trivial decision the wright stood up
             — dispatch the initial read-only reviews of distinct decisions in parallel
             (independent claims, fresh contexts); wright fixes stay serial — writers share files
 PROVE     → root: required build/browser/E2E, then returned-diff/path review; fail-on-red
+            (red/gap → repair wright, then re-review/re-prove; do not commit yet)
 RECORD    → orchestrator: after green verification, update state.md/evidence.md and
             upsert the authoritative candidate manifest from the actual scoped diff
-(CHECKPOINT) → orchestrator: commit the proven slice local-only as WIP(<slug>)
-            with a [devrites-context] body → clean tree, survives a crash (checkpoint.md)
-NEXT      → HITL root reports and stops; AFK root may repeat only under afk-discipline.md
+(CHECKPOINT) → only now, with review+proof green: local WIP(<slug>): <imperative summary>
+            on the control branch (no slice id) → checkpoint.md
+NEXT      → HITL root reports and stops. AFK with parallel cap>1: return to parallel-batch selection and run the new N_eff; otherwise repeat under afk-discipline.md
 ```
 
 ## Why the boundary matters

package/pack/generated/pi/skills/rite-build/reference/parallel-batch.md

@@ -28,18 +28,20 @@ N_eff = min(
 )
 ```
 
-Select **greedily in plan order**: walk pending slices whose `depends_on` are built and
-add each one while it stays pairwise disjoint with the selected set and the cap is not
-reached. Then `N_eff ≥ 2` → parallel batch; `N_eff = 1` → the serial one-slice cycle;
-nothing pending → Prove. A cap that cannot be filled is normal: take fewer.
-
-**Re-batch automatically.** After integrate + cleanup are green, re-read `state.md`,
-the pending slices (`observe slice`), and the updated tree, then recompute: integrated
-siblings leave the pending set and free their paths, and satisfied dependencies unlock
-new slices. Repeat until no pending slice remains. Under `.devrites/AFK` and
-`/rite-autocomplete` the repeat is part of the same run — a new batch is another
-`/rite-build --parallel` round inside it, not a new user invocation; HITL stops after
-each batch. A batch of three followed by one of four and then two is the expected shape.
+Select **greedily in plan order**: pass every currently dependency-ready pending slice
+(plan order, `Files likely touched`) to
+`devrites-engine parallel select --cap N [--root <dir>]`. `N_eff ≥ 2` → parallel batch;
+`N_eff = 1` → one serial round; nothing pending → Prove. A cap that cannot be filled
+is normal: take fewer. Serial is this round's size, not the rest of the run.
+
+**Re-batch automatically after every completed round** (parallel integrate+cleanup or
+a serial slice). Re-read `state.md`, pending slices, and the tree, then run
+`parallel select` again: finished work leaves the pending set, and satisfied
+dependencies unlock new slices. Under `.devrites/AFK` and `/rite-autocomplete` the
+repeat is the same run — HITL stops after each batch. `--parallel 5` with one eligible
+slice runs that one; when two to five then become eligible, the next round takes that
+many. **Failing case:** the run stays one-by-one after a serial round even though more
+slices are now eligible under the same cap.
 
 ## Path-disjoint
 
@@ -71,7 +73,8 @@ Lease: `batch_id`, `created_at`, `base_sha`, `n`,
 1. Orient/gate; parse the cap; compute `N_eff` and select the eligible set
    ([Dynamic selection and re-batching](#dynamic-selection-and-re-batching)) —
    candidates from `orient` `task_graph.slices` + built list, each candidate's
-   `Files likely touched` via `observe slice`, disjointness via `check path-disjoint`.
+   `Files likely touched` via `observe slice`, then
+   `parallel select --cap N` (pairwise disjointness is inside that verb).
 2. Write lease; freeze `B=HEAD`; `parallel create` worktrees.
 3. Dispatch ≤10 wrights in parallel (cwd=worktree; allowlist; prove `HEAD==B`).
 4. Inspect each returned path list, cumulative diff from `B`, transfer identity,
@@ -91,13 +94,16 @@ Lease: `batch_id`, `created_at`, `base_sha`, `n`,
    Expected test-first RED is not a terminal gate failure. Cancel only for a shared
    invalid foundation, safety/access failure, resource boundary, or explicit stop;
    preserve completed and in-progress recoverable work and classify each result.
-6. Integrate: each `transfer_commit` descends from `B` and diffs path-exact vs
-   `B`; squash-apply all in plan order into one `WIP(<slug>):` commit on the
-   staging branch (Ship collapses it). Conflict → reset to `B`,
-   `integrate-failed`; classify under repair rounds (siblings stay in place).
-7. Success: FF control to the squash commit — the batch lands as one local
-   commit, never pushed; union `touched-files.md`; update state/evidence;
-   AFK +1 per integrated sibling; optional `check candidate`.
+6. `parallel integrate --apply-to-control` **only after steps 4–5 are green**:
+   each `transfer_commit` descends from `B` and diffs path-exact vs
+   `B`; apply each in plan order as its own local `WIP(<slug>):` commit
+   (imperative summary, never a slice id). Staging branch, then FF. Conflict →
+   reset to `B`, `integrate-failed`; classify under repair rounds (siblings stay
+   in place). Never integrate because a wright returned.
+7. Success: FF control (the branch that held `HEAD` when the batch started —
+   often `main`/`master`, otherwise whatever the user was on) to the integrate
+   tip: N local commits, never pushed; union `touched-files.md`; update
+   state/evidence; AFK +1 per integrated sibling; optional `check candidate`.
 8. Cleanup runs only after `integrate` marks the lease `complete` — work
    landed in control, so `parallel cleanup` removes worktrees/branches.
    Blocked/human-stopped batches keep lease, worktrees, branches — nothing is
@@ -163,6 +169,7 @@ Repair rejected work in place; never discard/rebuild while budget remains.
 ## Engine verbs
 
 ```text
+devrites-engine parallel select --cap <1-10> [--root <dir>] [<json-file>|-]
 devrites-engine parallel create --root <repo> --slug <slug> --batch <id> --base <B> --json <file>|-
 devrites-engine parallel record-green --root <repo> --slug <slug> --slice <id> --commit <sha>
 devrites-engine parallel integrate --root <repo> --slug <slug> --apply-to-control
@@ -174,9 +181,9 @@ devrites-engine parallel lease-write|lease-read|lease-clear --root <repo> --slug
 #   parallel cleanup --root <repo> --slug <slug> --force   (salvages, prints retained refs)
 ```
 
-`integrate` without `--apply-to-control` stages the squash commit, leaves the
-lease `running` and control at `B`; cleanup still refuses — the commit cannot
-be lost. `record-green` and `integrate` also accept an `integrate-failed`
+`integrate` without `--apply-to-control` stages the per-sibling commits, leaves
+the lease `running` and control at `B`; cleanup still refuses — the commits
+cannot be lost. `record-green` and `integrate` also accept an `integrate-failed`
 lease, so a failed integrate retries after repair. `--apply-to-control`
 refuses when control moved past `B` or holds uncommitted changes on slice
 paths — commit/stash and retry; the batch is untouched. Go is SSOT; never

package/pack/generated/pi/skills/rite-build/reference/phase-contract.md

@@ -44,8 +44,10 @@ Spec Drift Guard still applies.
    Reapply host admission before correction; affected proof/evidence follows candidate
    integrity. Human gates remain product/irreversible/access decisions.
 7. **Record green.** Upsert actual scoped `present`/`deleted` rows in `touched-files.md`;
-   update state, evidence and applicable UI/browser proof. Manifest stays mutable
-   until Polish. For a release milestone, after the last slice's rows run
+   update state, evidence and applicable UI/browser proof. Checkpoint per
+   [`checkpoint.md`](checkpoint.md) only after steps 5–6 are green and every
+   repair wright has been re-reviewed and re-proved; never on wright return.
+   Manifest stays mutable until Polish. For a release milestone, after the last slice's rows run
    `devrites-engine state merge-manifest <slug>` to fold the recorded
    predecessor chain into the union manifest before Prove. Record stood
    decisions/dead ends; refresh verified/falsified

package/pack/generated/pi/skills/rite-build/reference/wright-dispatch.md

@@ -25,12 +25,13 @@ discard user work to qualify. Ask host for an explicit current-`HEAD` base when
 supported. Regardless of host defaults, the wright's first command must prove actual `git rev-parse HEAD` equals supplied
 `worktree_base`. Mismatch returns a gap with no write before project reads or baseline proof.
 
-The isolated wright returns one local unpushed `transfer_commit`, its `worktree_base`,
-and exact files. Root proves descendant base, exact `git diff --name-only`
+The isolated wright returns one local unpushed `transfer_commit` (contract
+`WIP(<slug>):` subject, no slice id), its `worktree_base`, and exact files.
+That commit is worker-branch transport, not the control-branch checkpoint. Root proves descendant base, exact `git diff --name-only`
 `` `<base>..<transfer>` ``, no `.devrites/**`/submodule/symlink/unrelated delta, unchanged
 source base, and no user-work overwrite. Use only host-native explicit reconciliation;
-never ad hoc copy, cherry-pick, or merge from read-only root. Compare transferred bytes,
-run approved proof, record evidence, then let host remove worktree.
+never ad hoc copy, cherry-pick, or merge from read-only root. Land on control
+only per [`checkpoint.md`](checkpoint.md).
 
 Conflict, extra/missing commit, moved base, or cleanup failure is `gap`/STOP:
 preserve the worktree and commit. Without explicit reconciliation, use same-worktree serial.
@@ -48,7 +49,8 @@ worktrees stay forbidden.
    [`workflow-artifacts.md`](../../devrites-lib/reference/standards/workflow-artifacts.md);
    its rejection here is not a blocker.
 2. Include goal, verbatim acceptance, exclusions, context,
-   `test-plan.md` proof commands, and applicable standards. For each triggered
+   `test-plan.md` proof commands, applicable standards, and the exact
+   `WIP(<slug>):` subject (no slice id). For each triggered
    topology/data/integration standard, include only the feature-specific owner/invariant,
    failure or partial-state case, recovery rule, and required proof from the vetted plan.
    Do not paste the whole standard or silently omit an applicable risk.
@@ -75,12 +77,17 @@ Opt-in `/rite-build --parallel N` fans out only under [`parallel-batch.md`](para
    assertions. Dedicated test analysis treats weakening as Critical.
    Confirm a test for a data/integration/topology risk can actually exhibit that risk;
    mocks that erase it and one-root proof offered for another root are unproven.
-3. Run only repository proof already approved by `test-plan.md`, then inspect
-   `git diff --name-only` again in case a proof tool changed source.
-4. Apply [independent Build review](phase-contract.md#independent-build-review) before
-   proof acceptance. Human choices return; technical failures follow
+3. Apply [independent Build review](phase-contract.md#independent-build-review)
+   before proof. Human choices return; technical failures follow
    [the canonical retry contract](../../devrites-lib/reference/standards/afk-hitl.md#retry-cap-no-progress-loops-and-self-resolve).
    Derive accounting from recorded reproductions, corrections, and decisive rechecks.
+4. Run only repository proof already approved by `test-plan.md`, then inspect
+   `git diff --name-only` again in case a proof tool changed source.
+   **Do not land on control until review and proof are green.** Isolated
+   `transfer_commit` stays on the worker branch; same-worktree diffs stay
+   uncommitted. Serial: [`checkpoint.md`](checkpoint.md), then host may remove the
+   worktree. Parallel: `record-green` only; land with `parallel integrate
+   --apply-to-control` after the batch; `parallel cleanup` removes worktrees.
 5. Reconcile returned reuse, conventions, principles, sources, assumptions,
    decisions, dead ends, follow-ups, gates, and touched files. Persist the
    relevant facts in canonical artifacts, not the wholesale report. A plan-gap

package/pack/generated/pi/skills/rite-plan/reference/slicing.md

@@ -106,8 +106,8 @@ Make each continuation cheap and drift-free:
 - Phases chain automatically only **inside** one workspace (`/rite-autocomplete`
   drives spec → clarify → temper → define → vet → build × slices → prove → polish →
   review → seal; plain HITL chains plan↔vet inline and stops at each other boundary).
-  Crossing into the next continuation is a new invocation by design, so the human sees
-  each delivered increment before the next one starts.
+  Next continuation is a new invocation by default. Same-run chaining is
+  `continue_sequence: true` (Deferred-ship).
 
 ### Release milestone (full-picture gate)
 
@@ -138,7 +138,8 @@ product:
   product picture across milestones; Polish folds each milestone's deltas.
 - **Deferred-ship sequence** (`.devrites/AFK` `continue_sequence: true`, `max_workspaces: N`):
   milestones are sealed but not shipped, and the armed run opens the next recorded
-  continuation automatically; per-slice `WIP(<slug>)` checkpoints still land locally,
+  continuation automatically; local `WIP(<slug>):` checkpoints still land with
+  human summaries (never a slice id),
   so the tree stays clean. One release ship at the end collapses the sequence's
   checkpoints into the single release commit, pushes/tags it, and may archive the
   sealed predecessors. Because no milestone boundary was shipped, later work can touch

package/pack/generated/pi/skills/rite-polish/SKILL.md

@@ -91,7 +91,9 @@ Incomplete comparison is **not** agreement. Record axis deltas in `polish-report
    affected real re-proof using the approved commands, fresh proof-runner
    validation, refreshed evidence/browser bindings, and an updated candidate
    manifest. Record a **`Re-verification:`** line in `polish-report.md`. Close
-   the candidate for Review only after these checks are green.
+   the candidate for Review only after these checks are green. Then checkpoint
+   remaining candidate diffs per
+   [`checkpoint.md`](../rite-build/reference/checkpoint.md).
 7. **Aggregate output:** each phase appends to the single `polish-report.md`.
 
 ## Refinement modes

package/pack/generated/pi/skills/rite-prove/SKILL.md

@@ -106,6 +106,9 @@ test changes.
    attempt. Never guess the runtime fix or reuse old GO.
 10. **Record.** Root updates `evidence.md`, optional `browser-evidence.md`,
     traceability, and state, with exactly one observed candidate binding.
+    After independent validators are green, checkpoint remaining candidate
+    diffs per [`checkpoint.md`](../rite-build/reference/checkpoint.md). A wright
+    correction during Recover red does not commit on control until this step.
 
 > Do not claim an unobserved pass, skip browser proof, or proceed with pending
 > slices. Load `reference/anti-patterns.md` when tempted to do so.

package/pack/generated/pi/skills/rite-review/SKILL.md

@@ -142,7 +142,9 @@ Pull these via `Read` when the diff demands them:
    binding in `review.md` for the current digest, distinguishing fresh accounts from
    cited unchanged sub-scope evidence and reconciling complete coverage.
    **Completion:** the records name the reviewed candidate identity and every accepted
-   correction has affected proof plus a fresh Review.
+   correction has affected proof plus a fresh Review. Then checkpoint remaining
+   candidate diffs per [`checkpoint.md`](../rite-build/reference/checkpoint.md);
+   a wright correction does not commit on control until that Review is green.
 
 ## Finding labels
 

package/pack/generated/pi/skills/rite-temper/SKILL.md

@@ -27,8 +27,8 @@ the spec applicability map triggers that risk family.
 - **Raise outcome ambition without expanding the solution unnecessarily.** Solve the
   underlying problem without adding speculative capability or abstraction.
 - **Route every scope change through the Spec Drift Guard.** A scope change takes effect
-  only when `spec.md` records the confirmed decision. Expansion is **opt-in** (HITL
-  confirm; AFK pauses: see autocomplete policy). Nothing auto-grows into the build.
+  only when `spec.md` records the confirmed decision. HITL confirms expand;
+  autocomplete auto-applies it. Irreversible-risk still pauses.
 - **Apply maximum caution to hard-to-reverse changes.** Auth, migration, public API, and
   data-model changes always pause under the irreversible-risk list.
 - **Honest verdict.** Never round "needs work" up to "ready"; record every scope call's *why*.
@@ -89,8 +89,8 @@ the spec applicability map triggers that risk family.
    `AskUserQuestion`, one at a time, best-guess + **why**. Each material scope call ends as a
    **recorded decision**: a resolved `questions.md` qid (HITL) or a `decisions.md` ADR (AFK):
    so the review leaves an auditable record outside chat. (AFK gate policy —
-   [`reference/significance.md`](reference/significance.md) — `hold-rigor` + `reduce-to-MVP`
-   auto-apply, **any `expand` is a blocking pause**, irreversible-risk always pauses.)
+   [`reference/significance.md`](reference/significance.md) — autocomplete applies
+   the recommended mode including `expand`; irreversible-risk always pauses.)
    Apply objective clarity, mitigation, and assumption fixes directly.
 6. **Write `strategy.md` + fold back:** [`reference/strategy-template.md`](reference/strategy-template.md).
    **Choose the drift path based on whether a plan exists:** *no `plan.md` yet* (the normal pre-define
@@ -110,8 +110,8 @@ the spec applicability map triggers that risk family.
    blocking/escalating question routes `/rite-clarify`/HITL. Only after the
    matrix is re-closed may the phase advance.
    Set `Phase: temper`; `Next step: /rite-define` only after verification.
-   Human-owned expansion/unapproved irreversible choices set `Awaiting human` +
-   `Status: awaiting_human`; objective below-bar findings continue correction.
+   Unapproved irreversible choices set `Awaiting human`. Autocomplete expand does
+   not. Objective below-bar findings continue correction.
 7. **Adversarial verification loop:** ask the exact
    [`devrites-strategy-reviewer`](.pi/agents/devrites-strategy-reviewer.md)
    through the native fresh-context contract in

package/pack/generated/pi/skills/rite-temper/reference/significance.md

@@ -41,6 +41,6 @@ seal can see the call was made deliberately.
 
 ## In `/rite-autocomplete`
 Autocomplete runs the significance test every feature. On skip → straight to `/rite-define`
-(no pause). On fire → run the full review under the AFK gate ceiling: `hold-rigor` and
-`reduce-to-MVP` auto-apply (they never grow acceptance); **any `expand` is a blocking pause**;
-irreversible-risk findings always pause. Expansion is never auto-grown unattended.
+(no pause). On fire → run the full review and auto-apply the recommended mode, including
+`expand` and extra acceptance (record the ADR; fold via Spec Drift Guard).
+Irreversible-risk findings always pause.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "devrites",
-  "version": "5.7.2",
+  "version": "5.9.0",
   "description": "DevRites: a disciplined senior-engineer workflow pack for Claude Code, Codex, omp, and pi",
   "license": "SEE LICENSE IN LICENSE",
   "homepage": "https://github.com/ViktorsBaikers/DevRites#readme",

package/scripts/pi-generate.sh

@@ -111,6 +111,57 @@ _pi_map_tools() {
   printf '%s' "$_out"
 }
 
+# pi-subagents treats frontmatter tools: as a strict allowlist, so ambient
+# pi-lean-ctx / pi-lens tools are dropped unless named. Append those names
+# after the mapped builtins (preserve base order). Unknown names are pruned
+# non-fatally by pi-subagents. Read-only agents stay read-only: ctx_edit /
+# ctx_patch only when the base already has edit or write; ctx_shell only
+# when the base already has bash.
+_PI_EXTENSION_NAV_TOOLS="ctx_read, ctx_ls, ctx_find, ctx_grep, ctx_glob, ctx_search, ctx_compose, ctx_callgraph, ctx_tree, symbol_search, project_report, module_report, read_symbol, read_enclosing, lens_diagnostics"
+
+_pi_csv_has() {
+  case ", ${1}, " in
+  *", ${2}, "*) return 0 ;;
+  *) return 1 ;;
+  esac
+}
+
+_pi_csv_append() {
+  local _list="$1" _name="$2"
+  if [ -z "$_name" ]; then
+    printf '%s' "$_list"
+    return
+  fi
+  if [ -z "$_list" ]; then
+    printf '%s' "$_name"
+    return
+  fi
+  if _pi_csv_has "$_list" "$_name"; then
+    printf '%s' "$_list"
+    return
+  fi
+  printf '%s, %s' "$_list" "$_name"
+}
+
+_pi_append_extension_tools() {
+  local _base="$1"
+  local _out="$_base" _tok
+  while IFS= read -r _tok; do
+    _tok="${_tok#"${_tok%%[![:space:]]*}"}"
+    _tok="${_tok%"${_tok##*[![:space:]]}"}"
+    [ -z "$_tok" ] && continue
+    _out="$(_pi_csv_append "$_out" "$_tok")"
+  done < <(printf '%s\n' "$_PI_EXTENSION_NAV_TOOLS" | tr ',' '\n')
+  if _pi_csv_has "$_base" "edit" || _pi_csv_has "$_base" "write"; then
+    _out="$(_pi_csv_append "$_out" "ctx_edit")"
+    _out="$(_pi_csv_append "$_out" "ctx_patch")"
+  fi
+  if _pi_csv_has "$_base" "bash"; then
+    _out="$(_pi_csv_append "$_out" "ctx_shell")"
+  fi
+  printf '%s' "$_out"
+}
+
 # Generate a pi-subagents Markdown agent from a Claude Code markdown agent.
 # pi-subagents loads project agents from .pi/agents/**/*.md (YAML frontmatter +
 # body). The tools allowlist carries the Claude permission boundary: only
@@ -126,7 +177,7 @@ gen_pi_agent() {
   _skills="$(awk 'NR==1 && $0=="---"{fm=1; next} fm && $0=="---"{exit} fm && /^skills:[[:space:]]*$/{list=1; next} list && /^[[:space:]]*-[[:space:]]*/{sub(/^[[:space:]]*-[[:space:]]*/, ""); print; next} list{exit}' "$_src" | tr '\n' ' ' | sed 's/ $//; s/ /, /g')"
   [ -n "$_name" ] || _name="$(basename "$_src" .md)"
   [ -n "$_desc" ] || _desc="DevRites custom agent."
-  _tools="$(_pi_map_tools "$_tools_raw" "$_name")"
+  _tools="$(_pi_append_extension_tools "$(_pi_map_tools "$_tools_raw" "$_name")")"
   _desc_tmp="$TMP_GEN_DIR/pi-agent-desc-$(basename "$_src").txt"
   _desc_pi="$TMP_GEN_DIR/pi-agent-desc-$(basename "$_src").pi.txt"
   printf '%s' "$_desc" >"$_desc_tmp"