@joshuafolkken/kit 1.1050.0 → 1.1094.0

package/.claude/settings.json

@@ -5,6 +5,11 @@
 		"deny": [
 			"Bash(rm -rf *)",
 			"Bash(rm -rf /*)",
+			"Bash(rm -fr *)",
+			"Bash(gh repo delete*)",
+			"Bash(gh repo archive*)",
+			"Bash(gh pr close*)",
+			"Read(./.env)",
 			"Bash(git push --force*)",
 			"Bash(git push -f*)",
 			"Bash(git push *--force*)",
@@ -56,11 +61,7 @@
 				"hooks": [
 					{
 						"type": "command",
-						"command": "echo 'MANDATORY before writing any implementation code: present the two-layer work summary (Now / Change / Check, then every change with its test). Full rule: Code Change Rules Step 0 in CLAUDE.md.'"
-					},
-					{
-						"type": "command",
-						"command": "if [ -f dist/hooks/session-lang.js ]; then node dist/hooks/session-lang.js; else pnpm josh session:lang; fi",
+						"command": "if project_root=\"$(env -u GIT_ALTERNATE_OBJECT_DIRECTORIES -u GIT_COMMON_DIR -u GIT_DIR -u GIT_INDEX_FILE -u GIT_NAMESPACE -u GIT_OBJECT_DIRECTORY -u GIT_WORK_TREE git rev-parse --show-toplevel 2>/dev/null)\"; then unset GIT_ALTERNATE_OBJECT_DIRECTORIES GIT_COMMON_DIR GIT_DIR GIT_INDEX_FILE GIT_NAMESPACE GIT_OBJECT_DIRECTORY GIT_WORK_TREE; else project_root=\"$(git rev-parse --show-toplevel)\" || exit 1; fi; cd \"$project_root\" && if node --disable-warning=ExperimentalWarning scripts/hooks/hook-bundle-ready.ts; then node dist/hooks/session-lang.js; else pnpm josh session:lang; fi",
 						"timeout": 10
 					}
 				]
@@ -72,7 +73,7 @@
 				"hooks": [
 					{
 						"type": "command",
-						"command": "if [ -f dist/hooks/pretool-guard.js ]; then node dist/hooks/pretool-guard.js; else pnpm josh pretool:guard; fi",
+						"command": "if project_root=\"$(env -u GIT_ALTERNATE_OBJECT_DIRECTORIES -u GIT_COMMON_DIR -u GIT_DIR -u GIT_INDEX_FILE -u GIT_NAMESPACE -u GIT_OBJECT_DIRECTORY -u GIT_WORK_TREE git rev-parse --show-toplevel 2>/dev/null)\"; then unset GIT_ALTERNATE_OBJECT_DIRECTORIES GIT_COMMON_DIR GIT_DIR GIT_INDEX_FILE GIT_NAMESPACE GIT_OBJECT_DIRECTORY GIT_WORK_TREE; else project_root=\"$(git rev-parse --show-toplevel)\" || exit 1; fi; cd \"$project_root\" && if node --disable-warning=ExperimentalWarning scripts/hooks/hook-bundle-ready.ts; then node dist/hooks/pretool-guard.js; else pnpm josh pretool:guard; fi",
 						"timeout": 20
 					}
 				]
@@ -84,7 +85,7 @@
 				"hooks": [
 					{
 						"type": "command",
-						"command": "if [ -f dist/hooks/format-edited.js ]; then node dist/hooks/format-edited.js; else pnpm josh format:edited; fi",
+						"command": "if project_root=\"$(env -u GIT_ALTERNATE_OBJECT_DIRECTORIES -u GIT_COMMON_DIR -u GIT_DIR -u GIT_INDEX_FILE -u GIT_NAMESPACE -u GIT_OBJECT_DIRECTORY -u GIT_WORK_TREE git rev-parse --show-toplevel 2>/dev/null)\"; then unset GIT_ALTERNATE_OBJECT_DIRECTORIES GIT_COMMON_DIR GIT_DIR GIT_INDEX_FILE GIT_NAMESPACE GIT_OBJECT_DIRECTORY GIT_WORK_TREE; else project_root=\"$(git rev-parse --show-toplevel)\" || exit 1; fi; cd \"$project_root\" && if node --disable-warning=ExperimentalWarning scripts/hooks/hook-bundle-ready.ts; then node dist/hooks/format-edited.js; else pnpm josh format:edited; fi",
 						"timeout": 90
 					}
 				]
@@ -96,7 +97,7 @@
 				"hooks": [
 					{
 						"type": "command",
-						"command": "if [ -f dist/hooks/stop-guard.js ]; then node dist/hooks/stop-guard.js; else pnpm josh stop:guard; fi",
+						"command": "if project_root=\"$(env -u GIT_ALTERNATE_OBJECT_DIRECTORIES -u GIT_COMMON_DIR -u GIT_DIR -u GIT_INDEX_FILE -u GIT_NAMESPACE -u GIT_OBJECT_DIRECTORY -u GIT_WORK_TREE git rev-parse --show-toplevel 2>/dev/null)\"; then unset GIT_ALTERNATE_OBJECT_DIRECTORIES GIT_COMMON_DIR GIT_DIR GIT_INDEX_FILE GIT_NAMESPACE GIT_OBJECT_DIRECTORY GIT_WORK_TREE; else project_root=\"$(git rev-parse --show-toplevel)\" || exit 1; fi; cd \"$project_root\" && if node --disable-warning=ExperimentalWarning scripts/hooks/hook-bundle-ready.ts; then node dist/hooks/stop-guard.js; else pnpm josh stop:guard; fi",
 						"timeout": 20
 					}
 				]

package/.claude/skills/epic-commands/SKILL.md

@@ -6,9 +6,7 @@ description: The procedures for the `josh epic:*` commands that make an epic run
 # The `josh epic:*` commands
 
 These three commands are what turn an epic from a list of issue numbers into something a run can
-execute unattended. **This skill is their single source**: `prompts/collaboration-workflow/` keeps
-`epic-bundle.md`, `epic-audit.md` and `cross-repo-epic.md` only as pointers here, and the history
-behind the rules is `docs/maintainers/epic-commands-rationale.md` (joshuafolkken/kit#2892).
+execute unattended. **This skill is their single source**, and the history behind the rules is `docs/maintainers/epic-commands-rationale.md` (joshuafolkken/kit#2892).
 
 The workflow keywords themselves — `kickoff`, `fullrun`, `halfrun`, `backlogrun` — live in the
 `workflow-commands` skill.
@@ -118,7 +116,7 @@ about the search itself rather than about anything the children say (joshuafolkk
 
 **One thing it cannot check** belongs to planning: when a child introduces a new label, command,
 state or artifact, list the existing code referencing that concept and confirm some child owns
-updating it. Label names are single-sourced in `scripts/git/issue-labels.ts`.
+updating it. Label names are single-sourced in `scripts/issue/issue-labels.ts`.
 
 History: `docs/maintainers/epic-commands-rationale.md` → "`epic:audit` — why the children are read across".
 
@@ -153,7 +151,7 @@ command prints a ⚠️ line naming that child rather than reporting a reorderin
 `owner/repo#number` and kept by the epic named earlier; withheld there, it stays withheld, because a
 `blocked-by` relation belongs to the issue rather than to the epic listing it. **One unusable graph
 refuses the whole answer**, and **one reference that does not parse fails the read** rather than
-being dropped. `docs/josh-commands.md` → "`josh epic:next`" carries the worked form.
+being dropped. `docs/josh-commands-automation.md` → "`josh epic:next`" carries the worked form.
 
 **An `in-progress` issue occupies a lane rather than the whole repository.** The occupancy is counted
 from that repository's own `in-progress` listing — never from anything the session remembers, since
@@ -196,7 +194,7 @@ inherits; open and tracked by none, the child waits on a person and the
 blocker is named on standard error; a state the relation did not carry reads as waiting. **So an order
 between two epics is recorded with a native `blocked-by` relation and honoured by naming both epics**
 — `epic:next 1936 1931`, or `backlog:next`, whose set is the whole opted-in backlog. The table is
-`docs/josh-commands.md` → "`josh epic:next`".
+`docs/josh-commands-automation.md` → "`josh epic:next`".
 
 Two things stop the command rather than being worked around: a **circular dependency**, and a
 **disagreement between the epic body and the `blocked-by` relations** (an epic written before `josh`
@@ -484,7 +482,7 @@ than restated — and beside it the one thing this one deliberately refuses: whe
 already been filed, from a title comparison (joshuafolkken/kit#1252). **Both run**, and neither
 replaces the other: `pnpm josh issue:file` runs the scout before it creates the issue, and
 `epic:bundle` afterwards, from the real number and the relations recorded against it.
-Full behavior: `docs/josh-commands.md` → "`josh issue:file`".
+Full behavior: `docs/josh-commands-automation.md` → "`josh issue:file`".
 
 **When the relation carries an order, record it** in `blocked-by` and in the epic's `Dependencies` —
 on an addition as much as on a new epic. Without it the batch survives and the reason for it does

package/.claude/skills/workflow-commands/SKILL.md

@@ -1,20 +1,20 @@
 ---
 name: workflow-commands
-description: The procedures for the Issue-driven shorthand commands `kickoff`, `fullrun`, `halfrun` and `backlogrun` — planning, implementation, the verification gate, unattended epic and backlog execution, the `/code-review` → `followup` chain rule, auto-merge and the Telegram notifications. Read this the moment the user types one of those keywords (with or without `#N` / `new`), before running any command, and read it too when asked what one of them does or when a run of one has to be resumed or repaired.
+description: The procedures for the Issue-driven shorthand commands `kickoff`, `fullrun`, `halfrun`, `prrun` and `backlogrun` — planning, implementation, the verification gate, unattended epic and backlog execution, the `/code-review` → `followup` chain rule, auto-merge and the Telegram notifications. Read this the moment the user types one of those keywords (with or without `#N` / `new`), before running any command, and read it too when asked what one of them does or when a run of one has to be resumed or repaired.
 ---
 
 # Issue-driven workflow commands
 
-`kickoff`, `fullrun`, `halfrun` and `backlogrun` are the shorthand commands this
+`kickoff`, `fullrun`, `halfrun`, `prrun` and `backlogrun` are the shorthand commands this
 package's collaboration workflow is built on. Their procedures live here rather than in `CLAUDE.md`
 because each one applies only while its own command is running.
 
-The canonical extended reference is `prompts/collaboration-workflow/` (indexed by
-`prompts/collaboration-workflow.md`); this skill is the operational procedure, and the two must agree.
+Each topic file under `prompts/collaboration-workflow/` sources its own rule; this skill sources the
+procedures. Neither restates the other.
 
 ## 0. The rule that fires before any of them — explicit invocation
 
-**Never start a `kickoff` / `halfrun` / `fullrun` / `backlogrun` workflow (including their
+**Never start a `kickoff` / `halfrun` / `prrun` / `fullrun` / `backlogrun` workflow (including their
 `#N` and `new` variants) unless the user has typed the keyword in the current turn's prompt.** This rule is also
 resident in the AI documents, because it has to hold when this skill has *not* been loaded.
 
@@ -44,6 +44,7 @@ the file its pointer names (for `fullrun`, the step lists are `fullrun-steps.md`
 | `kickoff` / `kickoff #N` / `kickoff new` | `kickoff.md`                                |
 | `fullrun` / `fullrun #N` / `fullrun new` | `fullrun.md`                                |
 | `halfrun` / `halfrun #N` / `halfrun new` | `halfrun.md`                                |
+| `prrun` / `prrun #N` / `prrun new`       | `prrun.md` — the difference over `fullrun.md`, read with it |
 | `backlogrun` / `backlogrun #N…` / `backlogrun #E…` | `backlogrun.md` — its dispatched child reads `fullrun.md` + `split-assessment.md` in its own unit, not the parent at entry |
 
 Each command manifest cites `split-assessment.md` → "The question" — the split decision, read at the
@@ -115,12 +116,12 @@ procedure.
 | While implementing | Re-run one check by name, not the whole gate — `pnpm josh lint:related`, `pnpm josh cspell:dot`, `pnpm josh test:related`; the last pair runs in front of the gate, and `pnpm josh review:brief` refuses a brief on a tree neither was green on | `chain-rule.md` |
 | A review has run | Its verdict counts only once `pnpm josh review:attest --check` answers `ok`; `missing` / `mismatch` are refusals `pnpm josh followup` blocks the merge on | `chain-rule.md` → "The brief names the checkout, and a review that read another one is refused" |
 | E2E gate | The CI E2E job where the command ends in a PR (`fullrun` / `backlogrun`, enforced by `pnpm josh followup`); you run `pnpm josh test:e2e` yourself where it does not (`halfrun`) | `prompts/testing-guide.md` → "Closing the E2E gate without a human run" |
-| A defect in the verification path turns up | The interrupt runs alone; a batch resumes only once it has merged — decided from an enumeration, not from how serious it looks | `prompts/collaboration-workflow/wip-cap.md` → 「実行のしかた」 |
+| A defect in kit's own verification turns up | It runs alone, and a batch resumes only once it has merged, when three conditions all hold (a defect, in kit's own verification, making unrelated PRs answer wrongly on `main` now) — never from how serious it looks | `prompts/collaboration-workflow/wip-cap.md` → 「実行のしかた」 |
 | A command can take minutes | Issue it in the background; the turn never ends at the push (`pnpm josh followup` stays foreground) | §2h → `background-commands.md` → "Background the gate and push" |
 | `pnpm josh issue:state <N>` answers `human_review: yes` | Implement and gate, then stop before the commit | §2z → `needs-human-review.md` |
 | Under `backlogrun`, a stop that would end a batch, or a named non-epic item | Park one child and continue; run a named non-epic item as a `fullrun` | `backlogrun-park.md` → "park and continue"; `backlogrun-child.md` → "When `#N` is not an epic" |
 | `backlogrun`'s authorization | The whole `auto-ok` opted-in pool as well as its named items; `pnpm josh backlog:next` offers them | `backlogrun.md` |
-| First call of `fullrun` / `halfrun` (not `kickoff`) | Claim the tree: `fullrun #N` starts with `pnpm josh run:entry <N>` (which runs the hold); `fullrun new` and `halfrun` use `pnpm josh run:hold` | §2f → `working-tree-hold.md` |
+| First call of any entry | `#N`: `pnpm josh run:entry <N> --to <command>` (claims the tree, except `kickoff`); `new` (not `kickoff`): `pnpm josh run:hold` | §2k; §2f → `working-tree-hold.md` |
 | Same turn as the hold (not a dispatched child, not `kickoff`) | `pnpm josh cost --cut`; `under` continues, `over` stops with a `confirmation` Telegram and the resume command, then `pnpm josh run:release` | `backlogrun-progress.md` → "The hand-off" (shared 135,000 threshold) |
 | Before any work starts (every entry) | The split assessment; the default is not to split — separability **and** a scope clearly over one gate must hold together; a `fullrun` / `halfrun` that finds a split files the epic and **stops** | `split-assessment.md` → "The question" |
 | Another Issue here must land first | A prerequisite is a dependency, not a park (the third of four mid-run discoveries) | §2d → `prerequisite.md` |
@@ -193,14 +194,14 @@ refuses the second `pnpm josh issue:file` call until it has.
 its duplicate and epic answers.** This applies inside every workflow, including observations and review
 follow-ups. The guard refuses any other filing call. Read `issue-scout.md` at that point for the
 duplicate, closed-Issue and epic decisions and for `--distinct`; `issue-fold-existing.md` handles a
-compatible duplicate. `docs/josh-commands.md` → "`josh issue:file`" defines the command.
+compatible duplicate. `docs/josh-commands-automation.md` → "`josh issue:file`" defines the command.
 
 ## 2f. The working-tree hold — one run per tree
 
 **Trigger:** the first call of `fullrun` and `halfrun` alike — before the title is normalized, before
-`git switch main`, and before a `new` entry files its Issue. **Then:** `fullrun #N` first runs
-`pnpm josh run:entry <N>`, which includes the tree claim; `fullrun new` and `halfrun` first run
-`pnpm josh run:hold [<N>]`. `hold` continues; `busy` and `unknown` stop with a `confirmation` Telegram
+`git switch main`, and before a `new` entry files its Issue. **Then:** a `#N` entry first runs
+`pnpm josh run:entry <N> --to <command>` (§2k, the tree claim included); `new` runs bare
+`pnpm josh run:hold`. `hold` continues; `busy` and `unknown` stop with a `confirmation` Telegram
 carrying what stderr printed. **`kickoff` is exempt** (it edits nothing). A stop that leaves the tree
 clean releases explicitly with `pnpm josh run:release [<N>]`; a `halfrun` or `needs-human-review` stop
 keeps the hold; `pnpm josh followup` releases a merged run. The answer table, the per-child rule and
@@ -241,6 +242,13 @@ digest it names once.** File up to two worthwhile improvements through `issue:fi
 `epic:bundle` included), stack the rest in the observation ledger, and close the step with the command described
 there. A dispatched lane child never runs the retrospective.
 
+## 2k. The stage ladder
+
+`kickoff` → `halfrun` → `prrun` → `fullrun` (joshuafolkken/kit#3042): the command sets how far a run
+goes, the Issue where it starts. `run:entry <N> --to <command>` prints `stage #<N> — at: … · start:
+…`; **`start: reached` redoes nothing — stop** (at `merged`, the next line answers). A
+stop's `Next:` line names the commands further up. Table: `docs/how-to/run-issues.md`.
+
 ## 3. What stays resident, and what is read from here
 
 **The residency criterion is `prompts/collaboration-workflow/residency.md`, its single source — read

package/.claude/skills/workflow-commands/background-commands.md

@@ -131,9 +131,10 @@ turn-end this section forbids. The boundary, its two commands and the resume ver
 
 **A headless lane child (`claude -p`) is where "a background command re-invokes the run" does not
 hold: its background Bash tasks are killed when its turn ends** (joshuafolkken/kit#2704). It hands the
-gate-to-merge region to `pnpm josh ship --detach` instead (`chain-rule.md` step 0); `pnpm josh
-rule:guard` refuses a backgrounded `josh gate` / `git` / `followup` there, and the `Stop` hook sends a
-child with a task still running back to wait rather than to notify.
+gate-to-merge region to a foreground `pnpm josh ship --detach` instead (`chain-rule.md` step 0) —
+its preflight runs before the supervisor exists, so a backgrounded `ship` dies with the turn
+(joshuafolkken/kit#3027); `pnpm josh rule:guard` refuses a backgrounded `josh gate` / `git` /
+`followup` / `ship` there, and the `Stop` hook sends a child with a task still running back to wait.
 
 The operational section above is the single source of the rule. `followup.md`, `chain-rule.md` and
 `backlogrun-progress.md` → "Progress while the run is quiet" route here for it rather than restating it.

package/.claude/skills/workflow-commands/backlogrun-child.md

@@ -94,7 +94,7 @@ child over" in `backlogrun-lanes.md` carries the command.
 JSONL. `JOSH_WORKER_MODEL` overrides Claude Code only; `JOSH_WORKER_EFFORT` covers both providers,
 and legacy `JOSH_LANE_*` applies only here. Bad markers, missing CLI/auth and failure
 refuse or park without fallback or retry.
-`docs/josh-commands.md` → "`josh lane:dispatch`" is the single source.
+`docs/josh-commands-automation.md` → "`josh lane:dispatch`" is the single source.
 
 **The parent reads GitHub, never the summary.** That is `epic-child`'s verifier: a unit that reports
 a child finished without its PR merged leaves that child open, and `pnpm josh issue:state <N>` says so

package/.claude/skills/workflow-commands/backlogrun-lanes.md

@@ -65,7 +65,7 @@ it is".
 
 `pnpm josh epic:next <E> --repo <owner/repo> --lanes` answers with **one issue number per line**, up to
 the number of free lanes, and each of those children runs in a **lane** of its own: a linked git work
-tree with its own branch, its own `.env` and its own dev and preview ports (`docs/josh-commands.md` →
+tree with its own branch, its own `.env` and its own dev and preview ports (`docs/josh-commands-automation.md` →
 "`josh lane:open` / `josh lane:close` / `josh lane:list` / `josh lane:prune`"). **Implementation, the
 verification gate and the review run in parallel; the merges stay serial** — each one lands on the
 `main` the next is then measured against.
@@ -76,12 +76,14 @@ verification are `pre-gate-cut.md`, the single source. **The child is told apart
 resume stage is handed to it, by a mark the dispatch sets** — `JOSH_LANE_CHILD`, the lane's issue
 number (`pre-gate-cut.md` → "The dispatch mark" and "The stage is passed to the resumed child").
 
-**One kind of child takes no lane beside anything: an interrupt whose subject is a defect in the
-verification path itself.** It runs alone, and the batch resumes only once it has merged. **Decide it
-from the enumeration, never from how serious it looks** — does the defect reach the verification gate
+**One kind of child takes no lane beside anything: a defect in kit's own verification that makes
+unrelated PRs answer wrongly on `main` today.** It runs alone, and the batch resumes only once it has
+merged. **Decide it from three conditions that must all hold, never from how serious it looks** — is
+it a defect (not an improvement, refactor, removal or feature)? Is it in kit's own verification gate
 (lint / type check / spell check / unit tests), the code review, the pre-push hook, or the merge
-checks? One of those, and the issue carries `run:solo`; none, and it carries `run:lane` and fills a
-lane like any other child. `backlog:next` and `epic:next --lanes` enforce both (joshuafolkken/kit#2776,
+checks — not a consumer repository's CI or template? Does it, on `main` now, make unrelated PRs
+answer wrongly (a false green or a false red)? All three, and the issue carries `run:solo`; any one
+missing, and it carries `run:lane` and fills a lane like any other child. `backlog:next` and `epic:next --lanes` enforce both (joshuafolkken/kit#2776,
 #2779). The rule is
 `prompts/collaboration-workflow/wip-cap.md` → 「実行のしかた」, its single source.
 

package/.claude/skills/workflow-commands/backlogrun-progress.md

@@ -48,7 +48,7 @@ for a whole interval (that exit says so on standard error). **Nothing in flight
 
 **`--mark` at every real report.** Whenever this loop reports something of its own — a child merged,
 parked, a stop — run `pnpm josh run:progress --mark` in the same turn to restart the silence clock. The clock is silence, never a timer
-(`docs/josh-commands.md` → "`josh run:progress`").
+(`docs/josh-commands-automation.md` → "`josh run:progress`").
 
 **Do not keep a progress clock of your own** — the hook refuses the arm rather than asking
 (`scripts/rules/early-heartbeat.ts` → `decide`), though **a single correctly-spaced arm is allowed**. It

package/.claude/skills/workflow-commands/backlogrun-steps.md

@@ -54,7 +54,7 @@ inside the invocation" below):
 | `--max` | how many issues one invocation may merge — a run's own filing competes for that number rather than extending it | `run:carry --merged` |
 | `--idle`, and the 8-hour whole-run bound | how long one invocation may go on looking for more | the record's `started_at` |
 | **Ten filings per invocation** | how much one invocation may add to the pool at all, on **every** filing route (`SKILL.md` → §2d) | `run:carry --filed` |
-| The WIP cap of 30 open issues | how large the pool may become, across invocations | `prompts/collaboration-workflow/wip-cap.md` |
+| The WIP cap on open issues | how large the pool may become, across invocations | `prompts/collaboration-workflow/wip-cap.md` |
 
 One invocation may add at most ten issues to the pool and merge at most `--max` of them, after which
 the run ends and the next one waits for a person to type the keyword.
@@ -140,7 +140,7 @@ be answered and every standing record is refused rather than resumed. A live PID
 the sandbox cannot read is held as `busy`.
 
 **Ask it before the plan, in the same turn as the first `git switch main && git pull`.** The contract
-is `docs/josh-commands.md` → "`josh run:carry`"; what this loop does with each answer is here:
+is `docs/josh-commands-automation.md` → "`josh run:carry`"; what this loop does with each answer is here:
 
 | It answers   | What the run does                                                                                                                                                                                                          |
 | ------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
@@ -233,7 +233,7 @@ expired or cannot be read ends it the same way. `none` — the run having finish
 
 **A person keeps control of it.** `pnpm josh run:wake --list` names the running supervisor and
 `--stop` ends it; the full contract, what it launches and why that is a constant rather than a
-setting are `docs/josh-commands.md` → "`josh run:wake`".
+setting are `docs/josh-commands-automation.md` → "`josh run:wake`".
 
 **Every unattended role runs with the provider selected from the invoking CLI and its own profile.**
 Codex sessions use OpenAI; Claude Code sessions use Anthropic. Anthropic uses scheduler
@@ -244,7 +244,7 @@ and legacy `JOSH_LANE_*` values to the worker only. Invalid configuration, a mis
 session marker, or a missing, outdated or unauthenticated CLI refuses without fallback, promotion or
 worker retry. `run:wake --list`, `lane:list`, the review brief and each launch
 log expose the resolved provider, role, model and effort.
-`docs/josh-commands.md` → "`josh lane:dispatch`" and `backlogrun-child.md` → "Each child runs in a
+`docs/josh-commands-automation.md` → "`josh lane:dispatch`" and `backlogrun-child.md` → "Each child runs in a
 delegated unit" are the single sources.
 
 **It relays progress from the existing report record.** The driver keeps the same `run:merge` event
@@ -301,10 +301,10 @@ stop at a time.**
   never the body.
 - **Order and isolate the pool in the same pass** (joshuafolkken/kit#2776), from the same
   `issue:read`: an issue that must land first (it builds what another reuses, or both edit one code
-  path) becomes a native `blocked-by`; an issue the `wip-cap.md` → 「実行のしかた」 enumeration hits
-  gets `run:solo`, **every other one `run:lane`**. Comment the reason; the offer commands enforce all
+  path) becomes a native `blocked-by`; an issue meeting all three of the `wip-cap.md` → 「実行のしかた」
+  conditions gets `run:solo`, **every other one `run:lane`**. Comment the reason; the offer commands enforce all
   three, answering `triage` while an issue has neither.
-- **`priority:high` puts an issue first** (joshuafolkken/kit#2928; ranking: `docs/josh-commands.md` →
+- **`priority:high` puts an issue first** (joshuafolkken/kit#2928; ranking: `docs/josh-commands-automation.md` →
   `josh backlog:next`). Apply it only on a cited ground — a stated deadline or urgency, or a person's
   written policy — commenting the ground; **never remove it**.
 - **Report the order those labels produce — `pnpm josh backlog:plan --waves`** (joshuafolkken/kit#2778),
@@ -342,7 +342,7 @@ follow, one per line.** `backlog:offer` forwards `--exclude` and `--repo` to `ba
 in `--json`. **The verdict table is "The two budgets" below; the answer-to-word mapping it applies is
 this section's table.**
 
-**`backlog:next`'s output contract is `docs/josh-commands.md` → "`josh backlog:next`", and four parts
+**`backlog:next`'s output contract is `docs/josh-commands-automation.md` → "`josh backlog:next`", and four parts
 of it decide how the mapping is written:**
 
 1. **Standard output is one token per line, and everything else is standard error.**
@@ -398,7 +398,7 @@ records.
 blocker sits in another opted-in epic — or is an opted-in standalone issue — makes the child wait on
 time, so one `backlogrun` runs both epics in that order. A blocker outside the opted-in backlog, or one
 inside it that itself waits on a person, makes the child wait on a person instead, and a cycle across
-epics answers `error`. The table is `docs/josh-commands.md` → "`josh epic:next`".
+epics answers `error`. The table is `docs/josh-commands-automation.md` → "`josh epic:next`".
 
 **New work is picked up without restarting anything.** The command re-derives its pool from GitHub
 labels on every ask, so an issue filed and opted in while the run is going is offered on the next
@@ -466,7 +466,7 @@ again at its full budget. Both are ISO-8601 timestamps (`date -u +%FT%TZ`), and
 `--active` is refused. `--merged` is what has merged and `--running` what is still in a lane; **both
 count against the maximum**. **No ending abandons a lane**: whatever would have ended the run answers
 `watch` while `--running` is above zero, so the lanes drain and their merges reach the report. The full
-contract is `docs/josh-commands.md` → "`josh backlog:budget`".
+contract is `docs/josh-commands-automation.md` → "`josh backlog:budget`".
 
 **The completion report names three things the budgets make meaningful**: how many issues this run
 took, how many of them were picked up during an idle watch, and the termination reason — quoted from

package/.claude/skills/workflow-commands/backlogrun.md

@@ -48,8 +48,8 @@ Each step is a terse trigger and a pointer; the procedure is read on demand from
    that bounds the amount. `auto-ok` is a person's alone.
 4. **Report the plan before the first child** — `pnpm josh backlog:plan`, then resolve every
    `needs-decision` issue decidable from its body in one pass. In the same pass, record `blocked-by`
-   between issues that must land in order, and apply `run:solo` where the verification-path
-   enumeration holds, `run:lane` elsewhere. `backlogrun-steps.md` → "The plan,
+   between issues that must land in order, and apply `run:solo` where all three of the
+   `wip-cap.md` → 「実行のしかた」 conditions hold, `run:lane` elsewhere. `backlogrun-steps.md` → "The plan,
    before the first child starts" and its "Resolve what the plan can resolve, before starting".
 5. **Named issues run first, in order** — `backlogrun-steps.md` → "Named issues run first, in order":
    the supervisor's driver dispatches each as a delegated `fullrun`, one at a time, then drains the

package/.claude/skills/workflow-commands/chain-rule.md

@@ -7,8 +7,10 @@ Review results and successful pushes are never turn boundaries.
 
 0. **A lane child** (#2428): `pnpm josh main:merge`, the scoped pair, `pnpm josh ship --detach --review
    "<title> #<N>"` (`--cite <N>`), then **end the turn** on `launched`/`busy`. A stop relaunches a child
-   whose `run:step` names `ship --log <N>`: fix, re-detach (`--review` only if no round is recorded,
-   else step 4). `failed` → step 1.
+   whose prompt names `pnpm josh ship --log <N>` and (Anthropic lane, #2964) the re-detach to run after
+   the fix — `pnpm josh ship --detach`, `--review` only if the stopped ship carried it and stopped before
+   round 2, which is final (`scripts/run/run-ship-next.ts`); the supervisor skips a recorded round 1.
+   `failed` → step 1.
 1. Run `pnpm josh main:merge`. **Then issue `pnpm josh run:cut <N>` alone, before the scoped pair and
    the gate** — the pre-gate cut (a no-op outside a lane, joshuafolkken/kit#2177). Then run the final scoped lint/test pair and `pnpm josh run:review`: it starts
    `pnpm josh gate` in the background and prints the `/code-review` brief in one call, so the two overlap

package/.claude/skills/workflow-commands/delegation.md

@@ -17,13 +17,13 @@ pnpm josh delegate --list   # the enumeration, and what was rejected and why
 **how a wrong result is caught** cheaply in the parent tier, not merely by being unlikely to fail.
 `pnpm josh delegate --list` names both delegatable and rejected steps; a rejected step either has no
 verifier or lets a wrong result propagate too far. The command distinguishes `kept deliberately`
-from `kept by default`. `docs/josh-commands.md` → "`josh delegate`" carries the full enumeration.
+from `kept by default`. `docs/josh-commands-automation.md` → "`josh delegate`" carries the full enumeration.
 
 **The mechanism is not the unit.** `pnpm josh delegate` covers a run step, a file-disjoint Step 0
 implementation unit (`pnpm josh fanout`), and `epic-child` — an epic's child and a named issue of a
 `backlogrun` alike. Do not add a second batch-child mechanism. Read `backlogrun-child.md` → "Each child
 runs in a delegated unit" at child dispatch; `backlogrun-steps.md` → "Named issues run first, in order"
-applies to named issues. `docs/josh-commands.md` → "`josh fanout`" carries file-disjoint dispatch.
+applies to named issues. `docs/josh-commands-automation.md` → "`josh fanout`" carries file-disjoint dispatch.
 
 **`followup-filing` delegates the late review-finding filing chain** with the parent's finding text;
 the parent verifies the new Issue using `pnpm josh issue:state <new>`. For `epic-child`, the parent
@@ -41,7 +41,7 @@ a temporary probe script and return its output.
 delegate the unread investigation. Brief the unit on what was already read; do not re-read it there.
 **A delegation resets the counter rather than spending it**; `pnpm josh investigation:guard` counts
 unedited files and refuses the threshold read. `pnpm josh delegate --list` prints the threshold.
-`docs/josh-commands.md` → "`josh investigation:guard`" carries the command's counting details.
+`docs/josh-commands-automation.md` → "`josh investigation:guard`" carries the command's counting details.
 
 **The main line does not idle while the unit reads:** read files this run will edit, then verify the
 unit's cited lines. Independent investigations launch together; a brief that needs another unit's

package/.claude/skills/workflow-commands/followup-reference.md

@@ -115,4 +115,4 @@ pnpm josh release:scope --json   # the same answer as one JSON object
 
 **`pnpm josh release --dry-run` was checked first and does not answer this.** It refuses off the default branch and on a dirty working tree, and it counts against `HEAD` rather than `origin/<default>` — and every position above is a feature branch or a lane, which is exactly where it throws. So `release:scope` adds **no counting of its own**: it reads `git_followup_pending.read_pending`, the same fetch-then-count `pnpm josh followup` already uses for the Telegram line, and the two therefore cannot disagree.
 
-**This section is the single source.** `fullrun.md`, `backlogrun.md` and `backlogrun.md` point here rather than restating it, and `docs/josh-commands.md` → "`josh release:scope`" documents the command itself.
+**This section is the single source.** `fullrun.md`, `backlogrun.md` and `backlogrun.md` point here rather than restating it, and `docs/josh-commands-automation.md` → "`josh release:scope`" documents the command itself.

package/.claude/skills/workflow-commands/followup.md

@@ -19,7 +19,10 @@ bullets. Use the file option whenever it contains a command or path.
 
 It waits for required CI, checks CodeRabbit and top-level AI review comments, sends the completion
 Telegram, merges by default, posts the Issue report, closes completed epics, removes `in-progress`,
-and releases the hold. Only `--no-merge` stops the merge; `--merge` is a deprecated no-op. Keep the
+and releases the hold. Only `--no-merge` stops the merge; `--merge` is a deprecated no-op. **A pull
+request already merged by hand** (a `prrun` stop, joshuafolkken/kit#3023) skips the CI wait, the AI
+review scan and the merge and runs only the post-merge tail; a completion report already on the Issue
+is not posted or notified twice, so re-running is safe. Keep the
 default Issue target. Ignore a finding only after verifying it is inapplicable; rate-limit text is not
 a finding.
 
@@ -174,8 +177,9 @@ pnpm josh ms
   Review findings before merging. If blockers are found, it sends a `confirmation` Telegram and exits
   non-zero — fix the findings and re-run. **Green CI is not authorization to merge while AI review
   findings are open.** (SonarCloud findings are not scanned by `followup`; the `sonar-qube.yml` CI
-  workflow runs the scan with `sonar.qualitygate.wait=true`, so a red Quality Gate fails the required
-  `SonarQube` check, which `followup` waits on.)
+  workflow runs the scan with `sonar.qualitygate.wait=true` and then `josh sonar:new-code`, so a red
+  Quality Gate or a single new Sonar issue or duplicated block fails the required `SonarQube` check,
+  which `followup` waits on.)
 - **CodeRabbit rate-limit is not a finding.** If the only CodeRabbit comment is a rate-limit warning
   (`rate limited by coderabbit.ai` or `Rate limit exceeded`) and there is no substantive review, treat
   it as "no findings" and proceed. Same if CodeRabbit produced no comment on the latest commit.

package/.claude/skills/workflow-commands/fullrun-steps.md

@@ -26,7 +26,7 @@ in outline: refactor → `pnpm josh main:merge` → **a dispatched lane child ha
 joshuafolkken/kit#2428) → otherwise `pnpm josh run:cut <N>` (the pre-gate cut, before the gate; a no-op
 outside a lane) → start `pnpm josh gate` and a subagent `/code-review`
 with the brief `pnpm josh review:brief` prints on `git diff main`, join the gate before the commit,
-iterate to no high/medium findings, at most two reviews → **the clean path folds the ship region into
+iterate to no high/medium findings, within the round cap (`prompts/review.md`) → **the clean path folds the ship region into
 one call**, `pnpm josh ship "<title> #<N>"` (gate → commit/push/PR → the CI-wait `followup` → the
 `run:tail` report bookkeeping, stopping at the first failed step; joshuafolkken/kit#2398), with any
 branch-2 filing (`pnpm josh issue:file`, which runs `epic:bundle` itself) run before it → **when a second round is due `ship` does not
@@ -44,7 +44,8 @@ implementation summary via `--notify-message` in the session language, leading w
 plain-language lines: `"Implemented <title>\nCause: ...\nFix: ...\nResult: ...\n\nDetails:\n-
 <change1>\n- <change2>"`. **`pnpm josh followup` waits for CI, verifies AI review findings, sends the
 completion notification, then merges; if blockers are found it exits non-zero — fix and re-run.**
-**マージ後に `pnpm josh ms` を実行する。** Codex レーンでは省略し、親の `run:merge` が主チェックアウトで同期する。Claude は従来どおり。
+**Run `pnpm josh ms` after the merge.** A Codex lane skips it — the parent's `run:merge` syncs the
+primary checkout; a Claude run keeps it.
 
 ## The `fullrun new` step list
 

package/.claude/skills/workflow-commands/fullrun.md

@@ -21,7 +21,7 @@ single sources). Step 2 — the `in-progress` label — stays its own call, appl
 call reports `hold`.
 
 1. **Claim the working tree — first, before anything else.** For `fullrun #N`, first run the folded
-   `pnpm josh run:entry <N>` above; it calls `run:hold` as its first step. For `fullrun new`, call
+   `pnpm josh run:entry <N>` above (no `--to` is `fullrun`, §2k); it calls `run:hold` as its first step. For `fullrun new`, call
    bare `pnpm josh run:hold`, ahead of the title and filing. `hold` continues; `busy` / `unknown` stop
    with a `confirmation` Telegram carrying stderr.
    `working-tree-hold.md` is the single source; a cross-repository target resolves its checkout from
@@ -63,7 +63,8 @@ call reports `hold`.
   boundary — immediately after `pnpm josh main:merge`, before the gate — it takes the cut with
   `pnpm josh run:cut <N>` (the ordered step in `chain-rule.md`), and it records any park on the Issue before the stop notify.
   `pre-gate-cut.md` is the single source of both.
-- **`resume: halfrun`** adopted a stopped `halfrun` (#2796): gate in full; `working-tree-hold.md`.
+- **`resume: halfrun`** adopted a stopped `halfrun` (#2796): gate in full; `resume: prrun-*` a stopped
+  `prrun` (#3023); `working-tree-hold.md`.
 
 ## The stop branches
 

package/.claude/skills/workflow-commands/halfrun.md

@@ -4,51 +4,48 @@ When this run files a new Issue, file it with `pnpm josh issue:file`, which lint
 
 `halfrun` sits between `kickoff` (plan only) and `fullrun` (full execution with auto-merge). It
 implements the change and runs the full verification gate, then **stops before commit** — nothing is
-committed, pushed, or opened as a PR — so the user manually verifies the change (typically by exercising
-the UI in a browser) against the working tree. Use `halfrun` when the change has UI/UX implications or
-anything else that requires human eyes before shipping.
+committed, pushed, or opened as a PR — so a person verifies the working tree by hand. Use it when a change needs human eyes before shipping.
 
-**This file is the manifest** (joshuafolkken/kit#2189): the ordered steps as terse triggers and
-pointers, the detail read on demand from the file each pointer names.
+**This file is the manifest** (joshuafolkken/kit#2189): terse ordered steps, each pointing at the file
+that holds its detail.
 
 ## The ordered entry sequence
 
-1. **Claim the working tree first** — `pnpm josh run:hold <N>` (bare for `halfrun new`), ahead of the
-   title and a `new` entry's filing; `busy` / `unknown` stop with a `confirmation` Telegram. **The stop
-   before commit keeps the hold** (the uncommitted work is what a second run would trample); a stop on a
+1. **Claim the working tree first** — `pnpm josh run:entry <N> --to halfrun` (bare `pnpm josh
+   run:hold` for `new`), ahead of the title and a `new` filing; it folds steps 3 and 5 and starts
+   at its stage line's `start:` (`SKILL.md` → §2k). `busy` / `unknown` stop with a `confirmation` Telegram. **The stop
+   before commit keeps the hold** (a second run would trample the uncommitted work); a stop on a
    split, prerequisite or third-party target releases it. `working-tree-hold.md` is the single source; a
    cross-repository target resolves its checkout from `pnpm josh doctor` first (`target-repository.md`).
 2. **Apply `in-progress` the moment `run:hold` answered `hold`** — the stop before commit keeps it on;
    a stop that leaves the tree clean removes it in the same turn as `pnpm josh run:release` (`gh api -X
    DELETE repos/{owner}/{repo}/issues/<N>/labels/in-progress 2>/dev/null || true`).
-3. **Ask the session boundary in the same turn as the hold** — `pnpm josh cost --cut`, exactly as
-   `fullrun`; `over` stops with a `confirmation` Telegram and the resume command (`halfrun #<N>` /
+3. **Ask the session boundary** — `pnpm josh cost --cut` (folded into `run:entry`); `over` stops with a `confirmation` Telegram and the resume command (`halfrun #<N>` /
    `halfrun new`). **Skip it when dispatched by a batch.** `backlogrun-progress.md` → "The hand-off" is
    the single source of the check and the shared 135,000 threshold.
 4. **Start the progress watcher once the hold is claimed** — `pnpm josh run:progress --wait` in the
    background, `--mark` in the same turn as every real report; the stop before commit ends the watcher
    itself (`backlogrun-progress.md` → "Progress while the run is quiet").
-5. **Gather the mechanical reads — `pnpm josh run:prep <N>`** (`issue:read`'s body/comments — `SKILL.md`
-   → §2g → `issue-comments.md`; `issue:state`'s `human_review`; `latest:scope`), then `pnpm josh
-   run:next <N>`.
+5. **The mechanical reads** — `run:entry` folds `run:prep` (body/comments — `SKILL.md` → §2g;
+   `human_review`; `latest:scope`); a `new` entry runs `pnpm josh run:prep <N>` once filed.
 
 ## The step list
 
 `halfrun #<N>`: add `in-progress` → read Issue #N and its comments → **normalize the title** (same as
 `fullrun`) → post the agreed plan only if the body is blank → `git switch main && git pull`, then `pnpm
-josh latest:scope` and update dependencies only on `required` (`latest-gate.md`; load the
-`dependency-update` skill on `required`) → implement → run the **full verification gate** (refactor →
+josh latest:scope` and update dependencies only on `required` (`latest-gate.md`; the
+`dependency-update` skill) → implement → run the **full verification gate** (refactor →
 start `pnpm josh gate` beside a subagent `/code-review` with the brief `pnpm josh review:brief` prints,
-join the gate before the stop, iterate to no high/medium findings, at most two reviews → `pnpm josh
+join the gate before the stop, iterate to no high/medium findings, within the round cap (`prompts/review.md`) → `pnpm josh
 test:e2e`, run by **you**, because `halfrun` opens no pull request and there is no CI E2E job; a printed
 skip is the answer where the project has no suite) → **mark the stop: `pnpm josh run:hold <N>
 --halfrun-stop`** (the record `fullrun #<N>` adopts; `new` passes the filed number) → send a
 `confirmation` Telegram with the resume commands in the body → **stop**. Plan comments are in the session language. The `confirmation` Telegram
-body MUST include the exact resume commands — **`fullrun #<N>` first**, since that is how a verified
+body MUST include the exact resume commands — **the `Next:` line first**, since that is how a verified
 `halfrun` ships (joshuafolkken/kit#2796): its `run:entry` adopts this stop's marked hold and resumes at
 the gate. The direct commands follow for shipping without an agent:
 `pnpm josh notify --task-type confirmation --issue-url "<issue-url>" --body=$'halfrun ready for manual
-verification\nNext: fullrun #<N>\nWithout an agent: pnpm josh git -y "<title> #<N>" && pnpm josh
+verification\nNext: prrun #<N> | fullrun #<N>\nWithout an agent: pnpm josh git -y "<title> #<N>" && pnpm josh
 followup "<title> #<N>" --notify-message "Implemented <title>\\nCause: ...\\nFix: ...\\nResult:
 ...\\n\\nDetails:\\n- <change1>"'`. The stop report names the same two, in the same order.
 **Invoking `halfrun` is _not_ authorization to commit, push, or merge** — do not run `pnpm josh git -y` or `pnpm josh followup` yourself. If the user comes
@@ -72,7 +69,7 @@ Telegram and **stop**.
 - **A split** — the assessment (`split-assessment.md` → "The question") finds two or more
   separately-mergeable deliverables over one gate: file the children (each `route:split`) and the epic,
   then **STOP** with "Please run `backlogrun #<E> --only` to execute this epic." Typing `halfrun`
-  authorized implementing **one** Issue and stopping for manual verification, never a batch.
+  authorized **one** Issue, never a batch.
 - **A prerequisite** — file it (`route:tier-a`), stash, record the dependency, and **STOP**;
   `prerequisite.md` is the single source of the filing, the `-u` stash and the epic:bundle branch.
 - **An observation** — file it without asking and carry on; `SKILL.md` → §2i.

package/.claude/skills/workflow-commands/issue-comments.md

@@ -66,7 +66,7 @@ procedure and not two. **Parking it is not the place**: `needs-decision` means "
 nobody has given", and here the answer exists.
 
 **The exit is the `already-done` label.** It is `needs-decision`'s counterpart: `epic:next`,
-`backlog:next` and `auto-ok:next` all stop offering the Issue (`scripts/git/issue-labels.ts` →
+`backlog:next` and `auto-ok:next` all stop offering the Issue (`scripts/issue/issue-labels.ts` →
 `NOT_DIRECTLY_RUNNABLE_LABELS`, `epic-classify.ts` → `human`), and `epic:busy` stops counting it as
 holding a lane. **Only a person removes it, by closing the Issue.**
 

package/.claude/skills/workflow-commands/issue-fold-existing.md

@@ -1,20 +1,20 @@
-# 未着手 Issue への追加要件の統合
+# Folding added requirements into an unstarted Issue
 
-## 候補の読み取り
+## Reading the candidates
 
-起票予定の目的・要件・受け入れ条件を含む全文を `pnpm josh issue:scout "<title>" --body-file <draft.md>` に渡す。明示的に参照した `#N` は見出しが似ていなくても候補になる。`Duplicates: incomplete` は読み取りまたは探索の不足であり、候補なしという結論ではない。
+Pass the whole draft — purpose, requirements and acceptance criteria — to `pnpm josh issue:scout "<title>" --body-file <draft.md>`. An explicitly referenced `#N` is a candidate even when its title looks unrelated. `Duplicates: incomplete` means the read or the search fell short; it is not a conclusion that no candidate exists.
 
-候補の本文とコメントを `pnpm josh issue:read <N>` で全て読み、状態とラベルを `pnpm josh issue:state <N>` で読む。紐づく PR と依存・実行順も調べる。本文と後のコメントが矛盾した場合は後のコメントを採る。読み取り失敗や打ち切りがあれば統合可否は未確定とする。
+Read each candidate's body and every comment with `pnpm josh issue:read <N>`, and its state and labels with `pnpm josh issue:state <N>`. Check the linked PRs and the dependencies and run order too. When the body and a later comment disagree, the later comment wins. A failed or truncated read leaves the fold decision undetermined.
 
-## 判定
+## Deciding
 
-下書きの各受け入れ条件を既存 Issue と照合する。完全な重複は起票も編集もしない。別の成果物は従来の起票経路を使う。固有の追加要件を統合できるのは、既存 Issue が open かつ未着手で PR がなく、依存と実行順に衝突がなく、合計の規模が `split-assessment.md` → "The question" の一回の検証に収まる場合に限る。状態または判断材料が不明なら統合しない。
+Match each acceptance criterion of the draft against the existing Issue. A complete duplicate is neither filed nor edited. A separate deliverable takes the ordinary filing path. Added requirements of its own may be folded in only when the existing Issue is open and unstarted with no PR, its dependencies and run order do not conflict, and the combined size fits the one verification pass of `split-assessment.md` → "The question". When the state or any input to the decision is unknown, do not fold.
 
-判定記録の JSON を作り、`pnpm josh issue:fold-existing <assessment.json> --json` を実行する。`content` は `duplicate` / `compatible` / `separate` / `unknown`、`size_verdict` は `single` / `split` とする。ほかに `is_open`、`is_unstarted`、`has_pull_request`、`has_complete_read`、`has_dependency_conflict`、`is_separable`、`existing_body`、`draft_body`、`verification` を記録する。不明な事実は省略し、`inspect` を得る。判定記録は読んだ証跡であり、読み取りそのものの代わりにはならない。
+Write the assessment as JSON and run `pnpm josh issue:fold-existing <assessment.json> --json`. `content` is `duplicate` / `compatible` / `separate` / `unknown`, and `size_verdict` is `single` / `split`. Also record `is_open`, `is_unstarted`, `has_pull_request`, `has_complete_read`, `has_dependency_conflict`, `is_separable`, `existing_body`, `draft_body` and `verification`. Omit a fact you do not know, and the answer is `inspect`. The assessment is evidence of the reading, never a substitute for it.
 
-## 追記と再読
+## Appending and re-reading
 
-`fold` の場合、追記案の `body` は元の本文を保持し、固有の追加要件と検証方法を末尾に加える。書き込み直前に本文とコメントが判定時から変わっていないことを再確認する。変わっていれば再判定する。
+On `fold`, the proposed `body` keeps the original body and appends the added requirements and how to verify them. Immediately before writing, confirm the body and comments have not changed since the assessment; if they have, assess again.
 
 ```bash
 pnpm josh issue:fold-existing assessment.json --json > result.json
@@ -24,4 +24,4 @@ gh api -X PATCH repos/{owner}/{repo}/issues/<N> --input patch.json
 pnpm josh issue:read <N>
 ```
 
-再読して、元の要件・コメント中の判断記録・追加要件・検証方法が残ることを確認する。書き込みまたは再読が失敗した場合、統合は完了していない。統合時は新しい Issue を作らない。`separate` は従来の起票経路へ戻り、`inspect` は不足した情報を読み直す。
+Re-read it and confirm the original requirements, the decisions recorded in comments, the added requirements and the verification all remain. A failed write or re-read means the fold is not complete. A fold never creates a new Issue. `separate` returns to the ordinary filing path, and `inspect` re-reads the missing information.