kotonoha 0.2.0 → 0.4.0

package/skills/consulting-analyst/references/handoff-contract.md

@@ -0,0 +1,90 @@
+# Analysis handoff contract
+
+The handoff transfers reasoning and evidence without transferring ownership
+of final prose or presentation design.
+
+## Required fields
+
+`synthesis-handoff.md` must include:
+
+- Decision-maker and decision question
+- Intended outcome and deadline
+- Recommended answer and confidence
+- Supporting issue, hypothesis, finding, source, and evidence IDs
+- Assumptions and estimates
+- Counterevidence and alternative interpretations
+- Options, criteria, weights, and sensitivity when applicable
+- Current, target, gap, intervention, and action IDs when applicable
+- Risks, unresolved questions, and evidence-gathering actions
+- Required destination and target doctype or presentation purpose
+- Frozen items the receiving skill must preserve
+
+## ID semantics and traceability
+
+- `Q` identifies an issue; `HYP` a hypothesis; `FND` a synthesized finding.
+- `SRC` identifies a source record; `EVD` an analysis evidence record linked
+  to its source. Never rename a source record to `EVD` or overwrite analysis
+  evidence with a source citation.
+- `GAP` identifies a current-to-target gap; `INT` an intervention defined in
+  Current–Target–Gap; `CRT` an option criterion; `ACT` a recommended action.
+- Findings preserve their Q / HYP and EVD links and reference relevant
+  GAP / INT / CRT IDs. Actions link to supporting FND IDs, related Q / HYP
+  IDs, and applicable GAP / INT / CRT IDs. Transition risks reference the
+  affected GAP / INT IDs.
+- Preserve this chain in destination documents. Blueprint traceability keeps
+  relevant Q / HYP / FND / EVD and GAP / INT / CRT alongside its driver,
+  principle, capability, workstream, and KPI IDs. White Paper claims link
+  relevant HYP / FND / EVD IDs, while source records remain SRC IDs.
+- Use only defined, relevant IDs. Mark inapplicable links `N/A` with a reason;
+  do not require consulting IDs when no consulting handoff exists.
+
+If `Analysis status` is `Incomplete`, the receiving skill must either return
+the decision-critical gaps for further analysis or visibly preserve the
+incomplete status, evidence gaps, confidence, and conditional nature of every
+affected conclusion. It must not convert an incomplete handoff into an
+unqualified recommendation.
+
+## Handoff to tech-writer
+
+`tech-writer` owns document structure, doctype completeness, Markdown, and
+reader-facing prose. It may:
+
+- Reorder analysis to fit the doctype
+- Rename headings
+- Condense repeated evidence
+- Add doctype-required metadata and controls
+
+It must not:
+
+- Change evidence IDs or source meaning
+- Present assumptions as facts
+- Remove counterevidence that affects the conclusion
+- Change criteria, weights, scores, confidence, or recommendation without
+  returning the change to analysis
+
+## Handoff to presentation-planner
+
+`presentation-planner` owns audience reasoning, scenario, slide order, and
+visual handoff. It may:
+
+- Select the shortest evidence set that supports the audience decision
+- Split findings across slides
+- Adapt the order for the audience's prior knowledge
+
+It must preserve:
+
+- The decision question and requested action
+- Evidence status and confidence
+- Material caveats and counterevidence
+- Option-comparison logic
+- Conditions that would change the recommendation
+
+## Return conditions
+
+Return the handoff to `consulting-analyst` when:
+
+- A new conclusion is required
+- New evidence changes confidence or ranking
+- The audience asks a different decision question
+- Criteria or target-state dimensions change
+- Communication edits expose a contradiction in the analysis

package/skills/japanese-prose/NOTICE.md

@@ -1,4 +1,4 @@
-# GiNZA dependency notice
+# Diagnostic dependency notices
 
 This skill is an original kotonoha implementation and does not include source
 code from `coji/natural-japanese`.
@@ -15,3 +15,9 @@ datasets.
 The implementation targets GiNZA 5.2.x and uses token surface forms, lemmas,
 universal part-of-speech tags, dependency relationships, sentence boundaries,
 and named-entity labels.
+
+The edit-invariant gate uses
+[markdown-it-py](https://github.com/executablebooks/markdown-it-py), distributed
+under the MIT License, to parse Markdown without treating short fences
+inside longer fenced code blocks as prose. Its dependencies are resolved by
+`uv` when `scripts/invariants.py` is run.

package/skills/japanese-prose/SKILL.md

@@ -6,10 +6,10 @@ description: >-
   reviewing, or scoring Japanese prose; when the user asks for more natural,
   readable, concise, or less AI-like Japanese; or when tech-writer delegates
   its sentence-level quality pass. Owns wording, sentence rhythm, reading
-  load, terminology review, and formulaic-expression detection. Does not own
-  technical-document structure or presentation storylines.
+  load, typo and grammar review, terminology, and edit-invariant checks.
+  Does not own technical-document structure or presentation storylines.
 license: MIT
-argument-hint: "[write|review|score] [quick|full] <target file or request>"
+argument-hint: "[write|proofread|review|score] [quick|full] <target file or request>"
 ---
 
 # japanese-prose
@@ -39,6 +39,8 @@ acceptance criteria, approval states, or normative force.
 - `write`: write or rewrite Japanese prose. Use `quick` unless the document
   is external-facing, high-risk, or longer than roughly 10,000 Japanese
   characters.
+- `proofread`: correct demonstrable typos and grammatical errors with minimal
+  edits. Do not perform optional stylistic rewrites or chase a higher score.
 - `review`: report problems and proposed corrections without editing.
 - `score`: run diagnostics and report the 0–100 score without rewriting.
 - `quick`: run prose lint once, review findings in context, edit, and rerun
@@ -50,33 +52,57 @@ acceptance criteria, approval states, or normative force.
 ## Workflow
 
 1. Read the target, audience, intended outcome, and calling skill's frozen
-   invariants.
+   invariants. Before editing, save an immutable copy of the entire original
+   file as `<workdir>/prose-original.md`. Keep this separate from diagnostic
+   baselines, which may change between rounds.
 2. Read `references/writing-guidelines.md` before generating or rewriting
-   prose.
+   prose. Resolve `<japanese-prose-dir>` to the directory containing this
+   loaded skill; do not assume the shell is running in that directory.
 3. Run the GiNZA prose diagnostic:
 
    ```bash
-   uv run scripts/lint.py <target-file> --genre tech --json > <workdir>/prose-baseline.json
+   uv run <japanese-prose-dir>/scripts/lint.py <target-file> --genre tech --json > <workdir>/prose-baseline.json
    ```
 
 4. For `full` mode, also run:
 
    ```bash
-   uv run scripts/lint.py <target-file> --genre tech --reading-load --json
-   uv run scripts/outline.py <target-file>
-   uv run scripts/terms.py <target-file> --json
+   uv run <japanese-prose-dir>/scripts/lint.py <target-file> --genre tech --reading-load --json
+   uv run <japanese-prose-dir>/scripts/outline.py <target-file>
+   uv run <japanese-prose-dir>/scripts/terms.py <target-file> --json
    ```
 
-5. Classify each finding as `fix` or `keep`. A detector identifies a review
-   target; it does not authorize blind replacement.
-6. Apply only fixes that improve the intended reader's understanding while
-   preserving the frozen invariants.
+5. Read the entire prose for typos, particle errors, subject/predicate
+   mismatches, and incorrect inflections even when lint reports no findings.
+   Classify each finding as `fix` or `keep`. A detector identifies a review
+   target; it does not authorize blind replacement. Adjacent duplicate
+   particles/words, Japanese bracket mismatches, and within-paragraph style
+   mixing are proofreading targets, not proof of an error.
+6. Correct demonstrable errors first. In `write` mode, then consider optional
+   wording changes that serve the reader's stated goal. Keep these separate
+   from necessary corrections. Preserve acceptable wording when a change
+   merely substitutes a synonym or removes a legitimate qualification.
+   Never infer a factual or proper-name correction from plausibility alone.
 7. Rerun the prose diagnostic with
    `--baseline <workdir>/prose-baseline.json` to classify new, persisting,
    and resolved findings. Replace the baseline only after recording the
    decisions for the current round.
-8. Stop when every finding has a decision, no new actionable finding appears,
-   and the document passes the checks in `references/review-workflow.md`.
+8. Run the edit-invariant gate against the immutable original:
+
+   ```bash
+   uv run <japanese-prose-dir>/scripts/invariants.py <workdir>/prose-original.md <target-file> --protect <proper-name-or-domain-term> --json
+   ```
+
+   Repeat `--protect` for each frozen proper name or domain term; omit it only
+   when there are none. Exit 2 blocks changed protected content. Any edit
+   requires a contextual semantic review, even if all mechanical checks
+   pass: exit 3 means that review is pending or rejected, not completion.
+   Follow `references/review-workflow.md` to record the hash-bound review,
+   then rerun with `--review <workdir>/semantic-review.json --json`.
+   Recheck after every subsequent edit; a stale review cannot approve it.
+9. Stop only when every finding has a decision, no new actionable finding
+   appears, and the invariant gate returns `passed`. If the gate cannot run,
+   report the failure rather than declaring completion.
 
 Allow at most three edit-and-diagnose rounds per invocation. If actionable
 findings or invariant violations remain, report that the optimization did not
@@ -87,7 +113,10 @@ converge and list the unresolved items.
 When strong emphasis touches surrounding prose, put half-width spaces outside
 the delimiters: `これは **重要** です`, not `これは**重要**です`. Spaces are
 unnecessary at line boundaries or next to punctuation, and must not be placed
-inside `**`.
+inside `**`. Use ASCII spaces (`U+0020`), never full-width spaces (`U+3000`),
+tabs, or non-breaking spaces, immediately before and after emphasis embedded
+in prose. Write `これは **「重要」** と説明する`, not
+`これは　**「重要」**　と説明する`.
 
 ## Diagnostic interpretation
 
@@ -105,4 +134,7 @@ Report:
 - findings fixed and findings deliberately kept
 - any skipped diagnostic and its reason
 - invariant verification result
+- necessary corrections versus optional wording changes
+- semantic review status and any remaining uncertainty; mechanical equality
+  is not a guarantee of preserved meaning
 - `completed` or `did not converge`

package/skills/japanese-prose/references/review-workflow.md

@@ -40,6 +40,61 @@ Read only headings and paragraph openings. The argument must still be
 predictable. Then read the finished prose continuously and verify that local
 rewrites did not damage transitions or create repeated explanations.
 
+## Require a semantic review of edits
+
+Run `scripts/invariants.py` on the immutable pre-edit file and the edited
+file. It protects numbers and known quantity units in occurrence order,
+uppercase identifiers, URL/link destinations, frontmatter, heading levels,
+inline code, fenced/indented code, Markdown tables, HTML, and caller-supplied
+`--protect` terms. The Markdown parser recognizes nested and long fences.
+The check is conservative: it may block a legitimate reorder or protected
+content correction. Such changes need separate authorization, not a
+reviewer override of a failed invariant.
+
+Mechanical equality cannot establish equivalent meaning. For every changed
+passage, compare the original and edited text, including nearby context:
+
+- `actors`: who performs or receives each action is unchanged
+- `negation`: polarity and the scope of negation are unchanged
+- `conditions`: prerequisites, exceptions, acceptance criteria, and approval states are unchanged
+- `modality`: obligations, recommendations, permissions, and uncertainty are unchanged
+- `scope`: limitations such as 「だけ」「すべて」「少なくとも」 are unchanged
+- `causality`: causal and temporal relationships are unchanged
+- `quantity_bindings`: each quantity still refers to the same object or action
+- `terminology`: proper names and domain concepts are unchanged
+- `structure`: section identity, order, quoted meaning, and traceability are unchanged
+
+Record the review as JSON. Copy `before_sha256` and `after_sha256` from the
+gate output, identify the actual reviewer, and set a check to `true` only
+after inspecting it. Do not infer approval from a score, an unchanged token
+count, or the absence of warnings. A review can be performed by the agent or
+a human, but an agent review is not a human approval or a semantic proof.
+
+```json
+{
+  "before_sha256": "<hash from the gate>",
+  "after_sha256": "<hash from the gate>",
+  "reviewer": "<actual reviewer identifier>",
+  "checks": {
+    "actors": false,
+    "negation": false,
+    "conditions": false,
+    "modality": false,
+    "scope": false,
+    "causality": false,
+    "quantity_bindings": false,
+    "terminology": false,
+    "structure": false
+  }
+}
+```
+
+Rerun the gate with `--review <review-file>`. Exit codes are 0 for `passed`,
+1 for input/runtime errors, 2 for protected-content violations, and 3 for
+missing, stale, incomplete, or rejected semantic reviews. Subsequent edits
+invalidate the review. If equivalence is uncertain, keep the original
+wording or report the unresolved concern.
+
 ## Convergence
 
 The review is complete when:
@@ -47,4 +102,6 @@ The review is complete when:
 - every finding has a `fix` or `keep` decision
 - rerunning diagnostics produces no new actionable finding
 - frozen invariants match the pre-edit document
+- `scripts/invariants.py` returns `passed` with a current semantic review
+  for changed text
 - the reader can reach the requested outcome without an unstated inference

package/skills/japanese-prose/references/scoring.md

@@ -22,3 +22,9 @@ A high score does not prove that facts are correct, the argument is complete,
 or the prose is natural. A low score does not require every finding to be
 changed. Always report the finding categories and contextual decisions beside
 the score.
+
+Proofreading findings and style/readability findings contribute to the same
+triage score, but they are not interchangeable measures of quality. Report
+the categories separately. Do not use this score as typo-detection recall,
+correction accuracy, semantic fidelity, or evidence that an LLM-assisted
+rewrite is better. A correctly repaired typo may leave the score unchanged.

package/skills/japanese-prose/scripts/core.py

@@ -76,10 +76,14 @@ def iter_content_lines(text: str) -> Iterable[tuple[int, str]]:
 
         fence = FENCE_RE.match(raw)
         if fence:
-            marker = fence.group(1)[0]
+            marker = fence.group(1)
             if not fence_marker:
                 fence_marker = marker
-            elif marker == fence_marker:
+            elif (
+                marker[0] == fence_marker[0]
+                and len(marker) >= len(fence_marker)
+                and not raw[fence.end():].strip()
+            ):
                 fence_marker = ""
             yield index, ""
             continue

package/skills/japanese-prose/scripts/invariants.py

@@ -0,0 +1,182 @@
+#!/usr/bin/env python3
+# /// script
+# requires-python = ">=3.10"
+# dependencies = ["markdown-it-py>=3,<5"]
+# ///
+"""Check protected content and require a hash-bound semantic review of edits."""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+from pathlib import Path
+import re
+import sys
+
+from markdown_it import MarkdownIt
+
+
+SEMANTIC_CHECKS = (
+    "actors", "negation", "conditions", "modality", "scope", "causality",
+    "quantity_bindings", "terminology", "structure",
+)
+NUMBER_RE = re.compile(r"\d+(?:[.,]\d+)*")
+IDENTIFIER_RE = re.compile(r"(?<![A-Za-z0-9_])[A-Z][A-Z0-9]*(?:[-_][A-Z0-9]+)+(?![A-Za-z0-9_])")
+QUANTITY_RE = re.compile(
+    r"(\d+(?:[.,]\d+)*)\s*"
+    r"(ミリ秒|時間|年間|か月|ヶ月|秒|分|日|週|月|年|回|件|台|人|個|円|倍|"
+    r"[A-Za-zµμ]+(?:/[A-Za-zµμ]+)?|%|％|℃)(?![A-Za-z])"
+)
+BARE_URL_RE = re.compile(r"https?://[^\s<>`\"()\[\]、。！？「」『』（）]+")
+
+
+def fingerprint(value: object) -> str:
+    return hashlib.sha256(
+        json.dumps(value, ensure_ascii=False, sort_keys=True).encode("utf-8")
+    ).hexdigest()
+
+
+def snapshot(text: str, protected_terms: list[str]) -> dict:
+    lines = text.splitlines(keepends=True)
+    frontmatter = ""
+    body = text
+    if lines and lines[0].strip() == "---":
+        end = next(
+            (index for index in range(1, len(lines)) if lines[index].strip() in {"---", "..."}),
+            None,
+        )
+        if end is not None:
+            frontmatter = "".join(lines[:end + 1])
+            body = "".join(lines[end + 1:])
+    body_lines = body.splitlines(keepends=True)
+    tokens = MarkdownIt("commonmark").enable("table").parse(body)
+    blocks = []
+    headings = []
+    code = []
+    links = []
+    html = []
+    for token in tokens:
+        if token.type in {"fence", "code_block", "table_open", "html_block"}:
+            if token.map is None:
+                raise ValueError(f"Missing source map for {token.type}")
+            start, end = token.map
+            blocks.append((token.type, "".join(body_lines[start:end])))
+        if token.type == "heading_open":
+            headings.append(token.tag)
+        for child in token.children or []:
+            if child.type == "code_inline":
+                code.append(child.content)
+            elif child.type == "link_open":
+                links.append(child.attrGet("href"))
+            elif child.type == "image":
+                links.append(child.attrGet("src"))
+            elif child.type == "html_inline":
+                html.append(child.content)
+    return {
+        "frontmatter": frontmatter,
+        "protected_blocks": blocks,
+        "heading_levels": headings,
+        "inline_code": code,
+        "link_destinations": links,
+        "html_tags": html,
+        "numbers_in_order": NUMBER_RE.findall(text),
+        "quantities_in_order": QUANTITY_RE.findall(text),
+        "identifiers_in_order": IDENTIFIER_RE.findall(text),
+        "bare_urls_in_order": BARE_URL_RE.findall(text),
+        "protected_terms": {term: text.count(term) for term in protected_terms},
+    }
+
+
+def check(
+    before: Path,
+    after: Path,
+    protected_terms: list[str] | None = None,
+    review_path: Path | None = None,
+) -> dict:
+    terms = protected_terms or []
+    if any(not term.strip() for term in terms):
+        raise ValueError("Protected terms must not be empty")
+    original = before.read_bytes()
+    edited = after.read_bytes()
+    before_hash = hashlib.sha256(original).hexdigest()
+    after_hash = hashlib.sha256(edited).hexdigest()
+    initial = snapshot(original.decode("utf-8"), terms)
+    final = snapshot(edited.decode("utf-8"), terms)
+    violations = [
+        {
+            "category": name,
+            "message": f"Protected content changed: {name}",
+            "before_fingerprint": fingerprint(initial[name]),
+            "after_fingerprint": fingerprint(final[name]),
+        }
+        for name in initial if initial[name] != final[name]
+    ]
+    review_errors = []
+    review_required = original != edited
+    reviewer = None
+    if review_path is not None:
+        review = json.loads(review_path.read_text(encoding="utf-8"))
+        if not isinstance(review, dict):
+            raise ValueError("Semantic review must be a JSON object")
+        reviewer = review.get("reviewer")
+        if not isinstance(reviewer, str) or not reviewer.strip():
+            review_errors.append("reviewer must be a non-empty identifier")
+        if review.get("before_sha256") != before_hash or review.get("after_sha256") != after_hash:
+            review_errors.append("review hashes do not match this exact before/after pair")
+        checks = review.get("checks")
+        if not isinstance(checks, dict):
+            review_errors.append("checks must be an object")
+        else:
+            review_errors.extend(
+                f"{name} has not been affirmed" for name in SEMANTIC_CHECKS
+                if checks.get(name) is not True
+            )
+    elif review_required:
+        review_errors.append("changed text requires a hash-bound semantic review")
+    status = "blocked" if violations else "review_required" if review_errors else "passed"
+    return {
+        "before": str(before),
+        "after": str(after),
+        "before_sha256": before_hash,
+        "after_sha256": after_hash,
+        "status": status,
+        "mechanical_violations": violations,
+        "semantic_review_required": review_required,
+        "semantic_checks": list(SEMANTIC_CHECKS),
+        "semantic_review_errors": review_errors,
+        "reviewer": reviewer,
+        "limitations": [
+            "Mechanical equality does not prove semantic equivalence.",
+            "Proper names and domain terms require caller-supplied --protect values and contextual review.",
+            "Semantic checks are reviewer attestations, not automated entailment judgments.",
+        ],
+    }
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("before")
+    parser.add_argument("after")
+    parser.add_argument("--protect", action="append", default=[])
+    parser.add_argument("--review", type=Path)
+    parser.add_argument("--json", action="store_true")
+    args = parser.parse_args()
+    try:
+        result = check(Path(args.before), Path(args.after), args.protect, args.review)
+    except (OSError, ValueError, UnicodeError) as error:
+        print(f"error: {error}", file=sys.stderr)
+        return 1
+    if args.json:
+        print(json.dumps(result, ensure_ascii=False, indent=2))
+    else:
+        print(f"{result['status']}: {args.before} -> {args.after}")
+        for violation in result["mechanical_violations"]:
+            print(f"  {violation['message']}")
+        for error in result["semantic_review_errors"]:
+            print(f"  Semantic review: {error}")
+    return {"passed": 0, "blocked": 2, "review_required": 3}[result["status"]]
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/skills/japanese-prose/scripts/lint.py

@@ -75,10 +75,12 @@ DOUBLE_NEGATIVE_RULES = (
     re.compile(r"ないわけではない"),
     re.compile(r"ないことはない"),
     re.compile(r"なくはない"),
-    re.compile(r"なくてはならない"),
-    re.compile(r"ざるを得ない"),
 )
 
+BRACKET_PAIRS = dict(zip("（［｛「『【", "）］｝」』】"))
+POLITE_END_RE = re.compile(r"(?:です|ます|でした|ました|ません(?:でした)?|でしょう|ましょう|ください|下さい)$")
+PLAIN_END_RE = re.compile(r"(?:である|だった|だ|る|た|ない)$")
+
 GENRE_LIMITS = {
     "general": {"length": 90, "critical_length": 150, "commas": 5, "depth": 8},
     "tech": {"length": 110, "critical_length": 180, "commas": 6, "depth": 9},
@@ -100,6 +102,64 @@ def add(
     )
 
 
+def proofread(block, doc, findings: list[Finding]) -> None:
+    stack: list[str] = []
+    unbalanced = False
+    for character in block.text:
+        if character in BRACKET_PAIRS:
+            stack.append(character)
+        elif character in BRACKET_PAIRS.values():
+            if not stack or BRACKET_PAIRS[stack[-1]] != character:
+                unbalanced = True
+            else:
+                stack.pop()
+    if stack or unbalanced:
+        add(
+            findings, block.start_line, "unbalanced_brackets", "warning",
+            "括弧の対応が取れていません。引用や数式として意図した表記か確認します。",
+            block.text,
+        )
+
+    for previous, current in zip(doc, doc[1:]):
+        if previous.idx + len(previous.text) != current.idx or previous.text != current.text:
+            continue
+        particle = previous.pos_ == current.pos_ == "ADP"
+        word = (
+            len(current.text) >= 2
+            and previous.pos_ == current.pos_
+            and current.pos_ in {"NOUN", "VERB", "ADJ", "ADV"}
+        )
+        if particle or word:
+            add(
+                findings, sentence_line(block, current.idx),
+                "duplicate_particle" if particle else "duplicate_word", "warning",
+                "同じ助詞が隣接しています。誤入力による重複か確認します。"
+                if particle else "同じ語が隣接しています。意図した反復か確認します。",
+                current.sent.text, {"repeated": current.text},
+            )
+
+    first_style = None
+    for sent in doc.sents:
+        if re.search(r'[「」『』"“”]', sent.text):
+            continue
+        ending = sent.text.strip().rstrip("。！？!?")
+        style = (
+            "polite" if POLITE_END_RE.search(ending)
+            else "plain" if PLAIN_END_RE.search(ending)
+            else None
+        )
+        if style and first_style and style != first_style:
+            add(
+                findings, sentence_line(block, sent.start_char),
+                "mixed_sentence_style", "warning",
+                "同じ段落に敬体と常体が混在しています。引用や意図した使い分けか確認します。",
+                sent.text,
+            )
+            break
+        if style:
+            first_style = style
+
+
 def analyze(path: Path, genre: str, reading_load: bool) -> dict:
     text = read_text(path)
     blocks = iter_prose_blocks(text)
@@ -110,12 +170,17 @@ def analyze(path: Path, genre: str, reading_load: bool) -> dict:
     paragraph_leads: list[tuple[int, str]] = []
 
     for block, doc in zip(blocks, nlp.pipe([item.text for item in blocks])):
+        if not reading_load:
+            proofread(block, doc, findings)
         paragraph_tokens = content_tokens(doc)
         if paragraph_tokens:
             paragraph_leads.append((block.start_line, paragraph_tokens[0].lemma_))
 
         for phrase, (category, message) in PHRASE_RULES.items():
-            if not reading_load and phrase in block.text:
+            pattern = re.escape(phrase)
+            if category == "formulaic_conclusion":
+                pattern += r"(?!か|[?？])"
+            if not reading_load and re.search(pattern, block.text):
                 add(findings, block.start_line, category, "warning", message, block.text)
 
         if not reading_load: