@joshuafolkken/kit 1.2116.0 → 1.3041.0

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

@@ -0,0 +1,112 @@
+import { gate_tree, type GateTree } from '#scripts/gate/gate-tree'
+import { git_command } from '#scripts/git/git-command'
+import { PROJECT_ROOT } from '#scripts/init/init-paths'
+import { file_map_stamp, type FileMapStampAccess } from '#scripts/josh/file-map-stamp'
+import type { JoshResult } from '#scripts/josh/josh-run'
+import { review_attest } from '#scripts/review/review-attest'
+import { run_ship_scoped, type Phase } from './run-ship-scoped'
+
+type NamedPhase = readonly [name: string, phase: Phase]
+
+interface Checkpoint {
+	name: string
+	phase: Phase
+	stamp: FileMapStampAccess
+}
+
+function checkpoints(
+	issue: string,
+	stage: string,
+	phases: ReadonlyArray<NamedPhase>,
+	head: string,
+): ReadonlyArray<Checkpoint> {
+	return phases.map(([name, phase]) => ({
+		name,
+		phase,
+		stamp: file_map_stamp.create(
+			`josh-ship-review-step-${issue}-${stage}-${name}-`,
+			PROJECT_ROOT,
+			() => head,
+		),
+	}))
+}
+
+function matches(stamp: FileMapStampAccess, tree: GateTree): boolean {
+	const prior = stamp.read()
+
+	if (prior?.completed_at === undefined) return false
+
+	return (
+		stamp.describes_inputs(prior) &&
+		file_map_stamp.describes_base(prior, tree.base) &&
+		file_map_stamp.changed_since(prior, tree.files).length === 0
+	)
+}
+
+async function attested_prefix(entries: ReadonlyArray<Checkpoint>, count: number): Promise<number> {
+	const provider = entries.findIndex(({ name }) => name === 'provider')
+
+	if (provider === -1 || provider >= count) return count
+	const { status } = await review_attest.check_here()
+
+	return status === 'missing' || status === 'mismatch' ? provider : count
+}
+
+// Only a completed prefix survives: rerunning a provider replaces its brief and nonce, so a later
+// attestation from an earlier attempt must never be reused even when the file map is unchanged.
+async function reusable_prefix(
+	entries: ReadonlyArray<Checkpoint>,
+	tree: GateTree,
+	is_stale: boolean,
+): Promise<number> {
+	const missing = entries.findIndex(({ stamp }) => is_stale || !matches(stamp, tree))
+	const count = await attested_prefix(entries, missing === -1 ? entries.length : missing)
+
+	for (const { stamp } of entries.slice(count)) stamp.remove()
+
+	return count
+}
+
+async function recorded(
+	phase: Phase,
+	stamp: FileMapStampAccess,
+	tree: GateTree,
+): Promise<JoshResult> {
+	stamp.write(tree.files, undefined, tree.base)
+	const result = await phase()
+
+	if (result.code === 0) stamp.complete()
+
+	return result
+}
+
+async function run(
+	issue: string,
+	stage: string,
+	phases: ReadonlyArray<NamedPhase>,
+	is_stale = false,
+): Promise<JoshResult> {
+	const tree = await gate_tree.read_gate_tree()
+
+	if (tree.base === undefined || Object.keys(tree.files).length === 0) {
+		for (const { stamp } of checkpoints(issue, stage, phases, '')) stamp.remove()
+
+		return await run_ship_scoped.run_phases(phases.map(([, phase]) => phase))
+	}
+
+	const entries = checkpoints(issue, stage, phases, await git_command.head_commit())
+	const count = await reusable_prefix(entries, tree, is_stale)
+
+	return await run_ship_scoped.run_phases(
+		entries.map(({ name, phase, stamp }, index) => async () => {
+			if (index < count) return { code: 0, out: `review step ${name}: reused` }
+
+			return await recorded(phase, stamp, tree)
+		}),
+	)
+}
+
+const run_ship_review_checkpoint = { run }
+
+export type { NamedPhase }
+export { run_ship_review_checkpoint }

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

@@ -12,7 +12,9 @@ const RAN_PREFIX = 'ran: --review with no reusable round 1 — '
 const UNNAMED_CAUSE = 'the recorded round does not cover this tree'
 
 function reused(answer: ReuseAnswer): string {
-	return answer.reuse === review_round_reuse.REUSE.HELD ? HELD_REASON : DELTA_REASON
+	const reason = answer.reuse === review_round_reuse.REUSE.HELD ? HELD_REASON : DELTA_REASON
+
+	return answer.note === undefined ? reason : `${reason} — ${answer.note}`
 }
 
 function ran(answer: ReuseAnswer): string {

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

@@ -4,11 +4,14 @@ import { lane_ledger_write } from '#scripts/lane/lane-ledger-write'
 import { review_attest, type ReviewSlot } from '#scripts/review/review-attest'
 import { review_interaction } from '#scripts/review/review-interaction'
 import { review_reviewed_tree } from '#scripts/review/review-reviewed-tree'
+import { review_round } from '#scripts/review/review-round'
 import { review_round_reuse, type ReuseAnswer } from '#scripts/review/review-round-reuse'
 import { review_round2 } from '#scripts/review/review-round2'
 import { review_stop_log } from '#scripts/review/review-stop-log'
 import { run_review } from '#scripts/run/review/run-review'
+import { run_ship_final_review } from './run-ship-final-review'
 import { run_ship_review, type RoundOutcome, type ScoredVerdict } from './run-ship-review'
+import { run_ship_review_checkpoint } from './run-ship-review-checkpoint'
 import { run_ship_review_reason } from './run-ship-review-reason'
 import { run_ship_reviewer, type Round } from './run-ship-reviewer'
 import { run_ship_scoped } from './run-ship-scoped'
@@ -30,7 +33,7 @@ import type { StepResult } from './run-ship-sync'
 // **Round 1's local fixes and round 2 stay inside the supervisor**. A round-1
 // reviewer that fixed its local Mediums in place changed the tree the background gate read, so that
 // join drains the gate rather than judging it — the ship's gate stage re-runs on the fixed tree. After
-// the commit, `round_two_stage` asks `review:round2 --record <N>` whether the fix delta owes a
+// sync and round 1, `round_two_stage` asks `review:round2 --record <N>` whether the fix delta owes a
 // second round, and on `required` runs it through the same commands the chain does: the scoped pair
 // `review:brief` requires, `review:brief --round 2`, a fresh reviewer session, attest and record.
 //
@@ -61,7 +64,7 @@ const FIXED_JOIN_NOTE =
 	'the round-1 gate read the tree before the review fixes — drained, not judged; the gate re-runs once the tree is fixed.'
 const ROUND_TWO_SKIPPED_NOTE = 'round 2 not due — nothing left to verify; shipping on.'
 const ROUND_ONE_RECORDED_NOTE =
-	'round 1 already recorded — reused, not reviewed again; round 2 decides on the fix delta after the commit.'
+	'round 1 already recorded — reused, not reviewed again; round 2 decides on the fix delta before the commit.'
 
 // The scoped pair's precondition, met by the supervisor itself rather than stopped on,
 // single-sourced with the preflight and gate stages.
@@ -125,10 +128,8 @@ async function join_gate(slots: ReadonlyArray<ReviewSlot>): Promise<JoshResult>
 	return { code: SUCCESS_EXIT_CODE, out: joined.out }
 }
 
-// **A passing round 2 is recorded on the issue, not in the tree**: it ran after the commit and reads
-// only, so no commit of the run's follows it, and a line appended now would be pushed onto the open
-// pull request by `pnpm josh followup` — restarting the CI the round ran beside. A blocking round 2
-// on a pushed, clean tree goes to the issue as well (`review-record-comment.ts`).
+// A passing round 2 records on the issue so it cannot move the tree the parallel gate reads.
+// Blocking findings stop both stages before the commit (`review-record-comment.ts`).
 function record_flags(round: Round, outcome: RoundOutcome): ReadonlyArray<string> {
 	return round === ROUND_TWO && outcome.is_passing ? [COMMENT_FLAG] : []
 }
@@ -179,16 +180,27 @@ async function is_fix_verified(slots: ReadonlyArray<ReviewSlot>): Promise<boolea
 	return checked.code === SUCCESS_EXIT_CODE
 }
 
+function outcome_for_round(round: Round, verdict: ScoredVerdict): RoundOutcome {
+	return round === ROUND_TWO
+		? run_ship_review.round_two_outcome(verdict)
+		: run_ship_review.round_one_outcome(verdict)
+}
+
 async function round_one_record(
 	issue: string,
 	slot: ReviewSlot,
 	is_verified: boolean,
 ): Promise<StepResult> {
+	const round =
+		slot === CODE
+			? review_round.from_brief(stamp_file.read_stamp_text(paths(slot).brief) ?? '')
+			: ROUND_ONE
+
 	return await record_and_route(
 		issue,
-		ROUND_ONE,
+		round,
 		(verdict) =>
-			is_verified ? run_ship_review.round_one_outcome(verdict) : run_ship_review.UNVERIFIED_OUTCOME,
+			is_verified ? outcome_for_round(round, verdict) : run_ship_review.UNVERIFIED_OUTCOME,
 		slot,
 	)
 }
@@ -226,7 +238,13 @@ function skipped(out: string): StepResult {
 // round whose `review:record` failed is not counted either: the relaunch re-runs it, and that run is
 // the one that ended.
 async function record_outcome(issue: string, verdict: string, cause?: string): Promise<void> {
-	if (verdict === run_ship_review.VERDICT.INVALID || cause === CAUSE.CHECK) return
+	if (
+		verdict === run_ship_review.VERDICT.INVALID ||
+		cause === CAUSE.CHECK ||
+		review_round.from_brief(stamp_file.read_stamp_text(paths(CODE).brief) ?? '') === ROUND_TWO
+	) {
+		return
+	}
 
 	await lane_ledger_write.record_round_one({ issue: Number(issue), verdict })
 }
@@ -279,7 +297,7 @@ async function reused_round(issue: string, reused: ReuseAnswer): Promise<StepRes
 	return { ...skipped(ROUND_ONE_RECORDED_NOTE), reason: run_ship_review_reason.reused(reused) }
 }
 
-// The round-1 review, beside the gate: scoped pair → open each slot's brief → their reviewers side by
+// The round-1 review, after the gate `run:review` waits on: scoped pair → open each slot's brief → their reviewers side by
 // side → join → attest → record, stopping at the first that did not pass.
 async function round_one_stage(
 	issue: string,
@@ -295,13 +313,19 @@ async function round_one_stage(
 	// A stale record narrows nothing: the next round reads the whole change under the new specification.
 	if (is_stale) review_reviewed_tree.discard()
 	const opens = round_one_opens(slots, unpinned_ok)
-	const ran = await run_phases([
-		tagged_phase(CAUSE.CHECK, scoped_pair),
-		...reviewed_together(opens, run_ship_review.reviewer_prompt, issue, ROUND_ONE),
-		tagged_phase(CAUSE.CHECK, async () => await join_gate(slots)),
-		attest_phase,
-		async () => await code_round_one_record(issue, slots),
-	])
+	const provider = reviewed_together(opens, run_ship_review.reviewer_prompt, issue, ROUND_ONE)
+	const ran = await run_ship_review_checkpoint.run(
+		issue,
+		`one-${slots.join('-')}`,
+		[
+			['scoped', tagged_phase(CAUSE.CHECK, scoped_pair)],
+			['provider', async () => await run_phases(provider)],
+			['gate', tagged_phase(CAUSE.CHECK, async () => await join_gate(slots))],
+			['attest', attest_phase],
+			['record', async () => await code_round_one_record(issue, slots)],
+		],
+		is_stale,
+	)
 
 	return { ...ran, reason: run_ship_review_reason.ran(reused) }
 }
@@ -312,12 +336,19 @@ async function round_one_stage(
 async function interaction_stage(issue: string): Promise<StepResult> {
 	const opens = [{ open: INTERACTION_BRIEF, slot: INTERACTION }]
 
-	return await run_phases([
-		tagged_phase(CAUSE.CHECK, scoped_pair),
-		...reviewed_together(opens, run_ship_review.reviewer_prompt, issue, ROUND_ONE),
-		attest_phase,
-		async () => await record_slots(issue, [INTERACTION]),
-	])
+	const provider = reviewed_together(opens, run_ship_review.reviewer_prompt, issue, ROUND_ONE)
+
+	return await run_ship_review_checkpoint.run(
+		issue,
+		'interaction',
+		[
+			['scoped', tagged_phase(CAUSE.CHECK, scoped_pair)],
+			['provider', async () => await run_phases(provider)],
+			['attest', attest_phase],
+			['record', async () => await record_slots(issue, [INTERACTION])],
+		],
+		await review_round_reuse.is_stale_here(),
+	)
 }
 
 async function due_slots(issue: string): Promise<ReadonlyArray<ReviewSlot>> {
@@ -367,13 +398,32 @@ async function review_stage(
 	return after_interaction(first, second)
 }
 
-// The round-2 verification pass, after the commit so it runs beside CI: due only when the round-1 fix
+// The round-2 verification pass, after sync and beside the gate: due only when the round-1 fix
 // delta says so, then scoped pair → brief → fresh reviewer → attest → record.
 //
 // **The decision is read as JSON and recorded in the lane ledger before it is acted on**, so
 // `josh lane:stats` can count the period's round-2 runs and skips by their reason code
 // (joshuafolkken/kit#4064). Output it cannot parse stops the ship rather than guessing a verdict.
-async function round_two_stage(issue: string): Promise<StepResult> {
+async function reviewed_round_two(issue: string): Promise<StepResult> {
+	const provider = reviewed(ROUND_TWO_BRIEF, run_ship_review.verification_prompt, issue, ROUND_TWO)
+
+	return await run_ship_review_checkpoint.run(
+		issue,
+		'two',
+		[
+			['scoped', tagged_phase(CAUSE.CHECK, scoped_pair)],
+			['provider', async () => await run_phases(provider)],
+			['attest', attest_phase],
+			[
+				'record',
+				async () => await record_and_route(issue, ROUND_TWO, run_ship_review.round_two_outcome),
+			],
+		],
+		await review_round_reuse.is_stale_here(),
+	)
+}
+
+async function execute_round_two_stage(issue: string): Promise<StepResult> {
 	const decision = await josh(round_two_decision(issue))
 
 	if (decision.code !== SUCCESS_EXIT_CODE) return tagged(CAUSE.CHECK, decision)
@@ -395,12 +445,11 @@ async function round_two_stage(issue: string): Promise<StepResult> {
 		return skipped(`${answer.verdict}\n${ROUND_TWO_SKIPPED_NOTE}`)
 	}
 
-	return await run_phases([
-		tagged_phase(CAUSE.CHECK, scoped_pair),
-		...reviewed(ROUND_TWO_BRIEF, run_ship_review.verification_prompt, issue, ROUND_TWO),
-		attest_phase,
-		async () => await record_and_route(issue, ROUND_TWO, run_ship_review.round_two_outcome),
-	])
+	return await reviewed_round_two(issue)
+}
+
+async function round_two_stage(issue: string): Promise<StepResult> {
+	return await run_ship_final_review.run(issue, async () => await execute_round_two_stage(issue))
 }
 
 const run_ship_review_steps = { review_stage, round_two_stage }

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

@@ -3,6 +3,7 @@ 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_prompt_level } from '#scripts/review/review-prompt-level'
 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
@@ -148,7 +149,7 @@ function findings_instruction(
 // (joshuafolkken/kit#3875).
 function issue_read_instruction(issue: string): string {
 	return [
-		`Read Issue ${issue_cite.plain(issue)} with \`pnpm josh issue:read ${issue}\`, which prints the body and every`,
+		`Read Issue ${issue_cite.plain_for('program', issue)} with \`pnpm josh issue:read ${issue}\`, which prints the body and every`,
 		`comment together — never a body-only \`gh api …/issues/${issue}\` read.`,
 	].join(' ')
 }
@@ -159,9 +160,10 @@ function issue_read_instruction(issue: string): string {
 const IN_SESSION_CLAUSE =
 	'Review it yourself in this session — you carry no Skill or Agent tool, so never launch a second reviewer.'
 
+// Each opening leads with the brief's level, so a transcript tells the review's level (joshuafolkken/kit#5555).
 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 —`,
+		`${review_prompt_level.opening(brief_path)}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(' ')
@@ -221,6 +223,10 @@ function slot_prompt(
 }
 
 // The round-2 verification pass: a fresh session over the round-1 fix delta, reading only.
+function final_opening(brief_path: string): string {
+	return `${round_one_opening(brief_path)} This is the final round-2 verification pass; read the scope the brief names. Do not edit any file.`
+}
+
 function verification_prompt(
 	brief_path: string,
 	slot: ReviewSlot,
@@ -228,10 +234,7 @@ function verification_prompt(
 	findings_path?: string,
 ): string {
 	return [
-		`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,
+		final_opening(brief_path),
 		issue_read_instruction(issue),
 		...review_prior_findings.prompt_clauses(issue),
 		findings_instruction(slot, '', findings_path),
@@ -347,12 +350,12 @@ function read_verdict(text: string | undefined): ReviewVerdict {
 	}
 }
 
-// The specs `review:record` is given: a stopped round's `fixed` marks are dropped, since a fix the scoped
+// The whole findings `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
+	if (outcome.is_passing) return verdict.report
 
-	return verdict.specs.map((spec) =>
+	return verdict.report.map((spec) =>
 		spec.startsWith(FIXED_PREFIX) ? spec.slice(FIXED_PREFIX.length) : spec,
 	)
 }
@@ -390,6 +393,7 @@ function round_two_outcome(verdict: ScoredVerdict): RoundOutcome {
 }
 
 const run_ship_review = {
+	final_opening,
 	FIXED_PREFIX,
 	OTHER_SITES_CLAUSE,
 	SWEEP_INSTRUCTION,

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

@@ -1,12 +1,16 @@
 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 { core_priority } from '#scripts/gate/core-priority'
 import { PROJECT_ROOT } from '#scripts/init/init-paths'
 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 { review_pair } from '#scripts/review/review-pair'
+import { review_pair_session } from '#scripts/review/review-pair-session'
+import { review_round } from '#scripts/review/review-round'
 import { detached_launch } from '#scripts/run/detached-launch'
 import { run_ship_brokered_review } from './run-ship-brokered-review'
 import { run_ship_review, type PromptOf } from './run-ship-review'
@@ -42,6 +46,7 @@ interface Briefed {
 
 const { CAUSE } = run_ship_stop_cause
 const { CODE } = review_attest.REVIEW_SLOT
+const { PRIORITY_ENVIRONMENT } = core_priority
 
 // **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).
@@ -61,8 +66,11 @@ function paths(slot?: ReviewSlot): { brief: string; findings: string; log: strin
 	return lane_session_broker.review_paths(PROJECT_ROOT, slot)
 }
 
+// The review stage's children claim cores with priority (`core-priority.ts`), as the commit's do: a
+// round's short checks need not queue behind other lanes' heavy ones (joshuafolkken/kit#5819). The gate
+// a round opens runs in the background and drops the mark at its launch (`run-review-steps.ts`).
 async function josh(argv: ReadonlyArray<string>): Promise<JoshResult> {
-	return await josh_command.josh_run(argv, should_forward_stderr)
+	return await josh_command.josh_run(argv, should_forward_stderr, undefined, PRIORITY_ENVIRONMENT)
 }
 
 function note(text: string): void {
@@ -130,7 +138,7 @@ async function run_direct_session(
 	round: Round,
 ): Promise<JoshResult> {
 	const log_path = paths(slot).log
-	const request = { argv, cwd: PROJECT_ROOT, log_path, profile }
+	const request = { argv, cwd: PROJECT_ROOT, log_path, profile, env: PRIORITY_ENVIRONMENT }
 
 	note(agent_role_profile.describe_review(Number(round), profile))
 	const result = await detached_launch.launch_attached(request, note)
@@ -193,6 +201,25 @@ async function run_brokered(
 		: ended_session(`isolated reviewer failed: ${answer.reason}`, slots)
 }
 
+// The paired comparison reviewer runs beside the code reviewer alone, and only while the code brief was
+// paired (joshuafolkken/kit#7020); a lane's broker starts it beside the reviewers it starts.
+async function launch_pair(slots: ReadonlyArray<ReviewSlot>): Promise<void> {
+	if (slots.includes(CODE)) await review_pair_session.launch(PROJECT_ROOT, PRIORITY_ENVIRONMENT)
+}
+
+async function run_slots(
+	sessions: ReadonlyArray<SlotSession>,
+	round: Round,
+	slots: ReadonlyArray<ReviewSlot>,
+): Promise<ReadonlyArray<JoshResult>> {
+	const [results] = await Promise.all([
+		Promise.all(sessions.map(async (session) => await run_slot(session, round))),
+		launch_pair(slots),
+	])
+
+	return results
+}
+
 // **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(
@@ -208,7 +235,7 @@ async function run_sessions(
 		return await run_brokered(issue, round, slots)
 	}
 
-	const results = await Promise.all(sessions.map(async (session) => await run_slot(session, round)))
+	const results = await run_slots(sessions, round, slots)
 
 	return (
 		results.find((result) => result.code !== SUCCESS_EXIT_CODE) ?? {
@@ -218,14 +245,34 @@ async function run_sessions(
 	)
 }
 
+function offer_pair(code: Briefed | undefined): void {
+	if (code !== undefined) review_pair.offer(code.brief)
+}
+
+// The paired round's comparison, recorded and never gating: a refused record is only noted. Only a
+// launch that briefed the code slot records, so an interaction pass alone never re-records the last
+// round 1's pair its paired brief still names.
+async function record_pair(issue: string, code: Briefed | undefined): Promise<void> {
+	if (code === undefined) return
+	const argv = review_pair_session.pair_argv(issue, paths(CODE).log, PROJECT_ROOT)
+	if (argv === undefined) return
+	const result = await josh(argv)
+
+	if (result.code !== SUCCESS_EXIT_CODE) note(`paired reviewer: review:pair recorded nothing`)
+}
+
 // 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.
+// nothing reads as unfinished rather than as the last round's verdict. The code brief is paired, or its
+// last pairing removed, before any reviewer starts (`review-pair.ts`).
 async function launch_reviewers(
 	briefs: ReadonlyArray<Briefed>,
 	prompt_of: PromptOf,
 	issue: string,
 	round: Round,
 ): Promise<JoshResult> {
+	const code = briefs.find(({ slot }) => slot === CODE)
+	const effective_round = review_round.from_brief(code?.brief ?? '', round)
+
 	for (const { brief, slot } of briefs) {
 		const target = paths(slot)
 
@@ -233,12 +280,17 @@ async function launch_reviewers(
 		stamp_file.remove_stamp(target.findings)
 	}
 
-	return await run_sessions(
-		prompt_of,
+	offer_pair(code)
+	const result = await run_sessions(
+		effective_round === ROUND_TWO ? run_ship_review.verification_prompt : prompt_of,
 		issue,
-		round,
+		effective_round,
 		briefs.map(({ slot }) => slot),
 	)
+
+	await record_pair(issue, code)
+
+	return result
 }
 
 // A refused attestation — the issue changed after the brief, an update left unread, no attestation —