chaffjs 0.27.1 → 0.29.0

package/rules/version-order.yaml

@@ -0,0 +1,85 @@
+id: version-order
+layer: L1
+status: stable
+how_to_find: version-order
+requires: [markdown]
+severity: warning
+
+name:
+  ja: 版の並びが前後している
+  en: A version out of order in a changelog
+
+why:
+  ja: 変更履歴は新しい版から順に（または古い版から順に）並べるのが決まりです。一つだけ並びから外れた版があると、読み手はどれが最新か、どの変更がどの版に入ったかを取り違えます。版を書き間違えたときや、項目を違う場所に足したときに起きます。見出しや箇条書き、表の行の先頭に書いた版（3.2.0、v3.2.0、[3.2.0]）を並びとして読み、並びの向きは多いほうで決めて、その向きの最も長い並びに入らない版を指します。
+  en: A changelog lists its versions newest first (or oldest first). One version out of that order makes the reader mistake which release is the latest, or which change went into which release. It happens when a version is mistyped or an entry is added in the wrong place. The versions at the start of headings, list items or table rows (3.2.0, v3.2.0, [3.2.0]) are read as a sequence; its direction is taken from most of its steps, and a version that fits in no longest run along that direction is pointed out.
+
+message:
+  ja: 「{version}」が、前後の版の並びから外れています（前は「{previous}」）
+  en: "{version} breaks the order of the versions around it (after {previous})"
+
+how_to_fix:
+  ja: 版の番号を確かめて、書き間違いなら直し、置き場所が違うなら正しい位置へ移してください。
+  en: Check the version number. Correct it if it is a typo, or move the entry to where it belongs.
+
+levels: { strict: error, normal: warning, relaxed: info }
+
+use_for: [technical, docs, blog, legal, academic, literature, speech]
+off_for:
+  legal: "Changelogs and release lists belong to technical writing."
+  academic: "Changelogs and release lists belong to technical writing."
+  literature: "Changelogs and release lists belong to technical writing."
+  speech: "Changelogs and release lists belong to technical writing."
+
+group: facts
+summary:
+  ja: 変更履歴の見出しや版の一覧で、一つだけ順番から外れた版
+  en: One version out of order in a changelog or a list of releases
+example:
+  ja:
+    config: { genre: technical/readme }
+    before: |
+      # 変更履歴
+
+      ## 3.2.0 - 2026-09-14
+
+      ## 3.1.1 - 2026-07-08
+
+      ## 3.3.0 - 2026-06-02
+
+      ## 3.0.0 - 2026-03-20
+    after: |
+      # 変更履歴
+
+      ## 3.2.0 - 2026-09-14
+
+      ## 3.1.1 - 2026-07-08
+
+      ## 3.1.0 - 2026-06-02
+
+      ## 3.0.0 - 2026-03-20
+  en:
+    config: { genre: technical/readme }
+    before: |
+      # Changelog
+
+      ## 3.2.0 - 2026-09-14
+
+      ## 3.1.1 - 2026-07-08
+
+      ## 3.3.0 - 2026-06-02
+
+      ## 3.0.0 - 2026-03-20
+    after: |
+      # Changelog
+
+      ## 3.2.0 - 2026-09-14
+
+      ## 3.1.1 - 2026-07-08
+
+      ## 3.1.0 - 2026-06-02
+
+      ## 3.0.0 - 2026-03-20
+
+not_flagged:
+  ja: 並べた版が三つ未満のもの、上がりと下がりが同じ数で向きが決まらないもの、向きに沿う版が半分以下の一覧（名前順の一覧）、同じ版の繰り返し、文の中の版、コードブロックの中の例、点で三つに区切っていない番号（3.1、22.04）は見ません。末尾が 0 の版（3.1.0）が無く上がっていく並び（1.2.1、1.2.2）は節の番号として numbering-gap が見ます。見出しは同じ深さどうし、箇条書きと表は続いた行どうしを比べます。
+  en: "Fewer than three versions, a sequence with as many steps up as down, a list where no more than half of the versions follow one direction (sorted by name), a repeated version, versions in running text, examples in a code block, and numbers not in three dotted parts (3.1, 22.04) are not checked. A sequence that goes up with no version ending in zero (1.2.1, 1.2.2) is read as section numbers, which numbering-gap checks. Headings are compared with headings of the same depth, and list items and table rows with the lines they run on from."

package/rules/very-adjective.yaml

@@ -3,26 +3,26 @@ layer: L2
 status: stable
 how_to_find: intensified-adjective
 word_list: very-intensifier
-extra_word_lists: [very-exception]
+extra_word_lists: [very-exception, very-copula]
 requires: [pos]
-languages: [en]
+languages: [ja, en]
 severity: info
 
 name:
-  ja: 「very + 形容詞」の多用
+  ja: 「とても + 形容詞」（very + 形容詞）の多用
   en: Too many "very" + adjective
 
 why:
-  ja: 英語の「very important」「very good」は、強い一語（critical、excellent）か、何がどうなのかを言えば要らない語です。一つ二つなら普通ですが、文書の長さのわりに多いと、どの「very」も効かなくなります。「the very first」「very few」のように意味の決まった言い方は語彙表で除いています。
-  en: '"Very important" and "very good" lean on "very" where a stronger word (critical, excellent), or saying what and how much, would do. One or two are ordinary; many for the length make every "very" weightless. Set phrases such as "the very first" and "very few" are excepted in the lexicon.'
+  ja: 「とても便利」「非常に危険」（英語の very important、very good）の強めは、何がどう便利なのか、どの程度危険なのかを書けば要らない語です。一つ二つなら普通ですが、文書の長さのわりに多いと、どの強めも効かなくなります。強めの語と、数えない言い方（the very first、very few）は言語ごとの語彙表にあります。
+  en: '"Very important" and "very good" (とても便利, 非常に危険) lean on "very" where a stronger word (critical, excellent), or saying what and how much, would do. One or two are ordinary; many for the length make every "very" weightless. The intensifiers, and set phrases not counted such as "the very first" and "very few", are listed in the lexicon.'
 
 message:
-  ja: 「{matched}」など、very + 形容詞が 1000 語あたり {density} 個あります（{limit} 個まで）
+  ja: 「{matched}」など、強め + 形容詞が 1000 字あたり {density} 個あります（{limit} 個まで）
   en: '"{matched}" and other "very" + adjective: {density} per 1000 words (limit {limit})'
 
 how_to_fix:
-  ja: 強い一語に替えるか、何がどの程度なのかを書いてください（very important → critical、very fast → under a second）。
-  en: Use a stronger word, or say what and how much ("very important" → "critical", "very fast" → "under a second").
+  ja: 強めを外して、何がどの程度なのかを書いてください（とても速い → 1 秒以内に開く、very important → critical）。
+  en: Use a stronger word, or say what and how much ("very important" → "critical", "very fast" → "under a second"; とても速い → 1 秒以内に開く).
 
 levels: { strict: 1, normal: 2, relaxed: 4 }
 
@@ -33,9 +33,15 @@ off_for:
 
 group: wording
 summary:
-  ja: 英語で、「very important」「very good」のような very + 形容詞が、文書の長さのわりに多い所
-  en: '"Very" + adjective, such as "very important", dense for the document''s length'
+  ja: 「とても便利」「非常に危険」（very important）のような強め + 形容詞が、文書の長さのわりに多い所
+  en: '"Very" + adjective, such as "very important" (とても便利), dense for the document''s length'
 example:
+  ja:
+    pad: true
+    before: |
+      新しい画面はとても便利です。読み込みもすごく速いです。ただ、設定は非常に複雑です。
+    after: |
+      新しい画面では、よく使う三つの操作が一か所にまとまりました。読み込みは 1 秒以内です。ただ、設定の項目は 40 あります。
   en:
     pad: true
     before: |
@@ -44,13 +50,25 @@ example:
       The launch was critical. The team was stretched, and the plan held.
 
 not_flagged:
-  ja: 「very」の後ろが形容詞のときだけ数えます（very well は数えない）。「the very first」「very few」「very much」は数えません。短い文書は密度を測りません。小説と話し言葉では既定で止めています（会話の言葉のため）。
-  en: Only "very" before an adjective ("very well" is not counted), and not "the very first", "very few" or "very much". Short documents are not measured. The fiction and speech presets turn it off, since dialogue speaks that way.
+  ja: 強めの後ろが形容詞のときだけ数えます（very well、とても助かる は数えない）。日本語の「便利」「静か」のような語は、後ろに「な」「で」「だ」「です」が続くときだけ形容詞と見ます。「the very first」「very few」「very much」と、empty-intensifier が見る「とても重要」は数えません。「大変」は決まった挨拶（大変お世話になりました）に使うので数えません。短い文書は密度を測りません。小説と話し言葉では既定で止めています（会話の言葉のため）。
+  en: Only "very" before an adjective ("very well" is not counted), and not "the very first", "very few" or "very much". In Japanese, a word such as 便利 counts as an adjective only before な, で, だ or です; とても重要 is left to empty-intensifier, and 大変, used in set courtesies (大変お世話になりました), is not counted. Short documents are not measured. The fiction and speech presets turn it off, since dialogue speaks that way.
 level_meaning:
-  ja: very + 形容詞が 1000 語あたり {limit} 個まで
+  ja: 強め + 形容詞が 1000 字あたり {limit} 個まで
   en: up to {limit} "very" + adjective per 1000 words
 rewrite:
   depth: light
+  ja:
+    direction: 強め（とても、すごく、非常に）を外し、本文や出典が言う具体（数、何がどうなのか）に置き換えてください。本文が何も言っていなければ、強めを外した形容詞だけにします。
+    pairs:
+      - before: 新しい画面はとても便利です。
+        after: 新しい画面では、よく使う三つの操作が一か所にまとまりました。
+      - before: 読み込みがすごく速いです。
+        after: 読み込みは 1 秒以内です。
+    keep:
+      - 各文の主張
+    avoid:
+      - 強めを別の強め（本当に、極めて）に替えるだけ
+      - 本文に無い数を作る
   en:
     direction: Replace "very" + adjective with a stronger single word, or with what the text says about how much. If the text says nothing more, a plain adjective without "very" will do.
     pairs:

package/rules/warning-without-action.yaml

@@ -0,0 +1,64 @@
+id: warning-without-action
+layer: L3
+status: stable
+how_to_find: warning-action
+# The labels and the words of an action come from the language's warning-label and warning-action lexicons; an English
+# sentence that opens with its verb is read from the parts of speech when they are available.
+uses: [pos]
+languages: [ja, en]
+severity: info
+
+name:
+  ja: することの書かれていない注意書き
+  en: Warning that gives no action
+
+why:
+  ja: 「注意：復元すると、今のデータベースは置き換わります。」のように危険だけを書いた注意書きは、読み手を不安にするだけで、何をすれば防げるのかを教えません。手順書の注意書きは、何が起きるかと、それを防ぐために読み手がすること（先に書き出す、電源を切らない）を一緒に書くものです。「注意」「警告」「危険」で始まる段落の、どの文にも「〜してください」「〜しないこと」のような読み手のすることが無いとき指します。
+  en: 'A warning that only names a risk ("Warning: the restore replaces the current database.") alarms the reader without saying how to avoid it. A warning in a manual says what happens and what the reader does to prevent it (export first, do not unplug the drive). A paragraph that opens with Warning, Caution or Danger is reported when none of its sentences tells the reader what to do: no "do not", "make sure", "must" and no sentence that opens with its verb ("Export today''s orders first").'
+
+message:
+  ja: この注意書きは危険を述べるだけで、読み手がすることを書いていません
+  en: This warning names a risk but not what the reader should do
+
+how_to_fix:
+  ja: 危険を避けるために読み手がすることを、同じ段落に書き足してください（「先に〜を書き出してください」「〜の間は電源を切らないでください」）。
+  en: Add what the reader does to avoid the risk to the same paragraph ("Export today's orders first", "Do not unplug the drive while it runs").
+
+levels: { strict: warning, normal: info, relaxed: info }
+
+use_for: [technical, docs, blog, legal, academic, literature, speech]
+off_for:
+  legal: "Warnings with an action to take are a convention of manuals and technical writing."
+  academic: "Warnings with an action to take are a convention of manuals and technical writing."
+  literature: "Warnings with an action to take are a convention of manuals and technical writing."
+  speech: "Warnings with an action to take are a convention of manuals and technical writing."
+
+group: wording
+summary:
+  ja: 「注意」「警告」で始まる段落で、危険だけを書き、読み手のすること（〜してください、〜しないこと）が無いもの
+  en: A paragraph opening with Warning or Caution that names a risk and no action for the reader
+example:
+  ja:
+    config: { genre: docs/manual }
+    before: |
+      # バックアップを復元する
+
+      注意：復元すると、今のデータベースは置き換わります。
+    after: |
+      # バックアップを復元する
+
+      注意：復元すると、今のデータベースは置き換わります。先に、今日の注文を書き出してください。
+  en:
+    config: { genre: docs/manual }
+    before: |
+      # Restoring a backup
+
+      Warning: the restore replaces the current database.
+    after: |
+      # Restoring a backup
+
+      Warning: the restore replaces the current database. Export today's orders first.
+
+not_flagged:
+  ja: 「注意」「警告」「危険」をそれだけで頭に置いた段落（「注意：」「**警告**」「> [!WARNING]」）だけを読みます。GitHub の注意（> [!WARNING]）は引用の終わりまでを一つの注意書きとして読みます。箇条書きの項目の中の注意書き、「メモ」「ヒント」「重要」の段落、「注意深く」のように語の一部になったもの、どれかの文が読み手のすること（〜してください、〜しないこと、〜する必要があります）で終わる注意書きは指しません。技術文書・手順書・ブログでだけ動きます。
+  en: 'Only paragraphs opening with Warning, Caution or Danger standing alone ("Warning:", "**Caution**", "> [!WARNING]") are read. A GitHub alert (> [!WARNING]) is read to the end of its block quote. Warnings inside list items, notes, tips and "Important" paragraphs, words that merely start with the label ("Warnings are logged"), and warnings with any sentence that gives an action (do not, make sure, must, or a sentence opening with its verb) are not reported. Technical documents, manuals and blogs only.'

package/rules/wordy-phrase.yaml

@@ -4,7 +4,7 @@ status: stable
 how_to_find: phrase-match
 word_list: wordy-phrase
 requires: [pos]
-languages: [en]
+languages: [ja, en]
 severity: info
 
 name:
@@ -12,16 +12,16 @@ name:
   en: Wordy phrase
 
 why:
-  ja: 英語の「in order to」「due to the fact that」「at this point in time」は、「to」「because」「now」と同じことを何語もかけて言います。読み手は語を多く読むだけで、得るものは増えません。言い回しと短い形の組は言語ごとの語彙表にあります。契約や法令がわざと使う言い方（with regard to、prior to）は入れていません。
-  en: '"In order to", "due to the fact that" and "at this point in time" say in several words what "to", "because" and "now" say in one. The reader reads more and learns nothing more. The phrases and their short forms are listed in the lexicon. Phrases that contracts and statutes use on purpose ("with regard to", "prior to") are left out.'
+  ja: 「することが可能」「現時点において」（英語の in order to、at this point in time）は、「できる」「現在」と同じことを何語もかけて言います。読み手は語を多く読むだけで、得るものは増えません。言い回しと短い形の組は言語ごとの語彙表にあります。契約や法令がわざと使う言い方（with regard to、prior to）は入れていません。
+  en: '"In order to", "due to the fact that" and "at this point in time" (することが可能, 現時点において) say in several words what "to", "because" and "now" say in one. The reader reads more and learns nothing more. The phrases and their short forms are listed in the lexicon. Phrases that contracts and statutes use on purpose ("with regard to", "prior to") are left out.'
 
 message:
   ja: 「{matched}」は、もっと短く言えます
   en: '"{matched}" can be said in fewer words'
 
 how_to_fix:
-  ja: 短い形に置き換えてください（in order to → to、due to the fact that → because、in the event that → if）。
-  en: Use the short form ("in order to" → "to", "due to the fact that" → "because", "in the event that" → "if").
+  ja: 短い形に置き換えてください（することが可能です → できます、現時点において → 現在、in order to → to、due to the fact that → because）。
+  en: Use the short form ("in order to" → "to", "due to the fact that" → "because", "in the event that" → "if"; することが可能です → できます).
 
 # 指摘に要る文の数。1 つなら書き手の癖とは言えないので、2 つから。
 levels: { strict: 1, normal: 2, relaxed: 4 }
@@ -34,9 +34,14 @@ off_for:
 
 group: wording
 summary:
-  ja: 英語で、「in order to」「due to the fact that」のように、一語で言えることを何語もかけて言う所
-  en: Phrases such as "in order to" and "due to the fact that" that take several words to say what one says
+  ja: 「することが可能」「現時点において」（in order to、due to the fact that）のように、一語で言えることを何語もかけて言う所
+  en: Phrases such as "in order to" and "due to the fact that" (することが可能, 現時点において) that take several words to say what one says
 example:
+  ja:
+    before: |
+      資料は社内から閲覧することが可能です。現時点において、追加の予定はありません。
+    after: |
+      資料は社内から閲覧できます。現在、追加の予定はありません。
   en:
     before: |
       In order to save time, we met online. Due to the fact that the room was booked, we stayed home.
@@ -44,13 +49,26 @@ example:
       To save time, we met online. Because the room was booked, we stayed home.
 
 not_flagged:
-  ja: 一覧にある言い回しだけを見ます。英語の文書だけで動きます。契約や法令がわざと使う言い方（with regard to、prior to、in accordance with）は一覧に入れていません。
-  en: Only the phrases on chaff's list are checked, and only in English documents. Phrases that contracts and statutes use on purpose ("with regard to", "prior to", "in accordance with") are not on it.
+  ja: 一覧にある言い回しだけを見ます。契約や法令がわざと使う言い方（with regard to、prior to、in accordance with）は一覧に入れていません。日本語では、人の書いた文章でもふつうの「することができる」と、名詞として要る「必要性」は入れていません。翻訳調（を可能にする）は translationese-density が、「〜を行う」は nominalization が見ます。
+  en: Only the phrases on chaff's list are checked. Phrases that contracts and statutes use on purpose ("with regard to", "prior to", "in accordance with") are not on it. In Japanese, することができる, ordinary in human writing, and 必要性, which a noun phrase may need, are left out; translationese (を可能にする) is translationese-density's and 〜を行う is nominalization's.
 level_meaning:
   ja: 回りくどい言い回しを含む文が {limit} 文あれば指摘
   en: reported once {limit} sentences hold one
 rewrite:
   depth: light
+  ja:
+    direction: 回りくどい言い回しを、語彙表の短い形に置き換えてください。文のほかの所は変えません。
+    pairs:
+      - before: 資料は社内から閲覧することが可能です。
+        after: 資料は社内から閲覧できます。
+      - before: 現時点において、追加の予定はありません。
+        after: 現在、追加の予定はありません。
+      - before: 今回の結果は成功であると言えます。
+        after: 今回の結果は成功です。
+    keep:
+      - 文のほかの所と、文が言っていること
+    avoid:
+      - 言い回しを縮めるついでに、文のほかの所を書き換える
   en:
     direction: Replace the wordy phrase with its short form from the lexicon. Leave the rest of the sentence alone.
     pairs:

package/src/ai-score/of-document.ts

@@ -7,7 +7,7 @@ import { MIN_DOCUMENT_LENGTH } from "../detectors/signals.ts";
 import { structureOf } from "../structure-shape/of-document.ts";
 import { HUMAN_SHARES } from "./human-shares.ts";
 import { aiScoreOf, type AiScore, type SignalRun } from "./score.ts";
-import { measuredLevelsOf, scoredSignalIds } from "./signals.ts";
+import { compositeSignalIds, measuredLevelsOf, scoredSignalIds } from "./signals.ts";
 
 const STRUCTURE_RULE = "ai-structure";
 
@@ -20,27 +20,37 @@ const structureApplies = (rules: readonly RuleDefinition[], genre: string): bool
   return rule !== undefined && standingIn(rule, genre, presetLevels(genre)).kind === "on";
 };
 
-/** The AI-shape rules run on the document at the levels the human shares were measured at, whatever chaff.yaml sets. */
-const signalRuns = (doc: ProseDocument, rules: readonly RuleDefinition[], genre: string): SignalRun[] => {
+type SignalResult = { readonly runs: SignalRun[]; readonly compositeFired: string[] };
+
+/**
+ * The AI-shape rules run on the document at the levels the human shares were measured at, whatever chaff.yaml sets,
+ * with ai-structure beside them: it is not counted as a signal, but it is one of the composite's.
+ */
+const signalRuns = (doc: ProseDocument, rules: readonly RuleDefinition[], genre: string): SignalResult => {
   const ofLanguage = rules.filter((rule) => rule.languages === undefined || rule.languages.includes(doc.language));
   const ids = scoredSignalIds(ofLanguage);
-  const signalRules = ofLanguage.filter((rule) => ids.includes(rule.id));
-  const result = runRulesWith(doc, signalRules, { settings: measuredLevelsOf(signalRules, presetLevels(genre)), experimental: true, genre });
-  return ids.map((rule) => {
+  const runRules = ofLanguage.filter((rule) => ids.includes(rule.id) || rule.id === STRUCTURE_RULE);
+  const result = runRulesWith(doc, runRules, { settings: measuredLevelsOf(runRules, presetLevels(genre)), experimental: true, genre });
+  const fired = (rule: string): boolean => result.findings.some((finding) => finding.rule === rule);
+  const runs = ids.map((rule) => {
     const notRun = result.skipped.find((skip) => skip.rule === rule)?.why;
     const count = result.findings.filter((finding) => finding.rule === rule).length;
     return notRun === undefined ? { rule, count } : { rule, count, notRun };
   });
+  return { runs, compositeFired: compositeSignalIds(ofLanguage).filter(fired) };
 };
 
 /** The quick score of a document read as lint reads it, against human documents of its genre group. */
-export const aiScoreOfDocument = (doc: ProseDocument, rules: readonly RuleDefinition[], genre: string): AiScore =>
-  aiScoreOf({
+export const aiScoreOfDocument = (doc: ProseDocument, rules: readonly RuleDefinition[], genre: string): AiScore => {
+  const { runs, compositeFired } = signalRuns(doc, rules, genre);
+  return aiScoreOf({
     group: genreGroupOf(genre),
     length: wordsOf(doc),
     minimum: MIN_DOCUMENT_LENGTH[doc.lengthUnit],
     unit: doc.lengthUnit,
-    signals: signalRuns(doc, rules, genre),
+    signals: runs,
     shares: HUMAN_SHARES,
     structure: structureApplies(rules, genre) ? structureOf(doc) : undefined,
+    compositeFired,
   });
+};

package/src/ai-score/render.ts

@@ -1,7 +1,17 @@
 import type { LengthUnit, Localized } from "../plugin.ts";
 import { localized } from "../render/text.ts";
 import type { StructureText } from "../outline/structure-text.ts";
-import { HIGH_SIGNS, MEDIUM_SIGNS, shownSignsOf, type AiScore, type NotScored, type SignalPlace, type StructurePlace } from "./score.ts";
+import {
+  HIGH_SIGNS,
+  MEDIUM_SIGNS,
+  shownSignsOf,
+  TOGETHER_SIGNALS,
+  type AiScore,
+  type NotScored,
+  type SignalPlace,
+  type StructurePlace,
+  type Together,
+} from "./score.ts";
 import type { AiScoreText } from "./text.ts";
 
 /** What a rendering needs besides the score: the texts, the rules' names, and the genre group's name, in one language. */
@@ -46,7 +56,15 @@ const signalLine = (signal: SignalPlace, view: ScoreView): string => {
 const namesLine = (names: readonly string[], line: (names: string) => string, view: ScoreView): string[] =>
   names.length === 0 ? [] : [`  ${line(names.join(view.text.listSeparator))}`];
 
-const signalLines = (signals: readonly SignalPlace[], view: ScoreView): string[] => {
+const COMPOSITE = "ai-generated-composite";
+
+const togetherLines = (together: Together, view: ScoreView): string[] => {
+  if (!together.counted) return [];
+  const names = together.fired.map((rule) => nameOf(rule, view)).join(view.text.listSeparator);
+  return [`  ${view.text.together(nameOf(COMPOSITE, view), names, together.fired.length, TOGETHER_SIGNALS)}`];
+};
+
+const signalLines = (signals: readonly SignalPlace[], together: Together, view: ScoreView): string[] => {
   const compared = signals.filter((signal) => signal.human !== undefined);
   const shown = compared.filter((signal) => signal.count > 0);
   const quiet = compared.length - shown.length;
@@ -55,6 +73,7 @@ const signalLines = (signals: readonly SignalPlace[], view: ScoreView): string[]
   return [
     view.text.signalsHeading,
     ...shown.map((signal) => `  ${signalLine(signal, view)}`),
+    ...togetherLines(together, view),
     ...(quiet > 0 ? [`  ${view.text.quiet(quiet)}`] : []),
     ...namesLine(unshared, view.text.noHumanShare, view),
     ...namesLine(notRun, view.text.notRun, view),
@@ -85,7 +104,7 @@ export const renderAiScoreFriendly = (path: string, score: AiScore, view: ScoreV
     `  ${view.text.signs(score.signs, score.compared, MEDIUM_SIGNS, HIGH_SIGNS)}`,
     `  ${view.text.disclaimer}`,
     "",
-    ...signalLines(score.signals, view),
+    ...signalLines(score.signals, score.together, view),
     "",
     ...structureBlock(score, view),
   ];
@@ -104,7 +123,7 @@ export const aiScoreJson = (score: AiScore): Readonly<Record<string, unknown>> =
   group: score.group,
   signs: score.signs,
   compared: score.compared,
-  thresholds: { medium: MEDIUM_SIGNS, high: HIGH_SIGNS },
+  thresholds: { medium: MEDIUM_SIGNS, high: HIGH_SIGNS, together: TOGETHER_SIGNALS },
   signals: score.signals.map((signal) => ({
     rule: signal.rule,
     count: signal.count,
@@ -121,4 +140,5 @@ export const aiScoreJson = (score: AiScore): Readonly<Record<string, unknown>> =
       beyond: place.beyond,
       sameAs: place.sameAs ?? null,
     })) ?? null,
+  together: { fired: score.together.fired, counted: score.together.counted },
 });

package/src/ai-score/score.ts

@@ -27,6 +27,12 @@ export const MIN_BASELINE_DOCUMENTS = Math.ceil(1 / RARE_SHARE);
 export const MEDIUM_SIGNS = 3;
 export const HIGH_SIGNS = 5;
 
+/**
+ * In the composite's own signals: ai-generated-composite's strict level, held to it by test_ai_score.ts. That many of
+ * them firing in one document is one more sign: `yarn ai-score:corpus --all` shows how many human documents reach it.
+ */
+export const TOGETHER_SIGNALS = 2;
+
 export type AiLevel = "low" | "medium" | "high";
 
 /** One AI-shape rule's run on the document: how many findings it made, or why it did not run. */
@@ -43,6 +49,9 @@ export type SignalPlace = SignalRun & {
 /** One structure measure against human articles. sameAs: the rule that reads the same shape, when that rule already counts it. */
 export type StructurePlace = Placement & { readonly sameAs: string | undefined };
 
+/** The composite's signals that fired in the document, and whether enough fired together to count as one more sign. */
+export type Together = { readonly fired: readonly string[]; readonly counted: boolean };
+
 export type NotScored =
   | { readonly reason: "too-short"; readonly length: number; readonly minimum: number; readonly unit: LengthUnit }
   | { readonly reason: "no-baseline"; readonly compared: number; readonly needed: number };
@@ -59,6 +68,7 @@ export type AiScore = {
   readonly signals: readonly SignalPlace[];
   /** The structure measures against human articles, or undefined where they are not compared for the genre. */
   readonly structure: readonly StructurePlace[] | undefined;
+  readonly together: Together;
 };
 
 /** What the score is computed from. structure: undefined where the structure baseline does not apply to the genre. */
@@ -70,6 +80,8 @@ export type ScoreInput = {
   readonly signals: readonly SignalRun[];
   readonly shares: HumanShares;
   readonly structure: StructureScore | undefined;
+  /** The ids of ai-generated-composite's signals that fired, at the levels the human shares were measured at. */
+  readonly compositeFired: readonly string[];
 };
 
 export const levelOf = (signs: number): AiLevel => {
@@ -106,16 +118,25 @@ export const aiScoreOf = (input: ScoreInput): AiScore => {
   const signals = input.signals.map((run) => placeSignal(run, input.shares, input.group));
   const placements = input.structure?.placements.map((placement) => placeStructure(placement, signals));
   const measures = placements ?? [];
-  const signs = signals.filter((signal) => signal.unusual).length + measures.filter((place) => place.beyond && place.sameAs === undefined).length;
+  const together = { fired: input.compositeFired, counted: input.compositeFired.length >= TOGETHER_SIGNALS };
+  const signs =
+    signals.filter((signal) => signal.unusual).length +
+    measures.filter((place) => place.beyond && place.sameAs === undefined).length +
+    (together.counted ? 1 : 0);
   const compared =
     signals.filter((signal) => signal.human !== undefined).length +
     measures.filter((place) => place.pastShare !== undefined && !comparedTwice(place, signals)).length;
   const notScored = notScoredOf(input, compared);
-  return { group: input.group, level: notScored === undefined ? levelOf(signs) : undefined, notScored, signs, compared, signals, structure: placements };
+  const level = notScored === undefined ? levelOf(signs) : undefined;
+  return { group: input.group, level, notScored, signs, compared, signals, structure: placements, together };
 };
 
-/** The signs that counted, for one line: rule ids, and structure measures as structure:<id>. */
+/** How the together sign shows in one line: the composite's id at the level whose count it uses. */
+export const TOGETHER_SIGN = "ai-generated-composite:strict";
+
+/** The signs that counted, for one line: rule ids, structure measures as structure:<id>, and TOGETHER_SIGN. */
 export const shownSignsOf = (score: AiScore): string[] => [
   ...score.signals.filter((signal) => signal.unusual).map((signal) => signal.rule),
   ...(score.structure ?? []).filter((place) => place.beyond && place.sameAs === undefined).map((place) => `structure:${place.feature.id}`),
+  ...(score.together.counted ? [TOGETHER_SIGN] : []),
 ];

package/src/ai-score/signals.ts

@@ -28,12 +28,22 @@ export const SAME_SHAPE: Readonly<Partial<Record<FeatureId, string>>> = {
   "three-item-lists": "rule-of-three",
 };
 
+/** The signals ai-generated-composite reads: the together sign counts how many of them fired. */
+export const compositeSignalIds = (rules: readonly RuleDefinition[]): readonly string[] => rules.find((rule) => rule.id === COMPOSITE)?.from ?? [];
+
 /** The composite's levels: the score's level boundaries are held to them (test_ai_score.ts). */
 export const compositeLevels = (rules: readonly RuleDefinition[]): LevelTable => rules.find((rule) => rule.id === COMPOSITE)?.levels ?? {};
 
 /**
  * The level each rule runs at when measured on human documents (`yarn rules:measure`): the genre's level, and normal
- * where the genre turns the rule off, so a share exists for every genre group the rule can run in.
+ * where the genre turns the rule off, so a share exists for every genre group the rule can run in. A rule that runs only
+ * with a style (opt_in) stays off: how often it fires on documents that never chose the style says nothing about it.
  */
+const measuredLevel = (rule: RuleDefinition, preset: Readonly<Record<string, Level>>): Level => {
+  if (rule.opt_in === true) return "off";
+  const level = preset[rule.id];
+  return level === undefined || level === "off" ? "normal" : level;
+};
+
 export const measuredLevelsOf = (rules: readonly RuleDefinition[], preset: Readonly<Record<string, Level>>): Record<string, Level> =>
-  Object.fromEntries(rules.map((rule) => [rule.id, preset[rule.id] === undefined || preset[rule.id] === "off" ? "normal" : (preset[rule.id] ?? "normal")]));
+  Object.fromEntries(rules.map((rule) => [rule.id, measuredLevel(rule, preset)]));

package/src/ai-score/text.ts

@@ -18,6 +18,8 @@ export type AiScoreText = {
   readonly fired: (name: string, count: number, fired: number, documents: number, group: string) => string;
   /** A signal that fired but is common in human documents of the group, so it does not count. */
   readonly common: (name: string, count: number, fired: number, documents: number) => string;
+  /** The composite's signals that fired together, enough at its strict level to count as one more sign. */
+  readonly together: (name: string, names: string, count: number, limit: number) => string;
   readonly quiet: (count: number) => string;
   /** The structure measures within what human articles show. */
   readonly usual: (count: number) => string;
@@ -59,6 +61,7 @@ export const AI_SCORE_TEXT: Texts<AiScoreText> = {
       `✗ ${name}: ${String(count)} 件  人が書いた文書（${group}）${String(documents)} 本のうち ${String(fired)} 本`,
     common: (name, count, fired, documents) =>
       `· ${name}: ${String(count)} 件  人の文書でも出る（${String(documents)} 本のうち ${String(fired)} 本）ので数えません`,
+    together: (name, names, count, limit) => `✗ ${name}: ${String(count)} 種（${names}）。厳しめの段階の ${String(limit)} 種から、目印 1 個に数えます`,
     quiet: (count) => `· ほかの ${String(count)} 項目は出ていません`,
     usual: (count) => `· ほかの ${String(count)} 項目は人の記事でふつうの値です`,
     noHumanShare: (names) => `比べていない（人の文書の基準が無い）: ${names}`,
@@ -67,7 +70,7 @@ export const AI_SCORE_TEXT: Texts<AiScoreText> = {
     sameAs: (name) => `「${name}」と同じ形なので 1 つに数えます`,
     summary: (headline, signs, path) => `${headline}: 目印 ${String(signs)} 個 ※ 書いたのが AI かどうかの判定ではありません。内訳: chaff ai-score ${path}`,
     summaryNotScored: (reason) => `AI らしさ: 測っていません（${reason}）`,
-    usage: "使い方: chaff ai-score <file>... [--genre <ジャンル>] [--format text|json] [--compact]",
+    usage: "使い方: chaff ai-score <file>... [--genre <ジャンル>] [--language ja|en|…] [--format text|json] [--json] [--compact]",
     unknownFormat: (format) => `--format は text か json です（${format} は知りません）`,
     listSeparator: "、",
     aside: (main, inner) => `${main}（${inner}）`,
@@ -86,6 +89,8 @@ export const AI_SCORE_TEXT: Texts<AiScoreText> = {
       `✗ ${name}: ${String(count)}  in ${String(fired)} of ${String(documents)} human-written documents (${group})`,
     common: (name, count, fired, documents) =>
       `· ${name}: ${String(count)}  common in human documents too (${String(fired)} of ${String(documents)}), not counted`,
+    together: (name, names, count, limit) =>
+      `✗ ${name}: ${String(count)} of its signals (${names}); from ${String(limit)}, its strict level, that is one more sign`,
     quiet: (count) => `· the other ${String(count)} did not show`,
     usual: (count) => `· the other ${String(count)} are usual for human articles`,
     noHumanShare: (names) => `not compared (no human baseline): ${names}`,
@@ -95,7 +100,7 @@ export const AI_SCORE_TEXT: Texts<AiScoreText> = {
     summary: (headline, signs, path) =>
       `${headline}: ${String(signs)} ${signs === 1 ? "sign" : "signs"}. Not a verdict on whether AI wrote it. Breakdown: chaff ai-score ${path}`,
     summaryNotScored: (reason) => `AI-likeness: not scored (${reason})`,
-    usage: "usage: chaff ai-score <file>... [--genre <genre>] [--format text|json] [--compact]",
+    usage: "usage: chaff ai-score <file>... [--genre <genre>] [--language ja|en|…] [--format text|json] [--json] [--compact]",
     unknownFormat: (format) => `--format is text or json (not ${format})`,
     listSeparator: ", ",
     aside: (main, inner) => `${main} (${inner})`,

package/src/announced-count.ts

@@ -44,7 +44,7 @@ const lastSentenceStart = (text: string): number => {
   return ends.at(-1) ?? 0;
 };
 
-const alternation = (words: readonly string[]): string =>
+export const alternation = (words: readonly string[]): string =>
   words
     .toSorted((a, b) => b.length - a.length)
     .map(escapeRegExp)
@@ -52,16 +52,18 @@ const alternation = (words: readonly string[]): string =>
 
 /**
  * 数と、それが数えるもの。数の前が数字・英字・数の字なら数の途中（十三、23、eleven の中）。
- * 英語は数と数える語の間に語を二つまで置ける（three key steps）。数える語が無くても、文がコロンで終わる直前の数（the following two:）は数に読む。
+ * 英語は数と数える語の間に語を二つまで置ける（three key steps）。数える語が無くても、文がコロンで終わる直前の数（the following two:）と、
+ * その後ろに語が一つだけある数（the following three documents:）は数に読む。どちらも先を指す語のすぐ後ろでだけ予告になる（pointsAhead）。
  */
 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 uncounted = String.raw`(?:[ \t]\p{Ll}[\p{Ll}-]*)?(?=[ \t]?[:：][ \t]*$)`;
+  return new RegExp(`(?<![\\p{N}A-Za-z${numberChars}])(${numbers})(?:${counted}|${uncounted})`, "giu");
 };
 
-const valueOf = (written: string, numbers: readonly string[]): number => {
+export 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;
@@ -111,15 +113,20 @@ const pointsAhead = (sentence: string, phrase: Phrase, anchors: readonly string[
   return COLON_END.test(sentence.trimEnd()) && !number.test(sentence.slice(phrase.end));
 };
 
-/** 最後の一文の予告。数がちょうど一つで、目安や順番でなく、先を指しているときだけ。 */
+/**
+ * 最後の一文の予告。数がちょうど一つで、目安や順番でなく、先を指しているときだけ。数える語の無い数に語が続くもの
+ * （2 weeks:）は、先を指す語のすぐ後ろでなければ数に数えない（within 2 weeks: は期限で、予告の数を消さない）。
+ */
 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 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,
+    }))
+    .filter((phrase) => phrase.counted || phrase.end === phrase.numberEnd || pointsAhead(sentence, phrase, words.anchors, patterns.number));
   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;