chaffjs 0.17.0 → 0.19.0

package/rules/vague-figure-reference.yaml

@@ -0,0 +1,66 @@
+id: vague-figure-reference
+layer: L2
+status: experimental
+how_to_find: vague-figure-pointer
+# 置き場所で指す言い方と、その言い方が指す種類（図・表）。図・表に名前を付ける語は dangling-figure-reference と同じ figure-label。
+# 箇条を置き場所で指す言い方は vague-clause-pointer。文書の構造の木に番号付きの条か章があるときだけ見る。
+word_list: vague-figure-pointer
+extra_word_lists: [figure-label, vague-clause-pointer]
+severity: warning
+
+name:
+  ja: 図や表、箇条を「上記の図」のように指している
+  en: A figure, table or clause pointed at by where it is
+
+why:
+  ja: 「上記の図」「下の表」は、どの図のことかを読み手に探させます。図を足したり動かしたりすると、指す先が黙って変わります。印刷やページの区切り、画面の幅で「上」「下」も変わります。JIS Z 8301:2019 の 10.6 は「上記の図」「以下の箇条」のような引用をしないとしています。図や表に番号を付けている文書なら、「図 3」のように番号で指せます。箇条も、条や章に番号を付けている文書なら「箇条 4」のように指せます。番号を一つも付けていない種類は見ません。
+  en: '"The figure above" makes the reader search for the figure. When a figure is added or moved, what it points at changes without a word. Printing, page breaks and the width of the screen change what is above and below as well. JIS Z 8301:2019, 10.6, rules out pointers such as "the figure above". A document that numbers its figures and tables can name them ("Figure 3"), and one that numbers its clauses can name a clause ("Clause 4"). A kind that the document never numbers is not checked.'
+
+message:
+  ja: 「{matched}」ではなく、番号で指してください（この文書は{kind}に番号を付けています）
+  en: 'Name it by its number instead of "{matched}" (this document numbers its {kind}s)'
+
+how_to_fix:
+  ja: 指している図や表、箇条の番号を書いてください。「上記の図のとおり」は「図 3 のとおり」に、「以下の箇条による」は「箇条 5 による」に。
+  en: 'Write the number of the figure, table or clause. "As the figure above shows" becomes "as Figure 3 shows"; "under the clause below" becomes "under Clause 5".'
+
+placeholders:
+  matched:
+    ja: 見つけた言い方
+    en: the phrase found
+  kind:
+    ja: 図、表や箇条
+    en: figure, table or clause
+
+levels: { strict: error, normal: warning, relaxed: info }
+
+use_for: [business, technical, blog, legal, docs, academic, literature, speech]
+sources: [jis-z8301-2019]
+
+group: structure
+summary:
+  ja: 図や表、条に番号を付けた文書で、「上記の図」「下の表」「以下の箇条」のように置き場所で指している所
+  en: '"The figure above", "the table below" or "the clause below" in a document that numbers its figures, tables or clauses'
+example:
+  ja:
+    before: |
+      売上は上記の図のとおり伸びた。
+
+      図1　売上の推移
+    after: |
+      売上は図1のとおり伸びた。
+
+      図1　売上の推移
+  en:
+    before: |
+      Sales rose, as the figure below shows.
+
+      Figure 1: Sales by month
+    after: |
+      Sales rose, as Figure 1 shows.
+
+      Figure 1: Sales by month
+
+not_flagged:
+  ja: 番号を一つも付けていない種類（番号で指しようがない）、番号を添えた言い方（上の図1）、長い語の一部（向上の図、上の図表）、コードの中は見ません。
+  en: 'A kind the document never numbers is not checked: there is no number to use. Nor are "Figure 2 below" (it has the number), a phrase inside a longer word, and code.'

package/skills/chaff/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: chaff
-description: "Check prose with chaff (npx chaffjs): pick the genre preset for the kind of document (contract, statute, manual, FAQ, paper, fiction, transcript…), run it on Markdown or text, read each finding, fix the text or record why not, and tune chaff.yaml with rules --json and relax --why. Use when asked to lint, proofread or tighten documents, or to set up a team's writing rules."
+description: "Check prose with chaff (npx chaffjs): pick the genre preset for the kind of document (contract, statute, manual, FAQ, paper, fiction, transcript…), run it on Markdown or text, read each finding, fix the text or record why not, and tune chaff.yaml with rules --json and relax --why. Use when asked to lint, proofread or tighten documents, or to set up a team's writing rules. Also use when asked to make text sound less AI-generated (「AIっぽさをなくして」「AI臭さを消して」「人間らしく書き直して」, 'make this sound human'): Light, Bold or Full mode, with Full (全面書き直し) when the request says 「全面的に」 or 'from scratch'."
 ---
 
 # Checking writing with chaff
@@ -61,6 +61,7 @@ relaxing a rule.
   existing one is left as it is), and adds `.chaff-cache/` and `.env*` to `.gitignore`.
 - `npx chaffjs rules --json [--genre <genre>]` prints every rule with its levels, the setting in effect (`now`,
   the genre's preset included) and why a rule is off. Read it instead of guessing rule names or limits.
+  `npx chaffjs rules` shows the same as a table, grouped, with the level each rule runs at now.
 - A level is `strict` / `normal` / `relaxed` / `off`; when even `relaxed` is too tight, a positive number is the
   limit itself (`max-sentence-length: 260`).
 - `prefer:` maps spellings to the team's (`e-mail: email`); `preferred-term: normal` turns the rule on.
@@ -68,6 +69,175 @@ relaxing a rule.
 - `genre:` sets the kind of document; `by_path` sets one per folder; `--genre` overrides both for one run.
   `rules:` wins over the genre's preset.
 
+## Turn a team's style note into chaff.yaml
+
+When the person gives house rules ("polite endings, sentences of at most 80 characters"), do not guess rule
+names or numbers:
+
+1. Read `npx chaffjs rules --json`. Each rule has `summary` (what it finds), `level_meaning` (what a level's
+   number means), `levels`, `example`, `not_flagged`, and `genres` (whether it runs in each genre).
+2. Split the note into single requirements; map each to the rule whose `summary` and `level_meaning` fit. A
+   number between levels is written as the number itself (`max-sentence-length: 80`). Spellings go under
+   `prefer`, in-house words under `jargon`, required headings under `required_sections`.
+3. Say plainly what no rule covers. For example, `no-mixed-desumasu` flags a register mixed into a document, but
+   does not require a particular one; a document wholly in the other register is not reported.
+4. Write only what differs from the default, then check before committing: `npx chaffjs explain <rule-id>`, a
+   short sample that breaks each requirement (each must be reported), and `npx chaffjs rules` (the table shows the
+   level each rule now runs at).
+
+## Adding a team rule
+
+Pick the easiest way that can say the requirement:
+
+| Requirement | Use |
+| --- | --- |
+| An existing rule covers it | A level, a number, `prefer`, `jargon` or `required_sections` in `chaff.yaml` |
+| A fixed phrase or pattern, with the team's own message | `custom_rules` of type `words` or `pattern` (coming in the next release) |
+| Decided by part of speech or inflection | `custom_rules` of type `tokens` (coming in the next release) |
+| Counting or comparing that the above cannot express | a Node function, `type: module` (a later release) |
+
+Test a new team rule the same way: `explain`, then a sample it must report and a sample it must not, before
+committing `chaff.yaml`. The guide page "Adding a rule" covers each way and how to add a rule to chaff itself.
+
+## Making AI-sounding text sound human
+
+Use this section when asked to make a text sound less generated: 「AIっぽさをなくして」「AI臭さを消して」「人間らしく
+書き直して」, "make this sound human", "this reads like AI wrote it".
+
+chaff marks the shapes common in generated text (group "Signs of generated text" in `npx chaffjs rules`: `ai-tell`,
+`contrast-framing`, `stock-transition`, `announcing-opener`, `colon-lead-in` (Japanese only), `assistant-residue`, and the signals
+`ai-generated-composite` reads). Most are experimental: run with `--experimental`. None of them says the text was
+generated. chaff never rewrites; the rewriting is yours.
+
+**Start with the plan.** Run `npx chaffjs fix-plan <file> --experimental` (with the genre's `--genre`; `--json` to
+read it as data). It prints, in the document's language:
+
+- the constraints: keep facts, numbers, conditions and names; add no fact; ask the writer instead of inventing a
+  specific; two passes at most;
+- the recommended mode and why, and the document-level signals with the outline's numbers;
+- for each rule that fired: its rewrite direction, what to keep, what to avoid, one before/after pair, hints for the
+  `ai-tell` phrases found, and the spots (line and sentence);
+- the check commands to run on the rewrite.
+
+Follow it. Rewrite in the mode it recommends; a request that says 「全面的に」 or "from scratch" means Full whatever it
+says. Apply each rule's direction at its spots. Where a fix needs a specific the text does not give, leave ［ ］ and
+ask. Save the result under the name the plan gives, run its check commands, and report the mode and the checks'
+output. The mode steps below say the rest.
+
+Pick one of three modes and say which.
+
+| Mode | Changes | Pick it when |
+| --- | --- | --- |
+| **Light** | only the flagged spots | the content and the structure are fine and only some phrasing is off |
+| **Bold** | each section's prose, keeping the outline | the outline is fixed (a report template, a manual, required sections) |
+| **Full** | the whole document, from scratch | the request says 「全面的に」「一から」「全部書き直して」 / "from scratch" / "rewrite the whole thing"; or the genre is `blog/*` or an essay (`literature/essay`); or `ai-generated-composite` fires |
+
+For a blog or an essay, and whenever `ai-generated-composite` fires, recommend Full. A Light or Bold pass leaves the
+skeleton of generated text: a heading every few paragraphs, bold lead-ins, symmetric sections, a closing まとめ that
+repeats the body. The writer usually wants the structure changed, not only the sentences.
+
+**Light** (only the flagged spots):
+
+1. `npx chaffjs fix-plan <file> --experimental` (or with the genre's `--genre`).
+2. Rewrite only the flagged spots, each by its rule's direction in the plan. Keep the meaning, numbers, conditions and
+   technical constraints.
+3. Run chaff again. At most two rewrite passes.
+4. Show the rewritten text and a short list of what changed and why.
+
+**Bold** (section by section, outline kept):
+
+1. Run chaff with `--experimental` and note the document-level signals: the `ai-generated-composite` inputs,
+   `bold-density`, `contrast-framing`, `stock-transition`, `sentence-rhythm`.
+2. Rewrite each section toward a human voice: less bold; one-line paragraphs and punchlines folded back into
+   paragraphs; no "X ではありません。Y です" / "It's not X. It's Y" frames; lists turned back into sentences where the
+   items connect; fewer em dashes; no announcing openers. Each paragraph carries one claim, joined to the last by a
+   connective, built around the writer's own experience or numbers where the original has them.
+3. Run chaff again and report the same signals before and after, from chaff's output.
+4. Run `npx chaffjs compare <old> <new>` (exit 1 on a dropped or added fact; `--json` to act on it). Restore every
+   dropped fact; for one that is not a fact (a number inside a metaphor, the heading of a section you cut), say why it
+   stays out. `--allow-dropped <kind>` excludes a kind you cut on purpose. Never leave an added fact.
+
+**Full** (全面書き直し, from scratch):
+
+1. **Take inventory before writing.** `npx chaffjs facts <file> --json` lists every fact `compare` will hold you to
+   (numbers, dates, times, URLs, code, names, quotations, headings, references, footnotes). `npx chaffjs outline <file>`
+   gives the old outline and its shape. Then write down, one line each, the writer's actual claims and every concrete
+   experience, example and opinion in the original. This inventory is what you write from; the old sentences are not.
+2. **Throw away the structure.** Decide what the piece is for and who reads it. Choose one angle or story for the
+   whole piece, and outline it the way a person would. Do these before writing:
+   - reorder: put the conclusion, or the most interesting episode, first;
+   - merge thin sections and split overloaded ones, so a section is a real unit, not one heading per paragraph;
+   - cut sections that only restate, the closing まとめ / "Conclusion" included;
+   - drop a heading that wraps a single paragraph;
+   - turn a list-of-points section into a narrative with one through-line;
+   - no symmetric three-point sections unless the content really has three parts;
+   - move the writer's concrete experience to where it carries the argument;
+   - open with the point or a concrete scene, not a generic opener.
+3. **Show the new outline first.** Put the old outline (headings from `chaff outline`) next to the proposed one:
+   headings, and one line per section on what it says. The writer then sees the structural change at a glance. Wait
+   for a yes, unless the person asked for it to be done without asking; then go straight on.
+4. **Write it fresh**, in the writer's voice, from the inventory:
+   - paragraphs that argue, joined by connectives; sentence lengths that vary;
+   - plain verbs instead of metaphors ("静かに壊れる", "silently fails" → what actually happens);
+   - the writer's own episodes and numbers kept; generic filler cut;
+   - bold only where a reader truly must not miss something; lists only for real enumerations, steps or commands;
+   - no hedges stacked on a claim, no announcing what you are about to say, no "it's not X, it's Y", no em dashes;
+   - the register of the writer's other paragraphs (です/ます or だ/である) and of the platform (Zenn, a company
+     report, an email);
+   - nothing the inventory does not have: no new facts, people, numbers, causes or consequences.
+
+   Three principles while writing:
+   - **Undo personification.** A thing or an idea as the subject of a verb of will (秩序が壊れる, 文化が醸成される,
+     アーキテクチャが要求する) becomes what a person or the system does. 「チームにレビューの文化が醸成された」 →
+     「チームで互いにレビューをするようになった」. If the original does not say who, ask the writer.
+   - **Turn noun endings and noun chains back into sentences with a verb.** 「キュー滞留によるメッセージ処理遅延の発生。」 →
+     「キューにメッセージが溜まり、処理が遅れた。」 A noun ending hides who did what and when.
+   - **Never invent specifics.** A vague sentence may read better with a concrete example. If the writer did not give
+     one, ask for it, or mark your guess for them to confirm. Never write it as fact.
+     「チームの雰囲気が良くなった」 stays as it is, with a question: 「雰囲気が良くなったと感じたのは、どんな場面でしたか」.
+     `chaff compare` catches an added number or name, but not added wording such as 「朝会で冗談が出るようになり」, so
+     this one is yours to keep.
+5. **Check.**
+   - `npx chaffjs <old> --experimental` and `npx chaffjs <new> --experimental`: the AI signals before and after.
+   - `npx chaffjs outline <old> <new>`: headings, average section length, text in lists, bold, before and after. A
+     restructure shows up here, not only in rule counts.
+   - `npx chaffjs compare <old> <new> --distinct --allow-dropped heading --allow-added heading`: the headings are the
+     structure you rebuilt on purpose; every other dropped fact is restored and no other fact is added. A cut まとめ
+     restates facts the body still holds, so `--distinct` counts a fact as kept when the new text states it at least
+     once.
+6. **Stop** when all of these hold, or after two full passes, whichever comes first:
+   - `ai-generated-composite` does not fire;
+   - the density rules (`bold-density`, `contrast-framing`, `stock-transition`, `colon-lead-in`) are under their limits;
+   - `compare` is clean, or every exclusion has a stated reason.
+7. **Show** the new text, a short "what changed and why" list, then a table of the signals and the shape before and
+   after, taken from chaff's output.
+
+**Read for these too.** chaff cannot detect them mechanically, so check them by reading, in every mode:
+
+- a generic opener or closer ("本記事では〜解説します", "いかがでしたでしょうか", "In today's fast-paced world");
+- explaining what every reader already knows;
+- every section the same length and the same shape;
+- a list of benefits with no cost or trade-off;
+- no first-hand detail: nothing the writer saw, measured or did;
+- the same enthusiasm everywhere, so nothing stands out;
+- politeness piled on politeness;
+- a definition nobody asked for;
+- headings that are full sentences or slogans;
+- a まとめ / "Conclusion" that repeats the body.
+
+In every mode:
+
+- Never add facts, people, numbers or causes the original does not have.
+- Keep a domain term a word rule trips when it is right in context.
+- Prefer a direct statement over a negated contrast. Say who does what.
+- Never loop just to silence a warning; two passes at most, and list what is left with the reason.
+- Per genre: in a tech article, replace metaphors ("静かに壊れる", "silently fails") with what happens and keep steps
+  and commands as lists; in a business document, put the conclusion and who does what first and keep tables and
+  figures; in an essay, fold punchlines back in and replace big words ("真理", "new possibilities") with the scene.
+
+The guide page "Making AI-sounding text sound human" has worked examples of a Bold and a Full rewrite, with chaff's
+output before and after.
+
 ## Structured documents
 
 - `npx chaffjs tree <file>` shows a contract or specification as a tree of addresses (`3.2` for 第3条第2項 or

package/src/acronym-expansions.ts

@@ -0,0 +1,106 @@
+import { namesAcronym } from "./detectors/acronym-expansion.ts";
+
+// 略語とその展開を、文書が書いたとおりに読む。同じ略語を二通りに展開していないかを比べるため。
+
+/** 本文の一続き（文）。start は文書の中の位置。 */
+export type ExpansionText = { readonly start: number; readonly text: string };
+
+export type Expansion = { readonly acronym: string; readonly name: string; readonly offset: number };
+
+const ACRONYM = String.raw`[A-Z][A-Z0-9&]*[A-Z]`;
+const QUOTE = String.raw`["“”'‘’「」]?`;
+
+/** 名前のあとに括弧で略語（Service Level Agreement (SLA)、(the "SLA")）。 */
+const NAME_FIRST = new RegExp(String.raw`[(（]\s*(?:the\s+)?${QUOTE}(?<acronym>${ACRONYM})${QUOTE}\s*[)）]`, "gu");
+/** 略語のあとに括弧で名前（SLA (Service Level Agreement)、CI（継続的インテグレーション））。 */
+const ACRONYM_FIRST = new RegExp(String.raw`(?<![\p{Script=Latin}\p{N}])(?<acronym>${ACRONYM})\s?[(（](?<name>[^()（）\n]{2,60})[)）]`, "gu");
+
+/** 頭文字に数えない短い語（Department of Defense の of）。 */
+const SMALL_WORDS: ReadonlySet<string> = new Set(["of", "and", "the", "for", "to", "in", "on", "a", "an", "&", "de", "by", "with"]);
+
+const wordsBefore = (text: string): string[] =>
+  text
+    .replaceAll(/["“”'‘’]/gu, "")
+    .trim()
+    .split(/\s+/u)
+    .filter((word) => word !== "");
+
+const initialsOf = (words: readonly string[]): string =>
+  words
+    .filter((word) => !SMALL_WORDS.has(word.toLowerCase()))
+    .flatMap((word) => word.split("-"))
+    .map((word) => word.charAt(0))
+    .join("")
+    .toUpperCase();
+
+/**
+ * 括弧の前の語のうち、頭文字がちょうど略語になる最も短い並び（the Federal Open Market Committee (FOMC) なら
+ * Federal Open Market Committee）。頭文字の揃う並びが無ければ、展開ではない（(see Table 2) や (FOMC) の前の文）。
+ */
+export const nameBefore = (text: string, acronym: string): string | undefined => {
+  const words = wordsBefore(text).slice(-acronym.length * 2 - 2);
+  const letters = acronym.replaceAll("&", "");
+  const width = words.findIndex((_word, index) => initialsOf(words.slice(-(index + 1))) === letters);
+  if (width < 0) return undefined;
+  const name = words.slice(-(width + 1));
+  const start = name.findIndex((word) => !SMALL_WORDS.has(word.toLowerCase()));
+  return name
+    .slice(start)
+    .join(" ")
+    .replace(/[,;:]$/u, "");
+};
+
+const NON_LATIN_NAME = /^[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}ー・\s\p{L}\p{N}-]+$/u;
+const HAS_KANA_OR_KANJI = /[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}]/u;
+/** 括弧の中の定義の語や文（以下「CI」という。、読点のある説明）は、名前ではない。 */
+const NOT_A_NAME = /以下|という|[、。,;:]/u;
+
+/** 略語のあとの括弧の中が、その略語の名前か。英字の名前は頭文字が揃うとき、日本語の名前は語だけのとき。 */
+const isNameAfter = (name: string, acronym: string): boolean => {
+  if (NOT_A_NAME.test(name)) return false;
+  if (HAS_KANA_OR_KANJI.test(name)) return NON_LATIN_NAME.test(name);
+  return namesAcronym(name, acronym);
+};
+
+/** 文の中の略語の展開。両方の形を、文書の中の位置の順に。 */
+export const expansionsIn = (body: ExpansionText): Expansion[] => {
+  const nameFirst = [...body.text.matchAll(NAME_FIRST)].flatMap((match) => {
+    const acronym = match.groups?.["acronym"] ?? "";
+    const name = nameBefore(body.text.slice(0, match.index), acronym);
+    return name === undefined ? [] : [{ acronym, name, offset: body.start + match.index }];
+  });
+  const acronymFirst = [...body.text.matchAll(ACRONYM_FIRST)].flatMap((match) => {
+    const acronym = match.groups?.["acronym"] ?? "";
+    const name = (match.groups?.["name"] ?? "").trim();
+    return isNameAfter(name, acronym) ? [{ acronym, name, offset: body.start + match.index }] : [];
+  });
+  return [...nameFirst, ...acronymFirst].toSorted((left, right) => left.offset - right.offset);
+};
+
+/** 比べる形。大文字小文字、ハイフンと空白、& と and、語の終わりの複数の s は名前を変えない。 */
+export const comparableName = (name: string): string =>
+  name
+    .toLowerCase()
+    .replaceAll("&", " and ")
+    .replaceAll(/[-‐‑\s]+/gu, " ")
+    .trim()
+    .replaceAll(/(?<=\p{Script=Latin}{3})s\b/gu, "");
+
+export type ExpansionConflict = { readonly expansion: Expansion; readonly first: Expansion };
+
+/** 同じ略語の、最初の展開と違う展開。違う書き方ごとに最初の一つだけ。 */
+export const expansionConflicts = (expansions: readonly Expansion[]): ExpansionConflict[] => {
+  const firsts = new Map<string, Expansion>();
+  const reported = new Set<string>();
+  return expansions.flatMap((expansion) => {
+    const first = firsts.get(expansion.acronym);
+    if (first === undefined) {
+      firsts.set(expansion.acronym, expansion);
+      return [];
+    }
+    const variant = `${expansion.acronym}\u0000${comparableName(expansion.name)}`;
+    if (comparableName(first.name) === comparableName(expansion.name) || reported.has(variant)) return [];
+    reported.add(variant);
+    return [{ expansion, first }];
+  });
+};

package/src/announced-count.ts

@@ -0,0 +1,190 @@
+import { escapeRegExp } from "./orthography.ts";
+import type { BulletList, Span } from "./plugin.ts";
+import { joined, linesAbove, type TextBlock } from "./text-above.ts";
+
+/**
+ * 箇条書きのすぐ前の文が予告した数（以下の3点、the following three steps）と、箇条書きのいちばん外側の項目の数。
+ * 予告と読むのは、文の最後の一文に数がちょうど一つあり、先を指す語がその前にあるか文がコロンで終わるときだけ。
+ * 言語の知識（先を指す語、漢数字や数の語、数える語、数を目安や順番にする語）は語彙表から受け取る。
+ */
+export type CountWords = {
+  /** 以下の、次の、following。 */
+  readonly anchors: readonly string[];
+  /** 数を字で書いたもの。一から順に並べる。 */
+  readonly numbers: readonly string[];
+  /** 数のすぐ後ろで並べるものを数える語。点、つ、steps。 */
+  readonly counters: readonly string[];
+  /** 数のすぐ前にあると予告でなくなる語（約、第、at least）。 */
+  readonly hedgesBefore: readonly string[];
+  /** 数か数える語のすぐ後ろにあると予告でなくなる語（以上、目、or more）。 */
+  readonly hedgesAfter: readonly string[];
+};
+
+export type CountMismatch = { readonly offset: number; readonly phrase: string; readonly announced: number; readonly listed: number };
+
+/** counted: 数える語が付いている（3点）。付いていない数（the following two:）は、先を指す語のすぐ後ろでだけ予告に読む。 */
+type Phrase = { readonly start: number; readonly numberEnd: number; readonly end: number; readonly announced: number; readonly counted: boolean };
+
+/** 予告の文の外側。見出し、表、引用、コードの囲みの行は、すぐ下の箇条書きを予告する文ではない。 */
+const NOT_A_LEAD = /^[ \t]*(?:#|\||>|```|~~~)/u;
+
+/** 箇条書きのすぐ前の塊。見出し・表・引用・コードの囲みなら undefined。 */
+const leadBefore = (source: string, listStart: number): TextBlock | undefined => {
+  const lines = linesAbove(source, listStart);
+  return lines.some((line) => NOT_A_LEAD.test(line.text)) ? undefined : joined(source, lines);
+};
+
+/** 文の終わり。英語の「.」は後ろが空白のときだけ（3.5 や e.g. の途中で切らない）。 */
+const SENTENCE_END = /[。！？!?]|\.(?=\s)/gu;
+
+/** 塊の最後の一文の始まり（塊の中の位置）。 */
+const lastSentenceStart = (text: string): number => {
+  const body = text.trimEnd();
+  const ends = [...body.matchAll(SENTENCE_END)].map((match) => match.index + match[0].length).filter((end) => end < body.length);
+  return ends.at(-1) ?? 0;
+};
+
+const alternation = (words: readonly string[]): string =>
+  words
+    .toSorted((a, b) => b.length - a.length)
+    .map(escapeRegExp)
+    .join("|");
+
+/**
+ * 数と、それが数えるもの。数の前が数字・英字・数の字なら数の途中（十三、23、eleven の中）。
+ * 英語は数と数える語の間に語を二つまで置ける（three key steps）。数える語が無くても、文がコロンで終わる直前の数（the following two:）は数に読む。
+ */
+const phrasePattern = (words: CountWords): RegExp => {
+  const numberChars = escapeRegExp([...new Set(words.numbers.join(""))].join(""));
+  const numbers = words.numbers.length === 0 ? "\\p{Nd}+" : `\\p{Nd}+|${alternation(words.numbers)}`;
+  const counted = `[ \\t\\u00a0]?(?:\\p{Ll}[\\p{Ll}-]*[ \\t]){0,2}(${alternation(words.counters)})(?![A-Za-z])`;
+  return new RegExp(`(?<![\\p{N}A-Za-z${numberChars}])(${numbers})(?:${counted}|(?=[ \\t]?[:：][ \\t]*$))`, "giu");
+};
+
+const valueOf = (written: string, numbers: readonly string[]): number => {
+  const digits = Number(written.normalize("NFKC"));
+  if (!Number.isNaN(digits)) return digits;
+  return numbers.findIndex((number) => number.toLowerCase() === written.toLowerCase()) + 1;
+};
+
+const LATIN_LETTER = /[A-Za-z]/u;
+const isLatin = (char: string | undefined): boolean => LATIN_LETTER.test(char ?? "");
+
+/** 英語の語は語の切れ目で照らす（over が moreover に当たらない）。日本語の語は字面どおり。 */
+const endsWithWord = (text: string, word: string): boolean => text.endsWith(word) && !(isLatin(word[0]) && isLatin(text.at(-word.length - 1)));
+
+const startsWithWord = (text: string, word: string): boolean => text.startsWith(word) && !(isLatin(word.at(-1)) && isLatin(text[word.length]));
+
+const isHedged = (sentence: string, phrase: Phrase, words: CountWords): boolean => {
+  const before = sentence.slice(0, phrase.start).trimEnd().toLowerCase();
+  const afters = [sentence.slice(phrase.numberEnd), sentence.slice(phrase.end)].map((text) => text.trimStart().toLowerCase());
+  return (
+    words.hedgesBefore.some((hedge) => endsWithWord(before, hedge.toLowerCase())) ||
+    words.hedgesAfter.some((hedge) => afters.some((after) => startsWithWord(after, hedge.toLowerCase())))
+  );
+};
+
+const COLON_END = /[:：][ \t]*$/u;
+
+/**
+ * 数字か、語の切れ目で区切った英語の数の語（two）。英字や点に続く数字は版や名前の一部（v2、1.2）なので数えない。
+ * 漢数字は「一緒」「一般」の中にもあるので数えない。
+ */
+const numberPattern = (words: CountWords): RegExp => {
+  const latin = words.numbers.filter((number) => isLatin(number[0]));
+  const digits = String.raw`(?<![A-Za-z.])\p{Nd}`;
+  return new RegExp(latin.length === 0 ? digits : `${digits}|(?<![A-Za-z])(?:${alternation(latin)})(?![A-Za-z])`, "iu");
+};
+
+type Patterns = { readonly phrase: RegExp; readonly number: RegExp };
+
+/**
+ * 数える語の無い数は、先を指す語のすぐ後ろでだけ（the following two:）。「under $75:」の金額を数に読まない。
+ * 先を指す語が無く、終わりのコロンだけが予告なら、コロンが渡すのはその手前のいちばん近い数。数の後ろにまだ数があれば
+ * （「1 つのページにまとめていましたが、2 ページに分けました:」）、その数は予告の数ではない。
+ */
+const pointsAhead = (sentence: string, phrase: Phrase, anchors: readonly string[], number: RegExp): boolean => {
+  const before = sentence.slice(0, phrase.start).toLowerCase();
+  const lowered = anchors.map((anchor) => anchor.toLowerCase());
+  if (!phrase.counted) return lowered.some((anchor) => endsWithWord(before.trimEnd(), anchor));
+  if (lowered.some((anchor) => before.includes(anchor))) return true;
+  return COLON_END.test(sentence.trimEnd()) && !number.test(sentence.slice(phrase.end));
+};
+
+/** 最後の一文の予告。数がちょうど一つで、目安や順番でなく、先を指しているときだけ。 */
+const announcedIn = (sentence: string, words: CountWords, patterns: Patterns): Phrase | undefined => {
+  const phrases = [...sentence.matchAll(patterns.phrase)].map((match) => ({
+    start: match.index,
+    numberEnd: match.index + (match[1] ?? "").length,
+    end: match.index + match[0].length,
+    announced: valueOf(match[1] ?? "", words.numbers),
+    counted: match[2] !== undefined,
+  }));
+  const only = phrases.length === 1 ? phrases[0] : undefined;
+  if (only === undefined || only.announced < 1 || isHedged(sentence, only, words)) return undefined;
+  return pointsAhead(sentence, only, words.anchors, patterns.number) ? only : undefined;
+};
+
+/** 位置から空白と改行を読み飛ばした先。 */
+const pastSpace = (source: string, at: number): number => {
+  const filled = /[^ \t\r\n]/gu;
+  filled.lastIndex = at;
+  return filled.exec(source)?.index ?? source.length;
+};
+
+/** 箇条書きの終わり（後ろの空白を読み飛ばした先）と始まり。空白だけを挟んで続く二つの箇条書きは、終わりと始まりが同じ位置になる。 */
+type Neighbours = { readonly ends: ReadonlySet<number>; readonly starts: ReadonlySet<number> };
+
+const neighboursOf = (source: string, lists: readonly BulletList[]): Neighbours => ({
+  ends: new Set(lists.map((list) => pastSpace(source, list.span.end))),
+  starts: new Set(lists.map((list) => list.span.start)),
+});
+
+/** 空白だけを挟んで前か後ろに別の箇条書きが続く。印が変わって二つに割れた一つの並びかもしれず、数を決められない。 */
+const hasNeighbour = (source: string, list: Span, neighbours: Neighbours): boolean =>
+  neighbours.ends.has(list.start) || neighbours.starts.has(pastSpace(source, list.end));
+
+/**
+ * 分類した箇条書き（「- **実運用**: CLI / Telegram」）の行は、ラベルの後ろに項目を区切って並べる。予告の数は区切った項目の数かもしれない。
+ * 区切りは斜線だけ。読点とコンマは項目の説明の文の中にも書くので（「UI: rename the button to Save, continue」）区切りに数えない。
+ * 行内のコードの中の斜線（`a/b`）も数えない。
+ */
+const CATEGORY_ITEM = /^[ \t]*(?:[-*+]|\d{1,9}[.)])[ \t]+[^:：\n]{1,40}[:：][ \t]*(?<members>\S[^\n]*)/u;
+const MEMBER_SEPARATOR = /[/／]/u;
+const INLINE_CODE = /`[^`\n]*`/gu;
+
+const membersOf = (item: string): number | undefined =>
+  CATEGORY_ITEM.exec(item)
+    ?.groups?.["members"]?.replace(INLINE_CODE, "code")
+    .split(MEMBER_SEPARATOR)
+    .filter((member) => member.trim() !== "").length;
+
+/** どの行も分類の形なら、区切って並べた項目の数の和。一行でも違えば undefined。 */
+const categorisedCount = (source: string, list: BulletList): number | undefined => {
+  const counts = list.itemSpans.map((item) => membersOf(source.slice(item.start, item.end)));
+  return counts.every((count) => count !== undefined) ? counts.reduce<number>((sum, count) => sum + (count ?? 0), 0) : undefined;
+};
+
+/** 予告の数が、行の数か、分類した行に並べた項目の数に合う。 */
+const matchesList = (announced: number, source: string, list: BulletList): boolean =>
+  announced === list.items.length || announced === categorisedCount(source, list);
+
+type Context = { readonly source: string; readonly words: CountWords; readonly patterns: Patterns; readonly neighbours: Neighbours };
+
+const mismatchOf = ({ source, words, patterns, neighbours }: Context, list: BulletList): CountMismatch[] => {
+  if (hasNeighbour(source, list.span, neighbours)) return [];
+  const lead = leadBefore(source, list.span.start);
+  if (lead === undefined) return [];
+  const sentenceStart = lastSentenceStart(lead.text);
+  const sentence = lead.text.slice(sentenceStart);
+  const phrase = announcedIn(sentence, words, patterns);
+  if (phrase === undefined || matchesList(phrase.announced, source, list)) return [];
+  const offset = lead.start + sentenceStart + phrase.start;
+  return [{ offset, phrase: sentence.slice(phrase.start, phrase.end).trim(), announced: phrase.announced, listed: list.items.length }];
+};
+
+export const announcedCountMismatches = (source: string, lists: readonly BulletList[], words: CountWords): CountMismatch[] => {
+  if (words.counters.length === 0) return [];
+  const context = { source, words, patterns: { phrase: phrasePattern(words), number: numberPattern(words) }, neighbours: neighboursOf(source, lists) };
+  return lists.flatMap((list) => mismatchOf(context, list));
+};