@joshuafolkken/kit 1.3044.0 → 1.3099.0

package/scripts/run/wake/run-wake-driver.ts

@@ -1,3 +1,4 @@
+import { backlog_drive_retrospective_unit } from '#scripts/backlog/backlog-drive-retrospective-unit'
 import { epic_triage } from '#scripts/epic/epic-triage'
 import { josh_command, type JoshResult } from '#scripts/josh/josh-run'
 import { run_carry, type CarryRead, type RunCarry } from '#scripts/run/carry/run-carry'
@@ -16,6 +17,8 @@ const TRUNCATION_MARK = '... '
 const ERROR_PREFIX = 'error '
 const { WINDOW_MINUTES } = run_wake_window
 const WINDOW_VERDICT = 'window'
+// `backlog-drive.ts`'s drain owing the retrospective.
+const WATCH_VERDICT = 'watch'
 const { TRIAGE_VERDICT } = epic_triage
 
 function driver_args(invocation: string): ReadonlyArray<string> | undefined {
@@ -74,11 +77,24 @@ const NEXT_BY_VERDICT: ReadonlyArray<readonly [string, string]> = [
 const NEXT_DEFAULT = `act on the result by the sections below, ${HAND_BACK}`
 // **A triage session is woken beside the driver, never in its place** (joshuafolkken/kit#7120): the
 // record stays the supervisor's, so the session counts nothing and its turn end hands nothing back.
-const NEXT_BESIDE =
-	"\nNext: the carry record stays the supervisor's, whose driver keeps collecting and filling lanes beside this session, so run no pnpm josh run:carry; act on the result by the sections below, then end the turn"
+const BESIDE =
+	"\nNext: the carry record stays the supervisor's, whose driver keeps collecting and filling lanes beside this session"
+const NEXT_BESIDE = `${BESIDE}, so run no pnpm josh run:carry; act on the result by the sections below, then end the turn`
+
+// **A drain's retrospective runs beside the driver too** (joshuafolkken/kit#7506): handed over, the
+// record left the backlog unread until the session ended and the next pass re-drove, so an issue
+// filed meanwhile waited on the retrospective. Beside it, the driver's re-drive dispatches that issue,
+// and the session's process on the resume line holds the next `watch` back until it has ended
+// (`backlog_drive_park_triage.hand_back`). The record stays this process's, so the close names it.
+const BESIDE_VERDICTS: ReadonlySet<string> = new Set([TRIAGE_VERDICT, WATCH_VERDICT])
 
 function next_move(verdict: string): string {
 	if (verdict === TRIAGE_VERDICT) return NEXT_BESIDE
+
+	if (verdict === WATCH_VERDICT) {
+		return `${BESIDE}. ${backlog_drive_retrospective_unit.brief_of(String(process.pid))} Then end the turn`
+	}
+
 	const found = NEXT_BY_VERDICT.find(([prefix]) => verdict.startsWith(prefix))
 
 	return `\nNext: ${ALREADY_CLAIMED} ${found?.[1] ?? NEXT_DEFAULT}`
@@ -102,7 +118,7 @@ function judged(verdict: string, resume: string, details: string): DriveResult {
 		return { kind: 'failed', note: `backlog:drive returned an invalid resume line: ${resume}` }
 	}
 
-	const kind = verdict === TRIAGE_VERDICT ? 'triage' : 'judgment'
+	const kind = BESIDE_VERDICTS.has(verdict) ? 'triage' : 'judgment'
 
 	return { kind, material: handoff_material(verdict, resume, details) }
 }
@@ -145,13 +161,22 @@ function read_result(result: JoshResult | undefined, target: string): DriveResul
 // **A record this process already owns is claimed again.** A driver that failed leaves the record
 // adopted for the supervisor and not handed off, and the restarted pass re-drives it from here; only a
 // record another live process holds is refused.
+//
+// **A record this process already holds is kept as it is, never rewritten** (joshuafolkken/kit#7506):
+// the adopt removes and re-creates it from this read, so a beside session's `run:carry
+// --retrospective` landing between the two would lose its mark or read no record to close.
+function standing_of(carry: RunCarry): 'adopt' | 'kept' | 'refused' {
+	if (carry.is_handed_off === true) return 'adopt'
+	if (run_carry.is_held_by_self(carry)) return 'kept'
+
+	return run_carry.is_held_by_another(carry) ? 'refused' : 'adopt'
+}
+
 function claim_record(target: string, invocation: string): boolean {
 	const current = run_carry.read_carry(target)
 	if (current.kind !== 'carried' || current.carry.invocation !== invocation) return false
-
-	if (current.carry.is_handed_off !== true && run_carry.is_held_by_another(current.carry)) {
-		return false
-	}
+	const standing = standing_of(current.carry)
+	if (standing !== 'adopt') return standing === 'kept'
 
 	const owner = {
 		...run_carry.owner_of(process.pid),

package/scripts/run/wake/run-wake-handoff.ts

@@ -19,10 +19,7 @@ import { run_carry_reclaim } from '#scripts/run/carry/run-carry-reclaim'
 // The adoption also recovers a record whose owner died without a cut (`run-wake.ts` →
 // `decide_not_handed_off`): it rewrites the owner and clears any hand-off, whoever held it.
 //
-// **A Codex session cannot be given its session id** (`agent-argv.ts` → `build`), so neither its
-// transcript nor its pid is known here: it is adopted with the pid-less owner `run:carry --resume`
-// writes for it, and its pid is never moved onto the record — a pid it cannot match would make its
-// own counts a foreign live owner's.
+// Codex authenticates with a launch identity; the launched PID supplies liveness independently.
 //
 // `hand_off` is the older recovery the backlog preflight still runs: it marks the record handed off,
 // as a `--cut` does, so a later claim over it reads `resume` rather than `standing`.
@@ -34,7 +31,9 @@ interface WakeSession {
 }
 
 function session_owner(session: WakeSession): CarryOwner {
-	if (session.provider === agent_provider.OPENAI_PROVIDER) return { is_headless: true }
+	if (session.provider === agent_provider.OPENAI_PROVIDER) {
+		return { session: session.session_id, is_headless: true }
+	}
 
 	const directory = cost_transcript.transcript_directory(session.worktree)
 	const transcript = run_carry_conversation.transcript_of(session.session_id, directory)
@@ -60,11 +59,13 @@ function hand_to(target: string, owner: CarryOwner): void {
 	run_carry.adopt_carry(target, read.carry, { ...owner, provider: read.carry.scheduler_provider })
 }
 
-// Through `reclaim_at`, so the transcript the adoption named is what lets the pid move — one writer.
+// Through the shared reclaim writer, authenticated by transcript or launch identity.
 function hand_on(target: string, owner: CarryOwner, pid: number): void {
-	if (owner.transcript === undefined) return
+	if (owner.transcript === undefined && owner.session === undefined) return
 
-	run_carry_reclaim.reclaim_at(target, run_carry.owner_of(pid, undefined, owner.transcript))
+	const process_owner = run_carry.owner_of(pid, undefined, owner.transcript)
+
+	run_carry_reclaim.reclaim_at(target, { ...process_owner, session: owner.session })
 }
 
 // **The launched pid is the supervisor's own write, so it is no sign the session picked the run up**:

package/scripts/run/wake/run-wake-loop.ts

@@ -30,6 +30,8 @@ const STOPPED_BY_PERSON: LoopStop = { reason: STOPPED_REASON, note: undefined }
 const CODE_CHANGED: LoopStop = { reason: RELOAD_REASON, note: undefined }
 
 interface LoopPorts {
+	refresh?: () => void
+	session_failure?: () => string | undefined
 	// The carry record, re-read every pass rather than cached: it is written by the parent loop of a
 	// different session, which is the whole point of reading it here.
 	read_carry: () => CarryRead
@@ -200,14 +202,25 @@ async function retry_closes(ports: LoopPorts): Promise<void> {
 // stopping any lane. A record already removed ends the loop before this pass is reached, and a carry
 // record that ended or became unreadable stops the run before the code is checked, so a reload never
 // hands a finished run to a successor.
+async function preflight_stop(
+	decision: WakeDecision,
+	ports: LoopPorts,
+): Promise<LoopStop | undefined> {
+	if (decision.kind === 'stop') return undefined
+	const failure = ports.session_failure?.()
+	if (failure !== undefined) return { reason: FAILED_REASON, note: failure }
+
+	return (await ports.is_code_stale()) ? CODE_CHANGED : undefined
+}
+
 async function run_pass(
 	target: string,
 	wake: RunWake,
 	ports: LoopPorts,
 ): Promise<LoopStop | undefined> {
 	const decision = await decide_pass(wake, ports)
-
-	if (decision.kind !== 'stop' && (await ports.is_code_stale())) return CODE_CHANGED
+	const stop = await preflight_stop(decision, ports)
+	if (stop !== undefined) return stop
 
 	await retry_closes(ports)
 
@@ -254,12 +267,19 @@ function without_release_gap(ports: LoopPorts): LoopPorts {
 	}
 }
 
+function refreshed_wake(target: string, ports: LoopPorts): RunWake | undefined {
+	if (run_wake.read_own_wake(target) === undefined) return undefined
+	ports.refresh?.()
+
+	return run_wake.read_own_wake(target)
+}
+
 async function run_loop(target: string, ports: LoopPorts, interval_ms: number): Promise<LoopStop> {
 	const continuous = without_release_gap(ports)
 
 	return await poll.wait_for(
 		async () => {
-			const wake = run_wake.read_own_wake(target)
+			const wake = refreshed_wake(target, continuous)
 
 			return wake === undefined ? STOPPED_BY_PERSON : await run_pass(target, wake, continuous)
 		},

package/scripts/run/wake/run-wake-ports.ts

@@ -5,8 +5,10 @@ import { lane_close } from '#scripts/lane/lane-close'
 import { lane_withdraw_closed } from '#scripts/lane/lane-withdraw-closed'
 import { poll } from '#scripts/lib/poll'
 import { run_carry, type CarryOwner, type RunCarry } from '#scripts/run/carry/run-carry'
+import { run_carry_session } from '#scripts/run/carry/run-carry-session'
 import { run_event_setup } from '#scripts/run/event/run-event-setup'
 import { run_headless } from '#scripts/run/run-headless'
+import { run_wake_codex } from './run-wake-codex'
 import type { WakeContext } from './run-wake-describe'
 import { run_wake_driver } from './run-wake-driver'
 import { run_wake_handoff } from './run-wake-handoff'
@@ -66,7 +68,12 @@ function launch_session(
 	if (built === undefined) return { kind: 'failed', note: UNSAFE_INVOCATION_NOTE }
 	if (built.kind === 'rejected') return { kind: 'failed', note: built.note }
 
-	const target = { cwd: context.worktree, env: session.environment, log_path: context.log_target }
+	const target = {
+		cwd: context.worktree,
+		env: session.environment,
+		log_path: run_wake_codex.log_path(context, session.id, profile),
+	}
+	if (profile.provider === 'openai') note_to_stderr(`session output: ${target.log_path}`)
 
 	return run_wake_session.launch({ argv: built.argv, ...target, profile }, note_to_stderr)
 }
@@ -136,7 +143,10 @@ function session_ports(context: WakeContext, profile: AgentProfile): SessionPort
 			wake_session(context, invocation, profile, {
 				id: session_id,
 				material,
-				environment: run_headless.environment(),
+				environment:
+					profile.provider === 'openai'
+						? { ...run_headless.environment(), [run_carry_session.KEY]: session_id }
+						: run_headless.environment(),
 			}),
 		wake_beside: (invocation, session_id, material) =>
 			wake_beside(context, invocation, profile, {
@@ -164,7 +174,11 @@ function ports_for(
 
 	return {
 		is_code_stale,
-		read_carry: () => run_carry.read_carry(context.carry_target),
+		refresh: () => {
+			run_wake_codex.refresh(context)
+		},
+		session_failure: () => run_wake_codex.failure(context),
+		read_carry: () => run_wake_codex.read_carry(context),
 		is_owner_live: (read) => read.kind === 'carried' && is_session_at_work(read.carry),
 		has_work: async () => true,
 		...session_ports(context, profile),

package/scripts/run/wake/run-wake-takeover.ts

@@ -1,3 +1,4 @@
+import { backlog_dispatch_bound } from '#scripts/backlog/backlog-dispatch-bound'
 import { process_identity } from '#scripts/josh/process-identity'
 import { poll } from '#scripts/lib/poll'
 import { MS_PER_SECOND } from '#scripts/lib/timeouts'
@@ -13,8 +14,10 @@ import { run_wake_stop } from './run-wake-stop'
 // bound, is a reload that failed.
 
 const TAKEOVER_INTERVAL_MS = MS_PER_SECOND
-// A cold `tsx` start claims within seconds; the bound is generous so a loaded machine is not a failure.
-const TAKEOVER_ATTEMPTS = 120
+// A cold `tsx` start claims within seconds. The successor still has a driver to start after its claim,
+// so the claim gets what the dispatch bound leaves after that start (joshuafolkken/kit#7507).
+const TAKEOVER_WAIT_MS = backlog_dispatch_bound.NOTICE_MS
+const TAKEOVER_ATTEMPTS = TAKEOVER_WAIT_MS / TAKEOVER_INTERVAL_MS
 
 type TakeoverResult = 'taken' | 'died' | 'unclaimed'
 
@@ -60,7 +63,7 @@ async function await_takeover(
 	return result
 }
 
-const run_wake_takeover = { await_takeover, ports_of }
+const run_wake_takeover = { TAKEOVER_WAIT_MS, await_takeover, ports_of }
 
 export type { TakeoverPorts, TakeoverResult }
 export { run_wake_takeover }

package/scripts/run/wake/run-wake-window.ts

@@ -1,3 +1,4 @@
+import { backlog_dispatch_bound } from '#scripts/backlog/backlog-dispatch-bound'
 import { MS_PER_MINUTE } from '#scripts/lib/timeouts'
 
 // **The driver is bounded so the supervisor reaches its pass boundary between dispatches**
@@ -10,6 +11,8 @@ const WINDOW_MS = WINDOW_MINUTES * MS_PER_MINUTE
 // **The supervisor's pause between passes is its own, not the driver's offer interval**
 // (joshuafolkken/kit#6718): a pass reads local records, and the backlog only through the driver, so
 // stretching the offer interval for the REST budget must not slow how soon a judgment hand-off is seen.
-const PASS_INTERVAL_MS = MS_PER_MINUTE
+// A pass may start a fresh driver, so the pause is what the dispatch bound leaves after that start
+// (joshuafolkken/kit#7507).
+const PASS_INTERVAL_MS = backlog_dispatch_bound.NOTICE_MS
 
 export const run_wake_window = { WINDOW_MINUTES, WINDOW_MS, PASS_INTERVAL_MS }

package/scripts/run/wake/run-wake.ts

@@ -45,6 +45,8 @@ interface RunWake {
 	woke: number
 	// The grace window is measured from this; cleared when the woken session claims the record.
 	woke_at?: string | undefined
+	// Kept after claim so legacy shared-log completion can authenticate the launch.
+	launch_at?: string | undefined
 	// Launches for the current cut: what was started, against `woke`'s what arrived.
 	attempts?: number | undefined
 	// Named in the failure warning, never killed — a slow session is still doing the run's work.
@@ -100,6 +102,7 @@ const run_wake_schema = process_owner_schema.extend({
 	started_at: z.string(),
 	woke: z.number(),
 	woke_at: z.string().optional(),
+	launch_at: z.string().optional(),
 	// Every optional `RunWake` field must be listed: `z.object` strips undeclared ones on the round trip.
 	attempts: z.number().optional(),
 	woke_pid: z.number().optional(),
@@ -199,6 +202,7 @@ function carried_state(existing: RunWake | undefined, invocation: string): Parti
 	return {
 		woke: existing.woke,
 		woke_at: existing.woke_at,
+		launch_at: existing.launch_at,
 		attempts: existing.attempts,
 		woke_pid: existing.woke_pid,
 		spawned: existing.spawned,
@@ -266,6 +270,7 @@ function count_claim(wake: RunWake): RunWake {
 	return {
 		...wake,
 		woke,
+		launch_at: wake.woke_at ?? wake.launch_at,
 		woke_at: undefined,
 		attempts: undefined,
 		idle_since: undefined,

package/scripts/sync/sync-ai-files.ts

@@ -1,5 +1,6 @@
 import { existsSync, readFileSync } from 'node:fs'
 import path from 'node:path'
+import { is_workflow_destination } from '#scripts/claude/workflow-destination'
 import { init_ai_copy } from '#scripts/init/init-ai-copy'
 import { transform_copied_content } from '#scripts/init/init-copy-content'
 import { init_logic } from '#scripts/init/init-logic'
@@ -7,7 +8,9 @@ import { PACKAGE_DIR, PROJECT_ROOT } from '#scripts/init/init-paths'
 import type { ProjectShape } from '#scripts/init/project-profile'
 import { security_policy } from '#scripts/init/security-policy'
 import { file_reader } from '#scripts/lib/read-file'
+import { managed_marker_logic } from '#scripts/managed-marker/managed-marker-logic'
 import { pack_hook } from '#scripts/safe-chain/pack-hook'
+import { KIT_PACKAGE_NAME } from '#scripts/version/kit-descriptor'
 import { claude_settings_merge } from './claude-settings-merge'
 import { copy_directory_failure, directory_copy_blocker } from './directory-copy-guard'
 import { file_content } from './file-content'
@@ -20,7 +23,21 @@ const CLAUDE_MD_FILENAME = 'CLAUDE.md'
 const CLAUDE_SETTINGS_FILE = '.claude/settings.json'
 const CODEX_HOOKS_FILE = '.codex/hooks.json'
 
+function keep_custom_workflow(destination: string): boolean {
+	if (!is_workflow_destination(destination)) return false
+	const existing = file_reader.read_optional(destination)
+	if (existing === undefined) return false
+	const marker = `${managed_marker_logic.MARKER_PREFIX} ${KIT_PACKAGE_NAME}`
+	if (existing.split(/\r?\n/u, 1)[0] === marker) return false
+	console.warn(
+		`  ⚠ kept      ${destination} (custom workflow; migrate its acquisition settings manually)`,
+	)
+
+	return true
+}
+
 function sync_ai_file(source_path: string, destination_path: string): boolean {
+	if (keep_custom_workflow(destination_path)) return false
 	const content = readFileSync(source_path, 'utf8')
 
 	return file_content.write_text_if_changed(

package/scripts/sync/sync-configs.ts

@@ -35,7 +35,17 @@ function sync_with_merge(
 // lines, including env-var forms: npmrcAuthFile can opt the file into authentication from a deploy
 // dashboard that sync cannot inspect.
 function sync_npmrc(destination_path: string): void {
-	sync_with_merge(destination_path, '.npmrc', init_logic.merge_npmrc)
+	const existing = existsSync(destination_path) ? readFileSync(destination_path, 'utf8') : ''
+	const merged = init_logic.merge_npmrc(existing, path.dirname(destination_path))
+
+	if (merged === existing) {
+		console.info('  ✔ unchanged .npmrc')
+
+		return
+	}
+
+	file_content.write_contained(destination_path, merged)
+	console.info('  ✔ synced    .npmrc')
 }
 
 // Union-merge kit's .gitignore entries into the consumer file instead of overwriting it,

package/scripts/sync/sync.ts

@@ -194,7 +194,11 @@ function sync_consumer_resolved_development_deps(destination_path: string): void
 function sync_prepare_lefthook_warning(destination_path: string): void {
 	sync_package_json_with(
 		destination_path,
-		(existing) => init_logic.upgrade_prepare_lefthook_warning(existing),
+		(existing) =>
+			init_logic.upgrade_npm_lifecycle(
+				init_logic.upgrade_prepare_lefthook_warning(existing),
+				path.dirname(destination_path),
+			),
 		'  ✔ synced    prepare lefthook install warning (run `pnpm install`)',
 	)
 }

package/scripts/test/test-pinned-cache-logic.ts

@@ -17,13 +17,14 @@ import type { RedProbe, RedVerdict } from './test-red-logic'
 // failed before the revert reads red too — and a red kept past any of those, or past an edit to the test
 // that failed, would pass an unpinned hunk. A test added or edited elsewhere cannot make that test
 // pass, so it keeps the red. A red with no failed file recorded holds only while no test file changed either.
-// **A `green` or `no-test` one holds while no test file's path or content changed** (`test_contents`):
-// it is only rechecked when a test could have come to reach it, and a stale one stops a lane rather
-// than passing it.
+// **A `green` or `no-test` one holds while no test file's path or content changed, nor the test
+// runner's configuration** (`test_contents`, joshuafolkken/kit#7521 — a widened `include` runs a test
+// that never ran): it is only rechecked when a test could have come to reach it, and a stale one stops a
+// lane rather than passing it.
 // **Past those tree-wide digests, a verdict also holds while its own `basis` is the same**
 // (joshuafolkken/kit#4873): for a `red`, the base commit, the changed non-code and whole-suite files,
 // and each failed test's import closure; for any other, the tests whose imports reach the hunk's file,
-// with their content. An edit outside them keeps the verdict; with no basis — no import graph, no
+// with their content, and the test runner's configuration. An edit outside them keeps the verdict; with no basis — no import graph, no
 // failed file recorded — only the tree-wide digests hold it, as before.
 // **A `red` verdict also holds while `pruned` reads the same** (joshuafolkken/kit#5004): the code
 // change since differs only by lines removed from `green` hunks (`test-pinned-prune-logic.ts`).
@@ -219,11 +220,16 @@ function fresh_verdict(
 	return { verdict: entry.verdict, failed: Object.keys(entry.tests) }
 }
 
-// A `green` or `no-test` verdict's basis: each test whose imports reach the hunk's file, with its content.
-function related_basis(tests: ReadonlyArray<string>, digests: ReadonlyMap<string, string>): Basis {
+// A `green` or `no-test` verdict's basis: each test whose imports reach the hunk's file, with its content,
+// and `config`, the test runner's configuration — which of those tests a run collects.
+function related_basis(
+	tests: ReadonlyArray<string>,
+	digests: ReadonlyMap<string, string>,
+	config: string,
+): Basis {
 	const pairs = sorted(tests).map((file) => [file, digests.get(file) ?? ''] as const)
 
-	return { digest: digest_of(JSON.stringify(pairs)), related: Object.fromEntries(pairs) }
+	return { digest: digest_of(JSON.stringify([config, pairs])), related: Object.fromEntries(pairs) }
 }
 
 // The tests added or edited since `before` was read; `undefined` once one of its tests is gone or no

package/scripts/test/test-pinned-cache.ts

@@ -1,6 +1,7 @@
 import { existsSync } from 'node:fs'
 import { readFile } from 'node:fs/promises'
 import path from 'node:path'
+import { config_fingerprint } from '#eslint/config-fingerprint.js'
 import { changed_paths } from '#scripts/git/changed-paths'
 import { git_spawn } from '#scripts/git/git-spawn'
 import { run_record_path } from '#scripts/josh/run-record-path'
@@ -18,6 +19,7 @@ import type { Hunk } from './test-pinned-logic'
 import { test_pinned_prune_logic, type CodeChange } from './test-pinned-prune-logic'
 import { test_pinned_reach, type Reach } from './test-pinned-reach'
 import type { RedProbe } from './test-red-logic'
+import { test_runner_config } from './test-runner-config'
 
 // The reads and writes of `josh test:pinned`'s verdict cache (joshuafolkken/kit#4706); what a key is and
 // when an entry holds is `test-pinned-cache-logic.ts`. `josh run:review` calls the same `test_pinned.run`,
@@ -31,9 +33,11 @@ const LINE_BREAK = '\n'
 // Peels a ref or tag to the commit it names, so a branch name and its SHA key the same change.
 const AS_COMMIT = '^{commit}'
 
+// `config` is one digest over the test runner's configuration files, which `test_contents` covers too.
 interface TreeRead {
 	test_digests: ReadonlyMap<string, string>
 	code: CodeChange
+	config: string
 	test_contents: string
 	change: string
 }
@@ -45,6 +49,7 @@ interface LoadedCache extends VerdictCache {
 	base: string
 	freshness: Freshness
 	test_digests: ReadonlyMap<string, string>
+	config: string
 	reach: Reach
 	code: CodeChange
 	hunks: ReadonlyArray<Hunk>
@@ -79,11 +84,11 @@ async function contents_of(files: ReadonlyArray<string>): Promise<Map<string, st
 	return new Map(existing.map((file, index) => [file, texts[index] ?? '']))
 }
 
-// Every test file in the work tree, tracked or untracked but not ignored.
-async function test_files(): Promise<Array<string>> {
+// Every file in the work tree `is_kept` accepts, tracked or untracked but not ignored.
+async function work_tree_files(is_kept: (file: string) => boolean): Promise<Array<string>> {
 	const listed = await test_pinned_reach.work_tree_files()
 
-	return listed.filter((file) => test_declared_logic.is_test_file(file))
+	return listed.filter((file) => is_kept(file))
 }
 
 // The digest of each named file the work tree still holds.
@@ -95,9 +100,20 @@ async function digests_of(files: ReadonlyArray<string>): Promise<Map<string, str
 	)
 }
 
-// Each test file's content digest, keyed by its path.
-async function test_digests_of(): Promise<Map<string, string>> {
-	return await digests_of(await test_files())
+// Each work tree file's content digest `is_kept` accepts, keyed by its path.
+async function kept_digests_of(is_kept: (file: string) => boolean): Promise<Map<string, string>> {
+	return await digests_of(await work_tree_files(is_kept))
+}
+
+// Each test runner configuration file and every local module it imports — where an `include` list may
+// sit, as `tools/test/vitest-include-globs.ts` does here — with its content digest.
+async function config_digests_of(): Promise<Map<string, string>> {
+	const configs = await work_tree_files((file) => test_runner_config.is_config(file))
+	const reached = config_fingerprint.list_reachable_modules(
+		configs.map((file) => path.resolve(file)),
+	)
+
+	return await digests_of([...reached].map((file) => path.relative(process.cwd(), file)))
 }
 
 // One digest over every test file's path and content.
@@ -123,13 +139,19 @@ async function code_change(base: string): Promise<CodeChange> {
 	return { commit: commit.trim(), code, digests: await digests_of(code) }
 }
 
-// The work tree's tree-wide digests, with what they were read off.
+// The work tree's tree-wide digests, with what they were read off. A test runner configuration change
+// can make a test run that never ran, so it moves `test_contents` as a test file would
+// (joshuafolkken/kit#7521).
 async function read_tree(base: string): Promise<TreeRead> {
-	const [test_digests, code] = await Promise.all([test_digests_of(), code_change(base)])
-	const test_contents = contents_digest(test_digests)
+	const [test_digests, configs, code] = await Promise.all([
+		kept_digests_of((file) => test_declared_logic.is_test_file(file)),
+		config_digests_of(),
+		code_change(base),
+	])
+	const test_contents = contents_digest(new Map([...test_digests, ...configs]))
 	const change = test_pinned_cache_logic.change_of(code.commit, code.code, code.digests)
 
-	return { test_digests, code, test_contents, change }
+	return { test_digests, code, config: contents_digest(configs), test_contents, change }
 }
 
 // The cache file's text and what the work tree holds now, with the files `hunks` and the recorded
@@ -176,7 +198,7 @@ async function basis_of(
 	if (probe.verdict !== 'red') {
 		const tests = await cache.reach.related(file)
 
-		return tests && test_pinned_cache_logic.related_basis(tests, cache.test_digests)
+		return tests && test_pinned_cache_logic.related_basis(tests, cache.test_digests, cache.config)
 	}
 
 	const digest = await cache.reach.failed(probe.failed)

package/scripts/test/test-related-cap.ts

@@ -4,11 +4,12 @@ import { direct_importers } from './direct-importers'
 import { test_declared_logic } from './test-declared-logic'
 import { test_pinned_logic } from './test-pinned-logic'
 import { test_pinned_reach, type ReachedCount } from './test-pinned-reach'
+import { test_related_imports } from './test-related-imports'
 import { test_related_pins } from './test-related-pins'
 import { related_scope } from './test-related-scope'
 
 // **A change whose imports reach more than `test_pinned_logic.MAX_TEST_FILES` test files runs only the
-// tests importing its widest files directly** (joshuafolkken/kit#5532, #5702), as a file every test imports does
+// tests importing its widest files directly when their imports are unchanged** (#7453, #5532, #5702), as a file every test imports does
 // (`direct-importers.ts`): the tests past them stay unchecked here, for `josh gate`'s whole suite and
 // CI to run. `--keep-whole-suite` (the gate's unit leg) lifts the cap outside a lane
 // (`test-related-whole.ts`), and so does a missing graph.
@@ -85,7 +86,8 @@ async function direct_of(
 	root: string,
 	over_cap: ReadonlyArray<string>,
 ): Promise<Array<[string, Array<string>]>> {
-	const importers = await direct_importers.importers_of(root, over_cap)
+	const stable = await test_related_imports.stable_files(root, over_cap)
+	const importers = await direct_importers.importers_of(root, stable)
 	const narrowed = [...importers].filter(([, tests]) => tests.length > 0)
 
 	return narrowed.map(([file, tests]) => [file, test_related_pins.with_pins(file, tests)])
@@ -96,7 +98,9 @@ async function split_of(
 	root: string,
 	files: ReadonlyArray<string>,
 ): Promise<[Map<string, Array<string>>, Array<string>]> {
-	const every_test = await direct_importers.every_test_importers(root, files)
+	const shared = direct_importers.every_test_imports_of(files)
+	const stable = await test_related_imports.stable_files(root, shared)
+	const every_test = await direct_importers.every_test_importers(root, stable)
 
 	return [every_test, candidates_of(root, files, every_test)]
 }

package/scripts/test/test-related-imports.ts

@@ -0,0 +1,92 @@
+import { readFileSync } from 'node:fs'
+import path from 'node:path'
+import { change_base } from '#scripts/git/change-base'
+import { git_spawn } from '#scripts/git/git-spawn'
+import type ts from 'typescript'
+
+type TypeScript = typeof ts
+
+interface Comparison {
+	base: string
+	typescript: TypeScript
+}
+
+// A new import can break an indirect test's mock while every direct importer passes (#7453).
+// Only unchanged import declarations and targets may use the direct-only cap. Unknown history keeps reach.
+function is_loading(typescript: TypeScript, node: ts.Node, source: ts.SourceFile): boolean {
+	if (!typescript.isCallExpression(node)) return false
+
+	return (
+		node.expression.kind === typescript.SyntaxKind.ImportKeyword ||
+		node.expression.getText(source) === 'require'
+	)
+}
+
+function signature(typescript: TypeScript, file: string, content: string): string {
+	const source = typescript.createSourceFile(file, content, typescript.ScriptTarget.Latest)
+	const declarations: Array<string> = []
+
+	function visit(node: ts.Node): void {
+		if (
+			typescript.isImportDeclaration(node) ||
+			typescript.isExportDeclaration(node) ||
+			is_loading(typescript, node, source)
+		) {
+			declarations.push(node.getText(source))
+		}
+
+		typescript.forEachChild(node, visit)
+	}
+
+	visit(source)
+
+	return JSON.stringify(declarations)
+}
+
+async function is_stable(root: string, file: string, comparison: Comparison): Promise<boolean> {
+	if (path.extname(file) === '.svelte') return false
+
+	try {
+		const before = await git_spawn.read(['-C', root, 'show', `${comparison.base}:${file}`])
+		const current = readFileSync(path.join(root, file), 'utf8')
+
+		return (
+			signature(comparison.typescript, file, before) ===
+			signature(comparison.typescript, file, current)
+		)
+	} catch {
+		return false
+	}
+}
+
+async function compare(root: string, files: ReadonlyArray<string>): Promise<Array<boolean>> {
+	try {
+		const base = await change_base.resolved_through_merge()
+		if (base === undefined) return files.map(() => false)
+		const { default: typescript } = await import('typescript')
+
+		return await Promise.all(
+			files.map(async (file) => await is_stable(root, file, { base, typescript })),
+		)
+	} catch {
+		return files.map(() => false)
+	}
+}
+
+async function stable_files(root: string, files: ReadonlyArray<string>): Promise<Array<string>> {
+	if (files.length === 0) return []
+	const stable = await compare(root, files)
+	const retained = files.filter((_file, index) => stable[index] !== true)
+
+	if (retained.length > 0) {
+		process.stdout.write(
+			`josh test:related: keeping full reach (imports changed or unknown): ${retained.join(', ')}\n`,
+		)
+	}
+
+	return files.filter((_file, index) => stable[index] === true)
+}
+
+const test_related_imports = { stable_files }
+
+export { test_related_imports }