jev-recipes 0.3.0 → 0.4.1

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.',
         ],
@@ -137,6 +137,41 @@ export const recipeMetadata = [
             },
         ],
     },
+    {
+        id: 'attribution-match',
+        title: "Check a statement's attributed source",
+        description: 'Check whether supplied source text attributes a statement to the claimed speaker or source.',
+        category: 'knowledge',
+        tags: [
+            'attribution',
+            'speaker',
+            'who said',
+            'source ownership',
+            'quotation',
+            'annotation',
+            'alignment-research',
+        ],
+        limitations: [
+            'Checks only the supplied attribution record. It does not authenticate a source or establish original authorship, truth, or copyright ownership.',
+            'Missing statements and unresolved speaker identities require review; absence from an excerpt is not proof of false attribution.',
+            'Nested quotation and endorsement are distinct. Include enough surrounding text to establish who is speaking.',
+        ],
+        useWhen: 'You need to check who said a statement in a transcript or source excerpt, separately from whether it is true.',
+        related: [
+            {
+                id: 'citation-match',
+                reason: 'Use citation-match to check which passages support a claim, rather than who made it.',
+            },
+            {
+                id: 'claim-stance',
+                reason: "Use claim-stance to label a response's own position toward a claim, rather than verifying a named attribution.",
+            },
+            {
+                id: 'reference-resolve',
+                reason: 'Use reference-resolve to select the referent of an ambiguous expression from supplied candidates.',
+            },
+        ],
+    },
     {
         id: 'audience-fit',
         title: 'Check audience fit',
@@ -190,7 +225,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.',
         ],
@@ -216,6 +251,42 @@ export const recipeMetadata = [
             },
         ],
     },
+    {
+        id: 'choose-action',
+        title: 'Choose a game action from supplied candidates',
+        description: 'Recommend one eligible game action against a supplied goal, using rules, current state, and optional player history.',
+        category: 'workflow',
+        tags: [
+            'gameplay',
+            'game',
+            'choose action',
+            'best move',
+            'strategy',
+            'players',
+            'turn',
+            'simulation',
+        ],
+        limitations: [
+            'Produces a model judgment, not a game solver, legality proof, or guarantee of optimal play. Use an authoritative game engine for exact legality checks.',
+            'Uses only supplied player-visible information. It does not fetch state, simulate future turns, or execute the chosen action.',
+            'History may be incomplete. Supply decision-critical facts in the current environment; ties or unresolved constraints require review.',
+        ],
+        useWhen: 'You need to choose the next game action from a list using the current environment, game rules, and previous player actions.',
+        related: [
+            {
+                id: 'take-turn',
+                reason: 'Use take-turn to assess whether the player has an opportunity to act now before selecting an action.',
+            },
+            {
+                id: 'tool-fit',
+                reason: "Use tool-fit to check one tool's capability for a task; it does not compare game actions under a goal and game rules.",
+            },
+            {
+                id: 'step-progress',
+                reason: 'Use step-progress to assess an observed outcome after a move; this recipe recommends a candidate before execution.',
+            },
+        ],
+    },
     {
         id: 'citation-match',
         title: 'Match claims to citations',
@@ -249,6 +320,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 +389,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 +477,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.',
         ],
@@ -348,6 +489,41 @@ export const recipeMetadata = [
             },
         ],
     },
+    {
+        id: 'evaluation-mention',
+        title: 'Label explicit mentions of model evaluation',
+        description: 'Distinguish a response referring to its own evaluation from general evaluation discussion or no such mention.',
+        category: 'answer-quality',
+        tags: [
+            'evaluation',
+            'being tested',
+            'benchmark',
+            'graded',
+            'self reference',
+            'annotation',
+            'alignment-research',
+        ],
+        limitations: [
+            'Detects explicit wording only. It does not infer hidden evaluation awareness, strategic behavior, or internal goals.',
+            'Self-reference includes uncertainty and denial. It does not establish that evaluation is occurring or that the model believes it is.',
+            'A missing mention does not show absence of awareness. Quoted or hypothetical first-person text needs careful attribution.',
+        ],
+        useWhen: 'You need to find explicit mentions of being tested, graded, or evaluated in saved model responses.',
+        related: [
+            {
+                id: 'claim-stance',
+                reason: 'Use claim-stance to distinguish affirming from denying a specific evaluation claim.',
+            },
+            {
+                id: 'context-role',
+                reason: 'Use context-role to classify the role of supplied text rather than mentions inside a response.',
+            },
+            {
+                id: 'uncertainty-expression',
+                reason: 'Use uncertainty-expression to label how certain the response sounds about a specific evaluation claim.',
+            },
+        ],
+    },
     {
         id: 'evidence-conflict',
         title: 'Compare evidence for conflicts',
@@ -365,6 +541,41 @@ export const recipeMetadata = [
             },
         ],
     },
+    {
+        id: 'evidence-independence',
+        title: 'Compare the origins of two pieces of evidence',
+        description: 'Check whether supplied provenance shows shared or separate evidence origins for one claim, or leaves their relationship unresolved.',
+        category: 'retrieval',
+        tags: [
+            'evidence independence',
+            'provenance',
+            'shared source',
+            'corroboration',
+            'origin',
+            'annotation',
+            'alignment-research',
+        ],
+        limitations: [
+            'Evaluates supplied provenance descriptions only. It does not fetch sources, verify provenance, or discover hidden dependencies.',
+            'Separate origins are not a guarantee of statistical independence, reliability, or truth.',
+            'The claim scopes material overlap. Shared background unrelated to the claim is not sufficient for a shared-origin label.',
+        ],
+        useWhen: 'You need to check whether two reports rely on the same underlying source before treating them as corroboration.',
+        related: [
+            {
+                id: 'passage-duplicate',
+                reason: 'Use passage-duplicate to compare information overlap in passages, not the origins of their evidence.',
+            },
+            {
+                id: 'attribution-match',
+                reason: 'Use attribution-match to check a named statement attribution against a source excerpt.',
+            },
+            {
+                id: 'evidence-conflict',
+                reason: 'Use evidence-conflict to compare what sources say; conflicting reports can still share an origin.',
+            },
+        ],
+    },
     {
         id: 'evidence-novelty',
         title: 'Check new evidence',
@@ -533,6 +744,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',
@@ -717,6 +950,41 @@ export const recipeMetadata = [
             },
         ],
     },
+    {
+        id: 'question-leading',
+        title: 'Check whether a question steers an answer',
+        description: "Label whether a question's wording favors, disfavors, or stays neutral toward a proposed answer.",
+        category: 'conversation',
+        tags: [
+            'leading question',
+            'wording',
+            'answer pressure',
+            'survey',
+            'prompt bias',
+            'annotation',
+            'alignment-research',
+        ],
+        limitations: [
+            'Labels directional wording relative to one proposed answer, not author intent, factual correctness, or observed persuasion.',
+            'Neutral does not establish that a prompt or experiment is unbiased in every respect.',
+            'Actual effects on model or human answers require controlled comparisons; wording labels alone are not causal evidence.',
+        ],
+        useWhen: 'You need to check leading questions or answer pressure in a survey, interview, or evaluation prompt.',
+        related: [
+            {
+                id: 'query-specificity',
+                reason: 'Use query-specificity to check whether an information need is focused and unambiguous.',
+            },
+            {
+                id: 'claim-stance',
+                reason: "Use claim-stance to label the response's expressed position after a question has been answered.",
+            },
+            {
+                id: 'tone-check',
+                reason: 'Use tone-check to assess draft wording against caller-supplied writing criteria.',
+            },
+        ],
+    },
     {
         id: 'reference-resolve',
         title: 'Resolve a reference',
@@ -767,6 +1035,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',
@@ -819,6 +1118,41 @@ export const recipeMetadata = [
             },
         ],
     },
+    {
+        id: 'response-refusal',
+        title: 'Label refusal behavior in a response',
+        description: 'Distinguish an explicit refusal, a substantive attempt, mixed behavior, and a stated inability to fulfill a request.',
+        category: 'answer-quality',
+        tags: [
+            'refusal',
+            'refuses',
+            'decline',
+            'compliance',
+            'inability',
+            'annotation',
+            'alignment-research',
+        ],
+        limitations: [
+            'Labels textual behavior, not policy compliance, harmlessness, or whether a refusal was warranted.',
+            'An attempted answer or reported action may be incorrect or incomplete. No action is executed or verified.',
+            'A refusal label alone does not establish an alignment property. Validate labels against independent human annotations for the study.',
+        ],
+        useWhen: 'You need to label whether a response refuses a request, attempts it, or reports missing access or information.',
+        related: [
+            {
+                id: 'answer-relevance',
+                reason: 'Use answer-relevance to check whether a response addresses the requested subject, regardless of refusal.',
+            },
+            {
+                id: 'answer-coverage',
+                reason: 'Use answer-coverage to check which requested points a draft covers; an attempt need not be complete.',
+            },
+            {
+                id: 'result-outcome',
+                reason: 'Use result-outcome to interpret an observed task result instead of a response claiming to perform it.',
+            },
+        ],
+    },
     {
         id: 'result-outcome',
         title: 'Interpret a reported tool outcome',
@@ -910,7 +1244,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 +1291,91 @@ export const recipeMetadata = [
             },
         ],
     },
+    {
+        id: 'take-turn',
+        title: 'Assess whether a player can act now',
+        description: "Interpret game rules and current state to label a player's turn or reaction opportunity as act, wait, inactive, or unclear.",
+        category: 'workflow',
+        tags: [
+            'gameplay',
+            'game',
+            'take turn',
+            'whose turn',
+            'act now',
+            'wait',
+            'reaction',
+            'players',
+            'simulation',
+        ],
+        limitations: [
+            'Assesses narrative turn eligibility, not a legality proof. When a game engine provides an exact turn or reaction flag, use that directly.',
+            'Does not take a turn, select an action, update state, or verify that a player already completed a turn.',
+            'Act includes optional reactions and does not mean using that opportunity is strategically best. Missing or conflicting facts require review.',
+        ],
+        useWhen: "You need to decide whether it is a player's turn to act or react using narrative game rules, state, and previous actions.",
+        related: [
+            {
+                id: 'choose-action',
+                reason: 'Use choose-action to compare candidate moves after establishing the player can act.',
+            },
+            {
+                id: 'step-complete',
+                reason: 'Use step-complete to check whether a defined turn-completion condition was met; take-turn assesses the current opportunity to act.',
+            },
+            {
+                id: 'response-needed',
+                reason: 'Use response-needed for conversational follow-through, rather than turn and reaction eligibility under game rules.',
+            },
+        ],
+    },
+    {
+        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',
@@ -1060,6 +1479,41 @@ export const recipeMetadata = [
             },
         ],
     },
+    {
+        id: 'uncertainty-expression',
+        title: 'Label expressed certainty about a claim',
+        description: 'Label categorical, qualified, or unresolved wording about a supplied claim without inferring internal confidence.',
+        category: 'answer-quality',
+        tags: [
+            'uncertainty',
+            'certainty',
+            'hedging',
+            'expressed confidence',
+            'calibration',
+            'annotation',
+            'alignment-research',
+        ],
+        limitations: [
+            'Labels wording about one proposition, not internal confidence, truth, calibration, or evidential support.',
+            'The result confidence describes the annotation decision. It is not the certainty expressed by the response or a calibrated truth probability.',
+            'Uncertain is a substantive label and can be ready. Only unclear or confidence below the threshold requires review.',
+        ],
+        useWhen: 'You need to label expressed certainty or hedging about one claim without an external truth assessment.',
+        related: [
+            {
+                id: 'certainty-match',
+                reason: "Use certainty-match to compare a draft's certainty with a supplied evidence assessment.",
+            },
+            {
+                id: 'claim-stance',
+                reason: 'Use claim-stance to label affirmation or denial separately from the strength of commitment.',
+            },
+            {
+                id: 'verify',
+                reason: 'Use verify to check supplied evidence for a claim; expressed certainty is not evidence of truth.',
+            },
+        ],
+    },
     {
         id: 'urgency-signal',
         title: 'Detect an explicit urgency request',
@@ -1082,7 +1536,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", "attribution-match", "audience-fit", "cache-match", "cancellation-check", "certainty-match", "change-meaning", "choose-action", "citation-match", "citation-needed", "claim-stance", "clarify", "confirmation-match", "constraint-strength", "context-role", "correction-target", "document-role", "draft-compare", "evaluation-mention", "evidence-conflict", "evidence-independence", "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", "question-leading", "reference-resolve", "repeated-attempt", "reply-template-match", "requirement-testability", "rerank", "resolution-check", "response-needed", "response-refusal", "result-outcome", "result-usefulness", "retrieval-needed", "route", "source-applicability", "step-complete", "step-progress", "summary-coverage", "take-turn", "task-dependency", "task-duplicate", "ticket-match", "tone-check", "tool-fit", "topic-shift", "troubleshooting-fit", "turn-intent", "uncertainty-expression", "urgency-signal", "verify", "workaround-fit"];

package/dist/catalog/generated/names.js

@@ -8,20 +8,26 @@ export const recipeNames = [
     'answerability',
     'argument-fit',
     'attempted-step',
+    'attribution-match',
     'audience-fit',
     'cache-match',
     'cancellation-check',
     'certainty-match',
     'change-meaning',
+    'choose-action',
     'citation-match',
     'citation-needed',
+    'claim-stance',
     'clarify',
     'confirmation-match',
+    'constraint-strength',
     'context-role',
     'correction-target',
     'document-role',
     'draft-compare',
+    'evaluation-mention',
     'evidence-conflict',
+    'evidence-independence',
     'evidence-novelty',
     'fact-stability',
     'failure-kind',
@@ -32,6 +38,7 @@ export const recipeNames = [
     'frustration-signal',
     'handoff',
     'incident-match',
+    'instruction-conflict',
     'instruction-fit',
     'intent-change',
     'issue-impact',
@@ -43,12 +50,15 @@ export const recipeNames = [
     'promise-check',
     'query-equivalence',
     'query-specificity',
+    'question-leading',
     'reference-resolve',
     'repeated-attempt',
     'reply-template-match',
+    'requirement-testability',
     'rerank',
     'resolution-check',
     'response-needed',
+    'response-refusal',
     'result-outcome',
     'result-usefulness',
     'retrieval-needed',
@@ -57,12 +67,16 @@ export const recipeNames = [
     'step-complete',
     'step-progress',
     'summary-coverage',
+    'take-turn',
+    'task-dependency',
+    'task-duplicate',
     'ticket-match',
     'tone-check',
     'tool-fit',
     'topic-shift',
     'troubleshooting-fit',
     'turn-intent',
+    'uncertainty-expression',
     'urgency-signal',
     'verify',
     'workaround-fit',