@joshuafolkken/kit 1.2116.0 → 1.3041.0

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

@@ -0,0 +1,40 @@
+import { lane_ledger, type LedgerEntry, type TestRelatedEntry } from './lane-ledger'
+
+// What a lane's `josh test:related` runs left unchecked (joshuafolkken/kit#5532): the changed files
+// past the reach cap, run by their direct importers alone, over the lane's runs.
+
+const LABEL = 'test:related'
+
+function is_lane_row(entry: LedgerEntry, issue: number): entry is TestRelatedEntry {
+	return entry.kind === lane_ledger.KIND.TEST_RELATED && entry.issue === issue
+}
+
+// The hub the most capped runs named, the earliest on a tie (joshuafolkken/kit#5699); none where no
+// run recorded one.
+function top_hub(rows: ReadonlyArray<TestRelatedEntry>): string | undefined {
+	const tally = new Map<string, number>()
+
+	for (const { over_cap_hub } of rows) {
+		if (over_cap_hub !== undefined) tally.set(over_cap_hub, (tally.get(over_cap_hub) ?? 0) + 1)
+	}
+
+	return [...tally].toSorted((first, second) => second[1] - first[1])[0]?.[0]
+}
+
+// The line `josh lane:breakdown` prints, `''` when no run of `issue` capped a file. The count is the
+// widest run's, the number its own summary line printed: a sum over runs counts one capped file once a
+// run (joshuafolkken/kit#6187).
+function over_cap_text(entries: ReadonlyArray<LedgerEntry>, issue: number): string {
+	const rows = entries.filter((entry) => is_lane_row(entry, issue))
+	const over_cap = Math.max(0, ...rows.map((row) => row.over_cap ?? 0))
+	if (over_cap === 0) return ''
+	const capped = rows.filter((row) => (row.over_cap ?? 0) > 0).length
+	const hub = top_hub(rows)
+	const text = `${LABEL} ${String(over_cap)} over cap, in ${String(capped)} of ${String(rows.length)} runs`
+
+	return hub === undefined ? text : `${text}, hub ${hub}`
+}
+
+const lane_breakdown_related = { over_cap_text }
+
+export { lane_breakdown_related }

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

@@ -1,42 +1,86 @@
+import type { RunEvent } from '#scripts/run/event/run-event-stream'
 import { lane_breakdown, type Breakdown, type Stage } from './lane-breakdown'
-import { lane_breakdown_implement, type ImplementDetail } from './lane-breakdown-implement'
+import { lane_breakdown_calls, type CallGroup } from './lane-breakdown-calls'
+import {
+	lane_breakdown_implement,
+	type ImplementDetail,
+	type PlanOutside,
+} from './lane-breakdown-implement'
 import { lane_breakdown_laps, type Laps } from './lane-breakdown-laps'
 import { lane_breakdown_pinned } from './lane-breakdown-pinned'
+import { lane_breakdown_related } from './lane-breakdown-related'
 import { lane_ci_path_stats } from './lane-ci-path-stats'
+import { lane_elapsed_time } from './lane-elapsed-time'
 import type { LedgerEntry } from './lane-ledger'
+import { lane_stage_budget, type BudgetStage } from './lane-stage-budget'
 
 // A lane's breakdown in words (joshuafolkken/kit#4995): the stages longest first, the implementation's
-// tool-call kinds beside it, and the waits taken out last. `josh lane:breakdown` prints it, the overrun
+// tool-call kinds beside it, the waits taken out, and the driver's followup outside the net time last. `josh lane:breakdown` prints it, the overrun
 // investigation comments it on the lane's Issue and leads its prompt with it (`lane-overrun.ts`).
 
 const HEADING = 'Net time by stage, longest first'
-const EXCLUDED = 'waits taken out (park, outage, usage limit, yield, host sleep)'
+const EXCLUDED = 'waits taken out (park, outage, usage limit, yield, split run, host sleep)'
 const SLEPT = 'of which host sleep'
 const YIELDED = 'of which yield wait'
+const HOLDER = 'yield wait: holder remaining'
+const GAP = 'yield wait: redispatch gap (offer + launch)'
+const UNSPLIT = 'yield wait: no holder named, unsplit'
+const OUTSIDE = 'outside calls'
+const DRIVER = '(outside lane net)'
 
 interface Report {
+	elapsed?: string | undefined
 	breakdown: Breakdown
 	detail: ImplementDetail
 	// The ship pre-detach line's `test:pinned` detail, `''` when none (joshuafolkken/kit#5078).
 	pinned?: string
 	// The discarded `run:review` background probes' line, `''` when none (joshuafolkken/kit#5262).
 	discarded?: string
+	// The `test:related` files past the reach cap, `''` when none (joshuafolkken/kit#5532).
+	related?: string
 	// The followup's CI wait's last check to settle, `''` when none was recorded (joshuafolkken/kit#5295).
 	critical?: string
-	// Each ship stage's laps, and the Bash between ship stages, longest first (joshuafolkken/kit#5294).
+	// Each ship stage's laps, and the call kinds between ship stages, longest first (joshuafolkken/kit#5294).
 	laps?: Laps
+	// The start to plan's longest call groups (joshuafolkken/kit#5539).
+	plan_calls?: ReadonlyArray<CallGroup>
+	// The start to plan's time outside every call and wait, absent when no calls were read
+	// (joshuafolkken/kit#6119).
+	plan_outside?: PlanOutside | undefined
 }
 
-// A stage's line and the laps printed under it.
+// A stage's line, the laps printed under it, and the call groups printed under it in the bullets
+// alone — the one-line form leaves them out.
 interface Entry {
 	text: string
 	laps: ReadonlyArray<string>
+	calls: ReadonlyArray<string>
 }
 
 function part_text(part: Stage): string {
 	return `${part.name} ${lane_breakdown.minutes_text(part.ms)}`
 }
 
+// The lane budget a stage counts against (`lane-stage-budget.ts`), `undefined` for one with none.
+function budget_of(name: string): BudgetStage | undefined {
+	const stages: Record<string, BudgetStage | undefined> = {
+		[lane_breakdown.PLAN_STAGE]: 'plan',
+		[lane_breakdown.IMPLEMENT_STAGE]: 'implement',
+		[lane_breakdown.DRIVER_FOLLOWUP_STAGE]: 'followup',
+	}
+	const ship = lane_breakdown.is_ship_stage(name) ? 'ship' : undefined
+
+	return stages[name] ?? ship
+}
+
+// What a stage ran past its budget, `''` within it or with none (joshuafolkken/kit#5563).
+function over_text(stage: Stage): string {
+	const budget = budget_of(stage.name)
+	const over = budget === undefined ? undefined : lane_stage_budget.over_minutes(budget, stage.ms)
+
+	return over === undefined ? '' : `, over budget +${String(over)} min`
+}
+
 // A kind's minutes, and the backgrounded subagent calls it counted at no time.
 function kind_text(kind: Stage, untimed: ImplementDetail['untimed']): string {
 	const count = untimed.get(kind.name) ?? 0
@@ -58,42 +102,112 @@ function reason_text(reason: string | undefined): string {
 	return reason === undefined ? '' : ` (${reason})`
 }
 
+// The start to plan's time outside its calls, and the backgrounded calls whose waits it holds,
+// `undefined` when it is not known.
+function outside_text(outside: PlanOutside | undefined): string | undefined {
+	if (outside === undefined) return undefined
+
+	const minutes = `${OUTSIDE} ${lane_breakdown.minutes_text(outside.ms)}`
+	const count = String(outside.background)
+	const background =
+		outside.background > 0 ? [`${count} backgrounded calls, their waits in it`] : []
+
+	return ` (${[minutes, ...background].join(', ')})`
+}
+
 // The detail a stage's line carries after its minutes, `''` for a stage with none.
 function suffix_of(name: string, report: Report): string {
 	const suffixes: Record<string, string | undefined> = {
+		[lane_breakdown.PLAN_STAGE]: outside_text(report.plan_outside),
 		[lane_breakdown.IMPLEMENT_STAGE]: detail_text(report.detail),
 		[lane_breakdown.PRE_DETACH_STAGE]: report.pinned,
-		[lane_breakdown.FOLLOWUP_STAGE]: report.critical,
 	}
 
 	return suffixes[name] ?? reason_text(report.breakdown.reasons?.get(name))
 }
 
+// Each implementation kind's longest call groups, the kind leading each line.
+function implement_calls(detail: ImplementDetail): Array<string> {
+	return detail.kinds.flatMap((kind) =>
+		(detail.calls?.get(kind.name) ?? []).map(
+			(group) => `${kind.name} › ${lane_breakdown_calls.group_text(group)}`,
+		),
+	)
+}
+
+// The call groups printed under a stage, none for a stage other than the start to plan and the implement.
+function calls_of(name: string, report: Report): Array<string> {
+	if (name === lane_breakdown.IMPLEMENT_STAGE) return implement_calls(report.detail)
+	if (name !== lane_breakdown.PLAN_STAGE) return []
+
+	return (report.plan_calls ?? []).map((group) => lane_breakdown_calls.group_text(group))
+}
+
 function stage_entry(stage: Stage, report: Report): Entry {
 	const laps = report.laps?.get(stage.name) ?? []
 
 	return {
-		text: `${part_text(stage)}${suffix_of(stage.name, report)}`,
+		text: `${part_text(stage)}${over_text(stage)}${suffix_of(stage.name, report)}`,
 		laps: laps.map((lap) => part_text(lap)),
+		calls: calls_of(stage.name, report),
 	}
 }
 
-function entries_of(report: Report): Array<Entry> {
-	const { breakdown } = report
+// The yield wait's holder remaining time and redispatch gap, and the wait no note's holder splits,
+// the lines under the waits taken out — each only where it counted time (joshuafolkken/kit#6006).
+function yield_lines(breakdown: Breakdown): Array<string> {
+	const split = breakdown.yield_split
+
+	if (split === undefined || breakdown.yield_ms === 0) return []
+
+	const named: Array<Stage> = [
+		{ name: HOLDER, ms: split.holder_ms },
+		{ name: GAP, ms: split.gap_ms },
+	]
+	const unsplit: Array<Stage> = [{ name: UNSPLIT, ms: split.unsplit_ms }]
+
+	return [
+		...(split.holder_ms + split.gap_ms > 0 ? named : []),
+		...(split.unsplit_ms > 0 ? unsplit : []),
+	].map((part) => part_text(part))
+}
+
+function excluded_entry(breakdown: Breakdown): Entry {
 	const yielded = `${YIELDED} ${lane_breakdown.minutes_text(breakdown.yield_ms)}`
 	const slept = `${SLEPT} ${lane_breakdown.minutes_text(breakdown.slept_ms)}`
 	const excluded = `${EXCLUDED} ${lane_breakdown.minutes_text(breakdown.excluded_ms)}, ${yielded}, ${slept}`
 
-	const discarded =
-		report.discarded === undefined || report.discarded === '' ? [] : [report.discarded]
+	return { text: excluded, laps: yield_lines(breakdown), calls: [] }
+}
 
-	const tail = [...discarded, excluded].map((text) => ({ text, laps: [] }))
+// The driver's followup, outside the net time, with the followup's laps and last check
+// (joshuafolkken/kit#6541).
+function driver_entry(stage: Stage, report: Report): Entry {
+	const laps = report.laps?.get(lane_breakdown.FOLLOWUP_STAGE) ?? []
 
-	return [...breakdown.stages.map((stage) => stage_entry(stage, report)), ...tail]
+	return {
+		text: `${part_text(stage)} ${DRIVER}${over_text(stage)}${report.critical ?? ''}`,
+		laps: laps.map((lap) => part_text(lap)),
+		calls: [],
+	}
+}
+
+function entries_of(report: Report): Array<Entry> {
+	const { breakdown } = report
+	const notes = [report.discarded, report.related]
+		.filter((text): text is string => text !== undefined && text !== '')
+		.map((text) => ({ text, laps: [], calls: [] }))
+
+	return [
+		...breakdown.stages.map((stage) => stage_entry(stage, report)),
+		...notes,
+		excluded_entry(breakdown),
+		...(breakdown.driver ?? []).map((stage) => driver_entry(stage, report)),
+	]
 }
 
 function bullets_of(entry: Entry): Array<string> {
-	return [`- ${entry.text}`, ...entry.laps.map((lap) => `  - ${lap}`)]
+	return [`- ${entry.text}`, ...[...entry.laps, ...entry.calls].map((lap) => `  - ${lap}`)]
 }
 
 function inline_of(entry: Entry): string {
@@ -106,17 +220,23 @@ function report_of(
 	issue: number,
 	breakdown: Breakdown,
 	entries: ReadonlyArray<LedgerEntry>,
+	events: ReadonlyArray<RunEvent> = [],
 ): Report {
 	const calls = lane_breakdown_implement.read(issue, breakdown)
 	const rows = lane_breakdown_pinned.rows_of(entries, issue, breakdown)
+	const timing = lane_elapsed_time.of(entries, events, issue, calls)
 
 	return {
+		elapsed: timing === undefined ? undefined : lane_elapsed_time.text(timing),
 		breakdown,
 		detail: lane_breakdown_implement.of(calls, breakdown),
 		laps: lane_breakdown_laps.of(entries, issue, breakdown, calls),
 		pinned: lane_breakdown_pinned.detail_text(rows),
 		discarded: lane_breakdown_pinned.discarded_text(entries, issue),
+		related: lane_breakdown_related.over_cap_text(entries, issue),
 		critical: lane_ci_path_stats.last_check_text(entries, issue),
+		plan_calls: lane_breakdown_implement.plan_calls(calls, breakdown),
+		plan_outside: lane_breakdown_implement.plan_outside(calls, breakdown),
 	}
 }
 
@@ -129,6 +249,7 @@ function comment(issue: number, minutes: number, report: Report): string {
 		`${lead} ${source}`,
 		'',
 		...entries_of(report).flatMap((entry) => bullets_of(entry)),
+		...(report.elapsed === undefined ? [] : [report.elapsed]),
 	].join('\n')
 }
 
@@ -139,7 +260,7 @@ function line(report: Report): string {
 		.join('; ')}.`
 }
 
-const lane_breakdown_text = { comment, line, report_of }
+const lane_breakdown_text = { budget_of, comment, line, report_of }
 
 export { lane_breakdown_text }
 export type { Report }

package/scripts/lane/lane-breakdown.ts

@@ -1,15 +1,19 @@
 import { MS_PER_MINUTE } from '#scripts/lib/timeouts'
 import { run_event_stream, type RunEvent } from '#scripts/run/event/run-event-stream'
 import { run_ship_stage } from '#scripts/run/ship/run-ship-stage'
+import { lane_breakdown_pause, type PauseMark } from './lane-breakdown-pause'
 import { lane_ledger, type LedgerEntry } from './lane-ledger'
 import { lane_net_time, type LaneSpan } from './lane-net-time'
+import { lane_plan_wait_event } from './lane-plan-wait-event'
+import { lane_stage_events } from './lane-stage-events'
 import { lane_stop_stats } from './lane-stop-stats'
+import { lane_yield_split, type YieldShare } from './lane-yield-split'
 
 // A lane's net time by stage (joshuafolkken/kit#4995), read off the run events it already leaves: from
-// its dispatch to its `plan`, the implementation from the `plan` (or `lane-phase implement`) to the first
-// ship stage, each ship stage from its start to its end, and the time between ship stages — a stopped
-// stage's fix included. The waits `lane:net` takes out are taken out of the stage they fell in and
-// counted apart, so the stages add up to the net time. A cut and its resume open no stage: the
+// its dispatch to its `plan`, the implementation from the `plan` (or `lane-phase implement`, or else
+// the first edit) to the first ship stage, each ship stage from its start to its end, and the time
+// between ship stages — a stopped stage's fix included. The waits `lane:net` takes out are taken out of the stage they fell in and
+// counted apart, so the stages add up to the net time; the ship's followup is a driver stage outside it. A cut and its resume open no stage: the
 // implementation stays one stage across them.
 
 const { EVENT_KIND } = run_event_stream
@@ -18,10 +22,14 @@ const { PHASE } = run_ship_stage
 const PLAN_STAGE = 'start to plan'
 const IMPLEMENT_STAGE = 'implement'
 const BETWEEN_STAGE = 'between ship stages'
+// A ship stop's marker before `closed` reads it — never a stage.
+const STOP_MARK = 'stop'
 const SHIP_LEAD = 'ship '
-const IMPLEMENT_SUFFIX = ' implement'
 const PRE_DETACH_STAGE = `${SHIP_LEAD}${lane_ledger.PRE_DETACH_STAGE}`
 const FOLLOWUP_STAGE = `${SHIP_LEAD}${run_ship_stage.STAGE.FOLLOWUP}`
+const ROUND_TWO_STAGE = `${SHIP_LEAD}${run_ship_stage.STAGE.ROUND_TWO}`
+// The ship's followup, outside the lane's net time (joshuafolkken/kit#6541).
+const DRIVER_FOLLOWUP_STAGE = `driver ${run_ship_stage.STAGE.FOLLOWUP}`
 
 // One stage's net milliseconds.
 interface Stage {
@@ -30,16 +38,25 @@ interface Stage {
 }
 
 interface Breakdown {
-	// Longest first, the waits taken out.
+	// Longest first, the waits and the driver's followup taken out.
 	stages: ReadonlyArray<Stage>
+	// The driver's followup outside the waits — CI, CodeRabbit and the merge, no lane seat held — or
+	// empty without one.
+	driver?: ReadonlyArray<Stage>
 	// The waits taken out, together.
 	excluded_ms: number
 	// The host's sleeps among them (joshuafolkken/kit#5032).
 	slept_ms: number
 	// The yields' waits for a redispatch among them (joshuafolkken/kit#5216).
 	yield_ms: number
+	// That yield wait split into the holder's remaining time and the redispatch gap
+	// (joshuafolkken/kit#6006).
+	yield_split?: YieldShare
 	// The waits taken out, each — the implementation's split leaves them out of its remainder too.
 	waits: ReadonlyArray<LaneSpan>
+	// The start-to-plan spans, waits left in — the window its longest calls are read in
+	// (joshuafolkken/kit#5539).
+	plan?: ReadonlyArray<LaneSpan>
 	// The implementation's spans, waits left in — the window its tool calls are read in.
 	implement: ReadonlyArray<LaneSpan>
 	// The ship pre-detach stage's spans — the window its `test:pinned` rows are read in
@@ -48,6 +65,11 @@ interface Breakdown {
 	// Each ship stage's spans and the spans between them, waits left in — the windows its laps and the
 	// fixes between stages are read in (joshuafolkken/kit#5294).
 	ship: ReadonlyArray<Segment>
+	// Every stage's spans in time order, waits left in, each with its net milliseconds — the rows
+	// `lane:breakdown --timeline` prints (joshuafolkken/kit#7186).
+	segments?: ReadonlyArray<NetSegment>
+	// The lane's parks, each naming the stretch between ship stages it fell in (joshuafolkken/kit#5646).
+	pauses?: ReadonlyArray<PauseMark>
 	// Why each ship stage last ran or was skipped, where its event line said (joshuafolkken/kit#5296).
 	reasons?: ReadonlyMap<string, string>
 }
@@ -56,8 +78,18 @@ interface Segment extends LaneSpan {
 	stage: string
 }
 
+// A segment and its length less what the time outside the lane covers of it.
+interface NetSegment extends Segment {
+	net_ms: number
+}
+
+// A ship stage's name, or the between-ship-stages bucket's.
+function is_ship_stage(name: string): boolean {
+	return name.startsWith(SHIP_LEAD) || name === BETWEEN_STAGE
+}
+
 function is_ship(segment: Segment): boolean {
-	return segment.stage.startsWith(SHIP_LEAD) || segment.stage === BETWEEN_STAGE
+	return is_ship_stage(segment.stage)
 }
 
 interface Marker {
@@ -65,6 +97,11 @@ interface Marker {
 	stage: string
 }
 
+interface Records {
+	entries: ReadonlyArray<LedgerEntry>
+	events: ReadonlyArray<RunEvent>
+}
+
 function ship_stage_of(text: string): string {
 	const { stage, phase } = run_ship_stage.words_of(text)
 
@@ -74,11 +111,8 @@ function ship_stage_of(text: string): string {
 // The stage an event opens, `undefined` for one that opens none.
 function stage_of(event: RunEvent): string | undefined {
 	if (event.kind === EVENT_KIND.SHIP_STAGE) return ship_stage_of(event.text)
-	const is_implement =
-		event.kind === EVENT_KIND.PLAN ||
-		(event.kind === EVENT_KIND.LANE_PHASE && event.text.endsWith(IMPLEMENT_SUFFIX))
 
-	return is_implement ? IMPLEMENT_STAGE : undefined
+	return lane_breakdown_pause.is_planning(event) ? IMPLEMENT_STAGE : undefined
 }
 
 function is_inside(at_ms: number, span: LaneSpan): boolean {
@@ -116,19 +150,69 @@ function reasons_of(
 	return new Map(ordered.flatMap((event) => reason_of(event, issue, span)))
 }
 
+// Whether a lane's first edit opens the implementation: no `plan` / `lane-phase implement` marker did,
+// and the edit came before the first stage another event opened.
+function opens_implement(opened: ReadonlyArray<Marker>, edit_ms: number): boolean {
+	const [first] = opened
+
+	if (opened.some((marker) => marker.stage === IMPLEMENT_STAGE)) return false
+
+	return first === undefined || edit_ms < first.at_ms
+}
+
+// The implementation's marker at the lane's first edit, where no event marked it — a docs-only lane
+// writes no runtime file, so its edits never write the `plan` / `lane-phase implement` events
+// (joshuafolkken/kit#5835).
+function edit_markers(
+	opened: ReadonlyArray<Marker>,
+	span: LaneSpan,
+	edit_ms: number | undefined,
+): Array<Marker> {
+	if (edit_ms === undefined || !is_inside(edit_ms, span)) return []
+
+	return opens_implement(opened, edit_ms) ? [{ at_ms: edit_ms, stage: IMPLEMENT_STAGE }] : []
+}
+
+function stop_of(entry: LedgerEntry, issue: number, span: LaneSpan): ReadonlyArray<Marker> {
+	if (entry.kind !== lane_ledger.KIND.STOP || entry.issue !== issue) return []
+	const at_ms = Date.parse(entry.at)
+
+	return is_inside(at_ms, span) ? [{ at_ms, stage: STOP_MARK }] : []
+}
+
+// A ship's stop closes the ship stage open at it (joshuafolkken/kit#6140) — a preflight stop writes
+// no stage of its own after its `pre-detach start` — and opens nothing anywhere else.
+function closing(marker: Marker, before: Marker | undefined): ReadonlyArray<Marker> {
+	if (marker.stage !== STOP_MARK) return [marker]
+	if (before?.stage.startsWith(SHIP_LEAD) !== true) return []
+
+	return [{ ...marker, stage: BETWEEN_STAGE }]
+}
+
+function closed(markers: ReadonlyArray<Marker>): Array<Marker> {
+	return markers.flatMap((marker, index) => closing(marker, markers[index - 1]))
+}
+
+// The stages the lane's events and ship stops opened, in time order.
+function opened_of(records: Records, issue: number, span: LaneSpan): Array<Marker> {
+	const events = records.events.flatMap((event) => marker_of(event, issue, span))
+	const stops = records.entries.flatMap((entry) => stop_of(entry, issue, span))
+
+	return closed([...events, ...stops].toSorted((left, right) => left.at_ms - right.at_ms))
+}
+
 function segments_of(
-	events: ReadonlyArray<RunEvent>,
-	issue: number,
+	opened: ReadonlyArray<Marker>,
 	span: LaneSpan,
+	edit_ms: number | undefined,
 ): Array<Segment> {
-	const opened = events
-		.flatMap((event) => marker_of(event, issue, span))
-		.toSorted((left, right) => left.at_ms - right.at_ms)
 	// A marker of the stage already open opens nothing: the `plan` and `lane-phase implement` of one
 	// start, or of a resumed session, leave the implementation one span.
-	const markers = [{ at_ms: span.from_ms, stage: PLAN_STAGE }, ...opened].filter(
-		(marker, index, all) => marker.stage !== all[index - 1]?.stage,
-	)
+	const markers = [
+		{ at_ms: span.from_ms, stage: PLAN_STAGE },
+		...edit_markers(opened, span, edit_ms),
+		...opened,
+	].filter((marker, index, all) => marker.stage !== all[index - 1]?.stage)
 
 	return markers.map((marker, index) => ({
 		stage: marker.stage,
@@ -137,6 +221,18 @@ function segments_of(
 	}))
 }
 
+// The lane's stages as spans, each `lane:plan` wait cut out as a stage of its own.
+function lane_segments(
+	records: Records,
+	issue: number,
+	span: LaneSpan,
+	edit_ms: number | undefined,
+): Array<Segment> {
+	const segments = segments_of(opened_of(records, issue, span), span, edit_ms)
+
+	return lane_plan_wait_event.carved(segments, lane_plan_wait_event.spans(records.events, issue))
+}
+
 function clipped(segment: LaneSpan, parts: ReadonlyArray<LaneSpan>): Array<LaneSpan> {
 	return parts
 		.map((part) => ({
@@ -177,39 +273,122 @@ function spans_ms(spans: ReadonlyArray<LaneSpan>): number {
 	return spans.reduce((sum, span) => sum + span.to_ms - span.from_ms, 0)
 }
 
+type Windows = Pick<Breakdown, 'plan' | 'implement' | 'pre_detach' | 'ship'>
+
+// The stages' spans each later read is windowed by.
+function windows_of(segments: ReadonlyArray<Segment>): Windows {
+	return {
+		plan: segments.filter((segment) => segment.stage === PLAN_STAGE),
+		implement: segments.filter((segment) => segment.stage === IMPLEMENT_STAGE),
+		pre_detach: segments.filter((segment) => segment.stage === PRE_DETACH_STAGE),
+		ship: segments.filter((segment) => is_ship(segment)),
+	}
+}
+
+// The yields' wait inside `span`, and its split into the holder's remaining time and the redispatch
+// gap — the yields whose wait began inside it.
+function yields_of(
+	entries: ReadonlyArray<LedgerEntry>,
+	events: ReadonlyArray<RunEvent>,
+	issue: number,
+	span: LaneSpan,
+): Pick<Breakdown, 'yield_ms' | 'yield_split'> {
+	const splits = lane_yield_split
+		.issue_parts(entries, events, issue)
+		.filter((split) => is_inside(split.wait.from_ms, span))
+
+	return {
+		yield_ms: spans_ms(lane_net_time.yielded(entries, events, issue, span)),
+		yield_split: lane_yield_split.share_of(splits),
+	}
+}
+
+// Each segment less what `outside` covers of it, longest first. The followup stage is all driver
+// time, so it is left out rather than listed at zero.
+function net_segments_of(
+	segments: ReadonlyArray<Segment>,
+	outside: ReadonlyArray<LaneSpan>,
+): Array<NetSegment> {
+	return segments.map((segment) => ({
+		...segment,
+		net_ms: segment.to_ms - segment.from_ms - covered_ms(segment, outside),
+	}))
+}
+
+function stages_of(segments: ReadonlyArray<NetSegment>): Array<Stage> {
+	const parts = segments.map((segment) => ({ name: segment.stage, ms: segment.net_ms }))
+
+	return ranked(parts.filter((part) => part.name !== FOLLOWUP_STAGE))
+}
+
+function driver_of(ms: number): Array<Stage> {
+	return ms > 0 ? [{ name: DRIVER_FOLLOWUP_STAGE, ms }] : []
+}
+
 /**
  * `issue`'s lane by stage, or `undefined` when the ledger holds no dispatch and merge of it — the same
- * span and waits `lane_net_time.net_ms` reads, so the stages add up to it.
+ * span and intervals `lane_net_time.net_ms` reads, so the stages add up to it and the driver's followup
+ * stands apart. `edit_ms`, the lane's first edit, opens the implementation where no event did.
  */
-function of(
+function breakdown_of(
 	entries: ReadonlyArray<LedgerEntry>,
 	events: ReadonlyArray<RunEvent>,
 	issue: number,
+	edit_ms?: number,
 ): Breakdown | undefined {
 	const span = lane_net_time.span_of(entries, issue)
 
 	if (span === undefined) return undefined
 
 	const waits = lane_net_time.waits(entries, events, issue, span)
-	const segments = segments_of(events, issue, span)
-	const parts = segments.map((segment) => ({
-		name: segment.stage,
-		ms: segment.to_ms - segment.from_ms - covered_ms(segment, waits),
-	}))
+	const outside = lane_net_time.outside(entries, events, issue, span)
+	const segments = lane_segments({ entries, events }, issue, span, edit_ms)
+	const net_segments = net_segments_of(segments, outside)
 
 	return {
-		stages: ranked(parts),
+		stages: stages_of(net_segments),
+		driver: driver_of(spans_ms(outside) - spans_ms(waits)),
 		excluded_ms: spans_ms(waits),
 		slept_ms: spans_ms(lane_net_time.slept(events, span)),
-		yield_ms: spans_ms(lane_net_time.yielded(entries, events, issue, span)),
+		...yields_of(entries, events, issue, span),
 		waits,
-		implement: segments.filter((segment) => segment.stage === IMPLEMENT_STAGE),
-		pre_detach: segments.filter((segment) => segment.stage === PRE_DETACH_STAGE),
-		ship: segments.filter((segment) => is_ship(segment)),
+		segments: net_segments,
+		...windows_of(segments),
 		reasons: reasons_of(events, issue, span),
+		pauses: lane_breakdown_pause.of(events, issue, span),
 	}
 }
 
+function of(
+	entries: ReadonlyArray<LedgerEntry>,
+	events: ReadonlyArray<RunEvent>,
+	issue: number,
+	edit_ms?: number,
+): Breakdown | undefined {
+	const span = lane_net_time.span_of(entries, issue)
+	const breakdown = breakdown_of(
+		entries,
+		lane_stage_events.of(entries, events, issue),
+		issue,
+		edit_ms,
+	)
+
+	return breakdown === undefined || span === undefined
+		? undefined
+		: { ...breakdown, reasons: reasons_of(events, issue, span) }
+}
+
+// The stage `at_ms` fell in — the plan, the implementation or a ship stage, by the spans `of` cut — or
+// `undefined` outside them; `josh cost:audit` attributes a request's tokens by it
+// (joshuafolkken/kit#5936).
+function stage_at(breakdown: Breakdown, at_ms: number): string | undefined {
+	const plan = (breakdown.plan ?? []).map((span) => ({ ...span, stage: PLAN_STAGE }))
+	const implement = breakdown.implement.map((span) => ({ ...span, stage: IMPLEMENT_STAGE }))
+	const segments = [...plan, ...implement, ...breakdown.ship]
+
+	return segments.find((segment) => is_inside(at_ms, segment))?.stage
+}
+
 function minutes_text(ms: number): string {
 	return `${(ms / MS_PER_MINUTE).toFixed(1)} min`
 }
@@ -225,14 +404,19 @@ function longest_of(breakdown: Breakdown): { name: string; minutes: number } | u
 
 const lane_breakdown = {
 	BETWEEN_STAGE,
+	DRIVER_FOLLOWUP_STAGE,
 	FOLLOWUP_STAGE,
 	IMPLEMENT_STAGE,
+	PLAN_STAGE,
 	PRE_DETACH_STAGE,
+	ROUND_TWO_STAGE,
 	covered_ms,
+	is_ship_stage,
 	longest_of,
 	minutes_text,
 	of,
 	ranked,
+	stage_at,
 }
 
 export { lane_breakdown }

package/scripts/lane/lane-broker-server.ts

@@ -51,7 +51,7 @@ function read(response: string, session: string): BrokerServer | undefined {
 
 // **The identity is checked when a ship first finds the server, the pid while it waits.** A response
 // a killed supervisor left behind is met on that first look, where a reissued pid must not read as
-// it; the wait polls every 100 ms, where a start-time probe would spawn `ps` on each. Both read
+// it; the wait polls repeatedly, where a start-time probe would spawn `ps` on each. Both read
 // through `is_present_*`, because a Codex lane's ship probes from inside its sandbox, where the kernel
 // answers `EPERM` for a supervisor it has found. A start time that cannot be read is no proof of a
 // dead server, so it does not fail the review.