@joshuafolkken/kit 1.2116.0 → 1.3000.0

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

@@ -7,13 +7,12 @@ Read before implementing a `#N` Issue.
 turn as whatever else the run needs:
 
 ```bash
-pnpm josh issue:read <N> [<N> ...]     # body and comments, one call per batch
-gh api repos/<owner>/<repo>/issues/<N>/comments --jq '.[] | {user: .user.login, created_at, body}'
+pnpm josh issue:read <N> [<N> ...]                       # body and comments, one call per batch
+pnpm josh issue:read <N> [<N> ...] --repo <owner/repo>   # an Issue in another repository
 ```
 
-**Type the first line**; it **says when a comment listing could not be read rather than showing no
-comments**. The `gh api` form is **cross-repository only** (the command takes no `--repo`); a read
-of this repository's Issue, its comments or its timeline — `repos/{owner}/…` or the repository
+The command **says when a comment listing could not be read rather than showing no comments**. A raw
+read of this repository's Issue, its comments or its timeline — `repos/{owner}/…` or the repository
 spelled out, and `gh issue view` — is refused (`pnpm josh rule:list` → `direct-issue-read`).
 
 An Issue whose author has no write access stops at `run:entry` until a person with write access
@@ -37,7 +36,7 @@ what.
   the body's criteria say; name the Issue it went to in the completion report.
 - **A comment saying the Issue no longer has a reason to exist** — the defect does not reproduce, or it
   was fixed elsewhere — takes the exit in "When the work turns out to be already merged". Closing an
-  Issue is Tier C.
+  Issue any other way is Tier C.
 
 Everything else, **a widened scope included**, is ordinary work; a widening into several
 separately-mergeable deliverables is the split assessment's business (`split-assessment.md`).
@@ -48,31 +47,46 @@ separately-mergeable deliverables is the split assessment's business (`split-ass
 satisfied in merged code — one procedure either way. **Parking it is not the place**: `needs-decision`
 means "waiting for an answer", and here the answer exists.
 
-**The exit is the `already-done` label.** `epic:next`, `backlog:next` and `auto-ok:next` stop offering
-the Issue (`scripts/issue/issue-labels.ts` → `NOT_DIRECTLY_RUNNABLE_LABELS`, `epic-classify.ts` →
-`human`), and `epic:busy` stops counting it. **Only a person removes it, by closing the Issue.**
+**The exit applies the `already-done` label, then closes the Issue as `completed` when a cited pull
+request reads back as merged or `origin/main` contains a cited commit SHA**
+(`scripts/issue/already-done-citation.ts`); the label stays, and a
+reopen undoes the close. **Anything else leaves it OPEN with the label**, the reason printed:
+`epic:next`, `backlog:next` and `auto-ok:next` stop offering the Issue
+(`scripts/issue/issue-labels.ts` → `NOT_DIRECTLY_RUNNABLE_LABELS`, `epic-classify.ts` → `human`),
+`epic:busy` stops counting it, and a person closes it.
 
 **Commit nothing, push nothing, open no pull request** — run one command; it posts the evidence,
-applies `already-done` and releases the hold, in that order, stopping at the first failure:
+applies `already-done` and closes the Issue when the citation checks, and releases the hold, in that
+order, stopping at a failed comment or label; a failed close leaves the labelled Issue OPEN and
+still releases the hold:
 
 ```bash
-pnpm josh issue:already-done <N> --evidence-file <path>
+pnpm josh issue:already-done <N> --evidence-file .josh/tmp/evidence.md
 ```
 
 **The evidence file names the merging pull request or commit and, per acceptance criterion, the
 `file:line` that satisfies it.** **A claim with no citations is not the finding this exit is for.**
 
-Then behave as the entry point does for a parked child: a typed `fullrun` / `halfrun` sends a
-`confirmation` Telegram naming the Issue and the covering merge, and stops; a `backlogrun` child is
-park-and-continue (`backlogrun-park.md` → "park and continue"). **Never close the Issue** — Tier C.
+A closed Issue ends the run. A labelled one is handled like a parked child: a typed `fullrun` /
+`halfrun` sends a `confirmation` Telegram naming the Issue and the covering merge, and stops; a
+`backlogrun` child is park-and-continue (`backlogrun-park.md` → "park and continue"). **Never close
+it by any other path** — Tier C.
 
 **Looking familiar is no license to skip the work**: a criterion you cannot point at merged code for is
 one this run still owes.
 
+## When a declared close condition holds
+
+The body's `## 背景` declares `- 中止条件:` and the run's finding meets it → before any commit, run
+`pnpm josh issue:premise-unmet <N> --evidence-file .josh/tmp/premise-unmet.md` with the measured
+values and the reason (refusals: `scripts/issue/issue-premise-unmet-cli.ts`).
+
+With no declared line, a judgement that the work is not worth doing still parks.
+
 ## A measurement-only Issue
 
 **Every criterion is a measurement, so no pull request closes it** → `pnpm josh issue:measured <N>
---evidence-file <path>` (per criterion, the result and its run), never a bare comment: an OPEN child is
+--evidence-file .josh/tmp/evidence.md` (per criterion, the result and its run), never a bare comment: an OPEN child is
 parked `run:stalled`. Invoking `fullrun` / `backlogrun` authorizes this close. `docs/josh-commands-backlog.md` → "`josh issue:measured`".
 
 ## A long thread

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

@@ -2,27 +2,22 @@
 
 ## Reading the candidates
 
-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.
+Pass the whole draft — purpose, requirements and acceptance criteria — to `pnpm josh issue:scout "<title>" --body-file .josh/tmp/body.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.
 
-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.
+First record the comment thread's token with `pnpm josh issue:fold-existing --fingerprint <N>`.
+
+Then 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
 
-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.
+Match each acceptance criterion of the draft against the existing Issue. A complete duplicate is not filed and its body is not 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.
 
-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.
+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`, `verification`, and `comment_fingerprint` as the token recorded before the read. `content`, `has_complete_read`, `existing_body`, `comment_fingerprint`, `draft_body` and `verification` are required; an assessment without one exits 1, and an unknown `content` is written `unknown`. Omit any other 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
 
-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.
+On a confirmed `duplicate` that stops Issue `<M>`, run `pnpm josh issue:fold-existing assessment.json --apply <N> --blocked <M>`. It records `<M>` as blocked by existing Issue `<N>` through the shared epic dependency recorder, including the tracking epic's declaration. It refuses a changed body or comment thread and reports a record failure with exit 1. Scout candidates, display-only assessment and a duplicate with no explicit stopped Issue write no dependency.
 
-```bash
-pnpm josh issue:fold-existing assessment.json --json > result.json
-jq -e '.verdict == "fold"' result.json
-jq '{body: .body}' result.json > patch.json
-gh api -X PATCH repos/{owner}/{repo}/issues/<N> --input patch.json
-pnpm josh issue:priority <N>
-pnpm josh issue:read <N>
-```
+On `fold`, run `pnpm josh issue:fold-existing assessment.json --apply <N>`. It keeps the original body, appends the added requirements and how to verify them, and writes only while the body still reads as `existing_body` and the comments as `comment_fingerprint`. It applies the body's priority floor (`issue-template.md` → F) and verifies the re-read. Any answer but `folded` means the fold is not complete; on `changed`, read and assess again. A fold never creates a new Issue. `separate` returns to the ordinary filing path, and `inspect` re-reads the missing information.
 
-A body edit applies no label: `pnpm josh issue:priority <N>` applies the body's floor (`issue-template.md` → F). 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.
+An independent requirement on lane `<M>` that folds into Issue `<N>` → `pnpm josh issue:fold-existing assessment.json --apply <N> --found-during <M>`; on `folded` it also records `<N>` as `<M>`'s split child (`docs/josh-commands-backlog.md` → "`josh issue:fold-existing`").

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

@@ -2,12 +2,11 @@
 
 Read this file when an Issue title exists and before the `pnpm josh issue:file` call that files it.
 Every filing asks whether the work already exists and which epic owns it; the command runs the
-`issue:scout` scan on the title and body first and holds the filing until every printed candidate is
-named in `--distinct`:
+`issue:scout` scan first and prints what holds the filing:
 
 ```bash
-pnpm josh issue:file "<title>" --body-file <complete-draft.md> [--route <route>]
-pnpm josh issue:file "<title>" --body-file <complete-draft.md> --distinct 2801,2795
+pnpm josh issue:file "<title>" --body-file .josh/tmp/body.md [--route <route>] [--over-cap]
+pnpm josh issue:file "<title>" --body-file .josh/tmp/body.md [--route <route>] [--over-cap] --distinct 2801,2795
 ```
 
 - **`Duplicates:` is read, not skimmed.** Open each candidate and apply `issue-fold-existing.md`
@@ -15,17 +14,15 @@ pnpm josh issue:file "<title>" --body-file <complete-draft.md> --distinct 2801,2
   Telegram and "Please run `fullrun #<existing>` to execute this Issue." A compatible addition follows
   that file's fold path; a separate deliverable follows the ordinary filing path. A title match alone
   never authorizes an edit.
-- **`--distinct` records that each candidate was read.** Reissue the call listing every candidate you
-  read and judged separate; never list one you have not read.
+- **`--distinct` names only candidates you read and judged separate.**
 - **A candidate marked `(closed)` is a different answer.** The scan covers what closed recently as
   well as what is open, because the work most likely to be filed twice is the work that just finished.
   A closed candidate that covers the same work means **the work is already done** — so there is nothing
   to run. Verify it against the merged code, then take the exit in `issue-comments.md` → "When the work
   turns out to be already merged". A closed candidate that does *not* cover the work is noted in one
   line, named in `--distinct`, and the filing carries on.
-- **`none` is an answer.** The command reports no candidate rather than the closest miss.
 - **`Epic:` front-loads the placement.** Its recommendation is `epic:bundle`'s, which makes
-  `add_to_epic` / `create_epic` Tier A and `ask` a stop, in exactly the reading `into-target.md`'s
+  `add_to_epic` / `create_epic` / `ask` Tier A, in exactly the reading `into-target.md`'s
   `into <target>` suffix would have given by hand. Where the user typed `into <target>`, that naming wins.
 - **`Epic: not asked` is not `Epic: none`.** The epic half decides from the issue numbers the body
   names in its acceptance criteria or its `parent: #N` line; a background mention does not count.

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

@@ -5,61 +5,52 @@
   1. Read Issue #N **and every comment on it** — `pnpm josh issue:read <N>`; the later text is the
      agreement in force (`issue-comments.md`, which also carries the answers that stop the run).
   2. Derive a clear English title.
-  3. Analyze requirements → **scope assessment per `split-assessment.md`**.
+  3. Analyze requirements → **scope assessment per `split-assessment.md` → "The question"**, exactly
+     as `kickoff new` does.
   4. **Record the plan** — written to a file in the session language (`JOSH_SESSION_LANG`, default
-     `ja`), then `pnpm josh issue:plan <N> --body-file <path> --title "<title>" --planned`: it renames
-     the issue, writes the plan into the body when it is blank and its author has write access (a
-     comment otherwise), and applies `run:planned`, so the next command's `run:entry` starts at the implementation. A target named in front of the reference
-     adds `--repo <owner/name>`. Before writing the plan, run `pnpm josh plan:consumers
-     <identifier...>` on what it adds or changes and finish the `### 影響を受ける既存の利用者` draft it
-     prints; `issue:plan` refuses a plan without it (`docs/josh-commands-backlog.md` → "`josh issue:plan`").
-  5. Send the Telegram notification, its last line `Next: halfrun #<N> | prrun #<N> | fullrun #<N>` →
-     **stop** (do not implement).
+     `ja`), then `pnpm josh issue:plan <N> --body-file .josh/tmp/plan.md --title "<title>" --planned`, which
+     records it, applies `run:planned` and sends the `planning` Telegram (`docs/josh-commands-backlog.md`
+     → "`josh issue:plan`"). A target named in front of the reference adds `--repo <owner/name>`.
+     Before writing the plan, run `pnpm josh plan:consumers <identifier...>` on what it adds or changes
+     and finish the `### 影響を受ける既存の利用者` draft it prints.
+  5. Report the plan, the Telegram's last line `Next: halfrun #<N> | prrun #<N> | fullrun #<N>`, then **stop** (do not implement).
 
-  **Two or more separately-mergeable deliverables** take the split path instead of a plan: rename `#N`
-  to the step-2 title (`gh api -X PATCH repos/{owner}/{repo}/issues/<N> -f title="<title>"` — neither
-  `issue:plan` nor `epic --promote` runs here to apply it), create the children as in `kickoff new`,
-  then either **promote `#N`** with `pnpm josh epic --promote <N> <N1> <N2>
-  ... [--ordered] [--rationale-file <path|->]` (when `#N` is a request, a discussion or a container), or
-  keep `#N` as a child and create a new epic with `pnpm josh epic`. That branch is Tier A: choose and
-  record the reasoning on the Issue. Present `backlogrun #<E> --only` and stop.
+  **Two or more separately-mergeable deliverables** take the split path instead of a plan: create the
+  children as in `kickoff new`, then either **promote `#N`** with `pnpm josh epic --promote <N> <N1> <N2>
+  ... --title "<title>" --notify [--ordered] [--rationale-file .josh/tmp/rationale.md]` (when `#N` is a request, a discussion
+  or a container) — `--title` renames it to the step-2 title — or keep `#N` as a child of a new epic
+  made with `pnpm josh epic … --notify`, renamed when its own plan is recorded (`issue:plan --title`). That branch is Tier A: choose and
+  record the reasoning on the Issue. Present `pnpm josh backlogrun <E> --only` and stop.
 
-  Telegram: `pnpm josh notify --task-type planning --issue-url "<issue-url>" --body=$'-
-  <bullet1>\n- <bullet2>\n...'`. `--task-type` sets the icon (`planning` 📋 / `completion` ✅ /
-  `failure` ❌ / `kickoff_retry` 🔄 / `confirmation` ⏸️); `--repo-name` and `--issue-title` are
-  auto-fetched. The Issue URL must be included.
+  `--notify` sends the split path's `planning` Telegram — the epic's URL, every child's URL and the
+  `backlogrun` line (`docs/josh-commands-backlog.md` → "`josh epic`").
 
 **`kickoff` does not claim the working-tree hold, and does not release one** — it touches GitHub, never
 the tree (`working-tree-hold.md`).
 
 **The target repository is named in front of the Issue reference** — `kickoff kit#new`,
-`kickoff joshuafolkken/kit#<N>` (`target-repository.md`). `kickoff` needs no checkout: name the target in
-every `gh api` path, reads included, and never clone. The exception is the split path's epic — `pnpm josh
+`kickoff joshuafolkken/kit#<N>` (`target-repository.md`). `kickoff` needs no checkout: name the target with
+`--repo <owner/repo>` on every `josh issue:read` and `issue:file` call, and never clone. The exception is the split path's epic — `pnpm josh
 epic` writes only the repository it runs in, and the promote arm stops when that repository is not
 checked out here. A third-party owner is Tier C: stop rather than file.
 
-**Read `split-assessment.md` → "The question" first** — `kickoff #N` assesses scope exactly as
-`kickoff new` does. The default is not to split: separability and a scope clearly over one verification
-gate must hold **together**. The rest of `split-assessment.md` is read when a split is found.
-
 - `kickoff new` or `kickoff new "<title>"`: (0) **Scope assessment** per `split-assessment.md` — one
   deliverable takes the **single-issue path**, several the **multi-issue split path**.
   - **Single-issue path**: (1) Derive an English title, or use the one given. (2) `pnpm josh issue:file
-    "<title>" --body-file <body-file>` plus the labels the words typed after `new` name
+    "<title>" --body-file .josh/tmp/body.md --over-cap` plus the labels the words typed after `new` name
     ("Words typed after `new`", below; body per `prompts/collaboration-workflow/issue-template.md`) —
     its duplicate scan runs first, and a candidate covering the same work stops the run (`SKILL.md` →
-    `issue-scout.md`). Capture `<N>`. (3) Post the plan as `kickoff #<N>` does. (4) Telegram. (5)
+    `issue-scout.md`). Capture `<N>`. (3) Post the plan as `kickoff #<N>` does — its `--planned` sends the Telegram. (4)
     **Stop**.
   - **Multi-issue split path**: (1) Per deliverable, `pnpm josh issue:file "<sub-title>" --body-file
-    <body-file> --route split` plus the labels the words after `new` name (duplicate scan
+    .josh/tmp/body.md --route split` plus the labels the words after `new` name (duplicate scan
     per `issue-scout.md`). A split filed into another repository gives every child body the `## Origin`
     backlink, the epic the same link as prose (never a checkbox row, which disables its auto-close), and
     the originating Issue lists children and epic under `## Upstream issues`. (2) **Epic — always, for
-    every split into two or more Issues**: `pnpm josh epic "<epic-title>" <N1> <N2> ... [--ordered]
-    [--rationale-file <path|->] [--origin <owner/repo#N>]`, capturing `<E>`. It builds the `epic` label,
-    the task-list rows (`- [ ] #N`), the machine-readable `Dependencies` and the `backlogrun` line; check
-    a hand-edited epic with `pnpm josh epic:check <E>`. (3) Telegram listing every created Issue. (4)
-    Present `backlogrun #<E> --only`. (5) **Stop**.
+    every split into two or more Issues**: `pnpm josh epic "<epic-title>" <N1> <N2> ... --notify [--ordered]
+    [--rationale-file .josh/tmp/rationale.md] [--origin <owner/repo#N>]`, capturing `<E>`; check a hand-edited epic
+    with `pnpm josh epic:check <E>`. (3) `--notify` sends the Telegram listing every created Issue.
+    (4) Present `pnpm josh backlogrun <E> --only`. (5) **Stop**.
 
   **The epic itself is never implemented** — `backlogrun` runs its *children*, and it closes itself
   once every child is closed, whichever josh path closes the last one. Children with no required order take `None — the children are

package/.claude/skills/workflow-commands/latest-gate.md

@@ -14,30 +14,22 @@ pnpm josh latest:scope   # → required | skip ; the reason on stderr
 **The input is when `josh latest` last finished in this checkout, and nothing else** — never a
 judgement that the dependencies are probably still fresh.
 
-- **No record answers `required`.** A fresh checkout, a cleared temp directory, a run that fell over
-  halfway — every one of them lands there, and none of them is evidence that anything is current.
+- **No record answers `required`.**
 - **The record is written by `josh latest` itself**, as the last step of its chain, so a chain that
-  failed leaves nothing behind and the next run updates again.
-- **The window is 12 hours**, moved in either direction by `JOSH_LATEST_MAX_AGE_HOURS`. A value that
-  is not a positive number falls back to the default rather than disabling the update.
-- **The record is per checkout.** An epic that spans repositories updates each one on its own
-  schedule.
+  failed leaves nothing behind.
+- **The window is 12 hours**, moved by `JOSH_LATEST_MAX_AGE_HOURS` (a non-positive value falls back to 12).
 
 ## What runs when the answer is `required`
 
 ```bash
-pnpm josh latest:if-required   # stash → josh latest → pop by message; nothing on `skip`
+pnpm josh latest:if-required   # stash → josh latest → pin check → pop by message; nothing on `skip`
 ```
 
 It asks `latest:scope` itself, so a run reads `run:prep`'s `latest:` line and never asks again. A
 failed update or a conflicted pop stops with the stash kept and names the pop to run.
 
-Then **load the `dependency-update` skill and follow its procedure** — the overrides in **both**
-`pnpm-workspace.yaml` and `package.json`, and the one expected `devEngines` pnpm bump — in every run in
-which `josh latest` actually ran; never report the pins intact without having run it.
-
-**On `skip`, the command does nothing** and the `dependency-update` skill is not read, because
-nothing rewrote a pin for it to check.
+**It prints the `dependency-update` check** (`overrides --diff HEAD`, before the pop) — quote it. A
+moved pin stops it: restore and ask. On `skip` nothing runs.
 
 **`pnpm josh ms` is not this gate's** — it runs per issue and per child either way, bringing the
 previous merge into the tree, before the update.

package/.claude/skills/workflow-commands/needs-human-review.md

@@ -13,11 +13,11 @@ point reached it — `fullrun` or `backlogrun` — and the label may be applied
 - **Nothing is committed, pushed, opened as a pull request or merged.** `pnpm josh bump`,
   `pnpm josh git` and `pnpm josh followup` are never reached.
 - **The working tree is left uncommitted, and nothing is stashed.**
-- **Mark the stop: `pnpm josh run:hold <N> --human-review-stop`, then stop the whole run.** It keeps
+- **Mark the stop: `pnpm josh run:hold <N> --human-review-stop`, then stop this child.** It keeps
   the hold, marks it as `halfrun`'s stop, and sends the `confirmation` Telegram with the resume command
   and the lane directory — never compose one. It answers `e2e-owed` until `test:e2e` answered green on
-  this tree. The remaining children are not started — inside a `backlogrun` this is the one thing that
-  is *not* park-and-continue.
+  this tree. Inside a `backlogrun`, the stopped lane holds no execution place once its worker exits;
+  the parent continues launching children in the free lanes (`backlogrun-park.md`). Never park or release it.
 - **Resuming is `halfrun`'s stop exactly**: a person looks at the working tree and, if it is right,
   carries on from the commit themselves. The stop report carries the resume command too.
 

package/.claude/skills/workflow-commands/observation-filing.md

@@ -21,7 +21,7 @@ report. Drop an observation nobody would act on.
 
 **Below the filing bar, a line that could still change a person's judgement is a board note**:
 `pnpm josh run:event --append note "#<N> <text>"`, shown by `pnpm josh run:board`
-(`docs/josh-commands-run.md` → "`josh run:board`").
+(`docs/josh-commands-board.md` → "`josh run:board`").
 
 **The filing ceilings still apply.** It counts toward the per-origin cap of ten (`prerequisite.md`); above the target
 repository's WIP cap, close one first or do not file (`prompts/collaboration-workflow/wip-cap.md`).
@@ -33,13 +33,12 @@ A bug filing's origin line: `prompts/collaboration-workflow/issue-template.md` (
 
 ### The depth test — a discretionary filing cites the product work it blocked
 
-**Depth is read off the subject rather than judged:**
+**Depth is read off the subject's path, never judged — `pnpm josh observation:depth <path>`.**
 
-| Depth | The subject | Where it lives |
-| --- | --- | --- |
-| **0** | What a consumer of this package touches | A `josh` command's behavior, a distributed document or config, the published package |
-| **1** | The run orchestration that executes an Issue | `fullrun` / `backlogrun`, lanes, the `epic:*` commands, the filing routes themselves |
-| **2** | What measures a run | `josh cost` and the run-timing report |
+The rows' single source is `scripts/observations/observation-depth.ts`.
+
+A command subject → pass its script's path (`script:` in `scripts/josh/josh-commands*.ts`), never the
+command line.
 
 **The depth is read, not recorded** — no label carries it.
 
@@ -66,6 +65,9 @@ added.** `route:tier-a` and `route:interrupt` carry over unchanged.
 
 ### A delegated child does not take this route
 
+A `backlogrun` child's parent is a driver with no person, so it files an interrupt itself —
+`pnpm josh issue:file --route interrupt --found-during <N>`, then `pnpm josh run:add <M>`.
+
 **A delegated child files `route:tier-a` and `route:interrupt` only.** Its discretionary observations
 go in the summary's "Observations that could bite later" line (`backlogrun-child.md` → "What the
 summary carries, and how long it may be"); the parent files what survives the depth test, inside the

package/.claude/skills/workflow-commands/observation-ledger.md

@@ -47,6 +47,9 @@ Choose it from the phenomenon, not the run, and record with one command:
 pnpm josh observation:record <slug> d<n> '<where>' '<what>' [--checkout <that repository's checkout>]
 ```
 
+`d<n>` → the token `pnpm josh observation:depth <path>` prints for the subject's path, a command's
+being its script (`observation-filing.md` → "The depth test").
+
 Standard output is one token: `file` (second sighting — file it, below) or `ledger` (nothing to file);
 standard error lists earlier sightings and the file appended to. A broken line, or `k:example`, exits
 1 with nothing appended. **Every file of the directory is counted**, in the named checkout. A
@@ -69,7 +72,7 @@ blocked depth-0 work is filed as before.
   passing round 2), so CI does not restart; so does any code round on a pushed, clean tree, a
   blocking round 2 included.
   Once the Issue closes, the next ledger round outside a lane carries the comment's lines into
-  `<N>-comment-rounds.md` (`review-comment-round.ts`); a lane child leaves that to
+  `<N>-comment-rounds.md` (`review-comment-round.ts`); a lane, including one without a child marker, leaves that to
   `pnpm josh observations:flush`.
 - **`pnpm josh followup` commits any other line appended after the run's commit onto the pull request,
   before the merge** — only when the ledger holds a pending append; a broken line refuses the merge.

package/.claude/skills/workflow-commands/pre-gate-cut.md

@@ -4,8 +4,8 @@ The **pre-gate cut**: a dispatched lane child ends its process the moment implem
 **fresh** process resumes the same lane from the gate onward, without the implementation's accumulated
 context.
 
-`run:cut` takes the boundary, `run:cut --resume` is the fresh
-process's entry check. A second boundary — the implementation-phase cut, _during_ implementation — is
+`run:cut` takes the boundary; `run:entry` checks it internally with `run:cut --resume` for the fresh
+process. A second boundary — the implementation-phase cut, _during_ implementation — is
 below; it states only what differs.
 
 ## Where the boundary is
@@ -26,23 +26,14 @@ answers `not-a-lane` outside a lane, so it is safe to issue unconditionally.
 
 ## Taking the cut
 
-`chain-rule.md` step 1 issues it after `pnpm josh main:merge`, before the scoped pair and the gate —
-**unconditionally**:
+`chain-rule.md` step 1 issues it before `pnpm josh run:chain <N>`, the scoped pair and the gate —
+**unconditionally** — first tick in #N's body the criteria this tree meets (`pnpm josh issue:tick <N> <ac-id>...`, using the plan's criterion IDs):
 
 ```bash
 pnpm josh run:cut <N>
 ```
 
-- `cut` (0) — record written and handed to the lane's launch owner (OpenAI supervisor starts the
-  successor after this process exits; Anthropic relaunches directly). **End the turn immediately.**
-- `under-threshold` (0) — the newest request's billed input is under the `pnpm josh cost --cut` threshold; **continue to the gate.**
-- `not-a-lane` (0) — not a dispatched child. **Continue to the gate.**
-- `unready` (1) — the tree is clean or on the default branch. Continue to the gate.
-- `busy` (1) — a cut is already in flight for this tree. Do not relaunch.
-- `failed` (1) — no live OpenAI supervisor, or the Anthropic relaunch could not start. Continue.
-- `unknown` (1) — the git directory could not be read. Continue to the gate.
-- `split-unresolved` (1) — `split-assessment.md` → "Over the guide before the gate".
-
+**Follow the printed `next:` line.** The verdict stays on stdout; its next action is on stderr.
 **`cut` is the only verdict that ends the turn.**
 
 ### The gate refuses until the cut has been taken
@@ -53,21 +44,23 @@ row: `prompts/collaboration-workflow/rule-delivery.md`.
 
 ## Resuming — the fresh process's entry check
 
-A fresh `fullrun #<N>` runs this **at its entry, before `run:hold` and the session-boundary check**:
+`fullrun #<N>` enters once. It checks the carried cut internally
+**before `run:hold` and the session-boundary check**; never call `run:cut --resume` separately:
 
 ```bash
-pnpm josh run:cut --resume <N>
+pnpm josh run:entry <N>
 ```
 
-- `fresh` (0) — an ordinary run; normal entry.
+- `fresh` (0) — normal entry completes; follow its stage and entry report.
 - `resume` (0) — a verified pre-gate cut. **Skip the title, the plan, the fresh hold claim and the
   implementation**; re-read the issue body and comments, then go straight to `pnpm josh gate`.
 - `resume-impl` (0) — the cut was taken **during** implementation. Skip the title, the plan, the
   fresh hold claim and the split assessment, re-read the plan, then **continue implementation** — do
   **not** go straight to the gate. A round 1 the resume prints is continued, not rerun
   (`scripts/run/cut/run-cut-review.ts`).
-- `handed-off` (0) — a successor already adopted this cut. **End the turn quietly and do nothing**;
-  no Telegram owed.
+- `handed-off` (0) — a successor adopted this cut and has not been released. **End the turn quietly
+  and do nothing**; no Telegram owed. After `run:merge` stops and releases that worker to wait or
+  park, the next resume verifies and adopts the saved cut again.
 - `stale` (1) — the record does not match the tree (branch, clean tree, expired, or unknown hand-off).
   **A resume failure**: send a `confirmation` Telegram and stop; never gate the wrong tree.
 - `busy` (1) — another process owns the resume. Send a `confirmation` Telegram and stop.
@@ -89,10 +82,12 @@ or re-normalize the title; the plan and decisions are read back from the issue.
 
 - **The resume verifies the tree against the record**: branch, dirty tree, issue, and the cutting
   run's hold. Any mismatch is `stale`.
-- **No owner is recorded on the cut** (OpenAI keeps its supervisor owner separately).
+- **Adoption records its session**; only that session may replace its adopted pre-gate record with an
+  implementation cut. An unknown adopter stays protected (OpenAI keeps its supervisor owner separately).
 - **The cut is exclusive** — a second cut on the same tree is `busy`.
-- **The resume is unique** — a spent record answers `handed-off`, and the take-over is an exclusive
-  create. One lane crosses the pre-gate boundary exactly once.
+- **The resume is unique until release** — a spent record answers `handed-off`, and the take-over is
+  an exclusive create. After stopping the worker, `run:merge` makes its adopted cut resumable again
+  for a later run, preserving the branch, timestamp and handoff.
 
 ## The implementation-phase cut — a lane child cuts before the gate too
 
@@ -114,16 +109,16 @@ clears. Outside a
 lane, `run:cut --impl` prints the held run's instruction: on `over`, keep the hold, send a
 `confirmation` Telegram naming `fullrun #<N>`, end the turn. **It fires on every threshold crossing,
 not once per run**; **An edit reissued right after a refusal passes**; **The run's own handoff
-`Write` always passes**; **An unmeasurable session
-warrants the cut**; **It is silent between a cut and its resume** (`scripts/rules/implementation-cut.ts`).
+`Write` always passes**; **An unmeasurable session is not cut**;
+**It is silent between a cut and its resume** (`scripts/rules/implementation-cut.ts`).
 A child that ended without cutting is detected by
 `pnpm josh run:ending <N> --output <path>`.
 
 ## The threshold
 
 The threshold is the break-even context `scripts/cost-runtime/context-cut-payback.ts` prices at the
-session's model — `pnpm josh cost --cut` prints it, no fixed figure fits every model; both cuts and the parent hand-off read the same verdict,
-and an unmeasurable session is always cut. Both cuts end the turn **before** the gate, so the push is never a
+session's model — `pnpm josh cost --cut` prints it, no fixed figure fits every model; both cuts and the parent hand-off read the same verdict;
+neither cut fires when it is unmeasurable. Both cuts end the turn **before** the gate, so the push is never a
 turn boundary (`chain-rule.md`).
 
 ## A lane child records its park before it stops

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

@@ -27,6 +27,13 @@ action. `pnpm josh run:merge` enforces the computable half: an unfinished child
 blocked-by is released to **wait** — no `needs-decision` label, no failure counted — and the backlog
 offer hands it back once its blockers merge.
 
+After collecting a merged cause, the driver retries this run's parked native blocked-by dependents
+through `run:add --retry` once all blockers close. It preserves the retry command's human-decision,
+active-lane and terminal-state protections; incomplete dependency reads and failed retries are errors.
+
+A dependent still carrying a protected label → re-parked with `blocker #M closed` on its board row
+(🙋 decision, after the question, for `needs-decision`); the round continues (`scripts/backlog/backlog-drive-retry.ts`).
+
 **A wait for the next published release is a dependency too** — never `needs-decision`. Record it
 with `pnpm josh issue:release <M> --wait` (`<M>` blocked by the release Issue, filed when none is
 open), then `pnpm josh run:pause <M> --for <the release Issue>` as for a prerequisite below; `fullrun` /
@@ -37,17 +44,24 @@ open), then `pnpm josh run:pause <M> --for <the release Issue>` as for a prerequ
 so the observation row carries no `route:` label (`observation-filing.md`):
 
 ```bash
-pnpm josh issue:file "<title>" --body-file <body-file> --route tier-a
+pnpm josh issue:file "<title>" --body-file .josh/tmp/body.md --route tier-a
 ```
 
-The command lints the body against `prompts/collaboration-workflow/issue-template.md`, applies the
-classification labels it declares, and runs the duplicate scan and `epic:bundle` itself
-(`docs/josh-commands-backlog.md` → `josh issue:file`).
+If the size check requires a split, use `--route split --label route:tier-a` instead.
+Then run `pnpm josh run:split <M> --prerequisite <N>` to record that the kept Issue waits for it.
+
+For a cause that stopped a run, declare `- 原因の park: #<M>` under `## 背景` before filing;
+repeat the single-number line for each local stopped Issue. `issue:file` records each stopped Issue
+as blocked by the cause through the same shared epic recorder the confirmed-duplicate path uses,
+settling the epic declaration too. A warning leaves the cause filed: repair the dependency, never
+file the cause again. The set-aside and release through `run:pause` below are still required.
 
 Every *file the prerequisite* step below means that filing, and it always happens **first** — the
 later steps name its number. **Its duplicate scan is read exactly as it is for a `new` entry**
 (`issue-scout.md`).
 
+## Each entry's branch, and the pause
+
 **Each entry point's own branch stays in that entry's file:**
 
 - **A named epic under `backlogrun`** files without confirmation, sets `<M>` — the child in hand —
@@ -59,8 +73,9 @@ later steps name its number. **Its duplicate scan is read exactly as it is for a
   a batch is a different authorization, so the stop stays.
 
 **Once the prerequisite is filed, every entry sets `<M>` aside with `pnpm josh run:pause <M> --for <N>`**
-— the stash, the comment naming its `stash:pop`, the blocked-by and the release; a failure is rerun as
-is (`docs/josh-commands-run.md` → `josh run:pause`). Name the comment's pop in the Telegram too.
+— the set-aside (a WIP commit on `<M>`'s lane branch, a stash off it), the comment naming the resume
+(`main:merge` on the lane, or the `stash:pop`), the blocked-by and the release; a failure is rerun as
+is (`docs/josh-commands-run.md` → `josh run:pause`). Name the comment's resume in the Telegram too.
 
 **Automatic filing is capped at 10 Issues per originating work item** at every entry point;
 `pnpm josh issue:file` refuses the eleventh, and `--found-during <N>` names an origin the checkout

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

@@ -1,6 +1,7 @@
 # The progress watcher — every implementing run
 
-**Read this file in full when the run's hold is claimed, before the watcher starts.** It is a
+**"Progress while the run is quiet" is never fetched: `run:entry` prints it after its own section
+outside a lane child, and `run:progress --wait` as it starts — once per session.** It is a
 point-of-use document, never an entry read, and the single source of the heartbeat for `fullrun`,
 `halfrun`, `prrun` and the `backlogrun` parent alike. `kickoff` starts none.
 
@@ -26,25 +27,14 @@ relays none. **It exits only on one of three, and the command computes which:**
 **A report is not an exit, and neither is a decline** — with no run recorded it keeps waiting, and the
 `--hours` exit says so on standard error.
 
-**`pnpm josh run:watcher:guard` detects a missed restart** — via `pretool-guard` it refuses the next
-tool call while lane children are in flight and the watcher's record is stale, once per run.
-
 **`--mark` at every real report** — `pnpm josh run:progress --mark` in the same turn restarts the
-silence clock (`docs/josh-commands-run.md` → "`josh run:progress`").
-
-**Do not keep a progress clock of your own** — the hook refuses the arm
-(`scripts/rules/early-heartbeat.ts` → `decide`), though a single correctly-spaced arm is allowed.
-`--wait` is not a wait timer.
-
-**The default interval is twenty minutes, overridable — by the person, not the run.**
-`JOSH_PROGRESS_INTERVAL_MINUTES` moves both sides; `josh` → `progress_interval_minutes` in
-`package.json` sits one step below it. **`--interval` moves the watcher alone** — quieter, never the
-guard stricter.
+silence clock; the interval and its overrides are the person's (`docs/josh-commands-board.md` →
+"`josh run:progress`"). **Do not keep a progress clock of your own** — the hook refuses the arm.
 
 ### What a report says
 
-**Every unscheduled progress statement is answered by `pnpm josh run:progress --once`** — under
-`backlogrun`, `pnpm josh run:board --chat` in one code block — the reply to an explicit ask and
+**Every unscheduled progress statement is answered by `pnpm josh run:board --chat`** in one code
+block — a `backlogrun`, a `fullrun` or a `halfrun` alike — the reply to an explicit ask and
 the note just after a run starts alike; each is exempt from the interval and records the report
 itself, so no `--mark` beside it. **Relay its lines verbatim** — round, rephrase
 or re-label nothing, and **never write a clock time the command did not print**; where a field is
@@ -56,10 +46,10 @@ person's own; **no session relays the stream** — name the board command once,
 asked; the person starts it, or the `josh: run board` task in `.vscode/tasks.json`, by hand.
 `pnpm josh run:event --watch` stays for following the raw events one by one. `pnpm josh run:wake --list` is the one-line read for a person who types for it.
 **A request for periodic progress is never a CronCreate job** — on screen, name `pnpm josh run:board`;
-off-screen, start `pnpm josh run:board --every <minutes>` in the background (`docs/josh-commands-run.md`).
+off-screen, start `pnpm josh run:board --every <minutes>` in the background (`docs/josh-commands-board.md`).
 
 **A stop is the only interrupt**: a `backlogrun` that has stopped ends with
-`pnpm josh run:carry --end --stopped "<reason>"`, which sends one ⏸️ confirmation; a parked child sends
+`pnpm josh run:report --end --stopped "<reason>"`, which sends one ⏸️ confirmation; a parked child sends
 its own (`backlogrun-park.md`).
 
 ### Who starts it, and what counts as a report

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

@@ -16,7 +16,7 @@ stop. A merged Issue is reached too, but the `entry #<N>` line after the stage l
 Where `fullrun` runs `pnpm josh followup` and merges, `prrun` does three things and stops:
 
 1. **Watch the pull request to mergeable** — `pnpm josh followup "<title> #<N>" --no-merge`
-   (`followup.md` → "Run `pnpm josh followup`", read in the same turn): required CI green and the AI
+   (`followup.md` → "Run `pnpm josh followup`", printed by `followup` as it starts): required CI green and the AI
    review findings resolved. A failure stops the run exactly as it stops a `fullrun`.
 2. **Mark the stop — `pnpm josh run:hold <N> --prrun-stop`.** It records the commit the pull request is
    on in this run's own hold, the record `fullrun #<N>` adopts (its prrun resume, `working-tree-hold.md`). **The hold and `in-progress` stay**: the run is not finished until the merge's tail runs.