jev-recipes 0.6.0 → 0.7.0

package/dist/catalog/generated/details/tool-call-gate.json

@@ -0,0 +1,123 @@
+{
+  "inputSchema": {
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "type": "object",
+    "properties": {
+      "request": { "type": "string" },
+      "toolCall": { "type": "string" },
+      "context": { "type": "string" },
+      "policy": { "type": "string" },
+      "minConfidence": { "type": "number", "minimum": 0, "maximum": 1 }
+    },
+    "required": ["request", "toolCall"]
+  },
+  "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": ["allow", "ask", "deny", "unclear"] },
+      "suggestedAction": { "type": "string", "enum": ["allow", "ask", "deny"] },
+      "action": { "type": "string", "enum": ["allow", "ask", "deny"] },
+      "confidence": { "type": "number", "minimum": 0, "maximum": 1 },
+      "probabilities": {
+        "type": "object",
+        "propertyNames": { "type": "string", "enum": ["allow", "ask", "deny", "unclear"] },
+        "additionalProperties": { "type": "number", "minimum": 0, "maximum": 1 },
+        "required": ["allow", "ask", "deny", "unclear"]
+      },
+      "risks": {
+        "type": "object",
+        "properties": {
+          "irreversible": {
+            "type": "object",
+            "properties": {
+              "status": { "type": "string", "enum": ["ready", "review"] },
+              "verdict": { "type": "string", "enum": ["present", "absent"] },
+              "probability": { "type": "number", "minimum": 0, "maximum": 1 },
+              "confidence": { "type": "number", "minimum": 0, "maximum": 1 }
+            },
+            "required": ["status", "verdict", "probability", "confidence"],
+            "additionalProperties": false
+          },
+          "destructive": {
+            "type": "object",
+            "properties": {
+              "status": { "type": "string", "enum": ["ready", "review"] },
+              "verdict": { "type": "string", "enum": ["present", "absent"] },
+              "probability": { "type": "number", "minimum": 0, "maximum": 1 },
+              "confidence": { "type": "number", "minimum": 0, "maximum": 1 }
+            },
+            "required": ["status", "verdict", "probability", "confidence"],
+            "additionalProperties": false
+          },
+          "outOfScope": {
+            "type": "object",
+            "properties": {
+              "status": { "type": "string", "enum": ["ready", "review"] },
+              "verdict": { "type": "string", "enum": ["present", "absent"] },
+              "probability": { "type": "number", "minimum": 0, "maximum": 1 },
+              "confidence": { "type": "number", "minimum": 0, "maximum": 1 }
+            },
+            "required": ["status", "verdict", "probability", "confidence"],
+            "additionalProperties": false
+          },
+          "exfiltrates": {
+            "type": "object",
+            "properties": {
+              "status": { "type": "string", "enum": ["ready", "review"] },
+              "verdict": { "type": "string", "enum": ["present", "absent"] },
+              "probability": { "type": "number", "minimum": 0, "maximum": 1 },
+              "confidence": { "type": "number", "minimum": 0, "maximum": 1 }
+            },
+            "required": ["status", "verdict", "probability", "confidence"],
+            "additionalProperties": false
+          },
+          "injected": {
+            "type": "object",
+            "properties": {
+              "status": { "type": "string", "enum": ["ready", "review"] },
+              "verdict": { "type": "string", "enum": ["present", "absent"] },
+              "probability": { "type": "number", "minimum": 0, "maximum": 1 },
+              "confidence": { "type": "number", "minimum": 0, "maximum": 1 }
+            },
+            "required": ["status", "verdict", "probability", "confidence"],
+            "additionalProperties": false
+          }
+        },
+        "required": ["irreversible", "destructive", "outOfScope", "exfiltrates", "injected"],
+        "additionalProperties": false
+      },
+      "detected": {
+        "type": "array",
+        "items": {
+          "type": "string",
+          "enum": ["irreversible", "destructive", "outOfScope", "exfiltrates", "injected"]
+        }
+      }
+    },
+    "required": [
+      "model",
+      "usage",
+      "status",
+      "verdict",
+      "suggestedAction",
+      "action",
+      "confidence",
+      "probabilities",
+      "risks",
+      "detected"
+    ],
+    "additionalProperties": false
+  }
+}

package/dist/catalog/generated/details/wake-gate.json

@@ -0,0 +1,40 @@
+{
+  "inputSchema": {
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "type": "object",
+    "properties": {
+      "waitingFor": { "type": "string" },
+      "event": { "type": "string" },
+      "context": { "type": "string" },
+      "minConfidence": { "type": "number", "minimum": 0, "maximum": 1 }
+    },
+    "required": ["waitingFor", "event"]
+  },
+  "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": ["wake", "not_yet", "unrelated", "unclear"] },
+      "confidence": { "type": "number", "minimum": 0, "maximum": 1 },
+      "probabilities": {
+        "type": "object",
+        "propertyNames": { "type": "string", "enum": ["wake", "not_yet", "unrelated", "unclear"] },
+        "additionalProperties": { "type": "number", "minimum": 0, "maximum": 1 },
+        "required": ["wake", "not_yet", "unrelated", "unclear"]
+      }
+    },
+    "required": ["model", "usage", "status", "verdict", "confidence", "probabilities"],
+    "additionalProperties": false
+  }
+}

package/dist/catalog/generated/loaders.js

@@ -46,12 +46,14 @@ export const recipeLoaders = {
     'commit-message-fit': () => import('../../recipes/commit-message-fit/index.js').then((recipe) => (input, options) => recipe.commitMessageFit(recipe.commitMessageFitInputSchema.parse(input), options)),
     'commitment-strength': () => import('../../recipes/commitment-strength/index.js').then((recipe) => (input, options) => recipe.commitmentStrength(recipe.commitmentStrengthInputSchema.parse(input), options)),
     'comparable-fit': () => import('../../recipes/comparable-fit/index.js').then((recipe) => (input, options) => recipe.comparableFit(recipe.comparableFitInputSchema.parse(input), options)),
+    'completion-gate': () => import('../../recipes/completion-gate/index.js').then((recipe) => (input, options) => recipe.completionGate(recipe.completionGateInputSchema.parse(input), options)),
     'confirmation-match': () => import('../../recipes/confirmation-match/index.js').then((recipe) => (input, options) => recipe.confirmationMatch(recipe.confirmationMatchInputSchema.parse(input), options)),
     'consent-request': () => import('../../recipes/consent-request/index.js').then((recipe) => (input, options) => recipe.consentRequest(recipe.consentRequestInputSchema.parse(input), options)),
     'consent-scope-fit': () => import('../../recipes/consent-scope-fit/index.js').then((recipe) => (input, options) => recipe.consentScopeFit(recipe.consentScopeFitInputSchema.parse(input), options)),
     'constraint-strength': () => import('../../recipes/constraint-strength/index.js').then((recipe) => (input, options) => recipe.constraintStrength(recipe.constraintStrengthInputSchema.parse(input), options)),
     'content-facets': () => import('../../recipes/content-facets/index.js').then((recipe) => (input, options) => recipe.contentFacets(recipe.contentFacetsInputSchema.parse(input), options)),
     'content-freshness-signal': () => import('../../recipes/content-freshness-signal/index.js').then((recipe) => (input, options) => recipe.contentFreshnessSignal(recipe.contentFreshnessSignalInputSchema.parse(input), options)),
+    'context-prune': () => import('../../recipes/context-prune/index.js').then((recipe) => (input, options) => recipe.contextPrune(recipe.contextPruneInputSchema.parse(input), options)),
     'context-role': () => import('../../recipes/context-role/index.js').then((recipe) => (input, options) => recipe.contextRole(recipe.contextRoleInputSchema.parse(input), options)),
     'continuation-compare': () => import('../../recipes/continuation-compare/index.js').then((recipe) => (input, options) => recipe.continuationCompare(recipe.continuationCompareInputSchema.parse(input), options)),
     'correction-target': () => import('../../recipes/correction-target/index.js').then((recipe) => (input, options) => recipe.correctionTarget(recipe.correctionTargetInputSchema.parse(input), options)),
@@ -60,6 +62,7 @@ export const recipeLoaders = {
     'deadline-risk': () => import('../../recipes/deadline-risk/index.js').then((recipe) => (input, options) => recipe.deadlineRisk(recipe.deadlineRiskInputSchema.parse(input), options)),
     'defect-report-facets': () => import('../../recipes/defect-report-facets/index.js').then((recipe) => (input, options) => recipe.defectReportFacets(recipe.defectReportFacetsInputSchema.parse(input), options)),
     'delegation-fit': () => import('../../recipes/delegation-fit/index.js').then((recipe) => (input, options) => recipe.delegationFit(recipe.delegationFitInputSchema.parse(input), options)),
+    'diff-hazards': () => import('../../recipes/diff-hazards/index.js').then((recipe) => (input, options) => recipe.diffHazards(recipe.diffHazardsInputSchema.parse(input), options)),
     'disclosure-facets': () => import('../../recipes/disclosure-facets/index.js').then((recipe) => (input, options) => recipe.disclosureFacets(recipe.disclosureFacetsInputSchema.parse(input), options)),
     'dispute-kind': () => import('../../recipes/dispute-kind/index.js').then((recipe) => (input, options) => recipe.disputeKind(recipe.disputeKindInputSchema.parse(input), options)),
     'document-role': () => import('../../recipes/document-role/index.js').then((recipe) => (input, options) => recipe.documentRole(recipe.documentRoleInputSchema.parse(input), options)),
@@ -86,6 +89,7 @@ export const recipeLoaders = {
     'feedback-kind': () => import('../../recipes/feedback-kind/index.js').then((recipe) => (input, options) => recipe.feedbackKind(recipe.feedbackKindInputSchema.parse(input), options)),
     'field-select': () => import('../../recipes/field-select/index.js').then((recipe) => (input, options) => recipe.fieldSelect(recipe.fieldSelectInputSchema.parse(input), options)),
     'financial-advice-signal': () => import('../../recipes/financial-advice-signal/index.js').then((recipe) => (input, options) => recipe.financialAdviceSignal(recipe.financialAdviceSignalInputSchema.parse(input), options)),
+    'finger-actions': () => import('../../recipes/finger-actions/index.js').then((recipe) => (input, options) => recipe.fingerActions(recipe.fingerActionsInputSchema.parse(input), options)),
     'followup-link': () => import('../../recipes/followup-link/index.js').then((recipe) => (input, options) => recipe.followupLink(recipe.followupLinkInputSchema.parse(input), options)),
     'forecast-confidence-wording': () => import('../../recipes/forecast-confidence-wording/index.js').then((recipe) => (input, options) => recipe.forecastConfidenceWording(recipe.forecastConfidenceWordingInputSchema.parse(input), options)),
     'format-fit': () => import('../../recipes/format-fit/index.js').then((recipe) => (input, options) => recipe.formatFit(recipe.formatFitInputSchema.parse(input), options)),
@@ -132,6 +136,7 @@ export const recipeLoaders = {
     'memory-value': () => import('../../recipes/memory-value/index.js').then((recipe) => (input, options) => recipe.memoryValue(recipe.memoryValueInputSchema.parse(input), options)),
     'message-facets': () => import('../../recipes/message-facets/index.js').then((recipe) => (input, options) => recipe.messageFacets(recipe.messageFacetsInputSchema.parse(input), options)),
     'methods-facets': () => import('../../recipes/methods-facets/index.js').then((recipe) => (input, options) => recipe.methodsFacets(recipe.methodsFacetsInputSchema.parse(input), options)),
+    'model-route': () => import('../../recipes/model-route/index.js').then((recipe) => (input, options) => recipe.modelRoute(recipe.modelRouteInputSchema.parse(input), options)),
     'modulation-moment': () => import('../../recipes/modulation-moment/index.js').then((recipe) => (input, options) => recipe.modulationMoment(recipe.modulationMomentInputSchema.parse(input), options)),
     'mood-match': () => import('../../recipes/mood-match/index.js').then((recipe) => (input, options) => recipe.moodMatch(recipe.moodMatchInputSchema.parse(input), options)),
     'mood-request': () => import('../../recipes/mood-request/index.js').then((recipe) => (input, options) => recipe.moodRequest(recipe.moodRequestInputSchema.parse(input), options)),
@@ -197,6 +202,7 @@ export const recipeLoaders = {
     'rollback-signal': () => import('../../recipes/rollback-signal/index.js').then((recipe) => (input, options) => recipe.rollbackSignal(recipe.rollbackSignalInputSchema.parse(input), options)),
     'root-cause-depth': () => import('../../recipes/root-cause-depth/index.js').then((recipe) => (input, options) => recipe.rootCauseDepth(recipe.rootCauseDepthInputSchema.parse(input), options)),
     route: () => import('../../recipes/route/index.js').then((recipe) => (input, options) => recipe.route(recipe.routeInputSchema.parse(input), options)),
+    'route-many': () => import('../../recipes/route-many/index.js').then((recipe) => (input, options) => recipe.routeMany(recipe.routeManyInputSchema.parse(input), options)),
     'rule-compliance': () => import('../../recipes/rule-compliance/index.js').then((recipe) => (input, options) => recipe.ruleCompliance(recipe.ruleComplianceInputSchema.parse(input), options)),
     'runbook-fit': () => import('../../recipes/runbook-fit/index.js').then((recipe) => (input, options) => recipe.runbookFit(recipe.runbookFitInputSchema.parse(input), options)),
     'safety-incident-kind': () => import('../../recipes/safety-incident-kind/index.js').then((recipe) => (input, options) => recipe.safetyIncidentKind(recipe.safetyIncidentKindInputSchema.parse(input), options)),
@@ -224,6 +230,7 @@ export const recipeLoaders = {
     'tension-level': () => import('../../recipes/tension-level/index.js').then((recipe) => (input, options) => recipe.tensionLevel(recipe.tensionLevelInputSchema.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-call-gate': () => import('../../recipes/tool-call-gate/index.js').then((recipe) => (input, options) => recipe.toolCallGate(recipe.toolCallGateInputSchema.parse(input), options)),
     'tool-compare': () => import('../../recipes/tool-compare/index.js').then((recipe) => (input, options) => recipe.toolCompare(recipe.toolCompareInputSchema.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)),
@@ -233,5 +240,6 @@ export const recipeLoaders = {
     '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)),
+    'wake-gate': () => import('../../recipes/wake-gate/index.js').then((recipe) => (input, options) => recipe.wakeGate(recipe.wakeGateInputSchema.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

@@ -26,7 +26,7 @@ export const recipeMetadata = [
         title: 'Label the side effects of an action',
         description: 'Which side effects does the described action involve: writing or modifying data, sending a message or notification, spending or moving money, deleting something, or calling an external service?',
         category: 'workflow',
-        tags: ['agent', 'safety', 'action', 'side-effects', 'approval', 'labels'],
+        tags: ['agent', 'safety', 'action', 'side-effects', 'approval', 'labels', 'harness'],
         limitations: [
             'Labels the effects the action description states or plainly entails. It does not know what your tools actually do behind the description.',
             'Read-only lookups against an external API still count as external calls; whether that is acceptable is a policy decision for application code.',
@@ -49,7 +49,7 @@ export const recipeMetadata = [
         title: 'Grade action reversibility',
         description: 'How reversible is action, given any context, from a trivial undo to an irreversible external effect?',
         category: 'workflow',
-        tags: ['agent', 'safety', 'action', 'reversibility', 'approval'],
+        tags: ['agent', 'safety', 'action', 'reversibility', 'approval', 'harness'],
         limitations: [
             'Grades the action as described. It does not know which undo, backup, or recall facilities your system actually provides unless context says so.',
             'Reversibility is not permission. An irreversible action may be exactly what the user asked for, and a trivial one may still be out of scope.',
@@ -67,7 +67,7 @@ export const recipeMetadata = [
         title: 'Check proposed action scope',
         description: 'Is proposedAction within the work requested in request and constraints?',
         category: 'workflow',
-        tags: ['workflow', 'action', 'scope'],
+        tags: ['workflow', 'action', 'scope', 'harness'],
         limitations: [
             'Assesses semantic scope only. User authorization and access controls must be enforced by the application.',
         ],
@@ -1038,6 +1038,32 @@ export const recipeMetadata = [
             },
         ],
     },
+    {
+        id: 'completion-gate',
+        title: 'Gate an agent claiming it is done',
+        description: 'Did an agent finish task, judging report against evidence, with unproven claims, quietly narrowed scope, open questions, and unresolved errors flagged in the same call?',
+        category: 'workflow',
+        tags: ['agent', 'completion', 'stop-hook', 'verification', 'evidence', 'harness', 'done'],
+        limitations: [
+            'Judges only the supplied report and evidence. It does not run tests or inspect the repository; supply that output in evidence.',
+            'A complete verdict means the supplied material shows the task done, not that the work is correct or well made.',
+        ],
+        useWhen: 'A coding agent says it is finished and you must decide, before accepting or before letting it stop, whether the work is actually complete.',
+        related: [
+            {
+                id: 'step-complete',
+                reason: 'Use step-complete to check one explicit completion condition against evidence.',
+            },
+            {
+                id: 'goal-drift',
+                reason: 'Use goal-drift while the agent is still working to catch a step that wanders from the goal.',
+            },
+            {
+                id: 'result-plausibility',
+                reason: 'Use result-plausibility to check whether a single tool result is a real answer.',
+            },
+        ],
+    },
     {
         id: 'confirmation-match',
         title: 'Interpret a confirmation',
@@ -1179,6 +1205,33 @@ export const recipeMetadata = [
             },
         ],
     },
+    {
+        id: 'context-prune',
+        title: 'Prune agent context',
+        description: 'Which of items, earlier tool results and messages in an agent session, are still needed to finish objective, so the rest can be dropped from context?',
+        category: 'memory',
+        tags: ['agent', 'context', 'compaction', 'prune', 'memory', 'tool-results', 'harness'],
+        limitations: [
+            'Judges each item on its own text and the stated objective. It cannot see dependencies between items unless their text makes them explicit.',
+            'Uncertain items stay in keep. A short objective that hides what the agent still has to do makes most items look unnecessary; state the remaining work concretely.',
+            'Accepts up to 50 items per call. Chunk longer histories and pass recent so later chunks know what was already handled.',
+        ],
+        useWhen: 'An agent session is growing long and you want to drop stale tool output and messages before the next model turn without summarizing what must stay verbatim.',
+        related: [
+            {
+                id: 'rerank',
+                reason: 'Use rerank to order passages by relevance to a query rather than decide what an agent still needs.',
+            },
+            {
+                id: 'memory-value',
+                reason: 'Use memory-value to decide whether a fact is worth storing long term.',
+            },
+            {
+                id: 'progress-stall',
+                reason: 'Use progress-stall to detect an agent that keeps reprocessing the same context.',
+            },
+        ],
+    },
     {
         id: 'context-role',
         title: 'Identify a passage role',
@@ -1329,7 +1382,7 @@ export const recipeMetadata = [
         title: 'Check delegation fit',
         description: 'Does subtask fall within the capabilities described for the delegate?',
         category: 'workflow',
-        tags: ['agent', 'delegation', 'capabilities', 'routing', 'multi-agent'],
+        tags: ['agent', 'delegation', 'capabilities', 'routing', 'multi-agent', 'harness'],
         limitations: [
             'Judges fit against the capabilities as written. Abilities the delegate has but the description omits count as missing.',
             'Reports whether the subtask is within scope, not whether the delegate would do it well or how long it would take.',
@@ -1346,6 +1399,41 @@ export const recipeMetadata = [
             },
         ],
     },
+    {
+        id: 'diff-hazards',
+        title: 'Flag hazards in a code diff',
+        description: 'Which hazards does diff introduce: leaked secrets, destructive commands, debug leftovers, weakened tests, or dependency changes?',
+        category: 'workflow',
+        tags: [
+            'diff',
+            'code-review',
+            'secrets',
+            'destructive',
+            'pre-commit',
+            'agent',
+            'safety',
+            'harness',
+        ],
+        limitations: [
+            'Reads only the supplied diff text. It does not run the code, resolve imports, or see files outside the diff.',
+            'A pattern that looks like a secret, such as an example key in documentation, may be flagged; treat detections as a prompt for review, not proof.',
+        ],
+        useWhen: 'A coding agent or pre-commit hook needs a fast screen of a diff for the mistakes that reviewers most often catch late.',
+        related: [
+            {
+                id: 'change-risk',
+                reason: 'Use change-risk to grade the overall shipping risk of a described change rather than flag specific hazards in the diff text.',
+            },
+            {
+                id: 'commit-message-fit',
+                reason: 'Use commit-message-fit to check whether the commit message describes the change.',
+            },
+            {
+                id: 'breaking-change-signal',
+                reason: 'Use breaking-change-signal to check whether a change breaks callers.',
+            },
+        ],
+    },
     {
         id: 'disclosure-facets',
         title: 'Label what a property disclosure addresses',
@@ -1918,6 +2006,29 @@ export const recipeMetadata = [
             },
         ],
     },
+    {
+        id: 'finger-actions',
+        title: 'Choose an action for every finger',
+        description: 'On beat, which listed option should each finger in fingers take, given music and style, or rest?',
+        category: 'workflow',
+        tags: ['music', 'piano', 'performance', 'fingers', 'assignment', 'live-performance', 'agent'],
+        limitations: [
+            'Each finger is judged as its own question within one request, so two fingers can pick the same key. Resolve collisions and physical reach in code.',
+            'Options are the caller-supplied reachable actions for that finger; the recipe does not invent notes or check key membership.',
+            'Beat timing, note durations, and MIDI output belong in application code.',
+        ],
+        useWhen: 'A playing loop advances one subdivision at a time and wants every finger to pick from its own reachable options in a single call.',
+        related: [
+            {
+                id: 'next-note',
+                reason: 'Use next-note when the loop chooses one melodic note rather than an action per finger.',
+            },
+            {
+                id: 'next-chord',
+                reason: 'Use next-chord to pick the harmony first, then let finger-actions voice it.',
+            },
+        ],
+    },
     {
         id: 'followup-link',
         title: 'Link a follow-up request',
@@ -2088,7 +2199,7 @@ export const recipeMetadata = [
         title: 'Detect goal drift',
         description: 'Does step still serve goal, or has work drifted to something goal did not ask for?',
         category: 'workflow',
-        tags: ['agent', 'goal', 'drift', 'scope', 'monitoring', 'gate'],
+        tags: ['agent', 'goal', 'drift', 'scope', 'monitoring', 'gate', 'harness'],
         limitations: [
             'Judges a single step against the stated goal. It does not know whether the user later widened or changed the goal unless context says so.',
             'Reports drift, not whether the drifted work is harmful or valuable. Stopping, asking, or continuing is an application decision.',
@@ -2169,7 +2280,7 @@ export const recipeMetadata = [
         title: 'Grade handoff completeness',
         description: 'How ready is item, a work description being handed to another agent or person, to be picked up without asking questions, on a five-level rubric?',
         category: 'workflow',
-        tags: ['agent', 'delegation', 'handoff', 'completeness', 'multi-agent'],
+        tags: ['agent', 'delegation', 'handoff', 'completeness', 'multi-agent', 'harness'],
         limitations: [
             'Grades what the item states, not whether the stated goal is correct, feasible, or worth doing.',
             'Cannot know what the recipient already knows, so shared context that is not written into the item counts as missing.',
@@ -2250,7 +2361,7 @@ export const recipeMetadata = [
         title: 'Detect agent-directed instructions',
         description: 'Does text contain instructions aimed at steering an AI system or agent?',
         category: 'workflow',
-        tags: ['security', 'prompt-injection', 'agent', 'safety', 'gate', 'retrieval'],
+        tags: ['security', 'prompt-injection', 'agent', 'safety', 'gate', 'retrieval', 'harness'],
         limitations: [
             'Detects instruction-like content aimed at machines. It does not judge whether the instructions would succeed or are malicious.',
             'Quarantine, stripping, and logging decisions belong in application code.',
@@ -2333,7 +2444,7 @@ export const recipeMetadata = [
         title: 'Decide which conflicting instruction wins',
         description: 'When firstInstruction and secondInstruction conflict, which should take precedence under the stated policy?',
         category: 'workflow',
-        tags: ['agent', 'instructions', 'policy', 'precedence', 'comparison', 'safety'],
+        tags: ['agent', 'instructions', 'policy', 'precedence', 'comparison', 'safety', 'harness'],
         limitations: [
             'Applies the policy as written. It does not decide whether the policy itself is sensible or whether the instructions really conflict.',
             'Depends on each instruction stating or implying its source; if the policy ranks by source and the source is not given, the result is unclear.',
@@ -2918,6 +3029,37 @@ export const recipeMetadata = [
             },
         ],
     },
+    {
+        id: 'model-route',
+        title: 'Route a request to a model tier',
+        description: 'Which of the described models should serve request, and how much reasoning effort does it need, decided in one call so a cheap model handles easy turns and a capable one handles hard turns?',
+        category: 'workflow',
+        tags: [
+            'agent',
+            'model-routing',
+            'cost',
+            'effort',
+            'reasoning',
+            'tiering',
+            'harness',
+            'gateway',
+        ],
+        limitations: [
+            'Chooses among the supplied descriptions only. The quality of the routing depends on how honestly each model entry describes its strengths, weaknesses, and cost.',
+            'The effort grade is a judgment about the request text, not a measurement; calibrate its thresholds against your own traffic.',
+        ],
+        useWhen: 'An agent harness, gateway, or proxy chooses per request which LLM and thinking level to use, and you want that choice made in well under a second.',
+        related: [
+            {
+                id: 'route',
+                reason: 'Use route to send a request to a named handler or team when no effort level is needed.',
+            },
+            {
+                id: 'task-complexity',
+                reason: 'Use task-complexity for a five-level complexity grade without picking a model.',
+            },
+        ],
+    },
     {
         id: 'modulation-moment',
         title: 'Check whether now is a moment to change key',
@@ -3686,7 +3828,7 @@ export const recipeMetadata = [
         title: 'Detect a stalled agent',
         description: 'Does transcript, the recent agent steps, show the agent failing to make progress toward objective by repeating actions, circling, or reprocessing the same information?',
         category: 'workflow',
-        tags: ['agent', 'monitoring', 'loop', 'stall', 'safety'],
+        tags: ['agent', 'monitoring', 'loop', 'stall', 'safety', 'harness'],
         limitations: [
             'Judges the window of steps supplied in transcript. A loop longer than the window, or progress made before it, is invisible.',
             'Reports that the agent is stalled, not why or what it should do instead. Interrupting, redirecting, or escalating is an application decision.',
@@ -4162,7 +4304,7 @@ export const recipeMetadata = [
         title: 'Check result plausibility',
         description: 'Is result a plausible, internally consistent answer to request rather than an error, placeholder, empty, or unrelated output dressed as data?',
         category: 'workflow',
-        tags: ['agent', 'tool-result', 'plausibility', 'validation', 'quality', 'gate'],
+        tags: ['agent', 'tool-result', 'plausibility', 'validation', 'quality', 'gate', 'harness'],
         limitations: [
             'Judges internal consistency and fit to the request, not factual accuracy. A plausible result can still be wrong.',
             'A genuine empty answer, such as a search that legitimately found nothing, is only plausible if the result says so rather than returning blank output.',
@@ -4218,7 +4360,7 @@ export const recipeMetadata = [
         title: 'Decide whether to retry',
         description: 'Does failure describe a transient condition where an identical retry could succeed, given any attempt history?',
         category: 'workflow',
-        tags: ['agent', 'retry', 'failure', 'resilience', 'transient', 'gate'],
+        tags: ['agent', 'retry', 'failure', 'resilience', 'transient', 'gate', 'harness'],
         limitations: [
             'Judges the failure text as written. It does not know your retry budget, backoff policy, or whether the action is safe to repeat.',
             'Says whether an identical retry could succeed, not whether a modified attempt would. Fixing inputs or permissions is a different decision.',
@@ -4394,6 +4536,28 @@ export const recipeMetadata = [
             },
         ],
     },
+    {
+        id: 'route-many',
+        title: 'Route many requests in batches',
+        description: 'Which named route handles each of up to 500 requests, judged in batched Jev requests so a queue of tickets, emails, or events is routed in a handful of calls instead of one per item?',
+        category: 'support',
+        tags: ['batch', 'routing', 'triage', 'queue', 'bulk', 'tickets', 'email', 'throughput'],
+        limitations: [
+            'Every request in a batch shares one model call, so accuracy can fall as batches grow; the default batch size of 20 is a starting point to tune against your own labels.',
+            'Per-item results are independent judgments. The recipe does not deduplicate or group related requests.',
+        ],
+        useWhen: 'You have a backlog or stream of messages to route to the same set of handlers and want batched throughput with a per-item review outcome.',
+        related: [
+            {
+                id: 'route',
+                reason: 'Use route for a single request, or when each request has its own set of routes.',
+            },
+            {
+                id: 'ticket-match',
+                reason: 'Use ticket-match to link a new message to an existing ticket rather than a queue.',
+            },
+        ],
+    },
     {
         id: 'rule-compliance',
         title: 'Check rule compliance',
@@ -4682,7 +4846,7 @@ export const recipeMetadata = [
         title: 'Check one completion condition',
         description: 'Does evidence establish that condition has been met?',
         category: 'workflow',
-        tags: ['workflow', 'step', 'complete', 'alignment-research'],
+        tags: ['workflow', 'step', 'complete', 'alignment-research', 'harness'],
         limitations: [
             'Assesses supplied evidence for one condition. Use exact system state checks when the condition can be determined in code.',
         ],
@@ -4981,12 +5145,52 @@ export const recipeMetadata = [
             },
         ],
     },
+    {
+        id: 'tool-call-gate',
+        title: 'Gate an agent tool call',
+        description: 'Should an agent run toolCall now, ask a person first, or refuse it, given request and policy, with irreversible, destructive, out-of-scope, exfiltration, and injection risks flagged in the same call?',
+        category: 'workflow',
+        tags: [
+            'agent',
+            'tool-call',
+            'permission',
+            'guardrail',
+            'safety',
+            'injection',
+            'pre-tool-use',
+            'harness',
+        ],
+        limitations: [
+            'Judges the call as described in toolCall. Pass the actual tool name and arguments, not a summary written by the agent.',
+            'Deterministic rules such as allowlists, path restrictions, and rate limits are cheaper and more reliable for what they cover; run them first and use this recipe for the cases they leave open.',
+            'A review or ask outcome means a person should look; it does not itself block execution. The application must enforce the action.',
+        ],
+        useWhen: 'A coding or browsing agent is about to execute a tool call and you need an allow, ask, or deny decision plus the specific risks, in one fast request.',
+        related: [
+            {
+                id: 'action-scope',
+                reason: 'Use action-scope when you only need to know whether an action stays within the request.',
+            },
+            {
+                id: 'action-reversibility',
+                reason: 'Use action-reversibility for a five-level grade of how reversible one action is.',
+            },
+            {
+                id: 'action-effects',
+                reason: 'Use action-effects to label what kinds of side effects an action has.',
+            },
+            {
+                id: 'injection-signal',
+                reason: 'Use injection-signal to screen text for embedded instructions before an agent reads it.',
+            },
+        ],
+    },
     {
         id: 'tool-compare',
         title: 'Compare two tools for a task',
         description: 'Which of firstTool and secondTool, as described by their stated capabilities, better fits task?',
         category: 'workflow',
-        tags: ['agent', 'tool-use', 'comparison', 'pairwise', 'planning', 'workflow'],
+        tags: ['agent', 'tool-use', 'comparison', 'pairwise', 'planning', 'workflow', 'harness'],
         limitations: [
             'Compares the capability descriptions as written. It does not invoke either tool, check credentials, or know about tools not supplied.',
             'A tool can fit the task better and still be unavailable, rate-limited, or forbidden; availability and permission belong in application code.',
@@ -5008,7 +5212,7 @@ export const recipeMetadata = [
         title: 'Check a tool fit',
         description: 'Can the capabilities explicitly described in tool perform task?',
         category: 'workflow',
-        tags: ['workflow', 'tool', 'fit'],
+        tags: ['workflow', 'tool', 'fit', 'harness'],
         limitations: [
             'Assesses a supplied capability description. It does not discover tools, validate credentials, or grant permission.',
         ],
@@ -5164,6 +5368,28 @@ export const recipeMetadata = [
             },
         ],
     },
+    {
+        id: 'wake-gate',
+        title: 'Decide whether an event should wake a waiting agent',
+        description: 'Should event wake an agent that is paused until waitingFor happens: wake now, keep waiting, or ignore it as unrelated?',
+        category: 'workflow',
+        tags: ['agent', 'wake', 'resume', 'event', 'pause', 'scheduler', 'long-running', 'harness'],
+        limitations: [
+            "Judges only the supplied event against the stated wait condition. It does not know about earlier events or the agent's full history unless context supplies them.",
+            'A wake verdict means the condition appears met or materially changed; the resumed agent still has to verify the actual state.',
+        ],
+        useWhen: 'A paused or sleeping agent receives a timer tick, webhook, message, or file change and you must decide whether to resume its model loop.',
+        related: [
+            {
+                id: 'goal-drift',
+                reason: "Use goal-drift to check whether a resumed agent's next step still serves its goal.",
+            },
+            {
+                id: 'progress-stall',
+                reason: 'Use progress-stall to detect an agent that keeps waking without making progress.',
+            },
+        ],
+    },
     {
         id: 'workaround-fit',
         title: 'Check workaround fit',