@joshuafolkken/kit 1.1178.0 → 1.1229.0

package/scripts/gate/project-checks.ts

@@ -2,6 +2,7 @@ import { existsSync, globSync, readFileSync } from 'node:fs'
 import path from 'node:path'
 import { find_local_bin_upwards } from '#scripts/build/local-bin'
 import { project_profile } from '#scripts/init/project-profile'
+import { ancestor_directories } from '#scripts/lib/ancestor-directories'
 import { json_value } from '#scripts/lib/json-value'
 import { SKIP_MARKER } from '#scripts/test/skip-marker'
 import { z } from 'zod'
@@ -43,15 +44,11 @@ const DEPENDENCY_FIELDS = ['dependencies', 'devDependencies']
 const object_schema = z.record(z.string(), z.unknown())
 
 function project_root(directory: string): string {
-	let current = directory
-
-	while (!existsSync(path.join(current, PACKAGE_JSON))) {
-		const parent = path.dirname(current)
-		if (parent === current) return directory
-		current = parent
-	}
-
-	return current
+	return (
+		ancestor_directories.nearest(directory, (candidate) =>
+			existsSync(path.join(candidate, PACKAGE_JSON)),
+		) ?? directory
+	)
 }
 
 function is_ignored(entry: string): boolean {

package/scripts/gate/type-check-step.ts

@@ -1,4 +1,5 @@
 import { find_local_bin_upwards } from '#scripts/build/local-bin'
+import { COMMAND_TIMEOUT_MS } from '#scripts/lib/timeouts'
 import { execa } from 'execa'
 
 // joshuafolkken/kit#934: `josh gate`'s type-check step used to be `tsc --noEmit` for every project.
@@ -28,8 +29,6 @@ const TOOLKIT_BINS: ReadonlyArray<string> = ['josh-app', 'josh-game']
 // a bracketed warning printed first would otherwise be read as the command list.
 const USAGE_COMMANDS_PATTERN = /Usage:[^<>\n]*<([^<>\n]+)>/u
 const COMMAND_SEPARATOR = '|'
-// A toolkit that prints its usage answers in milliseconds; anything slower is hung.
-const USAGE_TIMEOUT_MS = 30_000
 
 function parse_usage_commands(output: string): ReadonlyArray<string> {
 	const group = USAGE_COMMANDS_PATTERN.exec(output)?.[1]
@@ -46,7 +45,7 @@ async function read_toolkit_commands(bin_path: string): Promise<ReadonlyArray<st
 		const result = await execa(bin_path, [], {
 			all: true,
 			reject: false,
-			timeout: USAGE_TIMEOUT_MS,
+			timeout: COMMAND_TIMEOUT_MS,
 		})
 
 		return parse_usage_commands(result.all)

package/scripts/gate/verification-gate.ts

@@ -4,6 +4,7 @@ import { fileURLToPath } from 'node:url'
 import type { FileMapStamp } from '#scripts/josh/file-map-stamp'
 import { GATE_COMMAND } from '#scripts/josh/josh-command-types'
 import { composite_arguments, USAGE_ERROR_EXIT_CODE } from '#scripts/josh/josh-composite-arguments'
+import { lane_ledger } from '#scripts/lane/lane-ledger'
 import { bounded_pool } from '#scripts/lib/bounded-pool'
 import { buffered_process, FAIL_EXIT_CODE } from '#scripts/lib/buffered-process'
 import { review_stamps } from '#scripts/review/review-stamps'
@@ -166,7 +167,7 @@ interface BudgetContext {
 function default_budget(): BudgetContext {
 	return {
 		available_cores: availableParallelism(),
-		is_reserved: !unit_worker_share.is_nested_run(),
+		is_reserved: !unit_worker_share.is_nested_run() && !core_budget.is_held(),
 	}
 }
 
@@ -222,10 +223,17 @@ async function run_gate_steps(
 ): Promise<ReadonlyArray<GateStepResult>> {
 	const reserved = await build_reserved_steps(process.cwd(), plan, budget.available_cores)
 
-	return await bounded_pool.bounded_map(
-		reserved,
-		plan.concurrency,
-		async (entry) => await run_reserved_step(entry, budget),
+	// **The checks run under the held mark, so a check's own dispatch claims nothing**
+	// (joshuafolkken/kit#3345). Each check is a `pnpm josh <target>` child, and a target that declares
+	// a weight would otherwise claim a second place for the cores reserved for it here. A nested gate
+	// sets the mark too, since its checks are covered by the outer gate's reservation.
+	return await core_budget.with_held_mark(
+		async () =>
+			await bounded_pool.bounded_map(
+				reserved,
+				plan.concurrency,
+				async (entry) => await run_reserved_step(entry, budget),
+			),
 	)
 }
 
@@ -299,6 +307,9 @@ interface GateOptions {
 	// The scoped records' paths, overridable so a test can plant a green pair rather than depend on the
 	// surrounding checkout's — the reason `scoped-green.ts` takes a `source` per stamp.
 	scoped_sources?: ScopedSources
+	// The lane ledger a finished gate's duration is appended to (joshuafolkken/kit#3355). Only the CLI
+	// entry resolves it, so a suite driving the gate never writes a measurement of checks that never ran.
+	ledger_path?: string | undefined
 }
 
 // **The gate refuses to start when the scoped pair has not been green on this tree**
@@ -339,14 +350,20 @@ async function settle_gate(
 	tree: GateTree,
 	options: GateOptions & { started_at: number },
 ): Promise<number> {
+	const elapsed_ms = performance.now() - options.started_at
 	const failed_labels = gate_report.report_gate_steps(results, {
 		is_verbose: options.is_verbose ?? false,
 		log_path: options.log_path,
-		elapsed_ms: performance.now() - options.started_at,
+		elapsed_ms,
 		step_count: String(plan.checks.length),
 	})
+	const is_passed = failed_labels.length === 0
 
-	if (failed_labels.length > 0) return FAIL_EXIT_CODE
+	if (options.ledger_path !== undefined) {
+		await lane_ledger.record_gate(options.ledger_path, elapsed_ms, is_passed)
+	}
+
+	if (!is_passed) return FAIL_EXIT_CODE
 
 	await record_whole_gate(plan, results, tree, options)
 
@@ -474,7 +491,9 @@ async function run_gate_command(
 // summary, written last, is the first thing lost. Setting the code lets the writes drain and the
 // process end on its own, which it can, since every child has already exited by here.
 if (process.argv[1] === fileURLToPath(import.meta.url)) {
-	process.exitCode = await run_gate_command(process.argv.slice(FIRST_ARGUMENT_INDEX))
+	process.exitCode = await run_gate_command(process.argv.slice(FIRST_ARGUMENT_INDEX), {
+		ledger_path: await lane_ledger.target(),
+	})
 }
 
 const verification_gate = {

package/scripts/gh/git-gh-api-path.ts

@@ -14,8 +14,8 @@ const FULL_PAGE_QUERY = '?per_page=100'
 // `gh api` expands `{owner}` and `{repo}` from the current repository, so the unqualified form needs
 // no extra lookup to name a path. An explicit `repo` names another repository — the form a
 // cross-repository reference takes.
-function repo_api_path(repo?: string): string {
-	return `repos/${repo ?? '{owner}/{repo}'}`
+function repo_api_path(repo = '{owner}/{repo}'): string {
+	return `repos/${repo}`
 }
 
 // The issue collection — what a listing pages through and what a creation posts to. One segment,

package/scripts/gh/git-gh-issue-rest.ts

@@ -1,8 +1,8 @@
+import { blocking_issue_schema } from '#scripts/git/git-schemas'
 import {
 	parse_json_array_or_undefined,
 	parse_json_object_safe,
 } from '#scripts/git/parse-json-array'
-import { blocking_issue_schema } from '#scripts/git/schemas'
 import type { IssueReference } from '#scripts/issue/issue-reference'
 import { z } from 'zod'
 import { MERGED_STATE, to_gh_state } from './git-gh-rest-state'
@@ -163,8 +163,8 @@ function empty_blocked_by(): BlockedBy {
 // repository and names a different issue there (joshuafolkken/kit#1126). Undefined when the field is
 // absent or shaped otherwise; the caller then falls back to the repository it is reading in, which is
 // what an unqualified relation has always meant.
-function repo_of_url(repository_url: string | undefined): string | undefined {
-	const match = REPOSITORY_URL.exec(repository_url ?? '')
+function repo_of_url(repository_url: string | undefined = ''): string | undefined {
+	const match = REPOSITORY_URL.exec(repository_url)
 
 	return match?.[REPOSITORY_URL_GROUP]
 }

package/scripts/gh/git-gh-issue-write.ts

@@ -29,6 +29,7 @@ const DELETE_METHOD = 'DELETE'
 // object, so the same value is unwrapped out of it rather than the shape being changed.
 const HTML_URL_FILTER = '.html_url'
 const ID_FILTER = '.id'
+const LABEL_NAMES_FILTER = '.[].name'
 
 const LABELS_SEGMENT = '/labels'
 const COMMENTS_SEGMENT = '/comments'
@@ -182,17 +183,60 @@ async function issue_create_with_label(input: {
 	)
 }
 
+// The outcome of applying one label, with the swallowed failure's gist kept for a caller that has to
+// say why it refused (joshuafolkken/kit#3312).
+type LabelWrite = { is_applied: true } | { is_applied: false; reason: string }
+
+// The issue's label names, read back after a failed write. A read that itself fails answers
+// `undefined`, which the caller treats as "not applied" — the write's own error is the reason then.
+async function read_label_names(issue_number: string): Promise<Array<string> | undefined> {
+	try {
+		const raw = await git_gh_exec.exec_gh_api({
+			path: `${git_gh_api_path.issue_api_path(issue_number)}${LABELS_SEGMENT}`,
+			should_paginate: true,
+			jq_filter: LABEL_NAMES_FILTER,
+		})
+
+		return raw.split('\n').map((name) => name.trim())
+	} catch (error) {
+		error_text.trace_swallowed('git_gh_issue_write.read_label_names', error)
+
+		return undefined
+	}
+}
+
+// **A failed answer is not a failed write.** The POST is idempotent, and a timeout, a non-zero exit
+// after the write or a secondary rate limit can each throw after the label landed — which refused a
+// lane dispatch whose label was in fact applied (joshuafolkken/kit#3312). So a throw is confirmed by
+// reading the labels back, and only a label that is really absent answers `is_applied: false`.
+async function issue_apply_label(issue_number: string, label: string): Promise<LabelWrite> {
+	const labels_path = `${git_gh_api_path.issue_api_path(issue_number)}${LABELS_SEGMENT}`
+
+	try {
+		await git_gh_exec.exec_gh_api({ path: labels_path, body: JSON.stringify({ labels: [label] }) })
+
+		return { is_applied: true }
+	} catch (error) {
+		const names = await read_label_names(issue_number)
+
+		if (names?.includes(label) === true) return { is_applied: true }
+		error_text.trace_swallowed('git_gh_issue_write.issue_apply_label', error)
+
+		// The first line is the gist: gh follows it with the response body, which a one-line refusal
+		// does not need.
+		const [gist = ''] = error_text.message_of(error).split('\n', 1)
+
+		return { is_applied: false, reason: gist }
+	}
+}
+
 // Applied after the body edit so a failure leaves an issue with the epic sections and no label,
 // which `epic:check` reports — rather than a labelled issue with nothing to track. The caller checks
 // the return: the label is what the auto-close filters on (joshuafolkken/kit#865).
 async function issue_add_label(issue_number: string, label: string): Promise<boolean> {
-	return await did_write_succeed(
-		async () =>
-			await git_gh_exec.exec_gh_api({
-				path: `${git_gh_api_path.issue_api_path(issue_number)}${LABELS_SEGMENT}`,
-				body: JSON.stringify({ labels: [label] }),
-			}),
-	)
+	const write = await issue_apply_label(issue_number, label)
+
+	return write.is_applied
 }
 
 // The counterpart to the addition above, for a run taking its own marker back off
@@ -279,6 +323,7 @@ const git_gh_issue_write = {
 	label_ensure,
 	issue_create_request,
 	issue_create_with_label,
+	issue_apply_label,
 	issue_add_label,
 	issue_remove_label,
 	issue_add_blocked_by,
@@ -286,3 +331,4 @@ const git_gh_issue_write = {
 }
 
 export { git_gh_issue_write }
+export type { LabelWrite }

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

@@ -89,9 +89,24 @@ interface PullMergeState {
 type PullNumberRead =
 	{ kind: 'read'; pr_number: number } | { kind: 'missing' } | { kind: 'unreadable'; cause: unknown }
 
+// The branch-keyed detail read, in the same three answers. `missing` and `unreadable` are the
+// resolution's own; `unreadable` also covers a resolved number whose detail read failed, which every
+// branch-keyed reader used to fold into "no pull request" (joshuafolkken/kit#3263).
+type PullRead = Exclude<PullNumberRead, { kind: 'read' }> | { kind: 'read'; pull: RestPull }
+
 // The lookups still in flight, keyed the same way the resolved numbers are.
 const pending_pr_number_by_branch = new Map<string, Promise<PullNumberRead>>()
 
+// The detail reads, keyed by number and remembered for the life of the command
+// (joshuafolkken/kit#3263). `josh followup` asks `pr_get_body` and `pr_get_url` in one tick — the
+// same `GET /pulls/{N}` each time. The promise is stored, so readers in one tick share the request as
+// well as its answer; a read that fails is dropped and re-tried, the rule the number memo holds.
+// **Every write to a pull request clears it** through `forget_pr_numbers`, and the two state readers
+// never read it: `pr_get_merge_state` answers where the pull request stands *now*, which `josh ship`
+// asks again after every merge it pushes, and `pr_view` decides whether `josh git -y` writes onto the
+// pull request — after a commit and a push its preflight read would otherwise outlast.
+const pull_by_number = new Map<number, Promise<RestPull>>()
+
 async function fetch_pr_number_read(branch_name: string): Promise<PullNumberRead> {
 	try {
 		const pr_number = await fetch_pr_number(branch_name)
@@ -130,10 +145,11 @@ async function start_pr_number_read(branch_name: string): Promise<PullNumberRead
 	}
 }
 
-// Defined after the map it clears, so the two memos are declared before anything reaches them.
+// Defined after the maps it clears, so the memos are declared before anything reaches them.
 function forget_pr_numbers(): void {
 	pr_number_by_branch.clear()
 	pending_pr_number_by_branch.clear()
+	pull_by_number.clear()
 }
 
 async function read_pr_number(branch_name: string): Promise<PullNumberRead> {
@@ -144,9 +160,9 @@ async function read_pr_number(branch_name: string): Promise<PullNumberRead> {
 }
 
 // `undefined` covers both "this branch has no pull request" and "the lookup failed", which is the
-// distinction `gh pr view` never made either — every *read* here folds them together on purpose:
-// `pr_view` answers the empty string either way, the comment readers `undefined`. The two callers
-// that act on the absence rather than displaying it — `require_pr_number` and `pr_exists` — opt out.
+// distinction `gh pr view` never made either — the *display* reads here fold them together on
+// purpose: the comment readers answer `undefined` either way. The callers that act on the absence
+// rather than displaying it — `require_pr_number`, `pr_exists` and `pr_view` — opt out.
 async function resolve_pr_number(branch_name: string): Promise<number | undefined> {
 	const read = await read_pr_number(branch_name)
 
@@ -186,19 +202,43 @@ async function read_pull(pr_number: number): Promise<RestPull> {
 	return git_gh_pr_rest.parse_rest_pull(json)
 }
 
+// The identity check keeps a failure from evicting a read that `forget_pr_numbers` already replaced.
+async function read_remembered_pull(pr_number: number): Promise<RestPull> {
+	const pending = pull_by_number.get(pr_number) ?? read_pull(pr_number)
+
+	pull_by_number.set(pr_number, pending)
+
+	try {
+		return await pending
+	} catch (error) {
+		if (pull_by_number.get(pr_number) === pending) pull_by_number.delete(pr_number)
+		throw error
+	}
+}
+
 // One pull request named by its branch: the resolution, then the detail read that carries
 // `mergeable` and `mergeable_state`, which the lookup listing does not.
-async function read_pull_of_branch(branch_name: string): Promise<RestPull | undefined> {
-	const pr_number = await resolve_pr_number(branch_name)
-	if (pr_number === undefined) return undefined
+async function read_pull_of_branch(
+	branch_name: string,
+	read: (pr_number: number) => Promise<RestPull> = read_remembered_pull,
+): Promise<PullRead> {
+	const number_read = await read_pr_number(branch_name)
+	if (number_read.kind !== 'read') return number_read
 
 	try {
-		return await read_pull(pr_number)
-	} catch {
-		return undefined
+		return { kind: 'read', pull: await read(number_read.pr_number) }
+	} catch (error) {
+		return { kind: 'unreadable', cause: error }
 	}
 }
 
+// The display readers' fold: "no pull request" and "nothing could be read" are one empty answer.
+async function read_pull_or_undefined(branch_name: string): Promise<RestPull | undefined> {
+	const read = await read_pull_of_branch(branch_name)
+
+	return read.kind === 'read' ? read.pull : undefined
+}
+
 // **`false` means the branch has no pull request, and nothing else.** This is the second half of
 // joshuafolkken/kit#1048's distinction, on the caller that needs it most: `pr_exists` is not read for
 // display, it decides whether `git-pr.ts` **opens** a pull request. Folding an unreadable lookup into
@@ -218,7 +258,7 @@ async function pr_get_number(branch_name: string): Promise<number | undefined> {
 }
 
 async function pr_get_url(branch_name: string): Promise<string | undefined> {
-	const pull = await read_pull_of_branch(branch_name)
+	const pull = await read_pull_or_undefined(branch_name)
 	if (pull?.html_url === undefined) return undefined
 
 	return git_gh_helpers.parse_pr_state_string(pull.html_url)
@@ -229,9 +269,11 @@ async function pr_get_url(branch_name: string): Promise<string | undefined> {
 // made on GitHub moves without touching the local branch. `undefined` covers both "no pull request"
 // and "nothing could be read": `followup` then takes its ordinary path, whose merge step settles a
 // pull request that did merge after all (`pr_merge`), so an unread answer costs a wait, not a wrong tail.
+// Read past the detail memo: `josh ship` asks it again after each merge it pushes (joshuafolkken/kit#3263).
 async function pr_get_merge_state(branch_name: string): Promise<PullMergeState | undefined> {
-	const pull = await read_pull_of_branch(branch_name)
-	if (pull === undefined) return undefined
+	const read = await read_pull_of_branch(branch_name, read_pull)
+	if (read.kind !== 'read') return undefined
+	const { pull } = read
 
 	return {
 		is_merged: git_gh_pr_rest.is_merged(pull),
@@ -244,19 +286,22 @@ async function pr_get_merge_state(branch_name: string): Promise<PullMergeState |
 // REST answers JSON null for a pull request with no body where `gh --json body` answered an empty
 // string, and both used to arrive here as the empty answer this folds to `undefined`.
 async function pr_get_body(branch_name: string): Promise<string | undefined> {
-	const pull = await read_pull_of_branch(branch_name)
+	const pull = await read_pull_or_undefined(branch_name)
 	const body = pull?.body
 
 	return typeof body === 'string' && body.length > 0 ? body : undefined
 }
 
-// The empty string means "there is nothing to read" — a branch with no pull request, or a read that
-// failed. `git-pr.ts` checks the length before parsing.
+// The empty string means "this branch has no pull request", and nothing else. A read that failed
+// throws, carrying gh's reason as the `cause`: `git-pr.ts` decides from this state whether the
+// branch's pull request merged, and a rate limit answered as "no state" sent a merged pull request
+// down the open one's path (joshuafolkken/kit#3263). Read past the detail memo, like the merge state.
 async function pr_view(branch_name: string): Promise<string> {
-	const pull = await read_pull_of_branch(branch_name)
-	if (pull === undefined) return ''
+	const read = await read_pull_of_branch(branch_name, read_pull)
+	if (read.kind === 'unreadable') throw to_unreadable_error(branch_name, read.cause)
+	if (read.kind === 'missing') return ''
 
-	return JSON.stringify(git_gh_pr_rest.to_pr_info(pull))
+	return JSON.stringify(git_gh_pr_rest.to_pr_info(read.pull))
 }
 
 // `undefined` when the listing could not be read — a failed request, or a PR whose number could not

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

@@ -1,8 +1,8 @@
+import { rest_comment_schema } from '#scripts/git/git-schemas'
 import {
 	parse_json_array_or_undefined,
 	parse_json_object_safe,
 } from '#scripts/git/parse-json-array'
-import { rest_comment_schema } from '#scripts/git/schemas'
 import { z } from 'zod'
 import { MERGED_STATE, to_gh_state } from './git-gh-rest-state'
 

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

@@ -152,10 +152,12 @@ async function pr_comment(branch_name: string, body: string): Promise<string> {
 
 // Replaces the body of the branch's open pull request. `git -y` opens a pull request once, so a
 // body supplied on a later run — the live-execution evidence `followup` gates the merge on
-// (joshuafolkken/kit#2446) — reaches an already-open one only through this write.
+// (joshuafolkken/kit#2446) — reaches an already-open one only through this write. The remembered
+// detail read holds the old body, so it is cleared first (joshuafolkken/kit#3263).
 async function pr_update_body(branch_name: string, body: string): Promise<void> {
 	const pr_number = await require_pr_number(branch_name)
 
+	forget_pr_numbers()
 	await git_gh_exec.exec_gh_api({
 		path: git_gh_api_path.pull_api_path(String(pr_number)),
 		method: PATCH_METHOD,
@@ -163,7 +165,9 @@ async function pr_update_body(branch_name: string, body: string): Promise<void>
 	})
 }
 
+// A merge moves the remembered detail read's state, so it is cleared first (joshuafolkken/kit#3263).
 async function put_merge(pr_number: number): Promise<void> {
+	forget_pr_numbers()
 	await git_gh_exec.exec_gh_api({
 		path: git_gh_api_path.pull_merge_api_path(String(pr_number)),
 		method: PUT_METHOD,

package/scripts/gh/git-pr-ai-review.ts

@@ -1,6 +1,6 @@
 // cspell:words coderabbit coderabbitai
+import { ai_review_pull_comment_schema } from '#scripts/git/git-schemas'
 import { parse_json_array_or_undefined } from '#scripts/git/parse-json-array'
-import { ai_review_pull_comment_schema } from '#scripts/git/schemas'
 import {
 	classify_ai_review_comments,
 	type ClassifiedFinding,

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

@@ -191,9 +191,7 @@ function evaluate_pr_state(snapshot: PrStateSnapshot): PrEvaluation {
 
 	if (failure !== undefined) return failure
 
-	if (is_mergeable_state(snapshot) && is_every_required_passing(statuses)) {
-		return 'success'
-	}
+	if (is_mergeable_state(snapshot) && is_every_required_passing(statuses)) return 'success'
 
 	return 'pending'
 }

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

@@ -1,4 +1,4 @@
-import { pr_raw_schema, type RollupItemData } from '#scripts/git/schemas'
+import { pr_raw_schema, type RollupItemData } from '#scripts/git/git-schemas'
 import { json_value } from '#scripts/lib/json-value'
 
 const CHECK_STATUS_PASS = 'pass'

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

@@ -7,7 +7,6 @@ import {
 	SECONDS_TO_MS,
 	wait_for_pr_success,
 	type PrStateEvaluator,
-	type ReviewDecisionPredicate,
 } from './git-pr-checks'
 import { is_coderabbit_check, is_required_check, type PrEvaluation } from './git-pr-checks-eval'
 import {
@@ -116,12 +115,14 @@ function describe_checks_failure(snapshot: PrStateSnapshot): string {
 // **The watch never reads `review_decision`**, so the poll must not spend a request fetching it. It
 // is the same difference `evaluate_checks_settled` is written for, said to the fetcher instead of to
 // the verdict: three requests a poll rather than four (joshuafolkken/kit#1043).
-const SHOULD_NEVER_READ_REVIEW_DECISION: ReviewDecisionPredicate = () => false
+function should_never_read_review_decision(): boolean {
+	return false
+}
 
 const CHECKS_SETTLED_EVALUATOR: PrStateEvaluator = {
 	evaluate: evaluate_checks_settled,
 	describe: describe_checks_failure,
-	should_read_review_decision: SHOULD_NEVER_READ_REVIEW_DECISION,
+	should_read_review_decision: should_never_read_review_decision,
 }
 
 async function watch_until_settled(branch_name: string): Promise<void> {
@@ -145,7 +146,7 @@ async function watch_until_settled(branch_name: string): Promise<void> {
 // from failing on the first read: two minutes is the grace, and an empty rollup at the end of them
 // is the answer `gh` gave immediately.
 async function fail_when_no_checks(branch_name: string): Promise<void> {
-	const snapshot = await default_fetch_pr_state(branch_name, SHOULD_NEVER_READ_REVIEW_DECISION)
+	const snapshot = await default_fetch_pr_state(branch_name, should_never_read_review_decision)
 	if (snapshot.rollup.length === 0) throw new Error(NO_CHECKS_MESSAGE)
 }
 
@@ -173,7 +174,7 @@ export {
 	git_pr_checks_watch,
 	fail_when_no_checks,
 	CHECKS_SETTLED_EVALUATOR,
-	SHOULD_NEVER_READ_REVIEW_DECISION,
+	should_never_read_review_decision,
 	evaluate_checks_settled,
 	is_awaited_check,
 	describe_checks_failure,

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

@@ -1,4 +1,4 @@
-import { package_name_schema } from '#scripts/git/schemas'
+import { package_name_schema } from '#scripts/git/git-schemas'
 import { poll } from '#scripts/lib/poll'
 import { git_gh_pr_auto_merge } from './git-gh-pr-auto-merge'
 import { git_gh_pr_snapshot } from './git-gh-pr-snapshot'
@@ -87,7 +87,9 @@ type ReviewDecisionPredicate = (snapshot: PrStateSnapshot) => boolean
 
 // The conservative answer, and the one every evaluator that does not say gets: read it every poll,
 // which is what all of them did before the predicate existed.
-const SHOULD_ALWAYS_READ_REVIEW_DECISION: ReviewDecisionPredicate = () => true
+function should_always_read_review_decision(): boolean {
+	return true
+}
 
 type PrStateFetcher = (
 	branch_name: string,
@@ -199,7 +201,7 @@ async function read_pr_state(
 	try {
 		const snapshot = await input.options.fetcher(
 			input.options.branch_name,
-			evaluator.should_read_review_decision ?? SHOULD_ALWAYS_READ_REVIEW_DECISION,
+			evaluator.should_read_review_decision ?? should_always_read_review_decision,
 		)
 
 		return { kind: 'read', snapshot }
@@ -297,7 +299,7 @@ async function wait_for_pr_success(options: WaitForPrSuccessOptions): Promise<Pr
 // (joshuafolkken/kit#1043).
 async function default_fetch_pr_state(
 	branch_name: string,
-	should_read_review_decision: ReviewDecisionPredicate = SHOULD_ALWAYS_READ_REVIEW_DECISION,
+	should_read_review_decision: ReviewDecisionPredicate = should_always_read_review_decision,
 ): Promise<PrStateSnapshot> {
 	const checks = await git_gh_pr_snapshot.pr_get_checks_snapshot(branch_name)
 	const snapshot = parse_pr_state_snapshot(checks.snapshot_json)
@@ -385,7 +387,7 @@ export {
 	is_pr_checks_timeout,
 	default_fetch_pr_state,
 	MERGE_GATE_EVALUATOR,
-	SHOULD_ALWAYS_READ_REVIEW_DECISION,
+	should_always_read_review_decision,
 }
 export type { MergeProgress, PrStateFetcher, PrStateEvaluator, ReviewDecisionPredicate }
 export {

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

@@ -1,5 +1,5 @@
+import { pull_comment_schema } from '#scripts/git/git-schemas'
 import { parse_json_array_or_undefined } from '#scripts/git/parse-json-array'
-import { pull_comment_schema } from '#scripts/git/schemas'
 import { git_gh_command } from './git-gh-command'
 import { has_ignore_reason } from './git-pr-ai-review'
 

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

@@ -8,9 +8,7 @@ function has_error_cause(error: Error): boolean {
 
 function is_pr_already_exists_error(error: unknown): boolean {
 	if (error instanceof Error) {
-		if (is_pr_already_exists_message(error.message)) {
-			return true
-		}
+		if (is_pr_already_exists_message(error.message)) return true
 
 		return has_error_cause(error)
 	}

package/scripts/gh/git-pr.ts

@@ -1,6 +1,6 @@
 import { pr_classification, type ReleaseClassification } from '#scripts/ci/pr-classification'
 import type { IssueInfo } from '#scripts/git/git-issue'
-import { pr_info_schema } from '#scripts/git/schemas'
+import { pr_info_schema } from '#scripts/git/git-schemas'
 import { animation_helpers, type AnimationOptions } from '#scripts/lib/animation-helpers'
 import { git_gh_command } from './git-gh-command'
 import { git_pr_error } from './git-pr-error'
@@ -98,18 +98,14 @@ function parse_pr_state(pr_info_json: string): string | undefined {
 	}
 }
 
-async function get_pr_state_safe(branch_name: string): Promise<string | undefined> {
-	try {
-		const pr_info_json = await git_gh_command.pr_view(branch_name)
+// A read that failed throws rather than answering `undefined`: "no state" is read as "not merged",
+// which would write onto a pull request that already merged (joshuafolkken/kit#3263).
+async function get_pr_state(branch_name: string): Promise<string | undefined> {
+	const pr_info_json = await git_gh_command.pr_view(branch_name)
 
-		if (pr_info_json.length === 0) {
-			return undefined
-		}
+	if (pr_info_json.length === 0) return undefined
 
-		return parse_pr_state(pr_info_json)
-	} catch {
-		return undefined
-	}
+	return parse_pr_state(pr_info_json)
 }
 
 function is_pr_state_merged(pr_state: string | undefined): boolean {
@@ -137,7 +133,7 @@ async function handle_existing_pr(
 	branch_name: string,
 	options: { label: ReleaseClassification; should_replace_body: boolean },
 ): Promise<void> {
-	const pr_state_result = await get_pr_state_safe(branch_name)
+	const pr_state_result = await get_pr_state(branch_name)
 
 	if (is_pr_state_merged(pr_state_result)) {
 		git_pr_messages.display_merged_pr_message()
@@ -181,7 +177,7 @@ function build_body(issue_info: IssueInfo, extra_body?: string): string {
 
 async function existing_pr_label(branch_name: string): Promise<ReleaseClassification | undefined> {
 	if (!(await git_gh_command.pr_exists(branch_name))) return undefined
-	if (is_pr_state_merged(await get_pr_state_safe(branch_name))) return undefined
+	if (is_pr_state_merged(await get_pr_state(branch_name))) return undefined
 
 	return await git_gh_command.pr_get_classification(branch_name)
 }

package/scripts/gh/github-issue-url.ts

@@ -75,8 +75,8 @@ function build_target(match: RegExpExecArray): ParsedUrl {
 	}
 }
 
-function parse_with(pattern: RegExp, url: string | undefined): ParsedUrl | undefined {
-	const match = pattern.exec(url ?? '')
+function parse_with(pattern: RegExp, url: string | undefined = ''): ParsedUrl | undefined {
+	const match = pattern.exec(url)
 	if (match === null) return undefined
 
 	return build_target(match)