@litfamily/litcodex 1.0.0

package/marketplace/plugins/litcodex/components/rules/dist/deliverable-hedge-guard.js

@@ -0,0 +1,434 @@
+import { readFileSync } from "node:fs";
+import { extname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { formatAdditionalContextOutput } from "./hook-output.js";
+import { readCurrentTurnHookContext } from "./transcript-search.js";
+export const artifactGenres = [
+    "client_deliverable",
+    "internal_analysis",
+    "audit_report",
+    "working_note",
+    "no_artifact",
+];
+const defaultSkillRoot = fileURLToPath(new URL("../../../skills", import.meta.url));
+const proseExtensions = new Set([".adoc", ".html", ".md", ".mdx", ".rst", ".tex", ".txt"]);
+const writerTools = new Set([
+    "apply_patch",
+    "write",
+    "edit",
+    "multi_edit",
+    "multiedit",
+    "mcp__filesystem__write_file",
+    "mcp__filesystem__edit_file",
+]);
+export const deliverableRuntimeLimits = Object.freeze({
+    maxPathCandidates: 64,
+    maxAggregateContentBytes: 4 * 1024 * 1024,
+    maxFindings: 256,
+    maxOutputBytes: 2048,
+});
+const expectedChannel = Object.freeze({
+    client_deliverable: "reply",
+    internal_analysis: "designated_section",
+    audit_report: "methodology_paragraph",
+    working_note: "inline",
+    no_artifact: "reply",
+});
+const referenceContractSkills = new Set(["frontend-ui-ux", "visual-qa"]);
+const evidenceNouns = /근거|자료|측정값|관찰\s*기록|데이터|증거|출처|참고문헌|평가\s*자료|검토\s*자료|시험\s*결과|검증\s*결과|수치|통계|evidence|data|measurement|observation|source|citation|test result/iu;
+const evaluationNouns = /접근성|성능|효과|유효성|품질|평가|결과|점수|충족\s*여부|적합성|안전성|accessibility|performance|effect|validity|quality|score|compliance|safety/iu;
+const missingEvidenceForm = /없(?:어(?:서)?|습니다|음)|부족|부재|제공되지\s*않|주어지지\s*않|확인되지\s*않|검증되지\s*않/u;
+const cannotConcludeForm = /(?:평가|판단|산정)할\s*수\s*없|알\s*수\s*없/u;
+const englishEvidenceGap = /\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 englishCannotConclude = /\b(?:cannot|can not|unable to)\s+(?:assess|determine|calculate|establish|substantiate|verify)\b/iu;
+const directPatterns = [
+    ["deferred", /보류\s*중|별도로\s*진행|추후\s*진행|to be determined separately/iu],
+    ["scope-limit", /한정됩니다|국한됩니다|범위\s*내에서만|limited to the provided evidence/iu],
+    ["negated-action", /하지\s*않았습니다|포함되지\s*않습니다|다루지\s*않습니다|was not performed|is not included/iu],
+    ["self-protection", /참고용|추가\s*검증이\s*필요|완전하지\s*않을\s*수\s*있|for reference only|may be incomplete/iu],
+    ["process-meta", /as an AI|이\s*작업에서는|프롬프트가/iu],
+];
+export function readOutputChannelContract(skillId, skillRoot = defaultSkillRoot) {
+    if (!/^[a-z][a-z0-9-]{0,63}$/u.test(skillId))
+        throw new Error(`OUTPUT_CHANNEL_SKILL_INVALID skill=${skillId}`);
+    const skillPath = resolve(skillRoot, skillId, "SKILL.md");
+    const skillText = readFileSync(skillPath, "utf8");
+    const activationYaml = skillText.match(/^## #contract\.activation\s*\n\s*```yaml\s*\n([\s\S]*?)\n```\s*$/mu)?.[1];
+    const nested = activationYaml === undefined ? undefined : nestedChannel(activationYaml, skillPath);
+    if (nested !== undefined)
+        return nested;
+    if (!referenceContractSkills.has(skillId))
+        throw new Error(`OUTPUT_CHANNEL_MISSING skill=${skillId}`);
+    const completePath = resolve(skillRoot, skillId, "references", "complete-contract.md");
+    const completeText = readFileSync(completePath, "utf8");
+    const standalone = completeText.match(/^## #contract\.output_channels\s*\n\s*```yaml\s*\n([\s\S]*?)\n```\s*$/mu)?.[1];
+    if (standalone === undefined)
+        throw new Error(`OUTPUT_CHANNEL_MISSING skill=${skillId}`);
+    return channelFromPairs(standalone, completePath, "");
+}
+function nestedChannel(yaml, source) {
+    const marker = yaml.match(/^output_channels:\s*$/mu);
+    if (marker?.index === undefined)
+        return undefined;
+    return channelFromPairs(yaml.slice(marker.index + marker[0].length), source, "  ");
+}
+function channelFromPairs(text, source, indentation) {
+    const genre = text.match(new RegExp(`^${indentation}artifact_genre:\\s*([a-z_]+)\\s*$`, "mu"))?.[1];
+    const channel = text.match(new RegExp(`^${indentation}limitations_channel:\\s*([a-z_]+)\\s*$`, "mu"))?.[1];
+    if (!isArtifactGenre(genre))
+        throw new Error(`OUTPUT_CHANNEL_GENRE_INVALID source=${source}`);
+    const required = expectedChannel[genre];
+    if (channel !== required)
+        throw new Error(`OUTPUT_CHANNEL_LIMITATIONS_MISMATCH source=${source}`);
+    return { artifactGenre: genre, limitationsChannel: required };
+}
+function isArtifactGenre(value) {
+    return typeof value === "string" && artifactGenres.some((candidate) => candidate === value);
+}
+function activeSkillFromTranscript(transcriptPath, turnId) {
+    if (transcriptPath === null)
+        return undefined;
+    const trustedText = readCurrentTurnHookContext(transcriptPath, turnId);
+    if (trustedText === null)
+        return undefined;
+    const marker = /<litcodex-skill-body name="([a-z][a-z0-9-]{0,63})">/gu;
+    let latest;
+    for (const match of trustedText.matchAll(marker))
+        latest = match[1];
+    return latest;
+}
+function isAuthorEvidenceGap(line) {
+    if (englishEvidenceGap.test(line))
+        return true;
+    if (englishCannotConclude.test(line) && (evidenceNouns.test(line) || evaluationNouns.test(line)))
+        return true;
+    if (evidenceNouns.test(line) && (missingEvidenceForm.test(line) || cannotConcludeForm.test(line)))
+        return true;
+    return evaluationNouns.test(line) && cannotConcludeForm.test(line) && missingEvidenceForm.test(line);
+}
+function insideQuotedText(line, at) {
+    for (const quote of ['"', "'"]) {
+        let open = line.indexOf(quote);
+        while (open >= 0) {
+            const close = line.indexOf(quote, open + 1);
+            if (close < 0)
+                break;
+            if (open < at && at < close)
+                return true;
+            open = line.indexOf(quote, close + 1);
+        }
+    }
+    return false;
+}
+function isStatusEncoding(line) {
+    if (/^\s*["']?[A-Za-z_][\w.-]*["']?\s*:\s*["']?(?:pending|deferred|보류\s*중)["']?\s*[,}]?\s*$/iu.test(line)) {
+        return true;
+    }
+    return line.includes("|") && /status|state|상태|pending|deferred|보류\s*중/iu.test(line);
+}
+function headingDepth(line) {
+    return line.match(/^(#{1,6})\s+/u)?.[1]?.length ?? 0;
+}
+function allowedLimitationLines(lines, genre) {
+    const allowed = lines.map(() => false);
+    if (genre === "working_note" || genre === "no_artifact")
+        return lines.map(() => true);
+    if (genre === "client_deliverable")
+        return allowed;
+    if (genre === "audit_report") {
+        const methodology = lines.findIndex((line) => /^#{1,6}\s+.*(?:방법론|methodology)/iu.test(line));
+        if (methodology < 0)
+            return allowed;
+        let paragraphStarted = false;
+        for (let index = methodology + 1; index < lines.length; index += 1) {
+            const line = lines[index];
+            if (line === undefined || headingDepth(line) > 0)
+                break;
+            if (line.trim() === "") {
+                if (paragraphStarted)
+                    break;
+                continue;
+            }
+            paragraphStarted = true;
+            allowed[index] = true;
+        }
+        return allowed;
+    }
+    const limitations = lines.findIndex((line) => /^#{1,6}\s+.*(?:한계|limitations?)/iu.test(line));
+    if (limitations < 0)
+        return allowed;
+    const limitationsHeading = lines[limitations];
+    if (limitationsHeading === undefined)
+        return allowed;
+    const boundaryDepth = headingDepth(limitationsHeading);
+    for (let index = limitations + 1; index < lines.length; index += 1) {
+        const line = lines[index];
+        if (line === undefined)
+            break;
+        const depth = headingDepth(line);
+        if (depth > 0 && depth <= boundaryDepth)
+            break;
+        allowed[index] = true;
+    }
+    return allowed;
+}
+export function inspectDeliverableHedges(text, genre, maxFindings = Number.MAX_SAFE_INTEGER) {
+    if (!Number.isSafeInteger(maxFindings) || maxFindings < 1)
+        return [];
+    const lines = text.replace(/\r\n?/g, "\n").split("\n");
+    const allowed = allowedLimitationLines(lines, genre);
+    const findings = [];
+    let fence;
+    for (const [offset, line] of lines.entries()) {
+        const boundary = line.match(/^\s*(```|~~~)/u)?.[1];
+        if (boundary !== undefined) {
+            fence = fence === undefined ? boundary : fence === boundary ? undefined : fence;
+            continue;
+        }
+        if (fence !== undefined || allowed[offset])
+            continue;
+        if (isAuthorEvidenceGap(line)) {
+            findings.push({ category: "absent-evidence", line: offset + 1 });
+            if (findings.length >= maxFindings)
+                return findings;
+        }
+        for (const [category, pattern] of directPatterns) {
+            const match = pattern.exec(line);
+            if (match === null)
+                continue;
+            if (category === "deferred" && (insideQuotedText(line, match.index) || isStatusEncoding(line)))
+                continue;
+            findings.push({ category, line: offset + 1 });
+            if (findings.length >= maxFindings)
+                return findings;
+        }
+    }
+    return findings;
+}
+export function extractBoundedPendingArtifactWrites(input) {
+    // Artifact paths are identifiers only. Runtime inspection is restricted to content carried by
+    // the trusted PostToolUse event because named-path opens cannot prove ancestor identity under ABA.
+    if (!writerTools.has(input.tool_name.toLowerCase()))
+        return { ok: false, reason: "unsupported" };
+    if (isFailedToolResponse(input.tool_response) || !isRecord(input.tool_input)) {
+        return { ok: false, reason: "unsupported" };
+    }
+    const collector = new PendingWriteCollector(input.cwd);
+    collector.preflightDeclaredPaths(input.tool_input);
+    if (collector.failed !== undefined)
+        return { ok: false, reason: collector.failed };
+    const toolName = input.tool_name.toLowerCase();
+    if (toolName === "apply_patch") {
+        const patch = firstString(input.tool_input, ["command", "patch", "input"]);
+        if (patch === undefined)
+            return { ok: false, reason: "unsupported" };
+        collector.addPatch(patch);
+    }
+    else if (toolName === "write" || toolName === "mcp__filesystem__write_file") {
+        collector.addDirect(input.tool_input, undefined, ["content"]);
+    }
+    else {
+        collector.addDirect(input.tool_input, undefined, ["new_string", "newString", "new_text", "newText"]);
+        for (const key of ["edits", "files", "changes"]) {
+            const records = input.tool_input[key];
+            if (!Array.isArray(records))
+                continue;
+            for (const item of records) {
+                if (isRecord(item)) {
+                    collector.addDirect(item, firstString(input.tool_input, pathKeys), [
+                        "new_string",
+                        "newString",
+                        "new_text",
+                        "newText",
+                        "after",
+                        "content",
+                    ]);
+                }
+            }
+        }
+    }
+    if (collector.failed !== undefined)
+        return { ok: false, reason: collector.failed };
+    const writes = collector.writes();
+    return writes.length === 0 ? { ok: false, reason: "unsupported" } : { ok: true, writes };
+}
+export function runDeliverableHedgePostToolUse(input, options = {}) {
+    if (!writerTools.has(input.tool_name.toLowerCase()))
+        return "";
+    const extracted = extractBoundedPendingArtifactWrites(input);
+    if (!extracted.ok)
+        return "";
+    const skillId = activeSkillFromTranscript(input.transcript_path, input.turn_id);
+    if (skillId === undefined)
+        return "";
+    let contract;
+    try {
+        contract = readOutputChannelContract(skillId);
+    }
+    catch {
+        return "";
+    }
+    const inspect = options.inspect ?? inspectDeliverableHedges;
+    const findings = [];
+    let findingsTruncated = false;
+    for (const write of extracted.writes) {
+        const remaining = deliverableRuntimeLimits.maxFindings - findings.length;
+        const next = inspect(write.content, contract.artifactGenre, remaining + 1);
+        if (next.length > remaining) {
+            findings.push(...next.slice(0, remaining));
+            findingsTruncated = true;
+            break;
+        }
+        findings.push(...next);
+    }
+    if (findings.length === 0)
+        return "";
+    const findingCount = findingsTruncated ? `>=${deliverableRuntimeLimits.maxFindings}` : String(findings.length);
+    const output = formatAdditionalContextOutput("PostToolUse", `DELIVERABLE_HEDGE_VIOLATION skill=${skillId} genre=${contract.artifactGenre} findings=${findingCount} files=${extracted.writes.length}. Revise the pending write content and place limitations in ${contract.limitationsChannel}.`);
+    return Buffer.byteLength(output, "utf8") <= deliverableRuntimeLimits.maxOutputBytes ? output : "";
+}
+const pathKeys = ["path", "filePath", "file_path", "target", "targetPath", "target_path"];
+const pathArrayKeys = ["paths", "filePaths", "file_paths"];
+class PendingWriteCollector {
+    #cwd;
+    #contentByPath = new Map();
+    #declaredPaths = new Set();
+    #pathCandidates = 0;
+    #aggregateBytes = 0;
+    constructor(cwd) {
+        this.#cwd = cwd;
+    }
+    preflightDeclaredPaths(input) {
+        this.registerRecordPaths(input);
+        for (const key of pathArrayKeys) {
+            const paths = input[key];
+            if (!Array.isArray(paths))
+                continue;
+            if (paths.length > deliverableRuntimeLimits.maxPathCandidates) {
+                this.failed = "path-limit";
+                return;
+            }
+            for (const path of paths)
+                this.registerPath(path);
+        }
+        for (const key of ["edits", "files", "changes"]) {
+            const records = input[key];
+            if (!Array.isArray(records))
+                continue;
+            if (records.length > deliverableRuntimeLimits.maxPathCandidates) {
+                this.failed = "path-limit";
+                return;
+            }
+            for (const item of records) {
+                if (typeof item === "string")
+                    this.registerPath(item);
+                else if (isRecord(item))
+                    this.registerRecordPaths(item);
+            }
+        }
+    }
+    addDirect(record, fallbackPath, contentKeys) {
+        const path = firstString(record, pathKeys) ?? fallbackPath;
+        const content = firstString(record, contentKeys);
+        if (path === undefined || content === undefined)
+            return;
+        this.addContent(path, content);
+    }
+    addPatch(patch) {
+        if (Buffer.byteLength(patch, "utf8") > deliverableRuntimeLimits.maxAggregateContentBytes) {
+            this.failed = "content-limit";
+            return;
+        }
+        let currentPath;
+        let additions = [];
+        const flush = () => {
+            if (currentPath !== undefined && additions.length > 0)
+                this.addContent(currentPath, additions.join("\n"));
+            additions = [];
+        };
+        for (const line of patch.replace(/\r\n?/gu, "\n").split("\n")) {
+            const header = patchPathHeader(line);
+            if (header !== undefined) {
+                flush();
+                currentPath = header;
+                this.registerPath(header);
+                if (this.failed !== undefined)
+                    return;
+                continue;
+            }
+            if (line === "*** End Patch") {
+                flush();
+                currentPath = undefined;
+                continue;
+            }
+            if (currentPath !== undefined && line.startsWith("+") && !line.startsWith("+++")) {
+                additions.push(line.slice(1));
+            }
+        }
+        flush();
+    }
+    writes() {
+        return [...this.#contentByPath.entries()].map(([path, parts]) => ({ path, content: parts.join("\n") }));
+    }
+    registerRecordPaths(record) {
+        for (const key of pathKeys)
+            this.registerPath(record[key]);
+    }
+    registerPath(value) {
+        if (this.failed !== undefined || typeof value !== "string" || value.length === 0)
+            return;
+        this.#pathCandidates += 1;
+        if (this.#pathCandidates > deliverableRuntimeLimits.maxPathCandidates ||
+            value.length > 4096 ||
+            value.includes("\0")) {
+            this.failed = "path-limit";
+            return;
+        }
+        this.#declaredPaths.add(resolve(this.#cwd, value));
+    }
+    addContent(path, content) {
+        if (this.failed !== undefined)
+            return;
+        const normalizedPath = resolve(this.#cwd, path);
+        if (!this.#declaredPaths.has(normalizedPath))
+            this.registerPath(path);
+        if (this.failed !== undefined)
+            return;
+        const bytes = Buffer.byteLength(content, "utf8");
+        this.#aggregateBytes += bytes;
+        if (this.#aggregateBytes > deliverableRuntimeLimits.maxAggregateContentBytes) {
+            this.failed = "content-limit";
+            return;
+        }
+        if (!proseExtensions.has(extname(normalizedPath).toLowerCase()))
+            return;
+        const parts = this.#contentByPath.get(normalizedPath) ?? [];
+        parts.push(content);
+        this.#contentByPath.set(normalizedPath, parts);
+    }
+}
+function patchPathHeader(line) {
+    for (const prefix of ["*** Add File: ", "*** Update File: ", "*** Move to: "]) {
+        if (line.startsWith(prefix)) {
+            const path = line.slice(prefix.length).trim();
+            return path.length === 0 ? undefined : path;
+        }
+    }
+    return undefined;
+}
+function firstString(record, keys) {
+    for (const key of keys) {
+        const value = record[key];
+        if (typeof value === "string")
+            return value;
+    }
+    return undefined;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isFailedToolResponse(value) {
+    if (!isRecord(value))
+        return false;
+    return (value["isError"] === true || value["is_error"] === true || value["error"] === true || value["status"] === "error");
+}

package/marketplace/plugins/litcodex/components/rules/dist/dynamic-target-fingerprints.d.ts

@@ -0,0 +1,7 @@
+import type { PiRulesConfig } from "./rules/types.js";
+export interface DynamicTargetFingerprint {
+    targetPath: string;
+    cacheKey: string;
+    fingerprint: string;
+}
+export declare function fingerprintDynamicTargets(cwd: string, targetPaths: ReadonlyArray<string>, config: PiRulesConfig): DynamicTargetFingerprint[];

package/marketplace/plugins/litcodex/components/rules/dist/dynamic-target-fingerprints.js

@@ -0,0 +1,65 @@
+import { statSync } from "node:fs";
+import { resolve } from "node:path";
+import { isSameOrChildPath, toPosixPath, uniqueStrings } from "./path-utils.js";
+import { createRuleDiscoveryCache, findRuleCandidates } from "./rules/finder.js";
+import { hashContent } from "./rules/matcher.js";
+import { sortCandidates } from "./rules/ordering.js";
+import { findProjectRoot } from "./rules/project-root.js";
+import { disabledSourcesFromConfig } from "./rules/sources.js";
+export function fingerprintDynamicTargets(cwd, targetPaths, config) {
+    const disabledSources = disabledSourcesFromConfig(config);
+    const discoveryCache = createRuleDiscoveryCache();
+    const cwdProjectRoot = findProjectRoot(cwd);
+    const fingerprints = [];
+    for (const targetPath of uniqueStrings(targetPaths)) {
+        const projectRoot = cwdProjectRoot !== null && isSameOrChildPath(targetPath, cwdProjectRoot)
+            ? cwdProjectRoot
+            : findProjectRoot(targetPath);
+        const findOptions = {
+            projectRoot,
+            targetFile: targetPath,
+            cache: discoveryCache,
+        };
+        if (disabledSources !== undefined) {
+            findOptions.disabledSources = disabledSources;
+        }
+        const candidates = findRuleCandidates(findOptions);
+        const candidateFingerprint = sortCandidates(candidates).map(fingerprintCandidate).join("\u0001");
+        const cacheKey = dynamicTargetCacheKey(targetPath);
+        fingerprints.push({
+            targetPath,
+            cacheKey,
+            fingerprint: hashContent([
+                "v1",
+                config.enabledSources === "auto" ? "auto" : config.enabledSources.join(","),
+                projectRoot ?? "",
+                cacheKey,
+                candidateFingerprint,
+            ].join("\u0000")),
+        });
+    }
+    return fingerprints;
+}
+function fingerprintCandidate(candidate) {
+    return [
+        candidate.realPath,
+        candidate.relativePath,
+        candidate.source,
+        candidate.isGlobal ? "global" : "project",
+        candidate.isSingleFile ? "single" : "multi",
+        String(candidate.distance),
+        fileFingerprint(candidate.path),
+    ].join("\u0000");
+}
+function fileFingerprint(filePath) {
+    try {
+        const stats = statSync(filePath, { bigint: true });
+        return `${stats.mtimeNs}:${stats.ctimeNs}:${stats.size}`;
+    }
+    catch {
+        return "missing";
+    }
+}
+function dynamicTargetCacheKey(targetPath) {
+    return toPosixPath(resolve(targetPath));
+}

package/marketplace/plugins/litcodex/components/rules/dist/event-budget.d.ts

@@ -0,0 +1,7 @@
+import type { PiRulesConfig } from "./rules/types.js";
+export declare function withDynamicBudget(config: PiRulesConfig): PiRulesConfig;
+export declare function withPromptBudget(config: PiRulesConfig): PiRulesConfig;
+export declare function withOptionalContextBudget(config: PiRulesConfig, optionalBlocks: ReadonlyArray<string>, hasLeadingContext?: boolean): {
+    config: PiRulesConfig;
+    blocks: string[];
+};

package/marketplace/plugins/litcodex/components/rules/dist/event-budget.js

@@ -0,0 +1,28 @@
+export function withDynamicBudget(config) {
+    return {
+        ...config,
+        maxRuleChars: Math.min(config.maxRuleChars, config.dynamicMaxRuleChars),
+        maxResultChars: Math.min(config.maxResultChars, config.dynamicMaxResultChars),
+    };
+}
+export function withPromptBudget(config) {
+    return {
+        ...config,
+        maxRuleChars: Math.min(config.maxRuleChars, config.promptMaxRuleChars),
+        maxResultChars: Math.min(config.maxResultChars, config.promptMaxResultChars),
+    };
+}
+export function withOptionalContextBudget(config, optionalBlocks, hasLeadingContext = true) {
+    const blocks = optionalBlocks.filter((block) => block.trim().length > 0);
+    const reservedChars = blocks.reduce((total, block, index) => total + block.length + (index === 0 && !hasLeadingContext ? 0 : 2), 0);
+    if (reservedChars > config.maxResultChars) {
+        return { config, blocks: [] };
+    }
+    return {
+        config: {
+            ...config,
+            maxResultChars: config.maxResultChars - reservedChars,
+        },
+        blocks,
+    };
+}

package/marketplace/plugins/litcodex/components/rules/dist/hook-output.d.ts

@@ -0,0 +1,3 @@
+export type ContextInjectionHookEventName = "SessionStart" | "UserPromptSubmit" | "PostToolUse";
+export declare function formatAdditionalContextOutput(eventName: ContextInjectionHookEventName, additionalContext: string): string;
+export declare function prepareAdditionalContext(additionalContext: string): string;

package/marketplace/plugins/litcodex/components/rules/dist/hook-output.js

@@ -0,0 +1,24 @@
+const MAX_ADDITIONAL_CONTEXT_CHARS = 32_000;
+export function formatAdditionalContextOutput(eventName, additionalContext) {
+    const normalizedContext = prepareAdditionalContext(additionalContext);
+    if (normalizedContext.length === 0)
+        return "";
+    return `${JSON.stringify({
+        hookSpecificOutput: {
+            hookEventName: eventName,
+            additionalContext: normalizedContext,
+        },
+    })}\n`;
+}
+export function prepareAdditionalContext(additionalContext) {
+    return limitAdditionalContext(additionalContext.replace(/\r\n/g, "\n").replace(/\r/g, "\n").trim());
+}
+function limitAdditionalContext(additionalContext) {
+    if (additionalContext.length <= MAX_ADDITIONAL_CONTEXT_CHARS)
+        return additionalContext;
+    const marker = `\n\n[Truncated hook additional context to ${MAX_ADDITIONAL_CONTEXT_CHARS} chars to avoid Codex context overflow.]`;
+    if (marker.length >= MAX_ADDITIONAL_CONTEXT_CHARS)
+        return marker.slice(0, MAX_ADDITIONAL_CONTEXT_CHARS);
+    const head = additionalContext.slice(0, MAX_ADDITIONAL_CONTEXT_CHARS - marker.length).replace(/[ \t\r\n]+$/, "");
+    return `${head}${marker}`;
+}

package/marketplace/plugins/litcodex/components/rules/dist/model-metadata.d.ts

@@ -0,0 +1,14 @@
+export interface ModelMetadata {
+    readonly slug: string;
+    readonly contextWindow: number;
+}
+export type ModelMetadataResult = {
+    readonly state: "available";
+    readonly metadata: ModelMetadata;
+} | {
+    readonly state: "unavailable";
+    readonly reason: "model-not-found" | "malformed-metadata" | "host-probe-failed";
+};
+export declare function resetModelMetadataCacheForTests(): void;
+export declare function resolveModelMetadata(model: string, structuredCatalog?: string): ModelMetadataResult;
+export declare function managedGpt56Slug(model: string): "gpt-5.6" | "gpt-5.6-sol" | "gpt-5.6-terra" | null;