@joshuafolkken/kit 1.1784.0 → 1.2116.0

package/scripts/lane/lane-child-marker.ts

@@ -1,4 +1,5 @@
 import { issue_number_shape } from '#scripts/issue/issue-number-shape'
+import { lane_child_mark_keys } from './lane-child-mark-keys'
 import { lane_paths } from './lane-paths'
 
 // The mark a dispatched lane child carries, so the pre-gate cut and a resume are decided from the
@@ -17,7 +18,7 @@ import { lane_paths } from './lane-paths'
 // equals the lane's own issue, so a leaked mark for another issue is read as absent. The name, the
 // meaning and the lifetime are documented once in
 // `.claude/skills/workflow-commands/pre-gate-cut.md`.
-const KEY = 'JOSH_LANE_CHILD'
+const { KEY, OVERRUN_KEY } = lane_child_mark_keys
 
 // **A dispatched child also asks for the five-minute prompt-cache TTL**. A
 // headless `claude -p` session on a subscription defaults to the one-hour TTL, whose writes bill at 2x
@@ -28,6 +29,11 @@ const KEY = 'JOSH_LANE_CHILD'
 const CACHE_TTL_KEY = 'CLAUDE_CODE_PROMPT_CACHE_TTL'
 const CACHE_TTL = '5m'
 
+// **An overrun investigation also carries its own mark** (joshuafolkken/kit#4880): it runs as the
+// lane's child, so `issue:file` reads this one to record its filings as the investigation's rather than
+// the child's. The launcher sets it, so the record never rests on the model passing an argument.
+const OVERRUN_VALUE = '1'
+
 type MarkerSource = Readonly<Record<string, string | undefined>>
 
 // The environment fragment that marks a child dispatched for `#<issue>`. Composed from a digits-only
@@ -50,6 +56,16 @@ function marked_issue(source: MarkerSource = process.env): string | undefined {
 	return issue_number_shape.ISSUE_NUMBER_PATTERN.test(value) ? value : undefined
 }
 
+// The environment of the overrun investigation of `#<issue>`'s lane: the child's, plus its own mark.
+function overrun_environment_for(issue: string): Record<string, string> {
+	return { ...environment_for(issue), [OVERRUN_KEY]: OVERRUN_VALUE }
+}
+
+// Read only beside a valid child mark, so a mark leaked without one is read as absent.
+function is_overrun(source: MarkerSource = process.env): boolean {
+	return source[OVERRUN_KEY] === OVERRUN_VALUE && marked_issue(source) !== undefined
+}
+
 // True when this session is a dispatched lane child for the checkout it is running in: the mark is
 // present and names this lane's own issue, read from the checkout path. A numeric mark naming a
 // *different* issue leaked in from a parent session into a checkout it does not belong to, so it is
@@ -63,8 +79,11 @@ function is_child_of(directory: string, source: MarkerSource = process.env): boo
 
 const lane_child_marker = {
 	KEY,
+	OVERRUN_KEY,
 	env_for: environment_for,
+	overrun_env_for: overrun_environment_for,
 	is_child_of,
+	is_overrun,
 	marked_issue,
 }
 

package/scripts/lane/lane-ci-path-stats.ts

@@ -0,0 +1,73 @@
+import { lane_check_stats } from './lane-check-stats'
+import { lane_ledger, type LedgerEntry, type StageEntry } from './lane-ledger'
+import { lane_ledger_write } from './lane-ledger-write'
+import { lane_stats, type StatsWindow } from './lane-stats'
+
+// The followup's critical path (joshuafolkken/kit#5295): over the period's `ci-wait` rows, which check
+// settled last — how often, and the median and maximum of when it settled into the wait — printed by
+// `josh lane:stats`. A row from before the field, or a wait no check was seen to settle in, names none
+// and is left out.
+
+const COLUMNS = ['followup critical path', 'runs', 'median (s)', 'max (s)'] as const
+
+interface LastCheck {
+	name: string
+	elapsed_ms: number
+}
+
+function settled({ last_check, check_ms }: StageEntry): LastCheck | undefined {
+	if (last_check === undefined) return undefined
+
+	const elapsed_ms = check_ms?.[last_check]
+
+	return elapsed_ms === undefined ? undefined : { name: last_check, elapsed_ms }
+}
+
+function last_check_of(entry: LedgerEntry): LastCheck | undefined {
+	if (entry.kind !== lane_ledger.KIND.STAGE || entry.stage !== lane_ledger_write.CI_WAIT_STAGE) {
+		return undefined
+	}
+
+	return settled(entry)
+}
+
+function name_row(name: string, lasts: ReadonlyArray<LastCheck>): string {
+	const elapsed = lasts.filter((last) => last.name === name).map((last) => last.elapsed_ms)
+
+	return lane_stats.to_row([
+		name,
+		String(elapsed.length),
+		lane_check_stats.cell(lane_stats.median(elapsed)),
+		lane_check_stats.cell(lane_stats.peak(elapsed)),
+	])
+}
+
+// The period's table: `entries` is the whole ledger, filtered here to `window`.
+function table(entries: ReadonlyArray<LedgerEntry>, window: StatsWindow): string {
+	const lasts = lane_stats
+		.in_window(entries, window)
+		.map((entry) => last_check_of(entry))
+		.filter((last) => last !== undefined)
+	const names = [...new Set(lasts.map((last) => last.name))]
+
+	return [...lane_check_stats.header(COLUMNS), ...names.map((name) => name_row(name, lasts))].join(
+		'\n',
+	)
+}
+
+// `issue`'s followup line detail for `lane:breakdown`: the last check its latest `ci-wait` row names,
+// `''` where none does.
+function last_check_text(entries: ReadonlyArray<LedgerEntry>, issue: number): string {
+	const last = entries
+		.filter((entry) => entry.kind === lane_ledger.KIND.STAGE && entry.issue === issue)
+		.map((entry) => last_check_of(entry))
+		.findLast((found) => found !== undefined)
+
+	return last === undefined
+		? ''
+		: ` (last check: ${last.name} ${lane_check_stats.cell(last.elapsed_ms)}s)`
+}
+
+const lane_ci_path_stats = { last_check_text, table }
+
+export { lane_ci_path_stats }

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

@@ -0,0 +1,84 @@
+import { MS_PER_SECOND } from '#scripts/lib/timeouts'
+import { lane_ledger, type GateCheckRecord, type GateEntry, type LedgerEntry } from './lane-ledger'
+import { lane_stage_stats } from './lane-stage-stats'
+import { lane_stats, type StatsWindow } from './lane-stats'
+import { lane_tail_stats } from './lane-tail-stats'
+
+// What each gate check claimed from the core budget against what it used (joshuafolkken/kit#5138): one
+// period's per-check rows reduced to one row per check — the median cores requested, then the cores it
+// kept busy (`cpu_ms ÷ elapsed_ms`) as a median, a 90th percentile and a maximum, and the seconds its
+// claims waited. The weights in `scripts/gate/core-weights.ts` are changed from this table, never by it.
+//
+// **Only a measured run is counted**: a reused check started no process, and a check with no `cpu_ms`
+// was recorded before the field existed, so neither says how many cores the check used.
+
+const DECIMALS = 1
+const COLUMNS = [
+	'check',
+	'claim',
+	'runs',
+	'cores median',
+	'cores p90',
+	'cores max',
+	'wait (s)',
+] as const
+const { NOT_MEASURED } = lane_stage_stats
+
+interface MeasuredCheck {
+	label: string
+	elapsed_ms: number
+	cpu_ms: number
+	claim?: GateCheckRecord['claim']
+}
+
+function is_gate(entry: LedgerEntry): entry is GateEntry {
+	return entry.kind === lane_ledger.KIND.GATE
+}
+
+function is_measured(check: GateCheckRecord): check is GateCheckRecord & MeasuredCheck {
+	return check.is_reused !== true && check.cpu_ms !== undefined && check.elapsed_ms > 0
+}
+
+function number_cell(value: number | undefined): string {
+	return value === undefined ? NOT_MEASURED : value.toFixed(DECIMALS)
+}
+
+function seconds_cell(milliseconds: number | undefined): string {
+	return number_cell(milliseconds === undefined ? undefined : milliseconds / MS_PER_SECOND)
+}
+
+function total(values: ReadonlyArray<number>): number {
+	return values.reduce((sum, value) => sum + value, 0)
+}
+
+function check_row(label: string, checks: ReadonlyArray<MeasuredCheck>): string {
+	const runs = checks.filter((check) => check.label === label)
+	const cores = runs.map((check) => check.cpu_ms / check.elapsed_ms)
+	const claims = runs.map((check) => check.claim).filter((claim) => claim !== undefined)
+	const requested = claims.map((claim) => claim.requested)
+	const waited_ms = claims.length === 0 ? undefined : total(claims.map((claim) => claim.waited_ms))
+
+	return lane_stats.to_row([
+		label,
+		number_cell(lane_stats.median(requested)),
+		String(runs.length),
+		number_cell(lane_stats.median(cores)),
+		number_cell(lane_tail_stats.tail_minutes(cores)),
+		number_cell(lane_stats.peak(cores)),
+		seconds_cell(waited_ms),
+	])
+}
+
+// The period's table: `entries` is the whole ledger, filtered here to `window`.
+function table(entries: ReadonlyArray<LedgerEntry>, window: StatsWindow): string {
+	const gates = lane_stats.in_window(entries, window).filter(is_gate)
+	const checks = gates.flatMap((gate) => gate.checks ?? []).filter(is_measured)
+	const labels = [...new Set(checks.map((check) => check.label))]
+	const header = [lane_stats.to_row(COLUMNS), lane_stats.to_row(COLUMNS.map(() => '---'))]
+
+	return [...header, ...labels.map((label) => check_row(label, checks))].join('\n')
+}
+
+const lane_claim_stats = { table }
+
+export { lane_claim_stats }

package/scripts/lane/lane-close.ts

@@ -3,6 +3,7 @@ import { git_command } from '#scripts/git/git-command'
 import { git_worktree } from '#scripts/git/git-worktree'
 import { error_text } from '#scripts/lib/error-message'
 import { lane_paths } from './lane-paths'
+import { lane_plan } from './lane-plan'
 import { lane_reap } from './lane-reap'
 import { lane_reap_settle } from './lane-reap-settle'
 import { lane_registry, type LaneInfo } from './lane-registry'
@@ -160,6 +161,12 @@ async function left_behind_of(issue: string, targets: LaneTargets): Promise<Arra
 	return [...(await residue(targets)), ...survivors]
 }
 
+// An ended lane's cleared plan goes with it; a plan its lane yielded on stays (`lane_plan.release`).
+async function record_end(issue: string): Promise<void> {
+	await lane_state.record_change({ issue, state: 'ended', command: 'lane:close' })
+	lane_plan.release(Number(issue), process.cwd())
+}
+
 async function close_lane(issue: string): Promise<CloseOutcome> {
 	const { existing, targets } = await resolve_lane(issue)
 	const did_exist = existing !== undefined || existsSync(targets.directory)
@@ -174,9 +181,7 @@ async function close_lane(issue: string): Promise<CloseOutcome> {
 	const left_behind = await left_behind_of(issue, targets)
 	const kind = close_kind(did_exist, left_behind)
 
-	if (await is_ending(issue, kind)) {
-		await lane_state.record_change({ issue, state: 'ended', command: 'lane:close' })
-	}
+	if (await is_ending(issue, kind)) await record_end(issue)
 
 	return { issue, kind, left_behind, reaped, residents }
 }

package/scripts/lane/lane-dispatch-log.ts

@@ -1,11 +1,11 @@
-import { stamp_file } from '#scripts/josh/stamp-file'
+import { durable_state } from '#scripts/josh/durable-state'
 import type { LaneInfo } from './lane-registry'
 
-const LOG_PREFIX = 'josh-lane-dispatch-'
+const LOG_PREFIX = durable_state.PREFIX.LANE_DISPATCH
 const LOG_SUFFIX = '.log'
 
 function default_log_path(lane: LaneInfo): string {
-	return stamp_file.stamp_path(`${LOG_PREFIX}${lane.issue}-`, lane.directory, LOG_SUFFIX)
+	return durable_state.path(`${LOG_PREFIX}${lane.issue}-`, lane.directory, LOG_SUFFIX)
 }
 
 const lane_dispatch_log = { default_log_path }

package/scripts/lane/lane-dispatch.ts

@@ -16,7 +16,7 @@ import { run_label } from '#scripts/run/run-label'
 import { lane_child_invocation } from './lane-child-invocation'
 import { lane_child_marker } from './lane-child-marker'
 import { lane_dispatch_log } from './lane-dispatch-log'
-import { lane_ledger } from './lane-ledger'
+import { lane_ledger_write } from './lane-ledger-write'
 import { lane_output } from './lane-output'
 import { lane_registry, type LaneInfo } from './lane-registry'
 import { lane_resume, type ResumePlan } from './lane-resume'
@@ -345,7 +345,7 @@ async function record_started(issue: string, start: DispatchStart): Promise<void
 		`${issue_cite.plain(issue)} dispatched`,
 		now,
 	)
-	await lane_ledger.record_dispatch(Number(issue))
+	await lane_ledger_write.record_dispatch(Number(issue))
 	await lane_state.record_change(
 		{
 			issue,

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

@@ -2,6 +2,7 @@ import { agent_role_profile } from '#scripts/agent/agent-role-profile'
 import { MS_PER_SECOND } from '#scripts/lib/timeouts'
 import { run_event_stream, type RunEvent } from '#scripts/run/event/run-event-stream'
 import { lane_ledger, type LedgerEntry, type MergeEntry } from './lane-ledger'
+import { lane_net_time } from './lane-net-time'
 import { lane_spans, type Span } from './lane-spans'
 import { lane_stage_stats } from './lane-stage-stats'
 import { lane_stats, type StatsWindow } from './lane-stats'
@@ -17,6 +18,8 @@ import { lane_stop_stats } from './lane-stop-stats'
 //   entry. A pool that stays full writes no line after its one `released`, and a driver handed back
 //   writes none, so a gap over the offer interval is a full pool or no driver, never the hand-over
 //   (joshuafolkken/kit#4410). The ship's cap park and the driver's collection of it are each timed.
+// - `yield → redispatch`: a yield (`lane:plan` gave the seat back) until its issue's next `dispatch`, the
+//   wait `josh lane:net` takes out (`lane-net-time.ts`, joshuafolkken/kit#5216).
 // - `followup → merge`: the ship's last `followup` stage before the merge until the parent wrote the
 //   `merge` line, the step that releases the slot. A merge with no `followup` stage has no start.
 //
@@ -26,10 +29,11 @@ const COLUMNS = ['gap', 'count', 'median (s)', 'max (s)', 'not ended'] as const
 const RELAUNCH = 'cut → resume'
 const OUTAGE = 'outage → relaunch'
 const PARK = 'park → offer'
+const YIELD = 'yield → redispatch'
 const MERGE = 'followup → merge'
 const FOLLOWUP_STAGE = 'followup'
 const IMPLEMENTATION_CUT = `cut (${agent_role_profile.IMPLEMENTATION_PHASE})`
-const { NOT_MEASURED, is_dispatch, is_number, is_stage } = lane_stage_stats
+const { NOT_MEASURED, is_dispatch, is_merge, is_number, is_stage } = lane_stage_stats
 const { EVENT_KIND } = run_event_stream
 // The offer answers that are not a dispatch: a free lane held, or the pool found full.
 const OFFER_ANSWERS: ReadonlySet<string> = new Set([
@@ -38,7 +42,7 @@ const OFFER_ANSWERS: ReadonlySet<string> = new Set([
 ])
 
 // Only an implementation cut appends a `resume` when it is adopted; a pre-gate resume appends nothing,
-// so its cut would read as never ended (`run-cut-cli.ts` → `emit_resume_event`).
+// so its cut would read as never ended (`run-cut-resume.ts` → `emit_resume_event`).
 function implementation_cuts(events: ReadonlyArray<RunEvent>): Array<RunEvent> {
 	return events.filter((event) => event.text.endsWith(IMPLEMENTATION_CUT))
 }
@@ -81,10 +85,6 @@ function park_spans(
 		.map((park) => ({ from_ms: park.at_ms, end_ms: offers.find((at) => at > park.at_ms) }))
 }
 
-function is_merge(entry: LedgerEntry): entry is MergeEntry {
-	return entry.kind === lane_ledger.KIND.MERGE
-}
-
 function is_followup_of(entry: LedgerEntry, merge: MergeEntry): boolean {
 	return (
 		is_stage(entry) &&
@@ -147,6 +147,7 @@ function table(
 		gap_row(RELAUNCH, relaunch_spans(events), window),
 		gap_row(OUTAGE, outage_spans(events), window),
 		gap_row(PARK, park_spans(entries, events), window),
+		gap_row(YIELD, lane_net_time.yield_spans(entries, events), window),
 		gap_row(MERGE, merge_spans(entries), window),
 	].join('\n')
 }

package/scripts/lane/lane-guard-policy.ts

@@ -26,7 +26,7 @@ import { lane_child_marker, type MarkerSource } from './lane-child-marker'
 // The three ways a guard may behave in a lane child. Outside a lane child every
 // guard is `refuse`, which is why that is also the fail-safe default below.
 type LaneGuardMode = 'refuse' | 'notice' | 'off'
-type LaneGuardId = 'investigation' | 'batching' | 'rule' | 'duplicate-read'
+type LaneGuardId = 'investigation' | 'batching' | 'search-batching' | 'rule' | 'duplicate-read'
 
 // The mode outside a lane child, and the fail-safe for a guard nobody enumerated: a denial, the same
 // direction `delegation-policy.ts` takes, because a silenced rule is the one mistake that ships unseen.
@@ -55,6 +55,12 @@ const LANE_GUARD_POLICY: ReadonlyArray<LaneGuardEntry> = [
 		because:
 			'a refusal ends a child turn and every advisory notice was measured not to move the call density, so the guard is off and the density stays readable through `josh time:density`',
 	},
+	{
+		id: 'search-batching',
+		mode_in_lane_child: 'refuse',
+		because:
+			'the largest share of single-call pairs in lane children is a search chain (`grep` / `sed` issued one per turn, about 10,600 pairs in 14 days), and a refusal re-fires only every third single-call search turn, so one refused round trip (about $0.036) is repaid once it folds two later searches into one turn',
+	},
 	{
 		id: 'duplicate-read',
 		mode_in_lane_child: 'notice',

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

@@ -0,0 +1,207 @@
+import { lane_implement_subagents, type ImplementLane } from './lane-implement-subagents'
+import { lane_paused_spans, type PausedSpan, 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 stage broken down by what its time went on (joshuafolkken/kit#4887). The ledger's
+// implement is one span per lane, dispatch to the ship's first stage (`lane-stage-stats.ts`); the lane's
+// transcript holds every tool call inside it, so each call's span — from the latest end of the session's
+// earlier calls to its own, the model's turn before it included — is put to one sub-stage, and `lane:stats` prints each one's
+// median over the period's lanes.
+//
+// **A lane's implement ends at its first `josh 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`
+// 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
+// taken out (joshuafolkken/kit#5168).
+
+const SUB_STAGES = ['plan', 'read', 'edit', 'check', 'review-fix'] as const
+type SubStage = (typeof SUB_STAGES)[number]
+const [PLAN, READ, EDIT, CHECK, REVIEW_FIX] = SUB_STAGES
+type Totals = ReadonlyMap<SubStage, number>
+
+const EDIT_TOOLS: ReadonlySet<string> = new Set(['Edit', 'MultiEdit', 'NotebookEdit', 'Write'])
+const CHECK_COMMANDS: ReadonlySet<string> = new Set([
+	'check:related',
+	'cspell:dot',
+	'gate',
+	'lint:related',
+	'metrics',
+	'test:pinned',
+	'test:related',
+])
+const REVIEW_COMMANDS: ReadonlySet<string> = new Set(['review:brief', 'run:review'])
+const SHIP_COMMANDS: ReadonlySet<string> = new Set(['ship'])
+// `backgrounded` counts a subagent row's untimed calls (`lane-implement-subagents.ts`); a sub-stage has none.
+const COLUMNS = [
+	'implement sub-stage',
+	'lanes',
+	'median (min)',
+	'max (min)',
+	'backgrounded',
+] as const
+
+interface Phase {
+	edited: boolean
+	reviewing: boolean
+}
+
+// The latest end of the calls seen so far in one session; calls run side by side overlap.
+interface Reach {
+	session_id: ToolCall['session_id'] | undefined
+	end_ms: number
+}
+
+const NO_REACH: Reach = { session_id: undefined, end_ms: 0 }
+
+function runs_any(call: ToolCall, names: ReadonlySet<string>): boolean {
+	return lane_transcript_stats.josh_commands(call.command).some((name) => names.has(name))
+}
+
+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 next_phase(call: ToolCall, phase: Phase): Phase {
+	return {
+		edited: phase.edited || is_edit(call),
+		reviewing: phase.reviewing || runs_any(call, REVIEW_COMMANDS),
+	}
+}
+
+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
+
+	return phase.edited ? READ : PLAN
+}
+
+function end_ms(call: ToolCall): number {
+	return call.started_ms + (call.duration_ms ?? 0)
+}
+
+function span_ms(call: ToolCall, reach: Reach): number {
+	if (reach.session_id !== call.session_id) return call.duration_ms ?? 0
+
+	return Math.max(0, end_ms(call) - reach.end_ms)
+}
+
+function next_reach(call: ToolCall, reach: Reach): Reach {
+	const latest = reach.session_id === call.session_id ? reach.end_ms : 0
+
+	return { session_id: call.session_id, end_ms: Math.max(latest, end_ms(call)) }
+}
+
+// The call's span less the time its lane stood paused inside it.
+function active_ms(call: ToolCall, reach: Reach, paused: ReadonlyArray<PausedSpan>): number {
+	const span = span_ms(call, reach)
+	const end = end_ms(call)
+
+	return span - lane_paused_spans.overlap_ms(paused, end - span, end)
+}
+
+// Each sub-stage's summed span over one lane's implement calls, oldest first.
+function lane_totals(calls: ReadonlyArray<ToolCall>, paused: ReadonlyArray<PausedSpan>): Totals {
+	const totals = new Map<SubStage, number>(SUB_STAGES.map((stage) => [stage, 0]))
+	let phase: Phase = { edited: false, reviewing: false }
+	let reach = NO_REACH
+
+	for (const call of calls) {
+		phase = next_phase(call, phase)
+		const stage = sub_stage_of(call, phase)
+
+		totals.set(stage, (totals.get(stage) ?? 0) + active_ms(call, reach, paused))
+		reach = next_reach(call, reach)
+	}
+
+	return totals
+}
+
+// One lane's calls before its first ship, or `undefined` when it never shipped.
+function implement_calls(calls: ReadonlyArray<ToolCall>): ReadonlyArray<ToolCall> | undefined {
+	const ship = calls.findIndex((call) => runs_any(call, SHIP_COMMANDS))
+
+	return ship === -1 ? undefined : calls.slice(0, ship)
+}
+
+function lanes_of(calls: ReadonlyArray<ToolCall>): Array<ReadonlyArray<ToolCall>> {
+	const lanes = [...new Set(calls.map((call) => call.lane))]
+
+	return lanes.map((lane) =>
+		calls
+			.filter((call) => call.lane === lane)
+			.toSorted((left, right) => left.started_ms - right.started_ms),
+	)
+}
+
+// One lane's implement calls and paused spans, or `undefined` when it never shipped.
+function implement_lane(
+	lane: ReadonlyArray<ToolCall>,
+	paused: PausedSpans,
+): ImplementLane | undefined {
+	const implement = implement_calls(lane)
+	const spans = lane_paused_spans.of_lane(paused, lane[0]?.lane ?? '')
+
+	return implement === undefined ? undefined : { calls: implement, paused: spans }
+}
+
+// The implement calls and paused spans of each lane that shipped in `window`.
+function implement_lanes(
+	calls: ReadonlyArray<ToolCall>,
+	window: StatsWindow,
+	paused: PausedSpans,
+): Array<ImplementLane> {
+	const lanes = lanes_of(lane_transcript_stats.in_period(calls, window))
+
+	return lanes.flatMap((lane) => implement_lane(lane, paused) ?? [])
+}
+
+// The sub-stage totals of each lane that shipped in `window`.
+function lane_totals_in(
+	calls: ReadonlyArray<ToolCall>,
+	window: StatsWindow,
+	paused: PausedSpans,
+): Array<Totals> {
+	return implement_lanes(calls, window, paused).map((lane) => lane_totals(lane.calls, lane.paused))
+}
+
+function stage_row(stage: SubStage, totals: ReadonlyArray<Totals>): Array<string> {
+	const values = totals.map((lane) => lane.get(stage) ?? 0)
+
+	return [
+		stage,
+		String(values.length),
+		lane_stage_stats.cell(lane_stats.median(values)),
+		lane_stage_stats.cell(lane_stats.peak(values)),
+		'',
+	]
+}
+
+// The period's table: `calls` is every lane session's calls, filtered here to `window`; `paused` is
+// each lane's paused spans (`lane-paused-spans.ts`). The sub-stages, then the subagents by agent type
+// (`lane-implement-subagents.ts`).
+function table(calls: ReadonlyArray<ToolCall>, window: StatsWindow, paused: PausedSpans): string {
+	const lanes = implement_lanes(calls, window, paused)
+	const totals = lanes.map((lane) => lane_totals(lane.calls, lane.paused))
+	const rows = [
+		...SUB_STAGES.map((stage) => stage_row(stage, totals)),
+		...lane_implement_subagents.rows(lanes),
+	]
+
+	return [
+		lane_stats.to_row(COLUMNS),
+		lane_stats.to_row(COLUMNS.map(() => '---')),
+		...rows.map((row) => lane_stats.to_row(row)),
+	].join('\n')
+}
+
+const lane_implement_stats = { SUB_STAGES, lane_totals_in, table }
+
+export type { SubStage }
+export { lane_implement_stats }

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

@@ -0,0 +1,90 @@
+import { lane_paused_spans, type PausedSpan } from './lane-paused-spans'
+import { lane_stage_stats } from './lane-stage-stats'
+import { lane_stats } from './lane-stats'
+import type { ToolCall } from './lane-transcript-calls'
+
+// The implement's subagent time by the agent dispatched (joshuafolkken/kit#5297): one row per agent
+// type under `lane:stats`'s implement sub-stages, over the lanes that dispatched it. **A row times the
+// call's own duration**, less the time its lane stood paused inside it — the sub-stages above already
+// put the same call's span to `plan`, `read` or `review-fix`, so the rows break those down rather than
+// add to them. **A backgrounded call is counted, never timed**: its result line is the background
+// notice (`lane-transcript-calls.ts`), so it adds to the row's `backgrounded` count alone — a lane
+// whose calls of a type were all untimed is not among the lanes the median and max are taken over.
+// **The first cell is the type alone**, so a `lane:value cell --row "subagent: <type>"` address holds
+// from one period to the next.
+
+// One lane's implement calls and the spans it stood paused (`lane-implement-stats.ts`).
+interface ImplementLane {
+	calls: ReadonlyArray<ToolCall>
+	paused: ReadonlyArray<PausedSpan>
+}
+
+interface TypeTotal {
+	ms: number
+	timed: number
+	untimed: number
+}
+
+const NO_TOTAL: TypeTotal = { ms: 0, timed: 0, untimed: 0 }
+
+function own_ms(call: ToolCall, paused: ReadonlyArray<PausedSpan>): number {
+	const duration = call.duration_ms ?? 0
+	const end = call.started_ms + duration
+
+	return duration - lane_paused_spans.overlap_ms(paused, call.started_ms, end)
+}
+
+function added(total: TypeTotal, call: ToolCall, paused: ReadonlyArray<PausedSpan>): TypeTotal {
+	return {
+		ms: total.ms + own_ms(call, paused),
+		timed: total.timed + (call.duration_ms === undefined ? 0 : 1),
+		untimed: total.untimed + (call.background ? 1 : 0),
+	}
+}
+
+// Each agent type's summed time and backgrounded count over one lane's implement calls.
+function lane_types(lane: ImplementLane): ReadonlyMap<string, TypeTotal> {
+	const types = new Map<string, TypeTotal>()
+
+	for (const call of lane.calls) {
+		const type = call.subagent?.type
+
+		if (type !== undefined) types.set(type, added(types.get(type) ?? NO_TOTAL, call, lane.paused))
+	}
+
+	return types
+}
+
+// The type's row: its timed lanes, their median and max, and its backgrounded calls over every lane.
+function type_row(type: string, totals: ReadonlyArray<TypeTotal>): Array<string> {
+	const values = totals.filter((total) => total.timed > 0).map((total) => total.ms)
+	const untimed = totals.reduce((sum, total) => sum + total.untimed, 0)
+
+	return [
+		`subagent: ${type}`,
+		String(values.length),
+		lane_stage_stats.cell(lane_stats.median(values)),
+		lane_stage_stats.cell(lane_stats.peak(values)),
+		String(untimed),
+	]
+}
+
+// One row per agent type any lane dispatched, by name; its lanes are the lanes that dispatched it.
+function rows(lanes: ReadonlyArray<ImplementLane>): Array<Array<string>> {
+	const per_lane = lanes.map((lane) => lane_types(lane))
+	const types = [...new Set(per_lane.flatMap((types_of) => [...types_of.keys()]))].toSorted(
+		(left, right) => left.localeCompare(right),
+	)
+
+	return types.map((type) =>
+		type_row(
+			type,
+			per_lane.flatMap((types_of) => types_of.get(type) ?? []),
+		),
+	)
+}
+
+const lane_implement_subagents = { rows }
+
+export type { ImplementLane }
+export { lane_implement_subagents }

package/scripts/lane/lane-investigation-switch.ts

@@ -0,0 +1,16 @@
+import { hook_decision } from '#scripts/josh/hook-decision'
+
+// The switch the automatic lane investigations `run:merge` launches — the overrun's
+// (`lane-overrun.ts`) and the baseline's (`lane-baseline.ts`) — share (joshuafolkken/kit#5044). It
+// defaults off, so an unset variable launches no session; `run:merge` loads `.env`, where it is set.
+// Not `JOSH_LANE_OVERRUN`, the mark an investigation session itself carries.
+const INVESTIGATION_ENV_KEY = 'JOSH_LANE_INVESTIGATION'
+
+// Read at call time, so a suite that switches the variable between cases is not answered from a cache.
+function is_on(): boolean {
+	return hook_decision.is_switch_opt_in(INVESTIGATION_ENV_KEY)
+}
+
+const lane_investigation_switch = { is_on }
+
+export { lane_investigation_switch }