@joshuafolkken/kit 1.1050.0 → 1.1128.0

package/scripts/release/github-release.ts

@@ -2,15 +2,15 @@ import { setTimeout } from 'node:timers/promises'
 import semver from 'semver'
 import { z } from 'zod'
 
-const API_URL = 'https://api.github.com/repos/joshuafolkken/kit/releases'
-const WORKFLOW_RUNS_URL =
-	'https://api.github.com/repos/joshuafolkken/kit/actions/workflows/publish.yml/runs?per_page=100'
-const WORKFLOW_JOBS_URL = 'https://api.github.com/repos/joshuafolkken/kit/actions/runs'
+const API_ROOT = 'https://api.github.com/repos'
+const LATEST_PATH = '/releases/latest'
+const REPOSITORY_PATTERN = /^[\w.-]+\/[\w.-]+$/u
 const TAG_PATTERN = /^v\d+\.\d+\.\d+(?:[.-][0-9A-Za-z.-]+)?$/u
 const REQUEST_TIMEOUT_MS = 30_000
 const NOT_FOUND_STATUS = 404
-// Tags through v1.887.0 predate automatic GitHub Releases and must not block the first new release.
-const AUTOMATION_START_TAG = 'v1.887.0'
+// A job skipped by its `if:` (or neutral) belongs to a run that succeeded; counting it would skip a
+// lower tag whose release is still on its way.
+const FAILED_CONCLUSIONS = new Set(['failure', 'cancelled', 'timed_out', 'startup_failure'])
 const POLL_INTERVAL_MS = 30_000
 const MAX_WAIT_ATTEMPTS = 120
 const RELEASE_SCHEMA = z.object({ tag_name: z.string().min(1) })
@@ -23,16 +23,42 @@ const JOB_SCHEMA = z.object({
 })
 const RUNS_SCHEMA = z.object({ workflow_runs: z.array(RUN_SCHEMA) })
 const JOBS_SCHEMA = z.object({ jobs: z.array(JOB_SCHEMA) })
-const PREREQUISITES = ['publish-github', 'publish-npm', 'update-production']
 
 type ReleaseRequest = (url: string, init: RequestInit) => Promise<Response>
 type Wait = () => Promise<void>
 
-interface PublishOptions {
+// What differs between repositories. `start_tag` is the last tag that predates automatic releases;
+// without it the latest existing release is the floor. `workflow` names the publish workflow whose
+// failed run lets a lower tag be skipped, and `jobs` the jobs in it that count (empty: every job).
+interface ReleaseSettings {
+	repository: string
+	start_tag?: string | undefined
+	workflow?: string | undefined
+	jobs?: ReadonlyArray<string> | undefined
+}
+
+interface PublishOptions extends ReleaseSettings {
 	tags?: ReadonlyArray<string>
 	wait?: Wait
 }
 
+interface Client {
+	request: ReleaseRequest
+	token: string
+	url: string
+	workflow: string | undefined
+	jobs: ReadonlyArray<string>
+}
+
+// `fallback` answers when no tag sits between the floor and the target; without one the floor itself
+// is the latest release and the answer.
+interface Ladder {
+	tags: ReadonlyArray<string>
+	floor: string | undefined
+	fallback?: () => Promise<string>
+	wait: Wait
+}
+
 function request_options(token: string, method: string, body?: object): RequestInit {
 	return {
 		method,
@@ -46,21 +72,22 @@ function request_options(token: string, method: string, body?: object): RequestI
 	}
 }
 
+async function api_get(client: Client, path: string): Promise<Response> {
+	return await client.request(`${client.url}${path}`, request_options(client.token, 'GET'))
+}
+
+async function api_post(client: Client, path: string, body: object): Promise<Response> {
+	return await client.request(`${client.url}${path}`, request_options(client.token, 'POST', body))
+}
+
 async function read_response(response: Response): Promise<unknown> {
 	if (!response.ok) throw new Error(`GitHub Releases API returned HTTP ${String(response.status)}`)
 
 	return await response.json()
 }
 
-async function existing_release(
-	request: ReleaseRequest,
-	token: string,
-	tag: string,
-): Promise<boolean> {
-	const response = await request(
-		`${API_URL}/tags/${encodeURIComponent(tag)}`,
-		request_options(token, 'GET'),
-	)
+async function existing_release(client: Client, tag: string): Promise<boolean> {
+	const response = await api_get(client, `/releases/tags/${encodeURIComponent(tag)}`)
 	if (response.status === NOT_FOUND_STATUS) return false
 
 	RELEASE_SCHEMA.parse(await read_response(response))
@@ -68,153 +95,183 @@ async function existing_release(
 	return true
 }
 
-async function previous_tag(request: ReleaseRequest, token: string): Promise<string> {
-	const response = await request(`${API_URL}/latest`, request_options(token, 'GET'))
-	const release = RELEASE_SCHEMA.parse(await read_response(response))
+async function previous_tag(client: Client): Promise<string> {
+	const response = await api_get(client, LATEST_PATH)
 
-	return release.tag_name
+	return RELEASE_SCHEMA.parse(await read_response(response)).tag_name
 }
 
-function predecessor(tags: ReadonlyArray<string>, target: string): string | undefined {
+async function latest_release(client: Client): Promise<string | undefined> {
+	const response = await api_get(client, LATEST_PATH)
+	if (response.status === NOT_FOUND_STATUS) return undefined
+
+	return RELEASE_SCHEMA.parse(await read_response(response)).tag_name
+}
+
+function predecessor(
+	tags: ReadonlyArray<string>,
+	target: string,
+	floor: string | undefined,
+): string | undefined {
 	return tags
 		.filter(
-			(tag) => semver.valid(tag) && semver.gt(tag, AUTOMATION_START_TAG) && semver.lt(tag, target),
+			(tag) =>
+				semver.valid(tag) &&
+				(floor === undefined || semver.gt(tag, floor)) &&
+				semver.lt(tag, target),
 		)
 		.toSorted((left, right) => semver.compare(right, left))[0]
 }
 
-function is_failed_job(job: z.infer<typeof JOB_SCHEMA>): boolean {
-	if (job.status !== 'completed' || job.conclusion === 'success') return false
+function is_failed_job(job: z.infer<typeof JOB_SCHEMA>, names: ReadonlyArray<string>): boolean {
+	if (job.status !== 'completed' || !FAILED_CONCLUSIONS.has(job.conclusion ?? '')) return false
+	if (names.length === 0) return true
 
-	return PREREQUISITES.some((name) => job.name === name || job.name.startsWith(`${name} /`))
+	return names.some((name) => job.name === name || job.name.startsWith(`${name} /`))
 }
 
-function publication_failed(jobs: Array<z.infer<typeof JOB_SCHEMA>>): boolean {
-	return jobs.some((job) => is_failed_job(job))
-}
+async function failed_publication(client: Client, tag: string): Promise<boolean> {
+	if (client.workflow === undefined) return false
 
-async function failed_publication(
-	request: ReleaseRequest,
-	token: string,
-	tag: string,
-): Promise<boolean> {
-	const runs_response = await request(WORKFLOW_RUNS_URL, request_options(token, 'GET'))
+	const workflow = encodeURIComponent(client.workflow)
+	const runs_response = await api_get(client, `/actions/workflows/${workflow}/runs?per_page=100`)
 	const runs = RUNS_SCHEMA.parse(await read_response(runs_response)).workflow_runs
 	const run = runs.find((item) => item.display_title === `Publish ${tag}`)
 	if (!run) return false
 
-	const url = `${WORKFLOW_JOBS_URL}/${String(run.id)}/jobs?per_page=100`
-	const jobs_response = await request(url, request_options(token, 'GET'))
+	const jobs_response = await api_get(client, `/actions/runs/${String(run.id)}/jobs?per_page=100`)
+	const { jobs } = JOBS_SCHEMA.parse(await read_response(jobs_response))
 
-	return publication_failed(JOBS_SCHEMA.parse(await read_response(jobs_response)).jobs)
+	return jobs.some((job) => is_failed_job(job, client.jobs))
 }
 
 async function default_wait(): Promise<void> {
 	await setTimeout(POLL_INTERVAL_MS)
 }
 
-async function release_state(
-	request: ReleaseRequest,
-	token: string,
-	tag: string,
-): Promise<'ready' | 'failed' | 'pending'> {
-	if (await existing_release(request, token, tag)) return 'ready'
-	if (await failed_publication(request, token, tag)) return 'failed'
+async function release_state(client: Client, tag: string): Promise<'ready' | 'failed' | 'pending'> {
+	if (await existing_release(client, tag)) return 'ready'
+	if (await failed_publication(client, tag)) return 'failed'
 
 	return 'pending'
 }
 
-async function wait_for_release(
-	request: ReleaseRequest,
-	token: string,
-	tag: string,
-	wait: Wait,
-): Promise<boolean> {
+async function wait_for_release(client: Client, tag: string, wait: Wait): Promise<boolean> {
 	for (let attempt = 0; attempt < MAX_WAIT_ATTEMPTS; attempt += 1) {
-		const state = await release_state(request, token, tag)
+		// eslint-disable-next-line no-await-in-loop -- polling: each read waits on the state the previous one saw
+		const state = await release_state(client, tag)
 		if (state !== 'pending') return state === 'ready'
 
+		// eslint-disable-next-line no-await-in-loop -- polling: each read waits on the state the previous one saw
 		await wait()
 	}
 
 	throw new Error(`Timed out waiting for previous GitHub Release ${tag}`)
 }
 
+async function ladder_end(ladder: Ladder): Promise<string | undefined> {
+	return ladder.fallback ? await ladder.fallback() : ladder.floor
+}
+
+// With no floor the repository has no release at all, so no lower tag will ever gain one: the
+// nearest lower tag is the baseline as it stands, and none means notes without a baseline.
 async function baseline_tag(
-	request: ReleaseRequest,
-	token: string,
+	client: Client,
 	tag: string,
-	options: PublishOptions,
-): Promise<string> {
-	const prior = predecessor(options.tags ?? [], tag)
-	if (!prior) return await previous_tag(request, token)
+	ladder: Ladder,
+): Promise<string | undefined> {
+	const prior = predecessor(ladder.tags, tag, ladder.floor)
+	if (ladder.floor === undefined) return prior
+	if (!prior) return await ladder_end(ladder)
+
+	return (await wait_for_release(client, prior, ladder.wait))
+		? prior
+		: await baseline_tag(client, prior, ladder)
+}
 
-	if (!(await wait_for_release(request, token, prior, options.wait ?? default_wait))) {
-		return await baseline_tag(request, token, prior, options)
+function assert_older(previous: string | undefined, tag: string): void {
+	if (previous !== undefined && !semver.lt(previous, tag)) {
+		throw new Error(`Latest release ${previous} is not older than ${tag}`)
+	}
+}
+
+async function build_ladder(client: Client, options: PublishOptions): Promise<Ladder> {
+	const tags = options.tags ?? []
+	const wait = options.wait ?? default_wait
+	const { start_tag } = options
+
+	if (start_tag !== undefined) {
+		return { tags, wait, floor: start_tag, fallback: async () => await previous_tag(client) }
 	}
 
-	return prior
+	return { tags, wait, floor: await latest_release(client) }
 }
 
 async function generate_notes(
-	request: ReleaseRequest,
-	token: string,
+	client: Client,
 	tag: string,
-	previous: string,
+	previous: string | undefined,
 ): Promise<z.infer<typeof NOTES_SCHEMA>> {
-	const response = await request(
-		`${API_URL}/generate-notes`,
-		request_options(token, 'POST', {
-			tag_name: tag,
-			previous_tag_name: previous,
-			configuration_file_path: '.github/release.yml',
-		}),
-	)
+	const response = await api_post(client, '/releases/generate-notes', {
+		tag_name: tag,
+		...(previous !== undefined && { previous_tag_name: previous }),
+		configuration_file_path: '.github/release.yml',
+	})
 
 	return NOTES_SCHEMA.parse(await read_response(response))
 }
 
 async function create_release(
-	request: ReleaseRequest,
-	token: string,
+	client: Client,
 	tag: string,
-	previous: string,
+	previous: string | undefined,
 ): Promise<void> {
-	const notes = await generate_notes(request, token, tag, previous)
-	const response = await request(
-		API_URL,
-		request_options(token, 'POST', {
-			tag_name: tag,
-			name: notes.name,
-			body: notes.body,
-			draft: false,
-			prerelease: false,
-		}),
-	)
+	const notes = await generate_notes(client, tag, previous)
+	const response = await api_post(client, '/releases', {
+		tag_name: tag,
+		name: notes.name,
+		body: notes.body,
+		draft: false,
+		prerelease: false,
+	})
 
 	RELEASE_SCHEMA.parse(await read_response(response))
 }
 
+function create_client(request: ReleaseRequest, token: string, settings: ReleaseSettings): Client {
+	if (!REPOSITORY_PATTERN.test(settings.repository)) {
+		throw new Error(`Invalid repository: ${settings.repository}`)
+	}
+
+	return {
+		request,
+		token,
+		url: `${API_ROOT}/${settings.repository}`,
+		workflow: settings.workflow,
+		jobs: settings.jobs ?? [],
+	}
+}
+
 async function publish(
 	request: ReleaseRequest,
 	token: string,
 	tag: string,
-	options: PublishOptions = {},
+	options: PublishOptions,
 ): Promise<string> {
 	if (!TAG_PATTERN.test(tag)) throw new Error(`Invalid release tag: ${tag}`)
-	if (await existing_release(request, token, tag)) return 'already-published'
 
-	const previous = await baseline_tag(request, token, tag, options)
+	const client = create_client(request, token, options)
+	if (await existing_release(client, tag)) return 'already-published'
 
-	if (!semver.lt(previous, tag)) {
-		throw new Error(`Latest release ${previous} is not older than ${tag}`)
-	}
+	const previous = await baseline_tag(client, tag, await build_ladder(client, options))
 
-	await create_release(request, token, tag, previous)
+	assert_older(previous, tag)
+	await create_release(client, tag, previous)
 
-	return `published ${tag} from ${previous}`
+	return `published ${tag} from ${previous ?? 'the first commit'}`
 }
 
 const github_release = { publish }
 
+export type { ReleaseSettings }
 export { github_release }

package/scripts/release/release-history.ts

@@ -125,7 +125,6 @@ const release_history = {
 	read_current_version,
 	read_release_plan,
 	BASE_SEARCH_LIMIT,
-	DEFAULT_TIP,
 }
 
 export { release_history }

package/scripts/release/release-plan.ts

@@ -123,7 +123,6 @@ const release_plan = {
 	format_plan,
 	next_version,
 	short_sha,
-	PENDING_ICON,
 }
 
 export { release_plan }

package/scripts/release/release-publish.ts

@@ -1,7 +1,8 @@
+import { git_gh_command } from '#scripts/gh/git-gh-command'
+import { git_pr_checks } from '#scripts/gh/git-pr-checks'
 import { git_command } from '#scripts/git/git-command'
-import { git_gh_command } from '#scripts/git/git-gh-command'
-import { git_pr_checks } from '#scripts/git/git-pr-checks'
 import { git_remote_branch } from '#scripts/git/git-remote-branch'
+import { repository_lock } from '#scripts/git/repository-lock'
 import { write_version } from '#scripts/version/bump-version'
 import { version_targets } from '#scripts/version/version-targets'
 import type { ReleasePlan } from './release-plan'
@@ -20,6 +21,9 @@ const { PACKAGE_JSON } = version_targets
 const SUCCESS_EXIT_CODE = 0
 const FAILURE_EXIT_CODE = 1
 const IGNORE_FOR_RELEASE_LABEL = 'ignore-for-release'
+const RELEASE_LOCK_PREFIX = 'josh-release-lock-'
+// A release waits on CI for minutes, so a second run refuses rather than queueing behind it.
+const RELEASE_LOCK_MAX_WAIT_MS = 0
 
 function branch_name_for(version: string): string {
 	return `release/v${version}`
@@ -87,6 +91,14 @@ async function refuse_existing_branch(branch_name: string): Promise<void> {
 	throw new Error(existing_branch_message(branch_name))
 }
 
+// **The leftovers go before the guard asks** (joshuafolkken/kit#3058). A run cut off before its
+// `finally`, or a `worktree add` that failed after creating its branch, leaves a local
+// `release/v<version>` that the guard would otherwise refuse as a release already opened.
+async function clear_the_way(branch_name: string): Promise<void> {
+	await release_worktree.clear_leftover()
+	await refuse_existing_branch(branch_name)
+}
+
 // **No `checkout -b` and no branch guard here** (joshuafolkken/kit#2411). The work tree is already
 // sitting on the release branch — `release_worktree.create` cut it that way — and the guard ran
 // before that creation, because `worktree_add` makes the branch local and `branch_exists` would then
@@ -121,10 +133,10 @@ async function merge_and_tag(plan: ReleasePlan, branch_name: string): Promise<nu
 // branch guard runs before the tree exists, `process.chdir` points the version write and the git
 // commands at the tree, and the `finally` returns to the root and removes the tree — whichever way
 // the wait ended, so a failed tag watch cleans up rather than leaving debris behind.
-async function publish(plan: ReleasePlan): Promise<number> {
+async function publish_locked(plan: ReleasePlan): Promise<number> {
 	const branch_name = branch_name_for(plan.next_version)
 
-	await refuse_existing_branch(branch_name)
+	await clear_the_way(branch_name)
 
 	const directory = await release_worktree.create(branch_name)
 	const previous_cwd = process.cwd()
@@ -140,6 +152,28 @@ async function publish(plan: ReleasePlan): Promise<number> {
 	}
 }
 
+function release_running_message(target: string): string {
+	return `Another \`pnpm josh release\` is running in this repository (lock \`${target}\`); wait for it to finish, then run it again.`
+}
+
+// **One release at a time per repository, held for the whole run** (joshuafolkken/kit#3058).
+// `clear_leftover` removes an unpushed, commit-less release branch, which is also what a live run
+// looks like while it installs dependencies — so it may only run once no other release is alive. The
+// lock answers that: a run cut off before its `finally` leaves a record whose owner is gone, which
+// `repository_lock` clears on the next claim, while a live owner makes this run refuse at once.
+async function publish(plan: ReleasePlan): Promise<number> {
+	const target = repository_lock.lock_path(RELEASE_LOCK_PREFIX)
+	const exit_code = await repository_lock.with_lock(
+		async () => await publish_locked(plan),
+		target,
+		RELEASE_LOCK_MAX_WAIT_MS,
+	)
+
+	if (exit_code === undefined) throw new Error(release_running_message(target))
+
+	return exit_code
+}
+
 const release_publish = {
 	branch_name_for,
 	commit_message,
@@ -150,7 +184,6 @@ const release_publish = {
 	publish,
 	pull_request_body,
 	unreachable_remote_message,
-	FAILURE_EXIT_CODE,
 	SUCCESS_EXIT_CODE,
 }
 

package/scripts/release/release-scope-cli.ts

@@ -1,6 +1,6 @@
 #!/usr/bin/env tsx
 import { fileURLToPath } from 'node:url'
-import { git_followup_pending } from '#scripts/git/git-followup-pending'
+import { git_followup_pending } from '#scripts/followup/git-followup-pending'
 import { path_decision } from '#scripts/josh/path-decision'
 import { release_plan } from './release-plan'
 
@@ -87,7 +87,6 @@ const release_scope_cli = {
 	main,
 	run,
 	JSON_KEY,
-	KNOWN_FLAGS,
 	NOTHING_PENDING_REASON,
 	RELEASE_HINT,
 	REQUIRED_SCOPE,

package/scripts/release/release-tag.ts

@@ -1,5 +1,5 @@
-import { git_gh_api_path } from '#scripts/git/git-gh-api-path'
-import { git_gh_exec } from '#scripts/git/git-gh-exec'
+import { git_gh_api_path } from '#scripts/gh/git-gh-api-path'
+import { git_gh_exec } from '#scripts/gh/git-gh-exec'
 import { poll, type PollOptions } from '#scripts/lib/poll'
 
 // **The release is not finished when the pull request merges — it is finished when the tag exists.**
@@ -82,12 +82,10 @@ const release_tag = {
 	attempts_for,
 	configured_timeout_seconds,
 	format_result,
-	tag_exists,
 	tag_name,
 	wait_for_tag,
 	DEFAULT_TIMEOUT_SECONDS,
 	TAG_POLL_INTERVAL_MS,
-	TIMEOUT_ENV,
 }
 
 export { release_tag }

package/scripts/release/release-worktree.ts

@@ -1,7 +1,9 @@
 import path from 'node:path'
 import { git_command } from '#scripts/git/git-command'
+import { git_remote_branch } from '#scripts/git/git-remote-branch'
 import { git_worktree } from '#scripts/git/git-worktree'
 import { lane_install } from '#scripts/lane/lane-install'
+import { lane_leftover } from '#scripts/lane/lane-leftover'
 import { lane_paths } from '#scripts/lane/lane-paths'
 
 // The dedicated linked work tree `pnpm josh release` runs inside (joshuafolkken/kit#2411). The whole
@@ -51,18 +53,111 @@ async function install_or_clean(directory: string, branch_name: string): Promise
 // tree on the default branch, so the tree is created directly on the release branch — `git worktree
 // add --no-track -b release/v<version> <dir> origin/<default>`, which `worktree_add` already spells
 // when it is given a start point.
+//
+// **A failed add takes back the branch it made** (joshuafolkken/kit#3058). `git worktree add -b`
+// creates the branch before it looks at the path, so an add refused for a path that already exists
+// still leaves `release/v<version>` behind — and the next run's branch guard then refuses that name
+// as a release already opened. The guard ran before this call and found no such branch, so one
+// present now is this call's own.
+async function add_or_take_back(directory: string, branch_name: string): Promise<void> {
+	const default_branch = await git_command.get_default_branch()
+
+	try {
+		await git_worktree.worktree_add(directory, branch_name, `origin/${default_branch}`)
+	} catch (error) {
+		if (await git_command.branch_exists(branch_name)) await git_worktree.branch_delete(branch_name)
+
+		throw error
+	}
+}
+
 async function create(branch_name: string): Promise<string> {
 	const directory = directory_for(process.cwd())
-	const default_branch = await git_command.get_default_branch()
 
-	await git_worktree.worktree_add(directory, branch_name, `origin/${default_branch}`)
+	await add_or_take_back(directory, branch_name)
 	await install_or_clean(directory, branch_name)
 
 	return directory
 }
 
+// **A run that never reached its `finally` leaves its tree and branch behind** (joshuafolkken/kit#3058)
+// — a Ctrl-C, a closed terminal — and every later release then fails on them until a person removes
+// both by hand. They are cleared here only when clearing loses nothing: a release branch origin does
+// not have and that carries no commit beyond `origin/<default>`. Uncommitted edits in the tree are
+// the version bump the next run writes again, so they are not counted as a loss. A branch that was
+// pushed, or that holds a commit, may be a release still in flight, so it is reported and kept. A
+// live run with neither yet is excluded by the caller: `release_publish.publish` holds the release
+// lock, so no other release is alive when this runs.
+const RELEASE_BRANCH_PATTERN = 'release/v*'
+
+async function leftover_reason(branch_name: string, base: string): Promise<string | undefined> {
+	const answer = await git_remote_branch.ask(branch_name)
+
+	if (answer !== 'absent') return `origin answers \`${answer}\` for it`
+
+	const ahead = await git_command.commit_count_beyond(base, branch_name)
+
+	return ahead === 0 ? undefined : `it holds ${String(ahead)} commit(s) not on \`${base}\``
+}
+
+function kept_message(directory: string, kept: ReadonlyArray<[string, string]>): string {
+	const lines = kept.map(([branch_name, reason]) => `- \`${branch_name}\`: ${reason}`)
+	const commands = [
+		`git worktree remove --force ${directory}`,
+		...kept.map(([branch_name]) => `git branch -D ${branch_name}`),
+	].join('; ')
+
+	return [
+		'A previous `pnpm josh release` left release branches that may still be in use, so nothing was removed:',
+		...lines,
+		`If no release is running, finish or close its pull request, delete the remote branch if it was pushed, then run \`${commands}\` and \`pnpm josh release\` again.`,
+	].join('\n')
+}
+
+async function kept_branches(branches: ReadonlyArray<string>): Promise<Array<[string, string]>> {
+	const base = `origin/${await git_command.get_default_branch()}`
+	const reasons = await Promise.all(branches.map(async (name) => await leftover_reason(name, base)))
+
+	return branches.flatMap((name, index) => {
+		const reason = reasons[index]
+
+		return reason === undefined ? [] : [[name, reason] as [string, string]]
+	})
+}
+
+async function is_registered(directory: string): Promise<boolean> {
+	const listing = await git_worktree.worktree_list()
+
+	return listing.split('\n').includes(`worktree ${directory}`)
+}
+
+// The tree goes before the branches, for the reason `remove` gives. A directory git does not register
+// is `lane_leftover.reclaim`'s to remove or refuse — the same test a lane's leftover path gets.
+// Registration is asked before existence: a directory deleted by hand stays registered, and git
+// refuses to delete a branch a registered tree holds until `worktree remove` drops the registration.
+async function remove_leftover_tree(directory: string): Promise<void> {
+	if (await is_registered(directory)) await git_worktree.worktree_remove(directory)
+	else await lane_leftover.reclaim(directory)
+}
+
+async function clear_leftover(): Promise<void> {
+	const directory = directory_for(process.cwd())
+	const branches = await git_command.branch_names(RELEASE_BRANCH_PATTERN)
+	const kept = await kept_branches(branches)
+
+	if (kept.length > 0) throw new Error(kept_message(directory, kept))
+
+	await remove_leftover_tree(directory)
+
+	for (const branch_name of branches) {
+		// eslint-disable-next-line no-await-in-loop -- each `branch -D` takes the same ref lock
+		await git_worktree.branch_delete(branch_name)
+	}
+}
+
 const release_worktree = {
 	directory_for,
+	clear_leftover,
 	create,
 	remove,
 	RELEASE_WORKTREE_NAME,

package/scripts/repo/auto-merge-setting-logic.ts

@@ -41,7 +41,7 @@ function format_disabled_detail(repo: string | undefined): ReadonlyArray<string>
 		`    off, so ${WORKFLOW_PATH} fails with`,
 		'    `Auto-merge is not allowed for this repository` and Dependabot pull requests stay open.',
 		`    Enable: ${enable_command(repo)}`,
-		`    ${ORIGIN_ISSUE} distributes the workflow; kit never changes a repository setting.`,
+		`    ${ORIGIN_ISSUE} distributes the workflow; kit never changes this setting.`,
 	]
 }
 
@@ -89,9 +89,6 @@ function format_auto_merge_report(
 
 const auto_merge_setting_logic = {
 	SETTING_LABEL,
-	ALLOW_AUTO_MERGE_FIELD,
-	WORKFLOW_PATH,
-	enable_command,
 	classify_auto_merge,
 	format_auto_merge_report,
 }

package/scripts/repo/repo-setting.ts

@@ -1,4 +1,4 @@
-import { git_gh_exec } from '#scripts/git/git-gh-exec'
+import { git_gh_exec } from '#scripts/gh/git-gh-exec'
 import { PROJECT_ROOT } from '#scripts/init/init-paths'
 
 // The shared half of every "report a GitHub repository setting kit cannot write" check.

package/scripts/repo/repository-labels.ts

@@ -1,5 +1,5 @@
-import { git_gh_exec } from '#scripts/git/git-gh-exec'
-import { REPOSITORY_LABELS, type LabelDefinition } from '#scripts/git/issue-labels'
+import { git_gh_exec } from '#scripts/gh/git-gh-exec'
+import { REPOSITORY_LABELS, type LabelDefinition } from '#scripts/issue/issue-labels'
 
 // Creates the labels kit's workflow and the distributed `pr-classification.yml` rely on, and only
 // those the repository is missing (joshuafolkken/kit#2797). The one place labels are created: `josh
@@ -86,6 +86,6 @@ function ensure_labels(repo: string | undefined): ReadonlyArray<string> {
 	return create_missing(missing_labels(existing), repo)
 }
 
-const repository_labels = { missing_labels, ensure_labels }
+const repository_labels = { ensure_labels }
 
 export { repository_labels }