@joshuafolkken/kit 1.1514.0 → 1.2114.0

package/scripts/gh/git-pr-checks.ts

@@ -48,10 +48,10 @@ function get_configured_max_attempts(): number {
 const CHECK_MAX_ATTEMPTS = get_configured_max_attempts()
 const DEFAULT_STABLE_READS = 2
 
-// One authoritative gate poll is enough once `pr_checks_watch` has already seen every check finish:
-// the watch is the first confirmation, so the poll that follows need only agree once. The two reads
-// exist for the pending→settled window a bare poll opens on, and the watch has itself already spanned
-// that window — so waiting a second interval after it merely re-proves what the watch established.
+// One authoritative gate poll is enough once `pr_checks_watch` has returned — every check finished, or
+// its budget ran out on a pending read. The two reads exist for the pending→settled window a bare poll
+// opens on, and a returned watch has either spanned that window or seen its pending side, which the
+// poll's first settled read then closes — so a second interval merely re-proves it (#5080).
 const WATCH_CONFIRMED_STABLE_READS = 1
 
 // **A read that failed is not a verdict.** The loop reads every ten seconds, so a dropped connection,
@@ -314,7 +314,7 @@ async function default_fetch_pr_state(
 }
 
 // **`required_stable_reads` is a parameter, not a constant, so the caller can lower it** — `run_checks`
-// passes `WATCH_CONFIRMED_STABLE_READS` when the watch already confirmed completion. It defaults to
+// passes `WATCH_CONFIRMED_STABLE_READS` when the watch returned. It defaults to
 // `DEFAULT_STABLE_READS`, so every caller that names only the branch is exactly where it was.
 // What a caller is shown of each poll it waits on — `followup` reports the checks to the run's event
 // stream from it (joshuafolkken/kit#3770). It decides nothing: the wait reads the same snapshot.

package/scripts/gh/git-pr-merge-checked.ts

@@ -0,0 +1,80 @@
+import { git_gh_command } from './git-gh-command'
+import { git_pr_checks, type PrStateSnapshot } from './git-pr-checks'
+
+// **A merge lands the head the merge gate passed, and nothing pushed after it** (#4036).
+//
+// The gate reads the checks of one commit, and the merge request names that commit as its `sha`. A
+// push between the two moves the head, GitHub answers 409, and the wait starts over on the new head
+// — so the push is merged once its own checks pass, with nobody having to re-run anything. The
+// retries are bounded: a branch that keeps moving under every wait is not one to merge unattended.
+
+const MAX_HEAD_MOVES = 3
+const NO_CHECKED_HEAD_MESSAGE =
+	'The merge gate answered without the head commit it checked, so there is no commit to bind the merge to'
+const HEAD_MOVED_NOTE =
+	'The pull request head moved after its checks passed — waiting on the new head'
+const HEAD_KEPT_MOVING_MESSAGE = `The pull request head moved after its checks passed ${String(MAX_HEAD_MOVES)} times, so it was not merged`
+
+type WaitForGreen = () => Promise<PrStateSnapshot>
+
+interface CheckedMerge {
+	branch_name: string
+	// The wait to go back to when the head moved — the caller's own, so a re-wait watches what the
+	// first wait watched.
+	wait_for_green: WaitForGreen
+	// The snapshot the gate already passed. Absent, the merge waits for one first.
+	checked?: PrStateSnapshot | undefined
+}
+
+function checked_head(snapshot: PrStateSnapshot): string {
+	if (snapshot.head_sha === undefined) throw new Error(NO_CHECKED_HEAD_MESSAGE)
+
+	return snapshot.head_sha
+}
+
+// `false` is "the head moved"; every other failure is the caller's to see.
+async function try_merge(branch_name: string, snapshot: PrStateSnapshot): Promise<boolean> {
+	const head_sha = checked_head(snapshot)
+
+	try {
+		await git_gh_command.pr_merge(branch_name, head_sha)
+
+		return true
+	} catch (error) {
+		if (!git_gh_command.is_head_moved(error)) throw error
+
+		return false
+	}
+}
+
+async function merge_checked(input: CheckedMerge): Promise<void> {
+	let snapshot = input.checked ?? (await input.wait_for_green())
+
+	for (let move = 0; move < MAX_HEAD_MOVES; move += 1) {
+		// eslint-disable-next-line no-await-in-loop -- each merge names the head the wait before it passed
+		if (await try_merge(input.branch_name, snapshot)) return
+
+		console.info(HEAD_MOVED_NOTE)
+		// eslint-disable-next-line no-await-in-loop -- the new head has to pass before it is merged
+		snapshot = await input.wait_for_green()
+	}
+
+	throw new Error(HEAD_KEPT_MOVING_MESSAGE)
+}
+
+// The merge gate's default wait, then the bound merge.
+async function merge_when_green(branch_name: string): Promise<void> {
+	async function wait_for_green(): Promise<PrStateSnapshot> {
+		return await git_pr_checks.wait_for_pr_success(branch_name)
+	}
+
+	await merge_checked({ branch_name, wait_for_green })
+}
+
+const git_pr_merge_checked = {
+	merge_checked,
+	merge_when_green,
+}
+
+export type { CheckedMerge, WaitForGreen }
+export { git_pr_merge_checked, HEAD_KEPT_MOVING_MESSAGE, MAX_HEAD_MOVES, NO_CHECKED_HEAD_MESSAGE }

package/scripts/git/base-tree.ts

@@ -1,4 +1,5 @@
-import { mkdtemp, rm, symlink } from 'node:fs/promises'
+import { rmSync } from 'node:fs'
+import { copyFile, mkdir, mkdtemp, rm, symlink } from 'node:fs/promises'
 import { tmpdir } from 'node:os'
 import path from 'node:path'
 import { git_worktree } from './git-worktree'
@@ -13,6 +14,12 @@ import { git_worktree } from './git-worktree'
 
 const TREE_NAME = 'tree'
 const NODE_MODULES = 'node_modules'
+const TERMINATE_SIGNAL = 'SIGTERM'
+// 128 + SIGTERM's 15: the code the process would have exited with had no listener caught the signal.
+const TERMINATED_EXIT_CODE = 143
+
+// The temp directories of the trees this process holds now.
+const live_parents = new Set<string>()
 
 interface BaseTree {
 	// The temp directory holding the tree — a file written here sits beside the tree, never in it.
@@ -43,6 +50,26 @@ async function remove(base_tree: BaseTree): Promise<void> {
 	}
 }
 
+// **A terminated run removes its trees before it exits** (joshuafolkken/kit#4794): `josh run:review
+// --join` stops a `test:pinned` that fell behind, and a `finally` never runs past a signal, so each
+// tree would stay in the temp directory and in `git worktree list`. The removal is synchronous because
+// the process exits right after it; the next `with_tree`'s prune drops the registrations.
+function remove_live_trees(): void {
+	for (const parent of live_parents) rmSync(parent, { force: true, recursive: true })
+
+	process.exit(TERMINATED_EXIT_CODE)
+}
+
+function track(parent: string): void {
+	if (live_parents.size === 0) process.on(TERMINATE_SIGNAL, remove_live_trees)
+	live_parents.add(parent)
+}
+
+function untrack(parent: string): void {
+	live_parents.delete(parent)
+	if (live_parents.size === 0) process.off(TERMINATE_SIGNAL, remove_live_trees)
+}
+
 async function with_tree<T>(
 	prefix: string,
 	commit: string,
@@ -51,16 +78,36 @@ async function with_tree<T>(
 	const parent = await mkdtemp(path.join(tmpdir(), prefix))
 	const base_tree = { parent, tree: path.join(parent, TREE_NAME) }
 
+	track(parent)
+
 	try {
 		await prepare(base_tree.tree, commit)
 
 		return await use(base_tree)
 	} finally {
 		await remove(base_tree)
+		untrack(parent)
 	}
 }
 
-const base_tree = { NODE_MODULES, with_tree }
+async function copy_one(tree: string, file: string): Promise<void> {
+	const target = path.join(tree, file)
+
+	await mkdir(path.dirname(target), { recursive: true })
+	await copyFile(file, target)
+}
+
+// The caller's working-tree files into the tree at the same relative paths. Each file has its own
+// target, and a recursive `mkdir` tolerates a sibling creating the same parent.
+async function copy_in(tree: string, files: ReadonlyArray<string>): Promise<void> {
+	await Promise.all(
+		files.map(async (file) => {
+			await copy_one(tree, file)
+		}),
+	)
+}
+
+const base_tree = { NODE_MODULES, copy_in, with_tree }
 
 export type { BaseTree }
 export { base_tree }

package/scripts/git/change-base.ts

@@ -1,4 +1,5 @@
 import { git_command } from './git-command'
+import { git_diff_reads } from './git-diff-reads'
 import { git_spawn } from './git-spawn'
 
 // **The change base as a commit, or nothing — never a ref name**.
@@ -22,29 +23,22 @@ async function resolved(): Promise<string | undefined> {
 	}
 }
 
-const MERGE_BASE_COMMAND = 'merge-base'
-const MERGE_HEAD = 'MERGE_HEAD'
-const LINE_BREAK = '\n'
-
 // Where the side a merge in progress brings in left the default branch — `undefined` where no merge
 // is in progress, which is every ordinary run.
 async function incoming_base(): Promise<string | undefined> {
 	try {
 		const reference = await git_command.default_branch_reference()
 
-		return await git_spawn.read([MERGE_BASE_COMMAND, reference, MERGE_HEAD])
+		return await git_spawn.read([...git_diff_reads.incoming_base_arguments(reference)])
 	} catch {
 		return undefined
 	}
 }
 
-// `--independent` drops every commit another one listed reaches, so of two commits on the default
-// branch's history it keeps the later.
 async function later_of(base: string, incoming: string): Promise<string> {
-	const kept = await git_spawn.read([MERGE_BASE_COMMAND, '--independent', base, incoming])
-	const [later = base] = kept.split(LINE_BREAK)
+	const kept = await git_spawn.read([...git_diff_reads.later_base_arguments(base, incoming)])
 
-	return later
+	return git_diff_reads.later_base_of(kept, base)
 }
 
 // **The base of the tree, not of `HEAD`, while a merge is in progress.** A merge of the default

package/scripts/git/changed-file-scope.ts

@@ -11,9 +11,10 @@ import { git_command } from './git-command'
 // nothing, and listing what was narrowed by — is identical, so it lives here once rather than in
 // each command.
 //
-// **A narrowed run is added in front of the whole check, never in place of it.** Both fallbacks
-// therefore end at the whole check, and each says which of the two it was: the one thing this must
-// never do is answer "nothing to run" quietly.
+// The narrowed unit run replaces the whole suite in the gate (joshuafolkken/kit#4065), and the
+// narrowed lint the whole-tree lint (joshuafolkken/kit#4085), each with CI's whole run behind it.
+// Either way both fallbacks end at the whole check, and each says which of the two it was: the
+// one thing this must never do is answer "nothing to run" quietly.
 
 type ScopeMode = 'all' | 'related'
 
@@ -176,7 +177,7 @@ async function resolve_command_scope(request: ScopeRequest): Promise<ChangedFile
 // describing a set the caller never handed over.
 function report_unusable_arguments(
 	command_arguments: ReadonlyArray<string>,
-	scope: ChangedFileScope,
+	scope: Pick<ChangedFileScope, 'files'>,
 	label: string,
 ): void {
 	const narrowed = new Set(scope.files)
@@ -195,6 +196,7 @@ const changed_file_scope = {
 	UNREADABLE_REASON,
 	describe_scope,
 	flags_of,
+	format_file_list,
 	is_flag,
 	read_changed_files,
 	report_unusable_arguments,

package/scripts/git/changed-paths-sync.ts

@@ -0,0 +1,63 @@
+import { changed_paths } from './changed-paths'
+import { git_diff_reads } from './git-diff-reads'
+import { git_location_environment } from './git-location-environment'
+import { git_spawn_sync, type GitSyncOptions } from './git-spawn-sync'
+
+// The synchronous counterpart of `changed_paths.read_changed_paths(false)` — the branch diff since
+// the merge base plus the untracked files — for a `PreToolUse` hook, which cannot await. It spawns the
+// argument lists `git-diff-reads.ts` spawns, so the two readings agree on what "changed" is — through
+// a merge of the default branch in progress too, measured from the base `change_base.resolved_through_merge`
+// answers (joshuafolkken/kit#5309). Any failure is the empty list.
+
+// With an explicit `cwd`, the git location variables are cleared so that directory is what git
+// answers for, as in `git_spawn_sync.origin_url`.
+function options_of(cwd: string | undefined): GitSyncOptions {
+	if (cwd === undefined) return {}
+
+	return { cwd, env: git_location_environment.location_free_environment() }
+}
+
+function default_branch_reference(options: GitSyncOptions): string {
+	const output = git_spawn_sync.read([...git_diff_reads.DEFAULT_BRANCH_ARGUMENTS], options)
+	const default_branch = git_diff_reads.default_branch_of(output)
+	const remote_reference = git_diff_reads.remote_reference_of(default_branch)
+	const check = git_diff_reads.reference_check_arguments(remote_reference)
+
+	return git_spawn_sync.read(check, options) === undefined ? default_branch : remote_reference
+}
+
+// While a merge is in progress, the later of the base of `HEAD` and the base of `MERGE_HEAD`.
+function through_merge(base: string, reference: string, options: GitSyncOptions): string {
+	const incoming = git_spawn_sync.read(git_diff_reads.incoming_base_arguments(reference), options)
+
+	if (incoming === undefined) return base
+
+	const kept = git_spawn_sync.read(git_diff_reads.later_base_arguments(base, incoming), options)
+
+	return git_diff_reads.later_base_of(kept, base)
+}
+
+function change_base(options: GitSyncOptions): string {
+	const reference = default_branch_reference(options)
+	const base = git_spawn_sync.read(git_diff_reads.merge_base_arguments(reference), options)
+
+	if (base === undefined) return reference
+
+	return through_merge(base, reference, options)
+}
+
+// Repository-root-relative paths, as the asynchronous reading returns them.
+function read_changed_paths(cwd?: string): ReadonlyArray<string> {
+	const options = options_of(cwd)
+	const tracked = git_spawn_sync.read(
+		git_diff_reads.names_since_arguments(change_base(options)),
+		options,
+	)
+	const untracked = git_spawn_sync.read(git_diff_reads.UNTRACKED_ARGUMENTS, options)
+
+	return [tracked, untracked].flatMap((raw = '') => changed_paths.to_paths(raw))
+}
+
+const changed_paths_sync = { read_changed_paths }
+
+export { changed_paths_sync }

package/scripts/git/changed-paths.ts

@@ -1,3 +1,4 @@
+import { change_base } from './change-base'
 import { git_command } from './git-command'
 
 // The set of changed paths a mechanical, path-driven decision is made from.
@@ -12,18 +13,49 @@ function to_paths(raw: string): Array<string> {
 		.filter((line) => line !== '')
 }
 
+// joshuafolkken/kit#5307: **the tracked half is measured from the tree's base, through a merge in
+// progress** (`change_base.resolved_through_merge`). A merge of the default branch stopped on a
+// conflict holds the default branch's files in the tree while `HEAD` is still the commit before it,
+// so the diff from `HEAD`'s merge-base read everything the merge brought in as this branch's own — and
+// the ship's `unplanned` precondition refused the re-detach it had itself told the lane to make. A
+// base that cannot be resolved reads as before.
+async function tracked_names(): Promise<string> {
+	const base = await change_base.resolved_through_merge()
+
+	if (base === undefined) return await git_command.diff_main_names()
+
+	return await git_command.diff_names_since(base)
+}
+
 // The branch diff **plus** the untracked files. `git diff` lists neither, so a change that adds a
 // new module and edits one inert file looked like an inert-only change and was handed `low`. The
 // staged form needs no such addition: a file staged for addition is already in the cached diff.
 async function read_changed_paths(is_staged: boolean): Promise<Array<string>> {
 	if (is_staged) return to_paths(await git_command.diff_cached_names())
 
-	const tracked = to_paths(await git_command.diff_main_names())
+	const tracked = to_paths(await tracked_names())
 	const untracked = to_paths(await git_command.untracked_names())
 
 	return [...tracked, ...untracked]
 }
 
-const changed_paths = { read_changed_paths, to_paths }
+// The same reading against any commit rather than the change base — the change since the tree a
+// test-read map was recorded on.
+async function read_changed_since(commit: string): Promise<Array<string>> {
+	const tracked = to_paths(await git_command.diff_names_since(commit))
+	const untracked = to_paths(await git_command.untracked_names())
+
+	return [...new Set([...tracked, ...untracked])]
+}
+
+// The paths among `paths` the tree of `commit` held. An empty list asks git nothing, since
+// `ls-tree` with no path lists the whole tree.
+async function read_held_at(commit: string, paths: ReadonlyArray<string>): Promise<Array<string>> {
+	if (paths.length === 0) return []
+
+	return to_paths(await git_command.tree_names_at(commit, paths))
+}
+
+const changed_paths = { read_changed_paths, read_changed_since, read_held_at, to_paths }
 
 export { changed_paths }

package/scripts/git/git-common-directory.ts

@@ -8,6 +8,9 @@ import { git_location_environment, GIT_LOCATION_VARIABLES } from './git-location
 // cannot name different directories. It had been run in three places with three timeouts and no
 // memory of the answer, though a `PreToolUse` hook may ask it several times in one call.
 
+// josh's own per-clone state inside the common git directory, in one entry of it so nothing josh writes
+// sits at its root beside git's own files.
+const STATE_DIRECTORY = 'josh'
 const OWN_GIT_DIRECTORY = 0
 const COMMON_GIT_DIRECTORY = 1
 // The read runs inside `PreToolUse` hooks, which hold the tool call for as long as it takes;
@@ -97,6 +100,13 @@ function resolve(cwd: string): string | undefined {
 	return select_linked(directories(cwd))
 }
 
-const git_common_directory = { directories, own, repository, resolve, select_linked }
+const git_common_directory = {
+	STATE_DIRECTORY,
+	directories,
+	own,
+	repository,
+	resolve,
+	select_linked,
+}
 
 export { git_common_directory }

package/scripts/git/git-diff-reads.ts

@@ -31,6 +31,16 @@ async function get_default_branch(): Promise<string> {
 
 const MERGE_BASE_COMMAND = 'merge-base'
 
+// The argument lists below are shared with `changed-paths-sync.ts`, so the hook-side synchronous
+// reading cannot drift from this one.
+function reference_check_arguments(reference: string): ReadonlyArray<string> {
+	return ['rev-parse', '--verify', '--quiet', reference]
+}
+
+function remote_reference_of(default_branch: string): string {
+	return `${REFS_REMOTES_ORIGIN_PREFIX}${default_branch}`
+}
+
 // **The ref the default branch is actually at**, which is not the same thing as its name.
 // `get_default_branch` returns the bare name, and git resolves that to the
 // *local* `refs/heads/<default>` — a ref nothing in this workflow advances, because merges happen on
@@ -45,7 +55,7 @@ const MERGE_BASE_COMMAND = 'merge-base'
 // `prevent-main-commit.ts` exists to stop.
 async function reference_exists(reference: string): Promise<boolean> {
 	try {
-		await git_spawn.read(['rev-parse', '--verify', '--quiet', reference])
+		await git_spawn.read([...reference_check_arguments(reference)])
 
 		return true
 	} catch {
@@ -55,11 +65,33 @@ async function reference_exists(reference: string): Promise<boolean> {
 
 async function default_branch_reference(): Promise<string> {
 	const default_branch = await get_default_branch()
-	const remote_reference = `${REFS_REMOTES_ORIGIN_PREFIX}${default_branch}`
+	const remote_reference = remote_reference_of(default_branch)
 
 	return (await reference_exists(remote_reference)) ? remote_reference : default_branch
 }
 
+function merge_base_arguments(reference: string): ReadonlyArray<string> {
+	return [MERGE_BASE_COMMAND, reference, 'HEAD']
+}
+
+// Where the side a merge in progress brings in left the default branch; git fails it where no merge
+// is in progress. These three are `change_base.resolved_through_merge`'s, shared with the sync reading.
+function incoming_base_arguments(reference: string): ReadonlyArray<string> {
+	return [MERGE_BASE_COMMAND, reference, 'MERGE_HEAD']
+}
+
+// `--independent` drops every commit another one listed reaches, so of two commits on the default
+// branch's history it keeps the later — read from its output by `later_base_of`.
+function later_base_arguments(base: string, incoming: string): ReadonlyArray<string> {
+	return [MERGE_BASE_COMMAND, '--independent', base, incoming]
+}
+
+function later_base_of(output: string | undefined, base: string): string {
+	const [later = ''] = output?.split('\n', 1) ?? []
+
+	return later === '' ? base : later
+}
+
 // The commit this branch was cut from — and the base every "changed" reading below measures
 // against, in place of the default branch itself.
 //
@@ -89,7 +121,7 @@ async function change_base(): Promise<string> {
 	const default_branch = await default_branch_reference()
 
 	try {
-		return await git_spawn.read([MERGE_BASE_COMMAND, default_branch, 'HEAD'])
+		return await git_spawn.read([...merge_base_arguments(default_branch)])
 	} catch {
 		return default_branch
 	}
@@ -151,18 +183,45 @@ async function change_base_commit(): Promise<string> {
 	return await git_spawn.read(['rev-parse', await change_base()])
 }
 
-async function diff_main_names(): Promise<string> {
-	return await git_spawn.read([
+// The working tree against any commit, with the same flags as the branch diff. `josh test:related`
+// reads the change since the commit its test-read map was recorded on, which is not the merge base.
+function names_since_arguments(commit: string): ReadonlyArray<string> {
+	return [
 		...NO_PATH_QUOTING,
 		'diff',
 		NAME_ONLY_FLAG,
 		NO_RELATIVE_PATHS,
 		NO_RENAME_DETECTION,
-		await change_base(),
+		commit,
 		'--',
+	]
+}
+
+async function diff_names_since(commit: string): Promise<string> {
+	return await git_spawn.read([...names_since_arguments(commit)])
+}
+
+// Which of `paths` a commit's tree holds. `josh test:related` asks it of the tree its test-read map
+// was recorded on: a file that tree held and no test read is one no test reads, while a file added
+// since is one the map knows nothing about. **Callers pass at least one path** — with none, `ls-tree`
+// lists the whole tree.
+async function tree_names_at(commit: string, paths: ReadonlyArray<string>): Promise<string> {
+	return await git_spawn.read([
+		...NO_PATH_QUOTING,
+		'ls-tree',
+		'-r',
+		NAME_ONLY_FLAG,
+		'--full-tree',
+		commit,
+		'--',
+		...paths,
 	])
 }
 
+async function diff_main_names(): Promise<string> {
+	return await diff_names_since(await change_base())
+}
+
 async function diff_cached_names(): Promise<string> {
 	return await git_spawn.read([
 		...NO_PATH_QUOTING,
@@ -174,17 +233,17 @@ async function diff_cached_names(): Promise<string> {
 	])
 }
 
-// The branch diff as `added\tdeleted\tpath` rows — the same base and flags as `diff_main_names`, so
-// the size read against and the name read agree on what "changed" is. A binary file prints `-` for
-// both counts; the parser above `josh split:assess` reads it treats those as zero changed lines.
-async function diff_main_numstat(): Promise<string> {
+// The diff since `base` as `added\tdeleted\tpath` rows — the same flags as `diff_names_since`, so the
+// size read and the name read agree on what "changed" is. A binary file prints `-` for both counts;
+// the parser above `josh split:assess` reads it treats those as zero changed lines.
+async function diff_numstat_since(base: string): Promise<string> {
 	return await git_spawn.read([
 		...NO_PATH_QUOTING,
 		'diff',
 		'--numstat',
 		NO_RELATIVE_PATHS,
 		NO_RENAME_DETECTION,
-		await change_base(),
+		base,
 		'--',
 	])
 }
@@ -203,19 +262,22 @@ async function diff_main_numstat(): Promise<string> {
 // pathspec restores the whole tree; the flag restores the root-relative spelling.
 const WHOLE_TREE_PATHSPEC = ':/'
 
+const UNTRACKED_ARGUMENTS: ReadonlyArray<string> = [
+	...NO_PATH_QUOTING,
+	'ls-files',
+	'--others',
+	'--exclude-standard',
+	'--full-name',
+	WHOLE_TREE_PATHSPEC,
+]
+
 async function untracked_names(): Promise<string> {
-	return await git_spawn.read([
-		...NO_PATH_QUOTING,
-		'ls-files',
-		'--others',
-		'--exclude-standard',
-		'--full-name',
-		WHOLE_TREE_PATHSPEC,
-	])
+	return await git_spawn.read([...UNTRACKED_ARGUMENTS])
 }
 
 const git_diff_reads = {
 	DEFAULT_BRANCH_ARGUMENTS,
+	UNTRACKED_ARGUMENTS,
 	change_base,
 	change_base_commit,
 	default_branch_of,
@@ -223,8 +285,17 @@ const git_diff_reads = {
 	diff_cached_names,
 	diff_main,
 	diff_main_names,
-	diff_main_numstat,
+	diff_numstat_since,
+	diff_names_since,
 	get_default_branch,
+	incoming_base_arguments,
+	later_base_arguments,
+	later_base_of,
+	merge_base_arguments,
+	names_since_arguments,
+	reference_check_arguments,
+	remote_reference_of,
+	tree_names_at,
 	untracked_names,
 }
 

package/scripts/git/git-error.ts

@@ -25,13 +25,18 @@ function get_cause_message(cause: unknown): string | undefined {
 	return undefined
 }
 
+// The heads of the lines a failed command names the error it ended on, and that error's cause, with —
+// read back by a stopped `josh ship` stage (joshuafolkken/kit#5052).
+const FAILURE_PREFIX = '❌ Error:'
+const DETAILS_PREFIX = '💡 Details:'
+
 function display_error_details(cause: unknown): void {
 	const cause_message = get_cause_message(cause)
 
 	if (cause_message === undefined || cause_message.length === 0) return
 
 	console.error('')
-	console.error('💡 Details:', cause_message)
+	console.error(DETAILS_PREFIX, cause_message)
 }
 
 const FAILURE_EXIT_CODE = 1
@@ -72,7 +77,7 @@ function display_failure(error: unknown): void {
 	const error_message = error_text.message_of(error)
 
 	console.error('')
-	console.error('❌ Error:', error_message)
+	console.error(FAILURE_PREFIX, error_message)
 
 	if (error instanceof Error && error.cause !== undefined) {
 		display_error_details(error.cause)
@@ -118,6 +123,8 @@ function handle(error: unknown): void {
 }
 
 const git_error = {
+	DETAILS_PREFIX,
+	FAILURE_PREFIX,
 	handle,
 }