@joshuafolkken/kit 1.1455.0 → 1.1514.0

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

@@ -1,3 +1,5 @@
+import { issue_cite } from '#scripts/issue/issue-cite'
+import { session_cite } from '#scripts/issue/session-cite'
 import { run_cut, type CutState, type RunCut } from './run-cut'
 import { run_cut_handoff } from './run-cut-handoff'
 
@@ -136,6 +138,30 @@ function report_reviewer(): number {
 	return report(NOT_A_LANE_VERDICT, SUCCESS_EXIT_CODE)
 }
 
+// The cut outside a lane is taken, and nothing is relaunched: the session that took it is the one a
+// person is watching, so the run is handed on the way `fullrun`'s entry `over` stop hands it on.
+function report_held_cut(issue: string): number {
+	console.error(
+		`The cut is recorded for ${session_cite.issue(issue)} outside a lane, so nothing was relaunched. Keep the hold, send a \`confirmation\` Telegram whose body names the resume command \`fullrun ${issue_cite.plain(issue)}\`, and end the turn; the fresh session's \`pnpm josh run:cut --resume ${issue}\` answers \`resume-impl\` with the handoff.`,
+	)
+
+	return report(CUT_VERDICT, SUCCESS_EXIT_CODE)
+}
+
+// **A cut that relaunched its successor says so on this session's own transcript** (joshuafolkken/kit#3936).
+// The successor's `run:cut --resume` can clear the record before this session's turn ends, so the
+// `Stop` hook cannot tell a cut stop by the record alone; it reads this line off the turn instead, a
+// fact no other process can remove. The held cut never prints it — a person resumes that one. **A bare
+// token line**, so it is read off the `run:cut` call's own result (`cost-run-cut.ts`), and a turn that
+// merely quotes it is not read as a relaunch.
+const RELAUNCHED_CUT_MARKER = 'cut-relaunched'
+
+function report_relaunched_cut(): number {
+	console.error(RELAUNCHED_CUT_MARKER)
+
+	return report(CUT_VERDICT, SUCCESS_EXIT_CODE)
+}
+
 // **An implementation cut is never resumed by a session over the threshold**.
 // The cut outside a lane leaves the session that took it open, so a person retyping `fullrun #N` there
 // would be answered `resume-impl`, keep implementing over the threshold, and be cut again on the next
@@ -162,6 +188,7 @@ const run_cut_report = {
 	INCOMPLETE_VERDICT,
 	NOT_A_LANE_VERDICT,
 	OVER_VERDICT,
+	RELAUNCHED_CUT_MARKER,
 	RESUME_IMPL_VERDICT,
 	RESUME_VERDICT,
 	STALE_VERDICT,
@@ -176,8 +203,10 @@ const run_cut_report = {
 	report_busy,
 	report_fault,
 	report_handed_off,
+	report_held_cut,
 	report_incomplete,
 	report_over,
+	report_relaunched_cut,
 	report_reviewer,
 	report_stale,
 	report_under_threshold,

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

@@ -106,6 +106,8 @@ interface CutState {
 	is_held: boolean
 	// The issue a `fullrun` hold names, absent when the tree is not held by one.
 	held_issue?: string | undefined
+	// When the hold standing over the tree was taken — what keys a declined cut to the run it answered.
+	hold_taken_at?: string | undefined
 }
 
 // The fields a cut is written from, bundled so `begin_cut` stays within the parameter limit. `phase`
@@ -402,7 +404,13 @@ async function current_state(): Promise<CutState> {
 	const is_dirty = await run_hold.is_tree_dirty()
 	const hold = hold_of(await worktree_directory())
 
-	return { branch, is_dirty, is_held: hold !== undefined, held_issue: fullrun_issue(hold) }
+	return {
+		branch,
+		is_dirty,
+		is_held: hold !== undefined,
+		held_issue: fullrun_issue(hold),
+		hold_taken_at: hold?.taken_at,
+	}
 }
 
 function describe_cut(cut: RunCut): string {
@@ -466,6 +474,7 @@ const run_cut = {
 	handed_off_message,
 	has_required_handoff,
 	held_issue_sync,
+	hold_of,
 	incomplete_message,
 	invocation_for,
 	is_expired,

package/scripts/run/detached-launch.ts

@@ -4,6 +4,7 @@ import { agent_launch_environment } from '#scripts/agent/agent-launch-environmen
 import { agent_role_profile, type AgentProfile } from '#scripts/agent/agent-role-profile'
 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'
 
 // Starting a process that outlives this one, and keeping what it writes.
 //
@@ -34,13 +35,18 @@ const UNSAFE_NOTE =
 //
 // A NUL byte is what `execve` treats as the end of a string, so a value carrying one executes as a
 // prefix of itself; the other control characters have no business in a command line and their presence
-// means the value did not come from where it was supposed to.
+// means the value did not come from where it was supposed to. **An agent's prompt is the one element a
+// line break belongs in** — a ship-stop prompt carries the failed output's lines — so a vector marked
+// `ends_with_prompt` lets it into its last element alone (joshuafolkken/kit#3964).
 //
 // The shared value validation lives with the role policy so environment overrides and argv elements
 // cannot disagree about which control characters or lengths are safe.
 interface LaunchArgv {
 	command: string
 	args: ReadonlyArray<string>
+	// Set by an agent argv builder, whose prompt is the last element: that one element may carry line
+	// breaks (`is_safe_prompt`), and every other element is checked as before.
+	ends_with_prompt?: boolean
 }
 
 type LaunchResult = { kind: 'launched'; pid: number } | { kind: 'failed'; note: string }
@@ -65,12 +71,23 @@ interface LaunchRequest {
 	profile?: AgentProfile | undefined
 }
 
-const { is_safe_value } = agent_role_profile
+const { is_safe_prompt, is_safe_value } = agent_role_profile
+const LAST = -1
+
+// An agent vector's prompt, the last element, may break lines; every other element is a value.
+function is_safe_element(argv: LaunchArgv, value: string, index: number): boolean {
+	const is_prompt = argv.ends_with_prompt === true && index === argv.args.length + LAST
+
+	return is_prompt ? is_safe_prompt(value) : is_safe_value(value)
+}
 
 // The single gate every argument vector passes before it reaches the operating system, whoever
 // composed it.
 function is_safe_argv(argv: LaunchArgv): boolean {
-	return is_safe_value(argv.command) && argv.args.every((value) => is_safe_value(value))
+	return (
+		is_safe_value(argv.command) &&
+		argv.args.every((value, index) => is_safe_element(argv, value, index))
+	)
 }
 
 function note_of(error: unknown): string {
@@ -251,6 +268,7 @@ async function attached_spawn(
 		child.once('exit', (exit_code) => {
 			resolve({ kind: 'completed', pid: child.pid ?? 0, exit_code })
 		})
+		launch_priority.lower(child.pid)
 		notify_spawn(child.pid, on_spawn, on_error)
 	})
 }
@@ -287,6 +305,7 @@ function spawned(
 		on_error(note_of(error))
 	})
 	child.unref()
+	launch_priority.lower(child.pid)
 
 	return child.pid === undefined ? { kind: 'failed', note: NO_PID_NOTE } : launched(child.pid)
 }
@@ -341,5 +360,5 @@ const detached_launch = {
 	note_of,
 }
 
-export type { LaunchArgv, LaunchRequest, LaunchResult }
+export type { AttachedLaunchResult, LaunchArgv, LaunchRequest, LaunchResult }
 export { detached_launch }

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

@@ -22,6 +22,7 @@ import {
 } from '#scripts/run/run-stage'
 import { run_stage_read, type StageRead } from '#scripts/run/run-stage-read'
 import { run_step } from '#scripts/run/run-step'
+import { run_step_section } from '#scripts/run/run-step-section'
 import { run_entry, type EntryParts } from './run-entry'
 import { run_entry_stop } from './run-entry-stop'
 
@@ -259,7 +260,13 @@ async function proceed(issue_number: string, hold: string, cost: string): Promis
 	// update is measured against (`issue-watch.ts`).
 	await issue_watch.record_baseline_here(issue_number)
 
-	return emit({ issue_number, hold, cost, verdict: reads.verdict, report: reads.report })
+	const code = emit({ issue_number, hold, cost, verdict: reads.verdict, report: reads.report })
+
+	// The entry's own read — the split assessment every run answers before its work — printed here so
+	// the reader does not spend a turn fetching it.
+	if (code !== SUCCESS_EXIT_CODE) return code
+
+	return run_step_section.print_section(run_step_section.ENTRY)
 }
 
 async function claim_run(

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

@@ -29,6 +29,7 @@ const KIND_LABELS: Readonly<Record<EventKind, KindLabel>> = {
 	cut: { ja: 'セッション交代', en: 'session cut' },
 	resume: { ja: '実装を再開', en: 'implementation resumed' },
 	restart: { ja: '止めて出し直し', en: 'restarted' },
+	withdraw: { ja: '取り下げ', en: 'withdrawn' },
 	drain: { ja: 'バックログが空', en: 'backlog drained' },
 	stop: { ja: '停止', en: 'stopped' },
 	'pr-opened': { ja: 'PR 作成', en: 'PR opened' },

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

@@ -94,6 +94,7 @@ const KIND = run_event_stream.EVENT_KIND
 const BATCH_RECORD_KINDS: ReadonlySet<string> = new Set([
 	KIND.CHILD_LAUNCH,
 	KIND.RESTART,
+	KIND.WITHDRAW,
 	KIND.PARK,
 	KIND.SPLIT,
 	KIND.RETROSPECTIVE,
@@ -167,12 +168,14 @@ function last_issue_event(
 }
 
 // A child's launch and the endings `run:merge` settles it with — the ones `run:board` stops drawing it
-// running on. A park or a split already ran `run:merge`, so a child closed after one owes nothing.
+// running on. A park or a split already ran `run:merge`, so a child closed after one owes nothing; a
+// withdrawal settles the child itself, its issue closed by the person who withdrew it.
 const LAUNCH_OR_SETTLE_KINDS: ReadonlySet<string> = new Set([
 	KIND.CHILD_LAUNCH,
 	KIND.MERGE,
 	KIND.PARK,
 	KIND.SPLIT,
+	KIND.WITHDRAW,
 ])
 
 // Whether this invocation's newest launch of the issue has not yet been settled.
@@ -186,9 +189,24 @@ function is_merge_owed(events: ReadonlyArray<RunEvent>, scope: EventScope, issue
 	return newest?.kind === KIND.CHILD_LAUNCH
 }
 
+function is_launch_or_withdrawal(event: RunEvent, issue: string): boolean {
+	const is_kind = event.kind === KIND.CHILD_LAUNCH || event.kind === KIND.WITHDRAW
+
+	return is_kind && names_issue(event, issue)
+}
+
+// Whether a person withdrew the issue's newest launch (`lane:withdraw`): its newest launch or withdrawal
+// is a withdrawal. A launch after it is a fresh attempt, which the old withdrawal does not settle.
+function is_withdrawn(events: ReadonlyArray<RunEvent>, issue: string): boolean {
+	const newest = events.findLast((event) => is_launch_or_withdrawal(event, issue))
+
+	return newest?.kind === KIND.WITHDRAW
+}
+
 const run_event_scope = {
 	UNKNOWN_EVENT_SCOPE,
 	is_merge_owed,
+	is_withdrawn,
 	issue_named,
 	last_issue_event,
 	last_scoped_event,

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

@@ -113,10 +113,9 @@ async function emit_heartbeat(line: string): Promise<void> {
 	await emit(run_event_stream.EVENT_KIND.HEARTBEAT, line)
 }
 
-// The events of the invocation now running, for a reader restoring the run from its stream
-// (`backlog:drive`). Fail-quiet like the writers: no repository or an unreadable stream is an empty
-// invocation.
-async function current_events(): Promise<ReadonlyArray<RunEvent>> {
+// The events of the invocation now running, `undefined` where the invocation's scope could not be told
+// — for a reader that must not take "no events" for "nothing launched" (`backlog-occupied.ts`).
+async function scoped_current_events(): Promise<ReadonlyArray<RunEvent> | undefined> {
 	try {
 		const repository = await run_carry.repository_directory()
 
@@ -126,12 +125,19 @@ async function current_events(): Promise<ReadonlyArray<RunEvent>> {
 		const scope = run_event_scope.scope_of(read)
 		const events = run_event_stream.read_events(run_event_stream.target_of(repository))
 
-		return run_event_scope.scoped_events(events, scope) ?? []
+		return run_event_scope.scoped_events(events, scope)
 	} catch {
-		return []
+		return undefined
 	}
 }
 
+// The events of the invocation now running, for a reader restoring the run from its stream
+// (`backlog:drive`). Fail-quiet like the writers: no repository, an unreadable stream or an
+// undetermined scope is an empty invocation.
+async function current_events(): Promise<ReadonlyArray<RunEvent>> {
+	return (await scoped_current_events()) ?? []
+}
+
 // The invocation's events for a writer deciding whether a marker is already there: unlike
 // `current_events`, an undetermined scope keeps the whole stream, so a run with no carry record skips a
 // marker it already wrote rather than writing it twice.
@@ -167,6 +173,7 @@ const run_event_stream_emit = {
 	emit_once,
 	emit_once_since,
 	invocation_or_all_events,
+	scoped_current_events,
 	stream_target,
 }
 

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

@@ -64,6 +64,10 @@ const EVENT_KIND = {
 	// (`lane:restart`). It follows the fresh dispatch's `CHILD_LAUNCH`, so it is a launch to the parent and
 	// the board, and — like that launch — a batch record a lane child never reads as its own position.
 	RESTART: 'restart',
+	// A person withdrew a lane child — stopped it and closed its issue as not planned (`lane:withdraw`).
+	// It is written before the stop, so `run:merge` settles the child as withdrawn whatever GitHub says
+	// by the time the parent collects it, and counts it as neither a merge, a failure nor an outage.
+	WITHDRAW: 'withdraw',
 	// The backlog emptied while nothing of the run's own was in flight — the drain. It marks the position
 	// at which the end-of-run retrospective is owed, *before* the idle watch opens, so `run:step` fires
 	// the retrospective at the drain rather than after the watch runs its course. It is not itself a

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

@@ -176,14 +176,25 @@ function held_block(hold: RunHold, issue: string): string | undefined {
 	return run_hold.is_reentry(hold, issue) ? undefined : run_hold.held_message(hold)
 }
 
+// An expired record of the claimant's own issue that no stop marked is the earlier run of the same work —
+// a child killed and re-dispatched into its lane — so the claim adopts it with the work it left. A
+// stopped `halfrun` or `prrun` keeps its own adopt path.
+function is_own_unstopped(hold: RunHold, issue: string): boolean {
+	return run_hold.is_reentry(hold, issue) && !run_hold.is_stop_marked(hold)
+}
+
+async function stale_block(hold: RunHold, issue: string): Promise<string | undefined> {
+	if (is_own_unstopped(hold, issue)) return undefined
+
+	return (await run_hold.is_tree_dirty()) ? run_hold.uncommitted_message(hold) : undefined
+}
+
 async function blocking_message(read: HoldRead, issue: string): Promise<string | undefined> {
 	if (read.kind === 'held') return held_block(read.hold, issue)
 
 	if (read.kind === 'unreadable') return run_hold.unreadable_message()
 
-	const is_expired_over_work = read.kind === 'stale' && (await run_hold.is_tree_dirty())
-
-	return is_expired_over_work ? run_hold.uncommitted_message(read.hold) : undefined
+	return read.kind === 'stale' ? await stale_block(read.hold, issue) : undefined
 }
 
 // A record already here is never overwritten by a claim: overwriting is what the guard exists to

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

@@ -0,0 +1,46 @@
+import { stamp_file } from '#scripts/josh/stamp-file'
+import { run_halfrun_resume } from '#scripts/run/run-halfrun-resume'
+import { run_hold, type RunHold, type SessionOwner } from './run-hold'
+
+// What the `Stop` hook asks of a hold beyond "is one in place" (joshuafolkken/kit#3961): whether it is
+// this session's own run's, and whether its pause was already announced.
+//
+// **Another run's hold is not this session's pause.** A `kickoff`, or a question answered while a
+// `backlogrun` parent holds the same tree, stops in a session that holds nothing — announcing that stop
+// as the held run's "confirmation required" reports a decision nobody is waiting on.
+//
+// **Unknown is this session's own.** A record written outside an agent session, or a hook that cannot
+// read its own session, keeps the behavior the hold had before ownership was recorded: a missed notify
+// costs a person a silent pause, a wrong one only a needless Telegram.
+
+function is_same_start(recorded: string | undefined, own: string | undefined): boolean {
+	return recorded === undefined || own === undefined || recorded === own
+}
+
+function is_session_hold(hold: RunHold, owner: SessionOwner = run_hold.session_owner()): boolean {
+	if (hold.owner_pid === undefined || owner.owner_pid === undefined) return true
+
+	return hold.owner_pid === owner.owner_pid && is_same_start(hold.owner_start, owner.owner_start)
+}
+
+// **A pause is announced once, and a person's prompt ends it.** The hook's own send is recorded on the
+// hold, so a later stop of the same pause — a background notice that woke the session — finds it; a send before `pause_start` belongs to an earlier pause. An unknown start
+// announces again: a needless Telegram costs less than a silent wait.
+function is_notified_since(hold: RunHold, pause_start: string | undefined): boolean {
+	if (pause_start === undefined || hold.notified_at === undefined) return false
+
+	return Date.parse(hold.notified_at) >= Date.parse(pause_start)
+}
+
+// Stamps the send on the record in place; a tree no longer held has nothing to stamp. A stale record is
+// stamped too: the hook reads it as the hold (`hold_of`), so a run past the expiry age still finds its send.
+function mark_notified(target: string, now: Date = new Date()): void {
+	const hold = run_halfrun_resume.hold_of(run_hold.read_hold(target, now))
+	if (hold === undefined) return
+
+	stamp_file.write_stamp(target, { ...hold, notified_at: now.toISOString() })
+}
+
+const run_hold_session = { is_notified_since, is_session_hold, mark_notified }
+
+export { run_hold_session }

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

@@ -65,6 +65,10 @@ interface RunHold {
 	// fields, or by a claim made outside an agent session.
 	owner_pid?: number | undefined
 	owner_start?: string | undefined
+	// When the `Stop` hook last sent this run's `confirmation` Telegram — its own send leaves no command
+	// on the transcript, so the record is what keeps one pause from being announced twice
+	// (`run-hold-session.ts`).
+	notified_at?: string | undefined
 }
 
 type HoldRead =
@@ -107,6 +111,7 @@ const run_hold_schema = z.object({
 	prrun_stop_head: z.string().optional(),
 	owner_pid: z.number().optional(),
 	owner_start: z.string().optional(),
+	notified_at: z.string().optional(),
 })
 
 // `undefined` for anything that is not a well-formed record, so the caller decides what a broken one
@@ -129,10 +134,12 @@ function is_expired(hold: RunHold, now: Date): boolean {
 // nothing. Only a recorded session that is provably gone counts — no owner, or a live pid whose start
 // cannot be read, leaves the age as the whole test. **A stop-marked record is exempt**: a `halfrun` or
 // `prrun` stop is held across a person's latency on purpose, long after its session ends.
-function is_owner_gone(hold: RunHold): boolean {
-	const is_stop_mark = hold.is_halfrun_stop === true || hold.prrun_stop_head !== undefined
+function is_stop_marked(hold: RunHold): boolean {
+	return hold.is_halfrun_stop === true || hold.prrun_stop_head !== undefined
+}
 
-	if (is_stop_mark || hold.owner_pid === undefined) return false
+function is_owner_gone(hold: RunHold): boolean {
+	if (is_stop_marked(hold) || hold.owner_pid === undefined) return false
 
 	return process_identity.is_same_process(hold.owner_pid, hold.owner_start) === false
 }
@@ -317,6 +324,7 @@ function unknown_message(): string {
 }
 
 const run_hold = {
+	is_stop_marked,
 	FORCE_RELEASE_COMMAND,
 	HOLD_MAX_AGE_HOURS,
 	HOLD_MAX_AGE_MS,
@@ -339,6 +347,7 @@ const run_hold = {
 	race_message,
 	read_hold,
 	release_hold,
+	session_owner,
 	stale_message,
 	uncommitted_message,
 	unknown_message,
@@ -347,5 +356,5 @@ const run_hold = {
 	write_hold,
 }
 
-export type { HoldRead, RunHold, StopMarkFields }
+export type { HoldRead, RunHold, SessionOwner, StopMarkFields }
 export { run_hold }

package/scripts/run/launch-priority.ts

@@ -0,0 +1,32 @@
+import { setPriority } from 'node:os'
+
+// **A launched session runs below the interactive one, so a saturated machine still answers the
+// user.** Every headless session and everything it starts — gates, tests, builds — used to share the
+// interactive session's priority, and at a load of ~30 the lanes took the terminal's responsiveness
+// with them (#3947). The niceness is set on the child right after `spawn` returns: a process inherits
+// its parent's niceness at fork, and an agent CLI boots for far longer than this takes before it forks
+// anything, so every descendant inherits it. Efficiency-core confinement (`taskpolicy -b`) is not
+// used — it throttles a lane far beyond yielding to the user.
+const LANE_NICENESS = 10
+
+type SetPriority = (pid: number, priority: number) => void
+
+// **A priority that cannot be lowered starts the session as before.** A platform without the call, or
+// a child that already runs at a lower priority than this, is not a reason to fail the launch.
+function lower(pid: number | undefined, set_priority: SetPriority = setPriority): void {
+	if (pid === undefined) return
+
+	try {
+		set_priority(pid, LANE_NICENESS)
+	} catch {
+		// the session keeps the priority it was started with
+	}
+}
+
+const launch_priority = {
+	LANE_NICENESS,
+	lower,
+}
+
+export type { SetPriority }
+export { launch_priority }

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

@@ -1,9 +1,7 @@
 #!/usr/bin/env tsx
 import { fileURLToPath } from 'node:url'
-import { api_outage } from '#scripts/agent/api-outage'
 import { CONTEXT_CUT_THRESHOLD } from '#scripts/cost-runtime/context-cut-threshold'
 import { issue_cite } from '#scripts/issue/issue-cite'
-import { issue_closing_pr } from '#scripts/issue/issue-closing-pr'
 import { issue_number_shape } from '#scripts/issue/issue-number-shape'
 import { issue_state_cli } from '#scripts/issue/issue-state-cli'
 import { lane_handoff } from '#scripts/lane/lane-handoff'
@@ -12,9 +10,9 @@ import { cli_flags } from '#scripts/lib/cli-flags'
 import { run_carry, type CarryOwner, type RunCarry } from '#scripts/run/carry/run-carry'
 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_ending } from '#scripts/run/run-ending'
 import { run_label } from '#scripts/run/run-label'
-import { run_merge, type ChildOutcome, type EndingSignals } from './run-merge'
+import { run_merge, type ChildOutcome } from './run-merge'
+import { run_merge_signals } from './run-merge-signals'
 import { run_merge_steps, type FailedResult, type MergeContext } from './run-merge-steps'
 import { run_merge_token, type MergeToken } from './run-merge-token'
 
@@ -189,40 +187,6 @@ async function offered(ctx: MergeContext): Promise<OfferVerdict> {
 	return { token: await run_merge_steps.ask_next(ctx), code: SUCCESS_EXIT_CODE, is_offer: true }
 }
 
-// Whether the child's exit record shows it could not reach the API — read only when `--output` named
-// the transcript, off otherwise. The path is validated inside
-// `run_ending.read_exit`, which returns `undefined` for an unreadable or missing record, so a missing
-// output is simply "not an outage".
-function read_is_outage(output: string | undefined): boolean {
-	if (output === undefined) return false
-
-	return api_outage.is_outage(run_ending.read_exit(output))
-}
-
-type IssueRead = Awaited<ReturnType<typeof issue_state_cli.read_issue>>
-
-// The timeline is read only for an OPEN, unparked child — the one classification a merged closing pull
-// request changes. A CLOSED child was closed by GitHub, so it must carry no `merged_pr` for
-// `do_merged` to close again.
-async function read_merged_pr(child: string, read: IssueRead): Promise<string | undefined> {
-	if (read.kind !== 'state' || run_merge.classify_child(read.state) !== 'failed') return undefined
-
-	return await issue_closing_pr.read_closing_pr(child)
-}
-
-async function read_signals(ctx: MergeContext, read: IssueRead): Promise<EndingSignals> {
-	const [is_cut, merged_pr] = await Promise.all([
-		run_merge_steps.has_resumable_cut(ctx.child),
-		read_merged_pr(ctx.child, read),
-	])
-
-	return { is_outage: read_is_outage(ctx.output), is_cut, merged_pr }
-}
-
-function outcome_of(read: IssueRead, signals: EndingSignals): ChildOutcome {
-	return read.kind === 'state' ? run_merge.classify_child(read.state, signals) : 'unresolved'
-}
-
 // A refused count means this session is not the carry record's owner, so the whole operation is
 // rejected — the lane is not closed and no next child is offered.
 function report_count_refused(carry: RunCarry | undefined): MergeVerdict {
@@ -374,6 +338,13 @@ async function on_skipped(ctx: MergeContext): Promise<MergeVerdict> {
 	return await offered(ctx)
 }
 
+// A child a person withdrew with `lane:withdraw`: the withdrawal already stopped it, closed its issue
+// and lane and put itself on the stream, so nothing is counted or written here and its seat goes to the
+// next child.
+async function on_withdrawn(ctx: MergeContext): Promise<MergeVerdict> {
+	return await offered(ctx)
+}
+
 // The child's own ending: it stopped before its commit for a person to look at, so nothing is counted
 // and no next child is offered.
 async function on_human_review(): Promise<MergeVerdict> {
@@ -399,6 +370,7 @@ const HANDLERS: Readonly<Record<ChildOutcome, (ctx: MergeContext) => Promise<Mer
 	split: on_skipped,
 	unresolved: on_unresolved,
 	shipping: on_shipping,
+	withdrawn: on_withdrawn,
 }
 
 // The whole merge event for one returned child, in-process: read its state, classify it, and run the
@@ -409,10 +381,12 @@ async function merge_child(ctx: MergeContext): Promise<MergeResult> {
 	}
 
 	const read = await issue_state_cli.read_issue(ctx.child, ctx.repo)
-	const signals = await read_signals(ctx, read)
-	const outcome = outcome_of(read, signals)
+	const signals = await run_merge_signals.read_signals(ctx, read)
+	const outcome = run_merge_signals.outcome_of(read, signals)
+
+	const { merged_pr, is_unanswered } = signals
 
-	return { outcome, ...(await HANDLERS[outcome]({ ...ctx, merged_pr: signals.merged_pr })) }
+	return { outcome, ...(await HANDLERS[outcome]({ ...ctx, merged_pr, is_unanswered })) }
 }
 
 async function run(argv: ReadonlyArray<string>): Promise<number> {
@@ -438,7 +412,7 @@ async function main(argv: ReadonlyArray<string>): Promise<void> {
 const run_merge_cli = {
 	merge_child,
 	parse,
-	read_merged_pr,
+	read_merged_pr: run_merge_signals.read_merged_pr,
 	record_merged,
 	run,
 }

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

@@ -1,6 +1,9 @@
 import { git_common_directory } from '#scripts/git/git-common-directory'
+import { lane_registry } from '#scripts/lane/lane-registry'
+import { lane_relaunch } from '#scripts/lane/lane-relaunch'
 import { run_event_scope } from '#scripts/run/event/run-event-scope'
 import { run_event_stream, type RunEvent } from '#scripts/run/event/run-event-stream'
+import { run_ending } from '#scripts/run/run-ending'
 import { run_ship_detach } from '#scripts/run/ship/run-ship-detach'
 
 // Why `run:merge` parks a child whose detached ship has already ended (joshuafolkken/kit#3808).
@@ -56,6 +59,61 @@ function cause(child: string, directory: string = process.cwd()): string | undef
 	return cause_of(run_ship_detach.read_result(repository, child), events, child)
 }
 
-const run_merge_ship = { cause, cause_of }
+// Whether the ended ship was never answered: a session relaunched to fix a stop writes to the
+// transcript after it, so a transcript last written before the newest stop means no fix-up ran — its
+// broker or relaunch could not start. A ship with no stop at all ended abnormally only when its supervisor
+// died before reaching a stage.
+function is_stop_unanswered(
+	ending: ShipEnding,
+	attempt: Events,
+	written_at: number | undefined,
+): boolean {
+	const stop = attempt.findLast((event) => event.kind === run_event_stream.EVENT_KIND.SHIP_STOP)
+
+	if (stop === undefined) return ending?.result === 'abnormal'
+
+	return written_at !== undefined && written_at < Date.parse(stop.at)
+}
+
+// Whether the child's ship ended through an interruption rather than its work, so the child is
+// re-dispatched instead of parked.
+function interrupted_of(
+	ending: ShipEnding,
+	events: Events,
+	child: string,
+	written_at: number | undefined,
+): boolean {
+	if (ending === undefined || !ENDED_RESULTS.has(ending.result)) return false
+
+	const attempt = since_ship_launch(events, child)
+
+	return attempt !== undefined && is_stop_unanswered(ending, attempt, written_at)
+}
+
+function is_interrupted(
+	child: string,
+	written_at: number | undefined,
+	directory: string = process.cwd(),
+): boolean {
+	const repository = git_common_directory.repository(directory)
+	if (repository === undefined) return false
+
+	const events = run_event_stream.read_events(run_event_stream.target_of(repository))
+
+	return interrupted_of(run_ship_detach.read_result(repository, child), events, child, written_at)
+}
+
+// Whether the child's ship stopped and the relaunch meant to fix it never ran, read against its
+// transcript at `output`. An OpenAI lane is never relaunched — its parent books every stop as an ended
+// child — and nothing relaunches a child whose lane is gone, so only an open non-OpenAI lane reads as one.
+async function is_unanswered(child: string, output: string | undefined): Promise<boolean> {
+	if (output === undefined || !is_interrupted(child, run_ending.written_at(output))) return false
+
+	const lane = await lane_registry.find_open_lane(child)
+
+	return lane !== undefined && !lane_relaunch.is_openai_lane(lane)
+}
+
+const run_merge_ship = { cause, cause_of, interrupted_of, is_unanswered }
 
 export { run_merge_ship }