@fenixforce/kernel 0.1.0

package/dist/security/tool-access-control.d.ts

@@ -0,0 +1,114 @@
+/**
+ * Per-Tool Access Control — tool registry ACL with per-agent,
+ * per-edition configuration. Edition manifests declare available
+ * tool sets; agents receive a subset of those tools based on
+ * their role and explicit grants/denials.
+ *
+ * Access resolution order:
+ *  1. Tool must exist in the registry
+ *  2. Tool must be included in the active edition manifest
+ *  3. Agent must have access (explicit grant, role default, or wildcard)
+ *  4. Tool must not be in the agent's deny list
+ *
+ * A denied tool always wins over a grant (deny takes precedence).
+ */
+export type ToolCategory = "llm" | "web" | "file" | "memory" | "browser" | "media" | "notification" | "admin" | "system";
+export interface ToolDefinition {
+    /** Unique tool name (e.g. "file.read", "web.search"). */
+    name: string;
+    /** Human-readable description. */
+    description: string;
+    /** Tool category for bulk grants. */
+    category: ToolCategory;
+    /** Whether this tool has side effects (writes, sends, deletes). */
+    sideEffects: boolean;
+    /** Optional tags for fine-grained filtering. */
+    tags?: string[];
+}
+export type EditionName = "pro" | "mobile" | "voices" | string;
+export interface EditionManifest {
+    /** Edition identifier. */
+    name: EditionName;
+    /** Human-readable label. */
+    label: string;
+    /** Tool names available in this edition. Use "*" for all. */
+    tools: string[];
+    /** Tool categories included (expanded to individual tools at check time). */
+    categories?: ToolCategory[];
+    /** Maximum number of concurrent workers. Informational. */
+    maxWorkers?: number;
+}
+export type AgentRole = "admin" | "standard" | "restricted" | "readonly";
+export interface AgentConfig {
+    /** Unique agent identifier. */
+    agentId: string;
+    /** Human-readable name. */
+    name?: string;
+    /** Agent role — determines default access level. */
+    role: AgentRole;
+    /** Explicit tool grants (overrides role defaults).
+     *  Use "*" for all tools, "category:<name>" for category grants. */
+    grants?: string[];
+    /** Explicit tool denials (always takes precedence over grants). */
+    denials?: string[];
+}
+export type AccessVerdict = "allow" | "deny";
+export interface AccessCheckResult {
+    verdict: AccessVerdict;
+    toolName: string;
+    agentId: string;
+    edition: EditionName;
+    reason: string;
+}
+export type AccessEventType = "tool_registered" | "tool_removed" | "edition_set" | "agent_registered" | "agent_removed" | "access_allowed" | "access_denied";
+export interface AccessEvent {
+    type: AccessEventType;
+    timestamp: Date;
+    detail: string;
+    toolName?: string;
+    agentId?: string;
+    edition?: EditionName;
+}
+export type AccessEventListener = (event: AccessEvent) => void;
+export declare const EDITION_PRO: EditionManifest;
+export declare const EDITION_MOBILE: EditionManifest;
+export declare const EDITION_VOICES: EditionManifest;
+export interface ToolAccessControlConfig {
+    /** The active edition manifest. */
+    edition: EditionManifest;
+}
+export interface ToolAccessControl {
+    /** Register a tool definition. */
+    registerTool(tool: ToolDefinition): void;
+    /** Remove a tool from the registry. */
+    removeTool(name: string): boolean;
+    /** Get a tool definition. */
+    getTool(name: string): ToolDefinition | undefined;
+    /** List all registered tools. */
+    listTools(): ToolDefinition[];
+    /** List tools by category. */
+    listToolsByCategory(category: ToolCategory): ToolDefinition[];
+    /** Get the active edition manifest. */
+    getEdition(): EditionManifest;
+    /** Set/switch the active edition manifest. */
+    setEdition(manifest: EditionManifest): void;
+    /** Check if a tool is available in the current edition. */
+    isToolInEdition(toolName: string): boolean;
+    /** List all tools available in the current edition. */
+    listEditionTools(): ToolDefinition[];
+    /** Register an agent with its access configuration. */
+    registerAgent(config: AgentConfig): void;
+    /** Remove an agent. */
+    removeAgent(agentId: string): boolean;
+    /** Get an agent's configuration. */
+    getAgent(agentId: string): AgentConfig | undefined;
+    /** List all agents. */
+    listAgents(): AgentConfig[];
+    /** Check if an agent can use a specific tool. */
+    checkAccess(agentId: string, toolName: string): AccessCheckResult;
+    /** List all tools an agent can use (intersection of edition + grants). */
+    listAccessibleTools(agentId: string): ToolDefinition[];
+    on(listener: AccessEventListener): void;
+    off(listener: AccessEventListener): void;
+}
+export declare function createToolAccessControl(config: ToolAccessControlConfig): ToolAccessControl;

package/dist/session-compaction.d.ts

@@ -0,0 +1,20 @@
+import type { Message } from "./providers/interface.js";
+import type { LLMProvider } from "./providers/interface.js";
+import type { AgentEvent } from "./events/types.js";
+export type CompactionStrategy = "summarize-all" | "summarize-oldest" | "hybrid";
+export interface CompactionContext {
+    contextWindowTokens: number;
+    utilityProvider?: LLMProvider;
+    utilityModel?: string;
+    sessionId?: string;
+}
+export interface CompactionResult {
+    messages: Message[];
+    removed: number;
+    strategy: CompactionStrategy;
+    beforeTokens: number;
+    afterTokens: number;
+}
+export declare function shouldCompact(messages: Message[], context: CompactionContext): boolean;
+export declare function sessionCompact(messages: Message[], context: CompactionContext): Promise<CompactionResult>;
+export declare function sessionCompactWithEvents(messages: Message[], context: CompactionContext): AsyncGenerator<AgentEvent, CompactionResult>;

package/dist/session-orient.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Session orient — lightweight initialization that runs before the
+ * first LLM call in each conversation. Gathers user profile, pending
+ * jobs, observation thresholds, and brain artifacts into a single
+ * context object for system-prompt injection.
+ */
+import type { StorageAdapter, UserProfile, BrainArtifact } from "./storage/interface.js";
+import { type ObservationReviewResult } from "./memory/observation-thresholds.js";
+export interface OrientContext {
+    userId: string;
+    conversationId: string;
+    storage: StorageAdapter;
+}
+export interface OrientResult {
+    profile: UserProfile | null;
+    pendingJobs: number;
+    nextJobAt: Date | null;
+    observationReview: ObservationReviewResult | null;
+    brainArtifacts: BrainArtifact[];
+    orientPromptSection: string;
+}
+export declare function sessionOrient(ctx: OrientContext): Promise<OrientResult>;

package/dist/session-repair.d.ts

@@ -0,0 +1,6 @@
+import type { Message } from "./providers/interface.js";
+/**
+ * Runs all 7 repair phases on a message array.
+ * Mutates in-place for performance but returns the array for chaining.
+ */
+export declare function repairSession(messages: Message[]): Message[];

package/dist/storage/index.d.ts

@@ -0,0 +1,24 @@
+import type { StorageAdapter } from "./interface.js";
+export type { StorageAdapter } from "./interface.js";
+export * from "./interface.js";
+export { createPostgresStorage } from "./postgres.js";
+export type { PostgresStorageConfig } from "./postgres.js";
+export { createSqliteStorage } from "./sqlite.js";
+export interface StorageConfig {
+    backend: "postgres" | "sqlite";
+    connectionString?: string;
+    /** Maximum pool size (postgres only). */
+    maxConnections?: number;
+}
+/**
+ * Create a StorageAdapter from config.
+ *
+ * ```ts
+ * const storage = createStorage({
+ *   backend: "postgres",
+ *   connectionString: process.env.DATABASE_URL,
+ * });
+ * await storage.initialize();
+ * ```
+ */
+export declare function createStorage(config: StorageConfig): StorageAdapter;

package/dist/storage/interface.d.ts

@@ -0,0 +1,245 @@
+export interface User {
+    id: string;
+    externalId: string;
+    platform: string;
+    displayName: string | null;
+    email: string | null;
+    metadata: Record<string, unknown>;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export interface Conversation {
+    id: string;
+    userId: string;
+    title: string | null;
+    channel: string;
+    metadata: Record<string, unknown>;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export interface Message {
+    id: string;
+    conversationId: string;
+    userId: string;
+    role: "user" | "assistant" | "system" | "tool";
+    content: string;
+    channel: string;
+    tokenCount: number | null;
+    metadata: Record<string, unknown>;
+    createdAt: Date;
+}
+export interface MemorySegment {
+    id: string;
+    userId: string;
+    content: string;
+    category: "fact" | "preference" | "experience" | "knowledge";
+    embedding: number[] | null;
+    heat: number;
+    accessCount: number;
+    lastAccessedAt: Date;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export interface MemorySearchResult {
+    segment: MemorySegment;
+    score: number;
+}
+export interface UserProfile {
+    userId: string;
+    summary: string;
+    updatedAt: Date;
+}
+export interface Observation {
+    id: string;
+    userId: string;
+    conversationId: string | null;
+    content: string;
+    category: string;
+    reviewed: boolean;
+    createdAt: Date;
+    reviewedAt: Date | null;
+}
+export interface Entity {
+    id: string;
+    userId: string;
+    name: string;
+    entityType: string;
+    metadata: Record<string, unknown>;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export interface Relation {
+    id: string;
+    userId: string;
+    sourceEntityId: string;
+    targetEntityId: string;
+    relationType: string;
+    strength: number;
+    metadata: Record<string, unknown>;
+    createdAt: Date;
+}
+export interface Checkpoint {
+    id: string;
+    conversationId: string;
+    summary: string;
+    tokensSaved: number;
+    createdAt: Date;
+}
+export interface BrainArtifact {
+    id: string;
+    conversationId: string;
+    artifactType: string;
+    title: string;
+    content: string;
+    metadata: Record<string, unknown>;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export interface ApprovalRecord {
+    id: string;
+    userId: string;
+    conversationId: string;
+    action: string;
+    status: "pending" | "approved" | "denied";
+    payload: Record<string, unknown>;
+    decidedAt: Date | null;
+    createdAt: Date;
+}
+export interface CostLog {
+    id: string;
+    userId: string;
+    conversationId: string | null;
+    provider: string;
+    model: string;
+    inputTokens: number;
+    outputTokens: number;
+    costUsd: number;
+    createdAt: Date;
+}
+export interface CostEvent {
+    id: string;
+    userId: string;
+    eventType: string;
+    amount: number;
+    currency: string;
+    metadata: Record<string, unknown>;
+    createdAt: Date;
+}
+export type JobStatus = "pending" | "running" | "completed" | "failed" | "dead";
+export interface Job {
+    id: string;
+    type: string;
+    status: JobStatus;
+    priority: number;
+    payload: Record<string, unknown>;
+    result: Record<string, unknown> | null;
+    error: string | null;
+    attempts: number;
+    maxAttempts: number;
+    claimedAt: Date | null;
+    completedAt: Date | null;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export type ContentSourceStatus = "pending" | "crawling" | "chunking" | "ready" | "failed";
+export interface ContentSource {
+    id: string;
+    userId: string;
+    sourceType: string;
+    uri: string;
+    status: ContentSourceStatus;
+    metadata: Record<string, unknown>;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export interface ContentChunk {
+    id: string;
+    sourceId: string;
+    content: string;
+    embedding: number[] | null;
+    chunkIndex: number;
+    metadata: Record<string, unknown>;
+    createdAt: Date;
+}
+export interface ContentChunkSearchResult {
+    chunk: ContentChunk;
+    score: number;
+}
+export interface EncryptedCredential {
+    id: string;
+    userId: string;
+    provider: string;
+    encryptedData: Buffer;
+    iv: Buffer;
+    authTag: Buffer;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export interface IdentityFile {
+    id: string;
+    workspaceId: string;
+    fileName: string;
+    content: string;
+    metadata: Record<string, unknown>;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export interface PaginationOpts {
+    limit?: number;
+    offset?: number;
+}
+export interface CostQueryOpts {
+    userId: string;
+    startDate: Date;
+    endDate: Date;
+}
+export interface StorageAdapter {
+    /** Initialize connection pool and run migrations. */
+    initialize(): Promise<void>;
+    /** Graceful shutdown — drain connection pool. */
+    close(): Promise<void>;
+    saveMessage(msg: Omit<Message, "id" | "createdAt">): Promise<Message>;
+    getMessagesByConversation(conversationId: string, limit?: number): Promise<Message[]>;
+    getMessageById(id: string): Promise<Message | null>;
+    createConversation(conv: Omit<Conversation, "id" | "createdAt" | "updatedAt">): Promise<Conversation>;
+    listConversations(userId: string, opts?: PaginationOpts): Promise<Conversation[]>;
+    deleteConversation(id: string): Promise<void>;
+    saveMemorySegment(seg: Omit<MemorySegment, "id" | "createdAt" | "updatedAt" | "accessCount" | "lastAccessedAt">): Promise<MemorySegment>;
+    searchMemoryByEmbedding(userId: string, embedding: number[], limit?: number): Promise<MemorySearchResult[]>;
+    getProfile(userId: string): Promise<UserProfile | null>;
+    upsertProfile(userId: string, summary: string): Promise<UserProfile>;
+    updateHeatScores(segmentIds: string[], delta: number): Promise<void>;
+    saveObservation(obs: Omit<Observation, "id" | "createdAt" | "reviewed" | "reviewedAt">): Promise<Observation>;
+    listPendingObservations(userId: string, opts?: PaginationOpts): Promise<Observation[]>;
+    markObservationReviewed(id: string): Promise<void>;
+    saveBrainArtifact(artifact: Omit<BrainArtifact, "id" | "createdAt" | "updatedAt">): Promise<BrainArtifact>;
+    loadBrainArtifacts(conversationId: string): Promise<BrainArtifact[]>;
+    deleteBrainArtifact(id: string): Promise<void>;
+    insertCostLog(log: Omit<CostLog, "id" | "createdAt">): Promise<CostLog>;
+    queryCostLogs(opts: CostQueryOpts): Promise<CostLog[]>;
+    createJob(job: Omit<Job, "id" | "status" | "attempts" | "result" | "error" | "claimedAt" | "completedAt" | "createdAt" | "updatedAt">): Promise<Job>;
+    claimNextJob(types?: string[]): Promise<Job | null>;
+    updateJobStatus(id: string, status: JobStatus, result?: Record<string, unknown>, error?: string): Promise<Job>;
+    getJobById(id: string): Promise<Job | null>;
+    listJobs(filter: {
+        status?: JobStatus;
+        type?: string;
+    }, opts?: PaginationOpts): Promise<Job[]>;
+    markDeadJobs(timeoutSeconds: number): Promise<number>;
+    createContentSource(src: Omit<ContentSource, "id" | "createdAt" | "updatedAt">): Promise<ContentSource>;
+    updateContentSourceStatus(id: string, status: ContentSourceStatus): Promise<ContentSource>;
+    getContentSourceById(id: string): Promise<ContentSource | null>;
+    listContentSources(userId: string, opts?: PaginationOpts): Promise<ContentSource[]>;
+    bulkInsertContentChunks(chunks: Omit<ContentChunk, "id" | "createdAt">[]): Promise<ContentChunk[]>;
+    searchContentChunksByEmbedding(sourceIds: string[], embedding: number[], limit?: number): Promise<ContentChunkSearchResult[]>;
+    searchContentChunksByText(sourceIds: string[], query: string, limit?: number): Promise<ContentChunkSearchResult[]>;
+    deleteContentChunksBySource(sourceId: string): Promise<number>;
+    saveCredential(cred: Omit<EncryptedCredential, "id" | "createdAt" | "updatedAt">): Promise<EncryptedCredential>;
+    getCredential(userId: string, provider: string): Promise<EncryptedCredential | null>;
+    deleteCredential(id: string): Promise<void>;
+    listCredentials(userId: string): Promise<EncryptedCredential[]>;
+    saveIdentityFile(file: Omit<IdentityFile, "id" | "createdAt" | "updatedAt">): Promise<IdentityFile>;
+    getIdentityFile(workspaceId: string): Promise<IdentityFile | null>;
+    listIdentityFiles(): Promise<IdentityFile[]>;
+    query<T = Record<string, unknown>>(sql: string, params?: unknown[]): Promise<T[]>;
+}

package/dist/storage/postgres.d.ts

@@ -0,0 +1,6 @@
+import type { StorageAdapter } from "./interface.js";
+export interface PostgresStorageConfig {
+    connectionString: string;
+    max?: number;
+}
+export declare function createPostgresStorage(config: PostgresStorageConfig): StorageAdapter;

package/dist/storage/sqlite.d.ts

@@ -0,0 +1,2 @@
+import type { StorageAdapter } from "./interface.js";
+export declare function createSqliteStorage(): StorageAdapter;

package/dist/streaming/reasoning.d.ts

@@ -0,0 +1,67 @@
+export interface ReasoningBlock {
+    type: "reasoning";
+    id: string;
+    /** True while still generating, false when committed */
+    isThinking: boolean;
+    /** Accumulated thinking text */
+    content: string;
+    /** Some providers redact thinking content */
+    redacted?: boolean;
+    /** Provider that produced this reasoning */
+    provider?: string;
+    /** Timestamp when reasoning started */
+    startedAt: number;
+    /** Timestamp when reasoning committed */
+    committedAt?: number;
+}
+export interface ReasoningConfig {
+    /** Forward reasoning blocks to client event stream */
+    showReasoning: boolean;
+    /** Store reasoning in brain artifacts for inspection */
+    storeInArtifacts: boolean;
+}
+export declare const DEFAULT_REASONING_CONFIG: ReasoningConfig;
+export type ReasoningEventEmitter = (event: string, payload: Record<string, unknown>) => void;
+export type ArtifactStoreFn = (key: string, content: string) => Promise<void>;
+export declare class ReasoningProcessor {
+    private config;
+    private emit;
+    private storeArtifact;
+    private activeBlocks;
+    constructor(config?: Partial<ReasoningConfig>, opts?: {
+        emit?: ReasoningEventEmitter;
+        storeArtifact?: ArtifactStoreFn;
+    });
+    /**
+     * Extract reasoning from an Anthropic API response.
+     * Handles both extended thinking and encrypted (redacted) thinking.
+     */
+    processAnthropicResponse(sessionId: string, contentBlocks: AnthropicContentBlock[]): ReasoningBlock[];
+    /**
+     * Extract reasoning from an OpenAI reasoning model response (o3, o4-mini).
+     */
+    processOpenAIResponse(sessionId: string, message: OpenAIMessage): ReasoningBlock[];
+    /**
+     * Start a streaming reasoning block (for real-time thinking output).
+     */
+    startStreaming(sessionId: string, provider: string): ReasoningBlock;
+    /**
+     * Append content to a streaming reasoning block.
+     */
+    appendStreaming(blockId: string, text: string): void;
+    /**
+     * Commit a streaming reasoning block (thinking complete).
+     */
+    commitStreaming(blockId: string): Promise<ReasoningBlock | null>;
+    private createBlock;
+}
+export interface AnthropicContentBlock {
+    type: "text" | "thinking" | "redacted_thinking" | "tool_use";
+    text?: string;
+    thinking?: string;
+}
+export interface OpenAIMessage {
+    role: string;
+    content?: string;
+    reasoning_content?: string;
+}

package/dist/task-tracker.d.ts

@@ -0,0 +1,26 @@
+import type { TaskItem, TaskItemStatus, TaskTracker, AgentEvent } from "./events/types.js";
+/** Reset counter for testing */
+export declare function _resetTaskIdCounter(): void;
+export declare class TaskTrackerImpl implements TaskTracker {
+    private _tasks;
+    get tasks(): readonly TaskItem[];
+    add(title: string): TaskItem;
+    update(id: string, status: TaskItemStatus): void;
+    current(): TaskItem | undefined;
+    /** Plan multiple tasks at once, returns all created items */
+    plan(titles: string[]): TaskItem[];
+    /** Mark a task as done */
+    complete(id: string): void;
+    /** Mark a task as blocked */
+    block(id: string): void;
+    /** Get summary counts */
+    summary(): {
+        total: number;
+        pending: number;
+        inProgress: number;
+        done: number;
+        blocked: number;
+    };
+}
+export declare function planWithEvents(tracker: TaskTrackerImpl, titles: string[], sessionId?: string): Generator<AgentEvent, TaskItem[]>;
+export declare function updateWithEvents(tracker: TaskTrackerImpl, id: string, status: TaskItemStatus, sessionId?: string): Generator<AgentEvent>;

package/dist/testing/action-cache.d.ts

@@ -0,0 +1,39 @@
+import type { StorageAdapter } from "../storage/interface.js";
+export interface ActionRecord {
+    id: string;
+    sessionId: string;
+    turnIndex: number;
+    toolName: string;
+    toolInput: Record<string, unknown>;
+    toolOutput: unknown;
+    llmInput: string;
+    llmOutput: string;
+    timestamp: Date;
+}
+export interface ReplayMatch {
+    record: ActionRecord;
+    exact: boolean;
+}
+export interface ActionCacheConfig {
+    /** Recording mode — set by FENIX_RECORD=true */
+    record: boolean;
+    /** Replay mode — set by FENIX_REPLAY=<sessionId> */
+    replaySessionId: string | null;
+}
+export declare const ACTION_CACHE_SCHEMA = "\nCREATE TABLE IF NOT EXISTS action_cache (\n  id TEXT PRIMARY KEY,\n  session_id TEXT NOT NULL,\n  turn_index INTEGER NOT NULL,\n  tool_name TEXT NOT NULL,\n  tool_input JSONB NOT NULL,\n  tool_output JSONB,\n  llm_input TEXT NOT NULL,\n  llm_output TEXT NOT NULL,\n  input_hash TEXT NOT NULL,\n  timestamp TIMESTAMPTZ NOT NULL DEFAULT NOW()\n);\n\nCREATE INDEX IF NOT EXISTS idx_action_cache_session\n  ON action_cache (session_id, turn_index);\nCREATE INDEX IF NOT EXISTS idx_action_cache_lookup\n  ON action_cache (session_id, turn_index, tool_name, input_hash);\n";
+/** Stable JSON serialization with sorted keys and normalized timestamps. */
+export declare function stableHash(input: Record<string, unknown>): string;
+export declare class ActionCache {
+    private storage;
+    private config;
+    constructor(storage: StorageAdapter, config?: Partial<ActionCacheConfig>);
+    get isRecording(): boolean;
+    get isReplaying(): boolean;
+    get replaySessionId(): string | null;
+    /** Record an action (only in record mode). */
+    record(action: Omit<ActionRecord, "id" | "timestamp">): Promise<string | null>;
+    /** Look up a cached action for replay. Returns null if no match (partial replay). */
+    lookup(turnIndex: number, toolName: string, toolInput: Record<string, unknown>): Promise<ReplayMatch | null>;
+    /** Replay an entire session, optionally overriding specific turn inputs. */
+    replaySession(sessionId: string, inputOverrides?: Map<number, Record<string, unknown>>): Promise<ActionRecord[]>;
+}

package/dist/testing/incident-eval.d.ts

@@ -0,0 +1,49 @@
+import type { EvalCase } from "./workflow-evals.js";
+export type IncidentSeverity = "P0" | "P1" | "P2";
+export interface ToolCall {
+    tool: string;
+    input: Record<string, unknown>;
+    output: unknown;
+}
+export interface IncidentArtifact {
+    id: string;
+    severity: IncidentSeverity;
+    description: string;
+    inputPrompt: string;
+    toolTrace: ToolCall[];
+    agentOutput: string;
+    expectedBehavior: string;
+    piiRedacted: boolean;
+}
+export interface IncidentEvalMetadata {
+    incidentId: string;
+    severity: IncidentSeverity;
+    createdAt: Date;
+    owner: string;
+}
+export interface SynthesizedEval {
+    evalCase: EvalCase;
+    metadata: IncidentEvalMetadata;
+    hash: string;
+}
+export type PIIRedactorFn = (text: string) => string;
+export type LLMSynthesisFn = (prompt: string) => Promise<string>;
+export type EvalStoreFn = (filename: string, content: string) => Promise<void>;
+export type EvalHashLookupFn = (hash: string) => Promise<boolean>;
+/**
+ * Convert an incident artifact into a regression eval case.
+ */
+export declare function synthesizeEval(artifact: IncidentArtifact, owner: string, llmSynthesize: LLMSynthesisFn, redact?: PIIRedactorFn): Promise<SynthesizedEval>;
+/**
+ * Store a synthesized eval case as a regression test file.
+ * Returns false if a duplicate already exists.
+ */
+export declare function persistEval(synthesized: SynthesizedEval, store: EvalStoreFn, hashLookup: EvalHashLookupFn): Promise<boolean>;
+/**
+ * Determine if a failing eval should block release based on severity.
+ */
+export declare function shouldBlockRelease(severity: IncidentSeverity): boolean;
+/**
+ * Determine if a failing eval should emit a warning.
+ */
+export declare function shouldWarn(severity: IncidentSeverity): boolean;