@joshuafolkken/kit 1.1514.0 → 1.2114.0

package/scripts/run/entry/run-entry-spill.ts

@@ -0,0 +1,83 @@
+import { mkdtempSync, writeFileSync } from 'node:fs'
+import path from 'node:path'
+import { capped_output } from '#scripts/document/capped-print'
+import { capped_print_part } from '#scripts/document/capped-print-part'
+import { document_section } from '#scripts/document/document-section'
+import { document_section_cli } from '#scripts/document/document-section-cli'
+import { PLATFORM_TEMP_ROOT } from '#scripts/josh/platform-temporary'
+import { run_prep, type PrepParts } from '#scripts/run/run-prep'
+import { run_step_section } from '#scripts/run/run-step-section'
+
+// The `run:prep` bundle `run:entry` prints, kept under the Bash result cap (joshuafolkken/kit#5213).
+// Past the cap the harness hands back a preview, and a lane child re-ran `run:entry` into a file to see
+// the rest — two calls and two copies of the bundle in the context the implementation cut is measured on.
+//
+// **Over the budget, the whole bundle goes to one file and the issue section becomes its path.** The
+// stage, the `entry` line, the `prep` summary and the short sections stay inline, so the run still
+// branches on what it printed; the issue body and comments — the one unbounded section — are read from
+// the file. A bundle still over the budget without them keeps only the summary and the path.
+//
+// **The file has `capped_print`'s shape** — a fresh directory per call holding one part — so the
+// investigation guard already reads it as a session artifact, not as the Issue's subject.
+//
+// **The budget is `capped_output`'s, less what shares the same Bash result**: the split assessment's
+// section `run:entry` prints after the bundle, and a second headroom for the stage line and the
+// stderr the hold forwards before it.
+
+const FILE_MODE = 0o600
+const SECTION_SEPARATOR = '\n\n'
+
+function byte_length(text: string): number {
+	return Buffer.byteLength(text, 'utf8')
+}
+
+function entry_section_length(root: string): number {
+	const found = run_step_section.GOVERNING_SECTIONS.get(run_step_section.ENTRY)
+
+	if (found === undefined) return 0
+
+	const file = document_section_cli.resolve_document(found.document, root)
+	const markdown = document_section.read_optional(file) ?? ''
+
+	return byte_length(document_section.section(markdown, found.heading)?.text ?? '')
+}
+
+function report_budget(root: string): number {
+	const shared = entry_section_length(root) + capped_output.HEADROOM_CHARS
+
+	return capped_output.output_budget(root) - shared
+}
+
+function spill(whole: string): string {
+	const directory = mkdtempSync(path.join(PLATFORM_TEMP_ROOT, capped_print_part.DIRECTORY_PREFIX))
+	const file = path.join(directory, capped_print_part.part_name(0))
+	const size = byte_length(whole).toLocaleString('en-US')
+
+	writeFileSync(file, whole, { flag: 'wx', mode: FILE_MODE })
+
+	return `Over the Bash cap — the whole bundle (${size} B, the issue body and comments included) is written to ${file}; read it with the Read tool, once, not cat.`
+}
+
+// `compose` turns a report into the text `run:entry` prints for it, so the measure is of what reaches
+// the Bash result — the `entry` line and the cited links included — not of the report alone.
+function fit(
+	parts: PrepParts,
+	compose: (report: string) => string,
+	root: string = process.cwd(),
+): string {
+	const budget = report_budget(root)
+	const whole = run_prep.format_report(parts)
+
+	if (byte_length(compose(whole)) <= budget) return whole
+
+	const line = spill(whole)
+	const trimmed = run_prep.format_report({ ...parts, content_body: line })
+
+	if (byte_length(compose(trimmed)) <= budget) return trimmed
+
+	return [run_prep.summary(parts), line].join(SECTION_SEPARATOR)
+}
+
+const run_entry_spill = { fit, report_budget }
+
+export { run_entry_spill }

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

@@ -23,6 +23,8 @@ interface StopNotice {
 	command: string
 	reason: string
 	should_release: boolean
+	// The choice the Telegram recommends where a rerun alone would stop the same way again.
+	recommended?: string
 }
 
 interface StopPorts {
@@ -79,7 +81,9 @@ async function notify_stop(notice: StopNotice, ports: StopPorts): Promise<void>
 		issue_title: `${notice.command} ${issue_cite.plain(notice.issue_number)} stopped`,
 		body: body_of(notice),
 		recovery: RECOVERY,
-		recommended: `Run \`${notice.command} ${issue_cite.plain(notice.issue_number)}\` again in a fresh session`,
+		recommended:
+			notice.recommended ??
+			`Run \`${notice.command} ${issue_cite.plain(notice.issue_number)}\` again in a fresh session`,
 		alternatives: [LATER_ALTERNATIVE],
 	})
 

package/scripts/run/entry/run-entry-trust.ts

@@ -0,0 +1,91 @@
+import { issue_cite } from '#scripts/issue/issue-cite'
+import type { BlockRead, BlockTrust } from '#scripts/issue/issue-read-cli'
+import { issue_state } from '#scripts/issue/issue-state'
+import type { StateRead } from '#scripts/issue/issue-state-cli'
+
+// **An issue filed by an author without write access is not run on its own body**
+// (joshuafolkken/kit#4663). `backlogrun` never offers one, but a person can still name it as
+// `fullrun #N`, and its body would then reach the run as the specification. The run goes ahead only
+// once a trusted person has planned it with `kickoff #N` — the `run:planned` label and a comment from
+// an author with write access, the plan the run then follows instead of the body. Both, because the
+// label alone is within triage access and a trusted comment alone may be an automated one.
+//
+// Decided from the reads `run:prep` already made, so the gate costs no further call. A read that
+// failed is not judged here: `run:entry` already exits non-zero on it.
+//
+// **A trust read that failed stops as the failed read it is** (#4703) — a write-access lookup, the
+// comment listing or the label read that answered nothing still stops the run, but naming an
+// untrusted author there sends a person to plan an issue whose author may well be trusted.
+
+const STOP_REASON =
+	'the issue author does not have write access, and no trusted `kickoff` plan is on the issue'
+const UNREAD_REASON =
+	'the write-access lookup, the comment listing or the label read failed, so whether the issue may run on its body could not be read'
+const UNREAD_REMEDY = 'Check `gh auth status` and the network, then run it again'
+
+// What a stopped run prints, notifies and recommends.
+interface TrustStop {
+	reason: string
+	report: string
+	recommended: string
+}
+
+// The remedy, named with the issue: a trusted person's `kickoff` writes the plan the run will follow.
+function recommended(issue_number: string): string {
+	return `Have a person with write access run \`kickoff ${issue_cite.plain(issue_number)}\`, then run it again`
+}
+
+function untrusted_stop(issue_number: string): TrustStop {
+	const remedy = recommended(issue_number)
+
+	return {
+		reason: STOP_REASON,
+		report: `(issue author not trusted — ${remedy})`,
+		recommended: remedy,
+	}
+}
+
+const UNREAD_STOP: TrustStop = {
+	reason: UNREAD_REASON,
+	report: `(issue trust read failed — ${UNREAD_REMEDY})`,
+	recommended: UNREAD_REMEDY,
+}
+
+// Not cleared, and the read that would have cleared it answered nothing — a label read that failed
+// leaves the plan unknown unless the comment listing already ruled it out.
+function is_unread(trust: BlockTrust, state: StateRead): boolean {
+	const { is_body_trusted, has_trusted_comment } = trust
+
+	if (is_body_trusted === undefined) return true
+
+	const can_be_planned = state.kind !== 'state' || issue_state.is_planned(state)
+
+	return can_be_planned && has_trusted_comment !== false
+}
+
+// The plan is asked only of a body not already trusted — the state read is not needed otherwise.
+function untrusted_body_stop(
+	trust: BlockTrust,
+	state: StateRead,
+	issue_number: string,
+): TrustStop | undefined {
+	if (issue_state.is_planned(state) && trust.has_trusted_comment === true) return undefined
+
+	return is_unread(trust, state) ? UNREAD_STOP : untrusted_stop(issue_number)
+}
+
+// The stop an issue's trust calls for, or `undefined` when the run may go ahead.
+function stop_of(
+	content: BlockRead,
+	state: StateRead,
+	issue_number: string,
+): TrustStop | undefined {
+	if (content.kind !== 'ok' || content.trust.is_body_trusted === true) return undefined
+
+	return untrusted_body_stop(content.trust, state, issue_number)
+}
+
+const run_entry_trust = { STOP_REASON, UNREAD_REASON, stop_of }
+
+export type { TrustStop }
+export { run_entry_trust }

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

@@ -0,0 +1,56 @@
+// The wording of the baseline investigation's notes on the run's event stream (joshuafolkken/kit#4887):
+// `lane-baseline.ts` writes the launch and a failure, the session it launches writes its result, and
+// `lane-baseline.ts` reads them back so a merge count is investigated once. `run:board` shows each as a
+// note, since none reads as an overrun note.
+
+const MERGES_PATTERN = /^baseline @(?<merges>\d+) merges: (?<rest>.*)$/u
+const STARTED_PREFIX = 'started — '
+const FAILED_PREFIX = 'baseline investigation failed: '
+
+type BaselineNote =
+	| { kind: 'started'; merges: number; outcome: string }
+	| { kind: 'ended'; merges: number; result: string }
+	| { kind: 'failed'; note: string }
+
+function merges_text(merges: number, rest: string): string {
+	return `baseline @${String(merges)} merges: ${rest}`
+}
+
+// The launch at the `merges`-th merge, and what became of it.
+function started_text(merges: number, outcome: string): string {
+	return merges_text(merges, `${STARTED_PREFIX}${outcome}`)
+}
+
+// The session's result — the overrun investigation's vocabulary (`lane-overrun-prompt.ts`).
+function ended_text(merges: number, result: string): string {
+	return merges_text(merges, result)
+}
+
+// A failure — reading the ledger, or the launch itself — names no merge count, so a later merge asks
+// again.
+function failed_text(note: string): string {
+	return `${FAILED_PREFIX}${note}`
+}
+
+function merges_note(merges: number, rest: string): BaselineNote {
+	if (rest.startsWith(STARTED_PREFIX)) {
+		return { kind: 'started', merges, outcome: rest.slice(STARTED_PREFIX.length) }
+	}
+
+	return { kind: 'ended', merges, result: rest }
+}
+
+function parse(text: string): BaselineNote | undefined {
+	const note = text.slice(FAILED_PREFIX.length)
+
+	if (text.startsWith(FAILED_PREFIX)) return { kind: 'failed', note }
+
+	const groups = MERGES_PATTERN.exec(text)?.groups
+
+	return groups ? merges_note(Number(groups['merges']), groups['rest'] ?? '') : undefined
+}
+
+const run_event_baseline = { ended_text, failed_text, parse, started_text }
+
+export type { BaselineNote }
+export { run_event_baseline }

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

@@ -39,10 +39,6 @@ const TEXT_INDEX = 2
 const USAGE =
 	'Usage: josh run:event --append <kind> <text> | --from <position> | --follow <position> | --watch [<position>] | --last'
 
-function now_iso(): string {
-	return new Date().toISOString()
-}
-
 function report_usage(): number {
 	process.stderr.write(`${USAGE}\n`)
 
@@ -54,7 +50,7 @@ async function run_append(kind: string, text: string): Promise<number> {
 
 	if (target === undefined) return report_usage()
 
-	const result = run_event_stream.append(target, kind, text, now_iso())
+	const result = await run_event_stream_emit.append_at(target, kind, text, new Date())
 
 	if (!result.appended) {
 		process.stderr.write(`not a session-facing event kind: ${kind}\n`)

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

@@ -6,9 +6,9 @@ import {
 	has_label_name,
 } from '#scripts/issue/issue-labels'
 
-// The text of a `filed` event: the Issue a run filed, its kind, its title, and the child whose work
-// turned it up. `issue:file` writes it and `run:board` reads it back, both through this module, so the
-// two never spell it differently.
+// The text of a `filed` event: the Issue a run filed, its kind, its title, whether a run's own session
+// filed it, and the child whose work turned it up. `issue:file` writes it and `run:board` reads it
+// back, both through this module, so the two never spell it differently.
 
 // The classification labels a filing's kind is read from, in precedence order: a breaking change is
 // named as one whatever else it is.
@@ -25,13 +25,22 @@ interface Filed {
 	title: string
 	// The lane child that was working when the Issue was filed, when the filing came from one.
 	found_during: string | undefined
+	// A run's own session filed it — the parent holding the run's hold or a lane child — rather than one
+	// outside the run sharing the repository's stream (joshuafolkken/kit#4099). An event written before
+	// the mark was recorded reads as filed outside.
+	is_run?: boolean | undefined
+	// A lane's overrun investigation filed it, not the child (joshuafolkken/kit#4880). An event written
+	// before the mark was recorded reads as the child's.
+	is_overrun?: boolean | undefined
 }
 
 // The kind slot is always written, `[<label>]` or `[]`, against the reference with no space: an event
 // written before the kind always has the space there, so no title, whatever it opens with, reads as a
-// kind.
+// kind. The run's mark follows the kind slot, then the overrun's, again with no space.
+const RUN_MARK = '[run]'
+const OVERRUN_MARK = '[overrun]'
 const TEXT_PATTERN = new RegExp(
-	String.raw`^(?<reference>\S*#\d+)(?:\[(?<kind>${KINDS.join('|')}|)\])? (?<title>.*?)(?: \(found during #(?<during>\d+)\))?$`,
+	String.raw`^(?<reference>\S*#\d+)(?:\[(?<kind>${KINDS.join('|')}|)\](?<run>\[run\])?(?<overrun>\[overrun\])?)? (?<title>.*?)(?: \(found during #(?<during>\d+)\))?$`,
 	'u',
 )
 
@@ -41,7 +50,8 @@ function kind_of(labels: ReadonlyArray<string>): FiledKind | undefined {
 }
 
 function text_of(filed: Filed): string {
-	const kind = `[${filed.kind ?? ''}]`
+	const marks = `${filed.is_run === true ? RUN_MARK : ''}${filed.is_overrun === true ? OVERRUN_MARK : ''}`
+	const kind = `[${filed.kind ?? ''}]${marks}`
 	const suffix =
 		filed.found_during === undefined
 			? ''
@@ -60,6 +70,8 @@ function parse(text: string): Filed | undefined {
 		kind: KINDS.find((kind) => kind === groups['kind']),
 		title: String(groups['title']),
 		found_during: groups['during'],
+		is_run: groups['run'] !== undefined,
+		is_overrun: groups['overrun'] !== undefined,
 	}
 }
 

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

@@ -1,3 +1,4 @@
+import { MS_PER_MINUTE, MS_PER_SECOND } from '#scripts/lib/timeouts'
 import type { StreamRead } from './run-event-stream'
 
 // The follow read behind `josh run:event --follow` and `--watch`. A reader
@@ -24,10 +25,8 @@ import type { StreamRead } from './run-event-stream'
 // The follow's quiet-tick cadence and how promptly it notices an arrival. The interval only bounds a
 // wait that found nothing — an arrival returns within a tick of landing — so it can be as long as the
 // heartbeat without making an arrival late, and the tick is a cheap `stat` of one file.
-const MS_PER_SECOND = 1000
-const SECONDS_PER_MINUTE = 60
 const FOLLOW_INTERVAL_MINUTES = 20
-const FOLLOW_INTERVAL_MS = FOLLOW_INTERVAL_MINUTES * SECONDS_PER_MINUTE * MS_PER_SECOND
+const FOLLOW_INTERVAL_MS = FOLLOW_INTERVAL_MINUTES * MS_PER_MINUTE
 const FOLLOW_TICK_MS = MS_PER_SECOND
 
 interface FollowPorts {

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

@@ -0,0 +1,197 @@
+import { issue_cite } from '#scripts/issue/issue-cite'
+
+// The notes an overrun investigation leaves on the run's event stream (joshuafolkken/kit#4751): every
+// merged lane's net time, at or under the threshold or over it, or why there is none
+// (joshuafolkken/kit#4818); an overrun's start, naming the session's pid and start time; and its end —
+// the session's result or the launch's failure. `lane-overrun.ts` writes them and `run:board` reads them
+// back, both through this module, so the two never spell them differently.
+
+// What a note says of the investigation of `issue`. `start` is the session's `process_identity` start
+// token, which tells the session from a later process holding its pid; a launcher that could not read it
+// leaves it off. A start note that launched no session is a failure with its minutes.
+type OverrunNote =
+	| { kind: 'within'; issue: number; minutes: number }
+	| { kind: 'skipped'; issue: number; reason: string }
+	| {
+			kind: 'started'
+			issue: number
+			minutes: number
+			pid: number
+			start: string | undefined
+			longest: Longest | undefined
+	  }
+	| { kind: 'ended'; issue: number; result: string }
+	| { kind: 'failed'; issue: number; minutes: number | undefined }
+
+// The lane's longest stage in whole minutes (joshuafolkken/kit#4995, `lane-breakdown.ts`); a start note
+// written before it was carried has none.
+interface Longest {
+	name: string
+	minutes: number
+}
+
+type Groups = Partial<Record<string, string>>
+
+const WITHIN_PATTERN = /^#(?<issue>\d+) net: (?<minutes>\d+) min$/u
+const SKIPPED_PATTERN = /^#(?<issue>\d+) overrun skipped: (?<reason>.+)$/u
+const OVERRAN_PATTERN =
+	/^#(?<issue>\d+) overran: (?<minutes>\d+) min net(?:, longest (?<stage>.+?) (?<stage_minutes>\d+) min)? — (?<outcome>.*)$/u
+const INVESTIGATING_PATTERN = /^investigating in pid (?<pid>\d+)(?: started (?<start>.+))?$/u
+const ENDED_PATTERN = /^#(?<issue>\d+) overrun: (?<result>.*)$/u
+const FAILED_PATTERN = /^#(?<issue>\d+) overrun investigation failed: /u
+
+// Why an overrun was skipped with the switch off (joshuafolkken/kit#5044); the board draws it only
+// once the switch is on, hiding every merged row's minutes and skip while it stays off
+// (joshuafolkken/kit#5132, joshuafolkken/kit#5194).
+const DISABLED_REASON = 'disabled (JOSH_LANE_INVESTIGATION is not on)'
+// The result an investigation that filed records; the board shows the filings themselves.
+const FILED_RESULT = 'filed'
+const NONE_LEAD = 'none: '
+// What a result ends with for the stages the investigation judged not reducible (joshuafolkken/kit#4995).
+const NOT_REDUCIBLE_LEAD = '; not reducible: '
+const RECURRED_PATTERN = /^recurred #(?<number>\d+)/u
+// The result of an investigation that appended causes to open Issues, which file no new one
+// (joshuafolkken/kit#4858); any it filed besides show as filings.
+const FOLDED_LEAD = 'folded '
+const FOLDED_SEPARATOR = ','
+const FOLDED_PATTERN = /^folded (?<list>#\d+(?:,#\d+)*)/u
+const NUMBER_PATTERN = /#(?<number>\d+)/gu
+
+function started_text(issue: number, minutes: number, outcome: string, longest?: Longest): string {
+	const stage =
+		longest === undefined ? '' : `, longest ${longest.name} ${String(longest.minutes)} min`
+
+	return `${issue_cite.plain(issue)} overran: ${String(minutes)} min net${stage} — ${outcome}`
+}
+
+function within_text(issue: number, minutes: number): string {
+	return `${issue_cite.plain(issue)} net: ${String(minutes)} min`
+}
+
+function skipped_text(issue: number, reason: string): string {
+	return `${issue_cite.plain(issue)} overrun skipped: ${reason}`
+}
+
+// The start note's outcome for a launched session.
+function investigating(pid: number, start: string | undefined): string {
+	const outcome = `investigating in pid ${String(pid)}`
+
+	return start === undefined ? outcome : `${outcome} started ${start}`
+}
+
+function ended_text(issue: number, result: string): string {
+	return `${issue_cite.plain(issue)} overrun: ${result}`
+}
+
+function failed_text(issue: number, note: string): string {
+	return `${issue_cite.plain(issue)} overrun investigation failed: ${note}`
+}
+
+function none_result(reason: string): string {
+	return `${NONE_LEAD}${reason}`
+}
+
+function recurred_result(issue: number | string): string {
+	return `recurred ${issue_cite.plain(issue)}`
+}
+
+// The issue a `recurred #N` result commented on.
+function recurred_of(result: string): number | undefined {
+	const number = RECURRED_PATTERN.exec(result)?.groups?.['number']
+
+	return number === undefined ? undefined : Number(number)
+}
+
+function folded_result(issues: ReadonlyArray<number | string>): string {
+	return `${FOLDED_LEAD}${issues.map((issue) => issue_cite.plain(issue)).join(FOLDED_SEPARATOR)}`
+}
+
+// The Issues a `folded #A,#B` result appended to, else none; any text after the list is not read.
+function folded_of(result: string): ReadonlyArray<number> {
+	const list = FOLDED_PATTERN.exec(result)?.groups?.['list'] ?? ''
+
+	return [...list.matchAll(NUMBER_PATTERN)].map((match) => Number(match.groups?.['number']))
+}
+
+// The reason a `none: <reason>` result gives, else the result as it is — its stages not reducible left
+// out.
+function reason_of(result: string): string {
+	const [lead = ''] = result.split(NOT_REDUCIBLE_LEAD)
+
+	return lead.startsWith(NONE_LEAD) ? lead.slice(NONE_LEAD.length) : lead
+}
+
+function longest_of(groups: Groups): Longest | undefined {
+	const name = groups['stage']
+
+	return name === undefined ? undefined : { name, minutes: Number(groups['stage_minutes']) }
+}
+
+function overran(groups: Groups): OverrunNote {
+	const issue = Number(groups['issue'])
+	const minutes = Number(groups['minutes'])
+	const launched = INVESTIGATING_PATTERN.exec(groups['outcome'] ?? '')?.groups
+
+	if (launched === undefined) return { kind: 'failed', issue, minutes }
+
+	const pid = Number(launched['pid'])
+	const longest = longest_of(groups)
+
+	return { kind: 'started', issue, minutes, pid, start: launched['start'], longest }
+}
+
+function within(groups: Groups): OverrunNote {
+	return { kind: 'within', issue: Number(groups['issue']), minutes: Number(groups['minutes']) }
+}
+
+function skipped(groups: Groups): OverrunNote {
+	return { kind: 'skipped', issue: Number(groups['issue']), reason: groups['reason'] ?? '' }
+}
+
+function failed(groups: Groups): OverrunNote {
+	return { kind: 'failed', issue: Number(groups['issue']), minutes: undefined }
+}
+
+function ended(groups: Groups): OverrunNote {
+	return { kind: 'ended', issue: Number(groups['issue']), result: groups['result'] ?? '' }
+}
+
+const READERS: ReadonlyArray<readonly [RegExp, (groups: Groups) => OverrunNote]> = [
+	[WITHIN_PATTERN, within],
+	[SKIPPED_PATTERN, skipped],
+	[OVERRAN_PATTERN, overran],
+	[FAILED_PATTERN, failed],
+	[ENDED_PATTERN, ended],
+]
+
+function parse(text: string): OverrunNote | undefined {
+	for (const [pattern, read] of READERS) {
+		const groups = pattern.exec(text)?.groups
+
+		if (groups !== undefined) return read(groups)
+	}
+
+	return undefined
+}
+
+const run_event_overrun = {
+	DISABLED_REASON,
+	ended_text,
+	failed_text,
+	FILED_RESULT,
+	folded_of,
+	folded_result,
+	investigating,
+	none_result,
+	NOT_REDUCIBLE_LEAD,
+	parse,
+	reason_of,
+	recurred_of,
+	recurred_result,
+	skipped_text,
+	started_text,
+	within_text,
+}
+
+export { run_event_overrun }
+export type { Longest, OverrunNote }

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

@@ -1,3 +1,4 @@
+import { figure_format } from '#scripts/lib/figure-format'
 import type { EventKind, RunEvent } from './run-event-stream'
 
 // One run event as the line a person reads in the watch pane. The pane is a script, not a session, so
@@ -10,8 +11,6 @@ import type { EventKind, RunEvent } from './run-event-stream'
 
 const JA = 'ja'
 const FIELD_SEPARATOR = ' · '
-const CLOCK_WIDTH = 2
-const CLOCK_PAD = '0'
 
 interface KindLabel {
 	ja: string
@@ -26,6 +25,7 @@ const KIND_LABELS: Readonly<Record<EventKind, KindLabel>> = {
 	park: { ja: '保留', en: 'parked' },
 	split: { ja: '分割', en: 'split' },
 	outage: { ja: '障害', en: 'outage' },
+	'usage-limit': { ja: '利用上限', en: 'usage limit' },
 	cut: { ja: 'セッション交代', en: 'session cut' },
 	resume: { ja: '実装を再開', en: 'implementation resumed' },
 	restart: { ja: '止めて出し直し', en: 'restarted' },
@@ -41,6 +41,7 @@ const KIND_LABELS: Readonly<Record<EventKind, KindLabel>> = {
 	heartbeat: { ja: '生存確認', en: 'heartbeat' },
 	'ship-launch': { ja: '出荷を開始', en: 'ship launched' },
 	'ship-stop': { ja: '出荷が停止', en: 'ship stopped' },
+	'relaunch-failed': { ja: '再起動に失敗', en: 'relaunch failed' },
 	filed: { ja: '起票', en: 'filed' },
 	note: { ja: '意見', en: 'note' },
 	'lane-phase': { ja: 'レーンの段階', en: 'lane phase' },
@@ -48,6 +49,11 @@ const KIND_LABELS: Readonly<Record<EventKind, KindLabel>> = {
 	'lane-limit': { ja: 'レーン上限', en: 'lane limit' },
 	setup: { ja: '準備', en: 'setup' },
 	'pr-checks': { ja: 'PR のチェック', en: 'PR checks' },
+	'idle-notice': { ja: '待機の通知', en: 'idle notice' },
+	'lane-state': { ja: 'レーンの状態', en: 'lane state' },
+	'paused-notice': { ja: '一時停止の通知', en: 'paused notice' },
+	measured: { ja: '計測で完了', en: 'measured' },
+	sleep: { ja: 'ホストのスリープ', en: 'host sleep' },
 }
 
 const LABELS_BY_KIND: ReadonlyMap<string, KindLabel> = new Map(Object.entries(KIND_LABELS))
@@ -60,18 +66,12 @@ function label_of(kind: string, lang: string): string {
 	return lang === JA ? label.ja : label.en
 }
 
-function two_digits(value: number): string {
-	return String(value).padStart(CLOCK_WIDTH, CLOCK_PAD)
-}
-
 // The local wall-clock `HH:MM` of the event, the reading a person watching a pane compares with the clock
 // on their screen; an unparseable stamp is shown as written rather than as `NaN:NaN`.
 function clock_of(at: string): string {
-	const date = new Date(at)
-
-	if (Number.isNaN(date.getTime())) return at
+	const ms = new Date(at).getTime()
 
-	return `${two_digits(date.getHours())}:${two_digits(date.getMinutes())}`
+	return Number.isNaN(ms) ? at : figure_format.minute_of(ms)
 }
 
 function render(event: RunEvent, lang: string): string {

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

@@ -114,7 +114,7 @@ function is_own_ship_event(event: RunEvent, issue: string): boolean {
 }
 
 // The issue an event's text names, the way every reader here — and `run:board` — keys an event to a child.
-function issue_named(event: RunEvent): string | undefined {
+function issue_named(event: Pick<RunEvent, 'text'>): string | undefined {
 	return ISSUE_REFERENCE.exec(event.text)?.[1]
 }
 
@@ -169,7 +169,7 @@ function last_issue_event(
 
 // A child's launch and the endings `run:merge` settles it with — the ones `run:board` stops drawing it
 // running on. A park or a split already ran `run:merge`, so a child closed after one owes nothing; a
-// withdrawal settles the child itself, its issue closed by the person who withdrew it.
+// withdrawal settles the child itself, its issue left open for the next run.
 const LAUNCH_OR_SETTLE_KINDS: ReadonlySet<string> = new Set([
 	KIND.CHILD_LAUNCH,
 	KIND.MERGE,