@litfamily/litclaude 1.0.10 → 1.0.13

package/plugins/litclaude/skills/lit-humanizer/scripts/artifact-text.mjs

@@ -0,0 +1,38 @@
+import { spawnSync } from "node:child_process";
+import { dirname, extname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const here = dirname(fileURLToPath(import.meta.url));
+const MAX_INPUT_BYTES = 8 * 1024 * 1024;
+const MAX_OUTPUT_BYTES = 4 * 1024 * 1024;
+const extractionTimeoutMs = 2500;
+const textExtensions = new Set([".adoc", ".csv", ".htm", ".html", ".markdown", ".md", ".rst", ".svg", ".tex", ".tsv", ".txt", ".xml"]);
+
+const runExtractor = (command, args, input, label) => {
+  const result = spawnSync(command, args, {
+    input,
+    encoding: "utf8",
+    timeout: extractionTimeoutMs,
+    maxBuffer: MAX_OUTPUT_BYTES,
+    windowsHide: true,
+  });
+  if (result.error?.code === "ETIMEDOUT") throw new Error(`${label} extraction timed out`);
+  if (result.error?.code === "ENOENT") throw new Error(`${label} extractor is unavailable`);
+  if (result.error) throw new Error(`${label} extraction failed`);
+  if (result.status !== 0) throw new Error(`${label} extraction failed`);
+  return result.stdout;
+};
+
+export function extractArtifactText(extension, bytes) {
+  const normalized = typeof extension === "string" && extension.startsWith(".")
+    ? extension.toLowerCase()
+    : extname(String(extension)).toLowerCase();
+  if (!Buffer.isBuffer(bytes)) throw new TypeError("artifact bytes must be a Buffer");
+  if (bytes.length > MAX_INPUT_BYTES) throw new Error("artifact exceeds the bounded extraction size");
+  if (textExtensions.has(normalized)) return bytes.toString("utf8");
+  if (normalized === ".docx" || normalized === ".pptx") {
+    return runExtractor("python3", [resolve(here, "extract_office_text.py"), "--stdin", normalized], bytes, "Office document");
+  }
+  if (normalized === ".pdf") return runExtractor("pdftotext", ["-layout", "-", "-"], bytes, "PDF");
+  throw new Error(`unsupported document format: ${normalized || "unknown"}`);
+}

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

@@ -0,0 +1,207 @@
+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 === '.hermes' || /^HANDOFF/i.test(segment) || segment === '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/plugins/litclaude/skills/lit-humanizer/scripts/detect.mjs

@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+import { readFileSync } from "node:fs";
+import { dirname, extname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { extractArtifactText } from "./artifact-text.mjs";
+import { exitCode, parseRules, scanText } from "./core.mjs";
+
+const here = dirname(fileURLToPath(import.meta.url));
+const usage = "Usage: node scripts/detect.mjs [--json] [--rules FILE] [FILE ...] (use - or omit FILE to read stdin)";
+
+const contentFor = (file) => file === "-"
+  ? readFileSync(0, "utf8")
+  : extractArtifactText(extname(file), readFileSync(file));
+
+const 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");
+  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]);
+    } else if (arg.startsWith("--")) throw new Error(`unknown option: ${arg}`);
+    else 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 {
+      findings.push(...scanText(contentFor(file), rules, file));
+      scanned.push(file);
+    } catch (error) {
+      errors.push({ file, message: error instanceof Error ? error.message : String(error) });
+    }
+  }
+  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) {
+  process.stderr.write(`${usage}\n${error instanceof Error ? error.message : String(error)}\n`);
+  process.exitCode = 2;
+}

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

@@ -0,0 +1,112 @@
+#!/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 io import BytesIO
+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_archive(archive: zipfile.ZipFile, suffix: str) -> list[str]:
+    """Extract paragraph text from a DOCX or PPTX package using stdlib ZIP/XML."""
+    with 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 suffix.lower() == ".docx":
+            return xml_text(archive, "word/document.xml", WORD_NS)
+        if 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 extract_document(path: Path) -> list[str]:
+    return extract_archive(zipfile.ZipFile(path), path.suffix)
+
+
+def extract_document_bytes(data: bytes, suffix: str) -> list[str]:
+    return extract_archive(zipfile.ZipFile(BytesIO(data)), suffix)
+
+
+def main() -> int:
+    stdin_mode = len(sys.argv) == 3 and sys.argv[1] == "--stdin"
+    if stdin_mode:
+        suffix = sys.argv[2].lower()
+        if suffix not in {".docx", ".pptx"}:
+            print("Expected .docx or .pptx", file=sys.stderr)
+            return 2
+    elif len(sys.argv) == 2:
+        path = Path(sys.argv[1])
+        suffix = path.suffix
+    else:
+        print("Usage: python3 extract_office_text.py FILE.docx|FILE.pptx", file=sys.stderr)
+        return 2
+    try:
+        if stdin_mode:
+            data = sys.stdin.buffer.read(MAX_PACKAGE_XML_BYTES + 1)
+            if len(data) > MAX_PACKAGE_XML_BYTES:
+                raise ValueError("refusing oversized Office package")
+            text = extract_document_bytes(data, suffix)
+        else:
+            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/plugins/litclaude/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/plugins/litclaude/skills/lit-humanizer/scripts/scan-input.mjs

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+import { readFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { parseRules, scanText } from "./core.mjs";
+
+const here = dirname(fileURLToPath(import.meta.url));
+const MAX_INPUT_BYTES = 2 * 1024 * 1024;
+
+try {
+  const raw = readFileSync(0);
+  if (raw.length > MAX_INPUT_BYTES) throw new Error("input exceeds the bounded scan size");
+  const request = JSON.parse(raw.toString("utf8"));
+  if (!Array.isArray(request.artifacts) || request.artifacts.length > 16) throw new Error("invalid artifact list");
+  let totalBytes = 0;
+  const rules = parseRules(readFileSync(resolve(here, "../rules.json"), "utf8"));
+  const findings = [];
+  for (const artifact of request.artifacts) {
+    if (typeof artifact?.text !== "string" || typeof artifact?.path !== "string") throw new Error("invalid artifact record");
+    totalBytes += Buffer.byteLength(artifact.text, "utf8");
+    if (totalBytes > MAX_INPUT_BYTES) throw new Error("aggregate content exceeds the bounded scan size");
+    findings.push(...scanText(artifact.text, rules, artifact.path));
+  }
+  process.stdout.write(`${JSON.stringify({ findings })}\n`);
+} catch {
+  process.stderr.write("lit-humanizer scanner failed\n");
+  process.exitCode = 1;
+}

package/plugins/litclaude/skills/lit-loop/SKILL.md

@@ -99,6 +99,27 @@ success criteria before editing. Keep decisions, evidence, cleanup receipts,
 and remaining work in a durable notepad, plan, or ledger when the task spans
 multiple steps.
 
+## Finite-task fast lane
+
+When the user supplies an isolated workspace, concrete deliverables, and a
+finite acceptance contract, keep the loop proportional to that boundary:
+
+1. Write a short checklist from the requested outputs, behaviors, counts, and
+   hard constraints. Do not add criteria the user did not request.
+2. Reuse the supplied workspace. Create a goal, new worktree, persistent ledger,
+   broad plan, or subagent team only when the task crosses sessions, has
+   unresolved decisions, or materially benefits from that added state.
+3. For each defect being fixed, add one focused regression assertion. When the
+   original workspace can be tested safely, prove the assertion fails before
+   the fix and passes afterward.
+4. Check the contract at the boundary as well as the internal result: success
+   and error status codes, response shape, invalid and boundary inputs, and
+   concurrent behavior when the requested feature depends on them. Existing
+   visible tests do not establish untested boundary behavior.
+5. Run the requested checks again after the last behavior change, inspect every
+   named deliverable, and remove only temporary files created by this run. Do
+   not claim completion while a requested check or outcome remains unverified.
+
 This is a durable, evidence-driven execution loop. tests are necessary but not
 sufficient: every done claim needs the matching real Claude Code/package/user
 surface artifact, not just a green suite.
@@ -222,7 +243,15 @@ For each criterion:
 5. SURFACE: run the manual QA scenario through the chosen channel.
    When the criterion materially changes a browser, image, or terminal
    interface and `visual-qa` is available, use its finite tier, immutable
-   evidence, and blocker contract for this step.
+   evidence, and blocker contract for this step. When it creates or changes a
+   user-facing web interface, hand that part to `frontend-ui-ux`: its
+   direction and inventory shape the build, and its interface probe (run
+   from that skill's own directory across the full responsive matrix) is this
+   step's evidence. A HIGH finding the probe still
+   reports keeps the criterion FAIL until it is fixed or stated as a limitation
+   with its reason; `visual-qa` keeps the acceptance verdict. The Stop hook
+   holds a lit turn that edited interface files without a clean probe run
+   after the last edit. A CLI, library or backend-only criterion runs no probe.
 6. REVIEW: run the reviewer gate or request a review when the change is broad,
    risky, security-sensitive, or release-facing.
 7. CLEAN: tear down every spawned resource and record the cleanup receipt.

package/plugins/litclaude/skills/lit-plan/SKILL.md

@@ -344,7 +344,10 @@ Use this shape:
 5. Execution order; add waves or a dependency matrix only when multiple items
    can run independently or have non-obvious prerequisites.
 6. TODOs with Action, Output, Verification, and relevant failure/decision
-   branches; add a QA scenario when the task has a user-visible surface.
+   branches; add a QA scenario when the task has a user-visible surface. A task
+   that builds or changes a user-facing web interface names `frontend-ui-ux` in
+   its Verification: the interface probe across the responsive matrix, with no
+   HIGH finding left.
 7. TDD loop per task: `PIN -> RED -> GREEN -> VERIFY -> SURFACE -> REVIEW ->
    CLEAN -> RECORD`.
 8. Verification commands.