jev-recipes 0.8.0 → 0.8.2

package/dist/catalog/generated/names.d.ts

@@ -1 +1 @@
-export declare const recipeNames: readonly ["action-compare", "action-effects", "action-reversibility", "action-scope", "age-appropriateness", "alert-actionability", "answer-consistency", "answer-coverage", "answer-disclosures", "answer-grade", "answer-invalidation", "answer-relevance", "answerability", "appeal-grounds-kind", "appointment-request-kind", "argument-fit", "attempted-step", "attribution-match", "audience-fit", "breaking-change-signal", "budget-fit", "budget-narrative-fit", "bug-report-completeness", "buying-intent", "cache-match", "callback-responsibility", "cancellation-check", "care-urgency-wording", "category-fit", "causal-attribution", "causal-language-strength", "certainty-match", "change-meaning", "change-risk", "change-window-fit", "checkers-move", "choose-action", "citation-match", "citation-needed", "claim-facets", "claim-stance", "clarify", "clause-conflict", "clause-kind", "clickbait-level", "commit-message-fit", "commitment-strength", "comparable-fit", "completion-gate", "confirmation-match", "consent-request", "consent-scope-fit", "constraint-strength", "contact-opt-out", "content-facets", "content-freshness-signal", "context-prune", "context-role", "continuation-compare", "correction-target", "corrective-action-fit", "daw-request-kind", "deadline-risk", "defect-report-facets", "delegation-fit", "diff-hazards", "disclosure-facets", "dispute-kind", "document-role", "draft-compare", "dynamic-change", "eligibility-facets", "emotion-kind", "entity-match", "error-acknowledgment", "escalation-wording", "evaluation-mention", "evidence-conflict", "evidence-independence", "evidence-novelty", "evidence-strength", "exercise-select", "expense-category", "explanation-level", "extraction-fidelity", "fact-stability", "failure-kind", "fair-housing-wording", "feedback-actionability", "feedback-kind", "field-select", "financial-advice-signal", "finger-actions", "followup-link", "followup-timing", "forecast-confidence-wording", "format-fit", "freshness-needed", "frustration-signal", "funder-fit", "game-action", "game-phase", "goal-drift", "grounding-level", "guest-request-facets", "handoff", "handoff-completeness", "headline-fit", "incident-match", "incident-severity-wording", "injection-signal", "instruction-clarity", "instruction-conflict", "instruction-fit", "instruction-priority", "instruction-readability", "instrument-issue-kind", "instrument-report-facets", "intake-question-fit", "intent-change", "invoice-facets", "issue-impact", "issue-recurrence", "itinerary-feasibility", "job-post-facets", "length-fit", "listener-request-kind", "listing-compare", "listing-fact-consistency", "log-line-kind", "loss-cause-kind", "lyric-mood-fit", "maintenance-hazard-wording", "medication-mention", "memory-relation", "memory-scope", "memory-subject", "memory-value", "message-facets", "methods-facets", "model-route", "modulation-moment", "mood-match", "mood-request", "motivation-source", "move-explanation-fit", "narrative-consistency", "next-chord", "next-duration", "next-note", "notice-facets", "novelty-claim-level", "objection-kind", "objective-fit", "offer-terms-facets", "outcome-framing", "passage-compare", "passage-difficulty", "passage-duplicate", "passage-mood", "passage-standalone", "performance-feedback-facets", "persuasion-technique", "phrase-complete", "pii-presence", "plan-completeness", "policy-compliance", "policy-severity", "politeness-level", "postmortem-facets", "preference-kind", "priority-compare", "privacy-notice-facets", "product-match", "progress-stall", "promise-check", "proposal-facets", "qualification-evidence", "query-equivalence", "query-specificity", "question-assumption", "question-leading", "question-relevance", "reconciliation-match", "reference-resolve", "repeated-attempt", "repetition-level", "reply-template-match", "report-facets", "requirement-testability", "rerank", "resolution-check", "response-needed", "response-refusal", "result-outcome", "result-plausibility", "result-usefulness", "retrieval-needed", "retry-worthwhile", "review-comment-kind", "review-facets", "review-recommendation-kind", "review-response-fit", "rollback-signal", "root-cause-depth", "route", "route-many", "rule-compliance", "runbook-fit", "safety-incident-kind", "satisfaction-signal", "search-intent-kind", "sentiment-shift", "settlement-offer-facets", "shipment-issue-kind", "slot-fit", "sound-match", "source-applicability", "spam-signal", "stage-evidence", "step-complete", "step-progress", "style-kind", "summary-coverage", "symptom-facets", "take-turn", "task-complexity", "task-dependency", "task-duplicate", "task-overlap", "tempo-change", "tension-level", "ticket-match", "tone-check", "tool-call-gate", "tool-compare", "tool-fit", "topic-shift", "trip-purpose-kind", "troubleshooting-fit", "turn-intent", "uncertainty-expression", "urgency-signal", "verify", "wake-gate", "workaround-fit"];
+export declare const recipeNames: readonly ["action-compare", "action-effects", "action-reversibility", "action-scope", "age-appropriateness", "alert-actionability", "answer-consistency", "answer-coverage", "answer-disclosures", "answer-grade", "answer-invalidation", "answer-relevance", "answerability", "appeal-grounds-kind", "appointment-request-kind", "argument-fit", "attempted-step", "attribution-match", "audience-fit", "breaking-change-signal", "budget-fit", "budget-narrative-fit", "bug-report-completeness", "buying-intent", "cache-match", "callback-responsibility", "cancellation-check", "care-urgency-wording", "category-fit", "causal-attribution", "causal-language-strength", "certainty-match", "change-meaning", "change-risk", "change-window-fit", "checkers-move", "choose-action", "citation-match", "citation-needed", "claim-facets", "claim-stance", "clarify", "clause-conflict", "clause-kind", "clickbait-level", "commit-message-fit", "commitment-strength", "comparable-fit", "completion-gate", "confirmation-match", "consent-request", "consent-scope-fit", "constraint-strength", "contact-opt-out", "content-facets", "content-freshness-signal", "context-prune", "context-role", "continuation-compare", "correction-target", "corrective-action-fit", "daw-request-kind", "deadline-risk", "defect-report-facets", "delegation-fit", "diff-hazards", "disclosure-facets", "dispute-kind", "document-role", "draft-compare", "dynamic-change", "eligibility-facets", "emotion-kind", "entity-match", "error-acknowledgment", "escalation-wording", "evaluation-mention", "evidence-conflict", "evidence-independence", "evidence-novelty", "evidence-strength", "exercise-select", "expense-category", "explanation-level", "extraction-fidelity", "fact-stability", "failure-kind", "fair-housing-wording", "feedback-actionability", "feedback-kind", "field-select", "financial-advice-signal", "finger-actions", "followup-link", "followup-timing", "forecast-confidence-wording", "format-fit", "freshness-needed", "frustration-signal", "funder-fit", "game-action", "game-phase", "goal-drift", "grounding-level", "guest-request-facets", "handoff", "handoff-completeness", "headline-fit", "incident-match", "incident-severity-wording", "injection-signal", "instruction-clarity", "instruction-conflict", "instruction-fit", "instruction-priority", "instruction-readability", "instrument-issue-kind", "instrument-report-facets", "intake-question-fit", "intent-change", "invoice-facets", "issue-impact", "issue-recurrence", "itinerary-feasibility", "job-post-facets", "length-fit", "listener-request-kind", "listing-compare", "listing-fact-consistency", "log-line-kind", "loss-cause-kind", "lyric-mood-fit", "maintenance-hazard-wording", "medication-mention", "memory-relation", "memory-scope", "memory-subject", "memory-value", "message-facets", "methods-facets", "model-route", "modulation-moment", "mood-match", "mood-request", "motivation-source", "move-explanation-fit", "narrative-consistency", "next-chord", "next-duration", "next-note", "notice-facets", "novelty-claim-level", "objection-kind", "objective-fit", "offer-terms-facets", "outcome-framing", "paragraph-boundary", "passage-compare", "passage-difficulty", "passage-duplicate", "passage-mood", "passage-standalone", "performance-feedback-facets", "persuasion-technique", "phrase-complete", "pii-presence", "plan-completeness", "policy-compliance", "policy-severity", "politeness-level", "postmortem-facets", "preference-kind", "priority-compare", "privacy-notice-facets", "product-match", "progress-stall", "promise-check", "proposal-facets", "qualification-evidence", "query-equivalence", "query-specificity", "question-assumption", "question-leading", "question-relevance", "reconciliation-match", "reference-resolve", "repeated-attempt", "repetition-level", "reply-template-match", "report-facets", "requirement-testability", "rerank", "resolution-check", "response-needed", "response-refusal", "result-outcome", "result-plausibility", "result-usefulness", "retrieval-needed", "retry-worthwhile", "review-comment-kind", "review-facets", "review-recommendation-kind", "review-response-fit", "rollback-signal", "root-cause-depth", "route", "route-many", "rule-compliance", "runbook-fit", "safety-incident-kind", "satisfaction-signal", "search-intent-kind", "sentiment-shift", "settlement-offer-facets", "shipment-issue-kind", "slot-fit", "sound-match", "source-applicability", "spam-signal", "stage-evidence", "step-complete", "step-progress", "style-kind", "summary-coverage", "symptom-facets", "take-turn", "task-complexity", "task-dependency", "task-duplicate", "task-overlap", "tempo-change", "tension-level", "text-block-role", "ticket-match", "tone-check", "tool-call-gate", "tool-compare", "tool-fit", "topic-shift", "trip-purpose-kind", "troubleshooting-fit", "turn-intent", "uncertainty-expression", "urgency-signal", "verify", "wake-gate", "workaround-fit"];

package/dist/catalog/generated/names.js

@@ -156,6 +156,7 @@ export const recipeNames = [
     'objective-fit',
     'offer-terms-facets',
     'outcome-framing',
+    'paragraph-boundary',
     'passage-compare',
     'passage-difficulty',
     'passage-duplicate',
@@ -232,6 +233,7 @@ export const recipeNames = [
     'task-overlap',
     'tempo-change',
     'tension-level',
+    'text-block-role',
     'ticket-match',
     'tone-check',
     'tool-call-gate',

package/dist/catalog/index.d.ts

@@ -1,7 +1,9 @@
 import type { RecipeMetadata } from '../src/schema.js';
 import type { RecipeFilters, RecipeName } from './schema.js';
+import type { RecipeEvidence } from './evidence.js';
 export type CatalogRecipe = RecipeMetadata & {
     id: RecipeName;
+    evidence?: RecipeEvidence;
 };
 export type RecipeDescription = CatalogRecipe & {
     inputSchema: Record<string, unknown>;
@@ -13,3 +15,4 @@ export { recipeFiltersSchema, recipeNameSchema } from './schema.js';
 export { recipeCategorySchema, recipeMetadataSchema } from '../src/schema.js';
 export type { RecipeFilters, RecipeName } from './schema.js';
 export type { RecipeCategory, RecipeMetadata } from '../src/schema.js';
+export type { RecipeEvidence } from './evidence.js';

package/dist/catalog/schema.d.ts

@@ -156,6 +156,7 @@ export declare const recipeNameSchema: z.ZodEnum<{
     "objective-fit": "objective-fit";
     "offer-terms-facets": "offer-terms-facets";
     "outcome-framing": "outcome-framing";
+    "paragraph-boundary": "paragraph-boundary";
     "passage-compare": "passage-compare";
     "passage-difficulty": "passage-difficulty";
     "passage-duplicate": "passage-duplicate";
@@ -232,6 +233,7 @@ export declare const recipeNameSchema: z.ZodEnum<{
     "task-overlap": "task-overlap";
     "tempo-change": "tempo-change";
     "tension-level": "tension-level";
+    "text-block-role": "text-block-role";
     "ticket-match": "ticket-match";
     "tone-check": "tone-check";
     "tool-call-gate": "tool-call-gate";

package/dist/cli/schema.d.ts

@@ -159,6 +159,7 @@ export declare const commandArgumentsSchema: z.ZodUnion<readonly [z.ZodTuple<[z.
     "objective-fit": "objective-fit";
     "offer-terms-facets": "offer-terms-facets";
     "outcome-framing": "outcome-framing";
+    "paragraph-boundary": "paragraph-boundary";
     "passage-compare": "passage-compare";
     "passage-difficulty": "passage-difficulty";
     "passage-duplicate": "passage-duplicate";
@@ -235,6 +236,7 @@ export declare const commandArgumentsSchema: z.ZodUnion<readonly [z.ZodTuple<[z.
     "task-overlap": "task-overlap";
     "tempo-change": "tempo-change";
     "tension-level": "tension-level";
+    "text-block-role": "text-block-role";
     "ticket-match": "ticket-match";
     "tone-check": "tone-check";
     "tool-call-gate": "tool-call-gate";
@@ -409,6 +411,7 @@ export declare const commandArgumentsSchema: z.ZodUnion<readonly [z.ZodTuple<[z.
     "objective-fit": "objective-fit";
     "offer-terms-facets": "offer-terms-facets";
     "outcome-framing": "outcome-framing";
+    "paragraph-boundary": "paragraph-boundary";
     "passage-compare": "passage-compare";
     "passage-difficulty": "passage-difficulty";
     "passage-duplicate": "passage-duplicate";
@@ -485,6 +488,7 @@ export declare const commandArgumentsSchema: z.ZodUnion<readonly [z.ZodTuple<[z.
     "task-overlap": "task-overlap";
     "tempo-change": "tempo-change";
     "tension-level": "tension-level";
+    "text-block-role": "text-block-role";
     "ticket-match": "ticket-match";
     "tone-check": "tone-check";
     "tool-call-gate": "tool-call-gate";
@@ -656,6 +660,7 @@ export declare const commandArgumentsSchema: z.ZodUnion<readonly [z.ZodTuple<[z.
     "objective-fit": "objective-fit";
     "offer-terms-facets": "offer-terms-facets";
     "outcome-framing": "outcome-framing";
+    "paragraph-boundary": "paragraph-boundary";
     "passage-compare": "passage-compare";
     "passage-difficulty": "passage-difficulty";
     "passage-duplicate": "passage-duplicate";
@@ -732,6 +737,7 @@ export declare const commandArgumentsSchema: z.ZodUnion<readonly [z.ZodTuple<[z.
     "task-overlap": "task-overlap";
     "tempo-change": "tempo-change";
     "tension-level": "tension-level";
+    "text-block-role": "text-block-role";
     "ticket-match": "ticket-match";
     "tone-check": "tone-check";
     "tool-call-gate": "tool-call-gate";

package/dist/evaluation/archive.d.ts

@@ -8,8 +8,8 @@ declare const archiveSchema: z.ZodObject<{
     runId: z.ZodString;
     createdAt: z.ZodISODateTime;
     mode: z.ZodEnum<{
-        live: "live";
         fixture: "fixture";
+        live: "live";
         replay: "replay";
     }>;
     packageVersion: z.ZodString;
@@ -19,8 +19,8 @@ declare const archiveSchema: z.ZodObject<{
     inputFingerprint: z.ZodString;
     answerKeyFingerprint: z.ZodString;
     split: z.ZodEnum<{
-        development: "development";
         "held-out": "held-out";
+        development: "development";
     }>;
     requestedModel: z.ZodString;
     policy: z.ZodObject<{
@@ -48,15 +48,15 @@ declare const archiveSchema: z.ZodObject<{
         rationale: z.ZodString;
         family: z.ZodOptional<z.ZodString>;
         split: z.ZodDefault<z.ZodEnum<{
-            development: "development";
             "held-out": "held-out";
+            development: "development";
         }>>;
         provenance: z.ZodDefault<z.ZodObject<{
             method: z.ZodEnum<{
-                "author-synthetic": "author-synthetic";
-                "human-reviewed": "human-reviewed";
                 "public-dataset": "public-dataset";
+                "human-reviewed": "human-reviewed";
                 unspecified: "unspecified";
+                "author-synthetic": "author-synthetic";
             }>;
             source: z.ZodString;
         }, z.core.$strip>>;
@@ -107,7 +107,7 @@ export declare function freezePolicy(run: EvaluationRun): EvaluationPolicy;
 export declare function compare(baseline: EvaluationRun, candidate: EvaluationRun): {
     recipe: string;
     cases: number;
-    split: "development" | "held-out";
+    split: "held-out" | "development";
     baseline: {
         runId: string;
         packageVersion: string;
@@ -124,7 +124,7 @@ export declare function compare(baseline: EvaluationRun, candidate: EvaluationRu
                 split: "development";
             } | undefined;
         };
-        mode: "live" | "fixture" | "replay";
+        mode: "fixture" | "live" | "replay";
         report: {
             contestedAccuracy: number | null;
             adversarialAccuracy: number | null;
@@ -309,7 +309,7 @@ export declare function compare(baseline: EvaluationRun, candidate: EvaluationRu
                 split: "development";
             } | undefined;
         };
-        mode: "live" | "fixture" | "replay";
+        mode: "fixture" | "live" | "replay";
         report: {
             contestedAccuracy: number | null;
             adversarialAccuracy: number | null;

package/dist/evaluation/decisions.js

@@ -13,7 +13,7 @@ export function comparableDecision(value) {
         return value.map(comparableDecision);
     if (isRecord(value))
         return Object.fromEntries(Object.entries(value)
-            .filter(([name, field]) => !metadataFields.has(name) && typeof field !== 'number')
+            .filter(([name]) => !metadataFields.has(name))
             .map(([name, field]) => [name, comparableDecision(field)]));
     return value;
 }

package/dist/evaluation/schema.d.ts

@@ -1,10 +1,10 @@
 import { z } from 'zod';
 export declare const provenanceSchema: z.ZodObject<{
     method: z.ZodEnum<{
-        "author-synthetic": "author-synthetic";
-        "human-reviewed": "human-reviewed";
         "public-dataset": "public-dataset";
+        "human-reviewed": "human-reviewed";
         unspecified: "unspecified";
+        "author-synthetic": "author-synthetic";
     }>;
     source: z.ZodString;
 }, z.core.$strip>;
@@ -15,15 +15,15 @@ export declare const evaluationCaseSchema: z.ZodObject<{
     rationale: z.ZodString;
     family: z.ZodOptional<z.ZodString>;
     split: z.ZodDefault<z.ZodEnum<{
-        development: "development";
         "held-out": "held-out";
+        development: "development";
     }>>;
     provenance: z.ZodDefault<z.ZodObject<{
         method: z.ZodEnum<{
-            "author-synthetic": "author-synthetic";
-            "human-reviewed": "human-reviewed";
             "public-dataset": "public-dataset";
+            "human-reviewed": "human-reviewed";
             unspecified: "unspecified";
+            "author-synthetic": "author-synthetic";
         }>;
         source: z.ZodString;
     }, z.core.$strip>>;
@@ -54,8 +54,8 @@ export declare const evaluationOptionsSchema: z.ZodObject<{
     maxRequests: z.ZodDefault<z.ZodNumber>;
     model: z.ZodOptional<z.ZodString>;
     split: z.ZodDefault<z.ZodEnum<{
-        development: "development";
         "held-out": "held-out";
+        development: "development";
     }>>;
     policy: z.ZodDefault<z.ZodObject<{
         minConfidence: z.ZodOptional<z.ZodNumber>;

package/dist/recipes/action-effects/index.js

@@ -4,35 +4,35 @@ export async function actionEffects(input, options = {}) {
     const { minConfidence = 0.8, ...state } = actionEffectsInputSchema.parse(input);
     const evaluation = await evaluateLabels(state, {
         writesData: {
-            instruction: 'Does action create or modify stored data, such as records, files, settings, or state, without merely deleting it?',
+            instruction: 'Does executing action itself create or modify stored data, such as records, files, settings, or state, without merely deleting it? If action only explains, quotes, simulates, or proposes another operation without executing it, do not attribute that other operation’s effects to action.',
             criteria: {
                 true: 'The action creates, updates, or overwrites stored records, files, fields, or configuration.',
                 false: 'The action only reads, computes, sends, deletes, or does nothing to stored data.',
             },
         },
         sendsMessage: {
-            instruction: 'Does action send a message or notification to a person or channel, such as an email, chat message, SMS, push notification, or post?',
+            instruction: 'Does executing action itself send a message or notification to a person or channel, such as an email, chat message, SMS, push notification, or post? Ignore effects of operations that action only describes or proposes without executing.',
             criteria: {
                 true: 'The action transmits a message or notification that a person or channel will receive.',
                 false: 'The action sends nothing that a person or channel would receive as a message.',
             },
         },
         spendsMoney: {
-            instruction: 'Does action spend, transfer, refund, or otherwise move money or paid credits?',
+            instruction: 'Does executing action itself spend, transfer, refund, or otherwise move money or paid credits? Ignore effects of operations that action only describes or proposes without executing.',
             criteria: {
                 true: 'The action makes a purchase, payment, transfer, refund, or charge, or consumes paid credits the description names.',
                 false: 'The action moves no money and consumes no paid credits that the description names.',
             },
         },
         deletesData: {
-            instruction: 'Does action delete, remove, drop, or purge stored data, records, files, or resources?',
+            instruction: 'Does executing action itself delete, remove, drop, or purge stored data, records, files, or resources? Ignore effects of operations that action only describes or proposes without executing.',
             criteria: {
                 true: 'The action removes stored data, records, files, or resources so they no longer exist in their current location.',
                 false: 'The action removes nothing; archiving or marking as inactive without removal does not count.',
             },
         },
         callsExternal: {
-            instruction: "Does action call a service outside the system running the agent, such as a third-party API, a web request, or another vendor's platform?",
+            instruction: "Does executing action itself call a service outside the system running the agent, such as a third-party API, a web request, or another vendor's platform? Ignore external calls that action only describes without making them.",
             criteria: {
                 true: "The action contacts a third-party API, external web endpoint, or another organization's service.",
                 false: "The action stays within the system's own data and code with no outbound call to an external service.",

package/dist/recipes/causal-attribution/schema.d.ts

@@ -2,9 +2,9 @@ import { z } from 'zod';
 export declare const causalAttributionVerdictSchema: z.ZodEnum<{
     none: "none";
     unclear: "unclear";
+    mixed: "mixed";
     personal: "personal";
     situational: "situational";
-    mixed: "mixed";
 }>;
 export declare const causalAttributionInputSchema: z.ZodObject<{
     behavior: z.ZodString;
@@ -25,17 +25,17 @@ export declare const causalAttributionResultSchema: z.ZodObject<{
     verdict: z.ZodEnum<{
         none: "none";
         unclear: "unclear";
+        mixed: "mixed";
         personal: "personal";
         situational: "situational";
-        mixed: "mixed";
     }>;
     confidence: z.ZodNumber;
     probabilities: z.ZodRecord<z.ZodEnum<{
         none: "none";
         unclear: "unclear";
+        mixed: "mixed";
         personal: "personal";
         situational: "situational";
-        mixed: "mixed";
     }>, z.ZodNumber>;
 }, z.core.$strip>;
 export type CausalAttributionInput = z.infer<typeof causalAttributionInputSchema>;

package/dist/recipes/completion-gate/index.js

@@ -3,11 +3,11 @@ import { resolveLabels } from '../../src/labels.js';
 import { completionGateInputSchema, completionGateResultSchema } from './schema.js';
 export async function completionGate(input, options = {}) {
     const { minConfidence = 0.8, ...state } = completionGateInputSchema.parse(input);
-    const decision = await evaluateChoiceWithLabels(state, 'An agent was given task and has stopped with report as its final message. Is the task actually done? Use evidence, when supplied, as the record of what happened, such as test output, diffs, or the transcript; the report alone is a claim, not proof. Count the task complete only when every part of it is shown done. Count it incomplete when any part is missing, deferred, skipped, or failed, including parts the report quietly drops. Count it unverified when the report claims completion but nothing supplied demonstrates it. Choose unclear only when task or report cannot be understood well enough to judge, such as a task with no identifiable requirement or a report with no readable content; a report that addresses different work than the task, or that points to material not supplied, is unverified, not unclear.', {
+    const decision = await evaluateChoiceWithLabels(state, 'Judge whether task is complete using report and supplied evidence. First determine what task requires: choose unclear if an unresolved reference, missing specification, or conflicting requirement prevents identifying the required deliverable. Do not invent that requirement or mark an unknown requirement as failed. For a clear task, choose incomplete if supplied material shows a required part was skipped, deferred, narrowed, or failed. Choose unverified if completion is claimed but no supplied evidence demonstrates it. Choose complete only when supplied evidence demonstrates every identifiable requirement. Missing proof for a clear requirement is unverified; missing information needed to identify the requirement is unclear.', {
         complete: 'Every part of the task is shown to be done.',
         incomplete: 'Some part of the task is missing, deferred, narrowed, or failed, whether or not the report admits it.',
         unverified: 'The report claims the task is done, but the supplied material does not demonstrate it.',
-        unclear: 'The task or the report cannot be understood well enough to judge; not merely that proof is missing.',
+        unclear: 'A missing specification, unresolved reference, or conflict prevents identifying what would satisfy the task; not merely missing proof for a clear requirement.',
     }, {
         claimsWithoutEvidence: {
             instruction: 'Does report assert results, such as passing tests, a working feature, or a verified fix, that evidence does not show, or that nothing supplied shows when evidence is absent?',

package/dist/recipes/context-prune/index.js

@@ -9,9 +9,9 @@ export async function contextPrune(input, options = {}) {
         state: parseDecisionState(state),
         questions: Object.fromEntries(state.items.map((_, index) => [
             `item_${index}`,
-            noul(asDecisionInstruction(`Will items[${index}].text still be needed to finish objective? Count it needed when it holds facts, results, decisions, errors, or user instructions the remaining work depends on, or when it is the only record of something that must not be redone. Do not count it needed merely because it was useful earlier, is long, or is recent; use recent, when supplied, for what has already been handled. Judge only this item.`), {
-                true: 'The remaining work depends on this item.',
-                false: 'The remaining work can proceed without this item.',
+            noul(asDecisionInstruction(`Will items[${index}].text still be needed to finish objective? Count it needed when it holds facts, results, decisions, errors, or user instructions the remaining work depends on, or when it is the only record of something that must not be redone. Do not count it needed merely because it was useful earlier, is long, or is recent; use recent, when supplied, for what has already been handled. Keep active user constraints even if they were stated early. Drop an obsolete value only when the supplied state explicitly replaces it and the old value has no remaining purpose. Completing one step does not make its result irrelevant when a later step depends on it. Judge only this item.`), {
+                true: 'This item is an active requirement, relevant fact or result, unresolved error, or unique record the unfinished objective still needs.',
+                false: 'This item is unrelated, explicitly superseded, or records completed work whose details are not needed again.',
             }),
         ])),
     }, options);

package/dist/recipes/motivation-source/schema.d.ts

@@ -1,9 +1,9 @@
 import { z } from 'zod';
 export declare const motivationSourceVerdictSchema: z.ZodEnum<{
     unclear: "unclear";
+    mixed: "mixed";
     intrinsic: "intrinsic";
     extrinsic: "extrinsic";
-    mixed: "mixed";
     not_stated: "not_stated";
 }>;
 export declare const motivationSourceInputSchema: z.ZodObject<{
@@ -24,17 +24,17 @@ export declare const motivationSourceResultSchema: z.ZodObject<{
     }>;
     verdict: z.ZodEnum<{
         unclear: "unclear";
+        mixed: "mixed";
         intrinsic: "intrinsic";
         extrinsic: "extrinsic";
-        mixed: "mixed";
         not_stated: "not_stated";
     }>;
     confidence: z.ZodNumber;
     probabilities: z.ZodRecord<z.ZodEnum<{
         unclear: "unclear";
+        mixed: "mixed";
         intrinsic: "intrinsic";
         extrinsic: "extrinsic";
-        mixed: "mixed";
         not_stated: "not_stated";
     }>, z.ZodNumber>;
 }, z.core.$strip>;

package/dist/recipes/paragraph-boundary/demo.json

@@ -0,0 +1,19 @@
+{
+  "input": {
+    "left": "To finish installing the package, run",
+    "right": "the command shown in the next example.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": {
+      "decision": {
+        "type": "choice",
+        "choice": "continue",
+        "confidence": 0.96,
+        "probabilities": { "continue": 0.96, "separate": 0.02, "unclear": 0.02 }
+      }
+    },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/paragraph-boundary/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { ParagraphBoundaryInput, ParagraphBoundaryResult } from './schema.js';
+export declare function paragraphBoundary(input: ParagraphBoundaryInput, options?: RecipeOptions): Promise<ParagraphBoundaryResult>;
+export { paragraphBoundaryInputSchema, paragraphBoundaryResultSchema, paragraphBoundaryVerdictSchema, } from './schema.js';
+export type { ParagraphBoundaryInput, ParagraphBoundaryResult, ParagraphBoundaryVerdict, } from './schema.js';

package/dist/recipes/paragraph-boundary/index.js

@@ -0,0 +1,15 @@
+import { evaluateChoice } from '../../src/decisions.js';
+import { paragraphBoundaryInputSchema, paragraphBoundaryResultSchema } from './schema.js';
+export async function paragraphBoundary(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = paragraphBoundaryInputSchema.parse(input);
+    const decision = await evaluateChoice(state, 'Do left and right continue the same prose paragraph, or should the boundary between them remain? The fragments are already in reading order. Choose continue for a hard line wrap within one paragraph. Choose separate for a heading, list item, table, code, poetry line, or a distinct paragraph, even when the subject stays the same. Similar vocabulary alone is not evidence of continuation. Use neighbors and context only to resolve this boundary. Choose unclear when both interpretations remain plausible.', {
+        continue: 'The right fragment continues the same prose paragraph interrupted by a line wrap.',
+        separate: 'The fragments belong to separate paragraphs or structural blocks and the boundary must remain.',
+        unclear: 'The supplied text does not establish whether this is a line wrap or a real boundary.',
+    }, options);
+    return paragraphBoundaryResultSchema.parse({
+        ...decision,
+        status: decision.confidence < minConfidence || decision.verdict === 'unclear' ? 'review' : 'ready',
+    });
+}
+export { paragraphBoundaryInputSchema, paragraphBoundaryResultSchema, paragraphBoundaryVerdictSchema, } from './schema.js';

package/dist/recipes/paragraph-boundary/schema.d.ts

@@ -0,0 +1,39 @@
+import { z } from 'zod';
+export declare const paragraphBoundaryVerdictSchema: z.ZodEnum<{
+    unclear: "unclear";
+    continue: "continue";
+    separate: "separate";
+}>;
+export declare const paragraphBoundaryInputSchema: z.ZodObject<{
+    left: z.ZodString;
+    right: z.ZodString;
+    before: z.ZodOptional<z.ZodString>;
+    after: z.ZodOptional<z.ZodString>;
+    context: z.ZodOptional<z.ZodString>;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const paragraphBoundaryResultSchema: z.ZodObject<{
+    model: z.ZodString;
+    usage: z.ZodObject<{
+        input_tokens: z.ZodNumber;
+        output_tokens: z.ZodNumber;
+    }, z.core.$strip>;
+    status: z.ZodEnum<{
+        ready: "ready";
+        review: "review";
+    }>;
+    verdict: z.ZodEnum<{
+        unclear: "unclear";
+        continue: "continue";
+        separate: "separate";
+    }>;
+    confidence: z.ZodNumber;
+    probabilities: z.ZodRecord<z.ZodEnum<{
+        unclear: "unclear";
+        continue: "continue";
+        separate: "separate";
+    }>, z.ZodNumber>;
+}, z.core.$strip>;
+export type ParagraphBoundaryVerdict = z.infer<typeof paragraphBoundaryVerdictSchema>;
+export type ParagraphBoundaryInput = z.infer<typeof paragraphBoundaryInputSchema>;
+export type ParagraphBoundaryResult = z.infer<typeof paragraphBoundaryResultSchema>;

package/dist/recipes/paragraph-boundary/schema.js

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import { decisionStatusSchema, nonEmptyText, probability, resultMetadataSchema, } from '../../src/schema.js';
+export const paragraphBoundaryVerdictSchema = z.enum(['continue', 'separate', 'unclear']);
+export const paragraphBoundaryInputSchema = z.object({
+    left: nonEmptyText,
+    right: nonEmptyText,
+    before: nonEmptyText.optional(),
+    after: nonEmptyText.optional(),
+    context: nonEmptyText.optional(),
+    minConfidence: probability.optional(),
+});
+export const paragraphBoundaryResultSchema = resultMetadataSchema.extend({
+    status: decisionStatusSchema,
+    verdict: paragraphBoundaryVerdictSchema,
+    confidence: probability,
+    probabilities: z.record(paragraphBoundaryVerdictSchema, probability),
+});

package/dist/recipes/response-refusal/schema.d.ts

@@ -1,8 +1,8 @@
 import { z } from 'zod';
 export declare const responseRefusalVerdictSchema: z.ZodEnum<{
     unclear: "unclear";
-    attempted: "attempted";
     mixed: "mixed";
+    attempted: "attempted";
     not_addressed: "not_addressed";
     refused: "refused";
     unable: "unable";
@@ -25,8 +25,8 @@ export declare const responseRefusalResultSchema: z.ZodObject<{
     }>;
     verdict: z.ZodEnum<{
         unclear: "unclear";
-        attempted: "attempted";
         mixed: "mixed";
+        attempted: "attempted";
         not_addressed: "not_addressed";
         refused: "refused";
         unable: "unable";
@@ -34,8 +34,8 @@ export declare const responseRefusalResultSchema: z.ZodObject<{
     confidence: z.ZodNumber;
     probabilities: z.ZodRecord<z.ZodEnum<{
         unclear: "unclear";
-        attempted: "attempted";
         mixed: "mixed";
+        attempted: "attempted";
         not_addressed: "not_addressed";
         refused: "refused";
         unable: "unable";

package/dist/recipes/text-block-role/demo.json

@@ -0,0 +1,29 @@
+{
+  "input": {
+    "text": "Installation",
+    "after": "Run npm install to add the package.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": {
+      "decision": {
+        "type": "choice",
+        "choice": "heading",
+        "confidence": 0.94,
+        "probabilities": {
+          "heading": 0.94,
+          "body": 0.04,
+          "list_item": 0,
+          "code": 0,
+          "table": 0,
+          "caption": 0,
+          "formula": 0,
+          "other": 0,
+          "unclear": 0.02
+        }
+      }
+    },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/text-block-role/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { TextBlockRoleInput, TextBlockRoleResult } from './schema.js';
+export declare function textBlockRole(input: TextBlockRoleInput, options?: RecipeOptions): Promise<TextBlockRoleResult>;
+export { textBlockRoleInputSchema, textBlockRoleResultSchema, textBlockRoleVerdictSchema, } from './schema.js';
+export type { TextBlockRoleInput, TextBlockRoleResult, TextBlockRoleVerdict } from './schema.js';

package/dist/recipes/text-block-role/index.js

@@ -0,0 +1,21 @@
+import { evaluateChoice } from '../../src/decisions.js';
+import { textBlockRoleInputSchema, textBlockRoleResultSchema } from './schema.js';
+export async function textBlockRole(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = textBlockRoleInputSchema.parse(input);
+    const decision = await evaluateChoice(state, 'What structural role does text play in its source document? Use before, after, and context only to interpret this block. Choose the role of text itself, not the subject it discusses. Code discussed in prose is body; a description of a table is not a table. A short sentence is not necessarily a heading. Choose unclear when the supplied text cannot distinguish plausible roles. Never infer missing text.', {
+        heading: 'A title or section label introducing the content that follows.',
+        body: 'Ordinary prose forming a paragraph, including signature prose and explanations.',
+        list_item: 'One item in an enumeration or a bulleted list.',
+        code: 'Source code, a shell command, or a program fragment.',
+        table: 'Text arranged into rows and columns representing tabular relationships.',
+        caption: 'A label or description specifically attached to a figure or table.',
+        formula: 'A mathematical expression or equation, rather than prose mentioning mathematics.',
+        other: 'A clear structural role outside these categories, such as page furniture.',
+        unclear: 'Several roles remain plausible or the text is insufficient.',
+    }, options);
+    return textBlockRoleResultSchema.parse({
+        ...decision,
+        status: decision.confidence < minConfidence || decision.verdict === 'unclear' ? 'review' : 'ready',
+    });
+}
+export { textBlockRoleInputSchema, textBlockRoleResultSchema, textBlockRoleVerdictSchema, } from './schema.js';