chaffjs 0.19.0 → 0.20.0

package/src/check-source.ts

@@ -0,0 +1,75 @@
+import { loadAdapter } from "./adapter-load.ts";
+import { applyByPath } from "./config/by-path.ts";
+import type { Config } from "./config/load.ts";
+import { optionLayersOf } from "./config/option-problems.ts";
+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 { profileFor } from "./profile/for-file.ts";
+import { resolveGenre, type ResolvedGenre } from "./resolve-genre.ts";
+import { neededBy, runRulesWith, type RunContext, type RunResult } from "./run.ts";
+import { runCrossRules } from "./cross-run.ts";
+import { CROSS_DETECTORS } from "./detectors/index.ts";
+import { applySuppressions, type Applied } from "./stet.ts";
+
+/** A document's language when nothing names one for this run: its by_path entry, chaff.yaml's language, then a guess from the text. */
+export const documentLanguage = (path: string, source: string, config: Config): string =>
+  applyByPath(config.byPath, config.baseDir, path).language ?? config.language ?? guessLanguage(source).language;
+
+/** What this run chose over the settings: a language and a genre, when given, and whether experimental rules run. */
+export type CheckChoice = { readonly language?: string | undefined; readonly genre?: string | undefined; readonly experimental: boolean };
+
+/** One document linted: the rules that ran and why others did not, before and after stet silenced some. */
+export type SourceCheck = {
+  readonly language: string;
+  readonly genre: ResolvedGenre;
+  readonly rules: readonly RuleDefinition[];
+  readonly doc: ProseDocument;
+  /** What the rules ran with. The pass over several documents runs with it too. */
+  readonly context: RunContext;
+  readonly raw: RunResult;
+  readonly applied: Applied;
+};
+
+/** 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));
+  const doc = buildDocument(path, source, adapter, teamRules(config, language), profileFor(config, path, source, language, genre.genre));
+  const context: RunContext = {
+    settings: config.rules,
+    experimental: choice.experimental,
+    genre: genre.genre,
+    limits: limitsFor(config, language),
+    optionLayers: optionLayersOf(config),
+    detectors: config.extensions?.detectors ?? {},
+  };
+  const raw = runRulesWith(doc, rules, context);
+  return { language, genre, rules, doc, context, raw, applied: suppressedIn(source, doc, raw) };
+};
+
+/** stet で黙らせたものは、ここで落とす。stet は text（読んだままの本文）から読む。 */
+const suppressedIn = (text: string, doc: ProseDocument, raw: RunResult): Applied =>
+  applySuppressions(
+    text,
+    raw.findings,
+    doc.sections.map((section) => section.span),
+  );
+
+/**
+ * The checks of one run's documents, with the rules that compare documents run over all of them (cross-run.ts), and
+ * stet applied to their findings in the file each lands in. A run of one document comes back as it is.
+ */
+export const crossChecked = (checks: readonly SourceCheck[], detectors: Readonly<Record<string, CrossDetector>> = CROSS_DETECTORS): SourceCheck[] => {
+  if (checks.length < 2) return [...checks];
+  const results = runCrossRules(checks, detectors);
+  return checks.map((check, index) => {
+    const raw = results[index] ?? check.raw;
+    return raw === check.raw ? check : { ...check, raw, applied: suppressedIn(check.doc.source, check.doc, raw) };
+  });
+};

package/src/checks.ts

@@ -1,5 +1,5 @@
-import { existsSync, readFileSync } from "node:fs";
-import { parse } from "yaml";
+import { existsSync } from "node:fs";
+import { readYamlFile } from "./config/yaml-file.ts";
 import type { Level, Severity } from "./plugin.ts";
 
 export const CHECKS_FILE = "checks.yaml";
@@ -61,7 +61,7 @@ const toCheck = (raw: unknown, index: number, source: string): UserCheck | undef
 
 export const loadChecks = (path: string): UserCheck[] => {
   if (!existsSync(path)) return [];
-  const raw: unknown = parse(readFileSync(path, "utf8"));
+  const raw: unknown = readYamlFile(path);
   if (!isRecord(raw) || !Array.isArray(raw["checks"])) return [];
   return raw["checks"].map((entry, index) => toCheck(entry, index, path)).filter((entry) => entry !== undefined);
 };

package/src/cli-args.ts

@@ -2,7 +2,7 @@
  * Options of the commands that take files to check, whose value is the next argument. That value is not a file.
  * `--why` (relax), `--format` and `--language` (tree) belong to commands that read their own arguments.
  */
-const VALUE_FLAGS: ReadonlySet<string> = new Set(["--sarif", "--genre", "--rule", "--line"]);
+const VALUE_FLAGS: ReadonlySet<string> = new Set(["--sarif", "--genre", "--rule", "--line", "--include"]);
 
 /** The arguments that name what to check: everything that is neither an option nor an option's value. */
 export const targetsOf = (args: readonly string[]): string[] =>
@@ -13,3 +13,9 @@ export const withExperimental = <T extends { readonly experimental: boolean }>(c
   ...config,
   experimental: config.experimental || args.includes("--experimental"),
 });
+
+/** The settings with each --include <glob> added to chaff.yaml's include: the command line widens a directory walk as chaff.yaml can. */
+export const withIncludes = <T extends { readonly include?: readonly string[] | undefined }>(config: T, args: readonly string[]): T => {
+  const given = args.flatMap((arg, index) => (index > 0 && args[index - 1] === "--include" && !arg.startsWith("--") ? [arg] : []));
+  return given.length === 0 ? config : { ...config, include: [...(config.include ?? []), ...given] };
+};

package/src/cli-text.ts

@@ -5,6 +5,17 @@ import { counted, formFor } from "./render/plural.ts";
 import type { GenreSetting } from "./genre-check.ts";
 import type { ProfileSetting } from "./profile/check.ts";
 
+/** What a folder walk looked for, and how to look for more. Markdown always; include adds file-name globs. */
+const lookedForJa = (include: readonly string[]): string => {
+  const also = include.length > 0 ? `と ${include.join(" ")}` : "";
+  return `  探したもの: Markdown（.md .markdown .mdx）${also}。ほかのファイルも検査するには、chaff.yaml に include: ["*.yaml"] と書くか、--include "*.yaml" を付けてください。`;
+};
+
+const lookedForEn = (include: readonly string[]): string => {
+  const also = include.length > 0 ? ` and ${include.join(", ")}` : "";
+  return `  Looked for Markdown (.md, .markdown, .mdx)${also}. To check other files too, add include: ["*.yaml"] to chaff.yaml, or pass --include "*.yaml".`;
+};
+
 /** Where a file's genre came from, as the header names it. */
 export type GenreSource = "--genre" | "by_path" | "config" | "default" | "front-matter" | "path" | "content";
 
@@ -24,12 +35,15 @@ const USAGE_JA = `chaff — 文章の読みにくいところを見つけます
   chaff compare <前> <後>                書き換えで事実（数・日付・URL・コード・名前・引用…）が落ちても足されてもいないかを確かめる
   chaff facts <file>                     compare が照合する事実を、書き直す前の控えとして一覧にする
   chaff outline <file> [<後>]            見出しの構成と形（見出しの数・節の平均の長さ・箇条書きの割合・太字）を測る。2 つなら前と後を並べる
+  chaff grade <items.jsonl> [--out <results.jsonl>] [--json]
+                                 AI の出力を JSONL でまとめて採点する（指摘の率・事実・引用・合否。何も送らない）
   chaff fix-plan <file> [--json]         指摘をルールごとにまとめ、直す方向と確かめのコマンドを、書き直す人や AI 向けの計画にする（何も送らない）
   chaff rules                    ルールの一覧を、グループごとに表で出す（いまの段階つき）
   chaff rules --json             いまの設定とルールの説明を JSON で出す（AI に渡す用）
   chaff baseline <dir>           いまある指摘を棚上げする（既存の repo に入れるとき）
   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 feedback <file> --rule <rule> [--line N] | --missed --line N
                                  誤った指摘・見逃しの報告の下書きを作る（何も送らない。--with-config で chaff.yaml 全体も載せる）
@@ -41,6 +55,7 @@ const USAGE_JA = `chaff — 文章の読みにくいところを見つけます
   --watch           保存のたびに見直し、変わったところだけ出す
   --dry-run         test で、何を AI に送るかだけを見る（API を呼びません）
   --sarif <path>    指摘を SARIF で書き出す（GitHub の PR の行に出すため）
+  --include <glob>  フォルダを見るとき、Markdown のほかにこのファイルも検査する（--include "*.yaml"。chaff.yaml の include と同じ）
 
 この箇所だけ黙らせる:  <!-- stet: rule-id — 理由 -->
 
@@ -63,12 +78,15 @@ const USAGE_EN = `chaff — finds what makes writing hard to read. It never rewr
   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 grade <items.jsonl> [--out <results.jsonl>] [--json]
+                                 grade a JSONL file of model outputs (finding rates, facts, quotations, pass or fail; sends nothing)
   chaff fix-plan <file> [--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
   chaff rules --json             the current settings and what each rule is, as JSON (to give to an AI)
   chaff baseline <dir>           shelve today's findings (when adding chaff to an existing repository)
   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 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)
@@ -80,6 +98,7 @@ const USAGE_EN = `chaff — finds what makes writing hard to read. It never rewr
   --watch           re-check on every save and print only what changed
   --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)
 
 Silence one spot:  <!-- stet: rule-id — reason -->
 
@@ -93,8 +112,9 @@ export type CliText = {
   readonly header: (path: string, genre: string, language: string, from: string, shelved: number, hushed: number) => string;
   readonly suggested: (name: string, genre: string) => string;
   readonly suggestedNote: (name: string, genre: string, used: string) => string;
-  readonly noMarkdown: (targets: string) => string;
-  readonly noMarkdownHere: string;
+  /** Nothing to check among targets; include: the globs looked for besides Markdown. Says how to look for more. */
+  readonly noMarkdown: (targets: string, include: readonly string[]) => string;
+  readonly noMarkdownHere: (include: readonly string[]) => string;
   readonly noAdapter: (language: string) => string;
   readonly unknownGenre: (genre: string, where: string, known: readonly string[]) => string;
   readonly genreWhere: (where: GenreSetting, files: readonly string[]) => string;
@@ -132,8 +152,8 @@ export const CLI_TEXT: Texts<CliText> = {
     suggested: (name, genre) => `   ${name}のようです。--genre ${genre} を試せます`,
     suggestedNote: (name, genre, used) =>
       `  ジャンルを決めていないので、${used} として見ました。${name}なら、--genre ${genre} でその種類の書き方に合わせて見ます（npx chaffjs genres で一覧）。`,
-    noMarkdown: (targets) => `Markdown が 1 つも見つかりませんでした: ${targets}`,
-    noMarkdownHere: "Markdown が 1 つも見つかりませんでした。",
+    noMarkdown: (targets, include) => `検査するファイルが 1 つも見つかりませんでした: ${targets}\n${lookedForJa(include)}`,
+    noMarkdownHere: (include) => `検査するファイルが 1 つも見つかりませんでした。\n${lookedForJa(include)}`,
     noAdapter: (language) => `言語 "${language}" のアダプタがありません。`,
     unknownGenre: (genre, where, known) =>
       `ジャンル "${genre}" はありません（${where}）。使えるのは ${known.join("、")} です。npx chaff genres で一覧が出ます。`,
@@ -182,8 +202,8 @@ export const CLI_TEXT: Texts<CliText> = {
     suggested: (name, genre) => `   Looks like: ${name}. Try --genre ${genre}`,
     suggestedNote: (name, genre, used) =>
       `  No genre was set, so this was checked as ${used}. If it is ${name}, --genre ${genre} checks it the way that kind is written (npx chaffjs genres lists them).`,
-    noMarkdown: (targets) => `No Markdown files found: ${targets}`,
-    noMarkdownHere: "No Markdown files found.",
+    noMarkdown: (targets, include) => `No files to check found: ${targets}\n${lookedForEn(include)}`,
+    noMarkdownHere: (include) => `No files to check found.\n${lookedForEn(include)}`,
     noAdapter: (language) => `No language package for "${language}".`,
     unknownGenre: (genre, where, known) => `There is no genre "${genre}" (${where}). The genres are ${known.join(", ")}. npx chaff genres lists them.`,
     genreWhere: (where, files) => {

package/src/cli.ts

@@ -1,15 +1,11 @@
 import { mkdirSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
-import { loadAdapter, packageFor } from "./adapter-load.ts";
+import { packageFor } from "./adapter-load.ts";
+import { checkSource, crossChecked, type SourceCheck } from "./check-source.ts";
 import { CONFIG_FILE, type Config } from "./config/load.ts";
-import { applyByPath } from "./config/by-path.ts";
-import { limitsFor } from "./config/style.ts";
 import { applyLevel } from "./config/write.ts";
-import { buildDocument, teamRules } from "./document.ts";
-import { guessLanguage } from "./detect.ts";
 import { collectTargets, readDocumentFile } from "./files.ts";
 import { BASELINE_FILE, fingerprints, readBaseline, splitByBaseline, writeBaseline } from "./baseline.ts";
-import { applySuppressions } from "./stet.ts";
 import type { PerFile } from "./render/suppressions.ts";
 import { runSuppressions } from "./commands/suppressions.ts";
 import { clock, describeChange, snapshotOf, watchPaths, type Snapshot } from "./watch.ts";
@@ -19,7 +15,7 @@ import { GENRES } from "./genre.ts";
 import { resolveGenre } from "./resolve-genre.ts";
 import { runInit } from "./init.ts";
 import { initGenre } from "./commands/init-ask.ts";
-import { targetsOf, withExperimental } from "./cli-args.ts";
+import { targetsOf, withExperimental, withIncludes } from "./cli-args.ts";
 import { rulesOf } from "./custom/load.ts";
 import { renderCompact } from "./render/compact.ts";
 import { renderExplain } from "./render/explain.ts";
@@ -34,6 +30,7 @@ import { VERSION, VERSION_LINES } from "./version.ts";
 import type { TreeContext } from "./commands/tree.ts";
 import { DOCUMENT_COMMANDS } from "./commands/document-commands.ts";
 import { runSkill } from "./commands/skill.ts";
+import { GRADE_EXIT, runGrade } from "./commands/grade.ts";
 import { fixPlanTargets, runFixPlan } from "./commands/fix-plan.ts";
 import { runConditions, runFeedback, settingsOf, type Checked } from "./commands/feedback.ts";
 import { homedir } from "node:os";
@@ -41,14 +38,16 @@ import { settingWarnings } from "./config/warnings.ts";
 import { readConfigIn } from "./config/read.ts";
 import { optionLayersOf, settingSourcesOf } from "./config/option-problems.ts";
 import { renderSummary, type FileOutcome } from "./render/summary.ts";
-import { neededBy, runRulesWith } from "./run.ts";
+
 import type { Finding, Level, RuleDefinition } from "./plugin.ts";
 import { CLI_TEXT, type CliText, type GenreSource } from "./cli-text.ts";
 import { hostLanguage, sharedLanguage, uiLanguageOf, type UiLanguage } from "./ui.ts";
-import { profileFor } from "./profile/for-file.ts";
 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 { DEFAULT_GENRE } from "./init-choice.ts";
+import { stoppingOnYamlFileError } from "./config/yaml-file.ts";
 
 /** Text for output that is not about one document. */
 const hostText = (config: Config): CliText => CLI_TEXT[hostLanguage(config.language, process.env)];
@@ -93,32 +92,18 @@ type Inspected = {
   readonly kept: readonly Finding[];
 };
 
-const inspect = async (path: string, config: Config, argv: readonly string[]): Promise<Inspected> => {
-  const source = await readDocumentFile(path);
-  const language = applyByPath(config.byPath, config.baseDir, path).language ?? config.language ?? guessLanguage(source).language;
-  const adapter = await loadAdapter(language);
-  const { genre, from, unread } = resolveGenre(path, source, config, flag(argv, "--genre"));
-  if (unread !== undefined) console.error(`chaff: ${CLI_TEXT[uiLanguageOf(language)].unreadFrontMatterGenre(path, unread, GENRES)}`);
-  const rules = rulesOf(language, config);
+const checkFile = async (path: string, config: Config, argv: readonly string[]): Promise<SourceCheck> => {
   const experimental = config.experimental || argv.includes("--experimental");
-  await adapter.prepare?.(neededBy(rules, config.rules, experimental, genre, language));
-  const doc = buildDocument(path, source, adapter, teamRules(config, language), profileFor(config, path, source, language, genre));
-  const raw = runRulesWith(doc, rules, {
-    settings: config.rules,
-    experimental,
-    genre,
-    limits: limitsFor(config, language),
-    optionLayers: optionLayersOf(config),
-    detectors: config.extensions?.detectors ?? {},
-  });
-  // 応答は 3 つ。stet で黙らせたものは、ここで落とす。
-  const applied = applySuppressions(
-    source,
-    raw.findings,
-    doc.sections.map((section) => section.span),
-  );
+  return checkSource(path, await readDocumentFile(path), config, { genre: flag(argv, "--genre"), experimental });
+};
+
+const present = (check: SourceCheck, argv: readonly string[]): Inspected => {
+  const { language, genre: resolved, rules, raw, applied } = check;
+  const { path, source } = check.doc;
+  const { genre, from, unread } = resolved;
+  if (unread !== undefined) console.error(`chaff: ${CLI_TEXT[uiLanguageOf(language)].unreadFrontMatterGenre(path, unread, GENRES)}`);
   const baseline = argv.includes("--show-baseline") ? undefined : readBaseline(join(process.cwd(), BASELINE_FILE));
-  const split = splitByBaseline(path, applied.kept, baseline);
+  const split = splitByBaseline(path, applied.kept, baseline, process.cwd());
   const result = { ...raw, findings: split.fresh };
   const { header, notes } = fileHeader(path, source, language, { genre, from, unread }, { shelved: split.shelved, hushed: applied.suppressed.length });
   const notRun = notRunAmong(applied.named, raw.skipped);
@@ -135,6 +120,12 @@ const inspect = async (path: string, config: Config, argv: readonly string[]): P
   };
 };
 
+const inspect = async (path: string, config: Config, argv: readonly string[]): Promise<Inspected> => present(await checkFile(path, config, argv), argv);
+
+/** Every file of one run, with the rules that compare documents run over all of them. */
+const inspectRun = async (paths: readonly string[], config: Config, argv: readonly string[]): Promise<Inspected[]> =>
+  crossChecked(await Promise.all(paths.map((path) => checkFile(path, config, argv)))).map((check) => present(check, argv));
+
 /**
  * 指摘を PR の変更行に出すための出口。--sarif <path> を書いたときだけ作る。
  * 端末の出力は変えない。CI で上げるためのファイルが増えるだけ。
@@ -146,8 +137,9 @@ const writeSarif = (results: readonly Inspected[], argv: readonly string[], conf
   const located = results.flatMap((result) =>
     result.outcome.findings.map((finding) => ({ path: result.outcome.path, finding, language: result.language, rules: result.rules })),
   );
+  const notRun = results.flatMap((result) => result.checked.skipped.map((entry) => ({ path: result.outcome.path, rule: entry.rule, why: entry.why })));
   mkdirSync(dirname(path), { recursive: true });
-  writeFileSync(path, renderSarif(located, VERSION), "utf8");
+  writeFileSync(path, renderSarif(located, VERSION, notRun), "utf8");
   console.log(hostText(config).sarifWritten(path, located.length));
 };
 
@@ -162,10 +154,10 @@ const summaryLanguage = (results: readonly Inspected[], config: Config): UiLangu
 };
 
 const lint = async (targets: readonly string[], argv: readonly string[], config: Config): Promise<number> => {
-  const paths = collectTargets(targets);
+  const paths = collectTargets(targets, config.include);
   if (paths.length === 0) {
     // 0 件を成功にすると「CI は通っているが何も検証していない」状態が続く。§14。
-    console.error(hostText(config).noMarkdown(targets.join(", ")));
+    console.error(hostText(config).noMarkdown(targets.join(", "), config.include ?? []));
     return 1;
   }
   const language = config.language ?? "ja";
@@ -174,7 +166,7 @@ const lint = async (targets: readonly string[], argv: readonly string[], config:
     return 1;
   }
   warnRuleProblems(config, language);
-  const results = await Promise.all(paths.map((path) => inspect(path, config, argv)));
+  const results = await inspectRun(paths, config, argv);
   writeSarif(results, argv, config);
   results.filter((result) => result.outcome.findings.length > 0 || paths.length === 1).forEach((result) => console.log(result.text));
   renderSummary(
@@ -189,10 +181,10 @@ const lint = async (targets: readonly string[], argv: readonly string[], config:
  * 差分だけを出す。workflow spec §11。
  */
 const runWatch = async (targets: readonly string[], argv: readonly string[], config: Config): Promise<number> => {
-  const paths = collectTargets(targets);
+  const paths = collectTargets(targets, config.include);
   const text = hostText(config);
   if (paths.length === 0) {
-    console.error(text.noMarkdown(targets.join(", ")));
+    console.error(text.noMarkdown(targets.join(", "), config.include ?? []));
     return 1;
   }
   warnRuleProblems(config, config.language ?? "ja");
@@ -233,18 +225,19 @@ const explain = (config: Config, ruleId: string | undefined, genreFlag: string |
   }
   const preset = genre === undefined ? {} : presetLevels(genre);
   const current = config.rules[rule.id] ?? preset[rule.id] ?? (rule.status === "experimental" && !config.experimental ? "off" : "normal");
-  console.log(renderExplain(rule, current, language, genre, settingSourcesOf(config, rule.id, language)));
+  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;
 };
 
 const runBaseline = async (targets: readonly string[], argv: readonly string[], config: Config): Promise<number> => {
-  const paths = collectTargets(targets.length > 0 ? targets : ["."]);
+  const paths = collectTargets(targets.length > 0 ? targets : ["."], config.include);
   if (paths.length === 0) {
-    console.error(hostText(config).noMarkdownHere);
+    console.error(hostText(config).noMarkdownHere(config.include ?? []));
     return 1;
   }
-  const results = await Promise.all(paths.map((path) => inspect(path, config, [...argv, "--show-baseline"])));
-  const entries = results.flatMap((result) => fingerprints(result.outcome.path, result.kept));
+  const results = await inspectRun(paths, config, [...argv, "--show-baseline"]);
+  const entries = results.flatMap((result) => fingerprints(result.outcome.path, result.kept, process.cwd()));
   const file = join(process.cwd(), BASELINE_FILE);
   writeBaseline(file, entries);
   console.log(hostText(config).baselineDone(paths.length, entries.length, BASELINE_FILE).join("\n"));
@@ -303,10 +296,17 @@ const HANDLERS: Readonly<Record<string, Handler>> = {
   "fix-plan": (argv, config) =>
     runFixPlan(fixPlanTargets(argv), argv, { ...treeContext(config), check: async (path) => (await inspectAll(config, argv)(path)).checked }),
   baseline: (argv, config) => runBaseline(positional(argv), argv, config),
-  suppressions: (argv, config) => runSuppressions(positional(argv), inspectAll(config, argv), hostLanguage(config.language, process.env)),
+  suppressions: (argv, config) =>
+    runSuppressions(
+      positional(argv),
+      (paths) => inspectRun(paths, config, [...argv, "--show-baseline"]),
+      hostLanguage(config.language, process.env),
+      config.include,
+    ),
   relax: (argv, config) => changeSetting(config, "relaxed", argv[1], flag(argv, "--why")),
   strict: (argv, config) => changeSetting(config, "strict", argv[1], flag(argv, "--why")),
   off: (argv, config) => changeSetting(config, "off", argv[1], flag(argv, "--why")),
+  enable: (argv, config) => changeSetting(config, "normal", argv[1], flag(argv, "--why")),
   feedback: (argv, config) => {
     return runFeedback(positional(argv), argv, {
       cwd: process.cwd(),
@@ -321,13 +321,14 @@ const HANDLERS: Readonly<Record<string, Handler>> = {
       }),
     });
   },
+  grade: (argv, config) => runGrade(argv, { config, flag, ui: hostLanguage(config.language, process.env) }),
   skill: (argv, config) => runSkill(argv, { cwd: process.cwd(), home: homedir(), ui: hostLanguage(config.language, process.env) }),
 };
 
 /** Every subcommand. Anything else on the command line is a file to check. */
 export const COMMANDS: readonly string[] = Object.keys(HANDLERS);
 
-export const main = async (argv: readonly string[]): Promise<number> => {
+const dispatch = async (argv: readonly string[]): Promise<number> => {
   const first = argv[0];
   if (first === undefined || first === "--help" || first === "-h") {
     console.log(hostText(readConfig()).usage);
@@ -338,12 +339,17 @@ export const main = async (argv: readonly string[]): Promise<number> => {
     return 0;
   }
   // 知らないジャンルではどの rule も当たらず、知らない文書の種類では種類の知識が外れる。どちらも素通りに見えるので、何かする前に止める。
-  const config = await withExtensions(readConfig());
+  const config = withIncludes(await withExtensions(readConfig()), argv);
   const problems = settingProblems(first, flag(argv, "--genre"), config, hostText(config), hostLanguage(config.language, process.env));
   problems.forEach((problem) => console.error(problem));
-  if (problems.length > 0) return 1;
+  // grade は設定の誤りを 2 で返す。CI の門で「出力が悪い」（1）と取り違えないため。
+  if (problems.length > 0) return first === "grade" ? GRADE_EXIT.unreadable : 1;
   const handler = HANDLERS[first];
   if (handler !== undefined) return handler(argv, config);
   const targets = targetsOf(first === "lint" ? argv.slice(1) : argv);
   return argv.includes("--watch") ? runWatch(targets, argv, config) : lint(targets, argv, config);
 };
+
+/** A chaff.yaml or checks.yaml that is not YAML stops the run with its path and position, not a stack trace. */
+export const main = (argv: readonly string[]): Promise<number> =>
+  stoppingOnYamlFileError(() => dispatch(argv), process.cwd(), hostLanguage(undefined, process.env));

package/src/commands/compare.ts

@@ -6,7 +6,7 @@ import { extractFacts } from "../compare/extract.ts";
 import { outcomeOf, type Allowed, type Compared } from "../compare/outcome.ts";
 import { renderCompact, renderFriendly, renderJson } from "../compare/render.ts";
 import { COMPARE_TEXT } from "../compare/text.ts";
-import { readDocument } from "./read-document.ts";
+import { readDocument, type ReadDocument } from "./read-document.ts";
 import type { TreeContext } from "./tree.ts";
 
 /** Options whose value is the next argument. That value is not a file. */
@@ -33,13 +33,17 @@ const parseAllowed = (argv: readonly string[]): ParsedAllowed => {
 
 export type DocumentFacts = Compared & { readonly language: string };
 
+/** A document's facts, read with the team's names. */
+export const factsOf = (path: string, prose: ReadDocument, names: readonly string[]): DocumentFacts => {
+  const root = isMarkdownPath(path) ? readMarkdown(prose.doc.source).root : undefined;
+  const extraction = extractFacts({ doc: prose.doc, root, structure: prose.structure, names });
+  return { path, extraction, language: prose.language };
+};
+
 /** One document's facts, read as lint reads it: its language, the team's names, and the parts of speech. */
 export const readFacts = async (path: string, argv: readonly string[], context: TreeContext): Promise<DocumentFacts | undefined> => {
   const prose = await readDocument(path, argv, context, true);
-  if (prose === undefined) return undefined;
-  const root = isMarkdownPath(path) ? readMarkdown(prose.doc.source).root : undefined;
-  const extraction = extractFacts({ doc: prose.doc, root, structure: prose.structure, names: context.config.names ?? [] });
-  return { path, extraction, language: prose.language };
+  return prose === undefined ? undefined : factsOf(path, prose, context.config.names ?? []);
 };
 
 const renderFor = (argv: readonly string[]): typeof renderFriendly => {

package/src/commands/eval.ts

@@ -53,9 +53,9 @@ export type Context = {
  * 測った結果は文書の言語で出す（混ざっていれば測らないので、言語は 1 つ）。断りは ui の言語。
  */
 export const runEval = async (targets: readonly string[], argv: readonly string[], context: Context): Promise<number> => {
-  const paths = collectTargets(targets.length > 0 ? targets : ["."]);
+  const paths = collectTargets(targets.length > 0 ? targets : ["."], context.config.include);
   if (paths.length === 0) {
-    console.error(CLI_TEXT[context.ui].noMarkdown(targets.join(", ")));
+    console.error(CLI_TEXT[context.ui].noMarkdown(targets.join(", "), context.config.include ?? []));
     return 1;
   }
   const { config, resolveGenre, flag, ui } = context;

package/src/commands/fix-plan.ts

@@ -1,5 +1,6 @@
 import { existsSync } from "node:fs";
 import { outlineOf } from "../outline/shape.ts";
+import { structureOf } from "../structure-shape/of-document.ts";
 import { buildFixPlan } from "../fix-plan/plan.ts";
 import { renderFixPlanJson, renderFixPlanMarkdown } from "../fix-plan/render.ts";
 import { FIX_PLAN_TEXT } from "../fix-plan/text.ts";
@@ -20,7 +21,7 @@ export type FixPlanContext = TreeContext & {
 
 /**
  * An instruction document for whoever rewrites the file: the findings grouped by rule, each rule's rewrite direction,
- * the document-level signals, a recommended mode and the checks to run after. Deterministic; sends nothing anywhere.
+ * the document-level signals, the structure targets from human articles, a recommended mode and the checks to run after. Deterministic; sends nothing anywhere.
  */
 export const runFixPlan = async (targets: readonly string[], argv: readonly string[], context: FixPlanContext): Promise<number> => {
   const [path] = targets;
@@ -46,6 +47,7 @@ export const runFixPlan = async (targets: readonly string[], argv: readonly stri
     rules: checked.rules,
     skipped: checked.skipped,
     outline: outlineOf(prose.doc),
+    structure: structureOf(prose.doc),
     phrases: prose.doc.lexicons["ai-tell"] ?? [],
   });
   console.log(argv.includes("--json") ? renderFixPlanJson(plan) : renderFixPlanMarkdown(plan));

package/src/commands/grade-baseline.ts

@@ -0,0 +1,44 @@
+import { readDocumentFile } from "../files.ts";
+import { stampCheck } from "../grade/baseline.ts";
+import { BASELINE_TEXT } from "../grade/baseline-text.ts";
+import type { GradeResult, Stamp } from "../grade/result.ts";
+import { parseResults } from "../grade/results-read.ts";
+import { GRADE_TEXT } from "../grade/text.ts";
+import type { UiLanguage } from "../ui.ts";
+
+// `chaff grade --baseline <earlier results>` before anything is graded: the earlier results read, and their stamp
+// checked against this run's. Either can stop the run with exit 2, so no time is spent grading what cannot be compared.
+
+/** No --baseline; a baseline to compare with; or a reason already said why the run stops. */
+export type BaselineChoice =
+  { readonly kind: "none" } | { readonly kind: "stop" } | { readonly kind: "compare"; readonly path: string; readonly before: readonly GradeResult[] };
+
+const STOP: BaselineChoice = { kind: "stop" };
+
+const readResults = async (path: string, ui: UiLanguage): Promise<readonly GradeResult[] | undefined> => {
+  try {
+    const parsed = parseResults(await readDocumentFile(path));
+    if ("results" in parsed) return parsed.results;
+    console.error(BASELINE_TEXT[ui].unreadable(path, parsed.badLines.join(", ")));
+  } catch (error) {
+    console.error(GRADE_TEXT[ui].unreadable(path, error instanceof Error ? error.message : String(error)));
+  }
+  return undefined;
+};
+
+/** The earlier results, if they can be compared with a run stamped `stamp`. --allow-stamp-mismatch compares anyway, saying so first. */
+export const chooseBaseline = async (path: string | undefined, stamp: Stamp, allowMismatch: boolean, ui: UiLanguage): Promise<BaselineChoice> => {
+  if (path === undefined) return { kind: "none" };
+  const before = await readResults(path, ui);
+  if (before === undefined) return STOP;
+  const checked = stampCheck(before, stamp);
+  if (checked.comparable) return { kind: "compare", path, before };
+  const text = BASELINE_TEXT[ui];
+  const differ = checked.differ.map((part) => text.differ[part]).join(", ");
+  if (!allowMismatch || checked.differ.includes("mixed")) {
+    console.error(text.notComparable(path, differ));
+    return STOP;
+  }
+  console.error(text.mismatchAllowed(path, differ));
+  return { kind: "compare", path, before };
+};