kotonoha 0.3.0 → 0.4.0

package/CHANGELOG.md

@@ -7,6 +7,24 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.4.0] - 2026-10-19
+
+### Added
+
+- Add duplicate-particle/word, Japanese bracket, and paragraph style-mixing
+  diagnostics, plus a minimal-edit `proofread` skill mode.
+- Add a Markdown-aware invariant gate with protected-content checks and
+  required hash-bound semantic review of edits.
+
+### Fixed
+
+- Avoid treating obligation expressions as double-negative errors and
+  conclusion questions as formulaic assertions.
+- Keep shorter fence markers and fence-like info strings inside code blocks
+  out of prose diagnostics.
+- Require the invariant gate and current semantic review to pass before
+  claiming Japanese prose optimization completed.
+
 ## [0.3.0] - 2026-09-30
 
 ### Added

package/README-ja.md

@@ -97,7 +97,7 @@ White Paper向けの分析を作成して
 
 - GitHub Copilot CLIがインストールされていること
 - tech-writerの構造lintを実行する場合はPython 3.9以上
-- 同梱`japanese-prose`の文章lint、読解負荷分析、アウトライン抽出、用語検査を実行する場合はPython 3.10以上と`uv`。GiNZA、`ja_ginza`、spaCyは初回実行時に`uv`が解決
+- 同梱`japanese-prose`の文章lint、読解負荷分析、アウトライン抽出、用語検査、編集前後の不変条件検査を実行する場合はPython 3.10以上と`uv`。GiNZA、`ja_ginza`、spaCy、Markdown解析用の依存関係は、各スクリプトの初回実行時に`uv`が解決
 
 ### npmからインストール
 
@@ -136,6 +136,10 @@ npx kotonoha install --skill all --force
 
 kotonohaには独自開発の`japanese-prose`が同梱されるため、文章最適化スキルを別途インストールする必要はありません。`npx kotonoha install`により`tech-writer`と同じスキルルートへ配置され、GiNZAを使った文章lint、読解負荷検査、用語抽出、アウトライン検査、反復的な文章レビューをローカルで実行できます。この実装はkotonoha向けにゼロから開発しており、`natural-japanese`のソースコードを含みません。GiNZAの依存関係とライセンス情報は`skills/japanese-prose/NOTICE.md`に記録しています。
 
+文章lintでは、隣接する助詞・単語の重複、和文括弧の不整合、同一段落内の敬体・常体の混在も確認します。指摘は自動置換の指示ではなく、文脈を確認する対象です。`proofread`モードでは、任意の言い換えを避け、誤字と文法上の誤りだけを最小限に修正します。100点満点のスコアは確認箇所を探す補助であり、訂正精度や品質の保証ではありません。
+
+編集前の原文は変更せずに保存します。同梱の`scripts/invariants.py`が、数値、識別子、コード、表、リンク、指定された固有名詞・専門用語などの変更を検査します。編集した文章には、原文と編集後のファイルのハッシュに対応した意味保存レビューが必要です。機械的な一致だけでは、意味が保たれたとは判定しません。レビュー形式と終了コードは、[`review-workflow.md`](skills/japanese-prose/references/review-workflow.md)を参照してください。
+
 自然言語で指示するときは、GiNZAを明示する必要はありません。「日本語文書を自然にする」「読みやすくする」「簡潔にする」「AIらしい定型表現を減らす」といった依頼をすると、同梱の文章最適化ワークフローが呼び出されます。
 
 ```text
@@ -150,6 +154,7 @@ README-ja.mdの日本語を自然で読みやすい表現に修正して
 目的に応じて、次のようにモードを指定できます。
 
 - ファイルを修正する: `README-ja.mdの日本語表現を最適化して`
+- 誤りだけを修正する: `README-ja.mdをproofreadモードで校正して。任意の言い換えはせず、誤字と文法上の誤りだけを最小限に修正して`
 - 修正せずにレビューする: `README-ja.mdの日本語をレビューして。ファイルは修正しないで`
 - 採点だけ行う: `README-ja.mdの日本語表現を100点満点で採点して`
 - すべての診断を実行する: `README-ja.mdをfullモードで日本語表現最適化して`

package/README.md

@@ -155,7 +155,8 @@ handoff without inventing missing evidence.
 
 - GitHub Copilot CLI installed
 - Python 3.9+ for tech-writer's structural lint
-- Python 3.10+ and `uv` for the bundled GiNZA diagnostics such as prose lint,
+- Python 3.10+ and `uv` for the edit-invariant gate and bundled GiNZA
+  diagnostics such as prose lint,
   reading-load analysis, outline extraction, and terminology checks; `uv`
   resolves GiNZA, `ja_ginza`, and spaCy on first use
 
@@ -209,6 +210,20 @@ scratch for kotonoha and does not include `natural-japanese` source code.
 GiNZA dependency and license information is recorded in
 `skills/japanese-prose/NOTICE.md`.
 
+The lint also flags adjacent duplicate particles/words, Japanese bracket
+mismatches, and polite/plain style mixing within a paragraph. Findings are
+review targets, not automatic replacements. Use `proofread` mode for minimal
+typo/grammar corrections without optional stylistic rewriting. The 0–100
+score is a triage aid, not correction accuracy or a quality certificate.
+
+Before editing, the workflow saves an immutable original. The bundled
+`scripts/invariants.py` checks protected content and requires a hash-bound
+semantic review of changed prose. Numbers, identifiers, code, tables, links,
+and caller-supplied proper names/domain terms cannot be silently changed.
+Mechanical equality alone does not establish preserved meaning. See
+[`review-workflow.md`](skills/japanese-prose/references/review-workflow.md)
+for the review format and gate exit codes.
+
 You do not need to name GiNZA explicitly in a natural-language request.
 Requests to make a Japanese document more natural, readable, concise, or less
 formulaic invoke the bundled prose-optimization workflow. For example:
@@ -225,6 +240,7 @@ and repetitive AI-like phrasing, then fix the findings.
 You can specify the intended mode more precisely:
 
 - Edit the file: `Optimize the Japanese prose in README-ja.md.`
+- Correct errors only: `Proofread README-ja.md; make minimal typo/grammar corrections without stylistic rewrites.`
 - Review without editing: `Review the Japanese in README-ja.md, but do not modify the file.`
 - Score only: `Score the Japanese prose in README-ja.md out of 100.`
 - Run every diagnostic: `Run the full Japanese prose optimization workflow on README-ja.md.`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kotonoha",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "GitHub Copilot CLI skills for consulting analysis, technical writing, Japanese prose, and PPTX planning.",
   "license": "MIT",
   "author": "nahisaho",

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
@@ -108,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:

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

@@ -5,6 +5,7 @@
 #   "ginza>=5.2.0,<5.3",
 #   "ja-ginza>=5.2.0,<5.3",
 #   "spacy>=3.8.0,<4",
+#   "markdown-it-py>=3,<5",
 # ]
 # ///
 """Behavioral tests for kotonoha's original GiNZA diagnostics."""
@@ -12,6 +13,9 @@
 from __future__ import annotations
 
 import json
+import hashlib
+import subprocess
+import sys
 import tempfile
 import unittest
 from pathlib import Path
@@ -20,6 +24,7 @@ from core import strip_markdown_inline
 from lint import analyze, compare_baseline
 from outline import extract as extract_outline
 from terms import extract as extract_terms
+from invariants import SEMANTIC_CHECKS, check as check_invariants
 
 
 SCRIPT_DIR = Path(__file__).resolve().parent
@@ -27,6 +32,70 @@ FIXTURES = SCRIPT_DIR / "fixtures"
 
 
 class DiagnosticTests(unittest.TestCase):
+    def analyze_text(self, text: str, reading_load: bool = False) -> dict:
+        with tempfile.TemporaryDirectory() as directory:
+            path = Path(directory) / "sample.md"
+            path.write_text(text, encoding="utf-8")
+            return analyze(path, "tech", reading_load)
+
+    def test_proofreading_detects_adjacent_duplicates(self) -> None:
+        for text, category in (
+            ("管理者が設定をを確認します。", "duplicate_particle"),
+            ("管理者がが設定を確認します。", "duplicate_particle"),
+            ("管理者にに通知します。", "duplicate_particle"),
+            ("設定設定を保存します。", "duplicate_word"),
+        ):
+            with self.subTest(text=text):
+                result = self.analyze_text(text)
+                self.assertIn(category, {item["category"] for item in result["findings"]})
+                self.assertNotIn(
+                    category,
+                    {item["category"] for item in self.analyze_text(text, True)["findings"]},
+                )
+
+    def test_proofreading_checks_brackets_and_paragraph_style(self) -> None:
+        for text, category in (
+            ("設定（管理者向け））を保存します。", "unbalanced_brackets"),
+            ("設定を保存します。変更はすぐに反映される。", "mixed_sentence_style"),
+        ):
+            with self.subTest(text=text):
+                self.assertIn(category, {
+                    item["category"] for item in self.analyze_text(text)["findings"]
+                })
+
+    def test_proofreading_preserves_names_code_and_deliberate_styles(self) -> None:
+        text = (
+            "ののさんは、ももを食べます。操作を確認してください。\n\n"
+            "「設定を保存する」と説明します。結果を確認します。\n\n"
+            "設定を保存する。\n\n設定を確認します。\n\n"
+            "`設定設定（`という識別子を使用します。\n\n"
+            "```text\n設定をを確認します（\n```\n"
+        )
+        categories = {item["category"] for item in self.analyze_text(text)["findings"]}
+        self.assertFalse(categories & {
+            "duplicate_particle", "duplicate_word", "unbalanced_brackets", "mixed_sentence_style",
+        })
+
+    def test_short_fences_and_fence_info_do_not_expose_code_as_prose(self) -> None:
+        for text in (
+            "````text\n```python\n設定設定（をを確認する。\n```\n````\n",
+            "```text\n```python\n設定設定（をを確認する。\n```\n",
+        ):
+            with self.subTest(text=text):
+                self.assertEqual(self.analyze_text(text)["findings"], [])
+
+    def test_questions_and_obligations_are_not_style_errors(self) -> None:
+        for text in (
+            "この結果だけでは、安全だと言えるでしょうか。",
+            "この結果だけでは、安全だと言えるだろうか。",
+            "管理者は確認しなくてはならない。",
+            "この場合は停止せざるを得ない。",
+        ):
+            with self.subTest(text=text):
+                categories = {item["category"] for item in self.analyze_text(text)["findings"]}
+                self.assertNotIn("formulaic_conclusion", categories)
+                self.assertNotIn("double_negative", categories)
+
     def test_unnatural_fixture_scores_below_natural_fixture(self) -> None:
         unnatural = analyze(FIXTURES / "unnatural.md", "tech", False)
         natural = analyze(FIXTURES / "natural.md", "tech", False)
@@ -113,5 +182,104 @@ class DiagnosticTests(unittest.TestCase):
         self.assertTrue(values.isdisjoint({"npm", "run", "build", "workspace", "core"}))
 
 
+class InvariantTests(unittest.TestCase):
+    def test_protected_changes_cannot_be_approved_by_semantic_review(self) -> None:
+        original = (
+            "---\nowner: admin\n---\n# 概要\n\n"
+            "REQ-001ではAcmeが3回、30秒で確認します。帯域は3MB/sです。[仕様](https://example.com/spec)\n\n"
+            "`MAX_RETRY_COUNT`を使用します。\n\n"
+            "| 項目 | 値 |\n| --- | --- |\n| 上限 | 3 |\n\n"
+            "````text\n```python\nprint('old')\n```\n````\n"
+        )
+        changes = (
+            ("3回、30秒", "30回、3秒", "numbers_in_order"),
+            ("30秒", "30分", "quantities_in_order"),
+            ("3MB/s", "3MB/min", "quantities_in_order"),
+            ("REQ-001", "REQ-002", "identifiers_in_order"),
+            ("https://example.com/spec", "https://example.com/new", "link_destinations"),
+            ("MAX_RETRY_COUNT", "RETRY_COUNT", "inline_code"),
+            ("| 上限 | 3 |", "| 上限 | 4 |", "protected_blocks"),
+            ("owner: admin", "owner: user", "frontmatter"),
+            ("# 概要", "## 概要", "heading_levels"),
+            ("Acme", "Other", "protected_terms"),
+            ("print('old')", "print('new')", "protected_blocks"),
+        )
+        with tempfile.TemporaryDirectory() as directory:
+            before, after, review = (Path(directory) / name for name in ("before.md", "after.md", "review.json"))
+            before.write_text(original, encoding="utf-8")
+            for old, new, category in changes:
+                with self.subTest(category=category):
+                    after.write_text(original.replace(old, new), encoding="utf-8")
+                    self.write_review(before, after, review)
+                    result = check_invariants(before, after, ["Acme"], review)
+                    self.assertEqual(result["status"], "blocked")
+                    self.assertIn(category, {
+                        item["category"] for item in result["mechanical_violations"]
+                    })
+
+    def write_review(self, before: Path, after: Path, review: Path) -> None:
+        review.write_text(json.dumps({
+            "before_sha256": hashlib.sha256(before.read_bytes()).hexdigest(),
+            "after_sha256": hashlib.sha256(after.read_bytes()).hexdigest(),
+            "reviewer": "test-reviewer",
+            "checks": {name: True for name in SEMANTIC_CHECKS},
+        }), encoding="utf-8")
+
+    def test_review_must_cover_exact_edits_and_all_semantic_checks(self) -> None:
+        with tempfile.TemporaryDirectory() as directory:
+            before, after, review = (Path(directory) / name for name in ("before.md", "after.md", "review.json"))
+            before.write_text("管理者だけが設定を確認します。", encoding="utf-8")
+            after.write_text("設定を確認できるのは管理者だけです。", encoding="utf-8")
+            self.assertEqual(check_invariants(before, before)["status"], "passed")
+            self.assertEqual(check_invariants(before, after)["status"], "review_required")
+            self.write_review(before, after, review)
+            self.assertEqual(check_invariants(before, after, review_path=review)["status"], "passed")
+            after.write_text("誰でも設定を確認できます。", encoding="utf-8")
+            self.assertEqual(check_invariants(before, after, review_path=review)["status"], "review_required")
+            self.write_review(before, after, review)
+            value = json.loads(review.read_text(encoding="utf-8"))
+            value["checks"]["scope"] = False
+            review.write_text(json.dumps(value), encoding="utf-8")
+            self.assertEqual(check_invariants(before, after, review_path=review)["status"], "review_required")
+
+    def test_invariant_cli_exit_codes_and_input_errors(self) -> None:
+        with tempfile.TemporaryDirectory() as directory:
+            before, after = (Path(directory) / name for name in ("before.md", "after.md"))
+            before.write_text("上限は3回です。", encoding="utf-8")
+            for text, code in (
+                ("上限は3回です。", 0),
+                ("上限は30回です。", 2),
+                ("3回を上限とします。", 3),
+            ):
+                with self.subTest(code=code):
+                    after.write_text(text, encoding="utf-8")
+                    process = subprocess.run(
+                        [sys.executable, str(SCRIPT_DIR / "invariants.py"), str(before), str(after), "--json"],
+                        capture_output=True, text=True,
+                    )
+                    self.assertEqual(process.returncode, code, process.stderr)
+                    self.assertIn("status", json.loads(process.stdout))
+            process = subprocess.run(
+                [sys.executable, str(SCRIPT_DIR / "invariants.py"), str(before), str(Path(directory) / "missing.md")],
+                capture_output=True, text=True,
+            )
+            self.assertEqual(process.returncode, 1)
+            self.assertIn("error:", process.stderr)
+
+    def test_units_across_line_breaks_and_boolean_review_types(self) -> None:
+        with tempfile.TemporaryDirectory() as directory:
+            before, after, review = (Path(directory) / name for name in ("before.md", "after.md", "review.json"))
+            before.write_text("上限は30\n秒です。", encoding="utf-8")
+            after.write_text("上限は30\n分です。", encoding="utf-8")
+            self.assertEqual(check_invariants(before, after)["status"], "blocked")
+            before.write_text("設定をを保存します。", encoding="utf-8")
+            after.write_text("設定を保存します。", encoding="utf-8")
+            self.write_review(before, after, review)
+            value = json.loads(review.read_text(encoding="utf-8"))
+            value["checks"]["negation"] = "true"
+            review.write_text(json.dumps(value), encoding="utf-8")
+            self.assertEqual(check_invariants(before, after, review_path=review)["status"], "review_required")
+
+
 if __name__ == "__main__":
     unittest.main()

package/skills/tech-writer/references/japanese-prose-optimization.md

@@ -55,7 +55,9 @@ Never trade technical precision for conversational phrasing.
    discovered skill,
    and follow its workflow.
 2. Ask the loaded skill to review and rewrite only the Japanese prose under
-   the frozen invariants.
+   the frozen invariants. Save an immutable pre-edit copy, pass the frozen
+   proper names and domain terms for `--protect`, and keep necessary
+   corrections separate from optional wording changes.
 3. Let `<japanese-prose-dir>` be the directory containing the loaded
    optimizer's `SKILL.md`. When its diagnostics are available, run the
    optimizer's scripts with their qualified paths:
@@ -82,6 +84,12 @@ Never trade technical precision for conversational phrasing.
    violating edit, give the violated invariant back to the optimizer, and
    retry within the round limit. If the violation cannot be resolved, report
    `Japanese prose optimization did not converge`.
+   Run `<japanese-prose-dir>/scripts/invariants.py` against the immutable
+   original and current target. Require a hash-bound contextual semantic
+   review for changed prose, following the optimizer's review workflow.
+   A `review_required` result or an unavailable/failed invariant gate cannot
+   be treated as completion. Rerun after rubber-duck edits; old review hashes
+   do not approve new text.
 7. Re-run kotonoha's doctype checklist and structural lint before
    rubber-duck review.
 
@@ -91,9 +99,9 @@ When this pass is in scope (a living, multi-section document whose requested
 final language is Japanese, in `write` mode), report exactly one status:
 
 - `Japanese prose optimization completed`: the registered optimizer ran and
-  no actionable prose findings remain. Run diagnostics when available; if
-  `uv` or a diagnostic script is unavailable, note that limitation without
-  changing this status.
+  no actionable prose findings remain, and the invariant gate passed with
+  a current semantic review of any edits. A missing optional diagnostic may
+  be noted, but a missing or failed invariant gate prevents this status.
 - `Japanese prose optimization not performed`: the bundled optimizer was
   missing or unreadable, so no prose review or rewrite ran; include the
   concrete reason. A standard `npx kotonoha install` should prevent this
@@ -102,8 +110,8 @@ final language is Japanese, in `write` mode), report exactly one status:
   unresolved actionable findings or invariant violations, or the optimizer
   started but failed before producing a valid result, a required
   post-rubber-duck rerun failed or could not start because all 15 handoffs
-  were already used; list the findings, violations, failure, and attempted
-  fixes.
+  were already used, or the invariant gate/semantic review could not pass;
+  list the findings, violations, failure, and attempted fixes.
 
 Do not claim natural-language optimization based only on kotonoha's
 structural lint. Documents outside the scope of this pass require no Japanese