@joshuafolkken/kit 1.3044.0 → 1.3092.0

package/scripts/run/event/run-event-stream-emit.ts

@@ -1,3 +1,4 @@
+import { statSync } from 'node:fs'
 import { lane_state, type LaneStateRecord } from '#scripts/lane/lane-state'
 import { error_text } from '#scripts/lib/error-message'
 import { run_board_lane_time } from '#scripts/run/board/run-board-lane-time'
@@ -5,6 +6,8 @@ import { run_carry } from '#scripts/run/carry/run-carry'
 import { run_event_scope } from './run-event-scope'
 import { run_event_stream, type AppendResult, type RunEvent } from './run-event-stream'
 
+const UNRESOLVED_STREAM = 'Could not resolve the run event stream.'
+
 // The write side of the run's event stream. It resolves the run's identity and
 // appends, and it is where the "reporting must not break the work it reports on" contract is kept: every
 // failure — a git call that hangs, a temp directory that cannot be written — is swallowed, so a lane
@@ -127,7 +130,8 @@ async function fresh_target(kind: string): Promise<string | undefined> {
  * `false`: neither is a fresh episode.
  *
  * `before_append` runs only on a fresh episode and is awaited before the marker becomes visible, for an
- * effect a reader of the marker must see finished — the drain flush (joshuafolkken/kit#5329).
+ * effect a reader of the marker must see finished — the drain's idle stage, set before the drain
+ * flush starts detached (joshuafolkken/kit#7505).
  */
 async function emit_once(
 	kind: string,
@@ -215,7 +219,7 @@ function read_current_events(
 	repository: string | undefined,
 	is_required: boolean,
 ): ReadonlyArray<RunEvent> {
-	if (repository === undefined) throw new Error('Could not resolve the run event stream.')
+	if (repository === undefined) throw new Error(UNRESOLVED_STREAM)
 
 	const read = run_carry.read_carry(run_carry.carry_path(repository))
 	const scope = run_event_scope.scope_of(read)
@@ -252,14 +256,30 @@ async function invocation_or_all_events(): Promise<ReadonlyArray<RunEvent>> {
 	}
 }
 
-// Every event on the stream, across invocations, for a reader that scopes by the event's own text
-// rather than by the carry record (`issue:file`'s fold). Fail-quiet like `current_events`.
-async function all_events(): Promise<ReadonlyArray<RunEvent>> {
+function read_existing_events(target: string, is_required: boolean): ReadonlyArray<RunEvent> {
+	if (is_required && statSync(target, { throwIfNoEntry: false }) === undefined) return []
+
+	return run_event_stream.read_events(target, is_required)
+}
+
+function read_all_events(
+	target: string | undefined,
+	is_required: boolean,
+): ReadonlyArray<RunEvent> {
+	if (target === undefined && is_required) throw new Error(UNRESOLVED_STREAM)
+
+	return target === undefined ? [] : read_existing_events(target, is_required)
+}
+
+// Every invocation, for issue-scoped readers. Required reads preserve failures, as current_events does.
+async function all_events(is_required = false): Promise<ReadonlyArray<RunEvent>> {
 	try {
 		const target = await stream_target()
 
-		return target === undefined ? [] : run_event_stream.read_events(target)
-	} catch {
+		return read_all_events(target, is_required)
+	} catch (error) {
+		if (is_required) throw error
+
 		return []
 	}
 }

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

@@ -50,6 +50,8 @@ const FORCE_FLAG = '--force'
 // implementation cut outside a lane resumes as `fullrun #N`.
 const FULLRUN_FLAG = '--fullrun'
 const HALFRUN_STOP_FLAG = '--halfrun-stop'
+// A `halfrun` fix round's start: the stopped record re-opened as the round's (`run-halfrun-resume.ts`).
+const HALFRUN_ROUND_FLAG = '--halfrun-round'
 // A `prrun`'s stop before merge: its record keeps the commit it stopped on.
 const PRRUN_STOP_FLAG = '--prrun-stop'
 // A `needs-human-review` stop: marked as a `halfrun` stop is, with its own confirmation.
@@ -59,7 +61,7 @@ const ADOPT_FLAG = '--adopt'
 // The most a claim reads: the issue number and the one flag after it.
 const MAX_CLAIM_ARGUMENTS = 2
 const USAGE =
-	'Usage: josh run:hold [<issue-number> [--fullrun | --halfrun-stop | --human-review-stop | --prrun-stop]] | josh run:hold --adopt <issue-number> | josh run:release [<issue-number> | --force]'
+	'Usage: josh run:hold [<issue-number> [--fullrun | --halfrun-stop | --halfrun-round | --human-review-stop | --prrun-stop]] | josh run:hold --adopt <issue-number> | josh run:release [<issue-number> | --force]'
 
 const COMMAND = 'run:hold'
 
@@ -79,9 +81,16 @@ const HALFRUN_STOP_KIND = 'halfrun-stop'
 const HUMAN_REVIEW_STOP_KIND = 'human-review-stop'
 const PRRUN_STOP_KIND = 'prrun-stop'
 const ADOPT_KIND = 'adopt'
+const HALFRUN_ROUND_KIND = 'halfrun-round'
 
 type StopKind = typeof HALFRUN_STOP_KIND | typeof HUMAN_REVIEW_STOP_KIND | typeof PRRUN_STOP_KIND
 
+// The requests that take over a record this issue's own run left: `--adopt` and `--halfrun-round`.
+interface TakeOverRequest {
+	kind: typeof ADOPT_KIND | typeof HALFRUN_ROUND_KIND
+	issue: string
+}
+
 interface ClaimRequest {
 	kind: 'claim'
 	issue: string
@@ -96,7 +105,7 @@ interface StopRequest {
 type HoldRequest =
 	| ClaimRequest
 	| StopRequest
-	| { kind: typeof ADOPT_KIND; issue: string }
+	| TakeOverRequest
 	| { kind: 'release'; claimant: string }
 	| { kind: typeof FORCE_RELEASE_KIND }
 
@@ -110,6 +119,12 @@ function is_stop_request(request: HoldRequest): request is StopRequest {
 	return STOP_KINDS.has(request.kind)
 }
 
+const TAKE_OVER_KINDS: ReadonlySet<string> = new Set([ADOPT_KIND, HALFRUN_ROUND_KIND])
+
+function is_take_over_request(request: HoldRequest): request is TakeOverRequest {
+	return TAKE_OVER_KINDS.has(request.kind)
+}
+
 const FORCE_RELEASE_REQUEST: HoldRequest = { kind: FORCE_RELEASE_KIND }
 
 function release_request(claimant: string): HoldRequest {
@@ -122,8 +137,8 @@ const STOP_KIND_BY_FLAG: ReadonlyMap<string, StopKind> = new Map([
 	[PRRUN_STOP_FLAG, PRRUN_STOP_KIND],
 ])
 
-// The flag after a numbered claim: absent, `--fullrun`, `--halfrun-stop`, `--human-review-stop` or
-// `--prrun-stop`. Anything else is a usage error.
+// The flag after a numbered claim: absent, `--fullrun`, `--halfrun-stop`, `--halfrun-round`,
+// `--human-review-stop` or `--prrun-stop`. Anything else is a usage error.
 function numbered_claim(issue: string, flag: string | undefined): HoldRequest | undefined {
 	if (flag === undefined) return { kind: 'claim', issue }
 
@@ -131,6 +146,8 @@ function numbered_claim(issue: string, flag: string | undefined): HoldRequest |
 
 	if (stop_kind !== undefined) return { kind: stop_kind, issue }
 
+	if (flag === HALFRUN_ROUND_FLAG) return { kind: HALFRUN_ROUND_KIND, issue }
+
 	return flag === FULLRUN_FLAG ? { kind: 'claim', issue, is_fullrun: true } : undefined
 }
 
@@ -414,10 +431,28 @@ async function adopt(target: string, issue: string): Promise<number> {
 	return report(run_hold_adopt.foreign_message(issue), BUSY_VERDICT, FAILURE_EXIT_CODE)
 }
 
+// The re-opened record answers `hold`; anything but #N's own stop answers `busy`, a failure, since
+// the round has no stopped `halfrun` to pick up.
+async function reopen_round(target: string, issue: string): Promise<number> {
+	const result = await run_halfrun_resume.reopen(target, issue)
+
+	if (result === run_halfrun_resume.MARKED) return report_hold()
+
+	if (result === run_halfrun_resume.UNREADABLE) return report_unreadable_record()
+
+	return report(run_halfrun_resume.no_stop_message(issue), BUSY_VERDICT, FAILURE_EXIT_CODE)
+}
+
+async function take_over(target: string, request: TakeOverRequest): Promise<number> {
+	const { kind, issue } = request
+
+	return kind === ADOPT_KIND ? await adopt(target, issue) : await reopen_round(target, issue)
+}
+
 async function dispatch(request: HoldRequest, target: string, is_linked: boolean): Promise<number> {
 	if (request.kind === 'claim') return await claim(target, request, is_linked)
 
-	if (request.kind === ADOPT_KIND) return await adopt(target, request.issue)
+	if (is_take_over_request(request)) return await take_over(target, request)
 
 	if (is_stop_request(request)) return await mark_stop(target, request)
 

package/scripts/run/merge/run-merge-cut-release.ts

@@ -0,0 +1,17 @@
+import { lane_registry } from '#scripts/lane/lane-registry'
+import { run_cut } from '#scripts/run/cut/run-cut'
+import { run_cut_adoption } from '#scripts/run/cut/run-cut-adoption'
+
+// Only called after the worker has stopped; every terminal collection releases the same owner.
+async function release(child: string): Promise<void> {
+	const lane = await lane_registry.find_open_lane(child)
+	if (lane === undefined) return
+	const carried = run_cut.lane_cut_sync(lane.directory)
+	if (carried === undefined) return
+
+	run_cut_adoption.release(carried.target, carried.cut, child)
+}
+
+const run_merge_cut_release = { release }
+
+export { run_merge_cut_release }

package/scripts/run/merge/run-merge-human-review.ts

@@ -1,7 +1,9 @@
 import { issue_cite } from '#scripts/issue/issue-cite'
+import { lane_await } from '#scripts/lane/lane-await'
 import { lane_state } from '#scripts/lane/lane-state'
 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_merge_cut_release } from './run-merge-cut-release'
 
 // A child may exit before its stop marker: retain its lane before settling its dispatch.
 async function retain(issue: string): Promise<boolean> {
@@ -13,6 +15,10 @@ async function retain(issue: string): Promise<boolean> {
 
 	if (retained.kind !== 'written') return false
 
+	if (lane_await.process_trace_default(issue) === 'none') {
+		await run_merge_cut_release.release(issue)
+	}
+
 	await run_event_stream_emit.emit(
 		run_event_stream.EVENT_KIND.HUMAN_REVIEW,
 		`${issue_cite.plain_for('program', issue)} waiting for human review`,

package/scripts/run/merge/run-merge-steps.ts

@@ -1,11 +1,5 @@
-import { git_gh_command } from '#scripts/gh/git-gh-command'
 import { git_gh_issue_write } from '#scripts/gh/git-gh-issue-write'
-import { issue_cite } from '#scripts/issue/issue-cite'
-import { has_label_name, NOT_BEFORE_LABEL } from '#scripts/issue/issue-labels'
-import { issue_not_before } from '#scripts/issue/issue-not-before'
 import { issue_park } from '#scripts/issue/issue-park'
-import { issue_sample_prime } from '#scripts/issue/issue-sample-prime'
-import { issue_state_cli } from '#scripts/issue/issue-state-cli'
 import { session_cite } from '#scripts/issue/session-cite'
 import { josh_command, type JoshResult } from '#scripts/josh/josh-run'
 import { lane_preserve } from '#scripts/lane/lane-preserve'
@@ -23,14 +17,15 @@ import {
 } from '#scripts/run/carry/run-carry'
 import { run_carry_conversation } from '#scripts/run/carry/run-carry-conversation'
 import { run_cut, type RunCut } from '#scripts/run/cut/run-cut'
-import { run_cut_adoption } from '#scripts/run/cut/run-cut-adoption'
 import type { StallCause } from '#scripts/run/park/run-stalled'
 import { run_label } from '#scripts/run/run-label'
 import { run_merge, type EndingSignals } from './run-merge'
 import { run_merge_cap } from './run-merge-cap'
 import { run_merge_close } from './run-merge-close'
+import { run_merge_cut_release } from './run-merge-cut-release'
 import { run_merge_decision } from './run-merge-decision'
 import { run_merge_github_limit } from './run-merge-github-limit'
+import { run_merge_waits } from './run-merge-waits'
 
 // The result of attempting to apply a carry change. Distinguishing `refused` from `applied` lets
 // callers surface the refusal as a hard failure rather than silently continuing on a carry that was
@@ -53,7 +48,6 @@ const LANES = '--lanes'
 const REPO_FLAG = '--repo'
 const CLOSE_CAUSE = '`run:merge` closed it'
 const STOPPED_CAUSE = 'the unit stopped and `run:merge --stash` classified it'
-const OPEN_STATE = 'OPEN'
 const SYNC_RETRY = { attempts: 3, interval_ms: 5000 }
 
 // One returned child's context, gathered from the command line by the CLI, and the ending signals its
@@ -92,8 +86,6 @@ interface FailedResult {
 }
 
 const NO_WAITS: ReadonlyArray<string> = []
-// The wait a `not-before` label alone records: the label carries no date, only that one is ahead.
-const NOT_BEFORE_WAIT = 'a start date still ahead (`not-before`)'
 
 // A captured `pnpm josh` subprocess: its output is read back rather than inherited, and a non-zero
 // exit is a value to branch on rather than a throw. The step's stderr stays piped here — `run:merge`
@@ -270,21 +262,12 @@ async function do_merged(
 	return undefined
 }
 
-async function release_cut(child: string): Promise<void> {
-	const lane = await lane_registry.find_open_lane(child)
-	if (lane === undefined) return
-	const carried = run_cut.lane_cut_sync(lane.directory)
-	if (carried === undefined) return
-
-	run_cut_adoption.release(carried.target, carried.cut, child)
-}
-
 // A child that ended without a merge: end whatever of its process still runs, release its adoption, drop its stale
 // `in-progress`, and close its lane if the child left nothing in it. The reap comes first, so the lane
 // reads with no live process.
 async function release_child(child: string): Promise<void> {
 	await lane_seat_stop.stop(child)
-	await release_cut(child)
+	await run_merge_cut_release.release(child)
 	await run_label.unmark(child)
 	await close_vacant_lane(child)
 }
@@ -293,42 +276,6 @@ function refused_result(carry: RunCarry): FailedResult {
 	return { carry, is_parked: false, is_refused: true, waits: NO_WAITS }
 }
 
-// The child's open `blocked-by` blockers, cited. A read that fails answers none, so the child is
-// parked — a relation nobody could read is never taken as a dependency.
-async function open_blockers(child: string): Promise<ReadonlyArray<string>> {
-	try {
-		const references = await git_gh_command.issue_blocked_by_references(child, '')
-
-		return references
-			.filter((blocker) => blocker.state === OPEN_STATE)
-			.map((blocker) => issue_cite.plain_for('github', blocker.number, blocker.repo))
-	} catch {
-		return NO_WAITS
-	}
-}
-
-// Whether the child carries `not-before` — the body's start date copied to a label. Read only where the
-// body could not be: the body is the source, so a label it no longer backs is never a wait.
-async function has_not_before_label(ctx: MergeContext): Promise<boolean> {
-	const read = await issue_state_cli.read_issue(ctx.child, ctx.repo)
-
-	return read.kind === 'state' && has_label_name(read.state.labels, NOT_BEFORE_LABEL)
-}
-
-// The child's declared start date while it is still ahead (joshuafolkken/kit#4076), or its `not-before`
-// label when the body could not be read (joshuafolkken/kit#4102), or the samples it still waits on. A
-// due date or none answers none, so the child is parked as before.
-async function start_date_wait(ctx: MergeContext): Promise<ReadonlyArray<string>> {
-	const body = await git_gh_command.issue_get_body(ctx.child, ctx.repo)
-
-	if (body === undefined) return (await has_not_before_label(ctx)) ? [NOT_BEFORE_WAIT] : NO_WAITS
-
-	await issue_sample_prime.prime([body])
-	const reason = issue_not_before.waiting_reason(body)
-
-	return reason === undefined ? NO_WAITS : [reason]
-}
-
 // A child that ended unfinished while an open blocker it records still has to land first, or while
 // its declared start date is still ahead, is waiting, not failed: nothing is counted and
 // `needs-decision` is not applied — when it runs is already recorded, so there is nothing for a person
@@ -381,7 +328,7 @@ async function park_failed(ctx: MergeContext, cause: StallCause): Promise<Failed
 // person. Without a cause of the caller's, a child whose detached ship ended is parked for the ship's
 // stop.
 async function do_failed(ctx: MergeContext, cause?: StallCause): Promise<FailedResult> {
-	const waits = [...(await open_blockers(ctx.child)), ...(await start_date_wait(ctx))]
+	const waits = await run_merge_waits.read(ctx)
 
 	if (waits.length > 0) return await do_waiting(ctx, waits)
 

package/scripts/run/merge/run-merge-waits.ts

@@ -0,0 +1,54 @@
+import { git_gh_command } from '#scripts/gh/git-gh-command'
+import { issue_cite } from '#scripts/issue/issue-cite'
+import { has_label_name, NOT_BEFORE_LABEL } from '#scripts/issue/issue-labels'
+import { issue_not_before } from '#scripts/issue/issue-not-before'
+import { issue_sample_prime } from '#scripts/issue/issue-sample-prime'
+import { issue_state_cli } from '#scripts/issue/issue-state-cli'
+import { lane_dispatch_dependency } from '#scripts/lane/lane-dispatch-dependency'
+import type { MergeContext } from './run-merge-steps'
+
+const NOT_BEFORE_WAIT = 'a start date still ahead (`not-before`)'
+
+async function open_blockers(child: string): Promise<ReadonlyArray<string>> {
+	try {
+		const references = await git_gh_command.issue_blocked_by_references(child, '')
+
+		return references
+			.filter((blocker) => blocker.state === 'OPEN')
+			.map((blocker) => issue_cite.plain_for('github', blocker.number, blocker.repo))
+	} catch {
+		return []
+	}
+}
+
+async function has_not_before_label(ctx: MergeContext): Promise<boolean> {
+	const state = await issue_state_cli.read_issue(ctx.child, ctx.repo)
+
+	return state.kind === 'state' && has_label_name(state.state.labels, NOT_BEFORE_LABEL)
+}
+
+async function start_date_wait(ctx: MergeContext): Promise<ReadonlyArray<string>> {
+	const body = await git_gh_command.issue_get_body(ctx.child, ctx.repo)
+
+	if (body === undefined) {
+		return [(await has_not_before_label(ctx)) ? NOT_BEFORE_WAIT : 'issue body confirmation']
+	}
+
+	await issue_sample_prime.prime([body])
+	const reason = issue_not_before.waiting_reason(body)
+
+	return reason === undefined ? [] : [reason]
+}
+
+// A withheld resume is already known to be retryable, including a read failure. Do not turn it
+// into a mechanical failure because a second GitHub read still cannot answer.
+async function read(ctx: MergeContext): Promise<ReadonlyArray<string>> {
+	const deferred = await lane_dispatch_dependency.deferred(ctx.child)
+	if (deferred.length > 0) return deferred
+
+	return [...(await open_blockers(ctx.child)), ...(await start_date_wait(ctx))]
+}
+
+const run_merge_waits = { read }
+
+export { run_merge_waits }

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

@@ -2,6 +2,7 @@
 import { fileURLToPath } from 'node:url'
 import { backlog_drive_launch } from '#scripts/backlog/backlog-drive-launch'
 import { josh_command, type JoshResult } from '#scripts/josh/josh-run'
+import { run_startup } from '#scripts/run/startup/run-startup'
 
 // `josh run:prime` — what a backlogrun owes once per repository before its first lane opens, in one
 // call (`backlogrun-lanes.md` → "Once per repository, before the first lane opens"): `main:sync`,
@@ -30,7 +31,13 @@ function first_line(result: JoshResult): string {
 
 // `undefined` once the step failed, its failure named on stderr.
 async function step(argv: ReadonlyArray<string>): Promise<JoshResult | undefined> {
-	const result = await josh_command.josh_run(argv, should_forward_stderr)
+	const result = await run_startup.phase(
+		`initialization ${argv[0] ?? ''}`,
+		async () => await josh_command.josh_run(argv, should_forward_stderr),
+		{
+			edge_of: (value) => (value.code === SUCCESS_EXIT_CODE ? 'done' : 'failed'),
+		},
+	)
 
 	if (result.out !== '') console.error(result.out)
 	if (result.code === SUCCESS_EXIT_CODE) return result
@@ -93,7 +100,14 @@ async function run(argv: ReadonlyArray<string>): Promise<number> {
 		return FAILURE_EXIT_CODE
 	}
 
-	return (await primed()) ? await sweep() : FAILURE_EXIT_CODE
+	return await run_startup.phase(
+		'initialization',
+		async () => ((await primed()) ? await sweep() : FAILURE_EXIT_CODE),
+		{
+			root: true,
+			edge_of: (value) => (value === SUCCESS_EXIT_CODE ? 'done' : 'failed'),
+		},
+	)
 }
 
 if (process.argv[1] === fileURLToPath(import.meta.url)) {

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

@@ -54,7 +54,7 @@ import { run_review_unplanned } from './run-review-unplanned'
 // `josh check:related` before its round is recorded, joshuafolkken/kit#4948) starts it again on a tree a round-1 fix
 // moved, after the join has closed the pair, and reads its answer without joining a gate that already
 // settled. The ship's pre-detach reads that answer anyway, so a lane need not
-// (joshuafolkken/kit#4895), and a lane child's `--pinned` returns at once rather than wait in the
+// (joshuafolkken/kit#4895), and a lane child's `--pinned` returns at once except for a ship's remaining
 // foreground (joshuafolkken/kit#5293). **`--join --fixing` waits no grace on the check**: round 1's fixes will move
 // its tree. **A lane child's open commits first and `--push` pushes at the green gate**
 // (`run-review-early-push.ts`).
@@ -181,7 +181,7 @@ function join_hint(slots: ReadonlyArray<ReviewSlot>): string {
 // The early push waits on the gate this pair launched, so it follows a written brief alone.
 function follow_brief(slots: ReadonlyArray<ReviewSlot>, is_early_push: boolean): void {
 	process.stderr.write(`${join_hint(slots)}\n`)
-	if (is_early_push) run_review_early_push.launch()
+	if (is_early_push) run_review_early_push.launch(slots.length)
 }
 
 const GREEN_NOTE = 'Gate green — the review verdict may be adopted.'
@@ -441,15 +441,13 @@ async function run_open(is_code_only: boolean, argv: ReadonlyArray<string>): Pro
 }
 
 async function run_pinned(): Promise<number> {
-	if (lane_child_marker.is_child_of(process.cwd())) {
+	if (lane_child_marker.is_child_of(process.cwd()) && !run_review_pinned_steps.is_remaining()) {
 		process.stdout.write(`${LANE_PINNED_NOTE}\n`)
 
 		return SUCCESS_EXIT_CODE
 	}
 
-	const is_unpinned = await show_pinned(
-		run_review_join_read.read_with(run_review_pinned_steps.wait_alone),
-	)
+	const is_unpinned = await show_pinned(run_review_join_read.read_remaining())
 
 	return is_unpinned ? run_review.UNPINNED_EXIT_CODE : SUCCESS_EXIT_CODE
 }
@@ -459,13 +457,13 @@ const LONE_MODES: ReadonlyMap<string, () => Promise<number>> = new Map([
 	[JOIN_FLAG, run_join],
 	[`${JOIN_FLAG} ${FIXING_FLAG}`, run_join_fixing],
 	[PINNED_FLAG, run_pinned],
-	[run_review_early_push.PUSH_FLAG, run_review_early_push.push],
 ])
 
 async function run(argv: ReadonlyArray<string>): Promise<number> {
 	const lone = LONE_MODES.get(argv.join(' '))
 
 	if (lone !== undefined) return await lone()
+	if (argv[0] === run_review_early_push.PUSH_FLAG) return await run_review_early_push.push(argv[1])
 	const is_code_only = argv[0] === run_review.CODE_ONLY_FLAG
 
 	return await run_open(is_code_only, argv.slice(is_code_only ? 1 : 0))

package/scripts/run/review/run-review-early-push.ts

@@ -87,28 +87,37 @@ async function prepare(
 	directory?: string,
 ): Promise<boolean> {
 	const reason = preparation_skip(plan, environment ?? process.env, directory ?? PROJECT_ROOT)
+	const slots = plan.slots.length
 
 	if (reason !== undefined) {
-		await early_push_record.record('review', reason)
+		await early_push_record.record('review', reason, slots)
 
 		return false
 	}
 
 	const is_committed = await commit_locally()
 
-	if (!is_committed) await early_push_record.record('review', 'commit-refused')
+	if (!is_committed) await early_push_record.record('review', 'commit-refused', slots)
 
 	return is_committed
 }
 
-function launch(): void {
+// The background push records the round's slot count, so it rides on the argv.
+function launch(slots: number): void {
 	const log_path = stamp_file.stamp_path(PUSH_LOG_PREFIX, PROJECT_ROOT)
-	const result = run_review_steps.launch_josh([RUN_REVIEW_COMMAND, PUSH_FLAG], log_path)
+	const argv = [RUN_REVIEW_COMMAND, PUSH_FLAG, String(slots)]
+	const result = run_review_steps.launch_josh(argv, log_path)
 
 	if (result.kind !== 'failed') return
 
 	process.stderr.write(`${SKIPPED_NOTE}the push could not be started: ${result.note}\n`)
-	void early_push_record.record('review', 'launch-failed')
+	void early_push_record.record('review', 'launch-failed', slots)
+}
+
+function slot_count(argument: string | undefined): number | undefined {
+	const slots = Number(argument)
+
+	return Number.isSafeInteger(slots) && slots > 0 ? slots : undefined
 }
 
 async function skip_reason(): Promise<string | undefined> {
@@ -127,13 +136,14 @@ async function body_arguments(): Promise<ReadonlyArray<string>> {
 	return run_ship_body_draft.body_arguments(draft)
 }
 
-// `josh run:review --push`, the background half: a skipped push exits 0, as nothing failed.
-async function push(): Promise<number> {
+// `josh run:review --push <slots>`, the background half: a skipped push exits 0, as nothing failed.
+async function push(slots_argument?: string): Promise<number> {
+	const slots = slot_count(slots_argument)
 	const reason = await skip_reason()
 
 	if (reason !== undefined) {
 		process.stdout.write(`${SKIPPED_NOTE}${reason === DIRTY_REASON ? DIRTY_NOTE : RED_NOTE}\n`)
-		await early_push_record.record('review', reason)
+		await early_push_record.record('review', reason, slots)
 
 		return SUCCESS_EXIT_CODE
 	}
@@ -143,6 +153,7 @@ async function push(): Promise<number> {
 	await early_push_record.record(
 		'review',
 		result.code === SUCCESS_EXIT_CODE ? 'pushed' : 'push-failed',
+		slots,
 	)
 
 	process.stdout.write(`${result.out}\n`)

package/scripts/run/review/run-review-join-read.ts

@@ -5,6 +5,7 @@ import { test_pinned_logic } from '#scripts/test/test-pinned-logic'
 import type { PinnedSummary } from '#scripts/test/test-pinned-record'
 import { run_review_pinned_accepted } from './run-review-pinned-accepted'
 import { run_review_pinned_join } from './run-review-pinned-join'
+import { run_review_pinned_remaining } from './run-review-pinned-remaining'
 import { run_review_pinned_steps } from './run-review-pinned-steps'
 
 // The read of `josh run:review --join` on the background `josh test:pinned` (joshuafolkken/kit#5212).
@@ -76,19 +77,45 @@ async function read(
 	is_fixing = false,
 ): Promise<JoinVerdict | undefined> {
 	return await read_with(
-		async () => await run_review_pinned_join.wait_for_join(root, undefined, is_fixing),
+		async () =>
+			await run_review_pinned_remaining.collect(
+				await run_review_pinned_join.wait_for_join(root, undefined, is_fixing),
+				root,
+			),
 		root,
 	)
 }
 
-// `review:record`'s read: only an answer already left on this very tree
-// (`run_review_pinned_join.finished_on_tree`). It neither waits (joshuafolkken/kit#4895) nor starts a
-// check, so the restart that follows on a moved tree still says who reads its answer.
+// Record collects an existing remaining probe, but never waits for a fresh round-1 check.
 async function read_finished(root: string = PROJECT_ROOT): Promise<JoinVerdict | undefined> {
-	return await read_with(async () => await run_review_pinned_join.finished_on_tree(root), root)
+	return await read_with(
+		async () =>
+			(await run_review_pinned_remaining.read(root)) ??
+			(await run_review_pinned_remaining.collect(
+				await run_review_pinned_join.finished_on_tree(root),
+				root,
+			)),
+		root,
+	)
+}
+
+async function read_remaining(): Promise<JoinVerdict | undefined> {
+	return await read_with(
+		async () =>
+			(await run_review_pinned_remaining.read()) ??
+			(await run_review_pinned_remaining.collect(await run_review_pinned_steps.wait_alone())),
+	)
 }
 
-const run_review_join_read = { is_due, mark_due, read, read_finished, read_with, verdict }
+const run_review_join_read = {
+	is_due,
+	mark_due,
+	read,
+	read_finished,
+	read_remaining,
+	read_with,
+	verdict,
+}
 
 export type { JoinVerdict, PinnedWait }
 export { run_review_join_read }