@joshuafolkken/kit 1.1514.0 → 1.2114.0

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

@@ -1,20 +1,30 @@
+import { run_event_stream, type RunEvent } from '#scripts/run/event/run-event-stream'
+import { run_ship_planned } from '#scripts/run/ship/run-ship-planned'
 import { run_ship_stage } from '#scripts/run/ship/run-ship-stage'
 import { lane_ledger, type LedgerEntry, type StopEntry } from './lane-ledger'
+import type { IssueAt } from './lane-spans'
 import { lane_stage_stats } from './lane-stage-stats'
 import { lane_stats, type StatsWindow } from './lane-stats'
 
 // How long a lane stood stopped: the ledger's `stop` entries of one period reduced to one row per stop
-// reason — median, maximum, how many stops were resumed and how many never were — printed by
-// `josh lane:stats` under the per-stage table, so the stop reason worth removing next is a number.
+// reason — the wait's median, maximum and total, how many waits ended and how many never did — printed
+// by `josh lane:stats` under the per-stage table, so the stop reason worth removing next is a number.
 //
-// **The wait is derived, not recorded**: from a stop to the start of the same issue's next ship stage,
-// the way `implement` is. A stop that no ship stage followed — the lane parked, or left stopped — is
-// counted under `not resumed` and kept out of the median and the maximum, whose time has no end.
-//
-// **A re-dispatch of the issue ends the search**: the new child's ship is a fresh lane's work, not the
-// resumption of a stop that may be days old.
+// **The wait is derived, not recorded**: from a stop to whichever comes first of the same issue's next
+// ship stage (the lane resumed), its re-dispatch (a fresh lane took it over) and its park on the run's
+// event stream (the run gave up on it) — the time the stop held the issue (joshuafolkken/kit#3997). A
+// stop none of the three followed is counted under `not resumed` and kept out of the median, the
+// maximum and the total, whose time has no end.
 
-const COLUMNS = ['stop', 'median (min)', 'max (min)', 'runs', 'not resumed'] as const
+const COLUMNS = [
+	'stop',
+	'wait median (min)',
+	'wait max (min)',
+	'wait total (min)',
+	'runs',
+	'not resumed',
+	'causes',
+] as const
 const { STAGE } = run_ship_stage
 const { is_dispatch, is_number, is_stage } = lane_stage_stats
 const REASONS = [
@@ -28,9 +38,20 @@ const REASONS = [
 	STAGE.FOLLOWUP,
 	STAGE.REPORT,
 ] as const
+// `#<N> parked`, `#<N> parked (<reason>)`, `#<N> waiting on #<M>`, `#<N> cut (<phase>)` and
+// `#<N> resumed` name their issue first.
+const EVENT_ISSUE = /#([1-9]\d*)\b/u
 
+// A stop recorded before it carried a cause (joshuafolkken/kit#3998) is counted under this one.
+const UNRECORDED_CAUSE = 'unrecorded'
+const NO_CAUSES = '-'
+const NOTICED = ' (noticed)'
+
+// `causes` is a preflight stop's unmet preconditions or a review stop's blocking finding kinds, every
+// one of them, else the stop's one cause.
 interface StopWait {
 	reason: string
+	causes: ReadonlyArray<string>
 	wait_ms: number | undefined
 }
 
@@ -38,51 +59,138 @@ function is_stop(entry: LedgerEntry): entry is StopEntry {
 	return entry.kind === lane_ledger.KIND.STOP
 }
 
-function redispatch_ms(stop: StopEntry, entries: ReadonlyArray<LedgerEntry>): number {
-	const from_ms = Date.parse(stop.at)
-	const later = entries
-		.filter((entry) => is_dispatch(entry))
-		.filter((entry) => entry.issue === stop.issue)
-		.map((entry) => Date.parse(entry.at))
-		.filter((at) => at > from_ms)
+// The issue a run event's text names first, `NaN` where it names none.
+function issue_of(event: RunEvent): number {
+	return Number(EVENT_ISSUE.exec(event.text)?.[1])
+}
+
+// Every run event of `kind`, with the issue its text names first.
+function events_of(events: ReadonlyArray<RunEvent>, kind: string): Array<IssueAt> {
+	return events
+		.filter((event) => event.kind === kind)
+		.map((event) => ({ issue: issue_of(event), at_ms: Date.parse(event.at) }))
+}
 
-	return later.length === 0 ? Infinity : Math.min(...later)
+function parks_of(events: ReadonlyArray<RunEvent>): Array<IssueAt> {
+	return events_of(events, run_event_stream.EVENT_KIND.PARK)
 }
 
-function wait_ms(stop: StopEntry, entries: ReadonlyArray<LedgerEntry>): number | undefined {
-	const from_ms = Date.parse(stop.at)
-	const until_ms = redispatch_ms(stop, entries)
-	const starts = entries
+function dispatches_of(entries: ReadonlyArray<LedgerEntry>): Array<IssueAt> {
+	return entries
+		.filter((entry) => is_dispatch(entry))
+		.map((entry) => ({ issue: entry.issue, at_ms: Date.parse(entry.at) }))
+}
+
+function ends_of(
+	entries: ReadonlyArray<LedgerEntry>,
+	parks: ReadonlyArray<IssueAt>,
+): Array<IssueAt> {
+	const resumes = entries
 		.filter((entry) => is_stage(entry))
-		.filter((stage) => stage.issue === stop.issue)
-		.map((stage) => lane_stage_stats.started_ms(stage))
-		.filter((start) => start >= from_ms && start < until_ms)
+		.map((stage) => ({ issue: stage.issue, at_ms: lane_stage_stats.started_ms(stage) }))
+
+	return [...resumes, ...dispatches_of(entries), ...parks]
+}
+
+// A stage's start counts from the stop's own instant, so a ship relaunched within the same
+// millisecond still ends the wait; the stage that stopped started before it. `josh lane:net` derives
+// a park's and an outage's wait the same way (`lane-net-time.ts`).
+function wait_ms(stop: IssueAt, ends: ReadonlyArray<IssueAt>): number | undefined {
+	const later = ends
+		.filter((end) => end.issue === stop.issue && end.at_ms >= stop.at_ms)
+		.map((end) => end.at_ms - stop.at_ms)
+
+	return later.length === 0 ? undefined : Math.min(...later)
+}
 
-	return starts.length === 0 ? undefined : Math.min(...starts) - from_ms
+function instant_of(stop: StopEntry): IssueAt {
+	return { issue: stop.issue, at_ms: Date.parse(stop.at) }
 }
 
-function waits_of(entries: ReadonlyArray<LedgerEntry>): Array<StopWait> {
+// The `josh check:related` notices of the ship's `unplanned` answer (joshuafolkken/kit#5203).
+function notices_of(entries: ReadonlyArray<LedgerEntry>): Array<IssueAt> {
 	return entries
-		.filter(is_stop)
-		.map((stop) => ({ reason: stop.reason, wait_ms: wait_ms(stop, entries) }))
+		.filter((entry) => entry.kind === lane_ledger.KIND.UNPLANNED_NOTICE)
+		.map((entry) => ({ issue: entry.issue, at_ms: Date.parse(entry.at) }))
+}
+
+// An `unplanned` stop the same issue's `check:related` already printed counts as `unplanned (noticed)`,
+// so the stops the earlier notice did not prevent are a number of their own.
+function noticed(cause: string, stop: IssueAt, notices: ReadonlyArray<IssueAt>): string {
+	if (cause !== run_ship_planned.PRECONDITION) return cause
+	const is_noticed = notices.some(
+		(notice) => notice.issue === stop.issue && notice.at_ms <= stop.at_ms,
+	)
+
+	return is_noticed ? `${cause}${NOTICED}` : cause
+}
+
+// A stop recorded before it named its preconditions (joshuafolkken/kit#4166) or its finding kinds
+// (joshuafolkken/kit#4426) counts under its cause.
+function causes_of(stop: StopEntry, notices: ReadonlyArray<IssueAt>): ReadonlyArray<string> {
+	const { preconditions = [], findings = [] } = stop
+	const kinds = [...preconditions, ...findings]
+
+	if (kinds.length === 0) return [stop.cause ?? UNRECORDED_CAUSE]
+
+	return kinds.map((kind) => noticed(kind, instant_of(stop), notices))
+}
+
+function waits_of(
+	entries: ReadonlyArray<LedgerEntry>,
+	ends: ReadonlyArray<IssueAt>,
+	notices: ReadonlyArray<IssueAt>,
+): Array<StopWait> {
+	return entries.filter(is_stop).map((stop) => ({
+		reason: stop.reason,
+		causes: causes_of(stop, notices),
+		wait_ms: wait_ms(instant_of(stop), ends),
+	}))
+}
+
+function total(values: ReadonlyArray<number>): number | undefined {
+	return values.length === 0 ? undefined : values.reduce((sum, value) => sum + value, 0)
+}
+
+// `infra 2, check 1` — how many of one reason's stops each cause took, the most frequent first. A stop
+// with two unmet preconditions counts once under each.
+function causes_cell(waits: ReadonlyArray<StopWait>): string {
+	const all = waits.flatMap((wait) => wait.causes)
+	const counted = [...new Set(all)].map((cause) => ({
+		cause,
+		count: all.filter((each) => each === cause).length,
+	}))
+	const ranked = counted.toSorted((left, right) => right.count - left.count)
+
+	return ranked.length === 0
+		? NO_CAUSES
+		: ranked.map(({ cause, count }) => `${cause} ${String(count)}`).join(', ')
 }
 
 function reason_row(reason: string, waits: ReadonlyArray<StopWait>): string {
 	const of_reason = waits.filter((wait) => wait.reason === reason)
-	const resumed = of_reason.map((wait) => wait.wait_ms).filter((value) => is_number(value))
+	const ended = of_reason.map((wait) => wait.wait_ms).filter((value) => is_number(value))
 
 	return lane_stats.to_row([
 		reason,
-		lane_stage_stats.cell(lane_stats.median(resumed)),
-		lane_stage_stats.cell(lane_stats.peak(resumed)),
-		String(resumed.length),
-		String(of_reason.length - resumed.length),
+		lane_stage_stats.cell(lane_stats.median(ended)),
+		lane_stage_stats.cell(lane_stats.peak(ended)),
+		lane_stage_stats.cell(total(ended)),
+		String(ended.length),
+		String(of_reason.length - ended.length),
+		causes_cell(of_reason),
 	])
 }
 
-// The period's table: `entries` is the whole ledger, filtered here to `window`.
-function table(entries: ReadonlyArray<LedgerEntry>, window: StatsWindow): string {
-	const waits = waits_of(lane_stats.in_window(entries, window))
+// The period's table: `entries` is the whole ledger, filtered here to `window` — only the stops are; a
+// wait may end after the period's last stop. `events` is the run's event stream, read for its parks.
+function table(
+	entries: ReadonlyArray<LedgerEntry>,
+	window: StatsWindow,
+	events: ReadonlyArray<RunEvent> = [],
+): string {
+	const ends = ends_of(entries, parks_of(events))
+	const waits = waits_of(lane_stats.in_window(entries, window), ends, notices_of(entries))
 
 	return [
 		lane_stats.to_row(COLUMNS),
@@ -91,6 +199,6 @@ function table(entries: ReadonlyArray<LedgerEntry>, window: StatsWindow): string
 	].join('\n')
 }
 
-const lane_stop_stats = { REASONS, table }
+const lane_stop_stats = { REASONS, dispatches_of, ends_of, events_of, issue_of, table, wait_ms }
 
 export { lane_stop_stats }

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

@@ -0,0 +1,32 @@
+// The tail of the period's lane times beside `lane:stats`'s median (joshuafolkken/kit#4910): a lane's
+// target is a ceiling, so the lanes over the overrun threshold and the 90th percentile say what a median
+// hides. The threshold is the one the overrun investigation launches past (`lane-overrun.ts`), which
+// judges a lane's net time; `lane:stats` counts on its dispatch-to-merge time.
+
+// The net minutes a lane may take before its causes are investigated.
+const OVERRUN_LANE_MINUTES = 40
+const TAIL_PERCENTILE = 90
+const WHOLE_PERCENT = 100
+
+function is_overrun(minutes: number): boolean {
+	return minutes > OVERRUN_LANE_MINUTES
+}
+
+// The lanes over the threshold; one exactly at it is not over.
+function overrun_count(minutes: ReadonlyArray<number>): number {
+	return minutes.filter((value) => is_overrun(value)).length
+}
+
+// The nearest-rank 90th percentile, else `undefined` with no lane.
+function tail_minutes(minutes: ReadonlyArray<number>): number | undefined {
+	if (minutes.length === 0) return undefined
+
+	const sorted = minutes.toSorted((left, right) => left - right)
+	const rank = Math.ceil((TAIL_PERCENTILE / WHOLE_PERCENT) * sorted.length)
+
+	return sorted[rank - 1]
+}
+
+const lane_tail_stats = { is_overrun, OVERRUN_LANE_MINUTES, overrun_count, tail_minutes }
+
+export { lane_tail_stats }

package/scripts/lane/lane-test-related-stats.ts

@@ -0,0 +1,127 @@
+import { MS_PER_SECOND } from '#scripts/lib/timeouts'
+import { lane_ledger, type LedgerEntry, type TestRelatedEntry } from './lane-ledger'
+import { lane_stage_stats } from './lane-stage-stats'
+import { lane_stats, type StatsWindow } from './lane-stats'
+
+// What widened a `josh test:related` run (joshuafolkken/kit#4465): one row per scope it settled on —
+// `related`, `none` or the full-suite fallback kind — with the medians of its input (the change
+// itself, what a main sync brought in, what the change since the test-read map's tree joined, the
+// readers the map added), of the test files vitest
+// ran and of its duration. A `related` row whose test files far outrun its input is vitest widening the
+// run on its own.
+
+const DECIMALS = 1
+const RUNS_COLUMN = 'runs'
+const SECONDS_COLUMN = 'median (s)'
+const COLUMNS = [
+	'test:related scope',
+	RUNS_COLUMN,
+	'changed',
+	'synced',
+	'since map',
+	'readers',
+	'test files',
+	SECONDS_COLUMN,
+] as const
+const TRIGGER_COLUMNS = ['test:related whole-suite trigger', RUNS_COLUMN, SECONDS_COLUMN] as const
+
+type CountField = 'changed' | 'synced' | 'since_map' | 'readers'
+
+function is_test_related(entry: LedgerEntry): entry is TestRelatedEntry {
+	return entry.kind === lane_ledger.KIND.TEST_RELATED
+}
+
+function count_cell(values: ReadonlyArray<number>): string {
+	const median = lane_stats.median(values)
+
+	return median === undefined ? lane_stage_stats.NOT_MEASURED : String(median)
+}
+
+function seconds_cell(values: ReadonlyArray<number>): string {
+	const median = lane_stats.median(values)
+
+	return median === undefined
+		? lane_stage_stats.NOT_MEASURED
+		: (median / MS_PER_SECOND).toFixed(DECIMALS)
+}
+
+function median_of(runs: ReadonlyArray<TestRelatedEntry>, field: CountField): string {
+	return count_cell(runs.map((run) => run[field]))
+}
+
+function scope_row(scope: string, entries: ReadonlyArray<TestRelatedEntry>): string {
+	const runs = entries.filter((entry) => entry.scope === scope)
+	const test_files = runs.map((run) => run.test_files).filter((files) => files !== undefined)
+
+	return lane_stats.to_row([
+		scope,
+		String(runs.length),
+		median_of(runs, 'changed'),
+		median_of(runs, 'synced'),
+		median_of(runs, 'since_map'),
+		median_of(runs, 'readers'),
+		count_cell(test_files),
+		seconds_cell(runs.map((run) => run.elapsed_ms)),
+	])
+}
+
+function rows_under(columns: ReadonlyArray<string>, rows: ReadonlyArray<string>): string {
+	return [lane_stats.to_row(columns), lane_stats.to_row(columns.map(() => '---')), ...rows].join(
+		'\n',
+	)
+}
+
+function runs_in(
+	entries: ReadonlyArray<LedgerEntry>,
+	window: StatsWindow,
+): Array<TestRelatedEntry> {
+	return lane_stats.in_window(entries, window).filter(is_test_related)
+}
+
+// The period's table: `entries` is the whole ledger, filtered here to `window`.
+function table(entries: ReadonlyArray<LedgerEntry>, window: StatsWindow): string {
+	const runs = runs_in(entries, window)
+	const scopes = [...new Set(runs.map((run) => run.scope))]
+
+	return rows_under(
+		COLUMNS,
+		scopes.map((scope) => scope_row(scope, runs)),
+	)
+}
+
+interface TriggerRuns {
+	file: string
+	runs: ReadonlyArray<TestRelatedEntry>
+}
+
+function runs_sent_by(file: string, runs: ReadonlyArray<TestRelatedEntry>): TriggerRuns {
+	return { file, runs: runs.filter((run) => run.trigger_files?.includes(file) === true) }
+}
+
+function trigger_row({ file, runs }: TriggerRuns): string {
+	return lane_stats.to_row([
+		file,
+		String(runs.length),
+		seconds_cell(runs.map((run) => run.elapsed_ms)),
+	])
+}
+
+// Which changed file sent a run to the whole suite, most runs first (joshuafolkken/kit#4510): the
+// table `WHOLE_SUITE_FILES` and the test-read map are trimmed from. A row written before the files
+// were recorded names none, and so counts under no file.
+function trigger_table(entries: ReadonlyArray<LedgerEntry>, window: StatsWindow): string {
+	const runs = runs_in(entries, window)
+	const files = [...new Set(runs.flatMap((run) => run.trigger_files ?? []))]
+	const triggers = files
+		.map((file) => runs_sent_by(file, runs))
+		.toSorted((left, right) => right.runs.length - left.runs.length)
+
+	return rows_under(
+		TRIGGER_COLUMNS,
+		triggers.map((trigger) => trigger_row(trigger)),
+	)
+}
+
+const lane_test_related_stats = { table, trigger_table }
+
+export { lane_test_related_stats }

package/scripts/lane/lane-transcript-calls.ts

@@ -0,0 +1,202 @@
+import { json_value } from '#scripts/lib/json-value'
+import { z } from 'zod'
+
+// One lane session's transcript reduced to its tool calls: each `tool_use` an `assistant` line carries,
+// joined by its id to the `tool_result` a later `user` line carries, so `josh lane:stats` can time a
+// call as the gap between the two lines (joshuafolkken/kit#4418).
+//
+// **A backgrounded call is kept but not timed.** Its result line is the immediate "running in the
+// background" notice, so the gap measures nothing the run waited on; `duration_ms` is `undefined` for
+// it, as for a call whose result never arrived (an interrupted turn).
+//
+// **The tool's name is kept** (`Bash`, `Edit`, …), so `josh lane:value edit` can time the edits apart
+// from the shell calls, **and so is its lane** — the transcript directory every session of one lane
+// (its child, its ship reviewer) writes under — so a per-lane value divides by lanes, not sessions
+// (joshuafolkken/kit#4630).
+//
+// **A subagent call keeps its agent type and model** — `subagent_type`, the harness's
+// `general-purpose` when absent, and `model` when named — so the implement's subagent time splits by
+// the agent dispatched (joshuafolkken/kit#5297).
+
+interface Subagent {
+	type: string
+	model: string | undefined
+}
+
+interface ToolCall {
+	session_id: string
+	lane: string
+	started_ms: number
+	duration_ms: number | undefined
+	tool: string | undefined
+	background: boolean
+	command: string | undefined
+	subagent: Subagent | undefined
+	output: string
+}
+
+interface ToolUse {
+	started_ms: number
+	tool: string | undefined
+	background: boolean
+	command: string | undefined
+	subagent: Subagent | undefined
+}
+
+interface ToolResult {
+	ended_ms: number
+	output: string
+}
+
+interface TextPart {
+	text?: string | null | undefined
+}
+
+function join_parts(parts: ReadonlyArray<TextPart>): string {
+	return parts.map((part) => part.text ?? '').join('\n')
+}
+
+interface RawInput {
+	command?: unknown
+	run_in_background?: unknown
+	subagent_type?: unknown
+	model?: unknown
+}
+
+interface CallInput {
+	background: boolean
+	command: string | undefined
+	subagent: Subagent
+}
+
+const SUBAGENT_TOOLS: ReadonlySet<string> = new Set(['Agent', 'Task'])
+const GENERAL_PURPOSE = 'general-purpose'
+
+function string_or_undefined(value: unknown): string | undefined {
+	return typeof value === 'string' ? value : undefined
+}
+
+// A named string, `undefined` for an empty or non-string one.
+function named(value: unknown): string | undefined {
+	return value === '' ? undefined : string_or_undefined(value)
+}
+
+function subagent_of(input: RawInput | null | undefined): Subagent {
+	return { type: named(input?.subagent_type) ?? GENERAL_PURPOSE, model: named(input?.model) }
+}
+
+function to_input(input: RawInput | null | undefined): CallInput {
+	return {
+		background: input?.run_in_background === true,
+		command: string_or_undefined(input?.command),
+		subagent: subagent_of(input),
+	}
+}
+
+const TEXT_PARTS_SCHEMA = z.array(z.object({ text: z.string().nullish() }))
+// A result's text: a string, or the text parts of a block list; anything else reads as no output.
+const RESULT_CONTENT_SCHEMA = z
+	.union([z.string(), TEXT_PARTS_SCHEMA.transform(join_parts)])
+	.catch('')
+const INPUT_SCHEMA = z
+	.object({
+		command: z.unknown(),
+		run_in_background: z.unknown(),
+		subagent_type: z.unknown(),
+		model: z.unknown(),
+	})
+	.partial()
+
+const BLOCK_SCHEMA = z.object({
+	type: z.string(),
+	id: z.string().nullish(),
+	name: z.string().nullish(),
+	input: INPUT_SCHEMA.nullish().transform(to_input),
+	tool_use_id: z.string().nullish(),
+	content: RESULT_CONTENT_SCHEMA.optional(),
+})
+
+type Block = z.infer<typeof BLOCK_SCHEMA>
+
+function blocks_of(message: { content: Array<Block> } | null | undefined): Array<Block> {
+	return message?.content ?? []
+}
+
+// A line that is not JSON, not a message, or carries no readable timestamp fails the parse.
+const LINE_SCHEMA = z.object({
+	timestamp: z.string().transform(Date.parse).pipe(z.number()),
+	message: z
+		.object({ content: z.array(BLOCK_SCHEMA).catch([]) })
+		.nullish()
+		.transform(blocks_of),
+})
+
+interface Pairs {
+	uses: Map<string, ToolUse>
+	results: Map<string, ToolResult>
+}
+
+// The agent a subagent call dispatched; any other tool's input names none.
+function subagent_in(tool: string | undefined, block: Block): Subagent | undefined {
+	return SUBAGENT_TOOLS.has(tool ?? '') ? block.input.subagent : undefined
+}
+
+function record_use(pairs: Pairs, block: Block, started_ms: number): void {
+	if (block.type !== 'tool_use' || !block.id) return
+
+	const tool = block.name ?? undefined
+
+	pairs.uses.set(block.id, { started_ms, tool, ...block.input, subagent: subagent_in(tool, block) })
+}
+
+function record_result(pairs: Pairs, block: Block, ended_ms: number): void {
+	if (block.type !== 'tool_result' || !block.tool_use_id) return
+
+	pairs.results.set(block.tool_use_id, { ended_ms, output: block.content ?? '' })
+}
+
+function record_line(pairs: Pairs, line: string): void {
+	const parsed = LINE_SCHEMA.safeParse(json_value.parse_or_undefined(line))
+
+	if (!parsed.success) return
+
+	const { timestamp, message } = parsed.data
+
+	for (const block of message) {
+		record_use(pairs, block, timestamp)
+		record_result(pairs, block, timestamp)
+	}
+}
+
+// The transcript a call was read from: its session, and the lane that session belongs to.
+type CallSource = Pick<ToolCall, 'session_id' | 'lane'>
+
+function to_call(source: CallSource, use: ToolUse, result: ToolResult | undefined): ToolCall {
+	const is_timed = result !== undefined && !use.background
+
+	return {
+		...source,
+		started_ms: use.started_ms,
+		duration_ms: is_timed ? result.ended_ms - use.started_ms : undefined,
+		tool: use.tool,
+		background: use.background,
+		command: use.command,
+		subagent: use.subagent,
+		output: result?.output ?? '',
+	}
+}
+
+// Every tool call `raw` — one transcript's text — records, in the order the calls were made.
+function parse(source: CallSource, raw: string): Array<ToolCall> {
+	const pairs: Pairs = { uses: new Map(), results: new Map() }
+	const lines = raw.split('\n')
+
+	for (const line of lines) record_line(pairs, line)
+
+	return [...pairs.uses].map(([id, use]) => to_call(source, use, pairs.results.get(id)))
+}
+
+const lane_transcript_calls = { parse }
+
+export type { Subagent, ToolCall }
+export { lane_transcript_calls }