@litfamily/litcodex 1.0.0

package/marketplace/plugins/litcodex/components/rules/dist/cli.js

@@ -0,0 +1,148 @@
+#!/usr/bin/env node
+import { stdin as processStdin, stdout as processStdout } from "node:process";
+import { runPostCompactHook, runPostToolUseHook, runSessionStartHook, runUserPromptSubmitHook, } from "./codex-hook.js";
+import { runDeliverableHedgePostToolUse } from "./deliverable-hedge-guard.js";
+const command = process.argv[2];
+const subcommand = process.argv[3];
+const maxDeliverableHookInputBytes = 6 * 1024 * 1024;
+if (command === "hook" && subcommand === "session-start") {
+    await runHookCli("SessionStart");
+}
+else if (command === "hook" && subcommand === "user-prompt-submit") {
+    await runHookCli("UserPromptSubmit");
+}
+else if (command === "hook" && subcommand === "post-tool-use") {
+    await runHookCli("PostToolUse");
+}
+else if (command === "hook" && subcommand === "post-tool-use-deliverable-hedges") {
+    await runDeliverableHedgeHookCli();
+}
+else if (command === "hook" && subcommand === "post-compact") {
+    await runHookCli("PostCompact");
+}
+else {
+    process.stderr.write("Usage: litcodex-rules hook [session-start|user-prompt-submit|post-tool-use|post-tool-use-deliverable-hedges|post-compact]\n");
+    process.exitCode = 1;
+}
+async function runDeliverableHedgeHookCli() {
+    const raw = await readStdin(maxDeliverableHookInputBytes);
+    if (raw === undefined)
+        return;
+    if (raw.trim().length === 0)
+        return;
+    const parsed = parseHookInput(raw);
+    if (!isCodexPostToolUseInput(parsed))
+        return;
+    const output = runDeliverableHedgePostToolUse(parsed);
+    if (output.length > 0)
+        processStdout.write(output);
+}
+async function runHookCli(eventName) {
+    const raw = await readStdin();
+    if (raw === undefined)
+        return;
+    if (raw.trim().length === 0)
+        return;
+    const parsed = parseHookInput(raw);
+    if (!parsed)
+        return;
+    const pluginDataRoot = process.env["PLUGIN_DATA"];
+    const options = pluginDataRoot === undefined ? {} : { pluginDataRoot };
+    const output = await runHook(eventName, parsed, options);
+    if (output.length > 0) {
+        processStdout.write(output);
+    }
+}
+async function runHook(eventName, parsed, options) {
+    switch (eventName) {
+        case "SessionStart":
+            return isCodexSessionStartInput(parsed) ? await runSessionStartHook(parsed, options) : "";
+        case "UserPromptSubmit":
+            return isCodexUserPromptSubmitInput(parsed) ? await runUserPromptSubmitHook(parsed, options) : "";
+        case "PostToolUse":
+            return isCodexPostToolUseInput(parsed) ? await runPostToolUseHook(parsed, options) : "";
+        case "PostCompact":
+            return isCodexPostCompactInput(parsed) ? await runPostCompactHook(parsed, options) : "";
+    }
+}
+function parseHookInput(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        return parsed;
+    }
+    catch {
+        return undefined;
+    }
+}
+function isCodexSessionStartInput(value) {
+    return (isRecord(value) &&
+        value["hook_event_name"] === "SessionStart" &&
+        typeof value["session_id"] === "string" &&
+        isStringOrNull(value["transcript_path"]) &&
+        typeof value["cwd"] === "string" &&
+        typeof value["model"] === "string" &&
+        typeof value["permission_mode"] === "string" &&
+        typeof value["source"] === "string");
+}
+function isCodexUserPromptSubmitInput(value) {
+    return (isRecord(value) &&
+        value["hook_event_name"] === "UserPromptSubmit" &&
+        typeof value["session_id"] === "string" &&
+        typeof value["turn_id"] === "string" &&
+        isStringOrNull(value["transcript_path"]) &&
+        typeof value["cwd"] === "string" &&
+        typeof value["model"] === "string" &&
+        typeof value["permission_mode"] === "string" &&
+        typeof value["prompt"] === "string");
+}
+function isCodexPostToolUseInput(value) {
+    return (isRecord(value) &&
+        value["hook_event_name"] === "PostToolUse" &&
+        typeof value["session_id"] === "string" &&
+        typeof value["turn_id"] === "string" &&
+        isStringOrNull(value["transcript_path"]) &&
+        typeof value["cwd"] === "string" &&
+        typeof value["model"] === "string" &&
+        typeof value["permission_mode"] === "string" &&
+        typeof value["tool_name"] === "string" &&
+        typeof value["tool_use_id"] === "string");
+}
+function isCodexPostCompactInput(value) {
+    return (isRecord(value) &&
+        value["hook_event_name"] === "PostCompact" &&
+        typeof value["session_id"] === "string" &&
+        typeof value["turn_id"] === "string" &&
+        isStringOrNull(value["transcript_path"]) &&
+        typeof value["cwd"] === "string" &&
+        typeof value["model"] === "string" &&
+        (value["trigger"] === "manual" || value["trigger"] === "auto"));
+}
+function isStringOrNull(value) {
+    return typeof value === "string" || value === null;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readStdin(maxBytes = Number.MAX_SAFE_INTEGER) {
+    return new Promise((resolve, reject) => {
+        let data = "";
+        let bytes = 0;
+        let exceeded = false;
+        processStdin.setEncoding("utf8");
+        processStdin.on("data", (chunk) => {
+            if (exceeded)
+                return;
+            bytes += Buffer.byteLength(chunk, "utf8");
+            if (bytes > maxBytes) {
+                exceeded = true;
+                data = "";
+                return;
+            }
+            data += chunk;
+        });
+        processStdin.once("error", reject);
+        processStdin.once("end", () => {
+            resolve(exceeded ? undefined : data);
+        });
+    });
+}

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

@@ -0,0 +1,5 @@
+export interface CodexRulesHookOptions {
+    env?: NodeJS.ProcessEnv;
+    pluginDataRoot?: string;
+    platform?: NodeJS.Platform;
+}

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,47 @@
+import type { CodexRulesHookOptions } from "./codex-hook-options.js";
+export type { CodexRulesHookOptions } from "./codex-hook-options.js";
+export type CodexSessionStartInput = {
+    session_id: string;
+    transcript_path: string | null;
+    cwd: string;
+    hook_event_name: "SessionStart";
+    model: string;
+    permission_mode: string;
+    source: "startup" | "resume" | "clear" | "compact";
+};
+export type CodexUserPromptSubmitInput = {
+    session_id: string;
+    turn_id: string;
+    transcript_path: string | null;
+    cwd: string;
+    hook_event_name: "UserPromptSubmit";
+    model: string;
+    permission_mode: string;
+    prompt: string;
+};
+export type CodexPostToolUseInput = {
+    session_id: string;
+    turn_id: string;
+    transcript_path: string | null;
+    cwd: string;
+    hook_event_name: "PostToolUse";
+    model: string;
+    permission_mode: string;
+    tool_name: string;
+    tool_input: unknown;
+    tool_response: unknown;
+    tool_use_id: string;
+};
+export type CodexPostCompactInput = {
+    session_id: string;
+    turn_id: string;
+    transcript_path: string | null;
+    cwd: string;
+    hook_event_name: "PostCompact";
+    model: string;
+    trigger: "manual" | "auto";
+};
+export declare function runSessionStartHook(input: CodexSessionStartInput, options?: CodexRulesHookOptions): Promise<string>;
+export declare function runPostCompactHook(input: CodexPostCompactInput, options?: CodexRulesHookOptions): Promise<string>;
+export declare function runUserPromptSubmitHook(input: CodexUserPromptSubmitInput, options?: CodexRulesHookOptions): Promise<string>;
+export declare function runPostToolUseHook(input: CodexPostToolUseInput, options?: CodexRulesHookOptions): Promise<string>;

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

@@ -0,0 +1,137 @@
+import { configFromEnvironment } from "./config.js";
+import { hasContextPressureMarker, transcriptHasContextPressureMarker } from "./context-pressure.js";
+import { createHookDebugTimer } from "./debug-log.js";
+import { fingerprintDynamicTargets } from "./dynamic-target-fingerprints.js";
+import { withDynamicBudget } from "./event-budget.js";
+import { formatAdditionalContextOutput, prepareAdditionalContext } from "./hook-output.js";
+import { displayPath, uniqueStrings } from "./path-utils.js";
+import { claimPostCompactPending, clearSessionState, hasPostCompactPending, hydrateEngineState, isPostCompactRecoveryInProgress, markSessionCompacted, persistEngineState, sessionCachePath, } from "./persistent-cache.js";
+import { withPostCompactBudget } from "./post-compact-budget.js";
+import { claimedPostCompactKind, shouldSkipPostCompactClaim } from "./post-compact-claim.js";
+import { createRulesEngine } from "./rules-engine-factory.js";
+import { runStaticInjection } from "./static-injection.js";
+import { extractCodexToolPaths } from "./tool-paths.js";
+import { filterRulesAlreadyInTranscript } from "./transcript-rule-filter.js";
+export async function runSessionStartHook(input, options = {}) {
+    const cachePath = sessionCachePath(input.session_id, options.pluginDataRoot);
+    if (input.source === "clear") {
+        clearSessionState(cachePath);
+    }
+    else if (input.source !== "resume" && input.source !== "compact" && !hasPostCompactPending(cachePath)) {
+        clearSessionState(cachePath);
+    }
+    const postCompactClaim = input.source === "clear" ? "not-pending" : claimPostCompactPending(cachePath, "static");
+    const completedPostCompactKind = claimedPostCompactKind(postCompactClaim, "static") ??
+        (input.source === "compact" && postCompactClaim === "not-pending" ? "static" : undefined);
+    if (shouldSkipPostCompactClaim(postCompactClaim, input.source === "compact" && isPostCompactRecoveryInProgress(cachePath, "static"))) {
+        return "";
+    }
+    const transcriptPath = input.source === "clear" ? null : input.transcript_path;
+    return runStaticInjection(input.cwd, transcriptPath, "SessionStart", cachePath, options, completedPostCompactKind, { latestCompactedReplacementOnly: completedPostCompactKind !== undefined }, input.model);
+}
+export async function runPostCompactHook(input, options = {}) {
+    markSessionCompacted(sessionCachePath(input.session_id, options.pluginDataRoot));
+    return "";
+}
+export async function runUserPromptSubmitHook(input, options = {}) {
+    if (hasContextPressureMarker(input.prompt)) {
+        return "";
+    }
+    const cachePath = sessionCachePath(input.session_id, options.pluginDataRoot);
+    const postCompactClaim = claimPostCompactPending(cachePath, "static");
+    if (postCompactClaim === "not-pending" && transcriptHasContextPressureMarker(input.transcript_path)) {
+        return "";
+    }
+    const completedPostCompactKind = claimedPostCompactKind(postCompactClaim, "static");
+    if (shouldSkipPostCompactClaim(postCompactClaim, isPostCompactRecoveryInProgress(cachePath, "static"))) {
+        return "";
+    }
+    return runStaticInjection(input.cwd, input.transcript_path, "UserPromptSubmit", cachePath, options, completedPostCompactKind, { latestCompactedReplacementOnly: completedPostCompactKind !== undefined }, input.model);
+}
+export async function runPostToolUseHook(input, options = {}) {
+    const debugTimer = createHookDebugTimer("PostToolUse");
+    const config = configFromEnvironment(options.env);
+    debugTimer.lap("config", { disabled: config.disabled, mode: config.mode });
+    if (config.disabled || config.mode === "off" || config.mode === "static") {
+        debugTimer.done({ outputBytes: 0, reason: "disabled" });
+        return "";
+    }
+    const targetPaths = extractCodexToolPaths(input, input.cwd);
+    debugTimer.lap("extract", {
+        targets: targetPaths.length,
+        uniqueTargets: uniqueStrings(targetPaths).length,
+        tool: input.tool_name,
+    });
+    const firstTargetPath = targetPaths[0];
+    if (firstTargetPath === undefined) {
+        debugTimer.done({ outputBytes: 0, reason: "no-target" });
+        return "";
+    }
+    const cachePath = sessionCachePath(input.session_id, options.pluginDataRoot);
+    const postCompactClaim = claimPostCompactPending(cachePath, "dynamic");
+    if (postCompactClaim === "not-pending" && transcriptHasContextPressureMarker(input.transcript_path)) {
+        debugTimer.done({ outputBytes: 0, reason: "context-pressure-transcript" });
+        return "";
+    }
+    const completedPostCompactKind = claimedPostCompactKind(postCompactClaim, "dynamic");
+    if (shouldSkipPostCompactClaim(postCompactClaim, isPostCompactRecoveryInProgress(cachePath, "dynamic"))) {
+        debugTimer.done({ outputBytes: 0, reason: "post-compact-recovery-in-progress" });
+        return "";
+    }
+    const dynamicConfig = withDynamicBudget(config);
+    const engine = createRulesEngine(options, completedPostCompactKind !== undefined
+        ? withPostCompactBudget(dynamicConfig, { model: input.model, transcriptPath: input.transcript_path })
+        : dynamicConfig);
+    hydrateEngineState(engine, cachePath);
+    debugTimer.lap("hydrate", {
+        dynamicDedupScopes: engine.state.dynamicDedup.size,
+        dynamicTargetFingerprints: engine.state.dynamicTargetFingerprints.size,
+        staticDedup: engine.state.staticDedup.size,
+    });
+    const dynamicTargetFingerprints = fingerprintDynamicTargets(input.cwd, targetPaths, config);
+    debugTimer.lap("fingerprint", { fingerprints: dynamicTargetFingerprints.length });
+    const pendingTargetFingerprints = dynamicTargetFingerprints.filter((target) => engine.state.dynamicTargetFingerprints.get(target.cacheKey) !== target.fingerprint);
+    debugTimer.lap("pending", { pending: pendingTargetFingerprints.length });
+    if (pendingTargetFingerprints.length === 0) {
+        persistEngineState(engine, cachePath, completedPostCompactKind);
+        debugTimer.lap("persist", { reason: "no-pending" });
+        debugTimer.done({ outputBytes: 0, reason: "no-pending" });
+        return "";
+    }
+    const loaded = engine.loadDynamicRules(input.cwd, pendingTargetFingerprints.map((target) => target.targetPath));
+    debugTimer.lap("load", { diagnostics: loaded.diagnostics.length, loadedRules: loaded.rules.length });
+    const rules = filterRulesAlreadyInTranscript(loaded.rules.filter((rule) => !engine.isStaticInjected(rule) &&
+        (completedPostCompactKind !== undefined || !engine.isDynamicInjected(rule))), input.transcript_path, (rule) => {
+        engine.markDynamicInjected(rule);
+    }, { latestCompactedReplacementOnly: completedPostCompactKind !== undefined });
+    debugTimer.lap("filter", { rules: rules.length });
+    if (rules.length === 0) {
+        for (const target of pendingTargetFingerprints) {
+            engine.state.dynamicTargetFingerprints.set(target.cacheKey, target.fingerprint);
+        }
+        persistEngineState(engine, cachePath, completedPostCompactKind);
+        debugTimer.lap("persist", { reason: "no-rules" });
+        debugTimer.done({ outputBytes: 0, reason: "no-rules" });
+        return "";
+    }
+    const firstPendingTargetPath = pendingTargetFingerprints[0]?.targetPath ?? firstTargetPath;
+    const formatted = engine.formatDynamicResult(rules, displayPath(input.cwd, firstPendingTargetPath));
+    const deliveredContext = prepareAdditionalContext(formatted.block);
+    const blockDelivered = formatted.block.length > 0 && deliveredContext.startsWith(formatted.block.trim());
+    debugTimer.lap("format", { blockChars: formatted.block.length, rules: formatted.rules.length });
+    if (blockDelivered) {
+        for (const rule of formatted.rules) {
+            engine.markDynamicInjected(rule);
+        }
+    }
+    if (blockDelivered && formatted.rules.length === rules.length) {
+        for (const target of pendingTargetFingerprints) {
+            engine.state.dynamicTargetFingerprints.set(target.cacheKey, target.fingerprint);
+        }
+    }
+    persistEngineState(engine, cachePath, completedPostCompactKind);
+    debugTimer.lap("persist", { reason: "emit" });
+    const output = formatAdditionalContextOutput("PostToolUse", formatted.block);
+    debugTimer.done({ outputBytes: Buffer.byteLength(output), reason: "emit" });
+    return output;
+}

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

@@ -0,0 +1,2 @@
+import type { PiRulesConfig } from "./rules/types.js";
+export declare function configFromEnvironment(env?: NodeJS.ProcessEnv): PiRulesConfig;

package/marketplace/plugins/litcodex/components/rules/dist/config.js

@@ -0,0 +1,99 @@
+import { SOURCE_PRIORITY } from "./rules/constants.js";
+import { defaultConfig } from "./rules/engine.js";
+export function configFromEnvironment(env = process.env) {
+    const config = defaultConfig();
+    const disableBundledRules = isTruthy(firstEnv(env, "CODEX_RULES_DISABLE_BUNDLED", "PI_RULES_DISABLE_BUNDLED"));
+    config.disabled = isTruthy(firstEnv(env, "CODEX_RULES_DISABLED", "PI_RULES_DISABLED"));
+    config.mode = parseMode(firstEnv(env, "CODEX_RULES_MODE", "PI_RULES_MODE")) ?? config.mode;
+    config.maxRuleChars =
+        parsePositiveInteger(firstEnv(env, "CODEX_RULES_MAX_RULE_CHARS", "PI_RULES_MAX_RULE_CHARS")) ??
+            config.maxRuleChars;
+    config.maxResultChars =
+        parsePositiveInteger(firstEnv(env, "CODEX_RULES_MAX_RESULT_CHARS", "PI_RULES_MAX_RESULT_CHARS")) ??
+            config.maxResultChars;
+    config.postCompactMaxRuleChars =
+        parsePositiveInteger(firstEnv(env, "CODEX_RULES_POST_COMPACT_MAX_RULE_CHARS", "PI_RULES_POST_COMPACT_MAX_RULE_CHARS")) ?? config.postCompactMaxRuleChars;
+    config.postCompactMaxResultChars =
+        parsePositiveInteger(firstEnv(env, "CODEX_RULES_POST_COMPACT_MAX_RESULT_CHARS", "PI_RULES_POST_COMPACT_MAX_RESULT_CHARS")) ?? config.postCompactMaxResultChars;
+    config.dynamicMaxRuleChars =
+        parsePositiveInteger(firstEnv(env, "CODEX_RULES_DYNAMIC_MAX_RULE_CHARS", "PI_RULES_DYNAMIC_MAX_RULE_CHARS")) ??
+            config.dynamicMaxRuleChars;
+    config.dynamicMaxResultChars =
+        parsePositiveInteger(firstEnv(env, "CODEX_RULES_DYNAMIC_MAX_RESULT_CHARS", "PI_RULES_DYNAMIC_MAX_RESULT_CHARS")) ?? config.dynamicMaxResultChars;
+    config.promptMaxRuleChars =
+        parsePositiveInteger(firstEnv(env, "CODEX_RULES_PROMPT_MAX_RULE_CHARS", "PI_RULES_PROMPT_MAX_RULE_CHARS")) ??
+            config.promptMaxRuleChars;
+    config.promptMaxResultChars =
+        parsePositiveInteger(firstEnv(env, "CODEX_RULES_PROMPT_MAX_RESULT_CHARS", "PI_RULES_PROMPT_MAX_RESULT_CHARS")) ??
+            config.promptMaxResultChars;
+    config.enabledSources = parseEnabledSources(firstEnv(env, "CODEX_RULES_ENABLED_SOURCES", "PI_RULES_ENABLED_SOURCES"), disableBundledRules);
+    return config;
+}
+function firstEnv(env, ...names) {
+    for (const name of names) {
+        const value = env[name];
+        if (typeof value === "string" && value.trim().length > 0) {
+            return value;
+        }
+    }
+    return undefined;
+}
+function isTruthy(value) {
+    if (value === undefined)
+        return false;
+    return ["1", "true", "yes", "on"].includes(value.trim().toLowerCase());
+}
+function parseMode(value) {
+    if (value === undefined)
+        return undefined;
+    const normalized = value.trim().toLowerCase();
+    switch (normalized) {
+        case "static":
+        case "dynamic":
+        case "both":
+        case "off":
+            return normalized;
+        default:
+            return undefined;
+    }
+}
+function parsePositiveInteger(value) {
+    if (value === undefined)
+        return undefined;
+    const parsed = Number.parseInt(value.trim(), 10);
+    return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : undefined;
+}
+function parseEnabledSources(value, disableBundledRules) {
+    if (value === undefined || value.trim().toLowerCase() === "auto") {
+        return disableBundledRules ? sourcesWithoutBundledRules() : "auto";
+    }
+    const sources = [];
+    for (const rawSource of value.split(",")) {
+        const source = toRuleSource(rawSource.trim());
+        if (source === null) {
+            continue;
+        }
+        sources.push(source);
+    }
+    const enabledSources = disableBundledRules ? sources.filter((source) => source !== "plugin-bundled") : sources;
+    return enabledSources;
+}
+function sourcesWithoutBundledRules() {
+    return [...SOURCE_PRIORITY.keys()].filter((source) => source !== "plugin-bundled");
+}
+function toRuleSource(value) {
+    switch (value) {
+        case ".litcodex/rules":
+        case ".claude/rules":
+        case ".cursor/rules":
+        case ".github/instructions":
+        case ".github/copilot-instructions.md":
+        case "CONTEXT.md":
+        case "plugin-bundled":
+        case "~/.litcodex/rules":
+        case "~/.claude/rules":
+            return value;
+        default:
+            return null;
+    }
+}

package/marketplace/plugins/litcodex/components/rules/dist/context-pressure.d.ts

@@ -0,0 +1,2 @@
+export declare function hasContextPressureMarker(text: string): boolean;
+export declare function transcriptHasContextPressureMarker(transcriptPath: string | null | undefined): boolean;

package/marketplace/plugins/litcodex/components/rules/dist/context-pressure.js

@@ -0,0 +1,26 @@
+import { readFileSync } from "node:fs";
+const CONTEXT_PRESSURE_MARKERS = [
+    "context compacted",
+    "context_length_exceeded",
+    "skill descriptions were shortened",
+    "context_too_large",
+    "codex ran out of room in the model's context window",
+    "your input exceeds the context window",
+    "long threads and multiple compactions",
+];
+export function hasContextPressureMarker(text) {
+    const normalizedText = text.toLowerCase();
+    return CONTEXT_PRESSURE_MARKERS.some((marker) => normalizedText.includes(marker));
+}
+export function transcriptHasContextPressureMarker(transcriptPath) {
+    if (transcriptPath === undefined || transcriptPath === null)
+        return false;
+    try {
+        return hasContextPressureMarker(readFileSync(transcriptPath, "utf8"));
+    }
+    catch (error) {
+        if (error instanceof Error)
+            return false;
+        throw error;
+    }
+}

package/marketplace/plugins/litcodex/components/rules/dist/debug-log.d.ts

@@ -0,0 +1,8 @@
+type DebugFieldValue = boolean | number | string | null;
+type DebugFields = Record<string, DebugFieldValue>;
+export interface HookDebugTimer {
+    lap(phase: string, fields?: DebugFields): void;
+    done(fields?: DebugFields): void;
+}
+export declare function createHookDebugTimer(hookName: string): HookDebugTimer;
+export {};

package/marketplace/plugins/litcodex/components/rules/dist/debug-log.js

@@ -0,0 +1,36 @@
+import { performance } from "node:perf_hooks";
+import { debuglog } from "node:util";
+const debug = debuglog("codex-rules");
+const noopTimer = {
+    lap: () => { },
+    done: () => { },
+};
+export function createHookDebugTimer(hookName) {
+    if (!debug.enabled) {
+        return noopTimer;
+    }
+    const startMs = performance.now();
+    let lastMs = startMs;
+    return {
+        lap: (phase, fields = {}) => {
+            const nowMs = performance.now();
+            writeDebugLine(hookName, phase, nowMs - lastMs, nowMs - startMs, fields);
+            lastMs = nowMs;
+        },
+        done: (fields = {}) => {
+            const nowMs = performance.now();
+            writeDebugLine(hookName, "done", nowMs - lastMs, nowMs - startMs, fields);
+            lastMs = nowMs;
+        },
+    };
+}
+function writeDebugLine(hookName, phase, durationMs, totalMs, fields) {
+    debug("%s phase=%s ms=%s total_ms=%s%s", hookName, phase, durationMs.toFixed(3), totalMs.toFixed(3), formatFields(fields));
+}
+function formatFields(fields) {
+    const entries = Object.entries(fields);
+    if (entries.length === 0) {
+        return "";
+    }
+    return ` ${entries.map(([key, value]) => `${key}=${String(value)}`).join(" ")}`;
+}

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

@@ -0,0 +1,36 @@
+import type { CodexPostToolUseInput } from "./codex-hook.js";
+export declare const artifactGenres: readonly ["client_deliverable", "internal_analysis", "audit_report", "working_note", "no_artifact"];
+export type ArtifactGenre = (typeof artifactGenres)[number];
+export type LimitationsChannel = "reply" | "designated_section" | "methodology_paragraph" | "inline";
+export type OutputChannelContract = {
+    readonly artifactGenre: ArtifactGenre;
+    readonly limitationsChannel: LimitationsChannel;
+};
+export type DeliverableHedgeFinding = {
+    readonly category: "deferred" | "absent-evidence" | "scope-limit" | "negated-action" | "self-protection" | "process-meta";
+    readonly line: number;
+};
+export type PendingArtifactWrite = {
+    readonly path: string;
+    readonly content: string;
+};
+export type PendingArtifactExtraction = {
+    readonly ok: true;
+    readonly writes: readonly PendingArtifactWrite[];
+} | {
+    readonly ok: false;
+    readonly reason: "unsupported" | "path-limit" | "content-limit";
+};
+export type DeliverableHedgeGuardOptions = {
+    readonly inspect?: (text: string, genre: ArtifactGenre, maxFindings?: number) => DeliverableHedgeFinding[];
+};
+export declare const deliverableRuntimeLimits: Readonly<{
+    maxPathCandidates: 64;
+    maxAggregateContentBytes: number;
+    maxFindings: 256;
+    maxOutputBytes: 2048;
+}>;
+export declare function readOutputChannelContract(skillId: string, skillRoot?: string): OutputChannelContract;
+export declare function inspectDeliverableHedges(text: string, genre: ArtifactGenre, maxFindings?: number): DeliverableHedgeFinding[];
+export declare function extractBoundedPendingArtifactWrites(input: CodexPostToolUseInput): PendingArtifactExtraction;
+export declare function runDeliverableHedgePostToolUse(input: CodexPostToolUseInput, options?: DeliverableHedgeGuardOptions): string;