@joshuafolkken/kit 1.1514.0 → 1.2114.0

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

@@ -14,8 +14,8 @@ import { version_targets } from '#scripts/version/version-targets'
 // command's own modules rather than re-derived here, and it doubles as the visible signal that a
 // release is owed — a count that keeps climbing is a release nobody has run.
 
-// **The Telegram is sent before the merge**, deliberately: `git-pr-followup.ts` cuts its wrap-up
-// there because that is the last point at which the run can still fail safely. So the count taken
+// **The Telegram's body is read before the merge**, deliberately, though the send goes out beside it
+// (#5080): `git-pr-followup.ts` reads this line before it issues the merge. So the count taken
 // there cannot include this run's own merge, and a bare number would be understated by exactly one.
 // Saying so is the honest form of the same measurement. The console line printed after the merge
 // passes `false` and carries no note, because by then the merge is on the remote and the fetch below
@@ -61,7 +61,7 @@ async function read_tip(options: PendingReadOptions): Promise<string> {
 // remove.
 // The manifest read is **inside** the `try` with the rest. `readFileSync` can throw after
 // `existsSync` passed — EACCES, EISDIR, a racing write — and this function is called from
-// `notify_completion`, which runs *before* `pr_merge`: an escaping rejection there would abort the
+// `completion_sender`, which runs *before* `pr_merge`: an escaping rejection there would abort the
 // run and lose a merge over a cosmetic line.
 async function read_pending(options: PendingReadOptions): Promise<number | undefined> {
 	try {

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

@@ -1,6 +1,8 @@
 import { PrConflictError } from '#scripts/gh/git-pr-checks-eval'
-import { lane_ledger } from '#scripts/lane/lane-ledger'
+import { lane_ledger_write } from '#scripts/lane/lane-ledger-write'
 import { time_format } from '#scripts/time-runtime/time-format'
+import { followup_ci_path, type CiPath } from './followup-ci-path'
+import { followup_coderabbit_wait, type CodeRabbitWait } from './followup-coderabbit-wait'
 
 // Where `pnpm josh followup` spends its own wall clock.
 //
@@ -10,8 +12,9 @@ import { time_format } from '#scripts/time-runtime/time-format'
 // epic auto-close. Untimed, every proposal to shorten it is a guess, and a guess made under time
 // pressure falls on whichever stretch is easiest to cut rather than on the one that is long.
 //
-// **Those nine are seven printed rows**: the four reads in front of the wait go out together and so
-// do the two steps after the merge, and a lap measures an interval rather than a call. `STAGE` below is the list; the two names carrying `and` are the batches.
+// **Those nine are six printed rows**: the four reads in front of the wait go out together, so do the
+// Telegram and the merge, and so do the two steps after the merge, and a lap measures an interval
+// rather than a call. `STAGE` below is the list; the three names carrying `and` are the batches.
 //
 // **Laps, not a wrapper per stage.** The alternative was a `measure(name, () => …)` closure around
 // each call, which reads well and rewrites every call site in the file it instruments — nine
@@ -51,21 +54,29 @@ const NO_DURATION = 0
 // The stages, named once. They are the units a proposal to shorten `followup` would be written
 // against, so a rename has to move the printer and whatever reads it together.
 //
-// **Two names say `and` because two stages became one**. Requests that need
+// **Three names say `and` because each is two stages become one**. Requests that need
 // nothing from one another are now issued together, and a lap records an interval rather than a
 // call — so a batch is one interval, and what it holds has to be readable from its name or the
 // shortening becomes invisible to the very measurement that found it. `closes-and-context` is the
 // former `closes-check` and `context`; `completion-and-epic-close` the former `completion-comment`
-// and `epic-close`. **`checks-wait` is untouched, and deliberately so**: it is the merge gate, and
-// this change only ever moved time that was not a wait.
+// and `epic-close`; `telegram-and-merge` the former `telegram` and `merge` (#5080). **`checks-wait` is
+// untouched, and deliberately so**: it is the merge gate, and this change only ever moved time that was
+// not a wait.
 const STAGE = {
 	closes_and_context: 'closes-and-context',
 	checks_wait: 'checks-wait',
+	// Only on a run that retriggered a rate-limited CodeRabbit: the window and the review after it
+	// (joshuafolkken/kit#5289), kept out of `checks-wait` so the `ci-wait` row is the checks alone.
+	coderabbit_retrigger: 'coderabbit-retrigger',
 	coderabbit_comments: 'coderabbit-comments',
 	ai_review_comments: 'ai-review-comments',
+	// The interval of a run that merged nothing, where the send has nothing to go beside.
 	telegram: 'telegram',
-	merge: 'merge',
+	telegram_and_merge: 'telegram-and-merge',
 	completion_and_epic_close: 'completion-and-epic-close',
+	// The completion tail `git-followup-finish.ts` prints after this block (#5131): the next-issue list
+	// and the unreleased-merge count. Printed as its own row there, since the block is already out.
+	completion: 'completion',
 	// The lap that was still running when a stage threw. `followup` exits non-zero on an AI-review
 	// blocker and on a red check, and those are the runs whose wait is longest — reporting nothing for
 	// them would leave the measurement blind to exactly the invocations worth measuring.
@@ -90,13 +101,33 @@ interface FollowupStage {
 // `last_ms` is `performance.now()`'s clock rather than `Date.now()`'s, for the reason
 // `buffered-process.ts` states: it is monotonic, so a system clock adjusted mid-wait cannot produce a
 // negative lap.
+//
+// `coderabbit` rides on the log because every check wait of the run — the merge gate's and the one the
+// merge goes back to (#4036) — adds to the same CodeRabbit time. `ci_path` is the first wait's
+// per-check timing, which the `ci-wait` row carries (`followup-ci-path.ts`), with `issue` once the run
+// knows it, so `lane:breakdown` finds the lane's row.
 interface StageLog {
 	stages: Array<FollowupStage>
 	last_ms: number
+	coderabbit: CodeRabbitWait
+	ci_path: CiPath
+	issue?: number
 }
 
 function new_log(): StageLog {
-	return { stages: [], last_ms: performance.now() }
+	return {
+		stages: [],
+		last_ms: performance.now(),
+		coderabbit: followup_coderabbit_wait.new_wait(),
+		ci_path: followup_ci_path.new_path(),
+	}
+}
+
+// The issue the `ci-wait` row is written under; a number that does not parse leaves the row without one.
+function hold_issue(log: StageLog, issue_number: string | undefined): void {
+	const issue = Number(issue_number)
+
+	if (Number.isSafeInteger(issue) && issue > 0) log.issue = issue
 }
 
 function lap(log: StageLog, name: string): void {
@@ -140,28 +171,37 @@ function print_stages(log: StageLog): void {
 
 // The wait for CI goes to the lane ledger as well, where `josh lane:stats` reads it beside the review
 // round it would overlap: the printed block reaches only this run's reader. A wait that threw is the
-// `interrupted` lap and records nothing here.
+// `interrupted` lap and records nothing here. CodeRabbit's part of the waits goes beside it.
 async function record_ci_wait(log: StageLog): Promise<void> {
 	const wait = log.stages.find((stage) => stage.name === STAGE.checks_wait)
 
 	if (wait === undefined) return
 
-	await lane_ledger.record_stage({
-		stage: lane_ledger.CI_WAIT_STAGE,
+	await lane_ledger_write.record_stage({
+		stage: lane_ledger_write.CI_WAIT_STAGE,
 		elapsed_ms: wait.duration_ms,
+		...(log.issue !== undefined && { issue: log.issue }),
+		...followup_ci_path.record_of(log.ci_path),
 	})
 }
 
+async function record_waits(log: StageLog): Promise<void> {
+	await record_ci_wait(log)
+	await followup_coderabbit_wait.record(log.coderabbit)
+}
+
 const git_followup_stages = {
 	STAGE,
 	STAGE_LINE_PREFIX,
 	STAGE_TOTAL_PREFIX,
 	new_log,
+	hold_issue,
 	lap,
 	total_ms,
+	format_stage,
 	format_stages,
 	print_stages,
-	record_ci_wait,
+	record_waits,
 	stopped_lap,
 }
 

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

@@ -2,16 +2,14 @@
 import { parseArgs } from 'node:util'
 import { git_branch } from '#scripts/git/git-branch'
 import { git_error } from '#scripts/git/git-error'
-import { issue_number_shape } from '#scripts/issue/issue-number-shape'
-import { issue_watch_gate } from '#scripts/issue/issue-watch-gate'
 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 { acceptance_map_check } from '#scripts/review/acceptance-map-check'
 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 { removed_tests_check } from '#scripts/review/removed-tests-check'
 import { parse_issue_number_from_text } from './followup-issue-number'
+import { followup_review_gates } from './followup-review-gates'
 import { git_followup_finish } from './git-followup-finish'
 import { git_followup_flush } from './git-followup-flush'
 import { git_followup_merged, type MergePlan } from './git-followup-merged'
@@ -121,66 +119,7 @@ function is_merge_resolved(values: CliArguments['values']): boolean {
 	return values['no-merge'] !== true
 }
 
-// `/code-review` is forked by the harness and inherits the *session's* working directory, so a run
-// implementing in a lane can be reviewed against a different tree entirely — one holding the
-// previous child's already-merged code. That review finds nothing wrong and says so, and the run
-// would read the silence as a clean round. **This is the seam where that is caught**: a merge is
-// refused unless the review attested the checkout it was briefed on.
-//
-// **Absence is a refusal, not a pass.** The defect produces *no* signal, so a check that only
-// compared two present records would answer `ok` in exactly the state it exists to catch.
-//
-// **Scoped to a checkout that actually briefed a review.** `review_attest.check` answers
-// `not-required` where no `josh review:brief` was run here inside a run's lifetime, so a project or
-// a flow that does not use the brief merges exactly as it did before.
-//
-// The direction is deliberate: a wrongly-refused merge costs one re-run of the review, and a wrongly
-// allowed one ships a diff nobody read. Thrown rather than reported, so no `completion` Telegram is
-// sent and nothing merges — `git_pr_followup.run` is never reached.
-// `ok` means the guard was satisfied and `not-required` means it never applied to this checkout —
-// both let the merge proceed, so the two gates below read the verdict through one predicate rather
-// than repeating the pair of statuses.
-function is_merge_permitted(status: string): boolean {
-	return status === 'ok' || status === 'not-required'
-}
-
-function is_valid_issue(issue_number: string | undefined): issue_number is string {
-	return issue_number !== undefined && issue_number_shape.ISSUE_NUMBER_PATTERN.test(issue_number)
-}
-
-async function assert_review_attested(should_merge: boolean): Promise<void> {
-	if (!should_merge) return
-
-	const verdict = await review_attest.check_here()
-
-	if (!is_merge_permitted(verdict.status)) throw new Error(review_attest.refusal_message(verdict))
-
-	const refusal = await issue_watch_gate.review_refusal_here()
-
-	if (refusal !== undefined) throw new Error(refusal)
-}
-
-// Recording a review round as a prose request leaves the recurrence ledger blind whenever it is
-// skipped. **This is the seam where it is a gate instead**: a merge is refused unless the round left
-// a `- rf:` line for its issue, a zero-finding `none` line included.
-//
-// **Absence is a refusal, `missing` exactly as `assert_review_attested`'s is** — the defect this
-// exists for produces *no* line, so silence must not read as success. A checkout that keeps no ledger
-// answers `not-required` and merges as before, and a run whose issue the followup cannot identify has
-// no key to check, so it carries on rather than blocking on missing information.
-async function assert_review_recorded(
-	should_merge: boolean,
-	issue_number: string | undefined,
-): Promise<void> {
-	if (!should_merge || !is_valid_issue(issue_number)) return
-
-	const issue = Number(issue_number)
-	const verdict = await review_record.check(issue)
-
-	if (is_merge_permitted(verdict.status)) return
-
-	throw new Error(review_record.refusal_message(issue))
-}
+const { assert_review_attested, assert_review_recorded, is_valid_issue } = followup_review_gates
 
 // A runtime change merges only with its acceptance criteria run for real and
 // recorded in the pull request body — `live_evidence` carries the why. `exempt` (no runtime path
@@ -210,6 +149,20 @@ async function assert_acceptance_mapped(
 	if (refusal !== undefined) throw new Error(refusal)
 }
 
+// Every test the change removes is disposed of in the pull request body — `removed_tests` carries the
+// why. It reads this checkout's diff, which `assert_live_evidence` has already refused to read for a
+// branch other than the one checked out.
+async function assert_removed_tests_disposed(
+	should_merge: boolean,
+	branch_name: string,
+): Promise<void> {
+	if (!should_merge) return
+
+	const refusal = await removed_tests_check.refusal(branch_name)
+
+	if (refusal !== undefined) throw new Error(refusal)
+}
+
 // Every pre-merge refusal, in order — each one throws, so nothing merges past the first that fails.
 async function assert_merge_gates(
 	should_merge: boolean,
@@ -220,6 +173,7 @@ async function assert_merge_gates(
 	await assert_review_recorded(should_merge, issue_number)
 	await assert_live_evidence(should_merge, branch_name)
 	await assert_acceptance_mapped(should_merge, issue_number, branch_name)
+	await assert_removed_tests_disposed(should_merge, branch_name)
 }
 
 // After the gates, before the CI wait: a line appended since the run's commit rides the pull request
@@ -280,8 +234,7 @@ try {
 const git_followup_workflow = {
 	assert_acceptance_mapped,
 	assert_live_evidence,
-	assert_review_attested,
-	assert_review_recorded,
+	assert_removed_tests_disposed,
 	parse_issue_number_from_text,
 	prepare_merge,
 	resolve_branch_name,

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

@@ -6,10 +6,15 @@ import {
 	WATCH_CONFIRMED_STABLE_READS,
 	type SnapshotObserver,
 } from '#scripts/gh/git-pr-checks'
-import { is_coderabbit_check } from '#scripts/gh/git-pr-checks-eval'
+import {
+	FAILURE_MESSAGE_PREFIX,
+	is_coderabbit_check,
+	PrConflictError,
+} from '#scripts/gh/git-pr-checks-eval'
 import { CHECK_STATUS_PASS, type PrStateSnapshot } from '#scripts/gh/git-pr-checks-parse'
 import { issue_watch_gate } from '#scripts/issue/issue-watch-gate'
 import { json_value } from '#scripts/lib/json-value'
+import { followup_job_rerun } from './followup-job-rerun'
 
 // The check wait and the notes read off its snapshot — split out of `git-pr-followup.ts` when it
 // reached its line limit. `git-pr-followup` re-exports each name it always
@@ -71,12 +76,15 @@ async function handle_watch_failure(branch_name: string, error: unknown): Promis
 	console.info(`⚠️ ${WATCH_FAILED_NOTE}: ${git_gh_helpers.get_error_message_with_stderr(error)}`)
 }
 
-// **Returns whether the watch confirmed completion**: `true` only when
-// `pr_checks_watch` saw every check finish, `false` when it timed out with checks still pending or
-// fell through to polling on a swallowed failure. `run_checks` reads it to decide how many stable poll
-// reads the wait still needs. A timed-out watch (`timed_out: true`) never spanned the pending→settled
-// window, so it must keep the full stable-read window rather than claim the confirmation. A rethrown
-// failure — the empty-rollup case — never reaches a caller, so it needs no answer here.
+// **Returns whether the watch observed the checks**: `true` when `pr_checks_watch` returned — every
+// check finished, or the budget ran out with one still pending — and `false` when it fell through to
+// polling on a swallowed failure. `run_checks` reads it to decide how many stable poll reads the wait
+// still needs. **A timed-out watch counts too** (#5080): it read the checks for two minutes without
+// two settled reads in a row, so the checks were registered and not yet settled while it watched, and
+// the poll's first settled read closes that pending→settled window — the window the second stable read
+// exists for. Holding it to two cost ten seconds on every lane whose CI outlasts the two-minute
+// budget. A rethrown failure — the empty-rollup case — never reaches a caller, so it needs no answer
+// here.
 async function watch_before_polling(
 	branch_name: string,
 	observe: SnapshotObserver | undefined,
@@ -85,9 +93,9 @@ async function watch_before_polling(
 	console.info('📊 Watching PR checks...')
 
 	try {
-		const result = await git_gh_command.pr_checks_watch(branch_name, observe)
+		await git_gh_command.pr_checks_watch(branch_name, observe)
 
-		return !result.timed_out
+		return true
 	} catch (error) {
 		await handle_watch_failure(branch_name, error)
 
@@ -95,21 +103,23 @@ async function watch_before_polling(
 	}
 }
 
-// **A confirmed watch lowers the poll's stable-read requirement to one**. The
-// watch is the first confirmation that every check settled, so the poll that follows need only agree
-// once rather than twice — which removes the extra interval `followup` spent re-proving a settled run.
+// **A returned watch lowers the poll's stable-read requirement to one**. The
+// watch saw every check settle or saw them pending, so the poll that follows need only agree once
+// rather than twice — which removes the extra interval `followup` spent re-proving a settled run.
 // A skipped or fallen-through watch keeps `DEFAULT_STABLE_READS`, and a check that turned red is still
 // caught: the poll evaluates the full merge gate and throws on failure before any stable read counts.
 // `observe` is shown each poll's snapshot, the watch's included — the run's `pr-checks` line
 // (joshuafolkken/kit#3770).
-async function run_checks(input: {
+interface RunChecksInput {
 	branch_name: string
 	is_skip_watch: boolean
 	observe?: SnapshotObserver
-}): Promise<PrStateSnapshot> {
-	const is_watch_confirmed =
+}
+
+async function wait_for_checks(input: RunChecksInput): Promise<PrStateSnapshot> {
+	const is_watch_returned =
 		!input.is_skip_watch && (await watch_before_polling(input.branch_name, input.observe))
-	const stable_reads = is_watch_confirmed ? WATCH_CONFIRMED_STABLE_READS : DEFAULT_STABLE_READS
+	const stable_reads = is_watch_returned ? WATCH_CONFIRMED_STABLE_READS : DEFAULT_STABLE_READS
 
 	return await git_pr_checks.wait_for_pr_success(
 		input.branch_name,
@@ -119,6 +129,35 @@ async function run_checks(input: {
 	)
 }
 
+// A merge conflict is not a check, so no rerun can clear it.
+function is_checks_failure(error: unknown): boolean {
+	if (error instanceof PrConflictError) return false
+
+	return error instanceof Error && error.message.startsWith(FAILURE_MESSAGE_PREFIX)
+}
+
+// **A job the runner stopped after every step passed, or one red only on tests outside the change, is
+// rerun once and the wait judged again** (`followup-job-rerun.ts`). The second wait has no rerun of its own, so a job that stops the same way
+// twice — or any other failure — ends the run as before.
+async function rejudge_after_rerun(
+	input: RunChecksInput,
+	error: unknown,
+): Promise<PrStateSnapshot> {
+	if (!is_checks_failure(error)) throw error
+	const rerun = await followup_job_rerun.rerun_failed_jobs(input.branch_name)
+	if (rerun.length === 0) throw error
+
+	return await wait_for_checks(input)
+}
+
+async function run_checks(input: RunChecksInput): Promise<PrStateSnapshot> {
+	try {
+		return await wait_for_checks(input)
+	} catch (error) {
+		return await rejudge_after_rerun(input, error)
+	}
+}
+
 // Temporary: record every CodeRabbit check that was not passing when the merge gate
 // opened, so a merge shipped without CodeRabbit review stays auditable.
 function read_coderabbit_skip_notes(snapshot: PrStateSnapshot): Array<string> {

package/scripts/followup/git-pr-followup-wrapup.ts

@@ -1,6 +1,10 @@
 import { epic_close } from '#scripts/epic/epic-close'
 import { git_gh_command } from '#scripts/gh/git-gh-command'
+import type { PrStateSnapshot } from '#scripts/gh/git-pr-checks'
+import { git_pr_merge_checked, type WaitForGreen } from '#scripts/gh/git-pr-merge-checked'
+import { issue_body_or_comment } from '#scripts/issue/issue-body-or-comment'
 import { issue_watch_gate } from '#scripts/issue/issue-watch-gate'
+import { settled_together } from '#scripts/lib/settled-together'
 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'
@@ -40,6 +44,12 @@ interface WrapupInput {
 	// already on the issue does not post it twice (`git-followup-merged.ts`).
 	is_merged?: boolean | undefined
 	is_completion_recorded?: boolean | undefined
+	// The snapshot the merge gate passed, whose head the merge names, and the wait to go back to when
+	// that head moved before the merge (`git-pr-merge-checked.ts`, #4036).
+	checked?: PrStateSnapshot | undefined
+	wait_for_green: WaitForGreen
+	// The completion Telegram, its body already read, sent beside the merge.
+	send_completion: () => Promise<void>
 }
 
 function build_notify_body(input: {
@@ -57,12 +67,6 @@ function build_notify_body(input: {
 	})
 }
 
-function is_blank_issue_body(body: string | undefined): boolean {
-	if (body === undefined) return true
-
-	return body.trim().length === 0
-}
-
 async function post_notify_issue(input: {
 	issue_number: string | undefined
 	body: string
@@ -71,12 +75,7 @@ async function post_notify_issue(input: {
 		throw new Error('Issue number is required for issue notification.')
 	}
 
-	const current_body = await git_gh_command.issue_get_body(input.issue_number)
-	const should_edit_body = current_body !== undefined && is_blank_issue_body(current_body)
-
-	await (should_edit_body
-		? git_gh_command.issue_edit_body(input.issue_number, input.body)
-		: git_gh_command.issue_comment(input.issue_number, input.body))
+	await issue_body_or_comment.post(input.issue_number, input.body)
 }
 
 function should_notify_pr(target: GitNotifyConfig['target']): boolean {
@@ -236,13 +235,29 @@ async function run_tail_steps(input: WrapupInput): Promise<void> {
 // The last look at the issue before the merge: the CI poll checked it on every iteration, but a
 // person's update can land between that poll and this step, and only the seconds after this read are
 // left unwatched.
-async function run_wrapup(input: WrapupInput, log: StageLog): Promise<void> {
-	if (input.should_merge && input.is_merged !== true) {
-		await issue_watch_gate.assert_read_here()
-		await git_gh_command.pr_merge(input.branch_name)
-		lap(log, STAGE.merge)
+async function merge_step(input: WrapupInput): Promise<void> {
+	await issue_watch_gate.assert_read_here()
+	await git_pr_merge_checked.merge_checked(input)
+}
+
+// **The completion Telegram goes out beside the merge** (#5080): neither reads what the other writes,
+// and in sequence the send was about four seconds in front of every merge. The send is tolerant, so
+// its failure still never stops the merge; both settle before a merge failure is thrown, so a refused
+// merge does not cut a send in flight. Answers the stage the interval was.
+async function send_beside_merge(input: WrapupInput): Promise<string> {
+	if (!input.should_merge || input.is_merged === true) {
+		await input.send_completion()
+
+		return STAGE.telegram
 	}
 
+	await settled_together(input.send_completion(), merge_step(input))
+
+	return STAGE.telegram_and_merge
+}
+
+async function run_wrapup(input: WrapupInput, log: StageLog): Promise<void> {
+	lap(log, await send_beside_merge(input))
 	await run_tail_steps(input)
 
 	lap(log, STAGE.completion_and_epic_close)
@@ -256,7 +271,6 @@ export {
 	git_pr_followup_wrapup,
 	post_notify_issue,
 	post_completion_notification,
-	is_blank_issue_body,
 	build_notify_body,
 }
 export type { WrapupInput }