@joshuafolkken/kit 1.1471.0 → 1.1514.0

package/scripts/notify/telegram-test.ts

@@ -112,6 +112,14 @@ async function resolve_context(values: CliValues): Promise<ResolvedContext> {
 	return { repo_name, issue_title }
 }
 
+// The send behind the command line, for a caller that already holds the values — the `Stop` hook's
+// own confirmation (`stop-actions.ts`). It throws as `telegram_notify.send` does.
+async function send_values(values: CliValues): Promise<void> {
+	const context = await resolve_context(values)
+
+	await telegram_notify.send(telegram_test_logic.build_input({ values, context }))
+}
+
 async function main(): Promise<void> {
 	josh_environment_file.load_environment_file()
 	const values = parse_cli_arguments()
@@ -122,10 +130,7 @@ async function main(): Promise<void> {
 		return
 	}
 
-	const context = await resolve_context(values)
-	const input = telegram_test_logic.build_input({ values, context })
-
-	await telegram_notify.send(input)
+	await send_values(values)
 }
 
 // **A notification nobody received must not read as success**. This command
@@ -148,6 +153,6 @@ async function run_cli(): Promise<void> {
 
 if (process.argv[1] === fileURLToPath(import.meta.url)) await run_cli()
 
-const telegram_test = { fetch_repo_name, fetch_issue_title, resolve_context, run_cli }
+const telegram_test = { fetch_repo_name, fetch_issue_title, resolve_context, run_cli, send_values }
 
 export { telegram_test }

package/scripts/report/report-format-reference.ts

@@ -8,6 +8,7 @@ const REPORT_FORMAT_PATH = 'prompts/collaboration-workflow/report-format.md'
 const SUMMARY_RULES_HEADING = '作業前サマリはいつ・どう出すか'
 const SUMMARY_TEMPLATE_HEADING = '作業前サマリ（セッション向け・`JOSH_SESSION_LANG` の言語）'
 const COMPLETION_REPORT_HEADING = '完了報告（セッション向け）'
+const ACCEPTANCE_MAP_HEADING = 'PR 本文の受け入れ条件の対応表'
 
 // The heading goes in single quotes in the runnable form: the template heading carries backticks,
 // which a double-quoted shell argument would run as a command substitution.
@@ -16,6 +17,7 @@ function pointer(heading: string): string {
 }
 
 const report_format_reference = {
+	ACCEPTANCE_MAP_HEADING,
 	COMPLETION_REPORT_HEADING,
 	pointer,
 	REPORT_FORMAT_PATH,

package/scripts/review/acceptance-map-check.ts

@@ -0,0 +1,61 @@
+import { git_gh_command } from '#scripts/gh/git-gh-command'
+import { session_cite } from '#scripts/issue/session-cite'
+import { acceptance_map, type Deferral } from './acceptance-map'
+
+// The reads behind `acceptance_map`: the Issue as it reads at the merge, the pull request body, and
+// whether each issue a deferral row names exists. Kept apart so the comparison stays pure.
+
+const ISSUE_SEPARATOR = '#'
+
+// `owner/repo#12` reads that repository's issue; a bare `#12` reads this one's.
+async function is_found(deferral: Deferral): Promise<boolean> {
+	const [repo, number = ''] = deferral.issue.split(ISSUE_SEPARATOR)
+	const read = await git_gh_command.issue_get_body_classified(
+		number,
+		repo === '' ? undefined : repo,
+	)
+
+	return read.kind === 'read'
+}
+
+async function absent_deferrals(
+	deferrals: ReadonlyArray<Deferral>,
+): Promise<ReadonlyArray<string>> {
+	const found = await Promise.all(deferrals.map(async (deferral) => await is_found(deferral)))
+
+	return deferrals
+		.filter((_deferral, index) => found[index] !== true)
+		.map((deferral) => `- \`${deferral.id}\` names ${deferral.issue}`)
+}
+
+function unreadable_message(issue: string): string {
+	return `Issue ${session_cite.issue(issue)} could not be re-read to check its acceptance criteria, so the merge is refused; re-run once it can be.`
+}
+
+// **An Issue that cannot be re-read is a refusal, not a pass** — the criteria it would have named are
+// exactly what this gate exists to see. An Issue with no acceptance section merges as before.
+// `josh ship`'s preflight asks the body it is about to deliver, so a missing table stops it before the
+// review rather than at the merge.
+async function body_refusal(
+	issue: string,
+	pr_body: string | undefined,
+): Promise<string | undefined> {
+	const issue_read = await git_gh_command.issue_get_body_classified(issue)
+
+	if (issue_read.kind !== 'read') return unreadable_message(issue)
+	const criteria = acceptance_map.criteria_of(issue_read.text)
+	const comparison = acceptance_map.compare(criteria, acceptance_map.rows_of(pr_body))
+	const absent = await absent_deferrals(comparison.deferrals)
+
+	if (comparison.missing.length === 0 && absent.length === 0) return undefined
+
+	return acceptance_map.refusal_message(issue, comparison, absent)
+}
+
+async function refusal(issue: string, branch_name: string): Promise<string | undefined> {
+	return await body_refusal(issue, await git_gh_command.pr_get_body(branch_name))
+}
+
+const acceptance_map_check = { body_refusal, refusal }
+
+export { acceptance_map_check }

package/scripts/review/acceptance-map.ts

@@ -0,0 +1,205 @@
+import { createHash } from 'node:crypto'
+import { epic_audit_logic } from '#scripts/epic/epic-audit'
+import { markdown_section } from '#scripts/issue/markdown-section'
+import { session_cite } from '#scripts/issue/session-cite'
+import { report_format_reference } from '#scripts/report/report-format-reference'
+
+// A green gate and a clean review say the diff is sound, never that it delivers what the Issue asked
+// for. **This is the seam where each acceptance criterion is checked one by one**: the pull request
+// body carries one row per criterion — met, with its evidence, or deferred to a split-off issue — and
+// `josh followup` re-reads the Issue just before the merge and refuses a criterion with no row.
+//
+// **A criterion is matched by an identifier built from its own text**, so a criterion added or
+// reworded after the body was written has an identifier no row carries, and is refused as unmapped
+// rather than passing on a stale row. The checkbox is stripped first: ticking it changes nothing.
+//
+// The criteria are read through `epic_audit_logic.acceptance_section`, the one place the acceptance
+// headings are defined.
+
+const MAP_HEADING = '## 受け入れ条件の対応'
+const MET = '満たした'
+const DEFERRED = '見送り'
+const PENDING = '未記入'
+const PENDING_SUFFIX = `— ${PENDING}`
+const ID_PREFIX = 'ac-'
+const ID_HEX_LENGTH = 8
+const BACKTICK = '`'
+// A top-level list item only: a nested item is detail under a criterion, not one of its own.
+const CRITERION_PATTERN = /^(?:[-*+]|\d+\.)\s+(?:\[[ xX]\]\s+)?(?<text>\S.*)$/u
+// A list item, heading, table row or HTML comment opens a block of its own, never a wrapped line.
+const BLOCK_START_PATTERN = /^\s*(?:(?:[-*+]|\d+\.)\s|#|\||<!--)/u
+// The criterion's text may sit between the identifier and the status for the reader, so the status is
+// the last status word on the line — a criterion quoting the row format stays text.
+const ROW_PATTERN = new RegExp(
+	String.raw`^[-*]\s+${BACKTICK}(?<id>${ID_PREFIX}[0-9a-f]{${String(ID_HEX_LENGTH)}})${BACKTICK}(?:\s.*)?\s(?<kind>${MET}|${DEFERRED}):\s*(?<rest>\S.*)$`,
+	'u',
+)
+// A deferral names the split-off issue first, then why it was deferred.
+const DEFERRAL_PATTERN = /^(?<issue>(?:[\w.-]+\/[\w.-]+)?#\d+)\s+\S/u
+const ROW_FORMAT = `under ${MAP_HEADING}, one line per acceptance criterion: \`- \`<id>\` <criterion> — ${MET}: <test name, file:line or command output>\` or \`- \`<id>\` <criterion> — ${DEFERRED}: #<split-off issue> <reason>\``
+
+interface Criterion {
+	id: string
+	text: string
+}
+
+interface Deferral {
+	id: string
+	issue: string
+}
+
+interface Row {
+	id: string
+	kind: string
+	rest: string
+}
+
+interface MapRows {
+	met: ReadonlySet<string>
+	deferrals: ReadonlyArray<Deferral>
+	ids: ReadonlySet<string>
+}
+
+interface MapComparison {
+	missing: ReadonlyArray<Criterion>
+	deferrals: ReadonlyArray<Deferral>
+	stale: ReadonlyArray<string>
+}
+
+function criterion_id(text: string): string {
+	const normalized = text.replaceAll(/\s+/gu, ' ').trim()
+	const digest = createHash('sha256').update(normalized).digest('hex')
+
+	return `${ID_PREFIX}${digest.slice(0, ID_HEX_LENGTH)}`
+}
+
+function joins(last: string | undefined, line: string): boolean {
+	const is_continuation = line.trim() !== '' && !BLOCK_START_PATTERN.test(line)
+
+	return is_continuation && last !== undefined && CRITERION_PATTERN.test(last)
+}
+
+// A criterion wrapped onto continuation lines is one criterion, hashed whole — rewording any of its
+// lines changes its identifier. A blank line or a nested item ends it.
+function unwrapped(lines: ReadonlyArray<string>): ReadonlyArray<string> {
+	const items: Array<string> = []
+
+	for (const line of lines) {
+		items.push(joins(items.at(-1), line) ? `${items.pop() ?? ''} ${line.trim()}` : line)
+	}
+
+	return items
+}
+
+function criteria_of(issue_body: string | undefined): ReadonlyArray<Criterion> {
+	// A list item inside a code fence is an example the Issue quotes, not a criterion. An indented line
+	// outside one is a wrapped criterion's continuation, so it is kept.
+	const lines = markdown_section.fence_free_lines(epic_audit_logic.acceptance_section(issue_body))
+	const texts = unwrapped(lines).map((line) => CRITERION_PATTERN.exec(line)?.groups?.['text'])
+
+	return texts
+		.filter((text): text is string => text !== undefined)
+		.map((text) => ({ id: criterion_id(text), text: text.trim() }))
+}
+
+// A deferral row with no issue or no reason is no row at all, so its criterion reads as unmapped.
+function deferral_of(id: string, rest: string): Deferral | undefined {
+	const issue = DEFERRAL_PATTERN.exec(rest)?.groups?.['issue']
+
+	return issue === undefined ? undefined : { id, issue }
+}
+
+// Every group in `ROW_PATTERN` is mandatory, so a match always carries the name.
+function group(groups: Readonly<Record<string, string>>, name: string): string {
+	return groups[name] ?? ''
+}
+
+// A pending row is no row even when the criterion it quotes carries a status word — otherwise the
+// skeleton's own unfilled row would read as met.
+function row_of(line: string): Row | undefined {
+	const trimmed = line.trim()
+
+	if (trimmed.endsWith(PENDING_SUFFIX)) return undefined
+	const groups = ROW_PATTERN.exec(trimmed)?.groups
+
+	if (groups === undefined) return undefined
+
+	return { id: group(groups, 'id'), kind: group(groups, 'kind'), rest: group(groups, 'rest') }
+}
+
+function rows_of(pr_body = ''): MapRows {
+	const rows = markdown_section
+		.section_lines(pr_body, MAP_HEADING)
+		.map((line) => row_of(line))
+		.filter((row): row is Row => row !== undefined)
+	const met = rows.filter((row) => row.kind === MET).map((row) => row.id)
+	const deferrals = rows
+		.filter((row) => row.kind === DEFERRED)
+		.map((row) => deferral_of(row.id, row.rest))
+		.filter((deferral): deferral is Deferral => deferral !== undefined)
+
+	return { met: new Set(met), deferrals, ids: new Set([...met, ...deferrals.map((row) => row.id)]) }
+}
+
+function compare(criteria: ReadonlyArray<Criterion>, rows: MapRows): MapComparison {
+	const current = new Set(criteria.map((criterion) => criterion.id))
+
+	return {
+		missing: criteria.filter((criterion) => !rows.ids.has(criterion.id)),
+		deferrals: rows.deferrals.filter((deferral) => current.has(deferral.id)),
+		stale: [...rows.ids].filter((id) => !current.has(id)),
+	}
+}
+
+// What `josh pr` writes when the caller's body carries no table: every criterion as a pending row,
+// which the merge refuses until it is filled in.
+function skeleton(issue_body: string | undefined): string | undefined {
+	const criteria = criteria_of(issue_body)
+
+	if (criteria.length === 0) return undefined
+	const rows = criteria.map(
+		(criterion) => `- \`${criterion.id}\` ${criterion.text} ${PENDING_SUFFIX}`,
+	)
+
+	return [MAP_HEADING, '', ...rows].join('\n')
+}
+
+function has_map(pr_body = ''): boolean {
+	return markdown_section.has_unfenced_line(pr_body, MAP_HEADING)
+}
+
+function listed(title: string, lines: ReadonlyArray<string>): ReadonlyArray<string> {
+	return lines.length === 0 ? [] : [title, ...lines.map((line) => `  ${line}`)]
+}
+
+function refusal_message(
+	issue: string,
+	comparison: MapComparison,
+	absent: ReadonlyArray<string>,
+): string {
+	return [
+		`The pull request body does not map every acceptance criterion of ${session_cite.issue(issue)} as it reads now, so the merge is refused.`,
+		...listed(
+			'Criteria with no row (added or reworded since the body was written, or never mapped):',
+			comparison.missing.map((criterion) => `- \`${criterion.id}\` ${criterion.text}`),
+		),
+		...listed('Deferral rows naming an issue that could not be found:', absent),
+		...listed('Rows naming no current criterion:', comparison.stale),
+		`Write ${ROW_FORMAT} — format: ${report_format_reference.pointer(report_format_reference.ACCEPTANCE_MAP_HEADING)}`,
+		'Write it into the `--body-file` before `josh ship`, or update an open PR with `gh api -X PATCH repos/{owner}/{repo}/pulls/<N> -F body=@<path>`, then re-run.',
+	].join('\n')
+}
+
+const acceptance_map = {
+	MAP_HEADING,
+	compare,
+	criteria_of,
+	criterion_id,
+	has_map,
+	refusal_message,
+	rows_of,
+	skeleton,
+}
+
+export type { Criterion, Deferral, MapComparison }
+export { acceptance_map }

package/scripts/review/review-brief-cli.ts

@@ -330,7 +330,7 @@ async function run_review(round: number, reading: ChangeReading): Promise<number
 	const refusal = scoped_green.refusal_for(tree, commit)
 
 	if (refusal !== undefined) return report_error(refusal)
-	const resolved = agent_role_profile.resolve(agent_role_profile.REVIEWER)
+	const resolved = agent_role_profile.resolve_review(round)
 
 	if (resolved.kind === 'rejected') return report_error(resolved.note)
 	agent_role_profile.warn_of_default()

package/scripts/rules/agent-model.ts

@@ -0,0 +1,59 @@
+import { json_value } from '#scripts/lib/json-value'
+import type { GuardedCall } from '#scripts/time-runtime/time-batch-guard'
+
+// A `general-purpose` subagent dispatched without a `model` is refused until it names one
+// (joshuafolkken/kit#3927).
+//
+// **The omission is the cost, not the dispatch.** A subagent with no `model` inherits the parent's,
+// so a routine unit runs on the main line's model — measured at 94 such dispatches on Opus. A named
+// agent type carries its own `model` in its definition, so only the catch-all type is in scope; an
+// absent `subagent_type` is that type, the harness's default.
+//
+// **It fires on every occurrence**: the remedy is one field on the same call, so a refusal costs one
+// round trip and never wedges the run.
+
+// Both spellings of the subagent tool are in use: `Task` (published) and `Agent` (this harness).
+const SUBAGENT_TOOLS: ReadonlySet<string> = new Set(['Agent', 'Task'])
+const GENERAL_PURPOSE = 'general-purpose'
+
+// A dispatch of the catch-all type — the one whose model is otherwise inherited.
+function is_general_purpose(call: GuardedCall): boolean {
+	if (!SUBAGENT_TOOLS.has(call.name) || !json_value.is_record(call.input)) return false
+
+	const type = call.input['subagent_type']
+
+	return type === undefined || type === GENERAL_PURPOSE
+}
+
+function names_model(call: GuardedCall): boolean {
+	const model = json_value.is_record(call.input) ? call.input['model'] : undefined
+
+	return typeof model === 'string' && model.length > 0
+}
+
+function is_unnamed_model(call: GuardedCall): boolean {
+	return is_general_purpose(call) && !names_model(call)
+}
+
+function keeps_model(call: GuardedCall): boolean {
+	return is_general_purpose(call) && names_model(call)
+}
+
+const AGENT_MODEL_REASON =
+	'⛔ agent model: a `general-purpose` subagent with no `model` inherits the parent model. ' +
+	'Reissue the call with `model` set — `sonnet` for routine work, `opus` for judgment such as a review. ' +
+	'It fires on every occurrence (`.claude/skills/workflow-commands/delegation.md`).'
+
+// `reaches` is every catch-all dispatch, so `rule-value.ts` scores the named-model ones against it.
+const ROW = {
+	id: 'agent-model',
+	is_trigger: is_unnamed_model,
+	reason: AGENT_MODEL_REASON,
+	decide: (): boolean => true,
+	keeps: keeps_model,
+	reaches: is_general_purpose,
+}
+
+const agent_model = { AGENT_MODEL_REASON, ROW, is_unnamed_model }
+
+export { agent_model }

package/scripts/rules/delivered-rules.ts

@@ -2,6 +2,7 @@ import { investigation_reads } from '#scripts/delegation/investigation-reads'
 import { hook_decision, type GuardRun, type TranscriptGuardSpec } from '#scripts/josh/hook-decision'
 import { lane_guard_policy } from '#scripts/lane/lane-guard-policy'
 import { time_batch_guard, type GuardedCall } from '#scripts/time-runtime/time-batch-guard'
+import { agent_model } from './agent-model'
 import { bash_triggers } from './bash-triggers'
 import { direct_filing } from './direct-filing'
 import { early_heartbeat } from './early-heartbeat'
@@ -46,6 +47,9 @@ type CallTest = (
 	run: ReadonlyArray<GuardedCall>,
 ) => boolean
 
+// The tail is read lazily: most calls no rewrite applies to never need it.
+type CallRewrite = (call: GuardedCall, tail: () => string) => Record<string, unknown> | undefined
+
 // `id` keys the rule's own refusal record, so one rule firing never spends another's budget.
 interface DeliveredRule {
 	id: string
@@ -63,6 +67,9 @@ interface DeliveredRule {
 	// The occasion the rule governs, for a row whose trigger is the violation itself (else `is_trigger`
 	// would only count runs that broke it).
 	reaches?: CallTest
+	// The call made right, for a row `guard-remedy.ts` classes as a rewrite: `rule-rewrite.ts` runs it
+	// in place of the refusal. `undefined` where this call has no mechanical fix, so it is refused.
+	rewrite?: CallRewrite
 	// The note a hook attaches where it rewrites a violating call instead of refusing it, so
 	// `rule-value.ts` counts the rewrite as this row's delivery.
 	rewrite_note?: string
@@ -107,7 +114,8 @@ const DELIVERED_RULES: ReadonlyArray<DeliveredRule> = [
 		reason: piped_verification.PIPED_VERIFICATION_REASON,
 		keeps: on_bash_command(piped_verification.keeps_verdict_intact),
 		reaches: on_bash_command(piped_verification.runs_verification),
-		// A `| tail` / `| grep` masking is rewritten under `pipefail` by `pretool-guard.ts`, never refused.
+		// A masking whose filter reads to the end is rewritten under `pipefail`, never refused.
+		rewrite: piped_verification.pipefail_input,
 		rewrite_note: piped_verification.PIPEFAIL_NOTE,
 	},
 	{
@@ -146,6 +154,7 @@ const DELIVERED_RULES: ReadonlyArray<DeliveredRule> = [
 	lane_split_park.ROW,
 	lane_park.ROW,
 	lane_interactive_ask.ROW,
+	agent_model.ROW,
 	lane_carry_conflict.ROW,
 	lane_switch_main.ROW,
 	// Disjoint from `run-tail` by the `-y` flag.
@@ -304,5 +313,5 @@ const delivered_rules = {
 	is_issue_filing,
 }
 
-export type { DeliveredRule, MeasuredRule }
+export type { CallRewrite, DeliveredRule, MeasuredRule }
 export { delivered_rules }

package/scripts/rules/filing-cap.ts

@@ -123,6 +123,7 @@ const filing_cap = {
 	FILING_CAP,
 	FILING_CAP_REASON,
 	ROW,
+	current_turn,
 	is_prompt_line,
 	prior_filing_count,
 	turn_filing_count,

package/scripts/rules/firing-point.ts

@@ -9,15 +9,18 @@
 // time is the whole point of the check.
 
 // **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`), and the
-// lane-child interactive-ask row triggers on `AskUserQuestion`. A firing point naming one of these can
-// be delivered at the moment it binds; anything else cannot.
+// `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.
 const HOOK_DELIVERABLE_TOOLS: ReadonlyArray<string> = [
 	'Bash',
 	'Edit',
 	'Read',
 	'Write',
 	'AskUserQuestion',
+	'Agent',
+	'Task',
 ]
 
 // **Known Claude Code tool calls that a hook cannot deliver a rule on.** They are real tools, so a
@@ -31,8 +34,6 @@ const KNOWN_UNDELIVERABLE_TOOLS: ReadonlyArray<string> = [
 	'WebFetch',
 	'WebSearch',
 	'TodoWrite',
-	'Task',
-	'Agent',
 	'NotebookEdit',
 ]
 

package/scripts/rules/guard-remedy.ts

@@ -0,0 +1,117 @@
+// Every `PreToolUse` and `Stop` guard, classed by what its refusal asks for (joshuafolkken/kit#3920),
+// with the reason it cannot run itself instead.
+//
+// **A refusal whose right form follows from the call alone is a wasted round trip.** The model reissues
+// the call the refusal already described, at the run's whole context. Where that form is mechanical
+// and stays the same tool, the hook runs it instead (`rule-rewrite.ts`) and says what it changed. Every
+// other refusal asks for something the call does not carry: another tool, another command and its
+// arguments, or a decision.
+//
+// `rewrite` means the row rewrites where it can and refuses where it cannot; `judgment` means it always
+// refuses. **`why` is required**: a guard is the third rung of `principles.md` → "automate-first", so
+// each row says why a command or the hook running the step cannot replace it. `guard-remedy.test.ts`
+// pins that every guard is classed with a non-empty `why` and that each `rewrite` row has one.
+
+type Remedy = 'rewrite' | 'judgment'
+
+interface GuardRemedy {
+	remedy: Remedy
+	// Why the hook cannot make the step itself — printed by `rule:list` as `not automated`.
+	why: string
+}
+
+const REWRITTEN =
+	'the hook makes the same call right itself; it refuses only a spelling it cannot rewrite'
+const ANOTHER_TOOL = 'the right form is another tool, which `updatedInput` cannot switch to'
+const ANOTHER_COMMAND = 'the right act is another command, whose arguments the call does not carry'
+const NO_RUN = "the call must not run at all, or only on a person's word — refusing is the remedy"
+// 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'
+
+function rewrite(): GuardRemedy {
+	return { remedy: 'rewrite', why: REWRITTEN }
+}
+
+function judgment(why: string): GuardRemedy {
+	return { remedy: 'judgment', why }
+}
+
+const GUARD_REMEDIES: Readonly<Record<string, GuardRemedy>> = {
+	// The rewrites: each fix is the same call made right.
+	'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`)
+	'file-body': judgment(ANOTHER_TOOL), // Edit or Write
+	'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'),
+	'rule-body': judgment('a trigger-plus-pointer line is written, not derived'),
+	'direct-filing': judgment(ANOTHER_COMMAND),
+	'direct-pr-create': 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),
+	'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"),
+	'lane-carry-conflict': judgment(ANOTHER_COMMAND),
+	'lane-switch-main': judgment(ANOTHER_COMMAND),
+	'oracle-consulted': judgment(ANOTHER_COMMAND),
+	'test-declared': judgment(ANOTHER_COMMAND),
+	batching: judgment(ANOTHER_COMMAND),
+	investigation: judgment(ANOTHER_COMMAND),
+	'duplicate-read': judgment(ANOTHER_COMMAND),
+	'run-watcher': judgment(ANOTHER_COMMAND),
+	'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),
+	'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),
+}
+
+// A row family shares one class: `oracle-consulted:pkg:scout` is an `oracle-consulted` row.
+const FAMILY_SEPARATOR = ':'
+
+function entry_of(id: string): GuardRemedy | undefined {
+	return GUARD_REMEDIES[id] ?? GUARD_REMEDIES[id.split(FAMILY_SEPARATOR)[0] ?? '']
+}
+
+function remedy_of(id: string): Remedy | undefined {
+	return entry_of(id)?.remedy
+}
+
+function why_of(id: string): string | undefined {
+	return entry_of(id)?.why
+}
+
+function is_rewrite(id: string): boolean {
+	return remedy_of(id) === 'rewrite'
+}
+
+const guard_remedy = {
+	GUARD_REMEDIES,
+	is_rewrite,
+	remedy_of,
+	why_of,
+}
+
+export type { GuardRemedy, Remedy }
+export { guard_remedy }