@joshuafolkken/kit 1.1435.0 → 1.1453.0

package/scripts/release/release-issue-close.ts

@@ -0,0 +1,133 @@
+import { epic_issue } from '#scripts/epic/epic-issue'
+import { epic_parse } from '#scripts/epic/epic-parse'
+import type { IssueReference } from '#scripts/epic/epic-reference'
+import { git_gh_command } from '#scripts/gh/git-gh-command'
+import { epic_child_schema } from '#scripts/git/git-schemas'
+import { parse_json_object_or_undefined } from '#scripts/git/parse-json-array'
+import { issue_release_cli } from '#scripts/issue/issue-release-cli'
+import { session_cite } from '#scripts/issue/session-cite'
+
+// Closes the repository's open release Issue once `pnpm josh release` has published
+// (joshuafolkken/kit#3825). Its body promises that, and an Issue waiting on the release reopens only
+// once it closes; left open, it keeps naming published work as unreleased.
+//
+// **Nothing here throws or changes the release's exit code.** The version is already out by the time
+// this runs, so a close that fails is reported for a person to finish rather than read as a failed
+// release.
+
+function published_comment(version: string): string {
+	return `Published in \`v${version}\` by \`pnpm josh release\`.`
+}
+
+// Resolved through `epic_issue.blocker_references_of`, so a blocker in another repository keeps that
+// repository instead of reading as the same number here.
+function open_references_of(
+	json: string | undefined,
+	repo: string,
+): Array<IssueReference> | undefined {
+	if (json === undefined) return undefined
+	const parsed = parse_json_object_or_undefined(json, epic_child_schema)
+
+	if (parsed === undefined) return undefined
+
+	return epic_issue
+		.blocker_references_of(parsed, repo)
+		.filter((reference) => !epic_parse.is_state_closed(reference.state))
+}
+
+// The blockers still open at publish have not merged, so this release did not carry them.
+// `undefined` when the relations are unreadable: closing then could strand a blocker on a closed
+// release Issue that no open one tracks.
+async function open_blockers_of(
+	repo: string,
+	issue_number: number,
+): Promise<Array<IssueReference> | undefined> {
+	const json = await git_gh_command.issue_get_state_and_relations(String(issue_number))
+
+	try {
+		return open_references_of(json, repo)
+	} catch {
+		return undefined
+	}
+}
+
+// A release Issue tracks only its own repository's changes, so a blocker elsewhere is named for a
+// person to carry rather than linked under a number that means a different Issue here.
+function warn_foreign(repo: string, foreign: ReadonlyArray<IssueReference>): void {
+	for (const reference of foreign) {
+		const cite = session_cite.issue(reference.number, undefined, reference.repo)
+
+		console.warn(`⚠ ${cite} is not in ${repo}, so it was not carried — carry it by hand`)
+	}
+}
+
+// Each unmerged blocker joins the next release Issue — the first link files it, the rest find it
+// open — so an open release Issue still names every change no release has published.
+async function carry_forward(repo: string, blockers: ReadonlyArray<IssueReference>): Promise<void> {
+	const own = blockers.filter((blocker) => blocker.repo === repo)
+
+	warn_foreign(
+		repo,
+		blockers.filter((blocker) => blocker.repo !== repo),
+	)
+
+	for (const blocker of own) {
+		// eslint-disable-next-line no-await-in-loop -- the first link files the Issue the rest join
+		await issue_release_cli.link(blocker.number, repo)
+	}
+}
+
+async function close_and_carry(
+	repo: string,
+	issue_number: number,
+	version: string,
+	blockers: ReadonlyArray<IssueReference>,
+): Promise<void> {
+	const cite = `release Issue ${session_cite.issue(issue_number, undefined, repo)}`
+	const is_closed = await git_gh_command.issue_close(
+		String(issue_number),
+		published_comment(version),
+	)
+
+	if (!is_closed) {
+		console.warn(`⚠ ${cite} could not be closed — close it by hand`)
+
+		return
+	}
+
+	console.info(`${cite} closed (v${version})`)
+	await carry_forward(repo, blockers)
+}
+
+async function close_issue(repo: string, issue_number: number, version: string): Promise<void> {
+	const blockers = await open_blockers_of(repo, issue_number)
+
+	if (blockers === undefined) {
+		const cite = session_cite.issue(issue_number, undefined, repo)
+
+		console.warn(`⚠ the blockers of release Issue ${cite} could not be read, so it was left open`)
+
+		return
+	}
+
+	await close_and_carry(repo, issue_number, version, blockers)
+}
+
+async function close_published(version: string): Promise<void> {
+	const repo = await git_gh_command.repo_get_name_with_owner()
+
+	if (repo === undefined) {
+		console.warn('⚠ the repository is unreadable, so its release Issue was left open')
+
+		return
+	}
+
+	const open = await issue_release_cli.find_open(repo)
+
+	if (open === undefined) console.warn(`⚠ the release Issues of ${repo} could not be listed`)
+	else if (typeof open === 'number') await close_issue(repo, open, version)
+}
+
+const release_issue_close = { close_published }
+
+export { release_issue_close }

package/scripts/release/release-publish.ts

@@ -5,6 +5,7 @@ import { git_remote_branch } from '#scripts/git/git-remote-branch'
 import { repository_lock } from '#scripts/git/repository-lock'
 import { write_version } from '#scripts/version/bump-version'
 import { version_targets } from '#scripts/version/version-targets'
+import { release_issue_close } from './release-issue-close'
 import type { ReleasePlan } from './release-plan'
 import { release_progress } from './release-progress'
 import { release_tag } from './release-tag'
@@ -121,6 +122,14 @@ async function commit_release(plan: ReleasePlan): Promise<string> {
 	return pr_url
 }
 
+// The release Issue is closed only once the distribution answered success — a failed watch leaves it
+// open, still naming the work as unreleased (joshuafolkken/kit#3825).
+async function close_when_published(version: string, exit_code: number): Promise<number> {
+	if (exit_code === SUCCESS_EXIT_CODE) await release_issue_close.close_published(version)
+
+	return exit_code
+}
+
 // No tag means nothing downstream ran, so the npm and GitHub Release watches are not started.
 async function merge_and_tag(
 	plan: ReleasePlan,
@@ -136,7 +145,9 @@ async function merge_and_tag(
 	console.info(release_tag.format_result(plan.next_version, is_tagged))
 	if (!is_tagged) return FAILURE_EXIT_CODE
 
-	return await release_progress.wait_for_distribution(plan.next_version)
+	const exit_code = await release_progress.wait_for_distribution(plan.next_version)
+
+	return await close_when_published(plan.next_version, exit_code)
 }
 
 // The whole release happens inside a work tree cut for it, so the root checkout is never touched: the

package/scripts/repo/repository-labels.ts

@@ -86,6 +86,16 @@ function ensure_labels(repo: string | undefined): ReadonlyArray<string> {
 	return create_missing(missing_labels(existing), repo)
 }
 
-const repository_labels = { ensure_labels }
+// The label names `ensure_labels` would create, read without creating any — every one when the
+// repository does not exist yet (`josh start --dry-run`). Undefined when the listing cannot be read,
+// so an unread repository is not reported as one with no labels.
+function planned_labels(repo: string | undefined): ReadonlyArray<string> | undefined {
+	if (repo === undefined) return label_names(REPOSITORY_LABELS)
+	const existing = read_existing(repo)
+
+	return existing === undefined ? undefined : label_names(missing_labels(existing))
+}
+
+const repository_labels = { ensure_labels, planned_labels }
 
 export { repository_labels }

package/scripts/review/comment-ranges.ts

@@ -0,0 +1,199 @@
+import type ts from 'typescript'
+
+// The text of a source file with its comments taken out, so two versions that differ only in comments
+// read as the same text.
+//
+// **Every range comes from the TypeScript parser, never from a pattern.** A `//` inside a regular
+// expression or a template literal is code, and a hand-written scanner that took it for a comment
+// would strip a real edit and call the fix comment-only — the one wrong answer that buys a `skip`.
+// Driven by the parse tree, a range is only ever read from the trivia before a token.
+//
+// **What it cannot read, it does not strip**: a file that does not parse answers `undefined`, and a
+// comment the walk does not reach stays in the text. Both resolve to "the code changed", which costs a
+// round rather than skipping one.
+
+type TypeScriptApi = typeof ts
+type Range = readonly [number, number]
+
+// A comment's own opening — the shebang is trivia to the parser too, but it decides how the file is
+// executed, so it stays.
+const COMMENT_OPENINGS: ReadonlyArray<string> = ['//', '/*']
+// A private-use character, which no source file this reads holds.
+const MARK = ''
+const LINE_BREAK = '\n'
+const SEPARATOR = ' '
+// Script blocks are parsed; style blocks are left whole, so `<!--` in a stylesheet is never read as
+// a markup comment.
+const RAW_BLOCK = /<(?<tag>script|style)\b[^>]*>(?<body>[\s\S]*?)<\/\k<tag>>/gu
+const SCRIPT_TAG = 'script'
+const MARKUP_COMMENT = /<!--[\s\S]*?-->/gu
+const VIRTUAL_FILE_NAME = 'fix-delta.ts'
+// A comment a tool reads is code: a fix that silences lint, the type check or coverage, or changes
+// what a bundler or the type checker reads, does it by adding one — the edit only the review sees.
+// JSDoc type tags count too, since a checked `.js` file takes its types from them — any tag carrying a
+// `{…}` type expression, plus the type tags that carry none. Matching too much only costs a round.
+const DIRECTIVE_MARKERS: ReadonlyArray<string> = [
+	'///',
+	'@ts-',
+	'eslint',
+	'jshint',
+	'global ',
+	'globals ',
+	'prettier-ignore',
+	'svelte-ignore',
+	'cspell',
+	'v8 ignore',
+	'c8 ignore',
+	'istanbul ignore',
+	'__PURE__',
+	'__NO_SIDE_EFFECTS__',
+	'@vite-ignore',
+	'webpack',
+	'@jsx',
+	'@vitest-environment',
+]
+const JSDOC_TYPE_TAG =
+	/@(?:type|typedef|param|returns?|template|satisfies|import|callback|overload|enum|this)\b/u
+const JSDOC_TYPE_EXPRESSION = /@\w+\s*\{/u
+
+function is_directive(text: string, range: Range): boolean {
+	const comment = text.slice(range[0], range[1])
+
+	if (JSDOC_TYPE_TAG.test(comment) || JSDOC_TYPE_EXPRESSION.test(comment)) return true
+
+	return DIRECTIVE_MARKERS.some((marker) => comment.includes(marker))
+}
+
+function is_comment(text: string, range: Range): boolean {
+	return COMMENT_OPENINGS.some((opening) => text.startsWith(opening, range[0]))
+}
+
+function trivia_at(api: TypeScriptApi, text: string, position: number): Array<Range> {
+	const found = [
+		...(api.getLeadingCommentRanges(text, position) ?? []),
+		...(api.getTrailingCommentRanges(text, position) ?? []),
+	]
+
+	return found.map((range): Range => [range.pos, range.end])
+}
+
+// **JSDoc nodes are not descended into**: their children sit inside the comment, and a `//` there
+// would read as a line comment running past the `*/` into the code that follows it.
+function collect(
+	api: TypeScriptApi,
+	node: ts.Node,
+	source: ts.SourceFile,
+	into: Array<Range>,
+): void {
+	if (api.isJSDoc(node)) return
+
+	into.push(...trivia_at(api, source.text, node.pos))
+
+	for (const child of node.getChildren(source)) collect(api, child, source, into)
+}
+
+// Parsed as TypeScript whatever the extension, because a `.js` file is valid TypeScript syntax and JSX
+// is not — JSX text holding `//` is exactly what a trivia read would mistake for a comment, and here
+// it is a parse error instead.
+function script_ranges(api: TypeScriptApi, text: string): Array<Range> | undefined {
+	const source = api.createSourceFile(VIRTUAL_FILE_NAME, text, api.ScriptTarget.Latest, false)
+	const diagnostics = (source as ts.SourceFile & { parseDiagnostics?: ReadonlyArray<unknown> })
+		.parseDiagnostics
+
+	if (diagnostics === undefined || diagnostics.length > 0) return undefined
+	const ranges: Array<Range> = []
+
+	collect(api, source, source, ranges)
+
+	return ranges.filter((range) => is_comment(text, range))
+}
+
+function shifted(ranges: ReadonlyArray<Range>, offset: number): Array<Range> {
+	return ranges.map((range): Range => [range[0] + offset, range[1] + offset])
+}
+
+function is_inside(blocks: ReadonlyArray<Range>, index: number): boolean {
+	return blocks.some((block) => index >= block[0] && index < block[1])
+}
+
+function markup_ranges(text: string, blocks: ReadonlyArray<Range>): Array<Range> {
+	return [...text.matchAll(MARKUP_COMMENT)]
+		.filter((match) => !is_inside(blocks, match.index))
+		.map((match): Range => [match.index, match.index + match[0].length])
+}
+
+function block_ranges(api: TypeScriptApi, match: RegExpExecArray): Array<Range> | undefined {
+	if (match.groups?.['tag'] !== SCRIPT_TAG) return []
+	const body = match.groups['body'] ?? ''
+	const ranges = script_ranges(api, body)
+
+	return ranges && shifted(ranges, match.index + match[0].indexOf(body))
+}
+
+function svelte_ranges(api: TypeScriptApi, text: string): Array<Range> | undefined {
+	const matches = [...text.matchAll(RAW_BLOCK)]
+	const scripts = matches.map((match) => block_ranges(api, match))
+
+	if (scripts.includes(undefined)) return undefined
+	const blocks = matches.map((match): Range => [match.index, match.index + match[0].length])
+
+	return [...scripts.flatMap((ranges) => ranges ?? []), ...markup_ranges(text, blocks)]
+}
+
+// A comment spanning lines is a line terminator to the program — `return` followed by one returns
+// nothing — so its break is kept, and a one-line comment in its place cannot strip to the same text.
+function mark_for(text: string, start: number, end: number): string {
+	return text.slice(start, end).includes(LINE_BREAK) ? `${MARK}${LINE_BREAK}${MARK}` : MARK
+}
+
+function marked(text: string, ranges: ReadonlyArray<Range>): string {
+	const ordered = ranges.toSorted((left, right) => left[0] - right[0])
+	let result = ''
+	let cursor = 0
+
+	for (const [start, end] of ordered) {
+		if (start < cursor) continue
+		result += `${text.slice(cursor, start)}${mark_for(text, start, end)}`
+		cursor = end
+	}
+
+	return `${result}${text.slice(cursor)}`
+}
+
+// A comment is whitespace to the program, so it becomes one space, and a line it alone occupied goes
+// away. Indentation and lines without a comment are kept byte for byte — a blank line in a template
+// literal is data.
+function normalized_line(line: string): Array<string> {
+	if (!line.includes(MARK)) return [line]
+	const indentation = line.slice(0, line.length - line.trimStart().length)
+	const words = line
+		.split(MARK)
+		.map((part) => part.trim())
+		.filter((part) => part !== '')
+
+	return words.length === 0 ? [] : [`${indentation}${words.join(SEPARATOR)}`]
+}
+
+function without(text: string, ranges: ReadonlyArray<Range>): string {
+	return marked(text, ranges)
+		.split(LINE_BREAK)
+		.flatMap((line) => normalized_line(line))
+		.join(LINE_BREAK)
+}
+
+function strip(api: TypeScriptApi, text: string, is_svelte: boolean): string | undefined {
+	const ranges = is_svelte ? svelte_ranges(api, text) : script_ranges(api, text)
+
+	return (
+		ranges &&
+		without(
+			text,
+			ranges.filter((range) => !is_directive(text, range)),
+		)
+	)
+}
+
+const comment_ranges = { strip }
+
+export { comment_ranges }
+export type { TypeScriptApi }

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

@@ -17,6 +17,7 @@ import { run_ship_review } from '#scripts/run/ship/run-ship-review'
 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_level, type ReviewLevel } from './review-level'
@@ -112,13 +113,15 @@ function kept_note(taken_at: string): string {
 // `change_base`, and `change_base` is recomputed on every invocation — so without the commit it was
 // measured against, round 2 cannot tell a fix from a base that moved under it, and reports the
 // difference between two incomparable sets as round 1's fixes.
+// **Answers whether it wrote**, because the comment-free code record is taken only at that moment: a
+// code record retaken over a kept snapshot would describe the fixed tree, the exact retake above.
 function record_round_one(
 	round: number,
 	tree: Record<string, string>,
 	base: string | undefined,
 	target?: string,
-): void {
-	if (round !== FIRST_ROUND) return
+): boolean {
+	if (round !== FIRST_ROUND) return false
 
 	try {
 		const recorded = review_stamps.round_one_stamp.read(target)
@@ -126,12 +129,15 @@ function record_round_one(
 		if (recorded !== undefined) {
 			console.error(kept_note(recorded.taken_at))
 
-			return
+			return false
 		}
 
 		review_stamps.round_one_stamp.write(tree, target, base)
+
+		return true
 	} catch {
 		/* no record widens the next round rather than narrowing it */
+		return false
 	}
 }
 
@@ -308,6 +314,17 @@ async function read_change(): Promise<ChangeReading> {
 	return { base, commit, paths, tree }
 }
 
+async function record_review(
+	round: number,
+	tree: Record<string, string>,
+	commit: string | undefined,
+): Promise<void> {
+	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)
+}
+
 async function run_review(round: number, reading: ChangeReading): Promise<number> {
 	const { base, commit, paths, tree } = reading
 	const refusal = scoped_green.refusal_for(tree, commit)
@@ -318,8 +335,7 @@ 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 }))
-	record_round_one(round, tree, commit)
-	record_briefed(round, tree, commit)
+	await record_review(round, tree, commit)
 
 	return 0
 }
@@ -343,6 +359,7 @@ const review_brief_cli = {
 	format_reason,
 	KEPT_NOTE_PREFIX,
 	parse_round,
+	record_review,
 	record_round_one,
 	report_error,
 	run,

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

@@ -0,0 +1,119 @@
+import { readFileSync } from 'node:fs'
+import { createRequire } from 'node:module'
+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 { comment_ranges, type TypeScriptApi } from './comment-ranges'
+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
+// 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.
+//
+// **`.claude/` is outside it**: the decision on joshuafolkken/kit#3787 left `.claude/**` reviewed in
+// full, comments included.
+//
+// **TypeScript is resolved from the project, and its absence records nothing.** It is an optional peer
+// of this package, and a missing map is a comment-only arm that never fires — a round run, never one
+// skipped.
+
+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)
+}
+
+function is_source(relative: string): boolean {
+	if (relative.startsWith(EXCLUDED_PREFIX)) return false
+
+	return is_svelte(relative) || SCRIPT_EXTENSIONS.some((extension) => relative.endsWith(extension))
+}
+
+function load_typescript(root: string): TypeScriptApi | undefined {
+	try {
+		return createRequire(path.join(root, PACKAGE_JSON))(TYPESCRIPT_MODULE) as TypeScriptApi
+	} catch {
+		return undefined
+	}
+}
+
+function code_digest(api: TypeScriptApi, root: string, relative: string): string | undefined {
+	try {
+		const code = comment_ranges.strip(
+			api,
+			readFileSync(path.join(root, relative), 'utf8'),
+			is_svelte(relative),
+		)
+
+		return code === undefined ? undefined : stamp_file.digest(code)
+	} 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(
+	root: string,
+	paths: ReadonlyArray<string>,
+	api: TypeScriptApi | undefined = load_typescript(root),
+): Record<string, string> {
+	if (api === undefined) return {}
+	const entries = paths
+		.filter((relative) => is_source(relative))
+		.flatMap((relative) => {
+			const digest = code_digest(api, root, relative)
+
+			return digest === undefined ? [] : [[relative, digest] as const]
+		})
+
+	return Object.fromEntries(entries)
+}
+
+async function read(paths: ReadonlyArray<string>, root?: string): Promise<Record<string, string>> {
+	return tree_of(root ?? (await git_command.repository_root()), paths)
+}
+
+// Written only in the same brief that wrote the round-1 snapshot, so the two describe one moment. A
+// failure removes any earlier record rather than leaving one from another moment beside the new
+// snapshot.
+async function record(
+	paths: ReadonlyArray<string>,
+	base: string | undefined,
+	target?: string,
+	root?: string,
+): Promise<void> {
+	try {
+		review_stamps.round_one_code_stamp.write(await read(paths, root), target, base)
+	} catch {
+		review_stamps.clear_round_one_code(target)
+	}
+}
+
+// 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.
+function comment_only(
+	snapshot: FileMapStamp | undefined,
+	tree: Record<string, string>,
+	base: string | undefined,
+): ReadonlyArray<string> {
+	if (snapshot === undefined || base === undefined || snapshot.base !== base) return []
+
+	return Object.keys(snapshot.files).filter(
+		(relative) => snapshot.files[relative] === tree[relative],
+	)
+}
+
+const review_code_tree = { comment_only, read, record, tree_of }
+
+export { review_code_tree }

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

@@ -2,6 +2,7 @@
 import { fileURLToPath } from 'node:url'
 import { change_base } from '#scripts/git/change-base'
 import { path_decision } from '#scripts/josh/path-decision'
+import { review_code_tree } from './review-code-tree'
 import { review_round2 } from './review-round2'
 import { review_stamps } from './review-stamps'
 import { review_tree } from './review-tree'
@@ -44,6 +45,14 @@ function parse_options(argv: ReadonlyArray<string>): Options | undefined {
 	}
 }
 
+// Only the paths the code record covers are re-read, so a run without one parses nothing.
+async function read_comment_only(base: string | undefined): Promise<ReadonlyArray<string>> {
+	const snapshot = review_stamps.round_one_code_stamp.read()
+	const tree = await review_code_tree.read(Object.keys(snapshot?.files ?? {}))
+
+	return review_code_tree.comment_only(snapshot, tree, base)
+}
+
 async function run(argv: ReadonlyArray<string>): Promise<number> {
 	const options = parse_options(argv)
 
@@ -53,11 +62,13 @@ async function run(argv: ReadonlyArray<string>): Promise<number> {
 		return FAILURE_EXIT_CODE
 	}
 
+	// The commit the tree below is a diff against, so the snapshot can be refused when it was taken
+	// against a different one — and the resolved commit rather than `git_command.change_base`, whose
+	// fallback is a ref name that moves and would compare equal to itself.
+	const base = await change_base.resolved()
 	const { verdict, reason } = review_round2.decide({
-		// The commit the tree below is a diff against, so the snapshot can be refused when it was taken
-		// against a different one — and the resolved commit rather than `git_command.change_base`, whose
-		// fallback is a ref name that moves and would compare equal to itself.
-		base: await change_base.resolved(),
+		base,
+		comment_only: await read_comment_only(base),
 		is_round_one_closed: options.is_round_one_closed,
 		snapshot: review_stamps.round_one_stamp.read(),
 		// No paths argument: `read_changed_tree` reads them itself, from the one definition of
@@ -76,7 +87,7 @@ async function main(argv: ReadonlyArray<string>): Promise<void> {
 	process.exitCode = await run(argv)
 }
 
-const review_round2_cli = { CLOSED_FLAG, parse_options, run }
+const review_round2_cli = { CLOSED_FLAG, parse_options, read_comment_only, run }
 
 if (process.argv[1] === fileURLToPath(import.meta.url)) await main(process.argv.slice(ARGV_OFFSET))