chaffjs 0.4.0 → 0.5.0

package/rules/contraction-consistency.yaml

@@ -0,0 +1,28 @@
+id: contraction-consistency
+layer: L2
+status: experimental
+how_to_find: contraction-mix
+word_list: contraction
+languages: [en]
+severity: info
+
+name:
+  ja: 短縮形の使いかたが揃っていない
+  en: Contraction use is inconsistent
+
+why:
+  ja: 短縮形を使うかどうかは文体の選択で、どちらが正しいかは決めません。1 つの文書で混ざっていると、読み手は文ごとに距離感を測り直すことになります。
+  en: Whether to use contractions is a choice of register, and neither is wrong. Mixed within one document, the reader re-measures the distance sentence by sentence.
+
+message:
+  ja: 「{matched}」だけ他と書きかたが違います（そういう書きかたが {count} 種）
+  en: '"{matched}" is written differently from the rest of the document'
+
+how_to_fix:
+  ja: 多いほうに揃えてください。
+  en: Match the majority.
+
+# 少数派が何種までなら「混在」と見るか。これを超えたら混在ではなく、そういう文体。
+levels: { strict: 4, normal: 2, relaxed: 1 }
+
+use_for: [blog, business, technical]

package/rules/max-paragraph-length.yaml

@@ -1,6 +1,6 @@
 id: max-paragraph-length
 layer: L1
-status: experimental
+status: stable
 how_to_find: paragraph-length
 severity: warning
 

package/rules/ngram-repetition.yaml

@@ -1,6 +1,6 @@
 id: ngram-repetition
 layer: L1
-status: experimental
+status: stable
 how_to_find: ngram-repetition
 severity: info
 

package/rules/no-doubled-joshi.yaml

@@ -1,6 +1,6 @@
 id: no-doubled-joshi
 layer: L3
-status: experimental
+status: stable
 how_to_find: doubled-particle
 word_list: nesting-particle
 requires: [pos]

package/rules/no-em-dash.yaml

@@ -0,0 +1,32 @@
+id: no-em-dash
+layer: L1
+status: experimental
+how_to_find: dash-density
+
+# 記号の許容度は言語で違う。英語では正当な用法が多く、日本語の組版では扱いが難しい。spec §12.4。
+severity:
+  ja: warning
+  en: info
+
+name:
+  ja: ダッシュが多い
+  en: Too many dashes
+
+why:
+  ja: 日本語の組版でダッシュは扱いが難しく、環境によって長さも見えかたも変わります。読点や括弧で書けることが多いです。
+  en: In English a dash is a legitimate tool, and a heavy hand with it is also one of the better-known marks of generated text. On its own it says little; it counts toward the composite signal.
+
+message:
+  ja: 1000 字あたり {density} 個のダッシュがあります（{limit} 個まで）
+  en: "{density} dashes per 1000 words (limit {limit})"
+
+how_to_fix:
+  ja: 読点か括弧に置き換えてください。挟み込みなら括弧、言い換えなら読点が読みやすいです。
+  en: A comma or a pair of brackets usually reads better.
+
+# 1000 あたりの個数。英語は許容度が高いので緩い。
+levels:
+  ja: { strict: 1, normal: 3, relaxed: 8 }
+  en: { strict: 3, normal: 8, relaxed: 20 }
+
+use_for: [blog, business, technical]

package/rules/no-nakaguro-parallel.yaml

@@ -1,6 +1,6 @@
 id: no-nakaguro-parallel
 layer: L3
-status: experimental
+status: stable
 how_to_find: middle-dot
 languages: [ja]
 severity: info

package/rules/preamble-length.yaml

@@ -1,6 +1,6 @@
 id: preamble-length
 layer: L1
-status: experimental
+status: stable
 how_to_find: preamble-length
 severity: info
 

package/rules/taigen-dome-in-prose.yaml

@@ -1,6 +1,6 @@
 id: taigen-dome-in-prose
 layer: L3
-status: experimental
+status: stable
 how_to_find: noun-ending
 requires: [pos]
 languages: [ja]

package/src/adapter-load.ts

@@ -2,10 +2,47 @@ import type { LanguageAdapter } from "./plugin.ts";
 
 const ADAPTER_PACKAGE: Readonly<Record<string, string>> = { ja: "@chaffjs/lang-ja", en: "@chaffjs/lang-en" };
 
+/** core が読める契約の版。合わないアダプタは、動かしてから壊れるより先に断る。 */
+const API_VERSION = 1;
+
+const isCapabilities = (value: unknown): boolean => {
+  if (typeof value !== "object" || value === null) return false;
+  const record: Record<string, unknown> = { ...value };
+  const unit = record["lengthUnit"];
+  return (
+    record["sentenceSplit"] === true && (unit === "char" || unit === "word") && ["wordSplit", "pos", "lemma"].every((name) => typeof record[name] === "boolean")
+  );
+};
+
+/**
+ * 形だけを見る。中身が正しいかは動かさないと分からないが、**形が違うものを通すと
+ * 指摘 0 件で終わる**。0 件は「問題なし」と見分けがつかない。
+ */
 const isAdapter = (value: unknown): value is LanguageAdapter => {
   if (typeof value !== "object" || value === null) return false;
   const record: Record<string, unknown> = { ...value };
-  return record["kind"] === "language" && typeof record["id"] === "string" && typeof record["segment"] === "function";
+  return (
+    record["kind"] === "language" &&
+    typeof record["id"] === "string" &&
+    record["id"] !== "" &&
+    record["apiVersion"] === API_VERSION &&
+    typeof record["segment"] === "function" &&
+    typeof record["detect"] === "function" &&
+    isCapabilities(record["capabilities"])
+  );
+};
+
+/**
+ * 形が違うときに、どこが違うのかを返す。満たしていれば undefined。
+ * 「読めません」だけでは、アダプタを書いた人が直せない。
+ */
+export const checkAdapter = (value: unknown): string | undefined => {
+  if (isAdapter(value)) return undefined;
+  if (typeof value !== "object" || value === null) return "object ではありません";
+  const record: Record<string, unknown> = { ...value };
+  if (record["apiVersion"] !== API_VERSION) return `apiVersion が ${String(record["apiVersion"])} です（core は ${String(API_VERSION)}）`;
+  if (!isCapabilities(record["capabilities"])) return "capabilities の形が違います";
+  return "kind / id / segment / detect のどれかがありません";
 };
 
 const pickExport = (module: object): unknown => {
@@ -26,6 +63,7 @@ export const loadAdapter = async (language: string): Promise<LanguageAdapter> =>
   const module: unknown = await import(specifier);
   if (typeof module !== "object" || module === null) throw new Error(`${specifier} did not export a module`);
   const candidate = pickExport(module);
-  if (!isAdapter(candidate)) throw new Error(`${specifier} does not export a LanguageAdapter`);
+  const broken = checkAdapter(candidate);
+  if (broken !== undefined || !isAdapter(candidate)) throw new Error(`${specifier} が LanguageAdapter を export していません: ${broken ?? ""}`);
   return candidate;
 };

package/src/backends/anthropic.ts

@@ -5,7 +5,7 @@ import Anthropic from "@anthropic-ai/sdk";
 import { toFailure } from "./types.ts";
 import type { Failure, Judge, Prompt } from "./types.ts";
 
-export type AnthropicResponse = { readonly content: readonly { readonly type: string; readonly text?: string | undefined }[] };
+type AnthropicResponse = { readonly content: readonly { readonly type: string; readonly text?: string | undefined }[] };
 
 /** judge が使うのは messages.create だけ。最小の面だけを要求する。テストで差し替えられる。 */
 export type AnthropicClient = { readonly messages: { readonly create: (params: Anthropic.MessageCreateParamsNonStreaming) => Promise<AnthropicResponse> } };
@@ -26,7 +26,7 @@ export const DEFAULT_MODEL = "claude-opus-5";
  */
 const ENV_KEYS = ["ANTHROPIC_API_KEY", "ANTHROPIC_AUTH_TOKEN", "ANTHROPIC_IDENTITY_TOKEN", "ANTHROPIC_IDENTITY_TOKEN_FILE"];
 
-export const configDir = (): string => process.env["ANTHROPIC_CONFIG_DIR"] ?? join(homedir(), ".config", "anthropic");
+const configDir = (): string => process.env["ANTHROPIC_CONFIG_DIR"] ?? join(homedir(), ".config", "anthropic");
 
 export const hasCredentials = (profileDir: string = configDir()): boolean =>
   ENV_KEYS.some((name) => (process.env[name] ?? "").length > 0) || existsSync(profileDir);

package/src/backends/openai.ts

@@ -2,7 +2,7 @@ import OpenAI from "openai";
 import { toFailure } from "./types.ts";
 import type { Failure, Judge, Prompt } from "./types.ts";
 
-export type OpenAIResponse = { readonly choices: readonly { readonly message: { readonly content: string | null } }[] };
+type OpenAIResponse = { readonly choices: readonly { readonly message: { readonly content: string | null } }[] };
 
 /** judge が使うのは chat.completions.create だけ。最小の面だけを要求する。 */
 export type OpenAIClient = {

package/src/backends/types.ts

@@ -12,7 +12,7 @@ export type Judge = (prompt: Prompt) => Promise<string>;
 
 export type BackendName = "anthropic" | "openai";
 
-export const BACKENDS: readonly BackendName[] = ["anthropic", "openai"];
+const BACKENDS: readonly BackendName[] = ["anthropic", "openai"];
 
 export const isBackend = (value: unknown): value is BackendName => BACKENDS.some((name) => name === value);
 

package/src/cli.ts

@@ -1,6 +1,6 @@
 import { readFile } from "node:fs/promises";
-import { existsSync } from "node:fs";
-import { join } from "node:path";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
 import { loadAdapter, packageFor } from "./adapter-load.ts";
 import { CONFIG_FILE, EMPTY, loadConfig, type Config } from "./config/load.ts";
 import { applyByPath } from "./config/by-path.ts";
@@ -21,6 +21,8 @@ import { renderCompact } from "./render/compact.ts";
 import { renderExplain } from "./render/explain.ts";
 import { renderFriendly } from "./render/friendly.ts";
 import { rulesJson } from "./render/rules-json.ts";
+import { renderSarif } from "./render/sarif.ts";
+import { VERSION } from "./version.ts";
 import { renderSummary, type FileOutcome } from "./render/summary.ts";
 import { neededBy, runRules } from "./run.ts";
 import type { Level, RuleDefinition } from "./plugin.ts";
@@ -45,6 +47,7 @@ const USAGE = `chaff — 文章の読みにくいところを見つけます。
   --show-baseline   棚上げした分も含めて全部見る
   --watch           保存のたびに見直し、変わったところだけ出す
   --dry-run         test で、何を AI に送るかだけを見る（API を呼びません）
+  --sarif <path>    指摘を SARIF で書き出す（GitHub の PR の行に出すため）
 
 この箇所だけ黙らせる:  <!-- stet: rule-id — 理由 -->
 
@@ -81,7 +84,15 @@ const flag = (argv: readonly string[], name: string): string | undefined => {
   return at === -1 ? undefined : argv[at + 1];
 };
 
-type Inspected = { readonly text: string; readonly outcome: FileOutcome; readonly perFile: PerFile; readonly all: readonly string[] };
+type Inspected = {
+  readonly text: string;
+  readonly rules: readonly RuleDefinition[];
+  /** ファイルごとの言語。by_path で 1 つの repo に 2 言語が混ざる。 */
+  readonly language: string;
+  readonly outcome: FileOutcome;
+  readonly perFile: PerFile;
+  readonly all: readonly string[];
+};
 
 const headerFor = (path: string, genre: string, from: string, language: string, shelved: number, hushed: number): string => {
   const shelf = shelved > 0 ? `   棚上げ ${shelved} 件` : "";
@@ -112,12 +123,30 @@ const inspect = async (path: string, config: Config, argv: readonly string[]): P
   const text = argv.includes("--compact") ? renderCompact(header, result, rules, language) : renderFriendly(header, result, rules, language);
   return {
     text,
+    rules,
+    language,
     outcome: { path, findings: split.fresh, notRun: raw.skipped.length },
     perFile: { path, suppressed: applied.suppressed, reasonless: applied.unusedReasonless },
     all: applied.kept.map((finding) => fingerprint(path, finding)),
   };
 };
 
+/**
+ * 指摘を PR の変更行に出すための出口。--sarif <path> を書いたときだけ作る。
+ * 端末の出力は変えない。CI で上げるためのファイルが増えるだけ。
+ */
+const writeSarif = (results: readonly Inspected[], argv: readonly string[]): void => {
+  const path = flag(argv, "--sarif");
+  if (path === undefined) return;
+  // 文言はファイルの言語で描く。by_path で 1 つの repo に 2 言語が混ざるため。
+  const located = results.flatMap((result) =>
+    result.outcome.findings.map((finding) => ({ path: result.outcome.path, finding, language: result.language, rules: result.rules })),
+  );
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, renderSarif(located, VERSION), "utf8");
+  console.log(`\n  SARIF を書きました: ${path}（${located.length} 件）`);
+};
+
 const lint = async (targets: readonly string[], argv: readonly string[]): Promise<number> => {
   const paths = collectTargets(targets);
   if (paths.length === 0) {
@@ -132,6 +161,7 @@ const lint = async (targets: readonly string[], argv: readonly string[]): Promis
     return 1;
   }
   const results = await Promise.all(paths.map((path) => inspect(path, config, argv)));
+  writeSarif(results, argv);
   results.filter((result) => result.outcome.findings.length > 0 || paths.length === 1).forEach((result) => console.log(result.text));
   renderSummary(results.map((result) => result.outcome)).forEach((line) => console.log(line));
   return results.some((result) => result.outcome.findings.some((finding) => finding.severity === "error")) ? 1 : 0;

package/src/config/load.ts

@@ -29,7 +29,7 @@ export type Config = {
 
 /** 判定の質が誤検知に直結するので、既定は最上位のモデル。cost は絞り込みで削る。spec §14。 */
 /** 既定は Anthropic。openai にすると判定役だけが替わり、rule も判定の形も変わらない。 */
-export const DEFAULT_BACKEND: BackendName = "anthropic";
+const DEFAULT_BACKEND: BackendName = "anthropic";
 
 export const EMPTY: Config = {
   genre: undefined,

package/src/detectors/en-shape.ts

@@ -134,7 +134,8 @@ export const titleCaseMix: Detector = (doc, options): Finding[] => {
   const title = judged.filter((entry) => entry.title).length;
   const minorityIsTitle = title <= judged.length - title;
   const few = minorityIsTitle ? title : judged.length - title;
-  if (few === 0 || few > options.limit) return [];
+  // 同数なら少数派は無い。どちらかを「他と違う」と呼ぶのは、選びかたが恣意的になる。
+  if (few === 0 || few * 2 === judged.length || few > options.limit) return [];
   return judged
     .filter((entry) => entry.title === minorityIsTitle)
     .map(({ section }) => ({
@@ -173,7 +174,8 @@ export const oxfordComma: Detector = (doc, options): Finding[] => {
   const withComma = judged.filter((entry) => entry.oxford).length;
   const minorityUsesComma = withComma <= judged.length - withComma;
   const few = minorityUsesComma ? withComma : judged.length - withComma;
-  if (few === 0 || few > options.limit) return [];
+  // 同数なら少数派は無い。
+  if (few === 0 || few * 2 === judged.length || few > options.limit) return [];
   return judged
     .filter((entry) => entry.oxford === minorityUsesComma)
     .map(({ sentence }) => ({

package/src/detectors/heading-echo.ts

@@ -1,4 +1,5 @@
-import type { Detector, Finding } from "../plugin.ts";
+import { lengthOf } from "../measure.ts";
+import type { Detector, Finding, LengthUnit, Section } from "../plugin.ts";
 
 /** 見出しが短すぎると、偶然の一致で 100% になる。これ未満の見出しは見ない。 */
 const MIN_GRAMS = 4;
@@ -8,7 +9,9 @@ const MIN_GRAMS = 4;
  * 語 n-gram にすると wordSplit capability が要り、L1（言語を問わず動く）から外れる。
  */
 const trigrams = (text: string): Set<string> => {
-  const clean = [...text.replace(/\s+/gu, "")];
+  // 大文字小文字を畳む。英語では見出しが Title Case、本文が小文字になり、
+  // 同じ語でも一致しなくなる（Generating Output → generated output）。
+  const clean = [...text.toLowerCase().replace(/\s+/gu, "")];
   return new Set(clean.slice(0, Math.max(0, clean.length - 2)).map((__char, index) => clean.slice(index, index + 3).join("")));
 };
 
@@ -25,9 +28,32 @@ const containment = (heading: Set<string>, sentence: Set<string>): number => {
   return [...heading].filter((gram) => sentence.has(gram)).length / heading.size;
 };
 
+/**
+ * 見出しの語を含んでいても、文がそのぶん以上に中身を足していれば「何も受け取れない」ではない。
+ *
+ * 実文書（英語 11 本）で測ったら、この条件なしでは 72.7% の文書が該当した。
+ * 「## ToolsAgent」に対する「GraphAI provides ToolsAgent components that use LLMs to…」は
+ * 見出しの語を含むが、読み進める価値がある。見出し以外の中身の量で分ける。
+ */
+const NEW_MATERIAL = { word: 6, char: 20 };
+
+const headingUnits = (heading: string, unit: LengthUnit): number =>
+  unit === "word"
+    ? heading
+        .trim()
+        .split(/\s+/u)
+        .filter((word) => word.length > 0).length
+    : heading.replace(/\s+/gu, "").length;
+
+const addsLittle = (section: Section, unit: LengthUnit): boolean => {
+  const first = section.firstSentence;
+  if (first === undefined) return false;
+  return lengthOf(first, unit) - headingUnits(section.heading, unit) <= NEW_MATERIAL[unit];
+};
+
 export const headingEcho: Detector = (doc, options): Finding[] =>
   doc.sections
-    .filter((section) => section.heading.length > 0 && section.firstSentence !== undefined)
+    .filter((section) => section.heading.length > 0 && section.firstSentence !== undefined && addsLittle(section, doc.lengthUnit))
     .map((section) => ({ section, overlap: Math.round(containment(trigrams(section.heading), trigrams(section.firstSentence?.text ?? "")) * 100) }))
     .filter(({ overlap }) => overlap >= options.limit)
     .map(({ section, overlap }) => ({

package/src/detectors/index.ts

@@ -11,8 +11,8 @@ import { doubledParticle, nounEnding } from "./token-shape.ts";
 import { kanjiRun, middleDot } from "./char-shape.ts";
 import { adverbDensity, conjunctionRun, expletive, oxfordComma, titleCaseMix } from "./en-shape.ts";
 import { paragraphLength, paragraphVariance, preambleLength, ruleOfThree, sectionUniformity } from "./structure.ts";
-import { concreteEvidence, emojiDensity, ngramRepetition, undefinedAcronym } from "./signals.ts";
-import { aiTell, cushionDensity, hedgingDensity, repeatedConjunction, unqualifiedSuperlative } from "./lexicon.ts";
+import { concreteEvidence, dashDensity, emojiDensity, ngramRepetition, undefinedAcronym } from "./signals.ts";
+import { aiTell, contractionMix, cushionDensity, hedgingDensity, repeatedConjunction, unqualifiedSuperlative } from "./lexicon.ts";
 import { internalJargon, properNounDensity, requiredSections } from "./team.ts";
 
 /** rule 定義の how_to_find がここを引く。rule 側は実装を知らない。 */
@@ -40,6 +40,7 @@ export const DETECTORS: Readonly<Record<string, Detector>> = {
   "rule-of-three": ruleOfThree,
   "preamble-length": preambleLength,
   "emoji-density": emojiDensity,
+  "dash-density": dashDensity,
   "ngram-repetition": ngramRepetition,
   "undefined-acronym": undefinedAcronym,
   "concrete-evidence": concreteEvidence,
@@ -48,6 +49,7 @@ export const DETECTORS: Readonly<Record<string, Detector>> = {
   "unqualified-superlative": unqualifiedSuperlative,
   "repeated-conjunction": repeatedConjunction,
   "ai-tell": aiTell,
+  "contraction-mix": contractionMix,
   "internal-jargon": internalJargon,
   "required-sections": requiredSections,
   "proper-noun-density": properNounDensity,

package/src/detectors/lexicon.ts

@@ -122,3 +122,44 @@ export const aiTell: Detector = (doc, options): Finding[] => {
     },
   ];
 };
+
+/**
+ * 同じことを言う 2 つの書きかたが、1 つの文書で混ざっているか。
+ *
+ * **どちらが正しいかは決めない。** 短縮形を使うかどうかは文体の選択で、
+ * 立場を取ると方針の違う書き手に rule ごと無視される。spec §12.3。
+ *
+ * 語彙表は対を持つ（`pattern` と `instead_of`）。片方だけを数えても、
+ * 意図した硬い文体なのか不統一なのかが分からない。
+ */
+/**
+ * 語の境界で照合する。部分一致だと「it isn't」が「it is」を含んでしまい、
+ * 短縮形を使っている文が「使っていない」側に数えられる。
+ */
+const containsWord = (text: string, word: string): boolean => new RegExp(`\\b${word.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&")}\\b`, "u").test(text);
+
+export const contractionMix: Detector = (doc, options): Finding[] => {
+  const pairs = (options.lexicon ?? []).flatMap((entry) => (entry.instead_of === undefined ? [] : [{ short: entry.pattern, long: entry.instead_of }]));
+  const body = doc.sentences.map((sentence) => sentence.text.toLowerCase()).join(" ");
+  const used = pairs.filter((pair) => containsWord(body, pair.short.toLowerCase()));
+  const spelled = pairs.filter((pair) => containsWord(body, pair.long.toLowerCase()));
+  // 片方しか無ければ一貫している。両方あるときだけ、少数派を指摘する。
+  if (used.length === 0 || spelled.length === 0) return [];
+  const minorityIsShort = used.length <= spelled.length;
+  const few = minorityIsShort ? used : spelled;
+  if (few.length > options.limit) return [];
+  const wanted = few.map((pair) => (minorityIsShort ? pair.short : pair.long).toLowerCase());
+  const hits = doc.sentences.flatMap((sentence) => {
+    const text = sentence.text.toLowerCase();
+    const matched = wanted.find((word) => containsWord(text, word));
+    return matched === undefined ? [] : [{ sentence, matched }];
+  });
+  return hits.map((hit) => ({
+    rule: "contraction-consistency",
+    severity: "info",
+    line: 0,
+    column: 0,
+    quote: hit.sentence.text.trim(),
+    values: { matched: hit.matched, count: few.length, limit: options.limit, offset: hit.sentence.span.start },
+  }));
+};

package/src/detectors/signals.ts

@@ -49,13 +49,16 @@ export const emojiDensity: Detector = (doc, options): Finding[] => {
  * 同じ言い回しの繰り返し。character n-gram で見るので、語の区切りが要らない。
  * spec §10 が n-gram を選んだのはこのためで、新しい言語でそのまま動く。
  */
-const GRAM = 8;
+/**
+ * 窓の幅は単位で分ける。同じ 8 文字でも、日本語では 4〜5 形態素だが英語では 1 語半にしかならない。
+ * 実文書（英語 11 本）で 8 文字にしたら、上位は " generat"（generate）のような**語の断片**だった。
+ */
+const GRAM = { char: 8, word: 20 };
 
-/** 短い n-gram は偶然一致する。8 文字は「〜することができます」のような言い回しの長さ。 */
-const countGrams = (text: string): Map<string, number> => {
+const countGrams = (text: string, width: number): Map<string, number> => {
   const counts = new Map<string, number>();
-  Array.from({ length: Math.max(0, text.length - GRAM + 1) }).forEach((_, index) => {
-    const gram = text.slice(index, index + GRAM);
+  Array.from({ length: Math.max(0, text.length - width + 1) }).forEach((_, index) => {
+    const gram = text.slice(index, index + width);
     counts.set(gram, (counts.get(gram) ?? 0) + 1);
   });
   return counts;
@@ -69,7 +72,7 @@ const countGrams = (text: string): Map<string, number> => {
  * どちらを見るかは adapter が宣言する単位で決める。ひらがなを持たない char 単位の言語が
  * 来たら、この見分けは効かなくなる（そのときは adapter 側に判定を移す）。
  */
-const CONNECTIVE = { char: /[ぁ-ゖ]/u, word: / /u };
+const CONNECTIVE = { char: /[ぁ-ゖ]/u, word: /\S \S.*\S \S/u };
 
 const isPhrasing = (gram: string, unit: ProseDocument["lengthUnit"]): boolean => CONNECTIVE[unit].test(gram);
 
@@ -78,7 +81,7 @@ const gramsOf = (doc: ProseDocument): Map<string, number> => {
   const counts = new Map<string, number>();
   doc.sentences.forEach((sentence) => {
     const text = doc.lengthUnit === "char" ? proseText(sentence).replace(/\s+/gu, "") : proseText(sentence);
-    countGrams(text).forEach((count, gram) => counts.set(gram, (counts.get(gram) ?? 0) + count));
+    countGrams(text, GRAM[doc.lengthUnit]).forEach((count, gram) => counts.set(gram, (counts.get(gram) ?? 0) + count));
   });
   return counts;
 };
@@ -143,14 +146,21 @@ const COMMON = new Set([
 /**
  * 展開は略語の**すぐ隣**にあるときだけ認める。
  * 60 文字も見ると、同じ文のどこかに括弧があるだけで「説明済み」になり、1 件も出なくなる。
+ *
+ * 認めるのは 2 つの形。どちらも実際によく書かれる。
+ *   CI（継続的インテグレーション）   略語のあとに括弧
+ *   Continuous Integration (CI)      括弧の中が略語
  */
-const AFTER = /^\s*[(（]/u;
-const BEFORE = /[)）]\s*$/u;
+const OPENS = /^\s*[(（]/u;
+const CLOSES = /^\s*[)）]/u;
+const OPENED = /[(（]\s*$/u;
 
 const isExpanded = (body: string, acronym: string): boolean => {
   const at = body.indexOf(acronym);
   if (at === -1) return false;
-  return AFTER.test(body.slice(at + acronym.length, at + acronym.length + 3)) || BEFORE.test(body.slice(Math.max(0, at - 3), at));
+  const after = body.slice(at + acronym.length, at + acronym.length + 3);
+  const before = body.slice(Math.max(0, at - 3), at);
+  return OPENS.test(after) || (OPENED.test(before) && CLOSES.test(after));
 };
 
 export const undefinedAcronym: Detector = (doc, options): Finding[] => {
@@ -197,3 +207,26 @@ export const concreteEvidence: Detector = (doc, options): Finding[] => {
     },
   }));
 };
+
+/**
+ * ダッシュの多用。英語では正当な用法が多いが、2026 年時点で最も知られた生成文のシグナルでもある。
+ * 日本語の組版ではそもそも扱いが難しい。どちらが正しいかは severity の言語別指定で分ける。spec §12.4。
+ */
+const DASH = /[\u2014\u2015\u2013]/gu;
+
+export const dashDensity: Detector = (doc, options): Finding[] => {
+  const hits = findIn(doc, DASH);
+  const first = hits[0];
+  const rate = density(doc, hits.length);
+  if (wordsOf(doc) < FLOOR[doc.lengthUnit] || first === undefined || rate <= options.limit) return [];
+  return [
+    {
+      rule: "no-em-dash",
+      severity: "info",
+      line: 0,
+      column: 0,
+      quote: first.sentence.text.trim(),
+      values: { count: hits.length, density: rate, limit: options.limit, offset: first.offset },
+    },
+  ];
+};

package/src/document.ts

@@ -76,7 +76,17 @@ const EMPHASIS = new Set(["strong", "emphasis", "delete"]);
  */
 const DIRECTIVE = /^:::[^\n]*/gmu;
 
-const directiveSpans = (source: string): Span[] => [...source.matchAll(DIRECTIVE)].map((match) => ({ start: match.index, end: match.index + match[0].length }));
+/**
+ * `https://…` をそのまま書いた URL。GFM の autolink 拡張を入れていないので mdast では
+ * ただのテキストになり、本文として残る。残すと、見出しと URL の中の識別子が一致して
+ * 「見出しの繰り返し」と読まれる。表示される文字も本文ではない。
+ */
+const BARE_URL = /https?:\/\/[^\s)<>"'\]]+/gu;
+
+const matchSpans = (source: string, pattern: RegExp): Span[] =>
+  [...source.matchAll(pattern)].map((match) => ({ start: match.index, end: match.index + match[0].length }));
+
+const directiveSpans = (source: string): Span[] => [...matchSpans(source, DIRECTIVE), ...matchSpans(source, BARE_URL)];
 
 const collectMasks = (root: Node, source: string): Span[] => {
   const spans: Span[] = [...directiveSpans(source)];

package/src/eval.ts

@@ -63,9 +63,21 @@ const recommend = (rule: RuleDefinition, sweep: readonly Point[], total: number)
   return strictest;
 };
 
+/**
+ * lint で動かない rule は掃引しない。
+ * 動かないものの閾値を測ると、「どの閾値でも 0 件」が「よく校正されている」に見える。
+ */
+const measurable = (rule: RuleDefinition, docs: readonly ProseDocument[], genre: string, language: string): boolean => {
+  if (rule.layer === "L4" || !rule.use_for.some((target) => genre.startsWith(target))) return false;
+  if (rule.languages !== undefined && !rule.languages.includes(language)) return false;
+  if (rule.from.length > 0) return false;
+  const capabilities = docs[0]?.capabilities;
+  return !rule.requires.some((need) => (need === "lemma" ? capabilities?.lemma : capabilities?.pos) !== true);
+};
+
 export const evaluate = (docs: readonly ProseDocument[], rules: readonly RuleDefinition[], genre: string, language: string): RuleReport[] =>
   rules
-    .filter((rule) => rule.layer !== "L4" && rule.use_for.some((target) => genre.startsWith(target)))
+    .filter((rule) => measurable(rule, docs, genre, language))
     .map((rule) => {
       const sweep = candidates(rule).map((limit) => countAt(docs, rule, limit));
       const current = rule.levels.normal ?? 1;

package/src/files.ts

@@ -26,7 +26,7 @@ const expand = (target: string): string[] => {
  * ロケールを明示する。既定のロケールに任せると、同じ入力でも機械によって順序が変わる。
  * 指摘の並びは CI のログにも baseline にも入るので、順序が揺れてはいけない。
  */
-export const byPath = (left: string, right: string): number => left.localeCompare(right, "en");
+const byPath = (left: string, right: string): number => left.localeCompare(right, "en");
 
 export const collectTargets = (targets: readonly string[]): string[] => {
   const found = targets.flatMap(expand).filter((path) => !isSkipped(path));

package/src/levels.ts

@@ -1,6 +1,6 @@
 import type { Level, LevelTable, RuleDefinition } from "./plugin.ts";
 
-export const LEVELS: readonly Level[] = ["strict", "normal", "relaxed", "off"];
+const LEVELS: readonly Level[] = ["strict", "normal", "relaxed", "off"];
 
 export const isLevel = (value: unknown): value is Level => typeof value === "string" && LEVELS.some((level) => level === value);
 

package/src/mask.ts

@@ -7,7 +7,14 @@ import type { Span } from "./plugin.ts";
  * 切り出して繋ぐのではなく覆うのは、オフセットを元文字列と一致させ続けるため。
  * 行・列の計算も、引用して見せる範囲も、これで元の位置のまま使える。
  */
-const blankOut = (text: string): string => text.replace(/[^\n]/gu, " ");
+/**
+ * 空白は**元の文字と同じ UTF-16 長**にする。
+ *
+ * `u` 付きの正規表現は 1 文字（コードポイント）ずつ当たるので、絵文字のような
+ * サロゲートペアを空白 1 つに置き換えると文字列が 1 だけ縮む。mdast のオフセットは
+ * UTF-16 単位なので、そこから先の指摘がすべて 1 ずれる。
+ */
+const blankOut = (text: string): string => text.replace(/[^\n]/gu, (char) => " ".repeat(char.length));
 
 const merge = (spans: readonly Span[]): Span[] =>
   [...spans]

package/src/measure.ts

@@ -13,7 +13,7 @@ export const proseText = (sentence: Sentence): string => sentence.text.replace(/
 
 export const charLength = (sentence: Sentence): number => sentence.text.replace(/\s+/gu, "").length;
 
-export const wordLength = (sentence: Sentence): number =>
+const wordLength = (sentence: Sentence): number =>
   proseText(sentence)
     .split(" ")
     .filter((word) => word.length > 0).length;