chaffjs 0.19.0 → 0.21.0

package/skills/chaff/SKILL.md

@@ -115,6 +115,8 @@ read it as data). It prints, in the document's language:
 - the constraints: keep facts, numbers, conditions and names; add no fact; ask the writer instead of inventing a
   specific; two passes at most;
 - the recommended mode and why, and the document-level signals with the outline's numbers;
+- the structure targets: the structure score (how many structure measures lie past 90% of human articles) and, for
+  each measure past that line, a target from the human baseline ("fewer headings: N now, M at most for this length");
 - for each rule that fired: its rewrite direction, what to keep, what to avoid, one before/after pair, hints for the
   `ai-tell` phrases found, and the spots (line and sentence);
 - the check commands to run on the rewrite.
@@ -130,7 +132,7 @@ Pick one of three modes and say which.
 | --- | --- | --- |
 | **Light** | only the flagged spots | the content and the structure are fine and only some phrasing is off |
 | **Bold** | each section's prose, keeping the outline | the outline is fixed (a report template, a manual, required sections) |
-| **Full** | the whole document, from scratch | the request says 「全面的に」「一から」「全部書き直して」 / "from scratch" / "rewrite the whole thing"; or the genre is `blog/*` or an essay (`literature/essay`); or `ai-generated-composite` fires |
+| **Full** | the whole document, from scratch | the request says 「全面的に」「一から」「全部書き直して」 / "from scratch" / "rewrite the whole thing"; or the genre is `blog/*` or an essay (`literature/essay`); or `ai-generated-composite` fires; or the plan's structure score reaches its limit |
 
 For a blog or an essay, and whenever `ai-generated-composite` fires, recommend Full. A Light or Bold pass leaves the
 skeleton of generated text: a heading every few paragraphs, bold lead-ins, symmetric sections, a closing まとめ that
@@ -161,7 +163,8 @@ repeats the body. The writer usually wants the structure changed, not only the s
 
 1. **Take inventory before writing.** `npx chaffjs facts <file> --json` lists every fact `compare` will hold you to
    (numbers, dates, times, URLs, code, names, quotations, headings, references, footnotes). `npx chaffjs outline <file>`
-   gives the old outline and its shape. Then write down, one line each, the writer's actual claims and every concrete
+   gives the old outline, its shape and its structure block: each structure measure against human articles, with ✗ on
+   those past 90% of them. Then write down, one line each, the writer's actual claims and every concrete
    experience, example and opinion in the original. This inventory is what you write from; the old sentences are not.
 2. **Throw away the structure.** Decide what the piece is for and who reads it. Choose one angle or story for the
    whole piece, and outline it the way a person would. Do these before writing:
@@ -173,6 +176,9 @@ repeats the body. The writer usually wants the structure changed, not only the s
    - no symmetric three-point sections unless the content really has three parts;
    - move the writer's concrete experience to where it carries the argument;
    - open with the point or a concrete scene, not a generic opener.
+
+   Size the new outline by the plan's structure targets: as many headings as the target allows for this length, no
+   heading split into three unless the content has three parts, no bold-label lists, no closing that restates.
 3. **Show the new outline first.** Put the old outline (headings from `chaff outline`) next to the proposed one:
    headings, and one line per section on what it says. The writer then sees the structural change at a glance. Wait
    for a yes, unless the person asked for it to be done without asking; then go straight on.
@@ -199,8 +205,8 @@ repeats the body. The writer usually wants the structure changed, not only the s
      this one is yours to keep.
 5. **Check.**
    - `npx chaffjs <old> --experimental` and `npx chaffjs <new> --experimental`: the AI signals before and after.
-   - `npx chaffjs outline <old> <new>`: headings, average section length, text in lists, bold, before and after. A
-     restructure shows up here, not only in rule counts.
+   - `npx chaffjs outline <old> <new>`: headings, average section length, text in lists, bold, and the structure score
+     and each structure measure, before and after. A restructure shows up here, not only in rule counts.
    - `npx chaffjs compare <old> <new> --distinct --allow-dropped heading --allow-added heading`: the headings are the
      structure you rebuilt on purpose; every other dropped fact is restored and no other fact is added. A cut まとめ
      restates facts the body still holds, so `--distinct` counts a fact as kept when the new text states it at least
@@ -208,6 +214,8 @@ repeats the body. The writer usually wants the structure changed, not only the s
 6. **Stop** when all of these hold, or after two full passes, whichever comes first:
    - `ai-generated-composite` does not fire;
    - the density rules (`bold-density`, `contrast-framing`, `stock-transition`, `colon-lead-in`) are under their limits;
+   - `chaff outline <old> <new>` shows the new structure score under the plan's limit, with no ✗ left on the measures
+     the plan listed as targets;
    - `compare` is clean, or every exclusion has a stated reason.
 7. **Show** the new text, a short "what changed and why" list, then a table of the signals and the shape before and
    after, taken from chaff's output.
@@ -216,14 +224,14 @@ repeats the body. The writer usually wants the structure changed, not only the s
 
 - a generic opener or closer ("本記事では〜解説します", "いかがでしたでしょうか", "In today's fast-paced world");
 - explaining what every reader already knows;
-- every section the same length and the same shape;
+- every section the same shape (chaff measures the lengths and the heading forms, not what each section does);
 - a list of benefits with no cost or trade-off;
 - no first-hand detail: nothing the writer saw, measured or did;
 - the same enthusiasm everywhere, so nothing stands out;
 - politeness piled on politeness;
 - a definition nobody asked for;
 - headings that are full sentences or slogans;
-- a まとめ / "Conclusion" that repeats the body.
+- a まとめ / "Conclusion" that repeats the body in other words (chaff counts only the repeated wording).
 
 In every mode:
 

package/src/api.ts

@@ -107,9 +107,21 @@ export type RuleSpec = {
   readonly name?: Text;
   readonly why?: Text;
   readonly how_to_fix?: Text;
-  readonly example?: { readonly before: Text; readonly after: Text };
+  /** { before, after }, or one pair per language as chaff's own rules write it: { ja: { before, after }, en: … }. */
+  readonly example?: { readonly before: Text; readonly after: Text } | Readonly<Record<string, { readonly before: string; readonly after: string }>>;
   readonly message?: Text;
+  /** One severity for normal; strict is one heavier and relaxed one lighter. Or levels, not both. */
   readonly level?: Severity;
+  /** A severity for each level, as chaff's rules with nothing to count write them. normal is required. */
+  readonly levels?: Readonly<Partial<Record<"strict" | "normal" | "relaxed", Severity>>>;
+  /** The genres the rule is for, or their first part (business, business/report). Without it, every genre. */
+  readonly use_for?: readonly string[];
+  /** Where the rule reference lists it (readability, wording, …). Without it, team. */
+  readonly group?: string;
+  /** What the rule finds, in one line. Without it, the name. */
+  readonly summary?: Text;
+  /** How chaff fix-plan rewrites what the rule flags: depth (light / structure / register) and, by language, direction, pairs, keep and avoid. */
+  readonly rewrite?: Readonly<Record<string, unknown>>;
   /** The languages the rule checks. Without it, every language. */
   readonly languages?: readonly string[];
   /** A word list by name; the detector gets it as options.lexicon. A plugin's own lists are named without the plugin's prefix. */

package/src/baseline.ts

@@ -1,5 +1,6 @@
 import { createHash } from "node:crypto";
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { posix, relative, resolve, sep } from "node:path";
 import type { Finding } from "./plugin.ts";
 
 export const BASELINE_FILE = ".chaff-baseline.json";
@@ -13,16 +14,28 @@ export const fingerprint = (path: string, finding: Finding): string => {
   return createHash("sha256").update(body).digest("hex").slice(0, 16);
 };
 
+type PathRules = Pick<typeof posix, "relative" | "resolve" | "sep">;
+const NATIVE: PathRules = { relative, resolve, sep };
+
+/**
+ * baseline が覚えるパス。baseline のフォルダからの相対で、区切りはどの OS でも「/」。
+ * OS の区切りのまま覚えると、macOS で書いた baseline が Windows では何も棚上げしない。
+ */
+export const baselinePath = (path: string, folder: string, rules: PathRules = NATIVE): string =>
+  rules.relative(folder, rules.resolve(folder, path)).split(rules.sep).join("/");
+
 /**
  * findings の fingerprint を順に。一つの文から出た指摘は同じ文を引くので、文と rule の組ごとに一度だけ計算する。
  * 長い文に指摘が多いと、指摘ごとに文を読み直すのでは指摘数と文の長さの積になる。
+ * folder は baseline を置くフォルダ。パスはそこからの相対にしてから数える。
  */
-export const fingerprints = (path: string, findings: readonly Finding[]): string[] => {
+export const fingerprints = (path: string, findings: readonly Finding[], folder: string): string[] => {
+  const key = baselinePath(path, folder);
   const known = new Map<string, Map<string, string>>();
   return findings.map((finding) => {
     const byRule = known.get(finding.quote) ?? new Map<string, string>();
     known.set(finding.quote, byRule);
-    const found = byRule.get(finding.rule) ?? fingerprint(path, finding);
+    const found = byRule.get(finding.rule) ?? fingerprint(key, finding);
     byRule.set(finding.rule, found);
     return found;
   });
@@ -52,10 +65,10 @@ export const writeBaseline = (path: string, entries: readonly string[]): void =>
 export type Split = { readonly fresh: readonly Finding[]; readonly shelved: number };
 
 /** baseline にあるものは報告しない。新しく増えたものだけを出す。 */
-export const splitByBaseline = (path: string, findings: readonly Finding[], baseline: Baseline | undefined): Split => {
+export const splitByBaseline = (path: string, findings: readonly Finding[], baseline: Baseline | undefined, folder: string): Split => {
   if (baseline === undefined) return { fresh: findings, shelved: 0 };
   const known = new Set(baseline.entries);
-  const prints = fingerprints(path, findings);
+  const prints = fingerprints(path, findings, folder);
   const fresh = findings.filter((_, index) => !known.has(prints[index] ?? ""));
   return { fresh, shelved: findings.length - fresh.length };
 };

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,22 @@ import { counted, formFor } from "./render/plural.ts";
 import type { GenreSetting } from "./genre-check.ts";
 import type { ProfileSetting } from "./profile/check.ts";
 
+const ASCII_AT = /[\x21-\x7e]/u;
+
+/** A word set in Japanese text with a space on each side where it starts or ends with Latin text, as the guide writes it. */
+const spacedInJapanese = (word: string): string => `${ASCII_AT.test(word.at(0) ?? "") ? " " : ""}${word}${ASCII_AT.test(word.at(-1) ?? "") ? " " : ""}`;
+
+/** 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 +40,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 +60,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 +83,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 +103,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 -->
 
@@ -88,13 +112,16 @@ A rule's level is one of strict / normal / relaxed / off.
 
 export type CliText = {
   readonly usage: string;
+  /** Under one command's lines of the usage, for `chaff <command> --help`. */
+  readonly moreHelp: string;
   readonly languageName: (language: string) => string;
   readonly genreSource: Readonly<Record<GenreSource, string>>;
   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;
@@ -115,6 +142,7 @@ export type CliText = {
 export const CLI_TEXT: Texts<CliText> = {
   ja: {
     usage: USAGE_JA,
+    moreHelp: "すべてのコマンドと共通の指定は npx chaffjs --help で出ます。",
     languageName: (language) => (language === "ja" ? "日本語" : "英語"),
     genreSource: {
       "--genre": "--genre",
@@ -126,17 +154,19 @@ export const CLI_TEXT: Texts<CliText> = {
       content: "内容",
     },
     header: (path, genre, language, from, shelved, hushed) =>
-      [`${path}   ${genre} · ${language}   ジャンルは${from}から`, shelved > 0 ? `   棚上げ ${shelved} 件` : "", hushed > 0 ? `   stet ${hushed} 件` : ""].join(
-        "",
-      ),
+      [
+        `${path}   ${genre} · ${language}   ジャンルは${spacedInJapanese(from)}から`,
+        shelved > 0 ? `   棚上げ ${shelved} 件` : "",
+        hushed > 0 ? `   stet ${hushed} 件` : "",
+      ].join(""),
     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 で一覧が出ます。`,
+      `ジャンル "${genre}" はありません（${where}）。使えるのは ${known.join("、")} です。npx chaffjs genres で一覧が出ます。`,
     genreWhere: (where, files) => {
       if (where === "config") return "chaff.yaml の genre";
       return where === "by_path" ? `chaff.yaml の by_path、files: ${files.join(", ")}` : "--genre";
@@ -146,7 +176,7 @@ export const CLI_TEXT: Texts<CliText> = {
     unknownProfile: (profile, where, known) =>
       `文書の種類 "${profile}" はありません（${where}）。使えるのは ${known.join("、")} と、種類を使わない none です。`,
     profileWhere: (where, files) => (where === "config" ? "chaff.yaml の profile" : `chaff.yaml の by_path、files: ${files.join(", ")}`),
-    unknownRule: (id) => `${id} というルールはありません。npx chaff rules で一覧が出ます。`,
+    unknownRule: (id) => `${id} というルールはありません。npx chaffjs rules で一覧が出ます。`,
     unknownRuleWithList: (id, list) => `${id} というルールはありません。\n一覧:\n${list}`,
     unnamed: "(名前なし)",
     sarifWritten: (path, count) => `\n  SARIF を書きました: ${path}（${count} 件）`,
@@ -167,6 +197,7 @@ export const CLI_TEXT: Texts<CliText> = {
   },
   en: {
     usage: USAGE_EN,
+    moreHelp: "npx chaffjs --help lists every command and the options they share.",
     languageName: (language) => (language === "ja" ? "Japanese" : "English"),
     genreSource: {
       "--genre": "--genre",
@@ -182,10 +213,10 @@ 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.`,
+    unknownGenre: (genre, where, known) => `There is no genre "${genre}" (${where}). The genres are ${known.join(", ")}. npx chaffjs genres lists them.`,
     genreWhere: (where, files) => {
       if (where === "config") return "genre in chaff.yaml";
       return where === "by_path" ? `by_path in chaff.yaml, files: ${files.join(", ")}` : "--genre";
@@ -195,7 +226,7 @@ export const CLI_TEXT: Texts<CliText> = {
     unknownProfile: (profile, where, known) =>
       `There is no document profile "${profile}" (${where}). The profiles are ${known.join(", ")}; none uses no profile.`,
     profileWhere: (where, files) => (where === "config" ? "profile in chaff.yaml" : `by_path in chaff.yaml, files: ${files.join(", ")}`),
-    unknownRule: (id) => `There is no rule named ${id}. npx chaff rules lists them.`,
+    unknownRule: (id) => `There is no rule named ${id}. npx chaffjs rules lists them.`,
     unknownRuleWithList: (id, list) => `There is no rule named ${id}.\nRules:\n${list}`,
     unnamed: "(no name)",
     sarifWritten: (path, count) => `\n  Wrote SARIF: ${path} (${counted(count, "finding")})`,