@joshuafolkken/kit 1.3041.0 → 1.3092.0

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

@@ -11,6 +11,7 @@ import { run_event_retry } from '#scripts/run/event/run-event-retry'
 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_invocation } from '#scripts/run/run-invocation'
+import { run_repair_attempt } from '#scripts/run/run-repair-attempt'
 import { run_add, type AddContext, type AddOutcome, type AddPorts, type IssueView } from './run-add'
 import { run_add_epic } from './run-add-epic'
 import { run_add_issue } from './run-add-issue'
@@ -136,6 +137,17 @@ async function announce(
 	await announce(rest, roots, is_retry)
 }
 
+async function prepare_repairs(request: AddRequest): Promise<ReadonlySet<number>> {
+	if (!request.is_retry) return new Set()
+	const prepared = await Promise.all(
+		request.issues.map(async (issue) =>
+			(await run_repair_attempt.prepare(String(issue))) ? issue : undefined,
+		),
+	)
+
+	return new Set(prepared.filter((issue) => issue !== undefined))
+}
+
 // The blockers still open. A blocker whose state did not come back counts as open, so an issue is
 // never reported free to run on a read that did not say so.
 function view_of(issue: EpicIssue): IssueView {
@@ -166,7 +178,11 @@ async function clear_label(issue: number, label: string): Promise<boolean> {
 
 const GH_PORTS: AddPorts = { read_issue, apply_label, clear_label }
 
-async function context_of(live: LiveRun, is_retry: boolean): Promise<AddContext> {
+async function context_of(
+	live: LiveRun,
+	is_retry: boolean,
+	repairs: ReadonlySet<number>,
+): Promise<AddContext> {
 	const lanes = await lane_spent.lanes_in_use()
 	const events = await run_event_stream_emit.current_events(is_retry)
 	const active = backlog_drive_restore.active_issues(events)
@@ -174,6 +190,7 @@ async function context_of(live: LiveRun, is_retry: boolean): Promise<AddContext>
 
 	return {
 		is_retry,
+		repairs,
 		done: live.carry.done ?? [],
 		active: new Set([...active, ...lanes.working, ...lanes.unread]),
 		settled: new Set([
@@ -191,11 +208,12 @@ function report(outcomes: ReadonlyArray<AddOutcome>, is_priority: boolean): numb
 }
 
 async function add(request: AddRequest, live: LiveRun, ports: AddPorts): Promise<number> {
+	const repairs = await prepare_repairs(request)
 	const outcomes: ReadonlyArray<AddOutcome> = await run_add.add_all(
 		request.issues,
 		request.is_priority,
 		ports,
-		await context_of(live, request.is_retry),
+		await context_of(live, request.is_retry, repairs),
 	)
 	const additions = run_add.additions_of(outcomes, request.is_priority)
 	const roots = run_add.roots_of(outcomes)
@@ -203,7 +221,7 @@ async function add(request: AddRequest, live: LiveRun, ports: AddPorts): Promise
 	if (additions.length === 0) return report(outcomes, request.is_priority)
 
 	await announce(
-		additions.map((addition) => addition.issue),
+		additions.map((addition) => addition.issue).filter((issue) => !repairs.has(issue)),
 		roots,
 		request.is_retry,
 	)

package/scripts/run/add/run-add.ts

@@ -4,6 +4,7 @@ import {
 	has_label_name,
 	IN_PROGRESS_LABEL,
 	NEEDS_DECISION_LABEL,
+	NEEDS_HUMAN_MERGE_LABEL,
 	NEEDS_HUMAN_REVIEW_LABEL,
 	PRIORITY_HIGH_LABEL,
 	RUN_LANE_LABEL,
@@ -44,6 +45,8 @@ interface AddContext {
 	settled?: ReadonlySet<number>
 	// What the run already tracks, so an epic root is never recorded twice (`run_add_epic.tracked_of`).
 	tracked?: ReadonlySet<number>
+	// The issues whose repair attempt this call recorded (`run_repair_attempt.prepare`).
+	repairs?: ReadonlySet<number>
 }
 
 const DEFAULT_CONTEXT: AddContext = { is_retry: false, done: [], active: new Set() }
@@ -73,20 +76,34 @@ function labels_for(
 		: opted_in
 }
 
-// The first label that would not apply, or `undefined` once every one landed. Sequential, so a
+// The first label whose write failed, or `undefined` once every one landed. Sequential, so a
 // refused write stops the rest rather than leaving a half-labelled issue the pool reads differently.
-async function first_unapplied(
+async function first_failed(
 	issue: number,
 	labels: ReadonlyArray<string>,
-	ports: AddPorts,
+	write: AddPorts['apply_label'],
 ): Promise<string | undefined> {
 	const [label, ...rest] = labels
 
 	if (label === undefined) return undefined
 
-	if (!(await ports.apply_label(issue, label))) return label
+	if (!(await write(issue, label))) return label
+
+	return await first_failed(issue, rest, write)
+}
 
-	return await first_unapplied(issue, rest, ports)
+// The stops a retry clears: `run:stalled` always, and `needs-human-merge` only for an issue whose
+// repair attempt was recorded — a merge wait with no repair stays a person's (joshuafolkken/kit#7487).
+// The ship re-parks it while the diff still needs a person's merge (`followup-human-merge.ts`).
+// A recorded repair also clears the ended lane's `in-progress`, which the offer otherwise reads as
+// another session's work (joshuafolkken/kit#7493): the record is made only once no process holds
+// the issue and its lane tree is clean (`run-repair-attempt.ts`).
+function stops_of(issue: number, context: AddContext): ReadonlyArray<string> {
+	if (!context.is_retry) return []
+
+	return context.repairs?.has(issue) === true
+		? [RUN_STALLED_LABEL, NEEDS_HUMAN_MERGE_LABEL, IN_PROGRESS_LABEL]
+		: [RUN_STALLED_LABEL]
 }
 
 function retry_required(
@@ -131,13 +148,13 @@ async function label_one(
 	ports: AddPorts,
 	context: AddContext,
 ): Promise<AddOutcome> {
-	const label = await first_unapplied(issue, labels, ports)
+	const label = await first_failed(issue, labels, ports.apply_label)
 
 	if (label !== undefined) return { kind: 'unlabeled', issue, label }
 
-	if (context.is_retry && !(await ports.clear_label(issue, RUN_STALLED_LABEL))) {
-		return { kind: 'refused', issue, reason: 'could not clear run:stalled' }
-	}
+	const stop = await first_failed(issue, stops_of(issue, context), ports.clear_label)
+
+	if (stop !== undefined) return { kind: 'refused', issue, reason: `could not clear ${stop}` }
 
 	return { kind: 'queued', issue, blockers: [] }
 }

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

@@ -19,6 +19,7 @@ import type { QuotaHold, QuotaView } from './run-board-render-quota'
 import { run_board_render_slot } from './run-board-render-slot'
 import { run_board_render_title } from './run-board-render-title'
 import type { SeatRead } from './run-board-seat'
+import { run_board_setup } from './run-board-setup'
 import type { RunActivity } from './run-board-status'
 import type { LaneUsages, UsageScale } from './run-board-usage'
 import type { UsualTimes } from './run-board-usual'
@@ -46,7 +47,6 @@ const { padded } = run_board_fresh
 const aged_fresh = run_board_fresh.aged
 const UNKNOWN = '-'
 const BLANK = ' '
-const REPO_SEPARATOR = '/'
 const { GAP, PERCENT_WIDTH } = run_board_machine
 // A running run whose newest event is older than this is drawn as stale, so a hang stands out; past
 // twice that it is drawn as alarming.
@@ -165,9 +165,8 @@ const WORKING_MARKS: ReadonlySet<RunMark> = new Set<RunMark>(['running', 'setup'
 // Nothing running: the run is at work on a stage of its own; else it is waiting on a person when all
 // the plan has left is what `needs-decision` holds, or idle.
 function quiet_mark(header: BoardHeader): RunMark {
-	const { layout } = header
-
-	if (header.activity.setup !== undefined) return 'setup'
+	const { activity, layout } = header
+	if (run_board_setup.is_working(activity.setup, activity.is_setup_working)) return 'setup'
 
 	return layout?.queued.length === 0 && run_board_layout.people_of(layout).length > 0
 		? 'human'
@@ -191,7 +190,7 @@ function run_part(mark: RunMark, name = RUN_NAME): string {
 // The repository's own name — `kit` of `owner/kit` — under the run's, past the mark's columns, so a
 // board open beside another repository's is told apart. Blank before a plan names one.
 function repo_part(header: BoardHeader, mark: RunMark): string {
-	const name = header.repo?.split(REPO_SEPARATOR).at(-1) ?? ''
+	const name = header.repo?.split('/').at(-1) ?? ''
 	const indent = run_board_fit.width_of(RUN_MARKS[mark].glyph) + BLANK.length
 
 	return `${BLANK.repeat(indent)}${header.repo_link(name, 'home')}`

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

@@ -13,9 +13,9 @@ import { run_board_decision } from './run-board-decision'
 import { run_board_earlier, type EarlierLanes } from './run-board-earlier'
 import { run_board_ending_reason } from './run-board-ending-reason'
 import { run_board_human } from './run-board-human'
-import { run_board_human_merge } from './run-board-human-merge'
 import { run_board_kind, type BoardPriority } from './run-board-kind'
 import type { PauseRead } from './run-board-pause'
+import { run_board_retry_wait } from './run-board-retry-wait'
 import { run_board_standing_waits } from './run-board-standing-waits'
 import type { ItemState, ItemStatus } from './run-board-status'
 
@@ -327,7 +327,7 @@ function layout_of(
 	reason_of?: ReasonOf,
 	earlier: EarlierLanes = run_board_earlier.NO_EARLIER,
 ): BoardLayout {
-	const current = run_board_human_merge.overlay_of(input_plan, input_statuses)
+	const current = run_board_retry_wait.overlay_of(input_plan, input_statuses)
 	const { plan, statuses } = current
 	const overlay = { plan, statuses, reason_of }
 	const queue = plan.waves.waves.flat().filter((child) => is_untouched(child, overlay))

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

@@ -59,6 +59,8 @@ interface LocalRead {
 	is_stranded: boolean
 	// The newest operation of each session of the run, read off the end of its log.
 	operations?: SessionOperations | undefined
+	// The carry's session owner is still running, apart from the supervisor's own driver.
+	is_session_active?: boolean | undefined
 	// The open lanes no child is working in at this read (`lane-spent.ts`); one is drawn stopped once it
 	// has stayed so (`run-board-idle.ts`).
 	idle_lanes?: ReadonlyArray<string> | undefined
@@ -108,6 +110,7 @@ const NO_SPAN: SpanHere = {
 	roots: {},
 	carry: undefined,
 	is_stranded: false,
+	is_session_active: false,
 }
 
 interface SpanHere {
@@ -118,6 +121,7 @@ interface SpanHere {
 	roots: ProcessRoots
 	carry: RunCarry | undefined
 	is_stranded: boolean
+	is_session_active: boolean
 }
 
 // The main work tree, resolved once: it does not move while the board is open, and resolving it runs a
@@ -159,6 +163,7 @@ async function recorded_span_here(
 		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),
 	}
@@ -341,7 +346,7 @@ function span_fields(
 // snapshot, so it agrees with the usage columns.
 async function read_local(table?: TableRead): Promise<LocalRead | undefined> {
 	const repository = await run_carry.repository_directory()
-	const { span, resume, transcript, roots, carry, is_stranded } =
+	const { span, resume, transcript, roots, carry, is_stranded, is_session_active } =
 		repository === undefined ? NO_SPAN : await span_here(repository, table)
 
 	if (repository === undefined || span === undefined) return undefined
@@ -361,6 +366,7 @@ async function read_local(table?: TableRead): Promise<LocalRead | undefined> {
 		roots,
 		carry,
 		is_stranded,
+		is_session_active,
 		operations: run_board_operation_read.read(sources_of(repository, lanes, transcript)),
 		...(await lane_room_of(lanes, lane_read.lane_states, table)),
 		...ledger_here(repository),

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

@@ -5,6 +5,7 @@ import { epic_solo, type Labelled, type SoloQueue } from '#scripts/epic/epic-sol
 import { epic_triage } from '#scripts/epic/epic-triage'
 import { has_label_name, has_parked_label, IN_PROGRESS_LABEL } from '#scripts/issue/issue-labels'
 import { issue_not_before } from '#scripts/issue/issue-not-before'
+import { issue_observation_gate } from '#scripts/issue/issue-observation-gate'
 import { issue_sample_gate } from '#scripts/issue/issue-sample-gate'
 import { lane_state } from '#scripts/lane/lane-state'
 import type { RunCarry } from '#scripts/run/carry/run-carry'
@@ -266,6 +267,17 @@ function offer_wait(child: EpicChild, read: ReasonRead, pool: Pool): RowReason |
 // waits on; `📅 4313` while that pull request has not merged or its merge is unread — the cited issue
 // for a condition waiting on the pull request that closes it.
 function sample_wait_of(child: EpicChild): RowReason | undefined {
+	const observation = issue_observation_gate.wait_of(child.body)
+
+	if (observation !== undefined) {
+		return {
+			icon: WAIT_ICONS.not_before,
+			value: 'evidence',
+			tail: observation.reason,
+			evidence_url: observation.url,
+		}
+	}
+
 	const wait = issue_sample_gate.wait_of(child.body)
 
 	if (wait === undefined) return undefined

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-roots.ts

@@ -1,7 +1,7 @@
 import { process_identity } from '#scripts/josh/process-identity'
 import { lane_process_table, type TableRead } from '#scripts/lane/lane-process-table'
 import type { CarryRead } from '#scripts/run/carry/run-carry'
-import { run_wake } from '#scripts/run/wake/run-wake'
+import { run_wake, type RunWake } from '#scripts/run/wake/run-wake'
 import type { ProcessRoots } from './run-board-process-groups'
 
 // The run's own processes the 💻 section names: the supervisor from its wake stamp and the parent
@@ -38,6 +38,29 @@ function roots_of(
 	return { supervisor: supervisor_of(repository, is_same), parent: parent_of(read, is_same) }
 }
 
+// A handed-back budget or the supervisor's own driver is no judgment session. Codex's pid-less
+// carry uses the launch pid already recorded by the wake supervisor instead.
+function is_session_owner(read: CarryRead): boolean {
+	return read.kind === 'carried' && read.carry.is_handed_off !== true
+}
+
+function live_session_pid(
+	pid: number | undefined,
+	start: string | undefined,
+	wake: RunWake | undefined,
+	is_same: SameProcess,
+): boolean {
+	return pid !== undefined && pid !== wake?.pid && is_same(pid, start) !== false
+}
+
+function session_is_active(repository: string, read: CarryRead, is_same: SameProcess): boolean {
+	if (read.kind !== 'carried' || !is_session_owner(read)) return false
+	const wake = run_wake.read_wake(run_wake.wake_path(repository))
+	const pid = read.carry.owner_pid ?? wake?.woke_pid
+
+	return live_session_pid(pid, read.carry.owner_start, wake, is_same)
+}
+
 // `is_same_process` with each start time answered from the redraw's own `ps` snapshot, so the board's
 // read runs no `ps` of its own per pid (joshuafolkken/kit#4263). Without a snapshot no start is known,
 // and a recorded start reads as "cannot tell".
@@ -48,7 +71,7 @@ async function same_in(table: TableRead | undefined): Promise<SameProcess> {
 	return (pid, start) => process_identity.is_same_process(pid, start, read)
 }
 
-const run_board_roots = { roots_of, same_in }
+const run_board_roots = { roots_of, same_in, session_is_active }
 
 export { run_board_roots }
 export type { SameProcess }

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

@@ -21,19 +21,25 @@ interface SetupRead {
 
 const NO_SETUP: SetupRead = { setup: undefined, setup_ms: undefined }
 
+// Only these stages depend on the judgment session owning the carry.
+const SESSION_STAGES: ReadonlySet<string> = new Set([STAGE.JUDGING, STAGE.SESSION])
+
 // The stages of a hand-back to a session, and of the retrospective unit the driver waits on at a drain
 // (joshuafolkken/kit#6745). Only the run's next stage ends one, whatever the session or the unit writes
 // to the stream meanwhile.
-const SESSION_STAGES: ReadonlySet<string> = new Set([
-	STAGE.JUDGING,
-	STAGE.SESSION,
-	STAGE.RETROSPECTIVE,
-])
+const RETAINED_STAGES: ReadonlySet<string> = new Set([...SESSION_STAGES, STAGE.RETROSPECTIVE])
 
 function is_setup(event: RunEvent): boolean {
 	return event.kind === KIND.SETUP
 }
 
+// Session stages describe the last hand-off even after its owner has returned the budget.
+function is_working(setup: string | undefined, is_session_active: boolean | undefined): boolean {
+	if (setup === undefined) return false
+
+	return !SESSION_STAGES.has(setup) || is_session_active !== false
+}
+
 // A launch that returned without a child (`run_event_setup.no_child`): it ends its own lane's stage,
 // and prepares nothing a person waits on.
 function is_refusal(event: RunEvent): boolean {
@@ -44,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
@@ -65,7 +73,7 @@ function is_opening(events: ReadonlyArray<RunEvent>, stage: RunEvent): boolean {
 // Whether the run is at `stage` now: at any stage while it is starting; after that only at one it is
 // itself working through.
 function is_standing(events: ReadonlyArray<RunEvent>, stage: RunEvent): boolean {
-	if (!has_started(events) || SESSION_STAGES.has(stage.text)) return true
+	if (!has_started(events) || RETAINED_STAGES.has(stage.text)) return true
 
 	return is_opening(events, stage)
 }
@@ -119,7 +127,7 @@ function lane_stage(events: ReadonlyArray<RunEvent>, issue: number): LaneStage |
 	return { text: step.text, at_ms: Date.parse(step.at) }
 }
 
-const run_board_setup = { is_refusal, lane_stage, read }
+const run_board_setup = { is_refusal, is_working, lane_stage, read }
 
 export { run_board_setup }
 export type { LaneStage, SetupRead }

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

@@ -82,6 +82,8 @@ interface LatestEvent {
 // The run as a whole, read off the same stream. The setup half is `run-board-setup.ts`'s, absent
 // where a stream carries no stage.
 interface RunActivity extends Partial<SetupRead> {
+	// Runtime evidence for the stage, independent of its retained description.
+	is_setup_working?: boolean | undefined
 	last_event_ms: number | undefined
 	// The newest thing the run did — its newest position, or its newest event where it has none yet —
 	// in the event's own words, and when.

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

@@ -14,6 +14,7 @@ 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_seat, type SeatRead } from './run-board-seat'
+import { run_board_setup } from './run-board-setup'
 import type { Known } from './run-board-snapshot'
 import { run_board_spin, type Spun } from './run-board-spin'
 import { run_board_state, type BoardPorts, type BoardState, type Pace } from './run-board-state'
@@ -82,10 +83,15 @@ function titles_of(state: BoardState): Titles {
 
 // A run `run:carry --end` closed and one nobody drives any more are both drawn as stopped.
 function activity_here(local: LocalRead): RunActivity {
-	return run_board_status.activity_of(
+	const activity = run_board_status.activity_of(
 		local.events,
 		local.ended_ms !== undefined || local.is_stranded,
 	)
+
+	return {
+		...activity,
+		is_setup_working: run_board_setup.is_working(activity.setup, local.is_session_active),
+	}
 }
 
 // The already-read supervisor or parent drives retries until the run stops or becomes stranded.

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 }