@joshuafolkken/kit 1.1240.0 → 1.1373.0

package/scripts/test/test-declared-logic.ts

@@ -1,5 +1,4 @@
-// The verdict `josh test:declared` prints, decided from the changed paths alone
-// (joshuafolkken/kit#2118).
+// The verdict `josh test:declared` prints, decided from the changed paths alone.
 //
 // **The input is a set of paths, never a judgement.** The spelling of a test file is fixed by
 // `eslint/rules/test-filename.js` (`*.test.ts` / `*.e2e.ts`), and the mechanically-exempt non-runtime
@@ -30,7 +29,7 @@ const EXEMPT_PREFIXES: ReadonlyArray<string> = ['.idea/', '.vscode/', 'prompts/'
 const EXEMPT_SUFFIXES: ReadonlyArray<string> = ['.md']
 const BASIC_VISUAL_SUFFIXES: ReadonlyArray<string> = ['.html', '.css']
 
-// What stays `required` under the basic profile (joshuafolkken/kit#2820): the languages kit's own
+// What stays `required` under the basic profile: the languages kit's own
 // runner can test, and the data and config formats a JS/TS test can load. Any other file — HTML/CSS, or
 // the source of a project kit does not run, such as Lua — has no test kit could execute, so `required`
 // there would be unsatisfiable; it is confirmed by hand instead. The kept side is enumerated rather than

package/scripts/test/test-declared-match.ts

@@ -1,7 +1,7 @@
 import { test_type_logic, type TestType } from './test-type-logic'
 
-// The Step 0 declaration lines checked against the tests actually in the working-tree change set
-// (joshuafolkken/kit#2181). `CLAUDE.md` Step 0 fixes the shape of each line —
+// The Step 0 declaration lines checked against the tests actually in the working-tree change set.
+// `CLAUDE.md` Step 0 fixes the shape of each line —
 // `<what changes> — Test: <Unit|E2E> — <path> — <what it verifies>` — and `testing-guide.md` §0 asks
 // that the count of declared tests match the count added, yet nothing read the correspondence. This
 // reads it: for every declaration, whether the declared type matches the path, whether the path was
@@ -11,6 +11,9 @@ import { test_type_logic, type TestType } from './test-type-logic'
 const FIELD_SEPARATOR = ' — '
 const TEST_MARKER = 'Test:'
 const TYPES: ReadonlyArray<TestType> = [test_type_logic.UNIT, test_type_logic.E2E]
+// The template writes the path in a code span (`report-format.md`), so one wrapping pair of backticks
+// is the path's markup, not part of it — read raw, every template-shaped line was `path-missing`.
+const CODE_SPAN_PATTERN = /^`(?<path>[^`]+)`$/u
 
 type MatchStatus = 'match' | 'type-mismatch' | 'path-missing' | 'test-not-created'
 
@@ -42,6 +45,12 @@ function type_in_field(field: string): TestType | undefined {
 	return TYPES.find((type) => type === value)
 }
 
+function path_of(field: string): string {
+	const trimmed = field.trim()
+
+	return CODE_SPAN_PATTERN.exec(trimmed)?.groups?.['path'] ?? trimmed
+}
+
 // One declaration parsed from a summary line, or undefined when the line carries no `Test:` field with
 // a recognized type and a path after it.
 function parse_line(line: string): Declaration | undefined {
@@ -54,7 +63,19 @@ function parse_line(line: string): Declaration | undefined {
 	const declared_type = type_in_field(marker_field)
 	if (declared_type === undefined) return undefined
 
-	return { declared_type, path: path_field.trim() }
+	return { declared_type, path: path_of(path_field) }
+}
+
+function file_name_of(path: string): string {
+	return path.slice(directory_of(path).length)
+}
+
+// The changed paths a `path-missing` declaration probably meant — the same file name in another
+// directory — so the refusal names the fix rather than leaving the reader to diff by hand.
+function path_candidates(path: string, changed: ReadonlyArray<string>): ReadonlyArray<string> {
+	const name = file_name_of(path)
+
+	return changed.filter((candidate) => candidate !== path && file_name_of(candidate) === name)
 }
 
 function parse_declarations(summary: string): ReadonlyArray<Declaration> {
@@ -100,7 +121,7 @@ function match_report(summary: string, changed: ReadonlyArray<string>): Readonly
 	}))
 }
 
-const test_declared_match = { directory_of, match_report, parse_declarations }
+const test_declared_match = { directory_of, match_report, parse_declarations, path_candidates }
 
 export type { Declaration, MatchResult, MatchStatus }
 export { test_declared_match }

package/scripts/test/test-declared.ts

@@ -3,30 +3,32 @@ import { text } from 'node:stream/consumers'
 import { fileURLToPath } from 'node:url'
 import { project_checks } from '#scripts/gate/project-checks'
 import { cli_flags } from '#scripts/lib/cli-flags'
+import { report_format_reference } from '#scripts/report/report-format-reference'
 import { test_declared_changed } from './test-declared-changed'
 import { test_declared_logic, type Verdict } from './test-declared-logic'
 import { test_declared_match, type MatchResult } from './test-declared-match'
 import { test_type_logic } from './test-type-logic'
 
 // `josh test:declared` — prints one of `required` / `exempt` / `satisfied` to stdout from the
-// working-tree diff, with the reason on stderr (joshuafolkken/kit#2118). The verdict is
+// working-tree diff, with the reason on stderr. The verdict is
 // `test-declared-logic.ts`, the tree read is `test-declared-changed.ts`. This command is the way a
 // person confirms the same answer by hand; the refusal itself is delivered by the `test-declared` row
 // of `delivered-rules.ts` at the commit stage.
 //
 // `--match` reads a Step 0 work summary on stdin and checks each declared `Test: <type> — <path>`
 // line against the change set, printing `match` / `type-mismatch` / `path-missing` /
-// `test-not-created` per line and exiting non-zero on any mismatch (joshuafolkken/kit#2181).
+// `test-not-created` per line and exiting non-zero on any mismatch.
 
 const CLEAN_EXIT = 0
 const MISMATCH_EXIT = 1
 const MATCH_STATUS = 'match'
+const PATH_MISSING_STATUS = 'path-missing'
 const ARGV_OFFSET = 2
 const NO_DECLARATIONS =
 	'no Test: declarations parsed from stdin — pipe the Step 0 work summary in, e.g. `pnpm josh test:declared --match < summary.md`'
 
 // **An unknown flag is a refusal, not a default** — `scripts/time/time-cli.ts` states the same
-// convention (joshuafolkken/kit#2297). Ignoring `--foo` and re-printing the verdict is what sent a
+// convention. Ignoring `--foo` and re-printing the verdict is what sent a
 // reader off to read the source by hand, so a misspelled or retired flag stops here with the usage.
 const PARSE_ARGS_OPTIONS = {
 	help: { type: 'boolean', short: 'h', default: false },
@@ -42,7 +44,7 @@ const USAGE = [
 ].join('\n')
 
 // The one command a `required` verdict leaves to run next: declare a test for each named runtime file,
-// then verify the declarations against the change set (joshuafolkken/kit#2297). Printed after the
+// then verify the declarations against the change set. Printed after the
 // detail so the verdict-to-detail mapping the report test pins stays untouched.
 const NEXT_STEP =
 	'next: declare a test for each runtime file above, then verify with `pnpm josh test:declared --match < summary.md`'
@@ -67,7 +69,7 @@ function next_step(verdict: Verdict): string | undefined {
 }
 
 // A runtime file with the test type its path calls for, so the required detail says which kind of
-// test to add rather than only that one is missing (joshuafolkken/kit#2181).
+// test to add rather than only that one is missing.
 function typed_runtime_file(path: string): string {
 	return `${test_type_logic.test_type_for(path)} — ${path}`
 }
@@ -76,7 +78,7 @@ const BROWSER_CHECK = 'confirm the rendered page in a browser'
 const RUN_CHECK = 'run the changed code by hand and report what you observed'
 
 // The manual confirmation a basic-profile exemption owes, one instruction per kind of file it covers:
-// HTML/CSS is looked at in a browser, a source kit cannot test is run by hand (joshuafolkken/kit#2820).
+// HTML/CSS is looked at in a browser, a source kit cannot test is run by hand.
 function manual_instruction(paths: ReadonlyArray<string>, is_basic: boolean): string {
 	const manual = test_declared_logic.manual_check_files(paths, is_basic)
 	const has_visual = manual.some((path) => test_declared_logic.is_basic_visual(path))
@@ -127,8 +129,23 @@ function run(): void {
 	if (next !== undefined) process.stderr.write(`${next}\n`)
 }
 
-function format_match(result: MatchResult): string {
-	return `${result.status}: ${result.declared_type} — ${result.path}`
+// A `path-missing` line names the changed paths it probably meant and where the declaration's shape is
+// written, so the summary is fixed without reading this command's source.
+function path_missing_hints(path: string, changed: ReadonlyArray<string>): ReadonlyArray<string> {
+	const candidates = test_declared_match.path_candidates(path, changed)
+	const shape = `  the declaration line's shape: ${report_format_reference.pointer(report_format_reference.SUMMARY_RULES_HEADING)}`
+
+	if (candidates.length === 0) return [shape]
+
+	return [`  changed with the same file name: ${candidates.join(', ')}`, shape]
+}
+
+function format_match(result: MatchResult, changed: ReadonlyArray<string> = []): string {
+	const line = `${result.status}: ${result.declared_type} — ${result.path}`
+
+	if (result.status !== PATH_MISSING_STATUS) return line
+
+	return [line, ...path_missing_hints(result.path, changed)].join('\n')
 }
 
 // The exit code the match run leaves: clean only when every declaration matched, so it gates. A
@@ -143,7 +160,7 @@ function run_match(summary: string, changed: ReadonlyArray<string>): number {
 		return MISMATCH_EXIT
 	}
 
-	for (const result of results) process.stdout.write(`${format_match(result)}\n`)
+	for (const result of results) process.stdout.write(`${format_match(result, changed)}\n`)
 
 	return results.every((result) => result.status === MATCH_STATUS) ? CLEAN_EXIT : MISMATCH_EXIT
 }

package/scripts/test/test-red-commit.ts

@@ -1,8 +1,9 @@
 import { git_gh_issue_read } from '#scripts/gh/git-gh-issue-read'
+import { session_cite } from '#scripts/issue/session-cite'
 import { test_red, type RedRun } from './test-red'
 import { test_red_logic } from './test-red-logic'
 
-// The commit-stage half of joshuafolkken/kit#2448: `josh git -y` on an Issue that declares itself a
+// The commit-stage half of `josh test:red`: `josh git -y` on an Issue that declares itself a
 // bug fix (`test_red_logic.BUG_DECLARATION_LINE`) refuses a commit whose tests are all green on the
 // pre-fix tree.
 //
@@ -22,7 +23,7 @@ const DEFAULT_PORTS: RedCommitPorts = {
 
 function reason_for(issue_number: string, files: ReadonlyArray<string>): string {
 	return (
-		`⛔ test:red — #${issue_number} declares \`${test_red_logic.BUG_DECLARATION_LINE}\`, but every ` +
+		`⛔ test:red — ${session_cite.issue(issue_number)} declares \`${test_red_logic.BUG_DECLARATION_LINE}\`, but every ` +
 		'changed test passes on the pre-fix tree (the merge-base), so none of them reproduces the ' +
 		`reported symptom:\n  ${files.join('\n  ')}\n` +
 		'Write a regression test at the grain the user saw the symptom (the whole output, not a ' +

package/scripts/test/test-red-logic.ts

@@ -1,14 +1,13 @@
 import { issue_bug_label } from '#scripts/issue/issue-bug-label'
+import { json_value } from '#scripts/lib/json-value'
 import { observation_ledger } from '#scripts/observations/observation-ledger'
 import { z } from 'zod'
 import { test_declared_logic } from './test-declared-logic'
 
-// The verdict `josh test:red` prints, and the Issue declaration that makes `josh git -y` ask for it
-// (joshuafolkken/kit#2448).
+// The verdict `josh test:red` prints, and the Issue declaration that makes `josh git -y` ask for it.
 //
 // **A regression test that is green on the pre-fix tree does not reproduce the reported symptom.**
-// joshuafolkken/kit#2308 closed with a test that never went red, and joshuafolkken/kit#2393 was the
-// same symptom back. `josh test:declared` only answers whether a test was added; this answers whether
+// An Issue closed with such a test leaves the symptom free to come back. `josh test:declared` only answers whether a test was added; this answers whether
 // that test catches anything — the added and changed tests run against the merge-base, and at least one
 // of them has to fail there.
 
@@ -34,11 +33,11 @@ function unit_test_files(paths: ReadonlyArray<string>): Array<string> {
 		.filter((path) => test_declared_logic.is_test_file(path) && path.endsWith(UNIT_TEST_SUFFIX))
 }
 
-// **A change whose every path is a test file has no pre-fix code to run against**
-// (joshuafolkken/kit#3214). The merge-base then runs the same code as HEAD, so its result equals HEAD's
+// **A change whose every path is a test file has no pre-fix code to run against**.
+// The merge-base then runs the same code as HEAD, so its result equals HEAD's
 // and says nothing about the fix. Exempt paths do not count: a document-rule test reads `*.md` and
 // `prompts/` files, so a change to one of those is pre-fix content the test can be red against.
-// Observation ledger paths do not count either way (joshuafolkken/kit#3230): a run commits its own
+// Observation ledger paths do not count either way: a run commits its own
 // ledger entry, and no test reads it as pre-fix content.
 function is_test_only(paths: ReadonlyArray<string>): boolean {
 	const counted = paths.filter((path) => !observation_ledger.is_ledger_path(path))
@@ -53,13 +52,7 @@ function is_test_only(paths: ReadonlyArray<string>): boolean {
 const REPORT_SCHEMA = z.object({ testResults: z.array(z.unknown()) })
 
 function ran_file_count(report: string): number {
-	try {
-		const parsed = REPORT_SCHEMA.safeParse(JSON.parse(report))
-
-		return parsed.success ? parsed.data.testResults.length : 0
-	} catch {
-		return 0
-	}
+	return json_value.parse_with(report, REPORT_SCHEMA)?.testResults.length ?? 0
 }
 
 // `no-test` when nothing ran; otherwise a failing run is `red` — the test caught the pre-fix tree — and

package/scripts/test/test-red.ts

@@ -1,30 +1,25 @@
 import { existsSync } from 'node:fs'
-import { copyFile, mkdir, mkdtemp, readFile, rm, symlink } from 'node:fs/promises'
-import { tmpdir } from 'node:os'
+import { copyFile, mkdir, readFile } from 'node:fs/promises'
 import path from 'node:path'
 import { fileURLToPath } from 'node:url'
+import { base_tree, type BaseTree } from '#scripts/git/base-tree'
 import { change_base } from '#scripts/git/change-base'
 import { changed_paths } from '#scripts/git/changed-paths'
 import { git_location_environment } from '#scripts/git/git-location-environment'
-import { git_worktree } from '#scripts/git/git-worktree'
 import { execa } from 'execa'
 import { test_red_logic, type RedVerdict } from './test-red-logic'
 
 // `josh test:red` — run the added and changed Vitest files against the pre-fix tree and print `red`,
-// `green`, `no-test` or `test-only` (joshuafolkken/kit#2448).
+// `green`, `no-test` or `test-only`.
 //
-// **The pre-fix tree is a detached worktree at the merge-base, never the caller's checkout.** The tests
-// are copied in from the working tree, so what runs is the new test against the old code, and the
-// caller's tree and index are never read back or written. The worktree borrows this checkout's
-// `node_modules` through a symlink rather than installing its own: what is being asked about is the
-// source the fix changed, and an install would add seconds and a network dependency to every commit.
+// **The pre-fix tree is a detached worktree at the merge-base, never the caller's checkout**
+// (`base-tree.ts`). The tests are copied in from the working tree, so what runs is the new test
+// against the old code.
 
 const ARGV_OFFSET = 2
 const TREE_PREFIX = 'josh-test-red-'
-const TREE_NAME = 'tree'
 const REPORT_NAME = 'report.json'
-const NODE_MODULES = 'node_modules'
-const VITEST_BIN = path.join(NODE_MODULES, '.bin', 'vitest')
+const VITEST_BIN = path.join(base_tree.NODE_MODULES, '.bin', 'vitest')
 const USAGE =
 	'Usage: josh test:red — prints red / green / no-test / test-only for the changed tests on the merge-base'
 
@@ -54,12 +49,6 @@ async function copy_in(tree: string, files: ReadonlyArray<string>): Promise<void
 	)
 }
 
-async function prepare(tree: string, base: string, files: ReadonlyArray<string>): Promise<void> {
-	await git_worktree.worktree_add_detached(tree, base)
-	await symlink(path.resolve(NODE_MODULES), path.join(tree, NODE_MODULES), 'dir')
-	await copy_in(tree, files)
-}
-
 function reporter_arguments(report: string): Array<string> {
 	// The plain `--outputFile`, not `--outputFile.json`: a config that sets `test.outputFile` as a string
 	// wins over the keyed form, which would send the report into the tree and read every run `no-test`.
@@ -75,8 +64,7 @@ async function read_report(report: string): Promise<string> {
 // all, so a file the old config excludes is `no-test` rather than a `green` that refuses a correct fix.
 // A test that ran and broke, or a file that could not load against the old code, makes it `red`.
 async function verdict_in(
-	parent: string,
-	tree: string,
+	{ parent, tree }: BaseTree,
 	files: ReadonlyArray<string>,
 ): Promise<RedVerdict> {
 	const report = path.join(parent, REPORT_NAME)
@@ -92,35 +80,12 @@ async function verdict_in(
 	return test_red_logic.verdict_for(ran, result.exitCode !== 0)
 }
 
-// Best effort: a removal that fails leaves a registration `worktree prune` drops once the directory is
-// gone, so the cleanup never replaces the verdict with its own error.
-async function remove_tree(parent: string, tree: string): Promise<void> {
-	try {
-		await git_worktree.worktree_remove(tree)
-	} catch {
-		// The directory is deleted below and the prune drops the stale registration.
-	}
-
-	await rm(parent, { force: true, recursive: true })
-
-	try {
-		await git_worktree.worktree_prune()
-	} catch {
-		// A failed prune leaves a stale registration the next prune drops; the verdict stands.
-	}
-}
-
 async function verdict_on(base: string, files: ReadonlyArray<string>): Promise<RedVerdict> {
-	const parent = await mkdtemp(path.join(tmpdir(), TREE_PREFIX))
-	const tree = path.join(parent, TREE_NAME)
-
-	try {
-		await prepare(tree, base, files)
+	return await base_tree.with_tree(TREE_PREFIX, base, async (pre_fix) => {
+		await copy_in(pre_fix.tree, files)
 
-		return await verdict_in(parent, tree, files)
-	} finally {
-		await remove_tree(parent, tree)
-	}
+		return await verdict_in(pre_fix, files)
+	})
 }
 
 // The verdict over the current checkout. No merge-base (not a repository, no default branch) reads as

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

@@ -6,7 +6,7 @@ import {
 	type ScopeVocabulary,
 } from '#scripts/git/changed-file-scope'
 
-// joshuafolkken/kit#1257: the unit suite always ran whole. Measured warm on kit, that is 384 files
+// The whole unit suite is expensive. Measured warm on kit, that is 384 files
 // and 6,616 tests — 13.9s wall and 110s of CPU, 84% of everything the four gate checks spend, and
 // an implementation loop paid it again on every re-check. The same tree narrowed to one changed
 // file runs 31 files and 566 tests in 2.4s (7.9s of CPU, −93%).
@@ -19,8 +19,7 @@ import {
 // The decision this file makes is which extensions vitest can walk a module graph back from, and
 // what to print about it. Everything the decision shares with `josh lint:related` — reading the
 // change, dropping what the tree no longer holds, and the two fallbacks — is
-// `changed-file-scope.ts`, so the two commands cannot drift apart about what "changed" means
-// (joshuafolkken/kit#1298).
+// `changed-file-scope.ts`, so the two commands cannot drift apart about what "changed" means.
 
 type RelatedScope = ChangedFileScope
 

package/scripts/test/test-related.ts

@@ -8,12 +8,12 @@ import { review_stamps } from '#scripts/review/review-stamps'
 import { related_scope } from './test-related-scope'
 import { test_unit_guard } from './test-unit-guard'
 
-// `josh test:related` — the unit check an implementation loop runs between edits
-// (joshuafolkken/kit#1257). The narrowing itself is `test-related-scope.ts` over the shared
+// `josh test:related` — the unit check an implementation loop runs between edits.
+// The narrowing itself is `test-related-scope.ts` over the shared
 // decision in `changed-file-scope.ts`; this is the process around it — how the run reaches vitest
 // through the same guard `josh test:unit` goes through.
 //
-// **A green run leaves a record of the tree it was green on** (joshuafolkken/kit#1511), so
+// **A green run leaves a record of the tree it was green on**, so
 // `josh review:brief` can tell a tree this check has read from one it has not. What the record means,
 // and the three states in which it is withheld, are `scoped-green.ts`.
 

package/scripts/test/test-type-logic.ts

@@ -1,5 +1,4 @@
-// The test type a changed path calls for — `Unit` or `E2E` — decided from the path alone
-// (joshuafolkken/kit#2181).
+// The test type a changed path calls for — `Unit` or `E2E` — decided from the path alone.
 //
 // **This mechanizes `prompts/testing-guide.md` §1's two-row table**, whose last line used to be "When
 // ambiguous, ask the user" — a Tier B stop on a question the path already answers. The table routes

package/scripts/test/test-unit-guard.ts

@@ -16,7 +16,7 @@ const UNIT_GLOB = '**/*.{test,spec}.{ts,js}'
 const NODE_MODULES = 'node_modules'
 
 // **A unit check that executed nothing may report success only where the project has no unit suite
-// at all** (joshuafolkken/kit#1224). The two halves of "nothing ran" are not the same state:
+// at all**. The two halves of "nothing ran" are not the same state:
 //
 // - **`vitest` absent is the young project.** `josh init` installs no vitest and writes no
 //   `test:unit` script, so a freshly-bootstrapped project always lands here — which is the case the
@@ -26,11 +26,10 @@ const NODE_MODULES = 'node_modules'
 //   project may carry vitest as an unused dependency without declaring a unit suite; zero files
 //   there are reported as skipped, never as a test pass.
 //
-// Rejected: leaving both halves green — joshuafolkken/kit#1216's `--verbose` makes the zero count
-// *readable* in the CI log, but nobody reads a green log and the merge gate reads only pass/fail;
-// and putting the failing half behind an opt-in such as `JOSH_REQUIRE_UNIT_TESTS`, which is off in
-// exactly the projects that need it. The full decision, including why the absent-vitest half is
-// deliberately left asymmetric, is on joshuafolkken/kit#1224.
+// Rejected: leaving both halves green — `--verbose` makes the zero count *readable* in the CI log,
+// but nobody reads a green log and the merge gate reads only pass/fail; and putting the failing half
+// behind an opt-in such as `JOSH_REQUIRE_UNIT_TESTS`, which is off in exactly the projects that need
+// it.
 //
 // **`scripts/test/test-e2e-guard.ts` deliberately keeps both skips, and that divergence is not an
 // oversight.** The argument above rests on the package's presence being a declaration, and
@@ -43,9 +42,8 @@ const FAIL_ACTION = 'fail-no-tests'
 type GuardAction = 'run' | typeof SKIP_ACTION | typeof SKIP_NO_TESTS_ACTION | typeof FAIL_ACTION
 
 // The word the gate looks for to know a passing step did not actually run. Exported and reused on
-// both sides rather than matched by eye: joshuafolkken/kit#967 stopped printing a passing check's
-// body, and without this a gate that skipped the whole unit suite printed the same five lines as one
-// that ran it.
+// both sides rather than matched by eye: the gate does not print a passing check's body, so without
+// this a gate that skipped the whole unit suite would print the same lines as one that ran it.
 const SKIP_REASON = 'vitest is not installed'
 const SKIP_NO_TESTS_REASON = 'no unit test files were found in this basic project'
 const FAIL_REASON =
@@ -80,7 +78,7 @@ function has_unit_tests(project_directory: string): boolean {
 }
 
 // The guard's decision for one project, asked here once so the run, the scoped record and the gate's
-// precondition can never disagree about whether this project's vitest runs (joshuafolkken/kit#3136).
+// precondition can never disagree about whether this project's vitest runs.
 function guard_action(project_directory: string): GuardAction {
 	return resolve_guard_action(
 		is_vitest_installed(project_directory),
@@ -112,12 +110,11 @@ function isolated_unit_environment(
 
 // The whole vitest invocation after the binary, not just the flags: `josh test:related` runs
 // `vitest related <files> --run` where this command runs `vitest run`, and the two must not grow
-// two copies of the guard, the spawn or the skip notice around that one difference
-// (joshuafolkken/kit#1257).
+// two copies of the guard, the spawn or the skip notice around that one difference.
 // **The share is read from inside the marker, not before it.** This is the one funnel every
 // josh-driven vitest goes through — `test:unit`, `test:related` and the pre-push hook alike — so it is
-// where a run both learns how many others are in flight and announces itself to them
-// (joshuafolkken/kit#1515). The pre-push hook is the reason it is here rather than only in the gate:
+// where a run both learns how many others are in flight and announces itself to them.
+// The pre-push hook is the reason it is here rather than only in the gate:
 // it passed no cap at all, so vitest opened one worker per core in every lane at once.
 //
 // Reading the share first and claiming afterwards leaves a window in which two hooks firing together
@@ -147,7 +144,7 @@ const UNIT_COMMAND_LABEL = 'test:unit'
 
 // The two non-running outcomes report through different streams and different exit codes, because
 // they mean different things: one says the project has no unit suite yet, the other says it has one
-// that could not be found (joshuafolkken/kit#1224). Only the first keeps `SKIP_MARKER`, so the
+// that could not be found. Only the first keeps `SKIP_MARKER`, so the
 // gate's "passed without running" handling still means exactly what it did.
 function report_no_run(action: Exclude<GuardAction, 'run'>, command_label: string): number {
 	if (action === FAIL_ACTION) {
@@ -165,8 +162,7 @@ function report_no_run(action: Exclude<GuardAction, 'run'>, command_label: strin
 
 // `announcement` is printed only on the branch that actually spawns vitest. A caller that wrote it
 // itself would claim a run before this guard had decided there would be one — the same "a passing
-// step did not actually run" ambiguity `SKIP_MARKER` exists for, reintroduced one layer up
-// (joshuafolkken/kit#1257).
+// step did not actually run" ambiguity `SKIP_MARKER` exists for, reintroduced one layer up.
 async function run_guarded_vitest(
 	project_directory: string,
 	vitest_arguments: ReadonlyArray<string>,

package/scripts/test/unit-worker-share.ts

@@ -7,19 +7,18 @@ import { process_owner_schema, type ProcessOwner } from '#scripts/josh/process-o
 import { stamp_file } from '#scripts/josh/stamp-file'
 import { json_value } from '#scripts/lib/json-value'
 
-// How wide one vitest run may fan out when it is not the only one on the machine
-// (joshuafolkken/kit#1515).
+// How wide one vitest run may fan out when it is not the only one on the machine.
 //
 // **`gate-plan.ts` sizes the unit suite from the core count and nothing else**, so six lanes running
 // `josh gate` at once each concluded "11 cores, take 7 workers" and put 42 workers on 11 cores. The
-// pre-push hook once passed no cap at all; it now runs the suite through `test_unit_guard.run_guarded_unit`
-// (joshuafolkken/kit#1334), the same guard `josh test:unit` uses, so the share below applies there too.
+// pre-push hook once passed no cap at all; it now runs the suite through `test_unit_guard.run_guarded_unit`,
+// the same guard `josh test:unit` uses, so the share below applies there too.
 // Measured on the machine this was found on — load average 14.97 in the field, and 209 in a deliberate
 // reproduction of six concurrent suites, against 22 once the share below was applied.
 //
 // **What it fixes, and what it does not.** Six concurrent copies of the full suite produced ten
 // `Test timed out in 10000ms` failures across six runs; at the share this module hands out, the same
-// six runs produced **none**. It is the *second* multiplicand of joshuafolkken/kit#1515 — the first
+// six runs produced **none**. It is the *second* multiplicand of those timeouts — the first
 // was a live `git fetch` inside two test files, which is fixed in `test-network-guard.ts` and its
 // callers, and which no worker count would have repaired: that one failed on an idle machine at one
 // worker.
@@ -57,7 +56,7 @@ function marker_path(pid: number = process.pid): string {
 // long-lived one, so unlike a `run:hold` record its identity is a liveness test rather than a note for
 // the reader.
 //
-// **The pid alone was not that identity** (joshuafolkken/kit#1245). The section below already named
+// **The pid alone was not that identity**. The section below already named
 // what goes wrong — a reissued pid turns a leaked marker into a permanent phantom — and answered it by
 // sweeping, which only ever collected the markers whose pid had *not* yet been reissued. Since the
 // record now carries the writing process's start time beside its pid, a reissued pid is recognized as
@@ -69,8 +68,8 @@ function marker_path(pid: number = process.pid): string {
 // readers do with it, and deliberately so.** A marker with no recorded start time — written before the
 // field existed, or on a platform where it cannot be read — resolves toward *more* sharing: being
 // wrong that way costs this run a narrower share of the machine, while being wrong the other way puts
-// six unit suites on eleven cores, which is the oversubscription joshuafolkken/kit#1515 measured at a
-// load average of 209.
+// six unit suites on eleven cores, an oversubscription measured at a load
+// average of 209.
 function is_running(marker: RunMarker): boolean {
 	return process_identity.is_same_process(marker.pid, marker.process_start) !== false
 }

package/scripts/time-runtime/time-agent-bundles.ts

@@ -2,8 +2,7 @@ import { time_bundle_call } from './time-bundle-call'
 import { time_round_trips } from './time-round-trips'
 import { time_spans, type Span } from './time-spans'
 
-// Independent subagent launches that went out one per turn, when they could have fanned out in one
-// (joshuafolkken/kit#1854).
+// Independent subagent launches that went out one per turn, when they could have fanned out in one.
 //
 // **This is a second series, deliberately kept apart from the consecutive one in `time-bundles.ts`.**
 // That one reads *consecutive* single-call turns, so a launch fired minutes apart with implementation
@@ -36,8 +35,7 @@ import { time_spans, type Span } from './time-spans'
 //
 // **A prompt that references a prior finding** (`has_prior_reference`, from `time-bundle-call.ts`). A
 // read-only investigation chain — the second question only askable once the first is answered — writes
-// nothing between its links, so the write test cannot see it; the marker scan is what does, and it is
-// the caveat joshuafolkken/kit#1847 recorded.
+// nothing between its links, so the write test cannot see it; the marker scan is what does.
 //
 // **Parallel launches are one turn and cost nothing.** Launches sharing a non-empty message id were
 // issued together, so they collapse to a single turn here — the review trio is one turn, not three —