jev-recipes 0.0.4 → 0.2.0

package/dist/catalog/recipes.js

@@ -1,50 +1,14 @@
-import { route, routeInputSchema, routeResultSchema } from '../recipes/route/index.js';
-import { metadata as routeMetadata } from '../recipes/route/metadata.js';
-import { rerank, rerankInputSchema, rerankResultSchema } from '../recipes/rerank/index.js';
-import { metadata as rerankMetadata } from '../recipes/rerank/metadata.js';
-import { verify, verifyInputSchema, verifyResultSchema } from '../recipes/verify/index.js';
-import { metadata as verifyMetadata } from '../recipes/verify/metadata.js';
-import { answerability, answerabilityInputSchema, answerabilityResultSchema, } from '../recipes/answerability/index.js';
-import { metadata as answerabilityMetadata } from '../recipes/answerability/metadata.js';
-import { clarify, clarifyInputSchema, clarifyResultSchema } from '../recipes/clarify/index.js';
-import { metadata as clarifyMetadata } from '../recipes/clarify/metadata.js';
-import { handoff, handoffInputSchema, handoffResultSchema } from '../recipes/handoff/index.js';
-import { metadata as handoffMetadata } from '../recipes/handoff/metadata.js';
+import { answersRecipes } from './groups/answers.js';
+import { retrievalRecipes } from './groups/retrieval.js';
+import { conversationRecipes } from './groups/conversation.js';
+import { workflowRecipes } from './groups/workflow.js';
+import { supportRecipes } from './groups/support.js';
+import { knowledgeRecipes } from './groups/knowledge.js';
 export const recipes = {
-    route: {
-        metadata: routeMetadata,
-        inputSchema: routeInputSchema,
-        resultSchema: routeResultSchema,
-        run: (input, options) => route(routeInputSchema.parse(input), options),
-    },
-    rerank: {
-        metadata: rerankMetadata,
-        inputSchema: rerankInputSchema,
-        resultSchema: rerankResultSchema,
-        run: (input, options) => rerank(rerankInputSchema.parse(input), options),
-    },
-    verify: {
-        metadata: verifyMetadata,
-        inputSchema: verifyInputSchema,
-        resultSchema: verifyResultSchema,
-        run: (input, options) => verify(verifyInputSchema.parse(input), options),
-    },
-    answerability: {
-        metadata: answerabilityMetadata,
-        inputSchema: answerabilityInputSchema,
-        resultSchema: answerabilityResultSchema,
-        run: (input, options) => answerability(answerabilityInputSchema.parse(input), options),
-    },
-    clarify: {
-        metadata: clarifyMetadata,
-        inputSchema: clarifyInputSchema,
-        resultSchema: clarifyResultSchema,
-        run: (input, options) => clarify(clarifyInputSchema.parse(input), options),
-    },
-    handoff: {
-        metadata: handoffMetadata,
-        inputSchema: handoffInputSchema,
-        resultSchema: handoffResultSchema,
-        run: (input, options) => handoff(handoffInputSchema.parse(input), options),
-    },
+    ...answersRecipes,
+    ...retrievalRecipes,
+    ...conversationRecipes,
+    ...workflowRecipes,
+    ...supportRecipes,
+    ...knowledgeRecipes,
 };

package/dist/catalog/schema.d.ts

@@ -2,10 +2,70 @@ import { z } from 'zod';
 export declare const recipeNameSchema: z.ZodEnum<{
     route: "route";
     answerability: "answerability";
-    rerank: "rerank";
+    "answer-coverage": "answer-coverage";
+    "answer-relevance": "answer-relevance";
+    "citation-match": "citation-match";
     verify: "verify";
+    "citation-needed": "citation-needed";
+    "answer-consistency": "answer-consistency";
+    "summary-coverage": "summary-coverage";
+    "certainty-match": "certainty-match";
+    "promise-check": "promise-check";
+    "tone-check": "tone-check";
+    "draft-compare": "draft-compare";
+    rerank: "rerank";
+    "retrieval-needed": "retrieval-needed";
+    "freshness-needed": "freshness-needed";
+    "source-applicability": "source-applicability";
+    "evidence-conflict": "evidence-conflict";
+    "passage-duplicate": "passage-duplicate";
+    "evidence-novelty": "evidence-novelty";
+    "cache-match": "cache-match";
+    "query-equivalence": "query-equivalence";
+    "context-role": "context-role";
+    "query-specificity": "query-specificity";
     clarify: "clarify";
+    "turn-intent": "turn-intent";
+    "followup-link": "followup-link";
+    "reference-resolve": "reference-resolve";
+    "intent-change": "intent-change";
+    "correction-target": "correction-target";
+    "confirmation-match": "confirmation-match";
+    "cancellation-check": "cancellation-check";
+    "topic-shift": "topic-shift";
+    "response-needed": "response-needed";
+    "resolution-check": "resolution-check";
     handoff: "handoff";
+    "tool-fit": "tool-fit";
+    "argument-fit": "argument-fit";
+    "result-usefulness": "result-usefulness";
+    "result-outcome": "result-outcome";
+    "action-scope": "action-scope";
+    "step-progress": "step-progress";
+    "repeated-attempt": "repeated-attempt";
+    "step-complete": "step-complete";
+    "failure-kind": "failure-kind";
+    "instruction-fit": "instruction-fit";
+    "issue-impact": "issue-impact";
+    "attempted-step": "attempted-step";
+    "workaround-fit": "workaround-fit";
+    "ticket-match": "ticket-match";
+    "incident-match": "incident-match";
+    "troubleshooting-fit": "troubleshooting-fit";
+    "frustration-signal": "frustration-signal";
+    "urgency-signal": "urgency-signal";
+    "feedback-kind": "feedback-kind";
+    "reply-template-match": "reply-template-match";
+    "memory-value": "memory-value";
+    "memory-scope": "memory-scope";
+    "memory-relation": "memory-relation";
+    "preference-kind": "preference-kind";
+    "fact-stability": "fact-stability";
+    "document-role": "document-role";
+    "audience-fit": "audience-fit";
+    "change-meaning": "change-meaning";
+    "answer-invalidation": "answer-invalidation";
+    "field-select": "field-select";
 }>;
 export declare const recipeFiltersSchema: z.ZodObject<{
     query: z.ZodOptional<z.ZodString>;
@@ -13,6 +73,10 @@ export declare const recipeFiltersSchema: z.ZodObject<{
         retrieval: "retrieval";
         conversation: "conversation";
         workflow: "workflow";
+        "answer-quality": "answer-quality";
+        support: "support";
+        memory: "memory";
+        knowledge: "knowledge";
     }>>;
 }, z.core.$strip>;
 export type RecipeName = z.infer<typeof recipeNameSchema>;

package/dist/cli/index.js

@@ -42,7 +42,7 @@ function printHelp() {
   jev-recipes run <recipe> <file|->      Run live with a JSON file or stdin
   jev-recipes --version
 
-Categories: retrieval, conversation, workflow. Quote multi-word search queries.
+Categories: ${recipeCategorySchema.options.join(', ')}. Quote multi-word search queries.
 Live runs send your input to TypeSafe and require TYPESAFE_API_KEY.
 Output is JSON. Errors go to stderr and exit with code 1.
 Review outcomes are successful evaluations; inspect status before acting.

package/dist/cli/schema.d.ts

@@ -6,34 +6,222 @@ export declare const commandArgumentsSchema: z.ZodUnion<readonly [z.ZodTuple<[z.
     retrieval: "retrieval";
     conversation: "conversation";
     workflow: "workflow";
+    "answer-quality": "answer-quality";
+    support: "support";
+    memory: "memory";
+    knowledge: "knowledge";
 }>], null>, z.ZodTuple<[z.ZodLiteral<"list">, z.ZodString, z.ZodLiteral<"--category">, z.ZodEnum<{
     retrieval: "retrieval";
     conversation: "conversation";
     workflow: "workflow";
+    "answer-quality": "answer-quality";
+    support: "support";
+    memory: "memory";
+    knowledge: "knowledge";
 }>], null>, z.ZodTuple<[z.ZodLiteral<"demo">, z.ZodUnion<readonly [z.ZodEnum<{
     route: "route";
     answerability: "answerability";
-    rerank: "rerank";
+    "answer-coverage": "answer-coverage";
+    "answer-relevance": "answer-relevance";
+    "citation-match": "citation-match";
     verify: "verify";
+    "citation-needed": "citation-needed";
+    "answer-consistency": "answer-consistency";
+    "summary-coverage": "summary-coverage";
+    "certainty-match": "certainty-match";
+    "promise-check": "promise-check";
+    "tone-check": "tone-check";
+    "draft-compare": "draft-compare";
+    rerank: "rerank";
+    "retrieval-needed": "retrieval-needed";
+    "freshness-needed": "freshness-needed";
+    "source-applicability": "source-applicability";
+    "evidence-conflict": "evidence-conflict";
+    "passage-duplicate": "passage-duplicate";
+    "evidence-novelty": "evidence-novelty";
+    "cache-match": "cache-match";
+    "query-equivalence": "query-equivalence";
+    "context-role": "context-role";
+    "query-specificity": "query-specificity";
     clarify: "clarify";
+    "turn-intent": "turn-intent";
+    "followup-link": "followup-link";
+    "reference-resolve": "reference-resolve";
+    "intent-change": "intent-change";
+    "correction-target": "correction-target";
+    "confirmation-match": "confirmation-match";
+    "cancellation-check": "cancellation-check";
+    "topic-shift": "topic-shift";
+    "response-needed": "response-needed";
+    "resolution-check": "resolution-check";
     handoff: "handoff";
+    "tool-fit": "tool-fit";
+    "argument-fit": "argument-fit";
+    "result-usefulness": "result-usefulness";
+    "result-outcome": "result-outcome";
+    "action-scope": "action-scope";
+    "step-progress": "step-progress";
+    "repeated-attempt": "repeated-attempt";
+    "step-complete": "step-complete";
+    "failure-kind": "failure-kind";
+    "instruction-fit": "instruction-fit";
+    "issue-impact": "issue-impact";
+    "attempted-step": "attempted-step";
+    "workaround-fit": "workaround-fit";
+    "ticket-match": "ticket-match";
+    "incident-match": "incident-match";
+    "troubleshooting-fit": "troubleshooting-fit";
+    "frustration-signal": "frustration-signal";
+    "urgency-signal": "urgency-signal";
+    "feedback-kind": "feedback-kind";
+    "reply-template-match": "reply-template-match";
+    "memory-value": "memory-value";
+    "memory-scope": "memory-scope";
+    "memory-relation": "memory-relation";
+    "preference-kind": "preference-kind";
+    "fact-stability": "fact-stability";
+    "document-role": "document-role";
+    "audience-fit": "audience-fit";
+    "change-meaning": "change-meaning";
+    "answer-invalidation": "answer-invalidation";
+    "field-select": "field-select";
 }>, z.ZodLiteral<"all">]>], null>, z.ZodTuple<[z.ZodEnum<{
     example: "example";
     describe: "describe";
 }>, z.ZodEnum<{
     route: "route";
     answerability: "answerability";
-    rerank: "rerank";
+    "answer-coverage": "answer-coverage";
+    "answer-relevance": "answer-relevance";
+    "citation-match": "citation-match";
     verify: "verify";
+    "citation-needed": "citation-needed";
+    "answer-consistency": "answer-consistency";
+    "summary-coverage": "summary-coverage";
+    "certainty-match": "certainty-match";
+    "promise-check": "promise-check";
+    "tone-check": "tone-check";
+    "draft-compare": "draft-compare";
+    rerank: "rerank";
+    "retrieval-needed": "retrieval-needed";
+    "freshness-needed": "freshness-needed";
+    "source-applicability": "source-applicability";
+    "evidence-conflict": "evidence-conflict";
+    "passage-duplicate": "passage-duplicate";
+    "evidence-novelty": "evidence-novelty";
+    "cache-match": "cache-match";
+    "query-equivalence": "query-equivalence";
+    "context-role": "context-role";
+    "query-specificity": "query-specificity";
     clarify: "clarify";
+    "turn-intent": "turn-intent";
+    "followup-link": "followup-link";
+    "reference-resolve": "reference-resolve";
+    "intent-change": "intent-change";
+    "correction-target": "correction-target";
+    "confirmation-match": "confirmation-match";
+    "cancellation-check": "cancellation-check";
+    "topic-shift": "topic-shift";
+    "response-needed": "response-needed";
+    "resolution-check": "resolution-check";
     handoff: "handoff";
+    "tool-fit": "tool-fit";
+    "argument-fit": "argument-fit";
+    "result-usefulness": "result-usefulness";
+    "result-outcome": "result-outcome";
+    "action-scope": "action-scope";
+    "step-progress": "step-progress";
+    "repeated-attempt": "repeated-attempt";
+    "step-complete": "step-complete";
+    "failure-kind": "failure-kind";
+    "instruction-fit": "instruction-fit";
+    "issue-impact": "issue-impact";
+    "attempted-step": "attempted-step";
+    "workaround-fit": "workaround-fit";
+    "ticket-match": "ticket-match";
+    "incident-match": "incident-match";
+    "troubleshooting-fit": "troubleshooting-fit";
+    "frustration-signal": "frustration-signal";
+    "urgency-signal": "urgency-signal";
+    "feedback-kind": "feedback-kind";
+    "reply-template-match": "reply-template-match";
+    "memory-value": "memory-value";
+    "memory-scope": "memory-scope";
+    "memory-relation": "memory-relation";
+    "preference-kind": "preference-kind";
+    "fact-stability": "fact-stability";
+    "document-role": "document-role";
+    "audience-fit": "audience-fit";
+    "change-meaning": "change-meaning";
+    "answer-invalidation": "answer-invalidation";
+    "field-select": "field-select";
 }>], null>, z.ZodTuple<[z.ZodLiteral<"run">, z.ZodEnum<{
     route: "route";
     answerability: "answerability";
-    rerank: "rerank";
+    "answer-coverage": "answer-coverage";
+    "answer-relevance": "answer-relevance";
+    "citation-match": "citation-match";
     verify: "verify";
+    "citation-needed": "citation-needed";
+    "answer-consistency": "answer-consistency";
+    "summary-coverage": "summary-coverage";
+    "certainty-match": "certainty-match";
+    "promise-check": "promise-check";
+    "tone-check": "tone-check";
+    "draft-compare": "draft-compare";
+    rerank: "rerank";
+    "retrieval-needed": "retrieval-needed";
+    "freshness-needed": "freshness-needed";
+    "source-applicability": "source-applicability";
+    "evidence-conflict": "evidence-conflict";
+    "passage-duplicate": "passage-duplicate";
+    "evidence-novelty": "evidence-novelty";
+    "cache-match": "cache-match";
+    "query-equivalence": "query-equivalence";
+    "context-role": "context-role";
+    "query-specificity": "query-specificity";
     clarify: "clarify";
+    "turn-intent": "turn-intent";
+    "followup-link": "followup-link";
+    "reference-resolve": "reference-resolve";
+    "intent-change": "intent-change";
+    "correction-target": "correction-target";
+    "confirmation-match": "confirmation-match";
+    "cancellation-check": "cancellation-check";
+    "topic-shift": "topic-shift";
+    "response-needed": "response-needed";
+    "resolution-check": "resolution-check";
     handoff: "handoff";
+    "tool-fit": "tool-fit";
+    "argument-fit": "argument-fit";
+    "result-usefulness": "result-usefulness";
+    "result-outcome": "result-outcome";
+    "action-scope": "action-scope";
+    "step-progress": "step-progress";
+    "repeated-attempt": "repeated-attempt";
+    "step-complete": "step-complete";
+    "failure-kind": "failure-kind";
+    "instruction-fit": "instruction-fit";
+    "issue-impact": "issue-impact";
+    "attempted-step": "attempted-step";
+    "workaround-fit": "workaround-fit";
+    "ticket-match": "ticket-match";
+    "incident-match": "incident-match";
+    "troubleshooting-fit": "troubleshooting-fit";
+    "frustration-signal": "frustration-signal";
+    "urgency-signal": "urgency-signal";
+    "feedback-kind": "feedback-kind";
+    "reply-template-match": "reply-template-match";
+    "memory-value": "memory-value";
+    "memory-scope": "memory-scope";
+    "memory-relation": "memory-relation";
+    "preference-kind": "preference-kind";
+    "fact-stability": "fact-stability";
+    "document-role": "document-role";
+    "audience-fit": "audience-fit";
+    "change-meaning": "change-meaning";
+    "answer-invalidation": "answer-invalidation";
+    "field-select": "field-select";
 }>, z.ZodString], null>]>;
 export declare const demoFixtureSchema: z.ZodObject<{
     input: z.ZodUnknown;

package/dist/examples/support/schema.d.ts

@@ -92,15 +92,15 @@ export declare const supportDecisionsSchema: z.ZodObject<{
                 review: "review";
             }>;
             verdict: z.ZodEnum<{
+                ambiguous: "ambiguous";
                 present: "present";
                 missing: "missing";
-                ambiguous: "ambiguous";
             }>;
             confidence: z.ZodNumber;
             probabilities: z.ZodRecord<z.ZodEnum<{
+                ambiguous: "ambiguous";
                 present: "present";
                 missing: "missing";
-                ambiguous: "ambiguous";
             }>, z.ZodNumber>;
         }, z.core.$strip>>;
     }, z.core.$strip>>;
@@ -255,15 +255,15 @@ export declare const supportResultSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
                     review: "review";
                 }>;
                 verdict: z.ZodEnum<{
+                    ambiguous: "ambiguous";
                     present: "present";
                     missing: "missing";
-                    ambiguous: "ambiguous";
                 }>;
                 confidence: z.ZodNumber;
                 probabilities: z.ZodRecord<z.ZodEnum<{
+                    ambiguous: "ambiguous";
                     present: "present";
                     missing: "missing";
-                    ambiguous: "ambiguous";
                 }>, z.ZodNumber>;
             }, z.core.$strip>>;
         }, z.core.$strip>>;
@@ -363,8 +363,8 @@ export declare const supportResultSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     stage: z.ZodEnum<{
         route: "route";
         answerability: "answerability";
-        rerank: "rerank";
         verify: "verify";
+        rerank: "rerank";
         clarify: "clarify";
         handoff: "handoff";
     }>;
@@ -425,15 +425,15 @@ export declare const supportResultSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
                     review: "review";
                 }>;
                 verdict: z.ZodEnum<{
+                    ambiguous: "ambiguous";
                     present: "present";
                     missing: "missing";
-                    ambiguous: "ambiguous";
                 }>;
                 confidence: z.ZodNumber;
                 probabilities: z.ZodRecord<z.ZodEnum<{
+                    ambiguous: "ambiguous";
                     present: "present";
                     missing: "missing";
-                    ambiguous: "ambiguous";
                 }>, z.ZodNumber>;
             }, z.core.$strip>>;
         }, z.core.$strip>>;

package/dist/recipes/action-scope/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { ActionScopeInput, ActionScopeResult } from './schema.js';
+export declare function actionScope(input: ActionScopeInput, options?: RecipeOptions): Promise<ActionScopeResult>;
+export { actionScopeInputSchema, actionScopeResultSchema, actionScopeVerdictSchema, } from './schema.js';
+export type { ActionScopeInput, ActionScopeResult, ActionScopeVerdict } from './schema.js';

package/dist/recipes/action-scope/index.js

@@ -0,0 +1,15 @@
+import { evaluateChoice } from '../../src/decisions.js';
+import { actionScopeInputSchema, actionScopeResultSchema } from './schema.js';
+export async function actionScope(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = actionScopeInputSchema.parse(input);
+    const decision = await evaluateChoice(state, 'Is proposedAction within the work requested in request and constraints? Do not treat a potentially helpful extra task as requested work. An explicit constraint overrides an implied convenience.', {
+        within_scope: 'The action is explicitly requested or directly necessary under the stated constraints.',
+        additional_work: 'The action introduces unrequested work, changes the requested outcome, or violates a stated scope constraint.',
+        unclear: 'The scope relationship cannot be established from the request.',
+    }, options);
+    return actionScopeResultSchema.parse({
+        ...decision,
+        status: decision.confidence < minConfidence || decision.verdict === 'unclear' ? 'review' : 'ready',
+    });
+}
+export { actionScopeInputSchema, actionScopeResultSchema, actionScopeVerdictSchema, } from './schema.js';

package/dist/recipes/action-scope/metadata.d.ts

@@ -0,0 +1,8 @@
+export declare const metadata: {
+    id: string;
+    title: string;
+    description: string;
+    category: "workflow";
+    tags: string[];
+    limitations: string[];
+};

package/dist/recipes/action-scope/metadata.js

@@ -0,0 +1,10 @@
+export const metadata = {
+    id: 'action-scope',
+    title: 'Check proposed action scope',
+    description: 'Is proposedAction within the work requested in request and constraints?',
+    category: 'workflow',
+    tags: ['workflow', 'action', 'scope'],
+    limitations: [
+        'Assesses semantic scope only. User authorization and access controls must be enforced by the application.',
+    ],
+};

package/dist/recipes/action-scope/schema.d.ts

@@ -0,0 +1,37 @@
+import { z } from 'zod';
+export declare const actionScopeVerdictSchema: z.ZodEnum<{
+    unclear: "unclear";
+    within_scope: "within_scope";
+    additional_work: "additional_work";
+}>;
+export declare const actionScopeInputSchema: z.ZodObject<{
+    request: z.ZodString;
+    proposedAction: z.ZodString;
+    constraints: z.ZodOptional<z.ZodString>;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const actionScopeResultSchema: z.ZodObject<{
+    model: z.ZodString;
+    usage: z.ZodObject<{
+        input_tokens: z.ZodNumber;
+        output_tokens: z.ZodNumber;
+    }, z.core.$strip>;
+    status: z.ZodEnum<{
+        ready: "ready";
+        review: "review";
+    }>;
+    verdict: z.ZodEnum<{
+        unclear: "unclear";
+        within_scope: "within_scope";
+        additional_work: "additional_work";
+    }>;
+    confidence: z.ZodNumber;
+    probabilities: z.ZodRecord<z.ZodEnum<{
+        unclear: "unclear";
+        within_scope: "within_scope";
+        additional_work: "additional_work";
+    }>, z.ZodNumber>;
+}, z.core.$strip>;
+export type ActionScopeInput = z.infer<typeof actionScopeInputSchema>;
+export type ActionScopeResult = z.infer<typeof actionScopeResultSchema>;
+export type ActionScopeVerdict = z.infer<typeof actionScopeVerdictSchema>;

package/dist/recipes/action-scope/schema.js

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+import { decisionStatusSchema, nonEmptyText, probability, resultMetadataSchema, } from '../../src/schema.js';
+export const actionScopeVerdictSchema = z.enum(['within_scope', 'additional_work', 'unclear']);
+export const actionScopeInputSchema = z.object({
+    request: nonEmptyText,
+    proposedAction: nonEmptyText,
+    constraints: nonEmptyText.optional(),
+    minConfidence: probability.optional(),
+});
+export const actionScopeResultSchema = resultMetadataSchema.extend({
+    status: decisionStatusSchema,
+    verdict: actionScopeVerdictSchema,
+    confidence: probability,
+    probabilities: z.record(actionScopeVerdictSchema, probability),
+});

package/dist/recipes/answer-consistency/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { AnswerConsistencyInput, AnswerConsistencyResult } from './schema.js';
+export declare function answerConsistency(input: AnswerConsistencyInput, options?: RecipeOptions): Promise<AnswerConsistencyResult>;
+export { answerConsistencyInputSchema, answerConsistencyResultSchema, answerConsistencyVerdictSchema, } from './schema.js';
+export type { AnswerConsistencyInput, AnswerConsistencyResult, AnswerConsistencyVerdict, } from './schema.js';

package/dist/recipes/answer-consistency/index.js

@@ -0,0 +1,16 @@
+import { evaluateChoice } from '../../src/decisions.js';
+import { answerConsistencyInputSchema, answerConsistencyResultSchema } from './schema.js';
+export async function answerConsistency(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = answerConsistencyInputSchema.parse(input);
+    const decision = await evaluateChoice(state, 'Do firstStatement and secondStatement make compatible claims about the same subject and circumstances? Distinguish different conditions from a contradiction.', {
+        consistent: 'Both statements concern the same subject and can hold under the supplied circumstances.',
+        conflicting: 'The statements concern the same circumstances and make mutually incompatible claims.',
+        unrelated: 'The statements concern different subjects or scopes that should not be compared.',
+        unclear: 'The supplied circumstances do not resolve whether the statements conflict.',
+    }, options);
+    return answerConsistencyResultSchema.parse({
+        ...decision,
+        status: decision.confidence < minConfidence || decision.verdict === 'unclear' ? 'review' : 'ready',
+    });
+}
+export { answerConsistencyInputSchema, answerConsistencyResultSchema, answerConsistencyVerdictSchema, } from './schema.js';

package/dist/recipes/answer-consistency/metadata.d.ts

@@ -0,0 +1,8 @@
+export declare const metadata: {
+    id: string;
+    title: string;
+    description: string;
+    category: "answer-quality";
+    tags: string[];
+    limitations: string[];
+};

package/dist/recipes/answer-consistency/metadata.js

@@ -0,0 +1,10 @@
+export const metadata = {
+    id: 'answer-consistency',
+    title: 'Check answer consistency',
+    description: 'Do firstStatement and secondStatement make compatible claims about the same subject and circumstances?',
+    category: 'answer-quality',
+    tags: ['answer-quality', 'answer', 'consistency', 'rag', 'evidence'],
+    limitations: [
+        'Checks semantic consistency between two statements. Exact numeric and date comparisons belong in code.',
+    ],
+};

package/dist/recipes/answer-consistency/schema.d.ts

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+export declare const answerConsistencyVerdictSchema: z.ZodEnum<{
+    conflicting: "conflicting";
+    unclear: "unclear";
+    consistent: "consistent";
+    unrelated: "unrelated";
+}>;
+export declare const answerConsistencyInputSchema: z.ZodObject<{
+    firstStatement: z.ZodString;
+    secondStatement: z.ZodString;
+    context: z.ZodOptional<z.ZodString>;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const answerConsistencyResultSchema: z.ZodObject<{
+    model: z.ZodString;
+    usage: z.ZodObject<{
+        input_tokens: z.ZodNumber;
+        output_tokens: z.ZodNumber;
+    }, z.core.$strip>;
+    status: z.ZodEnum<{
+        ready: "ready";
+        review: "review";
+    }>;
+    verdict: z.ZodEnum<{
+        conflicting: "conflicting";
+        unclear: "unclear";
+        consistent: "consistent";
+        unrelated: "unrelated";
+    }>;
+    confidence: z.ZodNumber;
+    probabilities: z.ZodRecord<z.ZodEnum<{
+        conflicting: "conflicting";
+        unclear: "unclear";
+        consistent: "consistent";
+        unrelated: "unrelated";
+    }>, z.ZodNumber>;
+}, z.core.$strip>;
+export type AnswerConsistencyInput = z.infer<typeof answerConsistencyInputSchema>;
+export type AnswerConsistencyResult = z.infer<typeof answerConsistencyResultSchema>;
+export type AnswerConsistencyVerdict = z.infer<typeof answerConsistencyVerdictSchema>;

package/dist/recipes/answer-consistency/schema.js

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+import { decisionStatusSchema, nonEmptyText, probability, resultMetadataSchema, } from '../../src/schema.js';
+export const answerConsistencyVerdictSchema = z.enum([
+    'consistent',
+    'conflicting',
+    'unrelated',
+    'unclear',
+]);
+export const answerConsistencyInputSchema = z.object({
+    firstStatement: nonEmptyText,
+    secondStatement: nonEmptyText,
+    context: nonEmptyText.optional(),
+    minConfidence: probability.optional(),
+});
+export const answerConsistencyResultSchema = resultMetadataSchema.extend({
+    status: decisionStatusSchema,
+    verdict: answerConsistencyVerdictSchema,
+    confidence: probability,
+    probabilities: z.record(answerConsistencyVerdictSchema, probability),
+});