jev-recipes 0.5.2 → 0.6.0

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

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { ContentFacetsInput, ContentFacetsResult } from './schema.js';
+export declare function contentFacets(input: ContentFacetsInput, options?: RecipeOptions): Promise<ContentFacetsResult>;
+export { contentFacetsInputSchema, contentFacetsResultSchema, contentFacetsLabelSchema, } from './schema.js';
+export type { ContentFacetsInput, ContentFacetsResult, ContentFacetsLabel } from './schema.js';

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

@@ -0,0 +1,48 @@
+import { evaluateLabels, resolveLabels } from '../../src/labels.js';
+import { contentFacetsInputSchema, contentFacetsResultSchema } from './schema.js';
+export async function contentFacets(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = contentFacetsInputSchema.parse(input);
+    const evaluation = await evaluateLabels(state, {
+        statesThesis: {
+            instruction: 'Does article state a clear central claim or position rather than only describing a topic?',
+            criteria: {
+                true: 'The article states a central claim or position that the rest of the text supports.',
+                false: 'The article surveys a topic without committing to a central claim.',
+            },
+        },
+        providesEvidence: {
+            instruction: 'Does article offer data, examples, citations, or named sources in support of its points?',
+            criteria: {
+                true: 'The article includes at least one concrete data point, example, citation, or named source offered as support.',
+                false: 'The article makes assertions without data, examples, citations, or named sources.',
+            },
+        },
+        addressesCounterarguments: {
+            instruction: 'Does article acknowledge or respond to an opposing view or objection?',
+            criteria: {
+                true: 'The article names at least one opposing view or objection and acknowledges or responds to it.',
+                false: 'The article presents only its own position and mentions no opposing view.',
+            },
+        },
+        includesCallToAction: {
+            instruction: 'Does article ask the reader to take a specific action?',
+            criteria: {
+                true: 'The article directs the reader to do something, such as try, sign up, download, contact, or change a practice.',
+                false: 'The article does not ask the reader to do anything.',
+            },
+        },
+        signalsExpertise: {
+            instruction: "Does article state the author's credentials, direct experience, or first-hand testing?",
+            criteria: {
+                true: "The article states the author's credentials, role, direct experience, or first-hand testing relevant to the subject.",
+                false: 'The article gives no indication of who the author is or why they are qualified.',
+            },
+        },
+    }, options);
+    return contentFacetsResultSchema.parse({
+        ...resolveLabels(evaluation.labels, minConfidence),
+        model: evaluation.model,
+        usage: evaluation.usage,
+    });
+}
+export { contentFacetsInputSchema, contentFacetsResultSchema, contentFacetsLabelSchema, } from './schema.js';

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

@@ -0,0 +1,95 @@
+import { z } from 'zod';
+export declare const contentFacetsLabelSchema: z.ZodEnum<{
+    statesThesis: "statesThesis";
+    providesEvidence: "providesEvidence";
+    addressesCounterarguments: "addressesCounterarguments";
+    includesCallToAction: "includesCallToAction";
+    signalsExpertise: "signalsExpertise";
+}>;
+export declare const contentFacetsInputSchema: z.ZodObject<{
+    article: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const contentFacetsResultSchema: 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<{
+        statesThesis: "statesThesis";
+        providesEvidence: "providesEvidence";
+        addressesCounterarguments: "addressesCounterarguments";
+        includesCallToAction: "includesCallToAction";
+        signalsExpertise: "signalsExpertise";
+    }>>;
+    labels: z.ZodObject<{
+        statesThesis: 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>;
+        providesEvidence: 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>;
+        addressesCounterarguments: 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>;
+        includesCallToAction: 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>;
+        signalsExpertise: 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 ContentFacetsLabel = z.infer<typeof contentFacetsLabelSchema>;
+export type ContentFacetsInput = z.infer<typeof contentFacetsInputSchema>;
+export type ContentFacetsResult = z.infer<typeof contentFacetsResultSchema>;

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

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+import { labelCheckSchema, labelsResultSchema, nonEmptyText, probability, } from '../../src/schema.js';
+export const contentFacetsLabelSchema = z.enum([
+    'statesThesis',
+    'providesEvidence',
+    'addressesCounterarguments',
+    'includesCallToAction',
+    'signalsExpertise',
+]);
+export const contentFacetsInputSchema = z.object({
+    article: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const contentFacetsResultSchema = labelsResultSchema.extend({
+    detected: z.array(contentFacetsLabelSchema),
+    labels: z.object({
+        statesThesis: labelCheckSchema,
+        providesEvidence: labelCheckSchema,
+        addressesCounterarguments: labelCheckSchema,
+        includesCallToAction: labelCheckSchema,
+        signalsExpertise: labelCheckSchema,
+    }),
+});

package/dist/recipes/content-freshness-signal/demo.json

@@ -0,0 +1,11 @@
+{
+  "input": {
+    "content": "Getting started with Node.js\n\nThe latest LTS release, Node 22, ships with built-in test runner support and a stable fetch API. Download the installer from nodejs.org; the current version is 22.11.0. Hosting on a small VPS costs around $6 per month with most providers this year. Once installed, run node --version to confirm the install.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": { "gate": { "type": "noul", "noul": 0.95 } },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/content-freshness-signal/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { ContentFreshnessSignalInput, ContentFreshnessSignalResult } from './schema.js';
+export declare function contentFreshnessSignal(input: ContentFreshnessSignalInput, options?: RecipeOptions): Promise<ContentFreshnessSignalResult>;
+export { contentFreshnessSignalInputSchema, contentFreshnessSignalResultSchema, contentFreshnessSignalVerdictSchema, } from './schema.js';
+export type { ContentFreshnessSignalInput, ContentFreshnessSignalResult, ContentFreshnessSignalVerdict, } from './schema.js';

package/dist/recipes/content-freshness-signal/index.js

@@ -0,0 +1,15 @@
+import { evaluateGate } from '../../src/gates.js';
+import { contentFreshnessSignalInputSchema, contentFreshnessSignalResultSchema } from './schema.js';
+export async function contentFreshnessSignal(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = contentFreshnessSignalInputSchema.parse(input);
+    const decision = await evaluateGate(state, 'Does content contain claims likely to go stale? Look for specific prices, version numbers, release dates, statistics tied to a year, references to current events or ongoing situations, and wording such as latest, new, currently, this year, or upcoming. Treat content as perishable when at least one such claim is central or repeated. Treat it as evergreen when its claims are definitions, principles, historical facts, or procedures that do not depend on the present moment. Ignore the publication date itself if it appears only as a byline.', {
+        true: 'The content includes at least one substantive claim tied to the present, such as a price, version number, current statistic, ongoing event, or latest or currently wording.',
+        false: 'The content consists of definitions, principles, historical facts, or procedures that do not depend on the present moment and contains no time-bound claim.',
+    }, options);
+    return contentFreshnessSignalResultSchema.parse({
+        ...decision,
+        verdict: decision.probability >= 0.5 ? 'perishable' : 'evergreen',
+        status: decision.confidence < minConfidence ? 'review' : 'ready',
+    });
+}
+export { contentFreshnessSignalInputSchema, contentFreshnessSignalResultSchema, contentFreshnessSignalVerdictSchema, } from './schema.js';

package/dist/recipes/content-freshness-signal/schema.d.ts

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+export declare const contentFreshnessSignalVerdictSchema: z.ZodEnum<{
+    evergreen: "evergreen";
+    perishable: "perishable";
+}>;
+export declare const contentFreshnessSignalInputSchema: z.ZodObject<{
+    content: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const contentFreshnessSignalResultSchema: 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<{
+        evergreen: "evergreen";
+        perishable: "perishable";
+    }>;
+}, z.core.$strip>;
+export type ContentFreshnessSignalVerdict = z.infer<typeof contentFreshnessSignalVerdictSchema>;
+export type ContentFreshnessSignalInput = z.infer<typeof contentFreshnessSignalInputSchema>;
+export type ContentFreshnessSignalResult = z.infer<typeof contentFreshnessSignalResultSchema>;

package/dist/recipes/content-freshness-signal/schema.js

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+import { gateResultSchema, nonEmptyText, probability } from '../../src/schema.js';
+export const contentFreshnessSignalVerdictSchema = z.enum(['perishable', 'evergreen']);
+export const contentFreshnessSignalInputSchema = z.object({
+    content: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const contentFreshnessSignalResultSchema = gateResultSchema.extend({
+    verdict: contentFreshnessSignalVerdictSchema,
+});

package/dist/recipes/continuation-compare/demo.json

@@ -0,0 +1,27 @@
+{
+  "input": {
+    "context": "G major, 4/4. Opening motif: G4 A4 B4 D5 | B4 A4 G4 (half). A rising line to the fifth answered by a stepwise descent home.",
+    "firstContinuation": "D5 E5 F#5 A5 | F#5 E5 D5 (half). The motif transposed up a fifth, same rhythm, same rise-and-fall contour.",
+    "secondContinuation": "C#4 (eighth) G#5 (eighth) Bb3 (quarter) rest | Eb5 (dotted half). Wide chromatic leaps in a new, jagged rhythm.",
+    "style": "Celtic air, lyrical and unhurried",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": {
+      "decision": {
+        "type": "choice",
+        "choice": "first",
+        "confidence": 0.91,
+        "probabilities": {
+          "first": 0.91,
+          "second": 0.02,
+          "tie": 0.02,
+          "neither": 0.03,
+          "unclear": 0.02
+        }
+      }
+    },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/continuation-compare/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { ContinuationCompareInput, ContinuationCompareResult } from './schema.js';
+export declare function continuationCompare(input: ContinuationCompareInput, options?: RecipeOptions): Promise<ContinuationCompareResult>;
+export { continuationCompareInputSchema, continuationCompareResultSchema, continuationCompareVerdictSchema, } from './schema.js';
+export type { ContinuationCompareInput, ContinuationCompareResult, ContinuationCompareVerdict, } from './schema.js';

package/dist/recipes/continuation-compare/index.js

@@ -0,0 +1,16 @@
+import { evaluateComparison } from '../../src/comparisons.js';
+import { continuationCompareInputSchema, continuationCompareResultSchema } from './schema.js';
+export async function continuationCompare(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = continuationCompareInputSchema.parse(input);
+    const decision = await evaluateComparison(state, 'Which of firstContinuation and secondContinuation better follows the musical context, given style when it is supplied? Judge how well each keeps or develops the motif in context, how naturally its contour follows the line, how its harmony fits what came before, and how well it matches the stated style. Prefer the continuation a listener would hear as belonging to the same piece. Answer tie when both follow about equally well and neither when both break with the context. Do not compute key membership, intervals, or beat counts; judge the musical sense of what is described.', {
+        first: 'Only the first continuation keeps or develops the motif, contour, harmony, and style of the context, or it does so clearly better than the second.',
+        second: 'Only the second continuation keeps or develops the motif, contour, harmony, and style of the context, or it does so clearly better than the first.',
+        tie: 'Both continuations follow the context about equally well.',
+        neither: 'Neither continuation follows the context; both break with its motif, contour, harmony, or style.',
+    }, options);
+    return continuationCompareResultSchema.parse({
+        ...decision,
+        status: decision.confidence < minConfidence || decision.verdict === 'unclear' ? 'review' : 'ready',
+    });
+}
+export { continuationCompareInputSchema, continuationCompareResultSchema, continuationCompareVerdictSchema, } from './schema.js';

package/dist/recipes/continuation-compare/schema.d.ts

@@ -0,0 +1,44 @@
+import { z } from 'zod';
+export declare const continuationCompareVerdictSchema: z.ZodEnum<{
+    first: "first";
+    second: "second";
+    tie: "tie";
+    neither: "neither";
+    unclear: "unclear";
+}>;
+export declare const continuationCompareInputSchema: z.ZodObject<{
+    context: z.ZodString;
+    firstContinuation: z.ZodString;
+    secondContinuation: z.ZodString;
+    style: z.ZodOptional<z.ZodString>;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const continuationCompareResultSchema: 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<{
+        first: "first";
+        second: "second";
+        tie: "tie";
+        neither: "neither";
+        unclear: "unclear";
+    }>;
+    confidence: z.ZodNumber;
+    probabilities: z.ZodRecord<z.ZodEnum<{
+        first: "first";
+        second: "second";
+        tie: "tie";
+        neither: "neither";
+        unclear: "unclear";
+    }>, z.ZodNumber>;
+}, z.core.$strip>;
+export type ContinuationCompareVerdict = z.infer<typeof continuationCompareVerdictSchema>;
+export type ContinuationCompareInput = z.infer<typeof continuationCompareInputSchema>;
+export type ContinuationCompareResult = z.infer<typeof continuationCompareResultSchema>;

package/dist/recipes/continuation-compare/schema.js

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { comparisonResultSchema, comparisonVerdictSchema, nonEmptyText, probability, } from '../../src/schema.js';
+export const continuationCompareVerdictSchema = comparisonVerdictSchema;
+export const continuationCompareInputSchema = z.object({
+    context: nonEmptyText,
+    firstContinuation: nonEmptyText,
+    secondContinuation: nonEmptyText,
+    style: nonEmptyText.optional(),
+    minConfidence: probability.optional(),
+});
+export const continuationCompareResultSchema = comparisonResultSchema;

package/dist/recipes/corrective-action-fit/demo.json

@@ -0,0 +1,12 @@
+{
+  "input": {
+    "rootCause": "The torque wrench at station 4 was reading 15% low because the tooling register lists a 24-month calibration interval for this wrench model while the manufacturer specifies 12 months. The wrench passed its last register-scheduled check and drifted out of tolerance eight months later, so every assembly torqued at station 4 since then is suspect.",
+    "action": "Rework the 340 assemblies built since the last calibration to the specified torque and verify with a calibrated reference wrench. Send the station 4 wrench for recalibration and return it to service once it passes. Brief operators on checking the calibration sticker before each shift.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": { "gate": { "type": "noul", "noul": 0.08 } },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/corrective-action-fit/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { CorrectiveActionFitInput, CorrectiveActionFitResult } from './schema.js';
+export declare function correctiveActionFit(input: CorrectiveActionFitInput, options?: RecipeOptions): Promise<CorrectiveActionFitResult>;
+export { correctiveActionFitInputSchema, correctiveActionFitResultSchema, correctiveActionFitVerdictSchema, } from './schema.js';
+export type { CorrectiveActionFitInput, CorrectiveActionFitResult, CorrectiveActionFitVerdict, } from './schema.js';

package/dist/recipes/corrective-action-fit/index.js

@@ -0,0 +1,15 @@
+import { evaluateGate } from '../../src/gates.js';
+import { correctiveActionFitInputSchema, correctiveActionFitResultSchema } from './schema.js';
+export async function correctiveActionFit(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = correctiveActionFitInputSchema.parse(input);
+    const decision = await evaluateGate(state, 'Does action change the condition named in rootCause so that the same cause would no longer produce the defect? Judge only whether the action acts on the stated cause. Reworking, scrapping, or sorting affected items, adding inspection, recalibrating or replacing the failed item once, and reminding or retraining people address the symptom or the instance, not the cause, unless rootCause itself is the absence of that inspection, calibration, or training. Ignore whether rootCause is correct, whether action is feasible, and whether it names an owner or date.', {
+        true: 'The action changes the process, design, specification, or organizational condition named in rootCause so that the same cause would no longer produce the defect.',
+        false: 'The action fixes the affected items, adds a check, or treats the failed instance while leaving the condition named in rootCause in place.',
+    }, options);
+    return correctiveActionFitResultSchema.parse({
+        ...decision,
+        verdict: decision.probability >= 0.5 ? 'addresses' : 'misses',
+        status: decision.confidence < minConfidence ? 'review' : 'ready',
+    });
+}
+export { correctiveActionFitInputSchema, correctiveActionFitResultSchema, correctiveActionFitVerdictSchema, } from './schema.js';

package/dist/recipes/corrective-action-fit/schema.d.ts

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+export declare const correctiveActionFitVerdictSchema: z.ZodEnum<{
+    addresses: "addresses";
+    misses: "misses";
+}>;
+export declare const correctiveActionFitInputSchema: z.ZodObject<{
+    rootCause: z.ZodString;
+    action: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const correctiveActionFitResultSchema: 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<{
+        addresses: "addresses";
+        misses: "misses";
+    }>;
+}, z.core.$strip>;
+export type CorrectiveActionFitVerdict = z.infer<typeof correctiveActionFitVerdictSchema>;
+export type CorrectiveActionFitInput = z.infer<typeof correctiveActionFitInputSchema>;
+export type CorrectiveActionFitResult = z.infer<typeof correctiveActionFitResultSchema>;

package/dist/recipes/corrective-action-fit/schema.js

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { gateResultSchema, nonEmptyText, probability } from '../../src/schema.js';
+export const correctiveActionFitVerdictSchema = z.enum(['addresses', 'misses']);
+export const correctiveActionFitInputSchema = z.object({
+    rootCause: nonEmptyText,
+    action: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const correctiveActionFitResultSchema = gateResultSchema.extend({
+    verdict: correctiveActionFitVerdictSchema,
+});

package/dist/recipes/daw-request-kind/demo.json

@@ -0,0 +1,26 @@
+{
+  "input": {
+    "request": "Quantize the drum track to sixteenth notes from bar 9 to bar 24, but leave the hi-hat lane alone.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": {
+      "decision": {
+        "type": "choice",
+        "choice": "edit",
+        "confidence": 0.9,
+        "probabilities": {
+          "record": 0.01,
+          "edit": 0.9,
+          "mix": 0.02,
+          "effect": 0.01,
+          "arrange": 0.03,
+          "export": 0,
+          "unclear": 0.03
+        }
+      }
+    },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/daw-request-kind/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { DawRequestKindInput, DawRequestKindResult } from './schema.js';
+export declare function dawRequestKind(input: DawRequestKindInput, options?: RecipeOptions): Promise<DawRequestKindResult>;
+export { dawRequestKindInputSchema, dawRequestKindResultSchema, dawRequestKindVerdictSchema, } from './schema.js';
+export type { DawRequestKindInput, DawRequestKindResult, DawRequestKindVerdict } from './schema.js';

package/dist/recipes/daw-request-kind/index.js

@@ -0,0 +1,19 @@
+import { evaluateChoice } from '../../src/decisions.js';
+import { dawRequestKindInputSchema, dawRequestKindResultSchema } from './schema.js';
+export async function dawRequestKind(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = dawRequestKindInputSchema.parse(input);
+    const decision = await evaluateChoice(state, 'Read request, a spoken or typed instruction to a DAW or music program, and decide which kind of operation it asks for. Judge by what the program would have to do, not by the words used: quantizing, trimming, and moving clips are edit operations, changing a level or pan is a mix operation, and adding or changing reverb, compression, or EQ is an effect operation. Pick the single kind request presses most. Use unclear when request does not ask the program to do anything recognizable, such as a general question or chatter.', {
+        record: 'The request asks to start, stop, arm, punch in, loop-record, or otherwise capture new audio or MIDI.',
+        edit: 'The request asks to cut, trim, split, move, copy, delete, quantize, stretch, or otherwise change existing clips or notes in place.',
+        mix: 'The request asks to change levels, panning, sends, buses, mute or solo state, or automation of those parameters.',
+        effect: 'The request asks to add, remove, bypass, or change the settings of an effect or processor such as reverb, delay, compression, EQ, or distortion.',
+        arrange: 'The request asks to add, remove, rename, or reorder tracks or sections, change tempo or time signature, set markers, or otherwise change the structure of the project.',
+        export: 'The request asks to bounce, render, export, share, or save the project or a part of it to a file or destination.',
+        unclear: 'The request does not ask the program to perform a recognizable operation, or is too vague to tell which kind it wants.',
+    }, options);
+    return dawRequestKindResultSchema.parse({
+        ...decision,
+        status: decision.confidence < minConfidence || decision.verdict === 'unclear' ? 'review' : 'ready',
+    });
+}
+export { dawRequestKindInputSchema, dawRequestKindResultSchema, dawRequestKindVerdictSchema, } from './schema.js';

package/dist/recipes/daw-request-kind/schema.d.ts

@@ -0,0 +1,47 @@
+import { z } from 'zod';
+export declare const dawRequestKindVerdictSchema: z.ZodEnum<{
+    record: "record";
+    unclear: "unclear";
+    edit: "edit";
+    mix: "mix";
+    effect: "effect";
+    arrange: "arrange";
+    export: "export";
+}>;
+export declare const dawRequestKindInputSchema: z.ZodObject<{
+    request: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const dawRequestKindResultSchema: 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<{
+        record: "record";
+        unclear: "unclear";
+        edit: "edit";
+        mix: "mix";
+        effect: "effect";
+        arrange: "arrange";
+        export: "export";
+    }>;
+    confidence: z.ZodNumber;
+    probabilities: z.ZodRecord<z.ZodEnum<{
+        record: "record";
+        unclear: "unclear";
+        edit: "edit";
+        mix: "mix";
+        effect: "effect";
+        arrange: "arrange";
+        export: "export";
+    }>, z.ZodNumber>;
+}, z.core.$strip>;
+export type DawRequestKindVerdict = z.infer<typeof dawRequestKindVerdictSchema>;
+export type DawRequestKindInput = z.infer<typeof dawRequestKindInputSchema>;
+export type DawRequestKindResult = z.infer<typeof dawRequestKindResultSchema>;

package/dist/recipes/daw-request-kind/schema.js

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+import { decisionStatusSchema, nonEmptyText, probability, resultMetadataSchema, } from '../../src/schema.js';
+export const dawRequestKindVerdictSchema = z.enum([
+    'record',
+    'edit',
+    'mix',
+    'effect',
+    'arrange',
+    'export',
+    'unclear',
+]);
+export const dawRequestKindInputSchema = z.object({
+    request: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const dawRequestKindResultSchema = resultMetadataSchema.extend({
+    status: decisionStatusSchema,
+    verdict: dawRequestKindVerdictSchema,
+    confidence: probability,
+    probabilities: z.record(dawRequestKindVerdictSchema, probability),
+});

package/dist/recipes/deadline-risk/demo.json

@@ -0,0 +1,19 @@
+{
+  "input": {
+    "deadline": "The migrated customer records must be live in the new CRM by end of day Friday, per the signed contract. It is now Thursday at 6pm.",
+    "progress": "The export from the old system finished Wednesday. The import script rejects about 30% of records with a schema mismatch that nobody has diagnosed yet. The engineer who wrote the field mapping is out until Monday. No fallback or partial go-live has been agreed with the customer.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": {
+      "score": {
+        "type": "score",
+        "score": 2.99,
+        "confidence": 0.82,
+        "probabilities": { "0": 0, "1": 0.01, "2": 0.08, "3": 0.82, "4": 0.09 }
+      }
+    },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/deadline-risk/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { DeadlineRiskInput, DeadlineRiskResult } from './schema.js';
+export declare function deadlineRisk(input: DeadlineRiskInput, options?: RecipeOptions): Promise<DeadlineRiskResult>;
+export { deadlineRiskInputSchema, deadlineRiskResultSchema, deadlineRiskVerdictSchema, } from './schema.js';
+export type { DeadlineRiskInput, DeadlineRiskResult, DeadlineRiskVerdict } from './schema.js';

package/dist/recipes/deadline-risk/index.js

@@ -0,0 +1,18 @@
+import { evaluateScore } from '../../src/scores.js';
+import { deadlineRiskInputSchema, deadlineRiskResultSchema, deadlineRiskVerdictSchema, } from './schema.js';
+export async function deadlineRisk(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = deadlineRiskInputSchema.parse(input);
+    const decision = await evaluateScore(state, 'How at risk is the work of missing deadline, given progress? Weigh the remaining work, open blockers, dependencies on unavailable people or systems, and the time the texts say is left. Judge only what the two texts state; do not compute dates yourself beyond what the texts make explicit, and do not assume effort or blockers the texts do not describe.', [
+        'The described remaining work fits comfortably in the stated time with no open blockers, so the deadline is on track.',
+        'The work is likely to land on time but the texts note a small open item, a tight margin, or a dependency that could slip.',
+        'Meeting the deadline is plausible but depends on something unresolved, such as a blocker with a known fix not yet applied or a review not yet scheduled.',
+        'The described remaining work or blockers do not fit the stated time without a change, such as an undiagnosed failure, a missing person, or scope still unfinished with little time left.',
+        'The texts state that the deadline has already passed, or the remaining work plainly cannot be done in the time described.',
+    ], options);
+    return deadlineRiskResultSchema.parse({
+        ...decision,
+        risk: deadlineRiskVerdictSchema.options[decision.level],
+        status: decision.confidence < minConfidence ? 'review' : 'ready',
+    });
+}
+export { deadlineRiskInputSchema, deadlineRiskResultSchema, deadlineRiskVerdictSchema, } from './schema.js';