@joshuafolkken/kit 1.1387.0 → 1.1453.0

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

@@ -150,7 +150,7 @@ 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 — and
-what is left of `JOSH_LANE_LIMIT` (**default 6**) is what gets offered. At zero the answer is `wait`
+what is left of `JOSH_LANE_LIMIT` (**default 4**) is what gets offered. At zero the answer is `wait`
 and the holders are named on standard error. A parked child releases its lane; one stopped by
 `needs-human-review` goes on holding one, because its uncommitted work is still in that checkout.
 

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

@@ -9,6 +9,11 @@ settle. `Nothing to bundle.` needs neither.
 already recorded between them. **A similar title never counts on its own** — "related" expands
 without limit, and the threshold is what keeps an unrelated issue out.
 
+**The release issue is neither a candidate nor a subject**, like an epic. `issue:file --release` records
+every change awaiting publication as its blocker, so that relation is mechanical, not a sign of shared
+work. Counted as a signal, it would put the release and an unrelated change in one epic. A
+`blocked-by` or a prose reference between any other two issues still counts.
+
 **The search is not limited to the open backlog.** Every issue number the subject's body names is read
 on its own, whatever its state. A **closed** reference counts only when an open epic already tracks
 it, since the answer worth recovering is `add_to_epic`; an epic created over a closed issue has

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

@@ -113,9 +113,10 @@ The bullets below describe that dispatch:
   trace alone**, because its log will never grow.
 - **The child is started as `fullrun #<N>` with the lane as its working directory.** The batch a
   person approved by typing `backlogrun` covers the child.
-- **It does not pass `--dangerously-skip-permissions`.** What the child may do is the checkout's own
-  `.claude/settings.json` to decide; a headless child reaches `gh` and merges through `pnpm josh
-  followup` without the flag, and the run reports what stopped rather than loosening it.
+- **It passes `--permission-mode bypassPermissions`, never `--dangerously-skip-permissions`.** A
+  current Claude Code ignores the mode `.claude/settings.json` declares, and a new lane worktree is
+  never a trusted workspace; that file's `deny` list still refuses what it names, so the run reports
+  what stopped rather than loosening it.
 
 **Start each child without blocking on it, and poll them all** — a silent one is
 `backlogrun-recovery.md` → "A delegated unit that stopped without reporting", read in that child's
@@ -142,6 +143,7 @@ conflict.
 | The child stopped on **`needs-human-review`** | **Left open and untouched** | The uncommitted work *is* the artifact a person has to look at. Name the lane directory in the stop report and in the Telegram |
 | The child **failed** | Whichever of the two parked rows applies, plus the consecutive-failure count | Same reasoning; only the counter differs. **A merge conflict is not this row** — it takes the row above, and it is not counted |
 | **`lane:open` failed on the install** | `pnpm josh lane:close <N>`, then park the child | A lane exists that no `pnpm josh …` runs in and the next `lane:open` answers `already-open`. Closing frees the seat; parking is right because the cause is one a person fixes. Carry pnpm's reason into the park note |
+| The lane is **spent** — no child working in it, its Issue closed, not one this run launched and has not collected with `run:merge`, a clean tree, no commit that is on no remote | Nothing to do — `pnpm josh lane:prune` closes it | Nothing in it is wanted, so no one has to type the close. Any other lane is kept and `lane:prune` says why on standard error |
 | The run was **interrupted** | Nothing to do — the work tree survives on disk | The next session's `pnpm josh lane:prune` closes what git no longer has a tree for. **Park that child**, naming the lane and `pnpm josh lane:close <N>` as the way out |
 
 **A lane closed after a push is reopened by `pnpm josh lane:open <N>`**, which attaches to a local

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

@@ -103,6 +103,8 @@ It never carries:
 
 - a choice with a clearly better default — that is Tier A: decide it and record it as an Issue comment;
 - whether to run something already planned and opted in with `auto-ok` — the opt-in is that decision;
+- a wait for the next published release — a dependency, `pnpm josh issue:release <N> --wait`
+  (`prerequisite.md`);
 - a defect in the running repository's own run tooling — the run fixes it and resumes
   (`prompts/collaboration-workflow/upstream-interrupt.md` → "実行中のリポジトリ自身のラン機構の不具合").
 

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

@@ -12,12 +12,12 @@ runs is stated by the keyword and its arguments, never inferred from a request's
 that would bound this the other way are prohibited** — dropping a run's own filings, and requiring a
 person's `auto-ok` on a child; the brake below bounds it. A Tier C action inside a child still stops that child.
 
-**`pnpm josh issue:file` decides the `auto-ok` default and prints it** — `auto-ok: applied` or
-`auto-ok: not applied` with the reason; `scripts/issue/issue-auto-ok.ts` is the single source. **Pass
-`--no-auto-ok` only when the new issue needs a person's judgement** — a Tier B toss-up or a Tier C
-action inside it. The retrospective's filings take the same default and count against the same brake.
-**A filing a person asked for declares `--requested` and takes no default** — `auto-ok` only when they
-named it (`kickoff.md` → "Words typed after `new`").
+**`pnpm josh issue:file` judges `auto-ok` and prints it** — `auto-ok: applied` or
+`auto-ok: not applied` with the reason; `scripts/issue/issue-auto-ok.ts` is the single source. Every
+filing is judged the same way, whoever asked for it: the excluded labels, then the body's
+`- 人の判断:` declaration (`issue-template.md`). **Declare `- 人の判断: 要` when the new issue needs a
+person's judgement** — a Tier B toss-up or a Tier C action inside it; `--no-auto-ok` withholds it too.
+The retrospective's filings are judged the same way and count against the same brake.
 
 Rationale: `docs/maintainers/backlogrun-steps-rationale.md` → "Why the authorization boundary is shaped this way";
 provenance of each rule: `docs/maintainers/backlogrun-steps-rationale.md` → "Where each rule came from"
@@ -61,7 +61,7 @@ resumed session runs `remaining` from `--json`. The contract is `docs/josh-comma
 ```bash
 pnpm josh run:carry --begin "backlogrun --max 5 --idle 30" --owner "$PPID"
 pnpm josh run:carry --json                                                   # read it back in a resumed session
-pnpm josh run:wake --start                                                   # same turn as --begin
+pnpm josh run:wake --start                                                   # same turn as --begin; `running` under `josh backlogrun`
 ```
 
 **Always pass `--owner "$PPID"`**, and ask it before the plan, in the same turn as the first `pnpm josh
@@ -85,7 +85,8 @@ named epic's children", never the root as a standalone `fullrun`, then ask `pnpm
 a child number or `complete` continues; only `stop` or a failure records `pnpm josh run:carry --done <E>
 --owner "$PPID"`.
 
-**A person keeps control of the supervisor** — `pnpm josh run:wake --list` / `--stop`.
+**A person keeps control of the run** — `pnpm josh run:wake --list` reads it, `pnpm josh backlogrun
+--stop` stops it (`docs/josh-commands.md` → "`josh backlogrun`").
 
 Rationale: `docs/maintainers/backlogrun-steps-rationale.md` → "Why a session cut does not end the run"
 
@@ -114,7 +115,8 @@ person, Out of scope) to the person in the session language, with any truncated-
   the loop, leaving whatever is still labelled parked.
 
 **`needs-decision`, `run:solo`, `run:lane` and `priority:high` are the only workflow labels a run
-applies by hand** — never `auto-ok` or `needs-human-review` (`needs-human-review.md`).
+applies by hand** — never `needs-human-review` (`needs-human-review.md`), and `auto-ok` only through
+`pnpm josh issue:file` or `pnpm josh auto-ok:judge`, which check the exclusions first.
 
 Rationale: `docs/maintainers/backlogrun-steps-rationale.md` → "Why the plan and the decision pass come first"
 
@@ -129,7 +131,8 @@ section the row names:
 | Handed back | What the session does | Read |
 | --- | --- | --- |
 | `triage` | Label each issue stderr names `run:solo` or `run:lane` (`blocked-by` where one must land first) | "Resolve what the plan can resolve, before starting" above |
-| `offer` | Report what stderr printed; **never pick an issue by hand** | — |
+| `judge` | For each number `pnpm josh auto-ok:judge` prints, read the issue (`pnpm josh issue:read <N>`) and answer `--apply <N> --lane\|--solo` or `--decline <N> --reason "<why>"` | `docs/josh-commands-backlog.md` → "`josh auto-ok:judge`" |
+| `offer` | Report what stderr printed — a failed offer, or a named issue whose state stayed unreadable; **never pick an issue by hand** | — |
 | `launch #N` | Read the lane's log and park `#N` | `backlogrun-park.md` → "park and continue" |
 | `merge [<token>] #N` | `environment` ends the run; the others re-read the child | `backlogrun-progress.md` → "Running a named epic's children" |
 | `epic #N` | A named epic's turn | "The session cut is inside the invocation" above |

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

@@ -35,7 +35,7 @@ is still that one invocation (`backlogrun-steps.md` → "The session cut is insi
 2. **Begin the carry record before the plan** — `pnpm josh run:carry --begin "<invocation>" --owner
    "$PPID"` and `pnpm josh run:wake --start`, in the same turn as the first `pnpm josh ms`.
 3. **What this invocation approves** — the opted-in pool, a run's own filings once bundled, and the
-   brake that bounds the amount; the route table's row points at the single source of the `auto-ok` default.
+   brake that bounds the amount; the route table's row points at the single source of the `auto-ok` rule.
 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, recording `blocked-by`, `run:solo` and
    `run:lane` in the same pass.
@@ -46,6 +46,7 @@ is still that one invocation (`backlogrun-steps.md` → "The session cut is insi
    session only when it needs judgment.
 7. **End the record when the run ends** — `run:report`, then `run:carry --end` (or `--end --stopped
    "<reason>"`) and `run:wake --stop`. An empty plan is not that end; the driver's idle watch decides it.
+   A person stops a run from the terminal with `pnpm josh backlogrun --stop`, which makes both calls.
 
 ## The route table
 
@@ -55,7 +56,7 @@ never a whole document (`SKILL.md` → "A section reference is read as a section
 | The moment | Read |
 | --- | --- |
 | The entry: the carry record and its answers | `backlogrun-steps.md` → "The session cut is inside the invocation" |
-| What the invocation may merge, and the `auto-ok` default | `backlogrun-steps.md` → "What one invocation approves" |
+| What the invocation may merge, and the `auto-ok` rule | `backlogrun-steps.md` → "What one invocation approves" |
 | Before the first child: the plan and the decision pass | `backlogrun-steps.md` → "The plan, before the first child starts" |
 | The driver hands a branch back | `backlogrun-steps.md` → "The loop" |
 | Once per session | `backlogrun-steps.md` → "What runs once per session, not once per issue" |

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

@@ -5,7 +5,8 @@
 This is the execution contract for `fullrun` and `backlogrun`, and for `prrun` up to the pull request: a `prrun` never issues `pnpm josh ship` or a merging `pnpm josh followup` — it opens the pull request with `pnpm josh git -y` and ends by `prrun.md` → "The difference — the end of the run". The record below is reference only.
 Review results and successful pushes are never turn boundaries.
 
-0. **A lane child**: `pnpm josh main:merge`, the scoped pair, `pnpm josh ship --detach --review
+0. **A lane child**: `pnpm josh main:merge`, the self-check (`prompts/review.md` → "Before round 1 —
+   the implementer's self-check"), 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 prompt names `pnpm josh ship --log <N>` and (Anthropic lane) the re-detach to run after
    the fix — `pnpm josh ship --detach`, `--review` only if the stopped ship carried it and stopped before
@@ -13,7 +14,8 @@ Review results and successful pushes are never turn boundaries.
    `failed` → step 1. A backgrounded `ship` issued alone is moved to the foreground by the hook
    rather than refused.
 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). Then run the final scoped lint/test pair and
+   the gate** — the pre-gate cut (a no-op outside a lane). Then answer the self-check
+   (`prompts/review.md` → "Before round 1 — the implementer's self-check"), 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. Launch the `/code-review` subagent as the `general-purpose`
    agent type with that brief (every tool, so `--fix` applies; never a guessed type name).

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

@@ -45,7 +45,7 @@ primary checkout; a Claude run keeps it.
 ## The `fullrun new` step list
 
 `kickoff new` + `fullrun #N` in one run. Steps: (1) Derive an English title, or use the provided one.
-(2) Create Issue: `pnpm josh issue:file "<title>" --body-file <body-file> --depth <n> --requested`,
+(2) Create Issue: `pnpm josh issue:file "<title>" --body-file <body-file> --depth <n>`,
 with the labels `kickoff.md` → "Words typed after `new`" maps (per
 `prompts/collaboration-workflow/issue-template.md`) — its duplicate scan runs first, and a candidate
 that covers the same work stops the run rather than filing a second Issue (`issue-scout.md`). Capture

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

@@ -42,7 +42,7 @@ back with fixes, treat each as a new round: implement, re-run `pnpm josh gate`,
 
 `halfrun new` or `halfrun new "<title>"`: `kickoff new` + `halfrun #<N>` (no Issue exists yet). Steps
 mirror `fullrun new` (1)–(8): derive an English title (or use the provided one) → create the Issue
-(`pnpm josh issue:file "<title>" --body-file <body-file> --depth <n> --requested`, with the labels
+(`pnpm josh issue:file "<title>" --body-file <body-file> --depth <n>`, with the labels
 `kickoff.md` → "Words typed after `new`" maps, body per
 `prompts/collaboration-workflow/issue-template.md`; its duplicate scan is read per `issue-scout.md`) → add `in-progress` (as `fullrun new` (3)) → post the agreed plan → stash
 any pre-existing changes with `git stash push -m "halfrun new: pre-existing changes" -- ':!.josh/observations'`

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

@@ -91,3 +91,9 @@ never the comment text.
 **`pnpm josh rule:guard` refuses the body-only read** and hands over the reissue and the conflict rule
 at the moment they bind (`prompts/collaboration-workflow/rule-delivery.md`). **This file is the rule,
 not the hook** — a session that runs no hooks still owes the read.
+
+## A person's update mid-run
+
+When the hook, `review:attest --check` or `followup` shows an Issue update, read it as above — the
+later text is in force — fix what it changes, then `pnpm josh issue:ack <N>`. The watch and what it
+does not catch: `docs/josh-commands-backlog.md` → "`josh issue:ack`".

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

@@ -43,8 +43,7 @@ is read on demand when a split is found.
 - `kickoff new` or `kickoff new "<title>"`: No Issue exists yet. Steps: (0) **Scope assessment** per
   `split-assessment.md`. If multiple → the **multi-issue split path**; if single → the **single-issue
   path**. **Single-issue path**: (1) Derive an English title from the conversation, or use the provided
-  title. (2) Create Issue: `pnpm josh issue:file "<title>" --body-file <body-file> --depth <n>
-  --requested` plus the labels the words typed after `new` name ("Words typed after `new`", below) (body
+  title. (2) Create Issue: `pnpm josh issue:file "<title>" --body-file <body-file> --depth <n>` 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 that covers the same work stops the run rather than filing a second Issue (`SKILL.md` →
   `issue-scout.md`). Capture `<N>`. (3)
@@ -52,7 +51,7 @@ is read on demand when a split is found.
   Telegram notification. (5) **Stop** — do not implement. **Multi-issue split path**: (1) For each
   independent deliverable, derive a focused English title and create a separate Issue with the
   `route:split` label (its duplicate scan is read per `issue-scout.md`): `pnpm josh issue:file
-  "<sub-title>" --body-file <body-file> --depth <n> --route split --requested` plus the labels the words typed after `new` name. Capture each Issue number. **When the split is filed into a repository other than
+  "<sub-title>" --body-file <body-file> --depth <n> --route split` plus the labels the words typed after `new` name. Capture each Issue number. **When the split is filed into a repository other than
   the one this session is running in**, every child body gets the `## Origin` backlink described in the
   cross-package rule the AI documents keep resident, the epic body carries the same link as prose or a
   plain bullet (never as a checkbox row, which would disable its auto-close), and the originating Issue
@@ -85,15 +84,15 @@ An Issue a consumer can use only once it is published is filed with `--release`
 
 ## Words typed after `new`
 
-**An Issue a person asked for is filed with `--requested`** — every `new` entry (each child of its
-multi-issue split included), and a request in conversation. A live carry record or an `auto-ok` branch Issue then does not opt it in, so no lane takes
-it before the person picks the run; `auto-ok` comes only from the words below (`issue-auto-ok.ts`). A
-filing the run decides on its own — observation, retrospective, a split the run finds itself, routed — never declares it.
+**`auto-ok` is judged by `pnpm josh issue:file`, never typed** — by the same criteria as every
+filing: the excluded labels and the body's `- 人の判断:` declaration, and a `不要` declaration also needs a run label
+(`issue-template.md`).
+`auto ok` typed after `new` adds nothing.
 
-**Words after `new`** (`kickoff new auto ok high`) are read like `into <target>`, never inferred. Each
-adds its labels to the `--requested` filing; a word not in the table is asked about:
+**Words after `new`** (`kickoff new high`) are read like `into <target>`, never inferred. Each adds its
+labels to the filing; a word not in the table is asked about:
 
-| Typed     | Added to `pnpm josh issue:file`    |
-| --------- | ---------------------------------- |
-| `auto ok` | `--label auto-ok --label run:lane` |
-| `high`    | `--label priority:high`            |
+| Typed     | Added to `pnpm josh issue:file` |
+| --------- | ------------------------------- |
+| `auto ok` | nothing — `issue:file` judges it |
+| `high`    | `--label priority:high`         |

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

@@ -70,7 +70,7 @@ defines, before the create call.
 
 - **It is read off the subject, exactly as the table is** — so applying it is not a judgement and not
   a person's to make, which is what separates it from `auto-ok` and `needs-human-review`. Those two
-  decide what a run may do (`auto-ok` by `issue:file`'s default for a filing found by opted-in work —
+  decide what a run may do (`auto-ok` by `issue:file`'s judgement against the criteria —
   `backlogrun-steps.md` → "What one invocation approves"); this one records what an Issue is about
   and withholds nothing.
 - **Applied at filing, not at completion.**

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

@@ -106,8 +106,9 @@ could not.
   and appends nothing. That round reads only, so no commit of the run's follows it; a line in the tree
   would be pushed onto the open pull request and its CI would start over. `pnpm josh ship --review`
   does this for a passing round 2. **A round 2 that blocks records in the tree as before** — the fix it
-  stops for is pushed anyway and carries the lines. The comment's lines are outside the count
-  `pnpm josh review:findings` and the retrospective read.
+  stops for is pushed anyway and carries the lines. Once the Issue is closed, the next round recorded
+  to the ledger carries the comment's lines into `<N>-comment-rounds.md` with its own commit, so
+  `pnpm josh review:findings` and the retrospective count them (`review-comment-round.ts`).
 - **`pnpm josh followup` commits any other line appended after the run's commit onto the pull request,
   before the merge** — the residual path, for an observation recorded between the commit and the
   merge. After the merge gates and before the CI wait, `followup` reads the tree and, **only when the

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

@@ -169,9 +169,11 @@ built for the lane child.
 **The trigger**: `pnpm josh rule:guard` refuses an `Edit` / `Write` in a dispatched lane child whose
 recent-context cost is over threshold, handing back `pnpm josh run:cut --impl <N> --handoff <path>`.
 `cut` ends the turn; a fresh process's `run:cut --resume <N>` answers `resume-impl` and continues
-implementation — **the implementation resume clears the record**, so the cut may fire again. Outside
-a lane, a held run on a measured `over` keeps the hold, sends a `confirmation` Telegram naming
-`fullrun #<N>` and ends the turn. The refusal states the rest — **It fires on every threshold crossing,
+implementation — **the implementation resume clears the record**, so the cut may fire again. **A cut
+that relaunches its successor owes no Telegram**, the pre-gate cut as much as this one: nobody has
+anything to act on, and a resume answering `stale` / `busy` sends its own. Outside a lane nothing is
+relaunched, so `run:cut --impl` prints the held run's instruction — on a measured `over` that run
+keeps the hold, sends a `confirmation` Telegram naming `fullrun #<N>` and ends the turn. The refusal states the rest — **It fires on every threshold crossing,
 not once per run**; **An edit reissued right after a refusal passes**; **An unmeasurable session
 warrants the cut**; **It is silent between a cut and its resume**. Rationale:
 `docs/maintainers/pre-gate-cut-rationale.md` → "Why the rules are guards, not prose";

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

@@ -28,6 +28,12 @@ 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.
 
+**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 stash, comment and `pnpm josh run:release <M>` as for a prerequisite below; `fullrun` /
+`halfrun` stop, `backlogrun` continues. Closing the release Issue once a person has published it hands
+`<M>` back to `backlog:next` (`docs/josh-commands-backlog.md` → `josh issue:release`).
+
 **File the prerequisite with the `route:tier-a` label**, so a Tier A filing made during implementation
 stays countable by filing route afterwards. **This paragraph belongs to the prerequisite row, not to
 the table** — the label means a filing the run is *blocked by*, so the observation row carries no

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

@@ -4,7 +4,7 @@
 not at the entry.** `SKILL.md` → §2's table keeps the rule itself: run what `run:step` prints once,
 file the improvements worth carrying into the next run, stack the rest, and mark the step done.
 Everything that decides *how* — what the four sections mean, how the top two are chosen, the
-exclusions, and the `auto-ok` default — is here. Read it in full, in the same turn, before filing.
+exclusions, and the `auto-ok` judgement — is here. Read it in full, in the same turn, before filing.
 
 **When it fires is not this file's, and not a judgement.** The run driver prints the step the moment the
 backlog drains — `backlog:offer` marks that drain on the event stream and `run:step` fires the
@@ -56,10 +56,10 @@ Issue, as after any filing.
 
 ## `auto-ok`, and closing the step
 
-**What a retrospective files carries `auto-ok`** — it files while the carry record is live, so
-`issue:file`'s default applies the label and the next run picks the improvements up without waiting
-for a person. **`backlogrun-steps.md` → "What one invocation approves" is that default's single
-source**; it is written there, beside the brakes that bound it, rather than restated here. Every brake still counts a retrospective's filings: the
+**What a retrospective files is judged for `auto-ok`** — an improvement that needs no person's
+judgement declares `- 人の判断: 不要`, so `issue:file` applies the label (with the run label `prompts/collaboration-workflow/issue-template.md` requires) and the next run picks it up
+without waiting for a person. **`backlogrun-steps.md` → "What one invocation approves" is that
+judgement's single source**; it is written there, beside the brakes that bound it, rather than restated here. Every brake still counts a retrospective's filings: the
 ten-per-invocation ceiling, the WIP cap, `--max` and the 150,000-token session budget.
 
 **Close with `pnpm josh run:carry --retrospective --summary "<result>" --owner "$PPID"`.** It marks the

package/.claude/skills/workflow-commands/split-assessment.md

@@ -77,8 +77,8 @@ moment that child merges and closes.
 
 **Each split child is filed with the `route:split` label** —
 `pnpm josh issue:file "<sub-title>" --body-file <body-file> --depth <n> --route split` — so the
-backlog's composition stays countable by filing route rather than by grepping issue bodies. A split of
-a person's `kickoff new` also takes `--requested` (`kickoff.md` → "Words typed after `new`").
+backlog's composition stays countable by filing route rather than by grepping issue bodies. Each child
+is judged for `auto-ok` like any filing (`kickoff.md` → "Words typed after `new`").
 
 ## Promote, or create a new epic
 

package/README.md

@@ -6,9 +6,9 @@ kit gives Claude Code or Codex your project's rules and checks.
 
 ## The workflow
 
-Type `backlogrun` and the agent takes the Issues you name from plan to merged PR — in parallel, unattended. A live board shows where each one stands:
+`backlogrun` takes your Issues to merged PRs — in parallel, unattended:
 
-![The backlogrun board: ten Issues running side by side, seven already merged, each with its stage and elapsed time](./docs/images/backlogrun-board.png)
+![The backlogrun board: ten Issues in one run, three already merged and the rest moving through their stages or waiting for a free lane, with recent findings and decisions below](./docs/images/backlogrun-board.png)
 
 [Every keyword, including the ones that stop for you earlier](./docs/how-to/run-issues.md)
 
@@ -23,7 +23,9 @@ Type `backlogrun` and the agent takes the Issues you name from plan to merged PR
 
 ## Quick start
 
-### With the GitHub workflow
+Pick one setup ([A or B: what differs](./docs/setup/choose.md)):
+
+### A. With GitHub — Issues, PRs and unattended runs
 
 Requires [Node.js, pnpm and the gh CLI](./docs/setup/prerequisites.md).
 
@@ -35,7 +37,17 @@ pnpm exec josh start
 
 Next: [tutorial](./docs/tutorial.md)
 
-### AI assistant only — no GitHub account needed
+#### Your first backlogrun
+
+Tell the agent the change you want, then type `kickoff new` to it. The Issue gets the `auto-ok` label when it needs no judgement from you (or add the label to an existing Issue).
+
+```bash
+pnpm josh backlogrun
+```
+
+Details: [Run the backlog unattended](./docs/how-to/run-backlog.md)
+
+### B. Without GitHub — AI assistant only
 
 Requires [Node.js and pnpm](./docs/setup/prerequisites.md).
 
@@ -45,6 +57,17 @@ pnpm --allow-build=esbuild dlx @joshuafolkken/kit init
 
 Next: [tutorial](./docs/tutorial.md#without-github-one-change-checked-locally)
 
+### Adding kit to an existing project
+
+- **Files written:** settings per profile, including Prettier — always on `full`, and on `basic` only when the project has web files and no formatter of its own ([per profile](./docs/init.md#project-profiles)); `--dry-run` previews them.
+- **Overwritten by `josh sync`:** the managed files, such as `.github/workflows/ci.yml` and `AGENTS.md` ([the list](./docs/sync.md#ai-files-overwritten)).
+- **Permissions:** the Claude Code settings kit writes (with `josh start`, or on `full`) set `bypassPermissions` with `Bash(*)`, guarded by a deny list and a hook ([how to opt out](./docs/init.md#claude-code-permission-mode)).
+- **On GitHub:** `josh start` adds labels, and on an existing `main` an Issue and a setup PR that you merge yourself ([the steps](./docs/init.md#josh-init-or-josh-start)).
+
+## Claude Code in a fresh-machine run
+
+A `josh fresh:run` scenario that runs Claude Code needs a sign-in saved once with `pnpm josh auth:setup` ([steps](./docs/maintainers/fresh-machine.md#claude-code)).
+
 ## Docs
 
 [How-to](./docs/how-to.md) · [All docs](./docs/overview.md)

package/dist/hooks/audit-provision.js

@@ -1,14 +1,14 @@
 #!/usr/bin/env tsx
 import {
   timed_fetch
-} from "./chunk-FZ6FUSBM.js";
+} from "./chunk-723HKZO5.js";
 import {
   error_text
 } from "./chunk-CDY4NFQG.js";
 import {
   PROJECT_ROOT,
   stamp_file
-} from "./chunk-NEC4AT4Z.js";
+} from "./chunk-DGT54IH5.js";
 
 // scripts/security/security-audit-provision.ts
 import { chmodSync, mkdirSync, renameSync, rmSync, writeFileSync } from "node:fs";

package/dist/hooks/batch-guard.js

@@ -9,13 +9,13 @@ import {
   load_environment_file,
   notice_refusal_path,
   refusal_path
-} from "./chunk-LMWBRJIP.js";
-import "./chunk-EAQEGME7.js";
-import "./chunk-EBSHN25W.js";
-import "./chunk-SL4GQ2XP.js";
-import "./chunk-J3KSS7II.js";
-import "./chunk-2YSW3CXH.js";
-import "./chunk-NEC4AT4Z.js";
+} from "./chunk-EF5GQ6WS.js";
+import "./chunk-UT7YC3N2.js";
+import "./chunk-W5ZKGTSY.js";
+import "./chunk-MBJYQPEK.js";
+import "./chunk-OLMO72ON.js";
+import "./chunk-3C4XRYG6.js";
+import "./chunk-DGT54IH5.js";
 export {
   DISABLED_VALUES,
   SWITCH_ENV_KEY,

package/dist/hooks/{chunk-2YSW3CXH.js → chunk-3C4XRYG6.js}

@@ -4,7 +4,7 @@ import {
   PROBE_TIMEOUT_MS,
   SUITE_TIMEOUT_MS,
   stamp_file
-} from "./chunk-NEC4AT4Z.js";
+} from "./chunk-DGT54IH5.js";
 
 // scripts/lib/json-value.ts
 function parse_or_undefined(text) {
@@ -511,12 +511,19 @@ async function commit(message) {
 async function delete_branch(branch_name) {
   await git_spawn.read(["branch", "-d", branch_name]);
 }
-async function commit_count_beyond(base, tip) {
-  const range = `${base}..${tip}`;
-  const output = await git_spawn.read(["rev-list", "--count", range]);
+async function read_commit_count(revisions) {
+  const output = await git_spawn.read(["rev-list", "--count", ...revisions]);
   const parsed = Number(output);
   if (output.length > 0 && Number.isFinite(parsed)) return parsed;
-  throw new Error(`\`git rev-list --count ${range}\` printed \`${output}\` rather than a count`);
+  throw new Error(
+    `\`git rev-list --count ${revisions.join(" ")}\` printed \`${output}\` rather than a count`
+  );
+}
+async function commit_count_beyond(base, tip) {
+  return await read_commit_count([`${base}..${tip}`]);
+}
+async function commit_count_unpushed(branch_name) {
+  return await read_commit_count([branch_name, "--not", "--remotes"]);
 }
 function is_exit_code_128(cause) {
   return typeof cause === "object" && cause !== null && "exit_code" in cause && cause.exit_code === "128";
@@ -633,6 +640,7 @@ var git_command = {
   checkout,
   commit,
   commit_count_beyond,
+  commit_count_unpushed,
   delete_branch,
   push: push2,
   pull_fast_forward,
@@ -660,6 +668,7 @@ var START_TIME_FORMAT = "lstart=";
 var PID_FLAG = "-p";
 var PROBE_ENVIRONMENT = { TZ: "UTC", LC_ALL: "C" };
 var LIVENESS_SIGNAL = 0;
+var NO_SUCH_PROCESS = "ESRCH";
 var LOWEST_REAL_PID = 1;
 var PROC_START_FIELD_INDEX = 19;
 var BEACON_SCHEME = "socket:";
@@ -674,15 +683,20 @@ var BEACON_GONE_STATUS = 2;
 var SOCKET_PROBE_SOURCE = `const net=require('node:net');const socket=net.createConnection(process.argv[1]);socket.once('connect',()=>process.exit(${String(BEACON_LIVE_STATUS)}));socket.once('error',(error)=>process.exit(['ECONNREFUSED','ENOENT'].includes(error.code)?${String(BEACON_GONE_STATUS)}:${String(BEACON_UNKNOWN_STATUS)}));socket.setTimeout(1000,()=>process.exit(${String(BEACON_UNKNOWN_STATUS)}));`;
 var beacons = /* @__PURE__ */ new Map();
 var exit_cleanup = { is_registered: false };
-function is_live_pid(pid) {
-  if (pid < LOWEST_REAL_PID) return false;
+function signal_refusal(pid) {
   try {
     process.kill(pid, LIVENESS_SIGNAL);
-    return true;
-  } catch {
-    return false;
+    return void 0;
+  } catch (error) {
+    return error.code ?? NO_SUCH_PROCESS;
   }
 }
+function is_live_pid(pid) {
+  return pid >= LOWEST_REAL_PID && signal_refusal(pid) === void 0;
+}
+function is_present_pid(pid) {
+  return pid >= LOWEST_REAL_PID && signal_refusal(pid) !== NO_SUCH_PROCESS;
+}
 function read_proc_start(pid) {
   try {
     const stat = readFileSync(`/proc/${String(pid)}/stat`, "utf8");
@@ -808,6 +822,11 @@ function is_same_process(pid, recorded_start, read3 = read_start) {
   if (recorded_start === void 0) return void 0;
   return matches_recorded_start(pid, recorded_start, read3);
 }
+function is_present_process(pid, recorded_start, read3 = read_start) {
+  if (!is_present_pid(pid)) return false;
+  if (recorded_start === void 0) return void 0;
+  return matches_recorded_start(pid, recorded_start, read3);
+}
 function is_own_process(pid, recorded_start) {
   return pid === process.pid && recorded_start === own_start();
 }
@@ -816,6 +835,8 @@ var process_identity = {
   is_live_beacon,
   is_live_pid,
   is_own_process,
+  is_present_pid,
+  is_present_process,
   is_same_process,
   open_beacon,
   own_fields,
@@ -2049,6 +2070,7 @@ var run_carry_schema = z2.object({
   owner_pid: z2.number().optional(),
   owner_start: z2.string().optional(),
   owner_transcript: z2.string().optional(),
+  is_owner_headless: z2.boolean().optional(),
   is_handed_off: z2.boolean().optional(),
   done: z2.array(z2.number()).optional(),
   retrospective: z2.boolean().optional(),
@@ -2090,7 +2112,8 @@ function fresh_carry(invocation, owner, now) {
     outages: NO_INCREMENT3,
     owner_pid: owner.pid,
     owner_start: owner.start,
-    owner_transcript: owner.transcript
+    owner_transcript: owner.transcript,
+    is_owner_headless: owner.is_headless
   };
 }
 function begin_carry(target, invocation, owner = NO_OWNER, now = /* @__PURE__ */ new Date()) {
@@ -2103,6 +2126,7 @@ function adopt_carry(target, carry, owner = NO_OWNER) {
     owner_pid: owner.pid,
     owner_start: owner.start,
     owner_transcript: owner.transcript,
+    is_owner_headless: owner.is_headless,
     is_handed_off: false
   };
   stamp_file.remove_stamp(target);