@joshuafolkken/kit 1.1379.0 → 1.1387.0

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

@@ -50,12 +50,12 @@ const { PRE_GATE_PHASE, IMPLEMENTATION_PHASE } = agent_role_profile
 // `pnpm josh cost --cut` hand-off uses (`backlogrun-progress.md` → "The hand-off"). The shared
 // threshold prevents the scheduler and worker boundaries from drifting apart.
 const IMPLEMENTATION_CONTEXT_THRESHOLD = CONTEXT_CUT_THRESHOLD
-// **The whole-run bound is `backlog-budget.ts`'s, imported rather than restated** — the same reuse
-// `run-carry.ts` makes. A resume is expected within seconds of the cut, so this age is only a backstop
+// **The bound is `backlog-budget.ts`'s idle wait, imported rather than restated**, so the eight hours
+// stay written once. A resume is expected within seconds of the cut, so this age is only a backstop
 // against a fresh process that never started; an expired record is cleared and replaced by the next
 // cut rather than blocking it.
-const CUT_MAX_AGE_MS = backlog_budget.WHOLE_RUN_BUDGET_MS
-const CUT_MAX_AGE_HOURS = backlog_budget.WHOLE_RUN_BUDGET_HOURS
+const CUT_MAX_AGE_MS = backlog_budget.DEFAULT_IDLE_MS
+const CUT_MAX_AGE_HOURS = backlog_budget.IDLE_WAIT_HOURS
 
 const END_COMMAND = 'pnpm josh run:cut --end'
 const READ_COMMAND = 'pnpm josh run:cut --json'

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

@@ -39,12 +39,12 @@ const KIND_LABELS: Readonly<Record<EventKind, KindLabel>> = {
 	heartbeat: { ja: '生存確認', en: 'heartbeat' },
 	'ship-launch': { ja: '出荷を開始', en: 'ship launched' },
 	'ship-stop': { ja: '出荷が停止', en: 'ship stopped' },
-	idle: { ja: '新着待ち', en: 'idle watch' },
 	filed: { ja: '起票', en: 'filed' },
 	note: { ja: '意見', en: 'note' },
 	'lane-phase': { ja: 'レーンの段階', en: 'lane phase' },
 	add: { ja: '割り込み', en: 'added' },
 	'lane-limit': { ja: 'レーン上限', en: 'lane limit' },
+	setup: { ja: '準備', en: 'setup' },
 }
 
 const LABELS_BY_KIND: ReadonlyMap<string, KindLabel> = new Map(Object.entries(KIND_LABELS))

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

@@ -55,16 +55,12 @@ function scoped_events(
 	return events.filter((event) => is_within(event, floor))
 }
 
-// The scope the run's own carry record implies. A record that reads at all names the invocation's start, and
-// **an expired one names it just as well**: expiry is the budget's verdict on a run, not a gap in the record,
-// so rounding it to unknown would withhold the scope from exactly the long runs that most need one. Only an
-// absent or unreadable record leaves the scope undetermined.
+// The scope the run's own carry record implies. A record that reads at all names the invocation's start,
+// however long ago that was; only an absent or unreadable record leaves the scope undetermined.
 function scope_of(read: CarryRead): EventScope {
-	if (read.kind === 'carried' || read.kind === 'expired') {
-		return { kind: SINCE_SCOPE, started_at: read.carry.started_at }
-	}
+	if (read.kind !== 'carried') return UNKNOWN_EVENT_SCOPE
 
-	return UNKNOWN_EVENT_SCOPE
+	return { kind: SINCE_SCOPE, started_at: read.carry.started_at }
 }
 
 // The newest event within scope, or `undefined` when the scope could not be determined or nothing falls

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

@@ -0,0 +1,47 @@
+import { issue_cite } from '#scripts/issue/issue-cite'
+import { error_text } from '#scripts/lib/error-message'
+import { run_event_stream } from './run-event-stream'
+import { run_event_stream_emit } from './run-event-stream-emit'
+
+// The stages a run passes between `josh backlogrun` and its first child, each written to the stream as
+// one `setup` event by the step that enters it. **The text is the stage's own words**: `run:board` draws
+// it as written, so the message a person reads and the `💓` beside it come from one event and cannot
+// disagree. Only a lane opening names an issue, which is how a reader tells it from the stages before it.
+
+const STAGE = {
+	// `josh backlogrun` started the parent session, which is reading its procedure.
+	STARTING: 'starting session',
+	// `run:carry --begin` claimed the run, and the parent is planning it.
+	PLANNING: 'planning',
+	// The supervisor took the run over from the parent and is asking for the first offer.
+	HANDING_OFF: 'handing off',
+} as const
+
+const OPENING = 'opening lane'
+
+// The driver is about to open a lane for `issue` — for every child, not only the first.
+function opening_lane(issue: string): string {
+	return `${OPENING} ${issue_cite.plain(issue)}`
+}
+
+// Best-effort, as every append to this stream is: a stage that could not be written is a board that
+// says less, never a run that failed.
+async function emit(text: string): Promise<void> {
+	await run_event_stream_emit.emit(run_event_stream.EVENT_KIND.SETUP, text)
+}
+
+// The same append for a caller that already holds the repository's common git directory and the moment
+// it wants the stage dated — the launcher, whose record and first stage carry one time.
+function emit_in(repository: string, text: string, at: Date): void {
+	try {
+		const target = run_event_stream.target_of(repository)
+
+		run_event_stream.append(target, run_event_stream.EVENT_KIND.SETUP, text, at.toISOString())
+	} catch (error) {
+		error_text.trace_swallowed('run_event_setup.emit_in', error)
+	}
+}
+
+const run_event_setup = { STAGE, emit, emit_in, opening_lane }
+
+export { run_event_setup }

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

@@ -70,30 +70,6 @@ async function emit_once(kind: string, text: string): Promise<boolean> {
 	}
 }
 
-/**
- * Append one event unless the newest event of this kind already carries this text — for a marker whose
- * value, not its presence, is the news. The idle window is re-derived on every
- * offer of a watching loop; only a window that moved is worth a line. Returns whether it appended.
- */
-async function emit_changed(kind: string, text: string): Promise<boolean> {
-	try {
-		const target = await stream_target()
-
-		if (target === undefined) return false
-
-		const newest = run_event_stream.read_events(target).findLast((event) => event.kind === kind)
-
-		if (newest?.text === text) return false
-
-		return run_event_stream.append(target, kind, text, now_iso()).appended
-	} catch (error) {
-		// Best-effort: a failed append is dropped rather than raised into the loop's work.
-		error_text.trace_swallowed('run_event_stream_emit.emit_changed', error)
-
-		return false
-	}
-}
-
 // The events of the invocation now running: the stream outlives every invocation, so a marker a previous
 // run left — a stall that ended with no dispatch after it — must not hold back this run's first one. An
 // undetermined scope (no carry record) keeps the whole stream, the side that under-notifies rather than
@@ -187,7 +163,6 @@ const run_event_stream_emit = {
 	all_events,
 	current_events,
 	emit,
-	emit_changed,
 	emit_heartbeat,
 	emit_once,
 	emit_once_since,

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

@@ -29,7 +29,7 @@ const EVENT_PREFIX = 'josh-run-events-'
 // every reader — a person, an editor — that it is a line stream rather than a single document, the same
 // distinction the ambient `.log` draws.
 const EVENT_SUFFIX = '.jsonl'
-// A run's session-facing events over the 8-hour whole-run bound: a plan, a launch/PR/review-round/merge
+// A run's session-facing events over one unattended night: a plan, a launch/PR/review-round/merge
 // per child across a few dozen children, plus parks, cuts and stops. Five hundred keeps the whole of a
 // large `backlogrun` and still bounds an unattended run — past it the oldest events roll off.
 const EVENT_CAP = 500
@@ -83,7 +83,8 @@ const EVENT_KIND = {
 	// stalled is pointed straight at dispatching the work rather than left waiting.
 	STALL: 'stall',
 	// The run's own driver is gone: the cut handed the budget off, the owner has died, and no supervisor
-	// is watching. Emitted once per strand episode by the stop-time detector,
+	// is watching. Emitted once per strand episode by the stop-time detector — or by the `run:wake`
+	// supervisor as it fails, leaves that state behind and has warned of it —
 	// exactly as `STALL` is — the newest-event dedup keeps a run polled every stop from notifying more
 	// than once, and a terminal reader following the stream sees the line. The strand is the step before
 	// the stall: a stalled run still has a driver that could dispatch, a stranded one has none.
@@ -106,11 +107,6 @@ const EVENT_KIND = {
 	// The position that hands control back: `run:step` prints the command that
 	// shows the stopped report, so the agent fixes it and relaunches rather than rebuilding the context.
 	SHIP_STOP: 'ship-stop',
-	// The idle watch's window — when the run began waiting on an empty backlog and when that wait ends
-	// `backlog:offer` writes it whenever the window changes, so `run:board` reads
-	// the deadline rather than guessing it. It is a trace: `emit_once`'s drain dedup and `run:step`'s
-	// position both read past it, so a watching loop never re-marks the drain it is waiting after.
-	IDLE: 'idle',
 	// An Issue the run filed on its way, written by `issue:file`, so a run started from the command line
 	// still surfaces what it found — `run:board`'s findings section reads it.
 	FILED: 'filed',
@@ -129,6 +125,11 @@ const EVENT_KIND = {
 	// arrival probe reads it as a wake: the lanes a raise frees are new room for a pool its baseline
 	// already holds. A trace: it says the run gained room, not where the run is.
 	LANE_LIMIT: 'lane-limit',
+	// One stage of the run's start — the session starting, the plan, the hand-off to the supervisor, a
+	// lane opening (`run-event-setup.ts`). `run:board` draws it until the first child launches, so the
+	// minutes before one read as work rather than as a run that has stopped. A trace: it says the run is
+	// getting ready, not where the run is.
+	SETUP: 'setup',
 } as const
 
 type EventKind = (typeof EVENT_KIND)[keyof typeof EVENT_KIND]
@@ -141,22 +142,23 @@ const EVENT_KINDS: ReadonlyArray<string> = Object.values(EVENT_KIND)
 const TRACE_KINDS: ReadonlySet<string> = new Set([
 	EVENT_KIND.SHIP_STAGE,
 	EVENT_KIND.HEARTBEAT,
-	EVENT_KIND.IDLE,
 	EVENT_KIND.FILED,
 	EVENT_KIND.NOTE,
 	EVENT_KIND.LANE_PHASE,
 	EVENT_KIND.ADD,
 	EVENT_KIND.LANE_LIMIT,
+	EVENT_KIND.SETUP,
 ])
 
 // The trace kinds that say only that the run was alive, so the bound rolls them off first. A `filed` or
 // `note` line is a trace to the position readers but is the board's record of what the run found, so
-// it rolls off only with the positions. A ship-stage `start` and an `idle` line are disposable but go
-// last of them: `run:board` draws from those lines.
+// it rolls off only with the positions. A ship-stage `start` is disposable but goes last of them:
+// `run:board` draws from that line. A `setup` line is read only until the child it prepares launches,
+// so every one but the newest goes.
 const DISPOSABLE_KINDS: ReadonlySet<string> = new Set([
 	EVENT_KIND.SHIP_STAGE,
 	EVENT_KIND.HEARTBEAT,
-	EVENT_KIND.IDLE,
+	EVENT_KIND.SETUP,
 ])
 
 const event_schema = z.object({
@@ -200,9 +202,10 @@ function parse_line(line: string): RunEvent | undefined {
 	return event_schema.safeParse(json_value.parse_or_undefined(line)).data
 }
 
-// Every event on the stream, oldest first. An absent or unreadable file is an empty stream, the same
-// fail-quiet direction `stamp_file.read_stamp_text` takes for a planted or unowned file.
-function read_events(target: string): ReadonlyArray<RunEvent> {
+// Every line on the stream that parses, oldest first, whatever its kind. An absent or unreadable file
+// is an empty stream, the same fail-quiet direction `stamp_file.read_stamp_text` takes for a planted or
+// unowned file.
+function read_lines(target: string): ReadonlyArray<RunEvent> {
 	const raw = stamp_file.read_stamp_text(target)
 
 	if (raw === undefined) return []
@@ -215,6 +218,13 @@ function read_events(target: string): ReadonlyArray<RunEvent> {
 		.filter(is_present)
 }
 
+// Every event on the stream, oldest first. A line whose kind the enumeration no longer names — one a
+// previous version wrote — reads as no event, so no reader takes it for a position or for the run's
+// newest activity.
+function read_events(target: string): ReadonlyArray<RunEvent> {
+	return read_lines(target).filter((event) => is_event_kind(event.kind))
+}
+
 function last_position(events: ReadonlyArray<RunEvent>): number {
 	return events[events.length - POSITION_INCREMENT]?.pos ?? FIRST_POSITION
 }
@@ -243,21 +253,23 @@ function is_stage_start(event: RunEvent): boolean {
 	return event.text.split(WORD_SEPARATOR)[STAGE_PHASE_INDEX] === run_ship_stage.PHASE.START
 }
 
-// A disposable line `run:board` draws from: a ship-stage `start` is a phase on a lane's track, and an
-// `idle` line is the deadline of the run's wait.
-function is_drawn(event: RunEvent): boolean {
-	return event.kind === EVENT_KIND.IDLE || is_stage_start(event)
+// The disposable lines the bound never drops: each issue's newest ship-stage and the run's newest
+// `setup` stage, the ones `run:board` draws from now.
+function drawn_lines(events: ReadonlyArray<RunEvent>): ReadonlySet<RunEvent> {
+	const setup = events.findLast((event) => event.kind === EVENT_KIND.SETUP)
+
+	return new Set([...newest_stages(events), ...(setup === undefined ? [] : [setup])])
 }
 
 // The lines the bound may drop, in the order it drops them: the ones that draw nothing first, then the
 // ones `run:board` draws from, each group oldest first.
 function droppable(events: ReadonlyArray<RunEvent>): ReadonlyArray<RunEvent> {
-	const kept = newest_stages(events)
+	const kept = drawn_lines(events)
 	const disposable = events.filter((event) => DISPOSABLE_KINDS.has(event.kind) && !kept.has(event))
 
 	return [
-		...disposable.filter((event) => !is_drawn(event)),
-		...disposable.filter((event) => is_drawn(event)),
+		...disposable.filter((event) => !is_stage_start(event)),
+		...disposable.filter((event) => is_stage_start(event)),
 	]
 }
 
@@ -269,11 +281,11 @@ function droppable(events: ReadonlyArray<RunEvent>): ReadonlyArray<RunEvent> {
 //
 // **Each issue's newest ship-stage is not disposable**: it is the only record `run:board` draws a lane's
 // review-and-later phase from, and on a stream full of positions it would otherwise roll off in its own
-// append.
+// append. **The newest `setup` stage is kept for the same reason**: it is the stage `run:board` draws
+// until the first child launches, and a run that starts on a full stream would otherwise show none.
 //
 // **A ship-stage `start` outlasts the other disposable lines**: each one is a phase on the lane's track,
-// so it is kept past the `done` lines and the heartbeats. An `idle` line goes with them, oldest first,
-// so a run's newest wait is not the first line a stream of starts and positions gives up.
+// so it is kept past the `done` lines and the heartbeats.
 //
 // **The kept line carries the history**: on a stream the positions fill, every append still rolls off
 // the issue's previous stage line, so the newest one lists every stage its
@@ -293,11 +305,12 @@ function serialize(events: ReadonlyArray<RunEvent>): string {
 }
 
 // The read-modify-write, run only while the stream's lock is held. `replace_text_stamp` publishes the
-// rewrite with a rename, so a reader never sees the stream absent or half-written.
+// rewrite with a rename, so a reader never sees the stream absent or half-written. The position counts
+// on from every line the file holds, so a line of a retired kind — dropped by this rewrite — never
+// hands its position to a new event.
 function append_held(target: string, event: Omit<RunEvent, 'pos'>): number {
-	const existing = read_events(target)
-	const position = last_position(existing) + POSITION_INCREMENT
-	const events = bounded([...existing, { pos: position, ...event }])
+	const position = last_position(read_lines(target)) + POSITION_INCREMENT
+	const events = bounded([...read_events(target), { pos: position, ...event }])
 
 	stamp_file.replace_text_stamp(target, serialize(events))
 

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

@@ -93,7 +93,7 @@ async function collect_carried(carry: RunCarry): Promise<void> {
 async function collect_merged(directory: string): Promise<void> {
 	const read = run_carry.read_carry(run_carry.carry_path(directory))
 
-	if (read.kind !== 'carried' && read.kind !== 'expired') return
+	if (read.kind !== 'carried') return
 
 	try {
 		await collect_carried(read.carry)

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

@@ -102,7 +102,7 @@ async function read_record(): Promise<{ target: string; carry: RunCarry } | unde
 	const target = run_carry.carry_path(directory)
 	const read = run_carry.read_carry(target)
 
-	if (read.kind !== 'carried' && read.kind !== 'expired') return undefined
+	if (read.kind !== 'carried') return undefined
 
 	return { target, carry: read.carry }
 }

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

@@ -123,7 +123,7 @@ function is_hold_present(read: HoldRead): boolean {
 }
 
 function is_carry_present(read: CarryRead): boolean {
-	return read.kind === 'carried' || read.kind === 'expired'
+	return read.kind === 'carried'
 }
 
 function hold_present(worktree: string | undefined): boolean {

package/scripts/run/run-headless.ts

@@ -44,8 +44,8 @@ function is_cut_capped(carry: RunCarry, source: EnvironmentSource = process.env)
 }
 
 // Only a live, un-handed-off record binds the session to its lanes. After `run:carry --cut` the next
-// successor drives them, and after `--end` (`none`) or past the bound (`expired`) there is no run left
-// to drive — ending the turn is correct in all three. An unreadable record fails open, as every stop
+// successor drives them, and after `--end` (`none`) there is no run left to drive — ending the turn is
+// correct in both. An unreadable record fails open, as every stop
 // rule does (`stop-guard.ts`).
 function is_driving(read: CarryRead | undefined): boolean {
 	return read?.kind === 'carried' && read.carry.is_handed_off !== true

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

@@ -25,7 +25,6 @@ const USAGE = 'Usage: josh run:status <issue-number> [--repo <owner/repo>]'
 const CARRY_NONE_NOTE = 'no run recorded here'
 const CARRY_UNREADABLE_NOTE = '(run record not bundled: unreadable)'
 const CARRY_SUMMARY_NONE = 'none'
-const CARRY_SUMMARY_EXPIRED = 'expired'
 const CARRY_SUMMARY_UNREADABLE = 'unreadable'
 const MERGED_SUFFIX = ' merged'
 
@@ -94,16 +93,13 @@ function failure_note(issue_number: string, kind: string): string {
 
 function carry_summary(carry: CarryRead): string {
 	if (carry.kind === 'carried') return `${String(carry.carry.merged)}${MERGED_SUFFIX}`
-	if (carry.kind === 'expired') return CARRY_SUMMARY_EXPIRED
 	if (carry.kind === 'unreadable') return CARRY_SUMMARY_UNREADABLE
 
 	return CARRY_SUMMARY_NONE
 }
 
 function carry_detail(carry: CarryRead): string {
-	if (carry.kind === 'carried' || carry.kind === 'expired') {
-		return run_carry.describe_carry(carry.carry)
-	}
+	if (carry.kind === 'carried') return run_carry.describe_carry(carry.carry)
 
 	if (carry.kind === 'unreadable') return CARRY_UNREADABLE_NOTE
 

package/scripts/run/run-step.ts

@@ -46,11 +46,6 @@ const VOCABULARY: ReadonlyArray<string> = [
 	UNKNOWN,
 ]
 
-// The whole-run bound is spent, and carrying the budget or discarding it is a person's call — the one
-// Tier-B point this machine surfaces rather than choosing.
-const EXPIRED_DECISION =
-	'decide: whole-run budget spent — resume with `pnpm josh run:carry --resume` | discard with `pnpm josh run:carry --end`'
-
 // The one step a stopped run still owes before it ends: the end-of-run retrospective.
 // It reads the run's own measurements and files the improvements worth carrying into the next run;
 // the command is kit-only, so it means nothing — and is never printed — in a consumer project.
@@ -288,12 +283,11 @@ function is_handed_off_parent(input: CarryFacts): boolean {
 	return input.is_handed_off && input.carry_kind === 'carried' && !input.is_lane_child
 }
 
-// The carry record's terminal answers: an unreadable record leaves the position unknowable, a handed-off
-// run is its successor's, and a spent budget is the person's call.
+// The carry record's terminal answers: an unreadable record leaves the position unknowable, and a
+// handed-off run is its successor's.
 function carry_terminal_action(input: CarryFacts): StepAction | undefined {
 	if (input.carry_kind === 'unreadable') return verdict(UNKNOWN)
 	if (is_handed_off_parent(input)) return verdict(STOP)
-	if (input.carry_kind === 'expired') return { kind: 'decide', line: EXPIRED_DECISION }
 
 	return undefined
 }
@@ -371,7 +365,6 @@ function next_action(input: StepInput): StepAction {
 
 const run_step = {
 	ALREADY_DONE,
-	EXPIRED_DECISION,
 	HAND_OFF_COMMAND,
 	HUMAN_REVIEW,
 	IMPLEMENT,

package/scripts/run/run-stop-notify.ts

@@ -28,7 +28,7 @@ const STOP_RECOVERY =
 // nothing readable there is no run this can honestly say stopped.
 function plan(read: CarryRead, reason: string | undefined): StopNotice | undefined {
 	if (reason === undefined || reason.length === 0) return undefined
-	if (read.kind !== 'carried' && read.kind !== 'expired') return undefined
+	if (read.kind !== 'carried') return undefined
 
 	return { reason }
 }

package/scripts/run/run-stranded-detect.ts

@@ -1,5 +1,6 @@
 import { telegram_notify } from '#scripts/notify/telegram-notify'
 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_event_stream } from '#scripts/run/event/run-event-stream'
 import { run_event_stream_emit } from '#scripts/run/event/run-event-stream-emit'
 import { run_wake, type RunWake } from '#scripts/run/wake/run-wake'
@@ -18,7 +19,7 @@ import {
 //
 // **Cheap and local.** Every read is a file on disk — the carry record, the wake record — and a process
 // liveness probe; there is no network call, so unlike the stall detector this makes every read every
-// time. The gate is the carry record itself: nothing carried, or a record that is expired or unreadable,
+// time. The gate is the carry record itself: nothing carried, or a record that is unreadable,
 // returns before the wake record is even read.
 
 // The recovery line names the command that hands the run to a fresh supervisor — the same one the pure
@@ -27,13 +28,14 @@ import {
 // so recovery is another actor's.
 const STRAND_RECOVERY = `Restart supervision with \`${run_stranded.RECOVERY_COMMAND}\` — it wakes a fresh successor to claim the budget; the cutting session must not resume it itself.`
 
-// The seams a test replaces: the two record targets, the two record reads, the owner and supervisor
-// liveness probes, and the two side effects. The defaults are the real readers; a test hands fakes so
+// The seams a test replaces: the two record targets, the two record reads, the ended-run read, the owner
+// and supervisor liveness probes, and the two side effects. The defaults are the real readers; a test hands fakes so
 // the gather and report logic run without a git tree, a process table or a network.
 interface DetectPorts {
 	resolve_targets: () => Promise<RecordTargets | undefined>
 	read_carry: (target: string) => CarryRead
 	is_owner_live: (carry: RunCarry) => boolean
+	has_ended: (target: string, started_at: string) => boolean
 	read_wake: (target: string) => RunWake | undefined
 	supervisor_liveness: (wake: RunWake | undefined) => SupervisorLiveness
 	emit_stranded: (text: string) => Promise<boolean>
@@ -45,15 +47,25 @@ interface RecordTargets {
 	wake: string
 }
 
+// The run a supervisor was watching: its carry record, where `run:carry --end` records the run it
+// removes, and the `started_at` the supervisor read when it took the run on.
+interface WatchedRun {
+	carry_target: string
+	ended_target: string
+	started_at: string
+}
+
+function targets_of(directory: string): RecordTargets {
+	return { carry: run_carry.carry_path(directory), wake: run_wake.wake_path(directory) }
+}
+
 // Both records key on the common git directory, the same one `run-carry.ts` and `run-wake.ts` resolve,
 // so a strand read from any lane reads the one run's records. `undefined` outside a repository: no git
 // directory to key on, so no run to be stranded.
 async function real_resolve_targets(): Promise<RecordTargets | undefined> {
 	const directory = await run_carry.repository_directory()
 
-	if (directory === undefined) return undefined
-
-	return { carry: run_carry.carry_path(directory), wake: run_wake.wake_path(directory) }
+	return directory === undefined ? undefined : targets_of(directory)
 }
 
 async function real_emit_stranded(text: string): Promise<boolean> {
@@ -68,20 +80,17 @@ const DEFAULT_PORTS: DetectPorts = {
 	resolve_targets: real_resolve_targets,
 	read_carry: (target) => run_carry.read_carry(target),
 	is_owner_live: run_carry.is_owner_live,
+	has_ended: run_carry_ended.has_ended,
 	read_wake: (target) => run_wake.read_wake(target),
 	supervisor_liveness: (wake) => run_stranded.supervisor_liveness(wake),
 	emit_stranded: real_emit_stranded,
 	notify_stranded: real_notify_stranded,
 }
 
-// The three facts, assembled behind the carry-record gate. A non-`carried` read — nothing carried, a
-// spent bound, or an unreadable record — is `undefined`: there is no live budget to be stranded, so the
+// The three facts, assembled behind the carry-record gate. A non-`carried` read — nothing carried, or
+// an unreadable record — is `undefined`: there is no live budget to be stranded, so the
 // wake record is never read and the judge is never asked.
-async function gather(ports: DetectPorts): Promise<StrandedInput | undefined> {
-	const targets = await ports.resolve_targets()
-
-	if (targets === undefined) return undefined
-
+function input_at(ports: DetectPorts, targets: RecordTargets): StrandedInput | undefined {
 	const read = ports.read_carry(targets.carry)
 
 	if (read.kind !== 'carried') return undefined
@@ -93,6 +102,12 @@ async function gather(ports: DetectPorts): Promise<StrandedInput | undefined> {
 	}
 }
 
+async function gather(ports: DetectPorts): Promise<StrandedInput | undefined> {
+	const targets = await ports.resolve_targets()
+
+	return targets === undefined ? undefined : input_at(ports, targets)
+}
+
 // The marker and the notification, both once per strand episode. `emit_stranded` refuses a second while
 // the strand event is still the newest, and its `false` is what holds the notification back too — so a
 // strand polled every stop reaches the person once, not once a turn.
@@ -128,7 +143,38 @@ async function run_stranded_check(): Promise<void> {
 	}
 }
 
-const run_stranded_detect = { detect_and_report, run_stranded_check }
+// The same judgement for a reader that draws the run rather than reports on it: `run:board` asks it
+// every local read, so a run nobody is driving is not drawn as one still waiting for work.
+function is_stranded_at(directory: string, ports: DetectPorts = DEFAULT_PORTS): boolean {
+	const input = input_at(ports, targets_of(directory))
+
+	return input !== undefined && run_stranded.is_stranded(input)
+}
+
+// The judgement a supervisor asks of the run it is about to stop watching. The asker is that
+// supervisor on its way out, so it is taken as gone, and so is an owner that is the asker itself
+// (`run_carry.is_held_by_another`) — that owner is about to be gone. A
+// record another session holds is not left stranded. **A record that does not read is left stranded
+// unless `run:carry --end` ended this very run**: the read that failed the driver fails here too, and
+// that run still has its budget and nobody watching it.
+function is_left_stranded(run: WatchedRun, ports: DetectPorts = DEFAULT_PORTS): boolean {
+	const read = ports.read_carry(run.carry_target)
+
+	if (read.kind !== 'carried') return !ports.has_ended(run.ended_target, run.started_at)
+
+	return run_stranded.is_stranded({
+		read,
+		is_owner_live: run_carry.is_held_by_another(read.carry, ports.is_owner_live),
+		supervisor: run_stranded.GONE,
+	})
+}
+
+const run_stranded_detect = {
+	detect_and_report,
+	is_left_stranded,
+	is_stranded_at,
+	run_stranded_check,
+}
 
 export { run_stranded_detect }
-export type { DetectPorts, RecordTargets }
+export type { DetectPorts, RecordTargets, WatchedRun }

package/scripts/run/run-stranded.ts

@@ -2,10 +2,10 @@ import { process_identity } from '#scripts/josh/process-identity'
 import { run_carry, type CarryRead, type RunCarry } from '#scripts/run/carry/run-carry'
 import type { RunWake } from '#scripts/run/wake/run-wake'
 
-// The mechanical judge of a *stranded* run: a handed-off budget whose cutting session died, with no
-// successor claiming it and no supervisor watching, so lanes run on with nobody driving. Three facts,
-// read and never weighed, are what say that state has been reached: the budget was handed off, its
-// owner is gone, and no supervisor is alive to wake a successor.
+// The mechanical judge of a *stranded* run: a budget whose owning session died — at a cut it handed
+// off, or with no hand-off at all — with no successor holding it and no supervisor watching, so lanes
+// run on with nobody driving. Three facts, read and never weighed, are what say that state has been
+// reached: the record names a driver, that owner is gone, and no supervisor is alive to wake a successor.
 //
 // **Pure by design, exactly as `backlog-stalled.ts` is.** The carry read, the owner's liveness and the
 // supervisor's are handed in, so the four acceptance cases — all three holding, a live owner, a claimed
@@ -72,19 +72,27 @@ function supervisor_liveness(
 	return is_same ? LIVE : GONE
 }
 
-// **The whole of the judgement, in four reads.** The carry record must be `carried` — an `expired`,
-// `none` or `unreadable` read is never a strand, because there is either no budget to strand or no way
-// to trust what the record says. It must be handed off and *not* yet adopted — `adopt_carry` spends
-// `is_handed_off` the instant a successor claims it, so a claimed successor reads `false` here. The owner
-// must be gone — a live owner is a session still spending the budget, the ordinary in-flight state. And
-// the supervisor must be `gone` — `live` or `unknown` both count as something that could still wake a
-// successor, so only a proven-absent supervisor completes the strand.
+// Whether the record names a driver whose absence can be proven: a hand-off waiting for its successor,
+// or an owner process. A record with neither was begun by nobody this machine can probe, and an
+// unprovable owner is never a strand.
+function had_driver(carry: RunCarry): boolean {
+	return carry.is_handed_off === true || carry.owner_pid !== undefined
+}
+
+// **The whole of the judgement, in four reads.** The carry record must be `carried` — a `none` or
+// `unreadable` read is never a strand, because there is either no run to strand or no way to trust
+// what the record says. The owner must be gone — a live owner is a session still spending the budget,
+// the ordinary in-flight state, and a successor that claimed a hand-off is that live owner, since
+// `adopt_carry` rewrites the owner as it spends `is_handed_off`. The record must name the driver that
+// is gone (`had_driver`). And the supervisor must be `gone` — `live` or `unknown` both count as
+// something that could still wake a successor, so only a proven-absent supervisor completes the strand.
+//
+// **A hand-off is not required.** An owner that died between its claim and the next cut — the
+// supervisor killed mid-drive, an interactive parent's terminal closed — leaves a record no cut handed
+// off, and with no supervisor nothing drives it either. `run-wake.ts` → `decide_not_handed_off`
+// recovers exactly that record, so the recovery the notification names holds for it too.
 function is_stranded(input: StrandedInput): boolean {
-	if (
-		input.read.kind !== 'carried' ||
-		input.read.carry.is_handed_off !== true ||
-		input.is_owner_live
-	) {
+	if (input.read.kind !== 'carried' || input.is_owner_live || !had_driver(input.read.carry)) {
 		return false
 	}
 
@@ -94,7 +102,7 @@ function is_stranded(input: StrandedInput): boolean {
 // The one line a person reads in the notification and on the stream: which run is stranded, and why. The
 // carry record's own summary carries the counts; this frames it as the strand it is.
 function describe(carry: RunCarry): string {
-	return `Run stranded — ${run_carry.describe_carry(carry)}. The owner is gone, no cut successor claimed the budget, and no supervisor is watching.`
+	return `Run stranded — ${run_carry.describe_carry(carry)}. The owner is gone, no successor holds the budget, and no supervisor is watching.`
 }
 
 function verdict_of(is_run_stranded: boolean): StrandedVerdict {