@joshuafolkken/kit 1.1514.0 → 1.1784.0

package/scripts/git/git-spawn.ts

@@ -1,4 +1,4 @@
-import { GIT_TIMEOUT_MS } from '#scripts/lib/timeouts'
+import { GIT_TIMEOUT_MS, MS_PER_SECOND } from '#scripts/lib/timeouts'
 import { execa } from 'execa'
 import { git_utilities } from './constants'
 import {
@@ -47,7 +47,6 @@ async function read(
 // still takes this one. The push's budget is reused rather than a second number chosen: both transfer
 // objects over the same transport, and that one is already read off what a healthy transfer costs here.
 const REMOTE_TIMEOUT_MS = PUSH_TIMEOUT_MS
-const MS_PER_SECOND = 1000
 
 // A budget kill is reported as a timeout, never as whatever the killed process printed first, and
 // `cause` carries the same `TIMEOUT_EXIT_CODE` a timed-out push does. Unlike the push it is not

package/scripts/git/git-status.ts

@@ -1,9 +1,9 @@
 import { animation_helpers, type AnimationOptions } from '#scripts/lib/animation-helpers'
+import { PACKAGE_JSON } from '#scripts/lib/package-manifest'
 import { REQUIRED_STATUS_LENGTH, STAGED_STATUS_INDEX, UNTRACKED_FILE_PREFIX } from './constants'
 import { git_command } from './git-command'
 
 const WARNING_ICON = '🔔'
-const PACKAGE_JSON_FILE = 'package.json'
 const STATUS_PREFIX_LENGTH = 2
 const VERSION_NOT_UPDATED = 'Not updated'
 
@@ -62,7 +62,7 @@ function is_package_json_staged(status_output: string): boolean {
 
 		const filename = extract_filename(line)
 
-		return filename === PACKAGE_JSON_FILE
+		return filename === PACKAGE_JSON
 	})
 }
 
@@ -148,7 +148,7 @@ async function check_package_json_version(): Promise<boolean> {
 	return await animation_helpers.execute_with_animation(
 		'Checking if package.json version is updated...',
 		async () => {
-			const diff_output: string = await git_command.diff_cached(PACKAGE_JSON_FILE)
+			const diff_output: string = await git_command.diff_cached(PACKAGE_JSON)
 
 			return is_version_updated_in_diff(diff_output)
 		},
@@ -166,7 +166,7 @@ async function check_branch_version(): Promise<boolean> {
 	return await animation_helpers.execute_with_animation(
 		'Checking if version is already updated on this branch...',
 		async () => {
-			const diff_output: string = await git_command.diff_main(PACKAGE_JSON_FILE)
+			const diff_output: string = await git_command.diff_main(PACKAGE_JSON)
 
 			return is_version_updated_in_diff(diff_output)
 		},

package/scripts/git/main-merge-main.ts

@@ -0,0 +1,12 @@
+#!/usr/bin/env tsx
+import { fileURLToPath } from 'node:url'
+import { main_merge } from './main-merge'
+
+// The `josh main:merge` entry, kept apart from `main-merge.ts` because `run-ship-sync.ts` imports
+// that one: a bundle is one file, so a main guard there would fire for every command that carries it
+// (joshuafolkken/kit#4186).
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+	const ARGV_OFFSET = 2
+
+	process.exitCode = await main_merge.run(process.argv.slice(ARGV_OFFSET))
+}

package/scripts/git/main-merge-regenerate.ts

@@ -10,7 +10,7 @@ import { git_spawn } from './git-spawn'
 // **This table is the single list of what is resolved that way** — a file a person writes never
 // belongs in it, because regenerating would discard that person's side of the merge. A conflict on any
 // path not listed here still stops as `conflict`. A file belongs here only once its committed content
-// is exactly what its command writes: `scripts/test/pure-files.ts` is not, so regenerating it would
+// is exactly what its command writes: `tools/test/pure-files.ts` is not, so regenerating it would
 // rewrite far more than the conflict.
 
 interface RegeneratedFile {
@@ -21,7 +21,7 @@ interface RegeneratedFile {
 const REGENERATED_FILES: ReadonlyArray<RegeneratedFile> = [
 	{
 		path: 'docs/josh-command-catalog.md',
-		command: ['pnpm', 'exec', 'tsx', 'scripts/document/generate-catalog.ts'],
+		command: ['pnpm', 'exec', 'tsx', 'tools/document/generate-catalog.ts'],
 	},
 ]
 

package/scripts/git/main-merge.ts

@@ -1,9 +1,9 @@
-#!/usr/bin/env tsx
-import { fileURLToPath } from 'node:url'
 import { extract_issue_number } from '#scripts/hooks/check-commit-message'
 import { issue_cite } from '#scripts/issue/issue-cite'
 import { composite_arguments, USAGE_ERROR_EXIT_CODE } from '#scripts/josh/josh-composite-arguments'
 import { error_text } from '#scripts/lib/error-message'
+import { split_assess } from '#scripts/split/split-assess'
+import { split_measure } from '#scripts/split/split-measure'
 import { git_command } from './git-command'
 import { main_merge_guard } from './main-merge-guard'
 import { main_merge_regenerate } from './main-merge-regenerate'
@@ -30,8 +30,9 @@ import { main_merge_regenerate } from './main-merge-regenerate'
 
 const SUCCESS_EXIT_CODE = 0
 const FAILURE_EXIT_CODE = 1
-const ARGV_OFFSET = 2
 const COMMAND_NAME = 'main:merge'
+const SPLIT_UNMEASURED =
+	'split notice: the diff could not be measured — run `pnpm josh split:assess`'
 
 // git's default merge message carries no `#N`, so on an issue branch the `commit-msg` hook refuses
 // it and leaves the index mid-merge. The number is read with the hook's
@@ -115,6 +116,25 @@ function failure_text(outcome: MergeOutcome): string | undefined {
 	return undefined
 }
 
+// joshuafolkken/kit#4302: every implementing run merges the default branch immediately before the
+// gate, so this is where a diff that outgrew the entry's split estimate is told so. The notice is
+// advisory: a finished merge never fails on it, and an unreadable diff says so rather than reading as
+// under the guide. It sits on the command, not on `merge()`, because `josh ship` merges again past the
+// point a run can act on it.
+async function split_notice(): Promise<string | undefined> {
+	try {
+		return split_assess.notice(await split_measure.read_branch())
+	} catch (error) {
+		return `${SPLIT_UNMEASURED}: ${error_text.message_of(error)}`
+	}
+}
+
+async function warn_over_split_guide(): Promise<void> {
+	const notice = await split_notice()
+
+	if (notice !== undefined) console.warn(notice)
+}
+
 async function merge_default_branch(): Promise<number> {
 	const outcome = await merge()
 	const failure = failure_text(outcome)
@@ -127,6 +147,8 @@ async function merge_default_branch(): Promise<number> {
 
 	if ('branch' in outcome) console.info(outcome.branch)
 
+	await warn_over_split_guide()
+
 	return SUCCESS_EXIT_CODE
 }
 
@@ -154,13 +176,7 @@ async function run(argv: ReadonlyArray<string>): Promise<number> {
 	}
 }
 
-async function main(argv: ReadonlyArray<string>): Promise<void> {
-	process.exitCode = await run(argv)
-}
-
 const main_merge = { merge, run }
 
-if (process.argv[1] === fileURLToPath(import.meta.url)) await main(process.argv.slice(ARGV_OFFSET))
-
 export { main_merge }
 export type { MergeOutcome }

package/scripts/git/main-sync-main.ts

@@ -0,0 +1,12 @@
+#!/usr/bin/env tsx
+import { fileURLToPath } from 'node:url'
+import { main_sync } from './main-sync'
+
+// The `josh main:sync` entry, kept apart from `main-sync.ts` because `observations-flush.ts` imports
+// that one: a bundle is one file, so a main guard there would fire for every command that carries it
+// (joshuafolkken/kit#4186).
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+	const ARGV_OFFSET = 2
+
+	process.exitCode = await main_sync.run(process.argv.slice(ARGV_OFFSET))
+}

package/scripts/git/main-sync.ts

@@ -1,5 +1,3 @@
-#!/usr/bin/env tsx
-import { fileURLToPath } from 'node:url'
 import { composite_arguments, USAGE_ERROR_EXIT_CODE } from '#scripts/josh/josh-composite-arguments'
 import { error_text } from '#scripts/lib/error-message'
 import { git_command } from './git-command'
@@ -27,7 +25,6 @@ import { lockfile_sync } from './lockfile-sync'
 
 const SUCCESS_EXIT_CODE = 0
 const FAILURE_EXIT_CODE = 1
-const ARGV_OFFSET = 2
 const COMMAND_NAME = 'main:sync'
 const INSTALL_FAILURE =
 	'node_modules is behind pnpm-lock.yaml and `pnpm install --frozen-lockfile` failed; run `pnpm josh ms` again, or the install here by hand.'
@@ -144,12 +141,6 @@ async function run(argv: ReadonlyArray<string>): Promise<number> {
 	}
 }
 
-async function main(argv: ReadonlyArray<string>): Promise<void> {
-	process.exitCode = await run(argv)
-}
-
 const main_sync = { run }
 
-if (process.argv[1] === fileURLToPath(import.meta.url)) await main(process.argv.slice(ARGV_OFFSET))
-
 export { main_sync }

package/scripts/git/stash/git-stash.ts

@@ -1,4 +1,5 @@
 import { git_spawn } from '#scripts/git/git-spawn'
+import { LEDGER_EXCLUSION_PATHSPEC } from '#scripts/observations/observation-ledger'
 
 // The one place a sanctioned `git stash pop` is targeted by its message rather than its stack
 // position. The stash is a single repository-wide stack shared by every
@@ -97,14 +98,34 @@ async function has_conflict(directory?: string): Promise<boolean> {
 
 // Uncommitted work is anything `git status --porcelain` lists — untracked files included, which is what
 // `push` below carries with `-u`, so the two agree on what "work" means.
-async function has_changes(directory?: string): Promise<boolean> {
-	return (await git_spawn.read(git_args(directory, ['status', '--porcelain']))) !== ''
+// A `pathspec` narrows both to the same paths, so a push never finds nothing where this found work.
+async function has_changes(
+	directory?: string,
+	pathspec: ReadonlyArray<string> = [],
+): Promise<boolean> {
+	const status = await git_spawn.read(git_args(directory, ['status', '--porcelain', ...pathspec]))
+
+	return status !== ''
+}
+
+// What `josh stash:push` sets aside: everything but the observation ledger, whose lines ride on the
+// run's own commit (`stash-push-cli.ts`).
+const STASHABLE_PATHSPEC: ReadonlyArray<string> = ['--', ...LEDGER_EXCLUSION_PATHSPEC]
+
+// Whether `josh stash:push` would push anything — the question to ask before telling someone to run it,
+// so a ledger-only tree is never sent to a push that answers `clean`.
+async function has_stashable_changes(directory?: string): Promise<boolean> {
+	return await has_changes(directory, STASHABLE_PATHSPEC)
 }
 
 // Push with a message `josh stash:pop` can later target — the stack is shared by every work tree, so an
 // entry pushed from a lane outlives the lane's own tree.
-async function push(message: string, directory?: string): Promise<void> {
-	await git_spawn.read(git_args(directory, ['stash', 'push', '-u', '-m', message]))
+async function push(
+	message: string,
+	directory?: string,
+	pathspec: ReadonlyArray<string> = [],
+): Promise<void> {
+	await git_spawn.read(git_args(directory, ['stash', 'push', '-u', '-m', message, ...pathspec]))
 }
 
 // The stack keyed by commit rather than position: a sweep that reads the
@@ -181,6 +202,7 @@ const git_stash = {
 	drop_by_hash,
 	has_changes,
 	has_conflict,
+	has_stashable_changes,
 	list,
 	list_by_hash,
 	matches,
@@ -188,6 +210,7 @@ const git_stash = {
 	pop,
 	push,
 	select,
+	STASHABLE_PATHSPEC,
 	work_message,
 }
 

package/scripts/git/stash/{stash-pop-args.ts → stash-args.ts}

@@ -1,13 +1,12 @@
 import { cli_flags } from '#scripts/lib/cli-flags'
 
-// `josh stash:pop` turns its `argv` into a single request: the message of the stash to pop. Parsing
-// lives here, acting on the stack lives in `stash-pop-cli.ts`, and a malformed command line is
-// `undefined` rather than a guessed intent — a pop run on a misread argument would take the wrong
-// entry off a stack shared by every lane.
+// `josh stash:push` and `josh stash:pop` turn their `argv` into a single request: the message of the
+// stash to push or pop. Parsing lives here, acting on the stack lives in each command's cli, and a
+// malformed command line is `undefined` rather than a guessed intent — a pop run on a misread argument
+// would take the wrong entry off a stack shared by every lane, and a push without its message would
+// leave an entry nothing can target.
 
-const USAGE = 'Usage: josh stash:pop "<message>" [--dir <path>]'
-
-// `--dir` points the pop at a lane's work tree; without it the pop lands in the current checkout.
+// `--dir` points the command at a lane's work tree; without it, it acts on the current checkout.
 const OPTIONS = { dir: { type: 'string' } } as const
 
 interface ParsedValues {
@@ -20,12 +19,16 @@ interface Request {
 	dir: string | undefined
 }
 
+function usage(command: string): string {
+	return `Usage: josh ${command} "<message>" [--dir <path>]`
+}
+
 function read_arguments(argv: ReadonlyArray<string>): ParsedValues | undefined {
 	return cli_flags.arguments_of(argv, OPTIONS)
 }
 
 // The message is the sole positional and must be a non-empty string: an empty message matches every
-// stash pushed without a message, which is exactly the ambiguity this command exists to refuse.
+// stash pushed without a message, which is exactly the ambiguity `stash:pop` exists to refuse.
 function message_of(positionals: ReadonlyArray<string>): string | undefined {
 	if (positionals.length !== 1) return undefined
 
@@ -42,7 +45,7 @@ function to_request(parsed: ParsedValues): Request | undefined {
 	return { message, dir: parsed.values.dir }
 }
 
-const stash_pop_args = { USAGE, read_arguments, to_request }
+const stash_args = { read_arguments, to_request, usage }
 
 export type { Request }
-export { stash_pop_args }
+export { stash_args }

package/scripts/git/stash/stash-pop-cli.ts

@@ -1,7 +1,6 @@
-import { fileURLToPath } from 'node:url'
 import { error_text } from '#scripts/lib/error-message'
 import { git_stash } from './git-stash'
-import { stash_pop_args, type Request } from './stash-pop-args'
+import { stash_args, type Request } from './stash-args'
 
 // `josh stash:pop "<message>"` — pop the stash whose message matches, and no other.
 // The stash stack is shared by every working tree of the repository, so a
@@ -9,6 +8,8 @@ import { stash_pop_args, type Request } from './stash-pop-args'
 // selector from the message and pops that entry alone; no match and more than one match are both
 // refusals rather than a guess at which was meant.
 
+const COMMAND = 'stash:pop'
+
 const POPPED_VERDICT = 'popped'
 const CONFLICTED_VERDICT = 'conflicted'
 const NO_MATCH_VERDICT = 'no-match'
@@ -16,7 +17,6 @@ const AMBIGUOUS_VERDICT = 'ambiguous'
 
 const SUCCESS_EXIT_CODE = 0
 const FAILURE_EXIT_CODE = 1
-const ARGV_OFFSET = 2
 
 function report(verdict: string, detail: string, code: number): number {
 	console.info(verdict)
@@ -26,7 +26,7 @@ function report(verdict: string, detail: string, code: number): number {
 }
 
 function refuse(): number {
-	console.error(stash_pop_args.USAGE)
+	console.error(stash_args.usage(COMMAND))
 
 	return FAILURE_EXIT_CODE
 }
@@ -73,11 +73,11 @@ function report_unknown(error: unknown): number {
 }
 
 async function run(argv: ReadonlyArray<string>): Promise<number> {
-	const parsed = stash_pop_args.read_arguments(argv)
+	const parsed = stash_args.read_arguments(argv)
 
 	if (parsed === undefined) return refuse()
 
-	const request = stash_pop_args.to_request(parsed)
+	const request = stash_args.to_request(parsed)
 
 	if (request === undefined) return refuse()
 
@@ -88,10 +88,6 @@ async function run(argv: ReadonlyArray<string>): Promise<number> {
 	}
 }
 
-async function main(argv: ReadonlyArray<string>): Promise<void> {
-	process.exitCode = await run(argv)
-}
-
 const stash_pop_cli = {
 	AMBIGUOUS_VERDICT,
 	CONFLICTED_VERDICT,
@@ -100,6 +96,4 @@ const stash_pop_cli = {
 	run,
 }
 
-if (process.argv[1] === fileURLToPath(import.meta.url)) await main(process.argv.slice(ARGV_OFFSET))
-
 export { stash_pop_cli }

package/scripts/git/stash/stash-pop-main.ts

@@ -0,0 +1,12 @@
+#!/usr/bin/env tsx
+import { fileURLToPath } from 'node:url'
+import { stash_pop_cli } from './stash-pop-cli'
+
+// The `josh stash:pop` entry, kept apart from `stash-pop-cli.ts` because `latest-if-required-cli.ts`
+// imports that one: a bundle is one file, so a main guard there would fire for every command that
+// carries it (joshuafolkken/kit#4186).
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+	const ARGV_OFFSET = 2
+
+	process.exitCode = await stash_pop_cli.run(process.argv.slice(ARGV_OFFSET))
+}

package/scripts/git/stash/stash-push-cli.ts

@@ -0,0 +1,76 @@
+import { error_text } from '#scripts/lib/error-message'
+import { git_stash } from './git-stash'
+import { stash_args, type Request } from './stash-args'
+
+// `josh stash:push "<message>"` — the one way a workflow sets its working tree aside, paired with
+// `josh stash:pop "<message>"` that brings it back. Two rules fix what it takes:
+//
+// - **Untracked files go with it (`-u`).** Work in progress almost always includes a new, untracked
+//   `*.test.ts`; a stash that leaves it behind leaves it for the next `pnpm josh ms` to refuse.
+// - **The observation ledger stays** — every path `observation_ledger.is_ledger_path` names, legacy
+//   ones included (`git_stash.STASHABLE_PATHSPEC`). A run appends its own lines to `.josh/observations/` and they
+//   ride on that run's commit; a stash would take them off the tree before the commit or the
+//   batch-end flush could see them.
+//
+// A tree with nothing outside the ledger to set aside pushes nothing and says `clean`, so a procedure
+// can call it unconditionally and pop only after `stashed`.
+
+const COMMAND = 'stash:push'
+
+const STASHED_VERDICT = 'stashed'
+const CLEAN_VERDICT = 'clean'
+
+const SUCCESS_EXIT_CODE = 0
+const FAILURE_EXIT_CODE = 1
+
+function report(verdict: string, detail: string): number {
+	console.info(verdict)
+	console.error(detail)
+
+	return SUCCESS_EXIT_CODE
+}
+
+function refuse(): number {
+	console.error(stash_args.usage(COMMAND))
+
+	return FAILURE_EXIT_CODE
+}
+
+type PushVerdict = typeof STASHED_VERDICT | typeof CLEAN_VERDICT
+
+// The decision and the push without the printing, so a caller that chains a pop on `stashed`
+// (`josh latest:if-required`) reads the verdict instead of parsing stdout.
+async function set_aside(request: Request): Promise<PushVerdict> {
+	if (!(await git_stash.has_stashable_changes(request.dir))) return CLEAN_VERDICT
+
+	await git_stash.push(request.message, request.dir, git_stash.STASHABLE_PATHSPEC)
+
+	return STASHED_VERDICT
+}
+
+async function answer(request: Request): Promise<number> {
+	if ((await set_aside(request)) === CLEAN_VERDICT) {
+		return report(CLEAN_VERDICT, 'Nothing to stash.')
+	}
+
+	return report(STASHED_VERDICT, `Stashed as "${request.message}".`)
+}
+
+async function run(argv: ReadonlyArray<string>): Promise<number> {
+	const parsed = stash_args.read_arguments(argv)
+	const request = parsed === undefined ? undefined : stash_args.to_request(parsed)
+
+	if (request === undefined) return refuse()
+
+	try {
+		return await answer(request)
+	} catch (error) {
+		console.error(error_text.message_of(error))
+
+		return FAILURE_EXIT_CODE
+	}
+}
+
+const stash_push_cli = { CLEAN_VERDICT, STASHED_VERDICT, run, set_aside }
+
+export { stash_push_cli }

package/scripts/git/stash/stash-push-main.ts

@@ -0,0 +1,12 @@
+#!/usr/bin/env tsx
+import { fileURLToPath } from 'node:url'
+import { stash_push_cli } from './stash-push-cli'
+
+// The `josh stash:push` entry, kept apart from `stash-push-cli.ts` because `run-pause.ts` and
+// `latest-if-required-cli.ts` import that one: a bundle is one file, so a main guard there would fire
+// for every command that carries it (joshuafolkken/kit#4186).
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+	const ARGV_OFFSET = 2
+
+	process.exitCode = await stash_push_cli.run(process.argv.slice(ARGV_OFFSET))
+}

package/scripts/hooks/batch-guard.ts

@@ -1,6 +1,3 @@
-#!/usr/bin/env tsx
-import { text } from 'node:stream/consumers'
-import { fileURLToPath } from 'node:url'
 import { hook_decision } from '#scripts/josh/hook-decision'
 import { lane_guard_policy, type LaneGuardMode } from '#scripts/lane/lane-guard-policy'
 import { time_batch_guard, type GuardedCall } from '#scripts/time-runtime/time-batch-guard'
@@ -121,11 +118,6 @@ const notice_refusal_path = hook_decision.create_refusal_stamp(
 ).path
 const { deny_envelope, load_environment_file, DISABLED_VALUES } = hook_decision
 
-if (process.argv[1] === fileURLToPath(import.meta.url)) {
-	if (process.stdin.isTTY) hook_decision.report_no_payload('batch:guard')
-	else hook_decision.write_outcome(await text(process.stdin), batch_outcome)
-}
-
 export {
 	batch_outcome,
 	batch_refusal,

package/scripts/hooks/check-commit-message-main.ts

@@ -0,0 +1,8 @@
+#!/usr/bin/env tsx
+import { fileURLToPath } from 'node:url'
+import { run_check } from './check-commit-message'
+
+// The `josh check-commit-message` entry, kept apart from `check-commit-message.ts` because
+// `main-merge.ts` imports that one: a bundle is one file, so a main guard there would fire for every
+// command that carries it (joshuafolkken/kit#4186). The message file is read from `process.argv`.
+if (process.argv[1] === fileURLToPath(import.meta.url)) process.exitCode = await run_check()

package/scripts/hooks/check-commit-message.ts

@@ -1,8 +1,6 @@
-#!/usr/bin/env tsx
 import { readFileSync } from 'node:fs'
 import os from 'node:os'
 import path from 'node:path'
-import { fileURLToPath } from 'node:url'
 import { git_command } from '#scripts/git/git-command'
 import { issue_cite } from '#scripts/issue/issue-cite'
 
@@ -122,16 +120,15 @@ async function check_commit_message(): Promise<CheckResult> {
 	}
 }
 
-async function main(): Promise<void> {
+// The `commit-msg` hook's run: the check's message, and a failure exit when it refused.
+async function run_check(): Promise<number> {
 	const result = await check_commit_message()
 
 	console.info(result.message)
 
-	if (!result.success) process.exit(1)
+	return result.success ? 0 : 1
 }
 
-if (process.argv[1] === fileURLToPath(import.meta.url)) await main()
-
-export { check_commit_message, extract_issue_number, is_safe_commit_message_path }
+export { check_commit_message, extract_issue_number, is_safe_commit_message_path, run_check }
 
 export type { CheckResult }

package/scripts/hooks/format-edited-file.ts

@@ -1,11 +1,11 @@
 #!/usr/bin/env tsx
 import { existsSync } from 'node:fs'
 import path from 'node:path'
-import { fileURLToPath } from 'node:url'
-import { resolve_local_bin, resolve_package_bin } from '#scripts/build/local-bin'
+import { resolve_local_bin } from '#scripts/build/local-bin'
 import { ESLINT_EDIT_CACHE_FLAGS } from '#scripts/josh/josh-command-types'
 import { json_value } from '#scripts/lib/json-value'
 import { HOOK_PROCESS_TIMEOUT_MS } from '#scripts/lib/timeouts'
+import { eslint_daemon } from '#scripts/lint/eslint-daemon'
 import { time_density_hook } from '#scripts/time-runtime/time-density-hook'
 import { execa } from 'execa'
 import { z } from 'zod'
@@ -83,12 +83,8 @@ const ESLINT_ARGUMENTS: ReadonlyArray<string> = [
 // identical rather than merely similar. The config entry file is re-read per request; the modules it
 // imports are not, which `plan_daemon_restart` below is the answer to. The daemon exits after 15
 // minutes of inactivity.
-const ESLINT_DAEMON = 'eslint_d'
+const { ESLINT_DAEMON } = eslint_daemon
 const DAEMON_RESTART = 'restart'
-// The two shapes a flat config is built from here and in every consumer of this kit: the root
-// `eslint.config.*` entry, and the rule modules under `eslint/` that it imports.
-const ESLINT_CONFIG_DIR = 'eslint'
-const ESLINT_CONFIG_ENTRY = /^eslint\.config\.[cm]?[jt]s$/u
 
 // The problems eslint could not auto-fix are handed to the model verbatim from eslint's own stdout —
 // its default formatter already prints the file, the `line:col`, and the rule name. A header names what the block is, since additionalContext arrives
@@ -104,11 +100,6 @@ const DIAGNOSTIC_TRUNCATION_NOTICE = '\n…(diagnostics truncated)'
 // present.
 const SECTION_SEPARATOR = '\n\n'
 
-// Where this file sits inside the kit package. `eslint_d` is kit's dependency rather than the
-// consumer's, and pnpm writes a `node_modules/.bin` shim only for a project's *direct* dependencies,
-// so a consumer's project root cannot see it and this directory can.
-const MODULE_DIRECTORY = path.dirname(fileURLToPath(import.meta.url))
-
 interface FormatCommand {
 	bin: string
 	command_arguments: ReadonlyArray<string>
@@ -226,10 +217,7 @@ const DAEMON_BINS: ReadonlySet<string> = new Set([ESLINT_BIN, ESLINT_DAEMON])
 function resolve_daemon_cli(bin: string, project_root: string): string | undefined {
 	if (!DAEMON_BINS.has(bin)) return undefined
 
-	return (
-		resolve_package_bin(MODULE_DIRECTORY, ESLINT_DAEMON, ESLINT_DAEMON) ??
-		resolve_package_bin(project_root, ESLINT_DAEMON, ESLINT_DAEMON)
-	)
+	return eslint_daemon.resolve_daemon_cli(project_root)
 }
 
 // Only the config *entry file* is re-read per request: ESLint cache-busts `eslint.config.js` by
@@ -238,13 +226,6 @@ function resolve_daemon_cli(bin: string, project_root: string): string | undefin
 // and then any source file, and it would be auto-fixed against the pre-edit rules for as long as the
 // daemon lives — an author testing a rule change would read that as the rule being broken. Restarting
 // after an edit to a config input is what makes the whole config current, not just its first file.
-function is_eslint_config_input(relative_path: string): boolean {
-	return (
-		relative_path.split(path.sep)[0] === ESLINT_CONFIG_DIR ||
-		ESLINT_CONFIG_ENTRY.test(relative_path)
-	)
-}
-
 function plan_daemon_restart(
 	file_path: string,
 	project_root: string,
@@ -253,7 +234,7 @@ function plan_daemon_restart(
 
 	if (
 		relative === undefined ||
-		!is_eslint_config_input(relative) ||
+		!eslint_daemon.is_config_input(relative) ||
 		resolve_daemon_cli(ESLINT_DAEMON, project_root) === undefined
 	) {
 		return []
@@ -392,8 +373,11 @@ async function format_edited_file(
 		...plan_commands(file_path, project_root),
 		...plan_daemon_restart(file_path, project_root),
 	]
+	const daemon_before = eslint_daemon.read_record(project_root)
 	const unfixed = await collect_unfixed(plan, runner, project_root)
 
+	eslint_daemon.remember_started(project_root, daemon_before)
+
 	return format_diagnostics(unfixed === '' ? undefined : unfixed)
 }