@joshuafolkken/kit 1.1514.0 → 1.1784.0

package/scripts/review/removed-tests.ts

@@ -0,0 +1,149 @@
+import { markdown_section } from '#scripts/issue/markdown-section'
+import { report_format_reference } from '#scripts/report/report-format-reference'
+import { test_titles } from './test-titles'
+
+// A test is the record of a behavior, and a change that deletes one with no word of what replaced it
+// loses that behavior silently: the gate stays green and the review reads only what is there
+// (joshuafolkken/kit#4287, after #4171 dropped `lane_thresholds()` with the tests that guarded it).
+// **This is the seam where a deleted test has to be accounted for**: every test the base had and the
+// change no longer has is listed in the review brief, and the merge is refused until the pull request
+// body names, for each, the test that replaced it or the Issue that retired its behavior.
+//
+// **A test that moved is not deleted.** Tests are compared by full name across every changed test
+// file, so one moved to another file keeps its name. One moved under another `describe` keeps its own
+// title, so a gone name is matched against an arrived name with the same title, one for one — a common
+// title such as "returns undefined" deleted under one block is still listed when another block keeps
+// its own copy.
+
+const DISPOSITION_HEADING = '## 消えたテストの処置'
+// The heading as a line of its own, never the mention of it inside a format hint.
+const HEADING_LINE = new RegExp(String.raw`^${DISPOSITION_HEADING}[ \t]*$`, 'mu')
+const REPLACED = '置き換え'
+const RETIRED = '廃止'
+const PENDING_SUFFIX = '— 未記入'
+const BRIEF_HEADING = 'Removed tests'
+// The title runs to the first backtick that a disposition follows, so a title holding backticks of its
+// own — `it('reads the \`.each\` table')` — can still be disposed.
+const ROW_PATTERN = new RegExp(
+	String.raw`^[-*]\s+\x60(?<title>.+?)\x60\s+—\s+(?<kind>${REPLACED}|${RETIRED}):\s*(?<rest>\S.*)$`,
+	'u',
+)
+// A retirement names the Issue that decided it first — an Issue or a plan comment on one — then why.
+const RETIREMENT_PATTERN = /^(?:[\w.-]+\/[\w.-]+)?#\d+\s+\S/u
+const ROW_FORMAT = `under ${DISPOSITION_HEADING}, one line per removed test: \`- \`<test>\` — ${REPLACED}: <the test that guards the behavior now>\` or \`- \`<test>\` — ${RETIRED}: #<Issue that retired the behavior> <reason>\``
+
+function unique(titles: ReadonlyArray<string>): ReadonlyArray<string> {
+	return [...new Set(titles)]
+}
+
+function leaf_counts(titles: ReadonlyArray<string>): Map<string, number> {
+	const counts = new Map<string, number>()
+
+	for (const title of titles) {
+		const leaf = test_titles.leaf_of(title)
+
+		counts.set(leaf, (counts.get(leaf) ?? 0) + 1)
+	}
+
+	return counts
+}
+
+// Spends one arrived name with the same title, so each arrival accounts for one departure only.
+function is_moved(arrived: Map<string, number>, title: string): boolean {
+	const leaf = test_titles.leaf_of(title)
+	const left = arrived.get(leaf) ?? 0
+
+	if (left === 0) return false
+	arrived.set(leaf, left - 1)
+
+	return true
+}
+
+function removed(base: ReadonlyArray<string>, head: ReadonlyArray<string>): ReadonlyArray<string> {
+	const base_names = new Set(base)
+	const head_names = new Set(head)
+	const arrived = leaf_counts(unique(head).filter((title) => !base_names.has(title)))
+
+	return unique(base)
+		.filter((title) => !head_names.has(title))
+		.filter((title) => !is_moved(arrived, title))
+}
+
+// A retirement with no Issue is no row at all, so its test reads as undisposed.
+function is_cited(groups: Readonly<Record<string, string>>): boolean {
+	return groups['kind'] === REPLACED || RETIREMENT_PATTERN.test(groups['rest'] ?? '')
+}
+
+function disposed_title(line: string): string | undefined {
+	const groups = ROW_PATTERN.exec(line.trim())?.groups
+
+	if (groups === undefined || !is_cited(groups)) return undefined
+
+	return groups['title']
+}
+
+function undisposed(removed_titles: ReadonlyArray<string>, pr_body = ''): ReadonlyArray<string> {
+	const disposed = new Set(
+		markdown_section
+			.section_lines(pr_body, DISPOSITION_HEADING)
+			.map((line) => disposed_title(line)),
+	)
+
+	return removed_titles.filter((title) => !disposed.has(title))
+}
+
+function pending_rows(titles: ReadonlyArray<string>): ReadonlyArray<string> {
+	return titles.map((title) => `- \`${title}\` ${PENDING_SUFFIX}`)
+}
+
+function has_row(lines: ReadonlyArray<string>, title: string): boolean {
+	return lines.some((line) => line.trim().startsWith(`- \`${title}\` `))
+}
+
+// The pending rows a body still lacks, put under its disposition heading — added at the end when the
+// body has none — so a run fills them in before `josh ship` rather than meeting them at its preflight
+// (joshuafolkken/kit#4563). A title with any row already, pending or filled, is left as it is.
+function with_pending_rows(body: string, titles: ReadonlyArray<string>): string {
+	const lines = markdown_section.section_lines(body, DISPOSITION_HEADING)
+	const rows = pending_rows(titles.filter((title) => !has_row(lines, title))).join('\n')
+
+	if (rows === '') return body
+	if (!HEADING_LINE.test(body)) return `${body.trimEnd()}\n\n${DISPOSITION_HEADING}\n\n${rows}\n`
+
+	return body.replace(HEADING_LINE, () => `${DISPOSITION_HEADING}\n\n${rows}`)
+}
+
+// Nothing when the change removed no test, so an ordinary brief is not one line longer.
+function brief_block(removed_titles: ReadonlyArray<string>): ReadonlyArray<string> {
+	if (removed_titles.length === 0) return []
+
+	return [
+		'',
+		`${BRIEF_HEADING} — these tests existed at the base and are gone from the change. For each, find the test that guards its behavior now, or the Issue that retired the behavior; a removed test with neither is a finding (missing test). The pull request body must dispose of each ${ROW_FORMAT}, or \`josh followup\` refuses the merge:`,
+		...pending_rows(removed_titles),
+	]
+}
+
+function refusal_message(titles: ReadonlyArray<string>): string {
+	return [
+		`Merge refused: this change removes ${String(titles.length)} test(s) the pull request body does not account for.`,
+		`Put these rows into the body's ${DISPOSITION_HEADING} section, replacing each ending with the test that replaced it or the Issue that retired its behavior:`,
+		DISPOSITION_HEADING,
+		'',
+		...pending_rows(titles),
+		`Write ${ROW_FORMAT} — format: ${report_format_reference.pointer(report_format_reference.REMOVED_TESTS_HEADING)}`,
+		'Write it into the `--body-file` before `josh ship`, or update an open PR with `gh api -X PATCH repos/{owner}/{repo}/pulls/<N> -F body=@<path>`, then re-run.',
+	].join('\n')
+}
+
+const removed_tests = {
+	brief_block,
+	DISPOSITION_HEADING,
+	refusal_message,
+	removed,
+	ROW_FORMAT,
+	undisposed,
+	with_pending_rows,
+}
+
+export { removed_tests }

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

@@ -1,4 +1,3 @@
-#!/usr/bin/env tsx
 import path from 'node:path'
 import { fileURLToPath } from 'node:url'
 import { agent_role_profile, type AgentProfile } from '#scripts/agent/agent-role-profile'
@@ -8,21 +7,26 @@ import { change_base } from '#scripts/git/change-base'
 import { changed_paths } from '#scripts/git/changed-paths'
 import { git_command } from '#scripts/git/git-command'
 import { PROJECT_ROOT } from '#scripts/init/init-paths'
+import { issue_watch_gate } from '#scripts/issue/issue-watch-gate'
 import type { FileMapStamp } from '#scripts/josh/file-map-stamp'
 import { find_package_directory } from '#scripts/josh/josh-logic'
 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 { removed_tests_check } from './removed-tests-check'
 import { review_attest } from './review-attest'
 import { review_brief } from './review-brief'
 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_interaction } from './review-interaction'
 import { review_level, type ReviewLevel } from './review-level'
+import { review_round_one_blobs } from './review-round-one-blobs'
 import { review_stamps } from './review-stamps'
 import { review_tree } from './review-tree'
+import { review_untouched_readers, type ReadersRead } from './review-untouched-readers'
 
 // `josh review:brief` — print the whole `/code-review` invocation, not just the level.
 //
@@ -33,8 +37,8 @@ import { review_tree } from './review-tree'
 // so "still running" is the usual answer at this point), how this project runs its unit tests, and —
 // on round 2 — which files the first round's fixes touched.
 
-const ARGV_OFFSET = 2
-const USAGE = 'Usage: josh review:brief [--round <1|2>] | --level-only [--staged] [--json]'
+const USAGE =
+	'Usage: josh review:brief [--round <1|2>] | --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
@@ -54,6 +58,7 @@ const ROUND_FLAG = '--round'
 // paths and nothing else. `--staged` and `--json` are passed straight through, exactly as the old
 // command took them.
 const LEVEL_ONLY_FLAG = '--level-only'
+const INTERACTION_FLAG = '--interaction'
 const LEVEL_KEY = 'level'
 const FIRST_ROUND = 1
 const FAILURE_EXIT_CODE = 1
@@ -132,7 +137,12 @@ function record_round_one(
 			return false
 		}
 
-		review_stamps.round_one_stamp.write(tree, target, base)
+		review_stamps.round_one_stamp.write(
+			tree,
+			target,
+			base,
+			review_round_one_blobs.capture(Object.keys(tree)),
+		)
 
 		return true
 	} catch {
@@ -202,6 +212,7 @@ interface ComposeRequest {
 	tree: Record<string, string>
 	base: string
 	profile: AgentProfile
+	interaction?: ReadonlyArray<string> | undefined
 }
 
 // **Swallowed, and the brief keeps its target line**: parts that could not be
@@ -221,9 +232,35 @@ async function read_diff(
 	}
 }
 
+// **Swallowed, and the brief omits the list**: `josh ship` and `followup` read the same list again
+// and refuse on a failure, so the merge never rests on this reading.
+async function read_removed_tests(): Promise<ReadonlyArray<string>> {
+	try {
+		return (await removed_tests_check.read()) ?? []
+	} catch {
+		return []
+	}
+}
+
+// **A failure is marked, and the brief says the list could not be read** — never an empty list,
+// which would read as a change with no reader outside it.
+async function read_readers(
+	root: string,
+	base: string,
+	paths: ReadonlyArray<string>,
+): Promise<ReadersRead> {
+	try {
+		return await review_untouched_readers.read({ root, base, paths })
+	} catch {
+		return review_untouched_readers.FAILED_READ
+	}
+}
+
 async function compose_brief(request: ComposeRequest): Promise<string> {
-	const { round, paths, tree, base, profile } = request
-	const contract = await open_contract()
+	const { round, paths, tree, base, profile, interaction } = request
+	const opened = await open_contract()
+	// 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(),
@@ -245,6 +282,9 @@ async function compose_brief(request: ComposeRequest): Promise<string> {
 		rubric_path: RUBRIC_PATH,
 		...contract,
 		diff: await read_diff(contract.checkout.root, base, paths),
+		readers: await read_readers(contract.checkout.root, base, paths),
+		removed_tests: await read_removed_tests(),
+		interaction,
 	})
 }
 
@@ -325,7 +365,13 @@ async function record_review(
 	record_briefed(round, tree, commit)
 }
 
-async function run_review(round: number, reading: ChangeReading): Promise<number> {
+// 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.
+async function run_review(
+	round: number,
+	reading: ChangeReading,
+	interaction?: ReadonlyArray<string>,
+): Promise<number> {
 	const { base, commit, paths, tree } = reading
 	const refusal = scoped_green.refusal_for(tree, commit)
 
@@ -334,14 +380,40 @@ async function run_review(round: number, reading: ChangeReading): Promise<number
 
 	if (resolved.kind === 'rejected') return report_error(resolved.note)
 	agent_role_profile.warn_of_default()
-	console.info(await compose_brief({ round, paths, tree, base, profile: resolved.profile }))
-	await record_review(round, tree, commit)
+	const { profile } = resolved
+
+	console.info(await compose_brief({ round, paths, tree, base, profile, interaction }))
+	if (interaction === undefined) await record_review(round, tree, commit)
 
 	return 0
 }
 
+// The interaction review's brief (joshuafolkken/kit#4276): `/code-review`'s round-1 brief over the
+// whole change, with the role and the run-tooling paths appended. Not due, it says so and exits 0.
+//
+// **An issue update taken in after round 1's brief refuses it**: minting this brief moves the pointer
+// `josh followup` measures that update against (`issue-watch-gate.ts`), so a round 1 that read the
+// earlier specification would merge without that refusal.
+async function run_interaction(): Promise<number> {
+	const reading = await read_change()
+	const targets = review_interaction.due_paths(reading.paths)
+
+	if (targets.length === 0) {
+		console.info(review_interaction.NOT_DUE_LINE)
+
+		return 0
+	}
+
+	const stale = await issue_watch_gate.review_refusal_here()
+
+	if (stale !== undefined) return report_error(stale)
+
+	return await run_review(FIRST_ROUND, reading, targets)
+}
+
 async function run(argv: ReadonlyArray<string>): Promise<number> {
 	if (argv[0] === LEVEL_ONLY_FLAG) return await run_level(argv.slice(1))
+	if (argv.length === 1 && argv[0] === INTERACTION_FLAG) return await run_interaction()
 
 	const round = parse_round(argv)
 
@@ -350,10 +422,6 @@ async function run(argv: ReadonlyArray<string>): Promise<number> {
 	return await run_review(round, await read_change())
 }
 
-async function main(argv: ReadonlyArray<string>): Promise<void> {
-	process.exitCode = await run(argv)
-}
-
 const review_brief_cli = {
 	FIRST_ROUND,
 	format_reason,
@@ -365,6 +433,4 @@ const review_brief_cli = {
 	run,
 }
 
-if (process.argv[1] === fileURLToPath(import.meta.url)) await main(process.argv.slice(ARGV_OFFSET))
-
 export { review_brief_cli }

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

@@ -0,0 +1,12 @@
+#!/usr/bin/env tsx
+import { fileURLToPath } from 'node:url'
+import { review_brief_cli } from './review-brief-cli'
+
+// The `josh review:brief` entry, kept apart from `review-brief-cli.ts` because `run-review-cli.ts`
+// imports that one: a bundle is one file, so a main guard there would fire for every command that
+// carries it (joshuafolkken/kit#4186).
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+	const ARGV_OFFSET = 2
+
+	process.exitCode = await review_brief_cli.run(process.argv.slice(ARGV_OFFSET))
+}

package/scripts/review/review-brief.ts

@@ -1,7 +1,10 @@
 import { agent_role_profile, type AgentProfile } from '#scripts/agent/agent-role-profile'
 import { file_map_stamp, type FileMapStamp } from '#scripts/josh/file-map-stamp'
+import { removed_tests } from './removed-tests'
 import { review_checkout, type ReviewCheckout } from './review-checkout'
 import { review_diff_parts, type DiffParts } from './review-diff-parts'
+import { review_interaction } from './review-interaction'
+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
 // already knows.
@@ -414,6 +417,14 @@ interface BriefInput {
 	// The change written as parts under the Bash output cap. Absent when the
 	// write failed, and the target line alone then names the change.
 	diff?: { parts: DiffParts; cap: number } | undefined
+	// The tests the change removes, listed for the reviewer to account for. Absent or empty, no section.
+	removed_tests?: ReadonlyArray<string> | undefined
+	// The run-tooling paths an interaction review is briefed on (joshuafolkken/kit#4276). Absent, the
+	// brief is `/code-review`'s alone.
+	interaction?: ReadonlyArray<string> | undefined
+	// The readers outside the diff of each exported name it edits (joshuafolkken/kit#4515). A failed
+	// read is printed as one; absent or empty, no section.
+	readers?: ReadersRead | undefined
 }
 
 const SECOND_ROUND = 2
@@ -437,16 +448,30 @@ 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 diff_block(input: BriefInput, target: string): ReadonlyArray<string> {
-	const is_whole_change = target.includes(whole_change_target(input.checkout.root, input.base))
+function is_whole_change(input: BriefInput, target: string): boolean {
+	return target.includes(whole_change_target(input.checkout.root, input.base))
+}
 
-	if (!is_whole_change || input.diff === undefined) return []
+function diff_block(input: BriefInput, target: string): ReadonlyArray<string> {
+	if (!is_whole_change(input, target) || input.diff === undefined) return []
 
 	return ['', review_diff_parts.reading_block(input.diff.parts, input.diff.cap)]
 }
 
+// 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 []
+
+	return review_untouched_readers.brief_block(input.readers)
+}
+
 // The level alone on the first line, because the level-only mode's contract — a caller reading the
 // answer with `$(...)` — is the one thing a brief must not break.
+function interaction_block(targets: ReadonlyArray<string> | undefined): ReadonlyArray<string> {
+	return targets === undefined ? [] : ['', review_interaction.brief_block(targets)]
+}
+
 function compose(input: BriefInput): string {
 	const profile = input.profile ?? agent_role_profile.DEFAULT_PROFILES.reviewer
 	const target = target_block(input)
@@ -465,6 +490,9 @@ function compose(input: BriefInput): string {
 		'',
 		target,
 		...diff_block(input, target),
+		...readers_block(input, target),
+		...removed_tests.brief_block(input.removed_tests ?? []),
+		...interaction_block(input.interaction),
 	].join('\n')
 }
 

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

@@ -4,6 +4,7 @@ import path from 'node:path'
 import { git_command } from '#scripts/git/git-command'
 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 { review_stamps } from './review-stamps'
 
@@ -26,7 +27,6 @@ const SCRIPT_EXTENSIONS: ReadonlyArray<string> = ['.ts', '.js']
 const SVELTE_EXTENSION = '.svelte'
 const EXCLUDED_PREFIX = '.claude/'
 const TYPESCRIPT_MODULE = 'typescript'
-const PACKAGE_JSON = 'package.json'
 
 function is_svelte(relative: string): boolean {
 	return relative.endsWith(SVELTE_EXTENSION)
@@ -100,20 +100,24 @@ async function record(
 }
 
 // The paths whose code round 1's fixes left as it was — whose difference, if any, is in comments.
-// Nothing qualifies against a record taken on another base, for the reason the round-1 snapshot is
-// refused on one.
+// Against a record taken on another base only `unmoved` qualifies — the paths the move left alone
+// (`review_round_one_blobs.unmoved`), where the carried file is round 1's own and equal code digests
+// still mean a comment-only fix (joshuafolkken/kit#4165).
 function comment_only(
 	snapshot: FileMapStamp | undefined,
 	tree: Record<string, string>,
 	base: string | undefined,
+	unmoved: ReadonlyArray<string> = [],
 ): ReadonlyArray<string> {
-	if (snapshot === undefined || base === undefined || snapshot.base !== base) return []
+	if (snapshot === undefined || base === undefined) return []
+	const is_same_base = snapshot.base === base
 
 	return Object.keys(snapshot.files).filter(
-		(relative) => snapshot.files[relative] === tree[relative],
+		(relative) =>
+			snapshot.files[relative] === tree[relative] && (is_same_base || unmoved.includes(relative)),
 	)
 }
 
-const review_code_tree = { comment_only, read, record, tree_of }
+const review_code_tree = { comment_only, load_typescript, read, record, tree_of }
 
 export { review_code_tree }

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

@@ -33,12 +33,14 @@ const PER_PAGE = '100'
 const UNNAMED_REPOSITORY = 'Could not name this repository from `git remote`.'
 const UNREAD_SEARCH = 'Could not read the search for closed issues with a comment round.'
 const UNREAD_COMMENTS = 'Could not read the comments of'
+const UNREAD_PERMISSION = 'Could not read the write permission of'
 
 const search_item_schema = z.object({ number: z.number() })
 const search_schema = z.object({ items: z.array(search_item_schema) })
 const comment_schema = z.object({
 	body: z.string().nullish(),
 	author_association: z.string().nullish(),
+	user: z.looseObject({ login: z.string() }).nullish(),
 })
 
 type IssueComment = z.infer<typeof comment_schema>
@@ -50,13 +52,29 @@ function body_of(lines: ReadonlyArray<string>): string {
 // The ledger lines of every comment round among one issue's comments, oldest first; any other
 // comment, one that only quotes the heading among them, carries none — nor does one whose author
 // cannot write to the repository: anyone can comment on a public issue, and the carried lines ride
-// the run's commit unreviewed.
-function lines_of(comments: ReadonlyArray<IssueComment>): Array<string> {
-	return comments
-		.filter((comment) => gh_author_association.is_trusted(comment.author_association))
-		.map((comment) => comment.body ?? '')
-		.filter((body) => body.startsWith(COMMENT_HEADING))
-		.flatMap((body) => body.split('\n'))
+// the run's commit unreviewed. A permission lookup that failed throws instead: the carried file is
+// written once, so a round dropped on a transient failure would never be carried.
+async function is_trusted_comment(comment: IssueComment): Promise<boolean> {
+	const login = comment.user?.login
+	const is_trusted = await gh_author_association.trust_of({
+		login,
+		association: comment.author_association,
+	})
+
+	if (is_trusted === undefined) throw new Error(`${UNREAD_PERMISSION} ${login ?? ''}`)
+
+	return is_trusted
+}
+
+async function lines_of(comments: ReadonlyArray<IssueComment>): Promise<Array<string>> {
+	const rounds = comments.filter((comment) => (comment.body ?? '').startsWith(COMMENT_HEADING))
+	const trusted = await Promise.all(
+		rounds.map(async (comment) => await is_trusted_comment(comment)),
+	)
+
+	return rounds
+		.filter((_comment, index) => trusted[index] === true)
+		.flatMap((comment) => (comment.body ?? '').split('\n'))
 		.filter((line) => review_finding_ledger.is_finding_line(line))
 }
 
@@ -93,7 +111,7 @@ async function carry_issue(issue: number, root: string): Promise<number> {
 
 	if (raw === undefined) throw new Error(`${UNREAD_COMMENTS} ${session_cite.issue(issue)}`)
 
-	const lines = lines_of(parse_json_array_safe(raw, comment_schema))
+	const lines = await lines_of(parse_json_array_safe(raw, comment_schema))
 
 	await observation_ledger_home.append(carried_path(issue, root), lines)
 

package/scripts/review/review-finding-ledger.ts

@@ -7,7 +7,10 @@ import { issue_cite } from '#scripts/issue/issue-cite'
 // prefix so `observation-ledger-line.ts`'s `- k:` grammar never treats them as its own — one ledger,
 // one commit path, a second line *type* rather than a second ledger.
 
-const FINDING_PREFIX = '- rf:'
+// **The interaction review writes the same grammar under its own prefix** (joshuafolkken/kit#4276), so
+// its round is told apart from `/code-review`'s by the merge gate, and its findings stay out of the
+// `/code-review` tally a reader compares rounds by.
+const PREFIX = { code: '- rf:', interaction: '- ri:' } as const
 const FIELD_SEPARATOR = ' | '
 const FIELD_COUNT = 5
 
@@ -34,6 +37,7 @@ const NO_FILE = '-'
 
 type Category = (typeof CATEGORIES)[number]
 type Severity = (typeof SEVERITIES)[number]
+type LineKind = keyof typeof PREFIX
 
 interface Finding {
 	category: Category
@@ -65,27 +69,36 @@ function issue_field(issue: number): string {
 	return issue_cite.plain(issue)
 }
 
-function line_of(fields: ReadonlyArray<string>): string {
-	return `${FINDING_PREFIX}${fields.join(FIELD_SEPARATOR)}`
+function line_of(fields: ReadonlyArray<string>, kind: LineKind): string {
+	return `${PREFIX[kind]}${fields.join(FIELD_SEPARATOR)}`
 }
 
-function finding_line(finding: Finding, date: string, issue: number): string {
-	return line_of([finding.category, finding.severity, finding.file, date, issue_field(issue)])
+function finding_line(
+	finding: Finding,
+	date: string,
+	issue: number,
+	kind: LineKind = 'code',
+): string {
+	return line_of([finding.category, finding.severity, finding.file, date, issue_field(issue)], kind)
 }
 
 // **A zero-finding round records `none`, not nothing.** Reading its absence as "no findings" would
 // merge the round that found nothing with the round nobody recorded, which is the exact confusion the
 // ledger exists to end.
-function zero_round_line(date: string, issue: number): string {
-	return line_of([NONE, NONE, NO_FILE, date, issue_field(issue)])
+function zero_round_line(date: string, issue: number, kind: LineKind = 'code'): string {
+	return line_of([NONE, NONE, NO_FILE, date, issue_field(issue)], kind)
 }
 
-function is_finding_line(line: string): boolean {
-	return line.trimStart().startsWith(FINDING_PREFIX)
+function is_finding_line(line: string, kind: LineKind = 'code'): boolean {
+	return line.trimStart().startsWith(PREFIX[kind])
+}
+
+function fields_of(line: string, kind: LineKind = 'code'): ReadonlyArray<string> {
+	return line.trimStart().slice(PREFIX[kind].length).split(FIELD_SEPARATOR)
 }
 
 function category_of(line: string): string | undefined {
-	const fields = line.trimStart().slice(FINDING_PREFIX.length).split(FIELD_SEPARATOR)
+	const fields = fields_of(line)
 
 	return fields.length === FIELD_COUNT ? fields[0] : undefined
 }
@@ -135,8 +148,8 @@ function zero_round_count(content: string): number {
 // The issue a finding line is keyed to — its fifth field, the `#<N>` token — or `undefined` for a
 // non-finding or malformed line. The record check reads this to ask whether a given issue's round was
 // recorded at all.
-function issue_of(line: string): string | undefined {
-	const fields = line.trimStart().slice(FINDING_PREFIX.length).split(FIELD_SEPARATOR)
+function issue_of(line: string, kind: LineKind): string | undefined {
+	const fields = fields_of(line, kind)
 
 	return fields.length === FIELD_COUNT ? fields[FIELD_COUNT - 1] : undefined
 }
@@ -145,10 +158,12 @@ function issue_of(line: string): string | undefined {
 // asks whether the round was recorded, not whether it found anything — reading the issue field, which
 // a zero-finding line carries too, is what keeps a clean round's single line from reading as "nobody
 // recorded this".
-function has_issue_record(content: string, issue: number): boolean {
+function has_issue_record(content: string, issue: number, kind: LineKind = 'code'): boolean {
 	const target = issue_field(issue)
 
-	return content.split('\n').some((line) => is_finding_line(line) && issue_of(line) === target)
+	return content
+		.split('\n')
+		.some((line) => is_finding_line(line, kind) && issue_of(line, kind) === target)
 }
 
 const review_finding_ledger = {
@@ -165,5 +180,5 @@ const review_finding_ledger = {
 	zero_round_line,
 }
 
-export type { CategoryCount, Finding }
+export type { CategoryCount, Finding, LineKind }
 export { review_finding_ledger }