chaffjs 0.28.0 → 0.30.0

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 -->
 

package/src/cli.ts

@@ -50,6 +50,7 @@ import { notRunAmong } from "./not-run.ts";
 import { settingProblems } from "./setting-problems.ts";
 import { withExtensions } from "./extension/load.ts";
 import { offOnlyAsExperimental } from "./experimental-alone.ts";
+import { levelFor } from "./run.ts";
 import { DEFAULT_GENRE } from "./init-choice.ts";
 import { stoppingOnYamlFileError } from "./config/yaml-file.ts";
 
@@ -236,7 +237,7 @@ const explain = (config: Config, ruleId: string | undefined, genreFlag: string |
     return 1;
   }
   const preset = genre === undefined ? {} : presetLevels(genre);
-  const current = config.rules[rule.id] ?? preset[rule.id] ?? (rule.status === "experimental" && !config.experimental ? "off" : "normal");
+  const current = levelFor(rule, config.rules, config.experimental, preset);
   const alone = offOnlyAsExperimental(rule, config, genre ?? DEFAULT_GENRE, preset, language);
   console.log(renderExplain(rule, current, language, genre, { ...settingSourcesOf(config, rule.id, language), offOnlyAsExperimental: alone }));
   return 0;

package/src/commands/cite-claims.ts

@@ -0,0 +1,103 @@
+// The claims file `chaff cite` reads: [{ source?, address?, quote }]. Pure: the shape is checked and every problem named,
+// so a half-filled file (a scaffold with a source left empty) stops with a reason instead of passing.
+import { isAnywhere, type Citation } from "../structure/cite.ts";
+import type { Texts, UiLanguage } from "../ui.ts";
+
+/** A citation and, when the claims file names it, the source it quotes: a file path, relative to the claims file. */
+export type Claim = Citation & { readonly source?: string };
+
+export type ParsedCitations = { readonly citations: readonly Claim[] } | { readonly error: string };
+
+type RawClaim = { readonly source?: string; readonly address?: string; readonly quote: string };
+
+const isRecord = (value: unknown): value is Record<string, unknown> => typeof value === "object" && value !== null && !Array.isArray(value);
+
+const isOptionalString = (value: unknown): boolean => value === undefined || typeof value === "string";
+
+const isRawClaim = (value: unknown): value is RawClaim =>
+  isRecord(value) && isOptionalString(value["address"]) && isOptionalString(value["source"]) && typeof value["quote"] === "string";
+
+const claimOf = (raw: RawClaim): Claim => ({
+  ...(raw.source === undefined ? {} : { source: raw.source }),
+  address: raw.address ?? "",
+  quote: raw.quote,
+});
+
+/** Neither an address nor a quote: saying ✓ would pass an entry nobody filled in. */
+const isEmpty = (claim: Claim): boolean => isAnywhere(claim) && claim.quote.trim() === "";
+
+/** The source a claim names, or undefined when it names none (missing, empty or blank). */
+export const sourceOf = (claim: Claim): string | undefined => {
+  const source = claim.source?.trim() ?? "";
+  return source === "" ? undefined : source;
+};
+
+type ClaimsText = {
+  readonly notJson: (why: string) => string;
+  readonly notArray: string;
+  readonly badEntry: (n: number) => string;
+  readonly emptyEntry: (n: number) => string;
+  readonly noSource: (n: number) => string;
+  readonly twoSources: (n: number) => string;
+};
+
+export const CLAIMS_TEXT: Texts<ClaimsText> = {
+  ja: {
+    notJson: (why) => `JSON として読めません: ${why}`,
+    notArray: '引用は配列で渡してください: [{ "address": "3.2", "quote": "…" }]',
+    badEntry: (n) => `${String(n)} 件目に quote（文字列）が無いか、address か source が文字列ではありません`,
+    emptyEntry: (n) => `${String(n)} 件目は address も quote も空で、確かめることがありません`,
+    noSource: (n) => `${String(n)} 件目に source がありません。原文を引数で渡さないときは、どの引用にも source（原文のファイル）を書いてください`,
+    twoSources: (n) => `${String(n)} 件目が source を書いていますが、原文も引数で渡されています。どちらか一方にしてください`,
+  },
+  en: {
+    notJson: (why) => `Not valid JSON: ${why}`,
+    notArray: 'Give the quotations as an array: [{ "address": "3.2", "quote": "…" }]',
+    badEntry: (n) => `Entry ${String(n)} needs quote (a string), and its address and source, if it has them, must be strings`,
+    emptyEntry: (n) => `Entry ${String(n)} has neither an address nor a quote, so there is nothing to check`,
+    noSource: (n) => `Entry ${String(n)} has no source. Without a source on the command line, every quotation needs one (the source's file)`,
+    twoSources: (n) => `Entry ${String(n)} names a source, and a source was also given on the command line. Give one or the other`,
+  },
+};
+
+const parseJson = (text: string, ui: UiLanguage): { readonly value: unknown } | { readonly error: string } => {
+  try {
+    return { value: JSON.parse(text) };
+  } catch (err) {
+    return { error: CLAIMS_TEXT[ui].notJson(err instanceof Error ? err.message : String(err)) };
+  }
+};
+
+/** 引用の一覧。[{ source?, address?, quote }] の配列だけを受け取る。address を省けば原文のどこか。形が違えば理由を返す。 */
+export const parseCitations = (text: string, ui: UiLanguage = "ja"): ParsedCitations => {
+  const parsed = parseJson(text, ui);
+  if ("error" in parsed) return parsed;
+  if (!Array.isArray(parsed.value)) return { error: CLAIMS_TEXT[ui].notArray };
+  const entries: readonly unknown[] = parsed.value;
+  const bad = entries.findIndex((entry) => !isRawClaim(entry));
+  if (bad !== -1) return { error: CLAIMS_TEXT[ui].badEntry(bad + 1) };
+  const citations = entries.filter(isRawClaim).map(claimOf);
+  const empty = citations.findIndex(isEmpty);
+  if (empty !== -1) return { error: CLAIMS_TEXT[ui].emptyEntry(empty + 1) };
+  return { citations };
+};
+
+/**
+ * Where each claim's source comes from. With a source on the command line, no claim may name its own; without one,
+ * every claim must. undefined when the claims agree with how cite was called, otherwise the reason.
+ */
+export const sourceProblem = (claims: readonly Claim[], sourceGiven: boolean, ui: UiLanguage): string | undefined => {
+  const at = claims.findIndex((claim) => (sourceOf(claim) === undefined) !== sourceGiven);
+  if (at === -1) return undefined;
+  return sourceGiven ? CLAIMS_TEXT[ui].twoSources(at + 1) : CLAIMS_TEXT[ui].noSource(at + 1);
+};
+
+/** The claims of each source, in the order the sources first appear. Every claim names its source (sourceProblem passed). */
+export const bySource = (claims: readonly Claim[]): { readonly source: string; readonly claims: readonly Claim[] }[] => {
+  const groups = new Map<string, Claim[]>();
+  claims.forEach((claim) => {
+    const source = sourceOf(claim) ?? "";
+    groups.set(source, [...(groups.get(source) ?? []), claim]);
+  });
+  return [...groups].map(([source, own]) => ({ source, claims: own }));
+};

package/src/commands/cite-page.ts

@@ -0,0 +1,61 @@
+import { fetchPage, type Fetcher } from "../html/fetch-page.ts";
+import { pageDocument } from "../html/page-document.ts";
+import { resolveGenre } from "../resolve-genre.ts";
+import { treeFromSource, treeLanguage, type SourceTree, type TreeContext } from "./tree.ts";
+import type { Texts } from "../ui.ts";
+
+/** A source on the web: read once, then checked like a file. The network is reached only through fetchPage. */
+export type CiteContext = TreeContext & {
+  /** What fetches a page. Tests pass a stand-in; the command line never does. */
+  readonly fetcher?: Fetcher;
+};
+
+/** Long enough for a slow page, short enough that a dead host does not hold up a run of checks. */
+const PAGE_TIMEOUT_MS = 30_000;
+
+/** Far beyond any article or statute page; a log or a dump served as text is refused instead of read whole. */
+const MAX_PAGE_BYTES = 20 * 1024 * 1024;
+
+const WEB = /^https?:\/\//iu;
+
+export const isWebSource = (source: string): boolean => WEB.test(source);
+
+const TEXT: Texts<{
+  readonly unfetched: (why: string) => string;
+  readonly unsupported: (url: string, type: string) => string;
+  readonly noStructure: (url: string, language: string) => string;
+}> = {
+  ja: {
+    unfetched: (why) => `ページを取得できませんでした: ${why}`,
+    unsupported: (url, type) => `${url}: ${type} は文字の文書として読めません（HTML、Markdown、テキストのページを渡してください）`,
+    noStructure: (url, language) => `${url}: 言語 ${language} のパッケージは文書の構造を読めません（structure がありません）`,
+  },
+  en: {
+    unfetched: (why) => `Could not fetch the page: ${why}`,
+    unsupported: (url, type) => `${url}: ${type} cannot be read as a text document (give an HTML, Markdown or plain-text page)`,
+    noStructure: (url, language) => `${url}: the ${language} package cannot read a document's structure (it has no structure)`,
+  },
+};
+
+/**
+ * A web page as a tree, read as `chaff tree` reads a file: HTML becomes Markdown first, so its headings are addresses.
+ * Once fetched, the same page gives the same tree. undefined, after saying why, when it cannot be fetched or read.
+ */
+export const readPageTree = async (url: string, argv: readonly string[], context: CiteContext): Promise<SourceTree | undefined> => {
+  const text = TEXT[context.ui ?? "ja"];
+  const fetched = await fetchPage(url, { timeout_ms: PAGE_TIMEOUT_MS, max_bytes: MAX_PAGE_BYTES }, context.fetcher).catch((err: unknown) => {
+    console.error(text.unfetched(err instanceof Error ? err.message : String(err)));
+    return undefined;
+  });
+  if (fetched === undefined) return undefined;
+  const page = pageDocument(fetched.contentType, fetched.text);
+  if ("unsupported" in page) {
+    console.error(text.unsupported(url, page.unsupported));
+    return undefined;
+  }
+  const language = treeLanguage(page.path, page.text, argv, context);
+  const genre = resolveGenre(page.path, page.text, context.config, context.flag(argv, "--genre")).genre;
+  const tree = await treeFromSource(page.path, page.text, language, genre, context.config);
+  if (tree === undefined) console.error(text.noStructure(url, language));
+  return tree === undefined ? undefined : { source: page.text, tree };
+};

package/src/commands/cite-scaffold.ts

@@ -0,0 +1,27 @@
+import { documentQuotesWithoutSource } from "../detectors/quote-without-source.ts";
+import type { ProseDocument } from "../plugin.ts";
+import { readDocument } from "./read-document.ts";
+import type { TreeContext } from "./tree.ts";
+
+/** One entry of the claims file the writer fills in: the source the words come from, and where in it (empty: anywhere). */
+export type ScaffoldClaim = { readonly source: string; readonly address: string; readonly quote: string };
+
+/**
+ * The quotations quote-without-source finds in a document, as cite's claims with the source and address left for the
+ * writer. The rule's genre and level do not apply: asking for a scaffold is asking for every such quotation.
+ */
+export const scaffoldClaims = (doc: ProseDocument): ScaffoldClaim[] =>
+  documentQuotesWithoutSource(doc).map((found) => ({ source: "", address: "", quote: found.quote }));
+
+/** Prints the claims file for one document. The writer fills in each source and runs `chaff cite <claims.json>`. */
+export const runScaffold = async (targets: readonly string[], argv: readonly string[], context: TreeContext, usage: string): Promise<number> => {
+  const [path] = targets;
+  if (path === undefined || targets.length !== 1) {
+    console.error(usage);
+    return 1;
+  }
+  const read = await readDocument(path, argv, context, false);
+  if (read === undefined) return 1;
+  console.log(JSON.stringify(scaffoldClaims(read.doc), null, 2));
+  return 0;
+};