@shuji-bonji/rfcxml-mcp 0.6.13 → 0.6.53

package/dist/utils/statement-matcher.js

@@ -309,8 +309,12 @@ export function extractKeywords(text) {
  * Extract requirement level from text
  */
 export function extractRequirementLevel(text) {
+    // **原文どおりの大文字だけ**をレベルとみなす。`toUpperCase()` してから照合
+    // していたため、"the optional cookie extension" の optional が `OPTIONAL` に
+    // なり、RFC 8446 §4.2.2 の MUST と「レベルの対」で矛盾していた（8 件）。
+    // BCP 14 は「すべて大文字で書かれたときに限る」と定めている（RFC 8174）。
     const regex = createRequirementRegex();
-    const match = regex.exec(text.toUpperCase());
+    const match = regex.exec(text);
     if (match) {
         return match[1];
     }
@@ -419,15 +423,29 @@ export function requirementSubjectOf(requirement) {
  * Score a requirement against statement keywords
  */
 export function scoreRequirementMatch(requirement, statementKeywords, statementSubject, statementLevel) {
-    const reqText = (requirement.text + ' ' + (requirement.fullContext || '')).toLowerCase();
+    // 当たりは段落まで見る。要件文だけでは条件が拾えないことがある。
+    // ただし **どこで当たったかを分けて返す**。分けずに返していたため、
+    // `_matchedKeywords` に要件文が持たない語が並んでいた。RFC 7159 §8.1 の
+    // `Implementations MUST NOT add a byte order mark …` は、同じ段落にある
+    // 次の文の語（`ignore` `presence` `rather` `treating` `error`）まで
+    // 「一致した語」として並べていた。**その要件は ignore とは書いていない。**
+    // 実測（RFC 67 本・一致の行 1,710 件）: 要件文に無い語を含む行が 1,092 件
+    // （63.9%）、最上位の一致に限ると 176 件中 28 件（15.9%）。
+    const ownText = requirement.text.toLowerCase();
+    const contextText = (requirement.fullContext || '').toLowerCase();
     const matchedKeywords = [];
+    const contextKeywords = [];
     let score = 0;
     // Score based on keyword matches
     for (const [keyword, weight] of statementKeywords) {
-        if (requirementTextHasKeyword(reqText, keyword)) {
+        if (requirementTextHasKeyword(ownText, keyword)) {
             matchedKeywords.push(keyword);
             score += weight;
         }
+        else if (requirementTextHasKeyword(contextText, keyword)) {
+            contextKeywords.push(keyword);
+            score += weight;
+        }
     }
     // Bonus for subject match
     const reqSubject = requirementSubjectOf(requirement);
@@ -444,11 +462,34 @@ export function scoreRequirementMatch(requirement, statementKeywords, statementS
         requirement,
         score,
         matchedKeywords,
+        contextKeywords,
         subjectMatch,
         levelMatch,
     };
 }
-const NEGATION_PAIRS = [
+/**
+ * どの動詞にも共通する否定の言い回し。
+ *
+ * `NEGATION_PAIRS` の `negative` は手書きだったため、動詞ごとに揃っていなかった。
+ * `mask` には "without mask" があるのに `send` には無く、RFC 2818 §2.2.1 の
+ * "Clients MUST send a closure alert before closing the connection." に対する
+ * 「The client closes the connection **without sending** a close_notify alert.」が
+ * 矛盾として挙がらなかった。
+ *
+ * 一致は部分文字列で見るので、"without send" は "without sending" にも当たる。
+ * 不規則な否定形（unmask / exclude / reject など）は各対に書く。
+ */
+function commonNegations(positive) {
+    return [`not ${positive}`, `never ${positive}`, `without ${positive}`];
+}
+/** 手書きの不規則な否定形に、共通の言い回しを足したもの。 */
+function withCommonNegations(pairs) {
+    return pairs.map((pair) => ({
+        ...pair,
+        negative: [...new Set([...pair.negative, ...commonNegations(pair.positive)])],
+    }));
+}
+const NEGATION_PAIRS = withCommonNegations([
     {
         positive: 'mask',
         negative: ['unmask', 'unmasked', 'not mask', 'without mask', 'without masking'],
@@ -489,7 +530,7 @@ const NEGATION_PAIRS = [
     { positive: 'enable', negative: ['disable', 'not enable'], generic: true },
     { positive: 'close', negative: ['not close', 'keep open'], generic: true },
     { positive: 'open', negative: ['not open', 'close'], generic: true },
-];
+]);
 /**
  * テキストが positive アクションを含むか判定（negative でないことを確認）
  * "masks" → true, "unmasked" → false
@@ -691,6 +732,84 @@ export function identifiersOf(text) {
     }
     return [...found];
 }
+/**
+ * 固有の名前どうしをつなぐ語。前の名前の直後から次の名前の直前まで。
+ *
+ * "1xx (Informational) or 204 (No Content)" / "GET, PUT, or DELETE" /
+ * "Transfer-Encoding or Content-Length" / "a) the 304 … or b) the 412" の形。
+ * 句点・動詞・目的語を挟むものはつながない。
+ */
+const IDENTIFIER_CONNECTOR = /^\s*(?:\([^()]*\)\s*)?,?\s*(?:(?:or|and|nor|and\/or)\s+)?(?:[a-z]\)\s*)?(?:(?:a|an|the)\s+)?$/i;
+/**
+ * 固有の名前を「すべて要る」ものと「いずれか 1 つで足りる」群に分ける。
+ *
+ * `describesSameAct` は `identifiersOf` の名前を**すべて**主張に求めていた。
+ * 要件が選言で書かれていると、片方だけを述べた違反を見逃す。RFC 9110 §8.6 の
+ * "A server MUST NOT send a Content-Length header field in any response with a
+ * status code of 1xx (Informational) or 204 (No Content)." に対し、
+ * "A server sends a Content-Length header field in a 204 response." は
+ * `1xx` が無いので「別の行為」になり、`isValid: true` を返していた。
+ * 同型の否定要件は 6 本で 11 件（RFC 9110 §9.3.6 `Transfer-Encoding or
+ * Content-Length`、RFC 9114 §4.1.1 `GET, PUT, or DELETE` など）。
+ *
+ * 名前の出現を並べ、`IDENTIFIER_CONNECTOR` でつながる連なりを 1 つの並びと
+ * みなす。並びのどこかに `or` があればその並びは選言で、いずれか 1 つが
+ * 主張にあればよい。`and` や読点だけの並び、単独の名前は従来どおりすべて要る
+ * （`MAX_PUSH_ID` のような名前は 1 つしか無いので、これまでと変わらない）。
+ */
+export function identifierGroupsOf(text) {
+    // 引用は落とすが、位置がずれないよう同じ長さの空白にする。
+    const scrubbed = text.replace(/\[[^\]]*\]/g, (citation) => ' '.repeat(citation.length));
+    const identifiers = identifiersOf(scrubbed);
+    const occurrences = [];
+    for (const name of identifiers) {
+        const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        const pattern = new RegExp(`(?<![A-Za-z0-9_])${escaped}(?![A-Za-z0-9_])`, 'g');
+        for (const match of scrubbed.matchAll(pattern)) {
+            occurrences.push({ name, start: match.index, end: match.index + name.length });
+        }
+    }
+    occurrences.sort((a, b) => a.start - b.start);
+    const runs = [];
+    let previous = null;
+    for (const current of occurrences) {
+        const between = previous ? scrubbed.slice(previous.end, current.start) : '';
+        const run = runs[runs.length - 1];
+        if (previous && run && IDENTIFIER_CONNECTOR.test(between)) {
+            run.names.push(current.name);
+            if (/\bor\b/i.test(between))
+                run.disjunctive = true;
+        }
+        else {
+            runs.push({ names: [current.name], disjunctive: false });
+        }
+        previous = current;
+    }
+    const anyOf = [];
+    const grouped = new Set();
+    for (const run of runs) {
+        if (run.disjunctive && run.names.length > 1) {
+            const names = [...new Set(run.names)];
+            anyOf.push(names);
+            for (const name of names)
+                grouped.add(name);
+        }
+    }
+    return { required: identifiers.filter((name) => !grouped.has(name)), anyOf };
+}
+/** 主張が、要件の固有の名前を（選言は 1 つで足りるとして）すべて含むか。 */
+function statementNamesIdentifiers(statementLower, scope) {
+    const { required, anyOf } = identifierGroupsOf(scope);
+    for (const identifier of required) {
+        if (!statementLower.includes(identifier.toLowerCase()))
+            return false;
+    }
+    for (const group of anyOf) {
+        if (!group.some((identifier) => statementLower.includes(identifier.toLowerCase())))
+            return false;
+    }
+    return true;
+}
 /**
  * 禁止や要求を限定している語。
  *
@@ -727,14 +846,38 @@ export function conditionOf(text) {
     const condition = clipAtClauseEnd(match[2]);
     return condition.length > 0 ? condition : null;
 }
-/** 2 つの文字列に共通する内容語があるか。 */
-function sharesContentWord(a, b) {
-    const wordsOf = (text) => text
+/** 内容語（機能語と BCP 14 キーワードを除いた 3 文字以上の語）。 */
+function contentWordsOf(text) {
+    return text
         .toLowerCase()
         .split(/[^a-z0-9]+/)
         .filter((word) => word.length >= MATCHING_LIMITS.MIN_KEYWORD_LENGTH && !STOP_WORDS.has(word));
-    const other = wordsOf(b).join(' ');
-    return wordsOf(a).some((word) => requirementTextHasKeyword(other, word));
+}
+/** 2 つの文字列に共通する内容語があるか。 */
+function sharesContentWord(a, b) {
+    const other = contentWordsOf(b).join(' ');
+    return contentWordsOf(a).some((word) => requirementTextHasKeyword(other, word));
+}
+/**
+ * 双方の条件節に内容語があるときだけ、重なりを求める。
+ *
+ * RFC 9110 §10.1.3 の "MUST NOT include the fragment and userinfo components
+ * of the URI reference [URI], **if any**, when generating the Referer field
+ * value." は、`condition` が "any" になる。内容語が 1 つも無い条件節は
+ * 比べようがなく、求めると当の要件が常に「別の行為」になる。
+ * 片方にしか無いときと同じく、判断材料が無いので通す。
+ */
+function conditionsDiverge(requirementCondition, statement) {
+    if (!requirementCondition)
+        return false;
+    const statementCondition = conditionOf(statement);
+    if (!statementCondition)
+        return false;
+    if (contentWordsOf(requirementCondition).length === 0)
+        return false;
+    if (contentWordsOf(statementCondition).length === 0)
+        return false;
+    return !sharesContentWord(requirementCondition, statementCondition);
 }
 /**
  * 主張の主動詞。主語語の次に来る語を採る。
@@ -752,17 +895,115 @@ export function statementMainVerb(statement, subject) {
         .map((word) => word.replace(/[^a-z]/g, ''))
         .filter(Boolean);
     const index = words.findIndex((word) => singular(word) === subject);
-    if (index === -1 || index + 1 >= words.length)
+    if (index === -1)
         return null;
-    return words[index + 1];
+    const next = afterCompoundSubject(words, index);
+    if (next >= words.length)
+        return null;
+    return words[next];
+}
+/**
+ * 複数語の主語の終わり。主語語の次の語を返す。
+ *
+ * `SUBJECT_TERMS` は 1 語ずつ持つので、"user agent" の主語は `user` になる。
+ * その次の語 `agent` を動詞の位置として読むと、`findStatementVerb` は
+ * 限定語でない語に当たって `null` を返し、**矛盾検出が一切動かない**。
+ * RFC 9110 §10.1.3 の Referer の禁止に反する主張が `isValid: true` になっていた
+ * （RFC 9110 で 36 件、RFC 6265 で 62 件中 38 件の要件が主語 `user agent`）。
+ *
+ * 主語語が続いているあいだ（"user agent" "proxy server"）は主語の一部として
+ * 読み飛ばす。"a user sends …" は次の語が主語語ではないので従来どおり。
+ */
+function afterCompoundSubject(words, subjectIndex) {
+    let index = subjectIndex + 1;
+    while (index < words.length && SUBJECT_TERMS.has(singular(words[index])))
+        index++;
+    return index;
 }
 /** 主張が実際にその動詞の行為を述べているか（主動詞で見る）。 */
-export function statementPerformsVerb(statement, subject, verb) {
-    const main = statementMainVerb(statement, subject);
-    if (!main)
-        return false;
+/** 主語と動詞の間に挟まる限定句を、何語まで飛ばすか。 */
+const SUBJECT_TO_VERB_GAP = 8;
+/**
+ * 主張の中でその行為を述べている動詞の位置を返す。無ければ `null`。
+ *
+ * 主語の**直後**だけを見ると、限定句を挟む主張で動詞が見つからない。
+ *
+ * - `An origin server without a clock generates a Date header field.`
+ *   → 主語 "server" の次は "without" で、動詞ではない
+ *
+ * 主語から数語のあいだを見て、その行為の動詞（同義語を含む）を探す。
+ */
+function findStatementVerb(statement, subject, verb) {
+    if (!subject)
+        return null;
+    const words = statement
+        .toLowerCase()
+        .split(/\s+/)
+        .map((word) => word.replace(/[^a-z']/g, ''))
+        .filter(Boolean);
+    const found = words.findIndex((word) => singular(word) === subject);
+    if (found === -1)
+        return null;
+    // 複数語の主語（"user agent"）は、最後の主語語のあとから動詞を探す。
+    const start = afterCompoundSubject(words, found) - 1;
     const group = VERB_SYNONYMS.find((synonyms) => synonyms.includes(verb)) ?? [verb];
-    return group.some((synonym) => main.startsWith(synonym));
+    const limit = Math.min(words.length, start + 1 + SUBJECT_TO_VERB_GAP);
+    // 飛ばしてよいのは、主語のすぐあとに続く限定句だけである。
+    // 語なら何でも飛ばすと、目的語の中の語を動詞と取り違える。
+    //
+    //   "The server removes masking for data frames received from a client."
+    //
+    // ここで "masking" を動詞と取ると、「サーバはマスクしてはならない」に
+    // 違反していると誤って報告する（実際はマスクを外す側の話である）。
+    let previousWasQualifier = false;
+    for (let index = start + 1; index < limit; index++) {
+        const word = words[index];
+        if (group.some((synonym) => word.startsWith(synonym))) {
+            return { index, words, matched: word };
+        }
+        const isQualifier = SUBJECT_QUALIFIER_WORDS.has(word);
+        if (!isQualifier && !previousWasQualifier)
+            return null;
+        previousWasQualifier = isQualifier;
+    }
+    return null;
+}
+/**
+ * 主語と動詞の間に挟まってよい語。
+ *
+ * 「限定句のすぐ次の 1 語」も飛ばす（"without **a clock** generates" の "clock"）。
+ */
+const SUBJECT_QUALIFIER_WORDS = new Set([
+    'with',
+    'without',
+    // `findQualifierOnlyViolation` の `saysTheSame` が拾う言い換え。ここに無いと
+    // "An origin server lacking a clock generates …" で動詞に届かず、
+    // `isValid: true` になっていた（"that lacks a clock" は `that` で届く）。
+    'lacking',
+    'lacks',
+    'lack',
+    'missing',
+    'that',
+    'which',
+    'who',
+    'has',
+    'have',
+    'having',
+    'no',
+    'a',
+    'an',
+    'the',
+    'of',
+    'in',
+    'on',
+    'for',
+    'its',
+    'their',
+    'and',
+    'or',
+]);
+export function statementPerformsVerb(statement, subject, verb) {
+    return findStatementVerb(statement, subject, verb) !== null;
 }
 /**
  * 主張と要求アクションが同じ事柄についてのものか。
@@ -783,25 +1024,23 @@ export function statementPerformsVerb(statement, subject, verb) {
  * 3. 双方に条件節があるなら、内容語が 1 語以上重なること
  *    （片方にしか無い場合は判断材料が無いので通す）
  */
-export function describesSameAct(statement, requirement, action) {
+export function describesSameAct(statement, requirement, action, options = {}) {
     const lower = statement.toLowerCase();
     // 名前と限定は要件文全体から取る。要求アクションの外に置かれることがある。
     //   "An origin server **without a clock** MUST NOT generate a Date header field."
     //   "The **HEAD** method is identical to GET except that the server MUST NOT send content …"
     const scope = `${requirement.text} ${action}`;
-    for (const identifier of identifiersOf(scope)) {
-        if (!lower.includes(identifier.toLowerCase()))
-            return false;
-    }
-    for (const qualifier of qualifiersOf(scope)) {
-        if (!lower.includes(qualifier))
-            return false;
-    }
-    const statementCondition = conditionOf(statement);
-    if (requirement.condition && statementCondition) {
-        if (!sharesContentWord(requirement.condition, statementCondition))
-            return false;
+    // 選言（"1xx … or 204"）の名前は、いずれか 1 つが主張にあればよい。
+    if (!statementNamesIdentifiers(lower, scope))
+        return false;
+    if (!options.ignoreQualifiers) {
+        for (const qualifier of qualifiersOf(scope)) {
+            if (!lower.includes(qualifier))
+                return false;
+        }
     }
+    if (conditionsDiverge(requirement.condition, statement))
+        return false;
     return true;
 }
 /**
@@ -845,8 +1084,28 @@ const VERB_SYNONYMS = [
  * 否定を含む主張は、禁止に従っていることを述べている見込みが高いので、
  * 「禁止された行為をしている」検査の対象から外す。
  */
-function hasNegation(text) {
-    return /\b(?:not|never|cannot|without|refrain|neither|nor)\b|n't\b/.test(text.toLowerCase());
+/** 動詞に否定が付いているか。直前の 2 語と、直後の 2 語を見る。 */
+const NEGATION_WORD = /^(?:not|never|cannot|without|refrain|neither|nor|no)$|n't$/;
+/**
+ * 動詞の後ろに置かれる否定。"sends **no** content" / "sends **nothing**" /
+ * "masks **none** of the frames"。
+ *
+ * 動詞の前しか見ていなかったため、RFC 9110 §9.3.8 の "A client MUST NOT send
+ * content in a TRACE request." に対する "The client sends no content in a TRACE
+ * request." が「禁じられた行為をしている」になり、`isValid: false` を返していた。
+ * 準拠を述べている文である。
+ */
+const NEGATION_AFTER_VERB = /^(?:no|nothing|none|neither)$/;
+function isNegatedVerb(words, verbIndex) {
+    for (let offset = 1; offset <= 2; offset++) {
+        const before = words[verbIndex - offset];
+        if (before && NEGATION_WORD.test(before))
+            return true;
+        const after = words[verbIndex + offset];
+        if (after && NEGATION_AFTER_VERB.test(after))
+            return true;
+    }
+    return false;
 }
 /**
  * 禁じられた行為の主動詞を取り出す。
@@ -893,21 +1152,37 @@ function statementHasTerm(statement, term) {
  *
  * 主語の一致は呼び出し側（`detectConflicts`）が先に確かめている。
  */
-export function findProhibitionViolation(statement, forbiddenAction, subject) {
+export function findProhibitionViolation(statement, forbiddenAction, subject, requirementSubject) {
     const statementLower = statement.toLowerCase();
-    if (hasNegation(statementLower))
-        return null;
     const verb = headVerbOf(forbiddenAction);
     if (!verb)
         return null;
     // 主張の主動詞がその行為であること。文中のどこかに動詞が現れるだけでは、
     // 別の行為を述べている見込みがある。
-    if (!statementPerformsVerb(statementLower, subject, verb))
+    const found = findStatementVerb(statementLower, subject, verb);
+    if (!found)
         return null;
-    const matchedVerb = statementMainVerb(statementLower, subject) ?? verb;
+    // 否定は**動詞に付いたもの**だけを見る。文全体を見ると、要件の条件を
+    // そのまま書き写した主張が落ちる。
+    //
+    //   "An origin server without a clock generates a Date header field."
+    //
+    // この "without" は行為を否定していない。要件
+    // "An origin server without a clock MUST NOT generate a Date header field."
+    // の条件を書き写しただけで、これは違反そのものである。
+    if (isNegatedVerb(found.words, found.index))
+        return null;
+    const matchedVerb = found.matched;
     const sharedTerms = [];
     const seen = new Set();
-    for (const word of forbiddenAction.toLowerCase().split(/[^a-z0-9]+/)) {
+    // 行為が短い禁止は、動詞を除くと共通語が 3 個に届かず落ちていた。
+    //
+    //   "clients MUST NOT show it to end users."（RFC 6455 §5.5.1）
+    //   → 行為 "show it to end users" の内容語は "end" と "users" の 2 個
+    //
+    // 何を誰に禁じているかは要件の主語にもあるので、そちらも語の元にする。
+    const pool = `${forbiddenAction} ${requirementSubject ?? ''}`;
+    for (const word of pool.toLowerCase().split(/[^a-z0-9]+/)) {
         if (!word || word === verb)
             continue;
         if (word.length < MATCHING_LIMITS.MIN_KEYWORD_LENGTH)
@@ -924,10 +1199,201 @@ export function findProhibitionViolation(statement, forbiddenAction, subject) {
         return null;
     return { verb: matchedVerb, sharedTerms };
 }
+/**
+ * 判断を取り下げるかを決めるための「同じ行為か」。
+ *
+ * `describesSameAct` の 3 条件のうち、**限定語の一致だけは求めない**。
+ * 矛盾を主張するときは、要件に `unless` `except` `without` があって主張に
+ * 無ければ落とすのが正しい。ここは逆で、限定語に触れていない主張こそ
+ * 判断できない。RFC 6455 §5.4 の
+ * "The fragments of one message MUST NOT be interleaved … unless an extension
+ * has been negotiated …" に対し、`unless` を求めると当の要件が落ち、
+ * 順位の下の無関係な要件（"MUST NOT be fragmented"）を名指ししていた。
+ *
+ * 固有の名前（`identifiersOf`）と条件節の重なりは `describesSameAct` と同じく求める。
+ */
+function sameActForWithdrawal(statementLower, requirement, action) {
+    const scope = `${requirement.text} ${action}`;
+    if (!statementNamesIdentifiers(statementLower, scope))
+        return false;
+    if (conditionsDiverge(requirement.condition, statementLower))
+        return false;
+    return true;
+}
+/**
+ * 限定語の言い換えだけで矛盾を落とした一致を返す。無ければ `null`。
+ *
+ * `describesSameAct` は、要件に限定語（`without` `except` `unless` など）が
+ * あれば主張にも同じ語を求める。要件を互いに区別しているのがその語だからである
+ * （RFC 9110 §6.6.1 は "An origin server **with** a clock MUST generate a Date
+ * header field" と "An origin server **without** a clock MUST NOT generate a
+ * Date header field" を並べて書く）。
+ *
+ * 言い換えられると当たらない。"The origin server generates a Date header field
+ * even though it **has no clock**." は `without` を含まないので、
+ * `MUST NOT` に反しているのに矛盾が出ず、`isValid` が `true` になっていた。
+ * **違反している主張に「矛盾なし」と答えることになる。**
+ *
+ * 限定語を無視すれば矛盾が出るときだけ拾い、`isValid` を `null` にする。
+ * 「違反している」とは言わない — 言い換えなのか別の話なのかは決められない。
+ */
+export function findQualifierOnlyViolation(statement, matches) {
+    const lower = statement.toLowerCase();
+    for (const match of matches) {
+        const req = match.requirement;
+        if (!NEGATIVE_LEVELS.has(req.level))
+            continue;
+        // `without X` だけを見る。ほかの限定語（`unless` `except` `arbitrarily`）は
+        // 言い換えの形が定まらず、言い換えなのか別の話なのかを見分けられない。
+        const scope = `${req.text} ${requiredActionOf(req) ?? ''}`;
+        const withoutWhat = /\bwithout\s+(?:a|an|the)?\s*([a-z][\w-]*)/i.exec(scope);
+        if (!withoutWhat)
+            continue;
+        if (lower.includes('without'))
+            continue;
+        // 主張が同じ否定を述べていること。"with a clock"（逆の枝）は取り下げない。
+        const noun = withoutWhat[1].toLowerCase();
+        const saysTheSame = new RegExp(`\\b(?:no|not\\s+have|does\\s+not\\s+have|lacks?|lacking|missing)\\b[^.]{0,30}\\b${noun}s?\\b`, 'i').test(lower);
+        if (!saysTheSame)
+            continue;
+        if (detectConflicts(statement, [req]).length > 0)
+            continue;
+        if (detectConflicts(statement, [req], { ignoreQualifiers: true }).length === 0)
+            continue;
+        return { requirement: req, qualifier: 'without' };
+    }
+    return null;
+}
+/** 受動態の行為。`MUST NOT` の直後が "be 過去分詞" になっている。 */
+const PASSIVE_ACTION_PATTERN = /^be\s+[a-z]+(?:ed|n|t)\b/;
+/**
+ * 受動態で書かれた禁止のうち、違反しているかを機械で決められないものを返す。
+ *
+ * 矛盾検出は、文の主語が禁じられた動詞を実行しているかを見る
+ * （`statementPerformsVerb`）。要件が "A reference identity of type CN-ID
+ * MUST NOT be used by clients." のように受動態で書かれていると、禁じられた
+ * 行為に実行者がいない。文が "The client uses the cn-id identifier type."
+ * でも矛盾は出ず、`conflicts` は空になる。
+ *
+ * 空の `conflicts` をそのまま `isValid: true` にすると、違反している文に
+ * 「矛盾なし」と返す。ここで拾って `null`（判断できない）にする。
+ *
+ * 実測（RFC 9110/9111/9112/9113/9114/6455/8446/5280 の `MUST NOT` から機械で
+ * 作った受動態の違反文 40 件）: `isValid` は `true` が 13 件、`null` が 27 件、
+ * `false` は 0 件だった。この 13 件が誤解を招く形である。
+ */
+export function findUndecidablePassiveProhibition(statement, matches) {
+    const lower = statement.toLowerCase();
+    // 文自身が否定なら、準拠していると述べている。判断を取り下げる必要はない。
+    if (/\b(?:not|never|no|cannot)\b/.test(lower))
+        return null;
+    for (const match of matches) {
+        const req = match.requirement;
+        if (!NEGATIVE_LEVELS.has(req.level))
+            continue;
+        const action = (requiredActionOf(req) ?? '')
+            .replace(/must not|shall not|should not|not recommended/gi, '')
+            .trim()
+            .toLowerCase();
+        if (!PASSIVE_ACTION_PATTERN.test(action))
+            continue;
+        if (!sameActForWithdrawal(lower, req, action))
+            continue;
+        return req;
+    }
+    return null;
+}
+/**
+ * 主張と要件が、同じ動詞について述べているか。
+ *
+ * レベルの対（`MAY` と `MUST NOT` など）だけで矛盾を出していた。重なりの条件は
+ * 文全体のキーワードを数えるので、主語と共通の名詞で埋まる。**動詞が違っても
+ * 当たる。**
+ *
+ * RFC 7159 §8.1 の
+ * `implementations that parse JSON texts MAY **ignore** the presence of a byte
+ * order mark` を主張として渡すと、`Implementations MUST NOT **add** a byte
+ * order mark to the beginning of a JSON text.` と `byte order mark` で重なり、
+ * 「MAY と MUST NOT」で矛盾になっていた。無視することと足すことは別の行為である。
+ * **RFC 自身の文をそのまま渡して「矛盾あり」と答えることになる。**
+ *
+ * 実測（RFC 67 本から要件文 300 件をそのまま主張として渡す）:
+ * `isValid: false` が 34 件 → 10 件。作った違反文 157 件の検出は 59 → 58 件。
+ *
+ * 目的語まで一致を求める案（`sharesContentWord` と `describesSameAct` を足す）も
+ * 測った。誤検出は 10 → 7 件に減るが、検出が 58 → 53 件に落ちる。3 件のために
+ * 5 件を落とすので採らない。
+ */
+function sameActVerb(statement, requirement) {
+    const statementAct = actAfterKeyword(statement);
+    const requirementAct = requiredActionOf(requirement) ?? actAfterKeyword(requirement.text);
+    if (!statementAct || !requirementAct)
+        return true;
+    const a = actVerb(statementAct);
+    const b = actVerb(requirementAct);
+    if (!a || !b || a === b)
+        return true;
+    return VERB_SYNONYMS.some((group) => {
+        const stems = group.map(stemVerb);
+        return stems.includes(a) && stems.includes(b);
+    });
+}
+/** BCP 14 のキーワードより後ろ。行為にあたる部分。 */
+function actAfterKeyword(text) {
+    const match = /\b(?:MUST NOT|SHALL NOT|SHOULD NOT|NOT RECOMMENDED|MUST|SHALL|SHOULD|MAY|REQUIRED|RECOMMENDED|OPTIONAL)\b/.exec(text);
+    if (!match)
+        return null;
+    const act = text.slice(match.index + match[0].length).trim();
+    return act.length > 0 ? act : null;
+}
+/**
+ * 行為の主動詞。副詞・助動詞・指示語を飛ばして最初の語を採る。
+ *
+ * 受動態（`be set as a status code`）では `be` を飛ばして `set` を採る。
+ */
+const ACT_LEAD_WORDS = new Set([
+    'be',
+    'been',
+    'being',
+    'not',
+    'only',
+    'also',
+    'always',
+    'never',
+    'immediately',
+    'then',
+    'either',
+    'both',
+    'still',
+    'otherwise',
+    'therefore',
+    'thus',
+    'further',
+    'again',
+    'that',
+    'this',
+    'it',
+    'they',
+    'to',
+]);
+/** 語尾を落として比べる。`sending` と `sends` と `send` を同じにする。 */
+function stemVerb(word) {
+    return word.replace(/(?:ing|ed|es|s)$/, '');
+}
+function actVerb(act) {
+    for (const raw of act.toLowerCase().split(/[^a-z]+/)) {
+        if (!raw)
+            continue;
+        if (ACT_LEAD_WORDS.has(raw))
+            continue;
+        return stemVerb(raw);
+    }
+    return null;
+}
 /**
  * Detect conflicts between statement and requirements
  */
-export function detectConflicts(statement, requirements) {
+export function detectConflicts(statement, requirements, options = {}) {
     const conflicts = [];
     const statementLevel = extractRequirementLevel(statement);
     const statementSubject = extractSubject(statement);
@@ -966,8 +1432,9 @@ export function detectConflicts(statement, requirements) {
                     if (requirementTextHasKeyword(reqText, keyword))
                         overlap++;
                 }
-                if (overlap >= MATCHING_LIMITS.MIN_OVERLAP_FOR_CONFLICT ||
-                    statementKeywords.size <= MATCHING_LIMITS.SHORT_STATEMENT_THRESHOLD) {
+                const enough = overlap >= MATCHING_LIMITS.MIN_OVERLAP_FOR_CONFLICT ||
+                    statementKeywords.size <= MATCHING_LIMITS.SHORT_STATEMENT_THRESHOLD;
+                if (enough && sameActVerb(statement, req)) {
                     conflicts.push({
                         requirement: req,
                         reason: `Statement uses "${statementLevel}" but requirement uses "${req.level}"`,
@@ -986,7 +1453,7 @@ export function detectConflicts(statement, requirements) {
         const reqLevel = req.level;
         // For MUST requirements: check if statement contradicts the required action
         if (reqAction && (reqLevel === 'MUST' || reqLevel === 'SHALL' || reqLevel === 'REQUIRED')) {
-            const contradiction = describesSameAct(statementLower, req, reqAction)
+            const contradiction = describesSameAct(statementLower, req, reqAction, options)
                 ? findActionContradiction(statementLower, reqAction, statementKeywords)
                 : null;
             if (contradiction) {
@@ -1013,13 +1480,17 @@ export function detectConflicts(statement, requirements) {
                 // 禁じられているのはこの動詞であること（付随的な言及ではない）
                 if (!forbiddenHeadVerb || !forbiddenHeadVerb.startsWith(pair.positive))
                     continue;
-                const statementDoesPositive = hasPositiveAction(statementLower, pair) &&
-                    statementPerformsVerb(statementLower, statementSubject, pair.positive);
+                // 動詞の後ろの否定（"sends no content"）は `hasPositiveAction` の
+                // 否定形一覧（"not send"）に無い。動詞の位置で否定を見る。
+                const performed = hasPositiveAction(statementLower, pair)
+                    ? findStatementVerb(statementLower, statementSubject, pair.positive)
+                    : null;
+                const statementDoesPositive = performed !== null && !isNegatedVerb(performed.words, performed.index);
                 // 一般的な動詞では、動詞が一致しただけの当たりを落とす（例: "MUST NOT send
                 // back a |Sec-WebSocket-Protocol| header field" と「マスクなしのフレームを送る」）
                 if (statementDoesPositive &&
                     sharesActionContext(statementKeywords, forbiddenAction, pair) &&
-                    describesSameAct(statementLower, req, forbiddenAction)) {
+                    describesSameAct(statementLower, req, forbiddenAction, options)) {
                     conflicts.push({
                         requirement: req,
                         reason: `Statement does what "${reqLevel}" forbids: "${forbiddenAction}"`,
@@ -1034,8 +1505,8 @@ export function detectConflicts(statement, requirements) {
             // `NEGATION_PAIRS` は肯定形と否定形の対しか見ないため、ここで漏れていた。
             if (!pairConflict &&
                 forbiddenAction &&
-                describesSameAct(statementLower, req, forbiddenAction)) {
-                const violation = findProhibitionViolation(statementLower, forbiddenAction, statementSubject);
+                describesSameAct(statementLower, req, forbiddenAction, options)) {
+                const violation = findProhibitionViolation(statementLower, forbiddenAction, statementSubject, req.subject);
                 if (violation) {
                     conflicts.push({
                         requirement: req,
@@ -1065,7 +1536,12 @@ export function matchStatement(statement, requirements, options = {}) {
         .sort((a, b) => b.score - a.score)
         .slice(0, maxResults);
     // Detect conflicts
-    const conflicts = detectConflicts(statement, requirements);
+    // 突き合わせる相手は、一致した要件だけにする。RFC 全体を相手にしていたため、
+    // `matchingRequirements` に出てこない要件が `conflicts` に入っていた。
+    // 利用者は、示された矛盾の相手を一致の一覧から探せない。
+    // 実測（RFC 67 本から要件文 300 件をそのまま主張として渡す）:
+    // `isValid: false` が 55 件 → 34 件。作った違反文 157 件の検出は 59 件のまま。
+    const conflicts = detectConflicts(statement, matches.map((match) => match.requirement));
     return {
         matches,
         conflicts,