@litfamily/litopencode 1.0.7 → 1.0.10

package/dist/deliverable-hedge-guard.js

@@ -1,302 +1,261 @@
+import { spawn } from "node:child_process";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { mutatedFilePaths } from "./tool-guards.js";
-export const artifactGenres = [
-    "client_deliverable",
-    "internal_analysis",
-    "audit_report",
-    "working_note",
-    "no_artifact"
-];
-const limitationsByGenre = Object.freeze({
-    client_deliverable: "reply",
-    internal_analysis: "designated_section",
-    audit_report: "methodology_paragraph",
-    working_note: "inline",
-    no_artifact: "reply"
-});
-const defaultSkillsRoot = fileURLToPath(new URL("../skills", import.meta.url));
-const lazyOutputChannelSkills = new Set(["frontend-ui-ux", "visual-qa"]);
-const readerFacingExtensions = new Set([".adoc", ".html", ".md", ".mdx", ".rst", ".tex", ".txt"]);
-const maxArtifactBytes = 2 * 1024 * 1024;
-const maxTrackedSessions = 256;
-const maxHedgeFindings = 32;
-const maxReportedLines = 16;
-const maxAdditionalContextBytes = 512;
-const textKeysByTool = Object.freeze({
-    write: ["content"],
-    edit: ["newString", "new_string"]
-});
-const phrasePatterns = [
-    { className: "deferred", pattern: /보류\s*중|별도로\s*진행|추후\s*진행|to be determined separately/giu },
-    { className: "scope-limit", pattern: /한정됩니다|국한됩니다|범위\s*내에서만|limited to the provided evidence/giu },
-    { className: "negated-action", pattern: /하지\s*않았습니다|포함되지\s*않습니다|다루지\s*않습니다|was not performed|is not included/giu },
-    { className: "self-protection", pattern: /참고용|추가\s*검증이\s*필요|완전하지\s*않을\s*수\s*있|for reference only|may be incomplete/giu },
-    { className: "process-meta", pattern: /as an AI|이\s*작업에서는|프롬프트가/giu }
-];
-const evidenceSubject = /근거|자료|측정값|관찰\s*기록|데이터|증거|출처|참고문헌|평가\s*자료|검토\s*자료|시험\s*결과|검증\s*결과|수치|통계|evidence|data|measurement|observation|source|citation|test result/iu;
-const evaluativeSubject = /접근성|성능|효과|유효성|품질|평가|결과|점수|충족\s*여부|적합성|안전성|accessibility|performance|effect|validity|quality|score|compliance|safety/iu;
-const koreanAbsence = /없(?:어(?:서)?|습니다|음)|부족|부재|제공되지\s*않|주어지지\s*않|확인되지\s*않|검증되지\s*않/u;
-const koreanEpistemicInability = /(?:평가|판단|산정)할\s*수\s*없|알\s*수\s*없/u;
-const englishAbsence = /\b(?:no evidence yet|not yet substantiated|(?:evidence|data|measurements?|observations?|sources?|citations?|test results?) (?:is|are|was|were)?\s*(?:missing|absent|unavailable|insufficient|not (?:provided|available|verified|substantiated)))\b/iu;
-const englishEpistemicInability = /\b(?:cannot|can not|unable to)\s+(?:assess|determine|calculate|establish|substantiate|verify)\b/iu;
-function isArtifactGenre(value) {
-    return typeof value === "string" && artifactGenres.some((candidate) => candidate === value);
+const defaultTimeoutMs = 1500;
+const maxTextBytes = 4 * 1024 * 1024;
+const maxOutputBytes = 16 * 1024 * 1024;
+const maxPendingCalls = 512;
+const readerFacingExtensions = new Set([
+    ".adoc", ".csv", ".html", ".htm", ".md", ".mdx", ".org", ".rst", ".svg", ".tex", ".txt", ".tsv",
+    ".xhtml", ".xml", ".json", ".jsonc", ".yaml", ".yml"
+]);
+const officeExtensions = new Set([".docx", ".pptx", ".pdf"]);
+const packageSkillRoot = fileURLToPath(new URL("../skills/lit-humanizer", import.meta.url));
+const detectorWorker = path.join(packageSkillRoot, "scripts", "guard-scan.mjs");
+const officeExtractor = path.join(packageSkillRoot, "scripts", "extract_office_text.py");
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function outputChannelBlock(markdown) {
-    return markdown.match(/^## #contract\.output_channels\s*\n\s*```ya?ml\s*\n([\s\S]*?)\n```\s*$/mu)?.[1];
+function isMissing(error) {
+    return typeof error === "object" && error !== null && "code" in error &&
+        (error.code === "ENOENT" || error.code === "ENOTDIR");
 }
-function parseScalarBlock(block, source) {
-    const values = {};
-    for (const line of block.split("\n")) {
-        if (line.trim() === "")
-            continue;
-        const scalar = line.match(/^([a-z_]+):\s*([a-z_]+)\s*$/u);
-        if (scalar === null || values[scalar[1]] !== undefined) {
-            throw new Error(`OUTPUT_CHANNEL_INVALID source=${source}`);
-        }
-        values[scalar[1]] = scalar[2];
-    }
-    return values;
+function isInternalPath(candidate) {
+    const segments = path.normalize(candidate).split(/[\\/]+/u);
+    return segments.some((segment) => segment === "plans" || segment === "evidence" ||
+        segment.toLowerCase() === ".hermes" || segment.toLowerCase() === "ledgers" ||
+        segment.startsWith(".lit") || /^HANDOFF/iu.test(segment));
 }
-function parseOutputChannel(markdown, source) {
-    const block = outputChannelBlock(markdown);
-    if (block === undefined)
-        return undefined;
-    const parsed = parseScalarBlock(block, source);
-    const artifactGenre = parsed.artifact_genre;
-    const limitationsChannel = parsed.limitations_channel;
-    if (!isArtifactGenre(artifactGenre)) {
-        throw new Error(`OUTPUT_CHANNEL_GENRE_INVALID source=${source}`);
-    }
-    const expectedChannel = limitationsByGenre[artifactGenre];
-    if (expectedChannel !== limitationsChannel) {
-        throw new Error(`OUTPUT_CHANNEL_LIMITATIONS_MISMATCH source=${source}`);
-    }
-    return { artifactGenre, limitationsChannel: expectedChannel };
+function oneLine(value) {
+    const message = value instanceof Error ? value.message : String(value);
+    return message.replace(/[\r\n\t]+/gu, " ").replace(/\s{2,}/gu, " ").slice(0, 180) || "unknown error";
 }
-export async function readOutputChannelContract(skillId, root = defaultSkillsRoot) {
-    if (!/^[a-z][a-z0-9-]{0,63}$/u.test(skillId))
-        throw new Error(`OUTPUT_CHANNEL_SKILL_INVALID skill=${skillId}`);
-    const skillPath = path.join(root, skillId, "SKILL.md");
-    const direct = parseOutputChannel(await fs.readFile(skillPath, "utf8"), skillPath);
-    if (direct !== undefined)
-        return direct;
-    if (!lazyOutputChannelSkills.has(skillId))
-        throw new Error(`OUTPUT_CHANNEL_MISSING skill=${skillId}`);
-    const completeContractPath = path.join(root, skillId, "references", "complete-contract.md");
-    const referenced = parseOutputChannel(await fs.readFile(completeContractPath, "utf8"), completeContractPath);
-    if (referenced === undefined)
-        throw new Error(`OUTPUT_CHANNEL_MISSING skill=${skillId}`);
-    return referenced;
+function displayPath(file) {
+    return file.replace(/[\r\n\t]+/gu, " ").slice(0, 120);
 }
-function canonicalSkillId(routeId) {
-    const normalized = routeId.trim().replace(/^\//u, "").toLowerCase();
-    if (normalized.startsWith("autoresearch-"))
-        return "autoresearch";
-    if (normalized.startsWith("autoconference-"))
-        return "autoconference";
-    if (normalized.startsWith("wikify-"))
-        return "wikify";
-    const aliases = Object.freeze({
-        lit: "workflow-loop",
-        "lit-loop": "workflow-loop",
-        "lit-work": "litwork",
-        litgoal: "durable-litgoal",
-        "lit-goal": "durable-litgoal",
-        "lit-research": "litresearch",
-        "text-neutralization": "lit-korean"
-    });
-    return aliases[normalized] ?? normalized;
+function toolText(input) {
+    if (input.tool !== "write" && input.tool !== "edit")
+        return undefined;
+    if (!isRecord(input.args))
+        return undefined;
+    const paths = mutatedFilePaths(input.args);
+    const candidate = paths[0];
+    if (candidate === undefined || isInternalPath(candidate))
+        return undefined;
+    const extension = path.extname(candidate).toLowerCase();
+    if (!readerFacingExtensions.has(extension))
+        return undefined;
+    const args = input.args;
+    const keys = input.tool === "write" ? ["content"] : ["newString", "new_string"];
+    const values = keys.map((key) => args[key]).filter((value) => typeof value === "string");
+    if (values.length !== 1)
+        return { file: candidate, unavailable: "write text was not available in one supported field" };
+    if (Buffer.byteLength(values[0], "utf8") > maxTextBytes)
+        return { file: candidate, unavailable: "new text exceeds scan limit" };
+    return { file: candidate, value: values[0] };
 }
-export function createDeliverableHedgeSessionState(root = defaultSkillsRoot) {
-    const active = new Map();
-    return {
-        async activate(sessionID, routeId) {
-            const skillId = canonicalSkillId(routeId);
-            try {
-                if (!active.has(sessionID) && active.size >= maxTrackedSessions) {
-                    const oldest = active.keys().next().value;
-                    if (oldest !== undefined)
-                        active.delete(oldest);
-                }
-                active.set(sessionID, { skillId, contract: await readOutputChannelContract(skillId, root) });
+function runJsonProcess(command, args, input, timeoutMs) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, [...args], { shell: false, windowsHide: true, stdio: ["pipe", "pipe", "pipe"] });
+        const stdout = [];
+        const stderr = [];
+        let outputBytes = 0;
+        let settled = false;
+        let timedOut = false;
+        const finish = (error, value = "") => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            if (error)
+                reject(error);
+            else
+                resolve(value);
+        };
+        const timer = setTimeout(() => {
+            timedOut = true;
+            child.kill("SIGKILL");
+        }, timeoutMs);
+        child.stdout.on("data", (chunk) => {
+            outputBytes += chunk.length;
+            if (outputBytes > maxOutputBytes) {
+                child.kill("SIGKILL");
+                finish(new Error("output limit exceeded"));
+                return;
             }
-            catch {
-                active.delete(sessionID);
+            stdout.push(chunk);
+        });
+        child.stderr.on("data", (chunk) => {
+            if (stderr.reduce((sum, item) => sum + item.length, 0) < 64 * 1024)
+                stderr.push(chunk);
+        });
+        child.on("error", (error) => finish(error));
+        child.on("close", (code) => {
+            if (timedOut) {
+                finish(new Error(`timeout after ${timeoutMs}ms`));
+                return;
             }
-        },
-        clear(sessionID) {
-            active.delete(sessionID);
-        },
-        dispose() {
-            active.clear();
-        },
-        contractFor(sessionID) {
-            return active.get(sessionID);
-        }
-    };
-}
-function quotedRangeContains(line, index) {
-    for (const quote of ['"', "'"]) {
-        let start = line.indexOf(quote);
-        while (start !== -1) {
-            const end = line.indexOf(quote, start + 1);
-            if (end === -1)
-                break;
-            if (start < index && index < end)
-                return true;
-            start = line.indexOf(quote, end + 1);
-        }
-    }
-    return false;
-}
-function isStateScalarOrTable(line) {
-    const scalar = /^\s*["']?[A-Za-z_][\w.-]*["']?\s*:\s*["']?(?:pending|deferred|보류\s*중)["']?\s*[,}]?\s*$/iu;
-    return scalar.test(line) || (line.includes("|") && /(?:status|state|상태|pending|deferred|보류\s*중)/iu.test(line));
-}
-function isAbsentEvidence(line) {
-    if (englishAbsence.test(line))
-        return true;
-    if (englishEpistemicInability.test(line) && evidenceSubject.test(line))
-        return true;
-    const hasEvidenceSubject = evidenceSubject.test(line);
-    const hasEvaluativeSubject = evaluativeSubject.test(line);
-    if (hasEvidenceSubject && (koreanAbsence.test(line) || koreanEpistemicInability.test(line)))
-        return true;
-    return hasEvaluativeSubject && koreanEpistemicInability.test(line) && /(?:없|부족|부재|제공되지|주어지지|확인되지|검증되지)/u.test(line);
+            if (code !== 0) {
+                finish(new Error(Buffer.concat(stderr).toString("utf8").trim() || `process exited ${String(code)}`));
+                return;
+            }
+            finish(undefined, Buffer.concat(stdout).toString("utf8"));
+        });
+        child.stdin.on("error", (error) => finish(error));
+        child.stdin.end(input, "utf8");
+    });
 }
-function headingLevel(line) {
-    return line.match(/^(#{1,6})\s+/u)?.[1].length ?? 0;
+async function defaultScan(request, timeoutMs) {
+    const raw = await runJsonProcess(process.execPath, [detectorWorker], JSON.stringify(request), timeoutMs);
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed.findings))
+        throw new Error("detector returned an invalid response");
+    return parsed.findings;
 }
-function permittedLineMask(lines, genre) {
-    const permitted = lines.map(() => false);
-    if (genre === "working_note" || genre === "no_artifact")
-        return lines.map(() => true);
-    if (genre === "client_deliverable")
-        return permitted;
-    if (genre === "audit_report") {
-        const heading = lines.findIndex((line) => /^#{1,6}\s+.*(?:방법론|methodology)/iu.test(line));
-        if (heading === -1)
-            return permitted;
-        let began = false;
-        for (let index = heading + 1; index < lines.length; index += 1) {
-            if (/^#{1,6}\s+/u.test(lines[index]))
-                break;
-            if (lines[index].trim() === "") {
-                if (began)
-                    break;
-                continue;
-            }
-            began = true;
-            permitted[index] = true;
-        }
-        return permitted;
+async function existingText(projectRoot, file) {
+    const absolute = path.resolve(projectRoot, file);
+    try {
+        const stat = await fs.stat(absolute);
+        if (!stat.isFile())
+            throw new Error("existing target is not a regular file");
+        if (stat.size > maxTextBytes)
+            throw new Error("existing target exceeds scan limit");
+        return await fs.readFile(absolute, "utf8");
     }
-    const heading = lines.findIndex((line) => /^#{1,6}\s+.*(?:한계|limitations?)/iu.test(line));
-    if (heading === -1)
-        return permitted;
-    const level = headingLevel(lines[heading]);
-    for (let index = heading + 1; index < lines.length; index += 1) {
-        const nextLevel = headingLevel(lines[index]);
-        if (nextLevel !== 0 && nextLevel <= level)
-            break;
-        permitted[index] = true;
+    catch (error) {
+        if (isMissing(error))
+            return "";
+        throw error;
     }
-    return permitted;
 }
-export function inspectDeliverableHedges(text, genre) {
-    const lines = text.replaceAll("\r\n", "\n").split("\n");
-    const permitted = permittedLineMask(lines, genre);
-    const findings = [];
-    let fence;
-    for (let index = 0; index < lines.length; index += 1) {
-        const line = lines[index];
-        const fenceMatch = line.match(/^\s*(```|~~~)/u)?.[1];
-        if (fenceMatch !== undefined) {
-            fence = fence === undefined ? fenceMatch : fence === fenceMatch ? undefined : fence;
-            continue;
-        }
-        if (fence !== undefined || permitted[index])
-            continue;
-        if (isAbsentEvidence(line))
-            findings.push({ className: "absent-evidence", line: index + 1 });
-        if (findings.length >= maxHedgeFindings)
-            break;
-        for (const candidate of phrasePatterns) {
-            candidate.pattern.lastIndex = 0;
-            const match = candidate.pattern.exec(line);
-            if (match === null)
-                continue;
-            if (candidate.className === "deferred" && (quotedRangeContains(line, match.index) || isStateScalarOrTable(line)))
-                continue;
-            findings.push({ className: candidate.className, line: index + 1 });
-            if (findings.length >= maxHedgeFindings)
-                break;
-        }
-        if (findings.length >= maxHedgeFindings)
-            break;
+function applyEdit(oldText, oldString, newString, replaceAll) {
+    if (typeof oldString !== "string" || oldString.length === 0)
+        throw new Error("edit has no usable oldString");
+    const index = oldText.indexOf(oldString);
+    if (index < 0)
+        throw new Error("edit oldString was not found in the current file");
+    if (replaceAll === true)
+        return oldText.split(oldString).join(newString);
+    if (oldText.indexOf(oldString, index + oldString.length) >= 0) {
+        throw new Error("edit oldString is ambiguous; exact changed text was not verified");
     }
-    return findings;
+    return oldText.slice(0, index) + newString + oldText.slice(index + oldString.length);
 }
-function isPlainRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
+function remember(pending, callID, notice) {
+    if (pending.size >= maxPendingCalls)
+        pending.delete(pending.keys().next().value);
+    pending.set(callID, notice);
 }
-function isReaderFacingPath(candidate) {
-    return !candidate.includes("\0") && readerFacingExtensions.has(path.extname(candidate).toLowerCase());
+function addNotice(output, message, tier, findings = 0) {
+    output.output = output.output.trim() === "" ? message : `${output.output}\n\n${message}`;
+    output.metadata = {
+        ...output.metadata,
+        litopencodeHumanizerGuard: { tier, findings }
+    };
 }
-function toolInputText(input) {
-    if (!isPlainRecord(input.args))
-        return undefined;
-    const args = input.args;
-    const keys = textKeysByTool[input.tool];
-    if (keys === undefined)
-        return undefined;
-    const values = keys
-        .map((key) => args[key])
-        .filter((value) => typeof value === "string");
-    if (values.length !== 1)
-        return undefined;
-    const text = values[0];
-    if (Buffer.byteLength(text, "utf8") > maxArtifactBytes)
-        return undefined;
-    const paths = mutatedFilePaths(args);
-    return paths.some(isReaderFacingPath) ? text : undefined;
+async function extractText(file, timeoutMs) {
+    const extension = path.extname(file).toLowerCase();
+    if (extension === ".docx" || extension === ".pptx") {
+        return runJsonProcess("python3", [officeExtractor, file], "", timeoutMs);
+    }
+    return runJsonProcess("pdftotext", ["-layout", file, "-"], "", timeoutMs);
 }
-function boundedUtf8(text, maxBytes) {
-    if (Buffer.byteLength(text, "utf8") <= maxBytes)
-        return text;
-    let end = Math.min(text.length, maxBytes);
-    while (end > 0 && Buffer.byteLength(text.slice(0, end), "utf8") > maxBytes)
-        end -= 1;
-    return text.slice(0, end);
+function findOfficePaths(value, depth = 0) {
+    if (depth > 5 || value === null || value === undefined)
+        return [];
+    if (typeof value === "string") {
+        const matches = value.match(/(?:^|[\s"'`=])((?:[A-Za-z]:)?(?:[\\/\w.@+-]+[\\/])?[\w.@+-]+\.(?:docx|pptx|pdf))(?=$|[\s"'`,;])/giu) ?? [];
+        return matches.map((match) => match.trim().replace(/^[\s"'`=]+|["'`,;]+$/gu, ""));
+    }
+    if (Array.isArray(value))
+        return value.slice(0, 100).flatMap((item) => findOfficePaths(item, depth + 1));
+    if (!isRecord(value))
+        return [];
+    return Object.values(value).slice(0, 100).flatMap((item) => findOfficePaths(item, depth + 1));
 }
-function modelVisibleContext(skillId, contract, findings) {
-    const uniqueLines = [...new Set(findings.map((finding) => finding.line))];
-    const reported = uniqueLines.slice(0, maxReportedLines);
-    const omitted = uniqueLines.length - reported.length;
-    const lines = `${reported.join(",")}${omitted > 0 ? `,+${omitted}` : ""}`;
-    return boundedUtf8(`DELIVERABLE_HEDGE_VIOLATION skill=${skillId} genre=${contract.artifactGenre} findings=${findings.length} lines=${lines}. Revise the artifact so limitations use ${contract.limitationsChannel}.`, maxAdditionalContextBytes);
+function officeCandidates(input) {
+    const paths = [...mutatedFilePaths(input.args), ...findOfficePaths(input.args)];
+    return [...new Set(paths.filter((file) => officeExtensions.has(path.extname(file).toLowerCase()) && !isInternalPath(file)))].slice(0, 8);
 }
-export async function applyDeliverableHedgeAfterHook(state, input, output) {
-    const active = state.contractFor(input.sessionID);
-    if (active === undefined)
-        return;
-    const text = toolInputText(input);
-    if (text === undefined)
-        return;
-    const findings = inspectDeliverableHedges(text, active.contract.artifactGenre);
-    if (findings.length === 0)
-        return;
-    const context = modelVisibleContext(active.skillId, active.contract, findings);
-    output.output = output.output.trim().length === 0 ? context : `${output.output}\n\n${context}`;
-    output.metadata = {
-        ...output.metadata,
-        litopencodeDeliverableHedgeGuard: {
-            skillId: active.skillId,
-            artifactGenre: active.contract.artifactGenre,
-            findings: findings.length
+export function createDeliverableHedgeGuard(options) {
+    const projectRoot = path.resolve(options.projectRoot);
+    const timeoutMs = options.timeoutMs ?? defaultTimeoutMs;
+    const scan = options.scan ?? ((request) => defaultScan(request, timeoutMs));
+    const pending = new Map();
+    return {
+        async before(input) {
+            const text = toolText(input);
+            if (text === undefined)
+                return;
+            pending.delete(input.callID);
+            if (text.unavailable !== undefined) {
+                remember(pending, input.callID, {
+                    tier: "unavailable",
+                    message: `LIT_HUMANIZER_GUARD_UNAVAILABLE: ${text.unavailable}; write allowed without this check.`
+                });
+                return;
+            }
+            try {
+                const oldText = await existingText(projectRoot, text.file);
+                const newText = input.tool === "write"
+                    ? text.value ?? ""
+                    : applyEdit(oldText, input.args.oldString ?? input.args.old_string, text.value ?? "", input.args.replaceAll);
+                if (Buffer.byteLength(newText, "utf8") > maxTextBytes)
+                    throw new Error("new text exceeds scan limit");
+                const findings = await scan({ file: text.file, oldText, newText });
+                const block = findings.filter((finding) => finding.severity === "block");
+                if (block.length > 0) {
+                    const first = block[0];
+                    throw new Error(`LIT_HUMANIZER_BLOCKED rule=${first.rule} line=${first.line} path=${displayPath(text.file)}. Revise the new text before saving.`);
+                }
+                if (findings.length > 0) {
+                    remember(pending, input.callID, {
+                        tier: "warn",
+                        message: `LIT_HUMANIZER_WARN findings=${findings.length} path=${displayPath(text.file)}. Review the new wording; keep any accurate, useful warning.`
+                    });
+                }
+            }
+            catch (error) {
+                if (error instanceof Error && error.message.startsWith("LIT_HUMANIZER_BLOCKED"))
+                    throw error;
+                remember(pending, input.callID, {
+                    tier: "unavailable",
+                    message: `LIT_HUMANIZER_GUARD_UNAVAILABLE: ${oneLine(error)}; write allowed without this check.`
+                });
+            }
+        },
+        async after(input, output) {
+            const notice = pending.get(input.callID);
+            pending.delete(input.callID);
+            if (notice !== undefined)
+                addNotice(output, notice.message, notice.tier);
+            for (const candidate of officeCandidates(input)) {
+                const file = path.resolve(projectRoot, candidate);
+                try {
+                    const stat = await fs.stat(file);
+                    if (!stat.isFile() || stat.size > maxTextBytes)
+                        throw new Error("artifact is not a bounded regular file");
+                    const text = await extractText(file, timeoutMs);
+                    const findings = await scan({ file: candidate, oldText: "", newText: text });
+                    if (findings.length === 0)
+                        continue;
+                    const blocks = findings.filter((finding) => finding.severity === "block");
+                    const tier = blocks.length > 0 ? "block" : "warn";
+                    const message = `LIT_HUMANIZER_OFFICE_${tier.toUpperCase()}_HIT findings=${findings.length} path=${displayPath(candidate)}. Fix the source and rebuild the document before presenting it.`;
+                    addNotice(output, message, tier, findings.length);
+                }
+                catch (error) {
+                    const message = path.extname(candidate).toLowerCase() === ".pdf" && oneLine(error).includes("ENOENT")
+                        ? "LIT_HUMANIZER_PDF_EXTRACTION_UNAVAILABLE: pdftotext is not installed; PDF text was not scanned."
+                        : `LIT_HUMANIZER_GUARD_UNAVAILABLE: ${oneLine(error)}; artifact text was not checked.`;
+                    addNotice(output, message, "unavailable");
+                }
+            }
+        },
+        dispose() {
+            pending.clear();
         }
     };
 }

package/dist/features.d.ts

@@ -1,5 +1,5 @@
 export type LitOpenCodeBindingKind = "agent" | "cli" | "command" | "config" | "hook" | "tool";
-export type LitOpenCodeFeatureId = "planning-start-work-loop" | "lit-litwork-activation" | "start-work" | "review-work" | "litresearch" | "durable-ledger" | "bounded-authority-lifecycle" | "agent-roster" | "lit-plan" | "reference-benchmark-claims" | "native-goal-verdict" | "doctor-install" | "search-workflow-ideas" | "lit-fetch" | "guardrails" | "lit-init" | "lit-crucible" | "refactor" | "lit-burnoff" | "lit-burnoff-file" | "comment-checker" | "lit-code" | "debugging" | "lit-commit" | "lsp" | "lsp-setup" | "rules" | "deep-interview" | "structural-search" | "browser-drive" | "lit-korean" | "lit-recap" | "lit-comprehend" | "lit-handoff" | "lit-scientific-visualization" | "readme-studio" | "frontend-ui-ux" | "visual-qa" | "autoresearch" | "autoconference" | "wikify";
+export type LitOpenCodeFeatureId = "planning-start-work-loop" | "lit-litwork-activation" | "start-work" | "review-work" | "litresearch" | "durable-ledger" | "bounded-authority-lifecycle" | "agent-roster" | "lit-plan" | "reference-benchmark-claims" | "native-goal-verdict" | "doctor-install" | "search-workflow-ideas" | "lit-fetch" | "guardrails" | "lit-init" | "lit-crucible" | "refactor" | "lit-burnoff" | "lit-burnoff-file" | "comment-checker" | "lit-code" | "debugging" | "lit-commit" | "lsp" | "lsp-setup" | "rules" | "deep-interview" | "structural-search" | "browser-drive" | "lit-humanizer" | "lit-recap" | "lit-comprehend" | "lit-handoff" | "lit-scientific-visualization" | "lit-diagram-drawer" | "lit-pptx" | "lit-typographic-motion" | "lit-docx" | "readme-studio" | "frontend-ui-ux" | "visual-qa" | "autoresearch" | "autoconference" | "wikify";
 export type LitOpenCodeFeatureBinding = {
     readonly kind: LitOpenCodeBindingKind;
     readonly id: string;
@@ -704,7 +704,7 @@ export declare const litOpenCodeFeatures: readonly ({
     })[];
     verification: string[];
 } | {
-    id: "lit-korean";
+    id: "lit-humanizer";
     title: string;
     summary: string;
     bindings: ({
@@ -803,6 +803,85 @@ export declare const litOpenCodeFeatures: readonly ({
         description: string;
     })[];
     verification: string[];
+} | {
+    id: "lit-diagram-drawer";
+    title: string;
+    summary: string;
+    bindings: ({
+        kind: "config";
+        id: string;
+        surface: string;
+        description: string;
+    } | {
+        kind: "cli";
+        id: string;
+        surface: string;
+        description: string;
+    })[];
+    verification: string[];
+} | {
+    id: "lit-typographic-motion";
+    title: string;
+    summary: string;
+    bindings: ({
+        kind: "config";
+        id: string;
+        surface: string;
+        description: string;
+    } | {
+        kind: "hook";
+        id: string;
+        surface: string;
+        description: string;
+    } | {
+        kind: "cli";
+        id: string;
+        surface: string;
+        description: string;
+    })[];
+    verification: string[];
+} | {
+    id: "lit-pptx";
+    title: string;
+    summary: string;
+    bindings: ({
+        kind: "config";
+        id: string;
+        surface: string;
+        description: string;
+    } | {
+        kind: "hook";
+        id: string;
+        surface: string;
+        description: string;
+    } | {
+        kind: "cli";
+        id: string;
+        surface: string;
+        description: string;
+    })[];
+    verification: string[];
+} | {
+    id: "lit-docx";
+    title: string;
+    summary: string;
+    bindings: ({
+        kind: "config";
+        id: string;
+        surface: string;
+        description: string;
+    } | {
+        kind: "hook";
+        id: string;
+        surface: string;
+        description: string;
+    } | {
+        kind: "cli";
+        id: string;
+        surface: string;
+        description: string;
+    })[];
+    verification: string[];
 } | {
     id: "readme-studio";
     title: string;