@joshuafolkken/kit 1.1514.0 → 1.1784.0

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

@@ -0,0 +1,96 @@
+import { setTimeout as sleep } from 'node:timers/promises'
+import { backlog_ready } from '#scripts/backlog/backlog-ready'
+import { git_common_directory } from '#scripts/git/git-common-directory'
+import { lane_capacity } from '#scripts/lane/lane-capacity'
+import { lane_handoff } from '#scripts/lane/lane-handoff'
+import { lane_registry, type LaneInfo } from '#scripts/lane/lane-registry'
+import { run_ship_stage, type Stage } from './run-ship-stage'
+
+// **A followup stop past the lane limit waits for a place, then relaunches**: its lane held no place
+// while it waited (`backlog-occupied.ts`), so the next launch may have taken it, and a child started at
+// once would run past the limit (joshuafolkken/kit#4466). The stopped lane counts again while this
+// supervisor waits, so the driver launches nothing into the place it waits for. An unreadable limit or
+// lane count relaunches at once, and so does a place that does not free within the wait.
+//
+// **Waiters queue in issue order rather than block each other**: every waiter counts in the lane use,
+// so three of them past a limit of two would each see the lanes full and wait out the hour together. A
+// waiter leaves out the waiters behind it, so the first ones that fit relaunch and the rest wait on them.
+// The mark is the ship stage record's (`run_ship_stage.mark_place_waiting`), read only while the ship
+// runs, so a dead supervisor's mark queues nobody.
+
+// An hour of lane counts, half a minute apart: about two lanes' median run (`lane:stats`).
+const PLACE_POLL_MS = 30_000
+const PLACE_POLLS = 120
+
+function is_behind(lane: LaneInfo, issue: string): boolean {
+	return lane.issue.localeCompare(issue, undefined, { numeric: true }) > 0
+}
+
+async function waiters_behind(issue: string): Promise<number> {
+	const lanes = await lane_registry.list_lanes()
+
+	return lanes.filter(
+		(lane) => is_behind(lane, issue) && lane_handoff.is_place_waiting(lane.issue, lane.directory),
+	).length
+}
+
+async function is_over_limit(issue: string): Promise<boolean> {
+	const limit = await lane_capacity.lane_limit()
+
+	if (limit.kind !== 'limit') return false
+
+	const use = await backlog_ready.lane_use()
+	const behind = await waiters_behind(issue)
+
+	return use.occupied - behind > lane_capacity.seated_limit(limit.limit)
+}
+
+async function is_place_taken(issue: string): Promise<boolean> {
+	try {
+		return await is_over_limit(issue)
+	} catch {
+		return false
+	}
+}
+
+// Best-effort: a mark that could not be written leaves this waiter counted by the others, as before.
+function mark(lane: LaneInfo, is_waiting: boolean): void {
+	const repository = git_common_directory.repository(lane.directory)
+
+	if (repository === undefined) return
+
+	try {
+		run_ship_stage.mark_place_waiting(
+			run_ship_stage.record_path(repository, lane.issue),
+			is_waiting,
+		)
+	} catch {
+		// The queue only orders waiters; an unmarked one still waits on the lane count.
+	}
+}
+
+async function poll(issue: string): Promise<void> {
+	for (let polled = 0; polled < PLACE_POLLS; polled += 1) {
+		// eslint-disable-next-line no-await-in-loop -- polling: each check waits on a lane the previous one saw busy
+		if (!(await is_place_taken(issue))) return
+
+		// eslint-disable-next-line no-await-in-loop -- polling: the wait between two lane counts
+		await sleep(PLACE_POLL_MS)
+	}
+}
+
+async function await_place(lane: LaneInfo, stage: Stage): Promise<void> {
+	if (stage !== run_ship_stage.STAGE.FOLLOWUP) return
+
+	mark(lane, true)
+
+	try {
+		await poll(lane.issue)
+	} finally {
+		mark(lane, false)
+	}
+}
+
+const run_ship_place = { await_place }
+
+export { run_ship_place }

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

@@ -0,0 +1,43 @@
+import type { JoshResult } from '#scripts/josh/josh-run'
+import { lane_ledger } from '#scripts/lane/lane-ledger'
+import { run_event_stream } from '#scripts/run/event/run-event-stream'
+import { run_event_stream_emit } from '#scripts/run/event/run-event-stream-emit'
+import { run_ship_pre_detach } from './run-ship-pre-detach'
+import { run_ship_stage, type Phase } from './run-ship-stage'
+
+// The pre-detach checks, timed into the lane ledger and marked on the event stream as a ship stage
+// is, so their minutes are no longer folded into the lane's implementation time
+// (joshuafolkken/kit#4382). They are not a `Stage`: nothing resumes past them, and `run:board` draws no
+// phase from a word it does not know.
+
+const SUCCESS_EXIT_CODE = 0
+const { PHASE } = run_ship_stage
+
+async function emit_phase(issue: string, phase: Phase): Promise<void> {
+	const text = run_ship_stage.event_text(issue, lane_ledger.PRE_DETACH_STAGE, phase)
+
+	await run_event_stream_emit.emit(run_event_stream.EVENT_KIND.SHIP_STAGE, text)
+}
+
+async function checks(
+	issue: string,
+	run: () => Promise<JoshResult> = run_ship_pre_detach.checks,
+): Promise<JoshResult> {
+	await emit_phase(issue, PHASE.START)
+	const started_ms = performance.now()
+	const result = await run()
+	const elapsed_ms = performance.now() - started_ms
+
+	await lane_ledger.record_stage({
+		stage: lane_ledger.PRE_DETACH_STAGE,
+		elapsed_ms,
+		issue: Number(issue),
+	})
+	await emit_phase(issue, result.code === SUCCESS_EXIT_CODE ? PHASE.DONE : PHASE.FAILED)
+
+	return result
+}
+
+const run_ship_pre_detach_timed = { checks }
+
+export { run_ship_pre_detach_timed }

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

@@ -1,17 +1,29 @@
 import { existsSync } from 'node:fs'
 import path from 'node:path'
+import { check_reuse, type CheckRecords } from '#scripts/gate/check-reuse'
+import { gate_plan } from '#scripts/gate/gate-plan'
+import type { GateStepResult } from '#scripts/gate/gate-report'
+import { gate_tree } from '#scripts/gate/gate-tree'
 import { project_checks } from '#scripts/gate/project-checks'
 import { type_check_step } from '#scripts/gate/type-check-step'
 import type { JoshResult } from '#scripts/josh/josh-run'
 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.
+//
+// **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,
@@ -25,14 +37,26 @@ import { buffered_process, type BufferedProcessResult } from '#scripts/lib/buffe
 // 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 STATIC_CHECKS: ReadonlyArray<PreDetachCheck> = [
+	{ list: ['josh', 'exports:unused'], label: gate_plan.EXPORTS_LABEL },
+	{ list: ['josh', 'cspell:dot'] },
 ]
 const GUARD_TEST_TARGETS: ReadonlyArray<string> = [
 	'scripts/document',
@@ -40,8 +64,8 @@ const GUARD_TEST_TARGETS: ReadonlyArray<string> = [
 	'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',
+	'tools/test/untested-sources.test.ts',
+	'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.
@@ -51,34 +75,52 @@ 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_TOTALS_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_plan.TYPE_CHECK_LABEL },
+		...STATIC_CHECKS,
+		...guard_tests(directory),
+		...kit_only(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)))
+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(results: ReadonlyArray<BufferedProcessResult>): JoshResult {
 	const failed = results.filter((result) => buffered_process.is_process_failed(result))
 
 	if (failed.length === 0) return { code: SUCCESS_EXIT_CODE, out: PASSED }
@@ -89,6 +131,20 @@ async function checks(directory: string = process.cwd()): Promise<JoshResult> {
 	}
 }
 
+// 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.
+async function checks(
+	directory: string = process.cwd(),
+	records: CheckRecords = check_reuse.DEFAULT_RECORDS,
+): Promise<JoshResult> {
+	const [lists, tree] = await Promise.all([command_lists(directory), gate_tree.read_gate_tree()])
+	const runs = await Promise.all(lists.map(async (check) => await run_in(directory, check)))
+
+	await check_reuse.record_green_checks(gate_results(runs), tree, records)
+
+	return verdict(runs.map(({ result }) => result))
+}
+
 const run_ship_pre_detach = {
 	GUARD_TEST_TARGETS,
 	METRICS_TOTALS_COMMAND,
@@ -97,4 +153,5 @@ const run_ship_pre_detach = {
 	checks,
 }
 
+export type { PreDetachCheck }
 export { run_ship_pre_detach }

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

@@ -4,11 +4,15 @@ 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_lock } from './run-ship-lock'
 import { run_ship_scoped } from './run-ship-scoped'
 
@@ -17,26 +21,58 @@ 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 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',
+	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)
+
+	if (draft !== undefined) return await readFile(draft, 'utf8')
+
+	return await git_gh_command.pr_get_body(branch)
+}
 
-	return await git_gh_command.pr_get_body(await git_branch.current())
+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 +80,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 +88,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 +125,128 @@ 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())
 }
 
 // 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] = 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()),
 	])
 
-	return [...preflight, ...evidence, ...acceptance, ...lock]
+	return [...preflight, ...evidence, ...acceptance, ...removed, ...lock]
 }
 
-async function stage(request: PreflightRequest): Promise<JoshResult> {
+async function stage(request: PreflightRequest): Promise<PreflightResult> {
 	const problems = 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,5 +1,6 @@
 import { git_command } from '#scripts/git/git-command'
 import { git_worktree } from '#scripts/git/git-worktree'
+import { issue_watch_gate } from '#scripts/issue/issue-watch-gate'
 import { error_text } from '#scripts/lib/error-message'
 import { run_hold } from '#scripts/run/hold/run-hold'
 import { run_preflight } from '#scripts/run/run-preflight'
@@ -60,16 +61,23 @@ async function read_merged(branch_name: string): Promise<boolean> {
 	return (await git_command.commit_count_beyond(base, HEAD_REFERENCE)) === 0
 }
 
+// The issue changed after the recorded review was briefed — the refusal `josh followup` would make
+// (joshuafolkken/kit#4221) — so the review stage re-runs instead of the followup failing again.
+async function read_review_stale(): Promise<boolean> {
+	return await or_false(async () => (await issue_watch_gate.review_refusal_here()) !== undefined)
+}
+
 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([
+	const [is_committed, is_pushed, is_merged, is_review_stale] = await Promise.all([
 		or_false(read_committed),
 		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 }
 }
 
 // A branch that cannot be named leaves nothing to ask about, so it reads as nothing done.
@@ -101,6 +109,6 @@ 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 = { read_review_stale, read_state, record_target, repository_directory }
 
 export { run_ship_probe }