@joshuafolkken/kit 1.1373.0 → 1.1383.0

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

@@ -157,28 +157,40 @@ function alert_of(spec: GaugeSpec, value: number, pressure: number | undefined):
 	return verdict ?? threshold_alert(value, spec)
 }
 
+// One gauge's reading: its value, the width its figure is right-aligned to where that is wider than
+// the figure's own, and the kernel's pressure verdict where the gauge takes one.
+interface Reading {
+	value: number | undefined
+	width: number
+	pressure?: number | undefined
+}
+
 // Icon, figure, then bar: the figure is what a person reads, and its fixed
 // width keeps every bar starting in one column. The bar stops full past `spec.full`; the figure still
 // says how far past, and takes the warning colors only, so a quiet machine's figures stay the terminal's
 // own.
-function gauge(spec: GaugeSpec, value: number | undefined, pressure?: number): string | undefined {
+function gauge(spec: GaugeSpec, reading: Reading): string | undefined {
+	const { value, width } = reading
+
 	if (value === undefined) return undefined
 
-	const alert = alert_of(spec, value, pressure)
+	const alert = alert_of(spec, value, reading.pressure)
 	const warning = alert === 'normal' ? undefined : GAUGE_SHADES[alert]
 	const bar = bar_of(value, spec.full, undefined, warning ?? spec.normal)
 
-	return `${spec.icon} ${painted(warning, spec.format(value))} ${bar}`
+	return `${spec.icon} ${painted(warning, spec.format(value).padStart(width))} ${bar}`
 }
 
-// `undefined` when not one gauge could be read, so the header draws no line at all.
-function line_of(gauges: MachineGauges | undefined): string | undefined {
+// `undefined` when not one gauge could be read, so the header draws no line at all. `width` is the
+// header's figure column: a figure narrower than it is right-aligned to it, so the first gauge's bar
+// starts under the progress bar whichever gauge that is.
+function line_of(gauges: MachineGauges | undefined, width = 0): string | undefined {
 	if (gauges === undefined) return undefined
 
 	const parts = [
-		gauge(SPECS.cpu, gauges.cpu_percent),
-		gauge(SPECS.memory, gauges.memory_percent, gauges.memory_pressure),
-		gauge(SPECS.swap, gauges.swap_mb_per_s),
+		gauge(SPECS.cpu, { value: gauges.cpu_percent, width }),
+		gauge(SPECS.memory, { value: gauges.memory_percent, width, pressure: gauges.memory_pressure }),
+		gauge(SPECS.swap, { value: gauges.swap_mb_per_s, width }),
 	].filter((part) => part !== undefined)
 
 	return parts.length === 0 ? undefined : parts.join(GAP)
@@ -188,6 +200,7 @@ const run_board_machine = {
 	CPU_YELLOW,
 	GAP,
 	MEMORY_YELLOW,
+	PERCENT_WIDTH,
 	gauges_of,
 	line_of,
 	percent_text,

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

@@ -373,11 +373,7 @@ function bounded(parts: FrameParts, bounds: FrameBounds): Array<string> {
 
 function render(view: BoardView): Array<string> {
 	const { header, notes } = view
-	const above = [
-		...run_board_header.header_lines(header),
-		...resume_lines(view.resume),
-		...run_board_header.idle_lines(header),
-	]
+	const above = [...run_board_header.header_lines(header), ...resume_lines(view.resume)]
 	const parts = {
 		above,
 		plan: plan_sections(header, view.size),

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

@@ -28,7 +28,6 @@ function ended_span(ended: EndedRun | undefined): BoardSpan | undefined {
 }
 
 // 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
 

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,
@@ -30,8 +29,6 @@ interface ItemStatus {
 // The run as a whole, read off the same stream.
 interface RunActivity {
 	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
 }
@@ -243,19 +240,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
 }
@@ -268,7 +252,6 @@ function activity_of(events: ReadonlyArray<RunEvent>, is_ended = false): RunActi
 
 	return {
 		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

@@ -135,6 +135,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-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,