chaffjs 0.23.0 → 0.25.0

package/rules/missing-space-after-comma.yaml

@@ -0,0 +1,57 @@
+id: missing-space-after-comma
+layer: L1
+status: stable
+how_to_find: missing-space-after-comma
+languages: [en]
+severity: warning
+
+name:
+  ja: カンマの後ろに空白が無い
+  en: No space after a comma
+
+why:
+  ja: 英文では、語をつなぐカンマの後ろに空白を一つ置きます。「address,and」のように空白が無いと、二つの語が一語に見え、検索でも別の語として当たりません。急いで打ったときや、書き換えの途中で空白が落ちた跡です。どちらの書き方を選ぶかの話ではなく、英語の句読点の決まりです。
+  en: 'English puts one space after a comma between words. Without it ("address,and") the two words read as one, and a search does not find either. It is a space dropped while typing or editing, not a matter of style.'
+
+message:
+  ja: 「{written}」のカンマの後ろに空白がありません
+  en: 'No space after the comma in "{written}"'
+
+how_to_fix:
+  ja: カンマの後ろに空白を一つ入れてください。
+  en: Put one space after the comma.
+
+levels: { strict: error, normal: warning, relaxed: info }
+
+use_for: [business, technical, blog, legal, docs, academic, literature, speech]
+off_for:
+  literature: Older printed texts and poetry set commas tight on purpose, and a transcribed edition keeps the printer's spacing.
+
+group: slips
+summary:
+  ja: 英文の「address,and」のように、語をつなぐカンマの後ろに空白が無い所
+  en: A comma between two words with no space after it, as in "address,and"
+example:
+  en:
+    before: |
+      Send the form to the office address,and keep a copy.
+    after: |
+      Send the form to the office address, and keep a copy.
+
+not_flagged:
+  ja: 英語の文書だけで動きます。値を並べたもの（blue,black,brown のようにカンマが二つ以上）、数字や記号を含むもの（3,000、a,b=c、path/a,b、user@x,y、file_name,size）、引用符で囲んだ値（"true,false"）、二字以下の語（id,x）、コードと URL は見ません。
+  en: 'Only in English documents. A run of values (two or more commas, as in blue,black,brown), a run holding a digit or a mark (3,000, a,b=c, path/a,b, user@x,y, file_name,size), a quoted value ("true,false"), words of one or two letters (id,x), code and URLs are not read.'
+sources: [vale-styles]
+rewrite:
+  depth: light
+  en:
+    direction: Put one space after the marked comma. Change nothing else.
+    pairs:
+      - before: Send it to the office address,and keep a copy.
+        after: Send it to the office address, and keep a copy.
+      - before: If the box is damaged,call us first.
+        after: If the box is damaged, call us first.
+    keep:
+      - the words and their order
+    avoid:
+      - adding spaces inside lists of values or code

package/rules/numbered-generic-heading.yaml

@@ -0,0 +1,111 @@
+id: numbered-generic-heading
+layer: L1
+status: stable
+how_to_find: generic-heading
+word_list: generic-heading-label
+requires: [markdown]
+severity: info
+
+name:
+  ja: 札と番号だけの見出し
+  en: Headings that are only a label and a number
+
+why:
+  ja: 「メリット1」「メリット2」「ポイント3」のように札と番号だけの見出しは、目次や見出しの一覧で読んでも、その節に何が書いてあるかが分かりません。読み手は節を開くまで中身を知れず、あとで探すこともできません。型をなぞって書いた文書に多い形です。札は語彙表 generic-heading-label にあり、手順の札（ステップ1）は順番そのものが中身なので入れていません。
+  en: 'Headings such as "Benefit 1", "Benefit 2" and "Tip 3" say nothing about their sections. A reader scanning the table of contents learns nothing until they open each one, and cannot find a section again later. Documents written to a template are full of them. The labels are in the lexicon generic-heading-label; step labels ("Step 1") are left out, since in a procedure the order is the content.'
+
+message:
+  ja: 見出し「{heading}」は札と番号だけで、節の中身が分かりません（そういう見出しが {count} 個）
+  en: 'The heading "{heading}" is only a label and a number and says nothing about the section ({count} such headings)'
+
+how_to_fix:
+  ja: 札の後ろに、その節で言うことを書いてください（メリット1 → メリット1：設定が要らない、または 設定が要らない）。
+  en: 'Say what the section says ("Benefit 1" becomes "Benefit 1: no setup" or simply "No setup needed").'
+
+levels: { strict: 1, normal: 2, relaxed: 3 }
+
+use_for: [blog, business, technical, docs, academic, legal, literature, speech]
+off_for:
+  literature: "A literary work names its parts as it likes."
+  speech: "A transcript has no headings of its own."
+
+group: structure
+summary:
+  ja: 「メリット1」「ポイント2」「Benefit 3」のように、札と番号だけで中身を言わない見出しが並ぶ所
+  en: Headings such as "Benefit 1" and "Tip 2" that are only a label and a number
+
+example:
+  ja:
+    before: |
+      # 新しい会議室予約の仕組み
+
+      ## メリット1
+
+      空き状況がすぐ分かります。
+
+      ## メリット2
+
+      予約の取り消しが一度で済みます。
+    after: |
+      # 新しい会議室予約の仕組み
+
+      ## 空き状況がすぐ分かる
+
+      空き状況がすぐ分かります。
+
+      ## 取り消しが一度で済む
+
+      予約の取り消しが一度で済みます。
+  en:
+    before: |
+      # The new room booking system
+
+      ## Benefit 1
+
+      You can see free rooms at once.
+
+      ## Benefit 2
+
+      You can cancel a booking in one step.
+    after: |
+      # The new room booking system
+
+      ## Free rooms at a glance
+
+      You can see free rooms at once.
+
+      ## One-step cancelling
+
+      You can cancel a booking in one step.
+
+not_flagged:
+  ja: 札の後ろに題を足した見出し（メリット1：設定が要らない）、手順・理由・課題の見出し（ステップ1、理由2、課題3）、章や節の番号（第1章）は、番号で引かれる単位なので指しません。Markdown の見出しだけを読みます。
+  en: 'A heading with a title after the label ("Benefit 1: no setup"), step, lesson, reason and feature headings ("Step 1", "Lesson 2", "Reason 3"), and chapter or section numbers ("Chapter 1") are not reported: each is a unit cited by its number. Only Markdown headings are read.'
+level_meaning:
+  ja: 札と番号だけの見出しが {limit} 個から指摘
+  en: reported from {limit} such headings
+
+rewrite:
+  depth: structure
+  ja:
+    direction: 札と番号だけの見出しに、その節で言うことを一言で書いてください。節の本文から言葉を取り、本文に無いことは足しません。
+    pairs:
+      - before: "## メリット1"
+        after: "## 空き状況がすぐ分かる"
+      - before: "## ポイント2"
+        after: "## 取り消しは前日まで"
+    keep:
+      - 節の順番と本文
+    avoid:
+      - 本文に書かれていない中身を見出しに書く
+  en:
+    direction: Give each label-and-number heading a few words that say what its section says, taken from the section itself.
+    pairs:
+      - before: "## Benefit 1"
+        after: "## Free rooms at a glance"
+      - before: "## Tip 2"
+        after: "## Cancel by the day before"
+    keep:
+      - the order of the sections and their text
+    avoid:
+      - putting a claim in a heading that the section does not make

package/rules/undefined-acronym.yaml

@@ -18,6 +18,7 @@ extra_word_lists:
     name-title,
     date-time-unit,
     http-method,
+    reference-list-heading,
   ]
 uses: [pos]
 severity: info

package/rules/unit-spacing-consistency.yaml

@@ -0,0 +1,74 @@
+id: unit-spacing-consistency
+layer: L2
+status: stable
+how_to_find: unit-spacing-consistency
+severity: info
+
+name:
+  ja: 数と単位の間の空白が混ざっている
+  en: Units spaced two ways
+
+why:
+  ja: 一つの文書で「5 GB」と「5GB」のように、数と単位記号の間を空ける所と詰める所が混ざると、読み手は違いに意味があるのかと迷い、別々の所から貼り合わせた文書に見えます。検索でも片方を取りこぼします。どちらが正しいかは決めず、単位ごとに、文書の中で少ないほうを指します。
+  en: 'A document writing "5 GB" in one place and "5GB" in another makes the reader wonder whether the difference means something, looks pasted together, and splits a search. chaff does not pick a side; unit by unit, it points at the way the document uses less.'
+
+message:
+  ja: 「{written}」と書いています（この文書はこの単位をふつう「{usual}」のように書きます。{of} 箇所のうち {count} 箇所が違う）
+  en: '"{written}" here, where the document usually writes this unit like "{usual}" ({count} of {of})'
+
+how_to_fix:
+  ja: 文書の多いほうの書き方に合わせてください。
+  en: Match the way the rest of the document writes units.
+
+# 少ないほうが、数と単位の組の何パーセントまでなら「混ざっている」と見るか。これを超えたら、文書が使い分けている。
+levels: { strict: 49, normal: 34, relaxed: 20 }
+
+use_for: [business, technical, blog, legal, docs, academic, literature, speech]
+
+group: consistency
+summary:
+  ja: 「5 GB」と「5GB」のように、一つの文書で数と単位記号の間を空けたり詰めたりしている所
+  en: A number and a unit symbol spaced in some places and not in others, such as "5 GB" and "5GB"
+example:
+  ja:
+    before: |
+      容量は 5 GB、転送量は 10 GB、上限は 20GB です。
+    after: |
+      容量は 5 GB、転送量は 10 GB、上限は 20 GB です。
+  en:
+    before: |
+      Storage is 5 GB, transfer is 10 GB and the cap is 20GB.
+    after: |
+      Storage is 5 GB, transfer is 10 GB and the cap is 20 GB.
+
+not_flagged:
+  ja: 単位記号の一覧にあるものだけを見ます。一字の記号（m、s、g）、パーセント、温度（°C）は、空けない書き方が別に定着しているので数えません。語で書いた単位（5 時間、5 hours）、コードの中、版や番地の中の数（1.2.3GB）も見ません。単位ごとに比べるので、「5 GB」と「500ms」が並んでも混在とは読みません。ノーブレークスペースも空白と数えます。少ないほうが 3 分の 1 を超える文書や、二通りが同じ数の文書は、使い分けていると読んで指しません。
+  en: Only the unit symbols on chaff's list are read. One-letter symbols (m, s, g), the percent sign and temperatures (°C) are left out, since many styles write them unspaced on purpose. Units written as words (5 hours), code, and numbers inside versions or addresses (1.2.3GB) are not read. Each unit is compared with itself, so "5 GB" next to "500ms" is not a mix. A no-break space counts as a space. When the less common way is over a third, or the two are equally common, the document is read as using both on purpose.
+level_meaning:
+  ja: 少ないほうが {limit}% までなら指摘
+  en: reported while the less common way is at most {limit}% of the units
+sources: [vale-styles]
+rewrite:
+  depth: light
+  ja:
+    direction: 指した所だけ、数と単位の間を文書の多いほうに合わせてください。ほかは変えません。
+    pairs:
+      - before: 上限は 20GB です。
+        after: 上限は 20 GB です。
+      - before: 間隔は 500 ms です。
+        after: 間隔は 500ms です。
+    keep:
+      - 数と単位そのもの
+    avoid:
+      - 単位を別の単位に換える
+  en:
+    direction: Add or remove the space between the number and the unit at the marked place only, to match the rest of the document.
+    pairs:
+      - before: The cap is 20GB.
+        after: The cap is 20 GB.
+      - before: The interval is 500 ms.
+        after: The interval is 500ms.
+    keep:
+      - the number and the unit
+    avoid:
+      - converting the unit

package/skills/chaff/SKILL.md

@@ -96,9 +96,26 @@ Pick the easiest way that can say the requirement:
 | Requirement | Use |
 | --- | --- |
 | An existing rule covers it | A level, a number, `prefer`, `jargon` or `required_sections` in `chaff.yaml` |
-| A fixed phrase or pattern, with the team's own message | `custom_rules` of type `words` or `pattern` (coming in the next release) |
-| Decided by part of speech or inflection | `custom_rules` of type `tokens` (coming in the next release) |
-| Counting or comparing that the above cannot express | a Node function, `type: module` (a later release) |
+| A fixed phrase or pattern, with the team's own message | `custom_rules` of type `words` or `pattern` |
+| Decided by part of speech or inflection | `custom_rules` of type `tokens` |
+| Counting or comparing that the above cannot express | a Node function, `type: module` |
+| The same rules shared across repositories | a rule pack of YAML files: `npx chaffjs init --plugin <name>`, then `plugins:` in `chaff.yaml` |
+
+A `words` rule names the words, the team's text for each field `explain` shows, and one example:
+
+```yaml
+custom_rules:
+  - id: banned-word
+    type: words
+    words: [禁止ワード]
+    severity: warning
+    name: { ja: 禁止ワード }
+    why: { ja: この文書で避ける語です }
+    message: { ja: "「{matched}」は使いません" }
+    how_to_fix: { ja: 別の言い方にします }
+    example:
+      ja: { before: 禁止ワードを使った文, after: 別の言い方の文 }
+```
 
 Test a new team rule the same way: `explain`, then a sample it must report and a sample it must not, before
 committing `chaff.yaml`. The guide page "Adding a rule" covers each way and how to add a rule to chaff itself.

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/connective-hierarchy.ts

@@ -0,0 +1,99 @@
+import type { Detector, Finding, LexiconEntry, Sentence, Span, Token } from "../plugin.ts";
+import { escapeRegExp } from "../orthography.ts";
+import { quotedSpans } from "../quoted-span.ts";
+
+// A connective that joins only the outer level of a two-level list, in a sentence with no inner level under it. The
+// lexicon holds both levels: an entry with a rewrite is an outer-level word (rewrite is the word a one-level list uses),
+// and an entry with instead_of is an inner-level word that stands under that outer-level word.
+
+/** One outer-level connective with nothing to stand above, and where it is in the document. */
+export type LoneConnective = { readonly offset: number; readonly written: string; readonly usual: string };
+
+const CONJUNCTION = "CCONJ";
+
+/** The word lists the detector reads: the connectives, and the phrases that hold one's letters without being one (歯並びに). */
+export type ConnectiveLists = { readonly connectives: readonly LexiconEntry[]; readonly lookalikes: readonly LexiconEntry[] };
+
+/**
+ * The tagger does not always tell a connective from a noun and a particle: it reads 申請書並びに as 並び + に and
+ * 文字の並びに as the conjunction. After の, a determiner or an adjective (の並びに, この並びに, 正しい並びに) the word is
+ * a noun of its own. Where the tagger splits it, it is a connective only between two nouns: a noun, a number or a mark
+ * before it, and no verb right after it (一列並びに座る).
+ */
+const MODIFIES_NOUN: ReadonlySet<string> = new Set(["DET", "ADJ"]);
+const GENITIVE = "の";
+const JOINS_AFTER: ReadonlySet<string> = new Set(["NOUN", "PROPN", "NUM", "PUNCT", "SYM"]);
+const ENDS_CLAUSE: ReadonlySet<string> = new Set(["VERB", "AUX"]);
+
+const modifiesNoun = (token: Token | undefined): boolean =>
+  token !== undefined && (MODIFIES_NOUN.has(token.pos) || (token.pos === "ADP" && token.surface === GENITIVE));
+
+const joinsNouns = (previous: Token | undefined, next: Token | undefined): boolean =>
+  previous !== undefined && JOINS_AFTER.has(previous.pos) && next !== undefined && !ENDS_CLAUSE.has(next.pos);
+
+/** A sentence's tokens by where they start and end, and the letters a connective there would not be read in. */
+type Reading = { readonly byStart: ReadonlyMap<number, Token>; readonly byEnd: ReadonlyMap<number, Token>; readonly hidden: readonly boolean[] };
+
+const placesOf = (text: string, word: string): number[] => [...text.matchAll(new RegExp(escapeRegExp(word), "gu"))].map((match) => match.index);
+
+/** Inside 「」 or 『』 (a quoted phrase holds half a list) or inside a lookalike (歯並びに), by the sentence's own offsets. */
+const hiddenLetters = (text: string, lookalikes: readonly LexiconEntry[]): boolean[] => {
+  const hidden = Array.from({ length: text.length }, () => false);
+  const hide = (start: number, end: number): boolean[] => hidden.fill(true, start, end);
+  quotedSpans(text).forEach((span) => hide(span.start, span.end));
+  lookalikes.forEach(({ pattern }) => placesOf(text, pattern).forEach((at) => hide(at, at + pattern.length)));
+  return hidden;
+};
+
+const readingOf = (sentence: Sentence, lookalikes: readonly LexiconEntry[]): Reading => {
+  const tokens = sentence.tokens ?? [];
+  return {
+    byStart: new Map(tokens.map((token) => [token.span.start, token])),
+    byEnd: new Map(tokens.map((token) => [token.span.end, token])),
+    hidden: hiddenLetters(sentence.text, lookalikes),
+  };
+};
+
+const standsAsConnective = (reading: Reading, span: Span): boolean => {
+  const previous = reading.byEnd.get(span.start);
+  if (modifiesNoun(previous)) return false;
+  const own = reading.byStart.get(span.start);
+  const tagged = own !== undefined && own.pos === CONJUNCTION && own.span.end === span.end;
+  return tagged || joinsNouns(previous, reading.byStart.get(span.end));
+};
+
+const hasInnerLevel = (sentence: Sentence, outer: LexiconEntry, connectives: readonly LexiconEntry[]): boolean =>
+  connectives.some((entry) => entry.instead_of === outer.pattern && sentence.text.includes(entry.pattern));
+
+/** Where one outer-level word stands as a connective in the sentence. */
+const connectiveSpans = (sentence: Sentence, outer: LexiconEntry, reading: Reading): Span[] =>
+  placesOf(sentence.text, outer.pattern)
+    .filter((at) => reading.hidden[at] !== true)
+    .map((at) => ({ start: sentence.span.start + at, end: sentence.span.start + at + outer.pattern.length }))
+    .filter((span) => standsAsConnective(reading, span));
+
+/** The outer-level connectives of a sentence that stand over no inner level. */
+export const loneConnectivesIn = (sentence: Sentence, lists: ConnectiveLists): LoneConnective[] => {
+  const lone = lists.connectives.filter(
+    (entry) => entry.rewrite !== undefined && sentence.text.includes(entry.pattern) && !hasInnerLevel(sentence, entry, lists.connectives),
+  );
+  if (lone.length === 0) return [];
+  const reading = readingOf(sentence, lists.lookalikes);
+  return lone
+    .flatMap((entry) => connectiveSpans(sentence, entry, reading).map((span) => ({ offset: span.start, written: entry.pattern, usual: entry.rewrite ?? "" })))
+    .sort((a, b) => a.offset - b.offset);
+};
+
+export const connectiveHierarchy: Detector = (doc, options): Finding[] => {
+  const lists = { connectives: options.lexicon ?? [], lookalikes: doc.lexicons["connective-lookalike"] ?? [] };
+  return doc.sentences.flatMap((sentence) =>
+    loneConnectivesIn(sentence, lists).map((lone) => ({
+      rule: "",
+      severity: "info",
+      line: 0,
+      column: 0,
+      quote: sentence.text.trim(),
+      values: { written: lone.written, usual: lone.usual, offset: lone.offset },
+    })),
+  );
+};