chaffjs 0.22.0 → 0.24.0

package/src/cli.ts

@@ -15,7 +15,10 @@ import { GENRES } from "./genre.ts";
 import { resolveGenre } from "./resolve-genre.ts";
 import { runInitCommand } from "./commands/init-command.ts";
 import { runPluginTest } from "./commands/plugin-test.ts";
-import { targetsOf, withExperimental, withIncludes } from "./cli-args.ts";
+import { targetsOf, withIncludes } from "./cli-args.ts";
+import { guidesOfRun, type RunGuide } from "./genre-guide/report.ts";
+import { showRules } from "./commands/rules.ts";
+import { renderGuideBlock } from "./genre-guide/render.ts";
 import { rulesOf } from "./custom/load.ts";
 import { renderCompact } from "./render/compact.ts";
 import { renderExplain } from "./render/explain.ts";
@@ -23,8 +26,6 @@ import { renderFriendly } from "./render/friendly.ts";
 import { renderGenres } from "./render/genres.ts";
 import { loadGenres, presetLevels } from "./genre-load.ts";
 import { fileHeader } from "./file-header.ts";
-import { rulesJson } from "./render/rules-json.ts";
-import { rulesTable } from "./render/rules-table.ts";
 import { renderSarif } from "./render/sarif.ts";
 import { VERSION, VERSION_LINES } from "./version.ts";
 import type { TreeContext } from "./commands/tree.ts";
@@ -38,7 +39,7 @@ import { runConditions, runFeedback, settingsOf, type Checked } from "./commands
 import { homedir } from "node:os";
 import { settingWarnings } from "./config/warnings.ts";
 import { readConfigIn } from "./config/read.ts";
-import { optionLayersOf, settingSourcesOf } from "./config/option-problems.ts";
+import { settingSourcesOf } from "./config/option-problems.ts";
 import { renderSummary, type FileOutcome } from "./render/summary.ts";
 
 import type { Finding, Level, RuleDefinition } from "./plugin.ts";
@@ -117,7 +118,7 @@ const present = (check: SourceCheck, argv: readonly string[]): Inspected => {
     genre,
     outcome: { path, findings: split.fresh, notRun: raw.skipped.length },
     perFile: { path, suppressed: applied.suppressed, reasonless: applied.unusedReasonless, notRun },
-    checked: { findings: split.fresh, rules, language, genre, skipped: raw.skipped },
+    checked: { findings: split.fresh, rules, language, genre, genreFrom: from, skipped: raw.skipped },
     kept: applied.kept,
   };
 };
@@ -132,7 +133,7 @@ const inspectRun = async (paths: readonly string[], config: Config, argv: readon
  * 指摘を PR の変更行に出すための出口。--sarif <path> を書いたときだけ作る。
  * 端末の出力は変えない。CI で上げるためのファイルが増えるだけ。
  */
-const writeSarif = (results: readonly Inspected[], argv: readonly string[], config: Config): void => {
+const writeSarif = (results: readonly Inspected[], argv: readonly string[], config: Config, guides: readonly RunGuide[]): void => {
   const path = flag(argv, "--sarif");
   if (path === undefined) return;
   // 文言はファイルの言語で描く。by_path で 1 つの repo に 2 言語が混ざるため。
@@ -141,7 +142,7 @@ const writeSarif = (results: readonly Inspected[], argv: readonly string[], conf
   );
   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, notRun), "utf8");
+  writeFileSync(path, renderSarif(located, VERSION, notRun, guides), "utf8");
   console.log(hostText(config).sarifWritten(path, located.length));
 };
 
@@ -169,7 +170,13 @@ const lint = async (targets: readonly string[], argv: readonly string[], config:
   }
   warnRuleProblems(config, language);
   const results = await inspectRun(paths, config, argv);
-  writeSarif(results, argv, config);
+  const guides = guidesOfRun(
+    results.map((result) => result.checked),
+    config,
+    argv,
+  );
+  writeSarif(results, argv, config, guides);
+  if (!argv.includes("--compact")) guides.forEach((entry) => console.log(renderGuideBlock(entry.guide, entry.language).join("\n")));
   results.filter((result) => result.outcome.findings.length > 0 || paths.length === 1).forEach((result) => console.log(result.text));
   renderSummary(
     results.map((result) => result.outcome),
@@ -255,17 +262,6 @@ type Handler = (argv: readonly string[], config: Config) => number | Promise<num
 /** `--` で始まらない引数。対象のパス。 */
 const positional = (argv: readonly string[]): string[] => targetsOf(argv.slice(1));
 
-/** `rules --json` for an AI to read; `rules` alone, a table for a person. */
-const showRules = (argv: readonly string[], written: Config): number => {
-  const config = withExperimental(written, argv);
-  const language = config.language ?? hostLanguage(undefined, process.env);
-  warnRuleProblems(config, language);
-  const genre = flag(argv, "--genre") ?? config.genre ?? "blog/tech";
-  const rules = rulesOf(language, config);
-  console.log(argv.includes("--json") ? rulesJson(rules, config, language, genre, optionLayersOf(config)) : rulesTable(rules, config, language, genre));
-  return 0;
-};
-
 const showGenres = (config: Config): number => {
   console.log(renderGenres(loadGenres(), hostLanguage(config.language, process.env)));
   return 0;
@@ -284,7 +280,7 @@ const measureContext = (argv: readonly string[], config: Config): { config: Conf
 const HANDLERS: Readonly<Record<string, Handler>> = {
   init: (argv, config) => runInitCommand((name) => flag(argv, name), argv.includes("--plugin"), hostLanguage(config.language, process.env), process.cwd()),
   genres: (_argv, config) => showGenres(config),
-  rules: showRules,
+  rules: (argv, config) => showRules(argv, config, { flag, warn: warnRuleProblems }),
   explain: (argv, config) => explain(config, argv[1], flag(argv, "--genre")),
   eval: (argv, config) => runEval(positional(argv), argv, { ...measureContext(argv, config), flag }),
   ...Object.fromEntries(Object.entries(DOCUMENT_COMMANDS).map(([name, run]): [string, Handler] => [name, (argv, config) => run(argv, treeContext(config))])),

package/src/commands/feedback.ts

@@ -9,6 +9,7 @@ import { excerptsAround } from "../feedback/excerpt.ts";
 import { feedbackDraft, type FeedbackDraft, type FeedbackKind, type ReportedFinding } from "../feedback/draft.ts";
 import { notRunAmong } from "../not-run.ts";
 import type { Skipped } from "../run.ts";
+import type { GenreSource } from "../cli-text.ts";
 
 export const FEEDBACK_FILE = ".chaff-feedback.md";
 const NEW_ISSUE = "https://github.com/isamu/lab/issues/new";
@@ -20,6 +21,8 @@ export type Checked = {
   readonly rules: readonly RuleDefinition[];
   readonly language: string;
   readonly genre: string;
+  /** Where the genre came from: set (--genre, chaff.yaml, by_path, front matter), guessed or defaulted. */
+  readonly genreFrom: GenreSource;
   /** The rules this check did not run, and why. */
   readonly skipped: readonly Skipped[];
   /** How the check was run, as the reader of a report would repeat it (runConditions). */

package/src/commands/fix-plan.ts

@@ -8,6 +8,9 @@ import { chosenDepthOf } from "../fix-plan/chosen-depth.ts";
 import type { Checked } from "./feedback.ts";
 import { readDocument } from "./read-document.ts";
 import type { TreeContext } from "./tree.ts";
+import { genreWasSet, reportedGuide, type ReportedGuide } from "../genre-guide/report.ts";
+import { showsGuide } from "../cli-args.ts";
+import type { Config } from "../config/load.ts";
 
 /** Options whose value is the next argument. That value is not a file. */
 const VALUED: ReadonlySet<string> = new Set(["--language", "--genre", "--depth"]);
@@ -24,6 +27,10 @@ export type FixPlanContext = TreeContext & {
   readonly check: (path: string) => Promise<Omit<Checked, "conditions">>;
 };
 
+/** The genre's guide, the plan's first section; none when the genre was not set or the guide is off. */
+const guideOf = (checked: Omit<Checked, "conditions">, config: Config, argv: readonly string[]): ReportedGuide | undefined =>
+  genreWasSet(checked.genreFrom) && showsGuide(argv) ? reportedGuide(config, checked.genre, checked.language, checked.rules) : undefined;
+
 /**
  * An instruction document for whoever rewrites the file: the findings grouped by rule, each rule's rewrite direction,
  * the document-level signals, the structure targets from human articles, a recommended mode and the checks to run after. Deterministic; sends nothing anywhere.
@@ -61,6 +68,7 @@ export const runFixPlan = async (targets: readonly string[], argv: readonly stri
     structure: structureOf(prose.doc),
     phrases: prose.doc.lexicons["ai-tell"] ?? [],
     chosenDepth: depth.chosen,
+    guide: guideOf(checked, context.config, argv),
   });
   console.log(argv.includes("--json") ? renderFixPlanJson(plan) : renderFixPlanMarkdown(plan));
   return 0;

package/src/commands/rules.ts

@@ -0,0 +1,34 @@
+import { showsGuide, withExperimental } from "../cli-args.ts";
+import type { Config } from "../config/load.ts";
+import { optionLayersOf } from "../config/option-problems.ts";
+import { rulesOf } from "../custom/load.ts";
+import { reportedGuide } from "../genre-guide/report.ts";
+import { rulesJson } from "../render/rules-json.ts";
+import { rulesTable } from "../render/rules-table.ts";
+import { hostLanguage } from "../ui.ts";
+
+/** The genre the rules are shown for when none is set. */
+const SHOWN_GENRE = "blog/tech";
+
+export type RulesContext = {
+  readonly flag: (argv: readonly string[], name: string) => string | undefined;
+  /** Says once, on stderr, what in the settings has no effect. */
+  readonly warn: (config: Config, language: string) => void;
+};
+
+/** `rules --json` for an AI to read, with the guide of a genre that was set; `rules` alone, a table for a person. */
+export const showRules = (argv: readonly string[], written: Config, context: RulesContext): number => {
+  const config = withExperimental(written, argv);
+  const language = config.language ?? hostLanguage(undefined, process.env);
+  context.warn(config, language);
+  const setGenre = context.flag(argv, "--genre") ?? config.genre;
+  const genre = setGenre ?? SHOWN_GENRE;
+  const rules = rulesOf(language, config);
+  if (!argv.includes("--json")) {
+    console.log(rulesTable(rules, config, language, genre));
+    return 0;
+  }
+  const guide = setGenre !== undefined && showsGuide(argv) ? reportedGuide(config, genre, language, rules) : undefined;
+  console.log(rulesJson(rules, config, language, genre, optionLayersOf(config), guide));
+  return 0;
+};

package/src/config/load.ts

@@ -7,6 +7,7 @@ import type { Level } from "../plugin.ts";
 import type { PathRule } from "./by-path.ts";
 import type { Extensions } from "../extension/load.ts";
 import type { StyleLimits } from "../style-parse.ts";
+import type { GuideLayer } from "../genre-guide/layer.ts";
 
 export const CONFIG_FILE = "chaff.yaml";
 
@@ -46,7 +47,7 @@ export type Config = {
   readonly unreadableOptions?: string | undefined;
   /** The house style chaff.yaml names (styles/*.yaml), as written. A value that is not a name is kept printed, to be reported. */
   readonly style?: string | undefined;
-  /** The style once applied (config/style.ts): its id, the rules whose level it decided, and its options. */
+  /** The style once applied (config/style.ts): its id, the rules whose level it decided, its options and its guide. */
   readonly applied?: AppliedStyle | undefined;
   /** custom_rules as written: the team's own rules. custom/parse.ts reads and checks them. */
   readonly customRules?: unknown;
@@ -54,6 +55,8 @@ export type Config = {
   readonly grade?: unknown;
   /** fix_plan as written: the depth chaff fix-plan rewrites to (fix-plan/chosen-depth.ts reads and checks it). */
   readonly fixPlan?: unknown;
+  /** guide as written: the team's changes to the genre guides, or off (genre-guide/of-config.ts reads it). */
+  readonly guide?: unknown;
   /** plugins as written: package names and paths. extension/plugin-load.ts reads and checks them. */
   readonly plugins?: unknown;
   /** The code chaff.yaml names, once loaded (extension/load.ts). Reading chaff.yaml does not load it. */
@@ -66,6 +69,8 @@ export type AppliedStyle = {
   readonly options: Readonly<Record<string, unknown>>;
   /** The style's numbers, by rule and language, for the rules whose level it decided. */
   readonly limits: StyleLimits;
+  /** The style's changes to the genre guides, when it has any. */
+  readonly guide?: GuideLayer | undefined;
 };
 
 /** 判定の質が誤検知に直結するので、既定は最上位のモデル。cost は絞り込みで削る。spec §14。 */
@@ -200,6 +205,7 @@ export const loadConfig = (path: string): Config => {
     customRules: raw["custom_rules"],
     grade: raw["grade"],
     fixPlan: raw["fix_plan"],
+    guide: raw["guide"],
     plugins: raw["plugins"],
   };
 };

package/src/config/style.ts

@@ -22,7 +22,7 @@ export const withStyle = (config: Config, styles: readonly StyleDefinition[]): C
   return {
     ...config,
     rules: { ...style.rules, ...config.rules },
-    applied: { style: style.id, levelsFrom: fromStyle, options: style.options, limits },
+    applied: { style: style.id, levelsFrom: fromStyle, options: style.options, limits, guide: style.guide },
   };
 };
 

package/src/config/warnings.ts

@@ -4,10 +4,12 @@ import type { UiLanguage } from "../ui.ts";
 import { ruleProblems } from "./rule-problems.ts";
 import { nameProblems } from "./name-problems.ts";
 import { configOptionProblems } from "./option-problems.ts";
+import { configGuideProblems } from "../genre-guide/of-config.ts";
 
-/** Everything in chaff.yaml that has no effect: unknown rules or levels, unreadable names, options that do not apply. Said before the results. */
+/** Everything in chaff.yaml that has no effect: unknown rules or levels, unreadable names, options that do not apply, guides that cannot be read. Said before the results. */
 export const settingWarnings = (config: Config, rules: readonly RuleDefinition[], ui: UiLanguage): string[] => [
   ...ruleProblems(config, rules, ui),
   ...nameProblems(config, ui),
   ...configOptionProblems(config, rules, ui),
+  ...configGuideProblems(config, ui),
 ];

package/src/detectors/bare-comparative.ts

@@ -0,0 +1,152 @@
+import type { Detector, Finding, Lexicon, Sentence, Span, Token } from "../plugin.ts";
+import { quotedIn } from "../quoted-span.ts";
+
+/**
+ * 比べる相手の無い比較（より良い結果、さらに高速に、The new engine is faster.）。何より良いのか、何より速いのかが書かれていない。
+ * 語は語彙表 comparative-baseline が言う。group marker は日本語の比べる副詞（より、さらに）、more は英語の比べる語、comparative は比べた形の語
+ * （faster、better）、baseline は相手を言う語（従来、以前、than、previous）、exempt は比較でない決まった言い方（より多くの、より詳しく）、
+ * condition は比較を条件や仮定の下に置く語（使うと、if、would）。条件を書いた比較は、その条件の無い場合と比べている。
+ * 同じ文か前の二文に相手を言う語があれば、相手は書いてある。
+ */
+
+export type ComparativeLists = {
+  readonly markers: ReadonlySet<string>;
+  readonly more: ReadonlySet<string>;
+  readonly comparatives: ReadonlySet<string>;
+  readonly baselines: readonly string[];
+  readonly exempt: ReadonlySet<string>;
+  readonly conditions: ReadonlySet<string>;
+};
+
+export type BareComparative = { readonly first: Token; readonly last: Token };
+
+/** 前に立てば、比べた形が述語として読める語の品詞（is faster、runs faster）。 */
+const PREDICATE_HEAD = new Set(["VERB", "AUX"]);
+/** 比べた形の後ろで節が終わる印。 */
+const CLAUSE_END = new Set([".", "!", "?", ",", ";", ":"]);
+/** 述語と比べた形のあいだに挟まってよい副詞の数（is now much faster）。 */
+const MAX_ADVERBS = 2;
+/** 日本語の形容動詞の語幹の後ろに来る語（高速な、高速に、高速です）。 */
+const ADJECTIVAL_TAIL = new Set(["な", "に", "だ", "です", "で"]);
+
+const lower = (token: Token | undefined): string => token?.surface.toLowerCase() ?? "";
+
+const isThirdPersonVerb = (token: Token): boolean => token.pos === "NOUN" && token.features?.["AlsoVerb"] === "Yes" && token.features["Number"] === "Plur";
+
+/** 比べる語の後ろの、程度を言える語（良い、高速な）。形容詞か、形容動詞の語幹。 */
+const isGradable = (tokens: readonly Token[], at: number): boolean => {
+  const word = tokens[at];
+  if (word?.pos === "ADJ") return true;
+  return word?.pos === "NOUN" && word.features?.["Bound"] !== "Yes" && ADJECTIVAL_TAIL.has(tokens[at + 1]?.surface ?? "");
+};
+
+/** 比べる副詞が語の頭に立つか。前が助詞・記号・接続の語か文の頭のときだけ（「学年だより等」の「より」は語の一部）。 */
+const OPENS_WORD = new Set(["ADP", "PUNCT", "SCONJ", "CCONJ", "ADV"]);
+
+/** 日本語: 副詞の「より」「さらに」の直後の、程度を言える語。比較の決まった言い方（より多くの）は除く。 */
+const markedAt = (tokens: readonly Token[], at: number, lists: ComparativeLists): BareComparative | undefined => {
+  const [marker, word] = [tokens[at], tokens[at + 1]];
+  if (marker?.pos !== "ADV" || !lists.markers.has(marker.surface) || word === undefined || lists.exempt.has(word.surface)) return undefined;
+  const previous = tokens[at - 1];
+  if (previous !== undefined && !OPENS_WORD.has(previous.pos)) return undefined;
+  return isGradable(tokens, at + 1) ? { first: marker, last: word } : undefined;
+};
+
+/** 比べた形の後ろで節が終わるか。読点の後ろに形容詞が続けば、名詞の前に並べた修飾語（better, more predictable results）。 */
+const closesClause = (tokens: readonly Token[], at: number): boolean => {
+  const next = tokens[at + 1];
+  if (next === undefined) return true;
+  if (!CLAUSE_END.has(next.surface)) return false;
+  const after = tokens[at + 2];
+  return next.surface !== "," || (after?.pos !== "ADJ" && after?.pos !== "ADV");
+};
+
+/** more と形容詞のあいだの副詞（more computationally efficient）を飛ばした、more の位置。無ければ -1。 */
+const moreBefore = (tokens: readonly Token[], at: number, more: ReadonlySet<string>): number => {
+  const before = tokens.slice(Math.max(0, at - 1 - MAX_ADVERBS), at).reverse();
+  const found = before.findIndex((token) => token.pos !== "ADV" || more.has(lower(token)));
+  return found !== -1 && more.has(lower(before[found])) ? at - 1 - found : -1;
+};
+
+/** 英語: 述語の後ろで節を閉じる比べた形（is faster.、runs faster,）か、more と形容詞。 */
+const predicateAt = (tokens: readonly Token[], at: number, lists: ComparativeLists): BareComparative | undefined => {
+  const word = tokens[at];
+  if (word === undefined || !closesClause(tokens, at)) return undefined;
+  const moreAt = word.pos === "ADJ" ? moreBefore(tokens, at, lists.more) : -1;
+  if (moreAt === -1 && !lists.comparatives.has(lower(word))) return undefined;
+  const start = moreAt === -1 ? at : moreAt;
+  const first = tokens[start] ?? word;
+  const adverbs = tokens.slice(Math.max(0, start - MAX_ADVERBS), start).reverse();
+  const skipped = adverbs.findIndex((token) => token.pos !== "ADV");
+  const head = tokens[start - 1 - (skipped === -1 ? adverbs.length : skipped)];
+  return head !== undefined && (PREDICATE_HEAD.has(head.pos) || isThirdPersonVerb(head)) ? { first, last: word } : undefined;
+};
+
+/** 比べた形より前に、条件か仮定を言う語があるか。並べる「と」（A と B）は条件でない。 */
+const isConditional = (tokens: readonly Token[], found: BareComparative, conditions: ReadonlySet<string>): boolean =>
+  tokens.some((token) => token.span.start < found.first.span.start && token.pos !== "CCONJ" && conditions.has(lower(token)));
+
+export const bareComparativesIn = (tokens: readonly Token[], lists: ComparativeLists): BareComparative[] =>
+  tokens
+    .flatMap((_, at) => markedAt(tokens, at, lists) ?? predicateAt(tokens, at, lists) ?? [])
+    .filter((found) => !isConditional(tokens, found, lists.conditions));
+
+/**
+ * 語が比べる相手を言う語か。語の形か原形で照らし、一字の語（旧）は語の頭だけ（旧版は相手、復旧は相手でない）。
+ */
+const isBaselineWord = (token: Token, baselines: readonly string[]): boolean => {
+  const [surface, lemma] = [token.surface.toLowerCase(), token.lemma?.toLowerCase()];
+  return baselines.some((baseline) => surface === baseline || lemma === baseline || ([...baseline].length === 1 && surface.startsWith(baseline)));
+};
+
+/** 相手を言う語が、続く語に分かれて書かれているか（これ・まで、で・は・なく）。 */
+const MAX_BASELINE_TOKENS = 3;
+const isSplitBaseline = (tokens: readonly Token[], at: number, baselines: readonly string[]): boolean => {
+  const joined = tokens
+    .slice(at, at + MAX_BASELINE_TOKENS)
+    .map((token) => token.surface.toLowerCase())
+    .reduce<string[]>((runs, surface) => [...runs, `${runs.at(-1) ?? ""}${surface}`], []);
+  return joined.slice(1).some((run) => baselines.includes(run));
+};
+
+/** 文の中に、比べる相手を言う語か、相手を受ける助詞の「より」（従来より）があるか。 */
+export const namesBaseline = (sentence: Sentence | undefined, baselines: readonly string[]): boolean =>
+  (sentence?.tokens ?? []).some(
+    (token, at, tokens) => (token.surface === "より" && token.pos === "ADP") || isBaselineWord(token, baselines) || isSplitBaseline(tokens, at, baselines),
+  );
+
+/** 比べる相手を探す、前の文の数。段落の中で相手を言ってから、一つ文を挟んで比べることがある。 */
+const BASELINE_REACH = 2;
+
+const groupOf = (lexicon: Lexicon, group: string): string[] => lexicon.filter((entry) => entry.group === group).map((entry) => entry.pattern.toLowerCase());
+
+export const listsOf = (lexicon: Lexicon): ComparativeLists => ({
+  markers: new Set(groupOf(lexicon, "marker")),
+  more: new Set(groupOf(lexicon, "more")),
+  comparatives: new Set(groupOf(lexicon, "comparative")),
+  baselines: groupOf(lexicon, "baseline"),
+  exempt: new Set(groupOf(lexicon, "exempt")),
+  conditions: new Set(groupOf(lexicon, "condition")),
+});
+
+/** 鉤括弧の中の比較（「給与所得の確定申告がさらに簡単に！」ページ）は題や語を挙げたもので、書き手の比較ではない。 */
+const insideSpan = (found: BareComparative, span: Span): boolean => found.first.span.start >= span.start && found.last.span.end <= span.end;
+
+export const bareComparative: Detector = (doc): Finding[] => {
+  const lists = listsOf(doc.lexicons["comparative-baseline"] ?? []);
+  return doc.sentences.flatMap((sentence, at) => {
+    const nearby = doc.sentences.slice(Math.max(0, at - BASELINE_REACH), at + 1);
+    if (sentence.embeddedLanguage !== undefined || nearby.some((near) => namesBaseline(near, lists.baselines))) return [];
+    const quoted = quotedIn(sentence);
+    return bareComparativesIn(sentence.tokens ?? [], lists)
+      .filter((found) => !quoted.some((span) => insideSpan(found, span)))
+      .map((found) => ({
+        rule: "",
+        severity: "info",
+        line: 0,
+        column: 0,
+        quote: sentence.text.trim(),
+        values: { matched: doc.source.slice(found.first.span.start, found.last.span.end), offset: found.first.span.start },
+      }));
+  });
+};

package/src/detectors/chat-citation.ts

@@ -1,5 +1,6 @@
 import type { Detector, Finding, Lexicon, ProseDocument, Span } from "../plugin.ts";
 import { escapeRegExp } from "../orthography.ts";
+import { isQuotedAlone } from "../quoted-span.ts";
 import { findingAt, markupOf } from "./markup-finding.ts";
 
 /** One marker a chat interface leaves when its answer is pasted: where it is and what was written. */
@@ -42,9 +43,35 @@ const reachesReader = (doc: ProseDocument, span: Span): boolean => {
   return showsInProse(doc.prose, span) || within([...markup.texts, ...destinations], span);
 };
 
+/** Quotation marks, parentheses and sentence punctuation at the ends of a word, which are not part of it. */
+const SURROUNDING = new Set(['"', "'", "“", "”", "‘", "’", "(", ")", ".", ",", ";", ":", "!", "?"]);
+const SPACE = /\s/u;
+
+/** What is left of a string after the surrounding marks at both of its ends. */
+const withoutSurrounding = (text: string): string => {
+  const chars = [...text];
+  const first = chars.findIndex((char) => !SURROUNDING.has(char));
+  return first === -1 ? "" : chars.slice(first, chars.findLastIndex((char) => !SURROUNDING.has(char)) + 1).join("");
+};
+
+/**
+ * Whether the marker stands as a word of its own (links ending in "?utm_source=chatgpt.com", marks such as oaicite.), or
+ * alone in quotation marks, as Japanese writes it with no spaces (「?utm_source=chatgpt.com」の付いたリンク): prose
+ * about the marks names them. What a chat answer leaves is always joined to a URL or a citation (oaicite:0).
+ */
+export const standsAlone = (source: string, span: Span): boolean => {
+  if (isQuotedAlone(source, span)) return true;
+  const lineStart = source.lastIndexOf("\n", span.start - 1) + 1;
+  const lineEnd = source.indexOf("\n", span.end);
+  const before = source.slice(lineStart, span.start).split(SPACE).at(-1) ?? "";
+  const after = source.slice(span.end, lineEnd === -1 ? source.length : lineEnd).split(SPACE)[0] ?? "";
+  const marker = source.slice(span.start, span.end);
+  return withoutSurrounding(`${before}${marker}${after}`) === marker;
+};
+
 /** Each marker is a leftover in its own right, so each is reported, from the first. */
 export const chatCitationResidue: Detector = (doc, options): Finding[] => {
-  const markers = markersIn(doc.source, options.lexicon ?? []).filter((marker) => reachesReader(doc, marker.span));
+  const markers = markersIn(doc.source, options.lexicon ?? []).filter((marker) => reachesReader(doc, marker.span) && !standsAlone(doc.source, marker.span));
   if (markers.length === 0 || markers.length < options.limit) return [];
   return markers.map((marker) => findingAt(doc, marker.span, { matched: marker.matched, count: markers.length, limit: options.limit }));
 };

package/src/detectors/clause-shape.ts

@@ -159,16 +159,30 @@ const NOMINAL_POS: ReadonlySet<string> = new Set(["NOUN", "PROPN"]);
 const headAfter = (tokens: readonly Token[], at: number): number =>
   tokens.findIndex((token, index) => index > at && !isSpace(token) && !SKIPPED_POS.has(token.pos) && token.features?.["Bound"] !== "Yes");
 
+/** The last noun of the compound that starts at head (新規受付, 受付開始): the compound is named by its last word. */
+const compoundEnd = (tokens: readonly Token[], head: number): number => {
+  const after = tokens.findIndex((token, index) => index > head && !isSpace(token) && !NOMINAL_POS.has(token.pos));
+  const end = after === -1 ? tokens.length : after;
+  return tokens.slice(head, end).reduce((last, token, offset) => (NOMINAL_POS.has(token.pos) ? head + offset : last), head);
+};
+
+const SENTENCE_STOP = "。";
+
 /**
- * The head names a start or a sending (開始, 参る, 連絡). A noun head must be the action itself: followed by an object
- * marker or a light verb (受付を開始, 開始します), not a noun being compared (昨年より販売が増えた).
+ * The head names a start or a sending (開始, 参る, 連絡). A noun head must be the action itself: a compound whose last
+ * noun is listed (新規受付を開始, 受付開始します), followed by a light verb, the end of the sentence, or an object marker
+ * whose verb is listed too; not a noun being compared (昨年より販売が増えた, 昨年より新規受付を増やした) or a compound
+ * named by another noun (昨年より受付件数を増やした).
  */
 const isOriginHead = (tokens: readonly Token[], head: number, heads: ReadonlySet<string>, objectMarkers: ReadonlySet<string>): boolean => {
   const token = tokens[head];
-  if (token === undefined || !isListed(heads, token)) return false;
-  if (!NOMINAL_POS.has(token.pos)) return true;
-  const next = nextWord(tokens, head);
-  return next !== undefined && (objectMarkers.has(next.surface) || next.features?.["VerbType"] === "Light");
+  if (token === undefined) return false;
+  if (!NOMINAL_POS.has(token.pos)) return isListed(heads, token);
+  const last = compoundEnd(tokens, head);
+  if (!isListed(heads, tokens[last])) return false;
+  const next = nextWord(tokens, last);
+  if (next === undefined || next.surface === SENTENCE_STOP || next.features?.["VerbType"] === "Light") return true;
+  return objectMarkers.has(next.surface) && isListed(heads, nextWord(tokens, tokens.indexOf(next)));
 };
 
 type ParticleWords = { readonly particles: ReadonlySet<string>; readonly heads: ReadonlySet<string>; readonly objectMarkers: ReadonlySet<string> };

package/src/detectors/definition-use.ts

@@ -1,11 +1,17 @@
 import type { Detector, Finding, ProseDocument } from "../plugin.ts";
-import { definedTerms, unusedDefinitions, usesBeforeDefinition, type BodyText } from "../structure/definition-use.ts";
+import { definedTerms, unusedDefinitions, usesBeforeDefinition, type BodyText, type Mentioned } from "../structure/definition-use.ts";
 import { expansionConflicts, expansionsIn } from "../acronym-expansions.ts";
 import { linesOf, lineNumberAt } from "../structure/lines.ts";
+import { isQuotedAlone } from "../quoted-span.ts";
 import { quoteAt } from "./structure-tree.ts";
 
 const bodyOf = (doc: ProseDocument): BodyText[] => doc.sentences.map((sentence) => ({ start: sentence.span.start, text: sentence.text }));
 
+const mentionedIn =
+  (doc: ProseDocument): Mentioned =>
+  (start, end) =>
+    isQuotedAlone(doc.source, { start, end });
+
 const findingAt = (doc: ProseDocument, offset: number, values: Readonly<Record<string, string | number>>): Finding => ({
   rule: "",
   severity: "warning",
@@ -19,13 +25,17 @@ const findingAt = (doc: ProseDocument, offset: number, values: Readonly<Record<s
 export const unusedDefinition: Detector = (doc): Finding[] =>
   doc.structure === undefined
     ? []
-    : unusedDefinitions(definedTerms(doc.structure), bodyOf(doc)).map((defined) => findingAt(doc, defined.span.start, { term: defined.term }));
+    : unusedDefinitions(definedTerms(doc.structure), bodyOf(doc), mentionedIn(doc)).map((defined) =>
+        findingAt(doc, defined.span.start, { term: defined.term }),
+      );
 
 /** 文の途中で括弧に入れて定義した語を、定義より前で使っている所。 */
 export const useBeforeDefinition: Detector = (doc): Finding[] =>
   doc.structure === undefined
     ? []
-    : usesBeforeDefinition(definedTerms(doc.structure), bodyOf(doc)).map((use) => findingAt(doc, use.offset, { term: use.term.term, defined: use.term.line }));
+    : usesBeforeDefinition(definedTerms(doc.structure), bodyOf(doc), mentionedIn(doc)).map((use) =>
+        findingAt(doc, use.offset, { term: use.term.term, defined: use.term.line }),
+      );
 
 /** 同じ略語を、文書の中で二通りに展開している所。 */
 export const acronymExpansionConflict: Detector = (doc): Finding[] => {

package/src/detectors/ellipsis.ts

@@ -0,0 +1,74 @@
+import type { Detector, Finding } from "../plugin.ts";
+import { escapeRegExp } from "../orthography.ts";
+import { formMinority } from "./form-minority.ts";
+import { quoteAround } from "./quote-around.ts";
+
+// One document writing an ellipsis two ways ("..." and "…", "……" and "・・・"). Neither is called right; the less common is
+// reported. The forms come from each language's lexicon "ellipsis".
+
+/** One ellipsis as written. form is the lexicon's pattern it matched. */
+export type WrittenEllipsis = { readonly offset: number; readonly form: string };
+
+/** Characters an ellipsis is made of. A longer run ("....", "…・") is not read, since its form is unclear. */
+const ELLIPSIS_PART = "[.．…・‥]";
+
+/** A digit or a slash beside the dots: a range (1...10), a path (docs/.../index.md) or a page number after a leader (第1章・・・3). */
+const NOT_PROSE_BESIDE = /[\p{N}/]/u;
+/** The rest of a line after a leader in a table of contents ("Intro ... 12"). */
+const PAGE_NUMBER_LINE = /^\s*\p{N}+\s*(?:\n|$)/u;
+/** A word holding a scheme or a slash around the dots is an address (https://example.com/a...b). */
+const ADDRESS_WORD = /:\/\/|\//u;
+
+const SPACE = /\s/u;
+
+/** The run of non-space characters holding the dots. */
+const wordAround = (text: string, start: number, end: number): string => {
+  const from =
+    text
+      .slice(0, start)
+      .split("")
+      .findLastIndex((char) => SPACE.test(char)) + 1;
+  const after = text
+    .slice(end)
+    .split("")
+    .findIndex((char) => SPACE.test(char));
+  return text.slice(from, after === -1 ? text.length : end + after);
+};
+
+/** Dots that are not an ellipsis in running text: a range, a path or address, a table of contents leader. */
+const isNotProse = (text: string, start: number, end: number): boolean =>
+  NOT_PROSE_BESIDE.test(text.charAt(start - 1)) ||
+  NOT_PROSE_BESIDE.test(text.charAt(end)) ||
+  PAGE_NUMBER_LINE.test(text.slice(end)) ||
+  ADDRESS_WORD.test(wordAround(text, start, end));
+
+/** The ellipses in a text, matched longest form first, standing alone (not part of a longer run of dots). */
+export const ellipsesIn = (text: string, forms: readonly string[]): WrittenEllipsis[] => {
+  if (forms.length === 0) return [];
+  const alternatives = forms
+    .toSorted((left, right) => right.length - left.length)
+    .map(escapeRegExp)
+    .join("|");
+  const pattern = new RegExp(`(?<!${ELLIPSIS_PART})(?:${alternatives})(?!${ELLIPSIS_PART})`, "gu");
+  return [...text.matchAll(pattern)].flatMap((match) =>
+    isNotProse(text, match.index, match.index + match[0].length) ? [] : [{ offset: match.index, form: match[0] }],
+  );
+};
+
+export const ellipsisConsistency: Detector = (doc, options): Finding[] => {
+  const text = doc.prose ?? doc.source;
+  const ellipses = ellipsesIn(
+    text,
+    (doc.lexicons["ellipsis"] ?? []).map((entry) => entry.pattern),
+  );
+  const minority = formMinority(ellipses, options.limit);
+  if (minority === undefined) return [];
+  return minority.odd.map((ellipsis) => ({
+    rule: "",
+    severity: "info",
+    line: 0,
+    column: 0,
+    quote: quoteAround(text, ellipsis.offset, ellipsis.offset + ellipsis.form.length),
+    values: { written: ellipsis.form, usual: minority.usual.form, count: minority.odd.length, of: ellipses.length, offset: ellipsis.offset },
+  }));
+};

package/src/detectors/generic-heading.ts

@@ -0,0 +1,30 @@
+import type { Detector, Finding, Lexicon, MarkupHeading, ProseDocument } from "../plugin.ts";
+import { escapeRegExp } from "../orthography.ts";
+import { findingAt, writtenHeadings } from "./markup-finding.ts";
+
+/**
+ * 札と番号だけの見出し（メリット1、ポイント2、Benefit 3）。目次を見ても、節に何が書いてあるかが分からない。
+ * 札は語彙表 generic-heading-label が言う。題を足した見出し（メリット1：設定が要らない）は読まない。
+ */
+
+/** 番号の書き方。数字、丸数字、漢数字。前に「その」や「#」、後ろに区切りの記号が付いてもよい。 */
+const NUMBER = String.raw`(?:その)?\s*#?\s*[(（]?\s*(?:[0-9０-９]+|[①-⑳]|[一二三四五六七八九十]+)\s*(?:つ目)?\s*[:：.．。)）]?`;
+
+/** 札のどれかと番号だけで書いた見出しの形。札が無ければ undefined。 */
+export const bareLabelPattern = (labels: Lexicon): RegExp | undefined => {
+  const words = labels.map((entry) => escapeRegExp(entry.pattern)).filter((word) => word !== "");
+  return words.length === 0 ? undefined : new RegExp(`^(?:${words.join("|")})\\s*${NUMBER}$`, "iu");
+};
+
+/** 札と番号だけの見出し。 */
+export const bareLabelHeadings = (doc: ProseDocument): MarkupHeading[] => {
+  const pattern = bareLabelPattern(doc.lexicons["generic-heading-label"] ?? []);
+  return pattern === undefined ? [] : writtenHeadings(doc).filter((heading) => pattern.test(heading.text.trim()));
+};
+
+/** 数で見る。一つなら書き手の選び方、並べば型をなぞった見出し。 */
+export const genericHeading: Detector = (doc, options): Finding[] => {
+  const bare = bareLabelHeadings(doc);
+  if (bare.length === 0 || bare.length < options.limit) return [];
+  return bare.map((heading) => findingAt(doc, heading, { heading: heading.text.trim(), count: bare.length, limit: options.limit }));
+};