jev-recipes 0.3.0 → 0.4.1

package/dist/catalog/generated/details/instruction-conflict.json

@@ -0,0 +1,52 @@
+{
+  "inputSchema": {
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "type": "object",
+    "properties": {
+      "firstInstruction": { "type": "string", "description": "The first instruction to compare." },
+      "secondInstruction": {
+        "type": "string",
+        "description": "The second instruction to compare."
+      },
+      "context": {
+        "type": "string",
+        "description": "The task and circumstances in which the instructions may apply."
+      },
+      "minConfidence": { "type": "number", "minimum": 0, "maximum": 1 }
+    },
+    "required": ["firstInstruction", "secondInstruction"]
+  },
+  "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": ["compatible", "conflicting", "different_scope", "unclear"]
+      },
+      "confidence": { "type": "number", "minimum": 0, "maximum": 1 },
+      "probabilities": {
+        "type": "object",
+        "propertyNames": {
+          "type": "string",
+          "enum": ["compatible", "conflicting", "different_scope", "unclear"]
+        },
+        "additionalProperties": { "type": "number", "minimum": 0, "maximum": 1 },
+        "required": ["compatible", "conflicting", "different_scope", "unclear"]
+      }
+    },
+    "required": ["model", "usage", "status", "verdict", "confidence", "probabilities"],
+    "additionalProperties": false
+  }
+}

package/dist/catalog/generated/details/question-leading.json

@@ -0,0 +1,52 @@
+{
+  "inputSchema": {
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "type": "object",
+    "properties": {
+      "question": {
+        "type": "string",
+        "description": "One question, including any framing that the respondent sees."
+      },
+      "proposedAnswer": {
+        "type": "string",
+        "description": "One candidate answer or position whose treatment by the question should be assessed."
+      },
+      "context": {
+        "type": "string",
+        "description": "Supplied context needed to interpret references and the candidate answer."
+      },
+      "minConfidence": { "type": "number", "minimum": 0, "maximum": 1 }
+    },
+    "required": ["question", "proposedAnswer"]
+  },
+  "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": ["favors", "disfavors", "neutral", "unclear"] },
+      "confidence": { "type": "number", "minimum": 0, "maximum": 1 },
+      "probabilities": {
+        "type": "object",
+        "propertyNames": {
+          "type": "string",
+          "enum": ["favors", "disfavors", "neutral", "unclear"]
+        },
+        "additionalProperties": { "type": "number", "minimum": 0, "maximum": 1 },
+        "required": ["favors", "disfavors", "neutral", "unclear"]
+      }
+    },
+    "required": ["model", "usage", "status", "verdict", "confidence", "probabilities"],
+    "additionalProperties": false
+  }
+}

package/dist/catalog/generated/details/requirement-testability.json

@@ -0,0 +1,45 @@
+{
+  "inputSchema": {
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "type": "object",
+    "properties": {
+      "requirement": {
+        "type": "string",
+        "description": "One requirement whose completion criteria need review."
+      },
+      "context": {
+        "type": "string",
+        "description": "Supplied definitions, acceptance criteria, and observation conditions."
+      },
+      "minConfidence": { "type": "number", "minimum": 0, "maximum": 1 }
+    },
+    "required": ["requirement"]
+  },
+  "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": ["testable", "not_testable", "unclear"] },
+      "confidence": { "type": "number", "minimum": 0, "maximum": 1 },
+      "probabilities": {
+        "type": "object",
+        "propertyNames": { "type": "string", "enum": ["testable", "not_testable", "unclear"] },
+        "additionalProperties": { "type": "number", "minimum": 0, "maximum": 1 },
+        "required": ["testable", "not_testable", "unclear"]
+      }
+    },
+    "required": ["model", "usage", "status", "verdict", "confidence", "probabilities"],
+    "additionalProperties": false
+  }
+}

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/task-dependency.json

@@ -0,0 +1,61 @@
+{
+  "inputSchema": {
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "type": "object",
+    "properties": {
+      "firstTask": {
+        "type": "string",
+        "description": "The first task, including its inputs and output when known."
+      },
+      "secondTask": {
+        "type": "string",
+        "description": "The second task, including its inputs and output when known."
+      },
+      "context": {
+        "type": "string",
+        "description": "Known prerequisites, available inputs, and relevant workflow conditions."
+      },
+      "minConfidence": { "type": "number", "minimum": 0, "maximum": 1 }
+    },
+    "required": ["firstTask", "secondTask"]
+  },
+  "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": ["first_before_second", "second_before_first", "independent", "cyclic", "unclear"]
+      },
+      "confidence": { "type": "number", "minimum": 0, "maximum": 1 },
+      "probabilities": {
+        "type": "object",
+        "propertyNames": {
+          "type": "string",
+          "enum": ["first_before_second", "second_before_first", "independent", "cyclic", "unclear"]
+        },
+        "additionalProperties": { "type": "number", "minimum": 0, "maximum": 1 },
+        "required": [
+          "first_before_second",
+          "second_before_first",
+          "independent",
+          "cyclic",
+          "unclear"
+        ]
+      }
+    },
+    "required": ["model", "usage", "status", "verdict", "confidence", "probabilities"],
+    "additionalProperties": false
+  }
+}

package/dist/catalog/generated/details/task-duplicate.json

@@ -0,0 +1,49 @@
+{
+  "inputSchema": {
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "type": "object",
+    "properties": {
+      "firstTask": { "type": "string", "description": "The first task and its intended outcome." },
+      "secondTask": {
+        "type": "string",
+        "description": "The second task and its intended outcome."
+      },
+      "context": {
+        "type": "string",
+        "description": "Relevant targets, scope, time periods, and constraints for the comparison."
+      },
+      "minConfidence": { "type": "number", "minimum": 0, "maximum": 1 }
+    },
+    "required": ["firstTask", "secondTask"]
+  },
+  "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": ["duplicate", "overlapping", "distinct", "unclear"] },
+      "confidence": { "type": "number", "minimum": 0, "maximum": 1 },
+      "probabilities": {
+        "type": "object",
+        "propertyNames": {
+          "type": "string",
+          "enum": ["duplicate", "overlapping", "distinct", "unclear"]
+        },
+        "additionalProperties": { "type": "number", "minimum": 0, "maximum": 1 },
+        "required": ["duplicate", "overlapping", "distinct", "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,20 +7,26 @@ 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)),
     clarify: () => import('../../recipes/clarify/index.js').then((recipe) => (input, options) => recipe.clarify(recipe.clarifyInputSchema.parse(input), options)),
     'confirmation-match': () => import('../../recipes/confirmation-match/index.js').then((recipe) => (input, options) => recipe.confirmationMatch(recipe.confirmationMatchInputSchema.parse(input), options)),
+    'constraint-strength': () => import('../../recipes/constraint-strength/index.js').then((recipe) => (input, options) => recipe.constraintStrength(recipe.constraintStrengthInputSchema.parse(input), options)),
     'context-role': () => import('../../recipes/context-role/index.js').then((recipe) => (input, options) => recipe.contextRole(recipe.contextRoleInputSchema.parse(input), options)),
     '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)),
@@ -31,6 +37,7 @@ export const recipeLoaders = {
     'frustration-signal': () => import('../../recipes/frustration-signal/index.js').then((recipe) => (input, options) => recipe.frustrationSignal(recipe.frustrationSignalInputSchema.parse(input), options)),
     handoff: () => import('../../recipes/handoff/index.js').then((recipe) => (input, options) => recipe.handoff(recipe.handoffInputSchema.parse(input), options)),
     'incident-match': () => import('../../recipes/incident-match/index.js').then((recipe) => (input, options) => recipe.incidentMatch(recipe.incidentMatchInputSchema.parse(input), options)),
+    'instruction-conflict': () => import('../../recipes/instruction-conflict/index.js').then((recipe) => (input, options) => recipe.instructionConflict(recipe.instructionConflictInputSchema.parse(input), options)),
     'instruction-fit': () => import('../../recipes/instruction-fit/index.js').then((recipe) => (input, options) => recipe.instructionFit(recipe.instructionFitInputSchema.parse(input), options)),
     'intent-change': () => import('../../recipes/intent-change/index.js').then((recipe) => (input, options) => recipe.intentChange(recipe.intentChangeInputSchema.parse(input), options)),
     'issue-impact': () => import('../../recipes/issue-impact/index.js').then((recipe) => (input, options) => recipe.issueImpact(recipe.issueImpactInputSchema.parse(input), options)),
@@ -42,12 +49,15 @@ 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)),
+    'requirement-testability': () => import('../../recipes/requirement-testability/index.js').then((recipe) => (input, options) => recipe.requirementTestability(recipe.requirementTestabilityInputSchema.parse(input), options)),
     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)),
@@ -56,12 +66,16 @@ 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)),
     'tone-check': () => import('../../recipes/tone-check/index.js').then((recipe) => (input, options) => recipe.toneCheck(recipe.toneCheckInputSchema.parse(input), options)),
     'tool-fit': () => import('../../recipes/tool-fit/index.js').then((recipe) => (input, options) => recipe.toolFit(recipe.toolFitInputSchema.parse(input), options)),
     '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)),