@litfamily/lithermes 1.0.7 → 1.0.9

package/assets/lithermes-plugin/diagnostics.py

@@ -21,6 +21,11 @@ try:
 except (ImportError, ModuleNotFoundError):
     import provider_metrics as _provider_metrics  # type: ignore
 
+try:
+    from .core_contract import KOREAN_PROSE_ALIASES, KOREAN_PROSE_COMMANDS
+except (ImportError, ModuleNotFoundError):
+    from core_contract import KOREAN_PROSE_ALIASES, KOREAN_PROSE_COMMANDS  # type: ignore
+
 PLUGIN_ROOT = Path(__file__).resolve().parent
 HOOKS = (
     "on_session_start",
@@ -36,9 +41,12 @@ HOOKS = (
 )
 SLASH_COMMANDS = (
     "lit", "lit-loop", "lit-plan", "litgoal", "review-work", "start-work",
-    "deep-interview", "litwork-loop", "litwork-plan", "lit-korean",
-    "text-naturalization", "text-neutralization", "lit-recap", "lit-handoff",
+    "deep-interview", "litwork-loop", "litwork-plan",
+    *KOREAN_PROSE_COMMANDS, *KOREAN_PROSE_ALIASES,
+    "lit-recap", "lit-handoff",
     "lit-scientific-visualization",
+    "lit-diagram-drawer",
+    "lit-pptx", "lit-docx", "lit-typographic-motion",
 )
 GOAL_TOOLS = (
     "goal_set", "goal_status", "goal_add_criterion", "goal_evidence",
@@ -171,14 +179,31 @@ def _host_config_path() -> Path:
     return home / "config.yaml"
 
 
+def _is_secret_looking_scalar(value: object) -> bool:
+    if not isinstance(value, str):
+        return False
+    trimmed = value.strip()
+    if not trimmed or re.fullmatch(r"(?:true|false|null)", trimmed, re.IGNORECASE):
+        return False
+    if re.fullmatch(r"[A-Z][A-Z0-9_]*", trimmed) and "_" in trimmed:
+        return False
+    if re.fullmatch(r"\$\{[A-Z][A-Z0-9_]*\}", trimmed):
+        return False
+    return not re.search(r"(?:^|[-_])(redacted|placeholder)(?:[-_]|$)", trimmed, re.IGNORECASE)
+
+
 def _has_credential_key(value: object) -> bool:
     if isinstance(value, dict):
-        return any(
-            _CREDENTIAL_KEY_RE.search(
-                re.sub(r"([a-z0-9])([A-Z])", r"\1_\2", str(key)).replace("-", "_")
-            ) or _has_credential_key(child)
-            for key, child in value.items()
-        )
+        for key, child in value.items():
+            normalized = re.sub(
+                r"([a-z0-9])([A-Z])", r"\1_\2", str(key or "")
+            ).replace("-", "_")
+            if (
+                _CREDENTIAL_KEY_RE.search(normalized)
+                and _is_secret_looking_scalar(child)
+            ) or _has_credential_key(child):
+                return True
+        return False
     if isinstance(value, list):
         return any(_has_credential_key(child) for child in value)
     return False
@@ -454,6 +479,7 @@ def status_report(host_version: str | None = None) -> str:
         _provider_metrics.capability_line(),
         f"litgoal evidence kinds: {', '.join(_evidence_kinds())}",
         f"scientific visualization: {_science.dependency_summary()}",
+        *_motion_runtime_lines(),
         *_capability_status_lines(version),
     ]
     host_note = _beyond_verified_host_note(version)
@@ -462,6 +488,27 @@ def status_report(host_version: str | None = None) -> str:
     return "\n".join(lines)
 
 
+def _motion_runtime_lines() -> list[str]:
+    import subprocess
+    command = PLUGIN_ROOT / "skills" / "lit-typographic-motion" / "bin" / "runtime.mjs"
+    if not command.is_file():
+        return ["motion Chrome: unavailable", "motion ffmpeg: unavailable", "motion WebGL2 renderer: unavailable",
+                "motion software GL: unknown", "motion pre-warm: missing; run lithermes motion-runtime install"]
+    try:
+        result = subprocess.run(["node", str(command), "status"], capture_output=True, text=True, timeout=35)
+        if result.returncode == 0 and len(result.stdout.splitlines()) == 5:
+            return ["motion " + line for line in result.stdout.splitlines()]
+    except (OSError, subprocess.TimeoutExpired):
+        pass
+    return ["motion Chrome: unavailable", "motion ffmpeg: unavailable", "motion WebGL2 renderer: unavailable",
+            "motion software GL: unknown", "motion pre-warm: status failed; run lithermes motion-runtime status"]
+
+
+def _motion_line_needs_attention(line: str) -> bool:
+    lowered = line.lower()
+    return any(marker in lowered for marker in ("not found", "no webgl2", "warning:", "not ready", "unavailable", "status failed", "not probed"))
+
+
 def doctor_report(host_version: str | None = None) -> tuple[list[str], int]:
     version = host_version or hermes_host_version()
     lines: list[str] = []
@@ -478,6 +525,27 @@ def doctor_report(host_version: str | None = None) -> tuple[list[str], int]:
     else:
         lines.append("[WARN] no skills found under skills/")
         healthy = False
+    diagram_skill = PLUGIN_ROOT / "skills" / "lit-diagram-drawer" / "SKILL.md"
+    if diagram_skill.is_file():
+        lines.append("[OK] lit-diagram-drawer entrypoint present")
+    else:
+        lines.append("[WARN] lit-diagram-drawer entrypoint missing")
+        healthy = False
+    for name in ("lit-pptx", "lit-docx", "lit-typographic-motion"):
+        entrypoint = PLUGIN_ROOT / "skills" / name / "SKILL.md"
+        if entrypoint.is_file():
+            lines.append(f"[OK] {name} entrypoint present")
+        else:
+            lines.append(f"[WARN] {name} entrypoint missing")
+            healthy = False
+    try:
+        import subprocess
+        runtime = PLUGIN_ROOT / "skills" / "lit-pptx" / "bin" / "office.mjs"
+        result = subprocess.run(["node", str(runtime), "doctor"], capture_output=True, text=True, timeout=10)
+        lines.append("[OK] " + result.stdout.strip() if result.returncode == 0 else "[WARN] Office runtime status unavailable")
+    except (OSError, subprocess.TimeoutExpired):
+        lines.append("[WARN] Office runtime status unavailable")
+    lines.extend(("[WARN] " if _motion_line_needs_attention(line) else "[OK] ") + line for line in _motion_runtime_lines())
     science = _science.dependency_status()
     science_tag = "OK" if science["state"] == "READY" else "DEGRADED"
     lines.append(f"[{science_tag}] scientific visualization: {_science.dependency_summary()}")

package/assets/lithermes-plugin/humanizer_detector.py

@@ -0,0 +1,348 @@
+"""Python port of the LitHumanizer line/sentence/document rule engine."""
+
+from __future__ import annotations
+
+import argparse
+from bisect import bisect_right
+import json
+from pathlib import Path
+import re
+import sys
+from typing import Iterable
+
+
+PLUGIN_ROOT = Path(__file__).resolve().parent
+SKILL_ROOT = PLUGIN_ROOT / "skills" / "lit-humanizer"
+RULES_PATH = SKILL_ROOT / "rules.json"
+VALID_LANGS = {"ko", "en", "code"}
+VALID_SEVERITIES = {"block", "warn"}
+VALID_SCOPES = {"line", "sentence", "document"}
+
+
+def _js_compatible_pattern(pattern: str) -> str:
+    """Port JavaScript ASCII word classes without narrowing Unicode ``\s``."""
+    result: list[str] = []
+    in_class = False
+    index = 0
+    while index < len(pattern):
+        char = pattern[index]
+        if char == "\\" and index + 1 < len(pattern):
+            code = pattern[index + 1]
+            if code in {"w", "d"}:
+                value = "A-Za-z0-9_" if code == "w" else "0-9"
+                result.append(value if in_class else f"[{value}]")
+            elif code in {"b", "B"} and not in_class:
+                result.append(r"(?a:\b)" if code == "b" else r"(?a:\B)")
+            else:
+                result.extend((char, code))
+            index += 2
+            continue
+        if char == "[" and not in_class:
+            in_class = True
+        elif char == "]" and in_class:
+            in_class = False
+        result.append(char)
+        index += 1
+    return "".join(result)
+
+
+def load_rules(path: str | Path = RULES_PATH) -> list[dict]:
+    """Load the bundled schema, rejecting malformed or duplicate rule entries."""
+    data = json.loads(Path(path).read_text(encoding="utf-8"))
+    if data.get("schema_version") != 1 or not isinstance(data.get("rules"), list):
+        raise ValueError("rules.json must use schema_version 1 and contain a rules array")
+    seen: set[str] = set()
+    result = []
+    flag_values = {"i": re.IGNORECASE, "m": re.MULTILINE, "s": re.DOTALL}
+    for item in data["rules"]:
+        rule_id = item.get("id")
+        if not isinstance(rule_id, str) or not rule_id or rule_id in seen:
+            raise ValueError(f"missing or duplicate rule id: {rule_id}")
+        seen.add(rule_id)
+        if item.get("lang") not in VALID_LANGS or item.get("severity") not in VALID_SEVERITIES or item.get("scope") not in VALID_SCOPES:
+            raise ValueError(f"invalid lang, severity, or scope for {rule_id}")
+        if not isinstance(item.get("pattern"), str) or not isinstance(item.get("context"), list):
+            raise ValueError(f"incomplete rule definition: {rule_id}")
+        flags = 0
+        for flag in item.get("flags", ""):
+            if flag not in flag_values:
+                raise ValueError(f"unsupported regex flag {flag!r} for {rule_id}")
+            flags |= flag_values[flag]
+        compiled = re.compile(_js_compatible_pattern(item["pattern"]), flags)
+        result.append({**item, "regex": compiled})
+    return result
+
+
+def _is_internal_path(file: str) -> bool:
+    segments = re.split(r"[\\/]+", str(file).replace("\\", "/"))
+    for index, segment in enumerate(segments):
+        lower = segment.lower()
+        if lower in {"plans", "evidence", "ledgers", ".hermes"} or lower.startswith(".lit") or segment.upper().startswith("HANDOFF"):
+            return True
+    return False
+
+
+def _is_caption(line: str) -> bool:
+    return bool(re.match(r"^\s*(?:>\s*)?(?:!\[)?(?:표\s*\d+|그림\s*\d+|table\s+\d+|figure\s+\d+)\b", line, re.IGNORECASE | re.ASCII))
+
+
+_PLAIN_SOURCE = re.compile(r"^\s*(?:Source|Sources|출처|자료|※\s*자료)\s*[:：]", re.IGNORECASE | re.ASCII)
+_BOLD_OR_HTML = re.compile(r"^\s*(?:\*\*|__|<b\b)", re.IGNORECASE | re.ASCII)
+_CAVEAT_PHRASE = re.compile(
+    r"\b(?:not\s+(?:realized\s+results?|verified|independently verified|performed|a permit decision|final|actual)|"
+    r"demo(?:nstration)?\s+(?:synthesis|assumptions|recommendations?)|"
+    r"(?:preliminary|provisional|tentative|draft|estimated?)\s+(?:results?|data|findings?|outcomes?|values?)|"
+    r"results?\s+may\s+(?:change|be revised)|subject\s+to\s+change)\b|미실현|실현되지|미검증|검증되지|미확인|"
+    r"(?:잠정|예비|추정|예상)(?:치)?(?:\s*(?:결과|자료|수치|값))?|변동\s*가능|변경\s*가능|확정되지|미확정",
+    re.IGNORECASE | re.ASCII,
+)
+_STANDALONE_STATUS = re.compile(
+    r"^(?:assumptions?|recommendations?|unverified|preliminary|provisional|tentative|draft|estimated?|estimate|forecast|projection|projected|planned|simulated|modeled|가정|권고|제안|잠정(?:치)?|예비|추정(?:치)?|예상)$",
+    re.IGNORECASE | re.ASCII,
+)
+_APPENDED_CAVEAT = re.compile(
+    r"(?:^|\s)(?:not\s+(?:realized\s+results?|verified|independently verified|performed|a permit decision|final|actual)|"
+    r"demo(?:nstration)?\s+(?:synthesis|assumptions|recommendations?)|"
+    r"(?:preliminary|provisional|tentative|draft|estimated?)\s+(?:results?|data|findings?|outcomes?|values?)|"
+    r"results?\s+may\s+(?:change|be revised)|subject\s+to\s+change|unverified|미실현|실현되지|미검증|검증되지|미확인|"
+    r"잠정(?:치)?|예비(?:자료|결과|수치)?|추정(?:치|자료|결과)?|예상(?:치|자료|결과)?|변동\s*가능|변경\s*가능|확정되지|미확정)\s*[.!?。)]*$",
+    re.IGNORECASE | re.ASCII,
+)
+
+
+def _plain_source_line(line: str) -> bool:
+    return bool(_PLAIN_SOURCE.match(line)) and not _BOLD_OR_HTML.match(line)
+
+
+def _has_embedded_caveat(line: str) -> bool:
+    body = re.sub(r"^\s*(?:Source|Sources|출처|자료|※\s*자료)\s*[:：]\s*", "", line, flags=re.IGNORECASE | re.ASCII)
+    segments = [re.sub(r"[.!?。]+$", "", segment.strip()) for segment in re.split(r"[,;:—–]", body)]
+    tail = segments[-1] if segments else ""
+    return bool(_CAVEAT_PHRASE.search(tail) or _STANDALONE_STATUS.fullmatch(tail) or _APPENDED_CAVEAT.search(body))
+
+
+def _inline_code_as_spaces(line: str) -> str:
+    return re.sub(r"(`+)[^`]*?\1", lambda match: " " * len(match.group(0)), line)
+
+
+def _source_rows(text: str) -> list[dict]:
+    fence: tuple[str, int] | None = None
+    caption_pending = 0
+    figure_active = False
+    rows = []
+    for number, line in enumerate(re.split(r"\r?\n", text), start=1):
+        marker = re.match(r"^ {0,3}(`{3,}|~{3,})", line)
+        if fence:
+            if marker and marker.group(1)[0] == fence[0] and len(marker.group(1)) >= fence[1]:
+                fence = None
+            caption_pending = 0
+            figure_active = False
+            rows.append({"line": line, "number": number, "candidate": "", "skipped": True, "caption": False, "caption_attribution": False})
+            continue
+        if marker:
+            caption_pending = 0
+            fence = (marker.group(1)[0], len(marker.group(1)))
+            figure_active = False
+            rows.append({"line": line, "number": number, "candidate": "", "skipped": True, "caption": False, "caption_attribution": False})
+            continue
+        if re.match(r"^\s{0,3}>", line):
+            caption_pending = 0
+            figure_active = False
+            rows.append({"line": line, "number": number, "candidate": "", "skipped": True, "caption": False, "caption_attribution": False})
+            continue
+        candidate = _inline_code_as_spaces(line)
+        caption = _is_caption(line)
+        plain_source = _plain_source_line(line)
+        source_anchor = bool(
+            re.match(r"^\s*\|", line)
+            or re.match(r"^\s*!\[[^\]]*\]\s*\(", line)
+            or re.match(r"^\s*<img\b", line, re.IGNORECASE | re.ASCII)
+            or caption
+        )
+        opens_figure = bool(re.search(r"<figure\b", line, re.IGNORECASE | re.ASCII))
+        closes_figure = bool(re.search(r"</figure\s*>", line, re.IGNORECASE | re.ASCII))
+        if opens_figure:
+            figure_active = True
+        caption_attribution = not _has_embedded_caveat(line) and plain_source and (caption_pending > 0 or figure_active)
+        if source_anchor or closes_figure:
+            caption_pending = 2
+        elif plain_source:
+            caption_pending = 0
+        elif line.strip() and caption_pending > 0:
+            caption_pending = 0
+        elif caption_pending > 0:
+            caption_pending -= 1
+        if closes_figure:
+            figure_active = False
+        rows.append({"line": line, "number": number, "candidate": candidate, "skipped": False, "caption": caption, "caption_attribution": caption_attribution})
+    return rows
+
+
+def _join_rows(rows: list[dict], separator: str) -> dict:
+    text_parts: list[str] = []
+    offsets: list[int] = []
+    size = 0
+    for index, row in enumerate(rows):
+        if index:
+            size += len(separator)
+        offsets.append(size)
+        text_parts.append(row["candidate"])
+        size += len(row["candidate"])
+    return {"text": separator.join(text_parts), "line_starts": list(zip(offsets, (row["number"] for row in rows)))}
+
+
+def _line_at_offset(span: dict, offset: int) -> int:
+    if "line" in span:
+        return span["line"]
+    starts = span["line_starts"]
+    if not starts:
+        return 1
+    positions = [entry[0] for entry in starts]
+    index = max(0, bisect_right(positions, offset) - 1)
+    return starts[index][1]
+
+
+def _slice_span(span: dict, start: int, end: int) -> dict:
+    selected = [(offset - start, line) for offset, line in span["line_starts"] if start <= offset < end]
+    if not selected or selected[0][0] > 0:
+        selected.insert(0, (0, _line_at_offset(span, start)))
+    return {"text": span["text"][start:end], "line_starts": selected}
+
+
+_SENTENCE_BOUNDARY = re.compile(r"[.!?。！？]+(?:[\"'”’»)\]]*)\s+")
+
+
+def _split_sentences(span: dict) -> list[dict]:
+    parts = []
+    start = 0
+    for match in _SENTENCE_BOUNDARY.finditer(span["text"]):
+        whitespace = len(match.group(0)) - len(match.group(0).rstrip())
+        end = match.end() - whitespace
+        if end > start:
+            parts.append(_slice_span(span, start, end))
+        start = match.end()
+    if start < len(span["text"]):
+        parts.append(_slice_span(span, start, len(span["text"])))
+    return parts
+
+
+def _rule_segments(rows: list[dict], rule: dict) -> list[dict]:
+    skip_captions = "table_figure_caption" in rule["context"]
+    if rule["scope"] == "line":
+        return [
+            {"text": row["candidate"], "line": row["number"]}
+            for row in rows
+            if not row["skipped"] and not (skip_captions and (row["caption"] or row["caption_attribution"]))
+        ]
+    segments: list[dict] = []
+    group: list[dict] = []
+
+    def flush() -> None:
+        nonlocal group
+        if group:
+            joined = _join_rows(group, " " if rule["scope"] == "sentence" else "\n")
+            segments.extend(_split_sentences(joined) if rule["scope"] == "sentence" else [joined])
+            group = []
+
+    for row in rows:
+        exempt = skip_captions and (row["caption"] or row["caption_attribution"])
+        if row["skipped"] or exempt or (rule["scope"] == "sentence" and not row["candidate"].strip()):
+            flush()
+        else:
+            group.append(row)
+    flush()
+    return segments
+
+
+def _matches_language(rule: dict, text: str) -> bool:
+    if rule["lang"] == "ko":
+        return bool(re.search(r"[가-힣]", text))
+    if rule["lang"] == "en":
+        return bool(re.search(r"[a-z]", text, re.IGNORECASE | re.ASCII))
+    return True
+
+
+def scan_text(text: str, rules: Iterable[dict] | None = None, file: str = "<stdin>") -> list[dict]:
+    """Return at most one finding per rule segment with canonical line mapping."""
+    if _is_internal_path(file):
+        return []
+    selected = list(rules) if rules is not None else load_rules()
+    rows = _source_rows(str(text or ""))
+    findings = []
+    cache: dict[tuple[str, bool], list[dict]] = {}
+    for rule in selected:
+        key = (rule["scope"], "table_figure_caption" in rule["context"])
+        if key not in cache:
+            # Scope is the only rule-specific segmentation property. A shallow
+            # rule copy shares its context only when caption handling differs.
+            cache[key] = _rule_segments(rows, rule)
+        for segment in cache[key]:
+            if not _matches_language(rule, segment["text"]):
+                continue
+            match = rule["regex"].search(segment["text"])
+            if match is None:
+                continue
+            excerpt = re.sub(r"\s+", " ", segment["text"].strip())[:180]
+            findings.append({
+                "file": str(file),
+                "rule": rule["id"],
+                "severity": rule["severity"],
+                "line": _line_at_offset(segment, match.start()),
+                "line_end": _line_at_offset(segment, max(match.start(), match.end() - 1)),
+                "match": match.group(0)[:240],
+                "excerpt": excerpt,
+            })
+    return findings
+
+
+def exit_code(findings: Iterable[dict]) -> int:
+    severities = {finding["severity"] for finding in findings}
+    return 2 if "block" in severities else 1 if "warn" in severities else 0
+
+
+def _read_text(path: Path) -> str:
+    suffix = path.suffix.lower()
+    if suffix in {".docx", ".pptx", ".pdf"}:
+        try:
+            from humanizer_office import extract_text
+        except ImportError:
+            from .humanizer_office import extract_text
+        return extract_text(path)
+    if path.stat().st_size > 2 * 1024 * 1024:
+        raise ValueError("refusing text larger than 2 MiB")
+    return path.read_text(encoding="utf-8")
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description="Scan new prose for LitHumanizer editing signals.")
+    parser.add_argument("--json", action="store_true", help="print findings as JSON")
+    parser.add_argument("--stdin-json", action="store_true", help=argparse.SUPPRESS)
+    parser.add_argument("path", nargs="?", help="text, DOCX, PPTX, or PDF file; stdin when omitted")
+    args = parser.parse_args(argv)
+    try:
+        if args.stdin_json:
+            payload = json.load(sys.stdin)
+            if not isinstance(payload, dict) or not isinstance(payload.get("text"), str):
+                raise ValueError("expected JSON object with a text string")
+            text = payload["text"]
+            file = str(payload.get("file") or "<stdin>")
+        else:
+            path = Path(args.path).expanduser() if args.path else None
+            text = _read_text(path) if path else sys.stdin.read()
+            file = str(path) if path else "<stdin>"
+        findings = scan_text(text, file=file)
+    except (OSError, UnicodeError, ValueError, json.JSONDecodeError, RuntimeError) as error:
+        print(f"LIT_HUMANIZER_SCAN_ERROR: {error}", file=sys.stderr)
+        return 3
+    if args.stdin_json or args.json:
+        print(json.dumps(findings, ensure_ascii=False, separators=(",", ":")))
+    else:
+        for finding in findings:
+            print(f"{finding['severity'].upper()} {finding['rule']}:{finding['line']}: {finding['excerpt']}")
+        if not findings:
+            print("LIT_HUMANIZER_CLEAN")
+    return 0 if args.stdin_json else exit_code(findings)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/assets/lithermes-plugin/humanizer_ko_metrics.py

@@ -0,0 +1,108 @@
+"""Review-only Korean prose metrics ported from the canonical Phase A script."""
+
+from __future__ import annotations
+
+import re
+
+
+THRESHOLDS = {
+    "conclusionPivotMin": 4,
+    "cleftMin": 2,
+    "cleftMinEojeol": 40,
+    "connectiveOpenersPerParagraph": 3,
+    "connectiveEndingCommaMin": 3,
+    "connectiveEndingCommaRate": 0.5,
+}
+_CONCLUSION = ("결론적으로", "따라서", "이를 통해", "그러므로")
+_CONNECTIVE_OPENERS = ("또한", "따라서", "즉", "나아가", "아울러", "게다가", "더욱이", "그러므로", "반면", "그러나", "하지만")
+_SAFE_BALANCE = ("양쪽 모두", "두 가지 모두", "장점도 있지만", "신중하게", "균형")
+_CONNECTIVE_ENDING = re.compile(r"(?:고|며|지만|면서|아서|어서)(?=[\s,\.!?。！？]|$)")
+_CONNECTIVE_ENDING_COMMA = re.compile(r"(?:고|며|지만|면서|아서|어서)\s*,")
+_INLINE_CODE = re.compile(r"`[^`]*`|\n+")
+_CLEFT = re.compile(r"(?:필요한|중요한|핵심인|문제인|관건인|답인|더\s+(?:심각한|뼈아픈))\s+것은\s+[^.!?。！？\n]{1,100}(?:이다|다|라는 점이다|데 있다)|(?:문제|핵심|관건|답)은\s+[^.!?。！？\n]{1,100}(?:이다|다|는 점이다|데 있다)")
+_SENTENCES = re.compile(r"[^.!?。！？\n]+[.!?。！？]?")
+
+
+def _strip_markdown(text: str) -> str:
+    kept = []
+    fenced = False
+    for line in re.split(r"\r?\n", text):
+        if re.match(r"^\s*~~~", line) or line.strip().startswith("```" ):
+            fenced = not fenced
+            continue
+        if fenced or re.match(r"^\s*>", line) or re.match(r"^\s{0,3}#{1,6}\s", line):
+            continue
+        if re.match(r"^\s*\|.*\|\s*$", line) or re.match(r"^\s*\|?\s*:?---{1,}", line):
+            continue
+        line = _INLINE_CODE.sub("", line)
+        line = re.sub(r"!?\[[^\]]*\]\([^)]*\)", "", line)
+        kept.append(line)
+    return "\n".join(kept)
+
+
+def _split_sentences(text: str) -> list[str]:
+    return [part.strip() for part in _SENTENCES.findall(text) if part.strip()]
+
+
+def _sentence_opener(sentence: str) -> str | None:
+    clean = re.sub(r"^\s*(?:[-*+]\s+|\d+[.)]\s+)", "", sentence).strip()
+    for word in _CONNECTIVE_OPENERS:
+        if re.match(rf"^{re.escape(word)}(?:[,，、:]|\s)", clean):
+            return word
+    return None
+
+
+def _count(text: str, pattern: re.Pattern) -> int:
+    return len(pattern.findall(text))
+
+
+def analyze_ko_text(input_text: str) -> dict:
+    prose = _strip_markdown(str(input_text or ""))
+    eojeol = len(re.findall(r"\S+", prose))
+    sentences = _split_sentences(prose)
+    conclusion_pivots = sum(prose.count(item) for item in _CONCLUSION)
+    clefts = _count(prose, _CLEFT)
+    paragraphs = [part.strip() for part in re.split(r"\n\s*\n", prose) if part.strip()]
+    opener_counts = [sum(_sentence_opener(sentence) is not None for sentence in _split_sentences(paragraph)) for paragraph in paragraphs]
+    connective_ending_count = _count(prose, _CONNECTIVE_ENDING)
+    connective_ending_comma_count = _count(prose, _CONNECTIVE_ENDING_COMMA)
+    comma_free_numbers = re.sub(r"(?<=\d),(?=\d)", "", prose)
+    comma_sentence_share = (
+        sum("," in re.sub(r"(?<=\d),(?=\d)", "", sentence) for sentence in sentences) / len(sentences)
+        if sentences else 0
+    )
+    lengths = [len(re.findall(r"\S+", sentence)) for sentence in sentences]
+    average_length = sum(lengths) / len(lengths) if lengths else 0
+    variance = sum((value - average_length) ** 2 for value in lengths) / len(lengths) if lengths else 0
+    ending_keys = [match.group(0).rstrip(".!?。！？") for sentence in sentences if (match := re.search(r"[가-힣]{1,2}[.!?。！？]?\Z", sentence))]
+    warnings = []
+    if conclusion_pivots >= THRESHOLDS["conclusionPivotMin"]:
+        warnings.append("ko-conclusion-pivot-cluster")
+    if eojeol >= THRESHOLDS["cleftMinEojeol"] and clefts >= THRESHOLDS["cleftMin"]:
+        warnings.append("ko-cleft-cluster")
+    if any(count >= THRESHOLDS["connectiveOpenersPerParagraph"] for count in opener_counts):
+        warnings.append("ko-paragraph-initial-connective-cluster")
+    comma_rate = connective_ending_comma_count / connective_ending_count if connective_ending_count else 0
+    if connective_ending_comma_count >= THRESHOLDS["connectiveEndingCommaMin"] and comma_rate >= THRESHOLDS["connectiveEndingCommaRate"]:
+        warnings.append("ko-connective-ending-comma-cluster")
+    return {
+        "version": 1,
+        "scope": "review-only; genre and sentence function still decide",
+        "metrics": {
+            "eojeol": eojeol,
+            "sentenceCount": len(sentences),
+            "conclusionPivotCount": conclusion_pivots,
+            "cleftCount": clefts,
+            "paragraphInitialConnectiveCounts": opener_counts,
+            "connectiveEndingCount": connective_ending_count,
+            "connectiveEndingCommaCount": connective_ending_comma_count,
+            "connectiveEndingCommaRate": round(comma_rate + 1e-12, 3),
+            "commaSentenceShare": round(comma_sentence_share + 1e-12, 3),
+            "sentenceLengthMeanEojeol": round(average_length + 1e-12, 2),
+            "sentenceLengthCv": round((variance ** 0.5 / average_length) + 1e-12, 3) if average_length else 0,
+            "endingVariety": round((len(set(ending_keys)) / len(ending_keys)) + 1e-12, 3) if ending_keys else 0,
+            "safeBalanceCount": sum(prose.count(item) for item in _SAFE_BALANCE),
+            "proseCommaCount": prose.count(",") if not comma_free_numbers else comma_free_numbers.count(","),
+        },
+        "warnings": warnings,
+    }

package/assets/lithermes-plugin/humanizer_office.py

@@ -0,0 +1,18 @@
+"""Public plugin-root adapter for the skill's bounded Office/PDF extractor."""
+
+from __future__ import annotations
+
+import importlib.util
+from pathlib import Path
+
+
+_SCRIPT = Path(__file__).resolve().parent / "skills" / "lit-humanizer" / "scripts" / "extract_office_text.py"
+_SPEC = importlib.util.spec_from_file_location("_lithermes_humanizer_office", _SCRIPT)
+if _SPEC is None or _SPEC.loader is None:
+    raise ImportError("LitHumanizer Office extractor is missing")
+_MODULE = importlib.util.module_from_spec(_SPEC)
+_SPEC.loader.exec_module(_MODULE)
+
+extract_text = _MODULE.extract_text
+extract_office_bytes = _MODULE.extract_office_bytes
+extract_pdf_bytes = _MODULE.extract_pdf_bytes

package/assets/lithermes-plugin/lit_mark.py

@@ -85,7 +85,7 @@ def render(rows, *, env=None, stream=None, json=False, mode=None) -> list[str]:
 def discipline(route: str) -> str:
     canonical = {"lit": "litwork", "litwork-loop": "lit-loop", "litwork-plan": "lit-plan",
                  "durable-workflow": "lit-loop", "kanban-team": "lit-team",
-                 "korean-prose-cleanup": "lit-korean"}.get(route, route)
+                 "korean-prose-cleanup": "lit-humanizer"}.get(route, route)
     if not re.fullmatch(r"[a-z0-9]+(?:-[a-z0-9]+)*", canonical):
         raise ValueError("invalid route discipline")
     return canonical