@joshuafolkken/kit 1.2116.0 → 1.3000.0

package/scripts/git/changed-paths.ts

@@ -6,6 +6,13 @@ import { git_command } from './git-command'
 // `josh review:level` asks this same question of the same tree (which level to review at), and a
 // second copy would let a caller disagree about what "changed" means.
 
+interface ChangedParts {
+	tracked: Array<string>
+	untracked: Array<string>
+	// `fallback` when no base resolved and the tracked half was read against the default branch.
+	base: 'merge_base' | 'fallback'
+}
+
 function to_paths(raw: string): Array<string> {
 	return raw
 		.split('\n')
@@ -19,12 +26,24 @@ function to_paths(raw: string): Array<string> {
 // 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> {
+async function tracked_names(): Promise<Pick<ChangedParts, 'tracked' | 'base'>> {
 	const base = await change_base.resolved_through_merge()
 
-	if (base === undefined) return await git_command.diff_main_names()
+	if (base === undefined) {
+		return { tracked: to_paths(await git_command.diff_main_names()), base: 'fallback' }
+	}
+
+	return { tracked: to_paths(await git_command.diff_names_since(base)), base: 'merge_base' }
+}
+
+// The unstaged reading split into its halves, and whether the tracked half was measured from a
+// resolved base or fell back to the default branch — what `josh test:related` records so a run whose
+// change swelled can be told apart by its cause (joshuafolkken/kit#6982).
+async function read_changed_parts(): Promise<ChangedParts> {
+	const { tracked, base } = await tracked_names()
+	const untracked = to_paths(await git_command.untracked_names())
 
-	return await git_command.diff_names_since(base)
+	return { tracked, untracked, base }
 }
 
 // The branch diff **plus** the untracked files. `git diff` lists neither, so a change that adds a
@@ -33,8 +52,7 @@ async function tracked_names(): Promise<string> {
 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 tracked_names())
-	const untracked = to_paths(await git_command.untracked_names())
+	const { tracked, untracked } = await read_changed_parts()
 
 	return [...tracked, ...untracked]
 }
@@ -56,6 +74,13 @@ async function read_held_at(commit: string, paths: ReadonlyArray<string>): Promi
 	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 }
+const changed_paths = {
+	read_changed_parts,
+	read_changed_paths,
+	read_changed_since,
+	read_held_at,
+	to_paths,
+}
 
+export type { ChangedParts }
 export { changed_paths }

package/scripts/git/git-command.ts

@@ -7,8 +7,15 @@ import { git_push_transport } from './git-push-transport'
 import { git_spawn } from './git-spawn'
 import { git_spawn_sync } from './git-spawn-sync'
 
+const BRANCH_ARGUMENTS = ['rev-parse', '--abbrev-ref', 'HEAD'] as const
+
 async function branch(): Promise<string> {
-	return await git_spawn.read(['rev-parse', '--abbrev-ref', 'HEAD'])
+	return await git_spawn.read([...BRANCH_ARGUMENTS])
+}
+
+// The branch of another work tree of the repository — the primary checkout, read from a lane.
+async function branch_at(directory: string): Promise<string> {
+	return await git_spawn.read(['-C', directory, ...BRANCH_ARGUMENTS])
 }
 
 // **The untracked-files mode is passed rather than inherited**. Every
@@ -392,6 +399,7 @@ async function count_merges(range: string): Promise<number> {
 const git_command = {
 	GIT_DIRECTORY_ARGUMENTS,
 	branch,
+	branch_at,
 	status,
 	repository_root,
 	head_commit,

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

@@ -1,4 +1,5 @@
 import { execFileSync } from 'node:child_process'
+import { durable_state_root } from '#scripts/josh/durable-state-root'
 import { git_utilities } from './constants'
 import { git_command } from './git-command'
 import { git_location_environment, GIT_LOCATION_VARIABLES } from './git-location-environment'
@@ -8,9 +9,8 @@ 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'
+// josh's own per-clone state inside the common git directory (`durable-state-root.ts`).
+const { STATE_DIRECTORY } = durable_state_root
 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;
@@ -87,6 +87,19 @@ function repository(cwd?: string): string | undefined {
 	return directories(cwd)[COMMON_GIT_DIRECTORY]
 }
 
+// The common git directory every lane of the repository shares, asked asynchronously and never
+// remembered — what a ship's stage record, its detached supervisor's log and its pid are keyed on — or
+// `undefined` outside one.
+async function read_repository(): Promise<string | undefined> {
+	try {
+		const found = await git_command.git_directories()
+
+		return found[COMMON_GIT_DIRECTORY]
+	} catch {
+		return undefined
+	}
+}
+
 function select_linked(found: ReadonlyArray<string>): string | undefined {
 	const own_directory = found[OWN_GIT_DIRECTORY]
 	const common = found[COMMON_GIT_DIRECTORY]
@@ -104,6 +117,7 @@ const git_common_directory = {
 	STATE_DIRECTORY,
 	directories,
 	own,
+	read_repository,
 	repository,
 	resolve,
 	select_linked,

package/scripts/git/git-issue.ts

@@ -54,7 +54,7 @@ function parse_issue_input(input: string): IssueInfo {
 	const issue_number = extract_issue_number(trimmed_input)
 	const title = extract_issue_title(trimmed_input)
 	const branch_name = create_branch_name(issue_number, title)
-	const commit_message = `${title} ${issue_cite.plain(issue_number)}`
+	const commit_message = `${title} ${issue_cite.plain_for('github', issue_number)}`
 
 	return {
 		title,
@@ -77,7 +77,7 @@ function is_lane_branch(branch_name: string, issue_number: string): boolean {
 const EXAMPLE_ISSUE_NUMBER = '42'
 
 function argument_hint(issue_number: string): string {
-	return `Provide an issue argument like "title ${issue_cite.plain(issue_number)}".`
+	return `Provide an issue argument like "title ${issue_cite.plain_for('github', issue_number)}".`
 }
 
 // Never falls back to the branch's own word: `lane` is not a title, and a commit message cannot be
@@ -112,7 +112,7 @@ async function derive_issue_input_from_branch(branch_name: string): Promise<stri
 		? await lane_issue_title(branch_name, number)
 		: slug.replaceAll('-', ' ').trim()
 
-	return `${title} ${issue_cite.plain(number)}`
+	return `${title} ${issue_cite.plain_for('github', number)}`
 }
 
 async function derive_from_branch(branch_name: string): Promise<IssueInfo> {

package/scripts/git/git-merge-conflicts.ts

@@ -1,5 +1,6 @@
 import { existsSync } from 'node:fs'
 import path from 'node:path'
+import { changed_paths_sync } from './changed-paths-sync'
 import { git_spawn_sync } from './git-spawn-sync'
 
 // The paths merging another branch into this working tree would stop on, read without touching any
@@ -65,15 +66,19 @@ function sides_of(file_path: string, commits: Commits, cwd: string): Sides {
 }
 
 // Of `paths` (relative to `cwd`, the working tree's root), the ones merging `theirs` would stop on;
-// `undefined` where the merge base with `theirs` could not be read.
+// `undefined` where the merge base with `theirs` could not be read. While a merge is in progress the
+// base moves up to where `MERGE_HEAD` meets `theirs`, so a resolution left uncommitted is one side's
+// change rather than a conflict against the branch's old fork point (joshuafolkken/kit#5582).
 function working_tree_conflicts(
 	theirs: string,
 	paths: ReadonlyArray<string>,
 	cwd: string,
 ): ReadonlyArray<string> | undefined {
-	const base = git_spawn_sync.read(['merge-base', HEAD, theirs], { cwd })
+	const fork = git_spawn_sync.read(['merge-base', HEAD, theirs], { cwd })
 
-	if (base === undefined) return undefined
+	if (fork === undefined) return undefined
+
+	const base = changed_paths_sync.through_merge(fork, theirs, { cwd })
 
 	return paths.filter((file_path) => !is_merged(sides_of(file_path, { base, theirs }, cwd), cwd))
 }

package/scripts/git/git-path-quoting.ts

@@ -0,0 +1,54 @@
+const OCTAL_RADIX = 8
+const OCTAL_WIDTH = 3
+const SPACE_CODE = 32
+const DELETE_CODE = 127
+const ESCAPES: ReadonlyMap<string, string> = new Map([
+	['\u{7}', 'a'],
+	['\b', 'b'],
+	['\t', 't'],
+	['\n', 'n'],
+	['\v', 'v'],
+	['\f', 'f'],
+	['\r', 'r'],
+	['"', '"'],
+	['\\', '\\'],
+])
+
+function escape_character(character: string): string {
+	const short = ESCAPES.get(character)
+
+	if (short !== undefined) return `\\${short}`
+	const code = character.codePointAt(0) ?? 0
+
+	return code === DELETE_CODE || code < SPACE_CODE
+		? `\\${code.toString(OCTAL_RADIX).padStart(OCTAL_WIDTH, '0')}`
+		: character
+}
+
+// Git's line-delimited output with core.quotePath=false still quotes control characters.
+function quote(file: string): string {
+	const escaped = Array.from(file, (character) => escape_character(character)).join('')
+
+	return escaped === file ? file : `"${escaped}"`
+}
+
+function unescape_character(escaped: string): string {
+	return (
+		[...ESCAPES].find((entry) => entry[1] === escaped)?.[0] ??
+		String.fromCodePoint(Number.parseInt(escaped, OCTAL_RADIX))
+	)
+}
+
+function unquote(file: string): string {
+	if (!file.startsWith('"') || !file.endsWith('"')) return file
+
+	return file
+		.slice(1, -1)
+		.replaceAll(/\\([0-7]{3}|a|b|f|n|r|t|v|["\\])/gu, (_match, escaped: string) =>
+			unescape_character(escaped),
+		)
+}
+
+const git_path_quoting = { quote, unquote }
+
+export { git_path_quoting }

package/scripts/git/git-push-transport.ts

@@ -9,18 +9,16 @@ import {
 } from './git-execa-error'
 import { git_ssh_keepalive } from './git-ssh-keepalive'
 
-// The budget for one `git push`, and the reason a push can no longer wait without end.
-// Measured on PR #1244: the commit itself took 0.6 seconds and the push
-// then sat silent for 8 minutes 13 seconds before it was found by hand and killed — about 9 minutes
-// 50 seconds of a 72-minute run, with no way while waiting to tell a stalled push from a slow one.
-// `execa` has always accepted a `timeout`; the push path never passed one, which left it the single
+// The budget for one `git push`, and the reason a push can no longer wait without end. On PR #1244
+// the push sat silent long after a quick commit until it was found by hand and killed
+// (joshuafolkken/kit#1251), with no way while waiting to tell a stalled push
+// from a slow one. `execa` has always accepted a `timeout`; the push path never passed one, which left it the single
 // unbounded network call in this directory beside `GH_REQUEST_TIMEOUT_MS`.
 //
 // **It sits at that same layer, and is deliberately larger.** That budget covers one REST request;
-// a push transfers objects, so this number is read off what a healthy push actually costs here — 22
-// seconds on the manual re-run that finally succeeded, 33 seconds on PR #1247. 120 is roughly four
-// times the slower of the two, which leaves room for a first push of a large branch while staying
-// far under the 6 minutes 45 seconds the hang had already reached when it was noticed.
+// a push transfers objects, so this number is a few times what a healthy push actually costs here
+// (joshuafolkken/kit#1251), which leaves room for a first push of a large branch while staying far
+// under how long the hang had already run when it was noticed.
 //
 // **It bounds one push, not one command.** A push killed on the budget is retried exactly once, and
 // `git_command.push` may then fall back to a `--set-upstream` push that is itself bounded and
@@ -96,7 +94,7 @@ function create_timeout_error(arguments_list: Array<string>): Error {
 // One push, bounded and retried once — and **only** on a timeout. A push the remote rejected (a
 // stale branch, a blocked hook, no upstream) answers the same way every time, so retrying it would
 // buy a second wait to reach an identical failure; a hang is the one outcome a second attempt has
-// been observed to clear, which is what the manual re-run on PR #1244 did in 22 seconds.
+// been observed to clear, which is what the manual re-run on PR #1244 did.
 async function push(arguments_list: Array<string>): Promise<void> {
 	if (!(await did_push_time_out(arguments_list))) return
 

package/scripts/git/git-schemas.ts

@@ -24,6 +24,7 @@ const pr_raw_schema = z.object({
 	mergeStateStatus: z.string().optional(),
 	reviewDecision: z.string().optional(),
 	headRefOid: z.string().optional(),
+	merged: z.boolean().optional(),
 })
 
 const pull_comment_schema = z.object({

package/scripts/git/git-spawn-sync.ts

@@ -51,16 +51,20 @@ function read(args: ReadonlyArray<string>, options: GitSyncOptions = {}): string
 	return result.exit_code === SUCCESS_EXIT_CODE ? result.stdout.trim() : undefined
 }
 
-// The configured `origin` URL, or undefined when the repository has none.
+// The options that make `cwd` the repository that answers; none without a `cwd`.
 //
 // **The git location variables are cleared, so `cwd` is the repository that answers.** A hook exports
 // `GIT_DIR`, which beats `cwd` outright — a caller reached from inside `pre-push` would otherwise be
-// told the `origin` of the repository being pushed rather than of the directory it named.
+// told about the repository being pushed rather than the directory it named.
+function located(cwd: string | undefined): GitSyncOptions {
+	if (cwd === undefined) return {}
+
+	return { cwd, env: git_location_environment.location_free_environment() }
+}
+
+// The configured `origin` URL, or undefined when the repository has none.
 function origin_url(cwd: string): string | undefined {
-	return read(['config', '--get', 'remote.origin.url'], {
-		cwd,
-		env: git_location_environment.location_free_environment(),
-	})
+	return read(['config', '--get', 'remote.origin.url'], located(cwd))
 }
 
 // The absolute repository (or worktree) root, asked under the C locale so a caller can tell "not a
@@ -69,7 +73,7 @@ function toplevel(timeout: number = GIT_TIMEOUT_MS): GitSyncResult {
 	return run(['rev-parse', '--show-toplevel'], { env: C_LOCALE, timeout })
 }
 
-const git_spawn_sync = { GIT_TIMEOUT_MS, C_LOCALE, run, read, origin_url, toplevel }
+const git_spawn_sync = { GIT_TIMEOUT_MS, C_LOCALE, run, read, located, origin_url, toplevel }
 
 export { git_spawn_sync }
 export type { GitSyncOptions, GitSyncResult }

package/scripts/git/git-spawn.ts

@@ -42,7 +42,7 @@ async function read(
 
 // The budget for a git call that talks to the remote — `fetch` and `pull`.
 // `read` and `with_output` once waited without end, and a `git fetch --prune` under `josh main:sync`
-// sat on a dead ssh connection for 37 minutes, stalling the unattended backlog driver whose merge step
+// sat on a dead ssh connection without end, stalling the unattended backlog driver whose merge step
 // runs it. Their default now is a local command's, far too short for a transfer, so a remote call
 // still takes this one. The push's budget is reused rather than a second number chosen: both transfer
 // objects over the same transport, and that one is already read off what a healthy transfer costs here.

package/scripts/git/git-ssh-keepalive.ts

@@ -6,10 +6,10 @@ import { has_timed_out } from './git-execa-error'
 // The ssh environment every git network call runs under. It began inside
 // `git-push-transport.ts` as the push's own, and moved here when the fetch
 // and pull of `josh main:sync` turned out to need the same thing: a dead connection under a `git
-// fetch` was waited on for 37 minutes, stalling the unattended backlog driver behind it.
+// fetch` was waited on without end, stalling the unattended backlog driver behind it.
 //
-// SSH's own liveness probe: three unanswered checks 15 seconds apart, so a connection that dies
-// mid-transfer is noticed in about 45 seconds instead of waiting on the TCP default. The caller's
+// SSH's own liveness probe: a few unanswered checks, so a connection that dies mid-transfer is
+// noticed quickly instead of waiting on the TCP default. The caller's
 // timeout bounds the damage either way; this is what makes the common case fail in seconds rather
 // than sit out the whole budget — and, because ssh exits on its own, it is also what leaves no ssh
 // behind: git does not kill its transport child when it is itself killed on a timeout.

package/scripts/git/git-workflow.ts

@@ -1,7 +1,9 @@
 #!/usr/bin/env tsx
 import { parseArgs } from 'node:util'
 import { git_pr } from '#scripts/gh/git-pr'
+import { hook_lap } from '#scripts/hooks/hook-lap'
 import { cli_body } from '#scripts/josh/cli-body'
+import { run_ship_lap } from '#scripts/run/ship/run-ship-lap'
 import { test_red_commit } from '#scripts/test/test-red-commit'
 import { git_branch } from './git-branch'
 import { git_commit } from './git-commit'
@@ -12,6 +14,9 @@ import { git_prompt, type WorkflowConfirmations } from './git-prompt'
 import { git_push } from './git-push'
 import { git_staging } from './git-staging'
 
+// Each step is a lap under the ship's commit when the ship spawned this run (joshuafolkken/kit#5831).
+const { GIT_STEP } = hook_lap
+
 const SKIP_MESSAGES = {
 	commit: '💡 Commit skipped.',
 	push: '💡 Push skipped.',
@@ -53,7 +58,9 @@ async function execute_commit_step(
 	confirmations: WorkflowConfirmations,
 ): Promise<void> {
 	if (confirmations.commit) {
-		await git_commit.commit(commit_message)
+		await run_ship_lap.timed(GIT_STEP.COMMIT, async () => {
+			await git_commit.commit(commit_message)
+		})
 	} else {
 		console.info(SKIP_MESSAGES.commit)
 	}
@@ -61,7 +68,9 @@ async function execute_commit_step(
 
 async function execute_push_step(confirmations: WorkflowConfirmations): Promise<void> {
 	if (confirmations.push) {
-		await git_push.push()
+		await run_ship_lap.timed(GIT_STEP.PUSH, async () => {
+			await git_push.push()
+		})
 	} else {
 		console.info(SKIP_MESSAGES.push)
 	}
@@ -73,7 +82,9 @@ async function execute_pr_step(
 	extra_body?: string,
 ): Promise<void> {
 	if (confirmations.pr) {
-		await git_pr.create_with_issue_info(issue_info, extra_body)
+		await run_ship_lap.timed(GIT_STEP.PR, async () => {
+			await git_pr.create_with_issue_info(issue_info, extra_body)
+		})
 	} else {
 		console.info(SKIP_MESSAGES.pr)
 	}
@@ -87,7 +98,12 @@ async function run_workflow_steps(
 ): Promise<void> {
 	const commit_message = commit_message_override ?? issue_info.commit_message
 
-	if (confirmations.commit) await test_red_commit.assert_reproduces(issue_info.number)
+	if (confirmations.commit) {
+		await run_ship_lap.timed(GIT_STEP.TEST_RED, async () => {
+			await test_red_commit.assert_reproduces(issue_info.number)
+		})
+	}
+
 	await execute_commit_step(commit_message, confirmations)
 	await execute_push_step(confirmations)
 	await execute_pr_step(issue_info, confirmations, extra_body)
@@ -209,15 +225,22 @@ async function execute_workflow(
 
 	// Unattended, nobody can fix a precondition between stages — so all are asked before staging.
 	if (is_non_interactive) {
-		await git_preflight.check({
-			cli_input: cli_issue_input,
-			will_open_pr: values['skip-pr'] !== true,
+		await run_ship_lap.timed(GIT_STEP.PREFLIGHT, async () => {
+			await git_preflight.check({
+				cli_input: cli_issue_input,
+				will_open_pr: values['skip-pr'] !== true,
+			})
 		})
 	}
 
-	await git_staging.check_and_confirm_staging(values.yes === true)
+	await run_ship_lap.timed(GIT_STEP.STAGING, async () => {
+		await git_staging.check_and_confirm_staging(values.yes === true)
+	})
 
-	const issue_info = await prepare_issue_info(cli_issue_input, is_non_interactive)
+	const issue_info = await run_ship_lap.timed(
+		GIT_STEP.ISSUE,
+		async () => await prepare_issue_info(cli_issue_input, is_non_interactive),
+	)
 	const confirmations = await get_workflow_confirmations(is_non_interactive, values)
 	const commit_message = build_commit_message(issue_info, commit_suffix)
 

package/scripts/git/git-worktree.ts

@@ -1,5 +1,6 @@
 import { INSTALL_TIMEOUT_MS, SUITE_TIMEOUT_MS } from '#scripts/lib/timeouts'
 import { PORCELAIN_FLAG } from './constants'
+import { git_command } from './git-command'
 import { ls_remote_branch_arguments } from './git-ls-remote'
 import { git_spawn } from './git-spawn'
 import { repository_lock } from './repository-lock'
@@ -14,10 +15,10 @@ import { repository_lock } from './repository-lock'
 // asynchronous `git ls-remote` spawn, and a second spawn helper beside it would be that same clone.
 // **It is not the only one in this package** — `propagate_git.has_remote_branch` runs the same query
 // synchronously against a consumer's path, and the two share their arguments through
-// `git-ls-remote.ts` rather than the spawn. Its sole caller is `git-remote-branch.ts`, which turns
-// the raw output into the three-way answer (`absent` / `present` / `unreachable`) that
-// `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.
+// `git-ls-remote.ts` rather than the spawn. `git-remote-branch.ts` turns the raw output into the
+// three-way answer (`absent` / `present` / `unreachable`) that `lane-start-point.ts` and
+// `release-publish.ts` both act on, and `lane-resolve-record.ts` reads the commit off it, which that
+// answer drops — so this module stops at "what git printed" and the meaning of it is decided there.
 const WORKTREE = 'worktree'
 const ORIGIN = 'origin'
 
@@ -148,7 +149,14 @@ async function branch_delete(branch_name: string): Promise<string> {
 	return await git_spawn.read(['branch', '-D', branch_name])
 }
 
+async function is_linked(): Promise<boolean> {
+	const [own, common] = await git_command.git_directories()
+
+	return own !== common
+}
+
 const git_worktree = {
+	is_linked,
 	branch_delete,
 	ls_remote_branch,
 	set_upstream,

package/scripts/git/main-merge.ts

@@ -3,9 +3,6 @@ import { issue_cite } from '#scripts/issue/issue-cite'
 import { composite_arguments, USAGE_ERROR_EXIT_CODE } from '#scripts/josh/josh-composite-arguments'
 import { lane_install } from '#scripts/lane/lane-install'
 import { error_text } from '#scripts/lib/error-message'
-import { split_assess } from '#scripts/split/split-assess'
-import { split_early_notice } from '#scripts/split/split-early-notice'
-import { split_measure } from '#scripts/split/split-measure'
 import { git_command } from './git-command'
 import { main_merge_guard } from './main-merge-guard'
 import { main_merge_regenerate } from './main-merge-regenerate'
@@ -33,8 +30,6 @@ import { main_merge_regenerate } from './main-merge-regenerate'
 const SUCCESS_EXIT_CODE = 0
 const FAILURE_EXIT_CODE = 1
 const COMMAND_NAME = 'main:merge'
-const SPLIT_UNMEASURED =
-	'split notice: the diff could not be measured — run `pnpm josh split:assess`'
 const LOCKFILE = 'pnpm-lock.yaml'
 const INSTALL_OWED =
 	'the merge brought in a lockfile change, but installing it failed — run `pnpm install --frozen-lockfile`'
@@ -48,7 +43,7 @@ function merge_message(default_branch: string, current_branch: string): string |
 
 	if (issue_number === undefined) return undefined
 
-	return `Merge ${default_branch} into ${current_branch} ${issue_cite.plain(issue_number)}`
+	return `Merge ${default_branch} into ${current_branch} ${issue_cite.plain_for('github', issue_number)}`
 }
 
 // What one merge of the default branch came to. `josh ship` merges it again
@@ -155,34 +150,8 @@ function failure_text(outcome: MergeOutcome): string | undefined {
 	return undefined
 }
 
-// joshuafolkken/kit#4302: every implementing run merges the default branch immediately before the
-// gate, so this is where a diff that outgrew the entry's split estimate is told so. The notice is
-// advisory: a finished merge never fails on it, and an unreadable diff says so rather than reading as
-// under the guide. It sits on the command, not on `merge()`, because `josh ship` merges again past the
-// point a run can act on it.
-async function measured_notice(): Promise<string | undefined> {
-	const measurement = await split_measure.read_branch()
-	const notice = split_assess.notice(measurement)
-
-	if (notice !== undefined) await split_early_notice.record(measurement)
-
-	return notice
-}
-
-async function split_notice(): Promise<string | undefined> {
-	try {
-		return await measured_notice()
-	} catch (error) {
-		return `${SPLIT_UNMEASURED}: ${error_text.message_of(error)}`
-	}
-}
-
-async function warn_over_split_guide(): Promise<void> {
-	const notice = await split_notice()
-
-	if (notice !== undefined) console.warn(notice)
-}
-
+// A finished merge prints no split notice: size is judged before implementation (`lane:plan`), and a
+// started Issue is implemented to the end (joshuafolkken/kit#7009).
 async function merge_default_branch(): Promise<number> {
 	const outcome = await merge()
 	const failure = failure_text(outcome)
@@ -195,8 +164,6 @@ async function merge_default_branch(): Promise<number> {
 
 	if ('branch' in outcome) console.info(outcome.branch)
 
-	await warn_over_split_guide()
-
 	return SUCCESS_EXIT_CODE
 }
 

package/scripts/git/main-sync.ts

@@ -1,6 +1,7 @@
 import { composite_arguments, USAGE_ERROR_EXIT_CODE } from '#scripts/josh/josh-composite-arguments'
 import { error_text } from '#scripts/lib/error-message'
 import { git_command } from './git-command'
+import { git_worktree } from './git-worktree'
 import { gone_branch, type PruneResult } from './gone-branch'
 import { lockfile_sync } from './lockfile-sync'
 
@@ -29,12 +30,6 @@ const COMMAND_NAME = 'main:sync'
 const INSTALL_FAILURE =
 	'node_modules is behind pnpm-lock.yaml and `pnpm install --frozen-lockfile` failed; run `pnpm josh ms` again, or the install here by hand.'
 
-// `git_directories()` returns `[--absolute-git-dir, --git-common-dir]`. They are the same path in the
-// main work tree and differ in a linked one, which is git's own definition of the distinction rather
-// than a guess from a directory name.
-const OWN_GIT_DIRECTORY = 0
-const COMMON_GIT_DIRECTORY = 1
-
 // The refusal covers every linked work tree, not lanes alone, because the hijack is a property of
 // the work tree rather than of what opened it. It names both ways out for that reason.
 const LANE_REFUSAL = [
@@ -43,12 +38,6 @@ const LANE_REFUSAL = [
 	'Run `pnpm josh ms` in the primary checkout instead; a lane is finished with `pnpm josh lane:close <issue-number>`.',
 ].join('\n')
 
-async function is_linked_work_tree(): Promise<boolean> {
-	const directories = await git_command.git_directories()
-
-	return directories[OWN_GIT_DIRECTORY] !== directories[COMMON_GIT_DIRECTORY]
-}
-
 // The count rather than the names: the first run on a long-lived checkout removes hundreds. A branch
 // `git branch -d` refused is named, because that one is left for a person to look at.
 function report_prune(result: PruneResult): void {
@@ -120,7 +109,7 @@ async function dispatch(argv: ReadonlyArray<string>): Promise<number> {
 		return USAGE_ERROR_EXIT_CODE
 	}
 
-	if (await is_linked_work_tree()) {
+	if (await git_worktree.is_linked()) {
 		console.error(LANE_REFUSAL)
 
 		return FAILURE_EXIT_CODE

package/scripts/git/repository-lock.ts

@@ -1,10 +1,10 @@
 import { randomUUID } from 'node:crypto'
 import { linkSync, renameSync, rmSync } from 'node:fs'
-import { setTimeout as sleep } from 'node:timers/promises'
 import { process_identity } from '#scripts/josh/process-identity'
 import { process_owner_schema, type ProcessOwner } from '#scripts/josh/process-owner'
 import { stamp_file } from '#scripts/josh/stamp-file'
 import { json_value } from '#scripts/lib/json-value'
+import { poll } from '#scripts/lib/poll'
 import { git_common_directory } from './git-common-directory'
 
 // One holder at a time per repository, for work that every work tree of that repository shares
@@ -111,13 +111,14 @@ function release(target: string): void {
 async function acquire(target: string, max_wait_ms: number): Promise<boolean> {
 	const deadline = Date.now() + max_wait_ms
 
-	while (!claim(target)) {
-		if (Date.now() >= deadline) return false
-		// eslint-disable-next-line no-await-in-loop -- polling: each read waits on the state the previous one saw
-		await sleep(POLL_INTERVAL_MS)
-	}
+	return await poll.wait_for(
+		() => {
+			if (claim(target)) return true
 
-	return true
+			return Date.now() >= deadline ? false : undefined
+		},
+		{ interval_ms: POLL_INTERVAL_MS },
+	)
 }
 
 // A blocking wait for a caller that cannot await. `Atomics.wait` parks the thread without spinning, so