jev-recipes 0.2.0 → 0.3.0

package/dist/catalog/generated/metadata.js

@@ -0,0 +1,1115 @@
+export const recipeMetadata = [
+    {
+        id: 'action-scope',
+        title: 'Check proposed action scope',
+        description: 'Is proposedAction within the work requested in request and constraints?',
+        category: 'workflow',
+        tags: ['workflow', 'action', 'scope'],
+        limitations: [
+            'Assesses semantic scope only. User authorization and access controls must be enforced by the application.',
+        ],
+        useWhen: 'You need to check whether a proposed action stays within the requested work and constraints.',
+        related: [
+            {
+                id: 'instruction-fit',
+                reason: 'Use instruction-fit to decide whether a particular instruction applies.',
+            },
+        ],
+    },
+    {
+        id: 'answer-consistency',
+        title: 'Check answer consistency',
+        description: 'Do firstStatement and secondStatement make compatible claims about the same subject and circumstances?',
+        category: 'answer-quality',
+        tags: ['answer-quality', 'answer', 'consistency', 'rag', 'evidence'],
+        limitations: [
+            'Checks semantic consistency between two statements. Exact numeric and date comparisons belong in code.',
+        ],
+        useWhen: 'You need to check whether two statements agree under the same conditions.',
+        related: [
+            {
+                id: 'verify',
+                reason: 'Use verify to assess a claim against evidence rather than another statement.',
+            },
+        ],
+    },
+    {
+        id: 'answer-coverage',
+        title: 'Check answer coverage',
+        description: 'Check whether a draft answers each supplied question.',
+        category: 'answer-quality',
+        tags: ['answer-quality', 'answer', 'coverage', 'rag', 'evidence'],
+        limitations: [
+            'Checks supplied question IDs only. It does not extract questions or verify the draft against sources.',
+            'Supply 1 to 50 items per list, each with a unique non-empty ID and non-empty text.',
+        ],
+        useWhen: 'You have a draft and need to check whether it answers each supplied question.',
+        related: [
+            {
+                id: 'answer-relevance',
+                reason: 'Use answer-relevance to assess how directly the draft addresses the overall request.',
+            },
+        ],
+    },
+    {
+        id: 'answer-invalidation',
+        title: 'Check an answer after a source change',
+        description: 'Does updatedEvidence still support the entire claim that was based on previousEvidence?',
+        category: 'knowledge',
+        tags: ['knowledge', 'answer', 'invalidation'],
+        limitations: [
+            'Assesses one supplied claim and source revision. It does not monitor changes, compare release dates, or invalidate a cache automatically.',
+        ],
+        useWhen: 'You need to check whether updated evidence still supports a previously supported claim.',
+        related: [
+            {
+                id: 'cache-match',
+                reason: 'Use cache-match to check reuse for a new question when evidence has not changed.',
+            },
+        ],
+    },
+    {
+        id: 'answer-relevance',
+        title: 'Check answer relevance',
+        description: 'How directly does draft address request?',
+        category: 'answer-quality',
+        tags: ['answer-quality', 'answer', 'relevance', 'rag', 'evidence'],
+        limitations: [
+            'Relevance does not establish correctness or complete coverage. Use answer-coverage and verify for those decisions.',
+        ],
+        useWhen: 'You need to check whether a draft stays relevant to the request.',
+        related: [
+            {
+                id: 'answer-coverage',
+                reason: 'Use answer-coverage to check separate question parts individually.',
+            },
+        ],
+    },
+    {
+        id: 'answerability',
+        title: 'Check answerability',
+        description: 'Decide whether supplied evidence can answer an entire question.',
+        category: 'retrieval',
+        tags: ['rag', 'abstention', 'evidence'],
+        limitations: [
+            'Does not generate an answer or establish source truth.',
+            'Provide 1 to 50 evidence passages with unique IDs; handle empty retrieval in application code.',
+        ],
+        useWhen: 'You need to know if you have enough evidence and can answer a question.',
+        related: [
+            {
+                id: 'answer-coverage',
+                reason: 'Use answer-coverage after drafting to check whether each question was addressed.',
+            },
+        ],
+    },
+    {
+        id: 'argument-fit',
+        title: 'Check argument meaning',
+        description: 'Does proposedValue for argument express the intended value in request and context?',
+        category: 'workflow',
+        tags: ['workflow', 'argument', 'fit'],
+        limitations: [
+            'Does not validate schemas, compare identifiers, or enforce authorization. Check those deterministically before acting.',
+        ],
+        useWhen: 'You need to check whether a proposed argument value matches the user request.',
+        related: [
+            {
+                id: 'tool-fit',
+                reason: 'Use tool-fit to check the tool capability before choosing its arguments.',
+            },
+        ],
+    },
+    {
+        id: 'attempted-step',
+        title: 'Check a previously attempted step',
+        description: 'Does conversation establish whether the customer already performed step?',
+        category: 'support',
+        tags: ['support', 'attempted', 'step'],
+        limitations: [
+            'Interprets reports of an attempt. It does not verify that the step was completed correctly or repeat the action.',
+        ],
+        useWhen: 'You need to know whether a customer already tried a troubleshooting step.',
+        related: [
+            {
+                id: 'troubleshooting-fit',
+                reason: 'Use troubleshooting-fit to check whether the procedure fits the symptoms.',
+            },
+        ],
+    },
+    {
+        id: 'audience-fit',
+        title: 'Check audience fit',
+        description: 'Does the level of explanation in document fit the knowledge and needs explicitly described in audience?',
+        category: 'knowledge',
+        tags: ['knowledge', 'audience', 'fit'],
+        limitations: [
+            'Uses only the supplied audience description. It does not infer ability from identity or rewrite the document.',
+        ],
+        useWhen: 'You need to check whether a document suits the stated audience knowledge and needs.',
+        related: [
+            { id: 'tone-check', reason: 'Use tone-check to evaluate specific writing criteria.' },
+        ],
+    },
+    {
+        id: 'cache-match',
+        title: 'Check a cached answer',
+        description: 'Does cachedAnswer address question with the same relevant meaning and conditions as originalQuestion?',
+        category: 'retrieval',
+        tags: ['retrieval', 'cache', 'match', 'rag', 'evidence'],
+        limitations: [
+            'Enforce tenant, permissions, version, and freshness checks in code before calling. A semantic match does not verify the cached answer.',
+        ],
+        useWhen: 'You want to know whether a saved answer applies to a new question.',
+        related: [
+            {
+                id: 'query-equivalence',
+                reason: 'Use query-equivalence to compare questions without assessing a saved answer.',
+            },
+        ],
+    },
+    {
+        id: 'cancellation-check',
+        title: 'Check cancellation intent',
+        description: 'Does message ask to cancel, pause, or continue task?',
+        category: 'conversation',
+        tags: ['conversation', 'cancellation', 'check'],
+        limitations: [
+            'Does not stop running work or infer permission to continue from silence. The caller applies the decision.',
+        ],
+        useWhen: 'You need to detect whether a message asks to stop, pause, or continue a task.',
+        related: [
+            {
+                id: 'intent-change',
+                reason: 'Use intent-change to assess broader changes to the current goal.',
+            },
+        ],
+    },
+    {
+        id: 'certainty-match',
+        title: 'Check certainty wording',
+        description: 'Does the certainty expressed in draft match assessment?',
+        category: 'answer-quality',
+        tags: ['answer-quality', 'certainty', 'match', 'rag', 'evidence'],
+        limitations: [
+            'Compares wording with a supplied assessment. It does not calibrate probabilities or establish the assessment itself.',
+        ],
+        useWhen: 'You want the wording of a draft to reflect the certainty of an assessment.',
+        related: [
+            { id: 'tone-check', reason: 'Use tone-check to evaluate other explicit writing criteria.' },
+        ],
+    },
+    {
+        id: 'change-meaning',
+        title: 'Assess a text revision',
+        description: 'Does the revision from before to after change material meaning, conditions, or obligations?',
+        category: 'knowledge',
+        tags: ['knowledge', 'change', 'meaning'],
+        limitations: [
+            'Compares supplied passages. It does not parse a repository diff or perform exact numeric and date comparisons.',
+        ],
+        useWhen: 'You need to know whether a revision changes material meaning or obligations.',
+        related: [
+            {
+                id: 'answer-invalidation',
+                reason: 'Use answer-invalidation to assess how changed evidence affects a saved claim.',
+            },
+        ],
+    },
+    {
+        id: 'citation-match',
+        title: 'Match claims to citations',
+        description: 'Find supplied passages that independently support an entire claim.',
+        category: 'answer-quality',
+        tags: ['answer-quality', 'citation', 'match', 'rag', 'evidence'],
+        limitations: [
+            'Returns passages that independently support the entire claim. Joint support across several individually incomplete passages is not assessed.',
+            'Supply 1 to 50 items per list, each with a unique non-empty ID and non-empty text.',
+        ],
+        uses: ['verify'],
+        useWhen: 'You want to find which supplied passages support an entire claim.',
+        related: [
+            { id: 'verify', reason: 'Use verify when each claim already has its own paired evidence.' },
+        ],
+    },
+    {
+        id: 'citation-needed',
+        title: 'Check citation requirements',
+        description: 'Do citationRules require evidence for statement?',
+        category: 'answer-quality',
+        tags: ['answer-quality', 'citation', 'needed', 'rag', 'evidence'],
+        limitations: [
+            'Assesses a supplied citation policy; does not find sources or determine whether a statement is true.',
+        ],
+        useWhen: 'You need to decide whether a statement requires a citation under your rules.',
+        related: [
+            {
+                id: 'citation-match',
+                reason: 'Use citation-match to find supporting passages once a citation is needed.',
+            },
+        ],
+    },
+    {
+        id: 'clarify',
+        title: 'Check required information',
+        description: 'Identify missing or ambiguous information before proceeding.',
+        category: 'conversation',
+        tags: ['requirements', 'ambiguity', 'clarification'],
+        limitations: [
+            'Checks only the requirements you supply; does not generate follow-up questions.',
+            'Provide 1 to 50 requirements with unique IDs.',
+        ],
+        useWhen: 'You need to check for missing or ambiguous requirements before proceeding.',
+        related: [
+            {
+                id: 'query-specificity',
+                reason: 'Use query-specificity to assess how focused the question is, without a requirements list.',
+            },
+        ],
+    },
+    {
+        id: 'confirmation-match',
+        title: 'Interpret a confirmation',
+        description: 'Does response clearly agree to or reject this exact proposal?',
+        category: 'conversation',
+        tags: ['conversation', 'confirmation', 'match'],
+        limitations: [
+            'Interprets language only. Approval identity, authority, scope, expiration, and action permissions remain application checks.',
+        ],
+        useWhen: 'You need to know whether a response accepts or rejects an exact proposal.',
+        related: [
+            {
+                id: 'cancellation-check',
+                reason: 'Use cancellation-check to assess instructions to stop or pause a task.',
+            },
+        ],
+    },
+    {
+        id: 'context-role',
+        title: 'Identify a passage role',
+        description: 'What role does passage play in answering question?',
+        category: 'retrieval',
+        tags: ['retrieval', 'context', 'role', 'rag', 'evidence'],
+        limitations: [
+            'Classifies a passage contribution. It does not rank sources or prove the answer is supported.',
+        ],
+        useWhen: 'You want to identify the role a passage plays in answering a question.',
+        related: [{ id: 'rerank', reason: 'Use rerank to select and order passages by relevance.' }],
+    },
+    {
+        id: 'correction-target',
+        title: 'Locate a correction target',
+        description: 'Which supplied field or statement is message correcting?',
+        category: 'conversation',
+        tags: ['conversation', 'correction', 'target'],
+        limitations: [
+            'Selects one correction target. It does not extract a replacement value or update a record.',
+            'Supply 1 to 50 items per list, each with a unique non-empty ID and non-empty text.',
+        ],
+        useWhen: 'You need to identify which supplied field or statement a message corrects.',
+        related: [
+            {
+                id: 'reference-resolve',
+                reason: 'Use reference-resolve for references that are not corrections.',
+            },
+        ],
+    },
+    {
+        id: 'document-role',
+        title: 'Identify document purpose',
+        description: 'What is the primary purpose of document?',
+        category: 'knowledge',
+        tags: ['knowledge', 'document', 'role'],
+        limitations: [
+            'Returns one primary role from the supplied text. It does not read files, split mixed documents, or create an index.',
+        ],
+        useWhen: 'You need to identify the primary purpose of a document.',
+        related: [
+            {
+                id: 'context-role',
+                reason: 'Use context-role to assess how a passage relates to a specific question.',
+            },
+        ],
+    },
+    {
+        id: 'draft-compare',
+        title: 'Compare two drafts',
+        description: 'Which draft better satisfies request under rubric?',
+        category: 'answer-quality',
+        tags: ['answer-quality', 'draft', 'compare', 'rag', 'evidence'],
+        limitations: [
+            'Makes a relative judgment against your rubric. A preferred draft can still contain unsupported facts.',
+        ],
+        useWhen: 'You have two drafts and want to choose the better fit for a request and rubric.',
+        related: [
+            {
+                id: 'tone-check',
+                reason: 'Use tone-check to evaluate each writing criterion for one draft.',
+            },
+        ],
+    },
+    {
+        id: 'evidence-conflict',
+        title: 'Compare evidence for conflicts',
+        description: 'Do firstPassage and secondPassage give incompatible evidence relevant to question under the same conditions?',
+        category: 'retrieval',
+        tags: ['retrieval', 'evidence', 'conflict', 'rag'],
+        limitations: [
+            'Does not decide which source is authoritative. Exact numbers, timestamps, and version ordering should be compared in code.',
+        ],
+        useWhen: 'You have two passages and need to check for conflicting evidence about a question.',
+        related: [
+            {
+                id: 'answer-consistency',
+                reason: 'Use answer-consistency to compare two statements directly.',
+            },
+        ],
+    },
+    {
+        id: 'evidence-novelty',
+        title: 'Check new evidence',
+        description: 'Does passage add material information relevant to question beyond existingEvidence?',
+        category: 'retrieval',
+        tags: ['retrieval', 'evidence', 'novelty', 'rag'],
+        limitations: [
+            'Assesses novelty within the supplied set. It does not establish correctness or decide when retrieval must stop.',
+            'Supply 1 to 50 items per list, each with a unique non-empty ID and non-empty text.',
+        ],
+        useWhen: 'You need to decide whether a new passage adds useful information to existing evidence.',
+        related: [
+            {
+                id: 'passage-duplicate',
+                reason: 'Use passage-duplicate to compare overlap between two passages.',
+            },
+        ],
+    },
+    {
+        id: 'fact-stability',
+        title: 'Assess fact stability',
+        description: 'Is fact about an enduring or historical attribute, or a state that is expected to change?',
+        category: 'memory',
+        tags: ['memory', 'fact', 'stability'],
+        limitations: [
+            'Does not establish truth, expiration times, or freshness. Refresh policies and timestamp comparisons belong in code.',
+        ],
+        useWhen: 'You need to assess whether a fact is enduring or likely to change over time.',
+        related: [
+            {
+                id: 'freshness-needed',
+                reason: 'Use freshness-needed to decide whether a question needs current information.',
+            },
+        ],
+    },
+    {
+        id: 'failure-kind',
+        title: 'Classify a described failure',
+        description: 'Which supplied category best describes the observed failure?',
+        category: 'workflow',
+        tags: ['workflow', 'failure', 'kind'],
+        limitations: [
+            'Maps text to your categories. Use structured error codes first; this recipe does not diagnose a root cause or initiate retries.',
+            'Supply 1 to 50 items per list, each with a unique non-empty ID and non-empty text.',
+        ],
+        useWhen: 'You need to assign an observed failure to one of your supplied categories.',
+        related: [
+            {
+                id: 'result-outcome',
+                reason: 'Use result-outcome when first determining what a result reports.',
+            },
+        ],
+    },
+    {
+        id: 'feedback-kind',
+        title: 'Classify customer feedback',
+        description: 'What is the primary kind of feedback in message?',
+        category: 'support',
+        tags: ['support', 'feedback', 'kind'],
+        limitations: [
+            'Returns one primary category. It does not create a ticket, extract multiple issues, or set a priority.',
+        ],
+        useWhen: 'You need to classify the kind of feedback expressed in a message.',
+        related: [
+            {
+                id: 'turn-intent',
+                reason: 'Use turn-intent for the broader purpose of a conversational turn.',
+            },
+        ],
+    },
+    {
+        id: 'field-select',
+        title: 'Select a field value',
+        description: 'Which supplied candidate is the value of field in document?',
+        category: 'knowledge',
+        tags: ['knowledge', 'field', 'select'],
+        limitations: [
+            'Chooses among caller-supplied candidates. Extract candidates with a parser or generator first; validate exact formats and identifiers in code.',
+            'Supply 1 to 50 items per list, each with a unique non-empty ID and non-empty text.',
+        ],
+        useWhen: 'You need to select which supplied candidate expresses a field value in a document.',
+        related: [
+            {
+                id: 'reference-resolve',
+                reason: 'Use reference-resolve to identify what a conversational reference points to.',
+            },
+        ],
+    },
+    {
+        id: 'followup-link',
+        title: 'Link a follow-up request',
+        description: 'Which supplied earlier request does message follow up on?',
+        category: 'conversation',
+        tags: ['conversation', 'followup', 'link'],
+        limitations: [
+            'Selects from the supplied earlier requests. Supply enough conversation context to resolve references.',
+            'Supply 1 to 50 items per list, each with a unique non-empty ID and non-empty text.',
+        ],
+        useWhen: 'You need to connect a follow-up message to one of the earlier requests.',
+        related: [
+            {
+                id: 'reference-resolve',
+                reason: 'Use reference-resolve to identify a referenced item rather than an earlier request.',
+            },
+        ],
+    },
+    {
+        id: 'freshness-needed',
+        title: 'Check information freshness needs',
+        description: 'Does question require a current or time-specific state that can change, or stable conceptual knowledge?',
+        category: 'retrieval',
+        tags: ['retrieval', 'freshness', 'needed', 'rag', 'evidence'],
+        limitations: [
+            'Does not check timestamps, determine whether a source is up to date, or retrieve current information.',
+        ],
+        useWhen: 'You need to know whether a question depends on current or changing information.',
+        related: [
+            {
+                id: 'fact-stability',
+                reason: 'Use fact-stability to assess a particular fact rather than a question.',
+            },
+        ],
+    },
+    {
+        id: 'frustration-signal',
+        title: 'Detect expressed frustration',
+        description: 'Does message express frustration or dissatisfaction in its wording?',
+        category: 'support',
+        tags: ['support', 'frustration', 'signal'],
+        limitations: [
+            'Classifies expressed language only. It does not diagnose emotions or determine customer importance or entitlement.',
+        ],
+        useWhen: 'You need to detect frustration or dissatisfaction expressed in a message.',
+        related: [
+            {
+                id: 'urgency-signal',
+                reason: 'Use urgency-signal to detect an explicit request for urgent attention.',
+            },
+        ],
+    },
+    {
+        id: 'handoff',
+        title: 'Check handoff rules',
+        description: 'Decide whether a request matches your human escalation rules.',
+        category: 'workflow',
+        tags: ['escalation', 'support', 'human'],
+        limitations: [
+            'Does not contact a person, execute actions, or enforce permissions.',
+            'Provide 1 to 50 rules with unique IDs; uncertain rules require review unless another rule confidently matches.',
+        ],
+        useWhen: 'You need to decide whether your escalation rules call for a human.',
+        related: [
+            { id: 'route', reason: 'Use route to choose a handler when escalation is not the decision.' },
+        ],
+    },
+    {
+        id: 'incident-match',
+        title: 'Match a known incident',
+        description: 'Which supplied incident is supported as a match for ticket?',
+        category: 'support',
+        tags: ['support', 'incident', 'match'],
+        limitations: [
+            'Matches only incidents supplied by the caller. Filter incident status, dates, affected regions, and exact versions in code first.',
+            'Supply 1 to 50 items per list, each with a unique non-empty ID and non-empty text.',
+        ],
+        useWhen: 'You need to connect a support ticket to a supplied known incident.',
+        related: [{ id: 'ticket-match', reason: 'Use ticket-match to compare two tickets directly.' }],
+    },
+    {
+        id: 'instruction-fit',
+        title: 'Check instruction applicability',
+        description: 'Does the explicit scope of instruction cover task and context?',
+        category: 'workflow',
+        tags: ['workflow', 'instruction', 'fit'],
+        limitations: [
+            'Checks semantic applicability. Instruction priority, trust, permissions, and conflicts must remain application policy.',
+        ],
+        useWhen: 'You need to check whether an instruction applies to the current task and context.',
+        related: [
+            {
+                id: 'action-scope',
+                reason: 'Use action-scope to check the boundaries of a proposed action.',
+            },
+        ],
+    },
+    {
+        id: 'intent-change',
+        title: 'Detect a change of intent',
+        description: 'How does message change currentGoal?',
+        category: 'conversation',
+        tags: ['conversation', 'intent', 'change'],
+        limitations: [
+            'Classifies a goal change. It does not rewrite the goal, alter a task queue, or measure exact requested limits.',
+        ],
+        useWhen: 'You need to check whether a new message changes the current task or goal.',
+        related: [
+            {
+                id: 'cancellation-check',
+                reason: 'Use cancellation-check for the narrower question of stopping, pausing, or continuing.',
+            },
+        ],
+    },
+    {
+        id: 'issue-impact',
+        title: 'Assess reported issue impact',
+        description: 'What practical impact does message explicitly describe?',
+        category: 'support',
+        tags: ['support', 'issue', 'impact'],
+        limitations: [
+            'Assesses reported impact, not verified system severity. Service commitments and escalation thresholds remain application rules.',
+        ],
+        useWhen: 'You need to assess the practical impact explicitly described in a support message.',
+        related: [
+            {
+                id: 'urgency-signal',
+                reason: 'Use urgency-signal to detect requests for immediate attention.',
+            },
+        ],
+    },
+    {
+        id: 'memory-relation',
+        title: 'Compare a new fact with memory',
+        description: 'How does newFact relate to existingMemory?',
+        category: 'memory',
+        tags: ['memory', 'relation'],
+        limitations: [
+            'Compares two supplied facts. It does not select a memory to overwrite or resolve conflicts by timestamp alone.',
+        ],
+        useWhen: 'You need to compare a new fact with an existing memory for agreement or change.',
+        related: [
+            {
+                id: 'memory-value',
+                reason: 'Use memory-value to assess usefulness before deciding how to store a fact.',
+            },
+        ],
+    },
+    {
+        id: 'memory-scope',
+        title: 'Identify memory scope',
+        description: 'What is the narrowest explicitly supported scope of fact in context?',
+        category: 'memory',
+        tags: ['memory', 'scope'],
+        limitations: [
+            'Identifies semantic scope. It does not identify a storage tenant, establish consent, or persist a memory.',
+        ],
+        useWhen: 'You need to identify the narrowest supported scope of a fact or preference.',
+        related: [
+            {
+                id: 'preference-kind',
+                reason: 'Use preference-kind to distinguish ongoing preferences from temporary instructions.',
+            },
+        ],
+    },
+    {
+        id: 'memory-value',
+        title: 'Assess a candidate memory',
+        description: 'How useful is fact for future work under purpose?',
+        category: 'memory',
+        tags: ['memory', 'value'],
+        limitations: [
+            'Assesses usefulness only. Storage consent, sensitive-data policy, retention, and deletion must be enforced separately.',
+        ],
+        useWhen: 'You need to assess whether a candidate fact is useful to remember for a stated purpose.',
+        related: [
+            { id: 'memory-scope', reason: 'Use memory-scope to determine where a fact applies.' },
+        ],
+    },
+    {
+        id: 'passage-duplicate',
+        title: 'Compare passages for duplication',
+        description: 'How much material information do firstPassage and secondPassage share?',
+        category: 'retrieval',
+        tags: ['retrieval', 'passage', 'duplicate', 'rag', 'evidence'],
+        limitations: [
+            'Compares a supplied pair. It does not search a corpus, cluster documents, or remove content.',
+        ],
+        useWhen: 'You want to detect duplicate or overlapping information in two passages.',
+        related: [
+            {
+                id: 'evidence-novelty',
+                reason: 'Use evidence-novelty to compare a passage with the evidence already collected.',
+            },
+        ],
+    },
+    {
+        id: 'preference-kind',
+        title: 'Identify a stated preference',
+        description: 'Does statement express an ongoing preference, a factual assertion, or a temporary request?',
+        category: 'memory',
+        tags: ['memory', 'preference', 'kind'],
+        limitations: [
+            'Classifies a statement. It does not infer unexpressed preferences or grant permission to store personal information.',
+        ],
+        useWhen: 'You need to distinguish an ongoing preference from a fact or temporary request.',
+        related: [
+            {
+                id: 'memory-scope',
+                reason: 'Use memory-scope to identify the supported scope of that preference.',
+            },
+        ],
+    },
+    {
+        id: 'promise-check',
+        title: 'Check reply commitments',
+        description: 'Does reply promise actions or outcomes beyond allowedCommitments?',
+        category: 'answer-quality',
+        tags: ['answer-quality', 'promise', 'check', 'rag', 'evidence'],
+        limitations: [
+            'Reviews expressed promises. It does not approve refunds, establish contractual obligations, or execute actions.',
+        ],
+        useWhen: 'You need to catch commitments in a reply that exceed what is allowed.',
+        related: [
+            {
+                id: 'action-scope',
+                reason: 'Use action-scope to check a proposed action against the requested work.',
+            },
+        ],
+    },
+    {
+        id: 'query-equivalence',
+        title: 'Compare question meaning',
+        description: 'Do firstQuestion and secondQuestion request the same information under the same stated conditions?',
+        category: 'retrieval',
+        tags: ['retrieval', 'query', 'equivalence', 'rag', 'evidence'],
+        limitations: [
+            'Compares supplied questions. It does not rewrite them or establish that an existing answer is still valid.',
+        ],
+        useWhen: 'You need to check whether two questions ask for the same information.',
+        related: [
+            {
+                id: 'cache-match',
+                reason: 'Use cache-match when deciding whether an existing answer can be reused.',
+            },
+        ],
+    },
+    {
+        id: 'query-specificity',
+        title: 'Check question specificity',
+        description: 'Does question, interpreted with context, identify a focused information need?',
+        category: 'retrieval',
+        tags: ['retrieval', 'query', 'specificity', 'rag', 'evidence'],
+        limitations: [
+            'Assesses focus only. Use clarify when the application has explicit required fields to check.',
+        ],
+        useWhen: 'You need to know whether a question identifies a focused information need.',
+        related: [
+            {
+                id: 'clarify',
+                reason: 'Use clarify to check named requirements for missing or ambiguous information.',
+            },
+        ],
+    },
+    {
+        id: 'reference-resolve',
+        title: 'Resolve a reference',
+        description: 'Which supplied candidate does reference refer to in message and context?',
+        category: 'conversation',
+        tags: ['conversation', 'reference', 'resolve'],
+        limitations: [
+            'Resolves a supplied reference among candidates. It does not extract references, verify identity, or authorize changes.',
+            'Supply 1 to 50 items per list, each with a unique non-empty ID and non-empty text.',
+        ],
+        useWhen: 'You need to resolve a phrase such as this one to a supplied candidate.',
+        related: [
+            {
+                id: 'correction-target',
+                reason: 'Use correction-target when the message corrects a particular field or statement.',
+            },
+        ],
+    },
+    {
+        id: 'repeated-attempt',
+        title: 'Compare attempted approaches',
+        description: 'Does proposedAttempt use essentially the same approach as previousAttempt for objective?',
+        category: 'workflow',
+        tags: ['workflow', 'repeated', 'attempt'],
+        limitations: [
+            'Compares two attempts only. Counting repeats, deciding whether a retry is justified, and stopping loops belong in application code.',
+        ],
+        useWhen: 'You need to detect whether a proposed retry repeats an earlier approach.',
+        related: [
+            {
+                id: 'step-progress',
+                reason: 'Use step-progress to assess what an attempted step actually changed.',
+            },
+        ],
+    },
+    {
+        id: 'reply-template-match',
+        title: 'Select a reply template',
+        description: 'Which supplied approved template applies to request and context?',
+        category: 'support',
+        tags: ['support', 'reply', 'template', 'match'],
+        limitations: [
+            'Selects a supplied template. It does not fill placeholders, approve its content, personalize it, or send a response.',
+            'Supply 1 to 50 items per list, each with a unique non-empty ID and non-empty text.',
+        ],
+        useWhen: 'You want to select a supplied approved reply template for a request.',
+        related: [
+            { id: 'route', reason: 'Use route to select a handler rather than a response template.' },
+        ],
+    },
+    {
+        id: 'rerank',
+        title: 'Rerank evidence',
+        description: 'Select candidate passages by relevance to a query.',
+        category: 'retrieval',
+        tags: ['rag', 'search', 'relevance'],
+        limitations: [
+            'Does not retrieve documents or establish source truth.',
+            'Provide 1 to 100 items with unique IDs.',
+        ],
+        useWhen: 'You have retrieved passages and want the most relevant evidence for a question.',
+        related: [
+            {
+                id: 'answerability',
+                reason: 'Use answerability to check whether the selected evidence is enough to answer.',
+            },
+        ],
+    },
+    {
+        id: 'resolution-check',
+        title: 'Check reported resolution',
+        description: 'Does message establish that the customer reports issue as resolved?',
+        category: 'conversation',
+        tags: ['conversation', 'resolution', 'check'],
+        limitations: [
+            'Interprets the customer report. It does not verify the system state, close a ticket, or treat courtesy alone as resolution.',
+        ],
+        useWhen: 'You need to know whether the customer reports that an issue is resolved.',
+        related: [
+            {
+                id: 'step-complete',
+                reason: 'Use step-complete to assess evidence against a supplied completion condition.',
+            },
+        ],
+    },
+    {
+        id: 'response-needed',
+        title: 'Check whether a reply is needed',
+        description: 'Does message require a substantive reply in context?',
+        category: 'conversation',
+        tags: ['conversation', 'response', 'needed'],
+        limitations: [
+            'Assesses conversational need. Channel-specific response obligations and customer service policies remain application rules.',
+        ],
+        useWhen: 'You need to decide whether a message calls for a substantive reply.',
+        related: [
+            {
+                id: 'turn-intent',
+                reason: 'Use turn-intent to classify the message purpose in more detail.',
+            },
+        ],
+    },
+    {
+        id: 'result-outcome',
+        title: 'Interpret a reported tool outcome',
+        description: 'What outcome does result report for task?',
+        category: 'workflow',
+        tags: ['workflow', 'result', 'outcome'],
+        limitations: [
+            'Interprets a report; it does not independently confirm an external action occurred. Prefer structured result fields when available.',
+        ],
+        useWhen: 'You need to classify what a tool result reports happened during a task.',
+        related: [
+            {
+                id: 'step-progress',
+                reason: 'Use step-progress to compare an observation with the previous state.',
+            },
+        ],
+    },
+    {
+        id: 'result-usefulness',
+        title: 'Check tool result usefulness',
+        description: 'Does result provide information useful for task?',
+        category: 'workflow',
+        tags: ['workflow', 'result', 'usefulness'],
+        limitations: [
+            'Assesses response content, not transport success or source truth. Handle empty bodies and status codes in code.',
+        ],
+        useWhen: 'You need to assess whether a tool result provides useful information for a task.',
+        related: [
+            {
+                id: 'result-outcome',
+                reason: 'Use result-outcome to classify the reported outcome rather than its usefulness.',
+            },
+        ],
+    },
+    {
+        id: 'retrieval-needed',
+        title: 'Check whether retrieval is needed',
+        description: 'Does request require facts beyond context?',
+        category: 'retrieval',
+        tags: ['retrieval', 'needed', 'rag', 'evidence'],
+        limitations: [
+            'Assesses information needs without searching. A no-retrieval decision does not establish source truth.',
+        ],
+        useWhen: 'You need to decide whether answering requires facts beyond the current context.',
+        related: [
+            {
+                id: 'freshness-needed',
+                reason: 'Use freshness-needed to check whether those facts must be current.',
+            },
+        ],
+    },
+    {
+        id: 'route',
+        title: 'Route a request',
+        description: 'Choose a named handler or return a review decision.',
+        category: 'workflow',
+        tags: ['routing', 'intent', 'dispatch'],
+        limitations: [
+            'Does not execute handlers or enforce access control.',
+            'Provide 1 to 254 routes; __review__ is reserved.',
+        ],
+        useWhen: 'You need to send a request to the right handler, team, or department.',
+        related: [
+            {
+                id: 'turn-intent',
+                reason: 'Use turn-intent to identify what a message is doing before choosing a handler.',
+            },
+        ],
+    },
+    {
+        id: 'source-applicability',
+        title: 'Check source applicability',
+        description: 'Does the scope described in passage apply to scenario?',
+        category: 'retrieval',
+        tags: ['retrieval', 'source', 'applicability', 'rag', 'evidence'],
+        limitations: [
+            'Assesses semantic scope. Enforce tenant, access, exact version, and region constraints in application code.',
+        ],
+        useWhen: 'You need to check whether the conditions and scope of a source fit a scenario.',
+        related: [
+            {
+                id: 'evidence-conflict',
+                reason: 'Use evidence-conflict to compare two applicable sources for disagreement.',
+            },
+        ],
+    },
+    {
+        id: 'step-complete',
+        title: 'Check one completion condition',
+        description: 'Does evidence establish that condition has been met?',
+        category: 'workflow',
+        tags: ['workflow', 'step', 'complete'],
+        limitations: [
+            'Assesses supplied evidence for one condition. Use exact system state checks when the condition can be determined in code.',
+        ],
+        useWhen: 'You need to check whether supplied evidence establishes a completion condition.',
+        related: [
+            {
+                id: 'result-outcome',
+                reason: 'Use result-outcome to interpret a tool result before checking completion.',
+            },
+        ],
+    },
+    {
+        id: 'step-progress',
+        title: 'Check step progress',
+        description: 'How does observation change progress toward objective relative to previousState?',
+        category: 'workflow',
+        tags: ['workflow', 'step', 'progress'],
+        limitations: [
+            'Compares one observation with a supplied prior state. It does not measure elapsed time or schedule the next step.',
+        ],
+        useWhen: 'You need to compare a new observation with the previous state of a task.',
+        related: [
+            {
+                id: 'step-complete',
+                reason: 'Use step-complete to check whether the completion condition has been met.',
+            },
+        ],
+    },
+    {
+        id: 'summary-coverage',
+        title: 'Check summary coverage',
+        description: 'Check whether a summary preserves each supplied point.',
+        category: 'answer-quality',
+        tags: ['answer-quality', 'summary', 'coverage', 'rag', 'evidence'],
+        limitations: [
+            'Checks the points you supply. It does not select important points from a transcript or detect unrelated invented statements.',
+            'Supply 1 to 50 items per list, each with a unique non-empty ID and non-empty text.',
+        ],
+        useWhen: 'You need to check whether a summary preserves each important source point.',
+        related: [
+            {
+                id: 'answer-coverage',
+                reason: 'Use answer-coverage when the checklist contains questions to answer.',
+            },
+        ],
+    },
+    {
+        id: 'ticket-match',
+        title: 'Compare support tickets',
+        description: 'Do firstTicket and secondTicket describe the same underlying reported issue?',
+        category: 'support',
+        tags: ['support', 'ticket', 'match'],
+        limitations: [
+            'Does not merge tickets or establish a shared root cause from similar symptoms alone. Compare exact identifiers in code.',
+        ],
+        useWhen: 'You want to check whether two tickets describe the same underlying issue.',
+        related: [
+            {
+                id: 'incident-match',
+                reason: 'Use incident-match to select a known incident for one ticket.',
+            },
+        ],
+    },
+    {
+        id: 'tone-check',
+        title: 'Check writing criteria',
+        description: 'Check a draft against each supplied writing criterion.',
+        category: 'answer-quality',
+        tags: ['answer-quality', 'tone', 'check', 'rag', 'evidence'],
+        limitations: [
+            'Checks supplied writing criteria. It does not rewrite text, determine factual accuracy, or check exact character counts.',
+            'Supply 1 to 50 items per list, each with a unique non-empty ID and non-empty text.',
+        ],
+        useWhen: 'You want to check a draft against a supplied set of writing criteria.',
+        related: [
+            {
+                id: 'draft-compare',
+                reason: 'Use draft-compare to choose between two drafts under a rubric.',
+            },
+        ],
+    },
+    {
+        id: 'tool-fit',
+        title: 'Check a tool fit',
+        description: 'Can the capabilities explicitly described in tool perform task?',
+        category: 'workflow',
+        tags: ['workflow', 'tool', 'fit'],
+        limitations: [
+            'Assesses a supplied capability description. It does not discover tools, validate credentials, or grant permission.',
+        ],
+        useWhen: 'You need to check whether a tool has the stated capability to perform a task.',
+        related: [
+            {
+                id: 'argument-fit',
+                reason: 'Use argument-fit to validate the meaning of a proposed tool argument.',
+            },
+        ],
+    },
+    {
+        id: 'topic-shift',
+        title: 'Detect a topic shift',
+        description: 'Does message stay with currentTopic, introduce a different topic, or contain both?',
+        category: 'conversation',
+        tags: ['conversation', 'topic', 'shift'],
+        limitations: [
+            'Compares one message with a supplied topic. It does not generate topic labels or split conversation threads.',
+        ],
+        useWhen: 'You need to detect whether a message moves away from the current topic.',
+        related: [
+            {
+                id: 'intent-change',
+                reason: 'Use intent-change when the important question is whether the goal changed.',
+            },
+        ],
+    },
+    {
+        id: 'troubleshooting-fit',
+        title: 'Check troubleshooting applicability',
+        description: 'Does procedure address symptoms under the described circumstances?',
+        category: 'support',
+        tags: ['support', 'troubleshooting', 'fit'],
+        limitations: [
+            'Assesses a supplied procedure; it does not diagnose a root cause, generate steps, or execute them.',
+        ],
+        useWhen: 'You need to choose whether a procedure fits the reported symptoms and circumstances.',
+        related: [
+            {
+                id: 'attempted-step',
+                reason: 'Use attempted-step to check whether that procedure has already been tried.',
+            },
+        ],
+    },
+    {
+        id: 'turn-intent',
+        title: 'Identify a conversation turn',
+        description: 'What is the primary communicative purpose of message in context?',
+        category: 'conversation',
+        tags: ['conversation', 'turn', 'intent'],
+        limitations: [
+            'Returns the primary purpose only. It does not split a message into separate requests or execute instructions.',
+        ],
+        useWhen: 'You need to classify a message as a request, answer, correction, cancellation, or acknowledgment.',
+        related: [
+            {
+                id: 'intent-change',
+                reason: 'Use intent-change to assess how the message changes an existing goal.',
+            },
+        ],
+    },
+    {
+        id: 'urgency-signal',
+        title: 'Detect an explicit urgency request',
+        description: 'Does message explicitly request urgent attention?',
+        category: 'support',
+        tags: ['support', 'urgency', 'signal'],
+        limitations: [
+            'Detects an expressed urgency request. Compute deadline proximity and apply incident or service priority rules in code.',
+        ],
+        useWhen: 'You need to detect whether a message explicitly asks for urgent attention.',
+        related: [
+            {
+                id: 'issue-impact',
+                reason: 'Use issue-impact to assess the reported practical consequences.',
+            },
+        ],
+    },
+    {
+        id: 'verify',
+        title: 'Verify claims',
+        description: 'Check each supplied claim against its paired evidence.',
+        category: 'retrieval',
+        tags: ['rag', 'grounding', 'claims'],
+        limitations: [
+            'Checks only supplied claims; does not establish source truth or completeness.',
+            'Provide 1 to 100 claims with unique IDs.',
+        ],
+        useWhen: 'You need to know whether a claim is supported by its supplied evidence.',
+        related: [
+            {
+                id: 'citation-match',
+                reason: 'Use citation-match to select which passages support one claim.',
+            },
+        ],
+    },
+    {
+        id: 'workaround-fit',
+        title: 'Check workaround fit',
+        description: 'Can workaround address issue without violating constraints?',
+        category: 'support',
+        tags: ['support', 'workaround', 'fit'],
+        limitations: [
+            'Assesses described compatibility. It does not establish operational safety, execute a workaround, or grant access.',
+        ],
+        useWhen: 'You need to check whether a workaround addresses an issue within the stated constraints.',
+        related: [
+            {
+                id: 'troubleshooting-fit',
+                reason: 'Use troubleshooting-fit to assess a diagnostic procedure rather than a workaround.',
+            },
+        ],
+    },
+];