@litfamily/litcodex 1.0.0

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

@@ -0,0 +1,101 @@
+import { spawnSync } from "node:child_process";
+let memoizedCatalog;
+export function resetModelMetadataCacheForTests() {
+    memoizedCatalog = undefined;
+}
+export function resolveModelMetadata(model, structuredCatalog) {
+    const slug = managedGpt56Slug(model);
+    if (slug === null) {
+        return { state: "unavailable", reason: "model-not-found" };
+    }
+    const raw = structuredCatalog ?? readCatalogOnce();
+    if (raw === null) {
+        return { state: "unavailable", reason: "host-probe-failed" };
+    }
+    try {
+        const parsed = JSON.parse(raw);
+        if (!isRecord(parsed) || !Array.isArray(parsed["models"])) {
+            return { state: "unavailable", reason: "malformed-metadata" };
+        }
+        if (slug === "gpt-5.6") {
+            return resolveAliasMetadata(parsed["models"]);
+        }
+        for (const entry of parsed["models"]) {
+            if (!isRecord(entry) || entry["slug"] !== slug)
+                continue;
+            const contextWindow = positiveContextWindow(entry);
+            return contextWindow === null
+                ? { state: "unavailable", reason: "malformed-metadata" }
+                : { state: "available", metadata: { slug, contextWindow } };
+        }
+        return { state: "unavailable", reason: "model-not-found" };
+    }
+    catch (error) {
+        if (error instanceof SyntaxError) {
+            return { state: "unavailable", reason: "malformed-metadata" };
+        }
+        throw error;
+    }
+}
+export function managedGpt56Slug(model) {
+    const normalized = model.trim().toLowerCase();
+    for (const slug of ["gpt-5.6-sol", "gpt-5.6-terra", "gpt-5.6"]) {
+        if (normalized === slug || normalized.endsWith(`.${slug}`) || normalized.endsWith(`/${slug}`)) {
+            return slug;
+        }
+    }
+    return null;
+}
+function resolveAliasMetadata(models) {
+    const aliasRows = matchingRows(models, "gpt-5.6");
+    const explicitSolRows = matchingRows(models, "gpt-5.6-sol");
+    if (aliasRows.length === 0 && explicitSolRows.length === 0) {
+        return { state: "unavailable", reason: "model-not-found" };
+    }
+    if (aliasRows.length > 1 || explicitSolRows.length > 1) {
+        return { state: "unavailable", reason: "malformed-metadata" };
+    }
+    const aliasRow = aliasRows[0];
+    const explicitSolRow = explicitSolRows[0];
+    const aliasContext = aliasRow === undefined ? undefined : positiveContextWindow(aliasRow);
+    const explicitSolContext = explicitSolRow === undefined ? undefined : positiveContextWindow(explicitSolRow);
+    if (aliasContext === null || explicitSolContext === null) {
+        return { state: "unavailable", reason: "malformed-metadata" };
+    }
+    if (aliasContext !== undefined && explicitSolContext !== undefined && aliasContext !== explicitSolContext) {
+        return { state: "unavailable", reason: "malformed-metadata" };
+    }
+    const contextWindow = aliasContext ?? explicitSolContext;
+    if (contextWindow === undefined) {
+        return { state: "unavailable", reason: "model-not-found" };
+    }
+    return {
+        state: "available",
+        metadata: { slug: "gpt-5.6", contextWindow },
+    };
+}
+function matchingRows(models, slug) {
+    return models.filter((entry) => isRecord(entry) && entry["slug"] === slug);
+}
+function positiveContextWindow(entry) {
+    const contextWindow = entry["context_window"];
+    return typeof contextWindow === "number" && Number.isFinite(contextWindow) && contextWindow > 0
+        ? contextWindow
+        : null;
+}
+function readCatalogOnce() {
+    if (memoizedCatalog !== undefined) {
+        return memoizedCatalog;
+    }
+    const result = spawnSync("codex", ["debug", "models"], {
+        encoding: "utf8",
+        timeout: 750,
+        maxBuffer: 2 * 1024 * 1024,
+        stdio: ["ignore", "pipe", "ignore"],
+    });
+    memoizedCatalog = result.status === 0 && result.error === undefined ? result.stdout : null;
+    return memoizedCatalog;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

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

@@ -0,0 +1,7 @@
+export declare const OUTPUT_STYLE_IDS: readonly ["off", "asd-ste100", "asd-ste100-ko", "eli5", "eli5-ko"];
+export type OutputStyleId = (typeof OUTPUT_STYLE_IDS)[number];
+/**
+ * Load and return the output-style file text for the style configured in CODEX_HOME/config.toml.
+ * Returns "" for "off", unset, or any error (fail-open). Never throws.
+ */
+export declare function loadOutputStyleText(env?: NodeJS.ProcessEnv): string;

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

@@ -0,0 +1,53 @@
+// Output-style injection helper — reads the persisted litcodex_output_style from the Codex
+// config file and loads the matching style file from output-styles/. Fail-open: any missing
+// file, unreadable config, or unrecognised id silently returns "". Never throws.
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { resolvePluginRulesRoot } from "./rules/plugin-root.js";
+export const OUTPUT_STYLE_IDS = ["off", "asd-ste100", "asd-ste100-ko", "eli5", "eli5-ko"];
+/**
+ * Load and return the output-style file text for the style configured in CODEX_HOME/config.toml.
+ * Returns "" for "off", unset, or any error (fail-open). Never throws.
+ */
+export function loadOutputStyleText(env = process.env) {
+    const id = readOutputStyleId(env);
+    if (id === "off")
+        return "";
+    try {
+        const pluginRoot = resolvePluginRulesRoot(undefined);
+        return readFileSync(join(pluginRoot, "output-styles", `${id}.md`), "utf8");
+    }
+    catch {
+        return "";
+    }
+}
+/** Read the persisted output style id from CODEX_HOME/config.toml. Returns "off" on any error. */
+function readOutputStyleId(env) {
+    try {
+        const home = homedir();
+        const codexHome = env["CODEX_HOME"]?.trim() || (home.length > 0 ? join(home, ".codex") : "");
+        if (codexHome.length === 0)
+            return "off";
+        const contents = readFileSync(join(codexHome, "config.toml"), "utf8");
+        return parseOutputStyleId(contents) ?? "off";
+    }
+    catch {
+        return "off";
+    }
+}
+function parseOutputStyleId(content) {
+    for (const line of content.split(/\n/)) {
+        const trimmed = line.trimStart();
+        if (trimmed.startsWith("["))
+            break; // root scope ends at first section header
+        if (trimmed.startsWith("#"))
+            continue;
+        const match = /^litcodex_output_style\s*=\s*"([^"]+)"/.exec(trimmed);
+        if (match !== null && match[1] !== undefined) {
+            const value = match[1];
+            return OUTPUT_STYLE_IDS.includes(value) ? value : null;
+        }
+    }
+    return null;
+}

package/marketplace/plugins/litcodex/components/rules/dist/path-utils.d.ts

@@ -0,0 +1,4 @@
+export declare function displayPath(cwd: string, filePath: string): string;
+export declare function isSameOrChildPath(childPath: string, parentPath: string): boolean;
+export declare function toPosixPath(path: string): string;
+export declare function uniqueStrings(values: ReadonlyArray<string>): string[];

package/marketplace/plugins/litcodex/components/rules/dist/path-utils.js

@@ -0,0 +1,24 @@
+import { isAbsolute, relative, resolve } from "node:path";
+export function displayPath(cwd, filePath) {
+    const rel = isAbsolute(filePath) ? relative(cwd, filePath) : filePath;
+    return toPosixPath(rel);
+}
+export function isSameOrChildPath(childPath, parentPath) {
+    const childRelativePath = relative(parentPath, resolve(childPath));
+    return childRelativePath === "" || (!childRelativePath.startsWith("..") && !isAbsolute(childRelativePath));
+}
+export function toPosixPath(path) {
+    return path.replaceAll("\\", "/");
+}
+export function uniqueStrings(values) {
+    const uniqueValues = [];
+    const seenValues = new Set();
+    for (const value of values) {
+        if (seenValues.has(value)) {
+            continue;
+        }
+        seenValues.add(value);
+        uniqueValues.push(value);
+    }
+    return uniqueValues;
+}

package/marketplace/plugins/litcodex/components/rules/dist/persistent-cache.d.ts

@@ -0,0 +1,14 @@
+import { type PostCompactPendingKind } from "./post-compact-state.js";
+import type { Engine } from "./rules/engine.js";
+export type PostCompactClaimResult = "claimed" | "not-pending" | "contended";
+export declare function hydrateEngineState(engine: Engine, cachePath: string): void;
+export declare function persistEngineState(engine: Engine, cachePath: string, completedPostCompactKind?: PostCompactPendingKind): void;
+export declare function clearSessionState(cachePath: string): void;
+export declare function markSessionCompacted(cachePath: string): void;
+export declare function hasPostCompactPending(cachePath: string): boolean;
+export declare function isPostCompactPending(cachePath: string, kind: PostCompactPendingKind): boolean;
+export declare function claimPostCompactPending(cachePath: string, kind: PostCompactPendingKind): PostCompactClaimResult;
+export declare function isPostCompactRecoveryInProgress(cachePath: string, kind: PostCompactPendingKind): boolean;
+export declare function completePostCompactRecovery(cachePath: string, kind: PostCompactPendingKind): void;
+export declare function retryPostCompactRecovery(cachePath: string, kind: PostCompactPendingKind): void;
+export declare function sessionCachePath(sessionId: string, pluginDataRoot: string | undefined): string;

package/marketplace/plugins/litcodex/components/rules/dist/persistent-cache.js

@@ -0,0 +1,180 @@
+import { mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { postCompactKindState, postCompactPendingKinds, postCompactRecoveringKinds, } from "./post-compact-state.js";
+import { SESSION_STATE_LOCK_CONTENDED, withSessionStateLock } from "./session-state-lock.js";
+export function hydrateEngineState(engine, cachePath) {
+    const state = readSessionState(cachePath);
+    engine.state.staticDedup.clear();
+    engine.state.dynamicDedup.clear();
+    engine.state.dynamicTargetFingerprints.clear();
+    for (const key of state.staticDedup) {
+        engine.state.staticDedup.add(key);
+    }
+    for (const [scope, keys] of Object.entries(state.dynamicDedup)) {
+        engine.state.dynamicDedup.set(scope, new Set(keys));
+    }
+    for (const [targetKey, fingerprint] of Object.entries(state.dynamicTargetFingerprints ?? {})) {
+        engine.state.dynamicTargetFingerprints.set(targetKey, fingerprint);
+    }
+}
+export function persistEngineState(engine, cachePath, completedPostCompactKind) {
+    const currentState = readSessionState(cachePath);
+    const dynamicDedup = {};
+    for (const [scope, keys] of engine.state.dynamicDedup.entries()) {
+        dynamicDedup[scope] = [...keys];
+    }
+    const postCompactPending = nextPostCompactPending(currentState, completedPostCompactKind);
+    const postCompactRecovering = nextPostCompactRecovering(currentState, completedPostCompactKind);
+    writeSessionState(cachePath, {
+        staticDedup: [...engine.state.staticDedup],
+        dynamicDedup,
+        dynamicTargetFingerprints: Object.fromEntries(engine.state.dynamicTargetFingerprints.entries()),
+        ...(postCompactPending === undefined ? {} : { postCompactPending }),
+        ...(postCompactRecovering === undefined ? {} : { postCompactRecovering }),
+    });
+}
+export function clearSessionState(cachePath) {
+    rmSync(cachePath, { force: true });
+}
+export function markSessionCompacted(cachePath) {
+    const state = readSessionState(cachePath);
+    // Compaction drops injected static rule bodies, so pre-compaction static
+    // dedup marks must not suppress the post-compact recovery directive.
+    // Dynamic dedup survives: those rules are recovered as read-directive paths.
+    writeSessionState(cachePath, {
+        staticDedup: [],
+        dynamicDedup: state.dynamicDedup,
+        dynamicTargetFingerprints: {},
+        postCompactPending: { static: true, dynamic: true },
+    });
+}
+export function hasPostCompactPending(cachePath) {
+    const state = readSessionState(cachePath);
+    return postCompactPendingKinds(state).size > 0 || postCompactRecoveringKinds(state).size > 0;
+}
+export function isPostCompactPending(cachePath, kind) {
+    return postCompactPendingKinds(readSessionState(cachePath)).has(kind);
+}
+export function claimPostCompactPending(cachePath, kind) {
+    const result = withSessionStateLock(cachePath, () => {
+        const state = readSessionState(cachePath);
+        const pendingKinds = postCompactPendingKinds(state);
+        if (!pendingKinds.has(kind)) {
+            return "not-pending";
+        }
+        pendingKinds.delete(kind);
+        const recoveringKinds = postCompactRecoveringKinds(state);
+        recoveringKinds.add(kind);
+        writeSessionState(cachePath, stateWithPostCompactKinds(state, pendingKinds, recoveringKinds));
+        return "claimed";
+    });
+    return result === SESSION_STATE_LOCK_CONTENDED ? "contended" : result;
+}
+export function isPostCompactRecoveryInProgress(cachePath, kind) {
+    return postCompactRecoveringKinds(readSessionState(cachePath)).has(kind);
+}
+export function completePostCompactRecovery(cachePath, kind) {
+    withSessionStateLock(cachePath, () => {
+        const state = readSessionState(cachePath);
+        const pendingKinds = postCompactPendingKinds(state);
+        const recoveringKinds = postCompactRecoveringKinds(state);
+        recoveringKinds.delete(kind);
+        writeSessionState(cachePath, stateWithPostCompactKinds(state, pendingKinds, recoveringKinds));
+    });
+}
+export function retryPostCompactRecovery(cachePath, kind) {
+    withSessionStateLock(cachePath, () => {
+        const state = readSessionState(cachePath);
+        const pendingKinds = postCompactPendingKinds(state);
+        const recoveringKinds = postCompactRecoveringKinds(state);
+        pendingKinds.add(kind);
+        recoveringKinds.delete(kind);
+        writeSessionState(cachePath, stateWithPostCompactKinds(state, pendingKinds, recoveringKinds));
+    });
+}
+export function sessionCachePath(sessionId, pluginDataRoot) {
+    const root = pluginDataRoot ?? process.env["PLUGIN_DATA"] ?? join(homedir(), ".codex", "litcodex", "rules");
+    return join(root, "sessions", `${safePathSegment(sessionId)}.json`);
+}
+function readSessionState(cachePath) {
+    try {
+        const parsed = JSON.parse(readFileSync(cachePath, "utf8"));
+        if (!isSerializedSessionState(parsed))
+            return emptyState();
+        return parsed;
+    }
+    catch {
+        return emptyState();
+    }
+}
+function writeSessionState(cachePath, state) {
+    mkdirSync(dirname(cachePath), { recursive: true });
+    writeFileSync(cachePath, `${JSON.stringify(state)}\n`);
+}
+function emptyState() {
+    return { staticDedup: [], dynamicDedup: {}, dynamicTargetFingerprints: {} };
+}
+function nextPostCompactPending(state, completedKind) {
+    const pendingKinds = postCompactPendingKinds(state);
+    if (completedKind !== undefined) {
+        pendingKinds.delete(completedKind);
+    }
+    if (pendingKinds.size === 0) {
+        return undefined;
+    }
+    return {
+        ...(pendingKinds.has("static") ? { static: true } : {}),
+        ...(pendingKinds.has("dynamic") ? { dynamic: true } : {}),
+    };
+}
+function nextPostCompactRecovering(state, completedKind) {
+    const recoveringKinds = postCompactRecoveringKinds(state);
+    if (completedKind !== undefined) {
+        recoveringKinds.delete(completedKind);
+    }
+    return postCompactKindState(recoveringKinds);
+}
+function stateWithPostCompactKinds(state, pendingKinds, recoveringKinds) {
+    const postCompactPending = postCompactKindState(pendingKinds);
+    const postCompactRecovering = postCompactKindState(recoveringKinds);
+    return {
+        staticDedup: state.staticDedup,
+        dynamicDedup: state.dynamicDedup,
+        ...(state.dynamicTargetFingerprints === undefined
+            ? {}
+            : { dynamicTargetFingerprints: state.dynamicTargetFingerprints }),
+        ...(postCompactPending === undefined ? {} : { postCompactPending }),
+        ...(postCompactRecovering === undefined ? {} : { postCompactRecovering }),
+    };
+}
+function safePathSegment(value) {
+    return value.replace(/[^A-Za-z0-9._-]/g, "_").slice(0, 120) || "unknown-session";
+}
+function isSerializedSessionState(value) {
+    if (!isRecord(value) || !Array.isArray(value["staticDedup"]) || !isRecord(value["dynamicDedup"])) {
+        return false;
+    }
+    const staticDedup = value["staticDedup"];
+    const dynamicDedup = value["dynamicDedup"];
+    const dynamicTargetFingerprints = value["dynamicTargetFingerprints"];
+    const postCompactPending = value["postCompactPending"];
+    const postCompactRecovering = value["postCompactRecovering"];
+    const compacted = value["compacted"];
+    return (staticDedup.every((item) => typeof item === "string") &&
+        Object.values(dynamicDedup).every((item) => Array.isArray(item) && item.every((nestedItem) => typeof nestedItem === "string")) &&
+        (dynamicTargetFingerprints === undefined ||
+            (isRecord(dynamicTargetFingerprints) &&
+                Object.entries(dynamicTargetFingerprints).every(([targetKey, fingerprint]) => typeof targetKey === "string" && typeof fingerprint === "string"))) &&
+        (postCompactPending === undefined || isPostCompactPendingState(postCompactPending)) &&
+        (postCompactRecovering === undefined || isPostCompactPendingState(postCompactRecovering)) &&
+        (compacted === undefined || typeof compacted === "boolean"));
+}
+function isPostCompactPendingState(value) {
+    return (isRecord(value) &&
+        (value["static"] === undefined || typeof value["static"] === "boolean") &&
+        (value["dynamic"] === undefined || typeof value["dynamic"] === "boolean"));
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

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

@@ -0,0 +1,8 @@
+import { type ModelMetadata } from "./model-metadata.js";
+import type { PiRulesConfig } from "./rules/types.js";
+export interface PostCompactBudgetContext {
+    readonly model: string;
+    readonly transcriptPath: string | null;
+    readonly modelMetadata?: ModelMetadata | null;
+}
+export declare function withPostCompactBudget(config: PiRulesConfig, context?: PostCompactBudgetContext): PiRulesConfig;

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

@@ -0,0 +1,103 @@
+import { readFileSync } from "node:fs";
+import { hasContextPressureMarker } from "./context-pressure.js";
+import { managedGpt56Slug, resolveModelMetadata } from "./model-metadata.js";
+const DEFAULT_EFFECTIVE_CONTEXT_WINDOW_PERCENT = 95;
+const ESTIMATED_TRANSCRIPT_CHARS_PER_TOKEN = 3;
+const PROJECTED_INJECTION_CHARS_PER_TOKEN = 2;
+const POST_COMPACT_RESERVED_CONTEXT_PERCENT = 5;
+const POST_COMPACT_MIN_RESERVED_TOKENS = 8_000;
+const POST_COMPACT_MIN_GUIDE_CHARS = 500;
+const FALLBACK_CONTEXT_WINDOW_TOKENS = 200_000;
+const MODEL_CONTEXT_BUDGETS = [
+    { slug: "gpt-5.5", contextWindowTokens: 272_000, effectivePercent: DEFAULT_EFFECTIVE_CONTEXT_WINDOW_PERCENT },
+    { slug: "gpt-5.4-mini", contextWindowTokens: 272_000, effectivePercent: DEFAULT_EFFECTIVE_CONTEXT_WINDOW_PERCENT },
+    {
+        slug: "codex-auto-review",
+        contextWindowTokens: 272_000,
+        effectivePercent: DEFAULT_EFFECTIVE_CONTEXT_WINDOW_PERCENT,
+    },
+];
+export function withPostCompactBudget(config, context) {
+    const postCompactMaxResultChars = dynamicPostCompactMaxResultChars(context) ?? config.postCompactMaxResultChars;
+    const maxResultChars = Math.min(config.maxResultChars, config.postCompactMaxResultChars, postCompactMaxResultChars);
+    const maxRuleChars = Math.min(config.maxRuleChars, config.postCompactMaxRuleChars, maxResultChars);
+    return {
+        ...config,
+        maxRuleChars,
+        maxResultChars,
+    };
+}
+function dynamicPostCompactMaxResultChars(context) {
+    if (context === undefined || context.transcriptPath === null) {
+        return undefined;
+    }
+    const transcript = estimateTranscript(context.transcriptPath);
+    if (transcript === undefined) {
+        return undefined;
+    }
+    if (hasContextPressureMarker(transcript.text)) {
+        return POST_COMPACT_MIN_GUIDE_CHARS;
+    }
+    const modelBudget = resolveModelContextBudget(context);
+    if (modelBudget === null) {
+        return POST_COMPACT_MIN_GUIDE_CHARS;
+    }
+    const effectiveContextWindow = Math.floor((modelBudget.contextWindowTokens * modelBudget.effectivePercent) / 100);
+    const reservedTokens = Math.max(POST_COMPACT_MIN_RESERVED_TOKENS, Math.floor((effectiveContextWindow * POST_COMPACT_RESERVED_CONTEXT_PERCENT) / 100));
+    const injectableTokens = Math.max(0, effectiveContextWindow - reservedTokens - transcript.tokens);
+    return Math.max(POST_COMPACT_MIN_GUIDE_CHARS, Math.floor(injectableTokens * PROJECTED_INJECTION_CHARS_PER_TOKEN));
+}
+function resolveModelContextBudget(context) {
+    const gpt56Slug = managedGpt56Slug(context.model);
+    if (gpt56Slug === null) {
+        return modelContextBudgetFor(context.model) ?? fallbackModelContextBudget();
+    }
+    if (context.modelMetadata !== undefined) {
+        return context.modelMetadata !== null && context.modelMetadata.slug === gpt56Slug
+            ? {
+                slug: gpt56Slug,
+                contextWindowTokens: context.modelMetadata.contextWindow,
+                effectivePercent: DEFAULT_EFFECTIVE_CONTEXT_WINDOW_PERCENT,
+            }
+            : null;
+    }
+    const resolved = resolveModelMetadata(context.model);
+    return resolved.state === "available"
+        ? {
+            slug: resolved.metadata.slug,
+            contextWindowTokens: resolved.metadata.contextWindow,
+            effectivePercent: DEFAULT_EFFECTIVE_CONTEXT_WINDOW_PERCENT,
+        }
+        : null;
+}
+function modelContextBudgetFor(model) {
+    const normalizedModel = model.trim().toLowerCase();
+    for (const budget of MODEL_CONTEXT_BUDGETS) {
+        if (normalizedModel === budget.slug ||
+            normalizedModel.endsWith(`.${budget.slug}`) ||
+            normalizedModel.endsWith(`/${budget.slug}`)) {
+            return budget;
+        }
+    }
+    return undefined;
+}
+function fallbackModelContextBudget() {
+    return {
+        slug: "unknown",
+        contextWindowTokens: FALLBACK_CONTEXT_WINDOW_TOKENS,
+        effectivePercent: DEFAULT_EFFECTIVE_CONTEXT_WINDOW_PERCENT,
+    };
+}
+function estimateTranscript(transcriptPath) {
+    let transcriptText;
+    try {
+        transcriptText = readFileSync(transcriptPath, "utf8");
+    }
+    catch {
+        return undefined;
+    }
+    return {
+        text: transcriptText,
+        tokens: Math.ceil(Buffer.byteLength(transcriptText, "utf8") / ESTIMATED_TRANSCRIPT_CHARS_PER_TOKEN),
+    };
+}

package/marketplace/plugins/litcodex/components/rules/dist/post-compact-claim.d.ts

@@ -0,0 +1,4 @@
+import type { PostCompactClaimResult } from "./persistent-cache.js";
+import type { PostCompactPendingKind } from "./post-compact-state.js";
+export declare function claimedPostCompactKind<T extends PostCompactPendingKind>(result: PostCompactClaimResult, kind: T): T | undefined;
+export declare function shouldSkipPostCompactClaim(result: PostCompactClaimResult, recoveryInProgress: boolean): boolean;

package/marketplace/plugins/litcodex/components/rules/dist/post-compact-claim.js

@@ -0,0 +1,6 @@
+export function claimedPostCompactKind(result, kind) {
+    return result === "claimed" ? kind : undefined;
+}
+export function shouldSkipPostCompactClaim(result, recoveryInProgress) {
+    return result === "contended" || (result === "not-pending" && recoveryInProgress);
+}

package/marketplace/plugins/litcodex/components/rules/dist/post-compact-directive.d.ts

@@ -0,0 +1,2 @@
+export declare function buildPostCompactReadDirective(rulePaths: ReadonlyArray<string>, maxChars: number): string;
+export declare function listPostCompactDirectivePaths(directive: string): string[];

package/marketplace/plugins/litcodex/components/rules/dist/post-compact-directive.js

@@ -0,0 +1,55 @@
+import { uniqueStrings } from "./path-utils.js";
+const DIRECTIVE_HEADER = [
+    "## MANDATORY: POST-COMPACTION RULE RECOVERY",
+    "",
+    "Context compaction DROPPED the project rule files listed below from your context.",
+    "YOU MUST READ THE FOLLOWING RULES with your file-reading tool RIGHT NOW, BEFORE ANY OTHER ACTION. NO EXCUSES.",
+    "Do not plan, answer, edit, or run anything until EVERY file below has been read end to end:",
+    "",
+].join("\n");
+const DIRECTIVE_FOOTER = "\nOperating without these rules is a protocol violation. Reconstructing them from memory is NOT reading. READ THEM ALL. NO EXCUSES.";
+const COMPACT_DIRECTIVE_HEADER = "## MANDATORY: POST-COMPACTION RULE RECOVERY\n\nMUST READ these project rules before any other action:\n";
+const COMPACT_DIRECTIVE_FOOTER = "\nNO EXCUSES.";
+export function buildPostCompactReadDirective(rulePaths, maxChars) {
+    const paths = uniqueStrings([...rulePaths]);
+    if (paths.length === 0) {
+        return "";
+    }
+    const fullDirective = buildDirective(DIRECTIVE_HEADER, DIRECTIVE_FOOTER, paths, maxChars);
+    if (fullDirective.length > 0) {
+        return fullDirective;
+    }
+    return buildDirective(COMPACT_DIRECTIVE_HEADER, COMPACT_DIRECTIVE_FOOTER, paths, maxChars);
+}
+export function listPostCompactDirectivePaths(directive) {
+    return directive
+        .split("\n")
+        .filter((line) => line.startsWith("- ") && !line.startsWith("- (+"))
+        .map((line) => line.slice(2));
+}
+function buildDirective(header, footer, paths, maxChars) {
+    const lines = [];
+    let usedChars = header.length + footer.length;
+    let omittedCount = 0;
+    for (const rulePath of paths) {
+        const line = `- ${rulePath}`;
+        const separatorChars = lines.length > 0 ? 1 : 0;
+        if (usedChars + separatorChars + line.length > maxChars) {
+            omittedCount += 1;
+            continue;
+        }
+        lines.push(line);
+        usedChars += separatorChars + line.length;
+    }
+    if (lines.length === 0) {
+        return "";
+    }
+    if (omittedCount > 0) {
+        const omittedLine = `- (+${omittedCount} more rule files omitted - rescan the project rule directories and read those too)`;
+        const separatorChars = 1;
+        if (usedChars + separatorChars + omittedLine.length <= maxChars) {
+            lines.push(omittedLine);
+        }
+    }
+    return `${header}${lines.join("\n")}${footer}`;
+}

package/marketplace/plugins/litcodex/components/rules/dist/post-compact-state.d.ts

@@ -0,0 +1,13 @@
+export type PostCompactPendingKind = "static" | "dynamic";
+export interface PostCompactPendingState {
+    static?: boolean;
+    dynamic?: boolean;
+}
+export interface PostCompactStateFields {
+    readonly postCompactPending?: PostCompactPendingState;
+    readonly postCompactRecovering?: PostCompactPendingState;
+    readonly compacted?: boolean;
+}
+export declare function postCompactKindState(kinds: ReadonlySet<PostCompactPendingKind>): PostCompactPendingState | undefined;
+export declare function postCompactPendingKinds(state: PostCompactStateFields): Set<PostCompactPendingKind>;
+export declare function postCompactRecoveringKinds(state: PostCompactStateFields): Set<PostCompactPendingKind>;

package/marketplace/plugins/litcodex/components/rules/dist/post-compact-state.js

@@ -0,0 +1,29 @@
+export function postCompactKindState(kinds) {
+    if (kinds.size === 0) {
+        return undefined;
+    }
+    return {
+        ...(kinds.has("static") ? { static: true } : {}),
+        ...(kinds.has("dynamic") ? { dynamic: true } : {}),
+    };
+}
+export function postCompactPendingKinds(state) {
+    const pendingKinds = new Set();
+    if (state.compacted === true || state.postCompactPending?.static === true) {
+        pendingKinds.add("static");
+    }
+    if (state.compacted === true || state.postCompactPending?.dynamic === true) {
+        pendingKinds.add("dynamic");
+    }
+    return pendingKinds;
+}
+export function postCompactRecoveringKinds(state) {
+    const recoveringKinds = new Set();
+    if (state.postCompactRecovering?.static === true) {
+        recoveringKinds.add("static");
+    }
+    if (state.postCompactRecovering?.dynamic === true) {
+        recoveringKinds.add("dynamic");
+    }
+    return recoveringKinds;
+}

package/marketplace/plugins/litcodex/components/rules/dist/rules/cache.d.ts

@@ -0,0 +1,9 @@
+import type { LoadedRule, SessionState } from "./types.js";
+export declare function createSessionState(cwd?: string): SessionState;
+export declare function staticDedupKey(cwd: string, rulePath: string, contentHash: string): string;
+export declare function dynamicDedupKey(rulePath: string, contentHash: string): string;
+export declare function markStaticInjected(state: SessionState, rule: LoadedRule): boolean;
+export declare function markDynamicInjected(state: SessionState, rule: LoadedRule): boolean;
+export declare function isStaticInjected(state: SessionState, rule: LoadedRule): boolean;
+export declare function isDynamicInjected(state: SessionState, rule: LoadedRule): boolean;
+export declare function clearSession(state: SessionState): void;