jev-recipes 0.5.2 → 0.6.0

package/dist/recipes/style-kind/demo.json

@@ -0,0 +1,26 @@
+{
+  "input": {
+    "description": "Walking bass in the left hand under extended seventh and ninth chords, swung eighth notes, a ii-V-I turnaround every four bars, right hand improvising around the changes with chromatic approach tones.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": {
+      "decision": {
+        "type": "choice",
+        "choice": "jazz",
+        "confidence": 0.92,
+        "probabilities": {
+          "classical": 0.02,
+          "jazz": 0.92,
+          "blues": 0.03,
+          "pop": 0.01,
+          "electronic": 0,
+          "folk": 0,
+          "unclear": 0.02
+        }
+      }
+    },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/style-kind/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { StyleKindInput, StyleKindResult } from './schema.js';
+export declare function styleKind(input: StyleKindInput, options?: RecipeOptions): Promise<StyleKindResult>;
+export { styleKindInputSchema, styleKindResultSchema, styleKindVerdictSchema } from './schema.js';
+export type { StyleKindInput, StyleKindResult, StyleKindVerdict } from './schema.js';

package/dist/recipes/style-kind/index.js

@@ -0,0 +1,19 @@
+import { evaluateChoice } from '../../src/decisions.js';
+import { styleKindInputSchema, styleKindResultSchema } from './schema.js';
+export async function styleKind(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = styleKindInputSchema.parse(input);
+    const decision = await evaluateChoice(state, "Read description, which describes either a musical passage or a listener's request for one, and decide which broad style it evokes. Judge the stylistic markers the text names or implies: harmony, rhythm, instrumentation, idiom, named genres, and named artists or composers. Pick the single style the description points to most. A named artist or genre counts as a stylistic marker. Choose unclear when description carries no stylistic marker or when it mixes styles with no one dominant.", {
+        classical: 'The description points to the Western art-music tradition: named classical composers or forms, functional harmony with cadences, counterpoint, or terms such as sonata, etude, or nocturne.',
+        jazz: 'The description points to jazz idiom: swing feel, walking bass, extended or altered chords, ii-V-I progressions, improvisation over changes, or named jazz artists.',
+        blues: 'The description points to blues idiom: twelve-bar form, dominant-seventh chords on I, IV, and V, blue notes, shuffle feel, or call-and-response phrasing.',
+        pop: 'The description points to pop or rock songwriting: verse and chorus, simple diatonic loops such as I-V-vi-IV, hook-led melody, or named pop artists.',
+        electronic: 'The description points to electronic dance or synth music: four-on-the-floor kick, arpeggiated synths, builds and drops, side-chain pumping, or named electronic artists.',
+        folk: 'The description points to folk or traditional idiom: modal or pentatonic melody, drones, fiddle or acoustic guitar figures, strophic song, or named traditional tunes.',
+        unclear: 'The description carries no stylistic marker, or mixes styles with none clearly dominant.',
+    }, options);
+    return styleKindResultSchema.parse({
+        ...decision,
+        status: decision.confidence < minConfidence || decision.verdict === 'unclear' ? 'review' : 'ready',
+    });
+}
+export { styleKindInputSchema, styleKindResultSchema, styleKindVerdictSchema } from './schema.js';

package/dist/recipes/style-kind/schema.d.ts

@@ -0,0 +1,47 @@
+import { z } from 'zod';
+export declare const styleKindVerdictSchema: z.ZodEnum<{
+    unclear: "unclear";
+    pop: "pop";
+    classical: "classical";
+    jazz: "jazz";
+    blues: "blues";
+    electronic: "electronic";
+    folk: "folk";
+}>;
+export declare const styleKindInputSchema: z.ZodObject<{
+    description: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const styleKindResultSchema: 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";
+        pop: "pop";
+        classical: "classical";
+        jazz: "jazz";
+        blues: "blues";
+        electronic: "electronic";
+        folk: "folk";
+    }>;
+    confidence: z.ZodNumber;
+    probabilities: z.ZodRecord<z.ZodEnum<{
+        unclear: "unclear";
+        pop: "pop";
+        classical: "classical";
+        jazz: "jazz";
+        blues: "blues";
+        electronic: "electronic";
+        folk: "folk";
+    }>, z.ZodNumber>;
+}, z.core.$strip>;
+export type StyleKindVerdict = z.infer<typeof styleKindVerdictSchema>;
+export type StyleKindInput = z.infer<typeof styleKindInputSchema>;
+export type StyleKindResult = z.infer<typeof styleKindResultSchema>;

package/dist/recipes/style-kind/schema.js

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+import { decisionStatusSchema, nonEmptyText, probability, resultMetadataSchema, } from '../../src/schema.js';
+export const styleKindVerdictSchema = z.enum([
+    'classical',
+    'jazz',
+    'blues',
+    'pop',
+    'electronic',
+    'folk',
+    'unclear',
+]);
+export const styleKindInputSchema = z.object({
+    description: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const styleKindResultSchema = resultMetadataSchema.extend({
+    status: decisionStatusSchema,
+    verdict: styleKindVerdictSchema,
+    confidence: probability,
+    probabilities: z.record(styleKindVerdictSchema, probability),
+});

package/dist/recipes/symptom-facets/demo.json

@@ -0,0 +1,17 @@
+{
+  "input": {
+    "message": "My lower back started hurting on Saturday after I moved some boxes, so it has been about five days now. It gets worse when I sit for a long time and eases up when I walk around. I have been taking ibuprofen twice a day and using a heating pad at night, but it is not really improving. Should I come in?",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": {
+      "statesOnset": { "type": "noul", "noul": 0.95 },
+      "statesSeverity": { "type": "noul", "noul": 0.12 },
+      "statesDuration": { "type": "noul", "noul": 0.93 },
+      "statesModifiers": { "type": "noul", "noul": 0.94 },
+      "statesPriorTreatment": { "type": "noul", "noul": 0.96 }
+    },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/symptom-facets/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { SymptomFacetsInput, SymptomFacetsResult } from './schema.js';
+export declare function symptomFacets(input: SymptomFacetsInput, options?: RecipeOptions): Promise<SymptomFacetsResult>;
+export { symptomFacetsInputSchema, symptomFacetsResultSchema, symptomFacetsLabelSchema, } from './schema.js';
+export type { SymptomFacetsInput, SymptomFacetsResult, SymptomFacetsLabel } from './schema.js';

package/dist/recipes/symptom-facets/index.js

@@ -0,0 +1,48 @@
+import { evaluateLabels, resolveLabels } from '../../src/labels.js';
+import { symptomFacetsInputSchema, symptomFacetsResultSchema } from './schema.js';
+export async function symptomFacets(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = symptomFacetsInputSchema.parse(input);
+    const evaluation = await evaluateLabels(state, {
+        statesOnset: {
+            instruction: 'Does message say when the symptom began or what it began after?',
+            criteria: {
+                true: 'The message names a time, date, or triggering event for when the symptom started.',
+                false: 'The message gives no indication of when the symptom began.',
+            },
+        },
+        statesSeverity: {
+            instruction: 'Does message describe how bad the symptom is?',
+            criteria: {
+                true: 'The message gives a rating, an intensity word, or a concrete effect on daily activity that conveys how bad the symptom is.',
+                false: 'The message gives no indication of how bad the symptom is.',
+            },
+        },
+        statesDuration: {
+            instruction: 'Does message say how long the symptom has lasted or how often it occurs?',
+            criteria: {
+                true: 'The message states an elapsed time or a frequency for the symptom.',
+                false: 'The message states no elapsed time or frequency for the symptom.',
+            },
+        },
+        statesModifiers: {
+            instruction: 'Does message say what makes the symptom better or worse?',
+            criteria: {
+                true: 'The message names at least one activity, position, time of day, or remedy that changes the symptom.',
+                false: 'The message names nothing that makes the symptom better or worse.',
+            },
+        },
+        statesPriorTreatment: {
+            instruction: 'Does message say what the patient has already tried for the symptom?',
+            criteria: {
+                true: 'The message names a medication, remedy, or action the patient has already taken for the symptom.',
+                false: 'The message names nothing the patient has already tried.',
+            },
+        },
+    }, options);
+    return symptomFacetsResultSchema.parse({
+        ...resolveLabels(evaluation.labels, minConfidence),
+        model: evaluation.model,
+        usage: evaluation.usage,
+    });
+}
+export { symptomFacetsInputSchema, symptomFacetsResultSchema, symptomFacetsLabelSchema, } from './schema.js';

package/dist/recipes/symptom-facets/schema.d.ts

@@ -0,0 +1,95 @@
+import { z } from 'zod';
+export declare const symptomFacetsLabelSchema: z.ZodEnum<{
+    statesOnset: "statesOnset";
+    statesSeverity: "statesSeverity";
+    statesDuration: "statesDuration";
+    statesModifiers: "statesModifiers";
+    statesPriorTreatment: "statesPriorTreatment";
+}>;
+export declare const symptomFacetsInputSchema: z.ZodObject<{
+    message: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const symptomFacetsResultSchema: 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";
+    }>;
+    detected: z.ZodArray<z.ZodEnum<{
+        statesOnset: "statesOnset";
+        statesSeverity: "statesSeverity";
+        statesDuration: "statesDuration";
+        statesModifiers: "statesModifiers";
+        statesPriorTreatment: "statesPriorTreatment";
+    }>>;
+    labels: z.ZodObject<{
+        statesOnset: z.ZodObject<{
+            status: z.ZodEnum<{
+                ready: "ready";
+                review: "review";
+            }>;
+            verdict: z.ZodEnum<{
+                present: "present";
+                absent: "absent";
+            }>;
+            probability: z.ZodNumber;
+            confidence: z.ZodNumber;
+        }, z.core.$strip>;
+        statesSeverity: z.ZodObject<{
+            status: z.ZodEnum<{
+                ready: "ready";
+                review: "review";
+            }>;
+            verdict: z.ZodEnum<{
+                present: "present";
+                absent: "absent";
+            }>;
+            probability: z.ZodNumber;
+            confidence: z.ZodNumber;
+        }, z.core.$strip>;
+        statesDuration: z.ZodObject<{
+            status: z.ZodEnum<{
+                ready: "ready";
+                review: "review";
+            }>;
+            verdict: z.ZodEnum<{
+                present: "present";
+                absent: "absent";
+            }>;
+            probability: z.ZodNumber;
+            confidence: z.ZodNumber;
+        }, z.core.$strip>;
+        statesModifiers: z.ZodObject<{
+            status: z.ZodEnum<{
+                ready: "ready";
+                review: "review";
+            }>;
+            verdict: z.ZodEnum<{
+                present: "present";
+                absent: "absent";
+            }>;
+            probability: z.ZodNumber;
+            confidence: z.ZodNumber;
+        }, z.core.$strip>;
+        statesPriorTreatment: z.ZodObject<{
+            status: z.ZodEnum<{
+                ready: "ready";
+                review: "review";
+            }>;
+            verdict: z.ZodEnum<{
+                present: "present";
+                absent: "absent";
+            }>;
+            probability: z.ZodNumber;
+            confidence: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type SymptomFacetsLabel = z.infer<typeof symptomFacetsLabelSchema>;
+export type SymptomFacetsInput = z.infer<typeof symptomFacetsInputSchema>;
+export type SymptomFacetsResult = z.infer<typeof symptomFacetsResultSchema>;

package/dist/recipes/symptom-facets/schema.js

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+import { labelCheckSchema, labelsResultSchema, nonEmptyText, probability, } from '../../src/schema.js';
+export const symptomFacetsLabelSchema = z.enum([
+    'statesOnset',
+    'statesSeverity',
+    'statesDuration',
+    'statesModifiers',
+    'statesPriorTreatment',
+]);
+export const symptomFacetsInputSchema = z.object({
+    message: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const symptomFacetsResultSchema = labelsResultSchema.extend({
+    detected: z.array(symptomFacetsLabelSchema),
+    labels: z.object({
+        statesOnset: labelCheckSchema,
+        statesSeverity: labelCheckSchema,
+        statesDuration: labelCheckSchema,
+        statesModifiers: labelCheckSchema,
+        statesPriorTreatment: labelCheckSchema,
+    }),
+});

package/dist/recipes/take-turn/schema.d.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 export declare const takeTurnVerdictSchema: z.ZodEnum<{
-    wait: "wait";
     unclear: "unclear";
+    wait: "wait";
     act: "act";
     inactive: "inactive";
 }>;
@@ -26,15 +26,15 @@ export declare const takeTurnResultSchema: z.ZodObject<{
         review: "review";
     }>;
     verdict: z.ZodEnum<{
-        wait: "wait";
         unclear: "unclear";
+        wait: "wait";
         act: "act";
         inactive: "inactive";
     }>;
     confidence: z.ZodNumber;
     probabilities: z.ZodRecord<z.ZodEnum<{
-        wait: "wait";
         unclear: "unclear";
+        wait: "wait";
         act: "act";
         inactive: "inactive";
     }>, z.ZodNumber>;

package/dist/recipes/task-complexity/demo.json

@@ -0,0 +1,19 @@
+{
+  "input": {
+    "task": "Migrate the billing service from the legacy payments API to the new provider, keeping existing subscriptions active and reconciling any invoices that fail during the cutover.",
+    "context": "The service has 40,000 active subscriptions and no staging replica of production data.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": {
+      "score": {
+        "type": "score",
+        "score": 3.04,
+        "confidence": 0.84,
+        "probabilities": { "0": 0.0, "1": 0.01, "2": 0.09, "3": 0.84, "4": 0.06 }
+      }
+    },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/task-complexity/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { TaskComplexityInput, TaskComplexityResult } from './schema.js';
+export declare function taskComplexity(input: TaskComplexityInput, options?: RecipeOptions): Promise<TaskComplexityResult>;
+export { taskComplexityInputSchema, taskComplexityResultSchema, taskComplexityVerdictSchema, } from './schema.js';
+export type { TaskComplexityInput, TaskComplexityResult, TaskComplexityVerdict } from './schema.js';

package/dist/recipes/task-complexity/index.js

@@ -0,0 +1,18 @@
+import { evaluateScore } from '../../src/scores.js';
+import { taskComplexityInputSchema, taskComplexityResultSchema, taskComplexityVerdictSchema, } from './schema.js';
+export async function taskComplexity(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = taskComplexityInputSchema.parse(input);
+    const decision = await evaluateScore(state, 'How complex is task, given any context? Judge the number of distinct steps, the judgment each step needs, and how clearly completion is defined. Ignore the length of the wording.', [
+        'A single direct step or lookup with an unambiguous completion condition.',
+        'A few sequential steps using one kind of tool or source, needing little judgment.',
+        'Several steps across more than one tool or source, needing some judgment or intermediate results.',
+        'Many interdependent steps with ambiguity, trade-offs, or coordination to resolve along the way.',
+        'Open-ended investigation or design work with no clearly defined completion condition.',
+    ], options);
+    return taskComplexityResultSchema.parse({
+        ...decision,
+        complexity: taskComplexityVerdictSchema.options[decision.level],
+        status: decision.confidence < minConfidence ? 'review' : 'ready',
+    });
+}
+export { taskComplexityInputSchema, taskComplexityResultSchema, taskComplexityVerdictSchema, } from './schema.js';

package/dist/recipes/task-complexity/schema.d.ts

@@ -0,0 +1,38 @@
+import { z } from 'zod';
+export declare const taskComplexityVerdictSchema: z.ZodEnum<{
+    trivial: "trivial";
+    moderate: "moderate";
+    simple: "simple";
+    complex: "complex";
+    "open-ended": "open-ended";
+}>;
+export declare const taskComplexityInputSchema: z.ZodObject<{
+    task: z.ZodString;
+    context: z.ZodOptional<z.ZodString>;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const taskComplexityResultSchema: 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";
+    }>;
+    score: z.ZodNumber;
+    level: z.ZodNumber;
+    confidence: z.ZodNumber;
+    probabilities: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    complexity: z.ZodEnum<{
+        trivial: "trivial";
+        moderate: "moderate";
+        simple: "simple";
+        complex: "complex";
+        "open-ended": "open-ended";
+    }>;
+}, z.core.$strip>;
+export type TaskComplexityVerdict = z.infer<typeof taskComplexityVerdictSchema>;
+export type TaskComplexityInput = z.infer<typeof taskComplexityInputSchema>;
+export type TaskComplexityResult = z.infer<typeof taskComplexityResultSchema>;

package/dist/recipes/task-complexity/schema.js

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import { nonEmptyText, probability, scoreResultSchema } from '../../src/schema.js';
+export const taskComplexityVerdictSchema = z.enum([
+    'trivial',
+    'simple',
+    'moderate',
+    'complex',
+    'open-ended',
+]);
+export const taskComplexityInputSchema = z.object({
+    task: nonEmptyText,
+    context: nonEmptyText.optional(),
+    minConfidence: probability.optional(),
+});
+export const taskComplexityResultSchema = scoreResultSchema.extend({
+    complexity: taskComplexityVerdictSchema,
+});

package/dist/recipes/task-duplicate/schema.d.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 export declare const taskDuplicateVerdictSchema: z.ZodEnum<{
-    duplicate: "duplicate";
     unclear: "unclear";
+    duplicate: "duplicate";
     overlapping: "overlapping";
     distinct: "distinct";
 }>;
@@ -22,15 +22,15 @@ export declare const taskDuplicateResultSchema: z.ZodObject<{
         review: "review";
     }>;
     verdict: z.ZodEnum<{
-        duplicate: "duplicate";
         unclear: "unclear";
+        duplicate: "duplicate";
         overlapping: "overlapping";
         distinct: "distinct";
     }>;
     confidence: z.ZodNumber;
     probabilities: z.ZodRecord<z.ZodEnum<{
-        duplicate: "duplicate";
         unclear: "unclear";
+        duplicate: "duplicate";
         overlapping: "overlapping";
         distinct: "distinct";
     }>, z.ZodNumber>;

package/dist/recipes/task-overlap/demo.json

@@ -0,0 +1,12 @@
+{
+  "input": {
+    "firstTask": "Add input validation to the user registration form so that email and password fields show inline errors before submit.",
+    "secondTask": "Refactor the registration form to use the shared FormField component and wire up its built-in error display for every field.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": { "gate": { "type": "noul", "noul": 0.93 } },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/task-overlap/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { TaskOverlapInput, TaskOverlapResult } from './schema.js';
+export declare function taskOverlap(input: TaskOverlapInput, options?: RecipeOptions): Promise<TaskOverlapResult>;
+export { taskOverlapInputSchema, taskOverlapResultSchema, taskOverlapVerdictSchema, } from './schema.js';
+export type { TaskOverlapInput, TaskOverlapResult, TaskOverlapVerdict } from './schema.js';

package/dist/recipes/task-overlap/index.js

@@ -0,0 +1,15 @@
+import { evaluateGate } from '../../src/gates.js';
+import { taskOverlapInputSchema, taskOverlapResultSchema } from './schema.js';
+export async function taskOverlap(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = taskOverlapInputSchema.parse(input);
+    const decision = await evaluateGate(state, 'Do firstTask and secondTask cover overlapping work, such that two workers doing them in parallel would duplicate effort or collide on the same files, records, or decisions? Count overlap when both tasks change or produce the same artifact, when one task is a subset of the other, or when completing one would make part of the other redundant. Do not count overlap when the tasks merely share a topic, a codebase, or a dependency while touching different things.', {
+        true: 'The tasks cover overlapping work that two workers would duplicate or collide on.',
+        false: 'The tasks cover distinct work that two workers could do independently.',
+    }, options);
+    return taskOverlapResultSchema.parse({
+        ...decision,
+        verdict: decision.probability >= 0.5 ? 'overlapping' : 'disjoint',
+        status: decision.confidence < minConfidence ? 'review' : 'ready',
+    });
+}
+export { taskOverlapInputSchema, taskOverlapResultSchema, taskOverlapVerdictSchema, } from './schema.js';

package/dist/recipes/task-overlap/schema.d.ts

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+export declare const taskOverlapVerdictSchema: z.ZodEnum<{
+    overlapping: "overlapping";
+    disjoint: "disjoint";
+}>;
+export declare const taskOverlapInputSchema: z.ZodObject<{
+    firstTask: z.ZodString;
+    secondTask: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const taskOverlapResultSchema: 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";
+    }>;
+    probability: z.ZodNumber;
+    confidence: z.ZodNumber;
+    verdict: z.ZodEnum<{
+        overlapping: "overlapping";
+        disjoint: "disjoint";
+    }>;
+}, z.core.$strip>;
+export type TaskOverlapVerdict = z.infer<typeof taskOverlapVerdictSchema>;
+export type TaskOverlapInput = z.infer<typeof taskOverlapInputSchema>;
+export type TaskOverlapResult = z.infer<typeof taskOverlapResultSchema>;

package/dist/recipes/task-overlap/schema.js

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { gateResultSchema, nonEmptyText, probability } from '../../src/schema.js';
+export const taskOverlapVerdictSchema = z.enum(['overlapping', 'disjoint']);
+export const taskOverlapInputSchema = z.object({
+    firstTask: nonEmptyText,
+    secondTask: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const taskOverlapResultSchema = gateResultSchema.extend({
+    verdict: taskOverlapVerdictSchema,
+});

package/dist/recipes/tempo-change/demo.json

@@ -0,0 +1,19 @@
+{
+  "input": {
+    "context": "Three chat messages in the last minute: 'pick it up a little', 'faster!!', and 'this is dragging'. No one asked for it to stay slow. Stream goal: follow chat when requests agree.",
+    "recentMaterial": "Slow ballad in E-flat major at about 60 bpm, half notes and quarter notes in the left hand, sparse melody, moderate dynamics, held for the last two minutes.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": {
+      "decision": {
+        "type": "choice",
+        "choice": "faster",
+        "confidence": 0.9,
+        "probabilities": { "slower": 0.01, "same": 0.05, "faster": 0.9, "unclear": 0.04 }
+      }
+    },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/tempo-change/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { TempoChangeInput, TempoChangeResult } from './schema.js';
+export declare function tempoChange(input: TempoChangeInput, options?: RecipeOptions): Promise<TempoChangeResult>;
+export { tempoChangeInputSchema, tempoChangeResultSchema, tempoChangeVerdictSchema, } from './schema.js';
+export type { TempoChangeInput, TempoChangeResult, TempoChangeVerdict } from './schema.js';

package/dist/recipes/tempo-change/index.js

@@ -0,0 +1,16 @@
+import { evaluateChoice } from '../../src/decisions.js';
+import { tempoChangeInputSchema, tempoChangeResultSchema } from './schema.js';
+export async function tempoChange(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = tempoChangeInputSchema.parse(input);
+    const decision = await evaluateChoice(state, 'Read context, which describes what listeners have asked for and any performance goals, and recentMaterial, which describes the tempo and character of what was just played. Decide whether the next passage should be slower, stay the same, or be faster. Weigh only requests in context that concern pace, energy, or rush, and compare them with the tempo recentMaterial describes: a request for more energy over slow material means faster, a request to relax over fast material means slower, and material that already matches what is asked means same. Ignore requests about mood, style, volume, or specific pieces except where they clearly imply a pace. Choose unclear when context contains no pace-related signal or when equally weighted requests contradict each other.', {
+        slower: 'Requests in context call for a slower, calmer, or less rushed pace than the tempo recentMaterial describes.',
+        same: 'Requests in context are satisfied by the tempo recentMaterial describes, or ask for the tempo to hold.',
+        faster: 'Requests in context call for a quicker, livelier, or more driving pace than the tempo recentMaterial describes.',
+        unclear: 'context carries no pace-related request, or equally weighted requests pull in opposite directions.',
+    }, options);
+    return tempoChangeResultSchema.parse({
+        ...decision,
+        status: decision.confidence < minConfidence || decision.verdict === 'unclear' ? 'review' : 'ready',
+    });
+}
+export { tempoChangeInputSchema, tempoChangeResultSchema, tempoChangeVerdictSchema, } from './schema.js';

package/dist/recipes/tempo-change/schema.d.ts

@@ -0,0 +1,39 @@
+import { z } from 'zod';
+export declare const tempoChangeVerdictSchema: z.ZodEnum<{
+    unclear: "unclear";
+    same: "same";
+    slower: "slower";
+    faster: "faster";
+}>;
+export declare const tempoChangeInputSchema: z.ZodObject<{
+    context: z.ZodString;
+    recentMaterial: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const tempoChangeResultSchema: 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";
+        same: "same";
+        slower: "slower";
+        faster: "faster";
+    }>;
+    confidence: z.ZodNumber;
+    probabilities: z.ZodRecord<z.ZodEnum<{
+        unclear: "unclear";
+        same: "same";
+        slower: "slower";
+        faster: "faster";
+    }>, z.ZodNumber>;
+}, z.core.$strip>;
+export type TempoChangeVerdict = z.infer<typeof tempoChangeVerdictSchema>;
+export type TempoChangeInput = z.infer<typeof tempoChangeInputSchema>;
+export type TempoChangeResult = z.infer<typeof tempoChangeResultSchema>;