@joshuafolkken/kit 1.1379.0 → 1.1387.0

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

@@ -1,3 +1,4 @@
+import type { PendingLaunch } from '#scripts/backlog/backlogrun-launch'
 import type { CarryRead } from '#scripts/run/carry/run-carry'
 import type { EndedRun } from '#scripts/run/carry/run-carry-ended'
 import { run_event_scope } from '#scripts/run/event/run-event-scope'
@@ -27,10 +28,40 @@ function ended_span(ended: EndedRun | undefined): BoardSpan | undefined {
 	return { invocation: ended.invocation, started_ms, ended_ms }
 }
 
+// A run `josh backlogrun` launched and its parent has not claimed yet: it has no carry record, so the
+// launch record is the only one that says a run is here and since when.
+function launch_span(launch: PendingLaunch | undefined): BoardSpan | undefined {
+	const started_ms = launch === undefined ? undefined : moment_of(launch.started_at)
+
+	if (launch === undefined || started_ms === undefined) return undefined
+
+	return { invocation: launch.invocation, started_ms, ended_ms: undefined }
+}
+
+// With no carry record: the run on its way, else the one that last ended. **A launch older than that
+// end is the ended run's own** — its parent outlives `run:carry --end` for a moment — so it never
+// redraws a finished run as one starting.
+function idle_span(
+	ended: EndedRun | undefined,
+	launch: PendingLaunch | undefined,
+): BoardSpan | undefined {
+	const last = ended_span(ended)
+	const coming = launch_span(launch)
+
+	if (coming === undefined) return last
+
+	return (last?.ended_ms ?? 0) >= coming.started_ms ? last : coming
+}
+
 // The running run wins over the ended one, so a run that begins replaces the finished board at once.
-// An expired carry is still the running run's budget spent, not a run that ended, so it draws nothing.
-function span_of(read: CarryRead, ended: EndedRun | undefined): BoardSpan | undefined {
-	if (read.kind !== 'carried') return read.kind === 'none' ? ended_span(ended) : undefined
+// **The launch's start is the carry's**: `run:carry --begin` inherits it for the parent the launch
+// started, so the clock does not restart when the record appears.
+function span_of(
+	read: CarryRead,
+	ended: EndedRun | undefined,
+	launch?: PendingLaunch,
+): BoardSpan | undefined {
+	if (read.kind !== 'carried') return read.kind === 'none' ? idle_span(ended, launch) : undefined
 
 	const started_ms = moment_of(read.carry.started_at)
 
@@ -39,12 +70,22 @@ function span_of(read: CarryRead, ended: EndedRun | undefined): BoardSpan | unde
 	return { invocation: read.carry.invocation, started_ms, ended_ms: undefined }
 }
 
-// The session a person resumes a stopped run from: only while the ended run is
-// the one drawn, and only when it stopped rather than finished. A run that begins hides it at once.
-function resume_of(read: CarryRead, ended: EndedRun | undefined): string | undefined {
-	if (read.kind !== 'none' || ended?.stopped === undefined) return undefined
+// Whether the span drawn with no carry record is the ended run's, rather than a launch's.
+function is_ended_drawn(ended: EndedRun | undefined, launch: PendingLaunch | undefined): boolean {
+	return idle_span(ended, launch)?.ended_ms !== undefined
+}
 
-	return ended.session
+// The session a person resumes a stopped run from: only while the ended run is
+// the one drawn, and only when it stopped rather than finished. A run that begins — or is on its way —
+// hides it at once.
+function resume_of(
+	read: CarryRead,
+	ended: EndedRun | undefined,
+	launch?: PendingLaunch,
+): string | undefined {
+	if (read.kind !== 'none' || !is_ended_drawn(ended, launch)) return undefined
+
+	return ended?.stopped === undefined ? undefined : ended.session
 }
 
 function is_within(event: RunEvent, span: BoardSpan): boolean {

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

@@ -1,4 +1,3 @@
-import { backlog_idle, type IdleWindow } from '#scripts/backlog/backlog-idle'
 import {
 	has_label_name,
 	IN_PROGRESS_LABEL,
@@ -8,6 +7,7 @@ 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 type { ClosedIssue } from './run-board-closed'
 import { run_board_phase, type Phase } from './run-board-phase'
+import { run_board_setup, type SetupRead } from './run-board-setup'
 
 // What each issue of a run is doing now, read from the run's own event stream and its open lanes.
 // Local reads only — no `gh` call — so `run:board` can redraw it every few seconds; the plan these
@@ -27,11 +27,10 @@ interface ItemStatus {
 	track?: ReadonlyArray<Phase> | undefined
 }
 
-// The run as a whole, read off the same stream.
-interface RunActivity {
+// 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> {
 	last_event_ms: number | undefined
-	// The idle watch's window, when the newest one opened after the newest launch.
-	idle: IdleWindow | undefined
 	// The run's last position is a `stop` that names no child — the run itself ended.
 	is_stopped: boolean
 }
@@ -128,16 +127,17 @@ function fold_events(events: ReadonlyArray<RunEvent>): Map<number, ItemStatus> {
 function is_running_lane(
 	issue: number,
 	status: ItemStatus | undefined,
+	events: ReadonlyArray<RunEvent>,
 	in_run: ReadonlySet<number>,
 ): boolean {
-	if (status === undefined) return in_run.has(issue)
+	if (status !== undefined) return status.state === 'running'
 
-	return status.state === 'running'
+	return in_run.has(issue) && !run_board_setup.is_lane_pending(events, issue)
 }
 
 // Every child the run has touched, with the lane each running child holds. A lane the stream never saw
 // launched — a run restored after the stream rolled — still reads as running while its issue is in the
-// run's plan (`in_run`).
+// run's plan (`in_run`); one the run is still setting up for stays waiting until its launch.
 function statuses_of(
 	events: ReadonlyArray<RunEvent>,
 	lanes: ReadonlyArray<string>,
@@ -149,7 +149,7 @@ function statuses_of(
 		const issue = Number(lane)
 		const status = statuses.get(issue)
 
-		if (is_running_lane(issue, status, in_run)) {
+		if (is_running_lane(issue, status, events, in_run)) {
 			statuses.set(issue, { state: 'running', ...status, lane: `lane ${lane}` })
 		}
 	}
@@ -243,19 +243,6 @@ function settle_closed(
 	return new Map([...statuses].map(([issue, status]) => [issue, settled(issue, status, read)]))
 }
 
-function newest_of(events: ReadonlyArray<RunEvent>, kind: string): RunEvent | undefined {
-	return events.findLast((event) => event.kind === kind)
-}
-
-function idle_of(events: ReadonlyArray<RunEvent>): IdleWindow | undefined {
-	const idle = newest_of(events, KIND.IDLE)
-	const launch = newest_of(events, KIND.CHILD_LAUNCH)
-
-	if (idle === undefined || (launch !== undefined && launch.pos > idle.pos)) return undefined
-
-	return backlog_idle.parse(idle.text)
-}
-
 function is_run_stop(event: RunEvent | undefined): boolean {
 	return event?.kind === KIND.STOP && run_event_scope.issue_named(event) === undefined
 }
@@ -267,8 +254,8 @@ function activity_of(events: ReadonlyArray<RunEvent>, is_ended = false): RunActi
 	const position = events.findLast((event) => !run_event_stream.TRACE_KINDS.has(event.kind))
 
 	return {
+		...run_board_setup.read(events),
 		last_event_ms: last === undefined ? undefined : moment(last),
-		idle: idle_of(events),
 		is_stopped: is_ended || is_run_stop(position),
 	}
 }

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

@@ -11,7 +11,7 @@ import type { LocalRead } from './run-board-read'
 import { run_board_render, type FrameBounds } from './run-board-render'
 import { run_board_spin, type Spun } from './run-board-spin'
 import { run_board_state, type BoardPorts, type BoardState, type Pace } from './run-board-state'
-import { run_board_status } from './run-board-status'
+import { run_board_status, type RunActivity } from './run-board-status'
 import { run_board_usage } from './run-board-usage'
 
 // One `run:board` redraw. **Three speeds**: the frame is redrawn once a second, on the second, so
@@ -116,6 +116,14 @@ interface Redraw {
 	now_ms: number
 }
 
+// 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(
+		local.events,
+		local.ended_ms !== undefined || local.is_stranded,
+	)
+}
+
 function header_of(
 	state: BoardState,
 	local: LocalRead,
@@ -126,7 +134,7 @@ function header_of(
 		now_ms: redraw.now_ms,
 		started_ms: local.started_ms,
 		ended_ms: local.ended_ms,
-		activity: run_board_status.activity_of(local.events, local.ended_ms !== undefined),
+		activity: activity_here(local),
 		layout,
 		baseline_total: state.baseline_total,
 		plan_fetched_ms: state.fetched_ms,
@@ -135,6 +143,7 @@ function header_of(
 		machine: state.gauges,
 		usages: state.usages,
 		form: redraw.ports.form,
+		repo: state.plan?.context.repo,
 		spinner: redraw.ports.is_tty ? SPOT : undefined,
 		link: run_board_link.linker(state.plan?.context.repo, redraw.ports.link),
 	}

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

@@ -51,7 +51,7 @@ function add_issues(
 ): RunCarry {
 	const next: RunCarry = { ...carry, added: next_added(carry, additions) }
 
-	stamp_file.write_stamp(target, next)
+	stamp_file.replace_stamp(target, next)
 
 	return next
 }

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

@@ -83,7 +83,7 @@ function apply_change(
 		retrospective: effective.retrospective === true || carry.retrospective,
 	}
 
-	stamp_file.write_stamp(target, next)
+	stamp_file.replace_stamp(target, next)
 
 	return next
 }

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

@@ -1,7 +1,9 @@
 #!/usr/bin/env tsx
 import { fileURLToPath } from 'node:url'
+import { backlogrun_launch } from '#scripts/backlog/backlogrun-launch'
 import { cost_cli } from '#scripts/cost-runtime/cost-cli'
 import { cost_verdict } from '#scripts/cost-runtime/cost-verdict'
+import { run_event_setup } from '#scripts/run/event/run-event-setup'
 import { run_event_stream } from '#scripts/run/event/run-event-stream'
 import { run_event_stream_emit } from '#scripts/run/event/run-event-stream-emit'
 import { run_merge_collect } from '#scripts/run/merge/run-merge-collect'
@@ -39,7 +41,6 @@ const RESUMED_VERDICT = 'resumed'
 const CARRIED_VERDICT = 'carried'
 const COUNTED_VERDICT = 'counted'
 const ENDED_VERDICT = 'ended'
-const EXPIRED_VERDICT = 'expired'
 const NONE_VERDICT = 'none'
 const UNREADABLE_VERDICT = 'unreadable'
 const MISMATCH_VERDICT = 'mismatch'
@@ -94,28 +95,14 @@ function report_unreadable(is_json: boolean): number {
 	return report(UNREADABLE_VERDICT, undefined, is_json, FAILURE_EXIT_CODE)
 }
 
-function report_expired(carry: RunCarry, is_json: boolean): number {
-	console.error(run_carry.expired_message(carry))
-
-	return report_carry(EXPIRED_VERDICT, carry, is_json)
-}
-
 function report_read(read: CarryRead, is_json: boolean): number {
 	if (read.kind === 'none') return report(NONE_VERDICT, undefined, is_json, SUCCESS_EXIT_CODE)
 
 	if (read.kind === 'unreadable') return report_unreadable(is_json)
 
-	if (read.kind === 'expired') return report_expired(read.carry, is_json)
-
 	return report_carry(CARRIED_VERDICT, read.carry, is_json)
 }
 
-function report_busy(carry: RunCarry, is_json: boolean): number {
-	console.error(run_carry.busy_message(carry))
-
-	return report(BUSY_VERDICT, carry, is_json, FAILURE_EXIT_CODE)
-}
-
 function refusal_message(claim: CarryClaim, carry: RunCarry, invocation: string): string {
 	if (claim === 'busy') return run_carry.busy_message(carry)
 
@@ -149,7 +136,7 @@ function report_adoption(
 
 // **Whose record it is, is the classifier's answer and not this command's guess.** `--end` is only
 // reached on the clean-finish path, so a run that crashed or stopped on a guard leaves its record
-// standing for up to the whole-run bound; `resumed` is reached only where the run itself declared the
+// standing until a person carries or discards it; `resumed` is reached only where the run itself declared the
 // cut, or where `--resume` says the reader has decided to carry it.
 function report_claim(
 	target: string,
@@ -166,59 +153,47 @@ function report_claim(
 	return report(CLAIM_VERDICTS[claim], carry, is_json, FAILURE_EXIT_CODE)
 }
 
-function start_fresh(
-	target: string,
-	request: CarryClaimRequest,
-	is_replacement: boolean,
-	is_json: boolean,
-): number {
-	const carry = is_replacement
-		? run_carry.replace_carry(target, request.invocation, request.owner)
-		: run_carry.begin_carry(target, request.invocation, request.owner)
+// When the run began: the moment `josh backlogrun` launched this owner, so the clock `run:board` was
+// already counting from does not restart at the claim; `undefined` — now — for every other run.
+async function launch_start(request: CarryClaimRequest): Promise<Date | undefined> {
+	const directory = await run_carry.repository_directory()
 
-	if (carry === undefined) return report_lost(is_json)
+	if (directory === undefined) return undefined
 
-	return report_carry(BEGAN_VERDICT, carry, is_json)
+	return backlogrun_launch.started_for(directory, request.owner.pid)
 }
 
-// **The bound ends *that* run, so a spent record whose owner is still running is not replaced
-// either.** Replacing it would delete a live parent's budget and answer `began` — two parents on one
-// record. Only that run, or a person who knows it is over, ends it.
-function begin_over_expired(
+// A run that began is planning, which is what its board says until the supervisor takes it over.
+async function start_fresh(
 	target: string,
-	carry: RunCarry,
 	request: CarryClaimRequest,
 	is_json: boolean,
-): number {
-	if (run_carry.is_foreign_live_owner(carry, request.owner)) return report_busy(carry, is_json)
+): Promise<number> {
+	const started = await launch_start(request)
+	const carry = run_carry.begin_carry(target, request.invocation, request.owner, started)
 
-	// **A hand-off says the resumption *is* that run, so the spent bound is this session's too.**
-	// Replaced here, the record would come back with `started_at` set to now — and `backlog:budget
-	// --started` reads that field, so the 8-hour bound would restart at every cut and never end the
-	// run. The answer is `expired`, and a person who really is starting a new run clears the record
-	// with `--end`, which is what the expiry message says.
-	if (carry.is_handed_off === true) return report_expired(carry, is_json)
+	if (carry === undefined) return report_lost(is_json)
 
-	console.error(run_carry.expired_message(carry))
+	await run_event_setup.emit(run_event_setup.STAGE.PLANNING)
 
-	return start_fresh(target, request, true, is_json)
+	return report_carry(BEGAN_VERDICT, carry, is_json)
 }
 
-// **A live record is never replaced, and never resumed into by something else.** Replacing one would
-// restart the budget the cut exists to carry, and resuming into one would put two parents on a single
-// budget. An expired one is replaced,
-// because its run has spent the whole-run bound and a person typing the keyword again is starting a
-// new run — unless its owner is still running, which is the case above.
-function begin(target: string, request: CarryClaimRequest, is_json: boolean): number {
+// **A standing record is never replaced, and never resumed into by something else.** Replacing one
+// would restart the budget the cut exists to carry, and resuming into one would put two parents on a
+// single budget. Its age changes none of that: a record is replaced by nothing but a person's `--end`.
+async function begin(
+	target: string,
+	request: CarryClaimRequest,
+	is_json: boolean,
+): Promise<number> {
 	const read = run_carry.read_carry(target)
 
 	if (read.kind === 'unreadable') return report_unreadable(is_json)
 
 	if (read.kind === 'carried') return report_claim(target, read.carry, request, is_json)
 
-	if (read.kind === 'expired') return begin_over_expired(target, read.carry, request, is_json)
-
-	return start_fresh(target, request, false, is_json)
+	return await start_fresh(target, request, is_json)
 }
 
 function report_nothing_to_resume(is_json: boolean): number {
@@ -237,8 +212,6 @@ function adopt(target: string, request: CarryClaimRequest, is_json: boolean): nu
 
 	if (read.kind === 'unreadable') return report_unreadable(is_json)
 
-	if (read.kind === 'expired') return report_expired(read.carry, is_json)
-
 	return report_claim(target, read.carry, request, is_json)
 }
 
@@ -254,10 +227,16 @@ function report_over(is_json: boolean): number {
 	return report(OVER_VERDICT, undefined, is_json, FAILURE_EXIT_CODE)
 }
 
-function claim_record(target: string, request: CarryClaimRequest, is_json: boolean): number {
+async function claim_record(
+	target: string,
+	request: CarryClaimRequest,
+	is_json: boolean,
+): Promise<number> {
 	if (cost_cli.session_verdict() === cost_verdict.OVER_VERDICT) return report_over(is_json)
 
-	return request.is_adoption ? adopt(target, request, is_json) : begin(target, request, is_json)
+	if (request.is_adoption) return adopt(target, request, is_json)
+
+	return await begin(target, request, is_json)
 }
 
 // The record is no longer this session's to advance — handed off at a cut, or taken over by a live
@@ -334,9 +313,7 @@ async function count(
 
 	await record_retrospective(request)
 
-	return read.kind === 'expired'
-		? report_expired(carry, is_json)
-		: report_carry(COUNTED_VERDICT, carry, is_json)
+	return report_carry(COUNTED_VERDICT, carry, is_json)
 }
 
 // **A stop over a record that is still there pushes one ⏸️ confirmation before the record goes**.
@@ -400,7 +377,7 @@ async function act(
 	request: Exclude<Request, { kind: 'end' }>,
 	is_json: boolean,
 ): Promise<number> {
-	if (request.kind === 'claim') return claim_record(target, request.claim, is_json)
+	if (request.kind === 'claim') return await claim_record(target, request.claim, is_json)
 
 	const read = run_carry.read_carry(target)
 
@@ -463,7 +440,6 @@ const run_carry_cli = {
 	CARRIED_VERDICT,
 	COUNTED_VERDICT,
 	ENDED_VERDICT,
-	EXPIRED_VERDICT,
 	MISMATCH_VERDICT,
 	NONE_VERDICT,
 	OVER_VERDICT,

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

@@ -55,7 +55,7 @@ function record_ended(
 	now: Date = new Date(),
 	stopped?: string,
 ): void {
-	if (read.kind !== 'carried' && read.kind !== 'expired') return
+	if (read.kind !== 'carried') return
 
 	const { invocation, started_at, owner_transcript } = read.carry
 	const ended_at = now.toISOString()
@@ -79,7 +79,15 @@ function read_ended(target: string): EndedRun | undefined {
 	return raw === undefined ? undefined : parse_ended(raw)
 }
 
-const run_carry_ended = { ended_path, read_ended, record_ended }
+// Whether the run that began at `started_at` is the one `--end` last ended — what tells a record that is
+// gone because its run ended from one that only failed to read.
+function has_ended(target: string, started_at: string | undefined): boolean {
+	const ended = read_ended(target)
+
+	return ended !== undefined && ended.started_at === started_at
+}
+
+const run_carry_ended = { ended_path, has_ended, read_ended, record_ended }
 
 export { run_carry_ended }
 export type { EndedRun }

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

@@ -1,8 +1,6 @@
-import { backlog_budget } from '#scripts/backlog/backlog-budget'
 import { git_command } from '#scripts/git/git-command'
 import { process_identity } from '#scripts/josh/process-identity'
 import { stamp_file } from '#scripts/josh/stamp-file'
-import { stamp_record, type StampRecordSpec } from '#scripts/josh/stamp-record'
 import { json_value } from '#scripts/lib/json-value'
 import { run_invocation } from '#scripts/run/run-invocation'
 import { z } from 'zod'
@@ -10,7 +8,7 @@ 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'
 
-// A `backlogrun` declares a budget — `--max`, `--idle` and the 8-hour whole-run bound — and the 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
 // the same authorization**, so the budget has to survive it: this record carries it across sessions,
 // where there is no epic to read progress back off when the run began from the backlog.
@@ -20,9 +18,10 @@ import { run_carry_conversation } from './run-carry-conversation'
 // one *invocation's* budget, and that invocation opens lanes — each a work tree of its own — so the
 // key is the common git directory, which every lane of one repository shares.
 //
-// **The 8-hour bound is the record's expiry.** Held as an age rather than as prose, the bound is
-// decided the same way `backlog:budget` decides the other two: the command answers, and the run
-// obeys. A run that reads `expired` has spent the bound whatever any count says.
+// **The record has no expiry of its own.** A run is bounded by its idle wait, which `backlog:budget`
+// counts from when the run last had work; an age counted from `started_at` would end a run that is
+// still working or still inside that wait. So a record a run never ended — a crash — stays `standing`
+// until a person carries it with `--resume` or discards it with `--end`.
 //
 // **Whose record it is, is decided by liveness and by a declared hand-off — never by the invocation
 // text**. Comparing the `invocation` string alone walks straight through the case that happens most: a
@@ -38,21 +37,14 @@ import { run_carry_conversation } from './run-carry-conversation'
 
 const CARRY_PREFIX = 'josh-run-carry-'
 const REPOSITORY_DIRECTORY_INDEX = 1
-// **The whole-run bound is `backlog-budget.ts`'s, imported rather than restated.** `backlogrun.md` →
-// "Waiting, and never waiting forever" states the figure and that module applies it; a second copy
-// here would drift, and the drift is silent in exactly the direction that matters — raised there and
-// still 8 here, this record answers `expired`, `--begin` replaces it, and the budget restarts at
-// zero — the loss this record exists to prevent.
-const CARRY_MAX_AGE_HOURS = backlog_budget.WHOLE_RUN_BUDGET_HOURS
-const CARRY_MAX_AGE_MS = backlog_budget.WHOLE_RUN_BUDGET_MS
 const NO_INCREMENT = 0
 
 // The most session cuts one invocation may take. This bounds `cuts`, which
 // only `run:carry --cut` increments — a `backlogrun`'s session hand-off at a child's merge (~one per
-// 50 minutes over the 8-hour whole-run budget), not the `run:cut` phase cuts a lane child takes. Each
+// 50 minutes of work), not the `run:cut` phase cuts a lane child takes. Each
 // cut drops the context it accumulated but pays a cold preamble to resume, so past a point the
-// re-establishment costs more than the accumulation it sheds; six sits well under the ~10 an 8-hour run
-// could otherwise take and refuses a run that has begun to churn. `is_at_cut_cap` reads it, and the
+// re-establishment costs more than the accumulation it sheds; six sits well under the ~10 a night of
+// work could otherwise take and refuses a run that has begun to churn. `is_at_cut_cap` reads it, and the
 // `--cut` count is refused at it rather than incrementing past it — except a headless judgment
 // session's hand-back to the driver, which `run_headless.is_cut_capped` exempts.
 const MAX_CUTS = 6
@@ -185,11 +177,7 @@ interface CarryChange {
 	retrospective?: boolean
 }
 
-type CarryRead =
-	| { kind: 'none' }
-	| { kind: 'carried'; carry: RunCarry }
-	| { kind: 'expired'; carry: RunCarry }
-	| { kind: 'unreadable' }
+type CarryRead = { kind: 'none' } | { kind: 'carried'; carry: RunCarry } | { kind: 'unreadable' }
 
 const NO_OWNER: CarryOwner = {}
 
@@ -234,32 +222,23 @@ function parse_carry(raw: string): RunCarry | undefined {
 	return json_value.parse_with(raw, run_carry_schema)
 }
 
-function started_at_of(carry: RunCarry): string {
-	return carry.started_at
-}
-
-// The expiry and the classification are `stamp-record.ts`'s, shared with `run-cut.ts` and
-// `run-hold.ts`; what a `started_at` that is not a date means is decided there.
-const CARRY_SPEC: StampRecordSpec<RunCarry> = {
-	parse: parse_carry,
-	timestamp_of: started_at_of,
-	max_age_ms: CARRY_MAX_AGE_MS,
-}
+// **A record that cannot be read is `unreadable`, never `none`** — absent is none; present and
+// unparseable is the state a guard must not fall open on. A `started_at` that is not a date is the
+// same state: it passes the schema as a string, and every reader of the record measures from it.
+function classify(raw: string | undefined): CarryRead {
+	if (raw === undefined) return { kind: 'none' }
 
-function is_expired(carry: RunCarry, now: Date): boolean {
-	return stamp_record.is_older_than(started_at_of(carry), CARRY_MAX_AGE_MS, now)
-}
-
-function classify(raw: string | undefined, now: Date): CarryRead {
-	const read = stamp_record.classify(raw, CARRY_SPEC, now)
+	const carry = parse_carry(raw)
 
-	if (!('record' in read)) return read
+	if (carry === undefined || Number.isNaN(Date.parse(carry.started_at))) {
+		return { kind: 'unreadable' }
+	}
 
-	return { kind: read.kind, carry: read.record }
+	return { kind: 'carried', carry }
 }
 
-function read_carry(target: string, now: Date = new Date()): CarryRead {
-	return classify(stamp_file.read_stamp_text(target), now)
+function read_carry(target: string): CarryRead {
+	return classify(stamp_file.read_stamp_text(target))
 }
 
 // The identity to record for a pid the caller declared. `read_start` is what makes the pair an
@@ -304,20 +283,6 @@ function begin_carry(
 	return stamp_file.create_stamp(target, carry) ? carry : undefined
 }
 
-// Replacing a record whose bound is spent. It removes and then creates exclusively rather than
-// writing over the old bytes, for the reason `run-hold.ts` replaces a stale hold the same way: a
-// plain write would put the race back one branch over.
-function replace_carry(
-	target: string,
-	invocation: string,
-	owner: CarryOwner = NO_OWNER,
-	now: Date = new Date(),
-): RunCarry | undefined {
-	stamp_file.remove_stamp(target)
-
-	return begin_carry(target, invocation, owner, now)
-}
-
 // Taking over a standing record: the counters and `started_at` are the run's and stay, the owner
 // becomes this session, and the hand-off is spent. **`cuts` is not incremented here** — `--cut`
 // counts the cut, and a record adopted after a crash crossed no cut at all.
@@ -371,6 +336,21 @@ function is_foreign_live_owner(carry: RunCarry, owner: CarryOwner): boolean {
 	return is_owner_live(carry) && !is_owned_by(carry, owner)
 }
 
+// Whether a process other than the caller still holds the record. **By process alone, never by
+// conversation**: the wake supervisor inherits the environment of the session that started it, so a
+// 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_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)
+}
+
 function is_handed_off_to(carry: RunCarry, invocation: string): boolean {
 	return carry.is_handed_off === true && carry.invocation === invocation
 }
@@ -424,9 +404,7 @@ function end_carry(target: string): void {
 // no record — `none` or `unreadable` — is not a run whose retrospective has run, so it answers `false`;
 // `run:step` reads it to decide whether the stop position still owes a retrospective.
 function retrospective_done_of(read: CarryRead): boolean {
-	if (read.kind !== 'carried' && read.kind !== 'expired') return false
-
-	return read.carry.retrospective === true
+	return read.kind === 'carried' && read.carry.retrospective === true
 }
 
 // **What the resumed session has to be told, computed rather than stored.** A stored remainder would
@@ -458,10 +436,6 @@ function describe_carry(carry: RunCarry): string {
 	return `${carry.invocation} started ${carry.started_at}; ${String(carry.merged)} merged, ${String(carry.filed)} filed, ${String(carry.failures)} failed in a row, ${String(carry.outages)} outage(s) in a row, ${String(carry.cuts)} cut(s) crossed${done_note(carry)}`
 }
 
-function expired_message(carry: RunCarry): string {
-	return `The ${String(CARRY_MAX_AGE_HOURS)}-hour whole-run bound is spent: ${describe_carry(carry)}. Clear it with \`${END_COMMAND}\`.`
-}
-
 // A record left standing by a run that never reached `--end`. Naming both invocations is the point:
 // the reader has to see that the budget in the way belongs to something else before deciding whether
 // that run is over.
@@ -525,8 +499,6 @@ function unknown_message(): string {
 }
 
 const run_carry = {
-	CARRY_MAX_AGE_HOURS,
-	CARRY_MAX_AGE_MS,
 	END_COMMAND,
 	MAX_CUTS,
 	NO_OWNER,
@@ -543,12 +515,11 @@ const run_carry = {
 	is_at_cut_cap,
 	describe_carry,
 	end_carry,
-	expired_message,
 	mismatch_message,
 	fresh_carry,
 	is_count_refused,
-	is_expired,
 	is_foreign_live_owner,
+	is_held_by_another,
 	is_owner_live,
 	lost_message,
 	nothing_to_resume_message,
@@ -556,7 +527,6 @@ const run_carry = {
 	parse_carry,
 	read_carry,
 	remaining_of,
-	replace_carry,
 	repository_directory,
 	retrospective_done_of,
 	standing_message,