jev-recipes 0.0.4 → 0.2.0

package/dist/catalog/recipes.d.ts

@@ -1,17 +1,2637 @@
-import type { RecipeOptions } from '../src/schema.js';
 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";
+            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<{
-            request: import("zod").ZodString;
-            routes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
+            firstPassage: import("zod").ZodString;
+            secondPassage: import("zod").ZodString;
             minConfidence: import("zod").ZodOptional<import("zod").ZodNumber>;
         }, import("zod/v4/core").$strip>;
         resultSchema: import("zod").ZodObject<{
@@ -24,41 +2644,364 @@ export declare const recipes: {
                 ready: "ready";
                 review: "review";
             }>;
-            route: import("zod").ZodNullable<import("zod").ZodString>;
-            suggestedRoute: import("zod").ZodNullable<import("zod").ZodString>;
+            verdict: import("zod").ZodEnum<{
+                unclear: "unclear";
+                duplicate: "duplicate";
+                overlapping: "overlapping";
+                distinct: "distinct";
+            }>;
             confidence: import("zod").ZodNumber;
-            probabilities: import("zod").ZodRecord<import("zod").ZodString, 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?: RecipeOptions) => Promise<{
+        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>;
+            allAnswered: boolean;
+            checks: {
+                id: string;
+                status: "ready" | "review";
+                verdict: "partial" | "missing" | "unclear" | "answered";
+                confidence: number;
+                probabilities: Record<"partial" | "missing" | "unclear" | "answered", number>;
+            }[];
         }>;
     };
-    rerank: {
+    'answer-relevance': {
         metadata: {
             id: string;
             title: string;
             description: string;
-            category: "retrieval";
+            category: "answer-quality";
             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>;
+            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;
@@ -70,42 +3013,47 @@ export declare const recipes: {
                 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;
+            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?: RecipeOptions) => Promise<{
+        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;
+            verdict: "unclear" | "relevant" | "partly_relevant" | "off_topic";
+            confidence: number;
+            probabilities: Record<"unclear" | "relevant" | "partly_relevant" | "off_topic", number>;
         }>;
     };
-    verify: {
+    'citation-match': {
         metadata: {
             id: string;
             title: string;
             description: string;
-            category: "retrieval";
+            category: "answer-quality";
             tags: string[];
             limitations: string[];
+            uses: string[];
         };
         inputSchema: import("zod").ZodObject<{
-            claims: import("zod").ZodArray<import("zod").ZodObject<{
+            claim: import("zod").ZodString;
+            passages: import("zod").ZodArray<import("zod").ZodObject<{
                 id: import("zod").ZodString;
-                claim: import("zod").ZodString;
-                evidence: import("zod").ZodString;
+                text: import("zod").ZodString;
             }, import("zod/v4/core").$strip>>;
             minConfidence: import("zod").ZodOptional<import("zod").ZodNumber>;
         }, import("zod/v4/core").$strip>;
@@ -115,6 +3063,11 @@ export declare const recipes: {
                 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<{
@@ -133,14 +3086,15 @@ export declare const recipes: {
                     unsupported: "unsupported";
                 }>, import("zod").ZodNumber>;
             }, import("zod/v4/core").$strip>>;
-            allSupported: import("zod").ZodBoolean;
         }, import("zod/v4/core").$strip>;
-        run: (input: unknown, options?: RecipeOptions) => Promise<{
+        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";
@@ -148,24 +3102,69 @@ export declare const recipes: {
                 confidence: number;
                 probabilities: Record<"supported" | "contradicted" | "unsupported", number>;
             }[];
-            allSupported: boolean;
         }>;
     };
-    answerability: {
+    'citation-needed': {
         metadata: {
             id: string;
             title: string;
             description: string;
-            category: "retrieval";
+            category: "answer-quality";
             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>>;
+            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<{
@@ -179,48 +3178,45 @@ export declare const recipes: {
                 review: "review";
             }>;
             verdict: import("zod").ZodEnum<{
-                sufficient: "sufficient";
-                partial: "partial";
-                insufficient: "insufficient";
                 conflicting: "conflicting";
+                unclear: "unclear";
+                consistent: "consistent";
+                unrelated: "unrelated";
             }>;
-            canAnswer: import("zod").ZodBoolean;
             confidence: import("zod").ZodNumber;
             probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
-                sufficient: "sufficient";
-                partial: "partial";
-                insufficient: "insufficient";
                 conflicting: "conflicting";
+                unclear: "unclear";
+                consistent: "consistent";
+                unrelated: "unrelated";
             }>, import("zod").ZodNumber>;
         }, import("zod/v4/core").$strip>;
-        run: (input: unknown, options?: RecipeOptions) => Promise<{
+        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;
+            verdict: "conflicting" | "unclear" | "consistent" | "unrelated";
             confidence: number;
-            probabilities: Record<"sufficient" | "partial" | "insufficient" | "conflicting", number>;
+            probabilities: Record<"conflicting" | "unclear" | "consistent" | "unrelated", number>;
         }>;
     };
-    clarify: {
+    'summary-coverage': {
         metadata: {
             id: string;
             title: string;
             description: string;
-            category: "conversation";
+            category: "answer-quality";
             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<{
+            summary: import("zod").ZodString;
+            points: import("zod").ZodArray<import("zod").ZodObject<{
                 id: import("zod").ZodString;
-                description: import("zod").ZodString;
+                text: import("zod").ZodString;
             }, import("zod/v4/core").$strip>>;
             minConfidence: import("zod").ZodOptional<import("zod").ZodNumber>;
         }, import("zod/v4/core").$strip>;
@@ -234,9 +3230,7 @@ export declare const recipes: {
                 ready: "ready";
                 review: "review";
             }>;
-            canProceed: import("zod").ZodBoolean;
-            missing: import("zod").ZodArray<import("zod").ZodString>;
-            ambiguous: import("zod").ZodArray<import("zod").ZodString>;
+            allPreserved: import("zod").ZodBoolean;
             checks: import("zod").ZodArray<import("zod").ZodObject<{
                 id: import("zod").ZodString;
                 status: import("zod").ZodEnum<{
@@ -244,53 +3238,49 @@ export declare const recipes: {
                     review: "review";
                 }>;
                 verdict: import("zod").ZodEnum<{
-                    present: "present";
+                    partial: "partial";
                     missing: "missing";
-                    ambiguous: "ambiguous";
+                    unclear: "unclear";
+                    preserved: "preserved";
                 }>;
                 confidence: import("zod").ZodNumber;
                 probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
-                    present: "present";
+                    partial: "partial";
                     missing: "missing";
-                    ambiguous: "ambiguous";
+                    unclear: "unclear";
+                    preserved: "preserved";
                 }>, import("zod").ZodNumber>;
             }, import("zod/v4/core").$strip>>;
         }, import("zod/v4/core").$strip>;
-        run: (input: unknown, options?: RecipeOptions) => Promise<{
+        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[];
+            allPreserved: boolean;
             checks: {
                 id: string;
                 status: "ready" | "review";
-                verdict: "present" | "missing" | "ambiguous";
+                verdict: "partial" | "missing" | "unclear" | "preserved";
                 confidence: number;
-                probabilities: Record<"present" | "missing" | "ambiguous", number>;
+                probabilities: Record<"partial" | "missing" | "unclear" | "preserved", number>;
             }[];
         }>;
     };
-    handoff: {
+    'certainty-match': {
         metadata: {
             id: string;
             title: string;
             description: string;
-            category: "workflow";
+            category: "answer-quality";
             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>>;
+            draft: import("zod").ZodString;
+            assessment: import("zod").ZodString;
             minConfidence: import("zod").ZodOptional<import("zod").ZodNumber>;
         }, import("zod/v4/core").$strip>;
         resultSchema: import("zod").ZodObject<{
@@ -303,13 +3293,108 @@ export declare const recipes: {
                 ready: "ready";
                 review: "review";
             }>;
-            decision: import("zod").ZodEnum<{
+            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";
-                human: "human";
-                continue: "continue";
             }>;
-            matchedRules: import("zod").ZodArray<import("zod").ZodString>;
-            uncertainRules: import("zod").ZodArray<import("zod").ZodString>;
+            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<{
@@ -317,35 +3402,87 @@ export declare const recipes: {
                     review: "review";
                 }>;
                 verdict: import("zod").ZodEnum<{
-                    matches: "matches";
-                    does_not_match: "does_not_match";
                     unclear: "unclear";
+                    pass: "pass";
+                    fail: "fail";
                 }>;
                 confidence: import("zod").ZodNumber;
                 probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
-                    matches: "matches";
-                    does_not_match: "does_not_match";
                     unclear: "unclear";
+                    pass: "pass";
+                    fail: "fail";
                 }>, import("zod").ZodNumber>;
             }, import("zod/v4/core").$strip>>;
         }, import("zod/v4/core").$strip>;
-        run: (input: unknown, options?: RecipeOptions) => Promise<{
+        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[];
+            allPassed: boolean;
             checks: {
                 id: string;
                 status: "ready" | "review";
-                verdict: "matches" | "does_not_match" | "unclear";
+                verdict: "unclear" | "pass" | "fail";
                 confidence: number;
-                probabilities: Record<"matches" | "does_not_match" | "unclear", 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>;
+        }>;
+    };
 };