@joshuafolkken/kit 1.1379.0 → 1.1383.0

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

@@ -39,7 +39,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 +93,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 +134,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,49 +151,17 @@ 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)
+function start_fresh(target: string, request: CarryClaimRequest, is_json: boolean): number {
+	const carry = run_carry.begin_carry(target, request.invocation, request.owner)
 
 	if (carry === undefined) return report_lost(is_json)
 
 	return report_carry(BEGAN_VERDICT, carry, is_json)
 }
 
-// **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(
-	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)
-
-	// **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)
-
-	console.error(run_carry.expired_message(carry))
-
-	return start_fresh(target, request, true, 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.
+// **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`.
 function begin(target: string, request: CarryClaimRequest, is_json: boolean): number {
 	const read = run_carry.read_carry(target)
 
@@ -216,9 +169,7 @@ function begin(target: string, request: CarryClaimRequest, is_json: boolean): nu
 
 	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 start_fresh(target, request, is_json)
 }
 
 function report_nothing_to_resume(is_json: boolean): number {
@@ -237,8 +188,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)
 }
 
@@ -334,9 +283,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**.
@@ -463,7 +410,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()

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,
-}
-
-function is_expired(carry: RunCarry, now: Date): boolean {
-	return stamp_record.is_older_than(started_at_of(carry), CARRY_MAX_AGE_MS, now)
-}
+// **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 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.
@@ -424,9 +389,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 +421,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 +484,6 @@ function unknown_message(): string {
 }
 
 const run_carry = {
-	CARRY_MAX_AGE_HOURS,
-	CARRY_MAX_AGE_MS,
 	END_COMMAND,
 	MAX_CUTS,
 	NO_OWNER,
@@ -543,11 +500,9 @@ 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_owner_live,
 	lost_message,
@@ -556,7 +511,6 @@ const run_carry = {
 	parse_carry,
 	read_carry,
 	remaining_of,
-	replace_carry,
 	repository_directory,
 	retrospective_done_of,
 	standing_message,

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,7 +39,6 @@ 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' },

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-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
@@ -106,11 +106,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',
@@ -141,7 +136,6 @@ 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,
@@ -151,13 +145,9 @@ const TRACE_KINDS: ReadonlySet<string> = new Set([
 
 // 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.
-const DISPOSABLE_KINDS: ReadonlySet<string> = new Set([
-	EVENT_KIND.SHIP_STAGE,
-	EVENT_KIND.HEARTBEAT,
-	EVENT_KIND.IDLE,
-])
+// it rolls off only with the positions. A ship-stage `start` is disposable but goes last of them:
+// `run:board` draws from that line.
+const DISPOSABLE_KINDS: ReadonlySet<string> = new Set([EVENT_KIND.SHIP_STAGE, EVENT_KIND.HEARTBEAT])
 
 const event_schema = z.object({
 	pos: z.number(),
@@ -200,9 +190,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 +206,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,12 +241,6 @@ 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 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> {
@@ -256,8 +248,8 @@ function droppable(events: ReadonlyArray<RunEvent>): ReadonlyArray<RunEvent> {
 	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)),
 	]
 }
 
@@ -272,8 +264,7 @@ function droppable(events: ReadonlyArray<RunEvent>): ReadonlyArray<RunEvent> {
 // append.
 //
 // **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 +284,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,