@joshuafolkken/kit 1.1050.0 → 1.1094.0

package/scripts/epic/epic.ts

@@ -9,7 +9,7 @@
  *                                                      [--decision-file <path|->]
  *        tsx scripts/epic/epic.ts --remove <E> <M> <N> ... [--decision-file <path|->]
  */
-import { git_gh_command } from '#scripts/git/git-gh-command'
+import { git_gh_command } from '#scripts/gh/git-gh-command'
 import { error_text } from '#scripts/lib/error-message'
 import { epic_add, type AddChildrenInput } from './epic-add'
 import { epic_cli, type AddArguments, type CrossRepoAddTarget } from './epic-cli'

package/scripts/exports/unused-members-cli.ts

@@ -0,0 +1,53 @@
+#!/usr/bin/env tsx
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { doctor_consumer } from '#scripts/doctor/doctor-consumer'
+import { project_checks } from '#scripts/gate/project-checks'
+import type { NamespaceMember } from './namespace-members'
+
+const CHECK = 'exports'
+const FAIL_EXIT_CODE = 1
+// A consumer's namespaces are read from `.svelte` files and routes a TypeScript program over its
+// `tsconfig.json` does not see, so every member they use would read as unused. The check is kit's own.
+const CONSUMER_SKIP_REASON = 'checks only the kit repository itself, not a consumer project'
+
+function format_member(root: string, member: NamespaceMember): string {
+	return `${path.relative(root, member.file)}:${String(member.line)}  ${member.namespace}.${member.member}`
+}
+
+function report(root: string, members: ReadonlyArray<NamespaceMember>): string {
+	if (members.length === 0) return `josh ${CHECK}: no unused namespace member`
+
+	return [
+		`josh ${CHECK}: ${String(members.length)} namespace member(s) nothing reads — remove each from its namespace object (and the declaration, if nothing in its file uses it either):`,
+		...members.map((member) => `  ${format_member(root, member)}`),
+	].join('\n')
+}
+
+async function run_unused_members(root: string): Promise<number> {
+	if (doctor_consumer.is_kit_consumer(root)) {
+		console.info(project_checks.skip_notice(CHECK, CONSUMER_SKIP_REASON))
+
+		return 0
+	}
+
+	// Loaded only past the skip: the scanner pulls in `typescript`, an optional peer a basic-profile
+	// consumer may not have, and this check runs in every consumer's gate. For the same reason the
+	// scanner is left out of the published package (`package.json` `files`); only this entry ships.
+	const { unused_members } = await import('./unused-members')
+	const members = unused_members.find_unused_members(root)
+	const output = report(root, members)
+
+	if (members.length === 0) console.info(output)
+	else console.error(output)
+
+	return members.length === 0 ? 0 : FAIL_EXIT_CODE
+}
+
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+	process.exitCode = await run_unused_members(project_checks.project_root(process.cwd()))
+}
+
+const unused_members_cli = { run_unused_members }
+
+export { unused_members_cli }

package/scripts/{git → followup}/followup-issue-number.ts

@@ -23,9 +23,4 @@ function parse_completed_issue_number(raw: string | undefined): number | undefin
 	return digits === undefined ? undefined : Number(digits)
 }
 
-const followup_issue_number = {
-	parse_issue_number_from_text,
-	parse_completed_issue_number,
-}
-
-export { followup_issue_number, parse_issue_number_from_text, parse_completed_issue_number }
+export { parse_issue_number_from_text, parse_completed_issue_number }

package/scripts/{git → followup}/git-followup-cleanup.ts

@@ -1,4 +1,4 @@
-import { git_gh_helpers } from './git-gh-helpers'
+import { git_gh_helpers } from '#scripts/gh/git-gh-helpers'
 
 // joshuafolkken/kit#1539: everything a run does after its merge is cleanup, and a merge cannot be
 // taken back. Those steps used to be plain sequential statements, so whichever of them threw first
@@ -70,6 +70,7 @@ async function run_guarded_steps(
 	let is_complete = true
 
 	for (const step of steps) {
+		// eslint-disable-next-line no-await-in-loop -- cleanup steps run in their declared order
 		const is_done = await run_guarded_step(is_guarded, step)
 
 		if (!is_done) is_complete = false

package/scripts/{git → followup}/git-followup-finish.ts

@@ -1,3 +1,4 @@
+import { git_next_issues } from '#scripts/issue/git-next-issues'
 import { review_attest } from '#scripts/review/review-attest'
 import { review_stamps } from '#scripts/review/review-stamps'
 import { run_hold } from '#scripts/run/run-hold'
@@ -5,7 +6,6 @@ import { run_progress_clock } from '#scripts/run/run-progress-clock'
 import { parse_completed_issue_number } from './followup-issue-number'
 import { git_followup_cleanup, type CleanupStep } from './git-followup-cleanup'
 import { git_followup_pending } from './git-followup-pending'
-import { git_next_issues } from './git-next-issues'
 
 // **The count of unreleased merges, not the project version** (joshuafolkken/kit#1486). This line
 // used to read the local `package.json` and was read as "the version this run just shipped"; children
@@ -208,8 +208,6 @@ const git_followup_finish = {
 	print_next_issues,
 	print_pending_release,
 	clear_review_records,
-	clear_round_one_snapshot,
-	clear_review_target,
 	release_worktree_hold,
 	end_progress_watcher,
 }

package/scripts/{git → followup}/git-followup-flush.ts

@@ -1,8 +1,8 @@
+import { git_command } from '#scripts/git/git-command'
+import { git_spawn } from '#scripts/git/git-spawn'
 import { observation_ledger } from '#scripts/observations/observation-ledger'
 import { observation_ledger_prepare } from '#scripts/observations/observation-ledger-prepare'
 import { observations_flush } from '#scripts/observations/observations-flush'
-import { git_command } from './git-command'
-import { git_spawn } from './git-spawn'
 
 // The residual commit path for the observation ledger (joshuafolkken/kit#1810). A run's appended lines
 // ride its own commit (joshuafolkken/kit#2763), so the ledger is usually clean by now and this

package/scripts/{git → followup}/git-followup-issue-close.ts

@@ -1,8 +1,8 @@
 import { epic_parse } from '#scripts/epic/epic-parse'
+import { git_gh_command } from '#scripts/gh/git-gh-command'
+import { parse_json_object_safe } from '#scripts/git/parse-json-array'
 import { poll, type PollOptions } from '#scripts/lib/poll'
 import { z } from 'zod'
-import { git_gh_command } from './git-gh-command'
-import { parse_json_object_safe } from './parse-json-array'
 
 // **A merged pull request whose `closes #N` GitHub did not apply** (joshuafolkken/kit#2770). From
 // 2026-09-30 06:34Z every merge `followup` made left its issue open — seven in a row, where every

package/scripts/{git → followup}/git-followup-label.ts

@@ -1,8 +1,8 @@
+import { git_gh_command } from '#scripts/gh/git-gh-command'
+import { parse_json_object_safe } from '#scripts/git/parse-json-array'
+import { issue_label_schema } from '#scripts/git/schemas'
+import { IN_PROGRESS_LABEL, label_name_of } from '#scripts/issue/issue-labels'
 import { z } from 'zod'
-import { git_gh_command } from './git-gh-command'
-import { IN_PROGRESS_LABEL, label_name_of } from './issue-labels'
-import { parse_json_object_safe } from './parse-json-array'
-import { issue_label_schema } from './schemas'
 
 // **`in-progress` means "a run is holding this issue right now", and a merged run is not holding
 // anything** (joshuafolkken/kit#1794). `pnpm josh followup` merged the pull request and closed the

package/scripts/followup/git-followup-merged.ts

@@ -0,0 +1,112 @@
+import { git_gh_command } from '#scripts/gh/git-gh-command'
+import type { PullMergeState } from '#scripts/gh/git-gh-pr-read'
+import { json_value } from '#scripts/lib/json-value'
+import { z } from 'zod'
+
+// joshuafolkken/kit#3023: `prrun` stops at a green, mergeable pull request and a person merges it by
+// hand. Re-running `pnpm josh followup` then has to finish what a merged `fullrun` finishes — the
+// completion report, the epic close, the merged issue's close, the `in-progress` removal, the hold
+// release and the completion Telegram — **from the one tail `followup` already runs**, not a copy of
+// it elsewhere: the hold release and `josh ms` act on the local work tree, which CI never sees.
+//
+// **A merged pull request is read, not declared.** No flag says "a person merged this"; `followup`
+// asks the pull request, so the same command works whichever of the two merged it. The merge plan
+// below is what the rest of the run branches on: merged skips every pre-merge step — the review and
+// live-evidence gates, the CI wait, the AI-review scans and the merge call — and runs the tail as a
+// merged run's, even under `--no-merge`, because there is nothing left for that flag to hold back.
+//
+// **A second run must not repeat the report.** Every other tail step is idempotent by nature (a
+// closed epic is not closed twice, a released hold releases nothing), but the completion comment and
+// the completion Telegram are writes that would land again. The comment is the record that the tail
+// already ran: a `✅` report naming this pull request, **posted on the issue at or after the merge**.
+// The time is what tells it apart from the report the `prrun` stop itself posted — a `--no-merge`
+// run's tail posts the same `✅` report naming the same pull request before anything merged, and
+// reading that one as the merged run's would skip the only report that says it merged. A report the
+// tail wrote into a blank issue body carries no time, so it is not counted: a re-run then posts it
+// once more as a comment, the cheaper failure than a merged run that reported nothing.
+
+interface MergePlan {
+	is_merged: boolean
+	should_merge: boolean
+	merged_at: string | undefined
+}
+
+const COMPLETION_MARK = '✅ '
+const PR_LINE_PREFIX = 'PR: '
+const LINE_SEPARATOR = '\n'
+
+const COMMENTS_SCHEMA = z.array(
+	z.object({ body: z.string().nullish(), created_at: z.string().nullish() }),
+)
+
+type IssueComment = z.infer<typeof COMMENTS_SCHEMA>[number]
+
+function to_merge_plan(state: PullMergeState | undefined, is_merge_requested: boolean): MergePlan {
+	const is_merged = state?.is_merged === true
+
+	return { is_merged, should_merge: is_merged || is_merge_requested, merged_at: state?.merged_at }
+}
+
+async function read_merge_plan(
+	branch_name: string,
+	is_merge_requested: boolean,
+): Promise<MergePlan> {
+	return to_merge_plan(await git_gh_command.pr_get_merge_state(branch_name), is_merge_requested)
+}
+
+function is_completion_text(text: string | null | undefined, pr_url: string): boolean {
+	if (typeof text !== 'string' || !text.startsWith(COMPLETION_MARK)) return false
+
+	return text.split(LINE_SEPARATOR).includes(`${PR_LINE_PREFIX}${pr_url}`)
+}
+
+function is_posted_since(comment: IssueComment, merged_at: string): boolean {
+	if (typeof comment.created_at !== 'string') return false
+
+	return Date.parse(comment.created_at) >= Date.parse(merged_at)
+}
+
+function parse_comments(comments_json: string | undefined): Array<IssueComment> {
+	const parsed = COMMENTS_SCHEMA.safeParse(json_value.parse_or_undefined(comments_json ?? ''))
+
+	return parsed.success ? parsed.data : []
+}
+
+// The pure half: whether one of the issue's comments is this pull request's report, posted since it merged.
+function has_completion_record(input: {
+	comments_json: string | undefined
+	pr_url: string
+	merged_at: string
+}): boolean {
+	return parse_comments(input.comments_json).some(
+		(comment) =>
+			is_completion_text(comment.body, input.pr_url) && is_posted_since(comment, input.merged_at),
+	)
+}
+
+// Asked only on a merged pull request: an unmerged run has never reached the tail, so its report
+// cannot be there yet. **An unreadable issue reads as "not recorded"** — the tail then posts, and a
+// duplicate report is the cheaper failure than a merged run that reported nothing.
+async function is_completion_recorded(input: {
+	merged_at: string | undefined
+	issue_number: string | undefined
+	pr_url: string | undefined
+}): Promise<boolean> {
+	const { merged_at, issue_number, pr_url } = input
+
+	if (issue_number === undefined || pr_url === undefined || merged_at === undefined) return false
+
+	const comments_json = await git_gh_command.issue_list_comments(issue_number)
+
+	return has_completion_record({ comments_json, pr_url, merged_at })
+}
+
+const git_followup_merged = {
+	has_completion_record,
+	is_completion_recorded,
+	read_merge_plan,
+	to_merge_plan,
+}
+
+export type { MergePlan }
+export { git_followup_merged }

package/scripts/{git → followup}/git-followup-pending.ts

@@ -1,7 +1,7 @@
+import { git_command } from '#scripts/git/git-command'
 import { release_history, type HistoryReader } from '#scripts/release/release-history'
 import { release_plan } from '#scripts/release/release-plan'
 import { version_targets } from '#scripts/version/version-targets'
-import { git_command } from './git-command'
 
 // What the completion notification says about versions, now that children do not set one
 // (joshuafolkken/kit#1486).

package/scripts/{git → followup}/git-followup-workflow.ts

@@ -1,16 +1,17 @@
 #!/usr/bin/env tsx
 import { parseArgs } from 'node:util'
+import { git_branch } from '#scripts/git/git-branch'
+import { git_error } from '#scripts/git/git-error'
 import { cli_body } from '#scripts/josh/cli-body'
 import { josh_environment_file } from '#scripts/josh/josh-environment-file'
+import { git_notify, type GitNotifyConfig } from '#scripts/notify/git-notify'
 import { live_evidence } from '#scripts/review/live-evidence'
 import { review_attest } from '#scripts/review/review-attest'
 import { review_record } from '#scripts/review/review-record'
 import { parse_issue_number_from_text } from './followup-issue-number'
-import { git_branch } from './git-branch'
-import { git_error } from './git-error'
 import { git_followup_finish } from './git-followup-finish'
 import { git_followup_flush } from './git-followup-flush'
-import { git_notify, type GitNotifyConfig } from './git-notify'
+import { git_followup_merged, type MergePlan } from './git-followup-merged'
 import { git_pr_followup } from './git-pr-followup'
 
 josh_environment_file.load_environment_file()
@@ -204,14 +205,18 @@ async function assert_merge_gates(
 }
 
 // After the gates, before the CI wait: a line appended since the run's commit rides the pull request
-// itself, so it merges with it — a lane's included (joshuafolkken/kit#2919).
+// itself, so it merges with it — a lane's included (joshuafolkken/kit#2919). **A pull request that has
+// already merged skips both** (joshuafolkken/kit#3023): the gates guard a merge this run no longer
+// makes, and a ledger commit would land on a branch that has already gone in.
 async function prepare_merge(
-	should_merge: boolean,
+	plan: MergePlan,
 	issue_number: string | undefined,
 	branch_name: string,
 ): Promise<void> {
-	await assert_merge_gates(should_merge, issue_number, branch_name)
-	await git_followup_flush.commit_ledger_step(should_merge, issue_number)
+	if (plan.is_merged) return
+
+	await assert_merge_gates(plan.should_merge, issue_number, branch_name)
+	await git_followup_flush.commit_ledger_step(plan.should_merge, issue_number)
 }
 
 async function main(): Promise<void> {
@@ -225,10 +230,10 @@ async function main(): Promise<void> {
 
 	const issue_number =
 		cli.values['issue-number'] ?? parse_issue_number_from_text(cli.positionals[0] ?? undefined)
-	const should_merge = is_merge_resolved(cli.values)
 	const branch_name = await resolve_branch_name(cli.values.branch)
+	const plan = await git_followup_merged.read_merge_plan(branch_name, is_merge_resolved(cli.values))
 
-	await prepare_merge(should_merge, issue_number, branch_name)
+	await prepare_merge(plan, issue_number, branch_name)
 	// **The number the run reports on is the one it used**, which is the number the pull request
 	// closes where the invocation named none (joshuafolkken/kit#1539). Recovered inside `run`, so the
 	// tail records a run the command line could not identify rather than silently skipping it.
@@ -239,10 +244,12 @@ async function main(): Promise<void> {
 		coderabbit_ignore_reason: cli.values['coderabbit-ignore-reason'],
 		ai_review_ignore_reason: cli.values['ai-review-ignore-reason'],
 		is_skip_watch: cli.values['skip-watch'] === true,
-		should_merge,
+		should_merge: plan.should_merge,
+		is_merged: plan.is_merged,
+		merged_at: plan.merged_at,
 	})
 
-	await git_followup_finish.finish(used_issue_number ?? issue_number, should_merge)
+	await git_followup_finish.finish(used_issue_number ?? issue_number, plan.should_merge)
 }
 
 try {
@@ -257,6 +264,7 @@ const git_followup_workflow = {
 	assert_review_attested,
 	assert_review_recorded,
 	parse_issue_number_from_text,
+	prepare_merge,
 	resolve_branch_name,
 	is_merge_resolved,
 }

package/scripts/{git → followup}/git-pr-followup-wrapup.ts

@@ -1,10 +1,10 @@
 import { epic_close } from '#scripts/epic/epic-close'
+import { git_gh_command } from '#scripts/gh/git-gh-command'
+import { git_notify, type GitNotifyConfig } from '#scripts/notify/git-notify'
 import { git_followup_cleanup } from './git-followup-cleanup'
 import { git_followup_issue_close } from './git-followup-issue-close'
 import { git_followup_label } from './git-followup-label'
 import { git_followup_stages, type StageLog } from './git-followup-stages'
-import { git_gh_command } from './git-gh-command'
-import { git_notify, type GitNotifyConfig } from './git-notify'
 
 const { STAGE, lap } = git_followup_stages
 
@@ -35,6 +35,10 @@ interface WrapupInput {
 	// completion notification (joshuafolkken/kit#1592). Empty on a run that changed nothing `josh sync`
 	// distributes, and an empty one adds no line.
 	managed_notes: ReadonlyArray<string>
+	// A pull request merged before this run is not merged again, and a tail whose completion report is
+	// already on the issue does not post it twice (joshuafolkken/kit#3023, `git-followup-merged.ts`).
+	is_merged?: boolean | undefined
+	is_completion_recorded?: boolean | undefined
 }
 
 function build_notify_body(input: {
@@ -113,6 +117,8 @@ async function post_completion_notification(input: {
 // merge, a step that throws is reported and the ones after it still run, rather than taking the epic
 // close and the working-tree hold release down with it.
 async function notify_step(input: WrapupInput): Promise<void> {
+	if (input.is_completion_recorded === true) return
+
 	await git_followup_cleanup.run_guarded_step(input.should_merge, {
 		label: 'The completion comment',
 		recovery: COMPLETION_COMMENT_RECOVERY,
@@ -227,7 +233,7 @@ async function run_tail_steps(input: WrapupInput): Promise<void> {
 }
 
 async function run_wrapup(input: WrapupInput, log: StageLog): Promise<void> {
-	if (input.should_merge) {
+	if (input.should_merge && input.is_merged !== true) {
 		await git_gh_command.pr_merge(input.branch_name)
 		lap(log, STAGE.merge)
 	}

package/scripts/{git → followup}/git-pr-followup.ts

@@ -1,18 +1,28 @@
-import { git_closes_keyword } from './git-closes-keyword'
+import { git_gh_command } from '#scripts/gh/git-gh-command'
+import { git_gh_helpers } from '#scripts/gh/git-gh-helpers'
+import { git_pr_ai_review, type TelegramContext } from '#scripts/gh/git-pr-ai-review'
+import {
+	DEFAULT_STABLE_READS,
+	git_pr_checks,
+	WATCH_CONFIRMED_STABLE_READS,
+} from '#scripts/gh/git-pr-checks'
+import { is_coderabbit_check } from '#scripts/gh/git-pr-checks-eval'
+import { CHECK_STATUS_PASS, type PrStateSnapshot } from '#scripts/gh/git-pr-checks-parse'
+import { git_pr_coderabbit } from '#scripts/gh/git-pr-coderabbit'
+import { git_pr_managed_config } from '#scripts/gh/git-pr-managed-config'
+import { github_issue_url } from '#scripts/gh/github-issue-url'
+import { git_closes_keyword } from '#scripts/git/git-closes-keyword'
+import { json_value } from '#scripts/lib/json-value'
+import type { GitNotifyConfig } from '#scripts/notify/git-notify'
+import {
+	telegram_notify,
+	type TelegramSendInput,
+	type TelegramTaskType,
+} from '#scripts/notify/telegram-notify'
+import { git_followup_merged } from './git-followup-merged'
 import { git_followup_pending } from './git-followup-pending'
 import { git_followup_stages, type StageLog } from './git-followup-stages'
-import { git_gh_command } from './git-gh-command'
-import { git_gh_helpers } from './git-gh-helpers'
-import type { GitNotifyConfig } from './git-notify'
-import { git_pr_ai_review, type TelegramContext } from './git-pr-ai-review'
-import { DEFAULT_STABLE_READS, git_pr_checks, WATCH_CONFIRMED_STABLE_READS } from './git-pr-checks'
-import { is_coderabbit_check } from './git-pr-checks-eval'
-import { CHECK_STATUS_PASS, git_pr_checks_parse, type PrStateSnapshot } from './git-pr-checks-parse'
-import { git_pr_coderabbit } from './git-pr-coderabbit'
 import { git_pr_followup_wrapup } from './git-pr-followup-wrapup'
-import { git_pr_managed_config } from './git-pr-managed-config'
-import { github_issue_url } from './github-issue-url'
-import { telegram_notify, type TelegramSendInput, type TelegramTaskType } from './telegram-notify'
 
 const { STAGE, lap } = git_followup_stages
 
@@ -64,6 +74,10 @@ interface FollowupInput {
 	ai_review_ignore_reason: string | undefined
 	is_skip_watch: boolean
 	should_merge: boolean
+	// The pull request merged before this run (joshuafolkken/kit#3023): only the tail is left to run.
+	is_merged?: boolean | undefined
+	// When it merged — a completion report posted before it is the `prrun` stop's, not this tail's.
+	merged_at?: string | undefined
 }
 
 const { parse_closes_issue_number } = git_closes_keyword
@@ -116,7 +130,7 @@ async function warn_if_missing_closes(branch_name: string): Promise<string | und
 // on the path this whole change exists to remove. So the question asked here is the narrow one —
 // *is this definitely an empty rollup* — and every other outcome falls through.
 function reads_as_empty_rollup(raw_json: string): boolean {
-	const parsed = git_pr_checks_parse.parse_json_safe(raw_json)
+	const parsed = json_value.parse_or_undefined(raw_json)
 
 	if (typeof parsed !== 'object' || parsed === null || !('statusCheckRollup' in parsed)) {
 		return false
@@ -342,6 +356,8 @@ async function run_review_checks(
 	context: TelegramContext,
 	log: StageLog,
 ): Promise<{ notes: Array<string>; managed: Array<string> }> {
+	if (input.is_merged === true) return { notes: [], managed: [] }
+
 	const managed = await git_pr_managed_config.handle_managed_config_changes({
 		should_merge: input.should_merge,
 	})
@@ -359,6 +375,26 @@ async function run_review_checks(
 	return { notes: [...managed, ...check_notes, ...scan_notes], managed }
 }
 
+// **A tail re-run after a merge does not report twice** (joshuafolkken/kit#3023): where the issue
+// already carries this pull request's completion report, the Telegram is skipped here and the comment
+// in the wrapup. Answers whether it was recorded, so the wrapup skips on the same read.
+async function notify_unless_recorded(
+	input: FollowupInput,
+	issue_number: string | undefined,
+	context: TelegramContext,
+	checks: { notes: Array<string> },
+): Promise<boolean> {
+	const is_recorded = await git_followup_merged.is_completion_recorded({
+		merged_at: input.is_merged === true ? input.merged_at : undefined,
+		issue_number,
+		pr_url: context.pr_url,
+	})
+
+	if (!is_recorded) await notify_completion(context, checks.notes, input.should_merge)
+
+	return is_recorded
+}
+
 // **Answers with the issue number the run actually used** (joshuafolkken/kit#1539), which is the one
 // the invocation named or, failing that, the one the pull request body closes. Everything downstream
 // takes it from here rather than from the input, so the Telegram context, the completion comment and
@@ -369,8 +405,7 @@ async function run_stages(input: FollowupInput, log: StageLog): Promise<string |
 
 	lap(log, STAGE.closes_and_context)
 	const checks = await run_review_checks(input, context, log)
-
-	await notify_completion(context, checks.notes, input.should_merge)
+	const is_completion_recorded = await notify_unless_recorded(input, issue_number, context, checks)
 
 	lap(log, STAGE.telegram)
 	await git_pr_followup_wrapup.run_wrapup(
@@ -382,6 +417,8 @@ async function run_stages(input: FollowupInput, log: StageLog): Promise<string |
 			pr_url: context.pr_url,
 			should_merge: input.should_merge,
 			managed_notes: checks.managed,
+			is_merged: input.is_merged,
+			is_completion_recorded,
 		},
 		log,
 	)
@@ -426,4 +463,4 @@ export {
 	log_skip_notes,
 }
 export type { FollowupInput }
-export type { TelegramContext } from './git-pr-ai-review'
+export type { TelegramContext } from '#scripts/gh/git-pr-ai-review'

package/scripts/gate/core-budget.ts

@@ -4,6 +4,7 @@ import { availableParallelism } from 'node:os'
 import path from 'node:path'
 import { PLATFORM_TEMP_ROOT } from '#scripts/josh/platform-temporary'
 import { process_identity } from '#scripts/josh/process-identity'
+import { process_owner_schema } from '#scripts/josh/process-owner'
 import { stamp_file } from '#scripts/josh/stamp-file'
 import { z } from 'zod'
 
@@ -45,9 +46,7 @@ const WAIT_CAP_MS = 120_000
 // The head of the ledger is always admitted, so the smallest budget worth planning against is one core.
 const MIN_BUDGET = 1
 
-const reservation_schema = z.object({
-	pid: z.number(),
-	process_start: z.string().optional(),
+const reservation_schema = process_owner_schema.extend({
 	weight: z.number(),
 	claimed_at: z.number(),
 })
@@ -228,6 +227,7 @@ async function await_admission(context: WaitContext): Promise<void> {
 	while (!is_admitted(context.key, live_reservations(context.directory), context.budget)) {
 		if (context.now() >= context.deadline) return
 
+		// eslint-disable-next-line no-await-in-loop -- polling: each read waits on the state the previous one saw
 		await context.sleep(context.poll_interval_ms)
 	}
 }
@@ -273,16 +273,10 @@ async function with_core_reservation<T>(
 }
 
 const core_budget = {
-	MIN_BUDGET,
-	POLL_INTERVAL_MS,
 	RESERVED_PREFIX,
-	WAIT_CAP_MS,
 	admitted_keys,
 	admitted_load,
-	is_admitted,
-	is_running,
 	live_reservations,
-	read_reservation,
 	release,
 	reserve,
 	with_core_reservation,

package/scripts/gate/gate-plan.ts

@@ -66,6 +66,11 @@ const STATIC_CHECKS: ReadonlyArray<GateCheck> = [
 	{ label: TYPE_CHECK_LABEL, target: 'check', reserved_cores: 1 },
 	{ label: 'cspell', target: 'cspell:dot', reserved_cores: 1 },
 	{ label: BEHAVIOR_LABEL, target: BEHAVIOR_LABEL, reserved_cores: 0 },
+	// **The unused-member check reserves no core** (joshuafolkken/kit#2987): it builds one TypeScript
+	// program and walks it single-threaded for about 5s — over well before lint and the type check, so
+	// a reservation would only take a place from the four-core CI runner's fan-out and a worker from
+	// the unit suite for the whole gate.
+	{ label: 'exports', target: 'exports:unused', reserved_cores: 0 },
 ]
 
 // The checks, in the order their output is printed — the static set, then the unit suite last (the
@@ -91,8 +96,8 @@ function has_unit_check(checks: ReadonlyArray<GateCheck>): boolean {
 	return checks.some((check) => check.label === UNIT_LABEL)
 }
 
-// What the three non-elastic checks hold between them: 2 + 1 + 1. Reduced over `STATIC_CHECKS`
-// rather than over all four, because that is the set the sentence above names: `resolve_unit_worker_cap`
+// What the non-elastic checks hold between them: 2 + 1 + 1. Reduced over `STATIC_CHECKS`
+// rather than over every check, because that is the set the sentence above names: `resolve_unit_worker_cap`
 // spends this as the cores the unit suite must leave to its siblings, so summing the unit check into
 // it would have the suite subtract its own reservation from its own budget the day that reservation
 // stops being zero. The two sets give the same number today, which is exactly why the narrower one
@@ -331,7 +336,6 @@ function format_gate_plan(
 }
 
 const gate_plan = {
-	BEHAVIOR_LABEL,
 	GATE_CHECKS,
 	LINT_LABEL,
 	MEASURED_CORES,
@@ -343,7 +347,6 @@ const gate_plan = {
 	check_weight,
 	format_gate_plan,
 	format_machine,
-	format_unit_cap,
 	has_unit_check,
 	plan_of,
 	resolve_concurrency,

package/scripts/gate/gate-report.ts

@@ -193,16 +193,10 @@ function report_gate_steps(
 
 const gate_report = {
 	format_failure_actions,
-	format_seconds,
-	gate_step_header,
 	has_checker_warning,
-	has_warnings,
 	is_gate_step_failed,
 	is_skip_notice,
-	print_gate_step,
-	print_gate_summary,
 	report_gate_steps,
-	should_print_body,
 }
 
 export type { GateReport, GateStep, GateStepResult }

package/scripts/gate/gate-tree.ts

@@ -43,7 +43,7 @@ async function read_gate_tree(): Promise<GateTree> {
 	return { files, base }
 }
 
-const gate_tree = { read_base, read_changed_files, read_gate_tree }
+const gate_tree = { read_gate_tree }
 
 export type { GateTree }
 export { gate_tree }

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

@@ -174,13 +174,7 @@ if (process.argv[1] === fileURLToPath(import.meta.url)) {
 const pre_commit_type_check = {
 	FORCE_ENV,
 	TYPE_CHECK_ARGUMENTS,
-	format_refusal,
-	format_skip,
-	is_recorded_check_this_check,
-	read_commit_tree,
-	reusable_green_commit,
 	run_pre_commit_type_check,
-	unexpected_arguments,
 }
 
 export type { CommitTree }