@joshuafolkken/kit 1.2116.0 → 1.3041.0

package/scripts/review/review-brief-cli.ts

@@ -15,6 +15,7 @@ import { path_decision } from '#scripts/josh/path-decision'
 import { stamp_file } from '#scripts/josh/stamp-file'
 import { lane_session_broker } from '#scripts/lane/lane-session-broker'
 import { run_ship_review } from '#scripts/run/ship/run-ship-review'
+import { test_related_verdict } from '#scripts/test/test-related-verdict'
 import { removed_tests_check } from './removed-tests-check'
 import { review_attest, type ReviewSlot } from './review-attest'
 import { review_brief } from './review-brief'
@@ -22,10 +23,14 @@ import { review_checkout, type ReviewCheckout } from './review-checkout'
 import { review_code_tree } from './review-code-tree'
 import type { DiffParts } from './review-diff-parts'
 import { review_diff_write } from './review-diff-write'
+import { review_fix_round, type RecordedRound } from './review-fix-round'
 import { review_interaction } from './review-interaction'
 import { review_level, type ReviewLevel } from './review-level'
 import { review_reviewed_tree } from './review-reviewed-tree'
+import { review_round } from './review-round'
 import { review_round_one_blobs } from './review-round-one-blobs'
+import { review_round_one_skip } from './review-round-one-skip'
+import { review_size } from './review-size'
 import { review_stamps } from './review-stamps'
 import { review_tree } from './review-tree'
 import { review_untouched_readers, type ReadersRead } from './review-untouched-readers'
@@ -40,7 +45,7 @@ import { review_untouched_readers, type ReadersRead } from './review-untouched-r
 // on round 2 — which files the first round's fixes touched.
 
 const USAGE =
-	'Usage: josh review:brief [--round <1|2>] | --interaction | --level-only [--staged] [--json]'
+	'Usage: josh review:brief [--round <1|2> | --full-change] | --interaction | --level-only [--staged] [--json]'
 
 // The rubric's absolute path, resolved against the kit package rather than the review checkout root.
 // The rubric ships inside the package, so a consumer that keeps no
@@ -52,7 +57,6 @@ const RUBRIC_PATH = path.join(
 	find_package_directory(MODULE_DIRECTORY),
 	review_brief.RUBRIC_RELATIVE_PATH,
 )
-const ROUND_FLAG = '--round'
 // `review:level` folded in here: it was a second command deciding the same
 // thing `review:brief` already prints on its first line, so it is now a mode of this one. `--level-only`
 // answers the level alone — for a pre-commit review run outside any workflow — and, unlike the full
@@ -64,26 +68,6 @@ const INTERACTION_FLAG = '--interaction'
 const LEVEL_KEY = 'level'
 const FIRST_ROUND = 1
 const FAILURE_EXIT_CODE = 1
-// The flag and its value; anything else is a usage error rather than a round.
-const ROUND_ARGUMENT_COUNT = 2
-const VALID_ROUNDS: ReadonlySet<number> = new Set([FIRST_ROUND, review_brief.SECOND_ROUND])
-
-// `Number` rather than a parse: `--round 2x` must be a usage error, and a parse would read it as 2.
-// A missing value gives `NaN`, which no valid round equals.
-function parse_round_value(raw: string | undefined): number | undefined {
-	const round = Number(raw)
-
-	return VALID_ROUNDS.has(round) ? round : undefined
-}
-
-// `undefined` on anything unrecognized rather than a default: a misspelled flag that silently
-// reviewed the whole diff would hand round 2 the scope the command exists to narrow.
-function parse_round(argv: ReadonlyArray<string>): number | undefined {
-	if (argv.length === 0) return FIRST_ROUND
-	if (argv.length !== ROUND_ARGUMENT_COUNT || argv[0] !== ROUND_FLAG) return undefined
-
-	return parse_round_value(argv[1])
-}
 
 // **Printed on stderr, because stdout is the `/code-review` invocation and nothing else.** A kept
 // record is not an error, but it is the one thing a second round-1 invocation has to be told: the
@@ -139,12 +123,9 @@ function record_round_one(
 			return false
 		}
 
-		review_stamps.round_one_stamp.write(
-			tree,
-			target,
-			base,
-			review_round_one_blobs.capture(Object.keys(tree)),
-		)
+		const blobs = review_round_one_blobs.capture(Object.keys(tree))
+
+		review_stamps.round_one_stamp.write(tree, target, base, blobs)
 
 		return true
 	} catch {
@@ -161,8 +142,8 @@ function record_round_one(
 //
 // **Whether this is a resume is read first**: `record_target` drops the
 // previous nonce's records, so asked afterwards the finished review would always read as absent. The
-// findings file is the ship's, keyed on `PROJECT_ROOT` as the ship keys it; a review run outside the
-// ship writes none, so it never reads as a resume and keeps the whole change.
+// findings file is keyed on `PROJECT_ROOT`, written by the ship's reviewer or by `review:submit`; a
+// clean round in it narrows the next brief as a resume, wherever that round ran.
 //
 // **The narrowing is measured from the tree that review was briefed on**, and only when that record
 // was written by the brief the pointer names: one left by an earlier brief is not the tree the
@@ -198,30 +179,35 @@ async function open_contract(slot: ReviewSlot): Promise<{
 	checkout: ReviewCheckout
 	nonce: string
 	resumed_from: FileMapStamp | undefined
+	fix_round: RecordedRound | undefined
 }> {
 	const checkout = await review_checkout.read_checkout()
-	const resumed_from = attested_tree(checkout)
+	const is_code = slot === review_attest.REVIEW_SLOT.CODE
+	const resumed_from = is_code ? attested_tree(checkout) : undefined
+	const fix_round = is_code ? review_fix_round.resume(checkout) : undefined
 	// Keyed on the root git just answered with, never on `process.cwd()`: the check made before the
 	// merge asks git the same question, and the two hash different keys the moment one of them runs
 	// from a subdirectory — a mismatch that would drop the guard with nothing printed.
 	const nonce = review_attest.record_target(checkout, checkout.root, slot)
 
-	return { checkout, nonce, resumed_from }
+	return { checkout, nonce, resumed_from, fix_round }
 }
 
-// Retaken on every round-1 brief, after the pointer it pairs with. Swallowed:
+// Retaken on every code brief, after the pointer it pairs with. Swallowed:
 // a record that failed to write predates the next pointer, so the resume widens rather than narrows.
-function record_briefed(round: number, tree: Record<string, string>, base?: string): void {
-	if (round !== FIRST_ROUND) return
-
+function record_briefed(tree: Record<string, string>, base?: string): void {
 	try {
-		review_stamps.briefed_stamp.write(tree, undefined, base)
+		const blobs = review_round_one_blobs.capture(Object.keys(tree))
+
+		review_stamps.briefed_stamp.write(tree, undefined, base, blobs)
 	} catch {
 		/* no record widens the resume rather than narrowing it */
 	}
 }
 
 interface ComposeRequest {
+	level: ReviewLevel
+	is_full_change?: boolean | undefined
 	round: number
 	paths: ReadonlyArray<string>
 	tree: Record<string, string>
@@ -273,9 +259,8 @@ async function read_readers(
 
 async function compose_brief(request: ComposeRequest): Promise<string> {
 	const { round, paths, tree, base, profile, interaction } = request
-	const opened = await open_contract(slot_of(interaction))
+	const contract = await open_contract(slot_of(interaction))
 	// The interaction review reads the whole change, never a resume's narrowing (joshuafolkken/kit#4276).
-	const contract = interaction === undefined ? opened : { ...opened, resumed_from: undefined }
 	const stamps = {
 		gate: review_stamps.gate_stamp.read(),
 		in_flight: review_stamps.in_flight_stamp.read(),
@@ -283,7 +268,8 @@ async function compose_brief(request: ComposeRequest): Promise<string> {
 	}
 
 	return review_brief.compose({
-		level: review_level.level_for(paths),
+		is_full_change: request.is_full_change,
+		level: request.level,
 		profile,
 		round,
 		tree,
@@ -328,32 +314,23 @@ function report_error(message: string): number {
 	return FAILURE_EXIT_CODE
 }
 
-// Why a change was reduced, or which path forced the default — moved here verbatim from the old
-// `review:level` command so `--level-only` says why rather than only what.
-function format_reason(paths: ReadonlyArray<string>, level: ReviewLevel): string {
-	if (level === review_level.REDUCED_LEVEL) {
-		return 'every changed path is inert — it neither executes nor instructs'
-	}
-
-	const deciding = review_level.deciding_paths(paths)
-
-	if (deciding.length === 0) return 'no changed paths; the default level stands'
-
-	return `changed paths that execute or instruct: ${path_decision.format_path_list(deciding)}`
-}
-
 // The level alone, over `path_decision` — the same reading `review:round2` shares — so `--staged`,
 // `--json` and the usage handling are the ones the old command had, not a second copy.
 async function run_level(argv: ReadonlyArray<string>): Promise<number> {
 	return await path_decision.run_path_decision(argv, {
 		usage: USAGE,
 		key: LEVEL_KEY,
-		decide: (paths) => review_level.level_for(paths),
-		explain: format_reason,
+		decide: async (paths, is_staged) => {
+			const lines = await review_size.read(paths, is_staged)
+
+			return review_level.level_for(paths, lines)
+		},
+		explain: review_level.format_reason,
 	})
 }
 
 interface ChangeReading {
+	level: ReviewLevel
 	base: string
 	commit: string | undefined
 	paths: ReadonlyArray<string>
@@ -362,14 +339,24 @@ interface ChangeReading {
 
 type Emit = (text: string) => void
 
+function refusal_for_round(reading: ChangeReading, round: number): string | undefined {
+	const { tree, commit } = reading
+	const refusal = scoped_green.refusal_for(tree, commit)
+
+	if (refusal === undefined || round === FIRST_ROUND) return refusal
+
+	return scoped_green.refusal_for(tree, commit, { test: test_related_verdict.touched_target() })
+}
+
 // One reading, used by every half below. Read twice, the level could describe a different change from
 // the digests printed beside it — and it would cost four git spawns to do so.
 async function read_change(): Promise<ChangeReading> {
 	const { base, commit } = await read_bases()
 	const paths = await changed_paths.read_changed_paths(false)
 	const tree = await review_tree.read_changed_tree(paths)
+	const lines = await review_size.read(paths)
 
-	return { base, commit, paths, tree }
+	return { base, commit, paths, tree, level: review_level.level_for(paths, lines) }
 }
 
 async function record_review(
@@ -380,29 +367,30 @@ async function record_review(
 	const is_snapshot_written = record_round_one(round, tree, commit)
 
 	if (is_snapshot_written) await review_code_tree.record(Object.keys(tree), commit)
-	record_briefed(round, tree, commit)
+	record_briefed(tree, commit)
+	review_round.record(round)
 }
 
 // An interaction brief records nothing: the round-one and briefed stamps describe `/code-review`'s
 // round, which already ran, and retaking them would move the delta round 2 is measured from.
+type ReviewOptions = Pick<ComposeRequest, 'interaction' | 'is_full_change'>
+
 async function run_review(
 	round: number,
 	reading: ChangeReading,
 	emit: Emit,
-	interaction?: ReadonlyArray<string>,
+	options: ReviewOptions = {},
 ): Promise<number> {
-	const { base, commit, paths, tree } = reading
-	const refusal = scoped_green.refusal_for(tree, commit)
+	const { commit, tree, level } = reading
+	const refusal = refusal_for_round(reading, round)
 
 	if (refusal !== undefined) return report_error(refusal)
-	const resolved = agent_role_profile.resolve_review(round)
+	const resolved = agent_role_profile.resolve_review(round, process.env, level === 'low')
 
 	if (resolved.kind === 'rejected') return report_error(resolved.note)
 	agent_role_profile.warn_of_default()
-	const { profile } = resolved
-
-	emit(await compose_brief({ round, paths, tree, base, profile, interaction }))
-	if (interaction === undefined) await record_review(round, tree, commit)
+	emit(await compose_brief({ ...reading, round, profile: resolved.profile, ...options }))
+	if (options.interaction === undefined) await record_review(round, tree, commit)
 
 	return 0
 }
@@ -427,7 +415,7 @@ async function run_interaction(emit: Emit): Promise<number> {
 
 	if (stale !== undefined) return report_error(stale)
 
-	return await run_review(FIRST_ROUND, reading, emit, targets)
+	return await run_review(FIRST_ROUND, reading, emit, { interaction: targets })
 }
 
 // The scoped-green refusal a brief on this tree would print, read without composing one — so
@@ -445,13 +433,23 @@ const REVIEWER_REFUSAL =
 	'review:brief refused: this is a reviewer session (JOSH_AGENT_ROLE=reviewer). A new brief would drop the attestation this review already left — review the brief you were handed and report.'
 
 async function run_brief(argv: ReadonlyArray<string>, emit: Emit): Promise<number> {
+	if (argv.length === 0) {
+		return await review_round_one_skip.run(
+			await review_round_one_skip.eligible_issue(),
+			async (round, is_full_change) =>
+				await run_review(round, await read_change(), emit, { is_full_change }),
+		)
+	}
+
 	if (argv.length === 1 && argv[0] === INTERACTION_FLAG) return await run_interaction(emit)
 
-	const round = parse_round(argv)
+	const round = review_round.parse_round(argv)
 
 	if (round === undefined) return report_error(USAGE)
 
-	return await run_review(round, await read_change(), emit)
+	const is_full_change = argv.includes(review_round.FULL_CHANGE_FLAG)
+
+	return await run_review(round, await read_change(), emit, { is_full_change })
 }
 
 // `emit` takes the brief: `josh run:review` writes it to a file, because its two briefs together exceed
@@ -470,9 +468,9 @@ async function run(argv: ReadonlyArray<string>): Promise<number> {
 const review_brief_cli = {
 	attested_tree,
 	FIRST_ROUND,
-	format_reason,
+	format_reason: review_level.format_reason,
 	KEPT_NOTE_PREFIX,
-	parse_round,
+	parse_round: review_round.parse_round,
 	record_review,
 	record_round_one,
 	report_error,

package/scripts/review/review-brief.ts

@@ -1,10 +1,13 @@
-import { agent_role_profile, type AgentProfile } from '#scripts/agent/agent-role-profile'
+import { agent_profile_schema, type AgentProfile } from '#scripts/agent/agent-profile-schema'
 import { file_map_stamp, type FileMapStamp } from '#scripts/josh/file-map-stamp'
 import { removed_tests } from './removed-tests'
 import { review_brief_paths } from './review-brief-paths'
 import { review_checkout, type ReviewCheckout } from './review-checkout'
 import { review_diff_parts, type DiffParts } from './review-diff-parts'
+import { review_fix_hunks } from './review-fix-hunks'
+import { review_fix_round, type RecordedRound } from './review-fix-round'
 import { review_interaction } from './review-interaction'
+import { review_round } from './review-round'
 import { review_untouched_readers, type ReadersRead } from './review-untouched-readers'
 
 // The text `josh review:brief` prints — the `/code-review` invocation, composed from what the run
@@ -363,33 +366,6 @@ function round_two_block(
 // 2 makes, measured from the tree that review was briefed on. Every reading that cannot narrow falls back to the whole
 // change: no record, a moved base, or an empty target. An empty target is included because a resumed
 // review that read nothing would report a clean verdict over the one already recorded.
-const RESUMED_HEADING =
-	'Resumed round 1 — a review of this branch was already attested, so this pass reads only what changed since the tree it read.'
-
-const RESUMED_QUESTION =
-	'Review these files in full against the rubric — they are the only code this pass has not already read.'
-
-function resumed_target(
-	snapshot: FileMapStamp | undefined,
-	tree: Record<string, string>,
-	root: string,
-	base: string,
-): string {
-	const scope = round_two_scope(snapshot, tree, base)
-
-	if (scope.recorded_at === undefined || scope.target.length === 0) {
-		return whole_change_target(root, base)
-	}
-
-	return [
-		RESUMED_HEADING,
-		`The attested review read the tree recorded at ${scope.recorded_at}.`,
-		`Target: only these files, which changed since that tree:\n${format_paths(root, scope.target)}`,
-		...reconciliation(root, base, scope),
-		RESUMED_QUESTION,
-	].join('\n')
-}
-
 interface BriefStamps {
 	gate: FileMapStamp | undefined
 	in_flight: FileMapStamp | undefined
@@ -397,6 +373,7 @@ interface BriefStamps {
 }
 
 interface BriefInput {
+	is_full_change?: boolean | undefined
 	level: string
 	profile?: AgentProfile
 	round: number
@@ -413,6 +390,7 @@ interface BriefInput {
 	// The tree a finished, clean review of this branch was briefed on, so round 1 is a resume.
 	// Absent, round 1 reads the whole change.
 	resumed_from?: FileMapStamp | undefined
+	fix_round?: RecordedRound | undefined
 	// The files a recorded High cites (`review_reviewed_tree.high_cited`), named in round 2 as the
 	// High's fix. Absent or empty, no line.
 	high_cited?: ReadonlyArray<string> | undefined
@@ -429,18 +407,34 @@ interface BriefInput {
 	readers?: ReadersRead | undefined
 }
 
-const SECOND_ROUND = 2
-
 function round_one_target(input: BriefInput): string {
 	const { root } = input.checkout
+	const previous = input.fix_round
+
+	if (previous !== undefined) {
+		const scope = round_two_scope(review_fix_round.snapshot(previous), input.tree, input.base)
+		const paths = [...scope.target, ...scope.dropped]
+
+		return scope.recorded_at === undefined
+			? whole_change_target(root, input.base)
+			: (review_fix_hunks.block(previous, paths, root) ?? whole_change_target(root, input.base))
+	}
 
 	if (input.resumed_from === undefined) return whole_change_target(root, input.base)
 
-	return resumed_target(input.resumed_from, input.tree, root, input.base)
+	const scope = round_two_scope(input.resumed_from, input.tree, input.base)
+
+	return review_fix_hunks.resumed_block({
+		recorded_at: scope.recorded_at,
+		paths: format_paths(root, scope.target),
+		reconciliation: reconciliation(root, input.base, scope),
+		fallback: whole_change_target(root, input.base),
+	})
 }
 
 function target_block(input: BriefInput): string {
-	if (input.round < SECOND_ROUND) return round_one_target(input)
+	if (input.is_full_change) return whole_change_target(input.checkout.root, input.base)
+	if (input.round < review_round.SECOND_ROUND) return round_one_target(input)
 
 	const { root } = input.checkout
 	const block = round_two_block(input.stamps.round_one, input.tree, root, input.base)
@@ -453,12 +447,13 @@ function target_block(input: BriefInput): string {
 // code that narrowing exists to keep out of scope. Decided by the target actually printed, not by
 // the round: every round that cannot narrow widens through `whole_change_target`, and that round
 // needs the parts as much as a first one does.
-function is_whole_change(input: BriefInput, target: string): boolean {
-	return target.includes(whole_change_target(input.checkout.root, input.base))
-}
-
 function diff_block(input: BriefInput, target: string): ReadonlyArray<string> {
-	if (!is_whole_change(input, target) || input.diff === undefined) return []
+	if (
+		!target.includes(whole_change_target(input.checkout.root, input.base)) ||
+		input.diff === undefined
+	) {
+		return []
+	}
 
 	return ['', review_diff_parts.reading_block(input.diff.parts, input.diff.cap)]
 }
@@ -466,7 +461,7 @@ function diff_block(input: BriefInput, target: string): ReadonlyArray<string> {
 // Beside a whole-change target only, for the reason `diff_block` gives: a narrowed round keeps the
 // rest of the change, and so its readers, out of scope.
 function readers_block(input: BriefInput, target: string): ReadonlyArray<string> {
-	if (!is_whole_change(input, target)) return []
+	if (!target.includes(whole_change_target(input.checkout.root, input.base))) return []
 
 	return review_untouched_readers.brief_block(input.readers)
 }
@@ -478,13 +473,14 @@ function interaction_block(targets: ReadonlyArray<string> | undefined): Readonly
 }
 
 function compose(input: BriefInput): string {
-	const profile = input.profile ?? agent_role_profile.DEFAULT_PROFILES.reviewer
+	const profile = input.profile ?? agent_profile_schema.DEFAULT_PROFILES.reviewer
 	const target = target_block(input)
 
 	return [
 		input.level,
 		'',
-		`Agent profile: ${agent_role_profile.describe(profile)}`,
+		`Agent profile: ${agent_profile_schema.describe(profile)}`,
+		...(input.is_full_change ? [review_round.FINAL_LINE] : []),
 		'',
 		rubric_line(input.rubric_path),
 		'',
@@ -511,7 +507,7 @@ const review_brief = {
 	dropped_line,
 	EMPTY_DELTA_LINE,
 	gate_line,
-	RESUMED_HEADING,
+	RESUMED_HEADING: review_fix_hunks.RESUMED_HEADING,
 	matching_stamp,
 	no_snapshot_line,
 	NOTHING_LEFT_LINE,
@@ -522,7 +518,7 @@ const review_brief = {
 	ROUND_TWO_QUESTION,
 	round_two_block,
 	round_two_scope,
-	SECOND_ROUND,
+	SECOND_ROUND: review_round.SECOND_ROUND,
 	TEST_COMMAND_LINE,
 	whole_change_target,
 }

package/scripts/review/review-code-tree.ts

@@ -6,13 +6,14 @@ import type { FileMapStamp } from '#scripts/josh/file-map-stamp'
 import { stamp_file } from '#scripts/josh/stamp-file'
 import { PACKAGE_JSON } from '#scripts/lib/package-manifest'
 import { comment_ranges, type TypeScriptApi } from './comment-ranges'
+import { import_specifiers } from './import-specifiers'
 import { review_stamps } from './review-stamps'
 
 // The second map round 1 records beside `review-tree.ts`'s: for each source file, the digest of its
 // text with the comments taken out (joshuafolkken/kit#3826).
 //
 // **Why a second record rather than a second reading of the first.** The round-1 snapshot holds
-// digests, not text, so after the fixes nothing can say what a changed `.ts` file used to contain. A
+// digests, not text, so it cannot reconstruct a changed `.ts` file's original contents. A
 // comment-free digest taken at the same moment is what lets round 2 tell "only the comments changed"
 // from "the code changed" — equal digests mean equal code.
 //
@@ -46,39 +47,72 @@ function load_typescript(root: string): TypeScriptApi | undefined {
 	}
 }
 
-function code_digest(api: TypeScriptApi, root: string, relative: string): string | undefined {
+type Digest = (text: string, relative: string) => string | undefined
+
+function text_digest(api: TypeScriptApi, text: string, relative: string): string | undefined {
+	const code = comment_ranges.strip(api, text, is_svelte(relative))
+
+	return code === undefined ? undefined : stamp_file.digest(code)
+}
+
+// The digest that also leaves out where each binding is imported from (joshuafolkken/kit#5789).
+function inert_digest(api: TypeScriptApi): Digest {
+	return (text, relative) =>
+		text_digest(api, import_specifiers.blank(api, text, relative), relative)
+}
+
+function code_digest(digest: Digest, root: string, relative: string): string | undefined {
+	try {
+		return digest(readFileSync(path.join(root, relative), 'utf8'), relative)
+	} catch {
+		return undefined
+	}
+}
+
+// A path absent at `base` (a new file) or that does not parse there has no digest. `git show`'s
+// output arrives with its final newline stripped, which the working-tree file still ends in.
+async function base_digest(
+	digest: Digest,
+	base: string,
+	relative: string,
+): Promise<string | undefined> {
 	try {
-		const code = comment_ranges.strip(
-			api,
-			readFileSync(path.join(root, relative), 'utf8'),
-			is_svelte(relative),
-		)
+		const text = await git_command.show_file(`${base}:${relative}`)
 
-		return code === undefined ? undefined : stamp_file.digest(code)
+		return digest(`${text}\n`, relative)
 	} catch {
 		return undefined
 	}
 }
 
-// A path that is deleted, does not parse, or is not a source file has no entry — and a path with no
-// entry is never comment-only.
-function tree_of(
+function digests_of(
 	root: string,
 	paths: ReadonlyArray<string>,
-	api: TypeScriptApi | undefined = load_typescript(root),
+	digest: Digest,
 ): Record<string, string> {
-	if (api === undefined) return {}
 	const entries = paths
 		.filter((relative) => is_source(relative))
 		.flatMap((relative) => {
-			const digest = code_digest(api, root, relative)
+			const value = code_digest(digest, root, relative)
 
-			return digest === undefined ? [] : [[relative, digest] as const]
+			return value === undefined ? [] : [[relative, value] as const]
 		})
 
 	return Object.fromEntries(entries)
 }
 
+// A path that is deleted, does not parse, or is not a source file has no entry — and a path with no
+// entry is never comment-only.
+function tree_of(
+	root: string,
+	paths: ReadonlyArray<string>,
+	api: TypeScriptApi | undefined = load_typescript(root),
+): Record<string, string> {
+	if (api === undefined) return {}
+
+	return digests_of(root, paths, (text, relative) => text_digest(api, text, relative))
+}
+
 async function read(paths: ReadonlyArray<string>, root?: string): Promise<Record<string, string>> {
 	return tree_of(root ?? (await git_command.repository_root()), paths)
 }
@@ -118,6 +152,36 @@ function comment_only(
 	)
 }
 
-const review_code_tree = { comment_only, load_typescript, read, record, tree_of }
+// The paths whose code is what it was at `base` — whose difference from it, if any, is in comments or
+// in a binding import's module specifier. Read before round 1 has recorded anything, so it compares
+// against the base's blobs rather than a round-1 snapshot (joshuafolkken/kit#5656). Round 1's own
+// record keeps the comment-only digest, so round 2 still reads an import a fix moved.
+async function inert_since(
+	base: string,
+	paths: ReadonlyArray<string>,
+	root?: string,
+	api?: TypeScriptApi,
+): Promise<ReadonlyArray<string>> {
+	const checkout = root ?? (await git_command.repository_root())
+	const typescript = api ?? load_typescript(checkout)
+	if (typescript === undefined) return []
+	const digest = inert_digest(typescript)
+	const tree = digests_of(checkout, paths, digest)
+	const sources = Object.keys(tree)
+	const digests = await Promise.all(
+		sources.map(async (relative) => await base_digest(digest, base, relative)),
+	)
+
+	return sources.filter((relative, index) => digests[index] === tree[relative])
+}
+
+const review_code_tree = {
+	comment_only,
+	inert_since,
+	load_typescript,
+	read,
+	record,
+	tree_of,
+}
 
 export { review_code_tree }

package/scripts/review/review-comment-carry.ts

@@ -1,5 +1,7 @@
 import { rmSync } from 'node:fs'
 import path from 'node:path'
+import { git_common_directory } from '#scripts/git/git-common-directory'
+import { lane_child_marker } from '#scripts/lane/lane-child-marker'
 import { error_text } from '#scripts/lib/error-message'
 import { observation_ledger } from '#scripts/observations/observation-ledger'
 import { review_comment_round } from './review-comment-round'
@@ -13,6 +15,11 @@ const CARRIED_LINE =
 	'review-finding line(s) recorded on closed issues after their pull requests opened into the ledger.'
 const CARRY_FAILED_LINE =
 	'Could not carry the closed issues’ comment rounds into the ledger; the next carry retries:'
+const LANE_CARRY_LINE =
+	'Not carrying the closed issues’ comment rounds: a lane leaves them to `pnpm josh observations:flush`.'
+const UNKNOWN_CHECKOUT_LINE =
+	'Not carrying the closed issues’ comment rounds: Git could not identify this checkout; `pnpm josh observations:flush` carries them later.'
+const GIT_DIRECTORY_COUNT = 2
 const UNTRACKED_PREFIX = '?? '
 
 // **A carried file no commit took is discarded before the default branch catches up**: left untracked
@@ -37,10 +44,33 @@ async function carry_reported(root: string): Promise<void> {
 	}
 }
 
+// joshuafolkken/kit#5442: unmarked linked lanes also leave other issues' rounds to the flush.
+// Only a known primary checkout carries here; a failed probe never permits a carry.
+async function carry_from_record(root: string): Promise<void> {
+	const directories = lane_child_marker.is_child_of(root)
+		? undefined
+		: git_common_directory.directories(root)
+
+	if (directories === undefined || git_common_directory.select_linked(directories) !== undefined) {
+		console.info(LANE_CARRY_LINE)
+
+		return
+	}
+
+	if (directories.length !== GIT_DIRECTORY_COUNT) {
+		console.warn(UNKNOWN_CHECKOUT_LINE)
+
+		return
+	}
+
+	await carry_reported(root)
+}
+
 const review_comment_carry = {
 	CARRIED_LINE,
 	CARRY_FAILED_LINE,
 	carry_reported,
+	carry_from_record,
 	discard_uncommitted,
 }