@joshuafolkken/kit 1.1178.0 → 1.1240.0

package/scripts/gate/gate-report.ts

@@ -25,6 +25,8 @@ interface GateStepResult extends BufferedProcessResult {
 	// What was actually run. The type check's command is resolved per project, so a failure on the
 	// `check` step is only reproducible if the header names the command rather than the label.
 	command: string
+	// Set when the check started past the machine-wide budget at the wait cap (joshuafolkken/kit#3371).
+	budget_note?: string | undefined
 }
 
 function is_gate_step_failed(result: GateStepResult): boolean {
@@ -141,25 +143,42 @@ function format_failure_actions(failed: ReadonlyArray<GateStepResult>): string {
 	return `${GATE_COMMAND} — next:\n${lines.join('\n')}\n`
 }
 
+// **A check that started past the core budget is said in the summary, not only in the log**
+// (joshuafolkken/kit#3371). The wait cap admits a check that waited two minutes whatever the budget says,
+// so a gate that ran over-subscribed would otherwise look exactly like one that fitted. The icon is
+// local rather than in `status-icons.ts` because nothing reads this line back.
+const WARN_ICON = '⚠'
+
+function format_budget_notes(results: ReadonlyArray<GateStepResult>): string {
+	const lines = results.flatMap((result) =>
+		result.budget_note === undefined
+			? []
+			: `  ${WARN_ICON} ${result.label} — ${result.budget_note}`,
+	)
+
+	return lines.length === 0 ? '' : `${lines.join('\n')}\n`
+}
+
 // The total is wall-clock for the whole command, not the sum of the four — they run concurrently,
 // so a sum would report about three times what the caller waited.
 //
 // The failure actions and the log path are printed with the summary and immediately **above** the
 // verdict line, which stays last for the reason `josh-verdict.ts` gives (joshuafolkken/kit#1227).
 function print_gate_summary(
-	failed: ReadonlyArray<GateStepResult>,
-	elapsed_ms: number,
-	step_count: string,
+	results: ReadonlyArray<GateStepResult>,
+	report: GateReport,
 	log_path?: string,
 ): void {
-	const total = format_seconds(elapsed_ms)
+	const failed = results.filter((result) => is_gate_step_failed(result))
+	const total = format_seconds(report.elapsed_ms)
 	const verdict =
 		failed.length === 0
-			? josh_verdict.format_gate_passed(step_count, total)
+			? josh_verdict.format_gate_passed(report.step_count, total)
 			: josh_verdict.format_gate_failed(failed.map((result) => result.label).join(', '), total)
+	const notes = format_budget_notes(results)
 
 	process.stdout.write(
-		`\n${format_failure_actions(failed)}${gate_log.format_log_notice(log_path)}${verdict}\n`,
+		`\n${notes}${format_failure_actions(failed)}${gate_log.format_log_notice(log_path)}${verdict}\n`,
 	)
 }
 
@@ -183,15 +202,15 @@ function report_gate_steps(
 		header: gate_step_header(result),
 		output: result.output,
 	}))
-	const failed = results.filter((result) => is_gate_step_failed(result))
 	const written_log = gate_log.write_gate_log(entries, report.log_path)
 
-	print_gate_summary(failed, report.elapsed_ms, report.step_count, written_log)
+	print_gate_summary(results, report, written_log)
 
-	return failed.map((result) => result.label)
+	return results.filter((result) => is_gate_step_failed(result)).map((result) => result.label)
 }
 
 const gate_report = {
+	format_budget_notes,
 	format_failure_actions,
 	has_checker_warning,
 	is_gate_step_failed,

package/scripts/gate/gate-skip.ts

@@ -60,18 +60,42 @@ const FORCE_FLAG = '--force'
 //
 // A `base` that could not be read is `undefined`, and an older record carries none: both compare
 // unequal to anything, so the gate runs its checks. No base means no reuse, never reuse without one.
-function reusable_green_gate(
+//
+// **A refusal carries its reason** (joshuafolkken/kit#3307): a pre-push hook that fell back to the
+// whole unit suite said nothing about why, so a merge base moved by ship's main sync and a lock file
+// rewritten by the hook's own install each cost minutes before anyone could tell them apart.
+type GateReuse = { stamp: FileMapStamp } | { miss: string }
+
+function base_moved(recorded: string | undefined, base: string): string {
+	return `the merge base moved since the green gate (${recorded ?? 'none'} → ${base})`
+}
+
+function gate_reuse(
 	tree: Record<string, string>,
 	base: string | undefined,
 	source?: string,
-): FileMapStamp | undefined {
-	if (base === undefined || Object.keys(tree).length === 0) return undefined
+): GateReuse {
+	if (base === undefined) return { miss: 'the merge base could not be read' }
+	if (Object.keys(tree).length === 0) return { miss: 'no file differs from the merge base' }
 
 	const stamp = review_brief.matching_stamp(review_stamps.gate_stamp.read(source), tree)
 
-	if (stamp?.base !== base) return undefined
+	if (stamp === undefined) return { miss: 'no green gate record matches the changed files' }
+	if (stamp.base !== base) return { miss: base_moved(stamp.base, base) }
+
+	return { stamp }
+}
+
+function stamp_of(reuse: GateReuse): FileMapStamp | undefined {
+	return 'stamp' in reuse ? reuse.stamp : undefined
+}
 
-	return stamp
+function reusable_green_gate(
+	tree: Record<string, string>,
+	base: string | undefined,
+	source?: string,
+): FileMapStamp | undefined {
+	return stamp_of(gate_reuse(tree, base, source))
 }
 
 // **The sentence claims the result, and never merely the omission.** "verification skipped" on its
@@ -116,8 +140,15 @@ function format_skip(taken_at: string): string {
 	})
 }
 
-const gate_skip = { FORCE_FLAG, format_reuse_notice, format_skip, reusable_green_gate }
+const gate_skip = {
+	FORCE_FLAG,
+	format_reuse_notice,
+	format_skip,
+	gate_reuse,
+	reusable_green_gate,
+	stamp_of,
+}
 
-export type { ReuseNotice }
+export type { GateReuse, ReuseNotice }
 
 export { gate_skip }

package/scripts/gate/hook-gate-reuse.ts

@@ -1,7 +1,6 @@
 import { git_command } from '#scripts/git/git-command'
-import type { FileMapStamp } from '#scripts/josh/file-map-stamp'
 import { observation_ledger } from '#scripts/observations/observation-ledger'
-import { gate_skip } from './gate-skip'
+import { gate_skip, type GateReuse } from './gate-skip'
 import type { GateTree } from './gate-tree'
 
 // What the two git hooks share when they decline to re-run a check `pnpm josh gate` already passed on
@@ -94,6 +93,8 @@ interface HookReuse {
 	// The hook-specific narrowing: whether what this git operation carries is the tree the record
 	// describes. `is_worktree_clean` for a push, `is_index_matching_worktree` for a commit.
 	is_tree_carried: boolean
+	// The reason a refusal on that narrowing reports, in the hook's own words (joshuafolkken/kit#3307).
+	carry_miss: string
 	extra_arguments: ReadonlyArray<string>
 	force_env: string
 	// The record to read, so a test can plant one without overwriting the record a live run relies on.
@@ -102,27 +103,28 @@ interface HookReuse {
 	source?: string | undefined
 }
 
-// The stamp rather than a boolean, for the same reason `gate_skip.reusable_green_gate` hands one back:
-// the caller prints `taken_at`, and a record that does not describe this tree has no timestamp worth
-// printing.
+// The stamp rather than a boolean, for the same reason `gate_skip.gate_reuse` hands one back: the
+// caller prints `taken_at`, and a record that does not describe this tree has no timestamp worth
+// printing. A refusal carries its reason instead (joshuafolkken/kit#3307).
 //
 // **Any argument at all refuses the reuse**, not only the force flag. A caller who narrowed the run
 // asked for that run rather than for a recorded result about a whole tree, and a hook's own line passes
 // none, so this costs it nothing.
-function reusable_green_hook(input: HookReuse): FileMapStamp | undefined {
-	if (input.extra_arguments.length > 0 || is_force_requested(input.force_env)) return undefined
-	if (!input.is_tree_carried) return undefined
+function hook_reuse(input: HookReuse): GateReuse {
+	if (input.extra_arguments.length > 0) return { miss: 'arguments were passed to the hook' }
+	if (is_force_requested(input.force_env)) return { miss: `${input.force_env} is set` }
+	if (!input.is_tree_carried) return { miss: input.carry_miss }
 
-	return gate_skip.reusable_green_gate(input.tree.files, input.tree.base, input.source)
+	return gate_skip.gate_reuse(input.tree.files, input.tree.base, input.source)
 }
 
 const hook_gate_reuse = {
 	GATE_REUSING_TARGETS,
+	hook_reuse,
 	is_force_requested,
 	is_index_matching_worktree,
 	is_worktree_clean,
 	read_status_lines,
-	reusable_green_hook,
 }
 
 export type { HookReuse }

package/scripts/gate/machine-capacity.ts

@@ -0,0 +1,175 @@
+import { readFile } from 'node:fs/promises'
+import { availableParallelism, cpus, totalmem } from 'node:os'
+import { execa } from 'execa'
+
+// What the machine has free right now, read for the core budget's admission (joshuafolkken/kit#3371).
+//
+// **The budget used to be the core count, and that count is not what is free.** The ledger in
+// `core-budget.ts` admits against `availableParallelism()`, so the load it never sees — Claude sessions,
+// node processes that do not pass through `josh`, the window server — ran on top of a budget already
+// spent. On 2026-10-07, three lanes on the 11-core / 18 GB machine reached a load average of 16.8 with
+// 31% of the CPU in the kernel, compressing and swapping 4.4 GB of memory the ledger never counted.
+//
+// **This is a closed loop, not the open-loop formula joshuafolkken/kit#1637 rejected.** That proposal
+// derived a share from the core count up front; this reads what is busy and free at the moment of
+// admission and subtracts only the part the ledger does not already account for.
+//
+// **The busy cores are the CPU-time difference over a short window, not the load average.** The load
+// average trails by a minute, so a gate started just after another one finished would see the finished
+// one's load as external and wait out the decay. `os.cpus()` is one read with no process spawned.
+//
+// **A reading that fails answers undefined, and undefined is the old behavior.** A CI runner or a
+// container — where the host's CPU times are not this process's quota — budgets by the core count and
+// admits without looking at memory, exactly as before.
+
+// The window the busy cores are measured over: long enough that one scheduler tick does not dominate it,
+// short enough that a solo admission is not visibly delayed.
+const SAMPLE_WINDOW_MS = 250
+// **The background a developer machine always carries, which the gate's weights were measured beside.**
+// On 2026-10-07 the 11-core machine idled at about 1.5 cores outside `josh` — Claude sessions 0.55, the
+// window server 0.47, a browser 0.5. The solo gate's weights sum to exactly the core count and were
+// measured with that load present, so only what exceeds it is load the budget must give way to;
+// counting the baseline would defer a solo gate's unit suite on every run.
+const BASELINE_CORES = 2
+const BYTES_PER_MB = 1_048_576
+const KB_PER_MB = 1024
+const PERCENT = 100
+const MEMINFO_PATH = '/proc/meminfo'
+const LINUX_AVAILABLE = /^MemAvailable:\s+(?<kb>\d+) kB/mu
+// The kernel's own memory-pressure figure: the percentage of memory still available, compressible and
+// purgeable pages included — what `os.freemem()` leaves out on macOS, where it reads near zero on a
+// machine with gigabytes to spare.
+const PRESSURE_ARGUMENTS = ['-n', 'kern.memorystatus_level']
+const PRESSURE_LEVEL = /^\s*(?<level>\d+)\s*$/u
+
+interface MachineReading {
+	busy_cores: number | undefined
+	available_mb: number | undefined
+}
+
+// What the ledger's admitted reservations declare — the part of the machine's load already accounted for.
+interface LedgerLoad {
+	cores: number
+	memory_mb: number
+}
+
+interface MachineBudget {
+	cores: number
+	memory_mb: number
+}
+
+interface CpuTimes {
+	busy: number
+	total: number
+}
+
+function cpu_times(): CpuTimes {
+	let busy = 0
+	let idle = 0
+
+	for (const { times } of cpus()) {
+		busy += times.user + times.nice + times.sys + times.irq
+		idle += times.idle
+	}
+
+	return { busy, total: busy + idle }
+}
+
+function busy_cores_between(before: CpuTimes, after: CpuTimes, cores: number): number | undefined {
+	const total = after.total - before.total
+
+	if (total <= 0) return undefined
+
+	return ((after.busy - before.busy) / total) * cores
+}
+
+// `kern.memorystatus_level` → `58`: the share of physical memory still available, as a percentage.
+function parse_darwin_pressure(output: string, total_bytes: number): number | undefined {
+	const level = PRESSURE_LEVEL.exec(output)?.groups?.['level']
+
+	if (level === undefined) return undefined
+
+	return (Number(level) / PERCENT) * (total_bytes / BYTES_PER_MB)
+}
+
+function parse_linux_available(meminfo: string): number | undefined {
+	const kb = LINUX_AVAILABLE.exec(meminfo)?.groups?.['kb']
+
+	return kb === undefined ? undefined : Number(kb) / KB_PER_MB
+}
+
+async function read_available_mb(
+	platform: NodeJS.Platform = process.platform,
+): Promise<number | undefined> {
+	try {
+		if (platform === 'darwin') {
+			const { stdout } = await execa('sysctl', PRESSURE_ARGUMENTS)
+
+			return parse_darwin_pressure(stdout, totalmem())
+		}
+
+		return platform === 'linux'
+			? parse_linux_available(await readFile(MEMINFO_PATH, 'utf8'))
+			: undefined
+	} catch {
+		return undefined
+	}
+}
+
+// A CPU quota narrower than the host makes the host-wide CPU times the wrong machine, so the busy cores
+// are read only where the quota and the host agree.
+function is_unquoted(): boolean {
+	return cpus().length > 0 && cpus().length === availableParallelism()
+}
+
+async function default_sleep(ms: number): Promise<void> {
+	await new Promise<void>((resolve) => {
+		setTimeout(resolve, ms)
+	})
+}
+
+async function read_machine(
+	sleep: (ms: number) => Promise<void> = default_sleep,
+): Promise<MachineReading> {
+	const before = cpu_times()
+	const [available_mb] = await Promise.all([read_available_mb(), sleep(SAMPLE_WINDOW_MS)])
+	const busy_cores = is_unquoted()
+		? busy_cores_between(before, cpu_times(), cpus().length)
+		: undefined
+
+	return { busy_cores, available_mb }
+}
+
+// The busy cores the ledger does not account for, beyond the baseline the weights were measured beside,
+// in whole cores — the budget is in whole cores, and a fraction of a core is not a core to give up.
+function external_cores(busy_cores: number | undefined, ledger_cores: number): number {
+	if (busy_cores === undefined) return 0
+
+	return Math.floor(Math.max(0, busy_cores - ledger_cores - BASELINE_CORES))
+}
+
+// **The budget the ledger admits against: what is free plus what the ledger itself already holds.**
+// The admitted reservations' load is inside the reading, and the admission walk counts their declared
+// weight again, so it is added back — what is subtracted is only the load from outside the ledger. The
+// caller passes every admitted claim's cores but only the memory of claims past
+// `core_admission.RAMP_UP_MS`, whose tools have had time to allocate.
+// Memory that could not be read is no limit at all, the behavior before memory was read.
+function machine_budget(cores: number, reading: MachineReading, ledger: LedgerLoad): MachineBudget {
+	return {
+		cores: cores - external_cores(reading.busy_cores, ledger.cores),
+		memory_mb:
+			reading.available_mb === undefined ? Infinity : reading.available_mb + ledger.memory_mb,
+	}
+}
+
+const machine_capacity = {
+	BASELINE_CORES,
+	busy_cores_between,
+	machine_budget,
+	parse_darwin_pressure,
+	parse_linux_available,
+	read_machine,
+}
+
+export type { LedgerLoad, MachineBudget, MachineReading }
+export { machine_capacity }

package/scripts/gate/pre-commit-type-check.ts

@@ -96,14 +96,17 @@ async function reusable_green_commit(
 	source?: string,
 	start_directory: string = process.cwd(),
 ): Promise<FileMapStamp | undefined> {
-	const reusable = hook_gate_reuse.reusable_green_hook({
+	const reuse = hook_gate_reuse.hook_reuse({
 		tree,
 		is_tree_carried: tree.is_index_matching_worktree,
+		carry_miss: 'the index differs from the working tree',
 		extra_arguments,
 		force_env: FORCE_ENV,
 		source,
 	})
 
+	const reusable = gate_skip.stamp_of(reuse)
+
 	if (reusable === undefined) return undefined
 
 	return (await is_recorded_check_this_check(start_directory)) ? reusable : undefined

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(),
 	}
 }
 
@@ -176,6 +177,7 @@ function default_budget(): BudgetContext {
 interface ReservedStep {
 	step: GateStep
 	weight: number
+	memory_mb: number
 }
 
 async function build_reserved_steps(
@@ -187,6 +189,7 @@ async function build_reserved_steps(
 		plan.checks.map(async (check) => ({
 			step: await build_gate_step(check, start_directory, plan),
 			weight: gate_plan.check_weight(check, plan, available_cores),
+			memory_mb: gate_plan.check_memory(check, plan, available_cores),
 		})),
 	)
 }
@@ -204,8 +207,11 @@ async function run_reserved_step(
 
 	return await core_budget.with_core_reservation(
 		reserved.weight,
-		async () => await run_gate_step(reserved.step),
-		{ budget: budget.available_cores },
+		async (admission) => ({
+			...(await run_gate_step(reserved.step)),
+			budget_note: core_budget.describe_overflow(admission),
+		}),
+		{ budget: budget.available_cores, memory_mb: reserved.memory_mb },
 	)
 }
 
@@ -222,10 +228,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 +312,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 +355,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 +496,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]
 }