@joshuafolkken/kit 1.1229.0 → 1.1370.0

package/scripts/rules/rule-registry-rows.ts

@@ -0,0 +1,282 @@
+// The `pnpm josh rule:guard` rows of the rule registry (`rule-registry.ts`), split out by size: the
+// human-readable side of each `delivered-rules.ts` row, keyed by the row's `id`.
+
+interface RegisteredRule {
+	id: string
+	title: string
+	// The single source of the rule's procedure.
+	topic: string
+	// The hook command that delivers it.
+	entry: string
+	fires: string
+	// The silent turn — it matches the state in which the rule is already kept.
+	quiet: string
+}
+
+const RULE_GUARD = 'pnpm josh rule:guard'
+const OPERATING_RULES = '`operating-rules.md`'
+const PRE_GATE_CUT = '`.claude/skills/workflow-commands/pre-gate-cut.md`'
+const SHELL_BODY = '`shell-body.md`'
+const BACKGROUND_COMMANDS = '`.claude/skills/workflow-commands/background-commands.md`'
+const BACKLOGRUN_LANES = '`.claude/skills/workflow-commands/backlogrun-lanes.md`'
+const GIT_RULES = '`CLAUDE.md` → Git Rules'
+
+const GUARD_ROWS: ReadonlyArray<RegisteredRule> = [
+	{
+		id: 'third-party-write',
+		title: 'Third-party write',
+		topic: '`upstream-interrupt.md`',
+		entry: RULE_GUARD,
+		fires:
+			'a `gh api` write (field flag or a write method) to a repository whose owner is not this session. Every occurrence',
+		quiet: 'a read, or a first-party owner (`pnpm josh repo:party`)',
+	},
+	{
+		id: 'direct-filing',
+		title: 'Direct filing',
+		topic: '`docs/josh-commands-backlog.md` → `josh issue:file`',
+		entry: RULE_GUARD,
+		fires:
+			'a `Bash` that creates an Issue outside `josh issue:file` (`gh issue create`, or a POST with `title` to `…/issues`); the refusal hands over the `pnpm josh issue:file` form. Every occurrence',
+		quiet:
+			'filing through `pnpm josh issue:file` — the duplicate scan, the body check and `epic:bundle` all run',
+	},
+	{
+		id: 'filing-cap',
+		title: 'The 10-Issue filing cap per run',
+		topic: '`.claude/skills/workflow-commands/prerequisite.md`, `observation-filing.md`',
+		entry: RULE_GUARD,
+		fires:
+			'the 11th `pnpm josh issue:file` in a run that already has 10 filings not refused; failed calls do not count. Every occurrence',
+		quiet: 'fewer than 10 filings not refused',
+	},
+	{
+		id: 'issue-comments',
+		title: 'Reading Issue comments',
+		topic: '`issue-comments.md`',
+		entry: RULE_GUARD,
+		fires:
+			'a `Bash` that reads only the Issue body (`gh issue view <N>`, or a GET ending in `…/issues/<N>`). Refused until it is re-read with the comments',
+		quiet:
+			'no Issue read, or a read with `--comments` / `--json comments` / `…/comments` from the start',
+	},
+	{
+		id: 'shell-body',
+		title: 'No body on the shell',
+		topic: SHELL_BODY,
+		entry: RULE_GUARD,
+		fires:
+			'a double-quoted body value (`-f body="…"` / `-f "body=…"` / `--body "…"` / `--notify-message "…"`) carrying a backtick or `$`',
+		quiet: 'the shell does not evaluate the body',
+	},
+	{
+		id: 'raw-field-body',
+		title: 'Posting `@path` literally',
+		topic: SHELL_BODY,
+		entry: RULE_GUARD,
+		fires: 'a raw field (`-f` / `--raw-field`) passing `body=@<path>`. Every occurrence',
+		quiet: '`-F` / `--field body=@`, a body without `@`, or `pnpm josh issue:comment`',
+	},
+	{
+		id: 'piped-verification',
+		title: 'Piped verification',
+		topic: '`output-bounds.md`',
+		entry: RULE_GUARD,
+		fires:
+			'a pass/fail josh check (`gate` / `check` / `lint*` / `cspell*` / `test*` / `eval` / `overrides` / `ranges`) in front of a pipe — rewritten under `set -o pipefail` when every filter is `tail` or a full-reading `grep`, refused otherwise',
+		quiet: 'the exit code reaches the caller — a failure reads as a failure',
+	},
+	{
+		id: 'early-heartbeat',
+		title: 'Early progress report',
+		topic:
+			'`.claude/skills/workflow-commands/progress-watcher.md` → "Progress while the run is quiet"',
+		entry: RULE_GUARD,
+		fires:
+			'a `Bash` whose only purpose is waiting (`sleep` alone, or `echo` / `:` / `date`) while a timer is live or before the interval. Every occurrence',
+		quiet: 'no hand-made wait timer — `run:progress` holds the one clock',
+	},
+	{
+		id: 'test-declared',
+		title: 'Test declaration',
+		topic: '`CLAUDE.md` → Code Change Rules',
+		entry: RULE_GUARD,
+		fires: '`pnpm josh git -y` (`josh g`) while `pnpm josh test:declared` answers `required`',
+		quiet: '`exempt` (non-runtime only) or `satisfied` (tests included)',
+	},
+	{
+		id: 'lane-background',
+		title: 'Lane child background push',
+		topic: BACKGROUND_COMMANDS,
+		entry: RULE_GUARD,
+		fires:
+			'a dispatched lane child backgrounding `josh gate` / `git` / `followup` / `ship`; it hands over `pnpm josh ship --detach`. Every occurrence',
+		quiet: 'not a lane child, or the foreground `ship --detach`',
+	},
+	{
+		id: 'run-tail',
+		title: 'Idle run tail',
+		topic: BACKGROUND_COMMANDS,
+		entry: RULE_GUARD,
+		fires:
+			'`pnpm josh git -y` (`josh g`, `--yes` alike) issued in the **foreground**. Every occurrence',
+		quiet: 'issued in the background — its completion resumes the run',
+	},
+	{
+		id: 'pre-gate-cut',
+		title: 'The cut before the gate',
+		topic: PRE_GATE_CUT,
+		entry: RULE_GUARD,
+		fires:
+			'`pnpm josh gate` (`josh ga`) in a lane work tree whose `JOSH_LANE_CHILD` names the Issue and has no cut record',
+		quiet: 'outside a lane, no marker (a person in the lane), or already cut',
+	},
+	{
+		id: 'lane-split-park',
+		title: 'A split is not a park',
+		topic: '`.claude/skills/workflow-commands/backlogrun-park.md` → "Splitting a child mid-run"',
+		entry: RULE_GUARD,
+		fires:
+			'a lane child that promoted its Issue to an epic this run parking it (`needs-decision`, `confirmation` notify). Every occurrence',
+		quiet: 'no promotion this run',
+	},
+	{
+		id: 'lane-park',
+		title: 'Lane child park',
+		topic: PRE_GATE_CUT,
+		entry: RULE_GUARD,
+		fires: 'a dispatched lane child issuing `pnpm josh notify --task-type confirmation`',
+		quiet: 'not a lane child, or not a stop notification',
+	},
+	{
+		id: 'lane-interactive-ask',
+		title: 'Lane child interactive ask',
+		topic: `${PRE_GATE_CUT} → "The interactive ask is refused one call earlier"`,
+		entry: RULE_GUARD,
+		fires:
+			"a dispatched lane child's `AskUserQuestion`; it hands over the park procedure. Every occurrence",
+		quiet: 'not a lane child, or not an interactive tool',
+	},
+	{
+		id: 'lane-carry-conflict',
+		title: 'Lane child carry commands',
+		topic: BACKLOGRUN_LANES,
+		entry: RULE_GUARD,
+		fires: 'a dispatched lane child running `pnpm josh run:merge` / `run:carry`. Every occurrence',
+		quiet: 'not a lane child — the parent owns the run budget',
+	},
+	{
+		id: 'lane-switch-main',
+		title: 'Lane child on `git switch main`',
+		topic: BACKLOGRUN_LANES,
+		entry: RULE_GUARD,
+		fires:
+			'a dispatched lane child switching to the default branch or running `josh main:sync`. Every occurrence',
+		quiet: 'not a lane child — `pnpm josh main:merge` brings the default in at the gate',
+	},
+	{
+		id: 'josh-git-bare',
+		title: 'Bare `pnpm josh git`',
+		topic: GIT_RULES,
+		entry: RULE_GUARD,
+		fires:
+			'`pnpm josh git` without `-y`, whose staging prompt cancels with no TTY. Every occurrence',
+		quiet: '`pnpm josh git -y`',
+	},
+	{
+		id: 'git-force',
+		title: 'Force push / branch delete',
+		topic: OPERATING_RULES,
+		entry: RULE_GUARD,
+		fires:
+			'a `git push` / `git branch` read as force (`--force` / `-f` / `-uf` …) or delete (`--delete` / `-d` / `-D` / `:branch`) in any spelling. Every occurrence',
+		quiet: 'a plain `git push` / `git branch`',
+	},
+	{
+		id: 'worktree-mutation',
+		title: 'Unauthorized work-tree mutation',
+		topic: OPERATING_RULES,
+		entry: RULE_GUARD,
+		fires:
+			'`git checkout -- <path>` / `git restore <path>` / forced `git clean -f` / an unauthorized `git stash` (bare, push without a message, positional pop). Every occurrence',
+		quiet: '`git stash push -m`, `git stash list`, `pnpm josh git`, `pnpm josh stash:pop`',
+	},
+	{
+		id: 'file-body',
+		title: 'No file body on the shell',
+		topic: '`file-edits.md`',
+		entry: RULE_GUARD,
+		fires:
+			'a heredoc write to an existing file, a writing `node -e` / interpreter heredoc, or `perl -0pi -e`. Every occurrence',
+		quiet: 'a new file, a read-only heredoc, or a short `sed -i`',
+	},
+	{
+		id: 'index-mutation',
+		title: 'Index mutation',
+		topic: OPERATING_RULES,
+		entry: RULE_GUARD,
+		fires:
+			'`git add` / `commit` / `reset` / `rm` / `mv` / `restore --staged` in any spelling. Every occurrence',
+		quiet: '`pnpm josh git` — the approved commit flow',
+	},
+	{
+		id: 'destructive-command',
+		title: 'Destructive command',
+		topic: OPERATING_RULES,
+		entry: RULE_GUARD,
+		fires:
+			'`rm -rf` (any spelling), `gh repo delete` / `archive`, `gh pr close`, `gh api -X DELETE`. Every occurrence',
+		quiet: "`gh issue close` or removing an Issue label — the workflow's own steps",
+	},
+	{
+		id: 'protected-file',
+		title: 'Protected file',
+		topic: OPERATING_RULES,
+		entry: RULE_GUARD,
+		fires:
+			'a `Read` of `.env`, or an `Edit` / `Write` of `.claude/settings.json` outside kit. Every occurrence',
+		quiet: "kit itself, or the user's `~/.claude/settings.json`",
+	},
+	{
+		id: 'direct-pr-create',
+		title: 'Direct PR creation',
+		topic: GIT_RULES,
+		entry: RULE_GUARD,
+		fires:
+			'`gh pr create`, or a `gh api` write to `repos/<o>/<r>/pulls`; it points at `pnpm josh pr`. Every occurrence',
+		quiet: '`pnpm josh pr`, or reading a PR — the path that writes `closes #N`',
+	},
+	{
+		id: 'poll-loop',
+		title: 'Output poll loop',
+		topic: BACKGROUND_COMMANDS,
+		entry: RULE_GUARD,
+		fires:
+			"a hand-written `while` / `until` wait loop over a command's output, a marker file or a process. Every occurrence",
+		quiet: 'the command started with `run_in_background` — its exit ends the wait',
+	},
+	{
+		id: 'implementation-cut',
+		title: 'The implementation-phase cut',
+		topic: `${PRE_GATE_CUT} → "It is a guard, fired at the edit that crosses the threshold"`,
+		entry: RULE_GUARD,
+		fires:
+			'an `Edit` / `Write` by an uncut lane child whose recent context is over the `pnpm josh cost --cut` threshold; it hands over `pnpm josh run:cut --impl <N> --handoff <path>`. At each threshold crossing',
+		quiet: 'not a lane child, a non-editing tool, already cut, or under the threshold',
+	},
+	{
+		id: 'rule-body',
+		title: 'Question 0 and the ordering question before writing a rule into prose',
+		topic: '`residency.md`',
+		entry: RULE_GUARD,
+		fires:
+			'an `Edit` / `Write` to `CLAUDE.md` / `prompts/**/*.md` / `.claude/skills/**/*.md` appending at least the threshold. Refused until both `pnpm josh oracle:list` and `pnpm josh run:step` ran',
+		quiet:
+			'not a rule document, an append under the threshold (typo, link swap, deletion), or both commands ran',
+	},
+]
+
+const rule_registry_rows = { GUARD_ROWS, RULE_GUARD }
+
+export type { RegisteredRule }
+export { rule_registry_rows }

package/scripts/rules/rule-registry.ts

@@ -0,0 +1,109 @@
+import { rule_registry_rows, type RegisteredRule } from './rule-registry-rows'
+
+// The human-readable side of every trigger-delivered rule, keyed by the `id` its guard row carries.
+// `prompts/collaboration-workflow/rule-delivery.md` used to hold this list
+// as a hand copy of `delivered-rules.ts`; `pnpm josh rule:list` now renders it from here, and
+// `rule-list.test.ts` pins that every row of `MEASURED_RULES` has an entry and no entry is orphaned.
+//
+// A hookless agent reads the rendered list as a self-applied checklist (`principles.md`). An entry
+// with no frequency in `fires` is delivered once per run; "every occurrence" fires each time, "until"
+// refuses until a prerequisite is on the transcript, and "again" re-fires after an interval.
+
+const { GUARD_ROWS, RULE_GUARD } = rule_registry_rows
+const STOP_GUARD = 'pnpm josh stop:guard'
+
+// The oracle rows share one entry: each `oracle-consulted:<name>` id is generated per oracle.
+const ORACLE_PREFIX = 'oracle-consulted'
+
+const MEASURED_ROWS: ReadonlyArray<RegisteredRule> = [
+	{
+		id: ORACLE_PREFIX,
+		title: 'An act its oracle was not asked about',
+		topic: '`decision-oracle.ts`',
+		entry: RULE_GUARD,
+		fires:
+			'a `Bash` governed by an oracle that declared a firing point (`pkg:scout` governs `pnpm add`), issued without that `pnpm josh <command>`. Refused until it ran',
+		quiet: 'no governed act, or the oracle already ran',
+	},
+	{
+		id: 'batching',
+		title: 'Turn batching',
+		topic: '`turn-batching.md`',
+		entry: 'pnpm josh batch:guard',
+		fires:
+			'the `Bash` / `Edit` / `Read` after three single-call turns in a row; fires **again** every three more such turns',
+		quiet: 'calls per round trip above the floor',
+	},
+	{
+		id: 'investigation',
+		title: 'Investigation delegation threshold',
+		topic: '`delegation.md`',
+		entry: 'pnpm josh investigation:guard',
+		fires:
+			'the `Read` / `Bash` that makes the third read of a file the run will not edit; fires **again** once reads pile up to the threshold again',
+		quiet: 'reads under the threshold — nothing to delegate yet',
+	},
+]
+
+// The `Stop` hook's rows; `stop:guard` judges every stop, so each blocks the stop while it holds.
+const STOP_ROWS: ReadonlyArray<RegisteredRule> = [
+	{
+		id: 'stop-notify',
+		title: 'Stop notification',
+		topic: '`CLAUDE.md` → "Mid-workflow stop notification"',
+		entry: STOP_GUARD,
+		fires: 'a stop with the work tree held and no `confirmation` notify that turn. Blocks the stop',
+		quiet: 'no hold, a `confirmation` notify on the tail, or a pre-gate cut taken',
+	},
+	{
+		id: 'hold-release',
+		title: 'Hold release',
+		topic: '`.claude/skills/workflow-commands/working-tree-hold.md`',
+		entry: STOP_GUARD,
+		fires: 'a stop on a clean tree with the `run:hold` record still in place. Blocks the stop',
+		quiet:
+			'a dirty tree (a `halfrun` stop before the commit, a `needs-human-review` stop) or already released',
+	},
+	{
+		id: 'issue-citation',
+		title: 'Issue citation format',
+		topic: '`prompts/collaboration-workflow/issue-citation.md`',
+		entry: STOP_GUARD,
+		fires:
+			'a bare `#N` in the prose of the last reply. Blocks the stop until the reply is reissued with the citation fixed',
+		quiet: 'link form, inside code or a quote, `#N` right after `PR`, or a GitHub-facing artifact',
+	},
+	{
+		id: 'filing-offer',
+		title: 'Offer to file',
+		topic: '`.claude/skills/workflow-commands/observation-filing.md`',
+		entry: STOP_GUARD,
+		fires:
+			'an unattended run (a kit-launched headless session, a lane child, a `backlogrun` parent) whose last reply offers to file without filing. Blocks the stop',
+		quiet:
+			'an interactive session, already filed, inside a fence or quote, a named third-party `owner/repo`, or an unknown owner',
+	},
+]
+
+const REGISTERED_RULES: ReadonlyArray<RegisteredRule> = [
+	...GUARD_ROWS,
+	...MEASURED_ROWS,
+	...STOP_ROWS,
+]
+
+// A guard row's id, with a generated oracle id read as the one oracle entry.
+function registry_id(row_id: string): string {
+	return row_id.startsWith(`${ORACLE_PREFIX}:`) ? ORACLE_PREFIX : row_id
+}
+
+function entry_for(row_id: string): RegisteredRule | undefined {
+	const id = registry_id(row_id)
+
+	return REGISTERED_RULES.find((rule) => rule.id === id)
+}
+
+const rule_registry = { REGISTERED_RULES, STOP_ROWS, entry_for, registry_id }
+
+export { rule_registry }
+
+export { type RegisteredRule } from './rule-registry-rows'

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

@@ -3,8 +3,8 @@ import { mkdirSync, renameSync, statSync, writeFileSync } from 'node:fs'
 import path from 'node:path'
 import { file_reader } from '#scripts/lib/read-file'
 
-// The `rule:value` reading at the `backlogrun` loop head, without the loop waiting on it
-// (joshuafolkken/kit#2881). Measuring re-reads every transcript and takes minutes, and `backlog:offer`
+// The `rule:value` reading at the `backlogrun` loop head, without the loop waiting on it.
+// Measuring re-reads every transcript and takes minutes, and `backlog:offer`
 // ran it synchronously on every iteration, so each dispatch waited on it. The loop head now prints the
 // last reading from a cache and, when the last refresh is old enough, starts one in a detached process
 // — `josh rule:value --refresh` — so the next iteration prints the newer reading.

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

@@ -5,8 +5,8 @@ import { delivered_rules } from './delivered-rules'
 import { rule_value, type RuleReading } from './rule-value'
 import { rule_value_cache } from './rule-value-cache'
 
-// `josh rule:value` — what each delivered rule earns on the channel that carries it, one row per rule
-// (joshuafolkken/kit#2271). `rule_value.measure` was public but had no caller outside its own test, so
+// `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
 // a rule that never fired stayed invisible until a person thought to measure it. This is that caller:
 // it groups every transcript by the run it belongs to — a lane's transcript counted with the parent
 // that dispatched it — measures them, and prints the reading.
@@ -86,8 +86,10 @@ function row(reading: RuleReading): 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()}`] : []
 
-	return [id, reached, rate_text(reading), refused].join(COLUMN_GAP)
+	return [id, reached, rate_text(reading), refused, ...rewritten].join(COLUMN_GAP)
 }
 
 // The reading as text, or `NO_TARGETS` when nothing measurable was found — never an empty output that
@@ -102,7 +104,7 @@ function render(runs: ReadonlyArray<ReadonlyArray<string>>): string {
 }
 
 // `--refresh` is the detached measurement the `backlogrun` loop head starts: the reading goes to the
-// cache `backlog:offer` prints from, never to stdout (`rule-value-cache.ts`, joshuafolkken/kit#2881).
+// cache `backlog:offer` prints from, never to stdout (`rule-value-cache.ts`).
 function run_rule_value(argv: ReadonlyArray<string> = [], cwd: string = process.cwd()): number {
 	const reading = render(gather_runs(cwd))
 

package/scripts/rules/rule-value.ts

@@ -4,13 +4,13 @@ import {
 	type TranscriptLine,
 } from '#scripts/time-runtime/time-transcript-line'
 import { delivered_rules, type MeasuredRule } from './delivered-rules'
+import { hook_context_line } from './hook-context-line'
 
-// What a rule is worth on the channel that carries it when its delivery has not fired
-// (joshuafolkken/kit#1525).
+// What a rule is worth on the channel that carries it when its delivery has not fired.
 //
 // **It exists because the eviction order was decided by protection rather than by value.**
 // `prompts/collaboration-workflow/residency.md` records that when a rule is trimmed to keep a
-// byte count, the sentence that goes is the one no marker pinned (joshuafolkken/kit#951) — so the
+// byte count, the sentence that goes is the one no marker pinned — so the
 // least-defended text leaves, never the least-useful. Nothing in the repository could tell the two
 // apart: `scripts/josh/hook-decision.ts` keeps a once-per-run stamp that answers "has this fired
 // yet", never "how often", and no other counter exists.
@@ -42,7 +42,7 @@ const PERCENT = 100
 // `scripts/time/time-batch-guard.ts` — so a session that
 // merely opened that file carries the text too — and did so in a result whose `is_error` is false.
 //
-// **That fact is read off the parsed block, never off the raw line** (joshuafolkken/kit#1642). The
+// **That fact is read off the parsed block, never off the raw line**. The
 // test it replaced was `line.includes('"is_error":true')`, which is two mistakes at once: it is
 // whitespace- and key-order-sensitive, so a serializer emitting `"is_error": true` would take every
 // rule's `refused` column to zero — indistinguishable from a hook that never fired — and it is
@@ -56,8 +56,7 @@ interface RuleReading {
 	// for a rule whose trigger is a neutral act** — filing an Issue, reading one — which a run keeping
 	// the rule still performs. Where the trigger is the violation itself, a run that kept the rule
 	// never trips it, so the row declares `reaches` and a run counts once it has reached *either* —
-	// the union, which equals `reaches` for every row whose trigger it covers
-	// (joshuafolkken/kit#1643).
+	// the union, which equals `reaches` for every row whose trigger it covers.
 	sessions: number
 	// Of those, the runs that kept the rule unaided — before the trigger fired, or without it firing
 	// at all, which is the ordinary case for a row that declares `reaches`. The compliance the carried
@@ -65,6 +64,9 @@ interface RuleReading {
 	unaided_kept: number
 	// Of those, the runs in which a refusal was actually delivered.
 	refusals: number
+	// Of those, the runs in which the hook rewrote the call instead of refusing it
+	//  — a delivery that cost no round trip.
+	rewrites: number
 	// Whether the rule declares what keeping it looks like. False makes `unaided_kept` meaningless.
 	is_measurable: boolean
 }
@@ -75,7 +77,7 @@ interface IssuedCall {
 }
 
 // **What a predicate is asked against beside the call: the turn it went out in, and the run it belongs
-// to** (joshuafolkken/kit#1867). The two travel as one parameter because every observer below takes
+// to**. The two travel as one parameter because every observer below takes
 // both, and passing them separately would put each one over the four-parameter limit. `run` is every
 // call the run issued, in timeline order, so a predicate reading it sees the whole run whatever point
 // of it the walk has reached — which is right for `reaches`, a question about *whether* the situation
@@ -96,12 +98,19 @@ interface RuleState {
 	is_reached: boolean
 	is_triggered: boolean
 	is_refused: boolean
+	is_rewritten: boolean
 }
 
 function blank_states(): Map<string, RuleState> {
 	const entries = delivered_rules.MEASURED_RULES.map((rule): [string, RuleState] => [
 		rule.id,
-		{ is_kept: false, is_reached: false, is_triggered: false, is_refused: false },
+		{
+			is_kept: false,
+			is_reached: false,
+			is_triggered: false,
+			is_refused: false,
+			is_rewritten: false,
+		},
 	])
 
 	return new Map(entries)
@@ -110,7 +119,7 @@ function blank_states(): Map<string, RuleState> {
 // **Keeping only counts before the trigger.** After the refusal the run complies because it was made
 // to, which is the delivery's contribution and not the carried text's.
 //
-// **A row may declare no call-shaped trigger at all** (joshuafolkken/kit#1792). The batching guard
+// **A row may declare no call-shaped trigger at all**. The batching guard
 // decides on the turns *behind* a call, so no predicate given one call could say whether it was
 // about to be refused; what the transcript records instead is the refusal, and `observe_error` below
 // is what closes the window for such a row.
@@ -148,13 +157,14 @@ function observe_call(
 	observe_before_trigger(rule, state, call, context)
 }
 
-// One transcript line, parsed once, as the two things a reading is taken from: the calls it issued
-// and the bodies of the results the harness wrote back as failures.
+// One transcript line, parsed once, as the things a reading is taken from: the calls it issued, the
+// bodies of the results the harness wrote back as failures, and the context a hook attached.
 interface DatedLine {
 	at_ms: number
 	message_id: string
 	calls: Array<IssuedCall>
 	errors: Array<string>
+	contexts: Array<string>
 }
 
 function calls_of(parsed: TranscriptLine): Array<IssuedCall> {
@@ -182,10 +192,11 @@ function dated_line(line: string): DatedLine | undefined {
 		message_id: parsed.message_id,
 		calls: calls_of(parsed),
 		errors: errors_of(parsed),
+		contexts: hook_context_line.hook_contexts_of(line),
 	}
 }
 
-// **A turn is a message id, not a line** (joshuafolkken/kit#1792). Claude Code writes one line per
+// **A turn is a message id, not a line**. Claude Code writes one line per
 // content block and repeats the message id on each, so a turn that thought and then issued two calls
 // is three lines carrying one id — the same reading `time-round-trips.ts` takes, for the same reason.
 // Read per line, a batched turn is indistinguishable from two turns of one call, which is the whole
@@ -206,7 +217,7 @@ function turn_key(entry: DatedLine, index: number): string {
 	return entry.message_id
 }
 
-// **The turn a call belongs to, gathered by id but never moved** (joshuafolkken/kit#1804). A folded
+// **The turn a call belongs to, gathered by id but never moved**. A folded
 // turn used to be *placed* where it opened, which both grouped a message's calls and reordered them:
 // a background unit's call landing between two blocks of a parent message was read after the whole
 // parent turn instead of at its own instant. This gathers each message's calls without touching the
@@ -232,15 +243,18 @@ function turns_by_key(entries: ReadonlyArray<DatedLine>): Map<string, Array<Issu
 // result, which is why the speaker is identified by what the body *opens* with rather than by what
 // it carries somewhere inside.
 //
-// **That is what stops a dump of the enumeration being read as a refusal by every rule at once**
-// (joshuafolkken/kit#1642). One `cat scripts/rules/delivered-rules.ts && false` writes a single
+// **That is what stops a dump of the enumeration being read as a refusal by every rule at once**.
+// One `cat scripts/rules/delivered-rules.ts && false` writes a single
 // errored result carrying all six reasons verbatim, and a containment test credited a refusal to
 // each of them; the file opens with its imports, so under this test nothing claims it. Position is
 // what separates the two, so no count of how many signatures appear is needed — and a body naming
 // several can no longer be attributed to any of them.
 function refused_id(text: string): string | undefined {
+	const body = text.trimStart()
 	const found = delivered_rules.MEASURED_RULES.find((rule) =>
-		text.trimStart().startsWith(rule.reason.slice(0, REASON_SIGNATURE_LENGTH)),
+		[rule.reason, ...(rule.former_reasons ?? [])].some((reason) =>
+			body.startsWith(reason.slice(0, REASON_SIGNATURE_LENGTH)),
+		),
 	)
 
 	return found?.id
@@ -253,13 +267,36 @@ function observe_error(states: Map<string, RuleState>, text: string): void {
 	if (state === undefined) return
 
 	state.is_refused = true
-	// **A delivered refusal is the trigger, whatever a predicate said** (joshuafolkken/kit#1792). The
+	// **A delivered refusal is the trigger, whatever a predicate said**. The
 	// hook refuses only where the rule bound, so the window in which compliance is the carried text's
 	// closes here — for the six rows this is already true by the time the result comes back, and for
 	// a row declaring no call-shaped trigger it is the only thing that can close it.
 	state.is_triggered = true
 }
 
+// **A rewrite is a delivery too, read off the note the hook attached**. The
+// call is recorded as typed and nothing errors, so the note is the one trace — matched at its opening,
+// exactly as a refusal's reason is.
+function rewritten_id(text: string): string | undefined {
+	const found = delivered_rules.MEASURED_RULES.find((rule) => {
+		const note = rule.rewrite_note
+
+		return note !== undefined && text.trimStart().startsWith(note.slice(0, REASON_SIGNATURE_LENGTH))
+	})
+
+	return found?.id
+}
+
+function observe_rewrite(states: Map<string, RuleState>, text: string): void {
+	const id = rewritten_id(text)
+	const state = id === undefined ? undefined : states.get(id)
+
+	if (state === undefined) return
+
+	state.is_rewritten = true
+	state.is_triggered = true
+}
+
 function observe_for_rule(
 	rule: MeasuredRule,
 	state: RuleState,
@@ -268,8 +305,7 @@ function observe_for_rule(
 ): void {
 	// This line's own calls, read in order; `context.turn` is every call the message issued, so a
 	// call's siblings are the rest of the turn it went out in even where the transcript split them
-	// across lines. The two coincide except when a message spans several lines
-	// (joshuafolkken/kit#1804).
+	// across lines. The two coincide except when a message spans several lines.
 	for (const call of calls) observe_call(rule, state, call, context)
 }
 
@@ -293,6 +329,7 @@ function observe_line(
 	observe_calls(states, entry.calls, context)
 
 	for (const text of entry.errors) observe_error(states, text)
+	for (const text of entry.contexts) observe_rewrite(states, text)
 }
 
 // **One timeline, ordered by timestamp — not the files read back to back.** "Kept before the
@@ -315,9 +352,9 @@ function timeline_of(texts: ReadonlyArray<string>): Array<DatedLine> {
 
 // Every text belonging to one run — the session transcript and the transcripts of the units it
 // delegated — read as one timeline. The lines are walked in timestamp order; `turns_by_key` supplies
-// each call the rest of its message as context, so grouping no longer reorders the reading
-// (joshuafolkken/kit#1804), and the run's own calls ride beside it for the one predicate that has to
-// ask about the run rather than the turn (joshuafolkken/kit#1867).
+// each call the rest of its message as context, so grouping no longer reorders the reading,
+// and the run's own calls ride beside it for the one predicate that has to
+// ask about the run rather than the turn.
 function read_run(texts: ReadonlyArray<string>): Map<string, RuleState> {
 	const states = blank_states()
 	const entries = timeline_of(texts)
@@ -337,6 +374,7 @@ function credit(reading: RuleReading, state: RuleState): void {
 	reading.sessions += 1
 	reading.unaided_kept += state.is_kept ? 1 : 0
 	reading.refusals += state.is_refused ? 1 : 0
+	reading.rewrites += state.is_rewritten ? 1 : 0
 }
 
 function reading_to_credit(
@@ -363,6 +401,7 @@ function blank_readings(): Map<string, RuleReading> {
 			sessions: 0,
 			unaided_kept: 0,
 			refusals: 0,
+			rewrites: 0,
 			is_measurable: rule.keeps !== undefined,
 		},
 	])