chaffjs 0.28.0 → 0.29.0

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;

package/src/check-source.ts

@@ -6,7 +6,7 @@ import { limitsFor } from "./config/style.ts";
 import { rulesOf } from "./custom/load.ts";
 import { guessLanguage } from "./detect.ts";
 import { buildDocument, teamRules } from "./document.ts";
-import type { CrossDetector, ProseDocument, RuleDefinition } from "./plugin.ts";
+import type { AdapterNeeds, CrossDetector, ProseDocument, RuleDefinition } from "./plugin.ts";
 import { profileFor } from "./profile/for-file.ts";
 import { resolveGenre, type ResolvedGenre } from "./resolve-genre.ts";
 import { neededBy, runRulesWith, type RunContext, type RunResult } from "./run.ts";
@@ -33,13 +33,22 @@ export type SourceCheck = {
   readonly applied: Applied;
 };
 
+/** What the language adapter is asked to prepare for these rules under this chaff.yaml: what the running rules read, nothing more. */
+export const adapterNeedsOf = (
+  rules: readonly RuleDefinition[],
+  config: Pick<Config, "rules">,
+  experimental: boolean,
+  genre: string,
+  language: string,
+): AdapterNeeds => neededBy(rules, config.rules, experimental, genre, language);
+
 /** Lints one text as `chaff <file>` does. The file need not exist: `chaff grade` checks a model's output from memory. */
 export const checkSource = async (path: string, source: string, config: Config, choice: CheckChoice): Promise<SourceCheck> => {
   const language = choice.language ?? documentLanguage(path, source, config);
   const adapter = await loadAdapter(language);
   const genre = resolveGenre(path, source, config, choice.genre);
   const rules = rulesOf(language, config);
-  await adapter.prepare?.(neededBy(rules, config.rules, choice.experimental, genre.genre, language));
+  await adapter.prepare?.(adapterNeedsOf(rules, config, choice.experimental, genre.genre, language));
   const doc = buildDocument(path, source, adapter, teamRules(config, language), profileFor(config, path, source, language, genre.genre));
   const context: RunContext = {
     settings: config.rules,

package/src/cli-text.ts

@@ -34,17 +34,26 @@ const USAGE_JA = `chaff — 文章の読みにくいところを見つけます
   chaff init --plugin <名前>     YAML だけのルールの束（chaff-plugin-<名前>/）を作る
   chaff plugin-test [フォルダ]   プラグインの各ルールを、そのルールの例にかけて確かめる
   chaff --version                chaffjs と言語パッケージの版
-  chaff eval <dir>               手元の文書で閾値を測り直す
+  chaff eval <dir> [--rule <rule>]  手元の文書で閾値を測り直す（--rule でそのルールだけ）
   chaff explain <rule>           そのルールの意図と根拠を読む
   chaff genres                   ジャンル（文書の種類）の一覧と、それぞれ何向けか
   chaff tree <file> [--format sexp|json]  文書を番地の付いた木にする（条・項・定義・参照）
-  chaff cite <原文> <引用.json>           回答の引用（番地と引用文）が原文にあるかを確かめる
-  chaff compare <前> <後>                書き換えで事実（数・日付・URL・コード・名前・引用…）が落ちても足されてもいないかを確かめる
-  chaff facts <file>                     compare が照合する事実を、書き直す前の控えとして一覧にする
-  chaff outline <file> [<後>]            見出しの構成と形（見出しの数・節の平均の長さ・箇条書きの割合・太字）を測る。2 つなら前と後を並べる
-  chaff ai-score <file>... [--format json]  AI らしさの簡易判定（低・中・高）。生成文に多い目印を、同じジャンルの人の文書と比べる（書いたのが AI かは判定しない）
-  chaff grade <items.jsonl> [--out <results.jsonl>] [--baseline <前の results.jsonl>] [--compact] [--json]
+  chaff cite <原文> <引用.json> [--format text|json]  回答の引用（番地と引用文）が原文にあるかを確かめる
+  chaff cite --scaffold <file>           出典の無い引用を、出典を書き込む引用.json のひな形にする
+  chaff cite --url <URL> <引用.json>      引用が Web のページにあるかを確かめる（取得したページは HTML から Markdown にして読む）
+  chaff compare <前> <後> [--json|--compact]  書き換えで事実（数・日付・URL・コード・名前・引用…）が落ちても足されてもいないかを確かめる
+                                 --allow-dropped <種類> と --allow-added <種類> は、その種類の欠落・追加を許す（カンマで並べる。種類は number date time url code name quote heading reference footnote）
+                                 --distinct は、何回述べたかではなく、述べているかだけを比べる
+  chaff facts <file> [--json|--compact]  compare が照合する事実を、書き直す前の控えとして一覧にする
+  chaff outline <file> [<後>] [--json|--compact]  見出しの構成と形（見出しの数・節の平均の長さ・箇条書きの割合・太字）を測る。2 つなら前と後を並べる
+  chaff ai-score <file>... [--format text|json] [--json] [--compact]
+                                 AI らしさの簡易判定（低・中・高）。生成文に多い目印を、同じジャンルの人の文書と比べる（書いたのが AI かは判定しない）
+                                 --json は --format json と同じ。--compact はファイルごとに 1 行
+  chaff grade <items.jsonl> [--out <results.jsonl>] [--baseline <前の results.jsonl>] [--allow-stamp-mismatch]
+              [--variant-key <欄>] [--format text|json|markdown] [--json] [--compact]
                                  AI の出力を JSONL でまとめて採点する（指摘の率・事実・引用・合否。何も送らない）
+                                 --allow-stamp-mismatch はルールか設定が前の回と違っても比べる（そのことを先に出す）
+                                 --variant-key は variant の欄の代わりにその欄で出力を分けて並べる。--json は --format json と同じ。markdown は PR のコメント向け
   chaff fix-plan <file> [--depth light|structure|register] [--json]
                                  指摘をルールごとにまとめ、直す方向と確かめのコマンドを、書き直す人や AI 向けの計画にする（何も送らない）
   chaff rules                    ルールの一覧を、グループごとに表で出す（いまの段階つき）
@@ -53,7 +62,8 @@ const USAGE_JA = `chaff — 文章の読みにくいところを見つけます
   chaff suppressions <dir>       stet で黙らせている指摘を数える
   chaff relax|strict|off <rule> [--why "理由"]
   chaff enable <rule> [--why "理由"]  試験中のルールを 1 つだけ動かす（chaff.yaml の rules に <rule>: normal と書く）
-  chaff skill [--global]         Claude Code の skill を入れる（.claude/skills/chaff/、--global で ~/.claude/）
+  chaff skill [--global] [--force]  Claude Code の skill を入れる（.claude/skills/chaff/、--global で ~/.claude/）
+                                 手で直したらしい skill は置き換えない。--force で置き換える
   chaff feedback <file> --rule <rule> [--line N] | --missed --line N
                                  誤った指摘・見逃しの報告の下書きを作る（何も送らない。--with-config で chaff.yaml 全体も載せる）
 
@@ -66,6 +76,7 @@ const USAGE_JA = `chaff — 文章の読みにくいところを見つけます
   --dry-run         test で、何を AI に送るかだけを見る（API を呼びません）
   --sarif <path>    指摘を SARIF で書き出す（GitHub の PR の行に出すため）
   --include <glob>  フォルダを見るとき、Markdown のほかにこのファイルも検査する（--include "*.yaml"。chaff.yaml の include と同じ）
+  --language <ja|en>  tree・cite・compare・facts・outline・ai-score で、文書の言語を決める（chaff.yaml と中身からの推定より優先）
 
 この箇所だけ黙らせる:  <!-- stet: rule-id — 理由 -->
 
@@ -82,17 +93,26 @@ const USAGE_EN = `chaff — finds what makes writing hard to read. It never rewr
   chaff init --plugin <name>     create a YAML rule pack, chaff-plugin-<name>/
   chaff plugin-test [folder]     run each rule of a plugin on the rule's own example
   chaff --version                the version of chaffjs and its language packages
-  chaff eval <dir>               re-measure the limits on your own documents
+  chaff eval <dir> [--rule <rule>]  re-measure the limits on your own documents (--rule: that rule only)
   chaff explain <rule>           read what a rule is for and why
   chaff genres                   list the genres (kinds of document) and what each is for
   chaff tree <file> [--format sexp|json]  the document as a tree of addresses (sections, clauses, definitions, references)
-  chaff cite <source> <quotes.json>       check that quoted passages (address and text) are in the source
-  chaff compare <before> <after>          check that a rewrite dropped no fact and added none (numbers, dates, URLs, code, names, quotations…)
-  chaff facts <file>                      list the facts compare checks, as an inventory to keep before a rewrite
-  chaff outline <file> [<after>]          measure the outline and its shape (headings, average section length, text in lists, bold); two files side by side
-  chaff ai-score <file>... [--format json]  quick AI-likeness score (low, medium, high): signs common in generated text against human documents of the genre (not a verdict on who wrote it)
-  chaff grade <items.jsonl> [--out <results.jsonl>] [--baseline <earlier results.jsonl>] [--compact] [--json]
+  chaff cite <source> <quotes.json> [--format text|json]  check that quoted passages (address and text) are in the source
+  chaff cite --scaffold <file>            a quotes.json to fill in with sources, from the quotations that give none
+  chaff cite --url <URL> <quotes.json>    check quotations against a web page (fetched, HTML read as Markdown)
+  chaff compare <before> <after> [--json|--compact]  check that a rewrite dropped no fact and added none (numbers, dates, URLs, code, names, quotations…)
+                                 --allow-dropped <kinds> and --allow-added <kinds> allow those kinds to go or come (comma-separated: number date time url code name quote heading reference footnote)
+                                 --distinct compares only whether a fact is stated, not how many times
+  chaff facts <file> [--json|--compact]   list the facts compare checks, as an inventory to keep before a rewrite
+  chaff outline <file> [<after>] [--json|--compact]  measure the outline and its shape (headings, average section length, text in lists, bold); two files side by side
+  chaff ai-score <file>... [--format text|json] [--json] [--compact]
+                                 quick AI-likeness score (low, medium, high): signs common in generated text against human documents of the genre (not a verdict on who wrote it)
+                                 --json is --format json; --compact prints one line per file
+  chaff grade <items.jsonl> [--out <results.jsonl>] [--baseline <earlier results.jsonl>] [--allow-stamp-mismatch]
+              [--variant-key <field>] [--format text|json|markdown] [--json] [--compact]
                                  grade a JSONL file of model outputs (finding rates, facts, quotations, pass or fail; sends nothing)
+                                 --allow-stamp-mismatch compares with the baseline even when its rules or settings differ, saying so first
+                                 --variant-key splits the outputs by that field instead of variant; --json is --format json; markdown is for a PR comment
   chaff fix-plan <file> [--depth light|structure|register] [--json]
                                  a plan for whoever rewrites the file, a person or an AI: findings by rule, how to rewrite each, the checks to run after (sends nothing)
   chaff rules                    the rules as a table, by group, with the level each runs at now
@@ -101,7 +121,8 @@ const USAGE_EN = `chaff — finds what makes writing hard to read. It never rewr
   chaff suppressions <dir>       count the findings silenced with stet
   chaff relax|strict|off <rule> [--why "reason"]
   chaff enable <rule> [--why "reason"]  turn on one experimental rule alone (writes <rule>: normal under rules in chaff.yaml)
-  chaff skill [--global]         install the Claude Code skill (.claude/skills/chaff/; --global for ~/.claude/)
+  chaff skill [--global] [--force]  install the Claude Code skill (.claude/skills/chaff/; --global for ~/.claude/)
+                                 a skill that looks edited by hand is kept; --force replaces it
   chaff feedback <file> --rule <rule> [--line N] | --missed --line N
                                  draft a report of a wrong or missed finding (sends nothing; --with-config adds all of chaff.yaml)
 
@@ -114,6 +135,7 @@ const USAGE_EN = `chaff — finds what makes writing hard to read. It never rewr
   --dry-run         with test, show what would be sent to the AI (no API call)
   --sarif <path>    write the findings as SARIF (for comments on a GitHub PR)
   --include <glob>  in a folder, check these files besides Markdown (--include "*.yaml"; as include in chaff.yaml)
+  --language <ja|en>  with tree, cite, compare, facts, outline and ai-score, the document's language (wins over chaff.yaml and the guess from the text)
 
 Silence one spot:  <!-- stet: rule-id — reason -->