@joshuafolkken/kit 1.3044.0 → 1.3099.0

package/scripts/run/detached-launch.ts

@@ -3,6 +3,7 @@ import { closeSync, constants, openSync, writeSync } from 'node:fs'
 import { agent_launch_environment } from '#scripts/agent/agent-launch-environment'
 import { agent_profile_schema, type AgentProfile } from '#scripts/agent/agent-profile-schema'
 import { agent_safe_text } from '#scripts/agent/agent-safe-text'
+import { codex_launch_identity } from '#scripts/agent/codex-launch-identity'
 import { agent_session_environment } from '#scripts/josh/agent-session-environment'
 import { stamp_file } from '#scripts/josh/stamp-file'
 import { launch_priority } from '#scripts/run/launch-priority'
@@ -25,9 +26,8 @@ const NO_PID_NOTE = 'the process started without a pid'
 const UNSAFE_NOTE =
 	'the wake command or its arguments are empty, over length, or contain characters that are not safe to execute'
 
-// Provider-specific commands and flags are composed before this boundary. This module accepts only
-// an argv vector and never infers policy from it; role/model/effort arrive separately as log metadata.
-// The provider adapter keeps the fixed binary and permission flags in one reviewed place.
+// Provider adapters own commands and flags. At this boundary the Codex adapter binds the launcher's
+// explicit lane identity to shell configuration before the final argv safety check.
 // **The inputs that reach `spawn` are validated rather than trusted, and that is a control rather than
 // a formality.** Two things already bound this — the argument vector never goes through a shell, so
 // there is no shell to inject into, and the invocation travels as exactly one argv element rather than
@@ -319,7 +319,15 @@ function spawned(
 // execs before it returns, so the child already holds its own duplicate of the descriptor by then;
 // what is closed here is this process's copy. Left open it would outlive the launch in a supervisor
 // that runs for hours and launches once per cut.
-function launch(request: LaunchRequest, on_error: (note: string) => void): LaunchResult {
+function prepared_request(request: LaunchRequest): LaunchRequest {
+	return {
+		...request,
+		argv: { ...request.argv, args: codex_launch_identity.arguments_for(request) },
+	}
+}
+
+function launch(input: LaunchRequest, on_error: (note: string) => void): LaunchResult {
+	const request = prepared_request(input)
 	if (!is_safe_argv(request.argv)) return { kind: 'failed', note: UNSAFE_NOTE }
 
 	const log = open_log(request.log_path, on_error)
@@ -336,10 +344,11 @@ function launch(request: LaunchRequest, on_error: (note: string) => void): Launc
 }
 
 async function launch_attached(
-	request: LaunchRequest,
+	input: LaunchRequest,
 	on_error: (note: string) => void,
 	on_spawn: (pid: number) => void = ignore_spawn,
 ): Promise<AttachedLaunchResult> {
+	const request = prepared_request(input)
 	if (!is_safe_argv(request.argv)) return { kind: 'failed', note: UNSAFE_NOTE }
 	const log = open_log(request.log_path, on_error)
 

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

@@ -2,15 +2,19 @@ import { git_branch } from '#scripts/git/git-branch'
 import { git_command } from '#scripts/git/git-command'
 import { lane_ledger_write } from '#scripts/lane/lane-ledger-write'
 
-// Measurement is best-effort, including the branch read outside a repository.
-async function record(source: 'review' | 'ship', result: string): Promise<void> {
+// Measurement is best-effort, including the branch read outside a repository. `slots` is the review
+// round's slot count, where the caller knows it.
+async function record(source: 'review' | 'ship', result: string, slots?: number): Promise<void> {
 	try {
 		const issue = git_branch.issue_from_branch(await git_command.branch())
+		const head = await git_command.head_commit()
 
 		await lane_ledger_write.record_early_push({
 			source,
 			result,
+			head,
 			...(issue !== undefined && { issue }),
+			...(slots !== undefined && { slots }),
 		})
 	} catch {
 		// A missing measurement never blocks a push.

package/scripts/run/event/run-event-setup.ts

@@ -17,6 +17,8 @@ const STAGE = {
 	PLANNING: 'planning',
 	// The supervisor took the run over from the parent and is asking for the first offer.
 	HANDING_OFF: 'handing off',
+	// No child is runnable; maintenance may still be finishing before the replaceable drain.
+	WATCHING: 'watching',
 	// The driver answered something only a session can act on — an untriaged child, an epic left to a
 	// person — and the supervisor is waking one. The next hand-off replaces it.
 	JUDGING: 'waiting on judgment',

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/hold/run-hold-ended.ts

@@ -0,0 +1,50 @@
+import { stamp_file } from '#scripts/josh/stamp-file'
+import { json_value } from '#scripts/lib/json-value'
+import { z } from 'zod'
+import type { HoldRead } from './run-hold'
+
+// The runs whose hold a merge released here. A single `fullrun` or `halfrun` in the root checkout has
+// no record but its hold (`run-board-single.ts`), and the release removes it, so without this
+// `run:board` would lose the run the moment it merged; this keeps when each began and ended for the
+// board's `✅ done` (joshuafolkken/kit#7525). The newest few only: the board reads the ones that ended
+// inside the run on screen.
+
+const ENDED_PREFIX = 'josh-run-hold-ended-'
+const KEPT_RUNS = 20
+
+const ended_hold_schema = z.object({
+	issue: z.string(),
+	is_fullrun: z.boolean().optional(),
+	taken_at: z.string(),
+	ended_at: z.string(),
+})
+
+type EndedHold = z.infer<typeof ended_hold_schema>
+
+// Keyed like the hold, on the work tree's own git directory.
+function ended_path(git_directory: string): string {
+	return stamp_file.stamp_path(ENDED_PREFIX, git_directory)
+}
+
+// None where no run has ended here, or the record does not read.
+function read_ended(target: string): ReadonlyArray<EndedHold> {
+	const raw = stamp_file.read_stamp_text(target)
+
+	return raw === undefined ? [] : (json_value.parse_with(raw, z.array(ended_hold_schema)) ?? [])
+}
+
+// Records the hold a merge is about to release; a read with no live hold names no run.
+function record_ended(target: string, read: HoldRead, now: Date = new Date()): void {
+	if (read.kind !== 'held') return
+
+	const { issue, is_fullrun, taken_at } = read.hold
+	const ended: EndedHold = { issue, taken_at, ended_at: now.toISOString() }
+
+	if (is_fullrun === true) ended.is_fullrun = true
+	stamp_file.replace_stamp(target, [...read_ended(target), ended].slice(-KEPT_RUNS))
+}
+
+const run_hold_ended = { KEPT_RUNS, ended_path, read_ended, record_ended }
+
+export { run_hold_ended }
+export type { EndedHold }

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))