chaffjs 0.15.0 → 0.17.0

package/src/render/rules-json.ts

@@ -2,9 +2,12 @@ import { definedLevels, resolve } from "../levels.ts";
 import type { Config } from "../config/load.ts";
 import type { RuleDefinition } from "../plugin.ts";
 import { uiLanguageOf, type Texts } from "../ui.ts";
+import { presetLevels } from "../genre-load.ts";
+import type { PresetLevels } from "../genre-parse.ts";
 
 const TEXT: Texts<{
   readonly offBySetting: string;
+  readonly offByGenre: (genre: string) => string;
   readonly offExperimental: string;
   readonly valuesNote: string;
   readonly reason: string;
@@ -12,6 +15,7 @@ const TEXT: Texts<{
 }> = {
   ja: {
     offBySetting: "設定で止めている",
+    offByGenre: (genre) => `ジャンル ${genre} では見ない`,
     offExperimental: "experimental な rule は既定で動かさない",
     valuesNote: "この 4 語のかわりに数字を直接書いてもよい。4 語のほうを勧める。",
     reason: "<理由>",
@@ -19,6 +23,7 @@ const TEXT: Texts<{
   },
   en: {
     offBySetting: "turned off in the settings",
+    offByGenre: (genre) => `the ${genre} genre does not check it`,
     offExperimental: "experimental rules do not run by default",
     valuesNote: "A number may be written instead of these four words. The words are recommended.",
     reason: "<reason>",
@@ -26,8 +31,9 @@ const TEXT: Texts<{
   },
 };
 
-const now = (rule: RuleDefinition, config: Config, genre: string, text: (typeof TEXT)["ja"]): Record<string, unknown> => {
-  const explicit = config.rules[rule.id];
+const now = (rule: RuleDefinition, config: Config, genre: string, text: (typeof TEXT)["ja"], preset: PresetLevels): Record<string, unknown> => {
+  const explicit = config.rules[rule.id] ?? preset[rule.id];
+  if (explicit === "off" && config.rules[rule.id] === undefined) return { level: "off", why_off: text.offByGenre(genre) };
   if (explicit === "off") return { level: "off", why_off: text.offBySetting };
   const limit = rule.layer === "L4" ? undefined : config.limits[rule.id];
   if (limit !== undefined) return { level: "normal", limit, set_as: "number" };
@@ -59,6 +65,7 @@ const levelsOf = (rule: RuleDefinition, genre: string): Record<string, unknown>
 /** AI に設定を書かせるときの入口。推測せずに書けるだけの情報を 1 つに入れる。spec §19.3。 */
 export const rulesJson = (rules: readonly RuleDefinition[], config: Config, language: string, genre: string): string => {
   const text = TEXT[uiLanguageOf(language)];
+  const preset = presetLevels(genre);
   return JSON.stringify(
     {
       schema_version: 1,
@@ -77,7 +84,7 @@ export const rulesJson = (rules: readonly RuleDefinition[], config: Config, lang
         ...levelsOf(rule, genre),
         levels_you_can_set: definedLevels(rule),
         your_setting: yourSetting(rule, config),
-        now: now(rule, config, genre, text),
+        now: now(rule, config, genre, text, preset),
       })),
       how_to_change: {
         by_command: ["relax", "strict", "off"].map((command) => `npx chaff ${command} <rule-id> --why "${text.reason}"`),

package/src/render/semantic.ts

@@ -1,35 +1,113 @@
 import type { Finding, RuleDefinition } from "../plugin.ts";
 import type { UserCheck } from "../checks.ts";
+import type { Narrowing } from "../look-at.ts";
 import type { Job as Plan, SemanticResult } from "../run-semantic.ts";
+import { uiLanguageOf, type Texts, type UiLanguage } from "../ui.ts";
 import { MARK, localized } from "./text.ts";
+import { counted, formFor } from "./plural.ts";
 
 const RULE = 60;
 
+const TEXT: Texts<{
+  readonly machineBanner: readonly string[];
+  readonly aiTitle: string;
+  readonly aiNote: readonly string[];
+  readonly read: (asked: number, seen: number) => string;
+  readonly wholeRead: (name: string) => readonly string[];
+  readonly word: (word: string) => string;
+  readonly number: string;
+  readonly narrowedRead: (name: string, what: string, kept: number, total: number) => string;
+  readonly line: (line: number) => string;
+  readonly confidence: (value: string) => string;
+  readonly disagree: readonly string[];
+  readonly silence: (rule: string) => string;
+  readonly relax: (rule: string) => string;
+  readonly notRunChecks: (count: number) => string;
+  readonly byMachine: string;
+  readonly whole: string;
+  readonly containing: (parts: string) => string;
+  readonly planLine: (count: number, name: string, how: string) => string;
+  readonly firstSample: string;
+  readonly planHead: (path: string, sentences: number, asked: number) => string;
+}> = {
+  ja: {
+    machineBanner: ["", `═══ 機械による判定 ${"═".repeat(RULE - 18)}`, "    同じ文章なら何度実行しても同じ結果になります", ""],
+    aiTitle: `═══ AI による判定 ${"═".repeat(RULE - 17)}`,
+    aiNote: ["    文章の意味を読んでいます。実行するたび結果が変わることが", "    あります。おかしいと思ったら、そのまま無視して構いません。"],
+    read: (asked, seen) => `    ${seen} 文のうち ${asked} 箇所を読みました（残りは機械が対象外と判断）`,
+    wholeRead: (name) => [`    ${name}: 見るところを絞れず、全文を読みました`, `      look_at に「」で語を書くと、その語を含む文だけになります`],
+    word: (word) => `「${word}」`,
+    number: "数字",
+    narrowedRead: (name, what, kept, total) => `    ${name}: ${what} を含む ${kept} 文だけを読みました（全 ${total} 文）`,
+    line: (line) => `${line} 行目`,
+    confidence: (value) => `確からしさ ${value}`,
+    disagree: ["     この指摘が違うと思ったら:"],
+    silence: (rule) => `       この箇所だけ黙らせる    <!-- stet: ${rule} — 理由 -->`,
+    relax: (rule) => `       ルールごとゆるめる      npx chaff relax ${rule}`,
+    notRunChecks: (count) => `  ${count} 件の検査は、見るところが無いため動いていません。`,
+    byMachine: "機械で絞り込み済み",
+    whole: "絞り込めず全文",
+    containing: (parts) => `${parts} を含む文`,
+    planLine: (count, name, how) => `    ${String(count).padStart(3)} 箇所  ${name}  （${how}）`,
+    firstSample: "  最初の 1 件に送る文章:",
+    planHead: (path, sentences, asked) => `${path}   全 ${sentences} 文のうち ${asked} 箇所を送ります（API は呼んでいません）`,
+  },
+  en: {
+    machineBanner: ["", `═══ Judged by machine ${"═".repeat(RULE - 21)}`, "    The same text gives the same result every time", ""],
+    aiTitle: `═══ Judged by AI ${"═".repeat(RULE - 16)}`,
+    aiNote: ["    These read the meaning of the text. The result can change", "    from run to run. If one looks wrong, feel free to ignore it."],
+    read: (asked, seen) => `    Read ${counted(asked, "passage")} out of ${counted(seen, "sentence")} (the machine ruled out the rest)`,
+    wholeRead: (name) => [
+      `    ${name}: could not narrow what to read, so read the whole text`,
+      `      Put words in quotes in look_at ("like this") to read only the sentences that contain them`,
+    ],
+    word: (word) => `"${word}"`,
+    number: "a number",
+    narrowedRead: (name, what, kept, total) => `    ${name}: read only the ${counted(kept, "sentence")} containing ${what} (of ${total})`,
+    line: (line) => `line ${line}`,
+    confidence: (value) => `confidence ${value}`,
+    disagree: ["     If you think this finding is wrong:"],
+    silence: (rule) => `       Silence this spot only    <!-- stet: ${rule} — reason -->`,
+    relax: (rule) => `       Relax the whole rule      npx chaff relax ${rule}`,
+    notRunChecks: (count) => `  ${counted(count, "check")} did not run: there was nothing for ${formFor(count, "it", "them")} to look at.`,
+    byMachine: "narrowed by machine",
+    whole: "not narrowed: the whole text",
+    containing: (parts) => `sentences containing ${parts}`,
+    planLine: (count, name, how) => `    ${String(count).padStart(3)} to send  ${name}  (${how})`,
+    firstSample: "  The text sent for the first one:",
+    planHead: (path, sentences, asked) => `${path}   sends ${counted(asked, "passage")} out of ${counted(sentences, "sentence")} (the API was not called)`,
+  },
+};
+
 const indent = (text: string, pad: string): string[] => text.split("\n").map((line) => `${pad}${line}`);
 
-export const MACHINE_BANNER = ["", `═══ 機械による判定 ${"═".repeat(RULE - 18)}`, "    同じ文章なら何度実行しても同じ結果になります", ""];
+/** The banner over a file's machine findings, in the file's language. */
+export const machineBanner = (language: string): readonly string[] => TEXT[uiLanguageOf(language)].machineBanner;
+
+/** The words a narrowing looks for, as the screen names them. */
+const lookedFor = (narrowing: Narrowing, language: UiLanguage): string[] => {
+  const text = TEXT[language];
+  return [...narrowing.words.map((word) => text.word(word)), ...(narrowing.needsNumber ? [text.number] : [])];
+};
 
 /**
  * 自分の書いた検査が、どこまで絞り込めたかを見せる。
  * 絞り込めないまま全文を読んでいることに気づけないと、遅さの原因が分からない。
  */
-const narrowingLines = (result: SemanticResult): string[] =>
+const narrowingLines = (result: SemanticResult, language: UiLanguage): string[] =>
   result.narrowed.flatMap(({ name, narrowing }) => {
-    if (narrowing.words.length === 0 && !narrowing.needsNumber) {
-      return [`    ${name}: 見るところを絞れず、全文を読みました`, `      look_at に「」で語を書くと、その語を含む文だけになります`];
-    }
-    const what = [...narrowing.words.map((word) => `「${word}」`), ...(narrowing.needsNumber ? ["数字"] : [])].join(" ");
-    return [`    ${name}: ${what} を含む ${narrowing.kept} 文だけを読みました（全 ${narrowing.total} 文）`];
+    if (narrowing.words.length === 0 && !narrowing.needsNumber) return [...TEXT[language].wholeRead(name)];
+    const what = lookedFor(narrowing, language).join(language === "ja" ? " " : ", ");
+    return [TEXT[language].narrowedRead(name, what, narrowing.kept, narrowing.total)];
   });
 
-const aiBanner = (result: SemanticResult): string[] => [
+const aiBanner = (result: SemanticResult, language: UiLanguage): string[] => [
   "",
-  `═══ AI による判定 ${"═".repeat(RULE - 17)}`,
-  "    文章の意味を読んでいます。実行するたび結果が変わることが",
-  "    あります。おかしいと思ったら、そのまま無視して構いません。",
+  TEXT[language].aiTitle,
+  ...TEXT[language].aiNote,
   "",
-  `    ${result.sentencesSeen} 文のうち ${result.asked} 箇所を読みました（残りは機械が対象外と判断）`,
-  ...narrowingLines(result),
+  TEXT[language].read(result.asked, result.sentencesSeen),
+  ...narrowingLines(result, language),
   "",
 ];
 
@@ -46,32 +124,37 @@ const nameOf = (rule: string, rules: readonly RuleDefinition[], checks: readonly
  * AI の指摘にだけ確からしさを出し、納得できないときの逃げ道を 2 つ添える。
  * 揺れる判定だと読む人が知らないと、誤検知に振り回される。
  */
-const block = (finding: Finding, named: Named): string[] => {
+const block = (finding: Finding, named: Named, language: UiLanguage): string[] => {
+  const text = TEXT[language];
   const confidence = finding.values["confidence"];
   const reason = String(finding.values["reason"] ?? "");
-  const sure = confidence === undefined ? "" : `            確からしさ ${String(confidence)}`;
+  const sure = confidence === undefined ? "" : `            ${text.confidence(String(confidence))}`;
   const fix = named.howToFix.length > 0 ? ["", ...indent(`→ ${named.howToFix}`, "     ")] : [];
   return [
     "",
-    `─── ${finding.line} 行目 ${"─".repeat(Math.max(0, RULE - String(finding.line).length - 8))}`,
+    // "12 行目" and "line 12" take the same width on a terminal, so the rule ends in the same column in both.
+    `─── ${text.line(finding.line)} ${"─".repeat(Math.max(0, RULE - String(finding.line).length - 8))}`,
     "",
     `  ${MARK[finding.severity] ?? "·"}  ${named.name}${sure}`,
     "",
     ...indent(reason, "     "),
     ...fix,
     "",
-    "     この指摘が違うと思ったら:",
-    `       この箇所だけ黙らせる    <!-- stet: ${finding.rule} — 理由 -->`,
-    `       ルールごとゆるめる      npx chaff relax ${finding.rule}`,
+    ...text.disagree,
+    text.silence(finding.rule),
+    text.relax(finding.rule),
     "",
   ];
 };
 
-export const renderSemantic = (result: SemanticResult, rules: readonly RuleDefinition[], checks: readonly UserCheck[], language: string): string[] => [
-  ...aiBanner(result),
-  ...result.findings.flatMap((finding) => block(finding, nameOf(finding.rule, rules, checks, language))),
-  ...(result.skipped.length > 0 ? [`  ${result.skipped.length} 件の検査は、見るところが無いため動いていません。`, ""] : []),
-];
+export const renderSemantic = (result: SemanticResult, rules: readonly RuleDefinition[], checks: readonly UserCheck[], language: string): string[] => {
+  const ui = uiLanguageOf(language);
+  return [
+    ...aiBanner(result, ui),
+    ...result.findings.flatMap((finding) => block(finding, nameOf(finding.rule, rules, checks, language), ui)),
+    ...(result.skipped.length > 0 ? [TEXT[ui].notRunChecks(result.skipped.length), ""] : []),
+  ];
+};
 
 /**
  * 何が送られるのかを、API を呼ばずに見せる。`chaff test --dry-run`。
@@ -79,19 +162,19 @@ export const renderSemantic = (result: SemanticResult, rules: readonly RuleDefin
  * 鍵が無い環境でも二段構えの 1 段目まで確かめられる。全文が送られようとしていることに
  * 請求書で気づくのでは遅い。spec §14。
  */
-const howNarrowed = (job: Plan): string => {
+const howNarrowed = (job: Plan, language: UiLanguage): string => {
   const narrowing = job.narrowing;
-  if (narrowing === undefined) return "機械で絞り込み済み";
-  const quoted = narrowing.words.map((word) => `「${word}」`);
-  const parts = narrowing.needsNumber ? [...quoted, "数字"] : quoted;
-  if (parts.length === 0) return "絞り込めず全文";
-  return `${parts.join(" ")} を含む文`;
+  if (narrowing === undefined) return TEXT[language].byMachine;
+  const parts = lookedFor(narrowing, language);
+  if (parts.length === 0) return TEXT[language].whole;
+  return TEXT[language].containing(parts.join(language === "ja" ? " " : ", "));
 };
 
-export const renderPlan = (path: string, jobs: readonly Plan[], sentences: number): string[] => {
+export const renderPlan = (path: string, jobs: readonly Plan[], sentences: number, language: string): string[] => {
+  const text = TEXT[uiLanguageOf(language)];
   const asked = jobs.reduce((sum, job) => sum + job.candidates.length, 0);
-  const lines = jobs.map((job) => `    ${String(job.candidates.length).padStart(3)} 箇所  ${job.name}  （${howNarrowed(job)}）`);
+  const lines = jobs.map((job) => text.planLine(job.candidates.length, job.name, howNarrowed(job, uiLanguageOf(language))));
   const first = jobs.find((job) => job.candidates.length > 0);
-  const sample = first === undefined ? [] : ["", "  最初の 1 件に送る文章:", "", ...indent(String(first.candidates[0]?.text ?? "").slice(0, 300), "    ")];
-  return ["", `${path}   全 ${sentences} 文のうち ${asked} 箇所を送ります（API は呼んでいません）`, "", ...lines, ...sample, ""];
+  const sample = first === undefined ? [] : ["", text.firstSample, "", ...indent(String(first.candidates[0]?.text ?? "").slice(0, 300), "    ")];
+  return ["", text.planHead(path, sentences, asked), "", ...lines, ...sample, ""];
 };

package/src/render/summary.ts

@@ -1,5 +1,6 @@
 import type { Finding } from "../plugin.ts";
 import type { Texts, UiLanguage } from "../ui.ts";
+import { counted } from "./plural.ts";
 
 export type FileOutcome = { readonly path: string; readonly findings: readonly Finding[]; readonly notRun: number };
 
@@ -21,9 +22,9 @@ const TEXT: Texts<{
   },
   en: {
     counts: {
-      error: (n) => `${n} error${n === 1 ? "" : "s"}`,
-      warning: (n) => `${n} warning${n === 1 ? "" : "s"}`,
-      info: (n) => `${n} note${n === 1 ? "" : "s"}`,
+      error: (n) => counted(n, "error"),
+      warning: (n) => counted(n, "warning"),
+      info: (n) => counted(n, "note"),
     },
     join: ", ",
     none: "No findings",

package/src/render/suppressions.ts

@@ -1,5 +1,6 @@
 import type { Suppressed, Suppression } from "../stet.ts";
 import type { Texts, UiLanguage } from "../ui.ts";
+import { counted } from "./plural.ts";
 
 const TEXT: Texts<{
   readonly nudge: string;
@@ -23,7 +24,7 @@ const TEXT: Texts<{
   },
   en: {
     nudge: "  <- consider changing the setting instead",
-    more: (n) => ` and ${n} more file${n === 1 ? "" : "s"}`,
+    more: (n) => ` and ${counted(n, "more file")}`,
     count: (n) => `${String(n).padStart(3)}`,
     reasons: (list) => `reasons: ${list}`,
     relaxAll: (rule) => `relax the whole rule: npx chaff relax ${rule} --why "..."`,
@@ -53,7 +54,7 @@ const groupByRule = (files: readonly PerFile[]): Group[] => {
         reasons: [...new Set(mine.flatMap((row) => (row.reason === undefined ? [] : [row.reason])))],
       };
     })
-    .sort((left, right) => right.count - left.count);
+    .toSorted((left, right) => right.count - left.count);
 };
 
 const groupLines = (group: Group, ui: UiLanguage): string[] => {

package/src/render/text.ts

@@ -1,13 +1,28 @@
 import type { Finding, Localized, RuleDefinition } from "../plugin.ts";
+import { formFor } from "./plural.ts";
 
 export const localized = (field: Localized, language: string): string => field[language] ?? field["en"] ?? Object.values(field)[0] ?? "";
 
+/** `{count}` is the value; `{count|word|words}` is the form that agrees with it (English only; Japanese has no plural). */
+const PLACEHOLDER = /\{(\w+)(?:\|([^|{}]*)\|([^|{}]*))?\}/gu;
+
 const fill = (template: string, values: Readonly<Record<string, string | number>>): string =>
-  template.replace(/\{(\w+)\}/gu, (whole, key: string) => {
+  template.replace(PLACEHOLDER, (whole, key: string, singular: string | undefined, plural: string | undefined) => {
     const value = values[key];
-    return value === undefined ? whole : String(value);
+    if (value === undefined) return whole;
+    return singular === undefined || plural === undefined ? String(value) : formFor(value, singular, plural);
   });
 
-export const messageOf = (rule: RuleDefinition, finding: Finding, language: string): string => fill(localized(rule.message, language), finding.values);
+/** A template as the rule reference shows it: each agreeing form as its plural ("{count} such words"). */
+export const templateForReading = (template: string): string =>
+  template.replace(PLACEHOLDER, (whole, _key: string, singular: string | undefined, plural: string | undefined) =>
+    singular === undefined || plural === undefined ? whole : plural,
+  );
+
+const templateOf = (rule: RuleDefinition, finding: Finding): Localized =>
+  (finding.variant === undefined ? undefined : rule.messages[finding.variant]) ?? rule.message;
+
+export const messageOf = (rule: RuleDefinition, finding: Finding, language: string): string =>
+  fill(localized(templateOf(rule, finding), language), finding.values);
 
 export const MARK: Readonly<Record<string, string>> = { error: "✖", warning: "⚠", info: "·" };

package/src/rule-load.ts

@@ -68,6 +68,10 @@ const missingFields = (raw: Record<string, unknown>, levels: LevelTable | undefi
 
 const localizedOf = (value: unknown): Record<string, string> => (isLocalized(value) ? value : {});
 
+/** 見つけ方ごとの message。読めないものは捨てる。 */
+const messagesOf = (value: unknown): Record<string, Record<string, string>> =>
+  isRecord(value) ? Object.fromEntries(Object.entries(value).flatMap(([variant, text]) => (isLocalized(text) ? [[variant, text]] : []))) : {};
+
 /**
  * severity も言語別に書ける。levels と同じ畳みかた。
  * 記号の許容度は言語で大きく違う（ダッシュは英語では普通、日本語の組版では扱いが難しい）。
@@ -79,6 +83,13 @@ const severityOf = (raw: unknown, language: string): Severity => {
   return isSeverity(picked) ? picked : "warning";
 };
 
+/** 言語で単位が違う数（日本語は文字、英語は語）。その言語のぶんだけを取る。無い言語では undefined。 */
+const numberFor = (raw: unknown, language: string): number | undefined => {
+  if (typeof raw === "number") return raw;
+  const picked: unknown = isRecord(raw) ? (raw[language] ?? raw["default"]) : undefined;
+  return typeof picked === "number" ? picked : undefined;
+};
+
 const stringList = (value: unknown): string[] | undefined => (Array.isArray(value) ? value.map((entry) => String(entry)) : undefined);
 
 const toRule = (raw: unknown, language: string, file: string): RuleDefinition => {
@@ -95,6 +106,7 @@ const toRule = (raw: unknown, language: string, file: string): RuleDefinition =>
     why: localizedOf(raw["why"]),
     how_to_fix: localizedOf(raw["how_to_fix"]),
     message: localizedOf(raw["message"]),
+    messages: messagesOf(raw["messages"]),
     levels,
     by_genre: genreTables(raw["by_genre"], language),
     how_to_find: String(raw["how_to_find"]),
@@ -102,6 +114,7 @@ const toRule = (raw: unknown, language: string, file: string): RuleDefinition =>
     extra_word_lists: stringList(raw["extra_word_lists"]) ?? [],
     what_to_check: isLocalized(raw["what_to_check"]) ? raw["what_to_check"] : undefined,
     where: typeof raw["where"] === "string" ? raw["where"] : undefined,
+    full_sentence: numberFor(raw["full_sentence"], language),
     requires: stringList(raw["requires"]) ?? [],
     uses: stringList(raw["uses"]) ?? [],
     from: stringList(raw["from"]) ?? [],
@@ -126,5 +139,5 @@ const parseRule = (dir: string, file: string): unknown => {
 export const loadRules = (language: string, dir: string = RULES_DIR): RuleDefinition[] =>
   readdirSync(dir)
     .filter((file) => file.endsWith(".yaml"))
-    .sort((left, right) => left.localeCompare(right, "en"))
+    .toSorted((left, right) => left.localeCompare(right, "en"))
     .map((file) => toRule(parseRule(dir, file), language, file));

package/src/run-semantic.ts

@@ -3,8 +3,9 @@ import { ask, type JudgeOptions } from "./judge.ts";
 import { FILTERS, type Candidate } from "./semantic.ts";
 import { narrow, type Narrowing } from "./look-at.ts";
 import { localized } from "./render/text.ts";
-import type { Finding, Level, ProseDocument, RuleDefinition, Severity } from "./plugin.ts";
+import type { AdapterNeeds, Finding, Level, ProseDocument, RuleDefinition, Severity } from "./plugin.ts";
 import { lineStarts, placeOf } from "./position.ts";
+import { wantsTags } from "./run.ts";
 
 export type SemanticResult = {
   readonly findings: readonly Finding[];
@@ -39,26 +40,33 @@ const severityFromLevel = (rule: RuleDefinition, level: Level): Severity => {
   return SEVERITY_BY_VALUE[Math.min(3, Math.max(1, Math.round(value)))] ?? "warning";
 };
 
+/** この文書で動かす、意味を読む rule。 */
+const semanticRules = (rules: readonly RuleDefinition[], settings: Readonly<Record<string, Level>>, genre: string): RuleDefinition[] =>
+  rules.filter((rule) => rule.layer === "L4" && rule.use_for.some((target) => genre.startsWith(target)) && settings[rule.id] !== "off");
+
+/** 意味を読む rule の絞り込みが品詞を使うか。chaff test はこれで解析器を読み込む（neededBy は L4 を数えない）。 */
+export const semanticNeeds = (rules: readonly RuleDefinition[], settings: Readonly<Record<string, Level>>, genre: string): AdapterNeeds => ({
+  pos: semanticRules(rules, settings, genre).some(wantsTags),
+});
+
 const builtInJobs = (doc: ProseDocument, rules: readonly RuleDefinition[], settings: Readonly<Record<string, Level>>, genre: string): Job[] =>
-  rules
-    .filter((rule) => rule.layer === "L4" && rule.use_for.some((target) => genre.startsWith(target)) && settings[rule.id] !== "off")
-    .flatMap((rule) => {
-      const rubric = rule.what_to_check === undefined ? undefined : localized(rule.what_to_check, doc.language);
-      if (rubric === undefined || rubric.length === 0) return [];
-      // 絞り込みが無い rule は動かさない。黙って落とさず、下の skipped に出す。
-      const filter = filterFor(rule.how_to_find);
-      if (filter === undefined) return [];
-      return [
-        {
-          rule: rule.id,
-          name: localized(rule.name, doc.language),
-          rubric,
-          howToFix: localized(rule.how_to_fix, doc.language),
-          severity: severityFromLevel(rule, settings[rule.id] ?? "normal"),
-          candidates: filter(doc),
-        },
-      ];
-    });
+  semanticRules(rules, settings, genre).flatMap((rule) => {
+    const rubric = rule.what_to_check === undefined ? undefined : localized(rule.what_to_check, doc.language);
+    if (rubric === undefined || rubric.length === 0) return [];
+    // 絞り込みが無い rule は動かさない。黙って落とさず、下の skipped に出す。
+    const filter = filterFor(rule.how_to_find);
+    if (filter === undefined) return [];
+    return [
+      {
+        rule: rule.id,
+        name: localized(rule.name, doc.language),
+        rubric,
+        howToFix: localized(rule.how_to_fix, doc.language),
+        severity: severityFromLevel(rule, settings[rule.id] ?? "normal"),
+        candidates: filter(doc),
+      },
+    ];
+  });
 
 const userJobs = (doc: ProseDocument, checks: readonly UserCheck[], genre: string): Job[] =>
   checks
@@ -129,7 +137,7 @@ export const runSemantic = async (
     ),
   );
   return {
-    findings: answers.filter((finding) => finding !== undefined).sort((left, right) => left.line - right.line),
+    findings: answers.filter((finding) => finding !== undefined).toSorted((left, right) => left.line - right.line),
     skipped,
     asked: live.reduce((sum, job) => sum + job.candidates.length, 0),
     sentencesSeen: doc.sentences.length,

package/src/run.ts

@@ -10,6 +10,7 @@ import { isMarkdownPath } from "./structure/markdown-path.ts";
 import { maskSpans } from "./mask.ts";
 import { textOutline } from "./page-furniture.ts";
 import { uiLanguageOf } from "./ui.ts";
+import { presetLevels } from "./genre-load.ts";
 
 export type Skipped = { readonly rule: string; readonly why: string };
 
@@ -18,18 +19,29 @@ export type RunResult = {
   readonly skipped: readonly Skipped[];
   /** 設定で明示的に有効にした experimental な rule。実行ごとに一度報告する。spec §18.4。 */
   readonly forcedExperimental: readonly string[];
+  /** The experimental rules the genre's preset turns on. Reported apart from forcedExperimental: chaff.yaml did not name them. */
+  readonly presetExperimental: readonly string[];
 };
 
 export type Settings = Readonly<Record<string, Level>>;
 
-const levelFor = (rule: RuleDefinition, settings: Settings, experimental: boolean): Level => {
+const levelFor = (rule: RuleDefinition, settings: Settings, experimental: boolean, preset: Settings): Level => {
   const explicit = settings[rule.id];
   // 明示設定は status の既定に勝つ。名指しで有効にしたものを黙って無効にしない。
   if (explicit !== undefined) return explicit;
+  // ジャンルの既定は chaff.yaml より弱く、status の既定より強い。--experimental でも、ジャンルが止めたものは止めたまま。
+  const fromPreset = preset[rule.id];
+  if (fromPreset !== undefined) return fromPreset;
   if (rule.status === "experimental" && !experimental) return "off";
   return "normal";
 };
 
+/** Why a rule at off did not run: chaff.yaml turned it off, the genre's preset did, or it is experimental. */
+const offReason = (rule: RuleDefinition, settings: Settings, preset: Settings, genre: string, reasons: Reasons): string => {
+  if (settings[rule.id] !== undefined) return reasons.turnedOff;
+  return preset[rule.id] === undefined ? reasons.experimental : reasons.presetOff(genre);
+};
+
 const reasonsFor = (doc: ProseDocument): Reasons => REASONS[uiLanguageOf(doc.language)];
 
 /**
@@ -41,11 +53,11 @@ const reasonsFor = (doc: ProseDocument): Reasons => REASONS[uiLanguageOf(doc.lan
  * 読むので、番号を読めなかった文書でも動く。どちらも capability ではなく、adapter が木を作れるかで決まる。
  */
 const TREE_NEEDS: ReadonlySet<string> = new Set(["structure", "dates", "quantities"]);
-const VALUE_NEEDS: readonly string[] = ["dates", "quantities"];
+const VALUE_NEEDS: ReadonlySet<string> = new Set(["dates", "quantities"]);
 
 const treeNeed = (rule: RuleDefinition, doc: ProseDocument): string | undefined => {
   if (rule.requires.includes("structure")) return treeProblem(doc);
-  return rule.requires.some((need) => VALUE_NEEDS.includes(need)) && doc.structure === undefined ? reasonsFor(doc).noStructure(doc.language) : undefined;
+  return rule.requires.some((need) => VALUE_NEEDS.has(need)) && doc.structure === undefined ? reasonsFor(doc).noStructure(doc.language) : undefined;
 };
 
 const treeProblem = (doc: ProseDocument): string | undefined => {
@@ -100,15 +112,18 @@ const untagged = (rule: RuleDefinition, doc: ProseDocument): string | undefined
 const forGenre = (rules: readonly RuleDefinition[], genre: string): RuleDefinition[] =>
   rules.filter((rule) => rule.use_for.some((target) => genre.startsWith(target)));
 
+/** rule が品詞か見出し語を要求するか、使えるなら使うか。 */
+export const wantsTags = (rule: RuleDefinition): boolean => [...rule.requires, ...rule.uses].some((need) => need === "pos" || need === "lemma");
+
 /**
  * 解析器の初期化に払う代金を決める。動く rule が 1 本も要求しないなら読み込まない。
  * capabilities は「払えばできる」の宣言なので、ここでは見ない。
  */
 export const neededBy = (rules: readonly RuleDefinition[], settings: Settings, experimental: boolean, genre: string, language: string): AdapterNeeds => ({
   pos: forGenre(rules, genre)
-    .filter((rule) => rule.layer !== "L4" && levelFor(rule, settings, experimental) !== "off")
+    .filter((rule) => rule.layer !== "L4" && levelFor(rule, settings, experimental, presetLevels(genre)) !== "off")
     .filter((rule) => rule.languages === undefined || rule.languages.includes(language))
-    .some((rule) => [...rule.requires, ...rule.uses].some((need) => need === "pos" || need === "lemma")),
+    .some(wantsTags),
 });
 
 const place = (starts: readonly number[], finding: Finding): Finding => {
@@ -153,11 +168,12 @@ export const runRules = (
   genre: string,
   limits: Limits = {},
 ): RunResult => {
+  const preset = presetLevels(genre);
   const starts = lineStarts(doc.source);
   const applicable = forGenre(rules, genre);
-  const forced = applicable
-    .filter((rule) => rule.status === "experimental" && settings[rule.id] !== undefined && settings[rule.id] !== "off")
-    .map((rule) => rule.id);
+  const experimentalOn = applicable.filter((rule) => rule.status === "experimental" && levelFor(rule, settings, experimental, preset) !== "off");
+  const forced = experimentalOn.filter((rule) => settings[rule.id] !== undefined).map((rule) => rule.id);
+  const presetOn = experimentalOn.filter((rule) => settings[rule.id] === undefined && preset[rule.id] !== undefined).map((rule) => rule.id);
   const outcome = applicable.reduce<{ findings: Finding[]; skipped: Skipped[] }>(
     (acc, rule) => {
       // L4 は意味を読む検査。chaff test が扱う。ここで「検出器が無い」と言わせない。
@@ -166,11 +182,9 @@ export const runRules = (
       }
       const blocked = unmet(rule, doc);
       if (blocked !== undefined) return { findings: acc.findings, skipped: [...acc.skipped, { rule: rule.id, why: blocked }] };
-      const level = levelFor(rule, settings, experimental);
-      if (level === "off") {
-        const why = rule.status === "experimental" && settings[rule.id] === undefined ? reasonsFor(doc).experimental : reasonsFor(doc).turnedOff;
-        return { findings: acc.findings, skipped: [...acc.skipped, { rule: rule.id, why }] };
-      }
+      const level = levelFor(rule, settings, experimental, preset);
+      if (level === "off")
+        return { findings: acc.findings, skipped: [...acc.skipped, { rule: rule.id, why: offReason(rule, settings, preset, genre, reasonsFor(doc)) }] };
       const noTags = untagged(rule, doc);
       if (noTags !== undefined) return { findings: acc.findings, skipped: [...acc.skipped, { rule: rule.id, why: noTags }] };
       // 木は capability ではなく、adapter が structure を持つかで決まる。持たない言語で動かすと「参照先が無い」が 0 件に見える。
@@ -190,6 +204,7 @@ export const runRules = (
         limit: limitFor(rule, level, genre, limits),
         lexicon: rule.word_list === undefined ? undefined : doc.lexicons[rule.word_list],
         where: rule.where,
+        fullSentence: rule.full_sentence,
       };
       const found = detector(doc, options).map((finding) => place(starts, { ...finding, rule: rule.id, severity: rule.severity }));
       return { findings: [...acc.findings, ...found], skipped: acc.skipped };
@@ -197,8 +212,10 @@ export const runRules = (
     { findings: [], skipped: [] },
   );
   const composites = applicable
-    .filter((rule) => rule.from.length > 0 && levelFor(rule, settings, experimental) !== "off")
-    .flatMap((rule) => compositeOf(rule, outcome.findings, limitFor(rule, levelFor(rule, settings, experimental), genre, limits), starts, doc.language));
+    .filter((rule) => rule.from.length > 0 && levelFor(rule, settings, experimental, preset) !== "off")
+    .flatMap((rule) =>
+      compositeOf(rule, outcome.findings, limitFor(rule, levelFor(rule, settings, experimental, preset), genre, limits), starts, doc.language),
+    );
   const all = [...outcome.findings, ...composites];
-  return { ...outcome, findings: [...all].sort((left, right) => left.line - right.line), forcedExperimental: forced };
+  return { ...outcome, findings: all.toSorted((left, right) => left.line - right.line), forcedExperimental: forced, presetExperimental: presetOn };
 };

package/src/semantic.ts

@@ -1,3 +1,5 @@
+import { calendarUnitsOf } from "./calendar-number.ts";
+import { closingAndEarlier, newNumbers } from "./closing-numbers.ts";
 import type { ProseDocument, Section } from "./plugin.ts";
 
 /**
@@ -27,17 +29,23 @@ export const riskDisclosure: Filter = (doc) => {
   return [{ text: body.slice(0, 4000), offset: doc.sentences[0]?.span.start ?? 0 }];
 };
 
-const EVIDENCE = /\d|`|https?:\/\//u;
+const EVIDENCE = /`|https?:\/\//u;
+
+/** 結びに、前に書いていない数があるか。本文の数を繰り返すだけ（「以上のように、9月は…」）なら具体物ではない。 */
+const hasNewNumber = (doc: ProseDocument, last: Section): boolean => {
+  const { closing, earlier } = closingAndEarlier(doc, last);
+  return newNumbers(closing, earlier, calendarUnitsOf(doc)).length > 0;
+};
 
 /**
  * 結びが本文の要約でしかないか。
- * 最後の節だけを見て、そこに具体物が無いときにだけ問い合わせる。
+ * 最後の節だけを見て、そこに具体物（前に書いていない数、コード、リンク）が無いときにだけ問い合わせる。
  */
 export const emptyConclusion: Filter = (doc) => {
   const last = doc.sections.at(-1);
   if (last === undefined || last.sentences.length === 0) return [];
   const text = sectionText(doc, last);
-  if (EVIDENCE.test(text)) return [];
+  if (EVIDENCE.test(text) || hasNewNumber(doc, last)) return [];
   return [{ text: text.slice(0, 2000), offset: last.sentences[0]?.span.start ?? last.span.start }];
 };