@litfamily/litopencode 1.0.7 → 1.0.9

package/skills/lit-humanizer/scripts/core.mjs

@@ -0,0 +1,208 @@
+import path from 'node:path';
+
+const VALID_LANGS = new Set(['ko', 'en', 'code']);
+const VALID_SEVERITIES = new Set(['block', 'warn']);
+const VALID_SCOPES = new Set(['line', 'sentence', 'document']);
+
+export function parseRules(raw) {
+  const data = JSON.parse(raw);
+  if (data.schema_version !== 1 || !Array.isArray(data.rules)) {
+    throw new Error('rules.json must use schema_version 1 and contain a rules array');
+  }
+  const ids = new Set();
+  return data.rules.map((rule) => {
+    if (typeof rule.id !== 'string' || ids.has(rule.id)) throw new Error(`missing or duplicate rule id: ${rule.id}`);
+    ids.add(rule.id);
+    if (!VALID_LANGS.has(rule.lang) || !VALID_SEVERITIES.has(rule.severity) || !VALID_SCOPES.has(rule.scope)) {
+      throw new Error(`invalid lang, severity, or scope for ${rule.id}`);
+    }
+    if (typeof rule.pattern !== 'string' || typeof rule.flags !== 'string' || !Array.isArray(rule.context) || !Array.isArray(rule.fixture_ids)) {
+      throw new Error(`incomplete rule definition: ${rule.id}`);
+    }
+    return { ...rule, regex: new RegExp(rule.pattern, rule.flags) };
+  });
+}
+
+function isInternalPath(file) {
+  const segments = path.normalize(file).split(/[\\/]+/);
+  const plansAt = segments.indexOf('plans');
+  if (plansAt >= 0 && segments[plansAt + 1] === 'lit-humanizer-canonical') return false;
+  return segments.some((segment) => segment === 'plans' || segment === 'evidence' ||
+    segment.startsWith('.lit') || segment.toLowerCase() === '.hermes' ||
+    /^HANDOFF/i.test(segment) || segment.toLowerCase() === 'ledgers');
+}
+
+function isCaption(line) {
+  return /^\s*(?:>\s*)?(?:!\[)?(?:표\s*\d+|그림\s*\d+|table\s+\d+|figure\s+\d+)\b/i.test(line);
+}
+
+function isPlainSourceLine(line) {
+  return /^\s*(?:Source|Sources|출처|자료|※\s*자료)\s*[:：]/i.test(line) &&
+    !/^\s*(?:\*\*|__|<b\b)/i.test(line);
+}
+
+function hasEmbeddedCaveat(line) {
+  const body = line.replace(/^\s*(?:Source|Sources|출처|자료|※\s*자료)\s*[:：]\s*/i, '');
+  const segments = body.split(/[,;:—–]/).map((segment) => segment.trim().replace(/[.!?。]+$/, ''));
+  const tail = segments.at(-1) ?? '';
+  const caveatPhrase = /\b(?:not\s+(?:realized\s+results?|verified|independently verified|performed|a permit decision|final|actual)|demo(?:nstration)?\s+(?:synthesis|assumptions|recommendations?)|(?:preliminary|provisional|tentative|draft|estimated?)\s+(?:results?|data|findings?|outcomes?|values?)|results?\s+may\s+(?:change|be revised)|subject\s+to\s+change)\b|미실현|실현되지|미검증|검증되지|미확인|(?:잠정|예비|추정|예상)(?:치)?(?:\s*(?:결과|자료|수치|값))?|변동\s*가능|변경\s*가능|확정되지|미확정/i;
+  const standaloneStatus = /^(?:assumptions?|recommendations?|unverified|preliminary|provisional|tentative|draft|estimated?|estimate|forecast|projection|projected|planned|simulated|modeled|가정|권고|제안|잠정(?:치)?|예비|추정(?:치)?|예상)$/i;
+  const appendedWithoutDelimiter = /(?:^|\s)(?:not\s+(?:realized\s+results?|verified|independently verified|performed|a permit decision|final|actual)|demo(?:nstration)?\s+(?:synthesis|assumptions|recommendations?)|(?:preliminary|provisional|tentative|draft|estimated?)\s+(?:results?|data|findings?|outcomes?|values?)|results?\s+may\s+(?:change|be revised)|subject\s+to\s+change|unverified|미실현|실현되지|미검증|검증되지|미확인|잠정(?:치)?|예비(?:자료|결과|수치)?|추정(?:치|자료|결과)?|예상(?:치|자료|결과)?|변동\s*가능|변경\s*가능|확정되지|미확정)\s*[.!?。)]*$/i;
+  return caveatPhrase.test(tail) || standaloneStatus.test(tail) || appendedWithoutDelimiter.test(body);
+}
+
+function inlineCodeAsSpaces(line) {
+  return line.replace(/(`+)[^`]*?\1/g, (match) => ' '.repeat(match.length));
+}
+
+function matchesLanguage(rule, text) {
+  if (rule.lang === 'ko') return /[가-힣]/.test(text);
+  if (rule.lang === 'en') return /[a-z]/i.test(text);
+  return true;
+}
+
+function sourceRows(text) {
+  let fence = null;
+  let captionPending = 0;
+  let figureActive = false;
+  return text.split(/\r?\n/).map((line, index) => {
+    const marker = line.match(/^ {0,3}(`{3,}|~{3,})/);
+    if (fence) {
+      if (marker && marker[1][0] === fence.char && marker[1].length >= fence.length) fence = null;
+      captionPending = 0;
+      figureActive = false;
+      return { line, number: index + 1, candidate: '', skipped: true, caption: false, captionAttribution: false };
+    }
+    if (marker) {
+      captionPending = 0;
+      fence = { char: marker[1][0], length: marker[1].length };
+      figureActive = false;
+      return { line, number: index + 1, candidate: '', skipped: true, caption: false, captionAttribution: false };
+    }
+    if (/^\s{0,3}>\s?/.test(line)) {
+      captionPending = 0;
+      figureActive = false;
+      return { line, number: index + 1, candidate: '', skipped: true, caption: false, captionAttribution: false };
+    }
+    const candidate = inlineCodeAsSpaces(line);
+    const caption = isCaption(line);
+    const plainSource = isPlainSourceLine(line);
+    const sourceAnchor = /^\s*\|/.test(line) || /^\s*!\[[^\]]*\]\s*\(/.test(line) ||
+      /^\s*<img\b/i.test(line) || caption;
+    const opensFigure = /<figure\b/i.test(line);
+    const closesFigure = /<\/figure\s*>/i.test(line);
+    if (opensFigure) figureActive = true;
+    const captionAttribution = !hasEmbeddedCaveat(line) && plainSource &&
+      (captionPending > 0 || figureActive);
+    if (sourceAnchor || closesFigure) captionPending = 2;
+    else if (plainSource) captionPending = 0;
+    else if (line.trim() && captionPending > 0) captionPending = 0;
+    else if (captionPending > 0 && !line.trim()) captionPending -= 1;
+    if (closesFigure) figureActive = false;
+    return { line, number: index + 1, candidate, caption, captionAttribution, skipped: false };
+  });
+}
+
+function joinRows(rows, separator) {
+  let text = '';
+  const lineStarts = [];
+  rows.forEach((row, index) => {
+    if (index > 0) text += separator;
+    lineStarts.push({ offset: text.length, line: row.number });
+    text += row.candidate;
+  });
+  return { text, lineStarts };
+}
+
+function lineAtOffset(span, offset) {
+  if (span.line !== undefined) return span.line;
+  let low = 0;
+  let high = span.lineStarts.length - 1;
+  while (low <= high) {
+    const mid = (low + high) >> 1;
+    if (span.lineStarts[mid].offset <= offset) low = mid + 1;
+    else high = mid - 1;
+  }
+  return span.lineStarts[Math.max(0, high)]?.line ?? 1;
+}
+
+function sliceSpan(span, start, end) {
+  const lineStarts = span.lineStarts
+    .filter((entry) => entry.offset >= start && entry.offset < end)
+    .map((entry) => ({ offset: entry.offset - start, line: entry.line }));
+  if (!lineStarts.length) lineStarts.push({ offset: 0, line: lineAtOffset(span, start) });
+  else if (lineStarts[0].offset > 0) lineStarts.unshift({ offset: 0, line: lineAtOffset(span, start) });
+  return { text: span.text.slice(start, end), lineStarts };
+}
+
+function splitSentences(span) {
+  const segments = [];
+  const boundary = /[.!?。！？]+(?:["'”’»)\]]*)\s+/gu;
+  let start = 0;
+  for (const match of span.text.matchAll(boundary)) {
+    const end = match.index + match[0].length - match[0].match(/\s+$/u)[0].length;
+    if (end > start) segments.push(sliceSpan(span, start, end));
+    start = match.index + match[0].length;
+  }
+  if (start < span.text.length) segments.push(sliceSpan(span, start, span.text.length));
+  return segments;
+}
+
+function ruleSegments(rows, rule, cache) {
+  const cacheKey = `${rule.scope}/${rule.context.includes('table_figure_caption')}`;
+  if (cache.has(cacheKey)) return cache.get(cacheKey);
+  const skipCaptions = rule.context.includes('table_figure_caption');
+  const segments = [];
+  let group = [];
+  const flush = () => {
+    if (!group.length) return;
+    const joined = joinRows(group, rule.scope === 'sentence' ? ' ' : '\n');
+    segments.push(...(rule.scope === 'sentence' ? splitSentences(joined) : [joined]));
+    group = [];
+  };
+
+  for (const row of rows) {
+    const captionExempt = skipCaptions && (row.caption || row.captionAttribution);
+    if (row.skipped || captionExempt || (rule.scope === 'sentence' && !row.candidate.trim())) {
+      flush();
+      continue;
+    }
+    if (rule.scope === 'line') {
+      segments.push({ text: row.candidate, line: row.number });
+    } else {
+      group.push(row);
+    }
+  }
+  flush();
+  cache.set(cacheKey, segments);
+  return segments;
+}
+
+export function scanText(text, rules, file = '<stdin>') {
+  if (isInternalPath(file)) return [];
+  const findings = [];
+  const rows = sourceRows(text);
+  const segmentCache = new Map();
+  for (const rule of rules) {
+    for (const segment of ruleSegments(rows, rule, segmentCache)) {
+      if (!matchesLanguage(rule, segment.text)) continue;
+      rule.regex.lastIndex = 0;
+      const match = rule.regex.exec(segment.text);
+      if (!match) continue;
+      findings.push({
+        file,
+        rule: rule.id,
+        severity: rule.severity,
+        line: lineAtOffset(segment, match.index),
+        excerpt: segment.text.trim().replace(/\s+/g, ' ').slice(0, 180),
+      });
+    }
+  }
+  return findings;
+}
+
+export function exitCode(findings) {
+  if (findings.some((finding) => finding.severity === 'block')) return 2;
+  if (findings.some((finding) => finding.severity === 'warn')) return 1;
+  return 0;
+}

package/skills/lit-humanizer/scripts/detect.mjs

@@ -0,0 +1,91 @@
+#!/usr/bin/env node
+import { spawnSync } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import { dirname, extname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { exitCode, parseRules, scanText } from './core.mjs';
+
+const here = dirname(fileURLToPath(import.meta.url));
+const usage = 'Usage: node scripts/detect.mjs [--json] [--rules FILE] [--path LABEL] [FILE ...] (use - or omit FILE to read stdin)';
+
+function contentFor(file) {
+  if (file === '-') return readFileSync(0, 'utf8');
+  if (['.docx', '.pptx'].includes(extname(file).toLowerCase())) {
+    const extractor = resolve(here, 'extract_office_text.py');
+    const result = spawnSync('python3', [extractor, file], { encoding: 'utf8', timeout: 1500, maxBuffer: 16 * 1024 * 1024 });
+    if (result.error) throw result.error;
+    if (result.status !== 0) throw new Error(result.stderr.trim() || `Office text extraction failed (${result.status})`);
+    return result.stdout;
+  }
+  if (extname(file).toLowerCase() === '.pdf') {
+    const result = spawnSync('pdftotext', ['-layout', file, '-'], { encoding: 'utf8', timeout: 1500, maxBuffer: 16 * 1024 * 1024 });
+    if (result.error) throw result.error;
+    if (result.status !== 0) throw new Error(result.stderr.trim() || `PDF text extraction failed (${result.status})`);
+    return result.stdout;
+  }
+  return readFileSync(file, 'utf8');
+}
+
+function main() {
+  const args = process.argv.slice(2);
+  const json = args.includes('--json');
+  if (args.includes('--help')) {
+    process.stdout.write(`${usage}\n`);
+    return 0;
+  }
+  let rulesPath = resolve(here, '../rules.json');
+  let stdinLabel = '<stdin>';
+  const files = [];
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === '--json') continue;
+    if (arg === '--rules') {
+      index += 1;
+      if (!args[index]) throw new Error('--rules requires a path');
+      rulesPath = resolve(args[index]);
+      continue;
+    }
+    if (arg === '--path') {
+      index += 1;
+      if (!args[index]) throw new Error('--path requires a label');
+      stdinLabel = args[index];
+      continue;
+    }
+    if (arg.startsWith('--')) throw new Error(`unknown option: ${arg}`);
+    files.push(arg);
+  }
+  if (files.length === 0) files.push('-');
+  const rules = parseRules(readFileSync(rulesPath, 'utf8'));
+  const findings = [];
+  const errors = [];
+  const scanned = [];
+  for (const file of files) {
+    try {
+      const label = file === '-' ? stdinLabel : file;
+      const hits = scanText(contentFor(file), rules, label);
+      findings.push(...hits);
+      scanned.push(file);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      errors.push({ file, message });
+    }
+  }
+  const block = findings.filter((item) => item.severity === 'block').length;
+  const warn = findings.filter((item) => item.severity === 'warn').length;
+  if (json) {
+    process.stdout.write(`${JSON.stringify({ scanned, summary: { block, warn }, findings, errors }, null, 2)}\n`);
+  } else {
+    for (const item of findings) process.stdout.write(`${item.file}:${item.line}: ${item.severity} ${item.rule}: ${item.excerpt}\n`);
+    for (const item of errors) process.stderr.write(`${item.file}: error: ${item.message}\n`);
+    process.stdout.write(`Scanned ${scanned.length} file(s): ${block} block, ${warn} warning hit(s).\n`);
+  }
+  return errors.length ? 2 : exitCode(findings);
+}
+
+try {
+  process.exitCode = main();
+} catch (error) {
+  const message = error instanceof Error ? error.message : String(error);
+  process.stderr.write(`${usage}\n${message}\n`);
+  process.exitCode = 2;
+}

package/skills/lit-humanizer/scripts/extract_office_text.py

@@ -0,0 +1,89 @@
+#!/usr/bin/env -S uv run --script
+# /// script
+# requires-python = ">=3.11"
+# dependencies = []
+# ///
+
+# ─── How to run ───
+# 1. Install uv (if not installed):
+#      curl -LsSf https://astral.sh/uv/install.sh | sh
+# 2. Run directly (no venv, no pip install needed):
+#      uv run extract_office_text.py FILE.docx|FILE.pptx
+# 3. Or make executable and run:
+#      chmod +x extract_office_text.py && ./extract_office_text.py FILE.docx
+# ──────────────────
+
+from __future__ import annotations
+
+import re
+import sys
+import zipfile
+from pathlib import Path
+from xml.etree.ElementTree import Element, ParseError, fromstring
+
+WORD_NS = "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}"
+DRAWING_NS = "{http://schemas.openxmlformats.org/drawingml/2006/main}"
+MAX_XML_BYTES = 32 * 1024 * 1024
+MAX_PACKAGE_XML_BYTES = 128 * 1024 * 1024
+
+
+def paragraph_text(element: Element, text_tag: str, tab_tag: str, break_tag: str) -> str:
+    """Return visible text for one Word or DrawingML paragraph."""
+    pieces: list[str] = []
+    for node in element.iter():
+        if node.tag == text_tag and node.text:
+            pieces.append(node.text)
+        elif node.tag == tab_tag:
+            pieces.append("\t")
+        elif node.tag == break_tag:
+            pieces.append(" ")
+    return "".join(pieces).strip()
+
+
+def xml_text(archive: zipfile.ZipFile, member: str, namespace: str) -> list[str]:
+    """Read bounded XML and collect paragraph text in document order."""
+    info = archive.getinfo(member)
+    if info.file_size > MAX_XML_BYTES:
+        raise ValueError(f"refusing oversized Office XML member: {member}")
+    root = fromstring(archive.read(member))
+    return [
+        value
+        for paragraph in root.iter(f"{namespace}p")
+        if (value := paragraph_text(paragraph, f"{namespace}t", f"{namespace}tab", f"{namespace}br"))
+    ]
+
+
+def extract_document(path: Path) -> list[str]:
+    """Extract paragraph text from a DOCX or PPTX package using stdlib ZIP/XML."""
+    with zipfile.ZipFile(path) as archive:
+        members = archive.namelist()
+        total_xml = sum(info.file_size for info in archive.infolist() if info.filename.endswith(".xml"))
+        if total_xml > MAX_PACKAGE_XML_BYTES:
+            raise ValueError("refusing Office package with oversized aggregate XML")
+        if path.suffix.lower() == ".docx":
+            return xml_text(archive, "word/document.xml", WORD_NS)
+        if path.suffix.lower() == ".pptx":
+            slide_names = [name for name in members if re.fullmatch(r"ppt/slides/slide\d+\.xml", name)]
+            slide_names.sort(key=lambda name: int(re.search(r"slide(\d+)", name).group(1)))
+            return [line for name in slide_names for line in xml_text(archive, name, DRAWING_NS)]
+    raise ValueError("expected a .docx or .pptx file")
+
+
+def main() -> int:
+    if len(sys.argv) != 2:
+        print("Usage: uv run extract_office_text.py FILE.docx|FILE.pptx", file=sys.stderr)
+        return 2
+    path = Path(sys.argv[1])
+    try:
+        text = extract_document(path)
+    except (OSError, zipfile.BadZipFile, KeyError, ParseError, ValueError) as error:
+        print(f"Office text extraction failed: {error}", file=sys.stderr)
+        return 2
+    sys.stdout.write("\n".join(text))
+    if text:
+        sys.stdout.write("\n")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/skills/lit-humanizer/scripts/guard-scan.mjs

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { parseRules, scanText } from "./core.mjs";
+
+const here = dirname(fileURLToPath(import.meta.url));
+const maxInputBytes = 8 * 1024 * 1024;
+
+try {
+  const input = readFileSync(0);
+  if (input.length > maxInputBytes) throw new Error("guard input limit exceeded");
+  const request = JSON.parse(input.toString("utf8"));
+  if (typeof request.file !== "string" || typeof request.oldText !== "string" || typeof request.newText !== "string") {
+    throw new Error("guard input must contain file, oldText, and newText strings");
+  }
+  const rules = parseRules(readFileSync(join(here, "../rules.json"), "utf8"));
+  const oldFindings = scanText(request.oldText, rules, request.file);
+  const remaining = new Map();
+  for (const finding of oldFindings) {
+    const key = JSON.stringify([finding.rule, finding.severity, finding.excerpt]);
+    remaining.set(key, (remaining.get(key) ?? 0) + 1);
+  }
+  const findings = scanText(request.newText, rules, request.file).filter((finding) => {
+    const key = JSON.stringify([finding.rule, finding.severity, finding.excerpt]);
+    const count = remaining.get(key) ?? 0;
+    if (count === 0) return true;
+    if (count === 1) remaining.delete(key);
+    else remaining.set(key, count - 1);
+    return false;
+  });
+  process.stdout.write(`${JSON.stringify({ findings })}\n`);
+} catch (error) {
+  process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+  process.exitCode = 2;
+}

package/skills/lit-humanizer/scripts/ko-metrics.mjs

@@ -0,0 +1,124 @@
+#!/usr/bin/env node
+// Genre-sensitive Korean prose signals. These are review prompts, never
+// authorship scores or automatic rewrite instructions.
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+export const thresholds = Object.freeze({
+  conclusionPivotMin: 4,
+  cleftMin: 2,
+  cleftMinEojeol: 40,
+  connectiveOpenersPerParagraph: 3,
+  connectiveEndingCommaMin: 3,
+  connectiveEndingCommaRate: 0.5
+});
+
+const conclusionLexicon = ['결론적으로', '따라서', '이를 통해', '그러므로'];
+const connectiveOpeners = ['또한', '따라서', '즉', '나아가', '아울러', '게다가', '더욱이', '그러므로', '반면', '그러나', '하지만'];
+const safeBalanceLexicon = ['양쪽 모두', '두 가지 모두', '장점도 있지만', '신중하게', '균형'];
+const connectiveEnding = /(?:고|며|지만|면서|아서|어서)(?=[\s,\.!?。！？]|$)/g;
+const connectiveEndingComma = /(?:고|며|지만|면서|아서|어서)\s*,/g;
+const inlineCodePattern = new RegExp(String.fromCharCode(96) + '[^' + String.fromCharCode(96) + ']*' + String.fromCharCode(96), 'g');
+const backtickFence = String.fromCharCode(96).repeat(3);
+
+function stripMarkdown(text) {
+  const kept = [];
+  let fenced = false;
+  for (const line of text.split(/\r?\n/)) {
+    if (/^\s*~~~/.test(line) || line.trim().startsWith(backtickFence)) {
+      fenced = !fenced;
+      continue;
+    }
+    if (fenced || /^\s*>/.test(line) || /^\s{0,3}#{1,6}\s/.test(line)) continue;
+    if (/^\s*\|.*\|\s*$/.test(line) || /^\s*\|?\s*:?-{3,}/.test(line)) continue;
+    kept.push(line.replace(inlineCodePattern, '').replace(/!\[[^\]]*\]\([^)]*\)/g, '').replace(/\[[^\]]+\]\([^)]*\)/g, ''));
+  }
+  return kept.join('\n');
+}
+
+function splitSentences(text) {
+  return (text.match(/[^.!?。！？\n]+[.!?。！？]?/g) || [])
+    .map((part) => part.trim())
+    .filter(Boolean);
+}
+
+function sentenceOpeners(text) {
+  const clean = text.replace(/^\s*(?:[-*+]|\d+[.)])\s+/, '').trim();
+  for (const word of connectiveOpeners) {
+    if (new RegExp('^' + word + '(?:[,，、:]|\\s)').test(clean)) return word;
+  }
+  return null;
+}
+
+function countOccurrences(text, pattern) {
+  return [...text.matchAll(pattern)].length;
+}
+
+export function analyzeKoText(input) {
+  const prose = stripMarkdown(input);
+  const eojeol = (prose.match(/\S+/g) || []).length;
+  const sentences = splitSentences(prose);
+  const conclusionPivots = conclusionLexicon.reduce((sum, item) => sum + prose.split(item).length - 1, 0);
+  const cleftPattern = /(?:필요한|중요한|핵심인|문제인|관건인|답인|더\s+(?:심각한|뼈아픈))\s+것은\s+[^.!?。！？\n]{1,100}(?:이다|다|라는 점이다|데 있다)|(?:문제|핵심|관건|답)은\s+[^.!?。！？\n]{1,100}(?:이다|다|는 점이다|데 있다)/g;
+  const clefts = countOccurrences(prose, cleftPattern);
+  const paragraphs = prose.split(/\n\s*\n/).map((p) => p.trim()).filter(Boolean);
+  const openerCounts = paragraphs.map((paragraph) => splitSentences(paragraph).filter(sentenceOpeners).length);
+  const connectiveEndingCount = countOccurrences(prose, new RegExp(connectiveEnding.source, 'g'));
+  const connectiveEndingCommaCount = countOccurrences(prose, new RegExp(connectiveEndingComma.source, 'g'));
+  const commaFreeNumbers = prose.replace(/(?<=\d),(?=\d)/g, '');
+  const commaSentenceShare = sentences.length
+    ? sentences.filter((sentence) => /,/.test(sentence.replace(/(?<=\d),(?=\d)/g, ''))).length / sentences.length
+    : 0;
+  const lengths = sentences.map((sentence) => (sentence.match(/\S+/g) || []).length);
+  const averageLength = lengths.length ? lengths.reduce((a, b) => a + b, 0) / lengths.length : 0;
+  const variance = lengths.length ? lengths.reduce((sum, value) => sum + (value - averageLength) ** 2, 0) / lengths.length : 0;
+  const endingKeys = sentences.map((sentence) => sentence.match(/[가-힣]{1,2}[.!?。！？]?$/)?.[0]?.replace(/[.!?。！？]/g, '')).filter(Boolean);
+  const warnings = [];
+
+  if (conclusionPivots >= thresholds.conclusionPivotMin) warnings.push('ko-conclusion-pivot-cluster');
+  if (eojeol >= thresholds.cleftMinEojeol && clefts >= thresholds.cleftMin) warnings.push('ko-cleft-cluster');
+  if (openerCounts.some((count) => count >= thresholds.connectiveOpenersPerParagraph)) warnings.push('ko-paragraph-initial-connective-cluster');
+  const commaRate = connectiveEndingCount ? connectiveEndingCommaCount / connectiveEndingCount : 0;
+  if (connectiveEndingCommaCount >= thresholds.connectiveEndingCommaMin && commaRate >= thresholds.connectiveEndingCommaRate) warnings.push('ko-connective-ending-comma-cluster');
+
+  return {
+    version: 1,
+    scope: 'review-only; genre and sentence function still decide',
+    metrics: {
+      eojeol,
+      sentenceCount: sentences.length,
+      conclusionPivotCount: conclusionPivots,
+      cleftCount: clefts,
+      paragraphInitialConnectiveCounts: openerCounts,
+      connectiveEndingCount,
+      connectiveEndingCommaCount,
+      connectiveEndingCommaRate: Number(commaRate.toFixed(3)),
+      commaSentenceShare: Number(commaSentenceShare.toFixed(3)),
+      sentenceLengthMeanEojeol: Number(averageLength.toFixed(2)),
+      sentenceLengthCv: averageLength ? Number((Math.sqrt(variance) / averageLength).toFixed(3)) : 0,
+      endingVariety: endingKeys.length ? Number((new Set(endingKeys).size / endingKeys.length).toFixed(3)) : 0,
+      safeBalanceCount: safeBalanceLexicon.reduce((sum, item) => sum + prose.split(item).length - 1, 0),
+      proseCommaCount: countOccurrences(commaFreeNumbers, /,/g)
+    },
+    warnings
+  };
+}
+
+function main() {
+  const args = process.argv.slice(2);
+  const json = args.includes('--json');
+  const files = args.filter((arg) => arg !== '--json');
+  const input = files.length
+    ? files.map((file) => fs.readFileSync(file, 'utf8')).join('\n\n')
+    : fs.readFileSync(0, 'utf8');
+  const result = analyzeKoText(input);
+  if (json) process.stdout.write(JSON.stringify(result, null, 2) + '\n');
+  else {
+    process.stdout.write('Korean prose signals (review only)\n');
+    process.stdout.write(JSON.stringify(result.metrics, null, 2) + '\n');
+    process.stdout.write('Warnings: ' + (result.warnings.join(', ') || 'none') + '\n');
+  }
+}
+
+if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) main();

package/skills/lit-humanizer/scripts/test-fixtures.mjs

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { parseRules, scanText } from "./core.mjs";
+
+const root = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+const rules = parseRules(readFileSync(resolve(root, "rules.json"), "utf8"));
+const cases = JSON.parse(readFileSync(resolve(root, "fixtures/rule-cases.json"), "utf8"));
+const counts = { positive: 0, negative: 0, tier: 0, caption: 0 };
+
+for (const rule of rules) {
+  assert(cases.positive[rule.id], `missing positive case: ${rule.id}`);
+  assert(cases.negative[rule.id], `missing clean negative case: ${rule.id}`);
+  assert(scanText(cases.positive[rule.id], [rule], `${rule.id}-positive.txt`).length > 0, `${rule.id} missed its positive case`);
+  assert.equal(scanText(cases.negative[rule.id], [rule], `${rule.id}-negative.txt`).length, 0, `${rule.id} hit its clean negative case`);
+  counts.positive += 1;
+  counts.negative += 1;
+}
+
+const metaRules = rules.filter((rule) => ["ko-plain-meta-label", "en-plain-meta-label"].includes(rule.id));
+for (const fixture of cases.contextCases.plainSourceAttached) {
+  const findings = scanText(fixture.text, metaRules, `caption-${fixture.name}.md`);
+  if (fixture.clean) assert.equal(findings.length, 0, `${fixture.name} should be exempt`);
+  else assert(findings.length > 0, `${fixture.name} should remain detectable`);
+  counts.caption += 1;
+}
+
+for (const fixture of cases.contextCases.tierRegressions) {
+  const rule = rules.find((candidate) => candidate.id === fixture.rule);
+  assert(rule, `${fixture.name} references missing rule ${fixture.rule}`);
+  const findings = scanText(fixture.text, [rule], `tier-${fixture.name}.txt`);
+  if (fixture.expect === "clean") assert.equal(findings.length, 0, `${fixture.name} should remain clean`);
+  else assert(findings.some((finding) => finding.severity === fixture.expect), `${fixture.name} should ${fixture.expect}`);
+  counts.tier += 1;
+}
+
+const realLines = readFileSync(resolve(root, "fixtures/pos-real.txt"), "utf8").split(/\r?\n/u).filter(Boolean);
+assert.equal(realLines.length, 26, "the real-line fixture set must remain complete");
+const recalled = realLines.filter((line) => scanText(line, rules, "fixtures/pos-real.txt").length > 0).length;
+assert(recalled >= 19, `detector recall fell below 19/26: ${recalled}/26`);
+
+const officeExtractor = resolve(root, "scripts/extract_office_text.py");
+for (const [name, expected] of [["minimal.docx", "I hope this helps."], ["minimal.pptx", "Source: report table 4."]]) {
+  const file = resolve(root, "fixtures/office", name);
+  const extracted = spawnSync("python3", [officeExtractor, file], { encoding: "utf8", timeout: 1500, maxBuffer: 2 * 1024 * 1024 });
+  assert.equal(extracted.status, 0, `${name} extraction failed: ${extracted.stderr}`);
+  assert(extracted.stdout.includes(expected), `${name} did not yield expected text`);
+}
+
+process.stdout.write(`Detector fixtures passed: ${rules.length} block/warn rules, ${counts.positive} positive, ${counts.negative} clean negative, ${counts.tier} tier regressions, ${counts.caption} caption/context cases, ${recalled}/26 real lines recalled.\n`);
+process.stdout.write("DOCX and PPTX standard-library extraction fixtures passed; no human-prose corpus is packaged.\n");

package/skills/lit-humanizer/scripts/test-ko-metrics.mjs

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { analyzeKoText, thresholds } from './ko-metrics.mjs';
+
+const here = path.dirname(fileURLToPath(import.meta.url));
+const fixturePath = path.join(here, '..', 'fixtures', 'ko-metrics-golden.json');
+const fixture = JSON.parse(fs.readFileSync(fixturePath, 'utf8'));
+
+for (const item of fixture.cases) {
+  const result = analyzeKoText(item.text);
+  if (item.warning) assert.ok(result.warnings.includes(item.warning), item.id + ': expected ' + item.warning);
+  if (item.absent) assert.ok(!result.warnings.includes(item.absent), item.id + ': unexpected ' + item.absent);
+  for (const [key, minimum] of Object.entries(item.minimum || {})) {
+    if (Array.isArray(minimum)) assert.deepEqual(result.metrics[key], minimum, item.id + ': ' + key);
+    else assert.ok(result.metrics[key] >= minimum, item.id + ': ' + key + ' below ' + minimum);
+  }
+  process.stdout.write('PASS ' + item.id + ' warnings=' + (result.warnings.join(',') || 'none') + '\n');
+}
+
+assert.equal(thresholds.conclusionPivotMin, 4);
+assert.equal(thresholds.cleftMin, 2);
+assert.equal(thresholds.connectiveOpenersPerParagraph, 3);
+assert.equal(thresholds.connectiveEndingCommaMin, 3);
+process.stdout.write('PASS thresholds; ' + fixture.cases.length + ' golden cases\n');