@joshuafolkken/kit 1.1471.0 → 1.1784.0

package/prompts/review.md

@@ -24,9 +24,10 @@ first review counts), whichever comes first. Round 2 is a verification pass over
 
 ## Before round 1 — the implementer's self-check
 
-Answer these five over your own diff before the scoped pair that precedes round 1, and fix what an
-answer turns up (about two in three of 135 sampled round-1 High/Medium findings fell under one). The
-review, its severity tests and the round cap are unchanged.
+Answer these nine over your own diff before the scoped pair that precedes round 1, 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.
 
 1. **Tests pin the change** — for each condition, branch or call added or changed, name the test that
    turns red when it is deleted or inverted, and check its fixture reaches that branch (no assert on a
@@ -38,8 +39,24 @@ review, its severity tests and the round cap are unchanged.
    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`.
 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
+   its writer and check it cannot be older than the decision (a past `success`, a tick's shared
+   snapshot, a sync before the commit) or written by another run in between.
+7. **The rule covers its whole input space** — list every kind of input a scan, pattern, matcher or
+   lookup must accept or reject (the sibling file type, the consumer's config beside the root, quoted
+   text, a subshell, a pipe, a heredoc) and pin one test row per kind.
+8. **Edge inputs and environments** — say what the change does when its input is empty, absent or
+   new, and outside a TTY, a lane or the default agent runtime.
+9. **Claims about other components are checked in their code** — for every claim your code or a
+   comment makes about another component's behavior (what a stage does, who enforces a limit, which
+   repository it runs in), open that component's code and confirm it; then name each context the
+   change runs in — kit and a consumer, and a predecessor that died midway leaving its record behind.
+
+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 本文の消えたテストの処置".
 
 ---
 
@@ -48,8 +65,7 @@ review, its severity tests and the round cap are unchanged.
 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. Derivation (inert paths, documentation at `medium`):
-`docs/maintainers/review-history.md` → "The level is decided from the changed paths".
+`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
@@ -60,10 +76,20 @@ pnpm josh review:brief --level-only --staged   # the staged diff
 
 ---
 
+## Interaction review
+
+After round 1 and its record, `pnpm josh review:brief --interaction` answers whether the change takes
+the interaction review and prints its brief; 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 followup` refuses a due change with none recorded; `pnpm josh ship --review` runs it itself.
+
 ## 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).
+something in. Whether round 2 is due is `pnpm josh review:round2`'s answer (below). The interaction
+review is not one of the two.
 
 ### A merge-conflict resolution review is not one of the two
 
@@ -94,16 +120,10 @@ deferred. Without the flag, and on any uncertainty (a missing round-1 snapshot i
   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. Why: `docs/maintainers/review-history.md`
-→ "The two skip arms".
-
-Record a skipped round on the Issue:
+code line, or a source file whose comment-free text cannot be read.
 
-1. Label the Issue `review-round2-skipped`, created once per repository:
-   `gh api repos/{owner}/{repo}/labels -f name=review-round2-skipped -f color=c5def5 -f description="Review round 2 was skipped under the condition in prompts/review.md" --silent 2>/dev/null || true`,
-   then `gh api repos/{owner}/{repo}/issues/<N>/labels -f 'labels[]=review-round2-skipped'`.
-2. Comment under `## Round 2 skipped`, naming which arm fired and quoting the command's reason line
-   verbatim.
+Record a skipped round on the Issue with a comment under `## Round 2 skipped`, naming which arm fired
+and quoting the command's reason line verbatim.
 
 ### Three-way disposition after the cap
 
@@ -129,7 +149,8 @@ Findings that reduce to one root judgement are filed as one Issue with a section
 
 Branch 2 only:
 
-- File a follow-up Issue referencing the current one; the current Issue completes.
+- 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
   `pnpm josh followup`; in `halfrun` or a standalone pre-commit self-review as soon as the disposition
@@ -140,19 +161,17 @@ Branch 2 only:
   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> --depth <n> --route review-cap`. It lints
+     `pnpm josh issue:file "<title>" --body-file <body-file> --route review-cap`. It lints
      the body, applies the declared labels, runs the duplicate scan and `epic:bundle`
      (`docs/josh-commands-backlog.md` → `josh issue:file`). `epic:bundle` reads open issues only, so
      after the parent closes it answers `none` permanently.
-  2. Act on the printed `epic:bundle` answer by running the write command yourself — `epic:bundle`
-     writes nothing, and a hand edit of the epic body leaves the task list and `blocked-by` relations
-     disagreeing (`epic:next` returns `error`). Tier A, no confirmation:
-     - `add_to_epic` → `pnpm josh epic --add <E> <new>`, with `--before <M>` / `--after <M>` when the
-       relation carries an order.
-     - `create_epic` → `pnpm josh epic "<title>" <new> <other> [--ordered]`.
-     - `ask` (candidates across two or more epics) → run the recommended epic's write command and record
-       what was taken, what was rejected and why on the new Issue and that epic's `## Decisions`. Stop
-       only where the two epics are genuinely too close to separate.
+  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".

package/prompts/testing-guide.md

@@ -2,20 +2,7 @@
 
 ## 0. Per-Requirement Test Coverage (MANDATORY)
 
-Before any implementation code, **list every requirement from the user's request and assign a test to each one**.
-
-### Planning template
-
-```text
-Req 1: "Label chip shown immediately"
-  → E2E: open editor, type new label, press Enter → chip visible without blurring
-
-Req 2: "Down arrow moves to next row"
-  → E2E: open editor on row 1, press ↓ → row 2 enters edit mode
-
-Req N: ...
-  → Unit/E2E: ...
-```
+Every requirement gets a test (`CLAUDE.md` → "Code Change Rules" Step 0); the declaration's form is `prompts/collaboration-workflow/report-format.md` → "作業前サマリはいつ・どう出すか". This section decides which test.
 
 ### Rules
 
@@ -24,7 +11,6 @@ Req N: ...
 - **Non-runtime updates (pre-approved manual-only exception):** a change touching no executable runtime code path — docs, non-executable config, editor/IDE files, cosmetic asset swaps with no selector/path change — may be verified by hand; declare it in Step 0 with the reason. The mechanically exempt (`*.md`, `.editorconfig`, `.idea/**`, `.vscode/**`, `prompts/**`) need no declaration. A runtime change whose test is infeasible needs the reason and user approval.
 - **basic で kit がテストできない言語だけの変更:** `package.json` に `josh.profile: basic`（改名前の `static` も同じ）があり、変更が HTML/CSS や Lua などのソースだけなら自動テストは不要。HTML/CSS はブラウザーで対象ページを開き、想定する画面幅でレイアウト・リンク・HTML 内の操作を確認する。そのほかのソースは変更した処理を実際に動かす。どちらも結果を記録する。JavaScript または TypeScript のファイルを含む変更は自動テストを行う。
 - Test infeasible (e.g., a native OS date-picker Playwright cannot drive) → comment why in the test file and test the closest observable behavior (e.g., the editor stays open after `change`).
-- A requirement without its test is not done.
 
 ### Verification checklist (add to the completion gate)
 
@@ -50,7 +36,7 @@ Req N: ...
 | Component / browser | `*.svelte.test.ts`       | browser/component vitest project |
 | E2E                 | `src/routes/**/*.e2e.ts` | Playwright                       |
 
-- **Never `*.spec.ts`** — lint-enforced by `eslint/rules/test-filename.js` (wired into `eslint/base.js`) for every JS/TS extension; rationale: `docs/maintainers/testing-guide-history.md` → "Why the `*.spec.*` ban is a lint rule".
+- **Never `*.spec.ts`** — lint-enforced by `eslint/rules/test-filename.js` (wired into `eslint/base.js`) for every JS/TS extension.
 - **Keep the `.svelte.` infix** on component/browser tests: `*.svelte.test.ts` matches the browser project (`include: src/**/*.svelte.{test,spec}.{js,ts}`), plain `*.test.ts` the node project (`include: src/**/*.{test,spec}.{js,ts}`); dropping it silently moves the file to the wrong project.
 - **Colocate** each test beside its code (`foo.test.ts` next to `foo.ts`); no top-level `tests/` (lint-enforced by the same rule). E2E specs go under `src/routes/**` — enforced by review only, since `playwright.config.ts` `testMatch: '**/*.e2e.{ts,js}'` runs them anywhere.
 
@@ -58,10 +44,7 @@ Req N: ...
 
 ## 2. Test Guidelines
 
-### Naming
-
-- Variables/functions: `snake_case` | Constants: `UPPER_SNAKE_CASE`
-- Boolean prefix: `is_`, `has_`, `should_`, `can_`, `will_`, `did_`
+Naming, imports, `any`, `@ts-ignore`, magic numbers, template `String()` and the 10-statement limit are lint-enforced (`eslint/base.js`); this section holds only what lint cannot see.
 
 ### Test Functions
 
@@ -73,15 +56,6 @@ Req N: ...
 - Playwright: `for` loop; Vitest: `test.each` / `it.each`
 - Cases: a `cases` or `*_cases` array at file top, outside test functions
 
-### Constants
-
-- Magic numbers/strings except `0`, `1`, `-1` → `UPPER_SNAKE_CASE` constants after the imports
-
-### Imports
-
-- Always the `.js` extension: `import { foo } from './bar.js'`
-- Type imports: `import { type Foo } from '...'`
-
 ### Playwright
 
 - Select with `page.getByTestId('id')`; add `data-testid` to the implementation
@@ -102,17 +76,6 @@ When tests leave persistent state behind:
 ### Error Messages
 
 - State expected and actual values
-- Wrap `number` in template literals with `String()`
-- No `?? ''` unless the value can be `undefined`
-
-### Type Safety
-
-- No `any`; use every loop variable
-- `@ts-expect-error`, not `@ts-ignore`
-
-### Statement Limit
-
-- Max 10 statements per test function; split beyond that
 
 ### No live network
 
@@ -122,15 +85,15 @@ When tests leave persistent state behind:
 
 ### 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 `scripts/test/josh-harness.ts` — kit, a consumer without `docs/`, a lane worktree (joshuafolkken/kit#2402). Packed suite: `vitest.harness.config.ts`
+- 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`
 
 ---
 
 ## 3. Checklist
 
-- [ ] `pnpm josh gate`, then E2E per § 6: the CI E2E job where a pull request is open; where there is none, run `pnpm josh test:e2e` with `CI` unset (DEV: `pnpm run dev` on the port `playwright.config.ts` derives from `PORT_SEED`); no `pnpm build` or `CI=true` unless asked. Playwright cannot run here → report the E2E result missing and the gate not closed
-- [ ] `read_lints`: 0 errors on touched files; Playwright: no failures and no flaky runs
-- [ ] § 2 holds: constants, `.js` imports, `data-testid` selectors, correct `async`/`await`, no `any`, ≤10 statements, `String()` / no needless `?? ''`
+- [ ] `pnpm josh gate`, then the E2E gate per § 6
+- [ ] `pnpm josh lint:related`: 0 errors on touched files; Playwright: no failures and no flaky runs
+- [ ] § 2 holds: `data-testid` selectors, `async` Playwright tests, expected/actual in error messages
 
 ---
 
@@ -148,7 +111,7 @@ Reset module state at the start of each test (`reset_praise_audio_index()` in `s
 
 ## 6. Closing the E2E gate without a human run
 
-No human E2E run closes the gate, and nothing a red local run stopped is let through (`docs/maintainers/testing-guide-history.md`).
+No human E2E run closes the gate, and nothing a red local run stopped is let through.
 
 ### Which result closes the gate
 
@@ -161,6 +124,8 @@ Decided by whether a pull request is open:
 
 **Never ask the user to run it**, in either row, and never report completion on an unread E2E result — unread is not a pass.
 
+Second row: run with `CI` unset (DEV: `pnpm run dev` on the port `playwright.config.ts` derives from `PORT_SEED`); no `pnpm build` or `CI=true` unless asked. Playwright cannot run here → report the E2E result missing and the gate not closed.
+
 Second row: prefer an integrated gate when the installed toolkit's printed command list has one (not by toolkit or version) — `@joshuafolkken/app-kit`'s `pnpm josh-app verify` builds and boots once for E2E and the DAST scan, delegating E2E to `josh test:e2e` (so the skip below applies).
 
 ### A project with no E2E suite

package/scripts/agent/agent-argv.ts

@@ -4,6 +4,7 @@ import {
 	type AgentEnvironment,
 	type AgentProfile,
 	type AgentRole,
+	type ProfileResult,
 } from './agent-role-profile'
 import { claude_agent_argv } from './claude-agent-argv'
 import { codex_agent_argv } from './codex-agent-argv'
@@ -11,6 +12,8 @@ import { codex_agent_argv } from './codex-agent-argv'
 interface AgentArgv {
 	command: string
 	args: ReadonlyArray<string>
+	// The invocation is the last element, so `detached-launch.ts` lets that one break lines.
+	ends_with_prompt: true
 }
 
 type AgentArgvResult =
@@ -112,22 +115,35 @@ function resume_argv(
 		: with_profile_in(invocation, resolved.profile, cwd)
 }
 
+function profiled_in(invocation: string, resolved: ProfileResult, cwd: string): AgentArgvResult {
+	return resolved.kind === 'rejected'
+		? resolved
+		: with_profile_in(invocation, resolved.profile, cwd)
+}
+
 function resolve_in(
 	invocation: string,
 	role: AgentRole,
 	cwd: string,
 	environment: AgentEnvironment = process.env,
 ): AgentArgvResult {
-	const resolved = agent_role_profile.resolve(role, environment)
+	return profiled_in(invocation, agent_role_profile.resolve(role, environment), cwd)
+}
 
-	return resolved.kind === 'rejected'
-		? resolved
-		: with_profile_in(invocation, resolved.profile, cwd)
+// The reviewer for one review round, so a verification pass runs on its own profile.
+function review_in(
+	invocation: string,
+	round: number,
+	cwd: string,
+	environment: AgentEnvironment = process.env,
+): AgentArgvResult {
+	return profiled_in(invocation, agent_role_profile.resolve_review(round, environment), cwd)
 }
 
 const agent_argv = {
 	resolve,
 	resolve_in,
+	review_in,
 	resume_argv,
 	with_profile,
 	with_profile_in,

package/scripts/agent/agent-event.ts

@@ -1,15 +1,11 @@
 import { json_value } from '#scripts/lib/json-value'
+import { transcript_record, type TranscriptRecord } from '#scripts/lib/transcript-record'
 import { z } from 'zod'
 import type { AgentProvider } from './agent-role-profile'
 import { claude_result_event } from './claude-result-event'
 
-const TEXT_BLOCK_SCHEMA = z.looseObject({ type: z.literal('text'), text: z.string() })
-const CLAUDE_MESSAGE_SCHEMA = z.looseObject({ content: z.array(z.unknown()).optional() })
+const ASSISTANT_TYPE = 'assistant'
 const CLAUDE_INIT_SCHEMA = z.looseObject({ type: z.literal('system'), subtype: z.literal('init') })
-const CLAUDE_ASSISTANT_SCHEMA = z.looseObject({
-	type: z.literal('assistant'),
-	message: CLAUDE_MESSAGE_SCHEMA,
-})
 const USAGE_SCHEMA = z.looseObject({
 	input_tokens: z.number().optional(),
 	cached_input_tokens: z.number().optional(),
@@ -58,12 +54,16 @@ function usable_text(value: unknown): string | undefined {
 	return typeof value === 'string' && value.trim() !== '' ? value : undefined
 }
 
-function claude_progress(content: ReadonlyArray<unknown>): string | undefined {
-	return content
-		.map((block) => TEXT_BLOCK_SCHEMA.safeParse(block))
-		.filter((parsed) => parsed.success)
-		.map((parsed) => parsed.data.text)
-		.findLast((text) => text.trim() !== '')
+function claude_progress(record: TranscriptRecord): string | undefined {
+	return transcript_record
+		.blocks_of(record)
+		.filter((block) => block.type === transcript_record.TEXT_TYPE)
+		.map((block) => usable_text(block.text))
+		.findLast((text) => text !== undefined)
+}
+
+function is_claude_assistant(record: TranscriptRecord | undefined): record is TranscriptRecord {
+	return record?.type === ASSISTANT_TYPE && record.message !== undefined && record.message !== null
 }
 
 function claude_result(value: unknown, state: AgentEventState): AgentEventState | undefined {
@@ -80,9 +80,9 @@ function claude_result(value: unknown, state: AgentEventState): AgentEventState
 }
 
 function claude_assistant(value: unknown, state: AgentEventState): AgentEventState | undefined {
-	const assistant = CLAUDE_ASSISTANT_SCHEMA.safeParse(value)
-	if (!assistant.success) return undefined
-	const progress = claude_progress(assistant.data.message.content ?? []) ?? state.progress
+	const record = transcript_record.read(value)
+	if (!is_claude_assistant(record)) return undefined
+	const progress = claude_progress(record) ?? state.progress
 
 	return { ...state, provider: 'anthropic', progress }
 }

package/scripts/agent/agent-exit-record.ts

@@ -42,6 +42,18 @@ function is_mid_turn(transcript: string): boolean {
 	return TURN_TYPES.has(last)
 }
 
-const agent_exit_record = { is_mid_turn, read_exit_record }
+// Whether the transcript's last line is its exit record. A log appended across launches keeps an
+// earlier session's record, so a later session that died before finishing — inside a turn, or on a
+// start-up error that is not JSON — leaves something else last and its own ending unread.
+function ends_on_exit_record(transcript: string): boolean {
+	const last = transcript.split('\n').findLast((line) => line.trim() !== '')
+
+	return (
+		last !== undefined &&
+		claude_result_event.decode(json_value.parse_or_undefined(last)) !== undefined
+	)
+}
+
+const agent_exit_record = { ends_on_exit_record, is_mid_turn, read_exit_record }
 
 export { agent_exit_record }

package/scripts/agent/agent-role-profile.ts

@@ -1,11 +1,8 @@
 import { agent_session_environment } from '#scripts/josh/agent-session-environment'
 import { z } from 'zod'
+import { agent_safe_text } from './agent-safe-text'
 
-const FIRST_PRINTABLE_CODE = 0x20
-const DELETE_CODE = 0x7f
-const FIRST_CODE_POINT = 0
 const EMPTY_LENGTH = 0
-const MAX_VALUE_LENGTH = 4096
 
 const ROLE_SCHEMA = z.enum(['scheduler', 'worker', 'reviewer'])
 const PROVIDER_SCHEMA = z.enum(['anthropic', 'openai'])
@@ -32,6 +29,18 @@ type ProfileResult = { kind: 'profile'; profile: AgentProfile } | { kind: 'rejec
 type Rejected = Extract<ProfileResult, { kind: 'rejected' }>
 type EffortResult = Rejected | { kind: 'effort'; effort: AgentEffort }
 type ProviderResult = Rejected | { kind: 'provider'; provider: AgentProvider; is_default?: true }
+type OverrideField = 'model' | 'effort'
+
+interface Override {
+	key: string
+	value: string | undefined
+}
+
+// What a resolution is keyed on beyond the role: the run phase (effort) and the review round (profile).
+interface AgentStage {
+	phase?: string | undefined
+	round?: number
+}
 
 const SCHEDULER: AgentRole = 'scheduler'
 const WORKER: AgentRole = 'worker'
@@ -72,6 +81,22 @@ const OPENAI_PROFILES: Readonly<Record<AgentRole, AgentProfile>> = {
 
 const PROVIDER_PROFILES = { anthropic: DEFAULT_PROFILES, openai: OPENAI_PROFILES }
 
+// **The verification pass resolves a profile of its own** (joshuafolkken/kit#3926). A round after the
+// first only checks that the first round's findings were fixed, so its model and effort are set apart:
+// its own keys win, then the reviewer's, then its own default.
+const FIRST_REVIEW_ROUND = 1
+// Sonnet holds the verification pass by the eval criterion: on every `verification-fix-*` scenario its
+// pass/fail equals Opus's (100% agreement), and Opus passes all 4.
+const VERIFICATION_MODEL = 'claude-sonnet-5-5'
+const VERIFICATION_PROFILES: Readonly<Record<AgentProvider, AgentProfile>> = {
+	anthropic: { ...DEFAULT_PROFILES.reviewer, model: VERIFICATION_MODEL },
+	openai: OPENAI_PROFILES.reviewer,
+}
+const VERIFICATION_KEYS = {
+	model: 'JOSH_REVIEWER_VERIFICATION_MODEL',
+	effort: 'JOSH_REVIEWER_VERIFICATION_EFFORT',
+}
+
 // **Effort as a function of the run phase, not the role alone**. For the first
 // merge only the mechanical ship/bookkeeping region is lowered: the pre-gate resume drives the gate,
 // commit, PR and merge, applying fixes the gate has already named — work delegation.md calls the opposite
@@ -93,19 +118,7 @@ const ENV_KEYS: Readonly<Record<AgentRole, { model: string; effort: string }>> =
 
 const LEGACY_WORKER_KEYS = { model: 'JOSH_LANE_MODEL', effort: 'JOSH_LANE_EFFORT' }
 
-function is_control_character(character: string): boolean {
-	const code = character.codePointAt(FIRST_CODE_POINT) ?? FIRST_PRINTABLE_CODE
-
-	return code < FIRST_PRINTABLE_CODE || code === DELETE_CODE
-}
-
-function is_safe_value(value: string): boolean {
-	if (value.length === EMPTY_LENGTH || value.length > MAX_VALUE_LENGTH) return false
-
-	for (const character of value) if (is_control_character(character)) return false
-
-	return true
-}
+const { MAX_VALUE_LENGTH, is_safe_prompt, is_safe_value, printable } = agent_safe_text
 
 function trimmed(value: string | undefined): string | undefined {
 	const result = value?.trim()
@@ -113,44 +126,53 @@ function trimmed(value: string | undefined): string | undefined {
 	return result === undefined || result.length === EMPTY_LENGTH ? undefined : result
 }
 
-function override_value(
+function is_verification(role: AgentRole, round: number | undefined): boolean {
+	return role === REVIEWER && round !== undefined && round > FIRST_REVIEW_ROUND
+}
+
+// The keys an override is read from, first match wins: a worker falls back to its legacy lane keys, and
+// a verification round reads its own keys ahead of the reviewer's.
+function override_keys(
 	role: AgentRole,
-	field: 'model' | 'effort',
-	environment: AgentEnvironment,
-): { key: string; value: string | undefined } {
+	field: OverrideField,
+	round: number | undefined,
+): readonly [string, ...Array<string>] {
 	const key = ENV_KEYS[role][field]
-	const value = trimmed(environment[key])
-	if (value !== undefined) return { key, value }
-	if (role !== WORKER) return { key, value: undefined }
+	if (role === WORKER) return [key, LEGACY_WORKER_KEYS[field]]
 
-	const legacy = LEGACY_WORKER_KEYS[field]
-	const legacy_value = trimmed(environment[legacy])
+	return is_verification(role, round) ? [VERIFICATION_KEYS[field], key] : [key]
+}
 
-	return legacy_value === undefined
-		? { key, value: undefined }
-		: { key: legacy, value: legacy_value }
+function override_value(
+	role: AgentRole,
+	field: OverrideField,
+	environment: AgentEnvironment,
+	round?: number,
+): Override {
+	const keys = override_keys(role, field, round)
+	const key = keys.find((candidate) => trimmed(environment[candidate]) !== undefined)
+
+	return key === undefined
+		? { key: keys[0], value: undefined }
+		: { key, value: trimmed(environment[key]) }
 }
 
 function model_override(
 	role: AgentRole,
 	environment: AgentEnvironment,
 	provider: AgentProvider,
-): { key: string; value: string | undefined } {
-	const key = ENV_KEYS[role].model
-
+	round: number | undefined,
+): Override {
 	return provider === OPENAI_PROVIDER
-		? { key, value: undefined }
-		: override_value(role, 'model', environment)
+		? { key: ENV_KEYS[role].model, value: undefined }
+		: override_value(role, 'model', environment, round)
 }
 
 function rejection(key: string, value: string, expected: string): Rejected {
 	return { kind: 'rejected', note: `${key}=${value} ${expected}, so the agent was not started` }
 }
 
-function resolved_effort(
-	override: { key: string; value: string | undefined },
-	fallback: AgentEffort,
-): EffortResult {
+function resolved_effort(override: Override, fallback: AgentEffort): EffortResult {
 	const parsed = EFFORT_SCHEMA.safeParse(override.value ?? fallback)
 
 	return parsed.success
@@ -290,17 +312,27 @@ function with_phase_effort(
 	return { ...profile, effort: overridden_effort(profile, phase, environment) }
 }
 
-function resolve(
+function stage_defaults(
+	provider: AgentProvider,
 	role: AgentRole,
-	environment: AgentEnvironment = process.env,
-	phase?: string,
+	round: number | undefined,
+): AgentProfile {
+	return is_verification(role, round)
+		? VERIFICATION_PROFILES[provider]
+		: PROVIDER_PROFILES[provider][role]
+}
+
+function resolve_stage(
+	role: AgentRole,
+	environment: AgentEnvironment,
+	stage: AgentStage,
 ): ProfileResult {
 	const selected = resolve_provider(environment)
 	if (selected.kind === 'rejected') return selected
-	const defaults = PROVIDER_PROFILES[selected.provider][role]
-	const model = model_override(role, environment, selected.provider)
-	const effort = override_value(role, 'effort', environment)
-	const resolved = resolved_effort(effort, phase_effort(role, phase, defaults.effort))
+	const defaults = stage_defaults(selected.provider, role, stage.round)
+	const model = model_override(role, environment, selected.provider, stage.round)
+	const effort = override_value(role, 'effort', environment, stage.round)
+	const resolved = resolved_effort(effort, phase_effort(role, stage.phase, defaults.effort))
 
 	if (resolved.kind === 'rejected') return resolved
 
@@ -314,10 +346,29 @@ function resolve(
 	return validate(profile, model.key)
 }
 
+function resolve(
+	role: AgentRole,
+	environment: AgentEnvironment = process.env,
+	phase?: string,
+): ProfileResult {
+	return resolve_stage(role, environment, { phase })
+}
+
+// The reviewer for one review round: round 1 as `resolve(REVIEWER)` does, any later round the
+// verification pass's own profile.
+function resolve_review(round: number, environment: AgentEnvironment = process.env): ProfileResult {
+	return resolve_stage(REVIEWER, environment, { round })
+}
+
 function describe(profile: AgentProfile): string {
 	return `provider=${profile.provider} role=${profile.role} model=${profile.model} effort=${profile.effort}`
 }
 
+// The run-log line a review launch writes, so each round's model is on record beside its round.
+function describe_review(round: number, profile: AgentProfile): string {
+	return `review round ${String(round)} · ${describe(profile)}`
+}
+
 function parse(value: unknown): AgentProfile | undefined {
 	const parsed = PROFILE_SCHEMA.safeParse(value)
 
@@ -335,15 +386,20 @@ const agent_role_profile = {
 	PROFILE_SCHEMA,
 	REVIEWER,
 	SCHEDULER,
+	VERIFICATION_PROFILES,
 	WORKER,
 	default_notice,
 	describe,
+	describe_review,
 	handoff_environment,
 	has_completion_callback,
+	is_safe_prompt,
 	is_safe_value,
 	parse,
+	printable,
 	resolve,
 	resolve_provider,
+	resolve_review,
 	warn_of_default,
 	with_phase_effort,
 }