jev-recipes 0.4.0 → 0.4.1

package/dist/catalog/generated/details/response-refusal.json

@@ -0,0 +1,55 @@
+{
+  "inputSchema": {
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "type": "object",
+    "properties": {
+      "request": {
+        "type": "string",
+        "description": "One bounded request against which to label the response."
+      },
+      "response": {
+        "type": "string",
+        "description": "The response to inspect for refusal and attempted fulfillment."
+      },
+      "context": {
+        "type": "string",
+        "description": "Only the surrounding text needed to resolve references or the scope of the request."
+      },
+      "minConfidence": { "type": "number", "minimum": 0, "maximum": 1 }
+    },
+    "required": ["request", "response"]
+  },
+  "resultSchema": {
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "type": "object",
+    "properties": {
+      "model": { "type": "string" },
+      "usage": {
+        "type": "object",
+        "properties": {
+          "input_tokens": { "type": "integer", "minimum": 0, "maximum": 9007199254740991 },
+          "output_tokens": { "type": "integer", "minimum": 0, "maximum": 9007199254740991 }
+        },
+        "required": ["input_tokens", "output_tokens"],
+        "additionalProperties": false
+      },
+      "status": { "type": "string", "enum": ["ready", "review"] },
+      "verdict": {
+        "type": "string",
+        "enum": ["refused", "attempted", "mixed", "unable", "not_addressed", "unclear"]
+      },
+      "confidence": { "type": "number", "minimum": 0, "maximum": 1 },
+      "probabilities": {
+        "type": "object",
+        "propertyNames": {
+          "type": "string",
+          "enum": ["refused", "attempted", "mixed", "unable", "not_addressed", "unclear"]
+        },
+        "additionalProperties": { "type": "number", "minimum": 0, "maximum": 1 },
+        "required": ["refused", "attempted", "mixed", "unable", "not_addressed", "unclear"]
+      }
+    },
+    "required": ["model", "usage", "status", "verdict", "confidence", "probabilities"],
+    "additionalProperties": false
+  }
+}

package/dist/catalog/generated/details/take-turn.json

@@ -0,0 +1,68 @@
+{
+  "inputSchema": {
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "type": "object",
+    "properties": {
+      "player": {
+        "type": "string",
+        "description": "The player whose current turn or reaction eligibility should be assessed."
+      },
+      "rules": {
+        "type": "string",
+        "description": "Applicable turn, phase, reaction, and participation rules."
+      },
+      "environment": {
+        "type": "string",
+        "description": "The current game snapshot available to the player, after the supplied history."
+      },
+      "history": {
+        "maxItems": 100,
+        "type": "array",
+        "items": {
+          "type": "object",
+          "properties": {
+            "player": {
+              "type": "string",
+              "description": "The player who took the recorded action."
+            },
+            "action": {
+              "type": "string",
+              "description": "The observed action, including its known outcome when relevant."
+            }
+          },
+          "required": ["player", "action"]
+        },
+        "description": "Optional observed actions by any players, oldest first. May be empty or incomplete."
+      },
+      "minConfidence": { "type": "number", "minimum": 0, "maximum": 1 }
+    },
+    "required": ["player", "rules", "environment"]
+  },
+  "resultSchema": {
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "type": "object",
+    "properties": {
+      "model": { "type": "string" },
+      "usage": {
+        "type": "object",
+        "properties": {
+          "input_tokens": { "type": "integer", "minimum": 0, "maximum": 9007199254740991 },
+          "output_tokens": { "type": "integer", "minimum": 0, "maximum": 9007199254740991 }
+        },
+        "required": ["input_tokens", "output_tokens"],
+        "additionalProperties": false
+      },
+      "status": { "type": "string", "enum": ["ready", "review"] },
+      "verdict": { "type": "string", "enum": ["act", "wait", "inactive", "unclear"] },
+      "confidence": { "type": "number", "minimum": 0, "maximum": 1 },
+      "probabilities": {
+        "type": "object",
+        "propertyNames": { "type": "string", "enum": ["act", "wait", "inactive", "unclear"] },
+        "additionalProperties": { "type": "number", "minimum": 0, "maximum": 1 },
+        "required": ["act", "wait", "inactive", "unclear"]
+      }
+    },
+    "required": ["model", "usage", "status", "verdict", "confidence", "probabilities"],
+    "additionalProperties": false
+  }
+}

package/dist/catalog/generated/details/uncertainty-expression.json

@@ -0,0 +1,55 @@
+{
+  "inputSchema": {
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "type": "object",
+    "properties": {
+      "claim": {
+        "type": "string",
+        "description": "One proposition whose expressed certainty should be labeled."
+      },
+      "response": {
+        "type": "string",
+        "description": "The response whose own wording about the claim should be labeled."
+      },
+      "context": {
+        "type": "string",
+        "description": "Supplied context needed to resolve references and conditions in the response."
+      },
+      "minConfidence": { "type": "number", "minimum": 0, "maximum": 1 }
+    },
+    "required": ["claim", "response"]
+  },
+  "resultSchema": {
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "type": "object",
+    "properties": {
+      "model": { "type": "string" },
+      "usage": {
+        "type": "object",
+        "properties": {
+          "input_tokens": { "type": "integer", "minimum": 0, "maximum": 9007199254740991 },
+          "output_tokens": { "type": "integer", "minimum": 0, "maximum": 9007199254740991 }
+        },
+        "required": ["input_tokens", "output_tokens"],
+        "additionalProperties": false
+      },
+      "status": { "type": "string", "enum": ["ready", "review"] },
+      "verdict": {
+        "type": "string",
+        "enum": ["categorical", "qualified", "uncertain", "not_addressed", "unclear"]
+      },
+      "confidence": { "type": "number", "minimum": 0, "maximum": 1 },
+      "probabilities": {
+        "type": "object",
+        "propertyNames": {
+          "type": "string",
+          "enum": ["categorical", "qualified", "uncertain", "not_addressed", "unclear"]
+        },
+        "additionalProperties": { "type": "number", "minimum": 0, "maximum": 1 },
+        "required": ["categorical", "qualified", "uncertain", "not_addressed", "unclear"]
+      }
+    },
+    "required": ["model", "usage", "status", "verdict", "confidence", "probabilities"],
+    "additionalProperties": false
+  }
+}

package/dist/catalog/generated/loaders.js

@@ -7,11 +7,13 @@ export const recipeLoaders = {
     answerability: () => import('../../recipes/answerability/index.js').then((recipe) => (input, options) => recipe.answerability(recipe.answerabilityInputSchema.parse(input), options)),
     'argument-fit': () => import('../../recipes/argument-fit/index.js').then((recipe) => (input, options) => recipe.argumentFit(recipe.argumentFitInputSchema.parse(input), options)),
     'attempted-step': () => import('../../recipes/attempted-step/index.js').then((recipe) => (input, options) => recipe.attemptedStep(recipe.attemptedStepInputSchema.parse(input), options)),
+    'attribution-match': () => import('../../recipes/attribution-match/index.js').then((recipe) => (input, options) => recipe.attributionMatch(recipe.attributionMatchInputSchema.parse(input), options)),
     'audience-fit': () => import('../../recipes/audience-fit/index.js').then((recipe) => (input, options) => recipe.audienceFit(recipe.audienceFitInputSchema.parse(input), options)),
     'cache-match': () => import('../../recipes/cache-match/index.js').then((recipe) => (input, options) => recipe.cacheMatch(recipe.cacheMatchInputSchema.parse(input), options)),
     'cancellation-check': () => import('../../recipes/cancellation-check/index.js').then((recipe) => (input, options) => recipe.cancellationCheck(recipe.cancellationCheckInputSchema.parse(input), options)),
     'certainty-match': () => import('../../recipes/certainty-match/index.js').then((recipe) => (input, options) => recipe.certaintyMatch(recipe.certaintyMatchInputSchema.parse(input), options)),
     'change-meaning': () => import('../../recipes/change-meaning/index.js').then((recipe) => (input, options) => recipe.changeMeaning(recipe.changeMeaningInputSchema.parse(input), options)),
+    'choose-action': () => import('../../recipes/choose-action/index.js').then((recipe) => (input, options) => recipe.chooseAction(recipe.chooseActionInputSchema.parse(input), options)),
     'citation-match': () => import('../../recipes/citation-match/index.js').then((recipe) => (input, options) => recipe.citationMatch(recipe.citationMatchInputSchema.parse(input), options)),
     'citation-needed': () => import('../../recipes/citation-needed/index.js').then((recipe) => (input, options) => recipe.citationNeeded(recipe.citationNeededInputSchema.parse(input), options)),
     'claim-stance': () => import('../../recipes/claim-stance/index.js').then((recipe) => (input, options) => recipe.claimStance(recipe.claimStanceInputSchema.parse(input), options)),
@@ -22,7 +24,9 @@ export const recipeLoaders = {
     'correction-target': () => import('../../recipes/correction-target/index.js').then((recipe) => (input, options) => recipe.correctionTarget(recipe.correctionTargetInputSchema.parse(input), options)),
     'document-role': () => import('../../recipes/document-role/index.js').then((recipe) => (input, options) => recipe.documentRole(recipe.documentRoleInputSchema.parse(input), options)),
     'draft-compare': () => import('../../recipes/draft-compare/index.js').then((recipe) => (input, options) => recipe.draftCompare(recipe.draftCompareInputSchema.parse(input), options)),
+    'evaluation-mention': () => import('../../recipes/evaluation-mention/index.js').then((recipe) => (input, options) => recipe.evaluationMention(recipe.evaluationMentionInputSchema.parse(input), options)),
     'evidence-conflict': () => import('../../recipes/evidence-conflict/index.js').then((recipe) => (input, options) => recipe.evidenceConflict(recipe.evidenceConflictInputSchema.parse(input), options)),
+    'evidence-independence': () => import('../../recipes/evidence-independence/index.js').then((recipe) => (input, options) => recipe.evidenceIndependence(recipe.evidenceIndependenceInputSchema.parse(input), options)),
     'evidence-novelty': () => import('../../recipes/evidence-novelty/index.js').then((recipe) => (input, options) => recipe.evidenceNovelty(recipe.evidenceNoveltyInputSchema.parse(input), options)),
     'fact-stability': () => import('../../recipes/fact-stability/index.js').then((recipe) => (input, options) => recipe.factStability(recipe.factStabilityInputSchema.parse(input), options)),
     'failure-kind': () => import('../../recipes/failure-kind/index.js').then((recipe) => (input, options) => recipe.failureKind(recipe.failureKindInputSchema.parse(input), options)),
@@ -45,6 +49,7 @@ export const recipeLoaders = {
     'promise-check': () => import('../../recipes/promise-check/index.js').then((recipe) => (input, options) => recipe.promiseCheck(recipe.promiseCheckInputSchema.parse(input), options)),
     'query-equivalence': () => import('../../recipes/query-equivalence/index.js').then((recipe) => (input, options) => recipe.queryEquivalence(recipe.queryEquivalenceInputSchema.parse(input), options)),
     'query-specificity': () => import('../../recipes/query-specificity/index.js').then((recipe) => (input, options) => recipe.querySpecificity(recipe.querySpecificityInputSchema.parse(input), options)),
+    'question-leading': () => import('../../recipes/question-leading/index.js').then((recipe) => (input, options) => recipe.questionLeading(recipe.questionLeadingInputSchema.parse(input), options)),
     'reference-resolve': () => import('../../recipes/reference-resolve/index.js').then((recipe) => (input, options) => recipe.referenceResolve(recipe.referenceResolveInputSchema.parse(input), options)),
     'repeated-attempt': () => import('../../recipes/repeated-attempt/index.js').then((recipe) => (input, options) => recipe.repeatedAttempt(recipe.repeatedAttemptInputSchema.parse(input), options)),
     'reply-template-match': () => import('../../recipes/reply-template-match/index.js').then((recipe) => (input, options) => recipe.replyTemplateMatch(recipe.replyTemplateMatchInputSchema.parse(input), options)),
@@ -52,6 +57,7 @@ export const recipeLoaders = {
     rerank: () => import('../../recipes/rerank/index.js').then((recipe) => (input, options) => recipe.rerank(recipe.rerankInputSchema.parse(input), options)),
     'resolution-check': () => import('../../recipes/resolution-check/index.js').then((recipe) => (input, options) => recipe.resolutionCheck(recipe.resolutionCheckInputSchema.parse(input), options)),
     'response-needed': () => import('../../recipes/response-needed/index.js').then((recipe) => (input, options) => recipe.responseNeeded(recipe.responseNeededInputSchema.parse(input), options)),
+    'response-refusal': () => import('../../recipes/response-refusal/index.js').then((recipe) => (input, options) => recipe.responseRefusal(recipe.responseRefusalInputSchema.parse(input), options)),
     'result-outcome': () => import('../../recipes/result-outcome/index.js').then((recipe) => (input, options) => recipe.resultOutcome(recipe.resultOutcomeInputSchema.parse(input), options)),
     'result-usefulness': () => import('../../recipes/result-usefulness/index.js').then((recipe) => (input, options) => recipe.resultUsefulness(recipe.resultUsefulnessInputSchema.parse(input), options)),
     'retrieval-needed': () => import('../../recipes/retrieval-needed/index.js').then((recipe) => (input, options) => recipe.retrievalNeeded(recipe.retrievalNeededInputSchema.parse(input), options)),
@@ -60,6 +66,7 @@ export const recipeLoaders = {
     'step-complete': () => import('../../recipes/step-complete/index.js').then((recipe) => (input, options) => recipe.stepComplete(recipe.stepCompleteInputSchema.parse(input), options)),
     'step-progress': () => import('../../recipes/step-progress/index.js').then((recipe) => (input, options) => recipe.stepProgress(recipe.stepProgressInputSchema.parse(input), options)),
     'summary-coverage': () => import('../../recipes/summary-coverage/index.js').then((recipe) => (input, options) => recipe.summaryCoverage(recipe.summaryCoverageInputSchema.parse(input), options)),
+    'take-turn': () => import('../../recipes/take-turn/index.js').then((recipe) => (input, options) => recipe.takeTurn(recipe.takeTurnInputSchema.parse(input), options)),
     'task-dependency': () => import('../../recipes/task-dependency/index.js').then((recipe) => (input, options) => recipe.taskDependency(recipe.taskDependencyInputSchema.parse(input), options)),
     'task-duplicate': () => import('../../recipes/task-duplicate/index.js').then((recipe) => (input, options) => recipe.taskDuplicate(recipe.taskDuplicateInputSchema.parse(input), options)),
     'ticket-match': () => import('../../recipes/ticket-match/index.js').then((recipe) => (input, options) => recipe.ticketMatch(recipe.ticketMatchInputSchema.parse(input), options)),
@@ -68,6 +75,7 @@ export const recipeLoaders = {
     'topic-shift': () => import('../../recipes/topic-shift/index.js').then((recipe) => (input, options) => recipe.topicShift(recipe.topicShiftInputSchema.parse(input), options)),
     'troubleshooting-fit': () => import('../../recipes/troubleshooting-fit/index.js').then((recipe) => (input, options) => recipe.troubleshootingFit(recipe.troubleshootingFitInputSchema.parse(input), options)),
     'turn-intent': () => import('../../recipes/turn-intent/index.js').then((recipe) => (input, options) => recipe.turnIntent(recipe.turnIntentInputSchema.parse(input), options)),
+    'uncertainty-expression': () => import('../../recipes/uncertainty-expression/index.js').then((recipe) => (input, options) => recipe.uncertaintyExpression(recipe.uncertaintyExpressionInputSchema.parse(input), options)),
     'urgency-signal': () => import('../../recipes/urgency-signal/index.js').then((recipe) => (input, options) => recipe.urgencySignal(recipe.urgencySignalInputSchema.parse(input), options)),
     verify: () => import('../../recipes/verify/index.js').then((recipe) => (input, options) => recipe.verify(recipe.verifyInputSchema.parse(input), options)),
     'workaround-fit': () => import('../../recipes/workaround-fit/index.js').then((recipe) => (input, options) => recipe.workaroundFit(recipe.workaroundFitInputSchema.parse(input), options)),

package/dist/catalog/generated/metadata.js

@@ -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',
@@ -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',
@@ -418,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',
@@ -435,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',
@@ -809,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',
@@ -942,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',
@@ -1080,6 +1291,43 @@ 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',
@@ -1231,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',

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", "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"];
+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,11 +8,13 @@ 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',
@@ -23,7 +25,9 @@ export const recipeNames = [
     'correction-target',
     'document-role',
     'draft-compare',
+    'evaluation-mention',
     'evidence-conflict',
+    'evidence-independence',
     'evidence-novelty',
     'fact-stability',
     'failure-kind',
@@ -46,6 +50,7 @@ export const recipeNames = [
     'promise-check',
     'query-equivalence',
     'query-specificity',
+    'question-leading',
     'reference-resolve',
     'repeated-attempt',
     'reply-template-match',
@@ -53,6 +58,7 @@ export const recipeNames = [
     'rerank',
     'resolution-check',
     'response-needed',
+    'response-refusal',
     'result-outcome',
     'result-usefulness',
     'retrieval-needed',
@@ -61,6 +67,7 @@ export const recipeNames = [
     'step-complete',
     'step-progress',
     'summary-coverage',
+    'take-turn',
     'task-dependency',
     'task-duplicate',
     'ticket-match',
@@ -69,6 +76,7 @@ export const recipeNames = [
     'topic-shift',
     'troubleshooting-fit',
     'turn-intent',
+    'uncertainty-expression',
     'urgency-signal',
     'verify',
     'workaround-fit',