@joshuafolkken/kit 1.2116.0 → 1.3000.0

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

@@ -1,6 +1,10 @@
 import { cost_transcript } from '#scripts/cost-runtime/cost-transcript'
+import type { RunEvent } from '#scripts/run/event/run-event-stream'
 import { lane_breakdown, type Breakdown, type Stage } from './lane-breakdown'
-import type { LaneSpan } from './lane-net-time'
+import { lane_breakdown_calls, type CallGroup } from './lane-breakdown-calls'
+import { lane_implement_stats } from './lane-implement-stats'
+import type { LedgerEntry } from './lane-ledger'
+import { lane_net_time, type LaneSpan } from './lane-net-time'
 import type { Subagent, ToolCall } from './lane-transcript-calls'
 import { lane_transcript_stats } from './lane-transcript-stats'
 
@@ -18,6 +22,8 @@ const REMAINDER = 'editing & thinking'
 const OTHER_BASH = 'other bash'
 const BASH_TOOL = 'Bash'
 const READ = 'read'
+const EDIT = 'edit'
+const EDIT_TOOLS: ReadonlySet<string> = new Set(['Edit', 'Write'])
 
 const TOOL_KINDS: ReadonlyMap<string, string> = new Map([
 	['Read', READ],
@@ -25,12 +31,23 @@ const TOOL_KINDS: ReadonlyMap<string, string> = new Map([
 	['Glob', READ],
 ])
 
+// Between two ship stages an edit counts as its own kind (joshuafolkken/kit#5834); inside the
+// implementation it stays in the remainder, its editing.
+const BETWEEN_TOOL_KINDS: ReadonlyMap<string, string> = new Map([
+	...TOOL_KINDS,
+	...[...lane_implement_stats.EDIT_TOOLS].map((tool) => [tool, EDIT] as const),
+])
+
 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'],
+	// Match each chain's own arguments, so a join flag on another command cannot rename its open.
+	[/\bjosh run:chain\b[^;&|\n]*\s--join\b/u, 'run:chain join'],
+	[/\bjosh run:chain\b/u, 'run:chain open'],
 	[/\bjosh run:review\b/u, 'run:review'],
-	[/\bjosh ship(?::wait)?\b/u, 'ship / ship:wait'],
+	// Not `\b`: it holds before the `:` of `ship:evidence`, whose wrapped command is its own kind.
+	[/\bjosh ship(?::wait)?(?![\w:-])/u, 'ship / ship:wait'],
 	[/\bjosh test(?::[\w-]+)?\b/u, 'test'],
 	[/\bjosh (?:lint|cspell)(?::[\w-]+)?\b/u, 'lint / cspell'],
 ]
@@ -42,6 +59,13 @@ interface ImplementDetail {
 	background: number
 	// Each subagent kind's backgrounded calls, counted at no time.
 	untimed: ReadonlyMap<string, number>
+	// Each kind's longest call groups (joshuafolkken/kit#5539).
+	calls?: ReadonlyMap<string, ReadonlyArray<CallGroup>>
+}
+
+interface PlanOutside {
+	ms: number
+	background: number
 }
 
 function command_kind(command: string): string {
@@ -52,48 +76,65 @@ 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 {
+// The kind a call counts under, `undefined` for one that falls in the remainder (under `TOOL_KINDS`
+// an edit included).
+function kind_of(call: ToolCall, tool_kinds: ReadonlyMap<string, string>): 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 ?? '')
+	return tool_kinds.get(call.tool ?? '')
 }
 
 interface TimedPart extends Stage {
 	from_ms: number
+	call: ToolCall
 }
 
 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)
+function end_ms(call: ToolCall): number {
+	return call.started_ms + (call.duration_ms ?? 0)
+}
+
+// A call's own milliseconds, cut at both ends of `span`; a backgrounded subagent call's none.
+function timed_part(
+	call: ToolCall,
+	span: LaneSpan,
+	tool_kinds: ReadonlyMap<string, string>,
+): ReadonlyArray<TimedPart> {
+	const name = kind_of(call, tool_kinds)
 
 	if (name === undefined) return []
 
-	const ms = Math.min(call.duration_ms ?? 0, span.to_ms - call.started_ms)
+	const from_ms = Math.max(call.started_ms, span.from_ms)
+	const ms = Math.min(end_ms(call), span.to_ms) - from_ms
 	const is_counted = call.duration_ms !== undefined || is_untimed_subagent(call)
 
-	return is_counted ? [{ name, ms, from_ms: call.started_ms }] : []
+	return is_counted ? [{ name, ms, from_ms, call }] : []
 }
 
 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))
+	const kinds = placed
+		.filter(([call]) => is_untimed_subagent(call))
+		.map(([call]) => kind_of(call, TOOL_KINDS))
 
 	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 {
+// What neither a timed call nor a wait covers of `spans`, each millisecond once.
+function remainder_ms(
+	parts: ReadonlyArray<TimedPart>,
+	spans: ReadonlyArray<LaneSpan>,
+	waits: ReadonlyArray<LaneSpan>,
+): 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(
+	const covering = [...busy, ...waits]
+	const idle = spans.map(
 		(span) => span.to_ms - span.from_ms - lane_breakdown.covered_ms(span, covering),
 	)
 
@@ -115,29 +156,89 @@ function placed_of(
 	})
 }
 
+// Whether `call` ran inside `span` — started in it, or started before and still running at its start.
+function is_overlapping(call: ToolCall, span: LaneSpan): boolean {
+	return call.started_ms < span.to_ms && Math.max(call.started_ms + 1, end_ms(call)) > span.from_ms
+}
+
+// Each span paired with every call that ran inside it, so a call that began before is counted too.
+function overlapping_of(
+	calls: ReadonlyArray<ToolCall>,
+	spans: ReadonlyArray<LaneSpan>,
+): Array<readonly [ToolCall, LaneSpan]> {
+	return spans.flatMap((span) =>
+		calls.filter((call) => is_overlapping(call, span)).map((call) => [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) }
+	const parts = placed.flatMap(([call, span]) => timed_part(call, span, TOOL_KINDS))
+	const remainder = {
+		name: REMAINDER,
+		ms: remainder_ms(parts, breakdown.implement, breakdown.waits),
+	}
 
 	return {
 		kinds: lane_breakdown.ranked([...parts, remainder]),
 		background: placed.filter(([call]) => call.background).length,
 		untimed: untimed_of(placed),
+		calls: lane_breakdown_calls.by_kind(parts),
 	}
 }
 
-// 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,
-	)
+// The start to plan's timed calls, each cut at its span.
+function plan_parts(calls: ReadonlyArray<ToolCall>, breakdown: Breakdown): Array<TimedPart> {
+	const placed = placed_of(calls, breakdown.plan ?? [])
+
+	return placed.flatMap(([call, span]) => timed_part(call, span, TOOL_KINDS))
+}
+
+// The longest call groups of the start to plan (joshuafolkken/kit#5539), a `lint:related` among them
+// with its timing line (joshuafolkken/kit#5712).
+function plan_calls(calls: ReadonlyArray<ToolCall>, breakdown: Breakdown): Array<CallGroup> {
+	const timed = plan_parts(calls, breakdown)
 
-	return lane_breakdown.ranked(placed.flatMap(([call, span]) => timed_part(call, span)))
+	return lane_breakdown_calls.with_lint_detail(lane_breakdown_calls.top_of(timed), timed)
+}
+
+// The start to plan's time no timed call and no wait covered (joshuafolkken/kit#6119), and the calls
+// backgrounded in it, whose waits fall in that time — `undefined` when no calls were read: its time is
+// not known to be off-call.
+function plan_outside(
+	calls: ReadonlyArray<ToolCall>,
+	breakdown: Breakdown,
+): PlanOutside | undefined {
+	if (calls.length === 0) return undefined
+
+	const spans = breakdown.plan ?? []
+
+	return {
+		ms: remainder_ms(plan_parts(calls, breakdown), spans, breakdown.waits),
+		background: placed_of(calls, spans).filter(([call]) => call.background).length,
+	}
+}
+
+// The calls run inside `spans`, by the implementation's kinds and an edit's own — the fixes, re-ships,
+// checks, reads, edits and subagents a lane child ran between two ship stages, and the `ship:wait`
+// begun in the stage before, a backgrounded subagent left out as it spent no known time
+// (joshuafolkken/kit#5294, joshuafolkken/kit#5834) — and what neither those
+// calls nor `waits` covered as the remainder (joshuafolkken/kit#5755), left out when nothing is left.
+// A reader that read no calls (`lane-sinks.ts`) gets no rows: its time is not known to be editing.
+function between_kinds(
+	calls: ReadonlyArray<ToolCall>,
+	spans: ReadonlyArray<LaneSpan>,
+	waits: ReadonlyArray<LaneSpan>,
+): Array<Stage> {
+	if (calls.length === 0) return []
+	const timed = calls.filter((call) => !is_untimed_subagent(call))
+	const placed = overlapping_of(timed, spans)
+	const parts = placed.flatMap(([call, span]) => timed_part(call, span, BETWEEN_TOOL_KINDS))
+	const remainder = { name: REMAINDER, ms: remainder_ms(parts, spans, waits) }
+
+	return lane_breakdown.ranked(remainder.ms > 0 ? [...parts, remainder] : parts)
 }
 
 // The lane's own transcript directories — `<lane root slug>-<issue>` under `~/.claude/projects`.
@@ -151,10 +252,10 @@ function transcript_directories(issue: number): ReadonlyArray<string> {
 		.filter((directory) => directory.endsWith(suffix))
 }
 
-// The tool calls of `issue`'s lane sessions still written to once its implementation began, up to the
+// The tool calls of `issue`'s lane sessions still written to once its start to plan began, up to the
 // end of its last ship stage.
 function read(issue: number, breakdown: Breakdown): Array<ToolCall> {
-	const [first] = breakdown.implement
+	const [first] = [...(breakdown.plan ?? []), ...breakdown.implement]
 	const last = breakdown.ship.at(-1) ?? breakdown.implement.at(-1)
 
 	if (first === undefined || last === undefined) return []
@@ -164,7 +265,43 @@ function read(issue: number, breakdown: Breakdown): Array<ToolCall> {
 	return lane_transcript_stats.read_calls(transcript_directories(issue), window)
 }
 
-const lane_breakdown_implement = { bash_kinds, of, read, transcript_directories }
+// When the first of `calls` that edited a file started inside `span`, `undefined` when none did — the
+// `edit_ms` `lane_breakdown.of` takes.
+function first_edit_ms(calls: ReadonlyArray<ToolCall>, span: LaneSpan): number | undefined {
+	const edits = calls
+		.filter((call) => EDIT_TOOLS.has(call.tool ?? '') && span_of(call, [span]) !== undefined)
+		.map((call) => call.started_ms)
+
+	return edits.length === 0 ? undefined : Math.min(...edits)
+}
+
+// The breakdown with its implementation opened at the lane's first edit where no event opened it
+// (joshuafolkken/kit#5835), the edit read off the lane's own transcripts.
+function breakdown_of(
+	entries: ReadonlyArray<LedgerEntry>,
+	events: ReadonlyArray<RunEvent>,
+	issue: number,
+): Breakdown | undefined {
+	const span = lane_net_time.span_of(entries, issue)
+
+	if (span === undefined) return undefined
+
+	const window = { since_ms: span.from_ms, until_ms: span.to_ms }
+	const calls = lane_transcript_stats.read_calls(transcript_directories(issue), window)
+
+	return lane_breakdown.of(entries, events, issue, first_edit_ms(calls, span))
+}
+
+const lane_breakdown_implement = {
+	between_kinds,
+	breakdown_of,
+	first_edit_ms,
+	of,
+	plan_calls,
+	plan_outside,
+	read,
+	transcript_directories,
+}
 
 export { lane_breakdown_implement }
-export type { ImplementDetail }
+export type { ImplementDetail, PlanOutside }

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

@@ -1,12 +1,14 @@
 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 { lane_breakdown_pause } from './lane-breakdown-pause'
+import { lane_ledger, type LedgerEntry, type ShipLapEntry } 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`).
+// the park it went to (`lane-breakdown-pause.ts`), else by the calls the lane child made there, by the
+// implementation's kinds, and the rest as its editing and thinking (`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.
 
@@ -19,12 +21,41 @@ type Laps = ReadonlyMap<string, ReadonlyArray<Stage>>
 interface Placed {
 	at_ms: number
 	part: Stage
+	stage?: string | undefined
+}
+
+// A gate the ship reused rather than started (joshuafolkken/kit#5567), counted per stage (`counted`).
+const REUSED_NOTE = '(reused)'
+
+// A scoped pair's rerun names its run count; a gate's reason stands alone (joshuafolkken/kit#5567).
+function rerun_note(entry: ShipLapEntry): ReadonlyArray<string> {
+	if (entry.rerun === undefined) return []
+
+	return [entry.runs === undefined ? entry.rerun : `run ${String(entry.runs)}: ${entry.rerun}`]
+}
+
+// Which run of the ship's scoped pair a lap was and why it ran again (joshuafolkken/kit#5538), and why
+// a check read the whole branch (joshuafolkken/kit#5531), after the step's name.
+function lap_name(entry: ShipLapEntry): string {
+	if (entry.reused_tree !== undefined) return `${entry.step} ${REUSED_NOTE}`
+
+	const run = rerun_note(entry)
+	const whole = entry.fallback === undefined ? [] : [`whole branch: ${entry.fallback}`]
+	const notes = [...run, ...whole]
+
+	return notes.length === 0 ? entry.step : `${entry.step} (${notes.join('; ')})`
 }
 
 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 } }]
+	return [
+		{
+			at_ms: Date.parse(entry.at),
+			part: { name: lap_name(entry), ms: entry.elapsed_ms },
+			stage: entry.stage === 'run:entry' ? lane_breakdown.PLAN_STAGE : undefined,
+		},
+	]
 }
 
 function wait_of(entry: LedgerEntry, issue: number): ReadonlyArray<Placed> {
@@ -52,56 +83,117 @@ function stage_at(segments: ReadonlyArray<Segment>, at_ms: number): string | und
 	return segment?.stage === lane_breakdown.BETWEEN_STAGE ? undefined : segment?.stage
 }
 
+// Entry maintenance may finish after plan: keep its scope instead of charging it to the ship.
+function stage_for(place: Placed, segments: ReadonlyArray<Segment>): string | undefined {
+	if (place.stage === undefined) return stage_at(segments, place.at_ms)
+
+	return segments.some((segment) => segment.stage === place.stage) ? place.stage : undefined
+}
+
 function grouped(
 	placed: ReadonlyArray<Placed>,
 	segments: ReadonlyArray<Segment>,
+	groups = new Map<string, Array<Stage>>(),
 ): 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)
+	for (const place of placed) {
+		const stage = stage_for(place, segments)
 
-		if (stage !== undefined) groups.set(stage, [...(groups.get(stage) ?? []), part])
+		if (stage !== undefined) groups.set(stage, [...(groups.get(stage) ?? []), place.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)
+// A stage's reused laps under one row carrying their count, `josh gate (reused ×2)`, before
+// `lane_breakdown.ranked` sums each name's time into one row.
+function counted(parts: ReadonlyArray<Stage>): Array<Stage> {
+	const reuses = new Map<string, number>()
+
+	for (const { name } of parts) {
+		if (name.endsWith(REUSED_NOTE)) reuses.set(name, (reuses.get(name) ?? 0) + 1)
+	}
+
+	return parts.map((part) => {
+		const count = reuses.get(part.name)
+
+		return count === undefined
+			? part
+			: { ...part, name: `${part.name.slice(0, -REUSED_NOTE.length)}(reused ×${String(count)})` }
+	})
+}
+
+// A stretch between ship stages a park fell in, under the park's row and net of the waits taken out
+// (joshuafolkken/kit#5646); a stretch with no park is left to the call kinds.
+function paused_of(segment: Segment, breakdown: Breakdown): ReadonlyArray<Stage> {
+	const mark = lane_breakdown_pause.in_segment(breakdown.pauses ?? [], segment)
+
+	if (mark === undefined) return []
+	const waited_ms = lane_breakdown.covered_ms(segment, breakdown.waits)
+
+	return [{ name: mark.name, ms: segment.to_ms - segment.from_ms - waited_ms }]
+}
 
-	return lane_breakdown_implement.bash_kinds(calls, between)
+function between_of(calls: ReadonlyArray<ToolCall>, breakdown: Breakdown): Array<Stage> {
+	const between = breakdown.ship.filter((segment) => segment.stage === lane_breakdown.BETWEEN_STAGE)
+	const paused = between.map((segment) => paused_of(segment, breakdown))
+	const unpaused = between.filter((_segment, index) => paused[index]?.length === 0)
+
+	return lane_breakdown.ranked([
+		...paused.flat(),
+		...lane_breakdown_implement.between_kinds(calls, unpaused, breakdown.waits),
+	])
 }
 
-/** `issue`'s ship stages split by their laps, and the time between them by the lane child's Bash. */
+// The start to plan as segments, where `run:entry` times its children (joshuafolkken/kit#5831) — only
+// laps are placed there, so a lane without them prints its start to plan as before.
+function plan_segments(breakdown: Breakdown): Array<Segment> {
+	return (breakdown.plan ?? []).map((span) => ({ ...span, stage: lane_breakdown.PLAN_STAGE }))
+}
+
+/**
+ * `issue`'s start to plan and ship stages split by their laps, and the time between them by the park it
+ * went to, else by the lane child's calls (joshuafolkken/kit#5834).
+ */
 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 lapped = entries.flatMap((entry) => lap_of(entry, issue))
+	const placed = entries.flatMap((entry) => [...wait_of(entry, issue), ...checks_of(entry, issue)])
+	const planned = grouped(lapped, plan_segments(breakdown))
 	const laps = new Map(
-		[...grouped(placed, breakdown.ship)].map(([stage, parts]) => [
+		[...grouped([...lapped, ...placed], breakdown.ship, planned)].map(([stage, parts]) => [
 			stage,
-			lane_breakdown.ranked(parts),
+			lane_breakdown.ranked(counted(parts)),
 		]),
 	)
-	const between = between_of(calls, breakdown.ship)
+	const between = between_of(calls, breakdown)
 
 	if (between.length > 0) laps.set(lane_breakdown.BETWEEN_STAGE, between)
 
 	return laps
 }
 
-const lane_breakdown_laps = { CORE_WAIT_STEP, of }
+// `issue`'s laps and core-budget waits that ended in a ship stage, one per run and unmerged — what
+// `josh lane:why` sums over the whole ship (joshuafolkken/kit#6154).
+function ship_parts(
+	entries: ReadonlyArray<LedgerEntry>,
+	issue: number,
+	breakdown: Breakdown,
+): Array<Stage> {
+	const placed = entries.flatMap((entry) => [...lap_of(entry, issue), ...wait_of(entry, issue)])
+
+	return [...grouped(placed, breakdown.ship).values()].flat()
+}
+
+// Whether a row stamped `at` ended in a ship stage of `breakdown`, by the rule its laps are placed by.
+function is_in_ship(breakdown: Breakdown, at: string): boolean {
+	return stage_at(breakdown.ship, Date.parse(at)) !== undefined
+}
+
+const lane_breakdown_laps = { CORE_WAIT_STEP, is_in_ship, of, ship_parts }
 
 export { lane_breakdown_laps }
 export type { Laps }

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

@@ -0,0 +1,127 @@
+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 type { LaneSpan } from './lane-net-time'
+import { lane_stop_stats } from './lane-stop-stats'
+
+// The stops a lane's time between ship stages went to (joshuafolkken/kit#5646): each `park` event of
+// the lane — `run:merge`'s `#<N> waiting on #<M>` for a pause on a blocker, `#<N> parked (<reason>)`
+// for a park — named where it fell, so the stretch it opened (the blocker filed, the pause, the
+// resume and the re-ship) is attributed to it rather than left to the call kinds.
+
+const { EVENT_KIND } = run_event_stream
+const IMPLEMENT_SUFFIX = ' implement'
+const REPLAN_NOTE = 're-plan'
+const RE_RUN_LEAD = 'ship ×'
+const RE_RUN_TAIL = ' re-run'
+const WAITING_LEAD = 'waiting on '
+const PARKED_LEAD = 'parked'
+// A park event names its child first, then what it parked on.
+const PARK_TEXT = /^#(?<issue>[1-9]\d*) (?<rest>.*)$/u
+
+// Where a park fell in the lane, and the row it names.
+interface PauseMark {
+	at_ms: number
+	name: string
+}
+
+// `pause for #5582` for a wait on blockers, `park (<reason>)` for a park, else no row.
+function name_of(rest: string): string | undefined {
+	if (rest.startsWith(WAITING_LEAD)) return `pause for ${rest.slice(WAITING_LEAD.length)}`
+	if (rest.startsWith(PARKED_LEAD)) return `park${rest.slice(PARKED_LEAD.length)}`
+
+	return undefined
+}
+
+// What `issue`'s park event says it parked on, `undefined` for another lane's park.
+function rest_of(event: RunEvent, issue: number): string | undefined {
+	const groups = PARK_TEXT.exec(event.text)?.groups
+
+	return Number(groups?.['issue']) === issue ? groups?.['rest'] : undefined
+}
+
+function mark_of(event: RunEvent, issue: number): ReadonlyArray<PauseMark> {
+	const name = name_of(rest_of(event, issue) ?? '')
+
+	return name === undefined ? [] : [{ at_ms: Date.parse(event.at), name }]
+}
+
+// A plan, or the lane turning to implement — after a pause, the lane re-planned.
+function is_planning(event: RunEvent): boolean {
+	return (
+		event.kind === EVENT_KIND.PLAN ||
+		(event.kind === EVENT_KIND.LANE_PHASE && event.text.endsWith(IMPLEMENT_SUFFIX))
+	)
+}
+
+// The ship runs counted so far, and the stages the last one started.
+interface Runs {
+	count: number
+	started: ReadonlySet<string>
+}
+
+// A ship starts each stage once, so a stage started again opens the next run. No one stage marks a
+// run's start — a resumed ship skips the stages it finished — nor does the stages' order, which
+// starts gate and round-2 side by side.
+function run_step(runs: Runs, stage: string): Runs {
+	if (runs.count > 0 && !runs.started.has(stage)) {
+		return { count: runs.count, started: new Set([...runs.started, stage]) }
+	}
+
+	return { count: runs.count + 1, started: new Set([stage]) }
+}
+
+function runs_of(events: ReadonlyArray<RunEvent>): number {
+	const starts = events
+		.filter((event) => event.kind === EVENT_KIND.SHIP_STAGE)
+		.map((event) => run_ship_stage.words_of(event.text))
+		.filter((words) => words.phase === run_ship_stage.PHASE.START)
+	let runs: Runs = { count: 0, started: new Set() }
+
+	for (const words of starts) runs = run_step(runs, words.stage)
+
+	return runs.count
+}
+
+// What the lane redid after a pause (joshuafolkken/kit#5649): ` (re-plan, ship ×2 re-run)`, or ''.
+function note_of(events: ReadonlyArray<RunEvent>): string {
+	const runs = runs_of(events)
+	const parts = [
+		...(events.some((event) => is_planning(event)) ? [REPLAN_NOTE] : []),
+		...(runs > 0 ? [`${RE_RUN_LEAD}${String(runs)}${RE_RUN_TAIL}`] : []),
+	]
+
+	return parts.length === 0 ? '' : ` (${parts.join(', ')})`
+}
+
+function between_of(events: ReadonlyArray<RunEvent>, span: LaneSpan): ReadonlyArray<RunEvent> {
+	return events.filter((event) => {
+		const at_ms = Date.parse(event.at)
+
+		return at_ms > span.from_ms && at_ms <= span.to_ms
+	})
+}
+
+/** `issue`'s parks inside `span`, in the stream's order, each with what the lane redid after it. */
+function of(events: ReadonlyArray<RunEvent>, issue: number, span: LaneSpan): Array<PauseMark> {
+	const lane = events.filter((event) => lane_stop_stats.issue_of(event) === issue)
+	const marks = events
+		.filter((event) => event.kind === EVENT_KIND.PARK)
+		.flatMap((event) => mark_of(event, issue))
+		.filter((mark) => mark.at_ms >= span.from_ms && mark.at_ms <= span.to_ms)
+
+	return marks.map((mark, index) => {
+		const after = { from_ms: mark.at_ms, to_ms: marks[index + 1]?.at_ms ?? span.to_ms }
+
+		return { ...mark, name: `${mark.name}${note_of(between_of(lane, after))}` }
+	})
+}
+
+// The park that fell inside `segment` — its first, when the lane paused twice in one stretch.
+function in_segment(marks: ReadonlyArray<PauseMark>, segment: LaneSpan): PauseMark | undefined {
+	return marks.find((mark) => mark.at_ms > segment.from_ms && mark.at_ms <= segment.to_ms)
+}
+
+const lane_breakdown_pause = { in_segment, is_planning, of }
+
+export { lane_breakdown_pause }
+export type { PauseMark }

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

@@ -13,6 +13,9 @@ const MAX_SHOWN = 5
 // `run:review`'s check and the pre-detach's probe past its stop (joshuafolkken/kit#5327) alike.
 const DISCARDED_LABEL = 'background test:pinned probes discarded'
 
+// A probe the scoped type check pinned before the full reach ran (joshuafolkken/kit#5385).
+const TYPE_CHECK_LABEL = 'type check'
+
 function is_lane_row(entry: LedgerEntry, issue: number): entry is TestPinnedEntry {
 	return entry.kind === lane_ledger.KIND.TEST_PINNED && entry.issue === issue
 }
@@ -52,8 +55,20 @@ function discarded_text(entries: ReadonlyArray<LedgerEntry>, issue: number): str
 
 function probe_text(probe: PinnedProbe): string {
 	const tests = probe.tests === undefined ? '' : ` ${String(probe.tests)} test files`
+	const pinned_by = probe.pinned_by === undefined ? '' : ` (${TYPE_CHECK_LABEL})`
+
+	return `${probe.file}${tests} ${lane_breakdown.minutes_text(probe.elapsed_ms)}${pinned_by}`
+}
+
+// The skipped hunks' counts, each named only when non-zero: `rewired` (joshuafolkken/kit#5235) and
+// `over cap` (joshuafolkken/kit#5503).
+function skipped_counts(rewired: number, over_cap: number): Array<string> {
+	const named: Array<[number, string]> = [
+		[rewired, 'rewired'],
+		[over_cap, 'over cap'],
+	]
 
-	return `${probe.file}${tests} ${lane_breakdown.minutes_text(probe.elapsed_ms)}`
+	return named.filter(([count]) => count > 0).map(([count, label]) => `${String(count)} ${label}`)
 }
 
 // The detail the pre-detach line carries, or `''` when no probe ran inside it.
@@ -64,9 +79,10 @@ function detail_text(rows: ReadonlyArray<TestPinnedEntry>): string {
 		.toSorted((left, right) => right.elapsed_ms - left.elapsed_ms)
 	const held = rows.reduce((sum, row) => sum + row.held, 0)
 	const rewired = rows.reduce((sum, row) => sum + (row.rewired ?? 0), 0)
-	const total = held + rewired + probes.length
+	const over_cap = rows.reduce((sum, row) => sum + (row.over_cap ?? 0), 0)
+	const total = held + rewired + over_cap + probes.length
 	const head = `test:pinned ${String(total)} hunks, ${String(held)} cached, ${String(probes.length)} probed`
-	const counts = rewired === 0 ? [head] : [head, `${String(rewired)} rewired`]
+	const counts = [head, ...skipped_counts(rewired, over_cap)]
 
 	return ` (${[...counts, ...probes.slice(0, MAX_SHOWN).map((probe) => probe_text(probe))].join(', ')})`
 }