@joshuafolkken/kit 1.1435.0 → 1.1453.0

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"
@@ -115,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"
 
@@ -130,6 +131,7 @@ 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 |
+| `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" |

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.
@@ -56,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/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/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/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,9 +37,9 @@ pnpm exec josh start
 
 Next: [tutorial](./docs/tutorial.md)
 
-### Your first backlogrun
+#### Your first backlogrun
 
-Tell the agent the change you want, then type `kickoff new auto ok` to it (or add the `auto-ok` label to an existing Issue).
+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
@@ -45,7 +47,7 @@ pnpm josh backlogrun
 
 Details: [Run the backlog unattended](./docs/how-to/run-backlog.md)
 
-### AI assistant only — no GitHub account needed
+### B. Without GitHub — AI assistant only
 
 Requires [Node.js and pnpm](./docs/setup/prerequisites.md).
 
@@ -55,20 +57,16 @@ pnpm --allow-build=esbuild dlx @joshuafolkken/kit init
 
 Next: [tutorial](./docs/tutorial.md#without-github-one-change-checked-locally)
 
-## Claude Code in a fresh-machine run
-
-A [`josh fresh:run`](./docs/maintainers/fresh-machine.md) scenario that runs Claude Code needs a sign-in, saved once:
+### Adding kit to an existing project
 
-1. In a terminal at the kit repository, run:
+- **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)).
 
-   ```bash
-   pnpm josh auth:setup
-   ```
+## Claude Code in a fresh-machine run
 
-2. A browser opens: sign in with your Claude account and press "Authorize".
-3. Done when the terminal prints `saved: CLAUDE_CODE_OAUTH_TOKEN (macOS keychain)`. There is no token to copy or write into a file.
-4. To check, run `pnpm josh auth:setup --check`: it prints `ok` and the day it was saved.
-5. When the token expires, Claude Code in the container fails to sign in — start again from step 1.
+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
 

package/dist/hooks/batch-guard.js

@@ -9,12 +9,12 @@ import {
   load_environment_file,
   notice_refusal_path,
   refusal_path
-} from "./chunk-7KMN5QB5.js";
-import "./chunk-5SJSSCJG.js";
-import "./chunk-MU4LJFIV.js";
-import "./chunk-XER6SSIB.js";
-import "./chunk-4BHUPFKF.js";
-import "./chunk-3LE6VLSR.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,

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

@@ -668,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:";
@@ -682,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");
@@ -816,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();
 }
@@ -824,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,