@joshuafolkken/kit 1.1514.0 → 1.2114.0

package/scripts/lint/lint-parallel.ts

@@ -1,6 +1,5 @@
-#!/usr/bin/env tsx
-import { fileURLToPath } from 'node:url'
 import { project_checks } from '#scripts/gate/project-checks'
+import { changed_file_scope } from '#scripts/git/changed-file-scope'
 import {
 	ESLINT_CACHE_FILE,
 	ESLINT_CACHE_FLAGS,
@@ -13,7 +12,10 @@ import {
 	type BufferedProcessResult,
 } from '#scripts/lib/buffered-process'
 import { SKIP_MARKER } from '#scripts/test/skip-marker'
-import { cross_file_recheck, type CrossFileRecheckOptions } from './cross-file-recheck'
+import { time_format } from '#scripts/time-runtime/time-format'
+import { eslint_cache_dependencies } from './eslint-cache-dependencies'
+import { eslint_daemon } from './eslint-daemon'
+import { lint_gate_scope } from './lint-gate-scope'
 
 // This — not the `lint:eslint` map entry — is the eslint invocation `josh gate` reaches, so the
 // cache flags come from the same constant the ignore rules are asserted against.
@@ -21,34 +23,58 @@ import { cross_file_recheck, type CrossFileRecheckOptions } from './cross-file-r
 // moves, with every test still green.
 const WHOLE_TREE = '.'
 const ESLINT_ARGS = ['exec', 'eslint', WHOLE_TREE, ...ESLINT_CACHE_FLAGS] as const
-const WHOLE_TREE_RECHECK: CrossFileRecheckOptions = {
-	cache_file: ESLINT_CACHE_FILE,
-	patterns: [WHOLE_TREE],
-}
 
 // Prettier's cache stays this checkout's own, never shared through `lane_cache_run` as eslint's is:
 // its entries do not survive a move (`josh-command-types.ts` → `GATE_CACHE_SPECS`).
 const PRETTIER_ARGS = ['exec', 'prettier', '--check', WHOLE_TREE, ...PRETTIER_CACHE_FLAGS] as const
 
-// What one eslint run is made of: the child's arguments, and what re-reading a cached cross-file report
-// (`cross-file-recheck.ts`) needs to ask the same question again — the cache file and the targets.
+// What one eslint run is made of: the child's arguments and the cache file they name.
 interface EslintRun {
 	args: ReadonlyArray<string>
-	recheck: CrossFileRecheckOptions
+	cache_file: string
+	warm_daemon: boolean
+}
+
+// Whether eslint may go through the checkout's warm daemon (`eslint-daemon.ts`). `josh lint:related`
+// asks for it; the gate's own lint does not, so its whole-tree run stays one cold process of its own.
+interface LintRunOptions {
+	warm_daemon: boolean
+}
+
+const COLD_RUN: LintRunOptions = { warm_daemon: false }
+
+interface LintPair {
+	prettier: BufferedProcessResult
+	eslint: BufferedProcessResult
 }
 
-// The finished report is re-read before it is returned, inside the lane's cache sharing, because
-// the re-reading uses that same cache file.
+// The warm daemon when asked for and reachable, else the cold `pnpm exec eslint` it falls back to.
+async function run_eslint_process(eslint: EslintRun): Promise<BufferedProcessResult> {
+	if (eslint.warm_daemon) return await eslint_daemon.run_or_cold(eslint.args)
+
+	return await buffered_process.run_buffered_process(eslint.args)
+}
+
+// The run sits inside the lane's cache sharing, between dropping the entries whose imports changed
+// and recording what the fresh ones read (`eslint-cache-dependencies.ts`).
 async function run_eslint(eslint: EslintRun): Promise<BufferedProcessResult> {
-	return await lane_cache_run.run(eslint.recheck.cache_file, async () => {
-		const result = await buffered_process.run_buffered_process(eslint.args)
+	const { cache_file } = eslint
 
-		return await cross_file_recheck.verify(result, eslint.recheck)
+	return await lane_cache_run.run(cache_file, async () => {
+		return await eslint_cache_dependencies.guard(
+			cache_file,
+			async () => await run_eslint_process(eslint),
+		)
 	})
 }
 
+// execa strips the child's final newline, so each output is closed here: unclosed, the next tool's
+// output, or the timing line, would start on the same line as prettier's last one.
 function write_output(result: BufferedProcessResult): void {
-	if (result.output) process.stdout.write(result.output)
+	const { output } = result
+	if (!output) return
+
+	process.stdout.write(output.endsWith('\n') ? output : `${output}\n`)
 }
 
 function skipped(check: string, reason: string): BufferedProcessResult {
@@ -103,40 +129,94 @@ function lint_exit_code(prettier: BufferedProcessResult, eslint: BufferedProcess
 // and through the same basic-project skip, so a narrowed run never reaches a tool the whole-tree
 // run would have skipped. The skip reasons answer nothing for a full
 // project, so the one path serves both profiles.
-//
-// A narrowed run re-reads a cached cross-file report too (`cross-file-recheck.ts`): one change's
-// files can hold both the reported file and the one it reads, and fixing the second leaves the
-// first's cached report standing.
-async function run_lint_checks(
+async function run_lint_pair(
 	prettier_args: ReadonlyArray<string>,
 	eslint_args: ReadonlyArray<string>,
-	recheck: CrossFileRecheckOptions,
-): Promise<number> {
+	cache_file: string,
+	options: LintRunOptions,
+): Promise<LintPair> {
 	const directory = process.cwd()
 	const [prettier, eslint] = await Promise.all([
 		run_prettier(directory, prettier_args),
-		run_checked_eslint(directory, { args: eslint_args, recheck }),
+		run_checked_eslint(directory, { args: eslint_args, cache_file, ...options }),
 	])
 
+	return { prettier, eslint }
+}
+
+function write_lint_pair({ prettier, eslint }: LintPair): number {
 	write_output(with_ran_notice('prettier', prettier, eslint))
 	write_output(with_ran_notice('eslint', eslint, prettier))
 
 	return lint_exit_code(prettier, eslint)
 }
 
+async function run_lint_checks(
+	prettier_args: ReadonlyArray<string>,
+	eslint_args: ReadonlyArray<string>,
+	cache_file: string,
+	options: LintRunOptions = COLD_RUN,
+): Promise<number> {
+	return write_lint_pair(await run_lint_pair(prettier_args, eslint_args, cache_file, options))
+}
+
+// joshuafolkken/kit#5116: the gate times `lint` as one step, and the two tools run side by side, so
+// the step's seconds name neither tool as the long pole. This line, the gate's lint alone, does.
+function timing_line({ prettier, eslint }: LintPair): string {
+	const prettier_seconds = time_format.format_seconds(prettier.elapsed_ms)
+	const eslint_seconds = time_format.format_seconds(eslint.elapsed_ms)
+
+	return `lint timing — prettier ${prettier_seconds} · eslint ${eslint_seconds}\n`
+}
+
+async function run_timed_lint_checks(
+	prettier_args: ReadonlyArray<string>,
+	eslint_args: ReadonlyArray<string>,
+	cache_file: string,
+): Promise<number> {
+	const pair = await run_lint_pair(prettier_args, eslint_args, cache_file, COLD_RUN)
+	const exit_code = write_lint_pair(pair)
+
+	process.stdout.write(timing_line(pair))
+
+	return exit_code
+}
+
 async function run_lint_parallel_checks(): Promise<number> {
-	return await run_lint_checks(PRETTIER_ARGS, ESLINT_ARGS, WHOLE_TREE_RECHECK)
+	return await run_lint_checks(PRETTIER_ARGS, ESLINT_ARGS, ESLINT_CACHE_FILE)
 }
 
-// `process.exitCode` rather than `process.exit()`: both reports are buffered and written here in
-// one go, and `process.exit()` truncates a piped stdout at its buffer size — which is exactly how
-// this command is read when `josh gate` runs it as one of four concurrent checks. Setting the code
-// lets the writes drain and the process end on its own, which it can, since both children have
-// already exited by here.
-if (process.argv[1] === fileURLToPath(import.meta.url)) {
-	process.exitCode = await run_lint_parallel_checks()
+// `josh lint --changed`, the gate's lint: the branch's changed files on the gate's own caches, or the
+// whole tree where `lint-gate-scope.ts` cannot narrow. The line naming the decision is printed first,
+// so a narrowed run is never read as a whole one.
+async function run_changed_lint_checks(): Promise<number> {
+	const root = await changed_file_scope.repository_root_or_cwd()
+	const files = await changed_file_scope.read_changed_files(root)
+	const scope = lint_gate_scope.resolve_gate_scope(files, root, process.env)
+
+	process.stdout.write(`${lint_gate_scope.describe_scope(scope, root)}\n`)
+
+	if (scope.mode === 'all') {
+		return await run_timed_lint_checks(PRETTIER_ARGS, ESLINT_ARGS, ESLINT_CACHE_FILE)
+	}
+
+	const narrowed = lint_gate_scope.narrowed_run(scope.files)
+
+	return await run_timed_lint_checks(narrowed.prettier, narrowed.eslint, narrowed.eslint_cache_file)
 }
 
-const lint_parallel = { run_lint_checks, run_lint_parallel_checks }
+async function run_lint_command(command_arguments: ReadonlyArray<string>): Promise<number> {
+	if (command_arguments.includes(lint_gate_scope.CHANGED_FLAG)) {
+		return await run_changed_lint_checks()
+	}
+
+	return await run_lint_parallel_checks()
+}
+
+const lint_parallel = {
+	run_lint_checks,
+	run_lint_command,
+	run_lint_parallel_checks,
+}
 
 export { ESLINT_ARGS, lint_parallel, PRETTIER_ARGS }

package/scripts/lint/lint-related-scope.ts

@@ -10,15 +10,12 @@ import {
 	ESLINT_RELATED_CACHE_FLAGS,
 	PRETTIER_RELATED_CACHE_FLAGS,
 } from '#scripts/josh/josh-command-types'
-import type { CrossFileRecheckOptions } from './cross-file-recheck'
 
 // `josh lint` reads the whole repository on every call, and an implementation loop calls it after
 // every few edits — re-reading files the change never touched.
 //
-// **This narrowing is added in front of the whole check, never in place of it.** `josh gate` still
-// runs `josh lint` over everything before the commit: a formatting rule can be broken by a file the
-// change did not name (a shared config, a generated snapshot), and only the whole-tree run sees
-// that. What the narrowing replaces is the repeat calls in between.
+// The gate narrows its own lint the same way, with its own caches and a whole-tree fallback for a
+// changed toolchain or lint configuration (`lint-gate-scope.ts`), and CI lints the whole tree.
 //
 // The decision this file makes is which extensions the two linters read, and how each of them is
 // asked about a file list instead of a directory. Everything it shares with `josh test:related` —
@@ -95,41 +92,49 @@ function describe_scope(scope: ChangedFileScope, root: string): string {
 	return changed_file_scope.describe_scope(scope, root, VOCABULARY)
 }
 
+// Where a narrowed run keeps its caches. `josh lint:related` keeps its own and the gate its own, for
+// the reason `eslint_arguments` gives below; a narrowed gate run on the gate's caches loses none of
+// the whole-tree entries, since a file it does not visit is not pruned (`josh-command-types.ts`).
+interface LintCaches {
+	eslint_file: string
+	eslint_flags: ReadonlyArray<string>
+	prettier_flags: ReadonlyArray<string>
+}
+
+const RELATED_CACHES: LintCaches = {
+	eslint_file: ESLINT_RELATED_CACHE_FILE,
+	eslint_flags: ESLINT_RELATED_CACHE_FLAGS,
+	prettier_flags: PRETTIER_RELATED_CACHE_FLAGS,
+}
+
 // The scoped run's own cache file, for the reason eslint's below gives: prettier too rewrites its
 // cache file whole, so a narrowed run sharing the gate's would discard entries a concurrent gate wrote.
-function prettier_arguments(files: ReadonlyArray<string>): ReadonlyArray<string> {
-	return [...PRETTIER_ARGS, ...files, ...PRETTIER_RELATED_CACHE_FLAGS]
+function prettier_arguments(
+	files: ReadonlyArray<string>,
+	caches: LintCaches = RELATED_CACHES,
+): ReadonlyArray<string> {
+	return [...PRETTIER_ARGS, ...files, ...caches.prettier_flags]
 }
 
 // The cache file is this command's own rather than the gate's, because the two run at the same time.
-// `josh gate` lints the whole tree beside the review while an
+// `josh gate` lints beside the review while an
 // implementation loop calls this command between edits, and each eslint run rewrites its cache file
 // whole from the copy it loaded at start-up — so on one file the run that finished last would
 // discard the other's entries, and a narrowed run finishing during a whole-tree run would roll the
 // cache back to its pre-gate state. Sharing would let a narrowed run warm the gate's cache only for
 // pruning, which says nothing about two writers. It is the same judgement the edit hook's own cache
 // file makes.
-//
-// **What is narrowed is still only the target list, never the gate.** `josh gate` runs `josh lint`
-// over the whole tree before any commit; this file decides which files a repeat call reads.
-function eslint_arguments(files: ReadonlyArray<string>): ReadonlyArray<string> {
-	return [...ESLINT_ARGS, ...files, ...ESLINT_RELATED_CACHE_FLAGS, ...ESLINT_SCOPED_FLAGS]
-}
-
-// What re-reading a cached cross-file report (`cross-file-recheck.ts`) needs to ask the narrowed run's question
-// again: the same targets, the same cache file, and the Node API's spelling of `--no-warn-ignored`.
-function cross_file_recheck_options(files: ReadonlyArray<string>): CrossFileRecheckOptions {
-	return {
-		cache_file: ESLINT_RELATED_CACHE_FILE,
-		patterns: files,
-		eslint_options: { warnIgnored: false },
-	}
+function eslint_arguments(
+	files: ReadonlyArray<string>,
+	caches: LintCaches = RELATED_CACHES,
+): ReadonlyArray<string> {
+	return [...ESLINT_ARGS, ...files, ...caches.eslint_flags, ...ESLINT_SCOPED_FLAGS]
 }
 
 const lint_related_scope = {
 	COMMAND_LABEL,
-	cross_file_recheck_options,
 	NOTHING_LINTABLE_REASON,
+	RELATED_CACHES,
 	describe_scope,
 	eslint_arguments,
 	is_lintable,
@@ -137,4 +142,5 @@ const lint_related_scope = {
 	scope_inputs,
 }
 
+export type { LintCaches }
 export { lint_related_scope }

package/scripts/lint/lint-related.ts

@@ -1,10 +1,19 @@
 #!/usr/bin/env tsx
 import { existsSync } from 'node:fs'
+import path from 'node:path'
 import { fileURLToPath } from 'node:url'
-import { document_byte_check } from '#scripts/document/document-byte-check'
+import { document_checks } from '#scripts/document/document-checks'
+import { unused_members_check } from '#scripts/exports/unused-members-check'
+import { gate_labels } from '#scripts/gate/gate-labels'
+import type { GateTree } from '#scripts/gate/gate-tree'
+import { metrics_totals } from '#scripts/gate/metrics-totals'
 import { scoped_green } from '#scripts/gate/scoped-green'
+import { since_green } from '#scripts/gate/since-green'
+import { structural_checks } from '#scripts/gate/structural-checks'
+import { verification_tail } from '#scripts/gate/verification-tail'
 import { changed_file_scope, type ChangedFileScope } from '#scripts/git/changed-file-scope'
 import { review_stamps } from '#scripts/review/review-stamps'
+import { split_early_notice } from '#scripts/split/split-early-notice'
 import { lint_parallel } from './lint-parallel'
 import { lint_related_scope } from './lint-related-scope'
 
@@ -36,48 +45,145 @@ async function lint_exit_code(scope: ChangedFileScope): Promise<number> {
 	return await lint_parallel.run_lint_checks(
 		lint_related_scope.prettier_arguments(scope.files),
 		lint_related_scope.eslint_arguments(scope.files),
-		lint_related_scope.cross_file_recheck_options(scope.files),
+		lint_related_scope.RELATED_CACHES.eslint_file,
+		{ warm_daemon: true },
 	)
 }
 
-// The byte check over the same scope the lint just ran: the resolved file list when narrowed, and
-// the whole budget when lint fell back to the whole tree — so the byte check is a superset in the
-// fallback exactly as lint is, never an empty list that would pass silently.
-function byte_check_exit_code(scope: ChangedFileScope, root: string): number {
-	if (scope.mode === 'all') return document_byte_check.check_all(root)
+// The document checks over the same scope the lint just ran: the resolved file list when narrowed,
+// and the whole budget when lint fell back to the whole tree — so each is a superset in the
+// fallback exactly as lint is, never an empty list that would pass silently. Both run, so one edit
+// reports its byte ceiling and its ratchets (`document-ratchet-check.ts`) in one pass.
+function document_check_exit_code(scope: ChangedFileScope, root: string): number {
+	if (scope.mode === 'all') return document_checks.check_all(root)
 
-	return document_byte_check.check_files(root, scope.files)
+	return document_checks.check_files(root, scope.files)
 }
 
-// The lint result folded together with the fast byte-ceiling check: the
-// same check the gate's `document-byte-budget.test.ts` runs, brought forward to this between-edits
-// path so a mandated documentation update over its ceiling surfaces in seconds. It reads no change
+interface LintOutcome {
+	stage: string
+	exit_code: number
+}
+
+const UNMOVED: LintOutcome = { stage: 'unmoved', exit_code: 0 }
+
+function is_failed(outcome: LintOutcome): boolean {
+	return outcome.exit_code !== 0
+}
+
+// The lint result folded together with the fast document checks: the
+// same checks the gate's `document-byte-budget.test.ts`, `command-reference.test.ts` and
+// `issue-citation-budget.test.ts` run, brought forward to this between-edits path so a mandated
+// documentation update over a ceiling surfaces in seconds. It reads no change
 // of its own — it takes the files this run already resolved, so the git contract is the lint
-// command's alone. A lint failure is reported as-is; only a green lint runs the byte check, so the
+// command's alone. A lint failure is reported as-is; only a green lint runs the document checks, so the
 // two never race to the exit code, and a green tree here is green on both — which is what the record
-// below then vouches for.
-async function scoped_exit_code(scope: ChangedFileScope, root: string): Promise<number> {
-	const lint_exit = await lint_exit_code(scope)
-	if (lint_exit !== 0) return lint_exit
+// below then vouches for. The structural checks (`structural-checks.ts`) run beside the lint rather
+// than after it, so their whole-program scan costs no wall clock the lint has not already spent.
+//
+// The gate's `exports` check comes after them on the same terms: a namespace member nothing reads is
+// reported here for the namespaces the changed files declare or import directly
+// (joshuafolkken/kit#4645, joshuafolkken/kit#4649), rather than at ship's pre-detach gate. The
+// fallback scans the whole program, a superset as the lint's is.
+//
+// The outcome names the stage that failed first, which the verdict line names (joshuafolkken/kit#5162).
+async function scoped_outcome(scope: ChangedFileScope, root: string): Promise<LintOutcome> {
+	const structural = structural_checks.run_structural(scope, root)
+	const lint = { stage: 'lint', exit_code: await lint_exit_code(scope) }
+	const failed = [lint, { stage: 'structural', exit_code: await structural }].find((outcome) =>
+		is_failed(outcome),
+	)
 
-	return byte_check_exit_code(scope, root)
+	if (failed !== undefined) return failed
+	// The linters' buffered output ends without a newline; keep the checks' own lines apart from it.
+	process.stdout.write('\n')
+	const documents = { stage: 'documents', exit_code: document_check_exit_code(scope, root) }
+	if (is_failed(documents)) return documents
+
+	const files = scope.mode === 'all' ? undefined : scope.files
+
+	return {
+		stage: 'unused members',
+		exit_code: await unused_members_check.run_unused_members(root, files),
+	}
 }
 
-// The narrowing line is printed before either child starts, so a scoped run is never read as a
-// whole one, and a fallback says which of the two it was rather than looking like a narrow run
-// that found nothing.
-//
-// **A green run leaves a record of the tree it was green on**, so
-// `josh review:brief` can tell a tree this check has read from one it has not. What the record means,
-// and the three states in which it is withheld, are `scoped-green.ts`.
-async function run_related_lint(command_arguments: ReadonlyArray<string>): Promise<number> {
-	const root = await changed_file_scope.repository_root_or_cwd()
-	const scope = await changed_file_scope.resolve_command_scope({
+// **A bare run reads only what moved since its last green run** (`since-green.ts`), against the tree
+// its green record is read from, so one run reads the gate tree once (joshuafolkken/kit#4655).
+// Explicit file arguments read no tree, so they never consult the record.
+async function read_since_green(
+	before: GateTree | undefined,
+): Promise<ReadonlyArray<string> | undefined> {
+	if (before === undefined) return undefined
+
+	return await since_green.read_moved(
+		review_stamps.lint_related_stamp,
+		gate_labels.LINT_LABEL,
+		undefined,
+		before,
+	)
+}
+
+// Narrowed to what moved while a lintable file is among it; otherwise the whole branch change, as before.
+function since_green_scope(
+	root: string,
+	moved: ReadonlyArray<string> | undefined,
+): ChangedFileScope | undefined {
+	if (moved === undefined) return undefined
+
+	const inputs = lint_related_scope.scope_inputs(existsSync)
+	const files = moved.map((file) => path.join(root, file))
+
+	if (changed_file_scope.select_files(files, inputs).length === 0) return undefined
+
+	process.stdout.write(`${since_green.describe(lint_related_scope.COMMAND_LABEL, moved)}\n`)
+
+	return changed_file_scope.resolve_scope(files, inputs)
+}
+
+async function resolve_lint_scope(
+	command_arguments: ReadonlyArray<string>,
+	root: string,
+	moved: ReadonlyArray<string> | undefined,
+): Promise<ChangedFileScope> {
+	const since = since_green_scope(root, moved)
+
+	if (since !== undefined) return since
+
+	return await changed_file_scope.resolve_command_scope({
 		command_arguments,
 		root,
 		inputs: lint_related_scope.scope_inputs(existsSync),
 	})
+}
+
+// In kit, a metrics total grown past the merge-base is reported after the lint and changes no exit
+// code (`metrics-totals.ts`). The totals are a whole-repository pass, so only a green bare run pays
+// for it: a red lint is edited again anyway, and a run narrowed by file arguments is a spot check.
+async function outcome_with_notice(
+	command_arguments: ReadonlyArray<string>,
+	scope: ChangedFileScope,
+	root: string,
+): Promise<LintOutcome> {
+	const outcome = await scoped_outcome(scope, root)
+	if (is_failed(outcome) || command_arguments.length > 0) return outcome
+
+	const notice = await metrics_totals.growth_notice(root)
 
+	// On a line of its own: a linter's buffered output need not end with a newline.
+	if (notice !== undefined) process.stdout.write(`\n${notice}\n`)
+
+	return outcome
+}
+
+// The narrowing line is printed before either child starts, so a scoped run is never read as a
+// whole one, and a fallback says which of the two it was rather than looking like a narrow run
+// that found nothing.
+function report_scope(
+	command_arguments: ReadonlyArray<string>,
+	scope: ChangedFileScope,
+	root: string,
+): void {
 	changed_file_scope.report_unusable_arguments(
 		command_arguments,
 		scope,
@@ -85,17 +191,64 @@ async function run_related_lint(command_arguments: ReadonlyArray<string>): Promi
 	)
 	report_ignored_flags(command_arguments)
 	process.stdout.write(`${lint_related_scope.describe_scope(scope, root)}\n`)
+}
 
+// **Nothing moved since the last green run lints nothing** (joshuafolkken/kit#4593), as
+// `josh test:related` runs no test.
+function report_unmoved(): LintOutcome {
+	process.stdout.write(
+		`${lint_related_scope.COMMAND_LABEL}: ${since_green.UNMOVED_REASON} — linting nothing.\n`,
+	)
+
+	return UNMOVED
+}
+
+async function checked_outcome(
+	command_arguments: ReadonlyArray<string>,
+	root: string,
+	moved: ReadonlyArray<string> | undefined,
+): Promise<LintOutcome> {
+	if (moved?.length === 0) return report_unmoved()
+
+	const scope = await resolve_lint_scope(command_arguments, root, moved)
+
+	report_scope(command_arguments, scope, root)
+
+	return await outcome_with_notice(command_arguments, scope, root)
+}
+
+// The run's last line names the stage that failed, or says it passed; the console is the only copy of
+// the output, so there is no log notice (`verification-tail.ts`).
+function report_verdict(outcome: LintOutcome): void {
+	const failed = is_failed(outcome) ? [outcome.stage] : []
+	const verdict = verification_tail.format_verdict(lint_related_scope.COMMAND_LABEL, failed)
+
+	process.stdout.write(`\n${verification_tail.format_tail({ failures: '', verdict })}`)
+}
+
+// **A green run leaves a record of the tree it was green on**, so
+// `josh review:brief` can tell a tree this check has read from one it has not. What the record means,
+// and the three states in which it is withheld, are `scoped-green.ts`. An unmoved run records too, as
+// `josh test:related`'s does: a main sync can move the base while moving no path, and a record left on
+// the old base would refuse `josh gate` while every re-run kept linting nothing.
+async function run_related_lint(command_arguments: ReadonlyArray<string>): Promise<number> {
+	const root = await changed_file_scope.repository_root_or_cwd()
 	const before = await scoped_green.read_before(command_arguments)
-	const exit_code = await scoped_exit_code(scope, root)
+	const moved = await read_since_green(before)
+	const outcome = await checked_outcome(command_arguments, root, moved)
 
-	await scoped_green.record_if_green(review_stamps.lint_related_stamp, { before, exit_code })
+	report_verdict(outcome)
+	await scoped_green.record_if_green(review_stamps.lint_related_stamp, {
+		before,
+		exit_code: outcome.exit_code,
+	})
 
-	return exit_code
+	return outcome.exit_code
 }
 
 if (process.argv[1] === fileURLToPath(import.meta.url)) {
 	process.exitCode = await run_related_lint(process.argv.slice(changed_file_scope.ARGV_START))
+	await split_early_notice.surface()
 }
 
 const lint_related = { run_related_lint }