@joshuafolkken/kit 1.1784.0 → 1.2114.0

package/scripts/run/ship/run-ship-review.ts

@@ -1,5 +1,8 @@
 import { issue_cite } from '#scripts/issue/issue-cite'
+import { review_attest, type ReviewSlot } from '#scripts/review/review-attest'
 import { review_finding_ledger } from '#scripts/review/review-finding-ledger'
+import { review_finding_text } from '#scripts/review/review-finding-text'
+import { review_prior_findings } from '#scripts/review/review-prior-findings'
 import { review_record_cli } from '#scripts/review/review-record-cli'
 
 // The pure half of `josh ship --review`: the one-line prompts the supervised reviewers are launched
@@ -24,17 +27,14 @@ const HIGH = 'high'
 const MEDIUM = 'medium'
 const FIXED_PREFIX = 'fixed '
 const KIND_FIELDS = 2
-// What a finding line carries after its spec: one sentence saying what is wrong, so a stopped ship's
-// log tells the resumed lane child the defect rather than only its location.
-const DESCRIPTION_SEPARATOR = ' — '
-// Where the spec ends on read: a reviewer that types the dash as `-`, `--` or `–` still ends it there,
-// so its sentence never lands in the ledger's file field.
-const DESCRIPTION_BOUNDARY = / [—–-]{1,2} /u
-// Where a description's first sentence ends, and the cap that keeps a run-on one a line. Japanese
-// sets no space after `。`, so it ends a sentence on its own.
-const SENTENCE_END = /(?<=[.!?])\s|(?<=。)/u
-const SENTENCE_LIMIT = 200
-const ELLIPSIS = '…'
+// `findings_path` is set only for a lane whose josh predates `review:submit`
+// (`lane-session-action.ts`).
+type PromptOf = (
+	brief_path: string,
+	slot: ReviewSlot,
+	issue: string,
+	findings_path?: string,
+) => string
 
 const VERDICT = {
 	CLEAN: 'clean',
@@ -78,24 +78,68 @@ const MISSING_NOTE = 'the reviewer wrote no findings file — the review did not
 const CLEAN_NOTE = 'review clean or Low-only — recorded; shipping on.'
 const FIXED_NOTE =
 	'review fixes applied in place — recorded; the gate re-runs on the fixed tree and round 2 follows the commit.'
-const BLOCKING_NOTE =
-	'review found High/Medium it did not fix — recorded; fix them, then take the round-2 route (`chain-rule.md`).'
+// Every stop that hands findings back for a fix: a fix of only the cited line left the same pattern
+// beside it for the next round to stop on again (joshuafolkken/kit#4673).
+const SWEEP_INSTRUCTION = [
+	'Before fixing, sweep each finding for its other sites — the same file, the callers of the same',
+	'function and a grep of the pattern — fix every site in one pass, and list each range searched on its',
+	'own line in the Issue fix comment.',
+].join(' ')
+const BLOCKING_NOTE = `review found High/Medium it did not fix — recorded. ${SWEEP_INSTRUCTION} Then take the round-2 route (\`chain-rule.md\`).`
 const UNVERIFIED_OUTCOME: RoundOutcome = {
 	is_passing: false,
-	note: 'review fixes did not pass the scoped checks — recorded as unfixed; fix them, then take the round-2 route (`chain-rule.md`).',
+	note: `review fixes did not pass the scoped checks — recorded as unfixed. ${SWEEP_INSTRUCTION} Then take the round-2 route (\`chain-rule.md\`).`,
 }
+// The findings line is all a stopped ship hands the lane, so the other sites the rubric asks the
+// reviewer to cite ride on it rather than in its prose report (joshuafolkken/kit#4673).
+const OTHER_SITES_CLAUSE = '"other sites: <file>:<line>, …" for each other site of the same pattern'
 const ROUND_TWO_CLEAN_NOTE = 'round 2 clean or Low-only — recorded; shipping on.'
-const ROUND_TWO_BLOCKING_NOTE =
-	'round 2 found High/Medium or edited the tree — recorded; round 2 is final: fix, push and gate it, then run followup (`chain-rule.md` step 4).'
+const SUBMIT_COMMAND = 'pnpm josh review:submit'
+const ROUND_TWO_BLOCKING_NOTE = `round 2 found High/Medium or edited the tree — recorded; round 2 is final. ${SWEEP_INSTRUCTION} Then push and gate it, and run followup (\`chain-rule.md\` step 4).`
+
+// **The reviewer hands its findings to a command, never to a path it copies** (joshuafolkken/kit#4799):
+// a reviewer that copied the findings path matched the `josh-review-*` files beside it and dropped
+// `ship-`, so the supervisor never read a review it had finished. `review:submit` knows the slot's path.
+function submit_command(slot: ReviewSlot): string {
+	return slot === review_attest.REVIEW_SLOT.CODE
+		? SUBMIT_COMMAND
+		: `${SUBMIT_COMMAND} --interaction`
+}
+
+// **A lane whose josh predates `review:submit` is handed the path**: the supervisor reloads onto main
+// at its pass boundary (`run-wake-code.ts`), so it meets lanes branched before the command existed.
+function sink_clauses(
+	slot: ReviewSlot,
+	findings_path: string | undefined,
+): readonly [string, string] {
+	if (findings_path !== undefined) {
+		return [
+			`Then write every finding to ${findings_path},`,
+			'and an empty file when there is none.',
+		]
+	}
+
+	return [
+		`Then pipe every finding on stdin to \`${submit_command(slot)}\` — never write a findings file yourself —`,
+		'or run it with `--none` and no stdin when there is none; if it refuses a line, fix that line and run it again.',
+	]
+}
 
-function findings_instruction(findings_path: string, fixed_clause: string): string {
+function findings_instruction(
+	slot: ReviewSlot,
+	fixed_clause: string,
+	findings_path: string | undefined,
+): string {
 	const categories = review_finding_ledger.CATEGORIES.join(', ')
+	const [opening, closing] = sink_clauses(slot, findings_path)
 
 	return [
-		`Then write every finding to ${findings_path}, one per line as`,
-		`<category>:<severity>:<file>[:<line>]${DESCRIPTION_SEPARATOR}<one sentence: what is wrong and why>`,
+		opening,
+		'one per line as',
+		`<category>:<severity>:<file>[:<line>]${review_finding_text.DESCRIPTION_SEPARATOR}<one sentence: what is wrong and why>`,
 		`(category one of ${categories}; severity high, medium or low)${fixed_clause},`,
-		'and an empty file when there is none.',
+		`a high or medium line ending with ${OTHER_SITES_CLAUSE},`,
+		closing,
 	].join(' ')
 }
 
@@ -109,56 +153,99 @@ function issue_read_instruction(issue: string): string {
 	].join(' ')
 }
 
+// **The review runs in this session itself** (joshuafolkken/kit#4715): a reviewer that invoked the
+// `/code-review` skill forked a second agent that read the same diff and brief again. The session is
+// launched without the `Skill` and `Agent` tools (`claude-agent-argv.ts`), and the prompt says so.
+const IN_SESSION_CLAUSE =
+	'Review it yourself in this session — you carry no Skill or Agent tool, so never launch a second reviewer.'
+
+function round_one_opening(brief_path: string): string {
+	return [
+		`Review this checkout as a /code-review: read the review brief at ${brief_path} and follow it exactly —`,
+		'the level on its first line, the rubric it names, the checkout it pins and its review:attest step.',
+		IN_SESSION_CLAUSE,
+	].join(' ')
+}
+
 // One line, because `detached_launch` refuses an argument carrying a control character: the multi-line
 // brief travels by path, never inline.
-function reviewer_prompt(brief_path: string, findings_path: string, issue: string): string {
+function reviewer_prompt(
+	brief_path: string,
+	slot: ReviewSlot,
+	issue: string,
+	findings_path?: string,
+): string {
 	return [
-		`Run a /code-review of this checkout: read the review brief at ${brief_path} and follow it exactly —`,
-		'the level on its first line, the rubric it names, the checkout it pins and its review:attest step.',
+		round_one_opening(brief_path),
 		issue_read_instruction(issue),
+		...review_prior_findings.prompt_clauses(issue),
 		'Apply a fix only for a Medium finding whose fix is small and local — a one-function refactor, an',
 		'added test, an added guard; never fix a High or a change that reaches beyond one place, and never',
 		'commit, stage or push. After any fix, run `pnpm josh lint:related && pnpm josh test:related` and',
 		'return only once both are green; revert a fix you cannot get green and report that finding unfixed.',
-		findings_instruction(findings_path, `, prefixing a finding you fixed with "${FIXED_PREFIX}"`),
+		findings_instruction(
+			slot,
+			`, prefixing a finding you fixed with "${FIXED_PREFIX}"`,
+			findings_path,
+		),
 	].join(' ')
 }
 
+// The round-1 review run beside the code review: it reads only, so the two sessions never fix, verify
+// and revert in the one shared checkout at once; its findings go to the lane's one fix pass.
+function report_prompt(
+	brief_path: string,
+	slot: ReviewSlot,
+	issue: string,
+	findings_path?: string,
+): string {
+	return [
+		round_one_opening(brief_path),
+		'Do not edit any file: the code review running beside this one fixes in this checkout.',
+		issue_read_instruction(issue),
+		...review_prior_findings.prompt_clauses(issue),
+		findings_instruction(slot, '', findings_path),
+	].join(' ')
+}
+
+// **One reviewer edits the checkout** (joshuafolkken/kit#4672): a slot reviewed beside the code slot
+// reads only, and a slot reviewed alone takes the round's own prompt.
+function slot_prompt(
+	round_prompt: PromptOf,
+	slot: ReviewSlot,
+	slots: ReadonlyArray<ReviewSlot>,
+): PromptOf {
+	if (slot === review_attest.REVIEW_SLOT.CODE || slots.length === 1) return round_prompt
+
+	return report_prompt
+}
+
 // The round-2 verification pass: a fresh session over the round-1 fix delta, reading only.
-function verification_prompt(brief_path: string, findings_path: string, issue: string): string {
+function verification_prompt(
+	brief_path: string,
+	slot: ReviewSlot,
+	issue: string,
+	findings_path?: string,
+): string {
 	return [
-		`Run a /code-review of this checkout — the round-2 verification pass over the round-1 fixes: read the`,
+		`Review this checkout as a /code-review — the round-2 verification pass over the round-1 fixes: read the`,
 		`review brief at ${brief_path} and follow it exactly — the level on its first line, the rubric it`,
 		'names, the checkout it pins and its review:attest step. Do not edit any file.',
+		IN_SESSION_CLAUSE,
 		issue_read_instruction(issue),
-		findings_instruction(findings_path, ''),
+		...review_prior_findings.prompt_clauses(issue),
+		findings_instruction(slot, '', findings_path),
 	].join(' ')
 }
 
 // The spec is what `review:record` reads; the description after it travels in the stage output and,
 // for a finding that stopped the ship, its first sentence in the durable stop log.
-function split_description(unmarked: string): { spec: string; description: string } {
-	const boundary = DESCRIPTION_BOUNDARY.exec(unmarked)
-
-	if (boundary === null) return { spec: unmarked.trim(), description: '' }
-
-	const rest = unmarked.slice(boundary.index + boundary[0].length)
-
-	return { spec: unmarked.slice(0, boundary.index).trim(), description: rest.trim() }
-}
-
 function finding_of(line: string): Finding {
 	const is_fixed = line.startsWith(FIXED_PREFIX)
 
-	return { ...split_description(is_fixed ? line.slice(FIXED_PREFIX.length) : line), is_fixed, line }
-}
-
-function first_sentence(description: string): string {
-	const [sentence = ''] = description.split(SENTENCE_END, 1)
+	const unmarked = is_fixed ? line.slice(FIXED_PREFIX.length) : line
 
-	if (sentence.length <= SENTENCE_LIMIT) return sentence
-
-	return `${sentence.slice(0, SENTENCE_LIMIT - ELLIPSIS.length)}${ELLIPSIS}`
+	return { ...review_finding_text.split_description(unmarked), is_fixed, line }
 }
 
 function spec_findings(text: string): ReadonlyArray<Finding> {
@@ -192,7 +279,11 @@ function kinds_of(findings: ReadonlyArray<Finding>): ReadonlyArray<string> {
 function stop_finding_of(finding: Finding): StopFinding {
 	const location = review_record_cli.parse_finding(finding.spec)?.file ?? ''
 
-	return { kind: kind_of(finding), location, sentence: first_sentence(finding.description) }
+	return {
+		kind: kind_of(finding),
+		location,
+		sentence: review_finding_text.first_sentence(finding.description),
+	}
 }
 
 // `bug-risks:medium` — each kind of finding that decided a stopped stage, once per kind (the stop
@@ -218,6 +309,14 @@ function blocking_details(text: string): ReadonlyArray<StopFinding> {
 	return deciding_findings(text).map((finding) => stop_finding_of(finding))
 }
 
+// The findings a passing round 1 fixed in place — the stop log's only chance to see them, since no stop
+// follows (joshuafolkken/kit#4780); none for any other round.
+function passing_fixes(verdict: ScoredVerdict, outcome: RoundOutcome): ReadonlyArray<StopFinding> {
+	if (!outcome.is_passing || verdict.kind !== VERDICT.FIXED) return []
+
+	return blocking_details(verdict.report.join('\n'))
+}
+
 function scored_kind(findings: ReadonlyArray<Finding>): ScoredVerdict['kind'] {
 	if (findings.some((finding) => is_blocking(finding))) return VERDICT.BLOCKING
 
@@ -225,9 +324,10 @@ function scored_kind(findings: ReadonlyArray<Finding>): ScoredVerdict['kind'] {
 }
 
 // Absent means the reviewer never finished; a line outside the grammar means its verdict cannot be
-// recorded — both stop the ship rather than read as clean. The specs are recorded without the `fixed`
-// mark: a fixed finding was still a finding of that round. The report keeps each line whole — mark and
-// description — for the stage output a resumed lane child reads.
+// recorded — both stop the ship rather than read as clean. A fixed finding is recorded with its
+// `fixed` mark, the disposition `review:record` keeps in the ledger and `review:round2` reads round 1's
+// closure from (joshuafolkken/kit#5286). The report keeps each line whole — mark and description — for
+// the stage output a resumed lane child reads.
 function read_verdict(text: string | undefined): ReviewVerdict {
 	if (text === undefined) return { kind: VERDICT.INVALID, note: MISSING_NOTE }
 
@@ -240,11 +340,23 @@ function read_verdict(text: string | undefined): ReviewVerdict {
 
 	return {
 		kind: scored_kind(findings),
-		specs: findings.map((finding) => finding.spec),
+		specs: findings.map((finding) =>
+			finding.is_fixed ? `${FIXED_PREFIX}${finding.spec}` : finding.spec,
+		),
 		report: findings.map((finding) => finding.line),
 	}
 }
 
+// The specs `review:record` is given: a stopped round's `fixed` marks are dropped, since a fix the scoped
+// pair turned down, or one beside a finding still blocking, has not closed what it marks.
+function recorded_specs(verdict: ScoredVerdict, outcome: RoundOutcome): ReadonlyArray<string> {
+	if (outcome.is_passing) return verdict.specs
+
+	return verdict.specs.map((spec) =>
+		spec.startsWith(FIXED_PREFIX) ? spec.slice(FIXED_PREFIX.length) : spec,
+	)
+}
+
 // Round 1 passes clean or with every blocking finding fixed in place; round 2 follows the commit.
 function round_one_outcome(verdict: ScoredVerdict): RoundOutcome {
 	if (verdict.kind === VERDICT.BLOCKING) return { is_passing: false, note: BLOCKING_NOTE }
@@ -279,18 +391,26 @@ function round_two_outcome(verdict: ScoredVerdict): RoundOutcome {
 
 const run_ship_review = {
 	FIXED_PREFIX,
+	OTHER_SITES_CLAUSE,
+	SWEEP_INSTRUCTION,
 	UNVERIFIED_OUTCOME,
 	VERDICT,
 	blocking_details,
 	blocking_kinds,
 	has_fixes,
 	is_clean_round_one,
+	passing_fixes,
 	read_verdict,
+	recorded_specs,
+	report_prompt,
 	reviewer_prompt,
+	round_one_opening,
 	round_one_outcome,
 	round_two_outcome,
+	slot_prompt,
+	submit_command,
 	verification_prompt,
 }
 
-export type { ReviewVerdict, RoundOutcome, ScoredVerdict, StopFinding }
+export type { PromptOf, ReviewVerdict, RoundOutcome, ScoredVerdict, StopFinding }
 export { run_ship_review }

package/scripts/run/ship/run-ship-reviewer.ts

@@ -1,4 +1,4 @@
-import { agent_argv, type AgentArgv } from '#scripts/agent/agent-argv'
+import { agent_argv, type AgentArgv, type AgentArgvResult } from '#scripts/agent/agent-argv'
 import { agent_role_profile, type AgentProfile } from '#scripts/agent/agent-role-profile'
 import { api_auth } from '#scripts/agent/api-auth'
 import { PROJECT_ROOT } from '#scripts/init/init-paths'
@@ -6,8 +6,10 @@ import { josh_command, type JoshResult } from '#scripts/josh/josh-run'
 import { stamp_file } from '#scripts/josh/stamp-file'
 import { lane_child_marker } from '#scripts/lane/lane-child-marker'
 import { lane_session_broker } from '#scripts/lane/lane-session-broker'
+import { review_attest, type ReviewSlot } from '#scripts/review/review-attest'
 import { detached_launch } from '#scripts/run/detached-launch'
-import { run_ship_review } from './run-ship-review'
+import { run_ship_brokered_review } from './run-ship-brokered-review'
+import { run_ship_review, type PromptOf } from './run-ship-review'
 import type { Phase } from './run-ship-scoped'
 import { run_ship_stop_cause, type Cause } from './run-ship-stop-cause'
 import type { StepResult } from './run-ship-sync'
@@ -22,13 +24,24 @@ const should_forward_stderr = true
 const ATTEST_CHECK = ['review:attest', '--check']
 const KEPT_REVIEW_NOTE =
 	'the reviewer wrote its findings before it failed — its review is kept; attest and record judge it.'
+const MISSING_FINDINGS_NOTE = 'the reviewer submitted no findings; nothing is at the slot path:'
 type Round = '1' | '2'
 
 const ROUND_ONE: Round = '1'
 const ROUND_TWO: Round = '2'
-type PromptOf = (brief_path: string, findings_path: string, issue: string) => string
+
+interface SlotOpen {
+	open: ReadonlyArray<string>
+	slot: ReviewSlot
+}
+
+interface Briefed {
+	brief: string
+	slot: ReviewSlot
+}
 
 const { CAUSE } = run_ship_stop_cause
+const { CODE } = review_attest.REVIEW_SLOT
 
 // **Every stop is tagged with the step's own cause**, so a round that stopped on a red join, a reviewer
 // that did not finish or a refused attestation is not booked as a finding (joshuafolkken/kit#4431).
@@ -44,8 +57,8 @@ function tagged_phase(cause: Cause, phase: Phase): Phase {
 	return async () => tagged(cause, await phase())
 }
 
-function paths(): { brief: string; findings: string; log: string } {
-	return lane_session_broker.review_paths(PROJECT_ROOT)
+function paths(slot?: ReviewSlot): { brief: string; findings: string; log: string } {
+	return lane_session_broker.review_paths(PROJECT_ROOT, slot)
 }
 
 async function josh(argv: ReadonlyArray<string>): Promise<JoshResult> {
@@ -66,17 +79,39 @@ function exited_note(log_path: string): string {
 	return `${api_auth.AUTH_FAILURE_NOTE}: ${exited}`
 }
 
-function current_verdict(): ReturnType<typeof run_ship_review.read_verdict> {
-	return run_ship_review.read_verdict(stamp_file.read_stamp_text(paths().findings))
+function current_verdict(slot?: ReviewSlot): ReturnType<typeof run_ship_review.read_verdict> {
+	return run_ship_review.read_verdict(stamp_file.read_stamp_text(paths(slot).findings))
+}
+
+// **A session that ended with no findings file names the slot's path** (joshuafolkken/kit#4774) — the
+// one `review:submit` writes, or the one a lane predating it was told to write: a reviewer that never
+// submitted otherwise stops the round later, on a join or a record that never says the file is missing.
+function missing_findings(slots: ReadonlyArray<ReviewSlot>): string | undefined {
+	const missing = slots
+		.map((slot) => paths(slot).findings)
+		.filter((findings) => stamp_file.read_stamp_text(findings) === undefined)
+
+	return missing.length === 0 ? undefined : `${MISSING_FINDINGS_NOTE} ${missing.join(', ')}`
+}
+
+function finished_session(slots: ReadonlyArray<ReviewSlot>): JoshResult {
+	const missing = missing_findings(slots)
+
+	return missing === undefined
+		? { code: SUCCESS_EXIT_CODE, out: '' }
+		: failure(missing, CAUSE.INFRA)
 }
 
 // **A session that ran and then failed keeps the review it wrote** (joshuafolkken/kit#4562). The
 // findings file is removed before the launch and written as the reviewer's last step, so a readable one
 // is this session's finished review — a late auth failure or a lost broker reply then costs nothing,
 // where a relaunch would review the whole change again. The attest and record phases still judge it.
-function ended_session(failed_note: string): JoshResult {
-	if (current_verdict().kind === run_ship_review.VERDICT.INVALID) {
-		return failure(failed_note, CAUSE.INFRA)
+// A broker answers for every slot it ran at once, so each slot's file must be readable.
+function ended_session(failed_note: string, slots: ReadonlyArray<ReviewSlot> = [CODE]): JoshResult {
+	if (slots.some((slot) => current_verdict(slot).kind === run_ship_review.VERDICT.INVALID)) {
+		const missing = missing_findings(slots)
+
+		return failure(missing === undefined ? failed_note : `${failed_note}\n${missing}`, CAUSE.INFRA)
 	}
 
 	note(`${failed_note}\n${KEPT_REVIEW_NOTE}`)
@@ -86,13 +121,15 @@ function ended_session(failed_note: string): JoshResult {
 
 // Under the round's reviewer profile — the same model and effort (`JOSH_REVIEWER_*` included) the
 // chain's subagent is given — and waited on, so the join below runs only once the review has finished.
-// Each call is its own process, so round 2 is a fresh session by construction.
+// Each call is its own process, so round 2 is a fresh session by construction. A failed session is
+// judged on its own slot's findings, not on a sibling's still being written.
 async function run_direct_session(
 	argv: AgentArgv,
 	profile: AgentProfile,
-	log_path: string,
+	slot: ReviewSlot,
 	round: Round,
 ): Promise<JoshResult> {
+	const log_path = paths(slot).log
 	const request = { argv, cwd: PROJECT_ROOT, log_path, profile }
 
 	note(agent_role_profile.describe_review(Number(round), profile))
@@ -102,9 +139,9 @@ async function run_direct_session(
 		return failure(`reviewer could not start: ${result.note}`, CAUSE.INFRA)
 	}
 
-	if (result.exit_code !== SUCCESS_EXIT_CODE) return ended_session(exited_note(log_path))
+	if (result.exit_code !== SUCCESS_EXIT_CODE) return ended_session(exited_note(log_path), [slot])
 
-	return { code: SUCCESS_EXIT_CODE, out: '' }
+	return finished_session([slot])
 }
 
 // A lane child's reviewer is started by the lane's broker: an OpenAI lane's always, since a nested Codex
@@ -117,77 +154,135 @@ function is_brokered(profile: AgentProfile, issue: string): boolean {
 	return profile.provider === 'openai' || lane_session_broker.is_serving(PROJECT_ROOT, issue)
 }
 
-async function run_session(
-	prompt: string,
-	log_path: string,
+interface SlotSession {
+	slot: ReviewSlot
+	built: AgentArgvResult
+}
+
+function session_for(
+	prompt_of: PromptOf,
 	issue: string,
 	round: Round,
-): Promise<JoshResult> {
-	const built = agent_argv.review_in(prompt, Number(round), PROJECT_ROOT)
+	slots: { slot: ReviewSlot; all: ReadonlyArray<ReviewSlot> },
+): SlotSession {
+	const { slot, all } = slots
+	const prompt = run_ship_review.slot_prompt(prompt_of, slot, all)(paths(slot).brief, slot, issue)
+
+	return { slot, built: agent_argv.review_in(prompt, Number(round), PROJECT_ROOT) }
+}
+
+async function run_slot(session: SlotSession, round: Round): Promise<JoshResult> {
+	const { built, slot } = session
 
 	if (built.kind === 'rejected') {
 		return failure(`reviewer profile rejected: ${built.note}`, CAUSE.INFRA)
 	}
 
-	if (!is_brokered(built.profile, issue)) {
-		return await run_direct_session(built.argv, built.profile, log_path, round)
-	}
+	return await run_direct_session(built.argv, built.profile, slot, round)
+}
 
-	const answer = await lane_session_broker.request(PROJECT_ROOT, issue, { kind: 'review', round })
+async function run_brokered(
+	issue: string,
+	round: Round,
+	slots: ReadonlyArray<ReviewSlot>,
+): Promise<JoshResult> {
+	const answer = await run_ship_brokered_review.request(PROJECT_ROOT, issue, round, slots)
 
 	return answer.is_success
-		? { code: SUCCESS_EXIT_CODE, out: '' }
-		: ended_session(`isolated reviewer failed: ${answer.reason}`)
+		? finished_session(slots)
+		: ended_session(`isolated reviewer failed: ${answer.reason}`, slots)
+}
+
+// **The slots' reviewers run side by side** (joshuafolkken/kit#4672), and the first failure among
+// them is the result — each slot is launched through the same path a single review takes.
+async function run_sessions(
+	prompt_of: PromptOf,
+	issue: string,
+	round: Round,
+	slots: ReadonlyArray<ReviewSlot>,
+): Promise<JoshResult> {
+	const sessions = slots.map((slot) => session_for(prompt_of, issue, round, { slot, all: slots }))
+	const [first] = sessions
+
+	if (first?.built.kind === 'argv' && is_brokered(first.built.profile, issue)) {
+		return await run_brokered(issue, round, slots)
+	}
+
+	const results = await Promise.all(sessions.map(async (session) => await run_slot(session, round)))
+
+	return (
+		results.find((result) => result.code !== SUCCESS_EXIT_CODE) ?? {
+			code: SUCCESS_EXIT_CODE,
+			out: '',
+		}
+	)
 }
 
 // The brief goes to a file and the previous round's findings are removed, so a reviewer that writes
 // nothing reads as unfinished rather than as the last round's verdict.
-async function launch_reviewer(
-	brief: string,
+async function launch_reviewers(
+	briefs: ReadonlyArray<Briefed>,
 	prompt_of: PromptOf,
 	issue: string,
 	round: Round,
 ): Promise<JoshResult> {
-	const target = paths()
+	for (const { brief, slot } of briefs) {
+		const target = paths(slot)
 
-	stamp_file.write_text_stamp(target.brief, brief)
-	stamp_file.remove_stamp(target.findings)
+		stamp_file.write_text_stamp(target.brief, brief)
+		stamp_file.remove_stamp(target.findings)
+	}
 
-	return await run_session(
-		prompt_of(target.brief, target.findings, issue),
-		target.log,
+	return await run_sessions(
+		prompt_of,
 		issue,
 		round,
+		briefs.map(({ slot }) => slot),
 	)
 }
 
 // A refused attestation — the issue changed after the brief, an update left unread, no attestation —
-// is no finding: the round read what it was briefed on.
+// is no finding: the round read what it was briefed on. `review:attest --check` asks every slot.
 async function attest_phase(): Promise<StepResult> {
 	return tagged(CAUSE.ATTEST, await josh(ATTEST_CHECK))
 }
 
-// A brief-minting command, then a reviewer handed what it printed.
-function reviewed(
-	open: ReadonlyArray<string>,
+// Each slot's brief-minting command in turn, then their reviewers side by side, each handed what its
+// command printed. The slots are the ones asked for, not the ones whose command has run so far.
+function reviewed_together(
+	opens: ReadonlyArray<SlotOpen>,
 	prompt_of: PromptOf,
 	issue: string,
 	round: Round,
 ): ReadonlyArray<Phase> {
-	const opened = { brief: '' }
+	const printed = new Map<ReviewSlot, string>()
+
+	function briefs(): ReadonlyArray<Briefed> {
+		return opens.map(({ slot }) => ({ brief: printed.get(slot) ?? '', slot }))
+	}
 
 	return [
-		async () => {
+		...opens.map(({ open, slot }) => async () => {
 			const result = await josh(open)
 
-			opened.brief = result.out
+			printed.set(slot, result.out)
 
 			return tagged(CAUSE.CHECK, result)
-		},
-		async () => await launch_reviewer(opened.brief, prompt_of, issue, round),
+		}),
+		async () => await launch_reviewers(briefs(), prompt_of, issue, round),
 	]
 }
 
+// A brief-minting command, then a reviewer handed what it printed.
+function reviewed(
+	open: ReadonlyArray<string>,
+	prompt_of: PromptOf,
+	issue: string,
+	round: Round,
+): ReadonlyArray<Phase> {
+	return reviewed_together([{ open, slot: CODE }], prompt_of, issue, round)
+}
+
 const run_ship_reviewer = {
 	attest_phase,
 	current_verdict,
@@ -196,6 +291,7 @@ const run_ship_reviewer = {
 	note,
 	paths,
 	reviewed,
+	reviewed_together,
 	ROUND_ONE,
 	ROUND_TWO,
 	SUCCESS_EXIT_CODE,