jev-recipes 0.2.0 → 0.3.0

package/dist/catalog/recipes.d.ts

@@ -1,3488 +0,0 @@
-export declare const recipes: {
-    'memory-value': {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "memory";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            fact: import("zod").ZodString;
-            purpose: import("zod").ZodString;
-            context: import("zod").ZodOptional<import("zod").ZodString>;
-            minConfidence: import("zod").ZodOptional<import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        resultSchema: import("zod").ZodObject<{
-            model: import("zod").ZodString;
-            usage: import("zod").ZodObject<{
-                input_tokens: import("zod").ZodNumber;
-                output_tokens: import("zod").ZodNumber;
-            }, import("zod/v4/core").$strip>;
-            status: import("zod").ZodEnum<{
-                ready: "ready";
-                review: "review";
-            }>;
-            verdict: import("zod").ZodEnum<{
-                unclear: "unclear";
-                ongoing_value: "ongoing_value";
-                task_only: "task_only";
-                incidental: "incidental";
-            }>;
-            confidence: import("zod").ZodNumber;
-            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
-                unclear: "unclear";
-                ongoing_value: "ongoing_value";
-                task_only: "task_only";
-                incidental: "incidental";
-            }>, import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        run: (input: unknown, options?: import("../src/schema.js").RecipeOptions) => Promise<{
-            model: string;
-            usage: {
-                input_tokens: number;
-                output_tokens: number;
-            };
-            status: "ready" | "review";
-            verdict: "unclear" | "ongoing_value" | "task_only" | "incidental";
-            confidence: number;
-            probabilities: Record<"unclear" | "ongoing_value" | "task_only" | "incidental", number>;
-        }>;
-    };
-    'memory-scope': {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "memory";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            fact: import("zod").ZodString;
-            context: import("zod").ZodString;
-            minConfidence: import("zod").ZodOptional<import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        resultSchema: import("zod").ZodObject<{
-            model: import("zod").ZodString;
-            usage: import("zod").ZodObject<{
-                input_tokens: import("zod").ZodNumber;
-                output_tokens: import("zod").ZodNumber;
-            }, import("zod/v4/core").$strip>;
-            status: import("zod").ZodEnum<{
-                ready: "ready";
-                review: "review";
-            }>;
-            verdict: import("zod").ZodEnum<{
-                unclear: "unclear";
-                task: "task";
-                user: "user";
-                project: "project";
-                session: "session";
-            }>;
-            confidence: import("zod").ZodNumber;
-            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
-                unclear: "unclear";
-                task: "task";
-                user: "user";
-                project: "project";
-                session: "session";
-            }>, import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        run: (input: unknown, options?: import("../src/schema.js").RecipeOptions) => Promise<{
-            model: string;
-            usage: {
-                input_tokens: number;
-                output_tokens: number;
-            };
-            status: "ready" | "review";
-            verdict: "unclear" | "task" | "user" | "project" | "session";
-            confidence: number;
-            probabilities: Record<"unclear" | "task" | "user" | "project" | "session", number>;
-        }>;
-    };
-    'memory-relation': {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "memory";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            existingMemory: import("zod").ZodString;
-            newFact: import("zod").ZodString;
-            context: import("zod").ZodOptional<import("zod").ZodString>;
-            minConfidence: import("zod").ZodOptional<import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        resultSchema: import("zod").ZodObject<{
-            model: import("zod").ZodString;
-            usage: import("zod").ZodObject<{
-                input_tokens: import("zod").ZodNumber;
-                output_tokens: import("zod").ZodNumber;
-            }, import("zod/v4/core").$strip>;
-            status: import("zod").ZodEnum<{
-                ready: "ready";
-                review: "review";
-            }>;
-            verdict: import("zod").ZodEnum<{
-                unclear: "unclear";
-                unrelated: "unrelated";
-                conflicts: "conflicts";
-                repeats: "repeats";
-                supplements: "supplements";
-                updates: "updates";
-            }>;
-            confidence: import("zod").ZodNumber;
-            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
-                unclear: "unclear";
-                unrelated: "unrelated";
-                conflicts: "conflicts";
-                repeats: "repeats";
-                supplements: "supplements";
-                updates: "updates";
-            }>, import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        run: (input: unknown, options?: import("../src/schema.js").RecipeOptions) => Promise<{
-            model: string;
-            usage: {
-                input_tokens: number;
-                output_tokens: number;
-            };
-            status: "ready" | "review";
-            verdict: "unclear" | "unrelated" | "conflicts" | "repeats" | "supplements" | "updates";
-            confidence: number;
-            probabilities: Record<"unclear" | "unrelated" | "conflicts" | "repeats" | "supplements" | "updates", number>;
-        }>;
-    };
-    'preference-kind': {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "memory";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            statement: import("zod").ZodString;
-            context: import("zod").ZodOptional<import("zod").ZodString>;
-            minConfidence: import("zod").ZodOptional<import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        resultSchema: import("zod").ZodObject<{
-            model: import("zod").ZodString;
-            usage: import("zod").ZodObject<{
-                input_tokens: import("zod").ZodNumber;
-                output_tokens: import("zod").ZodNumber;
-            }, import("zod/v4/core").$strip>;
-            status: import("zod").ZodEnum<{
-                ready: "ready";
-                review: "review";
-            }>;
-            verdict: import("zod").ZodEnum<{
-                unclear: "unclear";
-                fact: "fact";
-                preference: "preference";
-                temporary_request: "temporary_request";
-            }>;
-            confidence: import("zod").ZodNumber;
-            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
-                unclear: "unclear";
-                fact: "fact";
-                preference: "preference";
-                temporary_request: "temporary_request";
-            }>, import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        run: (input: unknown, options?: import("../src/schema.js").RecipeOptions) => Promise<{
-            model: string;
-            usage: {
-                input_tokens: number;
-                output_tokens: number;
-            };
-            status: "ready" | "review";
-            verdict: "unclear" | "fact" | "preference" | "temporary_request";
-            confidence: number;
-            probabilities: Record<"unclear" | "fact" | "preference" | "temporary_request", number>;
-        }>;
-    };
-    'fact-stability': {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "memory";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            fact: import("zod").ZodString;
-            context: import("zod").ZodOptional<import("zod").ZodString>;
-            minConfidence: import("zod").ZodOptional<import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        resultSchema: import("zod").ZodObject<{
-            model: import("zod").ZodString;
-            usage: import("zod").ZodObject<{
-                input_tokens: import("zod").ZodNumber;
-                output_tokens: import("zod").ZodNumber;
-            }, import("zod/v4/core").$strip>;
-            status: import("zod").ZodEnum<{
-                ready: "ready";
-                review: "review";
-            }>;
-            verdict: import("zod").ZodEnum<{
-                unclear: "unclear";
-                stable: "stable";
-                changeable: "changeable";
-            }>;
-            confidence: import("zod").ZodNumber;
-            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
-                unclear: "unclear";
-                stable: "stable";
-                changeable: "changeable";
-            }>, import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        run: (input: unknown, options?: import("../src/schema.js").RecipeOptions) => Promise<{
-            model: string;
-            usage: {
-                input_tokens: number;
-                output_tokens: number;
-            };
-            status: "ready" | "review";
-            verdict: "unclear" | "stable" | "changeable";
-            confidence: number;
-            probabilities: Record<"unclear" | "stable" | "changeable", number>;
-        }>;
-    };
-    'document-role': {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "knowledge";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            document: import("zod").ZodString;
-            minConfidence: import("zod").ZodOptional<import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        resultSchema: import("zod").ZodObject<{
-            model: import("zod").ZodString;
-            usage: import("zod").ZodObject<{
-                input_tokens: import("zod").ZodNumber;
-                output_tokens: import("zod").ZodNumber;
-            }, import("zod/v4/core").$strip>;
-            status: import("zod").ZodEnum<{
-                ready: "ready";
-                review: "review";
-            }>;
-            verdict: import("zod").ZodEnum<{
-                unclear: "unclear";
-                other: "other";
-                reference: "reference";
-                troubleshooting: "troubleshooting";
-                policy: "policy";
-                tutorial: "tutorial";
-                release_note: "release_note";
-            }>;
-            confidence: import("zod").ZodNumber;
-            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
-                unclear: "unclear";
-                other: "other";
-                reference: "reference";
-                troubleshooting: "troubleshooting";
-                policy: "policy";
-                tutorial: "tutorial";
-                release_note: "release_note";
-            }>, import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        run: (input: unknown, options?: import("../src/schema.js").RecipeOptions) => Promise<{
-            model: string;
-            usage: {
-                input_tokens: number;
-                output_tokens: number;
-            };
-            status: "ready" | "review";
-            verdict: "unclear" | "other" | "reference" | "troubleshooting" | "policy" | "tutorial" | "release_note";
-            confidence: number;
-            probabilities: Record<"unclear" | "other" | "reference" | "troubleshooting" | "policy" | "tutorial" | "release_note", number>;
-        }>;
-    };
-    'audience-fit': {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "knowledge";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            document: import("zod").ZodString;
-            audience: import("zod").ZodString;
-            minConfidence: import("zod").ZodOptional<import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        resultSchema: import("zod").ZodObject<{
-            model: import("zod").ZodString;
-            usage: import("zod").ZodObject<{
-                input_tokens: import("zod").ZodNumber;
-                output_tokens: import("zod").ZodNumber;
-            }, import("zod/v4/core").$strip>;
-            status: import("zod").ZodEnum<{
-                ready: "ready";
-                review: "review";
-            }>;
-            verdict: import("zod").ZodEnum<{
-                unclear: "unclear";
-                appropriate: "appropriate";
-                too_technical: "too_technical";
-                too_basic: "too_basic";
-            }>;
-            confidence: import("zod").ZodNumber;
-            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
-                unclear: "unclear";
-                appropriate: "appropriate";
-                too_technical: "too_technical";
-                too_basic: "too_basic";
-            }>, import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        run: (input: unknown, options?: import("../src/schema.js").RecipeOptions) => Promise<{
-            model: string;
-            usage: {
-                input_tokens: number;
-                output_tokens: number;
-            };
-            status: "ready" | "review";
-            verdict: "unclear" | "appropriate" | "too_technical" | "too_basic";
-            confidence: number;
-            probabilities: Record<"unclear" | "appropriate" | "too_technical" | "too_basic", number>;
-        }>;
-    };
-    'change-meaning': {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "knowledge";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            before: import("zod").ZodString;
-            after: import("zod").ZodString;
-            context: import("zod").ZodOptional<import("zod").ZodString>;
-            minConfidence: import("zod").ZodOptional<import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        resultSchema: import("zod").ZodObject<{
-            model: import("zod").ZodString;
-            usage: import("zod").ZodObject<{
-                input_tokens: import("zod").ZodNumber;
-                output_tokens: import("zod").ZodNumber;
-            }, import("zod/v4/core").$strip>;
-            status: import("zod").ZodEnum<{
-                ready: "ready";
-                review: "review";
-            }>;
-            verdict: import("zod").ZodEnum<{
-                unclear: "unclear";
-                meaning_changed: "meaning_changed";
-                editorial_only: "editorial_only";
-            }>;
-            confidence: import("zod").ZodNumber;
-            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
-                unclear: "unclear";
-                meaning_changed: "meaning_changed";
-                editorial_only: "editorial_only";
-            }>, import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        run: (input: unknown, options?: import("../src/schema.js").RecipeOptions) => Promise<{
-            model: string;
-            usage: {
-                input_tokens: number;
-                output_tokens: number;
-            };
-            status: "ready" | "review";
-            verdict: "unclear" | "meaning_changed" | "editorial_only";
-            confidence: number;
-            probabilities: Record<"unclear" | "meaning_changed" | "editorial_only", number>;
-        }>;
-    };
-    'answer-invalidation': {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "knowledge";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            claim: import("zod").ZodString;
-            previousEvidence: import("zod").ZodString;
-            updatedEvidence: import("zod").ZodString;
-            minConfidence: import("zod").ZodOptional<import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        resultSchema: import("zod").ZodObject<{
-            model: import("zod").ZodString;
-            usage: import("zod").ZodObject<{
-                input_tokens: import("zod").ZodNumber;
-                output_tokens: import("zod").ZodNumber;
-            }, import("zod/v4/core").$strip>;
-            status: import("zod").ZodEnum<{
-                ready: "ready";
-                review: "review";
-            }>;
-            verdict: import("zod").ZodEnum<{
-                unclear: "unclear";
-                still_supported: "still_supported";
-                invalidated: "invalidated";
-            }>;
-            confidence: import("zod").ZodNumber;
-            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
-                unclear: "unclear";
-                still_supported: "still_supported";
-                invalidated: "invalidated";
-            }>, import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        run: (input: unknown, options?: import("../src/schema.js").RecipeOptions) => Promise<{
-            model: string;
-            usage: {
-                input_tokens: number;
-                output_tokens: number;
-            };
-            status: "ready" | "review";
-            verdict: "unclear" | "still_supported" | "invalidated";
-            confidence: number;
-            probabilities: Record<"unclear" | "still_supported" | "invalidated", number>;
-        }>;
-    };
-    'field-select': {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "knowledge";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            field: import("zod").ZodString;
-            document: import("zod").ZodString;
-            candidates: import("zod").ZodArray<import("zod").ZodObject<{
-                id: import("zod").ZodString;
-                text: import("zod").ZodString;
-            }, import("zod/v4/core").$strip>>;
-            minConfidence: import("zod").ZodOptional<import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        resultSchema: import("zod").ZodObject<{
-            model: import("zod").ZodString;
-            usage: import("zod").ZodObject<{
-                input_tokens: import("zod").ZodNumber;
-                output_tokens: import("zod").ZodNumber;
-            }, import("zod/v4/core").$strip>;
-            status: import("zod").ZodEnum<{
-                ready: "ready";
-                review: "review";
-            }>;
-            verdict: import("zod").ZodEnum<{
-                matched: "matched";
-                none: "none";
-                ambiguous: "ambiguous";
-            }>;
-            selection: import("zod").ZodNullable<import("zod").ZodString>;
-            suggestedSelection: import("zod").ZodNullable<import("zod").ZodString>;
-            confidence: import("zod").ZodNumber;
-            probabilities: import("zod").ZodObject<{
-                candidates: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodNumber>;
-                none: import("zod").ZodNumber;
-                ambiguous: import("zod").ZodNumber;
-            }, import("zod/v4/core").$strip>;
-        }, import("zod/v4/core").$strip>;
-        run: (input: unknown, options?: import("../src/schema.js").RecipeOptions) => Promise<{
-            model: string;
-            usage: {
-                input_tokens: number;
-                output_tokens: number;
-            };
-            status: "ready" | "review";
-            verdict: "matched" | "none" | "ambiguous";
-            selection: string | null;
-            suggestedSelection: string | null;
-            confidence: number;
-            probabilities: {
-                candidates: Record<string, number>;
-                none: number;
-                ambiguous: number;
-            };
-        }>;
-    };
-    'issue-impact': {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "support";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            message: import("zod").ZodString;
-            context: import("zod").ZodOptional<import("zod").ZodString>;
-            minConfidence: import("zod").ZodOptional<import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        resultSchema: import("zod").ZodObject<{
-            model: import("zod").ZodString;
-            usage: import("zod").ZodObject<{
-                input_tokens: import("zod").ZodNumber;
-                output_tokens: import("zod").ZodNumber;
-            }, import("zod/v4/core").$strip>;
-            status: import("zod").ZodEnum<{
-                ready: "ready";
-                review: "review";
-            }>;
-            verdict: import("zod").ZodEnum<{
-                unclear: "unclear";
-                blocked: "blocked";
-                degraded: "degraded";
-                cosmetic: "cosmetic";
-            }>;
-            confidence: import("zod").ZodNumber;
-            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
-                unclear: "unclear";
-                blocked: "blocked";
-                degraded: "degraded";
-                cosmetic: "cosmetic";
-            }>, import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        run: (input: unknown, options?: import("../src/schema.js").RecipeOptions) => Promise<{
-            model: string;
-            usage: {
-                input_tokens: number;
-                output_tokens: number;
-            };
-            status: "ready" | "review";
-            verdict: "unclear" | "blocked" | "degraded" | "cosmetic";
-            confidence: number;
-            probabilities: Record<"unclear" | "blocked" | "degraded" | "cosmetic", number>;
-        }>;
-    };
-    'attempted-step': {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "support";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            step: import("zod").ZodString;
-            conversation: import("zod").ZodString;
-            minConfidence: import("zod").ZodOptional<import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        resultSchema: import("zod").ZodObject<{
-            model: import("zod").ZodString;
-            usage: import("zod").ZodObject<{
-                input_tokens: import("zod").ZodNumber;
-                output_tokens: import("zod").ZodNumber;
-            }, import("zod/v4/core").$strip>;
-            status: import("zod").ZodEnum<{
-                ready: "ready";
-                review: "review";
-            }>;
-            verdict: import("zod").ZodEnum<{
-                unclear: "unclear";
-                tried: "tried";
-                not_tried: "not_tried";
-            }>;
-            confidence: import("zod").ZodNumber;
-            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
-                unclear: "unclear";
-                tried: "tried";
-                not_tried: "not_tried";
-            }>, import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        run: (input: unknown, options?: import("../src/schema.js").RecipeOptions) => Promise<{
-            model: string;
-            usage: {
-                input_tokens: number;
-                output_tokens: number;
-            };
-            status: "ready" | "review";
-            verdict: "unclear" | "tried" | "not_tried";
-            confidence: number;
-            probabilities: Record<"unclear" | "tried" | "not_tried", number>;
-        }>;
-    };
-    'workaround-fit': {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "support";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            issue: import("zod").ZodString;
-            workaround: import("zod").ZodString;
-            constraints: import("zod").ZodString;
-            minConfidence: import("zod").ZodOptional<import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        resultSchema: import("zod").ZodObject<{
-            model: import("zod").ZodString;
-            usage: import("zod").ZodObject<{
-                input_tokens: import("zod").ZodNumber;
-                output_tokens: import("zod").ZodNumber;
-            }, import("zod/v4/core").$strip>;
-            status: import("zod").ZodEnum<{
-                ready: "ready";
-                review: "review";
-            }>;
-            verdict: import("zod").ZodEnum<{
-                unclear: "unclear";
-                fits: "fits";
-                conflicts: "conflicts";
-            }>;
-            confidence: import("zod").ZodNumber;
-            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
-                unclear: "unclear";
-                fits: "fits";
-                conflicts: "conflicts";
-            }>, import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        run: (input: unknown, options?: import("../src/schema.js").RecipeOptions) => Promise<{
-            model: string;
-            usage: {
-                input_tokens: number;
-                output_tokens: number;
-            };
-            status: "ready" | "review";
-            verdict: "unclear" | "fits" | "conflicts";
-            confidence: number;
-            probabilities: Record<"unclear" | "fits" | "conflicts", number>;
-        }>;
-    };
-    'ticket-match': {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "support";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            firstTicket: import("zod").ZodString;
-            secondTicket: import("zod").ZodString;
-            context: import("zod").ZodOptional<import("zod").ZodString>;
-            minConfidence: import("zod").ZodOptional<import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        resultSchema: import("zod").ZodObject<{
-            model: import("zod").ZodString;
-            usage: import("zod").ZodObject<{
-                input_tokens: import("zod").ZodNumber;
-                output_tokens: import("zod").ZodNumber;
-            }, import("zod/v4/core").$strip>;
-            status: import("zod").ZodEnum<{
-                ready: "ready";
-                review: "review";
-            }>;
-            verdict: import("zod").ZodEnum<{
-                unclear: "unclear";
-                related: "related";
-                different: "different";
-                same_issue: "same_issue";
-            }>;
-            confidence: import("zod").ZodNumber;
-            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
-                unclear: "unclear";
-                related: "related";
-                different: "different";
-                same_issue: "same_issue";
-            }>, import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        run: (input: unknown, options?: import("../src/schema.js").RecipeOptions) => Promise<{
-            model: string;
-            usage: {
-                input_tokens: number;
-                output_tokens: number;
-            };
-            status: "ready" | "review";
-            verdict: "unclear" | "related" | "different" | "same_issue";
-            confidence: number;
-            probabilities: Record<"unclear" | "related" | "different" | "same_issue", number>;
-        }>;
-    };
-    'incident-match': {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "support";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            ticket: import("zod").ZodString;
-            incidents: import("zod").ZodArray<import("zod").ZodObject<{
-                id: import("zod").ZodString;
-                text: import("zod").ZodString;
-            }, import("zod/v4/core").$strip>>;
-            context: import("zod").ZodOptional<import("zod").ZodString>;
-            minConfidence: import("zod").ZodOptional<import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        resultSchema: import("zod").ZodObject<{
-            model: import("zod").ZodString;
-            usage: import("zod").ZodObject<{
-                input_tokens: import("zod").ZodNumber;
-                output_tokens: import("zod").ZodNumber;
-            }, import("zod/v4/core").$strip>;
-            status: import("zod").ZodEnum<{
-                ready: "ready";
-                review: "review";
-            }>;
-            verdict: import("zod").ZodEnum<{
-                matched: "matched";
-                none: "none";
-                ambiguous: "ambiguous";
-            }>;
-            selection: import("zod").ZodNullable<import("zod").ZodString>;
-            suggestedSelection: import("zod").ZodNullable<import("zod").ZodString>;
-            confidence: import("zod").ZodNumber;
-            probabilities: import("zod").ZodObject<{
-                candidates: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodNumber>;
-                none: import("zod").ZodNumber;
-                ambiguous: import("zod").ZodNumber;
-            }, import("zod/v4/core").$strip>;
-        }, import("zod/v4/core").$strip>;
-        run: (input: unknown, options?: import("../src/schema.js").RecipeOptions) => Promise<{
-            model: string;
-            usage: {
-                input_tokens: number;
-                output_tokens: number;
-            };
-            status: "ready" | "review";
-            verdict: "matched" | "none" | "ambiguous";
-            selection: string | null;
-            suggestedSelection: string | null;
-            confidence: number;
-            probabilities: {
-                candidates: Record<string, number>;
-                none: number;
-                ambiguous: number;
-            };
-        }>;
-    };
-    'troubleshooting-fit': {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "support";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            symptoms: import("zod").ZodString;
-            procedure: import("zod").ZodString;
-            context: import("zod").ZodOptional<import("zod").ZodString>;
-            minConfidence: import("zod").ZodOptional<import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        resultSchema: import("zod").ZodObject<{
-            model: import("zod").ZodString;
-            usage: import("zod").ZodObject<{
-                input_tokens: import("zod").ZodNumber;
-                output_tokens: import("zod").ZodNumber;
-            }, import("zod/v4/core").$strip>;
-            status: import("zod").ZodEnum<{
-                ready: "ready";
-                review: "review";
-            }>;
-            verdict: import("zod").ZodEnum<{
-                unclear: "unclear";
-                unsuitable: "unsuitable";
-                applicable: "applicable";
-            }>;
-            confidence: import("zod").ZodNumber;
-            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
-                unclear: "unclear";
-                unsuitable: "unsuitable";
-                applicable: "applicable";
-            }>, import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        run: (input: unknown, options?: import("../src/schema.js").RecipeOptions) => Promise<{
-            model: string;
-            usage: {
-                input_tokens: number;
-                output_tokens: number;
-            };
-            status: "ready" | "review";
-            verdict: "unclear" | "unsuitable" | "applicable";
-            confidence: number;
-            probabilities: Record<"unclear" | "unsuitable" | "applicable", number>;
-        }>;
-    };
-    'frustration-signal': {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "support";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            message: import("zod").ZodString;
-            context: import("zod").ZodOptional<import("zod").ZodString>;
-            minConfidence: import("zod").ZodOptional<import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        resultSchema: import("zod").ZodObject<{
-            model: import("zod").ZodString;
-            usage: import("zod").ZodObject<{
-                input_tokens: import("zod").ZodNumber;
-                output_tokens: import("zod").ZodNumber;
-            }, import("zod/v4/core").$strip>;
-            status: import("zod").ZodEnum<{
-                ready: "ready";
-                review: "review";
-            }>;
-            verdict: import("zod").ZodEnum<{
-                unclear: "unclear";
-                expressed: "expressed";
-                not_expressed: "not_expressed";
-            }>;
-            confidence: import("zod").ZodNumber;
-            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
-                unclear: "unclear";
-                expressed: "expressed";
-                not_expressed: "not_expressed";
-            }>, import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        run: (input: unknown, options?: import("../src/schema.js").RecipeOptions) => Promise<{
-            model: string;
-            usage: {
-                input_tokens: number;
-                output_tokens: number;
-            };
-            status: "ready" | "review";
-            verdict: "unclear" | "expressed" | "not_expressed";
-            confidence: number;
-            probabilities: Record<"unclear" | "expressed" | "not_expressed", number>;
-        }>;
-    };
-    'urgency-signal': {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "support";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            message: import("zod").ZodString;
-            context: import("zod").ZodOptional<import("zod").ZodString>;
-            minConfidence: import("zod").ZodOptional<import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        resultSchema: import("zod").ZodObject<{
-            model: import("zod").ZodString;
-            usage: import("zod").ZodObject<{
-                input_tokens: import("zod").ZodNumber;
-                output_tokens: import("zod").ZodNumber;
-            }, import("zod/v4/core").$strip>;
-            status: import("zod").ZodEnum<{
-                ready: "ready";
-                review: "review";
-            }>;
-            verdict: import("zod").ZodEnum<{
-                unclear: "unclear";
-                expressed: "expressed";
-                not_expressed: "not_expressed";
-            }>;
-            confidence: import("zod").ZodNumber;
-            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
-                unclear: "unclear";
-                expressed: "expressed";
-                not_expressed: "not_expressed";
-            }>, import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        run: (input: unknown, options?: import("../src/schema.js").RecipeOptions) => Promise<{
-            model: string;
-            usage: {
-                input_tokens: number;
-                output_tokens: number;
-            };
-            status: "ready" | "review";
-            verdict: "unclear" | "expressed" | "not_expressed";
-            confidence: number;
-            probabilities: Record<"unclear" | "expressed" | "not_expressed", number>;
-        }>;
-    };
-    'feedback-kind': {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "support";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            message: import("zod").ZodString;
-            context: import("zod").ZodOptional<import("zod").ZodString>;
-            minConfidence: import("zod").ZodOptional<import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        resultSchema: import("zod").ZodObject<{
-            model: import("zod").ZodString;
-            usage: import("zod").ZodObject<{
-                input_tokens: import("zod").ZodNumber;
-                output_tokens: import("zod").ZodNumber;
-            }, import("zod/v4/core").$strip>;
-            status: import("zod").ZodEnum<{
-                ready: "ready";
-                review: "review";
-            }>;
-            verdict: import("zod").ZodEnum<{
-                question: "question";
-                unclear: "unclear";
-                other: "other";
-                bug_report: "bug_report";
-                feature_request: "feature_request";
-                praise: "praise";
-                complaint: "complaint";
-            }>;
-            confidence: import("zod").ZodNumber;
-            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
-                question: "question";
-                unclear: "unclear";
-                other: "other";
-                bug_report: "bug_report";
-                feature_request: "feature_request";
-                praise: "praise";
-                complaint: "complaint";
-            }>, import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        run: (input: unknown, options?: import("../src/schema.js").RecipeOptions) => Promise<{
-            model: string;
-            usage: {
-                input_tokens: number;
-                output_tokens: number;
-            };
-            status: "ready" | "review";
-            verdict: "question" | "unclear" | "other" | "bug_report" | "feature_request" | "praise" | "complaint";
-            confidence: number;
-            probabilities: Record<"question" | "unclear" | "other" | "bug_report" | "feature_request" | "praise" | "complaint", number>;
-        }>;
-    };
-    'reply-template-match': {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "support";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            request: import("zod").ZodString;
-            templates: import("zod").ZodArray<import("zod").ZodObject<{
-                id: import("zod").ZodString;
-                text: import("zod").ZodString;
-            }, import("zod/v4/core").$strip>>;
-            context: import("zod").ZodOptional<import("zod").ZodString>;
-            minConfidence: import("zod").ZodOptional<import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        resultSchema: import("zod").ZodObject<{
-            model: import("zod").ZodString;
-            usage: import("zod").ZodObject<{
-                input_tokens: import("zod").ZodNumber;
-                output_tokens: import("zod").ZodNumber;
-            }, import("zod/v4/core").$strip>;
-            status: import("zod").ZodEnum<{
-                ready: "ready";
-                review: "review";
-            }>;
-            verdict: import("zod").ZodEnum<{
-                matched: "matched";
-                none: "none";
-                ambiguous: "ambiguous";
-            }>;
-            selection: import("zod").ZodNullable<import("zod").ZodString>;
-            suggestedSelection: import("zod").ZodNullable<import("zod").ZodString>;
-            confidence: import("zod").ZodNumber;
-            probabilities: import("zod").ZodObject<{
-                candidates: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodNumber>;
-                none: import("zod").ZodNumber;
-                ambiguous: import("zod").ZodNumber;
-            }, import("zod/v4/core").$strip>;
-        }, import("zod/v4/core").$strip>;
-        run: (input: unknown, options?: import("../src/schema.js").RecipeOptions) => Promise<{
-            model: string;
-            usage: {
-                input_tokens: number;
-                output_tokens: number;
-            };
-            status: "ready" | "review";
-            verdict: "matched" | "none" | "ambiguous";
-            selection: string | null;
-            suggestedSelection: string | null;
-            confidence: number;
-            probabilities: {
-                candidates: Record<string, number>;
-                none: number;
-                ambiguous: number;
-            };
-        }>;
-    };
-    route: {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "workflow";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            request: import("zod").ZodString;
-            routes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
-            minConfidence: import("zod").ZodOptional<import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        resultSchema: import("zod").ZodObject<{
-            model: import("zod").ZodString;
-            usage: import("zod").ZodObject<{
-                input_tokens: import("zod").ZodNumber;
-                output_tokens: import("zod").ZodNumber;
-            }, import("zod/v4/core").$strip>;
-            status: import("zod").ZodEnum<{
-                ready: "ready";
-                review: "review";
-            }>;
-            route: import("zod").ZodNullable<import("zod").ZodString>;
-            suggestedRoute: import("zod").ZodNullable<import("zod").ZodString>;
-            confidence: import("zod").ZodNumber;
-            probabilities: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        run: (input: unknown, options?: import("../src/schema.js").RecipeOptions) => Promise<{
-            model: string;
-            usage: {
-                input_tokens: number;
-                output_tokens: number;
-            };
-            status: "ready" | "review";
-            route: string | null;
-            suggestedRoute: string | null;
-            confidence: number;
-            probabilities: Record<string, number>;
-        }>;
-    };
-    handoff: {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "workflow";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            request: import("zod").ZodString;
-            context: import("zod").ZodOptional<import("zod").ZodString>;
-            rules: import("zod").ZodArray<import("zod").ZodObject<{
-                id: import("zod").ZodString;
-                description: import("zod").ZodString;
-            }, import("zod/v4/core").$strip>>;
-            minConfidence: import("zod").ZodOptional<import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        resultSchema: import("zod").ZodObject<{
-            model: import("zod").ZodString;
-            usage: import("zod").ZodObject<{
-                input_tokens: import("zod").ZodNumber;
-                output_tokens: import("zod").ZodNumber;
-            }, import("zod/v4/core").$strip>;
-            status: import("zod").ZodEnum<{
-                ready: "ready";
-                review: "review";
-            }>;
-            decision: import("zod").ZodEnum<{
-                review: "review";
-                human: "human";
-                continue: "continue";
-            }>;
-            matchedRules: import("zod").ZodArray<import("zod").ZodString>;
-            uncertainRules: import("zod").ZodArray<import("zod").ZodString>;
-            checks: import("zod").ZodArray<import("zod").ZodObject<{
-                id: import("zod").ZodString;
-                status: import("zod").ZodEnum<{
-                    ready: "ready";
-                    review: "review";
-                }>;
-                verdict: import("zod").ZodEnum<{
-                    matches: "matches";
-                    does_not_match: "does_not_match";
-                    unclear: "unclear";
-                }>;
-                confidence: import("zod").ZodNumber;
-                probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
-                    matches: "matches";
-                    does_not_match: "does_not_match";
-                    unclear: "unclear";
-                }>, import("zod").ZodNumber>;
-            }, import("zod/v4/core").$strip>>;
-        }, import("zod/v4/core").$strip>;
-        run: (input: unknown, options?: import("../src/schema.js").RecipeOptions) => Promise<{
-            model: string;
-            usage: {
-                input_tokens: number;
-                output_tokens: number;
-            };
-            status: "ready" | "review";
-            decision: "review" | "human" | "continue";
-            matchedRules: string[];
-            uncertainRules: string[];
-            checks: {
-                id: string;
-                status: "ready" | "review";
-                verdict: "matches" | "does_not_match" | "unclear";
-                confidence: number;
-                probabilities: Record<"matches" | "does_not_match" | "unclear", number>;
-            }[];
-        }>;
-    };
-    'tool-fit': {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "workflow";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            task: import("zod").ZodString;
-            tool: import("zod").ZodString;
-            context: import("zod").ZodOptional<import("zod").ZodString>;
-            minConfidence: import("zod").ZodOptional<import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        resultSchema: import("zod").ZodObject<{
-            model: import("zod").ZodString;
-            usage: import("zod").ZodObject<{
-                input_tokens: import("zod").ZodNumber;
-                output_tokens: import("zod").ZodNumber;
-            }, import("zod/v4/core").$strip>;
-            status: import("zod").ZodEnum<{
-                ready: "ready";
-                review: "review";
-            }>;
-            verdict: import("zod").ZodEnum<{
-                unclear: "unclear";
-                fits: "fits";
-                does_not_fit: "does_not_fit";
-            }>;
-            confidence: import("zod").ZodNumber;
-            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
-                unclear: "unclear";
-                fits: "fits";
-                does_not_fit: "does_not_fit";
-            }>, import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        run: (input: unknown, options?: import("../src/schema.js").RecipeOptions) => Promise<{
-            model: string;
-            usage: {
-                input_tokens: number;
-                output_tokens: number;
-            };
-            status: "ready" | "review";
-            verdict: "unclear" | "fits" | "does_not_fit";
-            confidence: number;
-            probabilities: Record<"unclear" | "fits" | "does_not_fit", number>;
-        }>;
-    };
-    'argument-fit': {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "workflow";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            request: import("zod").ZodString;
-            argument: import("zod").ZodString;
-            proposedValue: import("zod").ZodString;
-            context: import("zod").ZodOptional<import("zod").ZodString>;
-            minConfidence: import("zod").ZodOptional<import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        resultSchema: import("zod").ZodObject<{
-            model: import("zod").ZodString;
-            usage: import("zod").ZodObject<{
-                input_tokens: import("zod").ZodNumber;
-                output_tokens: import("zod").ZodNumber;
-            }, import("zod/v4/core").$strip>;
-            status: import("zod").ZodEnum<{
-                ready: "ready";
-                review: "review";
-            }>;
-            verdict: import("zod").ZodEnum<{
-                unclear: "unclear";
-                fits: "fits";
-                conflicts: "conflicts";
-            }>;
-            confidence: import("zod").ZodNumber;
-            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
-                unclear: "unclear";
-                fits: "fits";
-                conflicts: "conflicts";
-            }>, import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        run: (input: unknown, options?: import("../src/schema.js").RecipeOptions) => Promise<{
-            model: string;
-            usage: {
-                input_tokens: number;
-                output_tokens: number;
-            };
-            status: "ready" | "review";
-            verdict: "unclear" | "fits" | "conflicts";
-            confidence: number;
-            probabilities: Record<"unclear" | "fits" | "conflicts", number>;
-        }>;
-    };
-    'result-usefulness': {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "workflow";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            task: import("zod").ZodString;
-            result: import("zod").ZodString;
-            minConfidence: import("zod").ZodOptional<import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        resultSchema: import("zod").ZodObject<{
-            model: import("zod").ZodString;
-            usage: import("zod").ZodObject<{
-                input_tokens: import("zod").ZodNumber;
-                output_tokens: import("zod").ZodNumber;
-            }, import("zod/v4/core").$strip>;
-            status: import("zod").ZodEnum<{
-                ready: "ready";
-                review: "review";
-            }>;
-            verdict: import("zod").ZodEnum<{
-                unclear: "unclear";
-                irrelevant: "irrelevant";
-                useful: "useful";
-                no_useful_information: "no_useful_information";
-            }>;
-            confidence: import("zod").ZodNumber;
-            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
-                unclear: "unclear";
-                irrelevant: "irrelevant";
-                useful: "useful";
-                no_useful_information: "no_useful_information";
-            }>, import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        run: (input: unknown, options?: import("../src/schema.js").RecipeOptions) => Promise<{
-            model: string;
-            usage: {
-                input_tokens: number;
-                output_tokens: number;
-            };
-            status: "ready" | "review";
-            verdict: "unclear" | "irrelevant" | "useful" | "no_useful_information";
-            confidence: number;
-            probabilities: Record<"unclear" | "irrelevant" | "useful" | "no_useful_information", number>;
-        }>;
-    };
-    'result-outcome': {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "workflow";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            task: import("zod").ZodString;
-            result: import("zod").ZodString;
-            minConfidence: import("zod").ZodOptional<import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        resultSchema: import("zod").ZodObject<{
-            model: import("zod").ZodString;
-            usage: import("zod").ZodObject<{
-                input_tokens: import("zod").ZodNumber;
-                output_tokens: import("zod").ZodNumber;
-            }, import("zod/v4/core").$strip>;
-            status: import("zod").ZodEnum<{
-                ready: "ready";
-                review: "review";
-            }>;
-            verdict: import("zod").ZodEnum<{
-                success: "success";
-                unclear: "unclear";
-                partial_success: "partial_success";
-                failure: "failure";
-            }>;
-            confidence: import("zod").ZodNumber;
-            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
-                success: "success";
-                unclear: "unclear";
-                partial_success: "partial_success";
-                failure: "failure";
-            }>, import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        run: (input: unknown, options?: import("../src/schema.js").RecipeOptions) => Promise<{
-            model: string;
-            usage: {
-                input_tokens: number;
-                output_tokens: number;
-            };
-            status: "ready" | "review";
-            verdict: "success" | "unclear" | "partial_success" | "failure";
-            confidence: number;
-            probabilities: Record<"success" | "unclear" | "partial_success" | "failure", number>;
-        }>;
-    };
-    'action-scope': {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "workflow";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            request: import("zod").ZodString;
-            proposedAction: import("zod").ZodString;
-            constraints: import("zod").ZodOptional<import("zod").ZodString>;
-            minConfidence: import("zod").ZodOptional<import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        resultSchema: import("zod").ZodObject<{
-            model: import("zod").ZodString;
-            usage: import("zod").ZodObject<{
-                input_tokens: import("zod").ZodNumber;
-                output_tokens: import("zod").ZodNumber;
-            }, import("zod/v4/core").$strip>;
-            status: import("zod").ZodEnum<{
-                ready: "ready";
-                review: "review";
-            }>;
-            verdict: import("zod").ZodEnum<{
-                unclear: "unclear";
-                within_scope: "within_scope";
-                additional_work: "additional_work";
-            }>;
-            confidence: import("zod").ZodNumber;
-            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
-                unclear: "unclear";
-                within_scope: "within_scope";
-                additional_work: "additional_work";
-            }>, import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        run: (input: unknown, options?: import("../src/schema.js").RecipeOptions) => Promise<{
-            model: string;
-            usage: {
-                input_tokens: number;
-                output_tokens: number;
-            };
-            status: "ready" | "review";
-            verdict: "unclear" | "within_scope" | "additional_work";
-            confidence: number;
-            probabilities: Record<"unclear" | "within_scope" | "additional_work", number>;
-        }>;
-    };
-    'step-progress': {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "workflow";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            objective: import("zod").ZodString;
-            previousState: import("zod").ZodString;
-            observation: import("zod").ZodString;
-            minConfidence: import("zod").ZodOptional<import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        resultSchema: import("zod").ZodObject<{
-            model: import("zod").ZodString;
-            usage: import("zod").ZodObject<{
-                input_tokens: import("zod").ZodNumber;
-                output_tokens: import("zod").ZodNumber;
-            }, import("zod/v4/core").$strip>;
-            status: import("zod").ZodEnum<{
-                ready: "ready";
-                review: "review";
-            }>;
-            verdict: import("zod").ZodEnum<{
-                unclear: "unclear";
-                progress: "progress";
-                no_progress: "no_progress";
-                setback: "setback";
-            }>;
-            confidence: import("zod").ZodNumber;
-            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
-                unclear: "unclear";
-                progress: "progress";
-                no_progress: "no_progress";
-                setback: "setback";
-            }>, import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        run: (input: unknown, options?: import("../src/schema.js").RecipeOptions) => Promise<{
-            model: string;
-            usage: {
-                input_tokens: number;
-                output_tokens: number;
-            };
-            status: "ready" | "review";
-            verdict: "unclear" | "progress" | "no_progress" | "setback";
-            confidence: number;
-            probabilities: Record<"unclear" | "progress" | "no_progress" | "setback", number>;
-        }>;
-    };
-    'repeated-attempt': {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "workflow";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            objective: import("zod").ZodString;
-            previousAttempt: import("zod").ZodString;
-            proposedAttempt: import("zod").ZodString;
-            minConfidence: import("zod").ZodOptional<import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        resultSchema: import("zod").ZodObject<{
-            model: import("zod").ZodString;
-            usage: import("zod").ZodObject<{
-                input_tokens: import("zod").ZodNumber;
-                output_tokens: import("zod").ZodNumber;
-            }, import("zod/v4/core").$strip>;
-            status: import("zod").ZodEnum<{
-                ready: "ready";
-                review: "review";
-            }>;
-            verdict: import("zod").ZodEnum<{
-                unclear: "unclear";
-                same_approach: "same_approach";
-                different_approach: "different_approach";
-            }>;
-            confidence: import("zod").ZodNumber;
-            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
-                unclear: "unclear";
-                same_approach: "same_approach";
-                different_approach: "different_approach";
-            }>, import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        run: (input: unknown, options?: import("../src/schema.js").RecipeOptions) => Promise<{
-            model: string;
-            usage: {
-                input_tokens: number;
-                output_tokens: number;
-            };
-            status: "ready" | "review";
-            verdict: "unclear" | "same_approach" | "different_approach";
-            confidence: number;
-            probabilities: Record<"unclear" | "same_approach" | "different_approach", number>;
-        }>;
-    };
-    'step-complete': {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "workflow";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            condition: import("zod").ZodString;
-            evidence: import("zod").ZodString;
-            minConfidence: import("zod").ZodOptional<import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        resultSchema: import("zod").ZodObject<{
-            model: import("zod").ZodString;
-            usage: import("zod").ZodObject<{
-                input_tokens: import("zod").ZodNumber;
-                output_tokens: import("zod").ZodNumber;
-            }, import("zod/v4/core").$strip>;
-            status: import("zod").ZodEnum<{
-                ready: "ready";
-                review: "review";
-            }>;
-            verdict: import("zod").ZodEnum<{
-                unclear: "unclear";
-                met: "met";
-                unmet: "unmet";
-            }>;
-            confidence: import("zod").ZodNumber;
-            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
-                unclear: "unclear";
-                met: "met";
-                unmet: "unmet";
-            }>, import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        run: (input: unknown, options?: import("../src/schema.js").RecipeOptions) => Promise<{
-            model: string;
-            usage: {
-                input_tokens: number;
-                output_tokens: number;
-            };
-            status: "ready" | "review";
-            verdict: "unclear" | "met" | "unmet";
-            confidence: number;
-            probabilities: Record<"unclear" | "met" | "unmet", number>;
-        }>;
-    };
-    'failure-kind': {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "workflow";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            failure: import("zod").ZodString;
-            categories: import("zod").ZodArray<import("zod").ZodObject<{
-                id: import("zod").ZodString;
-                text: import("zod").ZodString;
-            }, import("zod/v4/core").$strip>>;
-            context: import("zod").ZodOptional<import("zod").ZodString>;
-            minConfidence: import("zod").ZodOptional<import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        resultSchema: import("zod").ZodObject<{
-            model: import("zod").ZodString;
-            usage: import("zod").ZodObject<{
-                input_tokens: import("zod").ZodNumber;
-                output_tokens: import("zod").ZodNumber;
-            }, import("zod/v4/core").$strip>;
-            status: import("zod").ZodEnum<{
-                ready: "ready";
-                review: "review";
-            }>;
-            verdict: import("zod").ZodEnum<{
-                matched: "matched";
-                none: "none";
-                ambiguous: "ambiguous";
-            }>;
-            selection: import("zod").ZodNullable<import("zod").ZodString>;
-            suggestedSelection: import("zod").ZodNullable<import("zod").ZodString>;
-            confidence: import("zod").ZodNumber;
-            probabilities: import("zod").ZodObject<{
-                candidates: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodNumber>;
-                none: import("zod").ZodNumber;
-                ambiguous: import("zod").ZodNumber;
-            }, import("zod/v4/core").$strip>;
-        }, import("zod/v4/core").$strip>;
-        run: (input: unknown, options?: import("../src/schema.js").RecipeOptions) => Promise<{
-            model: string;
-            usage: {
-                input_tokens: number;
-                output_tokens: number;
-            };
-            status: "ready" | "review";
-            verdict: "matched" | "none" | "ambiguous";
-            selection: string | null;
-            suggestedSelection: string | null;
-            confidence: number;
-            probabilities: {
-                candidates: Record<string, number>;
-                none: number;
-                ambiguous: number;
-            };
-        }>;
-    };
-    'instruction-fit': {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "workflow";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            instruction: import("zod").ZodString;
-            task: import("zod").ZodString;
-            context: import("zod").ZodOptional<import("zod").ZodString>;
-            minConfidence: import("zod").ZodOptional<import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        resultSchema: import("zod").ZodObject<{
-            model: import("zod").ZodString;
-            usage: import("zod").ZodObject<{
-                input_tokens: import("zod").ZodNumber;
-                output_tokens: import("zod").ZodNumber;
-            }, import("zod/v4/core").$strip>;
-            status: import("zod").ZodEnum<{
-                ready: "ready";
-                review: "review";
-            }>;
-            verdict: import("zod").ZodEnum<{
-                unclear: "unclear";
-                applies: "applies";
-                does_not_apply: "does_not_apply";
-            }>;
-            confidence: import("zod").ZodNumber;
-            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
-                unclear: "unclear";
-                applies: "applies";
-                does_not_apply: "does_not_apply";
-            }>, import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        run: (input: unknown, options?: import("../src/schema.js").RecipeOptions) => Promise<{
-            model: string;
-            usage: {
-                input_tokens: number;
-                output_tokens: number;
-            };
-            status: "ready" | "review";
-            verdict: "unclear" | "applies" | "does_not_apply";
-            confidence: number;
-            probabilities: Record<"unclear" | "applies" | "does_not_apply", number>;
-        }>;
-    };
-    clarify: {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "conversation";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            request: import("zod").ZodString;
-            context: import("zod").ZodOptional<import("zod").ZodString>;
-            requirements: import("zod").ZodArray<import("zod").ZodObject<{
-                id: import("zod").ZodString;
-                description: import("zod").ZodString;
-            }, import("zod/v4/core").$strip>>;
-            minConfidence: import("zod").ZodOptional<import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        resultSchema: import("zod").ZodObject<{
-            model: import("zod").ZodString;
-            usage: import("zod").ZodObject<{
-                input_tokens: import("zod").ZodNumber;
-                output_tokens: import("zod").ZodNumber;
-            }, import("zod/v4/core").$strip>;
-            status: import("zod").ZodEnum<{
-                ready: "ready";
-                review: "review";
-            }>;
-            canProceed: import("zod").ZodBoolean;
-            missing: import("zod").ZodArray<import("zod").ZodString>;
-            ambiguous: import("zod").ZodArray<import("zod").ZodString>;
-            checks: import("zod").ZodArray<import("zod").ZodObject<{
-                id: import("zod").ZodString;
-                status: import("zod").ZodEnum<{
-                    ready: "ready";
-                    review: "review";
-                }>;
-                verdict: import("zod").ZodEnum<{
-                    ambiguous: "ambiguous";
-                    present: "present";
-                    missing: "missing";
-                }>;
-                confidence: import("zod").ZodNumber;
-                probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
-                    ambiguous: "ambiguous";
-                    present: "present";
-                    missing: "missing";
-                }>, import("zod").ZodNumber>;
-            }, import("zod/v4/core").$strip>>;
-        }, import("zod/v4/core").$strip>;
-        run: (input: unknown, options?: import("../src/schema.js").RecipeOptions) => Promise<{
-            model: string;
-            usage: {
-                input_tokens: number;
-                output_tokens: number;
-            };
-            status: "ready" | "review";
-            canProceed: boolean;
-            missing: string[];
-            ambiguous: string[];
-            checks: {
-                id: string;
-                status: "ready" | "review";
-                verdict: "ambiguous" | "present" | "missing";
-                confidence: number;
-                probabilities: Record<"ambiguous" | "present" | "missing", number>;
-            }[];
-        }>;
-    };
-    'turn-intent': {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "conversation";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            message: import("zod").ZodString;
-            context: import("zod").ZodOptional<import("zod").ZodString>;
-            minConfidence: import("zod").ZodOptional<import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        resultSchema: import("zod").ZodObject<{
-            model: import("zod").ZodString;
-            usage: import("zod").ZodObject<{
-                input_tokens: import("zod").ZodNumber;
-                output_tokens: import("zod").ZodNumber;
-            }, import("zod/v4/core").$strip>;
-            status: import("zod").ZodEnum<{
-                ready: "ready";
-                review: "review";
-            }>;
-            verdict: import("zod").ZodEnum<{
-                request: "request";
-                unclear: "unclear";
-                answer: "answer";
-                correction: "correction";
-                cancellation: "cancellation";
-                acknowledgment: "acknowledgment";
-                other: "other";
-            }>;
-            confidence: import("zod").ZodNumber;
-            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
-                request: "request";
-                unclear: "unclear";
-                answer: "answer";
-                correction: "correction";
-                cancellation: "cancellation";
-                acknowledgment: "acknowledgment";
-                other: "other";
-            }>, import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        run: (input: unknown, options?: import("../src/schema.js").RecipeOptions) => Promise<{
-            model: string;
-            usage: {
-                input_tokens: number;
-                output_tokens: number;
-            };
-            status: "ready" | "review";
-            verdict: "request" | "unclear" | "answer" | "correction" | "cancellation" | "acknowledgment" | "other";
-            confidence: number;
-            probabilities: Record<"request" | "unclear" | "answer" | "correction" | "cancellation" | "acknowledgment" | "other", number>;
-        }>;
-    };
-    'followup-link': {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "conversation";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            message: import("zod").ZodString;
-            requests: import("zod").ZodArray<import("zod").ZodObject<{
-                id: import("zod").ZodString;
-                text: import("zod").ZodString;
-            }, import("zod/v4/core").$strip>>;
-            context: import("zod").ZodOptional<import("zod").ZodString>;
-            minConfidence: import("zod").ZodOptional<import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        resultSchema: import("zod").ZodObject<{
-            model: import("zod").ZodString;
-            usage: import("zod").ZodObject<{
-                input_tokens: import("zod").ZodNumber;
-                output_tokens: import("zod").ZodNumber;
-            }, import("zod/v4/core").$strip>;
-            status: import("zod").ZodEnum<{
-                ready: "ready";
-                review: "review";
-            }>;
-            verdict: import("zod").ZodEnum<{
-                matched: "matched";
-                none: "none";
-                ambiguous: "ambiguous";
-            }>;
-            selection: import("zod").ZodNullable<import("zod").ZodString>;
-            suggestedSelection: import("zod").ZodNullable<import("zod").ZodString>;
-            confidence: import("zod").ZodNumber;
-            probabilities: import("zod").ZodObject<{
-                candidates: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodNumber>;
-                none: import("zod").ZodNumber;
-                ambiguous: import("zod").ZodNumber;
-            }, import("zod/v4/core").$strip>;
-        }, import("zod/v4/core").$strip>;
-        run: (input: unknown, options?: import("../src/schema.js").RecipeOptions) => Promise<{
-            model: string;
-            usage: {
-                input_tokens: number;
-                output_tokens: number;
-            };
-            status: "ready" | "review";
-            verdict: "matched" | "none" | "ambiguous";
-            selection: string | null;
-            suggestedSelection: string | null;
-            confidence: number;
-            probabilities: {
-                candidates: Record<string, number>;
-                none: number;
-                ambiguous: number;
-            };
-        }>;
-    };
-    'reference-resolve': {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "conversation";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            message: import("zod").ZodString;
-            reference: import("zod").ZodString;
-            candidates: import("zod").ZodArray<import("zod").ZodObject<{
-                id: import("zod").ZodString;
-                text: import("zod").ZodString;
-            }, import("zod/v4/core").$strip>>;
-            context: import("zod").ZodOptional<import("zod").ZodString>;
-            minConfidence: import("zod").ZodOptional<import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        resultSchema: import("zod").ZodObject<{
-            model: import("zod").ZodString;
-            usage: import("zod").ZodObject<{
-                input_tokens: import("zod").ZodNumber;
-                output_tokens: import("zod").ZodNumber;
-            }, import("zod/v4/core").$strip>;
-            status: import("zod").ZodEnum<{
-                ready: "ready";
-                review: "review";
-            }>;
-            verdict: import("zod").ZodEnum<{
-                matched: "matched";
-                none: "none";
-                ambiguous: "ambiguous";
-            }>;
-            selection: import("zod").ZodNullable<import("zod").ZodString>;
-            suggestedSelection: import("zod").ZodNullable<import("zod").ZodString>;
-            confidence: import("zod").ZodNumber;
-            probabilities: import("zod").ZodObject<{
-                candidates: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodNumber>;
-                none: import("zod").ZodNumber;
-                ambiguous: import("zod").ZodNumber;
-            }, import("zod/v4/core").$strip>;
-        }, import("zod/v4/core").$strip>;
-        run: (input: unknown, options?: import("../src/schema.js").RecipeOptions) => Promise<{
-            model: string;
-            usage: {
-                input_tokens: number;
-                output_tokens: number;
-            };
-            status: "ready" | "review";
-            verdict: "matched" | "none" | "ambiguous";
-            selection: string | null;
-            suggestedSelection: string | null;
-            confidence: number;
-            probabilities: {
-                candidates: Record<string, number>;
-                none: number;
-                ambiguous: number;
-            };
-        }>;
-    };
-    'intent-change': {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "conversation";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            currentGoal: import("zod").ZodString;
-            message: import("zod").ZodString;
-            context: import("zod").ZodOptional<import("zod").ZodString>;
-            minConfidence: import("zod").ZodOptional<import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        resultSchema: import("zod").ZodObject<{
-            model: import("zod").ZodString;
-            usage: import("zod").ZodObject<{
-                input_tokens: import("zod").ZodNumber;
-                output_tokens: import("zod").ZodNumber;
-            }, import("zod/v4/core").$strip>;
-            status: import("zod").ZodEnum<{
-                ready: "ready";
-                review: "review";
-            }>;
-            verdict: import("zod").ZodEnum<{
-                unclear: "unclear";
-                continues: "continues";
-                refines: "refines";
-                replaces: "replaces";
-            }>;
-            confidence: import("zod").ZodNumber;
-            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
-                unclear: "unclear";
-                continues: "continues";
-                refines: "refines";
-                replaces: "replaces";
-            }>, import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        run: (input: unknown, options?: import("../src/schema.js").RecipeOptions) => Promise<{
-            model: string;
-            usage: {
-                input_tokens: number;
-                output_tokens: number;
-            };
-            status: "ready" | "review";
-            verdict: "unclear" | "continues" | "refines" | "replaces";
-            confidence: number;
-            probabilities: Record<"unclear" | "continues" | "refines" | "replaces", number>;
-        }>;
-    };
-    'correction-target': {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "conversation";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            message: import("zod").ZodString;
-            targets: import("zod").ZodArray<import("zod").ZodObject<{
-                id: import("zod").ZodString;
-                text: import("zod").ZodString;
-            }, import("zod/v4/core").$strip>>;
-            context: import("zod").ZodOptional<import("zod").ZodString>;
-            minConfidence: import("zod").ZodOptional<import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        resultSchema: import("zod").ZodObject<{
-            model: import("zod").ZodString;
-            usage: import("zod").ZodObject<{
-                input_tokens: import("zod").ZodNumber;
-                output_tokens: import("zod").ZodNumber;
-            }, import("zod/v4/core").$strip>;
-            status: import("zod").ZodEnum<{
-                ready: "ready";
-                review: "review";
-            }>;
-            verdict: import("zod").ZodEnum<{
-                matched: "matched";
-                none: "none";
-                ambiguous: "ambiguous";
-            }>;
-            selection: import("zod").ZodNullable<import("zod").ZodString>;
-            suggestedSelection: import("zod").ZodNullable<import("zod").ZodString>;
-            confidence: import("zod").ZodNumber;
-            probabilities: import("zod").ZodObject<{
-                candidates: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodNumber>;
-                none: import("zod").ZodNumber;
-                ambiguous: import("zod").ZodNumber;
-            }, import("zod/v4/core").$strip>;
-        }, import("zod/v4/core").$strip>;
-        run: (input: unknown, options?: import("../src/schema.js").RecipeOptions) => Promise<{
-            model: string;
-            usage: {
-                input_tokens: number;
-                output_tokens: number;
-            };
-            status: "ready" | "review";
-            verdict: "matched" | "none" | "ambiguous";
-            selection: string | null;
-            suggestedSelection: string | null;
-            confidence: number;
-            probabilities: {
-                candidates: Record<string, number>;
-                none: number;
-                ambiguous: number;
-            };
-        }>;
-    };
-    'confirmation-match': {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "conversation";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            proposal: import("zod").ZodString;
-            response: import("zod").ZodString;
-            context: import("zod").ZodOptional<import("zod").ZodString>;
-            minConfidence: import("zod").ZodOptional<import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        resultSchema: import("zod").ZodObject<{
-            model: import("zod").ZodString;
-            usage: import("zod").ZodObject<{
-                input_tokens: import("zod").ZodNumber;
-                output_tokens: import("zod").ZodNumber;
-            }, import("zod/v4/core").$strip>;
-            status: import("zod").ZodEnum<{
-                ready: "ready";
-                review: "review";
-            }>;
-            verdict: import("zod").ZodEnum<{
-                unclear: "unclear";
-                agrees: "agrees";
-                rejects: "rejects";
-            }>;
-            confidence: import("zod").ZodNumber;
-            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
-                unclear: "unclear";
-                agrees: "agrees";
-                rejects: "rejects";
-            }>, import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        run: (input: unknown, options?: import("../src/schema.js").RecipeOptions) => Promise<{
-            model: string;
-            usage: {
-                input_tokens: number;
-                output_tokens: number;
-            };
-            status: "ready" | "review";
-            verdict: "unclear" | "agrees" | "rejects";
-            confidence: number;
-            probabilities: Record<"unclear" | "agrees" | "rejects", number>;
-        }>;
-    };
-    'cancellation-check': {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "conversation";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            task: import("zod").ZodString;
-            message: import("zod").ZodString;
-            context: import("zod").ZodOptional<import("zod").ZodString>;
-            minConfidence: import("zod").ZodOptional<import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        resultSchema: import("zod").ZodObject<{
-            model: import("zod").ZodString;
-            usage: import("zod").ZodObject<{
-                input_tokens: import("zod").ZodNumber;
-                output_tokens: import("zod").ZodNumber;
-            }, import("zod/v4/core").$strip>;
-            status: import("zod").ZodEnum<{
-                ready: "ready";
-                review: "review";
-            }>;
-            verdict: import("zod").ZodEnum<{
-                unclear: "unclear";
-                continue: "continue";
-                cancel: "cancel";
-                pause: "pause";
-            }>;
-            confidence: import("zod").ZodNumber;
-            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
-                unclear: "unclear";
-                continue: "continue";
-                cancel: "cancel";
-                pause: "pause";
-            }>, import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        run: (input: unknown, options?: import("../src/schema.js").RecipeOptions) => Promise<{
-            model: string;
-            usage: {
-                input_tokens: number;
-                output_tokens: number;
-            };
-            status: "ready" | "review";
-            verdict: "unclear" | "continue" | "cancel" | "pause";
-            confidence: number;
-            probabilities: Record<"unclear" | "continue" | "cancel" | "pause", number>;
-        }>;
-    };
-    'topic-shift': {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "conversation";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            currentTopic: import("zod").ZodString;
-            message: import("zod").ZodString;
-            context: import("zod").ZodOptional<import("zod").ZodString>;
-            minConfidence: import("zod").ZodOptional<import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        resultSchema: import("zod").ZodObject<{
-            model: import("zod").ZodString;
-            usage: import("zod").ZodObject<{
-                input_tokens: import("zod").ZodNumber;
-                output_tokens: import("zod").ZodNumber;
-            }, import("zod/v4/core").$strip>;
-            status: import("zod").ZodEnum<{
-                ready: "ready";
-                review: "review";
-            }>;
-            verdict: import("zod").ZodEnum<{
-                unclear: "unclear";
-                same_topic: "same_topic";
-                new_topic: "new_topic";
-                mixed: "mixed";
-            }>;
-            confidence: import("zod").ZodNumber;
-            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
-                unclear: "unclear";
-                same_topic: "same_topic";
-                new_topic: "new_topic";
-                mixed: "mixed";
-            }>, import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        run: (input: unknown, options?: import("../src/schema.js").RecipeOptions) => Promise<{
-            model: string;
-            usage: {
-                input_tokens: number;
-                output_tokens: number;
-            };
-            status: "ready" | "review";
-            verdict: "unclear" | "same_topic" | "new_topic" | "mixed";
-            confidence: number;
-            probabilities: Record<"unclear" | "same_topic" | "new_topic" | "mixed", number>;
-        }>;
-    };
-    'response-needed': {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "conversation";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            message: import("zod").ZodString;
-            context: import("zod").ZodOptional<import("zod").ZodString>;
-            minConfidence: import("zod").ZodOptional<import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        resultSchema: import("zod").ZodObject<{
-            model: import("zod").ZodString;
-            usage: import("zod").ZodObject<{
-                input_tokens: import("zod").ZodNumber;
-                output_tokens: import("zod").ZodNumber;
-            }, import("zod/v4/core").$strip>;
-            status: import("zod").ZodEnum<{
-                ready: "ready";
-                review: "review";
-            }>;
-            verdict: import("zod").ZodEnum<{
-                unclear: "unclear";
-                reply_needed: "reply_needed";
-                no_reply_needed: "no_reply_needed";
-            }>;
-            confidence: import("zod").ZodNumber;
-            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
-                unclear: "unclear";
-                reply_needed: "reply_needed";
-                no_reply_needed: "no_reply_needed";
-            }>, import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        run: (input: unknown, options?: import("../src/schema.js").RecipeOptions) => Promise<{
-            model: string;
-            usage: {
-                input_tokens: number;
-                output_tokens: number;
-            };
-            status: "ready" | "review";
-            verdict: "unclear" | "reply_needed" | "no_reply_needed";
-            confidence: number;
-            probabilities: Record<"unclear" | "reply_needed" | "no_reply_needed", number>;
-        }>;
-    };
-    'resolution-check': {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "conversation";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            issue: import("zod").ZodString;
-            message: import("zod").ZodString;
-            context: import("zod").ZodOptional<import("zod").ZodString>;
-            minConfidence: import("zod").ZodOptional<import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        resultSchema: import("zod").ZodObject<{
-            model: import("zod").ZodString;
-            usage: import("zod").ZodObject<{
-                input_tokens: import("zod").ZodNumber;
-                output_tokens: import("zod").ZodNumber;
-            }, import("zod/v4/core").$strip>;
-            status: import("zod").ZodEnum<{
-                ready: "ready";
-                review: "review";
-            }>;
-            verdict: import("zod").ZodEnum<{
-                unclear: "unclear";
-                resolved: "resolved";
-                unresolved: "unresolved";
-            }>;
-            confidence: import("zod").ZodNumber;
-            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
-                unclear: "unclear";
-                resolved: "resolved";
-                unresolved: "unresolved";
-            }>, import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        run: (input: unknown, options?: import("../src/schema.js").RecipeOptions) => Promise<{
-            model: string;
-            usage: {
-                input_tokens: number;
-                output_tokens: number;
-            };
-            status: "ready" | "review";
-            verdict: "unclear" | "resolved" | "unresolved";
-            confidence: number;
-            probabilities: Record<"unclear" | "resolved" | "unresolved", number>;
-        }>;
-    };
-    rerank: {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "retrieval";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            query: import("zod").ZodString;
-            items: import("zod").ZodArray<import("zod").ZodObject<{
-                id: import("zod").ZodString;
-                text: import("zod").ZodString;
-            }, import("zod/v4/core").$strip>>;
-            topK: import("zod").ZodOptional<import("zod").ZodNumber>;
-            minRelevance: import("zod").ZodOptional<import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        resultSchema: import("zod").ZodObject<{
-            model: import("zod").ZodString;
-            usage: import("zod").ZodObject<{
-                input_tokens: import("zod").ZodNumber;
-                output_tokens: import("zod").ZodNumber;
-            }, import("zod/v4/core").$strip>;
-            status: import("zod").ZodEnum<{
-                ready: "ready";
-                review: "review";
-            }>;
-            items: import("zod").ZodArray<import("zod").ZodObject<{
-                id: import("zod").ZodString;
-                text: import("zod").ZodString;
-                relevance: import("zod").ZodNumber;
-            }, import("zod/v4/core").$strip>>;
-            evaluated: import("zod").ZodNumber;
-        }, import("zod/v4/core").$strip>;
-        run: (input: unknown, options?: import("../src/schema.js").RecipeOptions) => Promise<{
-            model: string;
-            usage: {
-                input_tokens: number;
-                output_tokens: number;
-            };
-            status: "ready" | "review";
-            items: {
-                id: string;
-                text: string;
-                relevance: number;
-            }[];
-            evaluated: number;
-        }>;
-    };
-    verify: {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "retrieval";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            claims: import("zod").ZodArray<import("zod").ZodObject<{
-                id: import("zod").ZodString;
-                claim: import("zod").ZodString;
-                evidence: import("zod").ZodString;
-            }, import("zod/v4/core").$strip>>;
-            minConfidence: import("zod").ZodOptional<import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        resultSchema: import("zod").ZodObject<{
-            model: import("zod").ZodString;
-            usage: import("zod").ZodObject<{
-                input_tokens: import("zod").ZodNumber;
-                output_tokens: import("zod").ZodNumber;
-            }, import("zod/v4/core").$strip>;
-            checks: import("zod").ZodArray<import("zod").ZodObject<{
-                id: import("zod").ZodString;
-                status: import("zod").ZodEnum<{
-                    ready: "ready";
-                    review: "review";
-                }>;
-                verdict: import("zod").ZodEnum<{
-                    supported: "supported";
-                    contradicted: "contradicted";
-                    unsupported: "unsupported";
-                }>;
-                confidence: import("zod").ZodNumber;
-                probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
-                    supported: "supported";
-                    contradicted: "contradicted";
-                    unsupported: "unsupported";
-                }>, import("zod").ZodNumber>;
-            }, import("zod/v4/core").$strip>>;
-            allSupported: import("zod").ZodBoolean;
-        }, import("zod/v4/core").$strip>;
-        run: (input: unknown, options?: import("../src/schema.js").RecipeOptions) => Promise<{
-            model: string;
-            usage: {
-                input_tokens: number;
-                output_tokens: number;
-            };
-            checks: {
-                id: string;
-                status: "ready" | "review";
-                verdict: "supported" | "contradicted" | "unsupported";
-                confidence: number;
-                probabilities: Record<"supported" | "contradicted" | "unsupported", number>;
-            }[];
-            allSupported: boolean;
-        }>;
-    };
-    answerability: {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "retrieval";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            question: import("zod").ZodString;
-            evidence: import("zod").ZodArray<import("zod").ZodObject<{
-                id: import("zod").ZodString;
-                text: import("zod").ZodString;
-            }, import("zod/v4/core").$strip>>;
-            minConfidence: import("zod").ZodOptional<import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        resultSchema: import("zod").ZodObject<{
-            model: import("zod").ZodString;
-            usage: import("zod").ZodObject<{
-                input_tokens: import("zod").ZodNumber;
-                output_tokens: import("zod").ZodNumber;
-            }, import("zod/v4/core").$strip>;
-            status: import("zod").ZodEnum<{
-                ready: "ready";
-                review: "review";
-            }>;
-            verdict: import("zod").ZodEnum<{
-                sufficient: "sufficient";
-                partial: "partial";
-                insufficient: "insufficient";
-                conflicting: "conflicting";
-            }>;
-            canAnswer: import("zod").ZodBoolean;
-            confidence: import("zod").ZodNumber;
-            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
-                sufficient: "sufficient";
-                partial: "partial";
-                insufficient: "insufficient";
-                conflicting: "conflicting";
-            }>, import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        run: (input: unknown, options?: import("../src/schema.js").RecipeOptions) => Promise<{
-            model: string;
-            usage: {
-                input_tokens: number;
-                output_tokens: number;
-            };
-            status: "ready" | "review";
-            verdict: "sufficient" | "partial" | "insufficient" | "conflicting";
-            canAnswer: boolean;
-            confidence: number;
-            probabilities: Record<"sufficient" | "partial" | "insufficient" | "conflicting", number>;
-        }>;
-    };
-    'retrieval-needed': {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "retrieval";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            request: import("zod").ZodString;
-            context: import("zod").ZodString;
-            minConfidence: import("zod").ZodOptional<import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        resultSchema: import("zod").ZodObject<{
-            model: import("zod").ZodString;
-            usage: import("zod").ZodObject<{
-                input_tokens: import("zod").ZodNumber;
-                output_tokens: import("zod").ZodNumber;
-            }, import("zod/v4/core").$strip>;
-            status: import("zod").ZodEnum<{
-                ready: "ready";
-                review: "review";
-            }>;
-            verdict: import("zod").ZodEnum<{
-                unclear: "unclear";
-                needed: "needed";
-                unnecessary: "unnecessary";
-            }>;
-            confidence: import("zod").ZodNumber;
-            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
-                unclear: "unclear";
-                needed: "needed";
-                unnecessary: "unnecessary";
-            }>, import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        run: (input: unknown, options?: import("../src/schema.js").RecipeOptions) => Promise<{
-            model: string;
-            usage: {
-                input_tokens: number;
-                output_tokens: number;
-            };
-            status: "ready" | "review";
-            verdict: "unclear" | "needed" | "unnecessary";
-            confidence: number;
-            probabilities: Record<"unclear" | "needed" | "unnecessary", number>;
-        }>;
-    };
-    'freshness-needed': {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "retrieval";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            question: import("zod").ZodString;
-            minConfidence: import("zod").ZodOptional<import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        resultSchema: import("zod").ZodObject<{
-            model: import("zod").ZodString;
-            usage: import("zod").ZodObject<{
-                input_tokens: import("zod").ZodNumber;
-                output_tokens: import("zod").ZodNumber;
-            }, import("zod/v4/core").$strip>;
-            status: import("zod").ZodEnum<{
-                ready: "ready";
-                review: "review";
-            }>;
-            verdict: import("zod").ZodEnum<{
-                unclear: "unclear";
-                current: "current";
-                stable: "stable";
-            }>;
-            confidence: import("zod").ZodNumber;
-            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
-                unclear: "unclear";
-                current: "current";
-                stable: "stable";
-            }>, import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        run: (input: unknown, options?: import("../src/schema.js").RecipeOptions) => Promise<{
-            model: string;
-            usage: {
-                input_tokens: number;
-                output_tokens: number;
-            };
-            status: "ready" | "review";
-            verdict: "unclear" | "current" | "stable";
-            confidence: number;
-            probabilities: Record<"unclear" | "current" | "stable", number>;
-        }>;
-    };
-    'source-applicability': {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "retrieval";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            passage: import("zod").ZodString;
-            scenario: import("zod").ZodString;
-            minConfidence: import("zod").ZodOptional<import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        resultSchema: import("zod").ZodObject<{
-            model: import("zod").ZodString;
-            usage: import("zod").ZodObject<{
-                input_tokens: import("zod").ZodNumber;
-                output_tokens: import("zod").ZodNumber;
-            }, import("zod/v4/core").$strip>;
-            status: import("zod").ZodEnum<{
-                ready: "ready";
-                review: "review";
-            }>;
-            verdict: import("zod").ZodEnum<{
-                unclear: "unclear";
-                applies: "applies";
-                does_not_apply: "does_not_apply";
-            }>;
-            confidence: import("zod").ZodNumber;
-            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
-                unclear: "unclear";
-                applies: "applies";
-                does_not_apply: "does_not_apply";
-            }>, import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        run: (input: unknown, options?: import("../src/schema.js").RecipeOptions) => Promise<{
-            model: string;
-            usage: {
-                input_tokens: number;
-                output_tokens: number;
-            };
-            status: "ready" | "review";
-            verdict: "unclear" | "applies" | "does_not_apply";
-            confidence: number;
-            probabilities: Record<"unclear" | "applies" | "does_not_apply", number>;
-        }>;
-    };
-    'evidence-conflict': {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "retrieval";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            firstPassage: import("zod").ZodString;
-            secondPassage: import("zod").ZodString;
-            question: import("zod").ZodString;
-            minConfidence: import("zod").ZodOptional<import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        resultSchema: import("zod").ZodObject<{
-            model: import("zod").ZodString;
-            usage: import("zod").ZodObject<{
-                input_tokens: import("zod").ZodNumber;
-                output_tokens: import("zod").ZodNumber;
-            }, import("zod/v4/core").$strip>;
-            status: import("zod").ZodEnum<{
-                ready: "ready";
-                review: "review";
-            }>;
-            verdict: import("zod").ZodEnum<{
-                conflicting: "conflicting";
-                unclear: "unclear";
-                compatible: "compatible";
-                different_scope: "different_scope";
-            }>;
-            confidence: import("zod").ZodNumber;
-            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
-                conflicting: "conflicting";
-                unclear: "unclear";
-                compatible: "compatible";
-                different_scope: "different_scope";
-            }>, import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        run: (input: unknown, options?: import("../src/schema.js").RecipeOptions) => Promise<{
-            model: string;
-            usage: {
-                input_tokens: number;
-                output_tokens: number;
-            };
-            status: "ready" | "review";
-            verdict: "conflicting" | "unclear" | "compatible" | "different_scope";
-            confidence: number;
-            probabilities: Record<"conflicting" | "unclear" | "compatible" | "different_scope", number>;
-        }>;
-    };
-    'passage-duplicate': {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "retrieval";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            firstPassage: import("zod").ZodString;
-            secondPassage: import("zod").ZodString;
-            minConfidence: import("zod").ZodOptional<import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        resultSchema: import("zod").ZodObject<{
-            model: import("zod").ZodString;
-            usage: import("zod").ZodObject<{
-                input_tokens: import("zod").ZodNumber;
-                output_tokens: import("zod").ZodNumber;
-            }, import("zod/v4/core").$strip>;
-            status: import("zod").ZodEnum<{
-                ready: "ready";
-                review: "review";
-            }>;
-            verdict: import("zod").ZodEnum<{
-                unclear: "unclear";
-                duplicate: "duplicate";
-                overlapping: "overlapping";
-                distinct: "distinct";
-            }>;
-            confidence: import("zod").ZodNumber;
-            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
-                unclear: "unclear";
-                duplicate: "duplicate";
-                overlapping: "overlapping";
-                distinct: "distinct";
-            }>, import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        run: (input: unknown, options?: import("../src/schema.js").RecipeOptions) => Promise<{
-            model: string;
-            usage: {
-                input_tokens: number;
-                output_tokens: number;
-            };
-            status: "ready" | "review";
-            verdict: "unclear" | "duplicate" | "overlapping" | "distinct";
-            confidence: number;
-            probabilities: Record<"unclear" | "duplicate" | "overlapping" | "distinct", number>;
-        }>;
-    };
-    'evidence-novelty': {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "retrieval";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            passage: import("zod").ZodString;
-            existingEvidence: import("zod").ZodArray<import("zod").ZodObject<{
-                id: import("zod").ZodString;
-                text: import("zod").ZodString;
-            }, import("zod/v4/core").$strip>>;
-            question: import("zod").ZodString;
-            minConfidence: import("zod").ZodOptional<import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        resultSchema: import("zod").ZodObject<{
-            model: import("zod").ZodString;
-            usage: import("zod").ZodObject<{
-                input_tokens: import("zod").ZodNumber;
-                output_tokens: import("zod").ZodNumber;
-            }, import("zod/v4/core").$strip>;
-            status: import("zod").ZodEnum<{
-                ready: "ready";
-                review: "review";
-            }>;
-            verdict: import("zod").ZodEnum<{
-                unclear: "unclear";
-                adds_information: "adds_information";
-                repeats_information: "repeats_information";
-                irrelevant: "irrelevant";
-            }>;
-            confidence: import("zod").ZodNumber;
-            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
-                unclear: "unclear";
-                adds_information: "adds_information";
-                repeats_information: "repeats_information";
-                irrelevant: "irrelevant";
-            }>, import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        run: (input: unknown, options?: import("../src/schema.js").RecipeOptions) => Promise<{
-            model: string;
-            usage: {
-                input_tokens: number;
-                output_tokens: number;
-            };
-            status: "ready" | "review";
-            verdict: "unclear" | "adds_information" | "repeats_information" | "irrelevant";
-            confidence: number;
-            probabilities: Record<"unclear" | "adds_information" | "repeats_information" | "irrelevant", number>;
-        }>;
-    };
-    'cache-match': {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "retrieval";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            question: import("zod").ZodString;
-            originalQuestion: import("zod").ZodString;
-            cachedAnswer: import("zod").ZodString;
-            context: import("zod").ZodOptional<import("zod").ZodString>;
-            minConfidence: import("zod").ZodOptional<import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        resultSchema: import("zod").ZodObject<{
-            model: import("zod").ZodString;
-            usage: import("zod").ZodObject<{
-                input_tokens: import("zod").ZodNumber;
-                output_tokens: import("zod").ZodNumber;
-            }, import("zod/v4/core").$strip>;
-            status: import("zod").ZodEnum<{
-                ready: "ready";
-                review: "review";
-            }>;
-            verdict: import("zod").ZodEnum<{
-                unclear: "unclear";
-                reusable: "reusable";
-                unsuitable: "unsuitable";
-            }>;
-            confidence: import("zod").ZodNumber;
-            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
-                unclear: "unclear";
-                reusable: "reusable";
-                unsuitable: "unsuitable";
-            }>, import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        run: (input: unknown, options?: import("../src/schema.js").RecipeOptions) => Promise<{
-            model: string;
-            usage: {
-                input_tokens: number;
-                output_tokens: number;
-            };
-            status: "ready" | "review";
-            verdict: "unclear" | "reusable" | "unsuitable";
-            confidence: number;
-            probabilities: Record<"unclear" | "reusable" | "unsuitable", number>;
-        }>;
-    };
-    'query-equivalence': {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "retrieval";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            firstQuestion: import("zod").ZodString;
-            secondQuestion: import("zod").ZodString;
-            context: import("zod").ZodOptional<import("zod").ZodString>;
-            minConfidence: import("zod").ZodOptional<import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        resultSchema: import("zod").ZodObject<{
-            model: import("zod").ZodString;
-            usage: import("zod").ZodObject<{
-                input_tokens: import("zod").ZodNumber;
-                output_tokens: import("zod").ZodNumber;
-            }, import("zod/v4/core").$strip>;
-            status: import("zod").ZodEnum<{
-                ready: "ready";
-                review: "review";
-            }>;
-            verdict: import("zod").ZodEnum<{
-                unclear: "unclear";
-                equivalent: "equivalent";
-                related: "related";
-                different: "different";
-            }>;
-            confidence: import("zod").ZodNumber;
-            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
-                unclear: "unclear";
-                equivalent: "equivalent";
-                related: "related";
-                different: "different";
-            }>, import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        run: (input: unknown, options?: import("../src/schema.js").RecipeOptions) => Promise<{
-            model: string;
-            usage: {
-                input_tokens: number;
-                output_tokens: number;
-            };
-            status: "ready" | "review";
-            verdict: "unclear" | "equivalent" | "related" | "different";
-            confidence: number;
-            probabilities: Record<"unclear" | "equivalent" | "related" | "different", number>;
-        }>;
-    };
-    'context-role': {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "retrieval";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            question: import("zod").ZodString;
-            passage: import("zod").ZodString;
-            minConfidence: import("zod").ZodOptional<import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        resultSchema: import("zod").ZodObject<{
-            model: import("zod").ZodString;
-            usage: import("zod").ZodObject<{
-                input_tokens: import("zod").ZodNumber;
-                output_tokens: import("zod").ZodNumber;
-            }, import("zod/v4/core").$strip>;
-            status: import("zod").ZodEnum<{
-                ready: "ready";
-                review: "review";
-            }>;
-            verdict: import("zod").ZodEnum<{
-                unclear: "unclear";
-                unrelated: "unrelated";
-                direct_evidence: "direct_evidence";
-                background: "background";
-            }>;
-            confidence: import("zod").ZodNumber;
-            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
-                unclear: "unclear";
-                unrelated: "unrelated";
-                direct_evidence: "direct_evidence";
-                background: "background";
-            }>, import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        run: (input: unknown, options?: import("../src/schema.js").RecipeOptions) => Promise<{
-            model: string;
-            usage: {
-                input_tokens: number;
-                output_tokens: number;
-            };
-            status: "ready" | "review";
-            verdict: "unclear" | "unrelated" | "direct_evidence" | "background";
-            confidence: number;
-            probabilities: Record<"unclear" | "unrelated" | "direct_evidence" | "background", number>;
-        }>;
-    };
-    'query-specificity': {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "retrieval";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            question: import("zod").ZodString;
-            context: import("zod").ZodOptional<import("zod").ZodString>;
-            minConfidence: import("zod").ZodOptional<import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        resultSchema: import("zod").ZodObject<{
-            model: import("zod").ZodString;
-            usage: import("zod").ZodObject<{
-                input_tokens: import("zod").ZodNumber;
-                output_tokens: import("zod").ZodNumber;
-            }, import("zod/v4/core").$strip>;
-            status: import("zod").ZodEnum<{
-                ready: "ready";
-                review: "review";
-            }>;
-            verdict: import("zod").ZodEnum<{
-                ambiguous: "ambiguous";
-                specific: "specific";
-                too_broad: "too_broad";
-            }>;
-            confidence: import("zod").ZodNumber;
-            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
-                ambiguous: "ambiguous";
-                specific: "specific";
-                too_broad: "too_broad";
-            }>, import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        run: (input: unknown, options?: import("../src/schema.js").RecipeOptions) => Promise<{
-            model: string;
-            usage: {
-                input_tokens: number;
-                output_tokens: number;
-            };
-            status: "ready" | "review";
-            verdict: "ambiguous" | "specific" | "too_broad";
-            confidence: number;
-            probabilities: Record<"ambiguous" | "specific" | "too_broad", number>;
-        }>;
-    };
-    'answer-coverage': {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "answer-quality";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            draft: import("zod").ZodString;
-            questions: import("zod").ZodArray<import("zod").ZodObject<{
-                id: import("zod").ZodString;
-                text: import("zod").ZodString;
-            }, import("zod/v4/core").$strip>>;
-            minConfidence: import("zod").ZodOptional<import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        resultSchema: import("zod").ZodObject<{
-            model: import("zod").ZodString;
-            usage: import("zod").ZodObject<{
-                input_tokens: import("zod").ZodNumber;
-                output_tokens: import("zod").ZodNumber;
-            }, import("zod/v4/core").$strip>;
-            status: import("zod").ZodEnum<{
-                ready: "ready";
-                review: "review";
-            }>;
-            allAnswered: import("zod").ZodBoolean;
-            checks: import("zod").ZodArray<import("zod").ZodObject<{
-                id: import("zod").ZodString;
-                status: import("zod").ZodEnum<{
-                    ready: "ready";
-                    review: "review";
-                }>;
-                verdict: import("zod").ZodEnum<{
-                    partial: "partial";
-                    missing: "missing";
-                    unclear: "unclear";
-                    answered: "answered";
-                }>;
-                confidence: import("zod").ZodNumber;
-                probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
-                    partial: "partial";
-                    missing: "missing";
-                    unclear: "unclear";
-                    answered: "answered";
-                }>, import("zod").ZodNumber>;
-            }, import("zod/v4/core").$strip>>;
-        }, import("zod/v4/core").$strip>;
-        run: (input: unknown, options?: import("../src/schema.js").RecipeOptions) => Promise<{
-            model: string;
-            usage: {
-                input_tokens: number;
-                output_tokens: number;
-            };
-            status: "ready" | "review";
-            allAnswered: boolean;
-            checks: {
-                id: string;
-                status: "ready" | "review";
-                verdict: "partial" | "missing" | "unclear" | "answered";
-                confidence: number;
-                probabilities: Record<"partial" | "missing" | "unclear" | "answered", number>;
-            }[];
-        }>;
-    };
-    'answer-relevance': {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "answer-quality";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            request: import("zod").ZodString;
-            draft: import("zod").ZodString;
-            minConfidence: import("zod").ZodOptional<import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        resultSchema: import("zod").ZodObject<{
-            model: import("zod").ZodString;
-            usage: import("zod").ZodObject<{
-                input_tokens: import("zod").ZodNumber;
-                output_tokens: import("zod").ZodNumber;
-            }, import("zod/v4/core").$strip>;
-            status: import("zod").ZodEnum<{
-                ready: "ready";
-                review: "review";
-            }>;
-            verdict: import("zod").ZodEnum<{
-                unclear: "unclear";
-                relevant: "relevant";
-                partly_relevant: "partly_relevant";
-                off_topic: "off_topic";
-            }>;
-            confidence: import("zod").ZodNumber;
-            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
-                unclear: "unclear";
-                relevant: "relevant";
-                partly_relevant: "partly_relevant";
-                off_topic: "off_topic";
-            }>, import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        run: (input: unknown, options?: import("../src/schema.js").RecipeOptions) => Promise<{
-            model: string;
-            usage: {
-                input_tokens: number;
-                output_tokens: number;
-            };
-            status: "ready" | "review";
-            verdict: "unclear" | "relevant" | "partly_relevant" | "off_topic";
-            confidence: number;
-            probabilities: Record<"unclear" | "relevant" | "partly_relevant" | "off_topic", number>;
-        }>;
-    };
-    'citation-match': {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "answer-quality";
-            tags: string[];
-            limitations: string[];
-            uses: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            claim: import("zod").ZodString;
-            passages: import("zod").ZodArray<import("zod").ZodObject<{
-                id: import("zod").ZodString;
-                text: import("zod").ZodString;
-            }, import("zod/v4/core").$strip>>;
-            minConfidence: import("zod").ZodOptional<import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        resultSchema: import("zod").ZodObject<{
-            model: import("zod").ZodString;
-            usage: import("zod").ZodObject<{
-                input_tokens: import("zod").ZodNumber;
-                output_tokens: import("zod").ZodNumber;
-            }, import("zod/v4/core").$strip>;
-            status: import("zod").ZodEnum<{
-                ready: "ready";
-                review: "review";
-            }>;
-            passageIds: import("zod").ZodArray<import("zod").ZodString>;
-            checks: import("zod").ZodArray<import("zod").ZodObject<{
-                id: import("zod").ZodString;
-                status: import("zod").ZodEnum<{
-                    ready: "ready";
-                    review: "review";
-                }>;
-                verdict: import("zod").ZodEnum<{
-                    supported: "supported";
-                    contradicted: "contradicted";
-                    unsupported: "unsupported";
-                }>;
-                confidence: import("zod").ZodNumber;
-                probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
-                    supported: "supported";
-                    contradicted: "contradicted";
-                    unsupported: "unsupported";
-                }>, import("zod").ZodNumber>;
-            }, import("zod/v4/core").$strip>>;
-        }, import("zod/v4/core").$strip>;
-        run: (input: unknown, options?: import("../src/schema.js").RecipeOptions) => Promise<{
-            model: string;
-            usage: {
-                input_tokens: number;
-                output_tokens: number;
-            };
-            status: "ready" | "review";
-            passageIds: string[];
-            checks: {
-                id: string;
-                status: "ready" | "review";
-                verdict: "supported" | "contradicted" | "unsupported";
-                confidence: number;
-                probabilities: Record<"supported" | "contradicted" | "unsupported", number>;
-            }[];
-        }>;
-    };
-    'citation-needed': {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "answer-quality";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            statement: import("zod").ZodString;
-            citationRules: import("zod").ZodString;
-            minConfidence: import("zod").ZodOptional<import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        resultSchema: import("zod").ZodObject<{
-            model: import("zod").ZodString;
-            usage: import("zod").ZodObject<{
-                input_tokens: import("zod").ZodNumber;
-                output_tokens: import("zod").ZodNumber;
-            }, import("zod/v4/core").$strip>;
-            status: import("zod").ZodEnum<{
-                ready: "ready";
-                review: "review";
-            }>;
-            verdict: import("zod").ZodEnum<{
-                unclear: "unclear";
-                needed: "needed";
-                unnecessary: "unnecessary";
-            }>;
-            confidence: import("zod").ZodNumber;
-            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
-                unclear: "unclear";
-                needed: "needed";
-                unnecessary: "unnecessary";
-            }>, import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        run: (input: unknown, options?: import("../src/schema.js").RecipeOptions) => Promise<{
-            model: string;
-            usage: {
-                input_tokens: number;
-                output_tokens: number;
-            };
-            status: "ready" | "review";
-            verdict: "unclear" | "needed" | "unnecessary";
-            confidence: number;
-            probabilities: Record<"unclear" | "needed" | "unnecessary", number>;
-        }>;
-    };
-    'answer-consistency': {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "answer-quality";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            firstStatement: import("zod").ZodString;
-            secondStatement: import("zod").ZodString;
-            context: import("zod").ZodOptional<import("zod").ZodString>;
-            minConfidence: import("zod").ZodOptional<import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        resultSchema: import("zod").ZodObject<{
-            model: import("zod").ZodString;
-            usage: import("zod").ZodObject<{
-                input_tokens: import("zod").ZodNumber;
-                output_tokens: import("zod").ZodNumber;
-            }, import("zod/v4/core").$strip>;
-            status: import("zod").ZodEnum<{
-                ready: "ready";
-                review: "review";
-            }>;
-            verdict: import("zod").ZodEnum<{
-                conflicting: "conflicting";
-                unclear: "unclear";
-                consistent: "consistent";
-                unrelated: "unrelated";
-            }>;
-            confidence: import("zod").ZodNumber;
-            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
-                conflicting: "conflicting";
-                unclear: "unclear";
-                consistent: "consistent";
-                unrelated: "unrelated";
-            }>, import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        run: (input: unknown, options?: import("../src/schema.js").RecipeOptions) => Promise<{
-            model: string;
-            usage: {
-                input_tokens: number;
-                output_tokens: number;
-            };
-            status: "ready" | "review";
-            verdict: "conflicting" | "unclear" | "consistent" | "unrelated";
-            confidence: number;
-            probabilities: Record<"conflicting" | "unclear" | "consistent" | "unrelated", number>;
-        }>;
-    };
-    'summary-coverage': {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "answer-quality";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            summary: import("zod").ZodString;
-            points: import("zod").ZodArray<import("zod").ZodObject<{
-                id: import("zod").ZodString;
-                text: import("zod").ZodString;
-            }, import("zod/v4/core").$strip>>;
-            minConfidence: import("zod").ZodOptional<import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        resultSchema: import("zod").ZodObject<{
-            model: import("zod").ZodString;
-            usage: import("zod").ZodObject<{
-                input_tokens: import("zod").ZodNumber;
-                output_tokens: import("zod").ZodNumber;
-            }, import("zod/v4/core").$strip>;
-            status: import("zod").ZodEnum<{
-                ready: "ready";
-                review: "review";
-            }>;
-            allPreserved: import("zod").ZodBoolean;
-            checks: import("zod").ZodArray<import("zod").ZodObject<{
-                id: import("zod").ZodString;
-                status: import("zod").ZodEnum<{
-                    ready: "ready";
-                    review: "review";
-                }>;
-                verdict: import("zod").ZodEnum<{
-                    partial: "partial";
-                    missing: "missing";
-                    unclear: "unclear";
-                    preserved: "preserved";
-                }>;
-                confidence: import("zod").ZodNumber;
-                probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
-                    partial: "partial";
-                    missing: "missing";
-                    unclear: "unclear";
-                    preserved: "preserved";
-                }>, import("zod").ZodNumber>;
-            }, import("zod/v4/core").$strip>>;
-        }, import("zod/v4/core").$strip>;
-        run: (input: unknown, options?: import("../src/schema.js").RecipeOptions) => Promise<{
-            model: string;
-            usage: {
-                input_tokens: number;
-                output_tokens: number;
-            };
-            status: "ready" | "review";
-            allPreserved: boolean;
-            checks: {
-                id: string;
-                status: "ready" | "review";
-                verdict: "partial" | "missing" | "unclear" | "preserved";
-                confidence: number;
-                probabilities: Record<"partial" | "missing" | "unclear" | "preserved", number>;
-            }[];
-        }>;
-    };
-    'certainty-match': {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "answer-quality";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            draft: import("zod").ZodString;
-            assessment: import("zod").ZodString;
-            minConfidence: import("zod").ZodOptional<import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        resultSchema: import("zod").ZodObject<{
-            model: import("zod").ZodString;
-            usage: import("zod").ZodObject<{
-                input_tokens: import("zod").ZodNumber;
-                output_tokens: import("zod").ZodNumber;
-            }, import("zod/v4/core").$strip>;
-            status: import("zod").ZodEnum<{
-                ready: "ready";
-                review: "review";
-            }>;
-            verdict: import("zod").ZodEnum<{
-                unclear: "unclear";
-                overstated: "overstated";
-                appropriate: "appropriate";
-                understated: "understated";
-            }>;
-            confidence: import("zod").ZodNumber;
-            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
-                unclear: "unclear";
-                overstated: "overstated";
-                appropriate: "appropriate";
-                understated: "understated";
-            }>, import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        run: (input: unknown, options?: import("../src/schema.js").RecipeOptions) => Promise<{
-            model: string;
-            usage: {
-                input_tokens: number;
-                output_tokens: number;
-            };
-            status: "ready" | "review";
-            verdict: "unclear" | "overstated" | "appropriate" | "understated";
-            confidence: number;
-            probabilities: Record<"unclear" | "overstated" | "appropriate" | "understated", number>;
-        }>;
-    };
-    'promise-check': {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "answer-quality";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            reply: import("zod").ZodString;
-            allowedCommitments: import("zod").ZodString;
-            minConfidence: import("zod").ZodOptional<import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        resultSchema: import("zod").ZodObject<{
-            model: import("zod").ZodString;
-            usage: import("zod").ZodObject<{
-                input_tokens: import("zod").ZodNumber;
-                output_tokens: import("zod").ZodNumber;
-            }, import("zod/v4/core").$strip>;
-            status: import("zod").ZodEnum<{
-                ready: "ready";
-                review: "review";
-            }>;
-            verdict: import("zod").ZodEnum<{
-                unsupported: "unsupported";
-                unclear: "unclear";
-                within_commitments: "within_commitments";
-            }>;
-            confidence: import("zod").ZodNumber;
-            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
-                unsupported: "unsupported";
-                unclear: "unclear";
-                within_commitments: "within_commitments";
-            }>, import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        run: (input: unknown, options?: import("../src/schema.js").RecipeOptions) => Promise<{
-            model: string;
-            usage: {
-                input_tokens: number;
-                output_tokens: number;
-            };
-            status: "ready" | "review";
-            verdict: "unsupported" | "unclear" | "within_commitments";
-            confidence: number;
-            probabilities: Record<"unsupported" | "unclear" | "within_commitments", number>;
-        }>;
-    };
-    'tone-check': {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "answer-quality";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            draft: import("zod").ZodString;
-            criteria: import("zod").ZodArray<import("zod").ZodObject<{
-                id: import("zod").ZodString;
-                text: import("zod").ZodString;
-            }, import("zod/v4/core").$strip>>;
-            minConfidence: import("zod").ZodOptional<import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        resultSchema: import("zod").ZodObject<{
-            model: import("zod").ZodString;
-            usage: import("zod").ZodObject<{
-                input_tokens: import("zod").ZodNumber;
-                output_tokens: import("zod").ZodNumber;
-            }, import("zod/v4/core").$strip>;
-            status: import("zod").ZodEnum<{
-                ready: "ready";
-                review: "review";
-            }>;
-            allPassed: import("zod").ZodBoolean;
-            checks: import("zod").ZodArray<import("zod").ZodObject<{
-                id: import("zod").ZodString;
-                status: import("zod").ZodEnum<{
-                    ready: "ready";
-                    review: "review";
-                }>;
-                verdict: import("zod").ZodEnum<{
-                    unclear: "unclear";
-                    pass: "pass";
-                    fail: "fail";
-                }>;
-                confidence: import("zod").ZodNumber;
-                probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
-                    unclear: "unclear";
-                    pass: "pass";
-                    fail: "fail";
-                }>, import("zod").ZodNumber>;
-            }, import("zod/v4/core").$strip>>;
-        }, import("zod/v4/core").$strip>;
-        run: (input: unknown, options?: import("../src/schema.js").RecipeOptions) => Promise<{
-            model: string;
-            usage: {
-                input_tokens: number;
-                output_tokens: number;
-            };
-            status: "ready" | "review";
-            allPassed: boolean;
-            checks: {
-                id: string;
-                status: "ready" | "review";
-                verdict: "unclear" | "pass" | "fail";
-                confidence: number;
-                probabilities: Record<"unclear" | "pass" | "fail", number>;
-            }[];
-        }>;
-    };
-    'draft-compare': {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "answer-quality";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            request: import("zod").ZodString;
-            firstDraft: import("zod").ZodString;
-            secondDraft: import("zod").ZodString;
-            rubric: import("zod").ZodString;
-            minConfidence: import("zod").ZodOptional<import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        resultSchema: import("zod").ZodObject<{
-            model: import("zod").ZodString;
-            usage: import("zod").ZodObject<{
-                input_tokens: import("zod").ZodNumber;
-                output_tokens: import("zod").ZodNumber;
-            }, import("zod/v4/core").$strip>;
-            status: import("zod").ZodEnum<{
-                ready: "ready";
-                review: "review";
-            }>;
-            verdict: import("zod").ZodEnum<{
-                unclear: "unclear";
-                first: "first";
-                second: "second";
-                tie: "tie";
-                neither: "neither";
-            }>;
-            confidence: import("zod").ZodNumber;
-            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
-                unclear: "unclear";
-                first: "first";
-                second: "second";
-                tie: "tie";
-                neither: "neither";
-            }>, import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>;
-        run: (input: unknown, options?: import("../src/schema.js").RecipeOptions) => Promise<{
-            model: string;
-            usage: {
-                input_tokens: number;
-                output_tokens: number;
-            };
-            status: "ready" | "review";
-            verdict: "unclear" | "first" | "second" | "tie" | "neither";
-            confidence: number;
-            probabilities: Record<"unclear" | "first" | "second" | "tie" | "neither", number>;
-        }>;
-    };
-};