@joshuafolkken/kit 1.2116.0 → 1.3041.0

package/prompts/review-rubric.md

@@ -1,10 +1,8 @@
 # Code Review Rubric
 
 The rubric the reviewer applies: severity, output format, the nine categories and stop conditions.
-`pnpm josh review:brief` prints its absolute path for `/code-review`, which runs in a forked process
-reading no other repository document, so this file stands alone. Orchestration (when a review runs,
-which round is due, the gate, the PR) is in `prompts/review.md` and the `workflow-commands` skill,
-already resolved into the brief.
+It stands alone — the reviewer needs no other repository document; orchestration is already resolved
+into the brief.
 
 **Default hypothesis: this diff contains at least one non-trivial issue.** Your job is to find it, not
 to confirm correctness. Assume each category is wrong until proven otherwise; declare one clean only
@@ -15,14 +13,11 @@ the whole diff (see "The second round is a verification pass" below).
 
 ## Severity (decided by a test, never by discretion)
 
-`medium` blocks opening the PR, so a borderline `medium` costs a whole round — decide it by test.
-
 **A finding is `medium` or higher only when both of these hold:**
 
 1. **It reaches something real** — a runtime code path, a distributed artifact a consumer reads, or
    the verification that guards either (a test, fixture or CI check whose defect lets one of the first
-   two ship unnoticed). `package.json` does not ship `**/*.test.ts` or `**/*-fixture.ts`, so without
-   this third member a vacuous or wrongly-pinned suite could never exceed `low`.
+   two ship unnoticed).
 2. **You can write the concrete failure scenario** — the inputs or state, and the wrong output,
    breakage or misreading that follows. Not "this could be confusing": the actual sequence.
 
@@ -34,22 +29,16 @@ that passes test 1, and when the attempt fails write "no failure scenario — <w
 on a test-1 finding without that line is a skipped step.
 
 Distributed artifacts — `CLAUDE.md`, `prompts/**`, `.claude/**`, `docs/**` — are reviewed at the same
-level as runtime code: a dangling pointer or a citation naming the wrong file reaches every consumer,
-and no test covers prose.
+level as runtime code: a dangling pointer or a citation naming the wrong file is a defect.
 
-`high` is fixed before committing and blocks the merge regardless of round count. A `low` that fails
-test 1 (does not reach the user) may be dropped with a one-line reason; a `low` that passed test 1 and
-lacks only a failure scenario still reaches the user, so if it closes in a few lines inside a file the
-diff already touches, fix it.
+A `low` that fails test 1 may be dropped with a one-line reason; a `low` that passed test 1 and lacks
+only a failure scenario is fixed when it closes in a few lines inside a file the diff already touches.
 
 ---
 
 ## The second round is a verification pass, not a second full review
 
-Read twice under "assume it is wrong", one diff returns new findings whether or not the code changed,
-so round 2 asks a different question. **The question changes, never the standard**: a confirmed High
-still blocks the merge, the cap in `prompts/review.md` → "Review round cap" still holds, and every rule
-here applies unchanged.
+**The question changes, never the standard**: every rule here applies unchanged.
 
 |                | First round          | Second round                                                                                                          |
 | -------------- | -------------------- | --------------------------------------------------------------------------------------------------------------------- |
@@ -126,8 +115,6 @@ No issues — `parse_ids` returns what its name says; no near-copy of `split_ids
 
 ## Review categories (must all be checked)
 
-Round 1 checks all nine; round 2 checks category 1 plus the categories its fix delta touches.
-
 ### 1. Bug risks & logic errors
 
 Actively try to break the changed code.
@@ -207,7 +194,7 @@ concerns"; if nothing is uncertain, trace the logic path that gives that confide
 - **A checkout that cannot be attested** (`pnpm josh review:attest <nonce>` exits non-zero) → report
   `REVIEW TARGET MISMATCH`, no findings and no verdict of any kind: the review read a tree the brief did
   not describe.
-- High findings → must fix before committing
+- High findings → must fix before committing; a High blocks the merge regardless of round count
 - Medium findings → must fix before opening the PR
 - A finding wholly covered by an open follow-up this Issue filed (a `先送り: #M <title>` comment on
   it, which `issue:file --found-during <N>` posts) → record it as `low` citing `#M`, never `medium`

package/prompts/review.md

@@ -4,21 +4,19 @@ Review policy: the level, the round count, and what happens to a finding after t
 
 - Rubric (severity tests, nine categories, output format, stop conditions): `prompts/review-rubric.md`,
   handed to `/code-review` by `pnpm josh review:brief`.
-- Orchestration (gate beside the review, when the PR opens, the merge):
+- Orchestration (gate before round 1, when the PR opens, the merge):
   `.claude/skills/workflow-commands/chain-rule.md` → "Orchestration facts single-sourced here".
 
 ---
 
 ## When to run
 
-When: `CLAUDE.md` → "Pre-commit Self-Review"; inside a workflow, round 1 runs before the commit and
-round 2 beside CI (`.claude/skills/workflow-commands/chain-rule.md`). Launch the `reviewer` agent
-type (round 2: `reviewer-verification`), never nested, with the model `pnpm josh review:brief` prints.
-Before the reviewer returns its findings → `pnpm josh review:lint` (`.claude/agents/reviewer.md`).
+When: `CLAUDE.md` → "Pre-commit Self-Review"; in a workflow, as `run:chain` and `run:review` print.
+The reviewer is a `reviewer` agent (round 2: `reviewer-verification`), never nested, on the model
+`pnpm josh review:brief` prints.
 
 Re-run after fixes until **no high or medium findings remain or the round cap below is reached** (the
-first review counts), whichever comes first. Round 2 is a verification pass over the fixes
-(`prompts/review-rubric.md` → "The second round is a verification pass, not a second full review").
+first review counts).
 
 ---
 
@@ -27,21 +25,21 @@ first review counts), whichever comes first. Round 2 is a verification pass over
 Answer these ten over your own diff before the scoped pair that precedes round 1 — question 1 once
 `pnpm josh run:review --join` prints its lines after the review, or, under `--join --fixing` or a
 check `--join` restarted on a moved tree, the ship's pre-detach — and fix what an
-answer turns up (about four in five of 100 sampled High/Medium findings that stopped lane reviews
-fell under one; `pnpm josh lane:stats` counts the kinds that still stop). The review, its severity
-tests and the round cap are unchanged.
+answer turns up. The review, its severity tests and the round cap are unchanged.
 
 1. **Tests pin the change** — read the `unpinned` and `unchecked` lines `pnpm josh run:review --join`
    prints from `pnpm josh test:pinned` (each unchecked place is listed in its `full output:` log) (`docs/josh-commands.md` → "`josh test:pinned`"), and check a pinning test's fixture reaches its branch (no assert on a string the code
    never draws, no comparison against a literal copy).
 2. **Prose matches the code** — grep docs, prompts and comments for the old wording of every behavior,
-   constant, command and heading you changed, moved or removed (`pnpm josh prose:stale` finds the
-   removed ones), `"the table above"` and rewritten sentences included.
+   constant, command and heading you changed, moved or removed (`pnpm josh review:selfcheck` → `q2`),
+   `"the table above"` and rewritten sentences included.
 3. **Failure is not a negative answer** — every timeout, non-zero exit or `gh` failure on a touched
    path returns something a caller can tell apart from `false`, `undefined` or "nothing found".
 4. **Every caller moved with it** — grep every reference to a changed function, list or command, and
    update each sibling path (the other CLI, the registry, the consumer side) in the same change.
-   The readers outside the diff: `pnpm josh review:brief` → `## Readers outside the diff`.
+   The readers outside the diff: `pnpm josh review:selfcheck` → `q4`; where the interaction review is
+   due, answer the questions it prints under `q4 interaction review questions` too, then record
+   them: `pnpm josh review:selfcheck --interaction-answered` (`scripts/review/selfcheck-cli.ts`).
 5. **The Issue is met on HEAD** — the premises you relied on hold on the current tree, and each
    acceptance criterion is checked against the diff.
 6. **State is read fresh** — for every record, stamp, snapshot, memo or ledger a decision reads, name
@@ -58,8 +56,8 @@ tests and the round cap are unchanged.
    change runs in — kit and a consumer, and a predecessor that died midway leaving its record behind.
 10. **Commands your prose tells a reader to run are run** — for every command a refusal, hint or
     document you added or changed tells a reader to run, run it as written from a cwd other than the
-    root, with an absolute path, a relative path and an empty input, and check each result — in a
-    scratch copy (`mktemp -d`) when it writes, deletes, files or pushes, never on the lane's files.
+    root, with an absolute path, a relative path and an empty input (`pnpm josh review:selfcheck` →
+    `q10`), and check each result — in a scratch copy (`mktemp -d`) when it writes, deletes, files or pushes, never on the lane's files.
 
 The brief lists `Removed tests` → each needs a `## 消えたテストの処置` row in the PR body, or the
 merge is refused: `prompts/collaboration-workflow/report-format.md` → "PR 本文の消えたテストの処置".
@@ -68,17 +66,7 @@ merge is refused: `prompts/collaboration-workflow/report-format.md` → "PR 本
 
 ## Review level (decided by `pnpm josh review:brief --level-only`, never by judgement)
 
-Run `pnpm josh review:brief --level-only` and use what it prints — `low` or `medium`, from the changed
-paths only, never "this one is small". `--staged` classifies the staged diff, `--json` adds the reason;
-inside a workflow `pnpm josh review:brief` prints the level on its first line. `low` gets 1 round,
-`medium` up to 2. A diff that touches documentation is not inert: it stays at `medium`.
-
-```bash
-pnpm josh review:brief --level-only            # the branch diff
-pnpm josh review:brief --level-only --staged   # the staged diff
-```
-
-**A confirmed High blocks regardless of round count**, whatever the cap.
+Use the level `pnpm josh review:brief --level-only [--staged] [--json]` prints: `low` gets 1 round with Sonnet (Anthropic default), `medium` up to 2. Documentation, prompts and tests only get `low`; executable changes also get `low` at 20 added/deleted lines or fewer, including tests. Larger executable diffs, binary files and unreadable sizes stay `medium`. Model overrides still apply.
 
 ---
 
@@ -87,21 +75,25 @@ pnpm josh review:brief --level-only --staged   # the staged diff
 `pnpm josh run:review` writes its brief to a file beside round 1's where it is due, printing both paths; one still owed after round 1
 takes `pnpm josh review:brief --interaction`. Hand it to a reviewer subagent, dispose of the findings
 by the three-way disposition below, and record the pass with
-`pnpm josh review:record --interaction --issue <N> [<category>:<severity>:<file> ...]`.
+`pnpm josh review:record --from-slot --interaction --issue <N> [<n>=<disposition> ...]`.
 
 `pnpm josh followup` refuses a due change with none recorded; `pnpm josh ship --review` runs it itself, beside round 1, and stops once on the findings of both.
 
 ## Review round cap (2 rounds)
 
-Two rounds is the ceiling, not the schedule: every fix creates new surface a further round would find
-something in. Whether round 2 is due is `pnpm josh review:round2`'s answer (below). The interaction
-review is not one of the two.
+Two rounds is the ceiling, not the schedule; whether round 2 is due is `pnpm josh review:round2`'s
+answer (below). The interaction review is not one of the two.
+
+A bare `review:brief` starts at full-change final round 2 when both declared size axes fit, no
+High/Medium exists in the issue's history, and the gate is local; it records `round1: skipped-in-size`.
+Missing or unreadable inputs keep round 1; explicit round flags win. Final disposition and the
+independent interaction review still apply.
 
 ### A merge-conflict resolution review is not one of the two
 
 When `pnpm josh followup` reports `PR checks failed (merge conflict)`, the child resolves the conflict
-in its own lane and reviews the resolution — **that round does not count against the cap**, since it
-reads what merging a moved `main` did, not the change. Procedure and the four step-back conditions:
+in its own lane and reviews the resolution — **that round does not count against the cap**. Procedure
+and the four step-back conditions:
 `.claude/skills/workflow-commands/backlogrun-recovery.md` → "Conflicts are not predicted".
 `pnpm josh review:attest --check` must answer `ok` before the merge is re-issued; a confirmed High parks
 the child rather than buying a further round.
@@ -112,44 +104,30 @@ the child rather than buying a further round.
 pnpm josh review:round2 --record <N>   # → required | skip ; the reason on stderr
 ```
 
-Ask once round 1's fixes are in and the round is recorded with each finding's disposition
-(`pnpm josh review:record`'s usage), before the commit. Round 1 is closed only when the ledger shows
-every round-1 High/Medium as `fixed` or `false-positive`. Anything else, including a missing round-1
-snapshot, answers `required`.
-
-`skip` has exactly two arms, and the reason line names which fired:
-
-- **A** — the fix delta is empty.
-- **B** — every path in the fix delta is inert by the review-level classification above:
-  `docs/**/*.md`, the root `README.md`, under `prompts/`, a metrics approval under
-  `.josh/metrics-accepted/`, or a `.ts` / `.js` / `.svelte` file outside
-  `.claude/` changed only in comments (a lint, type-check, coverage or bundler directive comment counts
-  as code).
-
-One path outside that set makes it `required` — `.claude/**`, `CLAUDE.md`, a test, configuration, a
-code line, or a source file whose comment-free text cannot be read.
-
-`--record <N>` records a skipped round on the Issue itself: a comment under `## Round 2 skipped`
-naming which arm fired and quoting the reason line verbatim, written once however often it is asked.
+Ask once round 1's fixes are in and recorded (`pnpm josh review:record`'s usage), before the commit;
+the reason line says why. The `required` cases and the two `skip` arms are defined in
+`scripts/review/review-round2.ts` (`decide`, `is_unexecuted`); the skip comment `--record` posts, in
+`scripts/review/review-round2-skip-comment.ts`.
 
 ### Three-way disposition after the cap
 
 After round 2, place every remaining non-High finding in exactly one exit, decided by what the finding
-is. **The default exit is branch 3, and branch 2 has to be earned**. "It might matter later" is branch 3.
+is. **The default exit is branch 3; branch 2 has to be earned.**
 
 1. **Fix it in place** — it closes in a few lines inside a file the diff already changed, with no
    design decision (a stale comment, a name, an unused export). A fix-in-place never starts a new
-   review round. A finding that cannot close under both limits is filed, not fixed in place.
-2. **File it as an Issue** — a **confirmed defect that reaches a runtime code path** — both halves, and neither on its own.
-   Confirmed: the failure scenario is stated in concrete inputs and state.
-   **Reaching is read exactly as the rubric's Severity test 1 reads it** (a runtime code path, a
-   distributed artifact a consumer reads, or the verification that guards either), so a defect in a
-   distributed document is branch 2. `pnpm josh disposition <path>` answers `runtime` / `non-runtime`
-   from the finding's paths (the review level's inert set). **"It needs a decision" is no longer a branch-2 condition on its own**:
-   a design question with no defect under it takes branch 3.
-3. **Drop it with a one-line note in the PR body** — **This is the default, and it takes everything the other two branches did not**:
-   a Low that does not reach the user, a design preference, an unproven suspicion. **The note is not optional**:
-   one line naming the finding and why it was dropped.
+   review round; a finding that cannot close under both limits is not fixed in place.
+2. **File it as an Issue** — a **confirmed defect that reaches a runtime code path**, both halves.
+   Confirmed: the failure scenario is stated in concrete inputs and state. Reaching is the rubric's
+   Severity test 1 (a runtime code path, a distributed artifact a consumer reads, or the verification
+   that guards either); `pnpm josh disposition <path>` answers `runtime` / `non-runtime` from the
+   finding's paths. A design question with no defect under it is branch 3.
+3. **Drop it with a one-line note in the PR body** — everything the other two did not take: a Low that
+   does not reach the user, a design preference, an unproven suspicion, "it might matter later". The
+   note, naming the finding and why it was dropped, is required.
+
+Two or more findings remain after branch 1 → `pnpm josh disposition --batch <file>` prints each one's branch and
+the drop notes for the PR body (`docs/josh-commands-backlog.md` → `josh disposition`).
 
 Findings that reduce to one root judgement are filed as one Issue with a section per symptom
 (`## 現象 1` / `## 現象 2`).
@@ -158,8 +136,7 @@ Branch 2 only:
 
 - File a follow-up Issue whose `parent: #N` line names the current one — a mention in its background
   is not read by `epic:bundle`; the current Issue completes.
-- An Issue in no epic is never offered by `epic:next`, so filing continues to the epic. Run these steps
-  inside the CI wait: in `fullrun` / `backlogrun` after `pnpm josh git -y` and before
+- Filing continues to the epic: run these steps inside the CI wait — in `fullrun` / `backlogrun` after `pnpm josh git -y` and before
   `pnpm josh followup`; in `halfrun` or a standalone pre-commit self-review as soon as the disposition
   is decided. They may run delegated — `pnpm josh delegate followup-filing`.
 - A second follow-up from one round folds into the first by default
@@ -167,24 +144,19 @@ Branch 2 only:
   filing-time fold"). `pnpm josh issue:file` asks the fold question on the run's second filing and holds
   a `fold`; the first filing asks nothing.
 
-  1. Before the current Issue closes, file it tagged `route:review-cap`:
-     `pnpm josh issue:file "<title>" --body-file <body-file> --route review-cap --found-during <N>`
+  1. Before the current Issue closes, run the `issue:file` line `disposition --batch <file> --found-during <N>`
+     printed, its drafted body read first (no batch: write the body, same line):
+     `pnpm josh issue:file "<title>" --body-file <body-file> --route review-cap --label run:lane --found-during <N>`
      (`--found-during` leaves the deferral note on the current Issue the ship reviewer reads). It lints
      the body, applies the declared labels, runs the duplicate scan and `epic:bundle`
      (`docs/josh-commands-backlog.md` → `josh issue:file`). A security finding declares its
-     `- セキュリティ:` line (`issue-template.md` → H). `epic:bundle` reads open issues only, so
-     after the parent closes it answers `none` permanently.
+     `- セキュリティ:` line (`issue-template.md` → H).
   2. Act on the printed `epic:bundle` answer with `pnpm josh epic:bundle <new> --apply` — never a
-     hand edit of the epic body, which leaves the task list and `blocked-by` relations disagreeing
-     (`epic:next` returns `error`). Tier A, no confirmation:
-     - `add_to_epic` / `create_epic` → `--apply` writes it, with any recorded order.
-     - `ask` (candidates across two or more epics) → `--apply` writes nothing; place it in the
-       recommended epic with `pnpm josh epic --add <E> <new> --decision-file <path>`
-       (`.claude/skills/epic-commands/epic-bundle.md`).
-     - `none` → nothing.
-     - Non-zero exit, or any ⚠ warning above `Nothing to bundle.` → stop and report what it said; a
-       `none` after such a warning is not "nothing to bundle".
-
-**A confirmed High is never deferred** — it blocks the merge, never fixed-in-place, filed or dropped.
+     hand edit of the epic body. Tier A, no confirmation; what each answer does is
+     `.claude/skills/epic-commands/SKILL.md` → "`josh epic:bundle <N>` — does this new issue belong
+     with one already filed?". Non-zero exit, or any ⚠ warning above `Nothing to bundle.` → stop and
+     report what it said; a `none` after such a warning is not "nothing to bundle".
+
+**A confirmed High blocks regardless of round count** — never deferred, fixed-in-place, filed or dropped.
 If one still stands after round 2, do not start a third: stop, send a `confirmation` Telegram, and put
 the scope back to the user (usually: split the Issue).

package/prompts/sonar-hotspot-handling.md

@@ -46,7 +46,7 @@ A failed read (rate-limit, network) prints `unreadable: <reason>`, distinct from
 
 ## Step C: optional — mark SAFE via API if a token is available
 
-With `SONAR_TOKEN` exported (SonarCloud user token with write scope):
+With `SONAR_TOKEN` exported (SonarCloud user token with write scope), the user runs it — an agent's `curl` → ask the user (`scripts/rules/egress-guard.ts`):
 
 ```bash
 curl -sS -u "$SONAR_TOKEN:" -X POST \

package/prompts/testing-guide.md

@@ -15,7 +15,7 @@ Every requirement gets a test (`CLAUDE.md` → "Code Change Rules" Step 0); the
 
 ### Verification checklist (add to the completion gate)
 
-- [ ] Requirement count equals the count of tests added/updated (each gap documented as infeasible).
+- [ ] Every requirement has a declared test (each gap documented as infeasible); `pnpm josh test:declared --match` checks each declaration against the change set (`docs/josh-commands.md` → "josh test:declared").
 - [ ] UI changes: a screenshot of the affected screen was checked (`CLAUDE.md` → UI verification); if impossible here, say so and ask the user to check.
 
 ---
@@ -71,7 +71,7 @@ When tests leave persistent state behind:
 
 1. Add or extend a guard and confirm it fails (e.g. `dash_leak_guard.scrub_then_assert_clean` in `src/routes/dash/dash-leak-check.e2e.ts` scrubs `E2E_`-prefixed tasks, then asserts none remain).
 2. Fix production code or teardown — prefer `data-testid` over locale-specific `aria-label`; do not swallow cleanup errors unless intended.
-3. Confirm green with full `pnpm test:e2e` (or a targeted Playwright run).
+3. Confirm green with full `pnpm josh test:e2e` (or a targeted Playwright run).
 4. Document any new invariant here or in the E2E helper module.
 
 ### Error Messages
@@ -84,6 +84,19 @@ When tests leave persistent state behind:
 - **Mock the whole read**: a stub of one call leaving a second on its default still passes, slowly and against the remote (joshuafolkken/kit#1353: a 10-second CI timeout).
 - kit's `vitest.config.ts` fails such a run, listing the `gh` invocations (`docs/josh-commands.md` → `josh test:unit`); elsewhere the rule holds unguarded.
 
+### What not to test (テストしないもの)
+
+Writing an assertion → it must check behavior the code computes. Skip it when it only restates:
+
+- a re-export existing (barrel, `index.ts`)
+- raw text of a document or config — test the code that reads it
+- a mock's echo — a stub returning what the test set, or called with what the test passed through
+- a source literal re-typed into the test — import it, or assert what it drives
+
+### Use the shared test helpers (kit only)
+
+Creating a temp directory, a fixture file or an execa stub in a test → `#tools/test/temporary-directory`, `#tools/test/write-file`, `#tools/test/execa-result`. `mkdtempSync` and `vi.clearAllMocks()` in `beforeEach` are lint errors (`eslint/rules/test-helper-bans.js`).
+
 ### A josh command that writes state runs through the integration harness (kit only)
 
 - A new or changed state-writing josh command needs a test in all three environments of `tools/test/josh-harness.ts` — kit, a consumer without `docs/`, a lane worktree (joshuafolkken/kit#2402). Packed suite: `vitest.harness.config.ts`

package/scripts/agent/agent-argv.ts

@@ -1,3 +1,4 @@
+import { review_prompt_level } from '#scripts/review/review-prompt-level'
 import { agent_diagnostics } from './agent-diagnostics'
 import {
 	agent_role_profile,
@@ -6,6 +7,8 @@ import {
 	type AgentRole,
 	type ProfileResult,
 } from './agent-role-profile'
+import { agent_ship_cap } from './agent-ship-cap'
+import { agent_worker_profile } from './agent-worker-profile'
 import { claude_agent_argv } from './claude-agent-argv'
 import { codex_agent_argv } from './codex-agent-argv'
 
@@ -19,6 +22,12 @@ interface AgentArgv {
 type AgentArgvResult =
 	{ kind: 'argv'; argv: AgentArgv; profile: AgentProfile } | { kind: 'rejected'; note: string }
 
+// Where a cut relaunch runs, and how it reads its Issue's labels when `josh.worker` asks for them.
+interface ResumeSite {
+	cwd: string
+	labels: () => Promise<ReadonlyArray<string> | undefined>
+}
+
 // **`session_id` forces the fresh session's id, and only the Claude path can honour it**.
 // Codex has no such flag, and the run-state report reads Claude transcripts
 // alone, so an OpenAI scheduler simply builds as before; whiff attribution is a Claude-transcript
@@ -102,21 +111,27 @@ function profiled_in(invocation: string, resolved: ProfileResult, cwd: string):
 }
 
 // **A cut relaunch's profile, resolved for the phase the resumed child is entering**.
-// A stored lane profile keeps its model unless the phase's own model key is set, and takes the phase's
-// effort; a lane without one resolves the worker for the phase. An env override wins over the phase in
-// either path.
-function resume_argv(
+// A stored lane profile takes the phase's model where the phase has one (pre-gate: Sonnet, or
+// `JOSH_WORKER_SHIP_MODEL`) and the phase's effort; a lane without one resolves the worker for the
+// phase. An env override wins over the phase in either path. The phase's model is then capped at the
+// Issue's `josh.worker` profile, whose labels `site.labels` reads only when the setting exists.
+async function resume_argv(
 	invocation: string,
 	profile: AgentProfile | undefined,
 	phase: string,
-	cwd: string,
-): AgentArgvResult {
+	site: ResumeSite,
+): Promise<AgentArgvResult> {
 	const resolved =
 		profile === undefined
 			? agent_role_profile.resolve(agent_role_profile.WORKER, process.env, phase)
 			: agent_role_profile.with_phase(profile, phase)
+	const capped = await agent_ship_cap.capped(
+		resolved,
+		phase,
+		async () => await agent_worker_profile.resolve(site.cwd, site.labels),
+	)
 
-	return profiled_in(invocation, resolved, cwd)
+	return profiled_in(invocation, capped, site.cwd)
 }
 
 function resolve_in(
@@ -135,7 +150,13 @@ function review_in(
 	cwd: string,
 	environment: AgentEnvironment = process.env,
 ): AgentArgvResult {
-	return profiled_in(invocation, agent_role_profile.resolve_review(round, environment), cwd)
+	const is_reduced = review_prompt_level.level_of(invocation) === 'low'
+
+	return profiled_in(
+		invocation,
+		agent_role_profile.resolve_review(round, environment, is_reduced),
+		cwd,
+	)
 }
 
 const agent_argv = {
@@ -148,5 +169,5 @@ const agent_argv = {
 	with_resume_in,
 }
 
-export type { AgentArgv, AgentArgvResult }
+export type { AgentArgv, AgentArgvResult, ResumeSite }
 export { agent_argv }

package/scripts/agent/agent-consultation-model.ts

@@ -0,0 +1,47 @@
+import { agent_provider, type AgentProvider } from './agent-provider'
+
+const { ANTHROPIC_PROVIDER, PROVIDER_SCHEMA } = agent_provider
+
+// **The consultation main line runs on Opus** (joshuafolkken/kit#6901): the session a person opens
+// without a kit launcher. A design consultation goes from it to the `design-consultant` unit on Fable,
+// so the main line's own rate stays Opus for operating, filing and plain questions.
+const CONSULTATION_MAIN_MODEL = 'claude-opus-5-5'
+
+// **The consultation models** (joshuafolkken/kit#5351) — the high-rate models a launched main line
+// never runs on and a main line on one hands its run to `run:handoff`. The Astra id is confirmed on a
+// live Codex CLI by joshuafolkken/kit#5394.
+const CONSULTATION_MODELS: Readonly<Record<AgentProvider, string>> = {
+	anthropic: 'claude-fable-5-1',
+	openai: 'gpt-6.1-astra',
+}
+// The `Agent` tool's alias for the Claude consultation model.
+const CONSULTATION_ALIAS = 'fable'
+
+// Every Opus release, the default's family, costs more than the investigation model.
+const MAIN_FAMILY_PREFIX = 'claude-opus-'
+
+// The provider whose consultation model this is, by id or by the `Agent` alias; `undefined` for any
+// other model.
+function consultation_provider(model: string): AgentProvider | undefined {
+	if (model === CONSULTATION_ALIAS) return ANTHROPIC_PROVIDER
+
+	return PROVIDER_SCHEMA.options.find((provider) => CONSULTATION_MODELS[provider] === model)
+}
+
+// The provider a main line on this model hands its reading over on: the Opus family or a
+// consultation model, each above its investigation model's rate; `undefined` for a cheaper or unknown
+// model, which has nothing cheaper to hand to.
+function rated_provider(model: string): AgentProvider | undefined {
+	if (model.startsWith(MAIN_FAMILY_PREFIX)) return ANTHROPIC_PROVIDER
+
+	return consultation_provider(model)
+}
+
+const agent_consultation_model = {
+	CONSULTATION_ALIAS,
+	CONSULTATION_MAIN_MODEL,
+	consultation_provider,
+	rated_provider,
+}
+
+export { agent_consultation_model }

package/scripts/agent/agent-event.ts

@@ -34,6 +34,7 @@ interface AgentEventState {
 	provider: AgentProvider | undefined
 	launch: AgentLaunch
 	progress: string | undefined
+	last_message?: string | undefined
 	result: AgentResult
 	reason: string | undefined
 	usage: AgentUsage | undefined
@@ -84,7 +85,7 @@ function claude_assistant(value: unknown, state: AgentEventState): AgentEventSta
 	if (!is_claude_assistant(record)) return undefined
 	const progress = claude_progress(record) ?? state.progress
 
-	return { ...state, provider: 'anthropic', progress }
+	return { ...state, provider: 'anthropic', progress, last_message: progress }
 }
 
 function claude_terminal(value: unknown, state: AgentEventState): AgentEventState | undefined {
@@ -99,12 +100,20 @@ function claude_event(value: unknown, state: AgentEventState): AgentEventState |
 	return claude_assistant(value, state) ?? claude_terminal(value, state)
 }
 
+function codex_message(
+	item: z.infer<typeof CODEX_PROGRESS_SCHEMA>['item'],
+	previous: string | undefined,
+): string | undefined {
+	return item?.type === 'agent_message' ? (usable_text(item.text) ?? previous) : previous
+}
+
 function codex_progress(value: unknown, state: AgentEventState): AgentEventState | undefined {
 	const parsed = CODEX_PROGRESS_SCHEMA.safeParse(value)
 	if (!parsed.success) return undefined
 	const progress = usable_text(parsed.data.item?.text) ?? state.progress
+	const last_message = codex_message(parsed.data.item, state.last_message)
 
-	return { ...state, provider: 'openai', progress }
+	return { ...state, provider: 'openai', progress, last_message }
 }
 
 function codex_completed(value: unknown, state: AgentEventState): AgentEventState | undefined {

package/scripts/agent/agent-launch-environment.ts

@@ -1,78 +1,27 @@
-import { existsSync, lstatSync, mkdirSync, readlinkSync, symlinkSync, unlinkSync } from 'node:fs'
-import path from 'node:path'
-import { gh_cli_token } from '#scripts/gh/gh-cli-token'
 import { PLATFORM_TEMP_ROOT } from '#scripts/josh/platform-temporary'
 import { agent_headless } from './agent-headless'
-import { agent_role_profile, type AgentProfile } from './agent-role-profile'
+import type { AgentProfile } from './agent-profile-schema'
 import { agent_session_role } from './agent-session-role'
-import { codex_home_source } from './codex-home-source'
 
 const OPENAI_PROVIDER = 'openai'
-const REVIEWER_HOME = ['node_modules', '.cache', 'josh', 'openai', 'reviewer-home']
-const HOME_FILES = ['auth.json', 'config.toml']
-const PRIVATE_DIRECTORY_MODE = 0o700
 
 type LaunchEnvironment = Readonly<Record<string, string | undefined>>
 
-function openai_environment(): LaunchEnvironment {
-	const token = gh_cli_token.get()
-
-	return token === undefined
-		? { TMPDIR: PLATFORM_TEMP_ROOT }
-		: { GH_TOKEN: token, TMPDIR: PLATFORM_TEMP_ROOT }
-}
-
-function remove_old_home_link(source: string, target: string): boolean {
-	const current = lstatSync(target, { throwIfNoEntry: false })
-
-	if (current === undefined) return false
-	if (!current.isSymbolicLink()) throw new Error(`Reviewer home file is not a link: ${target}`)
-	if (existsSync(source) && readlinkSync(target) === source) return true
-
-	unlinkSync(target)
-
-	return false
-}
-
-function link_home_file(source_home: string, target_home: string, name: string): void {
-	const source = path.join(source_home, name)
-	const target = path.join(target_home, name)
-
-	if (!remove_old_home_link(source, target) && existsSync(source)) symlinkSync(source, target)
-}
-
-// A nested reviewer cannot open the parent Codex installation ID for writing inside a lane sandbox.
-// Keep credentials and user configuration readable, while its own mutable state stays in the lane.
-function reviewer_home(cwd: string, environment: LaunchEnvironment): string {
-	const source =
-		environment['CODEX_HOME'] ?? process.env['CODEX_HOME'] ?? codex_home_source.default_home()
-	const target = path.resolve(cwd, ...REVIEWER_HOME)
-
-	mkdirSync(target, { recursive: true, mode: PRIVATE_DIRECTORY_MODE })
-	for (const name of HOME_FILES) link_home_file(source, target, name)
-
-	return target
-}
-
+// An OpenAI child reads gh's keyring and the real Codex home as a Claude child does: every Codex role
+// runs with full access (joshuafolkken/kit#5438), so neither a GH_TOKEN nor a lane-local home is passed.
 function build(
-	cwd: string,
 	profile: AgentProfile | undefined,
 	environment: LaunchEnvironment = {},
 ): LaunchEnvironment {
-	if (profile === undefined) return environment
+	if (profile === undefined) return { ...environment, [agent_session_role.KEY]: undefined }
 
 	const marked = {
 		...agent_headless.environment(),
-		...agent_session_role.env_for(profile.role),
 		...environment,
+		...agent_session_role.env_for(profile.role),
 	}
-	if (profile.provider !== OPENAI_PROVIDER) return marked
-
-	const base = { ...openai_environment(), ...marked }
 
-	return profile.role === agent_role_profile.REVIEWER
-		? { ...base, CODEX_HOME: reviewer_home(cwd, environment) }
-		: base
+	return profile.provider === OPENAI_PROVIDER ? { TMPDIR: PLATFORM_TEMP_ROOT, ...marked } : marked
 }
 
 const agent_launch_environment = { build }

package/scripts/agent/agent-model-alias.ts

@@ -0,0 +1,19 @@
+// The `Agent` tool alias a pinned Claude model id runs under (`claude-opus-5-5` → `opus`), so a brief
+// can print it beside the id instead of the session converting it by hand.
+const CLAUDE_MODEL_PATTERN = /^claude-(?<family>opus|sonnet|haiku|fable)-/u
+
+// The alias of a Claude model id; `undefined` for any other model, a bare alias included.
+function alias_of(model: string): string | undefined {
+	return CLAUDE_MODEL_PATTERN.exec(model)?.groups?.['family']
+}
+
+// The ` (<alias>)` suffix printed after a model id; empty when the model has no alias.
+function suffix_of(model: string): string {
+	const alias = alias_of(model)
+
+	return alias === undefined ? '' : ` (${alias})`
+}
+
+const agent_model_alias = { alias_of, suffix_of }
+
+export { agent_model_alias }