@joshuafolkken/kit 1.1784.0 → 1.2114.0

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,13 +13,27 @@ 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]

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
 	}
@@ -153,8 +185,8 @@ async function change_base_commit(): Promise<string> {
 
 // 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.
-async function diff_names_since(commit: string): Promise<string> {
-	return await git_spawn.read([
+function names_since_arguments(commit: string): ReadonlyArray<string> {
+	return [
 		...NO_PATH_QUOTING,
 		'diff',
 		NAME_ONLY_FLAG,
@@ -162,7 +194,11 @@ async function diff_names_since(commit: string): Promise<string> {
 		NO_RENAME_DETECTION,
 		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
@@ -197,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,
 		'--',
 	])
 }
@@ -226,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,
@@ -246,9 +285,16 @@ 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,
 }
 

package/scripts/git/git-schemas.ts

@@ -36,6 +36,7 @@ const ai_review_pull_comment_schema = z.object({
 	body: z.string().optional(),
 	url: z.string().optional(),
 	author: z.object({ login: z.string().optional() }).optional(),
+	updatedAt: z.string().optional(),
 })
 
 const pr_info_schema = z.object({
@@ -108,6 +109,7 @@ const rest_comment_schema = z.looseObject({
 	body: z.string().nullish(),
 	html_url: z.string().optional(),
 	user: z.looseObject({ login: z.string().optional() }).nullish(),
+	updated_at: z.string().optional(),
 })
 
 // The `number,state,labels,body` read, for the epic check and the `--add` closed-epic refusal.
@@ -137,6 +139,12 @@ const epic_subject_schema = z.object({
 // So `blockedBy` is optional for the reason it is absent in practice — the display and the busy
 // check never ask for it, and a field that was not asked for is left out of the mapped row rather
 // than filled in.
+// Who wrote an issue, as REST names it — read through `gh_author_association.author_of`.
+const author_fields_schema = {
+	author_association: z.string().nullish(),
+	user: z.looseObject({ login: z.string() }).nullish(),
+}
+
 const open_issue_schema = z.object({
 	number: z.number(),
 	title: z.string(),
@@ -145,6 +153,10 @@ const open_issue_schema = z.object({
 	blockedBy: blocked_by_schema,
 	// Present only on the pickup listing, which reads it for the paths each issue declares.
 	body: z.string().optional(),
+	...author_fields_schema,
+	// Assembled by the pickup from the author above, never read off the listing: whether the author
+	// has write access. Absent on every other listing.
+	author_trusted: z.boolean().optional(),
 })
 
 type RollupItemData = z.infer<typeof rollup_item_schema>
@@ -154,6 +166,7 @@ type OpenIssueData = z.infer<typeof open_issue_schema>
 type RestCommentData = z.infer<typeof rest_comment_schema>
 
 export {
+	author_fields_schema,
 	package_name_schema,
 	rollup_item_schema,
 	pr_raw_schema,

package/scripts/git/git-worktree.ts

@@ -19,6 +19,7 @@ import { repository_lock } from './repository-lock'
 // `lane-start-point.ts` and `release-publish.ts` both act on — so this module stops at "what git
 // printed" and the meaning of it is decided there.
 const WORKTREE = 'worktree'
+const ORIGIN = 'origin'
 
 // **Every call that writes `.git/worktrees/` runs under one repository-wide lock**.
 // `git worktree add` is not safe against itself: while one add is still
@@ -87,6 +88,17 @@ async function worktree_add(
 	return await locked([WORKTREE, ...flags, directory, start_point ?? branch_name], SUITE_TIMEOUT_MS)
 }
 
+// **A lane's upstream is written when it is opened, not by its first push**
+// (joshuafolkken/kit#4653). A Codex lane's sandbox cannot write the common directory's `config`, so the
+// `--set-upstream` its push falls back to records nothing, and every later reader of `@{upstream}`
+// would take the pushed lane for an unpushed one. Pointing it at the lane's own name on `origin` keeps
+// a bare `git push` working before the remote branch exists. Under the work-tree lock, since two lanes
+// opened at once would otherwise race on `config.lock`.
+async function set_upstream(branch_name: string): Promise<void> {
+	await locked(['config', `branch.${branch_name}.remote`, ORIGIN])
+	await locked(['config', `branch.${branch_name}.merge`, `refs/heads/${branch_name}`])
+}
+
 // A throwaway tree at one commit, on no branch — `josh test:red` checks the merge-base out here, so
 // the pre-fix tree is built without creating a branch or touching the caller's tree and index.
 async function worktree_add_detached(directory: string, commit: string): Promise<string> {
@@ -139,6 +151,7 @@ async function branch_delete(branch_name: string): Promise<string> {
 const git_worktree = {
 	branch_delete,
 	ls_remote_branch,
+	set_upstream,
 	worktree_add,
 	worktree_add_detached,
 	worktree_list,

package/scripts/git/gone-branch.ts

@@ -7,7 +7,10 @@ import { git_spawn } from './git-spawn'
 // **A branch is removed only when all three hold** — its upstream is gone, it is merged into the
 // default branch, and no work tree has it checked out. Gone alone is not enough: a branch whose remote
 // was deleted by hand before its work merged still holds the only copy of it. A branch with no
-// upstream at all is never gone, so a local-only branch stays.
+// upstream at all is never gone, so a local-only branch stays. A lane branch has its upstream from the
+// moment it opens (`lane-open.ts`), so an unpushed lane reads `[gone]`: the merge test keeps one with
+// commits of its own, and one with none — merged already — is kept by its work tree, then deleted with
+// nothing lost once the tree is gone.
 //
 // **One `for-each-ref` read carries the work-tree answer too** — `%(worktreepath)` is git's own
 // record of which tree holds the branch, so no `git worktree list` parse is repeated here.

package/scripts/git/main-merge-budget-conflict.ts

@@ -0,0 +1,89 @@
+// The resolution of a merge that stopped on `document-byte-budget.ts`'s ceiling rows
+// (joshuafolkken/kit#4976). Two lanes that grow the same page each raise that page's ceiling and add a
+// comment naming their Issue, so the later merge stops on the same row from both sides.
+//
+// **Only a hunk made of ceiling rows and their comments is resolved**: each side is comment lines
+// followed by at most one ceiling row, both rows name the same page, and the result keeps every
+// comment from both sides and the larger ceiling. A hunk holding only comments is resolved only when
+// the row it annotates follows it. Any other hunk — the table's structure, another function — throws,
+// so the merge stays the `conflict` it was. The merged page's size is still checked against the kept
+// ceiling by `document-byte-budget.test.ts`.
+
+const BUDGET_TABLE_PATH = 'scripts/document/document-byte-budget.ts'
+const CEILING_ROW = /^\t\{ path: '(?<path>[^']+)', bytes: (?<bytes>[\d_]+) \},$/u
+const COMMENT_PREFIX = '\t// '
+const CONFLICT_MARKER = /^(?:<{7}|={7}|>{7}|\|{7})/mu
+// A diff3 base section, dropped before the hunks are read: the resolution needs only the two sides.
+const BASE_SECTION = /^\|{7} .*\n(?:.*\n)*?(?=={7}\n)/gmu
+// One conflict hunk; the line after it is captured without being consumed.
+const HUNK = /^<{7} .*\n(?<ours>(?:.*\n)*?)={7}\n(?<theirs>(?:.*\n)*?)>{7} .*\n(?=(?<after>.*))/gmu
+
+interface Side {
+	comments: ReadonlyArray<string>
+	row: string | undefined
+}
+
+function side_of(text: string): Side {
+	const lines = text.split('\n').slice(0, -1)
+	const last = lines.at(-1) ?? ''
+	const row = CEILING_ROW.test(last) ? last : undefined
+	const comments = row === undefined ? lines : lines.slice(0, -1)
+
+	if (comments.some((line) => !line.startsWith(COMMENT_PREFIX))) {
+		throw new Error(`${BUDGET_TABLE_PATH}: a conflict outside the ceiling rows`)
+	}
+
+	return { comments, row }
+}
+
+function ceiling_of(row: string): { path: string; bytes: number } {
+	const groups: Partial<Record<'path' | 'bytes', string>> = CEILING_ROW.exec(row)?.groups ?? {}
+
+	return { path: groups.path ?? '', bytes: Number(groups.bytes?.replaceAll('_', '')) }
+}
+
+function larger_row(ours: string, theirs: string): string {
+	const [mine, other] = [ceiling_of(ours), ceiling_of(theirs)]
+
+	if (mine.path !== other.path) {
+		throw new Error(
+			`${BUDGET_TABLE_PATH}: rows of two pages conflict (${mine.path}, ${other.path})`,
+		)
+	}
+
+	return mine.bytes >= other.bytes ? ours : theirs
+}
+
+function rows_of(ours: Side, theirs: Side, after: string): ReadonlyArray<string> {
+	if (ours.row !== undefined && theirs.row !== undefined) return [larger_row(ours.row, theirs.row)]
+	// Equal here only when both are undefined: a hunk of comments alone, kept only above a row.
+	if (ours.row === theirs.row && CEILING_ROW.test(after)) return []
+
+	throw new Error(`${BUDGET_TABLE_PATH}: a ceiling row changed on one side only`)
+}
+
+function merge_hunk(ours: string, theirs: string, after: string): string {
+	const [mine, other] = [side_of(ours), side_of(theirs)]
+	const comments = [...new Set([...mine.comments, ...other.comments])]
+
+	return [...comments, ...rows_of(mine, other, after)].map((line) => `${line}\n`).join('')
+}
+
+// The file with every hunk resolved; throws when any hunk is not a ceiling-row conflict.
+function resolve(content: string): string {
+	const resolved = content
+		.replaceAll(BASE_SECTION, '')
+		.replaceAll(HUNK, (_hunk: string, ours: string, theirs: string, after: string) =>
+			merge_hunk(ours, theirs, after),
+		)
+
+	if (resolved === content || CONFLICT_MARKER.test(resolved)) {
+		throw new Error(`${BUDGET_TABLE_PATH}: a conflict left unresolved`)
+	}
+
+	return resolved
+}
+
+const main_merge_budget_conflict = { BUDGET_TABLE_PATH, resolve }
+
+export { main_merge_budget_conflict }

package/scripts/git/main-merge-guard.ts

@@ -1,3 +1,4 @@
+import { lane_child_marker } from '#scripts/lane/lane-child-marker'
 import { git_spawn } from './git-spawn'
 
 // What `josh main:merge` refuses before it merges, and what it tells the run to do instead.
@@ -18,8 +19,12 @@ const UNMERGED_CODES = new Set(['DD', 'AU', 'UD', 'UA', 'DU', 'AA', 'UU'])
 const UNSTAGED_INDEX_CODES = new Set([' ', '?', '!'])
 const DIRECTORY_SUFFIX = '/'
 const COMMIT_COMMAND = '`pnpm josh git -y`'
+// A lane child's push is `josh ship`'s, so the lane-background row refuses a pushing `git -y` there;
+// this is the commit-only form ship's own sync closes a merge with (`run-ship-sync.ts`).
+const LANE_COMMIT_COMMAND = '`pnpm josh git -y --skip-push --skip-pr "<title> #<N>"`'
 const PROCEDURE_POINTER =
 	'`.claude/skills/workflow-commands/chain-rule.md` → "origin/main is merged in before the gate"'
+const MERGE_RERUN = '`pnpm josh main:merge`'
 
 function status_lines(status: string): Array<string> {
 	return status.split('\n').filter((line) => line.length > STATUS_PREFIX_LENGTH)
@@ -57,55 +62,85 @@ function overlapping_paths(status: string, incoming: ReadonlyArray<string>): Arr
 	return uncommitted.filter((path) => incoming.some((changed) => covers(path, changed)))
 }
 
-function unmerged_message(paths: ReadonlyArray<string>): string {
+function commit_command(is_lane_child = lane_child_marker.is_child_of(process.cwd())): string {
+	return is_lane_child ? LANE_COMMIT_COMMAND : COMMIT_COMMAND
+}
+
+// `prefix` names the refusing command, `rerun` what to run once the merge is closed — `josh stash:push`
+// refuses the same index, since `git stash` cannot set unresolved paths aside.
+function unresolved_message(
+	prefix: string,
+	paths: ReadonlyArray<string>,
+	rerun: string,
+	commit = commit_command(),
+): string {
 	return (
-		`main:merge: the index still holds unresolved paths (${paths.join(', ')}). Remove the conflict ` +
-		`markers, then finish through ${COMMIT_COMMAND} — it stages and commits them, so no \`git add\` ` +
-		`permission is needed, and inside a lane this is Tier A. Rerun \`pnpm josh main:merge\` after it ` +
+		`${prefix}: the index still holds unresolved paths (${paths.join(', ')}). Remove the conflict ` +
+		`markers, then finish through ${commit} — it stages and commits them, so no \`git add\` ` +
+		`permission is needed, and inside a lane this is Tier A. Rerun ${rerun} after it ` +
 		`(${PROCEDURE_POINTER}).`
 	)
 }
 
-function staged_message(paths: ReadonlyArray<string>): string {
+function staged_message(paths: ReadonlyArray<string>, commit: string): string {
 	return (
 		`main:merge: the index holds staged changes (${paths.join(', ')}), which git refuses to merge ` +
-		`over. Commit them first through ${COMMIT_COMMAND}, then rerun \`pnpm josh main:merge\` ` +
+		`over. Commit them first through ${commit}, then rerun \`pnpm josh main:merge\` ` +
 		`(${PROCEDURE_POINTER}).`
 	)
 }
 
-function overlap_message(default_branch: string, paths: ReadonlyArray<string>): string {
+function overlap_message(
+	default_branch: string,
+	paths: ReadonlyArray<string>,
+	commit: string,
+): string {
 	return (
 		`main:merge: uncommitted changes touch files origin/${default_branch} also changed ` +
-		`(${paths.join(', ')}). Commit the work first through ${COMMIT_COMMAND}, then rerun ` +
+		`(${paths.join(', ')}). Commit the work first through ${commit}, then rerun ` +
 		`\`pnpm josh main:merge\`. Never stash around the merge — a stash reapplied over it leaves the ` +
 		`conflict half-recorded in the index (${PROCEDURE_POINTER}).`
 	)
 }
 
 // Appended to git's own report when the merge itself stops on a conflict.
-const CONFLICT_HINT =
-	`main:merge: finish a conflicted merge by removing the conflict markers, then ${COMMIT_COMMAND} ` +
-	`records the merge commit — no \`git add\` permission is needed (${PROCEDURE_POINTER}).`
+function conflict_hint(commit = commit_command()): string {
+	return (
+		`main:merge: finish a conflicted merge by removing the conflict markers, then ${commit} ` +
+		`records the merge commit — no \`git add\` permission is needed (${PROCEDURE_POINTER}).`
+	)
+}
 
-function refusal(
+function merge_refusal(
 	status: string,
 	incoming: ReadonlyArray<string>,
 	default_branch: string,
+	commit: string,
 ): string | undefined {
-	const unmerged = unmerged_paths(status)
-
-	if (unmerged.length > 0) return unmerged_message(unmerged)
 	// Nothing incoming means git answers "Already up to date" whatever the index holds.
 	if (incoming.length === 0) return undefined
 
 	const staged = staged_paths(status)
 
-	if (staged.length > 0) return staged_message(staged)
+	if (staged.length > 0) return staged_message(staged, commit)
 
 	const overlap = overlapping_paths(status, incoming)
 
-	return overlap.length > 0 ? overlap_message(default_branch, overlap) : undefined
+	return overlap.length > 0 ? overlap_message(default_branch, overlap, commit) : undefined
+}
+
+// `commit` is the command the message names, resolved from the lane mark unless a caller passes it.
+function refusal(
+	status: string,
+	incoming: ReadonlyArray<string>,
+	default_branch: string,
+	commit = commit_command(),
+): string | undefined {
+	const unmerged = unmerged_paths(status)
+
+	if (unmerged.length > 0) return unresolved_message('main:merge', unmerged, MERGE_RERUN, commit)
+
+	return merge_refusal(status, incoming, default_branch, commit)
 }
 
 // The paths the default branch changed since this branch left it — what the merge would bring in.
@@ -122,12 +157,14 @@ async function incoming_paths(default_branch: string): Promise<Array<string>> {
 }
 
 const main_merge_guard = {
-	CONFLICT_HINT,
+	commit_command,
+	conflict_hint,
 	incoming_paths,
 	overlapping_paths,
 	refusal,
 	staged_paths,
 	unmerged_paths,
+	unresolved_message,
 }
 
 export { main_merge_guard }