@joshuafolkken/kit 1.3041.0 → 1.3092.0

package/scripts/run/run-repair-attempt.ts

@@ -0,0 +1,219 @@
+import { statSync } from 'node:fs'
+import { git_gh_command } from '#scripts/gh/git-gh-command'
+import { git_command } from '#scripts/git/git-command'
+import { git_common_directory } from '#scripts/git/git-common-directory'
+import { pr_info_schema } from '#scripts/git/git-schemas'
+import { repository_lock } from '#scripts/git/repository-lock'
+import { issue_state_cli } from '#scripts/issue/issue-state-cli'
+import { lane_await } from '#scripts/lane/lane-await'
+import { lane_registry, type LaneInfo } from '#scripts/lane/lane-registry'
+import { json_value } from '#scripts/lib/json-value'
+import { run_add } from './add/run-add'
+import { run_carry } from './carry/run-carry'
+import { run_cut } from './cut/run-cut'
+import { run_event_retry } from './event/run-event-retry'
+import { run_event_scope } from './event/run-event-scope'
+import { run_event_stream, type RunEvent } from './event/run-event-stream'
+import { run_event_stream_emit } from './event/run-event-stream-emit'
+import { run_pr_return } from './run-pr-return'
+import { run_ship_detach } from './ship/run-ship-detach'
+
+// A reviewed PR starts a repair only after the previous worker ended. The existing retry event is
+// the attempt boundary; its repair suffix makes a repeated queue request idempotent.
+const REPAIR_SUFFIX = ' repair'
+const LOCK_WAIT_MS = 5000
+const PERMANENT_KINDS: ReadonlySet<string> = new Set(['merge', 'withdraw', 'split'])
+const QUEUED_END_KINDS: ReadonlySet<string> = new Set([
+	...PERMANENT_KINDS,
+	run_event_stream.EVENT_KIND.HUMAN_REVIEW,
+	run_event_stream.EVENT_KIND.CHILD_LAUNCH,
+	run_event_stream.EVENT_KIND.PARK,
+])
+const WRITE_FAILED = 'Could not record the repair attempt boundary.'
+
+function repair_text(issue: string): string {
+	return `${run_event_retry.text_of(Number(issue))}${REPAIR_SUFFIX}`
+}
+
+function issue_attempt(events: ReadonlyArray<RunEvent>, issue: string): ReadonlyArray<RunEvent> {
+	return run_event_retry
+		.current_attempts(events)
+		.filter((event) => run_event_scope.issue_named(event) === issue)
+}
+
+function is_queued(events: ReadonlyArray<RunEvent>, issue: string): boolean {
+	return (
+		events[0]?.text === repair_text(issue) &&
+		events.every((event) => !QUEUED_END_KINDS.has(event.kind))
+	)
+}
+
+function reviewed_at(events: ReadonlyArray<RunEvent>): string | undefined {
+	if (events.some((event) => PERMANENT_KINDS.has(event.kind))) return undefined
+
+	return events.findLast((event) => event.kind === run_event_stream.EVENT_KIND.HUMAN_REVIEW)?.at
+}
+
+async function is_unprotected(issue: string): Promise<boolean> {
+	const read = await issue_state_cli.read_issue(issue)
+
+	return (
+		read.kind === 'state' &&
+		read.state.state === 'OPEN' &&
+		run_add.protected_label(read.state.labels) === undefined
+	)
+}
+
+async function is_returned(lane: LaneInfo, since: string | undefined): Promise<boolean> {
+	const raw = await git_gh_command.pr_view(lane.branch)
+
+	if (json_value.parse_with(raw, pr_info_schema)?.state !== 'OPEN') return false
+	if (since === undefined) return true
+	const returned = await run_pr_return.read(lane.issue, lane.directory)
+
+	return run_pr_return
+		.comments_since(returned.comments, Date.parse(since))
+		.some((comment) => comment.is_trusted === true)
+}
+
+function cut_target(lane: LaneInfo): string | undefined {
+	const directory = git_common_directory.own(lane.directory)
+
+	return directory === undefined ? undefined : run_cut.cut_path(directory)
+}
+
+function can_end_cut(target: string, lane: LaneInfo): boolean {
+	const read = run_cut.read_cut(target)
+
+	if (read.kind === 'none') return true
+	if (read.kind === 'unreadable') return false
+
+	return (
+		read.cut.issue === lane.issue &&
+		read.cut.branch === lane.branch &&
+		read.cut.invocation === run_cut.invocation_for(lane.issue)
+	)
+}
+
+async function append_boundary(issue: string): Promise<void> {
+	const target = await run_event_stream_emit.stream_target()
+
+	if (target === undefined) throw new Error(WRITE_FAILED)
+	const result = await run_event_stream_emit.append_at(
+		target,
+		run_event_stream.EVENT_KIND.ADD,
+		repair_text(issue),
+		new Date(),
+	)
+
+	if (!result.appended) throw new Error(WRITE_FAILED)
+}
+
+async function has_ended_ship(issue: string): Promise<boolean> {
+	const repository = await run_carry.repository_directory()
+
+	if (repository === undefined) return false
+	const info = statSync(run_ship_detach.result_path(repository, issue), { throwIfNoEntry: false })
+
+	if (info === undefined) return true
+	const result = run_ship_detach.read_result(repository, issue)
+
+	return result !== undefined && result.result !== 'running'
+}
+
+// Uncommitted work in the lane means its `in-progress` still marks a live hand-off; a tree git
+// cannot read counts as uncommitted (joshuafolkken/kit#7493).
+async function is_clean(lane: LaneInfo): Promise<boolean> {
+	try {
+		return (await git_command.status(lane.directory)) === ''
+	} catch {
+		return false
+	}
+}
+
+async function is_repairable(issue: string, lane: LaneInfo): Promise<boolean> {
+	return (await is_unprotected(issue)) && (await is_clean(lane))
+}
+
+async function ready_lane(issue: string): Promise<LaneInfo | undefined> {
+	if ((await lane_await.other_process_trace(issue)) !== 'none' || !(await has_ended_ship(issue))) {
+		return undefined
+	}
+
+	const lane = await lane_registry.find_open_lane(issue)
+
+	if (lane === undefined || !(await is_repairable(issue, lane))) return undefined
+
+	return lane
+}
+
+function eligible_cut_target(
+	lane: LaneInfo,
+	expected_target: string | undefined,
+): string | undefined {
+	const target = cut_target(lane)
+
+	if (expected_target !== undefined && expected_target !== target) return undefined
+
+	return target !== undefined && can_end_cut(target, lane) ? target : undefined
+}
+
+async function finish(
+	lane: LaneInfo,
+	events: ReadonlyArray<RunEvent>,
+	since: string | undefined,
+	expected_target: string | undefined,
+): Promise<boolean> {
+	const target = eligible_cut_target(lane, expected_target)
+
+	if (target === undefined || !(await is_returned(lane, since))) return false
+	if (!is_queued(events, lane.issue)) await append_boundary(lane.issue)
+	run_cut.end_cut(target)
+
+	return true
+}
+
+function is_candidate(events: ReadonlyArray<RunEvent>, issue: string): boolean {
+	return reviewed_at(events) !== undefined || is_queued(events, issue)
+}
+
+function checked_preparation(
+	is_prepared: boolean,
+	events: ReadonlyArray<RunEvent>,
+	issue: string,
+): boolean {
+	if (!is_prepared && is_queued(events, issue)) {
+		throw new Error('Could not safely resume the queued repair.')
+	}
+
+	return is_prepared
+}
+
+async function prepare_held(issue: string, expected_target: string | undefined): Promise<boolean> {
+	const events = issue_attempt(await run_event_stream_emit.all_events(true), issue)
+
+	if (!is_candidate(events, issue)) return false
+	const lane = await ready_lane(issue)
+
+	const is_prepared =
+		lane === undefined ? false : await finish(lane, events, reviewed_at(events), expected_target)
+
+	return checked_preparation(is_prepared, events, issue)
+}
+
+async function prepare(issue: string, expected_target?: string): Promise<boolean> {
+	const lock = repository_lock.lock_path(`josh-repair-${issue}-`)
+	const is_prepared = await repository_lock.with_lock(
+		async () => await prepare_held(issue, expected_target),
+		lock,
+		LOCK_WAIT_MS,
+	)
+
+	if (is_prepared === undefined) throw new Error('Could not lock the repair attempt.')
+
+	return is_prepared
+}
+
+const run_repair_attempt = { issue_attempt, prepare, reviewed_at }
+
+export { run_repair_attempt }

package/scripts/run/ship/run-ship-lap.ts

@@ -1,6 +1,6 @@
-import { AsyncLocalStorage } from 'node:async_hooks'
 import type { ShipLapRecord } from '#scripts/lane/lane-ledger-schema'
 import { lane_ledger_write } from '#scripts/lane/lane-ledger-write'
+import { inherited_scope } from '#scripts/lib/inherited-scope'
 import { z } from 'zod'
 
 // The inner steps of a `josh ship` stage, each timed into the lane ledger as a lap, so `lane:breakdown`
@@ -39,7 +39,7 @@ const STEP = {
 	COMMIT: 'josh git',
 } as const
 
-const scope = new AsyncLocalStorage<LapScope>()
+const scope = inherited_scope.create(ENVIRONMENT_KEY, lap_scope_schema)
 
 async function to_ledger(lap: ShipLapRecord): Promise<void> {
 	await lane_ledger_write.record_ship_lap(lap)
@@ -51,23 +51,11 @@ async function within<T>(
 	run: () => Promise<T>,
 	parent?: string,
 ): Promise<T> {
-	return await scope.run({ issue: Number(issue), stage, parent }, run)
-}
-
-// The scope a parent process handed down, `undefined` when none or unreadable.
-function inherited(): LapScope | undefined {
-	const text = process.env[ENVIRONMENT_KEY]
-	if (text === undefined || text === '') return undefined
-
-	try {
-		return lap_scope_schema.safeParse(JSON.parse(text)).data
-	} catch {
-		return undefined
-	}
+	return await scope.within({ issue: Number(issue), stage, parent }, run)
 }
 
 function current_scope(): LapScope | undefined {
-	return scope.getStore() ?? inherited()
+	return scope.current()
 }
 
 // The environment that times a child process's steps under `parent`, `{}` outside any scope.
@@ -113,7 +101,7 @@ const startup = { recorded: false }
 // `timeOrigin` until that lap, the tsx load among it — so the parent's lap is explained by its
 // children (joshuafolkken/kit#5896). A scope this process opened with `within` started no process.
 async function record_startup(current: LapScope, sink: LapSink, is_wanted: boolean): Promise<void> {
-	if (!is_wanted || startup.recorded || scope.getStore() !== undefined) return
+	if (!is_wanted || startup.recorded || scope.local() !== undefined) return
 	startup.recorded = true
 
 	await sink(lap_of(current, STARTUP_STEP, 0, {}))

package/scripts/run/ship/run-ship-pre-detach-pinned.ts

@@ -1,6 +1,5 @@
 import { randomUUID } from 'node:crypto'
 import { check_reuse } from '#scripts/gate/check-reuse'
-import { PROJECT_ROOT } from '#scripts/init/init-paths'
 import type { JoshResult } from '#scripts/josh/josh-run'
 import { buffered_process } from '#scripts/lib/buffered-process'
 import { error_text } from '#scripts/lib/error-message'
@@ -8,8 +7,8 @@ import { review_round_reuse } from '#scripts/review/review-round-reuse'
 import { run_review_pinned } from '#scripts/run/review/run-review-pinned'
 import { run_review_pinned_accepted } from '#scripts/run/review/run-review-pinned-accepted'
 import { run_review_pinned_join } from '#scripts/run/review/run-review-pinned-join'
+import { run_review_pinned_remaining } from '#scripts/run/review/run-review-pinned-remaining'
 import { run_review_pinned_steps } from '#scripts/run/review/run-review-pinned-steps'
-import { run_review_pinned_tree } from '#scripts/run/review/run-review-pinned-tree'
 import { test_pinned } from '#scripts/test/test-pinned'
 import { test_pinned_logic } from '#scripts/test/test-pinned-logic'
 import { test_pinned_record, type PinnedSummary } from '#scripts/test/test-pinned-record'
@@ -60,7 +59,7 @@ function remaining_note(remaining: number | undefined): string {
 	const hunks =
 		remaining === undefined ? 'the remaining hunks' : `${String(remaining)} remaining hunks`
 
-	return `test:pinned: probing ${hunks} in the background — the next ship's pre-detach reads their verdicts\n`
+	return `test:pinned: probing ${hunks} in the background — before editing or retrying ship, collect every verdict with \`pnpm josh run:review --pinned\`\n`
 }
 
 // **A stop at the first unpinned hunk leaves the rest probing in the background**
@@ -68,17 +67,9 @@ function remaining_note(remaining: number | undefined): string {
 // this tree, or waits it out on a fixed one so its verdicts reach the cache and only the hunks the fix
 // moved are probed again. A launch that failed or threw adds no note, and never fails the check.
 async function is_rest_launched(): Promise<boolean> {
-	try {
-		const tree = await run_review_pinned_tree.key()
-
-		run_review_pinned_steps.clear()
+	const launched = await run_review_pinned_remaining.start()
 
-		return run_review_pinned_steps.launch_remaining(PROJECT_ROOT, tree).kind === 'launched'
-	} catch (error) {
-		error_text.trace_swallowed('run_ship_pre_detach_pinned.is_rest_launched', error)
-
-		return false
-	}
+	return launched.kind === 'launched'
 }
 
 async function continued(answer: PinnedSummary): Promise<PinnedSummary> {

package/scripts/run/ship/run-ship-scoped.ts

@@ -27,28 +27,51 @@ const REUSED_PAIR = 'scoped pair: reused — both checks are green on this tree'
 const RED_PAIR = 'scoped pair: red on this tree in this ship — not run again'
 
 type Phase = () => Promise<JoshResult>
+
+interface ScopedPhase {
+	script: string
+	run: () => Promise<JoshResult>
+}
+
 // A pair's result with the files it was named over, or why a merge could not split, for its lap.
-type PairResult = JoshResult & { note?: Pick<LapNote, 'named' | 'unsplit'> }
+type PairResult = JoshResult & { note?: Pick<LapNote, 'named' | 'unsplit'>; verified?: GateTree }
 
-async function run_phases(phases: ReadonlyArray<Phase>): Promise<JoshResult> {
+async function run_phases(
+	phases: ReadonlyArray<Phase>,
+	after_phase?: (index: number) => Promise<void>,
+): Promise<JoshResult> {
 	let last: JoshResult = { code: SUCCESS_EXIT_CODE, out: '' }
 
-	for (const phase of phases) {
-		// eslint-disable-next-line no-await-in-loop -- phases run in order and the first failure stops the rest
+	for (const [index, phase] of phases.entries()) {
+		// eslint-disable-next-line no-await-in-loop -- stop at the first failed phase
 		last = await phase()
+		// eslint-disable-next-line no-await-in-loop -- snapshot a completed writer before starting readers
+		await after_phase?.(index)
 		if (last.code !== SUCCESS_EXIT_CODE) return last
 	}
 
 	return last
 }
 
-// The tree after the branch's metrics approval is re-recorded (`metrics-totals.ts`): every review fix
-// and the gate stage meet the pair here, so a rewrite lands before any record is written for the tree.
-async function rerecorded_tree(): Promise<GateTree> {
-	const tree = await gate_tree.read_gate_tree()
-	const is_rerecorded = await metrics_totals.rerecord(process.cwd(), tree.files)
+async function take_snapshot(
+	phase: ScopedPhase | undefined,
+	snapshot: { tree: GateTree },
+): Promise<void> {
+	if (phase?.script !== scoped_green.LINT_SCRIPT) return
+
+	snapshot.tree = await gate_tree.read_gate_tree()
+}
 
-	return is_rerecorded ? await gate_tree.read_gate_tree() : tree
+async function run_pair_phases(phases: ReadonlyArray<ScopedPhase>): Promise<PairResult> {
+	const snapshot = { tree: await gate_tree.read_gate_tree() }
+	const result = await run_phases(
+		phases.map((phase) => phase.run),
+		async (index) => {
+			await take_snapshot(phases[index], snapshot)
+		},
+	)
+
+	return { ...result, verified: snapshot.tree }
 }
 
 function printed(line: string): JoshResult {
@@ -58,16 +81,19 @@ function printed(line: string): JoshResult {
 }
 
 // Each check bare; every output is kept, so the lap reads each one's fallback reason.
-async function bare_pair(scripts: ReadonlyArray<string>): Promise<JoshResult> {
+async function bare_pair(scripts: ReadonlyArray<string>): Promise<PairResult> {
 	const outs: Array<string> = []
-	const result = await run_phases(
-		scripts.map((script) => async () => {
-			const ran = await josh_command.josh_run([script], should_forward_stderr)
+	const result = await run_pair_phases(
+		scripts.map((script) => ({
+			script,
+			run: async () => {
+				const ran = await josh_command.josh_run([script], should_forward_stderr)
 
-			outs.push(ran.out)
+				outs.push(ran.out)
 
-			return ran
-		}),
+				return ran
+			},
+		})),
 	)
 
 	return { ...result, out: outs.filter((out) => out !== '').join('\n') }
@@ -93,12 +119,11 @@ function check_phases(
 	checks: ReadonlyArray<SyncedCheck>,
 	files: ReadonlyArray<string>,
 	sync: SyncReading | undefined,
-): ReadonlyArray<Phase> {
+): ReadonlyArray<ScopedPhase> {
 	return checks.flatMap((check) =>
-		run_ship_narrowed.named_phases(
-			[check],
-			run_ship_synced_scope.files_for(sync, check.script, files),
-		),
+		run_ship_narrowed
+			.named_phases([check], run_ship_synced_scope.files_for(sync, check.script, files))
+			.map((run) => ({ script: check.script, run })),
 	)
 }
 
@@ -146,10 +171,12 @@ async function narrowed_or_bare(
 	printed(run_ship_narrowed.describe(named.files, named.why))
 
 	const checks = run_ship_synced_scope.checks_of(scripts)
-	const result = await run_phases(check_phases(checks, named.files, sync))
+	const result = await run_pair_phases(check_phases(checks, named.files, sync))
 
-	if (result.code === SUCCESS_EXIT_CODE && (await is_still(tree))) {
-		run_ship_narrowed.record(checks, tree)
+	const verified = result.verified ?? tree
+
+	if (result.code === SUCCESS_EXIT_CODE && (await is_still(verified))) {
+		run_ship_narrowed.record(checks, verified)
 	}
 
 	return { ...result, note: { named: named.files.length } }
@@ -187,8 +214,20 @@ async function stale_pair(tree: GateTree, scripts: ReadonlyArray<string>): Promi
 // base runs nothing when the merge shares nothing with the branch (`run-ship-synced-scope.ts`), and
 // only where the two meet when they do; a pair stale since this ship last met it green on this base
 // runs over what moved since (`run-ship-narrowed.ts`).
+async function remember_result(tree: GateTree, result: PairResult): Promise<PairResult> {
+	const { verified = tree, ...answer } = result
+
+	run_ship_pair_runs.met(verified, result.code, result.out)
+
+	if (result.code === SUCCESS_EXIT_CODE && (await is_still(verified))) {
+		run_ship_narrowed.remember(verified)
+	}
+
+	return answer
+}
+
 async function settled_pair(): Promise<PairResult> {
-	const tree = await rerecorded_tree()
+	const tree = await metrics_totals.rerecorded_tree()
 	const scripts = scoped_green.missing_scripts(tree.files, tree.base)
 
 	// Nothing stale ran nothing, so the records already vouch for the tree read — a ship retried over
@@ -202,10 +241,7 @@ async function settled_pair(): Promise<PairResult> {
 
 	const result = await stale_pair(tree, scripts)
 
-	run_ship_pair_runs.met(tree, result.code, result.out)
-	if (result.code === SUCCESS_EXIT_CODE && (await is_still(tree))) run_ship_narrowed.remember(tree)
-
-	return result
+	return await remember_result(tree, result)
 }
 
 function pair_note({ out, note }: PairResult): LapNote {

package/scripts/run/startup/run-startup-schema.ts

@@ -0,0 +1,31 @@
+import { lane_ledger_kind } from '#scripts/lane/lane-ledger-kind'
+import { z } from 'zod'
+
+const scope_schema = z.object({
+	run: z.string(),
+	attempt: z.string(),
+	issue: z.string().optional(),
+	span: z.string().optional(),
+	parent: z.string().optional(),
+	destination: z.string().optional(),
+})
+
+const entry_schema = scope_schema.omit({ destination: true }).extend({
+	kind: z.literal(lane_ledger_kind.KIND.STARTUP),
+	at: z.string(),
+	at_ms: z.number().nonnegative().optional(),
+	id: z.string(),
+	parent: z.string().optional(),
+	phase: z.string(),
+	edge: z.enum(['start', 'done', 'failed', 'waiting', 'api', 'cache']),
+	elapsed_ms: z.number().nonnegative().optional(),
+	metric: z.string().optional(),
+	key: z.string().optional(),
+})
+
+type StartupScope = z.infer<typeof scope_schema>
+type StartupEntry = z.infer<typeof entry_schema>
+
+const run_startup_schema = { scope_schema, entry_schema }
+export type { StartupScope, StartupEntry }
+export { run_startup_schema }

package/scripts/run/startup/run-startup-store.ts

@@ -0,0 +1,130 @@
+import { randomUUID } from 'node:crypto'
+import { lane_ledger_write } from '#scripts/lane/lane-ledger-write'
+import { run_carry } from '#scripts/run/carry/run-carry'
+import type { StartupEntry, StartupScope } from './run-startup-schema'
+
+async function carried_identity(issue?: string): Promise<StartupScope | undefined> {
+	const repository = await run_carry.repository_directory()
+	if (repository === undefined) return undefined
+	const read = run_carry.read_carry(run_carry.carry_path(repository))
+	if (read.kind !== 'carried') return undefined
+
+	return {
+		run: `${repository}:${read.carry.started_at}`,
+		attempt: randomUUID(),
+		destination: lane_ledger_write.target_of(repository),
+		...(issue !== undefined && { issue }),
+	}
+}
+
+async function identity(issue?: string): Promise<StartupScope | undefined> {
+	try {
+		if (process.env['VITEST'] !== undefined) return undefined
+
+		return await carried_identity(issue)
+	} catch {
+		return undefined
+	}
+}
+
+async function record(entry: StartupEntry, destination?: string): Promise<void> {
+	await lane_ledger_write.record(entry, destination)
+}
+
+interface StartupSummary {
+	start: StartupEntry
+	status: 'done' | 'failed' | 'waiting' | 'incomplete'
+	elapsed_ms: number | undefined
+	api: Record<string, number>
+	cache: Record<string, number>
+}
+
+function counts(rows: ReadonlyArray<StartupEntry>, edge: 'api' | 'cache'): Record<string, number> {
+	const result: Record<string, number> = {}
+
+	for (const row of rows) {
+		if (row.edge !== edge) continue
+		const key = row.metric ?? 'unknown'
+
+		result[key] = (result[key] ?? 0) + 1
+	}
+
+	return result
+}
+
+function is_terminal(
+	row: StartupEntry,
+): row is StartupEntry & { edge: 'done' | 'failed' | 'waiting' } {
+	return row.edge === 'done' || row.edge === 'failed' || row.edge === 'waiting'
+}
+
+function summary(start: StartupEntry, rows: ReadonlyArray<StartupEntry>): StartupSummary {
+	const ending = rows.find(is_terminal)
+
+	return {
+		start,
+		status: ending?.edge ?? 'incomplete',
+		elapsed_ms: ending?.elapsed_ms,
+		api: counts(rows, 'api'),
+		cache: counts(rows, 'cache'),
+	}
+}
+
+// Direct counts only; parent durations include children and must not be added to them.
+function by_span(entries: ReadonlyArray<StartupEntry>): Map<string, Array<StartupEntry>> {
+	const groups = new Map<string, Array<StartupEntry>>()
+
+	for (const row of entries) {
+		const group = groups.get(row.id) ?? []
+
+		group.push(row)
+		groups.set(row.id, group)
+	}
+
+	return groups
+}
+
+function summarize(entries: ReadonlyArray<StartupEntry>): Array<StartupSummary> {
+	const groups = by_span(entries)
+
+	return entries
+		.filter((row) => row.edge === 'start')
+		.map((start) => summary(start, groups.get(start.id) ?? []))
+}
+
+function timestamp(row: StartupEntry): number {
+	return row.at_ms ?? Date.parse(row.at)
+}
+
+function before_end(
+	row: StartupEntry,
+	other: StartupEntry,
+	endings: ReadonlyMap<string, number>,
+): boolean {
+	const end = endings.get(other.id)
+
+	return end !== undefined && timestamp(row) < end
+}
+
+function overlaps(
+	left: StartupEntry,
+	right: StartupEntry,
+	endings: ReadonlyMap<string, number>,
+): boolean {
+	if (left.id === right.id || left.key !== right.key) return false
+
+	return before_end(left, right, endings) && before_end(right, left, endings)
+}
+
+// A fill is a miss being computed, not a second cache lookup. Overlapping fills on the same hashed
+// key are concurrent misses, including separate processes; no deduplication or lock is introduced.
+function concurrent_misses(entries: ReadonlyArray<StartupEntry>): Array<StartupEntry> {
+	const fills = entries.filter((row) => row.edge === 'cache' && row.metric === 'fill')
+	const endings = new Map(entries.filter(is_terminal).map((row) => [row.id, timestamp(row)]))
+
+	return fills.filter((row) => fills.some((other) => overlaps(row, other, endings)))
+}
+
+const run_startup_store = { identity, record, summarize, concurrent_misses }
+export type { StartupSummary }
+export { run_startup_store }