@joshuafolkken/kit 1.1784.0 → 1.2114.0

package/scripts/rules/file-rewrite.ts

@@ -0,0 +1,146 @@
+import { json_value } from '#scripts/lib/json-value'
+import { file_reader } from '#scripts/lib/read-file'
+import { run_cut_handoff } from '#scripts/run/cut/run-cut-handoff'
+import type { GuardedCall } from '#scripts/time-runtime/time-batch-guard'
+import { edit_tool } from './edit-tool'
+
+// The trigger and the delivered text behind the `file-rewrite` row of `delivered-rules.ts`: a `Write`
+// over an existing file whose new body keeps most of the old one (joshuafolkken/kit#5284).
+//
+// **`file-edits.md`'s whole-rewrite conditions are countable, so the guard counts them.** A whole
+// rewrite is allowed for a new file and for a rebuild that shares almost nothing with the original;
+// a `Write` whose new body repeats most of the old lines is a region edit carried as a whole file, and
+// its diff cannot be read. The share is the new body's non-blank lines found in the old body, each old
+// line matched once.
+//
+// **The run's handoff is never refused**: `.josh/tmp/handoff-<N>.json` is rewritten whole by design,
+// the way `implementation-cut.ts` lets it through.
+//
+// It fires on every occurrence, for the reason `file-body.ts` does.
+
+const { WRITE, EDIT, is_edit_tool, string_field } = edit_tool
+
+// Above this share of the new body's lines kept from the old body, the `Write` is a region edit.
+// "Most" is the line `file-edits.md` draws: strictly more than half.
+const MAX_SHARED_RATIO = 0.5
+const PERCENT = 100
+const LINE_BREAK = '\n'
+
+const ISSUE_PLACEHOLDER = '<N>'
+const REGEX_SPECIALS = /[.*+?^${}()|[\]\\]/gu
+const ISSUE_DIGITS = String.raw`\d+`
+
+// The handoff path as a pattern, built from `run-cut-handoff.ts`'s single spelling of it.
+const HANDOFF_PATTERN = run_cut_handoff.HANDOFF_PATH.replaceAll(
+	REGEX_SPECIALS,
+	(special) => `\\${special}`,
+).replace(ISSUE_PLACEHOLDER, () => ISSUE_DIGITS)
+const HANDOFF = new RegExp(`(?:^|/)${HANDOFF_PATTERN}$`, 'u')
+
+function body_lines(text: string): Array<string> {
+	return text
+		.split(LINE_BREAK)
+		.map((line) => line.trim())
+		.filter((line) => line !== '')
+}
+
+function count_lines(lines: ReadonlyArray<string>): Map<string, number> {
+	const counts = new Map<string, number>()
+
+	for (const line of lines) counts.set(line, (counts.get(line) ?? 0) + 1)
+
+	return counts
+}
+
+function take_line(counts: Map<string, number>, line: string): boolean {
+	const left = counts.get(line) ?? 0
+
+	if (left === 0) return false
+	counts.set(line, left - 1)
+
+	return true
+}
+
+// The share of the new body's non-blank lines that the old body already carries, each old line
+// matched at most once; `0` for an empty new body.
+function shared_ratio(old_text: string, new_text: string): number {
+	const new_lines = body_lines(new_text)
+
+	if (new_lines.length === 0) return 0
+
+	const old_counts = count_lines(body_lines(old_text))
+	const shared = new_lines.filter((line) => take_line(old_counts, line)).length
+
+	return shared / new_lines.length
+}
+
+// The `Write` input over a path that is not the run's handoff; `undefined` for any other call.
+function write_input(call: GuardedCall): Record<string, unknown> | undefined {
+	if (call.name !== WRITE || !json_value.is_record(call.input)) return undefined
+
+	return HANDOFF.test(string_field(call.input, 'file_path')) ? undefined : call.input
+}
+
+// The file's current text, `undefined` for a new file. Injected so the suite controls it without
+// touching the real filesystem, the way `file-body.ts` injects its existence check.
+type ReadExisting = (file_path: string) => string | undefined
+
+function rewrite_ratio(call: GuardedCall, read: ReadExisting): number | undefined {
+	const input = write_input(call)
+	const old_text = input === undefined ? undefined : read(string_field(input, 'file_path'))
+
+	if (input === undefined || old_text === undefined) return undefined
+
+	return shared_ratio(old_text, string_field(input, 'content'))
+}
+
+// The trigger: a `Write` over an existing file keeping more than `MAX_SHARED_RATIO` of its lines.
+function rewrites_kept_body(
+	call: GuardedCall,
+	read: ReadExisting = file_reader.read_optional,
+): boolean {
+	return (rewrite_ratio(call, read) ?? 0) > MAX_SHARED_RATIO
+}
+
+// The occasion the rule governs: any `Edit` or `Write`. Read off the call alone, so a transcript is
+// measured without the file as it stood then.
+function reaches_file_change(call: GuardedCall): boolean {
+	return is_edit_tool(call.name)
+}
+
+// Keeping the rule: the region changed with `Edit`.
+function keeps_region_edit(call: GuardedCall): boolean {
+	return call.name === EDIT
+}
+
+const FILE_REWRITE_REASON =
+	`⛔ whole-file Write of an existing file: the new body keeps more than ${String(MAX_SHARED_RATIO * PERCENT)}% ` +
+	'of the old lines, so it is a region edit carried as a whole file and its diff cannot be read. ' +
+	'Change the region with the Edit tool; a Write stays for a new file or a rebuild sharing almost ' +
+	'nothing. This rule fires on every occurrence (`prompts/collaboration-workflow/file-edits.md`).'
+
+const ROW = {
+	id: 'file-rewrite',
+	is_trigger: (call: GuardedCall): boolean => rewrites_kept_body(call),
+	reason: FILE_REWRITE_REASON,
+	decide: (): boolean => true,
+	keeps: keeps_region_edit,
+	reaches: reaches_file_change,
+	about: {
+		title: 'No whole-file Write that keeps most of the old body',
+		topic: '`file-edits.md`',
+		fires:
+			'a `Write` over an existing file whose new body shares more than half its non-blank lines with the old one. Every occurrence',
+		quiet: "a new file, the run's handoff, a rebuild sharing half or less, or an `Edit`",
+	},
+}
+
+const file_rewrite = {
+	FILE_REWRITE_REASON,
+	MAX_SHARED_RATIO,
+	ROW,
+	rewrites_kept_body,
+	shared_ratio,
+}
+
+export { file_rewrite }

package/scripts/rules/firing-point.ts

@@ -11,8 +11,8 @@
 // **The hook-deliverable set — the single source is the list `pnpm josh rule:list` renders.** The
 // `PreToolUse` guard is wired to `Bash|Edit|Read|Write` (`scripts/hooks/pretool-guard.ts`), the
 // lane-child interactive-ask row triggers on `AskUserQuestion`, and the `agent-model` row on
-// `Agent|Task`. A firing point naming one of these can be delivered at the moment it binds; anything
-// else cannot.
+// `Agent|Task`; the `Stop` hook's `pnpm josh stop:guard` judges every finished reply. A firing point
+// naming one of these can be delivered at the moment it binds; anything else cannot.
 const HOOK_DELIVERABLE_TOOLS: ReadonlyArray<string> = [
 	'Bash',
 	'Edit',
@@ -21,6 +21,7 @@ const HOOK_DELIVERABLE_TOOLS: ReadonlyArray<string> = [
 	'AskUserQuestion',
 	'Agent',
 	'Task',
+	'Stop',
 ]
 
 // **Known Claude Code tool calls that a hook cannot deliver a rule on.** They are real tools, so a

package/scripts/rules/gh-api.ts

@@ -1,3 +1,5 @@
+import { git_argv } from './git-argv'
+
 // The one reading of a `gh api` segment shared by the rows of `delivered-rules.ts` that judge such a
 // call by its spelling: the issue-body-read guard classifies read vs write,
 // and the third-party-write guard needs the same classification plus the target `owner/repo`. Two
@@ -17,10 +19,39 @@ const GH_API_COMMAND = new RegExp(String.raw`^gh\s+${GH_FLAGS}api\s`, 'u')
 // The method override, and the field flags that turn a bare `gh api` into a POST. **All four field
 // spellings**, `-F` included — it is `--field`'s short form and reads as a different flag to a
 // pattern that only knows `-f`. A body passed with `--input <file>` counts as a write too: it carries
-// the fields inside the file.
-const API_METHOD = /(?:^|\s)(?:--method|-X)[= ]([A-Za-z]+)/u
-const API_FIELD = /(?:^|\s)(?:--raw-field|--field|--input|-F|-f)(?:[= ]|$)/u
+// the fields inside the file. A short flag also takes its value attached (`-XPUT`, `-fname=x`), as
+// `gh` accepts.
+//
+// **Read off the argv at flag positions, not the joined line**: a flag spelled inside a field value
+// (`-f 'note=a -X GET'`) is that field's value, and reading it as the method would class a POST a
+// read (joshuafolkken/kit#4650).
+const GH_COMMAND = 'gh'
+const METHOD_FLAGS: ReadonlySet<string> = new Set(['-X', '--method'])
+const ATTACHED_METHOD = /^(?:-X=?|--method=)([A-Za-z]+)$/u
+const FIELD_FLAGS: ReadonlySet<string> = new Set(['-f', '-F', '--field', '--raw-field', '--input'])
+const ATTACHED_FIELD = /^(?:-[fF].|--(?:raw-field|field|input)=)/u
+const QUOTES = /['"]/gu
+const FLAG_PREFIX = '-'
+const NEXT = 1
 const READ_METHOD = 'GET'
+// `gh api`'s flags that take a value as the next word, beside the repository selector — skipped so
+// `-X POST` or `-f body=…` is not read as the endpoint, and a value is not read as a flag.
+const API_VALUE_TAKING_FLAGS: ReadonlySet<string> = new Set([
+	'-R',
+	'--repo',
+	...METHOD_FLAGS,
+	...FIELD_FLAGS,
+	'-H',
+	'--header',
+	'-q',
+	'--jq',
+	'-t',
+	'--template',
+	'--hostname',
+	'-p',
+	'--preview',
+	'--cache',
+])
 
 // `repos/<owner>/<repo>` from an api path, with both halves captured. The path may carry a leading
 // slash, a query string, or further segments (`…/issues/5/comments`), so the owner and repo are taken
@@ -44,24 +75,111 @@ function is_gh_api(segment: string): boolean {
 	return GH_API_COMMAND.test(segment)
 }
 
+// Each flag of the call with the word after it — a word that is a value-taking flag's value is not
+// a flag itself.
+function flags_of(segment: string): Array<[string, string]> {
+	const words = git_argv.arguments_of(segment, GH_COMMAND) ?? []
+
+	return words
+		.map((word, index): [string, string] => [word, words[index + NEXT] ?? ''])
+		.filter(([word], index) => {
+			if (!word.startsWith(FLAG_PREFIX)) return false
+
+			return !API_VALUE_TAKING_FLAGS.has(words[index - NEXT] ?? '')
+		})
+}
+
+function method_value(flag: string, next: string): string | undefined {
+	if (METHOD_FLAGS.has(flag)) return next.replaceAll(QUOTES, '')
+
+	return ATTACHED_METHOD.exec(flag)?.[1]
+}
+
 // A read is a `GET` — explicit via a method flag, or implicit when no field flag makes it a POST.
-// The explicit `-X` / `--method` value, upper-cased, or `undefined` when the call names none.
+// The explicit `-X` / `--method` value, upper-cased, or `undefined` when the call names none; the
+// last one wins, as it does in `gh`.
 function method_of(segment: string): string | undefined {
-	return API_METHOD.exec(segment)?.[1]?.toUpperCase()
+	const methods = flags_of(segment).map(([flag, next]) => method_value(flag, next))
+
+	return methods.findLast((method) => method !== undefined)?.toUpperCase()
+}
+
+function is_field_flag(flag: string): boolean {
+	return FIELD_FLAGS.has(flag) || ATTACHED_FIELD.test(flag)
 }
 
 function is_read(segment: string): boolean {
 	const method = method_of(segment)
 
-	if (method !== undefined) return method.toUpperCase() === READ_METHOD
+	if (method !== undefined) return method === READ_METHOD
 
-	return !API_FIELD.test(segment)
+	return flags_of(segment).every(([flag]) => !is_field_flag(flag))
 }
 
 function is_write(segment: string): boolean {
 	return !is_read(segment)
 }
 
+// What one field flag sends: the value itself, or the file `gh` reads it from — `-F key=@<path>` and
+// `--input <path>`, standard input (`-`) excepted. `-f` / `--raw-field` sends `@<path>` as text.
+interface FieldSource {
+	kind: 'text' | 'file'
+	value: string
+}
+
+const INPUT_FLAG = '--input'
+const READS_FILE_FLAGS: ReadonlySet<string> = new Set(['-F', '--field'])
+const ATTACHED_PARTS = /^(-[fF]|--(?:raw-field|field|input))=?(.+)$/u
+const ATTACHED_FLAG_GROUP = 1
+const ATTACHED_VALUE_GROUP = 2
+const FILE_PREFIX = '@'
+const STANDARD_INPUT = '-'
+const FIELD_KEY_END = '='
+
+// The flag and its value, attached (`-fname=x`, `--input=path`) or as the next word.
+function field_parts(flag: string, next: string): [string, string] | undefined {
+	if (FIELD_FLAGS.has(flag)) return [flag, next]
+
+	const match = ATTACHED_PARTS.exec(flag)
+
+	if (match === null) return undefined
+
+	return [String(match[ATTACHED_FLAG_GROUP]), String(match[ATTACHED_VALUE_GROUP])]
+}
+
+function field_value(value: string): string {
+	return value.slice(value.indexOf(FIELD_KEY_END) + NEXT)
+}
+
+// The path a field flag has `gh` read, or `undefined` when it sends its value as text.
+function file_path(flag: string, value: string): string | undefined {
+	if (flag === INPUT_FLAG) return value
+
+	const sent = field_value(value)
+
+	if (!READS_FILE_FLAGS.has(flag) || !sent.startsWith(FILE_PREFIX)) return undefined
+
+	return sent.slice(FILE_PREFIX.length)
+}
+
+function field_source(flag: string, raw: string): FieldSource | undefined {
+	const value = raw.replaceAll(QUOTES, '')
+	const path = file_path(flag, value)
+
+	if (path === undefined) return { kind: 'text', value: field_value(value) }
+
+	return path === STANDARD_INPUT ? undefined : { kind: 'file', value: path }
+}
+
+function field_sources(segment: string): Array<FieldSource> {
+	return flags_of(segment).flatMap(([flag, next]) => {
+		const parts = field_parts(flag, next)
+		const source = parts === undefined ? undefined : field_source(...parts)
+
+		return source === undefined ? [] : [source]
+	})
+}
+
 function repo_target(segment: string): RepoTarget | undefined {
 	const match = REPO_PATH.exec(segment)
 
@@ -75,7 +193,9 @@ function is_owner_placeholder(owner: string): boolean {
 }
 
 const gh_api = {
+	API_VALUE_TAKING_FLAGS,
 	GH_FLAGS,
+	field_sources,
 	is_gh_api,
 	is_owner_placeholder,
 	is_read,
@@ -84,4 +204,5 @@ const gh_api = {
 	repo_target,
 }
 
+export type { FieldSource }
 export { gh_api }

package/scripts/rules/gh-repo-selector.ts

@@ -0,0 +1,84 @@
+import { direct_pr_create } from './direct-pr-create'
+import { git_argv } from './git-argv'
+
+// The `gh <group> <action> -R <owner>/<repo>` reading the third-party-write guard needs
+// (joshuafolkken/kit#4659). `gh pr create -R other/x` and `gh issue comment -R other/x` write to the
+// repository the selector names, so a guard that judged only `gh api`'s `repos/<owner>/` path let
+// every such write through.
+//
+// **A write unless it is a known read.** The read actions are few and stable; the write actions are
+// many and grow with `gh`. Listing the reads makes a new write subcommand refused by default instead
+// of passed by default.
+
+const GH_COMMAND = 'gh'
+const API_GROUP = 'api'
+const SELECTOR_FLAGS: ReadonlySet<string> = new Set(['-R', '--repo'])
+const ATTACHED_SELECTOR = /^(?:-R=?|--repo=)(.+)$/u
+const QUOTES = /['"]/gu
+const NEXT = 1
+// Groups that never write with a selector, whatever follows them.
+const READ_GROUPS: ReadonlySet<string> = new Set(['browse', 'search', 'status'])
+const READ_ACTIONS: ReadonlySet<string> = new Set([
+	'check',
+	'checkout',
+	'checks',
+	'clone',
+	'diff',
+	'download',
+	'get',
+	'list',
+	'status',
+	'verify',
+	'verify-asset',
+	'view',
+	'watch',
+])
+// `GH_REPO=<selector>` — inline before `gh`, or exported earlier in the line — selects the repository
+// exactly as `-R` does.
+const GH_REPO_ASSIGNMENT = /(?:^|\s)GH_REPO=(\S+)/gu
+const SELECTOR_GROUP = 1
+
+function selector_value(word: string, next: string | undefined): string | undefined {
+	if (SELECTOR_FLAGS.has(word)) return next
+
+	return ATTACHED_SELECTOR.exec(word)?.[1]
+}
+
+// Every `-R` / `--repo` value the call carries, quotes stripped. Each is a repository `gh` may send
+// the write to, so the caller judges all of them rather than guessing which one `gh` keeps.
+function selectors_of(args: ReadonlyArray<string>): Array<string> {
+	return args
+		.map((word, index) => selector_value(word, args[index + NEXT]))
+		.filter((value) => value !== undefined)
+		.map((value) => value.replaceAll(QUOTES, ''))
+}
+
+function is_write_call(args: ReadonlyArray<string>): boolean {
+	const [group = '', action = ''] = direct_pr_create.positional_words(args, SELECTOR_FLAGS)
+
+	if (group === API_GROUP || READ_GROUPS.has(group)) return false
+
+	return !READ_ACTIONS.has(action)
+}
+
+// Every `GH_REPO` value assigned in `segments` — the write's own segment and those before it.
+function assigned_selectors(segments: ReadonlyArray<string>): Array<string> {
+	return segments
+		.flatMap((segment) => [...segment.matchAll(GH_REPO_ASSIGNMENT)])
+		.map((match) => (match[SELECTOR_GROUP] ?? '').replaceAll(QUOTES, ''))
+}
+
+// The repository selectors of the `gh` write at `index` — its `-R` / `--repo` values and every
+// `GH_REPO` assigned up to it — or none when the segment is not `gh`, is a `gh api` call (judged by
+// its path), is a read, or names no selector.
+function write_selectors(segments: ReadonlyArray<string>, index: number): Array<string> {
+	const args = git_argv.arguments_of(segments[index] ?? '', GH_COMMAND)
+
+	if (args === undefined || !is_write_call(args)) return []
+
+	return [...selectors_of(args), ...assigned_selectors(segments.slice(0, index + NEXT))]
+}
+
+const gh_repo_selector = { write_selectors }
+
+export { gh_repo_selector }

package/scripts/rules/git-force.ts

@@ -15,7 +15,7 @@ import { shell_segments } from './shell-segments'
 //
 // **It fires on every occurrence, not once per run.** A force push is destructive every time it is
 // issued, so refused-once-and-free-after would put the second one back on the run's self-restraint —
-// the disposition `run-tail-rule.ts` and `filing-cap.ts` take for the same reason.
+// the disposition `run-tail-rule.ts` takes for the same reason.
 
 // A force push. The long forms all open with `--force` (`--force`, `--force-with-lease[=ref]`,
 // `--force-if-includes`); `-f` and any cluster carrying `f` are the short forms; a bare `--delete` and
@@ -84,7 +84,7 @@ const GIT_FORCE_REASON =
 
 // The row itself, so `delivered-rules.ts` spreads one entry. `decide` returns true so it refuses every
 // occurrence; it declares no `keeps` — not force-pushing is the absence of a call, not a call, so the
-// row is reported unmeasured rather than scored on an act that does not exist (`filing-cap.ts`).
+// row is reported unmeasured rather than scored on an act that does not exist.
 const ROW = {
 	id: 'git-force',
 	is_trigger: bash_triggers.on_bash_command(is_force_or_delete),

package/scripts/rules/guard-remedy.ts

@@ -28,9 +28,8 @@ const NO_RUN = "the call must not run at all, or only on a person's word — ref
 // The `Stop` rows that already run their step: each blocks only on the case the hook cannot finish.
 const STOP_NOTIFY = 'the hook sends the notify itself; it blocks only when the send fails'
 const HOLD_RELEASE = 'the hook releases the hold itself; it blocks only when that release fails'
-const ISSUE_CITATION =
-	'the hook prints the citation lines itself; it blocks only on a number it cannot cite'
 const FILING_OFFER = 'the filing needs a title and a body only the model can write'
+const CONCISE_REPLY = 'the shorter reply is prose only the model can write'
 
 function rewrite(): GuardRemedy {
 	return { remedy: 'rewrite', why: REWRITTEN }
@@ -45,29 +44,39 @@ const GUARD_REMEDIES: Readonly<Record<string, GuardRemedy>> = {
 	'piped-verification': rewrite(), // wrapped in `(set -o pipefail; …)`
 	'issue-comments': rewrite(), // the same Issue's comments read on the same line
 	'lane-background': rewrite(), // a lane child's `ship` run in the foreground (`pretool-guard.ts`)
+	'reviewer-foreground': rewrite(), // a lane child's `reviewer` given `run_in_background: false`
 	'file-body': judgment(ANOTHER_TOOL), // Edit or Write
+	'file-rewrite': judgment(ANOTHER_TOOL), // Edit
+	'sed-in-place': judgment(ANOTHER_TOOL), // Edit
 	'shell-body': judgment(
 		"which part of the body the shell was meant to expand is the author's, not the hook's",
 	),
 	'raw-field-body': judgment('the body moves to a file the call does not name'),
+	'credential-body': judgment(
+		'which text is the credential, and what replaces it, is the author’s',
+	),
 	'rule-body': judgment('a trigger-plus-pointer line is written, not derived'),
 	'direct-filing': judgment(ANOTHER_COMMAND),
 	'direct-issue-comment': judgment(ANOTHER_COMMAND),
+	'direct-issue-read': judgment(ANOTHER_COMMAND),
 	'direct-pr-create': judgment(ANOTHER_COMMAND),
 	'pr-merge': judgment(ANOTHER_COMMAND),
 	'josh-git-bare': judgment(ANOTHER_COMMAND),
 	'run-tail': judgment(ANOTHER_COMMAND),
 	'pre-gate-cut': judgment(ANOTHER_COMMAND),
 	'implementation-cut': judgment(ANOTHER_COMMAND),
+	'round-one-check-related': judgment(ANOTHER_COMMAND),
 	'early-heartbeat': judgment(ANOTHER_COMMAND),
 	'poll-loop': judgment(ANOTHER_COMMAND),
 	'lane-park': judgment(ANOTHER_COMMAND),
 	'lane-split-park': judgment(ANOTHER_COMMAND),
 	'lane-interactive-ask': judgment(ANOTHER_COMMAND),
 	'agent-model': judgment("which model fits the unit is the author's call"),
+	'investigator-foreground': judgment('which reads go beside the dispatch is the author’s call'),
 	'lane-carry-conflict': judgment(ANOTHER_COMMAND),
 	'lane-switch-main': judgment(ANOTHER_COMMAND),
-	'lane-direct-tool': judgment(ANOTHER_COMMAND),
+	'lane-direct-tool': rewrite(), // a one-command line behind `pnpm josh reserved-run <weight> --`
+	'lane-spilled-read': judgment(ANOTHER_COMMAND),
 	'timed-rerun': judgment(ANOTHER_COMMAND),
 	'oracle-consulted': judgment(ANOTHER_COMMAND),
 	'test-declared': judgment(ANOTHER_COMMAND),
@@ -78,17 +87,17 @@ const GUARD_REMEDIES: Readonly<Record<string, GuardRemedy>> = {
 	'parent-cut': judgment(ANOTHER_COMMAND),
 	'issue-watch': judgment(ANOTHER_COMMAND),
 	'third-party-write': judgment(NO_RUN),
-	'filing-cap': judgment(NO_RUN),
 	'git-force': judgment(NO_RUN),
 	'worktree-mutation': judgment(NO_RUN),
 	'index-mutation': judgment(NO_RUN),
 	'destructive-command': judgment(NO_RUN),
+	'repo-admin': judgment(NO_RUN),
 	'protected-file': judgment(NO_RUN),
 	// The `Stop` rows: the hook judges a finished reply, so it has no call to rewrite.
 	'stop-notify': judgment(STOP_NOTIFY),
-	'issue-citation': judgment(ISSUE_CITATION),
 	'filing-offer': judgment(FILING_OFFER),
 	'hold-release': judgment(HOLD_RELEASE),
+	'concise-reply': judgment(CONCISE_REPLY),
 }
 
 // A row family shares one class: `oracle-consulted:pkg:scout` is an `oracle-consulted` row.