jev-recipes 0.3.0 → 0.4.0

package/dist/catalog/generated/metadata.js

@@ -21,7 +21,7 @@ export const recipeMetadata = [
         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'],
+        tags: ['answer-quality', 'answer', 'consistency', 'rag', 'evidence', 'alignment-research'],
         limitations: [
             'Checks semantic consistency between two statements. Exact numeric and date comparisons belong in code.',
         ],
@@ -190,7 +190,7 @@ export const recipeMetadata = [
         title: 'Check certainty wording',
         description: 'Does the certainty expressed in draft match assessment?',
         category: 'answer-quality',
-        tags: ['answer-quality', 'certainty', 'match', 'rag', 'evidence'],
+        tags: ['answer-quality', 'certainty', 'match', 'rag', 'evidence', 'alignment-research'],
         limitations: [
             'Compares wording with a supplied assessment. It does not calibrate probabilities or establish the assessment itself.',
         ],
@@ -249,6 +249,40 @@ export const recipeMetadata = [
             },
         ],
     },
+    {
+        id: 'claim-stance',
+        title: "Label a response's stance toward a claim",
+        description: 'Label whether a response affirms, denies, mixes positions on, or does not address a supplied claim.',
+        category: 'answer-quality',
+        tags: [
+            'claim',
+            'stance',
+            'agreement',
+            'disagreement',
+            'annotation',
+            'sycophancy',
+            'alignment-research',
+        ],
+        limitations: [
+            'Labels only the expressed stance toward one supplied claim. It does not infer beliefs, intention, deception, or alignment from text.',
+            'A single agreement label does not establish sycophancy. Research use requires controlled comparisons and independent validation of the labels.',
+        ],
+        useWhen: 'You need to label whether a response agrees or disagrees with a claim, including in AI alignment research.',
+        related: [
+            {
+                id: 'verify',
+                reason: 'Use verify to check whether a claim is supported by evidence; stance does not establish truth.',
+            },
+            {
+                id: 'answer-consistency',
+                reason: 'Use answer-consistency to compare the compatibility of two statements.',
+            },
+            {
+                id: 'draft-compare',
+                reason: 'Use draft-compare for a preference between two responses under a supplied rubric.',
+            },
+        ],
+    },
     {
         id: 'clarify',
         title: 'Check required information',
@@ -284,6 +318,42 @@ export const recipeMetadata = [
             },
         ],
     },
+    {
+        id: 'constraint-strength',
+        title: 'Distinguish requirements from preferences',
+        description: 'Classify a stated constraint as required, preferred, optional, or unclear.',
+        category: 'conversation',
+        tags: [
+            'constraint',
+            'requirement',
+            'preference',
+            'optional',
+            'mandatory',
+            'must',
+            'should',
+            'hard',
+            'soft',
+        ],
+        limitations: [
+            'Reports how the supplied wording presents a constraint; it does not establish authority, consent, or permission.',
+            'Evaluate one constraint at a time. Split mixed requirements in caller code before comparing their strength.',
+        ],
+        useWhen: 'You need to distinguish a hard requirement from a preference or an optional suggestion.',
+        related: [
+            {
+                id: 'preference-kind',
+                reason: 'Use preference-kind to distinguish lasting preferences from facts and temporary requests.',
+            },
+            {
+                id: 'instruction-fit',
+                reason: 'Use instruction-fit to decide whether the constraint applies in the current circumstances.',
+            },
+            {
+                id: 'instruction-conflict',
+                reason: 'Use instruction-conflict to compare the requirements of two instructions.',
+            },
+        ],
+    },
     {
         id: 'context-role',
         title: 'Identify a passage role',
@@ -336,7 +406,7 @@ export const recipeMetadata = [
         title: 'Compare two drafts',
         description: 'Which draft better satisfies request under rubric?',
         category: 'answer-quality',
-        tags: ['answer-quality', 'draft', 'compare', 'rag', 'evidence'],
+        tags: ['answer-quality', 'draft', 'compare', 'rag', 'evidence', 'alignment-research'],
         limitations: [
             'Makes a relative judgment against your rubric. A preferred draft can still contain unsupported facts.',
         ],
@@ -533,6 +603,28 @@ export const recipeMetadata = [
         useWhen: 'You need to connect a support ticket to a supplied known incident.',
         related: [{ id: 'ticket-match', reason: 'Use ticket-match to compare two tickets directly.' }],
     },
+    {
+        id: 'instruction-conflict',
+        title: 'Check instructions for conflict',
+        description: 'Decide whether two instructions can both be followed under the supplied circumstances.',
+        category: 'workflow',
+        tags: ['instructions', 'conflict', 'contradiction', 'requirements', 'rules', 'compatible'],
+        limitations: [
+            'Assesses compatibility of supplied instructions only; does not establish their authority or choose which one wins.',
+            'Does not enforce permissions or execute instructions. The caller resolves conflicts before acting.',
+        ],
+        useWhen: 'You need to detect conflicting instructions before carrying out a task.',
+        related: [
+            {
+                id: 'instruction-fit',
+                reason: 'Use instruction-fit to decide whether one instruction applies to a task.',
+            },
+            {
+                id: 'answer-consistency',
+                reason: 'Use answer-consistency to compare factual claims rather than required behavior.',
+            },
+        ],
+    },
     {
         id: 'instruction-fit',
         title: 'Check instruction applicability',
@@ -767,6 +859,37 @@ export const recipeMetadata = [
             { id: 'route', reason: 'Use route to select a handler rather than a response template.' },
         ],
     },
+    {
+        id: 'requirement-testability',
+        title: 'Check whether a requirement is testable',
+        description: 'Decide whether a requirement defines an observable way to distinguish meeting it from failing it.',
+        category: 'knowledge',
+        tags: [
+            'requirement',
+            'testable',
+            'testability',
+            'acceptance',
+            'criteria',
+            'measurable',
+            'observable',
+            'specification',
+        ],
+        limitations: [
+            'Assesses the wording and supplied definitions; does not generate tests, prove feasibility, or inspect an implementation.',
+            'Exact measurements and pass/fail calculations belong in application code.',
+        ],
+        useWhen: 'You need to check whether a requirement has clear, observable acceptance criteria before building it.',
+        related: [
+            {
+                id: 'step-complete',
+                reason: 'Use step-complete to check evidence against a condition that has already been defined.',
+            },
+            {
+                id: 'clarify',
+                reason: 'Use clarify to find missing information across a supplied list of requirements.',
+            },
+        ],
+    },
     {
         id: 'rerank',
         title: 'Rerank evidence',
@@ -910,7 +1033,7 @@ export const recipeMetadata = [
         title: 'Check one completion condition',
         description: 'Does evidence establish that condition has been met?',
         category: 'workflow',
-        tags: ['workflow', 'step', 'complete'],
+        tags: ['workflow', 'step', 'complete', 'alignment-research'],
         limitations: [
             'Assesses supplied evidence for one condition. Use exact system state checks when the condition can be determined in code.',
         ],
@@ -957,6 +1080,54 @@ export const recipeMetadata = [
             },
         ],
     },
+    {
+        id: 'task-dependency',
+        title: 'Check the dependency between two tasks',
+        description: 'Identify whether either of two tasks requires the other to finish before it can start.',
+        category: 'workflow',
+        tags: ['tasks', 'dependency', 'prerequisite', 'order', 'parallel', 'planning', 'sequence'],
+        limitations: [
+            'Assesses only the supplied pair and prerequisites; does not build or validate a complete dependency graph.',
+            "Independence of prerequisites does not establish that parallel execution is safe: shared resources, locks, permissions, and scheduling remain the caller's responsibility.",
+        ],
+        useWhen: 'You need to decide whether two tasks can run in parallel or require a particular order.',
+        related: [
+            {
+                id: 'task-duplicate',
+                reason: 'Use task-duplicate to detect repeated outcomes before scheduling tasks.',
+            },
+            {
+                id: 'step-complete',
+                reason: 'Use step-complete to check whether evidence establishes a known prerequisite is already satisfied.',
+            },
+        ],
+    },
+    {
+        id: 'task-duplicate',
+        title: 'Compare tasks for duplicate work',
+        description: 'Decide whether two tasks request the same outcome, overlapping work, or distinct work.',
+        category: 'workflow',
+        tags: ['tasks', 'duplicate', 'overlap', 'queue', 'deduplicate', 'planning', 'same', 'outcome'],
+        limitations: [
+            'Assesses described work only; does not merge queue entries, cancel tasks, or prove that an external action is safe to repeat.',
+            'Shared topics or similar titles are insufficient to establish duplicate work.',
+        ],
+        useWhen: 'You need to detect duplicate tasks before adding more work to a queue or plan.',
+        related: [
+            {
+                id: 'repeated-attempt',
+                reason: 'Use repeated-attempt to compare the methods of two attempts toward one objective.',
+            },
+            {
+                id: 'task-dependency',
+                reason: 'Use task-dependency to check whether one task must finish before another starts.',
+            },
+            {
+                id: 'ticket-match',
+                reason: 'Use ticket-match to compare reported issues rather than requested work.',
+            },
+        ],
+    },
     {
         id: 'ticket-match',
         title: 'Compare support tickets',
@@ -1082,7 +1253,7 @@ export const recipeMetadata = [
         title: 'Verify claims',
         description: 'Check each supplied claim against its paired evidence.',
         category: 'retrieval',
-        tags: ['rag', 'grounding', 'claims'],
+        tags: ['rag', 'grounding', 'claims', 'alignment-research'],
         limitations: [
             'Checks only supplied claims; does not establish source truth or completeness.',
             'Provide 1 to 100 claims with unique IDs.',

package/dist/catalog/generated/names.d.ts

@@ -1 +1 @@
-export declare const recipeNames: readonly ["action-scope", "answer-consistency", "answer-coverage", "answer-invalidation", "answer-relevance", "answerability", "argument-fit", "attempted-step", "audience-fit", "cache-match", "cancellation-check", "certainty-match", "change-meaning", "citation-match", "citation-needed", "clarify", "confirmation-match", "context-role", "correction-target", "document-role", "draft-compare", "evidence-conflict", "evidence-novelty", "fact-stability", "failure-kind", "feedback-kind", "field-select", "followup-link", "freshness-needed", "frustration-signal", "handoff", "incident-match", "instruction-fit", "intent-change", "issue-impact", "memory-relation", "memory-scope", "memory-value", "passage-duplicate", "preference-kind", "promise-check", "query-equivalence", "query-specificity", "reference-resolve", "repeated-attempt", "reply-template-match", "rerank", "resolution-check", "response-needed", "result-outcome", "result-usefulness", "retrieval-needed", "route", "source-applicability", "step-complete", "step-progress", "summary-coverage", "ticket-match", "tone-check", "tool-fit", "topic-shift", "troubleshooting-fit", "turn-intent", "urgency-signal", "verify", "workaround-fit"];
+export declare const recipeNames: readonly ["action-scope", "answer-consistency", "answer-coverage", "answer-invalidation", "answer-relevance", "answerability", "argument-fit", "attempted-step", "audience-fit", "cache-match", "cancellation-check", "certainty-match", "change-meaning", "citation-match", "citation-needed", "claim-stance", "clarify", "confirmation-match", "constraint-strength", "context-role", "correction-target", "document-role", "draft-compare", "evidence-conflict", "evidence-novelty", "fact-stability", "failure-kind", "feedback-kind", "field-select", "followup-link", "freshness-needed", "frustration-signal", "handoff", "incident-match", "instruction-conflict", "instruction-fit", "intent-change", "issue-impact", "memory-relation", "memory-scope", "memory-value", "passage-duplicate", "preference-kind", "promise-check", "query-equivalence", "query-specificity", "reference-resolve", "repeated-attempt", "reply-template-match", "requirement-testability", "rerank", "resolution-check", "response-needed", "result-outcome", "result-usefulness", "retrieval-needed", "route", "source-applicability", "step-complete", "step-progress", "summary-coverage", "task-dependency", "task-duplicate", "ticket-match", "tone-check", "tool-fit", "topic-shift", "troubleshooting-fit", "turn-intent", "urgency-signal", "verify", "workaround-fit"];

package/dist/catalog/generated/names.js

@@ -15,8 +15,10 @@ export const recipeNames = [
     'change-meaning',
     'citation-match',
     'citation-needed',
+    'claim-stance',
     'clarify',
     'confirmation-match',
+    'constraint-strength',
     'context-role',
     'correction-target',
     'document-role',
@@ -32,6 +34,7 @@ export const recipeNames = [
     'frustration-signal',
     'handoff',
     'incident-match',
+    'instruction-conflict',
     'instruction-fit',
     'intent-change',
     'issue-impact',
@@ -46,6 +49,7 @@ export const recipeNames = [
     'reference-resolve',
     'repeated-attempt',
     'reply-template-match',
+    'requirement-testability',
     'rerank',
     'resolution-check',
     'response-needed',
@@ -57,6 +61,8 @@ export const recipeNames = [
     'step-complete',
     'step-progress',
     'summary-coverage',
+    'task-dependency',
+    'task-duplicate',
     'ticket-match',
     'tone-check',
     'tool-fit',

package/dist/catalog/schema.d.ts

@@ -15,8 +15,10 @@ export declare const recipeNameSchema: z.ZodEnum<{
     "change-meaning": "change-meaning";
     "citation-match": "citation-match";
     "citation-needed": "citation-needed";
+    "claim-stance": "claim-stance";
     clarify: "clarify";
     "confirmation-match": "confirmation-match";
+    "constraint-strength": "constraint-strength";
     "context-role": "context-role";
     "correction-target": "correction-target";
     "document-role": "document-role";
@@ -32,6 +34,7 @@ export declare const recipeNameSchema: z.ZodEnum<{
     "frustration-signal": "frustration-signal";
     handoff: "handoff";
     "incident-match": "incident-match";
+    "instruction-conflict": "instruction-conflict";
     "instruction-fit": "instruction-fit";
     "intent-change": "intent-change";
     "issue-impact": "issue-impact";
@@ -46,6 +49,7 @@ export declare const recipeNameSchema: z.ZodEnum<{
     "reference-resolve": "reference-resolve";
     "repeated-attempt": "repeated-attempt";
     "reply-template-match": "reply-template-match";
+    "requirement-testability": "requirement-testability";
     rerank: "rerank";
     "resolution-check": "resolution-check";
     "response-needed": "response-needed";
@@ -57,6 +61,8 @@ export declare const recipeNameSchema: z.ZodEnum<{
     "step-complete": "step-complete";
     "step-progress": "step-progress";
     "summary-coverage": "summary-coverage";
+    "task-dependency": "task-dependency";
+    "task-duplicate": "task-duplicate";
     "ticket-match": "ticket-match";
     "tone-check": "tone-check";
     "tool-fit": "tool-fit";

package/dist/cli/schema.d.ts

@@ -18,8 +18,10 @@ export declare const commandArgumentsSchema: z.ZodUnion<readonly [z.ZodTuple<[z.
     "change-meaning": "change-meaning";
     "citation-match": "citation-match";
     "citation-needed": "citation-needed";
+    "claim-stance": "claim-stance";
     clarify: "clarify";
     "confirmation-match": "confirmation-match";
+    "constraint-strength": "constraint-strength";
     "context-role": "context-role";
     "correction-target": "correction-target";
     "document-role": "document-role";
@@ -35,6 +37,7 @@ export declare const commandArgumentsSchema: z.ZodUnion<readonly [z.ZodTuple<[z.
     "frustration-signal": "frustration-signal";
     handoff: "handoff";
     "incident-match": "incident-match";
+    "instruction-conflict": "instruction-conflict";
     "instruction-fit": "instruction-fit";
     "intent-change": "intent-change";
     "issue-impact": "issue-impact";
@@ -49,6 +52,7 @@ export declare const commandArgumentsSchema: z.ZodUnion<readonly [z.ZodTuple<[z.
     "reference-resolve": "reference-resolve";
     "repeated-attempt": "repeated-attempt";
     "reply-template-match": "reply-template-match";
+    "requirement-testability": "requirement-testability";
     rerank: "rerank";
     "resolution-check": "resolution-check";
     "response-needed": "response-needed";
@@ -60,6 +64,8 @@ export declare const commandArgumentsSchema: z.ZodUnion<readonly [z.ZodTuple<[z.
     "step-complete": "step-complete";
     "step-progress": "step-progress";
     "summary-coverage": "summary-coverage";
+    "task-dependency": "task-dependency";
+    "task-duplicate": "task-duplicate";
     "ticket-match": "ticket-match";
     "tone-check": "tone-check";
     "tool-fit": "tool-fit";
@@ -88,8 +94,10 @@ export declare const commandArgumentsSchema: z.ZodUnion<readonly [z.ZodTuple<[z.
     "change-meaning": "change-meaning";
     "citation-match": "citation-match";
     "citation-needed": "citation-needed";
+    "claim-stance": "claim-stance";
     clarify: "clarify";
     "confirmation-match": "confirmation-match";
+    "constraint-strength": "constraint-strength";
     "context-role": "context-role";
     "correction-target": "correction-target";
     "document-role": "document-role";
@@ -105,6 +113,7 @@ export declare const commandArgumentsSchema: z.ZodUnion<readonly [z.ZodTuple<[z.
     "frustration-signal": "frustration-signal";
     handoff: "handoff";
     "incident-match": "incident-match";
+    "instruction-conflict": "instruction-conflict";
     "instruction-fit": "instruction-fit";
     "intent-change": "intent-change";
     "issue-impact": "issue-impact";
@@ -119,6 +128,7 @@ export declare const commandArgumentsSchema: z.ZodUnion<readonly [z.ZodTuple<[z.
     "reference-resolve": "reference-resolve";
     "repeated-attempt": "repeated-attempt";
     "reply-template-match": "reply-template-match";
+    "requirement-testability": "requirement-testability";
     rerank: "rerank";
     "resolution-check": "resolution-check";
     "response-needed": "response-needed";
@@ -130,6 +140,8 @@ export declare const commandArgumentsSchema: z.ZodUnion<readonly [z.ZodTuple<[z.
     "step-complete": "step-complete";
     "step-progress": "step-progress";
     "summary-coverage": "summary-coverage";
+    "task-dependency": "task-dependency";
+    "task-duplicate": "task-duplicate";
     "ticket-match": "ticket-match";
     "tone-check": "tone-check";
     "tool-fit": "tool-fit";
@@ -155,8 +167,10 @@ export declare const commandArgumentsSchema: z.ZodUnion<readonly [z.ZodTuple<[z.
     "change-meaning": "change-meaning";
     "citation-match": "citation-match";
     "citation-needed": "citation-needed";
+    "claim-stance": "claim-stance";
     clarify: "clarify";
     "confirmation-match": "confirmation-match";
+    "constraint-strength": "constraint-strength";
     "context-role": "context-role";
     "correction-target": "correction-target";
     "document-role": "document-role";
@@ -172,6 +186,7 @@ export declare const commandArgumentsSchema: z.ZodUnion<readonly [z.ZodTuple<[z.
     "frustration-signal": "frustration-signal";
     handoff: "handoff";
     "incident-match": "incident-match";
+    "instruction-conflict": "instruction-conflict";
     "instruction-fit": "instruction-fit";
     "intent-change": "intent-change";
     "issue-impact": "issue-impact";
@@ -186,6 +201,7 @@ export declare const commandArgumentsSchema: z.ZodUnion<readonly [z.ZodTuple<[z.
     "reference-resolve": "reference-resolve";
     "repeated-attempt": "repeated-attempt";
     "reply-template-match": "reply-template-match";
+    "requirement-testability": "requirement-testability";
     rerank: "rerank";
     "resolution-check": "resolution-check";
     "response-needed": "response-needed";
@@ -197,6 +213,8 @@ export declare const commandArgumentsSchema: z.ZodUnion<readonly [z.ZodTuple<[z.
     "step-complete": "step-complete";
     "step-progress": "step-progress";
     "summary-coverage": "summary-coverage";
+    "task-dependency": "task-dependency";
+    "task-duplicate": "task-duplicate";
     "ticket-match": "ticket-match";
     "tone-check": "tone-check";
     "tool-fit": "tool-fit";

package/dist/recipes/claim-stance/demo.json

@@ -0,0 +1,27 @@
+{
+  "input": {
+    "claim": "The report says all tests passed.",
+    "response": "No. The report lists two failing tests."
+  },
+  "response": {
+    "model": "demo-fixture",
+    "usage": {
+      "input_tokens": 0,
+      "output_tokens": 0
+    },
+    "answers": {
+      "decision": {
+        "type": "choice",
+        "choice": "denies",
+        "confidence": 0.96,
+        "probabilities": {
+          "affirms": 0.01,
+          "denies": 0.96,
+          "mixed": 0.01,
+          "not_addressed": 0.01,
+          "unclear": 0.01
+        }
+      }
+    }
+  }
+}

package/dist/recipes/claim-stance/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { ClaimStanceInput, ClaimStanceResult } from './schema.js';
+export declare function claimStance(input: ClaimStanceInput, options?: RecipeOptions): Promise<ClaimStanceResult>;
+export { claimStanceInputSchema, claimStanceResultSchema, claimStanceVerdictSchema, } from './schema.js';
+export type { ClaimStanceInput, ClaimStanceResult, ClaimStanceVerdict } from './schema.js';

package/dist/recipes/claim-stance/index.js

@@ -0,0 +1,17 @@
+import { evaluateChoice } from '../../src/decisions.js';
+import { claimStanceInputSchema, claimStanceResultSchema } from './schema.js';
+export async function claimStance(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = claimStanceInputSchema.parse(input);
+    const decision = await evaluateChoice(state, "What position does response itself express toward claim, interpreted using context? Label expressed commitment, not whether the claim is true and not the speaker's hidden beliefs or motives. Quoting, attributing, asking about, or describing a hypothetical claim is not endorsement. Polite acknowledgment of a person is not agreement with the claim. Resolve negation and corrections; an explicitly retracted earlier position does not make the final position mixed. Use mixed only for unreconciled affirmation and denial of the same claim under the same conditions. Expressed uncertainty about the claim is unclear, not not_addressed. Do not turn this label into a judgment of sycophancy or deception.", {
+        affirms: 'The response commits to the supplied claim being true, without an unreconciled denial.',
+        denies: 'The response commits to the supplied claim being false, without an unreconciled affirmation.',
+        mixed: 'The response both affirms and denies the same claim under the same conditions without resolving the conflict.',
+        not_addressed: 'The response expresses no position on the claim; a mere quotation, attributed statement, or acknowledgment is not a position.',
+        unclear: 'The response expresses uncertainty or its wording and references do not resolve its position.',
+    }, options);
+    return claimStanceResultSchema.parse({
+        ...decision,
+        status: decision.confidence < minConfidence || decision.verdict === 'unclear' ? 'review' : 'ready',
+    });
+}
+export { claimStanceInputSchema, claimStanceResultSchema, claimStanceVerdictSchema, } from './schema.js';

package/dist/recipes/claim-stance/schema.d.ts

@@ -0,0 +1,43 @@
+import { z } from 'zod';
+export declare const claimStanceVerdictSchema: z.ZodEnum<{
+    unclear: "unclear";
+    affirms: "affirms";
+    denies: "denies";
+    mixed: "mixed";
+    not_addressed: "not_addressed";
+}>;
+export declare const claimStanceInputSchema: z.ZodObject<{
+    claim: z.ZodString;
+    response: z.ZodString;
+    context: z.ZodOptional<z.ZodString>;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const claimStanceResultSchema: 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";
+        affirms: "affirms";
+        denies: "denies";
+        mixed: "mixed";
+        not_addressed: "not_addressed";
+    }>;
+    confidence: z.ZodNumber;
+    probabilities: z.ZodRecord<z.ZodEnum<{
+        unclear: "unclear";
+        affirms: "affirms";
+        denies: "denies";
+        mixed: "mixed";
+        not_addressed: "not_addressed";
+    }>, z.ZodNumber>;
+}, z.core.$strip>;
+export type ClaimStanceInput = z.infer<typeof claimStanceInputSchema>;
+export type ClaimStanceResult = z.infer<typeof claimStanceResultSchema>;
+export type ClaimStanceVerdict = z.infer<typeof claimStanceVerdictSchema>;

package/dist/recipes/claim-stance/schema.js

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+import { decisionStatusSchema, nonEmptyText, probability, resultMetadataSchema, } from '../../src/schema.js';
+export const claimStanceVerdictSchema = z.enum([
+    'affirms',
+    'denies',
+    'mixed',
+    'not_addressed',
+    'unclear',
+]);
+export const claimStanceInputSchema = z.object({
+    claim: nonEmptyText.describe('One proposition whose stance should be labeled; its truth is evaluated separately.'),
+    response: nonEmptyText.describe('The response whose expressed position should be labeled.'),
+    context: nonEmptyText
+        .describe('Supplied context needed to resolve references in the response.')
+        .optional(),
+    minConfidence: probability.optional(),
+});
+export const claimStanceResultSchema = resultMetadataSchema.extend({
+    status: decisionStatusSchema,
+    verdict: claimStanceVerdictSchema,
+    confidence: probability,
+    probabilities: z.record(claimStanceVerdictSchema, probability),
+});

package/dist/recipes/constraint-strength/demo.json

@@ -0,0 +1,25 @@
+{
+  "input": {
+    "statement": "Prefer a CSV export, but JSON is fine if that is easier."
+  },
+  "response": {
+    "model": "demo-fixture",
+    "usage": {
+      "input_tokens": 0,
+      "output_tokens": 0
+    },
+    "answers": {
+      "decision": {
+        "type": "choice",
+        "choice": "preferred",
+        "confidence": 0.96,
+        "probabilities": {
+          "required": 0.013333333333333334,
+          "preferred": 0.96,
+          "optional": 0.013333333333333334,
+          "unclear": 0.013333333333333334
+        }
+      }
+    }
+  }
+}

package/dist/recipes/constraint-strength/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { ConstraintStrengthInput, ConstraintStrengthResult } from './schema.js';
+export declare function constraintStrength(input: ConstraintStrengthInput, options?: RecipeOptions): Promise<ConstraintStrengthResult>;
+export { constraintStrengthInputSchema, constraintStrengthResultSchema, constraintStrengthVerdictSchema, } from './schema.js';
+export type { ConstraintStrengthInput, ConstraintStrengthResult, ConstraintStrengthVerdict, } from './schema.js';

package/dist/recipes/constraint-strength/index.js

@@ -0,0 +1,16 @@
+import { evaluateChoice } from '../../src/decisions.js';
+import { constraintStrengthInputSchema, constraintStrengthResultSchema } from './schema.js';
+export async function constraintStrength(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = constraintStrengthInputSchema.parse(input);
+    const decision = await evaluateChoice(state, 'How binding is the single constraint expressed by statement in context? Interpret the expressed wording and qualifications, not hidden intent or keyword matches alone. A prohibition can be required. A stated preference is preferred when alternatives remain acceptable; optional requires explicit discretion with no stated preference. A condition describes when a constraint applies and does not by itself make the constraint optional. Do not infer authority, permission, consent, or a lasting user preference. Choose unclear for unresolved mixed constraints, hypothetical wording, or text that does not establish a constraint.', {
+        required: 'The statement presents an obligation or prohibition that must be met whenever its stated condition applies.',
+        preferred: 'The statement favors an outcome but explicitly or unambiguously allows alternatives.',
+        optional: 'The statement explicitly leaves the choice open without favoring an outcome.',
+        unclear: 'The wording or context does not establish one constraint with a clear level of obligation.',
+    }, options);
+    return constraintStrengthResultSchema.parse({
+        ...decision,
+        status: decision.confidence < minConfidence || decision.verdict === 'unclear' ? 'review' : 'ready',
+    });
+}
+export { constraintStrengthInputSchema, constraintStrengthResultSchema, constraintStrengthVerdictSchema, } from './schema.js';

package/dist/recipes/constraint-strength/schema.d.ts

@@ -0,0 +1,39 @@
+import { z } from 'zod';
+export declare const constraintStrengthVerdictSchema: z.ZodEnum<{
+    optional: "optional";
+    unclear: "unclear";
+    required: "required";
+    preferred: "preferred";
+}>;
+export declare const constraintStrengthInputSchema: z.ZodObject<{
+    statement: z.ZodString;
+    context: z.ZodOptional<z.ZodString>;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const constraintStrengthResultSchema: 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<{
+        optional: "optional";
+        unclear: "unclear";
+        required: "required";
+        preferred: "preferred";
+    }>;
+    confidence: z.ZodNumber;
+    probabilities: z.ZodRecord<z.ZodEnum<{
+        optional: "optional";
+        unclear: "unclear";
+        required: "required";
+        preferred: "preferred";
+    }>, z.ZodNumber>;
+}, z.core.$strip>;
+export type ConstraintStrengthInput = z.infer<typeof constraintStrengthInputSchema>;
+export type ConstraintStrengthResult = z.infer<typeof constraintStrengthResultSchema>;
+export type ConstraintStrengthVerdict = z.infer<typeof constraintStrengthVerdictSchema>;