@joshuafolkken/kit 1.3041.0 → 1.3092.0

package/scripts/run/carry/run-carry.ts

@@ -10,6 +10,7 @@ import { z } from 'zod'
 import { run_carry_added, type CarryAddition } from './run-carry-added'
 import { run_carry_change } from './run-carry-change'
 import { run_carry_conversation } from './run-carry-conversation'
+import { run_carry_session } from './run-carry-session'
 
 // A `backlogrun` declares a budget — `--max` and `--idle` — and the session
 // cut ends the session, so the next one would start from nothing. **The cut is an execution detail of
@@ -99,6 +100,7 @@ interface RunCarry {
 	// `undefined`, so absent and explicitly-undefined are the *same* record on disk — a type that told
 	// them apart would be asserting a distinction nothing here can observe.
 	owner_pid?: number | undefined
+	owner_session?: string | undefined
 	owner_start?: string | undefined
 	// The owner conversation's transcript, which outlives a restart of its process
 	// (`run-carry-conversation.ts`). Optional for the same reason as the pid.
@@ -142,6 +144,7 @@ interface RunCarry {
 // token, so a reissued pid is never mistaken for the process that wrote the record — and the
 // transcript of the conversation that process runs, which outlives it (`run-carry-conversation.ts`).
 interface CarryOwner {
+	session?: string | undefined
 	provider?: AgentProvider | undefined
 	pid?: number | undefined
 	start?: string | undefined
@@ -207,6 +210,7 @@ const run_carry_schema = z.object({
 	// An absent owner reads as "no owner declared", which is the not-provably-live answer rather than a
 	// live one.
 	owner_pid: z.number().optional(),
+	owner_session: z.string().optional(),
 	owner_start: z.string().optional(),
 	owner_transcript: z.string().optional(),
 	is_owner_headless: z.boolean().optional(),
@@ -269,8 +273,10 @@ function owner_of(
 // none exported, no owner is declared.
 function session_owner(): CarryOwner {
 	const pid = agent_session_environment.own_session_pid()
+	const owner = pid === undefined ? NO_OWNER : owner_of(pid)
+	const session = run_carry_session.own()
 
-	return pid === undefined ? NO_OWNER : owner_of(pid)
+	return session === undefined ? owner : { ...owner, session }
 }
 
 function fresh_carry(invocation: string, owner: CarryOwner, now: Date): RunCarry {
@@ -284,6 +290,7 @@ function fresh_carry(invocation: string, owner: CarryOwner, now: Date): RunCarry
 		failures: NO_INCREMENT,
 		outages: NO_INCREMENT,
 		owner_pid: owner.pid,
+		owner_session: owner.session,
 		owner_start: owner.start,
 		owner_transcript: owner.transcript,
 		is_owner_headless: owner.is_headless,
@@ -318,17 +325,19 @@ function adopt_carry(
 	carry: RunCarry,
 	owner: CarryOwner = NO_OWNER,
 ): RunCarry | undefined {
+	const next_owner = run_carry_session.retain_execution(carry, owner)
 	// The run's own fields carry across untouched — the counters, the outage fold timestamp, `done` so the successor does not re-run what the cut session finished,
 	// and `retrospective` so a run resumed after a cut does not repeat its retrospective. Only the
 	// ownership fields are overridden: the new owner replaces the old — a caller that declared none
 	// writes `undefined`, so the previous owner cannot survive — and the declared hand-off is spent.
 	const next: RunCarry = {
 		...carry,
-		scheduler_provider: owner.provider,
-		owner_pid: owner.pid,
-		owner_start: owner.start,
+		scheduler_provider: next_owner.provider,
+		owner_pid: next_owner.pid,
+		owner_session: owner.session,
+		owner_start: next_owner.start,
 		owner_transcript: owner.transcript,
-		is_owner_headless: owner.is_headless,
+		is_owner_headless: next_owner.is_headless,
 		is_handed_off: false,
 	}
 
@@ -352,11 +361,7 @@ function is_owner_live(
 	return carry.is_owner_headless !== true && run_carry_conversation.is_conversation_live(carry, now)
 }
 
-function is_owned_by(carry: RunCarry, owner: CarryOwner): boolean {
-	if (run_carry_conversation.is_same_conversation(carry, owner)) return true
-
-	return carry.owner_pid === owner.pid && carry.owner_start === owner.start
-}
+const { is_owned_by } = run_carry_session
 
 // The one case that is not this caller's to touch: the record's owner is still running and it is
 // somebody else. **The invocation text is not consulted** — a live owner holds the budget whatever
@@ -370,14 +375,15 @@ function is_foreign_live_owner(carry: RunCarry, owner: CarryOwner): boolean {
 // conversation match would read that live session's record as the supervisor's own. The driver adopts
 // the record for the supervisor's process (`run-wake-driver.ts` → `claim_record`), so without this a
 // supervisor reads itself as a session at work.
+function is_held_by_self(carry: RunCarry, caller: CarryOwner = owner_of(process.pid)): boolean {
+	return carry.owner_pid === caller.pid && carry.owner_start === caller.start
+}
+
 function is_held_by_another(
 	carry: RunCarry,
 	is_live: (carry: RunCarry) => boolean = is_owner_live,
 ): boolean {
-	const caller = owner_of(process.pid)
-	const is_own = carry.owner_pid === caller.pid && carry.owner_start === caller.start
-
-	return !is_own && is_live(carry)
+	return !is_held_by_self(carry) && is_live(carry)
 }
 
 function is_handed_off_to(carry: RunCarry, invocation: string): boolean {
@@ -552,6 +558,7 @@ const run_carry = {
 	is_count_refused,
 	is_foreign_live_owner,
 	is_held_by_another,
+	is_held_by_self,
 	is_owner_live,
 	lost_message,
 	nothing_to_resume_message,

package/scripts/run/cut/run-cut-resume.ts

@@ -3,6 +3,7 @@ import { cost_verdict } from '#scripts/cost-runtime/cost-verdict'
 import { issue_cite } from '#scripts/issue/issue-cite'
 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_repair_attempt } from '#scripts/run/run-repair-attempt'
 import { run_cut, type RunCut } from './run-cut'
 import { run_cut_report } from './run-cut-report'
 import { run_cut_review } from './run-cut-review'
@@ -110,6 +111,19 @@ async function verify_and_adopt(
 	return await adopt(target, cut_record)
 }
 
+async function resume_carried(
+	target: string,
+	cut: RunCut,
+	issue: string,
+	is_expired: boolean,
+): Promise<number> {
+	if (await run_repair_attempt.prepare(issue, target)) {
+		return report(FRESH_VERDICT, SUCCESS_EXIT_CODE)
+	}
+
+	return is_expired ? report_stale(cut) : await verify_and_adopt(target, cut, issue)
+}
+
 async function resume(target: string, issue: string): Promise<number> {
 	const read = run_cut.read_cut(target)
 
@@ -117,9 +131,7 @@ async function resume(target: string, issue: string): Promise<number> {
 
 	if (read.kind === 'unreadable') return report_unreadable()
 
-	if (read.kind === 'expired') return report_stale(read.cut)
-
-	return await verify_and_adopt(target, read.cut, issue)
+	return await resume_carried(target, read.cut, issue, read.kind === 'expired')
 }
 
 const run_cut_resume = {

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

@@ -450,7 +450,7 @@ function busy_message(cut: RunCut): string {
 // A successor already resumed this cut, so a process that reaches `--resume` after its own hand-off is
 // told to stop quietly rather than to investigate a tree that is not wrong.
 function handed_off_message(cut: RunCut): string {
-	return `This cut was already handed off to a successor — ${describe_cut(cut)}. Nothing was resumed here; the run is being carried on by the process that adopted it, so this one has nothing to do.`
+	return `This cut was already adopted — ${describe_cut(cut)}. Nothing was resumed here; the record alone does not establish whether its owner is still running. After a trusted repair request on an open PR and confirmed owner exit, use \`pnpm josh run:add ${cut.issue} --retry\` in a live backlogrun, or \`pnpm josh run:entry ${cut.issue}\` in its lane. Active or unreadable owners remain protected.`
 }
 
 // The record does not match the tree the fresh process is in — wrong branch, a clean tree, an expired

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/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 }