@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/scripts/issue/issue-spill.ts

@@ -138,15 +138,29 @@ function follow_up_title(subject: SpillSubject): string {
 	return `Follow up ${issue_cite.plain_for('github', subject.issue_number)}: ${subject.title}`
 }
 
-// `sizing` is the caller's size lines: the estimate, then a reason line when one was given.
-function follow_up_body(subject: SpillSubject, sizing: ReadonlyArray<string>): string {
-	const origin = issue_cite.plain_for('github', subject.issue_number)
-
+// The plain-language summary `issue:file` requires first, for the person deciding on the follow-up,
+// then the background's opening line.
+function opening_lines(origin: string): ReadonlyArray<string> {
 	return [
+		issue_body_keys.heading('summary'),
+		'',
+		`**${origin} の受け入れ条件のうち、終わらなかった分を引き継ぐ Issue です。**`,
+		'',
+		`${origin} は一度に収まらなかったため、残った条件をここへ移し、${origin} は終わった分だけで閉じます。下の受け入れ条件を満たせば完了です。`,
+		'',
 		BACKGROUND_HEADING,
 		'',
 		`${origin} から切り出し。`,
 		'',
+	]
+}
+
+// `sizing` is the caller's size lines: the estimate, then a reason line when one was given.
+function follow_up_body(subject: SpillSubject, sizing: ReadonlyArray<string>): string {
+	const origin = issue_cite.plain_for('github', subject.issue_number)
+
+	return [
+		...opening_lines(origin),
 		...declarations(subject.body),
 		...sizing,
 		'',

package/scripts/issue/issue-template-section.ts

@@ -1,4 +1,5 @@
 import { existsSync, readFileSync } from 'node:fs'
+import path from 'node:path'
 import { package_path } from '#scripts/init/init-paths'
 import { issue_body_keys, type Column } from './issue-body-keys'
 import { markdown_section } from './markdown-section'
@@ -34,6 +35,11 @@ function section_of(document: string, heading: string): string | undefined {
 	return [heading, ...markdown_section.section_lines(template, heading)].join('\n').trimEnd()
 }
 
+// The template document's file name in the body's column, for a refusal that sends the filer to it.
+function document_name(): string {
+	return path.basename(TEMPLATE_PATHS[issue_body_keys.column()])
+}
+
 // A package without the template prints the bare problem rather than failing the lint.
 function section(heading: string): string | undefined {
 	const template_path = package_path(TEMPLATE_PATHS[issue_body_keys.column()])
@@ -43,6 +49,6 @@ function section(heading: string): string | undefined {
 	return section_of(readFileSync(template_path, 'utf8'), heading)
 }
 
-const issue_template_section = { section, section_of }
+const issue_template_section = { document_name, section, section_of }
 
 export { issue_template_section }

package/scripts/josh/josh-commands-ai.ts

@@ -512,10 +512,10 @@ const AI_COMMANDS: Record<string, CommandEntry> = {
 	'lane:stats': {
 		...MEASURE_ARGUMENTS,
 		description:
-			'Print period lane throughput, stage, stop (by failed CI check, longest first), check, runnable-to-dispatch wait and machine-load statistics; --sinks shows stage totals, --over lane chains, --why cause groups above a net-minute threshold, and --pairs scoped pair runs',
+			'Print period lane throughput, stage, stop (by failed CI check, longest first), check, runnable-to-dispatch wait and machine-load statistics; the per-lane core-budget wait and pre-split miss tables show their first 10 rows and a count of the rest unless --all; --sinks shows stage totals, --over lane chains, --why cause groups above a net-minute threshold, and --pairs scoped pair runs',
 		category: 'AI tools',
 		reference: [
-			'(--period <days> | --since <instant>) [--limit <lane-limit> | --sinks [<minutes>] | --over <minutes> | --why <minutes> | --pairs]',
+			'(--period <days> | --since <instant>) [[--limit <lane-limit>] [--all] | --sinks [<minutes>] | --over <minutes> | --why <minutes> | --pairs]',
 			'maintainer',
 			['none'],
 		],
@@ -523,6 +523,7 @@ const AI_COMMANDS: Record<string, CommandEntry> = {
 		usage: {
 			examples: [
 				{ arguments: '--period 7', note: "a 7-day period's stage medians and maxima" },
+				{ arguments: '--period 7 --all', note: 'the same with every per-lane table row' },
 				{ arguments: '--period 1 --sinks', note: 'stage totals of the lanes over 30 net min' },
 				{ arguments: '--period 1 --over 40', note: 'ledger chains of lanes over 40 net min' },
 				{ arguments: '--period 1 --why 40', note: 'cause groups of lanes over 40 net min' },

package/scripts/lane/lane-chain-stop-stats.ts

@@ -7,8 +7,10 @@ import { lane_stats, type StatsWindow } from './lane-stats'
 // reduced to one row per stage and reason, printed by `josh lane:stats` so the re-runs that dominate a
 // lane's implement time are counted by cause (joshuafolkken/kit#7024).
 //
-// **A stop lasts until the next `run:chain` on its issue starts** — that run's end less its length. A
-// stop no run followed is counted under `not re-run`, kept out of the minutes.
+// **A stop lasts until the run goes on for its issue** — the next `run:chain` or `josh ship` lap to
+// start, its end less its length: a held review is settled and shipped, not re-chained
+// (joshuafolkken/kit#7580). A stop nothing followed is counted under `not re-run`, kept out of the
+// minutes.
 
 const COLUMNS = ['stopped at', 'stops', 'to re-run (min)', 'median (min)', 'not re-run'] as const
 const JOIN_SUFFIX = ' --join'
@@ -21,15 +23,25 @@ interface ChainStop {
 	wait_ms: number | undefined
 }
 
+// A ledger row that marks the run going on: a `run:chain` or a `josh ship` lap.
+type Resume = Extract<
+	LedgerEntry,
+	{ kind: typeof lane_ledger.KIND.CHAIN | typeof lane_ledger.KIND.SHIP_LAP }
+>
+
 function is_chain(entry: LedgerEntry): entry is ChainEntry {
 	return entry.kind === lane_ledger.KIND.CHAIN
 }
 
-function started_ms(chain: ChainEntry): number {
-	return Date.parse(chain.at) - chain.elapsed_ms
+function is_resume(entry: LedgerEntry): entry is Resume {
+	return is_chain(entry) || entry.kind === lane_ledger.KIND.SHIP_LAP
+}
+
+function started_ms(run: Resume): number {
+	return Date.parse(run.at) - run.elapsed_ms
 }
 
-function wait_ms(stop: ChainEntry, runs: ReadonlyArray<ChainEntry>): number | undefined {
+function wait_ms(stop: ChainEntry, runs: ReadonlyArray<Resume>): number | undefined {
 	const stopped_ms = Date.parse(stop.at)
 	const starts = runs
 		.filter((run) => run.issue === stop.issue)
@@ -48,7 +60,7 @@ function cause_of(chain: ChainEntry): string | undefined {
 
 function stops_of(
 	period: ReadonlyArray<ChainEntry>,
-	runs: ReadonlyArray<ChainEntry>,
+	runs: ReadonlyArray<Resume>,
 ): Array<ChainStop> {
 	return period.flatMap((chain) => {
 		const cause = cause_of(chain)
@@ -94,7 +106,7 @@ function causes_of(stops: ReadonlyArray<ChainStop>): Array<string> {
 function table(entries: ReadonlyArray<LedgerEntry>, window: StatsWindow): string {
 	const stops = stops_of(
 		lane_stats.in_window(entries, window).filter(is_chain),
-		entries.filter(is_chain),
+		entries.filter(is_resume),
 	)
 	const rows = causes_of(stops).map((cause) => cause_row(cause, stops))
 

package/scripts/lane/lane-concurrency-stats.ts

@@ -1,4 +1,5 @@
 import { MS_PER_MINUTE, MS_PER_SECOND } from '#scripts/lib/timeouts'
+import { lane_concurrency_wait, type LaneWait } from './lane-concurrency-wait'
 import { lane_ledger, type LedgerEntry, type LoadEntry } from './lane-ledger'
 import { lane_stage_stats } from './lane-stage-stats'
 import { lane_stats, type StatsWindow } from './lane-stats'
@@ -9,7 +10,9 @@ import { lane_transcript_stats } from './lane-transcript-stats'
 // (joshuafolkken/kit#7025): the evidence a `JOSH_LANE_LIMIT` or verification-parallelism change is
 // filed from. A call's lane count is the latest load sample's `lanes` at or before it started; a call
 // with no sample within `SAMPLE_MAX_AGE_MS` before it is left out, since an old sample says nothing of
-// the lanes it ran beside.
+// the lanes it ran beside. Each command also reads the median core-budget wait of the calls a wait
+// record ties to (joshuafolkken/kit#7550): beside the elapsed median, it shows how much of a run was
+// admission rather than the run itself.
 
 const TIMED_COMMANDS: ReadonlyArray<string> = ['lint:related', 'test:related']
 const SAMPLE_MAX_AGE_MINUTES = 5
@@ -17,7 +20,11 @@ const SAMPLE_MAX_AGE_MS = SAMPLE_MAX_AGE_MINUTES * MS_PER_MINUTE
 const DECIMALS = 1
 const COLUMNS = [
 	'concurrent lanes',
-	...TIMED_COMMANDS.flatMap((name) => [`${name} runs`, `${name} median (s)`]),
+	...TIMED_COMMANDS.flatMap((name) => [
+		`${name} runs`,
+		`${name} median (s)`,
+		`${name} core wait median (s)`,
+	]),
 ]
 
 type CountedSample = LoadEntry & { lanes: number }
@@ -31,6 +38,7 @@ interface TimedRun {
 	name: string
 	lanes: number
 	ms: number
+	wait_ms: number | undefined
 }
 
 function is_counted(entry: LedgerEntry): entry is CountedSample {
@@ -52,23 +60,35 @@ function lanes_at(samples: ReadonlyArray<LaneSample>, started_ms: number): numbe
 		: undefined
 }
 
-function timed_run(name: string, call: ToolCall, lanes: number | undefined): Array<TimedRun> {
+interface RunRecords {
+	samples: ReadonlyArray<LaneSample>
+	waits: ReadonlyArray<LaneWait>
+	calls: ReadonlyArray<ToolCall>
+}
+
+function timed_run(name: string, call: ToolCall, records: RunRecords): Array<TimedRun> {
+	const lanes = lanes_at(records.samples, call.started_ms)
+
 	if (lanes === undefined || call.duration_ms === undefined) return []
 
-	return [{ name, lanes, ms: call.duration_ms }]
+	const wait_ms = lane_concurrency_wait.wait_ms(records.waits, name, call, records.calls)
+
+	return [{ name, lanes, ms: call.duration_ms, wait_ms }]
 }
 
-function timed_runs(
-	calls: ReadonlyArray<ToolCall>,
-	samples: ReadonlyArray<LaneSample>,
-): Array<TimedRun> {
+// `timed` is the period's calls; `records.calls` is every call, so a call started before the period
+// still holds its own wait records against one inside it.
+function timed_runs(timed: ReadonlyArray<ToolCall>, records: RunRecords): Array<TimedRun> {
 	return TIMED_COMMANDS.flatMap((name) =>
-		lane_transcript_stats
-			.solo_calls(calls, name)
-			.flatMap((call) => timed_run(name, call, lanes_at(samples, call.started_ms))),
+		lane_transcript_stats.solo_calls(timed, name).flatMap((call) => timed_run(name, call, records)),
 	)
 }
 
+// A row's waits are the calls a record tied to; a row with none reads `not measured`, never 0.
+function waits_of(runs: ReadonlyArray<TimedRun>): Array<number> {
+	return runs.map((run) => run.wait_ms).filter((wait_ms) => wait_ms !== undefined)
+}
+
 function seconds_cell(values: ReadonlyArray<number>): string {
 	const median = lane_stats.median(values)
 
@@ -80,9 +100,10 @@ function seconds_cell(values: ReadonlyArray<number>): string {
 function lane_row(lanes: number, runs: ReadonlyArray<TimedRun>): string {
 	const at_count = runs.filter((run) => run.lanes === lanes)
 	const cells = TIMED_COMMANDS.flatMap((name) => {
-		const durations = at_count.filter((run) => run.name === name).map((run) => run.ms)
+		const named = at_count.filter((run) => run.name === name)
+		const durations = named.map((run) => run.ms)
 
-		return [String(durations.length), seconds_cell(durations)]
+		return [String(durations.length), seconds_cell(durations), seconds_cell(waits_of(named))]
 	})
 
 	return lane_stats.to_row([String(lanes), ...cells])
@@ -95,7 +116,11 @@ function table(
 	calls: ReadonlyArray<ToolCall>,
 	window: StatsWindow,
 ): string {
-	const runs = timed_runs(lane_transcript_stats.in_period(calls, window), samples_of(entries))
+	const runs = timed_runs(lane_transcript_stats.in_period(calls, window), {
+		samples: samples_of(entries),
+		waits: lane_concurrency_wait.waits_of(entries),
+		calls,
+	})
 	const counts = [...new Set(runs.map((run) => run.lanes))].toSorted((left, right) => left - right)
 
 	return [

package/scripts/lane/lane-concurrency-wait.ts

@@ -0,0 +1,64 @@
+import { lane_ledger, type CoreWaitEntry, type LedgerEntry } from './lane-ledger'
+import { lane_paused_spans } from './lane-paused-spans'
+import type { ToolCall } from './lane-transcript-calls'
+import { lane_transcript_stats } from './lane-transcript-stats'
+
+// The core-budget wait inside one `lint:related` / `test:related` call (joshuafolkken/kit#7550): the
+// `core_wait` records its own lane wrote for the same command while the call ran, summed — one call
+// can admit more than one claim. `undefined` when no record ties to the call: no record is not a
+// zero wait, since an admission with no decision and no wait writes nothing.
+
+type LaneWait = CoreWaitEntry & { issue: number }
+
+function is_lane_wait(entry: LedgerEntry): entry is LaneWait {
+	return (
+		(entry.kind === lane_ledger.KIND.CORE_WAIT || entry.kind === lane_ledger.KIND.CORE_ADMISSION) &&
+		entry.issue !== undefined
+	)
+}
+
+function waits_of(entries: ReadonlyArray<LedgerEntry>): Array<LaneWait> {
+	return entries.filter((entry) => is_lane_wait(entry))
+}
+
+function is_inside(wait: LaneWait, call: ToolCall): boolean {
+	const at_ms = Date.parse(wait.at)
+
+	return at_ms >= call.started_ms && at_ms <= call.started_ms + (call.duration_ms ?? 0)
+}
+
+// Overlapping same-lane calls of one command (a background run beside a foreground one) would each
+// read the other's records, so a record goes to one call: the latest that started by the time its
+// wait began, else the earliest it falls inside.
+function owner_of(wait: LaneWait, rivals: ReadonlyArray<ToolCall>): ToolCall | undefined {
+	const holding = rivals
+		.filter((rival) => is_inside(wait, rival))
+		.toSorted((left, right) => left.started_ms - right.started_ms)
+	const wait_started_ms = Date.parse(wait.at) - wait.waited_ms
+
+	return holding.findLast((rival) => rival.started_ms <= wait_started_ms) ?? holding[0]
+}
+
+function wait_ms(
+	waits: ReadonlyArray<LaneWait>,
+	name: string,
+	call: ToolCall,
+	calls: ReadonlyArray<ToolCall>,
+): number | undefined {
+	const issue = lane_paused_spans.issue_of_lane(call.lane)
+	const rivals = calls.filter(
+		(rival) =>
+			rival.lane === call.lane &&
+			lane_transcript_stats.verification_commands(rival.command).includes(name),
+	)
+	const tied = waits.filter(
+		(wait) => wait.issue === issue && wait.command === name && owner_of(wait, rivals) === call,
+	)
+
+	return tied.length === 0 ? undefined : tied.reduce((sum, wait) => sum + wait.waited_ms, 0)
+}
+
+const lane_concurrency_wait = { waits_of, wait_ms }
+
+export type { LaneWait }
+export { lane_concurrency_wait }

package/scripts/lane/lane-core-wait-stats.ts

@@ -1,6 +1,7 @@
 import { lane_ledger, type CoreWaitEntry, type LedgerEntry } from './lane-ledger'
 import { lane_stage_stats } from './lane-stage-stats'
 import { lane_stats, type StatsWindow } from './lane-stats'
+import { lane_table_rows, type TableOptions } from './lane-table-rows'
 
 // How long each lane's commands waited for the core budget: the ledger's `core-wait` entries of one
 // period reduced to one row per lane, printed by `josh lane:stats` so a lane's time splits into work
@@ -8,6 +9,7 @@ import { lane_stats, type StatsWindow } from './lane-stats'
 // main checkout's — by its own row.
 
 const COLUMNS = ['lane', 'total (min)', 'median (min)', 'waits'] as const
+const LANE_ROWS = 10
 const OUTSIDE_A_LANE = 'outside a lane'
 const { NOT_MEASURED } = lane_stage_stats
 // A period with no wait: the table still prints, so a reader sees zero waits rather than no table.
@@ -49,18 +51,25 @@ function lanes_of(waits: ReadonlyArray<CoreWaitEntry>): Array<string> {
 	)
 }
 
-// The period's table: `entries` is the whole ledger, filtered here to `window`.
-function table(entries: ReadonlyArray<LedgerEntry>, window: StatsWindow): string {
+// The period's table: `entries` is the whole ledger, filtered here to `window`; at most `LANE_ROWS`
+// lanes unless `options` asks for all.
+function table(
+	entries: ReadonlyArray<LedgerEntry>,
+	window: StatsWindow,
+	options: TableOptions,
+): string {
 	const waits = lane_stats.in_window(entries, window).filter((entry) => is_core_wait(entry))
 	const rows = lanes_of(waits).map((lane) => lane_row(lane, waits))
 
 	return [
 		lane_stats.to_row(COLUMNS),
 		lane_stats.to_row(COLUMNS.map(() => '---')),
-		...(rows.length === 0 ? [lane_stats.to_row(NONE_ROW)] : rows),
+		...(rows.length === 0
+			? [lane_stats.to_row(NONE_ROW)]
+			: lane_table_rows.capped(rows, LANE_ROWS, options)),
 	].join('\n')
 }
 
-const lane_core_wait_stats = { table }
+const lane_core_wait_stats = { LANE_ROWS, table }
 
 export { lane_core_wait_stats }

package/scripts/lane/lane-implement-read-calls.ts

@@ -0,0 +1,123 @@
+import { time_shell } from '#scripts/time-runtime/time-shell'
+import { lane_implement_read } from './lane-implement-read'
+import { lane_implement_stats } from './lane-implement-stats'
+import type { ImplementLane } from './lane-implement-subagents'
+import type { PausedSpans } from './lane-paused-spans'
+import { lane_stage_stats } from './lane-stage-stats'
+import { lane_stats, type StatsWindow } from './lane-stats'
+import type { ToolCall } from './lane-transcript-calls'
+import { lane_transcript_stats } from './lane-transcript-stats'
+
+// The implement's `read` sub-stage tool time broken down by call kind (joshuafolkken/kit#7548), so a
+// shortening Issue can pick its target: a josh run is `josh <subcommand>`, another Bash command its
+// leading word past a `cd`, a subagent `Agent:<type>`, any other call its tool name.
+
+const BASH_TOOL = 'Bash'
+const AGENT_TOOL = 'Agent'
+const UNKNOWN = 'unknown'
+const TOP_KINDS = 10
+const COLUMNS = [
+	'implement read by call',
+	'calls',
+	'lanes',
+	'median per lane (min)',
+	'total (min)',
+] as const
+
+interface CallTotal {
+	calls: number
+	ms: number
+}
+
+interface KindRow {
+	kind: string
+	lanes: ReadonlyArray<CallTotal>
+	total_ms: number
+}
+
+// The command `time_shell` reads at the command position — past assignments, wrappers and navigation
+// builtins such as `cd` — so the kinds match the per-command tables.
+function leading_word(command: string): string {
+	const word = time_shell.leading_word(time_shell.unquoted(command))
+
+	return word === '' ? UNKNOWN : word
+}
+
+function bash_kind(command = ''): string {
+	const josh = lane_transcript_stats.josh_commands(command)
+
+	return josh.length > 0 ? `josh ${josh.join('+')}` : leading_word(command)
+}
+
+function agent_kind(call: ToolCall): string {
+	return `${AGENT_TOOL}:${call.subagent?.type ?? UNKNOWN}`
+}
+
+function kind_of(call: ToolCall): string {
+	if (call.tool === BASH_TOOL) return bash_kind(call.command)
+	if (call.tool === AGENT_TOOL) return agent_kind(call)
+
+	return call.tool ?? UNKNOWN
+}
+
+// One lane's read calls and their tool time, by kind.
+function lane_kinds(lane: ImplementLane): Map<string, CallTotal> {
+	const totals = new Map<string, CallTotal>()
+
+	for (const entry of lane_implement_read.read_calls(lane)) {
+		const kind = kind_of(entry.call)
+		const total = totals.get(kind) ?? { calls: 0, ms: 0 }
+
+		totals.set(kind, { calls: total.calls + 1, ms: total.ms + lane_implement_read.tool_ms(entry) })
+	}
+
+	return totals
+}
+
+// Each kind's per-lane totals, over the lanes that made such a call.
+function by_kind(lanes: ReadonlyArray<Map<string, CallTotal>>): Array<KindRow> {
+	const kinds = new Map<string, Array<CallTotal>>()
+	const entries = lanes.flatMap((totals) => [...totals])
+
+	for (const [kind, total] of entries) {
+		kinds.set(kind, [...(kinds.get(kind) ?? []), total])
+	}
+
+	return [...kinds].map(([kind, totals]) => ({
+		kind,
+		lanes: totals,
+		total_ms: lane_implement_read.sum(totals.map((total) => total.ms)),
+	}))
+}
+
+function by_total(left: KindRow, right: KindRow): number {
+	return right.total_ms - left.total_ms || left.kind.localeCompare(right.kind)
+}
+
+function kind_row({ kind, lanes, total_ms }: KindRow): Array<string> {
+	return [
+		kind,
+		String(lane_implement_read.sum(lanes.map((total) => total.calls))),
+		String(lanes.length),
+		lane_stage_stats.cell(lane_stats.median(lanes.map((total) => total.ms))),
+		lane_stage_stats.cell(total_ms),
+	]
+}
+
+// The period's table: the kinds that took the most read tool time over the lanes that shipped in `window`.
+function table(calls: ReadonlyArray<ToolCall>, window: StatsWindow, paused: PausedSpans): string {
+	const lanes = lane_implement_stats
+		.implement_lanes(calls, window, paused)
+		.map((lane) => lane_kinds(lane))
+	const rows = by_kind(lanes).toSorted(by_total).slice(0, TOP_KINDS)
+
+	return [
+		lane_stats.to_row(COLUMNS),
+		lane_stats.to_row(COLUMNS.map(() => '---')),
+		...rows.map((row) => lane_stats.to_row(kind_row(row))),
+	].join('\n')
+}
+
+const lane_implement_read_calls = { kind_of, table }
+
+export { lane_implement_read_calls }

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

@@ -80,10 +80,15 @@ function sum(values: ReadonlyArray<number>): number {
 	return values.reduce((total, value) => total + value, 0)
 }
 
-function breakdown(lane: ImplementLane): ReadBreakdown {
-	const reads = lane_implement_stats
+// The lane's implement calls put to the `read` sub-stage.
+function read_calls(lane: ImplementLane): Array<StagedCall> {
+	return lane_implement_stats
 		.staged(lane.calls, lane.paused)
 		.filter((entry) => entry.stage === READ_STAGE)
+}
+
+function breakdown(lane: ImplementLane): ReadBreakdown {
+	const reads = read_calls(lane)
 	const tool = sum(reads.map((entry) => tool_ms(entry)))
 	const files = files_read(reads)
 	const cited = cited_paths(lane.calls)
@@ -124,6 +129,6 @@ function table(calls: ReadonlyArray<ToolCall>, window: StatsWindow, paused: Paus
 	].join('\n')
 }
 
-const lane_implement_read = { table }
+const lane_implement_read = { read_calls, sum, table, tool_ms }
 
 export { lane_implement_read }

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

@@ -12,8 +12,10 @@ import { lane_transcript_stats } from './lane-transcript-stats'
 // median over the period's lanes.
 //
 // **A lane's implement ends at its first `ship` or `run:chain --join --ship` call**, so a lane that never shipped in the period
-// has no implement here. **`review-fix` runs from `run:review` on** — the round's fixes and their scoped
-// checks; before it, an edit is `edit`, a scoped check or gate is `check`, and any other call is `plan`
+// has no implement here. **`review-fix` runs from `run:review` on, or from the call after an open
+// `run:chain`** (no `--join`) whose output shows it ran `run:review` (joshuafolkken/kit#7566) — the round's
+// reviewer, fixes and their scoped checks; before it, an edit is `edit`, a scoped check, gate or open
+// `run:chain` is `check`, and any other call is `plan`
 // before the first edit, `read` after it. **A session's first call spans its own duration**, so the gap
 // between two sessions of one lane is nobody's. **Nor is the time the lane stood paused**: a
 // `lane:pause` leaves the call in flight on the clock, so its overlap with the lane's paused spans is
@@ -40,6 +42,7 @@ const SHIP_COMMANDS: ReadonlySet<string> = new Set(['ship'])
 const JOIN_FLAG = /\s--join(?:\s|$)/u
 const SHIP_FLAG = /\s--ship(?:\s|=|$)/u
 const CHAIN_REACHED_SHIP = /^run:chain \d+ — (?:ran (?:[^\s]+ → )*ship$|stopped at ship \()/mu
+const CHAIN_RAN_REVIEW = /^run:chain \d+ — ran (?:[^\s]+ → )*run:review$/mu
 const FIRST_LINT_ROW = `lane first ${LINT_RELATED}`
 // `backgrounded` counts a subagent row's untimed calls (`lane-implement-subagents.ts`); a sub-stage has none.
 const COLUMNS = [
@@ -53,6 +56,7 @@ const COLUMNS = [
 interface Phase {
 	edited: boolean
 	reviewing: boolean
+	chained: boolean
 }
 
 // The latest end of the calls seen so far in one session; calls run side by side overlap.
@@ -71,18 +75,41 @@ function is_edit(call: ToolCall): boolean {
 	return EDIT_TOOLS.has(call.tool ?? '')
 }
 
-// The phase once `call` ran: an edit, or a review started, holds for the rest of the lane.
+function opens_chain(segment: string): boolean {
+	return (
+		lane_transcript_stats.josh_commands(segment).includes('run:chain') && !JOIN_FLAG.test(segment)
+	)
+}
+
+function runs_open_chain(call: ToolCall): boolean {
+	return lane_transcript_stats
+		.command_segments(call.command)
+		.some((segment) => opens_chain(segment))
+}
+
+function is_check(call: ToolCall): boolean {
+	return runs_any(call, CHECK_COMMANDS) || runs_open_chain(call)
+}
+
+function chain_ran_review(call: ToolCall): boolean {
+	return runs_open_chain(call) && CHAIN_RAN_REVIEW.test(call.output)
+}
+
+// The phase once `call` ran: an edit, or a review started, holds for the rest of the lane; an open
+// `run:chain` is its own `check` and, once it ran `run:review`, starts the review from the next call —
+// one that stopped before it leaves the fix and re-run that follow in `edit` and `check`.
 function next_phase(call: ToolCall, phase: Phase): Phase {
 	return {
 		edited: phase.edited || is_edit(call),
-		reviewing: phase.reviewing || runs_any(call, REVIEW_COMMANDS),
+		reviewing: phase.reviewing || phase.chained || runs_any(call, REVIEW_COMMANDS),
+		chained: phase.chained || chain_ran_review(call),
 	}
 }
 
 function sub_stage_of(call: ToolCall, phase: Phase): SubStage {
 	if (phase.reviewing) return REVIEW_FIX
 	if (is_edit(call)) return EDIT
-	if (runs_any(call, CHECK_COMMANDS)) return CHECK
+	if (is_check(call)) return CHECK
 
 	return phase.edited ? READ : PLAN
 }
@@ -124,7 +151,7 @@ function staged(
 	paused: ReadonlyArray<PausedSpan>,
 ): Array<StagedCall> {
 	const result: Array<StagedCall> = []
-	let phase: Phase = { edited: false, reviewing: false }
+	let phase: Phase = { edited: false, reviewing: false, chained: false }
 	let reach = NO_REACH
 
 	for (const call of calls) {

package/scripts/lane/lane-ledger-schema-ship.ts

@@ -30,8 +30,19 @@ const early_push_schema = z.object({
 // failure or a followup `check` stopped on, so its re-ship can tell a fix-only tree from a moved base
 // (joshuafolkken/kit#6141, joshuafolkken/kit#6675), absent on every other stop. `checks` names the CI
 // checks a followup `check` stop's wait reported failed (joshuafolkken/kit#7333), absent on every other
-// stop and on one recorded before it had them. How long it stayed stopped is derived
+// stop and on one recorded before it had them. `unpinned` is the path an `unpinned` stop took and the
+// unpinned places it found (joshuafolkken/kit#7552): `no-reason` with no recorded `--unpinned-ok` reason,
+// `new-site` with one the places outran, `truncated` with one a check cut at its first unpinned hunk
+// never applies (`run-review-pinned-accepted.ts`), absent on any other stop and on one recorded before
+// it had it. On a cut check `hunks` is a lower bound and `remaining` counts the hunks it never probed,
+// absent on an uncut one. How long it stayed stopped is derived
 // from the next ship stage, not recorded, so a resumed ship never has to know the stop it ends.
+const UNPINNED_PATHS = ['no-reason', 'new-site', 'truncated'] as const
+const unpinned_stop_schema = z.object({
+	path: z.enum(UNPINNED_PATHS),
+	hunks: z.number(),
+	remaining: z.number().optional(),
+})
 const stop_schema = z.object({
 	kind: z.literal(KIND.STOP),
 	at: z.string(),
@@ -42,6 +53,7 @@ const stop_schema = z.object({
 	findings: z.array(z.string()).optional(),
 	base: z.string().optional(),
 	checks: z.array(z.string()).optional(),
+	unpinned: unpinned_stop_schema.optional(),
 })
 // One `josh run:chain` on `issue`, done or stopped: `at` is its end and `elapsed_ms` its length, so the
 // next run's start ends the wait after a stop. `stage` names where it stopped and `reason` why — the
@@ -94,7 +106,7 @@ const ship_lap_schema = z.object({
 // A merging `josh followup`'s size of `issue`: the Issue's declared size estimate and the branch's
 // measured diff, test files excluded, so `lane:stats` reads how far estimates miss the guide's
 // counting (joshuafolkken/kit#5384). Written before the merge, while the branch is still checked out.
-// `missed` marks a diff past the split notice bar: a size the pre-dispatch assessment let through, as
+// `missed` marks a diff past the split cap (the notice bar before joshuafolkken/kit#7579): a size the pre-dispatch assessment let through, as
 // the started lane is never split (joshuafolkken/kit#7183).
 const counts_schema = z.object({ files: z.number(), lines: z.number() })
 const size_schema = z.object({
@@ -108,6 +120,8 @@ const size_schema = z.object({
 
 type ChainEntry = z.infer<typeof chain_schema>
 type ChainRecord = Omit<ChainEntry, 'kind' | 'at'>
+type UnpinnedStop = z.infer<typeof unpinned_stop_schema>
+type UnpinnedPath = UnpinnedStop['path']
 
 const lane_ledger_schema_ship = {
 	chain_schema,
@@ -118,5 +132,5 @@ const lane_ledger_schema_ship = {
 	unplanned_notice_schema,
 }
 
-export type { ChainEntry, ChainRecord }
+export type { ChainEntry, ChainRecord, UnpinnedPath, UnpinnedStop }
 export { lane_ledger_schema_ship }