@joshuafolkken/kit 1.3044.0 → 1.3099.0

package/scripts/run/board/run-board-retry-wait.ts

@@ -0,0 +1,35 @@
+import { run_board_human_merge } from './run-board-human-merge'
+import type { BoardPlan } from './run-board-layout'
+import type { ItemStatus } from './run-board-status'
+
+type Statuses = ReadonlyMap<number, ItemStatus>
+
+// A `run:add --retry` settles an issue as waiting before it ever launched (`run-board-status.ts`). The
+// plan, classified as `backlog:next` classifies it, is what says whether it starts next or waits: one the
+// plan leaves unreached waits on something, so its status is dropped and it draws as the plan row it
+// is — in the waiting section with its reason — rather than as an empty ⏳ lane (joshuafolkken/kit#7488).
+function is_retry_wait(status: ItemStatus): boolean {
+	return status.state === 'waiting' && status.started_ms === undefined
+}
+
+function released(unreached: ReadonlyArray<{ number: number }>, statuses: Statuses): Statuses {
+	const waits = new Set(unreached.map((child) => child.number))
+
+	return new Map(
+		[...statuses].filter(([issue, status]) => !(waits.has(issue) && is_retry_wait(status))),
+	)
+}
+
+// The human-merge overlay, then the retry waits the plan leaves unreached released to their plan rows.
+function overlay_of(
+	plan: BoardPlan,
+	statuses: Statuses,
+): ReturnType<typeof run_board_human_merge.overlay_of> {
+	const current = run_board_human_merge.overlay_of(plan, statuses)
+
+	return { ...current, statuses: released(current.plan.waves.unreached, current.statuses) }
+}
+
+const run_board_retry_wait = { overlay_of }
+
+export { run_board_retry_wait }

package/scripts/run/board/run-board-root-layout.ts

@@ -0,0 +1,69 @@
+import { run_board_layout, type BoardLayout, type BoardRow, type RowRead } from './run-board-layout'
+import type { LocalRead } from './run-board-read'
+import type { EndedRoot } from './run-board-single'
+import { run_board_status, type ItemStatus } from './run-board-status'
+
+// The root checkout's single runs beside a carried run. A running one is drawn under 🏠 above the lanes
+// (joshuafolkken/kit#7524), its row read off its own span's events and kept out of `active`, so the
+// header counts no lane and no 🔄 for it. One a merge ended inside the run leaves 🏠 and is listed in
+// `✅ done` as a lane's finished row is, in its place by its end (joshuafolkken/kit#7525).
+
+type RootRead = Pick<LocalRead, 'root' | 'ended_roots' | 'lane_states'>
+
+function live_of(local: RootRead, read: RowRead): Pick<BoardLayout, 'root'> {
+	const { root } = local
+
+	if (root === undefined) return {}
+	const status = run_board_status.statuses_of(root.events, local.lane_states).get(root.issue)
+
+	if (status === undefined) return {}
+	const statuses = new Map([[root.issue, status]])
+	const [row] = run_board_layout.local_layout_of(statuses, undefined, read).active
+
+	return row === undefined ? {} : { root: { name: root.command, row } }
+}
+
+// A merge released the run's hold, so it ended merged.
+function ended_status(run: EndedRoot): ItemStatus {
+	return { state: 'merged', started_ms: run.started_ms, ended_ms: run.ended_ms }
+}
+
+// The ended runs' rows among the run's own, any row of the same issue replaced.
+function active_of(
+	active: ReadonlyArray<BoardRow>,
+	ended: ReadonlyArray<EndedRoot>,
+	read: RowRead,
+): ReadonlyArray<BoardRow> {
+	if (ended.length === 0) return active
+
+	const statuses = new Map(ended.map((run) => [run.issue, ended_status(run)]))
+	const rows = run_board_layout.local_layout_of(statuses, undefined, read).active
+	const kept = active.filter((row) => !statuses.has(row.number))
+
+	return [...kept, ...rows].toSorted(run_board_layout.active_order)
+}
+
+function layout_of(layout: BoardLayout, local: RootRead, read: RowRead): BoardLayout {
+	return {
+		...layout,
+		active: active_of(layout.active, local.ended_roots ?? [], read),
+		...live_of(local, read),
+	}
+}
+
+// The baseline the header counts arrivals against: the rows the ended runs add to the run's are no
+// arrival to its plan.
+function baseline_of(
+	baseline_total: number | undefined,
+	run_layout: BoardLayout,
+	layout: BoardLayout,
+): number | undefined {
+	if (baseline_total === undefined) return undefined
+	const { rows_of } = run_board_layout
+
+	return baseline_total + rows_of(layout).length - rows_of(run_layout).length
+}
+
+const run_board_root_layout = { baseline_of, layout_of }
+
+export { run_board_root_layout }

package/scripts/run/board/run-board-seat.ts

@@ -16,6 +16,8 @@ const { STAGE } = run_event_setup
 const { WAIT_ICONS } = run_board_labels
 const NO_CANDIDATE = 'no issue ready to start'
 const HELD = 'held'
+// A runnable row waits only for the driver a session restarts, not for a person (joshuafolkken/kit#7510).
+const RESTART_PENDING = 'driver restart pending'
 // The row waits that a free seat itself, or the driver's hold, answers — the row could run in the seat.
 const ROOM_ICONS: ReadonlySet<string> = new Set([
 	WAIT_ICONS.lane,
@@ -77,6 +79,11 @@ function with_hold(lead: string, hold: string | undefined): string {
 	return hold === undefined ? lead : `${lead} — ${backlog_hold_text.text_of(hold)}`
 }
 
+// What keeps a runnable row out: the driver's absence a session restart ends, or a hold.
+function held_lead(hold: string): string {
+	return backlog_hold_text.is_driver_restart(hold) ? RESTART_PENDING : HELD
+}
+
 // What a seat no refusal explains says: no runnable row, or the hold that keeps a runnable one out —
 // the hold as a sentence, never its ledger code (`backlog-hold-text.ts`).
 function idle_reason(room: SeatRoom): string | undefined {
@@ -84,7 +91,7 @@ function idle_reason(room: SeatRoom): string | undefined {
 
 	if (!has_candidate(room.layout)) return with_hold(NO_CANDIDATE, hold)
 
-	return hold === undefined ? undefined : with_hold(HELD, hold)
+	return hold === undefined ? undefined : with_hold(held_lead(hold), hold)
 }
 
 // No seat line where the seats are unread — before the plan is read, or once the run stopped.
@@ -101,7 +108,7 @@ function reasons_of(room: SeatRoom): Array<string> {
 	return reasons.filter((reason) => reason !== undefined)
 }
 
-const run_board_seat = { NO_CANDIDATE, read_of, reasons_of }
+const run_board_seat = { NO_CANDIDATE, RESTART_PENDING, read_of, reasons_of }
 
 export { run_board_seat }
 export type { SeatRead, SeatRoom }

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

@@ -50,11 +50,13 @@ function has_launched(events: ReadonlyArray<RunEvent>): boolean {
 	return events.some((event) => event.kind === KIND.CHILD_LAUNCH)
 }
 
-// The start is over at the first launch, or at a drain that came before one: a run whose backlog
-// emptied with nothing launched is watching, and the hand-off each wake of that watch writes is not a
-// run getting ready.
+// An idle decision ends preparation before the drain's maintenance finishes.
+function is_idle_decision(event: RunEvent): boolean {
+	return event.kind === KIND.DRAIN || (is_setup(event) && event.text === STAGE.WATCHING)
+}
+
 function has_started(events: ReadonlyArray<RunEvent>): boolean {
-	return has_launched(events) || events.some((event) => event.kind === KIND.DRAIN)
+	return has_launched(events) || events.some((event) => is_idle_decision(event))
 }
 
 // A lane is opening while the stage naming its issue is newer than the run's newest position: the

package/scripts/run/board/run-board-single.ts

@@ -6,7 +6,8 @@ import { stamped_memo } from '#scripts/lib/stamped-memo'
 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_hold, type HoldRead } from '#scripts/run/hold/run-hold'
-import type { BoardSpan } from './run-board-span'
+import { run_hold_ended, type EndedHold } from '#scripts/run/hold/run-hold-ended'
+import { run_board_span, type BoardSpan } from './run-board-span'
 
 // A single `fullrun #N` or `halfrun #N` has no carry record; the only record that says it is running
 // here is this checkout's hold (`run-hold.ts`), so the board draws it from there — no store of its own
@@ -24,6 +25,15 @@ interface SingleRun {
 	issue: number
 }
 
+interface RootRun extends SingleRun {
+	events: ReadonlyArray<RunEvent>
+}
+
+interface EndedRoot extends SingleRun {
+	started_ms: number
+	ended_ms: number
+}
+
 // The checkout's own git directory, resolved once per working directory: resolving it runs a `git`
 // subprocess the redraw would wait on, as `run-board-read.ts`'s main work tree does.
 const directories = stamped_memo.create<Promise<string | undefined>>()
@@ -68,8 +78,8 @@ async function directory_here(): Promise<string | undefined> {
 }
 
 // The single run held in this checkout; `undefined` where none is. A lane's hold is its `backlogrun`
-// child's, drawn as that run's row, so only outside a lane does a hold outrank the carry record — a
-// `fullrun` in another checkout beside a running `backlogrun`.
+// child's, drawn as that run's row, so only outside a lane is a hold read beside the carry record — a
+// `fullrun` in the root checkout beside a running `backlogrun`.
 async function span_here(is_carried: boolean): Promise<BoardSpan | undefined> {
 	if (is_carried && lane_paths.lane_issue_of(process.cwd()) !== undefined) return undefined
 
@@ -80,6 +90,41 @@ async function span_here(is_carried: boolean): Promise<BoardSpan | undefined> {
 	return span_of(run_hold.read_hold(run_hold.hold_path(directory)))
 }
 
+// A run the root checkout's merge released, as `run-hold-ended.ts` kept it; `undefined` where its
+// record names no issue or no moment.
+function ended_of(ended: EndedHold): EndedRoot | undefined {
+	if (!issue_number_shape.is_issue_number(ended.issue)) return undefined
+
+	const started_ms = run_event_scope.moment_of(ended.taken_at)
+	const ended_ms = run_event_scope.moment_of(ended.ended_at)
+
+	if (started_ms === undefined || ended_ms === undefined) return undefined
+
+	const command = ended.is_fullrun === true ? FULLRUN : HALFRUN
+
+	return { command, issue: Number(ended.issue), started_ms, ended_ms }
+}
+
+function is_inside(run: EndedRoot, span: BoardSpan): boolean {
+	return run.ended_ms >= span.started_ms && run.ended_ms <= (span.ended_ms ?? Infinity)
+}
+
+// The released runs that ended inside `span`, which the board lists in `✅ done` (joshuafolkken/kit#7525).
+function ended_in(records: ReadonlyArray<EndedHold>, span: BoardSpan): Array<EndedRoot> {
+	return records
+		.map((record) => ended_of(record))
+		.filter((run): run is EndedRoot => run !== undefined && is_inside(run, span))
+}
+
+// This checkout's released single runs inside `span`; none in a lane, where no merge records one.
+async function ended_here(span: BoardSpan): Promise<Array<EndedRoot>> {
+	const directory = await directory_here()
+
+	if (directory === undefined) return []
+
+	return ended_in(run_hold_ended.read_ended(run_hold_ended.ended_path(directory)), span)
+}
+
 // The command and issue of a single run's invocation; `undefined` for any other run's.
 function single_of(invocation: string): SingleRun | undefined {
 	const { command, issue } = SINGLE_INVOCATION.exec(invocation)?.groups ?? {}
@@ -118,6 +163,26 @@ function name_of(invocation: string): string | undefined {
 	return single_of(invocation)?.command
 }
 
-const run_board_single = { events_of, name_of, scope_of, span_here, span_of }
+// The root checkout's single run beside a carried run, with its own span's events its row's phase is
+// read from (joshuafolkken/kit#7524).
+function root_of(span: BoardSpan, events: ReadonlyArray<RunEvent>): RootRun | undefined {
+	const single = single_of(span.invocation)
+
+	if (single === undefined) return undefined
+
+	return { ...single, events: events_of(span, run_board_span.events_of(events, span)) }
+}
+
+const run_board_single = {
+	ended_here,
+	ended_in,
+	events_of,
+	name_of,
+	root_of,
+	scope_of,
+	span_here,
+	span_of,
+}
 
 export { run_board_single }
+export type { EndedRoot, RootRun }

package/scripts/run/board/run-board-span-read.ts

@@ -0,0 +1,85 @@
+import { backlogrun_launch } from '#scripts/backlog/backlogrun-launch'
+import type { TableRead } from '#scripts/lane/lane-process-table'
+import { run_carry, type CarryRead, type RunCarry } from '#scripts/run/carry/run-carry'
+import { run_carry_ended } from '#scripts/run/carry/run-carry-ended'
+import { run_stranded_detect } from '#scripts/run/run-stranded-detect'
+import type { ProcessRoots } from './run-board-process-groups'
+import { run_board_roots } from './run-board-roots'
+import { run_board_single } from './run-board-single'
+import { run_board_span, type BoardSpan } from './run-board-span'
+
+// What `run:board` reads of the run drawn here: its span, the session it resumes from and the
+// processes its record names.
+interface SpanHere {
+	span: BoardSpan | undefined
+	resume: string | undefined
+	// The parent session's transcript, where the run's record names one.
+	transcript: string | undefined
+	roots: ProcessRoots
+	carry: RunCarry | undefined
+	is_stranded: boolean
+	is_session_active: boolean
+	// The root checkout's single run beside the carried one.
+	root?: BoardSpan | undefined
+}
+
+const NO_SPAN: SpanHere = {
+	span: undefined,
+	resume: undefined,
+	transcript: undefined,
+	roots: {},
+	carry: undefined,
+	is_stranded: false,
+	is_session_active: false,
+}
+
+// Every process the run's record names is asked of `table`, the redraw's own `ps` snapshot — only once
+// a run is found, so a repository with no run waits on no `ps`.
+async function recorded_span_here(
+	repository: string,
+	table: TableRead | undefined,
+	read: CarryRead,
+): Promise<SpanHere> {
+	const ended = run_carry_ended.read_ended(run_carry_ended.ended_path(repository))
+	const launch = backlogrun_launch.pending_launch(repository)
+	const span = run_board_span.span_of(read, ended, launch)
+
+	if (span === undefined) return NO_SPAN
+
+	const same_process = await run_board_roots.same_in(table)
+	const stranded_ports = run_stranded_detect.ports_with(same_process)
+
+	return {
+		span,
+		resume: run_board_span.resume_of(read, ended, launch),
+		transcript: read.kind === 'carried' ? read.carry.owner_transcript : undefined,
+		roots: run_board_roots.roots_of(repository, read, same_process),
+		is_session_active: run_board_roots.session_is_active(repository, read, same_process),
+		carry: read.kind === 'carried' ? read.carry : undefined,
+		is_stranded: run_stranded_detect.is_stranded_at(repository, stranded_ports),
+	}
+}
+
+// A single run this checkout holds is the one drawn (`run-board-single.ts`) before the ended run; it
+// names no process. Beside a carried run it is the root checkout's, drawn as a row above the carried
+// run's lanes, which stays the frame (joshuafolkken/kit#7524). No repository, no run.
+async function span_here(
+	repository: string | undefined,
+	table: TableRead | undefined,
+): Promise<SpanHere> {
+	if (repository === undefined) return NO_SPAN
+	const read = run_carry.read_carry(run_carry.carry_path(repository))
+	const is_carried = read.kind !== 'none'
+	const single = await run_board_single.span_here(is_carried)
+
+	if (single === undefined) return await recorded_span_here(repository, table, read)
+	const recorded = is_carried ? await recorded_span_here(repository, table, read) : NO_SPAN
+
+	// A carried record that reads no span leaves the single run the one drawn.
+	return recorded.span === undefined ? { ...NO_SPAN, span: single } : { ...recorded, root: single }
+}
+
+const run_board_span_read = { span_here }
+
+export { run_board_span_read }
+export type { SpanHere }

package/scripts/run/board/run-board-tick.ts

@@ -13,6 +13,7 @@ import type { LocalRead } from './run-board-read'
 import { run_board_reason, type ReasonRead } from './run-board-reason'
 import { run_board_released } from './run-board-released'
 import { run_board_render } from './run-board-render'
+import { run_board_root_layout } from './run-board-root-layout'
 import { run_board_seat, type SeatRead } from './run-board-seat'
 import { run_board_setup } from './run-board-setup'
 import type { Known } from './run-board-snapshot'
@@ -321,13 +322,20 @@ function draw(ports: BoardPorts, lines: ReadonlyArray<string>): void {
 }
 
 // The first total the plan gives is the baseline every later arrival is counted against; the run's own
-// children before it are no total.
+// children before it are no total. The root checkout's single runs are laid over the run's.
 function draw_run(state: BoardState, local: LocalRead, redraw: Redraw): BoardState {
-	const layout = layout_for(state, local, redraw.now_ms)
+	const read = closed_under(known_of(state), state.closed)
+	const run_layout = layout_for(state, local, redraw.now_ms)
+	const layout = run_board_root_layout.layout_of(run_layout, local, read)
 	const first_total =
-		state.plan === undefined ? undefined : run_board_header.counts_of(layout).total
+		state.plan === undefined ? undefined : run_board_header.counts_of(run_layout).total
 	const settled = { ...state, baseline_total: state.baseline_total ?? first_total }
-	const { lines, spots } = frame_of(settled, local, layout, redraw)
+	const baseline_total = run_board_root_layout.baseline_of(
+		settled.baseline_total,
+		run_layout,
+		layout,
+	)
+	const { lines, spots } = frame_of({ ...settled, baseline_total }, local, layout, redraw)
 
 	draw(redraw.ports, lines)
 

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

@@ -1,5 +1,5 @@
 import { stamp_file } from '#scripts/josh/stamp-file'
-import { run_carry, type CarryOwner } from './run-carry'
+import { run_carry, type CarryOwner, type RunCarry } from './run-carry'
 import { run_carry_conversation } from './run-carry-conversation'
 
 // **A resumed conversation has to take its record back before it falls quiet**.
@@ -12,12 +12,22 @@ import { run_carry_conversation } from './run-carry-conversation'
 
 // Writes the record back under the caller's process when the caller is the record's own conversation
 // in a new one; answers whether it did.
+function reclaimed_owner(carry: RunCarry, owner: CarryOwner): RunCarry {
+	if (owner.session === undefined || owner.session !== carry.owner_session) {
+		return run_carry_conversation.reclaim_owner(carry, owner)
+	}
+
+	if (owner.pid === undefined || carry.is_handed_off === true) return carry
+
+	return { ...carry, owner_pid: owner.pid, owner_start: owner.start }
+}
+
 function reclaim_at(target: string, owner: CarryOwner): boolean {
 	const read = run_carry.read_carry(target)
 
 	if (read.kind !== 'carried') return false
 
-	const reclaimed = run_carry_conversation.reclaim_owner(read.carry, owner)
+	const reclaimed = reclaimed_owner(read.carry, owner)
 
 	if (reclaimed === read.carry) return false
 

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

@@ -0,0 +1,48 @@
+// A launch identity survives Codex's shell environment filtering without guessing its session PID.
+import { lane_child_marker } from '#scripts/lane/lane-child-marker'
+import { run_headless_keys } from '#scripts/run/run-headless-keys'
+import type { CarryOwner, RunCarry } from './run-carry'
+import { run_carry_conversation } from './run-carry-conversation'
+
+const KEY = 'JOSH_CARRY_SESSION'
+
+function own(): string | undefined {
+	if (
+		lane_child_marker.marked_issue(process.env) !== undefined ||
+		process.env[run_headless_keys.BESIDE_CHILD_KEY] === '1' ||
+		process.env[run_headless_keys.HANDOFF_CHILD_KEY] === '1'
+	) {
+		return undefined
+	}
+
+	return process.env[KEY]
+}
+
+function is_owned_by(carry: RunCarry, owner: CarryOwner): boolean {
+	if (carry.owner_session !== undefined) return carry.owner_session === owner.session
+	if (run_carry_conversation.is_same_conversation(carry, owner)) return true
+
+	return carry.owner_pid === owner.pid && carry.owner_start === owner.start
+}
+
+function retain_execution(carry: RunCarry, owner: CarryOwner): CarryOwner {
+	if (
+		owner.session === undefined ||
+		owner.session !== carry.owner_session ||
+		owner.pid !== undefined
+	) {
+		return owner
+	}
+
+	return {
+		...owner,
+		pid: carry.owner_pid,
+		start: carry.owner_start,
+		provider: carry.scheduler_provider,
+		is_headless: carry.is_owner_headless,
+	}
+}
+
+const run_carry_session = { KEY, own, is_owned_by, retain_execution }
+
+export { run_carry_session }

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