@joshuafolkken/kit 1.2116.0 → 1.3000.0

package/scripts/rules/rule-rewrite.ts

@@ -1,7 +1,8 @@
+import { hook_context, type HookContext } from '#scripts/hooks/hook-context'
 import { hook_decision } from '#scripts/josh/hook-decision'
 import { json_value } from '#scripts/lib/json-value'
-import { time_density_hook } from '#scripts/time-runtime/time-density-hook'
 import { time_hook_transcript } from '#scripts/time-runtime/time-hook-transcript'
+import { transcript_tail } from '#scripts/time-runtime/transcript-tail'
 import { delivered_rules, type DeliveredRule } from './delivered-rules'
 import { guard_remedy } from './guard-remedy'
 
@@ -36,7 +37,7 @@ function read_payload_tail(raw_payload: string): string {
 		const payload = hook_decision.parse_hook_payload(raw_payload)
 
 		return payload
-			? time_density_hook.read_tail(
+			? transcript_tail.read_tail(
 					time_hook_transcript.transcript_of(payload.transcript_path, payload.agent_id),
 				)
 			: ''
@@ -55,11 +56,16 @@ function tail_reader(raw_payload: string): () => string {
 	}
 }
 
-function fold(name: string, typed: Record<string, unknown>, tail: () => string): Folded {
+function fold(
+	name: string,
+	typed: Record<string, unknown>,
+	tail: () => string,
+	context: HookContext,
+): Folded {
 	const folded: Folded = { input: typed, notes: [] }
 
 	for (const rule of REWRITING_RULES) {
-		const input = rule.rewrite?.({ name, input: folded.input }, tail)
+		const input = rule.rewrite?.({ name, input: folded.input }, tail, context)
 
 		if (input === undefined) {
 			continue
@@ -91,12 +97,16 @@ function typed_payload(raw_payload: string): TypedPayload | undefined {
 		: undefined
 }
 
-function rewrite(raw_payload: string): RuleRewrite | undefined {
+// The rows read the cwd and environment from `context`, never off the process.
+function rewrite(
+	raw_payload: string,
+	context: HookContext = hook_context.from_process(),
+): RuleRewrite | undefined {
 	const typed = delivered_rules.is_enabled() ? typed_payload(raw_payload) : undefined
 
 	if (typed === undefined) return undefined
 
-	const { input, notes } = fold(typed.name, typed.input, tail_reader(raw_payload))
+	const { input, notes } = fold(typed.name, typed.input, tail_reader(raw_payload), context)
 
 	if (notes.length === 0) return undefined
 

package/scripts/rules/rule-value-cache.ts

@@ -136,7 +136,16 @@ function store(text: string, cwd: string = process.cwd()): void {
 	write_cache_file(cwd, CACHE_FILE, `${text}\n`)
 }
 
-const rule_value_cache = { CACHE_FILE, REFRESH_MS, STAMP_FILE, cache_path, emit, read_fresh, store }
+const rule_value_cache = {
+	CACHE_FILE,
+	REFRESH_MS,
+	STAMP_FILE,
+	cache_path,
+	emit,
+	is_linked_work_tree,
+	read_fresh,
+	store,
+}
 
 export type { CachePorts, FreshReading }
 export { rule_value_cache }

package/scripts/rules/rule-value-cli.ts

@@ -1,11 +1,15 @@
 #!/usr/bin/env tsx
 import { fileURLToPath } from 'node:url'
 import { cost_transcript, type SessionFile } from '#scripts/cost-runtime/cost-transcript'
+import { stamped_memo } from '#scripts/lib/stamped-memo'
 import { delivered_rules } from './delivered-rules'
-import { piped_verification_shapes, type ShapeCounts } from './piped-verification-shapes'
+import { piped_verification_shapes } from './piped-verification-shapes'
+import { rule_rephrase } from './rule-rephrase'
 import { rule_value, type RuleReading } from './rule-value'
 import { rule_value_cache, type FreshReading } from './rule-value-cache'
 import { rule_value_candidates } from './rule-value-candidates'
+import { rule_value_prose } from './rule-value-prose'
+import { rule_value_runs, type RunSummary } from './rule-value-runs'
 
 // `josh rule:value` — what each delivered rule earns on the channel that carries it, one row per rule.
 // `rule_value.measure` was public but had no caller outside its own test, so
@@ -20,6 +24,7 @@ import { rule_value_candidates } from './rule-value-candidates'
 const ARGV_OFFSET = 2
 const REFRESH_FLAG = '--refresh'
 const FRESH_FLAG = '--fresh'
+const PROSE_FLAG = '--prose'
 const CACHED_NOTE = 'cached reading taken at'
 const PERCENT_SIGN = '%'
 const COLUMN_GAP = '  '
@@ -48,47 +53,22 @@ function group_by_run(files: ReadonlyArray<SessionFile>): Map<string, Array<Sess
 	return runs
 }
 
-function readable_texts(files: ReadonlyArray<SessionFile>): Array<string> {
-	return files
-		.map((file) => cost_transcript.read_optional(file))
-		.filter((text): text is string => text !== undefined)
-}
-
-// **One run read at a time.** Each run's text is read only when `measure` asks for it and released
-// before the next is read, so the peak is the largest run rather than the whole corpus. A run whose
-// every file is unreadable yields nothing, as it was never a measurement target.
-function* runs_of(groups: Iterable<ReadonlyArray<SessionFile>>): Generator<Array<string>> {
-	for (const files of groups) {
-		const texts = readable_texts(files)
-
-		if (texts.length > 0) yield texts
-	}
-}
-
 // Every run reachable from the working tree — the session's own transcript directory and any lane
-// slugs beneath its main checkout — in the shape `rule_value.measure` reads.
-function gather_runs(cwd: string = process.cwd()): Generator<Array<string>> {
+// slugs beneath its main checkout — summarized, reading again only the runs whose files moved since
+// the stored measurement (`rule-value-runs.ts`). Without a store every run is read.
+function gather_summaries(cwd: string): Array<RunSummary> {
 	const directories = cost_transcript.transcript_directories(cwd)
-	const files = cost_transcript.list_sessions_across(directories)
+	const runs = group_by_run(cost_transcript.list_sessions_across(directories))
+	const store = rule_value_runs.open(cwd)
+	const summaries = rule_value_runs.summaries_of(runs, store ?? stamped_memo.create())
 
-	return runs_of(group_by_run(files).values())
-}
+	store?.save()
 
-// The `piped-verification` refusals are named by shape in the same pass, so the corpus is read once.
-interface Tally {
-	runs: number
-	shapes: ShapeCounts
+	return summaries
 }
 
-function* counted(
-	runs: Iterable<ReadonlyArray<string>>,
-	tally: Tally,
-): Generator<ReadonlyArray<string>> {
-	for (const texts of runs) {
-		tally.runs += 1
-		for (const text of texts) piped_verification_shapes.count(text, tally.shapes)
-		yield texts
-	}
+function* summarized(runs: Iterable<ReadonlyArray<string>>): Generator<RunSummary> {
+	for (const texts of runs) yield rule_value_runs.summarize(texts)
 }
 
 // The id column, wide enough for the longest rule id, so the reading lines up whatever the registry
@@ -105,14 +85,27 @@ function rate_text(reading: RuleReading): string {
 	return `${rate.toString()}${PERCENT_SIGN} unaided`
 }
 
-function row(reading: RuleReading): string {
+// A count column only where it is non-zero, so the rows of rules it never touched keep their shape.
+function optional_column(label: string, value: number): Array<string> {
+	return value > 0 ? [`${label} ${value.toString()}`] : []
+}
+
+// `rephrased` is the runs where the next call of a refused tool was allowed — the guard's
+// false-positive proxy, in the same unit as `refused` (`rule-rephrase.ts`).
+function row(reading: RuleReading, rephrased = 0): string {
 	const id = reading.id.padEnd(ID_WIDTH)
 	const reached = `reached ${reading.sessions.toString()}`
 	const refused = `refused ${reading.refusals.toString()}`
-	// Only where a rewrite happened, so the rows of rules that can only refuse keep their shape.
-	const rewritten = reading.rewrites > 0 ? [`rewritten ${reading.rewrites.toString()}`] : []
+	const rewritten = optional_column('rewritten', reading.rewrites)
 
-	return [id, reached, rate_text(reading), refused, ...rewritten].join(COLUMN_GAP)
+	return [
+		id,
+		reached,
+		rate_text(reading),
+		refused,
+		...rewritten,
+		...optional_column('rephrased', rephrased),
+	].join(COLUMN_GAP)
 }
 
 // `candidates` is set only where something measurable was found, so `NO_TARGETS` stays the whole answer.
@@ -123,23 +116,26 @@ interface Rendered {
 
 // The reading as text, or `NO_TARGETS` when nothing measurable was found — never an empty output that
 // would read as a broken command.
-// The runs are counted as `measure` consumes them, since a lazy source cannot be asked its length
-// up front.
-function render_parts(runs: Iterable<ReadonlyArray<string>>): Rendered {
-	const tally: Tally = { runs: 0, shapes: new Map() }
-	const readings = rule_value.measure(counted(runs, tally))
+function render_summaries(summaries: Iterable<RunSummary>): Rendered {
+	const { runs, readings, shapes, rephrased } = rule_value_runs.tally(summaries)
 
-	if (tally.runs === 0) return { table: NO_TARGETS }
+	if (runs === 0) return { table: NO_TARGETS }
 
-	const judged = rule_value_candidates.judge(readings, tally.runs)
-	const shapes = piped_verification_shapes.render(tally.shapes)
+	const judged = rule_value_candidates.judge(readings, runs)
 
 	return {
-		table: readings.map((reading) => row(reading)).join('\n'),
-		candidates: `${rule_value_candidates.render(judged, tally.runs)}\n${shapes}`,
+		table: readings
+			.map((reading) => row(reading, rule_rephrase.rephrased_of(reading.id, rephrased)))
+			.join('\n'),
+		candidates: `${rule_value_candidates.render(judged, runs)}\n${piped_verification_shapes.render(shapes)}`,
 	}
 }
 
+// The same reading from each run's texts, every run read.
+function render_parts(runs: Iterable<ReadonlyArray<string>>): Rendered {
+	return render_summaries(summarized(runs))
+}
+
 function render(runs: Iterable<ReadonlyArray<string>>): string {
 	return render_parts(runs).table
 }
@@ -153,7 +149,7 @@ function cached_text(fresh: FreshReading): string {
 }
 
 function print_measured(cwd: string): void {
-	const { table, candidates } = render_parts(gather_runs(cwd))
+	const { table, candidates } = render_summaries(gather_summaries(cwd))
 
 	process.stdout.write(`${[table, candidates].filter(Boolean).join('\n\n')}\n`)
 }
@@ -165,6 +161,18 @@ function print_reading(argv: ReadonlyArray<string>, cwd: string): void {
 	else process.stdout.write(`${cached_text(fresh)}\n`)
 }
 
+// `--prose` reads the documents instead of the transcripts: every prose rule and whether a registered
+// row enforces it (`rule-value-prose.ts`).
+function print_prose(cwd: string): void {
+	process.stdout.write(`${rule_value_prose.render(rule_value_prose.audit(cwd))}\n`)
+}
+
+function print_transcripts(argv: ReadonlyArray<string>, cwd: string): void {
+	if (argv.includes(REFRESH_FLAG)) {
+		rule_value_cache.store(render_summaries(gather_summaries(cwd)).table, cwd)
+	} else print_reading(argv, cwd)
+}
+
 // `--refresh` is the detached measurement the `backlogrun` loop head starts: the table goes to the
 // cache `backlog:offer` prints from, never to stdout (`rule-value-cache.ts`). The candidates are read
 // when a rule is retired, not at the loop head, so they print to stdout only and the cache keeps its
@@ -172,8 +180,8 @@ function print_reading(argv: ReadonlyArray<string>, cwd: string): void {
 // the measurement re-reads every transcript and takes minutes (joshuafolkken/kit#5186); `--fresh`
 // measures regardless.
 function run_rule_value(argv: ReadonlyArray<string> = [], cwd: string = process.cwd()): number {
-	if (argv.includes(REFRESH_FLAG)) rule_value_cache.store(render_parts(gather_runs(cwd)).table, cwd)
-	else print_reading(argv, cwd)
+	if (argv.includes(PROSE_FLAG)) print_prose(cwd)
+	else print_transcripts(argv, cwd)
 
 	return 0
 }
@@ -186,9 +194,9 @@ const rule_value_cli = {
 	group_by_run,
 	render,
 	render_parts,
+	render_summaries,
 	row,
 	run_rule_value,
-	runs_of,
 	CACHED_NOTE,
 	NO_TARGETS,
 	UNMEASURED,

package/scripts/rules/rule-value-prose.ts

@@ -0,0 +1,186 @@
+import { globSync, readFileSync } from 'node:fs'
+import path from 'node:path'
+import { document_section } from '#scripts/document/document-section'
+import { decision_oracle } from './decision-oracle'
+import { guard_rule_rows } from './guard-rule-rows'
+
+// `josh rule:value --prose` — every prose rule, read against the registered rules that cite its source.
+// A prose rule is a paragraph or list item that opens with a bold label, the form these documents
+// already cite a rule by (`document-section.ts` → "A bold label is an anchor too"). It is enforced
+// where a guard row's `topic` cites the section it sits in, measured only where just a decision
+// oracle's `single_source` does, and prose only where nothing does — the count the residency rule
+// works down (`prompts/collaboration-workflow/residency.md`).
+
+const PROSE_GLOBS = ['prompts/**/*.md', '.claude/skills/**/*.md', 'CLAUDE.md']
+const ENFORCED = '強制あり'
+const MEASURED = '計測のみ'
+const PROSE_ONLY = '文章だけ'
+// The label runs to its closing `**` or the line end, so a label that wraps still names its rule.
+const RULE_LINE = /^(?<marker>\s*(?:[-*]|\d+\.) )?\*\*(?<label>[^*]+)/u
+const SOURCE_ARROW = '→'
+const CITE_MARKS = /["`]/gu
+const MARKDOWN_EXTENSION = '.md'
+const LABEL_WIDTH = 80
+const COLUMN_GAP = '  '
+const LINE_BASE = 1
+
+type ProseClass = typeof ENFORCED | typeof MEASURED | typeof PROSE_ONLY
+
+interface ProseDocument {
+	file: string
+	markdown: string
+}
+
+interface ProseRule {
+	file: string
+	// One-based, as a `file:line` citation reads.
+	line: number
+	label: string
+}
+
+interface AuditedRule extends ProseRule {
+	class: ProseClass
+}
+
+// Zero-based and inclusive, as `document_section.section` reports a section.
+interface Span {
+	file: string
+	first_line: number
+	last_line: number
+}
+
+interface Sources {
+	guards: ReadonlyArray<string>
+	oracles: ReadonlyArray<string>
+}
+
+// A bare `**` line opens a rule only after a blank line; mid-paragraph it is a wrapped continuation.
+function opens_rule(lines: ReadonlyArray<string>, index: number, marker?: string): boolean {
+	return marker !== undefined || (lines[index - LINE_BASE] ?? '').trim() === ''
+}
+
+function opening_label(lines: ReadonlyArray<string>, index: number): string | undefined {
+	const groups = RULE_LINE.exec(lines[index] ?? '')?.groups ?? {}
+
+	return opens_rule(lines, index, groups['marker']) ? groups['label'] : undefined
+}
+
+function rule_at(file: string, lines: ReadonlyArray<string>, index: number): ProseRule | undefined {
+	const label = opening_label(lines, index)
+
+	if (label === undefined) return undefined
+
+	return { file, line: index + LINE_BASE, label: label.trim().slice(0, LABEL_WIDTH) }
+}
+
+// Fenced lines are quoted code, never a rule — the same flags the section reader skips them by.
+function rules_of({ file, markdown }: ProseDocument): Array<ProseRule> {
+	const lines = markdown.split('\n')
+	const fenced = document_section.fenced_flags(lines)
+
+	return lines
+		.map((_line, index) => (fenced[index] === true ? undefined : rule_at(file, lines, index)))
+		.filter((rule): rule is ProseRule => rule !== undefined)
+}
+
+// A cited file names a document by its path or its base name, as `topic` strings do.
+function is_cited_file(file: string, cited: string): boolean {
+	return file === cited || file.endsWith(`/${cited}`)
+}
+
+function span_of(document: ProseDocument, heading: string): Span | undefined {
+	const lines = document.markdown.split('\n')
+
+	if (heading === '') return { file: document.file, first_line: 0, last_line: lines.length }
+
+	const found = document_section.section(document.markdown, heading)
+
+	if (found === undefined) return undefined
+
+	return { file: document.file, first_line: found.first_line, last_line: found.last_line }
+}
+
+// The quotes and code marks around a cited name; the section reader drops inner backticks itself.
+function bare(text: string): string {
+	return text.replaceAll(CITE_MARKS, '').trim()
+}
+
+// `` `file.md` → "Heading" `` and `file.md → Heading` alike: the file before the arrow, the section
+// after it. A source that is not a markdown document cites no prose rule.
+function spans_of(source: string, documents: ReadonlyArray<ProseDocument>): Array<Span> {
+	const [head = '', ...rest] = source.split(SOURCE_ARROW)
+	const cited = bare(head)
+
+	if (!cited.endsWith(MARKDOWN_EXTENSION)) return []
+
+	const heading = bare(rest.join(SOURCE_ARROW))
+
+	return documents
+		.filter((document) => is_cited_file(document.file, cited))
+		.map((document) => span_of(document, heading))
+		.filter((span): span is Span => span !== undefined)
+}
+
+function all_spans(
+	sources: ReadonlyArray<string>,
+	documents: ReadonlyArray<ProseDocument>,
+): Array<Span> {
+	return sources.flatMap((source) => spans_of(source, documents))
+}
+
+function is_covered(rule: ProseRule, spans: ReadonlyArray<Span>): boolean {
+	const index = rule.line - LINE_BASE
+
+	return spans.some(
+		(span) => span.file === rule.file && span.first_line <= index && index <= span.last_line,
+	)
+}
+
+function classify(documents: ReadonlyArray<ProseDocument>, sources: Sources): Array<AuditedRule> {
+	const guard_spans = all_spans(sources.guards, documents)
+	const oracle_spans = all_spans(sources.oracles, documents)
+	const rules = documents.flatMap((document) => rules_of(document))
+
+	return rules.map(function audited(rule: ProseRule): AuditedRule {
+		if (is_covered(rule, guard_spans)) return { ...rule, class: ENFORCED }
+
+		return { ...rule, class: is_covered(rule, oracle_spans) ? MEASURED : PROSE_ONLY }
+	})
+}
+
+function documents_in(cwd: string): Array<ProseDocument> {
+	return globSync(PROSE_GLOBS, { cwd })
+		.toSorted((left, right) => left.localeCompare(right))
+		.map((file) => ({ file, markdown: readFileSync(path.join(cwd, file), 'utf8') }))
+}
+
+function registered_sources(): Sources {
+	return {
+		// The rows `rule:list` prints.
+		guards: guard_rule_rows.rows().map((row) => row.about.topic),
+		oracles: decision_oracle.DECISION_ORACLES.map((oracle) => oracle.single_source),
+	}
+}
+
+function audit(cwd: string = process.cwd()): Array<AuditedRule> {
+	return classify(documents_in(cwd), registered_sources())
+}
+
+function count_of(audited: ReadonlyArray<AuditedRule>, wanted: ProseClass): string {
+	return `${wanted} ${audited.filter((rule) => rule.class === wanted).length.toString()}`
+}
+
+function render(audited: ReadonlyArray<AuditedRule>): string {
+	const rows = audited.map((rule) =>
+		[rule.class, `${rule.file}:${rule.line.toString()}`, rule.label].join(COLUMN_GAP),
+	)
+	const classes: ReadonlyArray<ProseClass> = [ENFORCED, MEASURED, PROSE_ONLY]
+	const totals = classes.map((wanted) => count_of(audited, wanted))
+
+	return [...rows, '', totals.join(' · ')].join('\n')
+}
+
+const rule_value_prose = { audit, classify, render, ENFORCED, MEASURED, PROSE_ONLY }
+
+export type { AuditedRule, ProseDocument }
+export { rule_value_prose }

package/scripts/rules/rule-value-runs.ts

@@ -0,0 +1,171 @@
+import { createHash } from 'node:crypto'
+import { fileURLToPath } from 'node:url'
+import { cost_transcript, type SessionFile } from '#scripts/cost-runtime/cost-transcript'
+import { import_closure } from '#scripts/lib/import-closure'
+import { file_reader } from '#scripts/lib/read-file'
+import { stamped_memo, type StampedMemo } from '#scripts/lib/stamped-memo'
+import { stamped_store, type StampedStore } from '#scripts/lib/stamped-store'
+import { z } from 'zod'
+import { delivered_rules } from './delivered-rules'
+import {
+	piped_verification_shapes,
+	type RefusalShape,
+	type ShapeCounts,
+} from './piped-verification-shapes'
+import { rule_rephrase, type RephraseCounts } from './rule-rephrase'
+import { rule_value, type RuleReading, type RuleState } from './rule-value'
+import { rule_value_cache } from './rule-value-cache'
+
+// `josh rule:value` read run by run, each run's counts kept between measurements
+// (joshuafolkken/kit#7134).
+//
+// **A run adds to the reading on its own**: its rule states, its `piped-verification` refusal shapes
+// and its rephrased guards are summed into the totals and never read beside another run. So a run
+// whose files have not changed since the last measurement contributes the counts it contributed
+// then, and only a run whose files moved is read again. The table equals the one a full read draws.
+
+const STORE_FILE = 'rule-value-runs.json'
+const HASH = 'sha256'
+const LINE = '\n'
+const PAIR = '='
+
+// `states` holds only the credited ones (`rule_value.is_credited`): most rules never reach a run, and
+// their blank states would make up nearly all of the store.
+interface RunSummary {
+	is_read: boolean
+	states: Array<[string, RuleState]>
+	shapes: Array<[RefusalShape, number]>
+	rephrased: Array<[string, number]>
+}
+
+// A run with no readable text — not a measurement target, so not counted in `runs`.
+const UNREAD: RunSummary = { is_read: false, states: [], shapes: [], rephrased: [] }
+
+const state_schema = z.object({
+	is_kept: z.boolean(),
+	is_reached: z.boolean(),
+	is_triggered: z.boolean(),
+	is_refused: z.boolean(),
+	is_rewritten: z.boolean(),
+})
+
+const state_entry = z.tuple([z.string(), state_schema])
+const shape_entry = z.tuple([z.enum(piped_verification_shapes.SHAPE), z.number()])
+const count_entry = z.tuple([z.string(), z.number()])
+
+const summary_schema = z.object({
+	is_read: z.boolean(),
+	states: z.array(state_entry),
+	shapes: z.array(shape_entry),
+	rephrased: z.array(count_entry),
+})
+
+interface Tally {
+	runs: number
+	readings: ReadonlyArray<RuleReading>
+	shapes: ShapeCounts
+	rephrased: RephraseCounts
+}
+
+function summarize(texts: ReadonlyArray<string>): RunSummary {
+	if (texts.length === 0) return UNREAD
+
+	const shapes: ShapeCounts = new Map()
+	const rephrased: RephraseCounts = new Map()
+
+	for (const text of texts) piped_verification_shapes.count(text, shapes)
+	rule_rephrase.count_run(texts, rephrased)
+
+	const states = [...rule_value.read_run(texts)].filter(([, state]) =>
+		rule_value.is_credited(state),
+	)
+
+	return { is_read: true, states, shapes: [...shapes], rephrased: [...rephrased] }
+}
+
+function readable_texts(files: ReadonlyArray<SessionFile>): Array<string> {
+	return files
+		.map((file) => cost_transcript.read_optional(file))
+		.filter((text): text is string => text !== undefined)
+}
+
+// Every file of the run by path, with what changes when it is appended to, rewritten or replaced.
+function run_stamp(files: ReadonlyArray<SessionFile>): string {
+	return files
+		.map((file) => file.path)
+		.toSorted((left, right) => left.localeCompare(right))
+		.map((file) => `${file}${PAIR}${stamped_memo.file_stamp(file)}`)
+		.join(LINE)
+}
+
+// **One run read at a time**, and only a run whose stamp moved: its text is released before the next
+// is read, so the peak is the largest run rather than the corpus. A run gone from `runs` is forgotten.
+function summaries_of(
+	runs: ReadonlyMap<string, ReadonlyArray<SessionFile>>,
+	memo: StampedMemo<RunSummary>,
+): Array<RunSummary> {
+	memo.keep(new Set(runs.keys()))
+
+	return [...runs].map(([owner, files]) =>
+		memo.of(owner, run_stamp(files), () => summarize(readable_texts(files))),
+	)
+}
+
+function add<Key>(counts: Map<Key, number>, entries: ReadonlyArray<[Key, number]>): void {
+	for (const [key, count] of entries) counts.set(key, (counts.get(key) ?? 0) + count)
+}
+
+function tally(summaries: Iterable<RunSummary>): Tally {
+	const read = [...summaries].filter((summary) => summary.is_read)
+	const shapes: ShapeCounts = new Map()
+	const rephrased: RephraseCounts = new Map()
+
+	for (const summary of read) {
+		add(shapes, summary.shapes)
+		add(rephrased, summary.rephrased)
+	}
+
+	const readings = rule_value.measure_states(read.map((summary) => new Map(summary.states)))
+
+	return { runs: read.length, readings, shapes, rephrased }
+}
+
+// The code doing the counting: this module's static import closure, which reaches `read_run`, every
+// rule predicate, the refusal shapes and the rephrase count. Run from `dist/`, `import.meta.url` still
+// names this source file (`scripts/build/source-location.ts`), and `scripts/` ships beside it.
+function counting_sources(): Array<string> {
+	return [...import_closure.closure([fileURLToPath(import.meta.url)])].toSorted((left, right) =>
+		left.localeCompare(right),
+	)
+}
+
+// How the kept counts were computed: the measured rule ids and the content of every counting source,
+// so a change to any of them reads every run again.
+function version_of(sources: ReadonlyArray<string>): string {
+	const ids = delivered_rules.MEASURED_RULES.map((rule) => rule.id).join(LINE)
+	const hash = createHash(HASH).update(ids)
+
+	for (const source of sources) {
+		hash.update(LINE).update(file_reader.read_if_readable(source) ?? '')
+	}
+
+	return hash.digest('hex')
+}
+
+// The main checkout's store. A lane reads only its own transcripts, so it opens no store: keeping its
+// runs alone would forget every other one (`rule_value_cache.is_linked_work_tree`).
+function open(
+	cwd: string,
+	sources: ReadonlyArray<string> = counting_sources(),
+): StampedStore<RunSummary> | undefined {
+	if (rule_value_cache.is_linked_work_tree(cwd)) return undefined
+
+	const file = rule_value_cache.cache_path(cwd, STORE_FILE)
+
+	return stamped_store.open(file, version_of(sources), summary_schema)
+}
+
+const rule_value_runs = { counting_sources, open, summaries_of, summarize, tally, version_of }
+
+export { rule_value_runs }
+export type { RunSummary, Tally }