@litfamily/litopencode 1.0.0

package/dist/config-parser.js

@@ -0,0 +1,274 @@
+import fs from "node:fs/promises";
+export class LitOpenCodeConfigError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "LitOpenCodeConfigError";
+    }
+}
+const logLevels = new Set(["silent", "error", "info", "debug"]);
+const permissionModes = new Set(["safe", "balanced", "yolo"]);
+const outputStyleIds = new Set(["off", "asd-ste100", "asd-ste100-ko", "eli5", "eli5-ko"]);
+const reasoningEfforts = new Set(["none", "minimal", "low", "medium", "high", "xhigh", "max"]);
+const textVerbosities = new Set(["low", "medium", "high"]);
+const toolIds = new Set(["read", "write", "edit", "bash", "webfetch", "grep"]);
+const permissions = new Set(["ask", "allow", "deny"]);
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function optionalString(value, filePath, field) {
+    if (value === undefined || value === null)
+        return undefined;
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new LitOpenCodeConfigError(`Malformed LitOpenCode config at ${filePath}: ${field} must be a non-empty string.`);
+    }
+    return value;
+}
+function optionalBoolean(value, filePath, field) {
+    if (value === undefined || value === null)
+        return undefined;
+    if (typeof value !== "boolean") {
+        throw new LitOpenCodeConfigError(`Malformed LitOpenCode config at ${filePath}: ${field} must be boolean.`);
+    }
+    return value;
+}
+function optionalNumber(value, filePath, field) {
+    if (value === undefined || value === null)
+        return undefined;
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        throw new LitOpenCodeConfigError(`Malformed LitOpenCode config at ${filePath}: ${field} must be a finite number.`);
+    }
+    return value;
+}
+function boundedInteger(value, filePath, field, minimum, maximum) {
+    if (!Number.isSafeInteger(value) || value < minimum || value > maximum) {
+        throw new LitOpenCodeConfigError(`Malformed LitOpenCode config at ${filePath}: ${field} must be an integer between ${minimum} and ${maximum}.`);
+    }
+    return value;
+}
+function parseBoundedAuthority(value, filePath) {
+    if (value === undefined || value === null)
+        return undefined;
+    if (!isRecord(value)) {
+        throw new LitOpenCodeConfigError(`Malformed LitOpenCode config at ${filePath}: boundedAuthority must be an object.`);
+    }
+    const supported = new Set(["maxEvents", "maxHistory", "maxReceipts", "maxContextBytes"]);
+    for (const key of Object.keys(value)) {
+        if (!supported.has(key)) {
+            throw new LitOpenCodeConfigError(`Malformed LitOpenCode config at ${filePath}: boundedAuthority.${key} is not a supported setting.`);
+        }
+    }
+    const parsed = {};
+    if (value.maxEvents !== undefined)
+        parsed.maxEvents = boundedInteger(value.maxEvents, filePath, "boundedAuthority.maxEvents", 2, 512);
+    if (value.maxHistory !== undefined)
+        parsed.maxHistory = boundedInteger(value.maxHistory, filePath, "boundedAuthority.maxHistory", 1, 256);
+    if (value.maxReceipts !== undefined)
+        parsed.maxReceipts = boundedInteger(value.maxReceipts, filePath, "boundedAuthority.maxReceipts", 4, 512);
+    if (value.maxContextBytes !== undefined) {
+        parsed.maxContextBytes = boundedInteger(value.maxContextBytes, filePath, "boundedAuthority.maxContextBytes", 1024, 1_048_576);
+    }
+    return parsed;
+}
+function parseKnowledge(value, filePath) {
+    if (value === undefined || value === null)
+        return undefined;
+    if (!isRecord(value)) {
+        throw new LitOpenCodeConfigError(`Malformed LitOpenCode config at ${filePath}: knowledge must be an object.`);
+    }
+    for (const key of Object.keys(value)) {
+        if (key !== "capture") {
+            throw new LitOpenCodeConfigError(`Malformed LitOpenCode config at ${filePath}: knowledge.${key} is not a supported setting.`);
+        }
+    }
+    const capture = optionalBoolean(value.capture, filePath, "knowledge.capture");
+    return capture === undefined ? {} : { capture };
+}
+function optionalReasoningEffort(value, filePath, field) {
+    if (value === undefined || value === null)
+        return undefined;
+    if (typeof value !== "string" || !reasoningEfforts.has(value)) {
+        throw new LitOpenCodeConfigError(`Malformed LitOpenCode config at ${filePath}: ${field} must be one of none, minimal, low, medium, high, xhigh, max.`);
+    }
+    return value;
+}
+function optionalTextVerbosity(value, filePath, field) {
+    if (value === undefined || value === null)
+        return undefined;
+    if (typeof value !== "string" || !textVerbosities.has(value)) {
+        throw new LitOpenCodeConfigError(`Malformed LitOpenCode config at ${filePath}: ${field} must be one of low, medium, high.`);
+    }
+    return value;
+}
+function parseTools(value, filePath, field) {
+    if (value === undefined || value === null)
+        return undefined;
+    if (!isRecord(value)) {
+        throw new LitOpenCodeConfigError(`Malformed LitOpenCode config at ${filePath}: ${field} must be an object.`);
+    }
+    const tools = {};
+    for (const [tool, enabled] of Object.entries(value)) {
+        if (!toolIds.has(tool)) {
+            throw new LitOpenCodeConfigError(`Malformed LitOpenCode config at ${filePath}: ${field}.${tool} is not a supported tool id.`);
+        }
+        if (typeof enabled !== "boolean") {
+            throw new LitOpenCodeConfigError(`Malformed LitOpenCode config at ${filePath}: ${field}.${tool} must be boolean.`);
+        }
+        tools[tool] = enabled;
+    }
+    return tools;
+}
+function parsePermission(value, filePath, field) {
+    if (value === undefined || value === null)
+        return undefined;
+    if (!isRecord(value)) {
+        throw new LitOpenCodeConfigError(`Malformed LitOpenCode config at ${filePath}: ${field} must be an object.`);
+    }
+    const parsed = {};
+    for (const key of ["edit", "bash", "webfetch"]) {
+        const permission = value[key];
+        if (permission === undefined || permission === null)
+            continue;
+        if (typeof permission !== "string" || !permissions.has(permission)) {
+            throw new LitOpenCodeConfigError(`Malformed LitOpenCode config at ${filePath}: ${field}.${key} must be one of ask, allow, deny.`);
+        }
+        parsed[key] = permission;
+    }
+    return Object.keys(parsed).length > 0 ? parsed : undefined;
+}
+function assertJsonValue(value, filePath, field) {
+    if (value === null || typeof value === "string" || typeof value === "boolean")
+        return;
+    if (typeof value === "number") {
+        if (!Number.isFinite(value)) {
+            throw new LitOpenCodeConfigError(`Malformed LitOpenCode config at ${filePath}: ${field} must be finite JSON.`);
+        }
+        return;
+    }
+    if (Array.isArray(value)) {
+        for (const [index, item] of value.entries())
+            assertJsonValue(item, filePath, `${field}[${index}]`);
+        return;
+    }
+    if (isRecord(value)) {
+        for (const [key, item] of Object.entries(value))
+            assertJsonValue(item, filePath, `${field}.${key}`);
+        return;
+    }
+    throw new LitOpenCodeConfigError(`Malformed LitOpenCode config at ${filePath}: ${field} must be JSON-compatible.`);
+}
+function parseProviderOptions(value, filePath, field) {
+    if (value === undefined || value === null)
+        return undefined;
+    if (!isRecord(value)) {
+        throw new LitOpenCodeConfigError(`Malformed LitOpenCode config at ${filePath}: ${field} must be an object.`);
+    }
+    assertJsonValue(value, filePath, field);
+    return value;
+}
+function removeUndefined(value) {
+    for (const key of Object.keys(value)) {
+        if (value[key] === undefined)
+            delete value[key];
+    }
+    return value;
+}
+function parseAgentModelConfig(value, filePath, field) {
+    if (!isRecord(value)) {
+        throw new LitOpenCodeConfigError(`Malformed LitOpenCode config at ${filePath}: ${field} must be an object.`);
+    }
+    return removeUndefined({
+        provider: optionalString(value.provider, filePath, `${field}.provider`),
+        model: optionalString(value.model, filePath, `${field}.model`),
+        variant: optionalString(value.variant, filePath, `${field}.variant`),
+        category: optionalString(value.category, filePath, `${field}.category`),
+        reasoningEffort: optionalReasoningEffort(value.reasoningEffort, filePath, `${field}.reasoningEffort`),
+        textVerbosity: optionalTextVerbosity(value.textVerbosity, filePath, `${field}.textVerbosity`),
+        thinking: optionalBoolean(value.thinking, filePath, `${field}.thinking`),
+        temperature: optionalNumber(value.temperature, filePath, `${field}.temperature`),
+        topP: optionalNumber(value.topP ?? value.top_p, filePath, `${field}.topP`),
+        maxTokens: optionalNumber(value.maxTokens, filePath, `${field}.maxTokens`),
+        promptAppend: optionalString(value.promptAppend ?? value.prompt_append, filePath, `${field}.promptAppend`),
+        tools: parseTools(value.tools, filePath, `${field}.tools`),
+        permission: parsePermission(value.permission, filePath, `${field}.permission`),
+        providerOptions: parseProviderOptions(value.providerOptions, filePath, `${field}.providerOptions`)
+    });
+}
+function parseCategoryConfig(value, filePath, field) {
+    const parsed = parseAgentModelConfig(value, filePath, field);
+    const { category: _category, ...categoryConfig } = parsed;
+    return categoryConfig;
+}
+function parseNamedMap(value, filePath, field, parseItem) {
+    if (value === undefined || value === null)
+        return {};
+    if (!isRecord(value)) {
+        throw new LitOpenCodeConfigError(`Malformed LitOpenCode config at ${filePath}: ${field} must be an object.`);
+    }
+    const parsed = {};
+    for (const [key, item] of Object.entries(value)) {
+        if (key.trim().length === 0) {
+            throw new LitOpenCodeConfigError(`Malformed LitOpenCode config at ${filePath}: ${field} keys must be non-empty.`);
+        }
+        parsed[key] = parseItem(item, filePath, `${field}.${key}`);
+    }
+    return parsed;
+}
+function parseConfig(value, filePath) {
+    if (!isRecord(value)) {
+        throw new LitOpenCodeConfigError(`Malformed LitOpenCode config at ${filePath}: expected a JSON object.`);
+    }
+    const config = {};
+    if ("enabled" in value) {
+        if (typeof value.enabled !== "boolean") {
+            throw new LitOpenCodeConfigError(`Malformed LitOpenCode config at ${filePath}: enabled must be boolean.`);
+        }
+        config.enabled = value.enabled;
+    }
+    if ("logLevel" in value) {
+        if (typeof value.logLevel !== "string" || !logLevels.has(value.logLevel)) {
+            throw new LitOpenCodeConfigError(`Malformed LitOpenCode config at ${filePath}: logLevel must be one of silent, error, info, debug.`);
+        }
+        config.logLevel = value.logLevel;
+    }
+    if ("permissionMode" in value) {
+        if (typeof value.permissionMode !== "string" || !permissionModes.has(value.permissionMode)) {
+            throw new LitOpenCodeConfigError(`Malformed LitOpenCode config at ${filePath}: permissionMode must be one of safe, balanced, yolo.`);
+        }
+        config.permissionMode = value.permissionMode;
+    }
+    if ("outputStyle" in value) {
+        if (typeof value.outputStyle !== "string" || !outputStyleIds.has(value.outputStyle)) {
+            throw new LitOpenCodeConfigError(`Malformed LitOpenCode config at ${filePath}: outputStyle must be one of off, asd-ste100, asd-ste100-ko, eli5, eli5-ko.`);
+        }
+        config.outputStyle = value.outputStyle;
+    }
+    if ("boundedAuthority" in value) {
+        config.boundedAuthority = parseBoundedAuthority(value.boundedAuthority, filePath);
+    }
+    if ("knowledge" in value) {
+        config.knowledge = parseKnowledge(value.knowledge, filePath);
+    }
+    config.categories = parseNamedMap(value.categories, filePath, "categories", parseCategoryConfig);
+    config.agents = parseNamedMap(value.agents, filePath, "agents", parseAgentModelConfig);
+    return config;
+}
+export async function readLitOpenCodeConfigFile(filePath) {
+    let raw;
+    try {
+        raw = await fs.readFile(filePath, "utf8");
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT")
+            return undefined;
+        throw error;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : "invalid JSON";
+        throw new LitOpenCodeConfigError(`Malformed LitOpenCode config at ${filePath}: ${reason}`);
+    }
+    return parseConfig(parsed, filePath);
+}

package/dist/config.d.ts

@@ -0,0 +1,72 @@
+import { type RuntimePaths } from "./state.ts";
+import type { AgentPermission, AgentToolId } from "./agents/types.ts";
+export { LitOpenCodeConfigError, readLitOpenCodeConfigFile } from "./config-parser.ts";
+export type LogLevel = "silent" | "error" | "info" | "debug";
+export type LitOpenCodeConfigSource = "defaults" | "global" | "project" | "merged";
+export type LitOpenCodePermissionMode = "safe" | "balanced" | "yolo";
+export type ReasoningEffort = "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+export type TextVerbosity = "low" | "medium" | "high";
+export type BoundedAuthorityConfig = {
+    readonly maxEvents: number;
+    readonly maxHistory: number;
+    readonly maxReceipts: number;
+    readonly maxContextBytes: number;
+};
+export type KnowledgeConfig = {
+    readonly capture: boolean;
+};
+export type JsonScalar = string | number | boolean | null;
+export type JsonObject = {
+    readonly [key: string]: JsonValue;
+};
+export type JsonValue = JsonScalar | readonly JsonValue[] | JsonObject;
+export type LitOpenCodeAgentModelConfig = {
+    readonly provider?: string;
+    readonly model?: string;
+    readonly variant?: string;
+    readonly category?: string;
+    readonly reasoningEffort?: ReasoningEffort;
+    readonly textVerbosity?: TextVerbosity;
+    readonly thinking?: boolean;
+    readonly temperature?: number;
+    readonly topP?: number;
+    readonly maxTokens?: number;
+    readonly promptAppend?: string;
+    readonly tools?: Partial<Record<AgentToolId, boolean>>;
+    readonly permission?: {
+        readonly edit?: AgentPermission;
+        readonly bash?: AgentPermission;
+        readonly webfetch?: AgentPermission;
+    };
+    readonly providerOptions?: JsonObject;
+};
+export type LitOpenCodeCategoryConfig = Omit<LitOpenCodeAgentModelConfig, "category">;
+export type LitOpenCodeConfig = {
+    enabled: boolean;
+    logLevel: LogLevel;
+    permissionMode: LitOpenCodePermissionMode;
+    outputStyle: string;
+    boundedAuthority: BoundedAuthorityConfig;
+    knowledge: KnowledgeConfig;
+    agents: Record<string, LitOpenCodeAgentModelConfig>;
+    categories: Record<string, LitOpenCodeCategoryConfig>;
+};
+export type LoadedConfig = {
+    config: LitOpenCodeConfig;
+    paths: RuntimePaths;
+    source: LitOpenCodeConfigSource;
+    sources: readonly string[];
+};
+type AuthoredConfigSections = {
+    readonly categories: ReadonlySet<string>;
+    readonly agents: ReadonlySet<string>;
+};
+export declare function configSectionWasAuthored(config: LitOpenCodeConfig, section: keyof AuthoredConfigSections, id: string): boolean;
+export declare const defaultConfig: LitOpenCodeConfig;
+export declare const litOpenCodeConfigSchema = "https://litopencode.dev/config.schema.json";
+export declare function mergeAgentModelConfig(base: LitOpenCodeAgentModelConfig | undefined, override: LitOpenCodeAgentModelConfig | undefined): LitOpenCodeAgentModelConfig;
+export declare function mergeConfigs(base: LitOpenCodeConfig, override: Partial<LitOpenCodeConfig>): LitOpenCodeConfig;
+export declare function defaultGlobalConfigFile(): LitOpenCodeConfig;
+export declare function defaultGlobalConfigJson(): Record<string, unknown>;
+export declare function effectiveAgentConfig(config: LitOpenCodeConfig, agentId: string): LitOpenCodeAgentModelConfig;
+export declare function loadConfig(projectRoot: string): Promise<LoadedConfig>;

package/dist/config.js

@@ -0,0 +1,157 @@
+import { createRuntimePaths } from "./state.js";
+import { readLitOpenCodeConfigFile } from "./config-parser.js";
+export { LitOpenCodeConfigError, readLitOpenCodeConfigFile } from "./config-parser.js";
+// The runtime receives a merged config, so keep source ownership alongside
+// (rather than inside) the JSON-shaped config. This never serializes into a
+// user file and lets the host hook distinguish a fresh default from an
+// explicit value that happens to equal that default.
+const authoredConfigSections = new WeakMap();
+export function configSectionWasAuthored(config, section, id) {
+    return authoredConfigSections.get(config)?.[section].has(id) ?? false;
+}
+export const defaultConfig = Object.freeze({
+    enabled: true,
+    logLevel: "info",
+    permissionMode: "safe",
+    outputStyle: "off",
+    boundedAuthority: Object.freeze({
+        maxEvents: 64,
+        maxHistory: 32,
+        maxReceipts: 64,
+        maxContextBytes: 65_536
+    }),
+    knowledge: Object.freeze({ capture: true }),
+    categories: Object.freeze({
+        planning: Object.freeze({
+            provider: "openai",
+            model: "gpt-6-astra",
+            variant: "xhigh",
+            textVerbosity: "medium"
+        }),
+        execution: Object.freeze({
+            provider: "openai",
+            model: "gpt-5.6-luna",
+            variant: "max",
+            textVerbosity: "medium"
+        }),
+        review: Object.freeze({
+            provider: "openai",
+            model: "gpt-6-astra",
+            variant: "xhigh",
+            textVerbosity: "medium"
+        }),
+        research: Object.freeze({
+            provider: "openai",
+            model: "gpt-5.6-luna",
+            variant: "max",
+            textVerbosity: "medium"
+        })
+    }),
+    agents: Object.freeze({
+        "lit-loop": Object.freeze({ category: "execution" }),
+        "lit-plan": Object.freeze({ category: "planning" }),
+        "lit-implement": Object.freeze({ category: "execution" }),
+        "lit-architect": Object.freeze({ category: "planning" }),
+        "lit-forge": Object.freeze({ category: "execution" }),
+        "lit-oracle": Object.freeze({ category: "review" }),
+        "lit-prover": Object.freeze({ category: "review" }),
+        "lit-sentinel": Object.freeze({ category: "review" }),
+        "lit-librarian": Object.freeze({ category: "research" }),
+        "lit-explorer": Object.freeze({ category: "research" }),
+        "lit-archive-researcher": Object.freeze({ category: "review" }),
+        "lit-verdict-oracle": Object.freeze({ category: "review" }),
+        "lit-strategy-planner": Object.freeze({ category: "planning" }),
+        "lit-forge-worker": Object.freeze({ category: "execution" }),
+        "lit-systems-architect": Object.freeze({ category: "planning" }),
+        "lit-critical-reviewer": Object.freeze({ category: "review" }),
+        "lit-context-cartographer": Object.freeze({ category: "review" }),
+        "lit-persistence-runner": Object.freeze({ category: "execution" })
+    })
+});
+export const litOpenCodeConfigSchema = "https://litopencode.dev/config.schema.json";
+function cloneDefaultConfig() {
+    return mergeConfigs(defaultConfig, {});
+}
+export function mergeAgentModelConfig(base, override) {
+    const tools = { ...(base?.tools ?? {}), ...(override?.tools ?? {}) };
+    const permission = { ...(base?.permission ?? {}), ...(override?.permission ?? {}) };
+    const providerOptions = { ...(base?.providerOptions ?? {}), ...(override?.providerOptions ?? {}) };
+    return {
+        ...(base ?? {}),
+        ...(override ?? {}),
+        ...(Object.keys(tools).length > 0 ? { tools } : {}),
+        ...(Object.keys(permission).length > 0 ? { permission } : {}),
+        ...(Object.keys(providerOptions).length > 0 ? { providerOptions } : {})
+    };
+}
+export function mergeConfigs(base, override) {
+    const categories = { ...base.categories };
+    for (const [id, category] of Object.entries(override.categories ?? {})) {
+        categories[id] = mergeAgentModelConfig(categories[id], category);
+    }
+    const agents = { ...base.agents };
+    for (const [id, agent] of Object.entries(override.agents ?? {})) {
+        agents[id] = mergeAgentModelConfig(agents[id], agent);
+    }
+    const merged = {
+        enabled: override.enabled ?? base.enabled,
+        logLevel: override.logLevel ?? base.logLevel,
+        permissionMode: override.permissionMode ?? base.permissionMode,
+        outputStyle: override.outputStyle ?? base.outputStyle,
+        boundedAuthority: {
+            ...base.boundedAuthority,
+            ...(override.boundedAuthority ?? {})
+        },
+        knowledge: {
+            ...base.knowledge,
+            ...(override.knowledge ?? {})
+        },
+        categories,
+        agents
+    };
+    const baseAuthored = authoredConfigSections.get(base);
+    authoredConfigSections.set(merged, {
+        categories: new Set([
+            ...(baseAuthored?.categories ?? []),
+            ...Object.keys(override.categories ?? {})
+        ]),
+        agents: new Set([
+            ...(baseAuthored?.agents ?? []),
+            ...Object.keys(override.agents ?? {})
+        ])
+    });
+    return merged;
+}
+export function defaultGlobalConfigFile() {
+    return cloneDefaultConfig();
+}
+export function defaultGlobalConfigJson() {
+    return {
+        "$schema": litOpenCodeConfigSchema,
+        ...defaultGlobalConfigFile()
+    };
+}
+export function effectiveAgentConfig(config, agentId) {
+    const agentConfig = config.agents[agentId] ?? {};
+    const categoryConfig = agentConfig.category ? config.categories[agentConfig.category] : undefined;
+    return mergeAgentModelConfig(categoryConfig, agentConfig);
+}
+export async function loadConfig(projectRoot) {
+    const paths = createRuntimePaths(projectRoot);
+    const globalConfig = await readLitOpenCodeConfigFile(paths.globalConfigFile);
+    const projectConfig = await readLitOpenCodeConfigFile(paths.configFile);
+    const sources = [];
+    let source = "defaults";
+    let config = cloneDefaultConfig();
+    if (globalConfig !== undefined) {
+        config = mergeConfigs(config, globalConfig);
+        sources.push(paths.globalConfigFile);
+        source = "global";
+    }
+    if (projectConfig !== undefined) {
+        config = mergeConfigs(config, projectConfig);
+        sources.push(paths.configFile);
+        source = source === "global" ? "merged" : "project";
+    }
+    return { config, paths, source, sources };
+}

package/dist/deliverable-hedge-guard.d.ts

@@ -0,0 +1,26 @@
+import { type ToolGuardAfterOutput, type ToolGuardRequest } from "./tool-guards.ts";
+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 HedgeClass = "deferred" | "absent-evidence" | "scope-limit" | "negated-action" | "self-protection" | "process-meta";
+export type DeliverableHedgeFinding = {
+    readonly className: HedgeClass;
+    readonly line: number;
+};
+export declare function readOutputChannelContract(skillId: string, root?: string): Promise<OutputChannelContract>;
+export type DeliverableHedgeSessionState = {
+    readonly activate: (sessionID: string, routeId: string) => Promise<void>;
+    readonly clear: (sessionID: string) => void;
+    readonly dispose: () => void;
+    readonly contractFor: (sessionID: string) => {
+        readonly skillId: string;
+        readonly contract: OutputChannelContract;
+    } | undefined;
+};
+export declare function createDeliverableHedgeSessionState(root?: string): DeliverableHedgeSessionState;
+export declare function inspectDeliverableHedges(text: string, genre: ArtifactGenre): readonly DeliverableHedgeFinding[];
+export declare function applyDeliverableHedgeAfterHook(state: DeliverableHedgeSessionState, input: ToolGuardRequest, output: ToolGuardAfterOutput): Promise<void>;