@joshuafolkken/kit 1.1514.0 → 1.2114.0

package/scripts/run/ship/run-ship-pre-detach.ts

@@ -1,17 +1,33 @@
 import { existsSync } from 'node:fs'
 import path from 'node:path'
+import { check_reuse, type CheckRecords } from '#scripts/gate/check-reuse'
+import { gate_labels } from '#scripts/gate/gate-labels'
+import type { GateStepResult } from '#scripts/gate/gate-report'
+import { gate_tree } from '#scripts/gate/gate-tree'
+import { metrics_totals } from '#scripts/gate/metrics-totals'
 import { project_checks } from '#scripts/gate/project-checks'
+import { structural_checks } from '#scripts/gate/structural-checks'
 import { type_check_step } from '#scripts/gate/type-check-step'
 import type { JoshResult } from '#scripts/josh/josh-run'
+import { lane_ledger_write } from '#scripts/lane/lane-ledger-write'
 import { buffered_process, type BufferedProcessResult } from '#scripts/lib/buffered-process'
 
-// The fast checks a detached `josh ship` runs in the agent's own turn, after the preflight and before
-// the hand-off: a type error in a file the related-only checks never touched, an export nothing reads,
+// The fast checks a detached `josh ship` runs in the agent's own turn, after the preflight (whatever it
+// answered) and before the hand-off: a type error in a file the related-only checks never touched, an export nothing reads,
 // an unknown word, or a guard test (a SKILL.md pointer, a byte budget, the command list, a source with
 // no colocated test, a bare issue citation) that only the full suite runs, would otherwise first
 // surface after the detach and cost a relaunched session. They answer in seconds, so the same session
-// fixes what they find and ships again. **Nothing moves out of the gate**: the supervised gate stage
-// still runs every check, these included.
+// fixes what they find and ships again. A `--review` ship adds `test:pinned`, which probes the hunks
+// its verdict cache does not hold (`run-ship-pre-detach-pinned.ts`).
+//
+// **Nothing moves out of the gate, and the gate reuses what these already answered**: a check that is
+// the gate's own check passed silently here is recorded with the gate's per-check record
+// (`check-reuse.ts`), so the supervised gate stage reuses it while its declared inputs have not moved
+// and runs it again when they have. The record, its judgment and its inputs are the gate's; only the
+// type check (`check`) and `exports:unused` (`exports`) carry a gate label. The rest stay unrecorded:
+// `cspell:dot` declares no inputs and runs every gate (`verification-inputs.ts`), the guard tests are a
+// slice of the unit suite and do not answer for the gate's `test:unit`, and the metrics totals leave
+// out the durations the gate's `metrics` holds.
 //
 // joshuafolkken/kit#3924: nine of ten ship gate stops were `exports:unused`, `cspell:dot` or a
 // repository-wide guard test failing on the child's own code — none a check `test:related` selects,
@@ -21,80 +37,175 @@ import { buffered_process, type BufferedProcessResult } from '#scripts/lib/buffe
 // present run, and a consumer meets the static checks alone.
 //
 // In kit the metrics ratchet's totals join them: a feature grows a total almost every time, and here
-// the session that grew the total writes the reason itself rather than a relaunched one. The
+// the session that grew the total writes the reason itself rather than a relaunched one —
+// `josh lint:related` has already reported the growth in the loop (`metrics-totals.ts`), so this is
+// the stop for a growth that notice did not settle. A total the branch's approval already names is
+// re-recorded at its growth here rather than stopped (`--rerecord`, joshuafolkken/kit#4716). The
 // durations are left out: they read the gate ledger, stale before the detach, so they stay with the
 // supervised gate.
 
+interface PreDetachCheck {
+	list: ReadonlyArray<string>
+	// The gate check this one answers for, absent where it answers for none.
+	label?: string | undefined
+}
+
+interface PreDetachRun {
+	check: PreDetachCheck
+	result: BufferedProcessResult
+	elapsed_ms: number
+}
+
 const SUCCESS_EXIT_CODE = 0
 const FAILURE_EXIT_CODE = 1
 const SECTION_SEPARATOR = '\n\n'
 const PASSED = 'pre-detach checks passed'
-const METRICS_TOTALS_COMMAND: ReadonlyArray<string> = ['josh', 'metrics', '--totals-only']
-const STATIC_CHECKS: ReadonlyArray<ReadonlyArray<string>> = [
-	['josh', 'exports:unused'],
-	['josh', 'cspell:dot'],
+const UNPINNED = 'unpinned'
+const { METRICS_RERECORD_COMMAND } = metrics_totals
+const STATIC_CHECKS: ReadonlyArray<PreDetachCheck> = [
+	{ list: ['josh', 'exports:unused'], label: gate_labels.EXPORTS_LABEL },
+	{ list: ['josh', 'cspell:dot'] },
 ]
 const GUARD_TEST_TARGETS: ReadonlyArray<string> = [
 	'scripts/document',
 	'scripts/claude',
 	'scripts/rules',
 	'scripts/josh/josh-command-map.test.ts',
-	'scripts/issue/session-cite-scan.test.ts',
-	'scripts/test/untested-sources.test.ts',
-	'scripts/test/pure-files.test.ts',
+	...structural_checks.STRUCTURAL_GUARD_TARGETS,
+	'tools/test/pure-files.test.ts',
 ]
-// A present directory need not hold a test the project's Vitest includes — a consumer's own
-// `scripts/claude` of shell helpers, say — and a filter that matches nothing would stop every ship.
-const GUARD_TEST_COMMAND: ReadonlyArray<string> = ['josh', 'test:unit', '--passWithNoTests']
+const { GUARD_TEST_COMMAND, failure_prefix, failure_section } = structural_checks
 
 function present_targets(directory: string): ReadonlyArray<string> {
 	return GUARD_TEST_TARGETS.filter((target) => existsSync(path.join(directory, target)))
 }
 
-function guard_tests(directory: string): Array<ReadonlyArray<string>> {
+function guard_tests(directory: string): Array<PreDetachCheck> {
 	const targets = present_targets(directory)
 
-	return targets.length === 0 ? [] : [[...GUARD_TEST_COMMAND, ...targets]]
+	return targets.length === 0 ? [] : [{ list: [...GUARD_TEST_COMMAND, ...targets] }]
 }
 
 // The same kit-only rule as the gate's `is_kit_only` step: a consumer's kit has no `josh metrics`.
-function kit_only(directory: string): Array<ReadonlyArray<string>> {
-	return project_checks.is_kit_repository(directory) ? [METRICS_TOTALS_COMMAND] : []
+function kit_only(directory: string): Array<PreDetachCheck> {
+	return project_checks.is_kit_repository(directory) ? [{ list: METRICS_RERECORD_COMMAND }] : []
 }
 
-async function command_lists(directory: string): Promise<Array<ReadonlyArray<string>>> {
+async function command_lists(directory: string): Promise<Array<PreDetachCheck>> {
 	const type_check = await type_check_step.resolve_type_check_args(directory)
 
-	return [type_check, ...STATIC_CHECKS, ...guard_tests(directory), ...kit_only(directory)]
+	return [
+		{ list: type_check, label: gate_labels.TYPE_CHECK_LABEL },
+		...STATIC_CHECKS,
+		...guard_tests(directory),
+	]
 }
 
-async function run_in(
-	directory: string,
-	list: ReadonlyArray<string>,
-): Promise<BufferedProcessResult> {
-	return await buffered_process.run_buffered_process(list, { cwd: directory })
+async function run_in(directory: string, check: PreDetachCheck): Promise<PreDetachRun> {
+	const started = performance.now()
+	const result = await buffered_process.run_buffered_process(check.list, { cwd: directory })
+
+	return { check, result, elapsed_ms: performance.now() - started }
 }
 
-// All run at once, buffered, and every failure is reported, so one ship shows all there is to fix.
-async function checks(directory: string = process.cwd()): Promise<JoshResult> {
-	const lists = await command_lists(directory)
-	const results = await Promise.all(lists.map(async (list) => await run_in(directory, list)))
-	const failed = results.filter((result) => buffered_process.is_process_failed(result))
+interface GateRun extends PreDetachRun {
+	check: { list: ReadonlyArray<string>; label: string }
+}
+
+function is_gate_run(run: PreDetachRun): run is GateRun {
+	return run.check.label !== undefined
+}
+
+function gate_results(runs: ReadonlyArray<PreDetachRun>): Array<GateStepResult> {
+	return runs
+		.filter((run) => is_gate_run(run))
+		.map(({ check, result, elapsed_ms }) => {
+			return { ...result, label: check.label, command: check.list.join(' '), elapsed_ms }
+		})
+}
+
+function verdict(runs: ReadonlyArray<PreDetachRun>): JoshResult {
+	const failed = runs.filter(({ result }) => buffered_process.is_process_failed(result))
 
 	if (failed.length === 0) return { code: SUCCESS_EXIT_CODE, out: PASSED }
 
 	return {
 		code: FAILURE_EXIT_CODE,
-		out: failed.map((result) => result.output.trim()).join(SECTION_SEPARATOR),
+		out: failed
+			.map(({ check, result }) => failure_section(check.list, result))
+			.join(SECTION_SEPARATOR),
 	}
 }
 
+// The `test:pinned` check a `--review` ship adds (`run-ship-pre-detach-pinned.ts`); none is asked by default.
+type PinnedCheck = () => Promise<JoshResult>
+
+async function not_asked(): Promise<JoshResult> {
+	return { code: SUCCESS_EXIT_CODE, out: PASSED }
+}
+
+// The checks' answer, with the kinds a `stop` record names its red by: `pre-detach` for the static
+// checks, `unpinned` for `test:pinned`, so `lane:stats` tells an unpinned stop apart
+// (joshuafolkken/kit#5228).
+interface PreDetachResult extends JoshResult {
+	preconditions?: ReadonlyArray<string>
+}
+
+function joined(result: JoshResult, pinned: JoshResult): JoshResult {
+	if (pinned.code === SUCCESS_EXIT_CODE) return result
+	if (result.code === SUCCESS_EXIT_CODE) return pinned
+
+	return { code: FAILURE_EXIT_CODE, out: [result.out, pinned.out].join(SECTION_SEPARATOR) }
+}
+
+function red_kinds(result: JoshResult, pinned: JoshResult): ReadonlyArray<string> {
+	return [
+		...(result.code === SUCCESS_EXIT_CODE ? [] : [lane_ledger_write.PRE_DETACH_STAGE]),
+		...(pinned.code === SUCCESS_EXIT_CODE ? [] : [UNPINNED]),
+	]
+}
+
+// The pinned check's stop joins the others' rather than hiding them.
+function with_pinned(result: JoshResult, pinned: JoshResult): PreDetachResult {
+	const preconditions = red_kinds(result, pinned)
+	const answer = joined(result, pinned)
+
+	return preconditions.length === 0 ? answer : { ...answer, preconditions }
+}
+
+// All run at once, buffered, and every failure is reported, so one ship shows all there is to fix.
+// The tree is read before they start, so a record is written only for the tree they read. **The
+// metrics totals run first, alone**: they may re-record the branch's approval file
+// (`metrics-command.ts`), and a file written under the others would move the tree and leave the gate
+// nothing to reuse (joshuafolkken/kit#4716).
+async function checks(
+	directory: string = process.cwd(),
+	records: CheckRecords = check_reuse.DEFAULT_RECORDS,
+	pinned: PinnedCheck = not_asked,
+): Promise<PreDetachResult> {
+	const metrics = await Promise.all(
+		kit_only(directory).map(async (check) => await run_in(directory, check)),
+	)
+	const [lists, tree] = await Promise.all([command_lists(directory), gate_tree.read_gate_tree()])
+	const [runs, pinned_result] = await Promise.all([
+		Promise.all(lists.map(async (check) => await run_in(directory, check))),
+		pinned(),
+	])
+
+	await check_reuse.record_green_checks(gate_results(runs), tree, records)
+
+	return with_pinned(verdict([...runs, ...metrics]), pinned_result)
+}
+
 const run_ship_pre_detach = {
 	GUARD_TEST_TARGETS,
-	METRICS_TOTALS_COMMAND,
+	METRICS_RERECORD_COMMAND,
 	PASSED,
 	STATIC_CHECKS,
+	UNPINNED,
 	checks,
+	failure_prefix,
 }
 
+export type { PinnedCheck, PreDetachCheck, PreDetachResult }
 export { run_ship_pre_detach }

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

@@ -4,12 +4,18 @@ import { git_pr } from '#scripts/gh/git-pr'
 import { changed_paths } from '#scripts/git/changed-paths'
 import { git_branch } from '#scripts/git/git-branch'
 import { git_issue } from '#scripts/git/git-issue'
-import { git_preflight } from '#scripts/git/git-preflight'
+import { git_preflight, type Unmet } from '#scripts/git/git-preflight'
 import type { JoshResult } from '#scripts/josh/josh-run'
 import { error_text } from '#scripts/lib/error-message'
+import { report_format_reference } from '#scripts/report/report-format-reference'
+import { acceptance_map } from '#scripts/review/acceptance-map'
 import { acceptance_map_check } from '#scripts/review/acceptance-map-check'
 import { live_evidence } from '#scripts/review/live-evidence'
+import { removed_tests_check } from '#scripts/review/removed-tests-check'
+import { run_ship_body_draft } from './run-ship-body-draft'
+import { run_ship_lap } from './run-ship-lap'
 import { run_ship_lock } from './run-ship-lock'
+import { run_ship_planned } from './run-ship-planned'
 import { run_ship_scoped } from './run-ship-scoped'
 
 // `josh ship`'s first stage. The commit stage (`git -y`'s preflight) and the merge (`followup`'s
@@ -17,26 +23,60 @@ import { run_ship_scoped } from './run-ship-scoped'
 // **Every precondition decidable before the review is asked here, and all of them are reported at
 // once.** No check is new: the classification, issue and branch answers
 // are `git_preflight.problems_of`, and the evidence answer is `live_evidence.verdict_for` over the same
-// changed paths and the body this ship will deliver — `--body-file` when given, else the open PR's.
+// changed paths and the body this ship will deliver — `--body-file` when given, else the ship body
+// draft, else the open PR's. The `unplanned` answer is the branch's code files the lane's `lane:plan`
+// record never listed (`run-ship-planned.ts`).
 //
 // The scoped pair runs last, met rather than stopped on (`run-ship-scoped.ts`), so the review and the
 // gate start on a tree both checks are green on.
+//
+// A stop names the kinds of the preconditions it found unmet, beside the git preflight's own, so the
+// lane ledger can count which one stops ships (joshuafolkken/kit#4166).
 
 const SUCCESS_EXIT_CODE = 0
 const FAILURE_EXIT_CODE = 1
 const UNREADABLE = Symbol('unreadable body')
-const EVIDENCE_PROBLEM = `This change touches runtime code, but the PR body has no ${live_evidence.EVIDENCE_HEADING} section: run the acceptance criteria for real and pass the body with --body-file <path>. Write it ${live_evidence.EVIDENCE_FORMAT}`
-const EVIDENCE_PENDING = `This change touches runtime code and no PR is open yet: write the ${live_evidence.EVIDENCE_HEADING} section to a file and hand it to josh ship with --body-file <path>, or the ship refuses. Write it ${live_evidence.EVIDENCE_FORMAT}`
+const PRECONDITION = {
+	LIVE_EVIDENCE: 'live-evidence',
+	ACCEPTANCE_MAP: 'acceptance-map',
+	REMOVED_TESTS: 'removed-tests',
+	LOCK: 'lock',
+	SCOPED: 'scoped',
+	UNPLANNED: run_ship_planned.PRECONDITION,
+	UNREADABLE: 'unreadable',
+} as const
+const EVIDENCE_PROBLEM = `This change touches runtime code, but the body this ship delivers has no ${live_evidence.EVIDENCE_HEADING} section: run the acceptance criteria for real and write it into the ship body draft run:prep wrote (josh ship reads it when --body-file is omitted), or pass the body with --body-file <path>. Write it ${live_evidence.EVIDENCE_FORMAT}`
+const EVIDENCE_PENDING = `This change touches runtime code and no PR is open yet: write the ${live_evidence.EVIDENCE_HEADING} section into the ship body draft run:prep wrote (or a file handed to josh ship with --body-file <path>), or the ship refuses. Write it ${live_evidence.EVIDENCE_FORMAT}`
+
+// The draft `josh ship` reads when `--body-file` is omitted, named so the run fills that file in.
+function acceptance_pending_text(draft_path: string): string {
+	return `Fill in this ${acceptance_map.MAP_HEADING} section in the ship body draft ${draft_path} — josh ship reads it when --body-file is omitted — replacing each pending row's ending with what met or deferred it (format: ${report_format_reference.pointer(report_format_reference.ACCEPTANCE_MAP_HEADING)}), and write ${live_evidence.EVIDENCE_HEADING} there before the ship, or the ship refuses:`
+}
 
 interface PreflightRequest {
 	title: string
 	body_path: string | undefined
 }
 
+// `preconditions` names the kinds a stopped stage found unmet, each once, in the order they were asked.
+interface PreflightResult extends JoshResult {
+	preconditions?: ReadonlyArray<string>
+}
+
+// The body the next ship delivers: `--body-file`, else the run's ship body draft, else the open PR's.
 async function body_text(body_path: string | undefined): Promise<string | undefined> {
 	if (body_path !== undefined) return await readFile(body_path, 'utf8')
+	const branch = await git_branch.current()
+	const issue = git_issue.branch_number(branch)
+	const draft = issue === undefined ? undefined : await run_ship_body_draft.existing(issue)
 
-	return await git_gh_command.pr_get_body(await git_branch.current())
+	if (draft !== undefined) return await readFile(draft, 'utf8')
+
+	return await git_gh_command.pr_get_body(branch)
+}
+
+function of_kind(kind: string, problems: ReadonlyArray<string>): Array<Unmet> {
+	return problems.map((problem) => ({ kind, problem }))
 }
 
 // `no_body_problem` answers a runtime change with no body to read at all — no `--body-file` and no open
@@ -44,7 +84,7 @@ async function body_text(body_path: string | undefined): Promise<string | undefi
 async function evidence_problems(
 	body_path: string | undefined,
 	no_body_problem: string = EVIDENCE_PROBLEM,
-): Promise<Array<string>> {
+): Promise<Array<Unmet>> {
 	const [paths, body] = await Promise.all([
 		changed_paths.read_changed_paths(false),
 		body_text(body_path),
@@ -52,25 +92,28 @@ async function evidence_problems(
 
 	if (live_evidence.verdict_for(paths, body) !== 'required') return []
 
-	return [body === undefined ? no_body_problem : EVIDENCE_PROBLEM]
+	return of_kind(PRECONDITION.LIVE_EVIDENCE, [
+		body === undefined ? no_body_problem : EVIDENCE_PROBLEM,
+	])
 }
 
-function refusal(problems: ReadonlyArray<string>): JoshResult {
-	const lines = problems.map((problem) => `  - ${problem}`)
+function refusal(problems: ReadonlyArray<Unmet>): PreflightResult {
+	const lines = problems.map(({ problem }) => `  - ${problem}`)
 	const head = `${String(problems.length)} pull-request precondition(s) unmet before the review and the gate:`
+	const preconditions = [...new Set(problems.map(({ kind }) => kind))]
 
-	return { code: FAILURE_EXIT_CODE, out: [head, ...lines].join('\n') }
+	return { code: FAILURE_EXIT_CODE, out: [head, ...lines].join('\n'), preconditions }
 }
 
 // The reads here run in the ship's own process, where the commit stage's ran in a `git -y` child: a
 // throw — a `--body-file` path that does not exist, a git read that failed — would escape `ship()`
 // past the stop a supervised ship hands back on, so it is reported as one more unmet precondition.
 // Each side is caught on its own, so one side's failed read never hides what the other side found.
-async function caught(problems: Promise<Array<string>>): Promise<Array<string>> {
+async function caught(problems: Promise<Array<Unmet>>): Promise<Array<Unmet>> {
 	try {
 		return await problems
 	} catch (error) {
-		return [error_text.message_of(error)]
+		return of_kind(PRECONDITION.UNREADABLE, [error_text.message_of(error)])
 	}
 }
 
@@ -86,62 +129,136 @@ async function readable_body(
 
 // `followup`'s acceptance-map refusal, asked of the body this ship will deliver. A branch with no issue
 // number is `git_preflight`'s problem to name, and an unreadable body the evidence side's.
-async function acceptance_problems(body_path: string | undefined): Promise<Array<string>> {
+async function acceptance_problems(body_path: string | undefined): Promise<Array<Unmet>> {
 	const issue = git_issue.branch_number(await git_branch.current())
 	const body = await readable_body(body_path)
 
 	if (issue === undefined || body === UNREADABLE) return []
 	const problem = await acceptance_map_check.body_refusal(issue, body)
 
-	return problem === undefined ? [] : [problem]
+	return problem === undefined ? [] : of_kind(PRECONDITION.ACCEPTANCE_MAP, [problem])
+}
+
+// `followup`'s removed-test refusal, asked of the body this ship will deliver.
+async function removed_test_problems(body_path: string | undefined): Promise<Array<Unmet>> {
+	const body = await readable_body(body_path)
+
+	if (body === UNREADABLE) return []
+	const problem = await removed_tests_check.body_refusal(body)
+
+	return problem === undefined ? [] : of_kind(PRECONDITION.REMOVED_TESTS, [problem])
+}
+
+async function lock_problems(): Promise<Array<Unmet>> {
+	return of_kind(PRECONDITION.LOCK, await run_ship_lock.lock_problems())
+}
+
+async function planned_problems(): Promise<Array<Unmet>> {
+	return of_kind(PRECONDITION.UNPLANNED, await run_ship_planned.problems())
 }
 
 // The lock file is asked here too, so a drift stops the ship before the gate
 // rather than being rewritten by the pre-push hook's install under the push.
-async function asked_problems(request: PreflightRequest): Promise<Array<string>> {
-	const [preflight, evidence, acceptance, lock] = await Promise.all([
+async function asked_problems(request: PreflightRequest): Promise<Array<Unmet>> {
+	const [preflight, evidence, acceptance, removed, lock, planned] = await Promise.all([
 		caught(git_preflight.problems_of({ cli_input: request.title, will_open_pr: true })),
 		caught(evidence_problems(request.body_path)),
 		caught(acceptance_problems(request.body_path)),
-		caught(run_ship_lock.lock_problems()),
+		caught(removed_test_problems(request.body_path)),
+		caught(lock_problems()),
+		caught(planned_problems()),
 	])
 
-	return [...preflight, ...evidence, ...acceptance, ...lock]
+	return [...preflight, ...evidence, ...acceptance, ...removed, ...lock, ...planned]
 }
 
-async function stage(request: PreflightRequest): Promise<JoshResult> {
-	const problems = await asked_problems(request)
+async function stage(request: PreflightRequest): Promise<PreflightResult> {
+	const problems = await run_ship_lap.timed(
+		run_ship_lap.STEP.PRECONDITIONS,
+		async () => await asked_problems(request),
+	)
 
 	if (problems.length > 0) return refusal(problems)
 
 	const scoped = await run_ship_scoped.scoped_pair()
 
-	return scoped.code === SUCCESS_EXIT_CODE ? { code: SUCCESS_EXIT_CODE, out: 'ready' } : scoped
+	if (scoped.code === SUCCESS_EXIT_CODE) return { code: SUCCESS_EXIT_CODE, out: 'ready' }
+
+	return { ...scoped, preconditions: [PRECONDITION.SCOPED] }
 }
 
-async function classification_problems(issue_number: string): Promise<Array<string>> {
+async function classification_problems(issue_number: string): Promise<Array<Unmet>> {
 	await git_pr.release_classification(issue_number, await git_branch.current())
 
 	return []
 }
 
-// **The same two refusals, asked before the ship rather than by it**: a missing
-// classification or missing evidence is known long before the ship, yet refused there at the run's
-// largest context. `run:prep` (and so `run:entry`)
-// and `run:step` print this, so the Issue body and the evidence are met while they are cheap. Nothing
-// here replaces `stage`: the ship and `followup` still refuse on both. Before the PR exists the evidence
-// can only live in the file the ship will be handed, so it is asked for as that file, not reported as a
-// body that already failed.
+// Only a body still to be written is handed every row as pending: a draft or an open PR's body keeps
+// the refusal, which names just the rows missing, stale or deferred to an issue that does not exist.
+async function pending_map(
+	issue_number: string,
+	body: string | undefined,
+): Promise<string | undefined> {
+	if (body !== undefined) return undefined
+
+	return acceptance_map.skeleton(await git_gh_command.issue_get_body(issue_number))
+}
+
+// The rows land in the ship body draft as well as in the report (joshuafolkken/kit#4168).
+async function pending_text(issue_number: string, map: string): Promise<string> {
+	const draft = await run_ship_body_draft.prepare(issue_number, map)
+
+	return `${acceptance_pending_text(draft)}\n${map}`
+}
+
+// A refusal of a draft already written names it again, so a later `run:step` still points at the file.
+async function draft_refusal_text(issue_number: string, problem: string): Promise<string> {
+	const draft = await run_ship_body_draft.existing(issue_number)
+
+	return draft === undefined ? problem : `${acceptance_pending_text(draft)}\n${problem}`
+}
+
+// The acceptance-map refusal asked early carries the rows to write, identifiers included, built by
+// `acceptance_map.skeleton` — the one builder `josh pr` uses too (joshuafolkken/kit#4244). An Issue
+// with no criteria to build rows from keeps the refusal's own wording.
+async function acceptance_pending(issue_number: string): Promise<Array<Unmet>> {
+	const body = await body_text(undefined)
+	const problem = await acceptance_map_check.body_refusal(issue_number, body)
+
+	if (problem === undefined) return []
+	const map = await pending_map(issue_number, body)
+	const pending =
+		map === undefined
+			? await draft_refusal_text(issue_number, problem)
+			: await pending_text(issue_number, map)
+
+	return of_kind(PRECONDITION.ACCEPTANCE_MAP, [pending])
+}
+
+// **The same refusals, asked before the ship rather than by it**: a missing classification, missing
+// evidence or an unmapped acceptance criterion is known long before the ship, yet refused there at the
+// run's largest context. `run:prep` (and so `run:entry`)
+// and `run:step` print this, so the Issue body and the PR body are met while they are cheap. Nothing
+// here replaces `stage`: the ship and `followup` still refuse on all of them. Before the PR exists the
+// evidence can only live in the file the ship will be handed, so it is asked for as that file, not
+// reported as a body that already failed.
 async function ahead(issue_number: string): Promise<Array<string>> {
-	const [classification, evidence] = await Promise.all([
+	const [classification, evidence, acceptance] = await Promise.all([
 		caught(classification_problems(issue_number)),
 		caught(evidence_problems(undefined, EVIDENCE_PENDING)),
+		caught(acceptance_pending(issue_number)),
 	])
 
-	return [...classification, ...evidence]
+	return [...classification, ...evidence, ...acceptance].map(({ problem }) => problem)
 }
 
-const run_ship_preflight = { EVIDENCE_PENDING, EVIDENCE_PROBLEM, ahead, stage }
+const run_ship_preflight = {
+	EVIDENCE_PENDING,
+	EVIDENCE_PROBLEM,
+	acceptance_pending_text,
+	ahead,
+	stage,
+}
 
-export type { PreflightRequest }
+export type { PreflightRequest, PreflightResult }
 export { run_ship_preflight }

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

@@ -1,6 +1,7 @@
 import { git_command } from '#scripts/git/git-command'
 import { git_worktree } from '#scripts/git/git-worktree'
 import { error_text } from '#scripts/lib/error-message'
+import { review_round_reuse } from '#scripts/review/review-round-reuse'
 import { run_hold } from '#scripts/run/hold/run-hold'
 import { run_preflight } from '#scripts/run/run-preflight'
 import { run_ship_stage, type ShipState } from './run-ship-stage'
@@ -30,8 +31,8 @@ async function or_false(is_true: () => Promise<boolean>): Promise<boolean> {
 
 // A clean tree whose branch holds commits the default branch does not: the commit stage's output. A
 // dirty tree is uncommitted work, whatever is already committed beneath it.
-async function read_committed(): Promise<boolean> {
-	if (await run_hold.is_tree_dirty()) return false
+async function read_committed(is_dirty: boolean): Promise<boolean> {
+	if (is_dirty) return false
 
 	const base = await git_command.default_branch_reference()
 
@@ -60,16 +61,31 @@ async function read_merged(branch_name: string): Promise<boolean> {
 	return (await git_command.commit_count_beyond(base, HEAD_REFERENCE)) === 0
 }
 
+// A stale review re-runs the review stage instead of the followup failing again.
+async function read_review_stale(): Promise<boolean> {
+	return await review_round_reuse.is_stale_here()
+}
+
 const NOTHING_DONE: ShipState = { is_committed: false, is_pushed: false, is_merged: false }
 
 async function read_branch_state(branch_name: string): Promise<ShipState> {
-	const [is_committed, is_pushed, is_merged] = await Promise.all([
-		or_false(read_committed),
+	const is_dirty = await run_hold.is_tree_dirty()
+	const [is_committed, is_pushed, is_merged, is_review_stale] = await Promise.all([
+		or_false(async () => await read_committed(is_dirty)),
 		or_false(async () => await read_pushed(branch_name)),
 		or_false(async () => await read_merged(branch_name)),
+		read_review_stale(),
 	])
 
-	return { is_committed, is_pushed, is_merged }
+	return { is_committed, is_pushed, is_merged, is_review_stale, is_dirty }
+}
+
+// Origin holds `HEAD` and nothing is left uncommitted: a line written to the tree now has no commit of
+// the run's own to ride, so pushing it would restart the pull request's CI (joshuafolkken/kit#4907).
+async function is_pushed_clean(): Promise<boolean> {
+	if (await run_hold.is_tree_dirty()) return false
+
+	return await or_false(async () => await read_pushed(await git_command.branch()))
 }
 
 // A branch that cannot be named leaves nothing to ask about, so it reads as nothing done.
@@ -101,6 +117,12 @@ async function record_target(issue: string): Promise<string | undefined> {
 	return repository === undefined ? undefined : run_ship_stage.record_path(repository, issue)
 }
 
-const run_ship_probe = { read_state, record_target, repository_directory }
+const run_ship_probe = {
+	is_pushed_clean,
+	read_review_stale,
+	read_state,
+	record_target,
+	repository_directory,
+}
 
 export { run_ship_probe }