@joshuafolkken/kit 1.1050.0 → 1.1128.0

package/scripts/delegation/investigation-reads.ts

@@ -454,173 +454,10 @@ function should_block(
 	)
 }
 
-// What a read this rule saw was, in the four answers the rule itself can give
-// (joshuafolkken/kit#1764). `pnpm josh time` prints them as a block, and the ids are here rather than
-// there because each one is a fact about the guard: the two above the line are the reading §2b leaves
-// in the main line on purpose, and the two below it are the reading it sends to a unit.
-//
-// **The last is the gap, and naming it is the point.** A read that reached the threshold and was not
-// refused is neither by design nor caught, and nothing could see it — so the 35.9% of a run's turns
-// that `investigation` accounts for could not be told apart from the reading that belongs there. Two
-// things put a read in it, and the row deliberately covers both: a refusal already standing that the
-// arm above had not re-armed, and a spelling the guard never refuses at all (`sed -n`, below).
-const EDIT_TARGET_CLASS = 'edit targets'
-const UNDER_THRESHOLD_CLASS = 'under the threshold'
-const REFUSED_CLASS = 'refused'
-// Kept inside `time-format.ts`'s 24-character label column, which the fuller phrasing overflowed —
-// the prose beside the block is where the two reasons are named.
-const LET_THROUGH_CLASS = 'let through'
-const READ_CLASSES: ReadonlyArray<string> = [
-	EDIT_TARGET_CLASS,
-	UNDER_THRESHOLD_CLASS,
-	REFUSED_CLASS,
-	LET_THROUGH_CLASS,
-]
-
-// **The live guard refuses a `Read` always and a shell read only where the line cannot also write**,
-// which is why `Bash: sed` is counted and never refused: `sed -n` prints and `sed -i` rewrites, and
-// `time-batch-guard.ts` → `is_read_only_call` answers conservatively for both. A span carries the
-// label but not the command, so the replay asks the question the span *can* answer — and of the eight
-// printing commands, `sed` is the only one on `time-bundle-call.ts`'s writing list. **The residual is
-// named rather than hidden**: a redirection inside a `cat` line also stops the live call being refusable
-// and is invisible here, so a handful of such reads land in `refused` that the guard would have let
-// through. It is the same direction as the row below and far smaller.
-const NEVER_REFUSED_LABELS: ReadonlySet<string> = new Set([time_shell.bash_label('sed')])
-
-// The guard's state as a replay walks a recorded run, which is `ReadTally` plus the one thing a live
-// hook keeps on disk instead — the instant it last refused.
-interface Replay {
-	pending: Map<string, number>
-	reset_ms: number
-	window_start_ms: number
-	refused_at_ms: number
-	// The whole run's successful writes, gathered once by `classified_reads` and carried so `tally_now`
-	// can hand them to the same exclusion the live guard makes (joshuafolkken/kit#1840).
-	edited: ReadonlySet<string>
-}
-
-// The tally the live guard would have held at this instant, so the re-arm is asked of the one
-// function that answers it rather than of a second copy of the rule.
-function tally_now(replay: Replay): ReadTally {
-	return {
-		pending: [...replay.pending.keys()],
-		pending_since: pending_after(replay.pending, replay.refused_at_ms),
-		reset_ms: replay.reset_ms,
-		window_start_ms: replay.window_start_ms,
-		edited: replay.edited,
-	}
-}
-
-// The same two conditions `should_block` asks: the accumulated count is at the boundary, and this
-// read actually adds a file to it.
-function reaches_threshold(replay: Replay, targets: ReadonlyArray<string>): boolean {
-	const added = targets.filter((target) => !replay.pending.has(target))
-
-	return added.length > 0 && is_at_threshold(replay.pending.size)
-}
-
-// Whether the guard would have refused this read had it been armed — the same two conditions
-// `is_refusable_call` puts in front of every refusal, asked of a span.
-function would_refuse(replay: Replay, span: Span): boolean {
-	if (NEVER_REFUSED_LABELS.has(span.label)) return false
-
-	return is_rearmed(tally_now(replay), replay.refused_at_ms)
-}
-
-function class_of(replay: Replay, span: Span, edited: ReadonlySet<string>): string {
-	// Exclude the edited files first, so the threshold is judged on the same set `should_block` judges
-	// it on: an all-edited read is an edit target, and a mixed read reaches the threshold only on its
-	// genuinely new files, never on a file the run edited (joshuafolkken/kit#1840).
-	const fresh = subject_targets(span.targets).filter((target) => !edited.has(target))
-
-	if (fresh.length === 0) return EDIT_TARGET_CLASS
-	if (!reaches_threshold(replay, fresh)) return UNDER_THRESHOLD_CLASS
-
-	return would_refuse(replay, span) ? REFUSED_CLASS : LET_THROUGH_CLASS
-}
-
-// A span that is not a read, or whose every target was an instruction document or a session file,
-// classifies as nothing at all — it never reached the count, so putting it in a row would report the
-// guard as having an opinion about it.
-function read_class(replay: Replay, span: Span, edited: ReadonlySet<string>): string | undefined {
-	if (!is_content_read(span.label)) return undefined
-	if (subject_targets(span.targets).length === 0) return undefined
-
-	return class_of(replay, span, edited)
-}
-
-function step(replay: Replay, span: Span, edited: ReadonlySet<string>): string | undefined {
-	if (DELEGATION_TOOLS.has(span.label)) {
-		replay.reset_ms = span.ended_ms
-		apply_span(replay.pending, span, edited)
-
-		return undefined
-	}
-
-	const found = read_class(replay, span, edited)
-
-	// A refusal moves the disarm forward, exactly as the hook's own stamp does.
-	if (found === REFUSED_CLASS) replay.refused_at_ms = span.ended_ms
-
-	apply_span(replay.pending, span, edited)
-
-	return found
-}
-
-// **A read paired with where it fell in the run** (joshuafolkken/kit#1868). `index` is the read span's
-// position in the array handed to `classified_reads`; `time-investigation.ts` classifies that same
-// array's phases and pairs the two by index, so it can say which phase — setup above all — each read
-// landed in.
-interface ClassifiedRead {
-	found: string
-	index: number
-}
-
-const FIRST_SPAN = 0
-
-function fresh_replay(spans: ReadonlyArray<Span>, edited: ReadonlySet<string>): Replay {
-	return {
-		pending: new Map<string, number>(),
-		reset_ms: hook_decision.NEVER_MS,
-		window_start_ms: spans[FIRST_SPAN]?.ended_ms ?? hook_decision.NEVER_MS,
-		refused_at_ms: hook_decision.NEVER_MS,
-		edited,
-	}
-}
-
-// **What each of a run's reads was, replayed through this rule's own predicates**
-// (joshuafolkken/kit#1764). It is the measurement half of the guard and shares every decision with
-// it — the subject test, the threshold, the delegation reset and the re-arm — because a second walk
-// that merely resembled the guard would answer about a rule nobody ships. Each read carries its span's
-// index, so `time-investigation.ts` can place it in a phase (joshuafolkken/kit#1868).
-function classified_reads(spans: ReadonlyArray<Span>): Array<ClassifiedRead> {
-	const edited = edited_files(spans)
-	const replay = fresh_replay(spans, edited)
-	const reads: Array<ClassifiedRead> = []
-
-	for (const [index, span] of spans.entries()) {
-		const found = step(replay, span, edited)
-
-		if (found !== undefined) reads.push({ found, index })
-	}
-
-	return reads
-}
-
 const investigation_reads = {
-	CONTENT_READ_COMMANDS,
-	EDIT_TARGET_CLASS,
-	LET_THROUGH_CLASS,
-	READ_CLASSES,
-	REFUSED_CLASS,
-	UNDER_THRESHOLD_CLASS,
-	classified_reads,
-	subject_targets,
-	DELEGATION_TOOLS,
 	READ_TOOLS,
 	REASON,
 	is_at_threshold,
-	is_content_read,
 	is_instruction_document,
 	is_rearmed,
 	is_refusable_call,
@@ -633,5 +470,5 @@ const investigation_reads = {
 	tally_of,
 }
 
-export type { ClassifiedRead, ReadTally }
+export type { ReadTally }
 export { investigation_reads }

package/scripts/discovery/repo-map-logic.ts

@@ -94,7 +94,6 @@ function build_repository_map(
 
 const repo_map_logic = {
 	is_same_owner,
-	parse_overrides,
 	build_repository_map,
 }
 

package/scripts/discovery/repo-party-cli.ts

@@ -62,7 +62,7 @@ function main(argv: ReadonlyArray<string>): void {
 	process.exitCode = run(argv)
 }
 
-const repo_party_cli = { USAGE, decide, main, run }
+const repo_party_cli = { USAGE, decide, run }
 
 if (process.argv[1] === fileURLToPath(import.meta.url)) main(process.argv.slice(ARGV_OFFSET))
 

package/scripts/doctor/doctor-consumer.ts

@@ -1,10 +1,9 @@
 import { existsSync } from 'node:fs'
 import path from 'node:path'
+import { git_spawn_sync } from '#scripts/git/git-spawn-sync'
+import { json_value } from '#scripts/lib/json-value'
 import { file_reader } from '#scripts/lib/read-file'
-import { read_spawn_stdout } from '#scripts/lib/spawn-exit'
 import { KIT_PACKAGE_NAME } from '#scripts/version/kit-descriptor'
-import { safe_json_parse } from '#scripts/version/parse-json'
-import { execaSync } from 'execa'
 import { z } from 'zod'
 
 // The consumer-setup checks `josh doctor` runs in a repository that installs kit (joshuafolkken/kit#1930).
@@ -40,7 +39,7 @@ type ClaudeMdState = typeof STATE_OK | typeof STATE_TARGET_MISSING | typeof STAT
 function parse_manifest(root: string): ManifestShape | undefined {
 	const content = file_reader.read_if_readable(path.join(root, 'package.json'))
 	if (content === undefined) return undefined
-	const parsed = manifest_schema.safeParse(safe_json_parse(content))
+	const parsed = manifest_schema.safeParse(json_value.parse_or_undefined(content))
 
 	return parsed.success ? parsed.data : undefined
 }
@@ -69,7 +68,7 @@ function is_kit_consumer(root: string): boolean {
 function is_plugin_declared(root: string): boolean {
 	const content = file_reader.read_if_readable(path.join(root, SETTINGS_PATH))
 	if (content === undefined) return false
-	const parsed = settings_schema.safeParse(safe_json_parse(content))
+	const parsed = settings_schema.safeParse(json_value.parse_or_undefined(content))
 
 	return parsed.success && parsed.data.enabledPlugins?.[PLUGIN_ID] === true
 }
@@ -77,11 +76,9 @@ function is_plugin_declared(root: string): boolean {
 // The value of `core.hooksPath`, or undefined when it is unset. A set value is what stops lefthook
 // from installing kit's git hooks — the failure is silent but for one stderr line.
 function configured_hooks_path(root: string): string | undefined {
-	const result = execaSync('git', ['-C', root, 'config', '--get', 'core.hooksPath'], {
-		reject: false,
+	const value = git_spawn_sync.read(['-C', root, 'config', '--get', 'core.hooksPath'], {
 		timeout: GIT_TIMEOUT_MS,
 	})
-	const value = read_spawn_stdout(result).trim()
 
 	return value === '' ? undefined : value
 }
@@ -107,7 +104,7 @@ function status_line(is_ok: boolean, ok_text: string, warn_text: string): string
 function plugin_line(is_declared: boolean): string {
 	return status_line(
 		is_declared,
-		`kit plugin declared (run \`claude plugin install ${PLUGIN_ID}\` once if skills are missing)`,
+		'kit plugin declared (skills load in a trusted workspace; headless from its second session)',
 		'kit plugin not declared in .claude/settings.json — run `pnpm josh sync`',
 	)
 }
@@ -160,7 +157,6 @@ const doctor_consumer = {
 	claude_md_line,
 	claude_md_state,
 	configured_hooks_path,
-	consumer_setup_lines,
 	hooks_path_line,
 	is_kit_consumer,
 	is_plugin_declared,

package/scripts/doctor/doctor-io.ts

@@ -1,6 +1,7 @@
 import { existsSync, readFileSync } from 'node:fs'
 import path from 'node:path'
-import { read_spawn_stderr, read_spawn_stdout } from '#scripts/lib/spawn-exit'
+import { git_spawn_sync } from '#scripts/git/git-spawn-sync'
+import { read_spawn_stdout } from '#scripts/lib/spawn-exit'
 import { execaSync } from 'execa'
 import { doctor_logic } from './doctor-logic'
 
@@ -69,18 +70,13 @@ function classify_git_failure(exit_code: number | undefined, stderr: string): Gi
 // caller's check, because reporting an unknown as a clean result is the false all-clear
 // joshuafolkken/kit#805 exists to remove. See the two classifiers above for what proves what.
 function resolve_git_top_level(): GitTopLevel {
-	const result = execaSync('git', ['rev-parse', '--show-toplevel'], {
-		reject: false,
-		timeout: GIT_TIMEOUT_MS,
-		// git translates its messages, so the match below would fail under any non-English locale and
-		// the spurious warning would come back. `C` pins the output this code was written against.
-		env: { LC_ALL: 'C', LANGUAGE: 'C' },
-		extendEnv: true,
-	})
-
-	if (result.exitCode === 0) return classify_top_level(read_spawn_stdout(result).trim())
-
-	return classify_git_failure(result.exitCode, read_spawn_stderr(result))
+	// The C locale `toplevel` asks under is what keeps the stderr match below from failing on a
+	// translated message and bringing the spurious warning back.
+	const result = git_spawn_sync.toplevel(GIT_TIMEOUT_MS)
+
+	if (result.exit_code === 0) return classify_top_level(result.stdout.trim())
+
+	return classify_git_failure(result.exit_code, result.stderr)
 }
 
 // Whether one line is the setting itself rather than prose about it. kit's own template explains the

package/scripts/doctor/doctor-logic.ts

@@ -3,7 +3,6 @@ import path from 'node:path'
 const RECOVERY_COMMAND = 'josh doctor --fix'
 const REPOSITORY_MAP_HEADING = 'Repositories (same owner, discovered next to this one):'
 const NO_REPOSITORIES_FOUND = '  (none discovered — see JOSH_REPO_PATHS in docs/josh-commands.md)'
-const GLOBAL_REINSTALL_COMMAND = 'pnpm add -g @joshuafolkken/kit'
 // Markers identifying a `josh` on PATH that was generated by an old kit `postinstall`
 // (pre-0.200.0 `install-bin.ts` wrote a shim referencing the kit package / tsx runner).
 const KIT_SHIM_MARKERS: ReadonlyArray<string> = [
@@ -102,14 +101,11 @@ function format_shadow_warning(path_josh: string, global_josh: string): string {
 
 const doctor_logic = {
 	RECOVERY_COMMAND,
-	GLOBAL_REINSTALL_COMMAND,
 	NO_SHADOW_REASON,
 	NOT_KIT_SHIM_REASON,
-	RECLAIM_REASON,
 	REPOSITORY_MAP_HEADING,
 	NO_REPOSITORIES_FOUND,
 	format_repository_map,
-	normalize_path,
 	path_lookup_command,
 	first_path_line,
 	is_shadowed,

package/scripts/doctor/doctor.ts

@@ -6,6 +6,7 @@ import { repo_discovery } from '#scripts/discovery/repo-discovery'
 import { gh_spawn } from '#scripts/gh/gh-spawn'
 import { PROJECT_ROOT } from '#scripts/init/init-paths'
 import { auto_merge_setting } from '#scripts/repo/auto-merge-setting'
+import { ruleset_check } from '#scripts/repo/ruleset-check'
 import { security_updates } from '#scripts/security/security-updates'
 import { running_binary } from '#scripts/version/running-binary'
 import { doctor_consumer } from './doctor-consumer'
@@ -32,8 +33,10 @@ interface GateScope {
 
 // Which repository-scoped reports this project has a prerequisite for.
 interface ApplicableSettings {
+	root: string
 	security_updates: boolean
 	auto_merge: boolean
+	required_checks: boolean
 }
 
 interface DoctorContext {
@@ -110,11 +113,17 @@ function resolve_gate_scope(git: GitTopLevel): GateScope | undefined {
 // workflow of its own has the second prerequisite and not the first.
 function resolve_applicable(scope: GateScope): ApplicableSettings {
 	return {
+		root: scope.root,
 		security_updates: doctor_io.has_distributed_dependabot_config(scope.root, scope.boundary),
 		auto_merge: doctor_io.has_auto_merge_workflow(scope.root, scope.boundary),
+		required_checks: ruleset_check.expected_in(scope.root).length > 0,
 	}
 }
 
+function has_any_applicable(applicable: ApplicableSettings): boolean {
+	return applicable.security_updates || applicable.auto_merge || applicable.required_checks
+}
+
 // Everything past the gate reports, including a failed lookup: `could not be read` is informative
 // while silence is the false all-clear joshuafolkken/kit#805 exists to remove.
 function report_applicable_settings(
@@ -123,6 +132,10 @@ function report_applicable_settings(
 ): void {
 	if (applicable.security_updates) security_updates.report_security_updates_section(repo)
 	if (applicable.auto_merge) auto_merge_setting.report_auto_merge_section(repo)
+
+	if (applicable.required_checks) {
+		ruleset_check.report_required_checks_section(repo, applicable.root)
+	}
 }
 
 // Last, and after the local diagnosis: this is the only part of `doctor` that touches the network,
@@ -143,7 +156,7 @@ function report_repository_settings(git: GitTopLevel): void {
 	const scope = resolve_gate_scope(git)
 	if (scope === undefined) return
 	const applicable = resolve_applicable(scope)
-	if (!applicable.security_updates && !applicable.auto_merge) return
+	if (!has_any_applicable(applicable)) return
 
 	report_applicable_settings(
 		applicable,
@@ -216,15 +229,7 @@ function main(): void {
 if (process.argv[1] === fileURLToPath(import.meta.url)) main()
 
 const doctor = {
-	gather_context,
-	print_report,
-	reclaim_shim,
-	handle_shadow,
 	parse_options,
-	consumer_root,
-	run_reports,
-	report_repository_map,
-	report_port_seeds,
 	main,
 }
 

package/scripts/document/backlogrun-parent-read-set.ts

@@ -34,15 +34,26 @@ const UNUSED_SKILL_SECTIONS: ReadonlyArray<string> = [
 // the park — so it drops none. Named empty so the shared trim reads the same shape as the worker's.
 const SKIPPED_POINT_OF_USE: ReadonlySet<string> = new Set<string>()
 
+// **The parent runs the end-of-run retrospective** (`SKILL.md` §2j) when `run:step` prints it, but its
+// manifest names `retrospective.md` only through `backlogrun-steps.md` — one hop further than the
+// derivation follows — so the parent's reach names it (joshuafolkken/kit#3078).
+const REACHED_POINT_OF_USE: ReadonlySet<string> = new Set(['retrospective.md'])
+
 function costed(root: string): ReadSetCost {
 	return read_set_trim.costed(root, {
 		base_entry: BACKLOGRUN,
 		label: BACKLOGRUN,
 		unused_skill_sections: UNUSED_SKILL_SECTIONS,
 		skipped_point_of_use: SKIPPED_POINT_OF_USE,
+		reached_point_of_use: REACHED_POINT_OF_USE,
 	})
 }
 
-const backlogrun_parent_read_set = { BACKLOGRUN, UNUSED_SKILL_SECTIONS, costed }
+const backlogrun_parent_read_set = {
+	BACKLOGRUN,
+	REACHED_POINT_OF_USE,
+	UNUSED_SKILL_SECTIONS,
+	costed,
+}
 
 export { backlogrun_parent_read_set }

package/scripts/document/document-byte-budget.ts

@@ -6,7 +6,7 @@
 // documents no entry reads — the reference documents a human browses, drawn by
 // `document-reachability.ts` from `read:set`'s output rather than by a hand-written table.
 //
-// Agent-read documents (`.claude/skills/**/*.md`, `prompts/**/*.md` and `docs/josh-commands.md`) have
+// Agent-read documents (`.claude/skills/**/*.md`, `prompts/**/*.md` and the two `docs/josh-commands*.md` references) have
 // been shrunk by reduction epics (joshuafolkken/kit#1929, joshuafolkken/kit#1924) only to swell
 // again, because nothing held the reduced size — a PR that adds a few lines at a time goes unseen
 // until the next reduction epic. This list is that hold for the unreached ones:
@@ -81,14 +81,14 @@ const DOCUMENT_BYTE_BUDGET: ReadonlyArray<DocumentBudget> = [
 	{ path: '.claude/skills/workflow-commands/prerequisite.md', bytes: 8192 },
 	{ path: '.claude/skills/workflow-commands/target-repository.md', bytes: 8192 },
 	{ path: '.claude/skills/workflow-commands/working-tree-hold.md', bytes: 8192 },
-	{ path: 'docs/josh-commands.md', bytes: 184_320 },
+	// joshuafolkken/kit#2998 split the reference: the developer commands stay, the rest moved out.
+	{ path: 'docs/josh-commands-automation.md', bytes: 155_648 },
+	{ path: 'docs/josh-commands.md', bytes: 36_864 },
 	{ path: 'prompts/coding-standards.md', bytes: 8192 },
 	{ path: 'prompts/collaboration-workflow.md', bytes: 8192 },
-	{ path: 'prompts/collaboration-workflow/cross-repo-epic.md', bytes: 4096 },
-	{ path: 'prompts/collaboration-workflow/epic-audit.md', bytes: 4096 },
-	{ path: 'prompts/collaboration-workflow/epic-bundle.md', bytes: 4096 },
 	{ path: 'prompts/collaboration-workflow/file-edits.md', bytes: 12_288 },
 	{ path: 'prompts/collaboration-workflow/gh-rest.md', bytes: 8192 },
+	{ path: 'prompts/collaboration-workflow/glossary.md', bytes: 4096 },
 	{ path: 'prompts/collaboration-workflow/issue-citation.md', bytes: 8192 },
 	// #2662 adds the feature and compatibility declarations to the canonical filing procedure.
 	{ path: 'prompts/collaboration-workflow/issue-template.md', bytes: 28_672 },

package/scripts/document/document-byte-check.ts

@@ -123,7 +123,6 @@ const document_byte_check = {
 	ceiling_message,
 	check_all,
 	check_files,
-	entry_over_budget_messages,
 	over_budget_for,
 	over_budget_messages,
 }

package/scripts/document/document-read-cli.ts

@@ -71,8 +71,6 @@ function main(argv: ReadonlyArray<string>): void {
 const document_read_cli = {
 	OVER_CAP_PREFIX,
 	READ_TOOL_DIRECTIVE,
-	USAGE,
-	main,
 	over_cap_directive,
 	run,
 }

package/scripts/document/document-section-cli.ts

@@ -94,7 +94,7 @@ function main(argv: ReadonlyArray<string>): void {
 	process.exitCode = run(argv)
 }
 
-const document_section_cli = { FAILURE_EXIT_CODE, USAGE, main, resolve_document, run }
+const document_section_cli = { FAILURE_EXIT_CODE, USAGE, resolve_document, run }
 
 if (process.argv[1] === fileURLToPath(import.meta.url)) main(process.argv.slice(ARGV_OFFSET))
 

package/scripts/document/document-section.ts

@@ -138,13 +138,10 @@ function read_optional(file_path: string): string | undefined {
 }
 
 const document_section = {
-	FENCE,
-	HEADING_PATTERN,
 	candidates,
 	headings,
 	read_optional,
 	section,
-	select,
 	titles,
 }
 

package/scripts/document/edit-files-cli.ts

@@ -270,7 +270,6 @@ function main(argv: ReadonlyArray<string>): void {
 
 const edit_files_cli = {
 	USAGE,
-	main,
 	parse_plan,
 	run,
 }

package/scripts/document/entry-read-budget.ts

@@ -3,8 +3,9 @@
 //
 // **The per-document ceiling was a proxy for a run's cost, not the cost.** A run does not pay "one
 // document's size"; it pays the total its entry reads — the mandated skill files, the sections they
-// point out to, the point-of-use documents reached later, and the resident `CLAUDE.md` every request
-// carries. `read:set` already computes that total, so this budgets it directly: the entry total is
+// point out to, the point-of-use documents that entry reaches later, and the resident `CLAUDE.md` every
+// request carries. `read:set`'s `total read` is that sum less `CLAUDE.md`, which `entry_total_bytes`
+// adds back (`RESIDENT_BASE`), so this budgets the whole directly: the entry total is
 // the primary ceiling, and the per-document ceiling (`document-byte-budget.ts`) falls back to the
 // documents no entry reads (`document-reachability.ts` draws the line). A document an entry reads is
 // held by the entry total and carries no per-document ceiling, so neither budget holds it twice.
@@ -69,7 +70,7 @@ const ENTRY_READ_BUDGET: ReadonlyArray<EntryBudget> = [
 	// list, so its ~48KB read crossed a block downward and the recorded ceiling drops to the block multiple
 	// the stale-ratchet message named. The other entries still read it, so their rows hold.
 	// joshuafolkken/kit#2345 added the `implementation-unit` delegation row (full fan-out procedure in
-	// `docs/josh-commands.md` → "`josh fanout`"); `SKILL.md` §2b gained only a one-clause mention and a
+	// `docs/josh-commands-automation.md` → "`josh fanout`"); `SKILL.md` §2b gained only a one-clause mention and a
 	// pointer, folded into the existing enumeration and offset by tightening §2b prose, so every entry
 	// stayed within its block (kickoff has no block of headroom — its pre-#2294 ceiling is the next
 	// multiple, which the downward ratchet holds shut).
@@ -79,10 +80,23 @@ const ENTRY_READ_BUDGET: ReadonlyArray<EntryBudget> = [
 	// joshuafolkken/kit#2762 moved the rationale of five point-of-use documents to
 	// `docs/maintainers/*-rationale.md`, and the ratchet holds the reduction. joshuafolkken/kit#2895 did
 	// the same for eight more, lowering fullrun, halfrun and backlogrun one block each.
-	{ entry: 'kickoff', bytes: 229_376 },
-	{ entry: 'fullrun', bytes: 225_280 },
-	{ entry: 'halfrun', bytes: 225_280 },
-	{ entry: 'backlogrun', bytes: 229_376 },
+	// joshuafolkken/kit#2998 split the command reference, so every reference to an automation command
+	// now names `josh-commands-automation.md`; the longer path tipped backlogrun one block over.
+	// joshuafolkken/kit#2994 moved `CLAUDE.md`'s explanations to `docs/maintainers/claude-md-history.md`,
+	// lowering backlogrun one block; kickoff's reduction was offset by joshuafolkken/kit#3024's longer
+	// `wip-cap.md`, so its ceiling stays.
+	// joshuafolkken/kit#3023 added the `prrun` keyword to `SKILL.md` and `CLAUDE.md`, tipping backlogrun
+	// one block over; `prrun` reads `fullrun`'s set plus its own short manifest.
+	// Lowered in joshuafolkken/kit#3078 — a correction of an over-count, not a trim: every entry was
+	// charged for every global point-of-use document, so `kickoff` paid for `followup.md` and the
+	// `backlogrun-*` phase documents it never opens. Each total now counts only what its path reaches.
+	// joshuafolkken/kit#3077 trimmed non-resident rule bodies from `CLAUDE.md`, lowering fullrun, prrun
+	// and backlogrun one block each.
+	{ entry: 'kickoff', bytes: 65_536 },
+	{ entry: 'fullrun', bytes: 126_976 },
+	{ entry: 'halfrun', bytes: 106_496 },
+	{ entry: 'prrun', bytes: 131_072 },
+	{ entry: 'backlogrun', bytes: 212_992 },
 	{ entry: LANE_CHILD, bytes: 77_824 },
 ]
 

package/scripts/document/entry-read-set.ts

@@ -420,16 +420,40 @@ function point_of_use_cost(
 	return { file, heading: '', cost: cost_of(read_document(root, file)), is_resolved: true }
 }
 
-function point_of_use_costs(root: string, entry: string): Array<SectionCost> {
-	const found = document_section.section(read_document(root, SKILL_FILE), TABLE_SECTION)
-	const references = all_matches(found?.text ?? '', SECTION_REFERENCE).map((match) =>
-		to_reference(match),
-	)
+// **What an entry's path names: its own manifests, and the §1 trigger rows that name the entry**
+// (joshuafolkken/kit#3078). `SKILL.md`'s other text is left out for the reason `sections_for` gives —
+// §2 names every document, so counting it would charge a `kickoff` for `followup.md`. One hop only:
+// the point-of-use documents cite one another, and following them would reach the whole set again.
+// `also` is what a role reaches beside its base entry's path (`read-set-trim.ts`).
+function cited_by(
+	root: string,
+	entry: string,
+	table_text: string,
+	also: ReadonlySet<string>,
+): Set<string> {
+	const manifests = files_for(root, entry).filter((file) => file !== SKILL_FILE)
+	const rows = table_text
+		.split('\n')
+		.filter((line) => line.startsWith('|') && line.includes(`\`${entry}\``))
+	const texts = [...manifests.map((file) => read_document(root, file)), ...rows]
+
+	return new Set([...also, ...texts.flatMap((text) => names_in(text))])
+}
+
+function point_of_use_costs(
+	root: string,
+	entry: string,
+	also: ReadonlySet<string>,
+): Array<SectionCost> {
+	const table_text =
+		document_section.section(read_document(root, SKILL_FILE), TABLE_SECTION)?.text ?? ''
+	const references = all_matches(table_text, SECTION_REFERENCE).map((match) => to_reference(match))
+	const cited = cited_by(root, entry, table_text, also)
 
-	return point_of_use_files(entry).map((file) => point_of_use_cost(root, file, references))
+	return point_of_use_files(entry, cited).map((file) => point_of_use_cost(root, file, references))
 }
 
-function costed(root: string, entry: string): ReadSetCost {
+function costed(root: string, entry: string, also: ReadonlySet<string> = new Set()): ReadSetCost {
 	const { files, sections } = read_set(root, entry)
 	const own_costs = file_costs(root, files)
 	const section_costs = sections.map((reference) => section_cost(root, reference))
@@ -439,7 +463,7 @@ function costed(root: string, entry: string): ReadSetCost {
 		entry,
 		files: own_costs,
 		sections: section_costs,
-		point_of_use: point_of_use_costs(root, entry),
+		point_of_use: point_of_use_costs(root, entry, also),
 		bash_output_cap: bash_output_cap_reader.bash_output_cap(root),
 		whole: total([own, referenced_cost(root, sections)]),
 		scoped: total([own, scoped_cost(root, sections)]),

package/scripts/document/lane-child-read-set.ts

@@ -12,7 +12,7 @@
 // section level, and the point-of-use documents a leaf never reaches dropped — applied by the shared
 // `read-set-trim`, which the `backlogrun` parent trim uses too (joshuafolkken/kit#2256).
 
-import type { Cost, ReadSetCost } from './entry-read-set'
+import type { ReadSetCost } from './entry-read-set'
 import { read_set_trim } from './read-set-trim'
 
 const LANE_CHILD = 'lane-child'
@@ -64,25 +64,27 @@ const SKIPPED_POINT_OF_USE: ReadonlySet<string> = new Set([
 	'retrospective.md',
 ])
 
+// **A child that parks reads `backlogrun-park.md`** (`SKILL.md` §1, "A lane child that parks"), a
+// document a standalone `fullrun`'s path never names — so the child's reach adds it to its base
+// entry's (joshuafolkken/kit#3078).
+const REACHED_POINT_OF_USE: ReadonlySet<string> = new Set(['backlogrun-park.md'])
+
 function costed(root: string): ReadSetCost {
 	return read_set_trim.costed(root, {
 		base_entry: FULLRUN,
 		label: LANE_CHILD,
 		unused_skill_sections: UNUSED_SKILL_SECTIONS,
 		skipped_point_of_use: SKIPPED_POINT_OF_USE,
+		reached_point_of_use: REACHED_POINT_OF_USE,
 	})
 }
 
-function unused_skill_cost(root: string): Cost {
-	return read_set_trim.unused_skill_cost(root, UNUSED_SKILL_SECTIONS)
-}
-
 const lane_child_read_set = {
 	LANE_CHILD,
+	REACHED_POINT_OF_USE,
 	SKIPPED_POINT_OF_USE,
 	UNUSED_SKILL_SECTIONS,
 	costed,
-	unused_skill_cost,
 }
 
 export { lane_child_read_set }