@joshuafolkken/kit 1.2116.0 → 1.3041.0

package/scripts/run/run-step-section.ts

@@ -1,10 +1,13 @@
 import { document_section_cli } from '#scripts/document/document-section-cli'
-import { run_step, type StepAction } from './run-step'
+import { lane_child_marker } from '#scripts/lane/lane-child-marker'
+import type { StepAction } from './run-step'
+import { run_step_section_once } from './run-step-section-once'
+import { run_step_section_table, type SectionReference } from './run-step-section-table'
 
 // The section that governs each action `run:step` and `run:entry` print — the one table the action →
-// rule mapping lives in, so the manifests no longer carry a route table the reader walks to find it.
-// The command prints the section after its action line, which saves the `doc:section` turn the reader
-// would otherwise spend fetching a section the action already determined.
+// rule mapping lives in (`run-step-section-table.ts`), so the manifests no longer carry a route table
+// the reader walks to find it. The command prints the section after its action line, which saves the
+// `doc:section` turn the reader would otherwise spend fetching a section the action already determined.
 //
 // **A heading that does not resolve fails the command**, exactly as `doc:section` refuses it: a pointer
 // renamed away would otherwise print the action without its rule, and the reader would act unread.
@@ -12,52 +15,7 @@ import { run_step, type StepAction } from './run-step'
 const JOSH_PREFIX = 'pnpm josh '
 const COMMAND_SEPARATOR = ' '
 const SUCCESS_EXIT_CODE = 0
-
-// The key `run:entry` prints under — not a `run:step` action, but the entry's own read, kept in the
-// same table so every mechanically-chosen section has one home.
-const ENTRY = 'entry'
-
-interface SectionReference {
-	document: string
-	heading: string
-}
-
-function reference(document: string, heading: string): SectionReference {
-	return { document, heading }
-}
-
-// The gate's chain governs both the implementation it follows and a stopped ship's report.
-const CHAIN_RULE = 'chain-rule.md'
-const CHAIN = reference(CHAIN_RULE, 'Run the review-to-merge chain')
-const PROGRESS = 'backlogrun-progress.md'
-
-// Keyed on a verdict token, or on the josh subcommand a command action runs. An action with no row —
-// `wait`, `stop`, a `decide:` line — has no rule to read beyond its own line.
-const GOVERNING_SECTIONS: ReadonlyMap<string, SectionReference> = new Map([
-	[ENTRY, reference('split-assessment.md', 'The question')],
-	[run_step.IMPLEMENT, CHAIN],
-	[run_step.HUMAN_REVIEW, reference('needs-human-review.md', '`needs-human-review`')],
-	[run_step.UPDATE_DEPS, reference('latest-gate.md', 'The dependency update')],
-	['followup', reference('followup.md', 'Run `pnpm josh followup`')],
-	['review:round2', reference('prompts/review.md', 'Review round cap')],
-	['run:merge', reference(PROGRESS, "Running a named epic's children")],
-	['backlog:next', reference('backlogrun-steps.md', 'The loop')],
-	['run:cut', reference('pre-gate-cut.md', 'Resuming')],
-	['ship', CHAIN],
-	['retrospective', reference('retrospective.md', 'The end-of-run retrospective')],
-	['run:carry', reference(PROGRESS, 'The hand-off')],
-])
-
-// **A lane child reads its own step of the chain, never the whole of it** (joshuafolkken/kit#5016):
-// the chain's step 1 opens with `josh main:merge`, which a lane child leaves to ship's sync, and a
-// child handed the whole section ran it, moving the tree its scoped pair was green on. The step is
-// the chain's labelled step 0, cited where it stands, so it is written once; it ends at the sibling
-// item `1.`, so a blank line inside it would cut it short. A stopped ship's report reads it too.
-const LANE_CHILD_STEP = reference(CHAIN_RULE, 'A lane child')
-const LANE_CHILD_SECTIONS: ReadonlyMap<string, SectionReference> = new Map([
-	[run_step.IMPLEMENT, LANE_CHILD_STEP],
-	['ship', LANE_CHILD_STEP],
-])
+const { GOVERNING_SECTIONS, LANE_CHILD_SECTIONS } = run_step_section_table
 
 function key_of(action: StepAction): string {
 	if (action.kind !== 'command') return action.line
@@ -74,13 +32,33 @@ function section_for(key: string, is_lane_child: boolean): SectionReference | un
 }
 
 // Printed through `doc:section` itself, so the extent, the Bash-cap split and the refusal of an
-// unresolved heading are that command's, never a second copy of them.
+// unresolved heading are that command's, never a second copy of them. Each print is recorded for the
+// session, so a command printing its own row after it prints one line (`print_once`).
 function print_section(key: string, root: string = process.cwd(), is_lane_child = false): number {
 	const found = section_for(key, is_lane_child)
 
 	if (found === undefined) return SUCCESS_EXIT_CODE
+	const exit_code = document_section_cli.run([found.document, found.heading], root)
+
+	if (exit_code === SUCCESS_EXIT_CODE) run_step_section_once.record(found)
 
-	return document_section_cli.run([found.document, found.heading], root)
+	return exit_code
+}
+
+// **A command's own row prints once per session** (joshuafolkken/kit#5626): `run:review` and `ship`
+// print the section that governs them, so the reader spends no `doc:section` turn on it, and a
+// section this session already printed — by `run:step`, or by the other command — is one line.
+function print_once(key: string, root: string = process.cwd()): number {
+	const is_lane_child = lane_child_marker.is_child_of(root)
+	const found = section_for(key, is_lane_child)
+
+	if (found === undefined || !run_step_section_once.is_recorded(found)) {
+		return print_section(key, root, is_lane_child)
+	}
+
+	console.info(run_step_section_once.repeat_line(found))
+
+	return SUCCESS_EXIT_CODE
 }
 
 function print_for(
@@ -91,14 +69,22 @@ function print_for(
 	return print_section(key_of(action), root, is_lane_child)
 }
 
+const { CUT, ENTRY, PARK, PAUSE, PROGRESS, RESUME, RETROSPECTIVE } = run_step_section_table
+
 const run_step_section = {
+	CUT,
 	ENTRY,
 	GOVERNING_SECTIONS,
+	PARK,
+	PAUSE,
+	PROGRESS,
+	RESUME,
+	RETROSPECTIVE,
 	LANE_CHILD_SECTIONS,
 	key_of,
 	print_for,
+	print_once,
 	print_section,
 }
 
-export type { SectionReference }
 export { run_step_section }

package/scripts/run/run-step.ts

@@ -156,8 +156,9 @@ const KIND = run_event_stream.EVENT_KIND
 const OFFER_BACKLOG = 'pnpm josh backlog:next'
 const EVENT_ACTIONS: Record<string, (issue_number: string) => StepAction> = {
 	[KIND.PR_OPENED]: () => command('pnpm josh followup'),
-	[KIND.REVIEW_ROUND]: (issue_number) =>
-		command(`pnpm josh review:round2 --record ${issue_number}`),
+	// `ship --review` asks `review:round2 --record` itself and reuses a recorded round 1, so a run past
+	// round 1 hands the rest of the region to it rather than to the hand-run round-2 steps.
+	[KIND.REVIEW_ROUND]: () => command('pnpm josh ship --review'),
 	[KIND.MERGE]: merge_command,
 	[KIND.OUTAGE]: merge_command,
 	[KIND.PARK]: () => command(OFFER_BACKLOG),
@@ -201,7 +202,7 @@ function drain_action(input: StepInput): StepAction {
 // It is the existing merge-time cut, so the ownership check and the cut cap
 // apply unchanged, and the supervisor's driver adopts the in-flight lanes from their `child-launch`
 // events.
-const HAND_OFF_COMMAND = 'pnpm josh run:carry --cut --owner "$PPID"'
+const HAND_OFF_COMMAND = 'pnpm josh run:carry --cut'
 
 // After a dispatch the parent waits for its child — where waiting is free. A session the completion
 // does not re-invoke could only wait by polling, each poll a model call over its whole context, so a

package/scripts/run/run-stop-notify.ts

@@ -5,7 +5,7 @@ import type { CarryRead } from '#scripts/run/carry/run-carry'
 // remaining child blocked behind a parked one, the backlog drained of anything runnable, the failure
 // streak tripped — each ends the run, and while the session is the person's the stop is there in the
 // conversation. After a cut the parent is a headless `claude -p backlogrun`, so the stop would reach
-// its own transcript and nowhere else. The 15-minute heartbeat stays a pull; a *stop* is a state
+// its own transcript and nowhere else. The heartbeat stays a pull; a *stop* is a state
 // change, and a state change is what `confirmation` exists to push.
 //
 // **This is the decision, kept apart from the send so the dedup can be pinned without a Telegram.**

package/scripts/run/run-tail-cli.ts

@@ -1,8 +1,12 @@
 #!/usr/bin/env tsx
 import { fileURLToPath } from 'node:url'
+import { git_worktree } from '#scripts/git/git-worktree'
 import { issue_number_shape } from '#scripts/issue/issue-number-shape'
+import { session_cite } from '#scripts/issue/session-cite'
+import { josh_environment_file } from '#scripts/josh/josh-environment-file'
 import { josh_command } from '#scripts/josh/josh-run'
 import { lane_child_marker } from '#scripts/lane/lane-child-marker'
+import { report_labels } from '#scripts/report/report-labels'
 import { run_tail, type TailSection } from './run-tail'
 
 // `josh run:tail [<N> ...]` — one call for the fixed post-merge sequence a run closes on.
@@ -16,7 +20,7 @@ import { run_tail, type TailSection } from './run-tail'
 // — and go to `issue:cite`; the other two take none. A `run:tail` with no numbers still closes the run,
 // because `issue:cite` with no target exits zero.
 //
-// **A dispatched lane child skips the ledger step**. A flush opens a
+// **Every linked checkout, and a dispatched lane child, skips the ledger step**. A flush opens a
 // ledger-only pull request and waits out its whole CI before it merges — minutes per issue, spent on a
 // file only the retrospective and the measurements read — and a lane has nothing for it: its lines
 // merged with its own pull request. A single run outside a lane keeps the
@@ -50,8 +54,8 @@ const REPORT_STEPS: ReadonlyArray<Step> = [
 	{ header: run_tail.RELEASE_HEADER, argv: () => ['release:scope'] },
 ]
 
-function steps_for(is_lane_child: boolean): ReadonlyArray<Step> {
-	return is_lane_child ? REPORT_STEPS : [...LEDGER_STEPS, ...REPORT_STEPS]
+function steps_for(should_keep_checkout: boolean): ReadonlyArray<Step> {
+	return should_keep_checkout ? REPORT_STEPS : [...LEDGER_STEPS, ...REPORT_STEPS]
 }
 
 // Numbers only — a target `issue:cite` reads as an issue, so a stray flag is refused rather than
@@ -77,10 +81,11 @@ async function run_step(step: Step, issues: ReadonlyArray<string>): Promise<Tail
 async function close_run(issues: ReadonlyArray<string>): Promise<ReadonlyArray<TailSection>> {
 	const sections: Array<TailSection> = []
 
-	const is_lane_child = lane_child_marker.is_child_of(process.cwd())
+	const should_keep_checkout =
+		lane_child_marker.is_child_of(process.cwd()) || (await git_worktree.is_linked())
 
 	// eslint-disable-next-line no-await-in-loop -- the tail steps run in their declared order
-	for (const step of steps_for(is_lane_child)) sections.push(await run_step(step, issues))
+	for (const step of steps_for(should_keep_checkout)) sections.push(await run_step(step, issues))
 
 	return sections
 }
@@ -95,13 +100,16 @@ async function run(argv: ReadonlyArray<string>): Promise<number> {
 	}
 
 	const sections = await close_run(issues)
+	const citations = issues.map((issue) => session_cite.issue(issue))
+	const templates = run_tail.template_sections(citations, report_labels.session_labels())
 
-	console.info(run_tail.format_report(sections))
+	console.info(run_tail.format_report([...sections, ...templates]))
 
 	return run_tail.exit_code(sections)
 }
 
 async function main(argv: ReadonlyArray<string>): Promise<void> {
+	josh_environment_file.load_environment_file()
 	process.exitCode = await run(argv)
 }
 

package/scripts/run/run-tail.ts

@@ -9,15 +9,36 @@
 // each step's output under a header and answers the exit code from the collected codes, so a test pins
 // the composite without a ledger ever being committed or a release ever read.
 
+import type { ReportLabels } from '#scripts/report/report-labels'
+import { report_template } from '#scripts/report/report-template'
 import { run_section, type Section } from './run-section'
 
 const SYNC_HEADER = '=== sync ==='
 const OBSERVATIONS_HEADER = '=== observations ==='
 const CITATIONS_HEADER = '=== citations ==='
 const RELEASE_HEADER = '=== release ==='
+const CHILD_TEMPLATE_HEADER = '=== child summary template ==='
+const NOTIFY_TEMPLATE_HEADER = '=== notify-message template ==='
 
 type TailSection = Section
 
+// Only the cited targets are known here; the writer fills the narrative instead of inferring
+// success from bookkeeping. One result line keeps even a long target list within the summary bound.
+function template_sections(
+	citations: ReadonlyArray<string>,
+	labels: ReportLabels,
+): ReadonlyArray<TailSection> {
+	const targets = citations.join(', ')
+	const result = targets.length === 0 ? '<…>' : `<…> (${targets})`
+	const body = report_template.child_template(labels, result)
+
+	return [CHILD_TEMPLATE_HEADER, NOTIFY_TEMPLATE_HEADER].map((header) => ({
+		header,
+		body,
+		code: run_section.SUCCESS_EXIT_CODE,
+	}))
+}
+
 // **A failed step's stderr joins its body.** A detached run's log keeps the report, not the
 // terminal, so a refusal printed only to stderr would leave the section reading `ELIFECYCLE` alone. A
 // passing step's stderr is commentary and stays out of the report.
@@ -38,6 +59,7 @@ const run_tail = {
 	exit_code: run_section.exit_code_of,
 	format_report: run_section.format_sections,
 	section_body,
+	template_sections,
 }
 
 export type { TailSection }

package/scripts/run/run-watcher-guard.ts

@@ -1,3 +1,4 @@
+import { lane_reap } from '#scripts/lane/lane-reap'
 import { lane_registry } from '#scripts/lane/lane-registry'
 import { MS_PER_SECOND } from '#scripts/lib/timeouts'
 import { run_progress_clock } from '#scripts/run/progress/run-progress-clock'
@@ -39,18 +40,27 @@ const OK_RESULT: GuardResult = { kind: 'ok' }
 // `backlogrun` carry record is the one that dispatched them; every other session passes. A session
 // `run:wake` woke owes none either: the supervisor's driver watches the lanes, and the woken session
 // only acts on the branch it was handed and cuts.
-async function owes_watcher(): Promise<boolean> {
-	if (run_headless.is_headless() || !(await run_headless.is_backlog_parent())) return false
+async function owes_watcher(ancestry: () => ReadonlySet<number>): Promise<boolean> {
+	if (
+		run_headless.is_headless() ||
+		!(await run_headless.is_backlog_parent(process.env, ancestry))
+	) {
+		return false
+	}
 
 	return await lane_registry.has_lanes_in_flight()
 }
 
 // `life_target` is the path returned by `run_progress_read.stamp_target()` or
 // `run_progress_clock.life_target_of(git_directory)`. Passed in rather than resolved here so the
-// caller can use whichever resolution fits its sync/async context.
-async function check(life_target: string): Promise<GuardResult> {
+// caller can use whichever resolution fits its sync/async context. `ancestry` is the calling session's
+// (`HookContext`).
+async function check(
+	life_target: string,
+	ancestry: () => ReadonlySet<number> = lane_reap.own_ancestry,
+): Promise<GuardResult> {
 	if (
-		!(await owes_watcher()) ||
+		!(await owes_watcher(ancestry)) ||
 		run_progress_clock.is_life_fresh(life_target, STALE_THRESHOLD_MS)
 	) {
 		return OK_RESULT

package/scripts/run/run-watcher-hook.ts

@@ -1,3 +1,4 @@
+import { hook_context, type HookContext } from '#scripts/hooks/hook-context'
 import { hook_decision } from '#scripts/josh/hook-decision'
 import { lane_child_marker } from '#scripts/lane/lane-child-marker'
 import { json_value } from '#scripts/lib/json-value'
@@ -41,18 +42,22 @@ function fires_once(transcript: string, now_ms: number): boolean {
 
 // The guard is off when its switch is disabled or when this session is a dispatched lane child, which
 // runs no watcher of its own.
-function is_active(): boolean {
+function is_active(context: HookContext): boolean {
 	return (
 		hook_decision.is_switch_enabled(SWITCH_ENV_KEY) &&
-		lane_child_marker.marked_issue() === undefined
+		lane_child_marker.marked_issue(context.env) === undefined
 	)
 }
 
 // The guard's note when the watcher is stale and this call is the once-per-run one that refuses, or
 // `undefined` when the watcher is fresh (or the refusal was already spent this run). No session is asked
 // to relay the run's stream — the watch pane does.
-async function stale_reason(transcript: string, now_ms: number): Promise<string | undefined> {
-	const result = await run_watcher_guard.check(await run_progress_read.live_target())
+async function stale_reason(
+	transcript: string,
+	now_ms: number,
+	ancestry: () => ReadonlySet<number>,
+): Promise<string | undefined> {
+	const result = await run_watcher_guard.check(await run_progress_read.live_target(), ancestry)
 
 	if (result.kind === 'ok') return undefined
 
@@ -64,15 +69,16 @@ async function stale_reason(transcript: string, now_ms: number): Promise<string
 // record are read from disk; the composing hook already awaits.
 async function watcher_hook_reason(
 	raw_payload: string,
+	context: HookContext = hook_context.from_process(),
 	now_ms: number = Date.now(),
 ): Promise<string | undefined> {
-	if (!is_active()) return undefined
+	if (!is_active(context)) return undefined
 
 	const transcript = transcript_of(raw_payload)
 
 	if (transcript === undefined) return undefined
 
-	return await stale_reason(transcript, now_ms)
+	return await stale_reason(transcript, now_ms, context.ancestry)
 }
 
 const run_watcher_hook = { transcript_of, watcher_hook_reason }

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

@@ -1,4 +1,5 @@
 import { issue_number_shape } from '#scripts/issue/issue-number-shape'
+import { cli_body } from '#scripts/josh/cli-body'
 import { cli_flags } from '#scripts/lib/cli-flags'
 import { run_ship_body_draft } from './run-ship-body-draft'
 import type { ShipArguments } from './run-ship-steps'
@@ -78,6 +79,12 @@ function is_stray_unpinned_ok(values: ParsedValues): boolean {
 	return values.review !== true || reason.trim() === ''
 }
 
+// The preflight reads `--body-file` once per check and `git -y` reads it again, so stdin — readable
+// once — would reach all but the first as an empty body; `josh ship` takes a file path only.
+function is_refused_option(values: ParsedValues): boolean {
+	return is_stray_unpinned_ok(values) || values[BODY_FILE_OPTION] === cli_body.STDIN_PATH
+}
+
 // A follow-up citation passed as a trailing positional is a bare issue number, so a stray flag is
 // refused rather than forwarded to the wrong step.
 function ship_args(
@@ -117,7 +124,7 @@ function command_of(
 	positionals: ReadonlyArray<string>,
 ): ShipCommand | undefined {
 	if (values.log !== undefined) return log_command(values.log, positionals)
-	if (is_stray_unpinned_ok(values)) return undefined
+	if (is_refused_option(values)) return undefined
 
 	const title = positionals[FIRST]
 	const args =

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

@@ -10,18 +10,22 @@ import { run_ship_args } from './run-ship-args'
 import { run_ship_body_draft } from './run-ship-body-draft'
 import { run_ship_conflict_probe } from './run-ship-conflict-probe'
 import { run_ship_detach } from './run-ship-detach'
+import { run_ship_detach_wait } from './run-ship-detach-wait'
+import { run_ship_early_push } from './run-ship-early-push'
+import { run_ship_group } from './run-ship-group'
 import { run_ship_handover, type CodeCheck } from './run-ship-handover'
 import { run_ship_infra_retry } from './run-ship-infra-retry'
 import { run_ship_lap } from './run-ship-lap'
 import type { PreDetachResult } from './run-ship-pre-detach'
 import { run_ship_pre_detach_pinned } from './run-ship-pre-detach-pinned'
-import { run_ship_pre_detach_timed } from './run-ship-pre-detach-timed'
+import { run_ship_preflight } from './run-ship-preflight'
 import { run_ship_probe } from './run-ship-probe'
+import { run_ship_reship } from './run-ship-reship'
 import { run_ship_return } from './run-ship-return'
 import { run_ship_stage, type Phase, type ShipState, type Stage } from './run-ship-stage'
 import { run_ship_steps, type ShipArguments, type Step } from './run-ship-steps'
 import { run_ship_stop_cause } from './run-ship-stop-cause'
-import type { StepResult } from './run-ship-sync'
+import { run_ship_supervised } from './run-ship-supervised'
 
 // `josh ship "<title> #<N>"` — one call for the fixed commit-to-report region a run ships a change on.
 // It runs `gate`, `git -y`, `followup` and `run:tail` internally, so no round trip re-bills a lane's
@@ -135,13 +139,6 @@ async function emit_phase(
 	)
 }
 
-// A green stage that found nothing to do ends `skipped` rather than `done` (joshuafolkken/kit#5296).
-function settled_phase(section: ShipSection): Phase {
-	if (section.code !== SUCCESS_EXIT_CODE) return PHASE.FAILED
-
-	return section.is_skipped === true ? PHASE.SKIPPED : PHASE.DONE
-}
-
 // The record is written best-effort, as the event stream is: a record that could not be written costs
 // a resumed ship only the state re-read, never the stage that just succeeded.
 function record(target: string | undefined, write: (path: string) => void): void {
@@ -160,7 +157,7 @@ async function settle(
 	context: ShipContext,
 	section: ShipSection,
 ): Promise<void> {
-	const phase = settled_phase(section)
+	const phase = run_ship_group.settled_phase(section)
 
 	await emit_phase(args, context, { stage: step.stage, phase, reason: section.reason })
 
@@ -228,7 +225,9 @@ async function open_context(args: ShipArguments): Promise<ShipContext> {
 async function record_stop(args: ShipArguments, stage: Stage, failed?: ShipSection): Promise<void> {
 	const issue = Number(args.number)
 
-	await lane_ledger_write.record_stop(run_ship_stop_cause.record_of(issue, stage, failed))
+	await lane_ledger_write.record_stop(
+		await run_ship_reship.with_base(run_ship_stop_cause.record_of(issue, stage, failed)),
+	)
 	review_stop_log.record({ issue, stage, findings: run_ship_stop_cause.details_of(stage, failed) })
 }
 
@@ -261,14 +260,18 @@ async function ship_stage(
 	context: ShipContext,
 	sections: Array<ShipSection>,
 ): Promise<ShipOutcome | undefined> {
-	const section = await run_stage(step, args, context)
-
-	sections.push(section)
+	const failed = await run_ship_group.run(
+		step,
+		async (current) => await run_stage(current, args, context),
+		sections,
+	)
 
-	if (section.code !== SUCCESS_EXIT_CODE) {
-		return { sections: await stopped(sections, args, step, context), is_handed_over: false }
+	if (failed !== undefined) {
+		return { sections: await stopped(sections, args, failed.step, context), is_handed_over: false }
 	}
 
+	set_state(context, await run_ship_early_push.refresh(step.stage, args.is_review, context.state))
+
 	if (step.stage !== STAGE.SYNC) return undefined
 	const handover = await run_ship_handover.hand_over(args, context.is_stale)
 
@@ -314,7 +317,7 @@ async function print_log(number: string): Promise<number> {
 	return SUCCESS_EXIT_CODE
 }
 
-// The one-token contract `run:cut` keeps: the verdict on stdout, the explanation on stderr.
+// The verdict as its own stdout line, the explanation on stderr; a launch goes on to the wait.
 async function detach(args: ShipArguments): Promise<number> {
 	const repository = await run_ship_probe.repository_directory()
 
@@ -328,8 +331,9 @@ async function detach(args: ShipArguments): Promise<number> {
 
 	console.error(result.note)
 	console.info(result.verdict)
+	if (result.verdict !== run_ship_detach.LAUNCHED) return FAILURE_EXIT_CODE
 
-	return result.verdict === run_ship_detach.LAUNCHED ? SUCCESS_EXIT_CODE : FAILURE_EXIT_CODE
+	return await run_ship_detach_wait.after_launch(args.number)
 }
 
 // A headless lane child's turn ending kills a ship it left in its own process,
@@ -341,29 +345,30 @@ function should_detach(args: ShipArguments): boolean {
 	return !run_ship_detach.is_supervised() && lane_child_marker.is_child_of(process.cwd())
 }
 
-// The preflight stop's unmet kinds, with the red pre-detach checks' own kinds added beside them
-// (`run-ship-pre-detach.ts`).
-function with_checks(stop: ShipSection, checks: PreDetachResult): ShipSection {
-	if (checks.code === SUCCESS_EXIT_CODE) return stop
+// Record the stopped pre-detach stage while preserving the report's refusal order.
+async function pre_detach_stop(
+	args: ShipArguments,
+	stage: Stage,
+	sections: ReadonlyArray<ShipSection>,
+): Promise<ReadonlyArray<ShipSection>> {
+	await record_stop(args, stage, sections[0])
 
-	return {
-		...stop,
-		preconditions: [...(stop.preconditions ?? []), ...(checks.preconditions ?? [])],
-	}
+	return sections
 }
 
-// The stop is the sync stage's, so it is recorded and resumed as that stage's `conflict` is; the
-// preflight's refusal, if any, still prints last.
-async function conflict_sections(
+async function pre_detach_checks(
 	args: ShipArguments,
-	conflict: StepResult,
 	preflight: ShipSection,
+	checks_of: (args: ShipArguments) => Promise<PreDetachResult>,
 ): Promise<ReadonlyArray<ShipSection>> {
-	const section = run_ship.section_of(run_ship.SYNC_HEADER, conflict)
+	const result = await checks_of(args)
+	const checks = { header: run_ship.PRE_DETACH_HEADER, body: result.out, code: result.code }
 
-	await record_stop(args, STAGE.SYNC, section)
+	if (run_ship.exit_code([checks, preflight]) !== SUCCESS_EXIT_CODE) {
+		await record_stop(args, STAGE.PREFLIGHT, run_ship.with_checks(preflight, result))
+	}
 
-	return [section, preflight]
+	return [checks, preflight]
 }
 
 // The preflight is deterministic and fast, so it runs here, in the agent's own turn, before the
@@ -384,27 +389,37 @@ async function conflict_sections(
 //
 // **A conflict with origin/main stops before the checks** (joshuafolkken/kit#5018): the supervisor's
 // sync would stop on it after them, so they would only be run again once it is resolved.
+// A scoped failure stops before both the conflict and pinned probes: the review fix must pass its
+// local checks before costly work starts (joshuafolkken/kit#5472).
 async function pre_detach_sections(args: ShipArguments): Promise<ReadonlyArray<ShipSection>> {
 	const preflight = await run_stage(run_ship_steps.PREFLIGHT_STEP, args, await open_context(args))
-	const conflict = await run_ship_conflict_probe.probe()
 
-	if (conflict !== undefined) return await conflict_sections(args, conflict, preflight)
+	if (preflight.preconditions?.includes(run_ship_preflight.SCOPED_PRECONDITION)) {
+		return await pre_detach_stop(args, STAGE.PREFLIGHT, [preflight])
+	}
 
-	const result = await run_ship_pre_detach_timed.checks(
-		args.number,
-		run_ship_pre_detach_pinned.checks_for(args),
-	)
-	const checks = { header: run_ship.PRE_DETACH_HEADER, body: result.out, code: result.code }
+	const conflict = await run_ship_conflict_probe.probe()
 
-	if (run_ship.exit_code([checks, preflight]) !== SUCCESS_EXIT_CODE) {
-		await record_stop(args, run_ship_steps.PREFLIGHT_STEP.stage, with_checks(preflight, result))
+	if (conflict !== undefined) {
+		return await pre_detach_stop(args, STAGE.SYNC, [
+			run_ship.section_of(run_ship.SYNC_HEADER, conflict),
+			preflight,
+		])
 	}
 
-	return [checks, preflight]
+	return await pre_detach_checks(args, preflight, run_ship_pre_detach_pinned.timed_checks)
 }
 
+// A re-ship after a review or followup failure on an unmoved base passes over both but a `--review`
+// ship's `test:pinned` (`run-ship-reship.ts`).
 async function detach_after_preflight(args: ShipArguments): Promise<number> {
-	const sections = await pre_detach_sections(args)
+	const sections = (await run_ship_reship.is_due(args.number))
+		? await pre_detach_checks(
+				args,
+				await run_ship_reship.skipped(args.number),
+				run_ship_reship.checks,
+			)
+		: await pre_detach_sections(args)
 	const code = run_ship.exit_code(sections)
 
 	if (code === SUCCESS_EXIT_CODE) return await detach(args)
@@ -414,24 +429,6 @@ async function detach_after_preflight(args: ShipArguments): Promise<number> {
 	return code
 }
 
-async function supervised_repository(): Promise<string | undefined> {
-	return run_ship_detach.is_supervised() ? await run_ship_probe.repository_directory() : undefined
-}
-
-async function claim_supervised_identity(args: ShipArguments): Promise<void> {
-	const repository = await supervised_repository()
-	if (repository !== undefined) await run_ship_detach.claim_identity(repository, args.number)
-}
-
-async function record_supervised_result(
-	args: ShipArguments,
-	sections: ReadonlyArray<ShipSection>,
-): Promise<void> {
-	const repository = await supervised_repository()
-	if (repository === undefined) return
-	await run_ship_detach.mark_result(repository, args.number, run_ship.exit_code(sections))
-}
-
 async function run_ship_command(given: ShipArguments): Promise<number> {
 	const args = await run_ship_pre_detach_pinned.with_recorded_reason(given)
 
@@ -441,16 +438,22 @@ async function run_ship_command(given: ShipArguments): Promise<number> {
 		return await detach_after_preflight(args)
 	}
 
-	await claim_supervised_identity(args)
+	await run_ship_supervised.claim_identity(args)
 	const { sections, is_handed_over } = await ship(args)
 
 	// The successor carries the same launch record, so its result is the one written there.
-	if (!is_handed_over) await record_supervised_result(args, sections)
+	if (!is_handed_over) await run_ship_supervised.record_result(args, sections)
 	console.info(run_ship.format_report(sections))
 
 	return run_ship.exit_code(sections)
 }
 
+async function run_governed(args: ShipArguments): Promise<number> {
+	const printed = run_ship_supervised.print_section()
+
+	return printed === SUCCESS_EXIT_CODE ? await run_ship_command(args) : printed
+}
+
 async function run(argv: ReadonlyArray<string>): Promise<number> {
 	const command = run_ship_args.parse(argv)
 
@@ -462,7 +465,7 @@ async function run(argv: ReadonlyArray<string>): Promise<number> {
 
 	return command.kind === 'log'
 		? await print_log(command.number)
-		: await run_ship_command(await run_ship_body_draft.with_draft(command.args))
+		: await run_governed(await run_ship_body_draft.with_draft(command.args))
 }
 
 async function main(argv: ReadonlyArray<string>): Promise<void> {