ytdb-slate 0.5.1 → 0.6.1

package/README.md

@@ -1,5 +1,7 @@
 # ytdb-slate
 
+[![CI status](https://github.com/JetBrains/ytdb-slate/actions/workflows/tier-1.yml/badge.svg?branch=main)](https://github.com/JetBrains/ytdb-slate/actions/workflows/tier-1.yml)
+
 Slate is a thread-weaving orchestration extension for the [pi coding agent](https://pi.dev).
 
 The orchestrator (your main pi session) dispatches **bounded actions** to persistent **worker threads**. Each completed action is compressed by an LLM into an **episode** — a durable, structured record (intent, actions, findings, artifacts, open issues, handoff notes) that the orchestrator composes into further dispatches instead of re-reading raw transcripts. On top of that, Slate injects a mandatory workflow doctrine: research before design, design review, adversarial review, and track review — with optional umbrella **draft-PR publishing** for tracks. An opt-in **model-failover** map adds high availability: when a model API fails, the orchestrator, worker threads, and episode compression each retry once on a configured equal-quality alternative. A second opt-in, **action-level model routing**, gives each dispatched action a model and an effort level chosen to be up to the task and no more, so cost is bounded per action instead of per session.
@@ -57,6 +59,18 @@ Slate can pick the model and the effort level per dispatched action rather than
 
 What the code enforces is deliberately narrower than what the routing data advises. The dispatch guards refuse an unlisted model, a level off the target model's ladder and a level the provider rejects outright; they warn about — and mark — an unmeasured level, refusing it only when `router.allowUnmeasuredEffort` is `false`; and the context-window guard substitutes a wider listed model instead of ever blocking an action. The obligations that come from the profile data itself — keeping review and gate actions on measured levels, and honoring a REFUSE such as `anthropic/claude-fable-5`'s for zero-data-retention work — are stated in the doctrine for the orchestrator to honor; they are **not** code-enforced guards. Full semantics: the `router.*` rows in [Configuration](#configuration) and the shipped [`docs/model-routing.md`](docs/model-routing.md) — if they disagree, that document wins.
 
+## Optional writing guidance
+
+Set `writing.check` to `true` to add writing guidance and human-only telemetry. In orchestrator mode, Slate adds a doctrine rule that states the convention. It also adds a status value such as `writing 1/4`. This value means that one of four measured prose turns had a fail-level finding. Each worker gets a shorter preamble reminder about sentence length, semicolons, and contractions.
+
+The option has prompt cost. Each orchestrator system prompt contains the doctrine rule. You pay for this text on every turn. Each worker session also gets a gated preamble addition. Both additions are absent when the option is off. The worker preamble then stays byte-identical to its pre-feature form.
+
+> **No conformance claim:** This is a dictionary-free proxy. It embeds no controlled vocabulary and claims no ASD-STE100 conformance.
+
+The shipped CLI checks plain files, JSONL records, and unified diffs. See [`docs/writing-guidance.md`](docs/writing-guidance.md) for its rules, limits, output, and command examples.
+
+Set `writing.remind` to `true` to add context-paced reminders after eligible tool results. Context-paced means Slate waits for configured context growth between reminders. The reminders are hidden from the normal TUI. They repeat five writing requirements and the scope exclusion before the next assistant response. This option remains off unless `writing.check` is also `true`.
+
 ## Install
 
 Install into a project (pinned, project-scoped — recorded in `.pi/settings.json`):
@@ -82,6 +96,9 @@ Optional config file: `slate.json` in the project's pi config dir (`.pi/slate.js
 | `orchestratorPromptDocs` | string[] | `[]` | Project markdown files (paths relative to the project root) whose **contents** are appended to the orchestrator system prompt. |
 | `workerPromptDocs` | string[] | `[]` | Project markdown files whose **contents** are appended to every worker-thread system prompt. |
 | `workflow.draftPRs` | boolean | `false` | Enable umbrella draft-PR publishing for tracks. |
+| `writing.check` | boolean | `false` | Add the writing doctrine rule, per-turn status, and worker guidance. An absent option is silently off. A malformed `writing` value, or a non-boolean `check` value, warns and defaults to off. Unknown `writing` keys warn and are ignored. See [`docs/writing-guidance.md`](docs/writing-guidance.md). |
+| `writing.remind` | boolean | `false` | Send a hidden reminder after an eligible tool result. All gates must pass: orchestrator mode, project trust, `writing.check`, this option, no pause, cadence or handoff force, and one-per-round control. See [`docs/writing-guidance.md`](docs/writing-guidance.md). |
+| `writing.remindPercent` | number | `10` | Set cadence as a percentage of Slate's current effective context budget. The value must be finite and in `(0, 100]`. The interval has an 8,192-token floor and no cap. A handoff force bypasses this threshold. See [`docs/writing-guidance.md`](docs/writing-guidance.md). |
 | `doctrineExtraPath` | string | — | Project markdown whose **content** is appended to the orchestrator doctrine (project-specific workflow additions). |
 | `reviewPerspectivesPath` | string | — | Project review charters, each declaring its own finding-ID prefix. The doctrine references this **path**; the orchestrator reads the file alongside the shipped review rules. |
 | `modelFailover` | object (string → string) | — (empty, failover off) | Map of `provider/id` → equal-quality alternative model; on a model API failure the affected site retries once on the mapped model (worker/orchestrator sites only after pi's own retries are exhausted; episode compression has no pi retry loop). Read once at session start — see [`docs/model-failover.md`](docs/model-failover.md). |
@@ -99,6 +116,11 @@ Example `.pi/slate.json` (the `docs/agents/...` paths are placeholders — point
   "orchestratorPromptDocs": ["docs/agents/orchestrator-guidelines.md"],
   "workerPromptDocs": ["docs/agents/thread-guidelines.md"],
   "workflow": { "draftPRs": true },
+  "writing": {
+    "check": true,
+    "remind": false,
+    "remindPercent": 10
+  },
   "doctrineExtraPath": "docs/agents/workflow-additions.md",
   "reviewPerspectivesPath": "docs/agents/review-perspectives.md",
   "modelFailover": { "anthropic/claude-sonnet-5": "openai/gpt-5.2" },
@@ -106,6 +128,8 @@ Example `.pi/slate.json` (the `docs/agents/...` paths are placeholders — point
 }
 ```
 
+Older Slate releases warn about these reminder keys and ignore them. Use a Slate release whose documentation includes these keys.
+
 > **Silent skip:** the project-file keys fail silently — no error is shown. For the content-injected keys (`orchestratorPromptDocs`, `workerPromptDocs`, `doctrineExtraPath`) a missing, unreadable, or empty file is skipped and nothing is injected. For `reviewPerspectivesPath` the pointer is omitted only when the file is missing — the file is not read at injection time, so an unreadable or empty file is still cited. Verify your paths after copying the example.
 
 **Worker extensions (`workerExtensions`).** By default worker threads load no extensions. This key is a list of regex patterns that select extensions the **host session has already loaded** and load them into every worker too. Each pattern is matched **unanchored** (unlike `contextBudget.overrides`, which is anchored) against a load unit's recorded source spec (e.g. `npm:pi-web-search@1.3.1`), its load-unit path, or the entry path of any tool that unit contributes, so a bare package name matches:
@@ -143,6 +167,7 @@ In orchestrator mode, Slate appends a short **doctrine** (a block of numbered ru
 - `docs/design-principles.md` — Slate's own design rationale
 - `docs/model-failover.md` — the opt-in `modelFailover` map (**reference documentation** — unlike the entries above it is not workflow doctrine and is not cited by the doctrine)
 - `docs/context-budget.md` — the orchestrator `contextBudget`: defaults, per-model overrides, the window clamp, and the pricing rationale (also **reference documentation**, not cited by the doctrine)
+- `docs/writing-guidance.md` — the optional writing convention, `writing.check` behavior, status line, and checker CLI
 - `docs/model-routing.md` — action-level model routing: the two `router` keys, how a model becomes routable, how an omitted effort level resolves, the dispatch guards, and the warnings a first routed session emits. Unlike the two entries above it **is** cited by the doctrine, by absolute path, but only while the routing rule renders — it is the extra embedded path that appears with the rule, the fourth normally and the fifth when `workflow.draftPRs` is also on, which the size arithmetic in `docs/context-budget.md` accounts for. The routable model list itself is never read from this file: the rule renders it live from the session's own resolution, because that set depends on your registry and credentials.
 
 Project-specific additions layer on top — they extend, not replace, the shipped doctrine — via two distinct mechanisms:

package/docs/context-budget.md

@@ -108,6 +108,32 @@ Rationale: the clamp guarantees the pause fires before pi's
 auto-compaction and leaves room to write the handoff brief; the
 half-window floor keeps small-window models usable.
 
+## Writing-reminder cadence
+
+The effective budget also sets the optional hidden writing-reminder cadence.
+When `writing.check` and `writing.remind` are both true, Slate computes:
+
+```
+interval = max(8192, floor(effectiveBudget × remindPercent / 100))
+```
+
+`remindPercent` defaults to 10 and accepts a finite value in `(0, 100]`. The
+context-window clamp therefore shortens the cadence on a model whose configured
+budget does not fit. Slate checks the cadence after tool results. One reminder
+slot can fire after each assistant response.
+
+A successful handoff adoption sets `forceNext`. The next eligible tool result
+then bypasses token cadence and missing usage. It does not bypass trust,
+orchestrator mode, `writing.check`, `writing.remind`, or pause gates. Slate
+commits the cadence mark only when pi starts delivery of the custom message.
+
+The current hidden message is 320 ASCII characters, including its `[slate]`
+header, five reminder requirements, blank separator, and scope exclusion. That
+is about 80 tokens at four characters per token. This count is for the exact
+rendered production string, without JSONL framing or provider-role overhead. The
+message enters conversation context only when a reminder fires. Later requests
+resend it with the rest of the conversation.
+
 ## Compaction policy
 
 In orchestrator mode, for budget-driven configs only: a
@@ -129,69 +155,131 @@ you pay its input tokens every turn.
 
 **Its size depends on where the package is installed.** That is not
 obvious, and it catches anyone who measures: the doctrine cites the
-shipped docs by ABSOLUTE path, so three to five full filesystem
-paths are embedded in the block — three at minimum
+shipped docs by ABSOLUTE path, so three to six full filesystem paths
+are embedded in the block — three at minimum
 (`track-workflow.md`, `review-rules.md`, `design-principles.md`),
 plus `pr-publishing.md` when `workflow.draftPRs` is on, plus
-`model-routing.md` when the routing rule renders. Every additional
-character in the installed `docs/` directory therefore costs 3–5
+`model-routing.md` when the routing rule renders, plus
+`writing-guidance.md` when `writing.check` is on. Every additional
+character in the installed `docs/` directory therefore costs 3–6
 characters of doctrine.
 
-So the figures below are **portable characters**, defined exactly as
-Slate's own automated size check defines them: the block with each
-occurrence of the installed `docs/` DIRECTORY removed, keeping the
-filename. That makes them install-invariant by construction —
-verified by measuring at a 12-character docs path and at this repo's
-58-character one, which give identical portable counts — and it
-makes the arithmetic one multiplication:
+The figures below are **portable characters**, defined exactly as
+Slate's own automated `doctrine-budget` check defines them: the
+block with each occurrence of the installed `docs/` DIRECTORY
+removed, keeping the filename. That makes them install-invariant by
+construction and makes the arithmetic one multiplication:
 
 > rendered characters = portable + (embedded paths × length of your
 > installed `docs/` directory)
 
-Every row below states its full basis, because router state, model
-count and `draftPRs` each move the number:
-
-| router | models | `draftPRs` | paths | portable | lines | rendered at a 58-char docs dir |
+`doctrine-budget` in `verification/resolver-checks.mjs` is the
+definition of record for this convention and its enforced bounds.
+This table is a measured snapshot, not a second authority. It uses
+the same shipped-profile fixture as that check. The six-model rows
+use the six models in this repository's `.pi/slate.json`. Every row
+states its full basis, because router state, model count, `draftPRs`,
+and `writing.check` each move the number. Rows with the same fixture
+and basis must agree with `verification/README.md`. A different basis
+must be named instead of presented as the same measurement:
+
+| router | models | `draftPRs` | `writing.check` | paths | portable | lines |
 | --- | --- | --- | --- | --- | --- | --- |
-| off | — | off | 3 | 1,929 | 38 | 2,103 |
-| off | — | on | 4 | 1,948 | 38 | 2,180 |
-| on | 6 configured | off | 4 | 3,870 | 58 | 4,102 |
-| on | 6 configured | on | 5 | 3,889 | 58 | 4,179 |
-| on | all 9 shipped | off | 4 | 4,448 | 61 | 4,680 |
-| on | all 9 shipped | on | 5 | 4,467 | 61 | 4,757 |
+| off | — | off | off | 3 | 1,929 | 38 |
+| off | — | off | on | 4 | 2,999 | 60 |
+| off | — | on | off | 4 | 1,948 | 38 |
+| off | — | on | on | 5 | 3,018 | 60 |
+| on | `.pi/slate.json` six | off | off | 4 | 3,879 | 58 |
+| on | `.pi/slate.json` six | off | on | 5 | 4,949 | 80 |
+| on | `.pi/slate.json` six | on | off | 5 | 3,898 | 58 |
+| on | `.pi/slate.json` six | on | on | 6 | 4,968 | 80 |
+| on | all 9 shipped | off | off | 4 | 4,434 | 61 |
+| on | all 9 shipped | off | on | 5 | 5,504 | 83 |
+| on | all 9 shipped | on | off | 5 | 4,453 | 61 |
+| on | all 9 shipped | on | on | 6 | 5,523 | 83 |
 
 An untrusted project reads the first row whatever its `slate.json`
-says: no project config is loaded, so neither optional rule renders.
-Line counts do not vary with the install path. Enabling `draftPRs`
-costs 19 portable characters plus one more embedded path.
+says: no project config is loaded, so no optional rule renders. Line
+counts do not vary with the install path. Enabling `draftPRs` costs
+19 portable characters plus one embedded path. Enabling
+`writing.check` costs 1,070 portable characters, adds 22 lines to the
+whole doctrine, and adds one embedded path. Considered alone, the
+writing rule is 1,070 portable characters / 23 lines. Its leading
+newline becomes the separator when appended.
 
 Two parts of the block grow with configuration rather than with the
 path:
 
 - The routing rule is a live table with ONE ROW PER ROUTABLE MODEL,
   so what renders is the models you CONFIGURE — not the nine Slate
-  ships profiles for. It is 1,941 portable characters / 20 lines for
-  six configured models and 2,519 / 23 for all nine. A model ROW
-  costs 154–186 characters; the legend adds a one-off clause per
-  marker it has to explain, so listing the first cheap-tier model
-  costs ~50 characters more than its row (two new clauses). That is
-  why stepping from six to nine averages 193 per model where the
-  first six average 171.
+  ships profiles for. In this snapshot it is 1,950 portable
+  characters and adds 20 doctrine lines for six configured models;
+  for all nine it is 2,505 characters and adds 23 lines. The six
+  model rows are 146–181 characters; all nine are 146–183. The
+  legend adds a one-off clause per marker it has to explain, so
+  growth is not only the sum of new rows.
 - The worker-extension rule grows per whitelisted extension and per
-  tool that extension contributes, so it has no fixed size; one
+  tool that extension contributes, so it has no fixed size. One
   extension contributing two tools measured 373 portable characters
   / 7 lines.
 
-Against a 256,000-token budget none of this is material — as a rough
-estimate, at 4 characters per token (no tokenizer was run, and the
-table is denser than prose, so treat it as a floor) the whole block
-is ≈480–525 tokens with both optional rules off and ≈970–1,025 with
-six models routed, each range spanning portable to as-rendered-here.
-That is under half a percent of the default budget, though it is
-re-sent on every request rather than paid once. It is listed here
-because it is context Slate itself puts in front of the model on
-every turn, and because it is the number to check before assuming
-the budget's headroom is all conversation.
+The table above isolates the shipped rules. Two representative bases include
+worker extensions and support verification decisions:
+
+| basis | models | worker extensions | paths | portable | lines | rough tokens |
+| --- | ---: | --- | ---: | ---: | ---: | ---: |
+| current `.pi/slate.json` dogfood config | 6 | real 2 units / 4 tools | 6 | 5,884 | 90 | ≈1,471 |
+| stable maximal fixture | 9 | synthetic 2 units / 4 tools, every rendered field at its cap | 6 | 6,870 | 93 | ≈1,718 |
+
+The dogfood row uses `workflow.draftPRs: true`, `writing.check: true`, and the
+six models in `.pi/slate.json`. Its extension basis is
+`pi-smart-fetch@0.3.12` plus `pi-web-search@1.3.1`. Those packages resolve to two
+units and four tools. Their worker-extension rule is 916 portable characters /
+11 lines. Raw size remains symbolic: `portable + 6 × length(installed docs
+directory)`. No maintainer checkout path belongs in this shipped document.
+
+The stable maximal row uses all nine shipped profiles, draft PRs, and writing.
+Its direct post-resolution worker fixture has two units and four tools. Unit
+labels are 128 characters. Tool names are 64 characters. Descriptions are 140
+characters.
+
+Those are the renderer caps. The fixture uses safe ASCII letters. It is
+independent of installed extension labels, descriptions, versions and other
+prose. The worker rule measures 1,347 characters against its 1,600-character
+verification budget.
+
+`doctrine-budget` caps that representative maximal doctrine at 7,200 portable
+characters. The measured 6,870 leaves 330 characters, or 4.6 percent of the
+7,200-character bound. A positive control adds one capped tool
+and three copies of the largest measured model row. It measures 7,634 portable
+characters and exceeds the bound by 434. These figures are verification budgets,
+never runtime limits. Arbitrary user extension rosters can exceed them.
+
+The exact values are maintenance tripwires. A deliberate doctrine wording,
+requirement roster, renderer cap, or fixture change requires a fresh render
+through `doctrine-budget`. Update its exact expectations and every published
+figure in the same commit. Keep the positive control steps unchanged unless the
+fixture design itself changes.
+
+Against a 256,000-token context budget, these blocks remain small. At four
+characters per token as a rough estimate, the shipped-rule table ranges from
+about 482 tokens to about 1,381 tokens. The current dogfood basis is about 1,471
+tokens. The representative maximum is about 1,718 tokens, or 0.67 percent of the
+default budget.
+
+No tokenizer was run, and tables are denser than prose. The block is re-sent on every request rather than paid once. These figures show how
+much headroom Slate consumes before conversation content.
+
+### Worker writing preamble
+
+The doctrine table does not include the worker preamble. It belongs
+to each worker session's system prompt, not to the orchestrator's
+per-turn doctrine. The feature-off preamble is 226 bytes. With
+`writing.check` on it is 384 bytes, a 158-byte increase (the
+157-byte guidance plus its separating space). These are UTF-8 byte
+counts; the current text is ASCII, so its character counts happen to
+be identical. This separate figure states the worker-session cost
+without presenting it as orchestrator doctrine.
 
 ## Worker threads: the routing window guard
 
@@ -293,9 +381,8 @@ number.
   compaction can land in the same cycle and the handoff brief is
   written from compacted context — episodes and thread state survive
   on disk, so handoff still functions.
-- The doctrine sizes above cover the shipped rules only. A project
-  that also injects `doctrineExtraPath` or `orchestratorPromptDocs`,
-  or whitelists worker extensions, pays for those on top in the same
-  always-loaded position, and Slate measures none of it against the
-  budget separately — it simply arrives as context the budget then
-  has less room for.
+- The doctrine sizes above cover the stated fixtures only. A project that
+  injects `doctrineExtraPath` or `orchestratorPromptDocs` pays for those on top.
+  A larger worker-extension roster also adds context beyond the representative
+  fixtures. Slate imposes no runtime doctrine-size limit. This content simply
+  leaves less room under the context budget.

package/docs/model-routing.md

@@ -447,14 +447,13 @@ model's ladder is unreadable.
 - **In the orchestrator's own system prompt, every turn:** the
   doctrine gains a routing rule — a table with one row per routable
   model, plus the rules for reading it. This is the surface you do
-  not see, and it is the router's standing cost: 1,941 characters /
-  20 lines for six configured models, 2,519 / 23 for all nine — a
-  model row costs 154–186 characters, plus a one-off legend clause
-  for each marker it introduces (listing the first cheap-tier model
-  costs ~50 characters beyond its row, which is why six→nine
-  averages 193 per model against the first six's 171). Configuring
-  the router roughly doubles Slate's always-loaded block (1,929
-  characters with routing off). Those are PORTABLE characters — the
+  not see, and it is the router's standing cost: 1,950 characters /
+  20 added doctrine lines for six configured models, 2,505 / 23 for
+  all nine. In the current snapshot a model row costs 146–183
+  characters, plus a one-off legend clause for each marker it
+  introduces. Configuring the router roughly doubles Slate's
+  always-loaded block (1,929 characters with routing and writing
+  off). Those are PORTABLE characters — the
   doctrine with each occurrence of the installed `docs/` directory
   removed, filenames kept — because the doctrine embeds absolute doc
   paths and its raw size therefore depends on where the package is

package/docs/review-rules.md

@@ -37,14 +37,45 @@ automatically).
 
 ## 3. Choose perspectives by what the change touches
 
-There is no fixed roster — compose perspectives per change. Each
-bullet below is that perspective's charter:
+There is no fixed roster — compose perspectives per change. Every
+perspective has this first step before its specific charter: run
+`node /path/to/slate/extension/writing-check.mjs --diff PATH --format text`
+over the review diff, using the package root that contains this document.
+Report fail-level matches in changed prose governed by the reviewed
+project's writing convention. Diff mode deliberately selects only prose
+file types; inspect user-facing strings and comments in source files
+directly. For this package, [writing-guidance.md](writing-guidance.md)
+defines the convention, its scope and its exclusions.
+
+The checker is diagnostic, not authoritative. It embeds no controlled
+vocabulary and establishes no ASD-STE100 conformance. A clean run does
+not prove that writing is good, and a match is not automatically a
+defect. Apply the project's convention scope before grading output:
+
+- `fail`: in convention-governed changed text, normally `should-fix`;
+  use `blocker` only when the underlying defect prevents safe or correct
+  delivery. In excluded text, it is advisory only.
+- `warning`: normally at most a `suggestion`; raise it only when
+  independent evidence establishes a more consequential defect.
+- `house-style`: at most a `suggestion` when the applicable convention
+  calls for the change; otherwise report nothing.
+- `advisory`: never a defect by itself. File a finding only when
+  independent review establishes an underlying defect, graded on its
+  own consequences.
+
+Reviewer judgment governs every class. The checker cannot decide
+meaning, factual accuracy, claim truth, document structure, topic unity,
+or instruction completeness; those usually matter more than a
+mechanical match. Each bullet below is the remainder of that
+perspective's charter:
 
 - **Code baseline** (any production/test code change): correctness &
   bugs (logic, null safety, resource leaks, lifecycle); code quality
   (readability, duplication, error handling); test quality (do tests
   verify behavior, cover the change, and would they fail on
-  regression?).
+  regression?). Verify documentation claims about the code under review
+  against the implementation already being read. A contradiction is a
+  code-baseline finding, not work to leave for a prose specialist.
 - **Specialists**, added when the change touches their domain:
   - concurrency — any defect requiring reasoning about thread
     interleavings (locks, shared state, atomicity);
@@ -60,14 +91,26 @@ bullet below is that perspective's charter:
   domain specialists). Each charter in that file MUST declare its own
   stable finding-ID prefix (uniqueness rules in §4). Compose them per
   change exactly like the built-in perspectives above.
-- **Non-code artifacts** (docs, prompts, process rules, extension
-  guidance like this file) get their own perspectives INSTEAD of the
-  code baseline: internal consistency & cross-references; instruction
-  completeness (can a reader execute this without guessing?); context
-  budget (what becomes always-loaded vs on-demand); writing style;
-  and safety of any scripts/hooks/config touched.
-- **Mixed diffs**: scope each reviewer to its in-scope files. Code
-  reviewers never review process/docs files, and vice versa.
+- **Non-code baseline** (docs, prompts, process rules, extension
+  guidance like this file): internal consistency & cross-references;
+  factual and instruction completeness (can a reader execute this
+  without guessing?); context budget (what becomes always-loaded vs
+  on-demand); and safety of any scripts/hooks/config touched. This
+  baseline applies instead of the code baseline unless a mixed diff
+  also changes code.
+- **Text specialist**, added when a change ships user-facing or
+  licensing-adjacent prose: licensing and provenance exposure;
+  coherence with the project's writing convention; proportionality and
+  duplication; register, audience fit, structure, and accuracy as
+  prose. User documentation, command help, release notes, prompts, and
+  public-facing messages normally trigger it. Do not dispatch it solely
+  for a short internal code comment, test name, fixture string, or
+  mechanical label unless the text is licensing-adjacent or its prose
+  risk independently warrants review.
+- **Mixed diffs**: scope each reviewer to its charter. Code reviewers own
+  claims that describe their in-scope code even when those claims live
+  in documentation. They do not take on the rest of the non-code or text
+  charter, and non-code reviewers do not take on code correctness.
 - Selection is a judgment call, not a rigid filter — when in doubt,
   include the perspective. Risk/complexity changes how deep iteration
   goes (§6), never which perspectives run.
@@ -156,13 +199,19 @@ review dispatch:
   library code instead of assuming its semantics.
 - Enumerate cases exhaustively along the changed execution paths
   (branches, error paths, boundary values); mark each case as checked
-  or explicitly out of scope.
+  or explicitly out of scope. For prose, enumerate the affected
+  audiences, reader tasks, claims, definitions, cross-references,
+  examples, exceptions, and boundary conditions instead of execution
+  paths.
 - Back every defect claim (blocker or should-fix) with a concrete
   counterexample: the input, state, or interleaving that triggers the
   defect, traced through the code.
 - Back every correctness claim ("no issue here") with a justification
   for why no counterexample exists — not merely the absence of one
-  found.
+  found. For prose, proof of absence means a bounded, reproducible check
+  of the relevant set. Examples include checker output, targeted
+  searches, re-resolved references, and comparison with authoritative
+  sources. State explicitly what those checks cannot establish.
 - Before finalizing, run an alternative-hypothesis check: "if the
   opposite verdict were true, what evidence would exist?" — then look
   for that evidence.
@@ -170,3 +219,7 @@ review dispatch:
   sought → confirmed / refuted / refined) instead of wandering.
 - Derive the final verdict explicitly from the stated definitions and
   claims, not from overall impression.
+- Treat a fix series as a changed artifact that needs review. Verify the
+  addressed finding, then review the fix diff and the cumulative result
+  for new paths, claims, and regressions. Clearing the original finding
+  does not clear defects introduced by its fix.