@joshuafolkken/kit 1.2116.0 → 1.3000.0

package/scripts/review/prose-stale-scan.ts

@@ -10,13 +10,22 @@ import { review_readers_scan } from './review-readers-scan'
 // constant on a code file's removed line (the declaration reading is `review-readers-scan.ts`'s), a `josh x:y` command
 // on any removed line, and a `.md` file's `#` heading. **A word the diff still writes is not removed**: an
 // identifier or command any added line carries, a heading an added `.md` line still titles, and a command
-// the registry still holds.
+// the registry still holds, and a name a changed code file still declares in the working tree, an
+// unchanged line included (joshuafolkken/kit#6077). **A deleted file names only what another module
+// could import** (joshuafolkken/kit#6130). **A renamed declaration is removed unless an added line declares it again**
+// (joshuafolkken/kit#5540): a hunk whose removed lines declare a name its added lines do not, beside
+// one they declare anew, renamed it, and the old name an added comment or a local still carries as a
+// token is stale all the same. **A test file names nothing**: its declarations are its own
+// (joshuafolkken/kit#6737). **A plain name counts only where prose writes it as code** — in backticks, as
+// a call or a member, or with an identifier's `_`, digit or camelCase — so an English word that spells it
+// is not stale (joshuafolkken/kit#6737).
 
 type TermKind = 'name' | 'constant' | 'command' | 'heading'
 
 interface Term {
 	kind: TermKind
 	word: string
+	renamed_to?: string
 }
 
 interface Reference {
@@ -31,7 +40,14 @@ interface Report {
 }
 
 const CODE_FILE = /\.(?:ts|js)$/u
+const TEST_FILE = /\.test\.(?:ts|js)$/u
+// A word no English prose spells: an `_`, a digit, or a lower-to-upper camelCase step.
+const IDENTIFIER_SHAPE = /[_\d]|[a-z][A-Z]/u
+const REGEXP_SPECIAL = /[$()*+.?[\\\]^{|}]/gu
+const BACKTICK = '`'
+const SPAN_PARITY = 2
 const MARKDOWN_EXTENSION = '.md'
+const MARKDOWN_FILE = /\.md$/u
 const COMMAND = /\bjosh\s+(?<command>[a-z][\w-]*:[\w:-]+)/gu
 const UPPER_CASE = /^[A-Z][A-Z\d_]*[A-Z\d]$/u
 const HEADING = /^#{1,6} (?<text>.+)$/u
@@ -47,8 +63,16 @@ function to_terms(kind: TermKind, words: ReadonlyArray<string>): Array<Term> {
 	return words.map((word) => ({ kind, word }))
 }
 
-function code_terms(source: string): Array<Term> {
-	const declared = review_readers_scan.declarations(source).map((entry) => entry.name)
+// A deleted file's local names no other file could name are dropped (joshuafolkken/kit#6130): only
+// what it exported is searched.
+function declared_names(source: string, is_deleted: boolean): Array<string> {
+	if (is_deleted) return review_readers_scan.reachable_names(source)
+
+	return review_readers_scan.declarations(source).map((entry) => entry.name)
+}
+
+function code_terms(source: string, is_deleted: boolean): Array<Term> {
+	const declared = declared_names(source, is_deleted)
 	const listed = [...review_readers_scan.exported_names(source)]
 	const constants = declared.filter((name) => UPPER_CASE.test(name))
 	const names = [...declared.filter((name) => !UPPER_CASE.test(name)), ...listed]
@@ -70,9 +94,33 @@ function headings(lines: ReadonlyArray<string>): Array<string> {
 	return texts.filter((text): text is string => text !== undefined && text !== '')
 }
 
-function hunk_terms(hunk: Hunk): Array<Term> {
+function declared_in(lines: ReadonlyArray<string>): Array<string> {
+	return review_readers_scan.declarations(lines.join('\n')).map((entry) => entry.name)
+}
+
+// The old names paired, in order, with the names the same hunk's added lines declare in their place.
+function renamed_terms(hunk: Hunk): Array<Term> {
+	const before = declared_in(hunk.old_lines)
+	const after = declared_in(hunk.new_lines ?? [])
+	const gone = before.filter((name) => !after.includes(name))
+	const fresh = after.filter((name) => !before.includes(name))
+
+	return gone.flatMap((word, index): Array<Term> => {
+		const renamed_to = fresh[index]
+
+		if (renamed_to === undefined) return []
+
+		return [{ kind: UPPER_CASE.test(word) ? 'constant' : 'name', word, renamed_to }]
+	})
+}
+
+function hunk_terms(hunk: Hunk, deleted: ReadonlySet<string>): Array<Term> {
 	const lines = hunk.old_lines
-	const code = CODE_FILE.test(hunk.file) ? code_terms(lines.join('\n')) : []
+	const is_code = CODE_FILE.test(hunk.file) && !TEST_FILE.test(hunk.file)
+	const source = lines.join('\n')
+	const code = is_code
+		? [...code_terms(source, deleted.has(hunk.file)), ...renamed_terms(hunk)]
+		: []
 	const titled = hunk.file.endsWith(MARKDOWN_EXTENSION) ? to_terms('heading', headings(lines)) : []
 
 	return [...code, ...command_terms(lines), ...titled]
@@ -81,31 +129,58 @@ function hunk_terms(hunk: Hunk): Array<Term> {
 interface Kept {
 	tokens: ReadonlySet<string>
 	titles: ReadonlySet<string>
+	declared: ReadonlySet<string>
 	registered: ReadonlySet<string>
 }
 
+function added_lines(hunks: ReadonlyArray<Hunk>, extension: RegExp): Array<string> {
+	return hunks.filter((hunk) => extension.test(hunk.file)).flatMap((hunk) => hunk.new_lines ?? [])
+}
+
 function kept_of(hunks: ReadonlyArray<Hunk>, registered: ReadonlySet<string>): Kept {
 	const added = hunks.flatMap((hunk) => hunk.new_lines ?? [])
-	const markdown = hunks.filter((hunk) => hunk.file.endsWith(MARKDOWN_EXTENSION))
-	const titles = headings(markdown.flatMap((hunk) => hunk.new_lines ?? []))
+	const titles = headings(added_lines(hunks, MARKDOWN_FILE))
+	const declared = declared_in(added_lines(hunks, CODE_FILE))
 	const tokens = added.flatMap((line) => [...line.matchAll(TOKEN)].map((match) => match[0]))
 
-	return { tokens: new Set(tokens), titles: new Set(titles), registered }
+	return {
+		tokens: new Set(tokens),
+		titles: new Set(titles),
+		declared: new Set(declared),
+		registered,
+	}
 }
 
 function is_removed(term: Term, kept: Kept): boolean {
+	if (term.renamed_to !== undefined) return !kept.declared.has(term.word)
 	if (term.kind === 'heading') return !kept.titles.has(term.word)
 	if (term.kind === 'command' && kept.registered.has(term.word)) return false
 
 	return !kept.tokens.has(term.word)
 }
 
+// The working tree's answer for the change's code files: `surviving` the names they still declare, on
+// an unchanged line too; `deleted` the files the change removed.
+interface Tree {
+	surviving: ReadonlySet<string>
+	deleted: ReadonlySet<string>
+}
+
+const EMPTY_TREE: Tree = { surviving: new Set(), deleted: new Set() }
+
 // Each removed word once, in diff order; `registered` is the command registry's names.
-function stale_terms(hunks: ReadonlyArray<Hunk>, registered: ReadonlySet<string>): Array<Term> {
+function stale_terms(
+	hunks: ReadonlyArray<Hunk>,
+	registered: ReadonlySet<string>,
+	tree: Tree = EMPTY_TREE,
+): Array<Term> {
+	const { surviving, deleted } = tree
 	const kept = kept_of(hunks, registered)
-	const unique = new Map(hunks.flatMap((hunk) => hunk_terms(hunk)).map((term) => [term.word, term]))
+	const terms = hunks.flatMap((hunk) => hunk_terms(hunk, deleted))
+	const unique = new Map(terms.map((term) => [term.word, term]))
 
-	return [...unique.values()].filter((term) => is_removed(term, kept))
+	// A name a file still declares is kept, whatever a hunk did to it: renamed, moved or left unchanged.
+	return [...unique.values()].filter((term) => !surviving.has(term.word) && is_removed(term, kept))
 }
 
 // A heading is searched quoted, the way a `→ "Heading"` pointer names it; any other word as a whole word.
@@ -120,14 +195,43 @@ function is_prose(hit: Hit): boolean {
 	return hit.path.endsWith(MARKDOWN_EXTENSION) || COMMENT_LINE.test(hit.excerpt)
 }
 
+function code_spans(excerpt: string): Array<string> {
+	return excerpt.split(BACKTICK).filter((_span, index) => index % SPAN_PARITY === 1)
+}
+
+// The code shapes a plain name takes outside backticks — a fenced block's line included: `x.name`,
+// `name(`, an entry of a braced identifier list `{ a, name }`, and `import name from`. A bare comma
+// list is English (`name, status, and owner`), so the list needs its brace.
+function code_shape(word: string): RegExp {
+	const shapes = [
+		String.raw`\.${word}(?![\w$])`,
+		String.raw`(?<![\w$])${word}\(`,
+		String.raw`\{\s*(?:[\w$]+\s*,\s*)*${word}\s*[,}]`,
+		String.raw`\bimport\s+${word}\s+from\b`,
+	]
+
+	return new RegExp(shapes.join('|'), 'u')
+}
+
+// A plain name is written as code: inside a backtick span, or in one of `code_shape`'s shapes.
+function is_code_use(term: Term, excerpt: string): boolean {
+	if (term.kind !== 'name' || IDENTIFIER_SHAPE.test(term.word)) return true
+
+	const word = term.word.replaceAll(REGEXP_SPECIAL, String.raw`\$&`)
+	const whole = new RegExp(String.raw`(?<![\w$])${word}(?![\w$])`, 'u')
+
+	return code_spans(excerpt).some((span) => whole.test(span)) || code_shape(word).test(excerpt)
+}
+
 function reference_lines(reference: Reference): Array<string> {
-	const { kind, word } = reference.term
+	const { kind, word, renamed_to } = reference.term
+	const label = renamed_to === undefined ? word : `${word} (renamed to ${renamed_to})`
 
-	if (reference.has_failed) return [`search failed: ${kind} ${word}`]
+	if (reference.has_failed) return [`search failed: ${kind} ${label}`]
 
 	return reference.hits
-		.filter((hit) => is_prose(hit))
-		.map((hit) => `${hit.path}:${hit.line} ${kind} ${word}`)
+		.filter((hit) => is_prose(hit) && is_code_use(reference.term, hit.excerpt))
+		.map((hit) => `${hit.path}:${hit.line} ${kind} ${label}`)
 }
 
 function exit_code_of(references: ReadonlyArray<Reference>, lines: ReadonlyArray<string>): number {
@@ -146,7 +250,7 @@ function report(references: ReadonlyArray<Reference>): Report {
 	}
 }
 
-const prose_stale_scan = { FAILED_EXIT, pattern, report, stale_terms }
+const prose_stale_scan = { CODE_FILE, FAILED_EXIT, pattern, report, stale_terms }
 
-export type { Reference, Term }
+export type { Reference, Term, Tree }
 export { prose_stale_scan }

package/scripts/review/removed-tests-check.ts

@@ -28,6 +28,11 @@ import { test_titles } from './test-titles'
 const UNREADABLE_MESSAGE =
 	'Merge refused: the change base could not be resolved, so the tests this change removes could not be listed; re-run once `git merge-base` answers.'
 
+interface TitleChanges {
+	removed: ReadonlyArray<string>
+	added: ReadonlyArray<string>
+}
+
 function titles_in(api: TypeScriptApi, texts: ReadonlyArray<string>): ReadonlyArray<string> {
 	return texts.flatMap((text) => test_titles.titles_of(api, text))
 }
@@ -51,19 +56,37 @@ function tree_texts(root: string, paths: ReadonlyArray<string>): ReadonlyArray<s
 		.map((absolute) => readFileSync(absolute, 'utf8'))
 }
 
-async function read(): Promise<ReadonlyArray<string> | undefined> {
+// The titles the change added, so a draft row can be met by the test that names its criterion
+// (joshuafolkken/kit#5541).
+function added_titles(
+	before: ReadonlyArray<string>,
+	after: ReadonlyArray<string>,
+): ReadonlyArray<string> {
+	const held = new Set(before)
+
+	return after.filter((title) => !held.has(title))
+}
+
+async function changes(): Promise<TitleChanges | undefined> {
 	const base = await change_base.resolved_through_merge()
 
 	if (base === undefined) return undefined
 	const root = await git_command.repository_root()
 	const api = review_code_tree.load_typescript(root)
 
-	if (api === undefined) return []
+	if (api === undefined) return { removed: [], added: [] }
 	const changed = await changed_paths.read_changed_since(base)
 	const paths = changed.filter((relative) => test_declared_logic.is_test_file(relative))
 	const before = titles_in(api, await base_texts(base, paths))
+	const after = titles_in(api, tree_texts(root, paths))
+
+	return { removed: removed_tests.removed(before, after), added: added_titles(before, after) }
+}
+
+async function read(): Promise<ReadonlyArray<string> | undefined> {
+	const found = await changes()
 
-	return removed_tests.removed(before, titles_in(api, tree_texts(root, paths)))
+	return found?.removed
 }
 
 // `josh ship`'s preflight asks the body it is about to deliver, so a missing disposition stops it
@@ -81,6 +104,7 @@ async function refusal(branch_name: string): Promise<string | undefined> {
 	return await body_refusal(await git_gh_command.pr_get_body(branch_name))
 }
 
-const removed_tests_check = { body_refusal, read, refusal, UNREADABLE_MESSAGE }
+const removed_tests_check = { body_refusal, changes, read, refusal, UNREADABLE_MESSAGE }
 
+export type { TitleChanges }
 export { removed_tests_check }

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,