@joshuafolkken/kit 1.1514.0 → 1.2114.0

package/scripts/lane/lane-await.ts

@@ -2,7 +2,8 @@ import { spawnSync } from 'node:child_process'
 import { setTimeout as sleep } from 'node:timers/promises'
 import { parseArgs } from 'node:util'
 import { issue_number_shape } from '#scripts/issue/issue-number-shape'
-import { PROBE_TIMEOUT_MS } from '#scripts/lib/timeouts'
+import { poll } from '#scripts/lib/poll'
+import { MS_PER_SECOND, PROBE_TIMEOUT_MS } from '#scripts/lib/timeouts'
 import {
 	PROCESS_ALIVE,
 	PROCESS_NONE,
@@ -28,7 +29,6 @@ import { process_tools } from './process-tools'
 const RECONFIRM_MS = 15_000
 const DEFAULT_POLL_MS = 5000
 const NEVER_APPEARED_TIMEOUT_MS = 600_000
-const MS_PER_SECOND = 1000
 const PROCESS_FOUND = 0
 const PROCESS_NOT_FOUND = 1
 const PGREP_COMMAND = 'pgrep'
@@ -36,8 +36,14 @@ const PGREP_COMMAND = 'pgrep'
 // `is_settled` is read once, when the wait starts: a child that ended between two `lane:await` calls
 // never appears in the second one, and only its settled issue tells it apart from one not yet
 // launched.
+//
+// `alive_since` is when this run of the child was first seen alive: a ship it launched is no older, so
+// a ship record launched earlier is a past dispatch's (joshuafolkken/kit#4395). A child already alive
+// when the watch began gets the first poll's time, so a ship it launched before that is not read as
+// its own and its disappearance waits out the re-confirm window.
 interface AwaitState {
 	appeared: boolean
+	alive_since?: number | undefined
 	disappeared_at: number | undefined
 	first_polled_at: number | undefined
 	is_settled?: boolean
@@ -56,6 +62,7 @@ interface RawAwaitArguments {
 // Injectable for testing -- the CLI never overrides these.
 interface AwaitOptions {
 	is_running?: (issue: string) => boolean
+	is_shipped?: (issue: string, since_ms: number) => boolean
 	is_settled?: (issue: string) => Promise<boolean>
 	poll_ms?: number
 	reconfirm_ms?: number
@@ -64,8 +71,11 @@ interface AwaitOptions {
 	sleep?: (ms: number) => Promise<void>
 }
 
+// `is_shipped` is the one disappearance the re-confirm window never has to cover: a ship that ended in
+// success merged the child's work, so no cut hand-off can follow it (joshuafolkken/kit#4395).
 interface CheckConfig {
 	is_running: (issue: string) => boolean
+	is_shipped?: (issue: string, since_ms: number) => boolean
 	reconfirm_ms: number
 	never_appeared_timeout_ms: number
 }
@@ -100,6 +110,10 @@ function is_process_running_default(issue: string): boolean {
 	return process_trace_default(issue) === PROCESS_ALIVE
 }
 
+function is_shipped_default(issue: string, since_ms: number): boolean {
+	return lane_handoff.is_ship_succeeded(issue, process.cwd(), since_ms)
+}
+
 // The same positive evidence `run:liveness` answers `settled` on: the issue closed, or it was parked.
 async function is_settled_default(issue: string): Promise<boolean> {
 	return (await run_liveness.read_child_settled(issue)) === true
@@ -164,9 +178,16 @@ function resolve_timing(
 	}
 }
 
-function resolve_options(options: AwaitOptions): RunConfig {
+function resolve_probes(options: AwaitOptions): Pick<RunConfig, 'is_running' | 'is_shipped'> {
 	return {
 		is_running: options.is_running ?? is_process_running_default,
+		is_shipped: options.is_shipped ?? is_shipped_default,
+	}
+}
+
+function resolve_options(options: AwaitOptions): RunConfig {
+	return {
+		...resolve_probes(options),
 		is_settled: options.is_settled ?? is_settled_default,
 		now: options.now ?? Date.now,
 		sleep: options.sleep ?? sleep,
@@ -174,9 +195,11 @@ function resolve_options(options: AwaitOptions): RunConfig {
 	}
 }
 
-function update_liveness(state: AwaitState, is_live: boolean): void {
+function update_liveness(state: AwaitState, is_live: boolean, now_ms: number): void {
 	if (!is_live) return
 
+	if (!state.appeared || state.disappeared_at !== undefined) state.alive_since = now_ms
+
 	state.appeared = true
 	state.disappeared_at = undefined
 }
@@ -203,6 +226,28 @@ function check_not_appeared(
 	return undefined
 }
 
+// The ship this run of the child launched succeeded.
+function is_own_ship_done(issue: string, state: AwaitState, config: CheckConfig): boolean {
+	const { alive_since } = state
+
+	return alive_since !== undefined && config.is_shipped?.(issue, alive_since) === true
+}
+
+// A child that appeared and is gone: done at once when its ship succeeded, else once it stayed gone
+// past the re-confirm window.
+function check_gone(
+	issue: string,
+	state: AwaitState,
+	now_ms: number,
+	config: CheckConfig,
+): string | undefined {
+	if (is_own_ship_done(issue, state, config)) return issue
+
+	state.disappeared_at ??= now_ms
+
+	return now_ms - state.disappeared_at >= config.reconfirm_ms ? issue : undefined
+}
+
 // Returns the issue that has confirmed-completed this tick, `undefined` if none yet.
 // The `appeared` guard prevents a process that never showed up from being declared done, unless its
 // issue had already settled when the wait started.
@@ -214,7 +259,7 @@ function check_issue(
 ): string | undefined {
 	const is_live = config.is_running(issue)
 
-	update_liveness(state, is_live)
+	update_liveness(state, is_live, now_ms)
 
 	if (is_live) return undefined
 
@@ -222,13 +267,7 @@ function check_issue(
 		return check_not_appeared(issue, state, now_ms, config.never_appeared_timeout_ms)
 	}
 
-	if (state.disappeared_at === undefined) {
-		state.disappeared_at = now_ms
-
-		return undefined
-	}
-
-	return now_ms - state.disappeared_at >= config.reconfirm_ms ? issue : undefined
+	return check_gone(issue, state, now_ms, config)
 }
 
 function check_any(
@@ -252,14 +291,10 @@ async function wait_for_any(
 	const config = resolve_options(options)
 	const states = await make_states(issues, config.is_settled)
 
-	for (;;) {
-		const completed = check_any(states, config.now(), config)
-
-		if (completed !== undefined) return completed
-
-		// eslint-disable-next-line no-await-in-loop -- polling: each read waits on the state the previous one saw
-		await config.sleep(config.poll_ms)
-	}
+	return await poll.wait_for(() => check_any(states, config.now(), config), {
+		interval_ms: config.poll_ms,
+		sleeper: config.sleep,
+	})
 }
 
 const lane_await = {
@@ -267,6 +302,7 @@ const lane_await = {
 	RECONFIRM_MS,
 	check_issue,
 	is_process_running_default,
+	is_shipped_default,
 	parse_arguments,
 	process_trace_default,
 	wait_for_any,

package/scripts/lane/lane-baseline.ts

@@ -0,0 +1,123 @@
+import { detached_launch } from '#scripts/run/detached-launch'
+import { run_event_baseline } from '#scripts/run/event/run-event-baseline'
+import { run_event_stream, type RunEvent } from '#scripts/run/event/run-event-stream'
+import { run_event_stream_emit } from '#scripts/run/event/run-event-stream-emit'
+import { lane_investigation_switch } from './lane-investigation-switch'
+import { lane_ledger } from './lane-ledger'
+import { lane_overrun } from './lane-overrun'
+import { lane_overrun_prompt } from './lane-overrun-prompt'
+import { lane_stage_stats } from './lane-stage-stats'
+
+// Every `BASELINE_MERGES`-th merge the median lane itself is investigated (joshuafolkken/kit#4887).
+// The overrun investigation (`lane-overrun.ts`) reads only a lane slower than the threshold, so the time
+// every lane spends is never a candidate for a cut. `run:merge` asks at each merge: the last multiple the
+// ledger's merge count reached, when no note has it yet, launches a detached worker session that reads
+// `lane:stats`, takes the stages and sub-stages that spend the most per merge, and files their causes
+// by the overrun investigation's filing rules — the same prompt part, a cause's reducible minutes cut
+// from one median merge rather than one lane (joshuafolkken/kit#4928). Its filings name no lane they
+// were found during. The launch and the session's result go on the run's event stream as notes, which
+// `run:board` shows. It runs only while `JOSH_LANE_INVESTIGATION` is on (`lane-investigation-switch.ts`);
+// off by default, a due bucket launches nothing and notes nothing (joshuafolkken/kit#5044).
+
+const { EVENT_KIND } = run_event_stream
+const BASELINE_MERGES = 30
+const LOG_PREFIX = 'josh-lane-baseline-'
+const STATS_PERIOD_DAYS = 3
+const MEDIAN_PLACEHOLDER = '<median lane minutes>'
+const SCOPE = 'the median merge, judged from the per-merge minutes `lane:stats` prints'
+
+// The last multiple of `BASELINE_MERGES` the count reached: two merges recorded between two asks, or an
+// ask that failed, still leave the bucket due at the next merge.
+function due_bucket(merges: number): number {
+	return Math.floor(merges / BASELINE_MERGES) * BASELINE_MERGES
+}
+
+// A count investigated already — a retried merge finds its note — launches no second session. A
+// failure names no count, so it never answers for one.
+function is_noted(events: ReadonlyArray<RunEvent>, merges: number): boolean {
+	return events.some((event) => {
+		const note = event.kind === EVENT_KIND.NOTE ? run_event_baseline.parse(event.text) : undefined
+
+		return note !== undefined && note.kind !== 'failed' && note.merges === merges
+	})
+}
+
+// The due bucket of the ledger's merge count, else `undefined` before the first.
+async function due_merges(): Promise<number | undefined> {
+	const path = await lane_ledger.target()
+
+	if (path === undefined) return undefined
+
+	const merges = lane_ledger.read_entries(path).filter((entry) => lane_stage_stats.is_merge(entry))
+	const bucket = due_bucket(merges.length)
+
+	return bucket > 0 ? bucket : undefined
+}
+
+function reading(merges: number): string {
+	return [
+		`Investigate the median lane after ${String(merges)} merges: not an overrun, but the time every lane`,
+		'spends. Leave this checkout as it is: write any file, an issue body included, under the system temp',
+		'directory, and never stage, commit or push.',
+		`Read \`pnpm josh lane:stats --period ${String(STATS_PERIOD_DAYS)}\` — its stage table and its`,
+		'implement sub-stage table — and take the several stages and sub-stages with the largest per-merge',
+		"time, not just the one largest. Read the period lanes' transcripts (the lane directories `lane:stats`",
+		"reads) and the run events (`pnpm josh run:event --from 0`) for where each one's time goes, and find",
+		'the causes a fix could cut.',
+		'Trace each cause to what can fix it: the minutes it spends per merge, the signal that led to the',
+		'spend (which command printed what), the `file:line` of the code or document that decided it, and',
+		'where to fix it.',
+	].join(' ')
+}
+
+// One line: `detached_launch` lets a prompt break lines, but a single line keeps the log header whole.
+function prompt(issue: number, merges: number): string {
+	const handling = lane_overrun_prompt.cause_handling({
+		origin: undefined,
+		loss_lines: lane_overrun_prompt.loss_lines_of(issue, MEDIAN_PLACEHOLDER),
+		template: run_event_baseline.ended_text(merges, '<result>'),
+		scope: SCOPE,
+	})
+
+	return `${reading(merges)} ${handling}`
+}
+
+function note_failure(note: string): void {
+	void run_event_stream_emit.emit(EVENT_KIND.NOTE, run_event_baseline.failed_text(note))
+}
+
+// The launch at merge `issue`, the `merges`-th; its filings count against that lane.
+function launched(issue: number, merges: number): string {
+	return lane_overrun.launch({
+		env: {},
+		prompt: prompt(issue, merges),
+		log_prefix: `${LOG_PREFIX}${String(merges)}-`,
+		on_failure: note_failure,
+	})
+}
+
+async function investigate_baseline(issue: number): Promise<void> {
+	const merges = await due_merges()
+
+	if (merges === undefined || is_noted(await run_event_stream_emit.all_events(), merges)) return
+
+	await run_event_stream_emit.emit(
+		EVENT_KIND.NOTE,
+		run_event_baseline.started_text(merges, launched(issue, merges)),
+	)
+}
+
+// Never fails the merge it follows: an error is a note on the stream, not a refused merge.
+async function investigate(issue: number): Promise<void> {
+	if (!lane_investigation_switch.is_on()) return
+
+	try {
+		await investigate_baseline(issue)
+	} catch (error) {
+		note_failure(detached_launch.note_of(error))
+	}
+}
+
+const lane_baseline = { due_bucket, investigate }
+
+export { lane_baseline }

package/scripts/lane/lane-breakdown-cli.ts

@@ -0,0 +1,64 @@
+#!/usr/bin/env tsx
+import { fileURLToPath } from 'node:url'
+import { issue_number_shape } from '#scripts/issue/issue-number-shape'
+import { session_cite } from '#scripts/issue/session-cite'
+import { run_event_stream_emit } from '#scripts/run/event/run-event-stream-emit'
+import { lane_breakdown } from './lane-breakdown'
+import { lane_breakdown_text } from './lane-breakdown-text'
+import { lane_ledger } from './lane-ledger'
+import { lane_net_time } from './lane-net-time'
+
+// `josh lane:breakdown <issue>` — a merged lane's net time by stage (joshuafolkken/kit#4995), the same
+// breakdown its overrun investigation comments on its Issue.
+
+const ARGV_OFFSET = 2
+const FAILURE_EXIT_CODE = 1
+const USAGE = 'Usage: josh lane:breakdown <issue>'
+
+async function read_ledger(): Promise<ReturnType<typeof lane_ledger.read_entries>> {
+	const path = await lane_ledger.target()
+
+	return path === undefined ? [] : lane_ledger.read_entries(path)
+}
+
+function missing(issue: string): number {
+	const lane = session_cite.issue(issue)
+
+	console.error(`josh lane:breakdown ${issue}: the ledger holds no dispatch and merge of ${lane}`)
+
+	return FAILURE_EXIT_CODE
+}
+
+async function print(issue: string): Promise<number> {
+	const [entries, events] = [await read_ledger(), await run_event_stream_emit.all_events()]
+	const minutes = lane_net_time.net_minutes(entries, events, Number(issue))
+	const breakdown = lane_breakdown.of(entries, events, Number(issue))
+
+	if (minutes === undefined || breakdown === undefined) return missing(issue)
+
+	const report = lane_breakdown_text.report_of(Number(issue), breakdown, entries)
+
+	console.info(lane_breakdown_text.comment(Number(issue), minutes, report))
+
+	return 0
+}
+
+async function run(argv: ReadonlyArray<string>): Promise<number> {
+	const [issue = ''] = argv
+
+	if (argv.length === 1 && issue_number_shape.is_issue_number(issue)) return await print(issue)
+
+	console.error(USAGE)
+
+	return FAILURE_EXIT_CODE
+}
+
+async function main(argv: ReadonlyArray<string>): Promise<void> {
+	process.exitCode = await run(argv)
+}
+
+const lane_breakdown_cli = { USAGE, run }
+
+if (process.argv[1] === fileURLToPath(import.meta.url)) await main(process.argv.slice(ARGV_OFFSET))
+
+export { lane_breakdown_cli }

package/scripts/lane/lane-breakdown-implement.ts

@@ -0,0 +1,170 @@
+import { cost_transcript } from '#scripts/cost-runtime/cost-transcript'
+import { lane_breakdown, type Breakdown, type Stage } from './lane-breakdown'
+import type { LaneSpan } from './lane-net-time'
+import type { Subagent, ToolCall } from './lane-transcript-calls'
+import { lane_transcript_stats } from './lane-transcript-stats'
+
+// The implementation stage of a lane's breakdown (joshuafolkken/kit#4995) split by what its tool calls
+// spent, read off the lane's transcripts: the main josh commands, the subagents, the reads and the rest
+// of Bash, and what no call spent — the edits and the thinking. A backgrounded call has no duration
+// (`lane-transcript-calls.ts`), so the wait on its result falls in the remainder; only its count shows.
+//
+// **The subagents split by the agent dispatched** — `subagent: investigator`, `subagent: reviewer`, …
+// — and a backgrounded subagent call still names its kind, at no time, with its count beside it
+// (joshuafolkken/kit#5297). `run:review` and `ship` / `ship:wait` count apart from other bash
+// (joshuafolkken/kit#5293).
+
+const REMAINDER = 'editing & thinking'
+const OTHER_BASH = 'other bash'
+const BASH_TOOL = 'Bash'
+const READ = 'read'
+
+const TOOL_KINDS: ReadonlyMap<string, string> = new Map([
+	['Read', READ],
+	['Grep', READ],
+	['Glob', READ],
+])
+
+const COMMAND_KINDS: ReadonlyArray<readonly [RegExp, string]> = [
+	[/\bjosh main:merge\b/u, 'main:merge'],
+	[/\bjosh check:related\b/u, 'check:related'],
+	[/\bjosh gate\b/u, 'gate'],
+	[/\bjosh run:review\b/u, 'run:review'],
+	[/\bjosh ship(?::wait)?\b/u, 'ship / ship:wait'],
+	[/\bjosh test(?::[\w-]+)?\b/u, 'test'],
+	[/\bjosh (?:lint|cspell)(?::[\w-]+)?\b/u, 'lint / cspell'],
+]
+
+interface ImplementDetail {
+	// Longest first, the remainder among them.
+	kinds: ReadonlyArray<Stage>
+	// The calls backgrounded inside the implementation.
+	background: number
+	// Each subagent kind's backgrounded calls, counted at no time.
+	untimed: ReadonlyMap<string, number>
+}
+
+function command_kind(command: string): string {
+	return COMMAND_KINDS.find(([pattern]) => pattern.test(command))?.[1] ?? OTHER_BASH
+}
+
+function subagent_kind(subagent: Subagent): string {
+	return `subagent: ${subagent.type}`
+}
+
+// The kind a call counts under, `undefined` for one that falls in the remainder (an edit included).
+function kind_of(call: ToolCall): string | undefined {
+	if (call.tool === BASH_TOOL) return command_kind(call.command ?? '')
+	if (call.subagent !== undefined) return subagent_kind(call.subagent)
+
+	return TOOL_KINDS.get(call.tool ?? '')
+}
+
+interface TimedPart extends Stage {
+	from_ms: number
+}
+
+function is_untimed_subagent(call: ToolCall): boolean {
+	return call.background && call.subagent !== undefined
+}
+
+// A call's own milliseconds, cut at the end of the span it started in; a backgrounded subagent call's none.
+function timed_part(call: ToolCall, span: LaneSpan): ReadonlyArray<TimedPart> {
+	const name = kind_of(call)
+
+	if (name === undefined) return []
+
+	const ms = Math.min(call.duration_ms ?? 0, span.to_ms - call.started_ms)
+	const is_counted = call.duration_ms !== undefined || is_untimed_subagent(call)
+
+	return is_counted ? [{ name, ms, from_ms: call.started_ms }] : []
+}
+
+function untimed_of(placed: ReadonlyArray<readonly [ToolCall, LaneSpan]>): Map<string, number> {
+	const counts = new Map<string, number>()
+	const kinds = placed.filter(([call]) => is_untimed_subagent(call)).map(([call]) => kind_of(call))
+
+	for (const kind of kinds) if (kind !== undefined) counts.set(kind, (counts.get(kind) ?? 0) + 1)
+
+	return counts
+}
+
+// What neither a timed call nor a wait covers of the implementation's spans, each millisecond once.
+function remainder_ms(parts: ReadonlyArray<TimedPart>, breakdown: Breakdown): number {
+	const busy = parts.map((part) => ({ from_ms: part.from_ms, to_ms: part.from_ms + part.ms }))
+	const covering = [...busy, ...breakdown.waits]
+	const idle = breakdown.implement.map(
+		(span) => span.to_ms - span.from_ms - lane_breakdown.covered_ms(span, covering),
+	)
+
+	return idle.reduce((sum, ms) => sum + ms, 0)
+}
+
+function span_of(call: ToolCall, spans: ReadonlyArray<LaneSpan>): LaneSpan | undefined {
+	return spans.find((span) => call.started_ms >= span.from_ms && call.started_ms < span.to_ms)
+}
+
+function placed_of(
+	calls: ReadonlyArray<ToolCall>,
+	spans: ReadonlyArray<LaneSpan>,
+): Array<readonly [ToolCall, LaneSpan]> {
+	return calls.flatMap((call) => {
+		const span = span_of(call, spans)
+
+		return span === undefined ? [] : [[call, span] as const]
+	})
+}
+
+// The implementation split by the calls made inside it — parallel calls each count their own time, so
+// the kinds can add up to more — and the remainder, the time no call and no wait covered.
+function of(calls: ReadonlyArray<ToolCall>, breakdown: Breakdown): ImplementDetail {
+	const placed = placed_of(calls, breakdown.implement)
+	const parts = placed.flatMap(([call, span]) => timed_part(call, span))
+	const remainder = { name: REMAINDER, ms: remainder_ms(parts, breakdown) }
+
+	return {
+		kinds: lane_breakdown.ranked([...parts, remainder]),
+		background: placed.filter(([call]) => call.background).length,
+		untimed: untimed_of(placed),
+	}
+}
+
+// The Bash calls started inside `spans`, by the implementation's kinds — the fixes, re-ships and checks
+// a lane child ran between two ship stages (joshuafolkken/kit#5294).
+function bash_kinds(calls: ReadonlyArray<ToolCall>, spans: ReadonlyArray<LaneSpan>): Array<Stage> {
+	const placed = placed_of(
+		calls.filter((call) => call.tool === BASH_TOOL),
+		spans,
+	)
+
+	return lane_breakdown.ranked(placed.flatMap(([call, span]) => timed_part(call, span)))
+}
+
+// The lane's own transcript directories — `<lane root slug>-<issue>` under `~/.claude/projects`.
+function transcript_directories(issue: number): ReadonlyArray<string> {
+	const main_cwd = cost_transcript.session_cwd(process.cwd())
+	const home = cost_transcript.home_directory()
+	const suffix = `-${String(issue)}`
+
+	return cost_transcript
+		.lane_transcript_directories(main_cwd, home)
+		.filter((directory) => directory.endsWith(suffix))
+}
+
+// The tool calls of `issue`'s lane sessions still written to once its implementation began, up to the
+// end of its last ship stage.
+function read(issue: number, breakdown: Breakdown): Array<ToolCall> {
+	const [first] = breakdown.implement
+	const last = breakdown.ship.at(-1) ?? breakdown.implement.at(-1)
+
+	if (first === undefined || last === undefined) return []
+
+	const window = { since_ms: first.from_ms, until_ms: last.to_ms }
+
+	return lane_transcript_stats.read_calls(transcript_directories(issue), window)
+}
+
+const lane_breakdown_implement = { bash_kinds, of, read, transcript_directories }
+
+export { lane_breakdown_implement }
+export type { ImplementDetail }

package/scripts/lane/lane-breakdown-laps.ts

@@ -0,0 +1,107 @@
+import { lane_breakdown, type Breakdown, type Segment, type Stage } from './lane-breakdown'
+import { lane_breakdown_implement } from './lane-breakdown-implement'
+import { lane_ledger, type LedgerEntry } from './lane-ledger'
+import type { ToolCall } from './lane-transcript-calls'
+
+// What each ship stage of a lane's breakdown spent its time on (joshuafolkken/kit#5294): the laps the
+// ship wrote for its inner steps (`run-ship-lap.ts`), the lane's core-budget waits and the checks of
+// the lane's gates, each under the stage it ended in, and the time between two ship stages split by
+// the Bash the lane child ran there, by the implementation's kinds (`lane-breakdown-implement.ts`).
+// A lap and a wait or a check inside it overlap — the gate's wait for cores and its checks, run side
+// by side, are part of its `josh gate` lap — so a stage's laps can add up to more.
+
+const { KIND } = lane_ledger
+const CORE_WAIT_STEP = 'core-budget wait'
+
+// Each stage's laps, longest first, keyed by the stage's name in the breakdown.
+type Laps = ReadonlyMap<string, ReadonlyArray<Stage>>
+
+interface Placed {
+	at_ms: number
+	part: Stage
+}
+
+function lap_of(entry: LedgerEntry, issue: number): ReadonlyArray<Placed> {
+	if (entry.kind !== KIND.SHIP_LAP || entry.issue !== issue) return []
+
+	return [{ at_ms: Date.parse(entry.at), part: { name: entry.step, ms: entry.elapsed_ms } }]
+}
+
+function wait_of(entry: LedgerEntry, issue: number): ReadonlyArray<Placed> {
+	if (entry.kind !== KIND.CORE_WAIT || entry.issue !== issue) return []
+
+	return [{ at_ms: Date.parse(entry.at), part: { name: CORE_WAIT_STEP, ms: entry.waited_ms } }]
+}
+
+// Each check the lane's gate ran, placed where the gate ended (joshuafolkken/kit#5319). A row with no
+// `issue` — outside a lane, or written before the gate recorded it — is no lane's; a reused check
+// started nothing, so its zero is no time spent.
+function checks_of(entry: LedgerEntry, issue: number): ReadonlyArray<Placed> {
+	if (entry.kind !== KIND.GATE || entry.issue !== issue) return []
+	const at_ms = Date.parse(entry.at)
+
+	return (entry.checks ?? [])
+		.filter((check) => check.is_reused !== true)
+		.map((check) => ({ at_ms, part: { name: check.label, ms: check.elapsed_ms } }))
+}
+
+// The ship stage a lap, a wait or a check ended in — never the time between stages, which the ship runs nothing in.
+function stage_at(segments: ReadonlyArray<Segment>, at_ms: number): string | undefined {
+	const segment = segments.find((span) => at_ms > span.from_ms && at_ms <= span.to_ms)
+
+	return segment?.stage === lane_breakdown.BETWEEN_STAGE ? undefined : segment?.stage
+}
+
+function grouped(
+	placed: ReadonlyArray<Placed>,
+	segments: ReadonlyArray<Segment>,
+): Map<string, Array<Stage>> {
+	const groups = new Map<string, Array<Stage>>()
+
+	for (const { at_ms, part } of placed) {
+		const stage = stage_at(segments, at_ms)
+
+		if (stage !== undefined) groups.set(stage, [...(groups.get(stage) ?? []), part])
+	}
+
+	return groups
+}
+
+function between_of(
+	calls: ReadonlyArray<ToolCall>,
+	segments: ReadonlyArray<Segment>,
+): Array<Stage> {
+	const between = segments.filter((segment) => segment.stage === lane_breakdown.BETWEEN_STAGE)
+
+	return lane_breakdown_implement.bash_kinds(calls, between)
+}
+
+/** `issue`'s ship stages split by their laps, and the time between them by the lane child's Bash. */
+function of(
+	entries: ReadonlyArray<LedgerEntry>,
+	issue: number,
+	breakdown: Breakdown,
+	calls: ReadonlyArray<ToolCall>,
+): Laps {
+	const placed = entries.flatMap((entry) => [
+		...lap_of(entry, issue),
+		...wait_of(entry, issue),
+		...checks_of(entry, issue),
+	])
+	const laps = new Map(
+		[...grouped(placed, breakdown.ship)].map(([stage, parts]) => [
+			stage,
+			lane_breakdown.ranked(parts),
+		]),
+	)
+	const between = between_of(calls, breakdown.ship)
+
+	if (between.length > 0) laps.set(lane_breakdown.BETWEEN_STAGE, between)
+
+	return laps
+}
+
+const lane_breakdown_laps = { CORE_WAIT_STEP, of }
+
+export { lane_breakdown_laps }
+export type { Laps }