@joshuafolkken/kit 1.3041.0 → 1.3092.0

package/scripts/backlog/backlog-next-shared.ts

@@ -2,6 +2,7 @@ import { josh_command, type JoshResult } from '#scripts/josh/josh-run'
 import { shared_cache, type CacheSlot } from '#scripts/josh/shared-cache'
 import { run_event_stream } from '#scripts/run/event/run-event-stream'
 import { run_event_stream_emit } from '#scripts/run/event/run-event-stream-emit'
+import { run_startup } from '#scripts/run/startup/run-startup'
 import { z } from 'zod'
 import { backlog_next } from './backlog-next'
 import { backlog_wait_cause } from './backlog-wait-cause'
@@ -42,6 +43,15 @@ function is_kept(result: JoshResult): boolean {
 	return !result.out.split('\n').includes(backlog_next.VERDICT_TOKENS.retry)
 }
 
+function edge_of(result: JoshResult): 'done' | 'failed' | 'waiting' {
+	const [token = ''] = result.out.split('\n', 1)
+	const { error, retry, wait, stop, triage } = backlog_next.VERDICT_TOKENS
+	const is_failed = [error, retry].includes(token)
+	if (is_failed || result.code !== SUCCESS_EXIT_CODE) return 'failed'
+
+	return [wait, stop, triage].includes(token) ? 'waiting' : 'done'
+}
+
 // A kept answer replays its explanation where the live one would have streamed it.
 function replay(result: JoshResult, should_forward_stderr: boolean): JoshResult {
 	if (should_forward_stderr && result.err !== undefined && result.err !== '') {
@@ -79,13 +89,21 @@ async function read(
 
 	if (kept !== undefined) return replay(kept, should_forward_stderr)
 
-	const result = await josh_command.josh_run(argv, should_forward_stderr, timeout_ms)
+	const result = await run_startup.phase(
+		'candidate cache fill',
+		async () => {
+			run_startup.metric('cache', 'fill', `${NEXT_CACHE.prefix}:${key}`)
+
+			return await josh_command.josh_run(argv, should_forward_stderr, timeout_ms)
+		},
+		{ edge_of },
+	)
 
 	if (is_kept(result)) shared_cache.write(NEXT_CACHE, key, result, now_ms)
 
 	return result
 }
 
-const backlog_next_shared = { NEXT_CACHE, read, stream_key }
+const backlog_next_shared = { NEXT_CACHE, edge_of, read, stream_key }
 
 export { backlog_next_shared }

package/scripts/backlog/backlog-next.ts

@@ -14,6 +14,7 @@ import { git_gh_command } from '#scripts/gh/git-gh-command'
 import { PROJECT_ROOT } from '#scripts/init/init-paths'
 import { issue_not_before_label } from '#scripts/issue/issue-not-before-label'
 import { lane_net_read } from '#scripts/lane/lane-net-read'
+import { run_startup } from '#scripts/run/startup/run-startup'
 import { backlog_auto_triage } from './backlog-auto-triage'
 import { backlog_defect_priority } from './backlog-defect-priority'
 import { backlog_gate_scope, type OptedIn, type PoolContext } from './backlog-gate-scope'
@@ -196,7 +197,7 @@ function is_transport_failure(result: EpicNextResult): boolean {
 // `resolve` and a plan made before the run lists everything. The holders are
 // read only on a `run` answer — the one answer the gate can change. The cap follows the gate
 // (`backlog-rank.ts`).
-async function gate_solo(result: EpicNextResult, context: PoolContext): Promise<EpicNextResult> {
+async function gate_ready(result: EpicNextResult, context: PoolContext): Promise<EpicNextResult> {
 	if (result.verdict !== 'run') return result
 
 	const { repo } = context
@@ -215,6 +216,18 @@ async function gate_solo(result: EpicNextResult, context: PoolContext): Promise<
 	return gated.result
 }
 
+function result_edge(value: EpicNextResult | undefined): 'done' | 'failed' | 'waiting' {
+	if (value === undefined || value.verdict === 'error') return 'failed'
+
+	return value.verdict === 'wait' || value.verdict === 'stop' ? 'waiting' : 'done'
+}
+
+async function gate_solo(result: EpicNextResult, context: PoolContext): Promise<EpicNextResult> {
+	return await run_startup.phase('eligibility', async () => await gate_ready(result, context), {
+		edge_of: result_edge,
+	})
+}
+
 // The untriaged candidates are held out before the `run:solo` gate, which cannot read a label not
 // recorded yet (`backlog_next_report.report_held`).
 async function answer_held(
@@ -232,7 +245,13 @@ async function answer_held(
 
 // Each answer is recorded once in the lane ledger before it is printed (`backlog-next-offer.ts`).
 async function answer_pool(context: PoolContext): Promise<number> {
-	const resolved = await resolve(context)
+	const resolved = await run_startup.phase(
+		'candidate eligibility',
+		async () => await resolve(context),
+		{
+			edge_of: result_edge,
+		},
+	)
 
 	if (resolved === undefined) return FAILURE_EXIT_CODE
 
@@ -308,7 +327,9 @@ async function run(argv: ReadonlyArray<string>): Promise<number> {
 		return FAILURE_EXIT_CODE
 	}
 
-	const opted_in = await auto_ok_cli.fetch_opted_in()
+	const opted_in = await run_startup.phase('candidate listing', auto_ok_cli.fetch_opted_in, {
+		edge_of: (value) => (value.kind === 'read' ? 'done' : 'failed'),
+	})
 
 	if (opted_in.kind !== 'read') {
 		console.error(READ_FAILURES[opted_in.kind])

package/scripts/backlog/backlog-offer-cli.ts

@@ -1,9 +1,11 @@
-import { josh_command } from '#scripts/josh/josh-run'
+import { josh_command, type JoshResult } from '#scripts/josh/josh-run'
 import { cli_flags } from '#scripts/lib/cli-flags'
 import { json_value } from '#scripts/lib/json-value'
 import { rule_value_cache } from '#scripts/rules/rule-value-cache'
+import { run_event_setup } from '#scripts/run/event/run-event-setup'
 import { run_event_stream } from '#scripts/run/event/run-event-stream'
 import { run_event_stream_emit } from '#scripts/run/event/run-event-stream-emit'
+import { run_startup } from '#scripts/run/startup/run-startup'
 import { z } from 'zod'
 import { backlog_drain_flush } from './backlog-drain-flush'
 import { backlog_next_shared } from './backlog-next-shared'
@@ -40,6 +42,7 @@ const USAGE =
 	'Usage: josh backlog:offer --started <ISO-8601> [--active <ISO-8601>] [--merged <n>] [--running <n>] [--max <n>] [--idle <minutes>] [--retries <n>] [--exclude <n>[,<n>...]]... [--repo <owner/repo>] [--json]'
 
 const OPTIONS = {
+	[backlog_drain_flush.OPTION]: { type: 'boolean' },
 	active: { type: 'string' },
 	exclude: { type: 'string', multiple: true },
 	idle: { type: 'string' },
@@ -125,6 +128,11 @@ interface BudgetRead {
 	is_finish: boolean
 }
 
+interface OfferResult {
+	code: number
+	edge: ReturnType<typeof backlog_next_shared.edge_of>
+}
+
 function budget_of(out: string): BudgetRead | undefined {
 	const read = json_value.parse_with(out, budget_read_schema)
 	if (read === undefined) return undefined
@@ -179,6 +187,12 @@ function refuse(): number {
 	return FAILURE_EXIT_CODE
 }
 
+// Idle is visible first; the flush only starts, detached, so the next offer is never held behind it.
+async function prepare_drain(): Promise<void> {
+	await run_event_setup.emit(run_event_setup.STAGE.WATCHING)
+	backlog_drain_flush.start()
+}
+
 // The drain: the backlog is empty (`exhausted`) and nothing of the run's own is in flight, so the run is
 // about to open its idle watch or stop with `--idle 0`. Marking once per drain with `emit_once`
 // is what lets `run:step` fire the end-of-run retrospective *before* the watch rather than after it,
@@ -191,41 +205,75 @@ async function mark_drain(verdict: string, answer: string, running: number): Pro
 	if (answer !== EXHAUSTED_ANSWER || running !== NO_RUNNING) return false
 	if (verdict !== WATCH_VERDICT && verdict !== STOP_VERDICT) return false
 
-	// The flush finishes before the marker is visible: `backlogrun-replace` reads a drain as replaceable.
+	// A replace that reads this drain stops the parent's pid alone, never the detached flush.
 	return await run_event_stream_emit.emit_once(
 		run_event_stream.EVENT_KIND.DRAIN,
 		DRAIN_TEXT,
-		backlog_drain_flush.flush,
+		prepare_drain,
 	)
 }
 
-async function decide(values: ParsedValues, counts: OfferCounts): Promise<number> {
-	const next = await backlog_next_shared.read(next_argv(values), should_forward_stderr)
+function budget_edge(value: BudgetRead | undefined): OfferResult['edge'] {
+	if (value === undefined) return 'failed'
+
+	return value.verdict === WATCH_VERDICT || value.verdict === 'triage' ? 'waiting' : 'done'
+}
+
+async function read_budget(
+	values: ParsedValues,
+	offer: OfferAnswer,
+): Promise<BudgetRead | undefined> {
+	return await run_startup.phase(
+		'conditions',
+		async () => {
+			const result = await josh_command.josh_run(
+				budget_argv(values, offer.answer),
+				should_forward_stderr,
+			)
+
+			return result.code === SUCCESS_EXIT_CODE ? budget_of(result.out) : undefined
+		},
+		{ edge_of: budget_edge },
+	)
+}
+
+function offer_edge(next: JoshResult, budget: BudgetRead): OfferResult['edge'] {
+	const edge = backlog_next_shared.edge_of(next)
+
+	return edge === 'done' ? budget_edge(budget) : edge
+}
+
+async function decide(values: ParsedValues, counts: OfferCounts): Promise<OfferResult> {
+	const next = await run_startup.phase(
+		'candidates',
+		async () => await backlog_next_shared.read(next_argv(values), should_forward_stderr),
+		{ edge_of: backlog_next_shared.edge_of },
+	)
 	const offer = backlog_offer.answer_of(
 		{ code: next.code, tokens: to_tokens(next.out), err: next.err },
 		counts.running,
 		counts.retries,
 	)
-	const budget = await josh_command.josh_run(
-		budget_argv(values, offer.answer),
-		should_forward_stderr,
-	)
-
-	if (budget.code !== SUCCESS_EXIT_CODE) return FAILURE_EXIT_CODE
+	const decision = await read_budget(values, offer)
+	if (decision === undefined) return { code: FAILURE_EXIT_CODE, edge: 'failed' }
 
-	const decision = budget_of(budget.out)
+	await mark_drain(decision.verdict, offer.answer, counts.running)
 
-	if (decision === undefined) return FAILURE_EXIT_CODE
+	return { code: emit(decision, offer, values.json === true), edge: offer_edge(next, decision) }
+}
 
-	await mark_drain(decision.verdict, offer.answer, counts.running)
+// `--drain-flush`: the detached body `prepare_drain` starts, which never fails the process.
+async function flush_alone(): Promise<number> {
+	await backlog_drain_flush.flush()
 
-	return emit(decision, offer, values.json === true)
+	return SUCCESS_EXIT_CODE
 }
 
 async function run(argv: ReadonlyArray<string>): Promise<number> {
 	const values = read_values(argv)
 
 	if (values === undefined) return refuse()
+	if (values[backlog_drain_flush.OPTION] === true) return await flush_alone()
 
 	// The loop head is the one place `rule:value` is read from: once per iteration, the parent's
 	// context still small, so a rule that never fires shows up as a printed row rather than as
@@ -238,7 +286,12 @@ async function run(argv: ReadonlyArray<string>): Promise<number> {
 
 	if (counts === undefined) return refuse()
 
-	return await decide(values, counts)
+	const result = await run_startup.phase('offer', async () => await decide(values, counts), {
+		root: true,
+		edge_of: (value) => value.edge,
+	})
+
+	return result.code
 }
 
 const backlog_offer_cli = {

package/scripts/build/build-migration.ts

@@ -0,0 +1,25 @@
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { build } from 'esbuild'
+
+const ROOT = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', '..')
+const MIGRATION_OUTFILE = path.join(ROOT, 'dist', 'registry-migrate.mjs')
+
+// No installed kit, package.json imports, or external npm dependencies are needed by this entry.
+async function build_migration(outfile: string = MIGRATION_OUTFILE): Promise<string> {
+	await build({
+		entryPoints: [path.join(ROOT, 'scripts', 'registry-migration', 'migrate-cli.ts')],
+		outfile,
+		bundle: true,
+		platform: 'node',
+		format: 'esm',
+		target: 'node22',
+		banner: {
+			js: "import { createRequire } from 'node:module'; const require = createRequire(import.meta.url);",
+		},
+	})
+
+	return outfile
+}
+
+export { build_migration, MIGRATION_OUTFILE }

package/scripts/build/build.ts

@@ -6,6 +6,7 @@ import { build_claude_md } from './build-claude-md'
 import { build_commands } from './build-commands'
 import { build_hooks, OUT_DIR as HOOKS_OUT_DIR } from './build-hooks'
 import { build_library, PUBLIC_LIBRARIES } from './build-library'
+import { build_migration } from './build-migration'
 
 interface BuildStep {
 	name: string
@@ -44,6 +45,7 @@ function build_steps(): ReadonlyArray<BuildStep> {
 		{ name: 'bin', run: bin_step },
 		{ name: 'hooks', run: hooks_step },
 		{ name: 'commands', run: async () => await build_commands() },
+		{ name: 'migration', run: async () => await build_migration() },
 		...PUBLIC_LIBRARIES.map((name) => ({ name, run: async () => await library_step(name) })),
 		{ name: 'claude-md', run: claude_md_step },
 	]

package/scripts/epic/epic-classify.ts

@@ -1,5 +1,6 @@
 import { has_label_name, has_parked_label, IN_PROGRESS_LABEL } from '#scripts/issue/issue-labels'
 import { issue_not_before } from '#scripts/issue/issue-not-before'
+import { issue_publication_state } from '#scripts/issue/issue-publication-state'
 import { epic_graph, type EpicChild, type IssueReference } from './epic-graph'
 import { epic_nested } from './epic-nested'
 import {
@@ -55,7 +56,11 @@ function has_human_label(child: EpicChild): boolean {
 // A child someone else's session is finishing, or one held until its declared start time
 // (joshuafolkken/kit#4007). Either way waiting resolves it.
 function is_waiting(child: EpicChild): boolean {
-	return has_label(child, IN_PROGRESS_LABEL) || !issue_not_before.is_due(child.body)
+	return (
+		issue_publication_state.is_pending(child.body) ||
+		has_label(child, IN_PROGRESS_LABEL) ||
+		!issue_not_before.is_due(child.body)
+	)
 }
 
 // What a child is before its dependencies are considered. A parked child is `human` whatever blocks

package/scripts/epic/epic-live.ts

@@ -0,0 +1,46 @@
+import type { EpicChild, IssueReference } from '#scripts/epic/epic-graph'
+import { epic_issue } from '#scripts/epic/epic-issue'
+import { git_gh_api_path } from '#scripts/gh/git-gh-api-path'
+import { git_gh_etag_read } from '#scripts/gh/git-gh-etag-read'
+import { git_gh_issue_read } from '#scripts/gh/git-gh-issue-read'
+import { git_gh_issue_rest } from '#scripts/gh/git-gh-issue-rest'
+import { session_cite } from '#scripts/issue/session-cite'
+
+// Each read revalidates remotely; neither the process memo nor the dependency summary answers it.
+async function child(number: number, repo: string): Promise<EpicChild> {
+	const json = await git_gh_issue_read.issue_view_json(
+		String(number),
+		'number,state,labels,body',
+		repo,
+		git_gh_etag_read.read,
+	)
+	const parsed = epic_issue.parse_epic_issue(json)
+
+	if (parsed?.number !== number || !['OPEN', 'CLOSED'].includes(parsed.state)) {
+		throw new Error(`Cannot read live issue ${session_cite.issue(number, undefined, repo)}`)
+	}
+
+	return {
+		number,
+		repo,
+		state: epic_issue.normalize_state(parsed.state),
+		labels: epic_issue.label_names(parsed),
+		body: parsed.body,
+		blocked_by: [],
+	}
+}
+
+async function blockers(number: number, repo: string): Promise<Array<IssueReference>> {
+	const endpoint = git_gh_api_path.blocked_by_api_path(String(number), repo)
+	const json = await git_gh_etag_read.read_listing(
+		`${endpoint}${git_gh_api_path.FULL_PAGE_QUERY}`,
+		git_gh_api_path.FULL_PAGE_SIZE,
+	)
+	const listing = git_gh_issue_rest.to_blocked_by(json)
+
+	return listing.nodes.map((blocker) => git_gh_issue_rest.reference_of_blocker(blocker, repo))
+}
+
+const epic_live = { child, blockers }
+
+export { epic_live }

package/scripts/followup/followup-failed-tests.ts

@@ -1,5 +1,6 @@
 import path from 'node:path'
 import { git_gh_issue_write } from '#scripts/gh/git-gh-issue-write'
+import { import_graph } from '#scripts/lint/import-graph'
 import { observation_ledger_home } from '#scripts/observations/observation-ledger-home'
 import {
 	observation_record,
@@ -9,6 +10,7 @@ import {
 import { review_comment_round } from '#scripts/review/review-comment-round'
 import { test_related_pins } from '#scripts/test/test-related-pins'
 import { vitest_failure_summary } from '#scripts/test/vitest-failure-summary'
+import { whole_suite_files } from '#scripts/test/whole-suite-files'
 
 // A CI job that ended `failure` because a unit test went red can still owe nothing to the change: a test
 // the diff never touched fails under runner load (joshuafolkken/kit#5152, a frame-budget test on a busy
@@ -16,9 +18,8 @@ import { vitest_failure_summary } from '#scripts/test/vitest-failure-summary'
 // these are the readings that decide it: the failed tests a job's log names, and whether any of them
 // belongs to the change.
 //
-// **A test belongs to the change when its own file or its subject module moved** — `foo.claim.test.ts`
-// tests `foo.claim.ts` and `foo.ts`. A test reaching a moved module only through an import is missed,
-// and costs one rerun: the second red still stops `followup`, since a rerun attempt is never rerun.
+// A rerun needs proof that the test's complete runtime inputs exclude the change. Missing inputs
+// keep the failure for repair, as do import diagnostics that another runner cannot repair.
 
 // GitHub Actions stamps every log line `<ISO timestamp> `, which vitest's ` FAIL  ` line does not begin with.
 const LOG_TIMESTAMP = /^\d{4}-\d{2}-\d{2}T\S+Z /u
@@ -39,8 +40,11 @@ type TestVerdict = typeof RERUN_VERDICT | typeof KEPT_VERDICT | typeof UNNAMED_V
 interface FailedTests {
 	files: ReadonlyArray<string>
 	names: ReadonlyArray<string>
+	import_failure?: string
 }
 
+type InputsReader = (file: string) => ReadonlyArray<string> | undefined
+
 interface UnrelatedFailure {
 	job: string
 	tests: FailedTests
@@ -49,9 +53,15 @@ interface UnrelatedFailure {
 // The failed tests vitest named in a job's log — empty when the job failed on anything but a test.
 function read_failed_tests(log: string): FailedTests {
 	const lines = log.split('\n').map((line) => line.replace(LOG_TIMESTAMP, ''))
-	const names = vitest_failure_summary.failed_tests(lines.join('\n'))
+	const plain = lines.join('\n')
+	const names = vitest_failure_summary.failed_tests(plain)
+	const diagnostic = vitest_failure_summary.import_failure(plain)
 
-	return { files: vitest_failure_summary.failed_files(names), names }
+	return {
+		files: vitest_failure_summary.failed_files(names),
+		names,
+		...(diagnostic !== undefined && { import_failure: diagnostic }),
+	}
 }
 
 // The test file itself, then the module each leading run of its name's segments names.
@@ -73,19 +83,69 @@ function subjects_of(test_file: string): ReadonlyArray<string> {
 }
 
 // A test the change pins (`test-related-pins.ts`) belongs to it, as a subject's test does.
-function is_in_change(test_file: string, changed: ReadonlySet<string>): boolean {
-	if (test_related_pins.pinned_tests(changed).includes(test_file)) return true
+function inputs_in_change(
+	inputs: ReadonlyArray<string> | undefined,
+	test_file: string,
+	changed: ReadonlySet<string>,
+): boolean {
+	if (!inputs?.includes(path.resolve(test_file))) return true
+
+	return [...changed].some(
+		(file) => whole_suite_files.WHOLE_SUITE_FILES.has(file) || inputs.includes(path.resolve(file)),
+	)
+}
 
-	return subjects_of(test_file).some((subject) => changed.has(subject))
+function is_in_change(
+	test_file: string,
+	changed: ReadonlySet<string>,
+	read?: InputsReader,
+): boolean {
+	if (
+		test_related_pins.pinned_tests(changed).includes(test_file) ||
+		subjects_of(test_file).some((subject) => changed.has(subject))
+	) {
+		return true
+	}
+
+	const inputs = read?.(path.resolve(test_file))
+
+	return inputs_in_change(inputs, test_file, changed)
 }
 
 // **`rerun` only when the log named a failed test and none of them belongs to the change**, `kept`
 // when one does. A job red with no test named — a lint, a build, a job gathering others' results — is
 // `unnamed`: rerun only as one waiting on a job red on tests outside the change (`followup-job-needs.ts`).
-function verdict_of(tests: FailedTests, changed: ReadonlySet<string>): TestVerdict {
+function verdict_of(
+	tests: FailedTests,
+	changed: ReadonlySet<string>,
+	read?: InputsReader,
+): TestVerdict {
+	if (tests.import_failure !== undefined) return KEPT_VERDICT
+	if (tests.files.length === 0) return UNNAMED_VERDICT
+
+	const is_outside = tests.files.every((file) => !is_in_change(file, changed, read))
+
+	return is_outside ? RERUN_VERDICT : KEPT_VERDICT
+}
+
+async function read_verdict(
+	tests: FailedTests,
+	changed: ReadonlySet<string>,
+): Promise<TestVerdict> {
+	if (tests.import_failure !== undefined) {
+		console.info(`🔧 Repair CI import failure before rerunning: ${tests.import_failure}`)
+
+		if (tests.files.length > 0) {
+			console.info(`${vitest_failure_summary.RERUN_PREFIX}${tests.files.join(' ')}`)
+		}
+
+		return KEPT_VERDICT
+	}
+
 	if (tests.files.length === 0) return UNNAMED_VERDICT
+	const graph = await import_graph.create(process.cwd())
 
-	return tests.files.every((file) => !is_in_change(file, changed)) ? RERUN_VERDICT : KEPT_VERDICT
+	return verdict_of(tests, changed, graph?.test_inputs)
 }
 
 // The ledger line a rerun leaves, so a test that keeps failing beside unrelated changes is counted
@@ -154,6 +214,7 @@ async function record(
 const followup_failed_tests = {
 	observation_of,
 	read_failed_tests,
+	read_verdict,
 	record,
 	record_entry,
 	subjects_of,

package/scripts/followup/followup-job-rerun.ts

@@ -181,6 +181,7 @@ async function read_job_log(job: Job): Promise<string> {
 
 function is_download_failure(log: string): boolean {
 	const plain_log = stripVTControlCharacters(log)
+	if (followup_failed_tests.read_failed_tests(plain_log).import_failure !== undefined) return false
 
 	return DOWNLOAD_ERRORS.some((error) => error.test(plain_log))
 }
@@ -195,10 +196,9 @@ async function judge_job(job: Job, changed: ReadonlySet<string>): Promise<Judged
 	const log = await read_job_log(job)
 	if (is_download_failure(log)) return { job, verdict: RERUN_VERDICT }
 	if (!is_first_attempt(job)) return { job, verdict: UNNAMED_VERDICT }
-
 	const tests = followup_failed_tests.read_failed_tests(log)
 
-	return { job, verdict: followup_failed_tests.verdict_of(tests, changed), tests }
+	return { job, verdict: await followup_failed_tests.read_verdict(tests, changed), tests }
 }
 
 // A job red with no test named qualifies as a gate that failed though every job it needs succeeded, and

package/scripts/gate/change-scope-action.integration.test.ts

@@ -0,0 +1,88 @@
+import { execFileSync } from 'node:child_process'
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { expect, it, onTestFinished } from 'vitest'
+
+// cspell:words gpgsign
+const SCRIPT = fileURLToPath(new URL('change-scope-action.ts', import.meta.url))
+const MANIFEST = 'package.json'
+const RELEASED = 'runtime=false\npublish=true\n'
+const ENVIRONMENT = Object.fromEntries(
+	Object.entries(process.env).filter(([key]) => !key.startsWith('GIT_')),
+)
+
+function git(root: string, args: Array<string>): string {
+	return execFileSync(
+		'/usr/bin/git',
+		[
+			'-c',
+			'user.name=Test',
+			'-c',
+			'user.email=test@example.com',
+			'-c',
+			'commit.gpgsign=false',
+			...args,
+		],
+		{ cwd: root, encoding: 'utf8', env: ENVIRONMENT },
+	).trim()
+}
+
+function repository(): string {
+	// Distributed tests cannot import kit's unpublished tools/test helper; cleanup is registered below.
+	// eslint-disable-next-line no-restricted-syntax
+	const root = mkdtempSync(path.join(tmpdir(), 'change-scope-action-'))
+
+	onTestFinished(() => rmSync(root, { recursive: true, force: true }))
+
+	git(root, ['init', '--quiet'])
+	writeFileSync(path.join(root, MANIFEST), JSON.stringify({ version: '1.0.0', files: ['src'] }))
+	git(root, ['add', MANIFEST])
+	git(root, ['commit', '--quiet', '-m', 'Initial manifest'])
+
+	return root
+}
+
+function run(root: string, base: string): string {
+	const output = path.join(root, 'outputs')
+
+	return execFileSync(process.execPath, [SCRIPT], {
+		cwd: root,
+		encoding: 'utf8',
+		env: { ...ENVIRONMENT, CHANGE_BASE: base, CHANGE_HEAD: 'HEAD', GITHUB_OUTPUT: output },
+	})
+}
+
+it('classifies Git history and writes the action output for a version-only bump', () => {
+	const root = repository()
+	const base = git(root, ['rev-parse', 'HEAD'])
+
+	writeFileSync(path.join(root, MANIFEST), JSON.stringify({ version: '1.0.1', files: ['src'] }))
+	git(root, ['commit', '--quiet', '-am', 'Bump version'])
+
+	expect(run(root, base)).toBe(RELEASED)
+	expect(readFileSync(path.join(root, 'outputs'), 'utf8')).toBe(RELEASED)
+})
+
+it('fails instead of skipping checks when the base revision cannot be read', () => {
+	const root = repository()
+
+	expect(() => run(root, 'missing-revision')).toThrow()
+})
+
+it.each([
+	['source.ts', 'runtime=true\npublish=false\n'],
+	['README.md', RELEASED],
+	['pnpm-lock.yaml', 'runtime=true\npublish=true\n'],
+])('classifies committed %s through the local action (ac-c3170ba1)', (name, expected) => {
+	const root = repository()
+	const base = git(root, ['rev-parse', 'HEAD'])
+
+	writeFileSync(path.join(root, name), 'changed\n')
+	git(root, ['add', name])
+	git(root, ['commit', '--quiet', '-m', 'Change input'])
+
+	expect(run(root, base)).toBe(expected)
+	expect(readFileSync(path.join(root, 'outputs'), 'utf8')).toBe(expected)
+})

package/scripts/gate/change-scope-action.ts

@@ -43,6 +43,8 @@ function metadata(manifest: Manifest): string {
 const { matches } = path_glob
 
 function published(file: string, entries: Array<string> = []): boolean {
+	// npm keeps an explicitly named file even when a broader test exclusion matches it.
+	if (entries.includes(file)) return true
 	const included = entries.filter((entry) => !entry.startsWith('!'))
 	const excluded = entries.filter((entry) => entry.startsWith('!'))
 

package/scripts/gate/check-related-order.ts

@@ -2,8 +2,8 @@ import type { CheckResult } from './check-related-section'
 
 // **`test:related` starts only once `lint:related` is green** (joshuafolkken/kit#5387): a lint failure,
 // a document over its budget found in seconds, still let a full-reach `test:related` run its minutes
-// out, and the fix paid that reach again. The other checks still start beside `lint:related`; a run
-// whose `lint:related` is reused starts `test:related` at once. A `test:related --touched` waits the same.
+// out, and the fix paid that reach again. All readers wait for lint's writers; a run
+// whose `lint:related` is reused starts them at once. A `test:related --touched` waits the same.
 
 const LINT_RELATED = 'lint:related'
 const TEST_RELATED = 'test:related'
@@ -36,9 +36,7 @@ async function is_lint_green(lint: Promise<CheckResult>): Promise<boolean> {
 // An executor that runs `lint:related` once, at whichever call asks first, and holds `test:related`
 // behind its verdict.
 function lint_first(execute: CheckExecutor, commands: ReadonlyArray<string>): CheckExecutor {
-	const has_test = commands.some((command) => is_test_related(command))
-
-	if (!has_test || !commands.includes(LINT_RELATED)) return execute
+	if (!commands.includes(LINT_RELATED)) return execute
 
 	const runs = new Map<string, Promise<CheckResult>>()
 
@@ -52,9 +50,10 @@ function lint_first(execute: CheckExecutor, commands: ReadonlyArray<string>): Ch
 
 	async function ordered(command: string): Promise<CheckResult> {
 		if (command === LINT_RELATED) return await lint_run()
-		if (!is_test_related(command)) return await execute(command)
+		const is_green = await is_lint_green(lint_run())
+		if (!is_green && is_test_related(command)) return skipped_result(command)
 
-		return (await is_lint_green(lint_run())) ? await execute(command) : skipped_result(command)
+		return await execute(command)
 	}
 
 	return ordered