jev-recipes 0.5.3 → 0.6.0

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

@@ -0,0 +1,48 @@
+import { evaluateLabels, resolveLabels } from '../../src/labels.js';
+import { proposalFacetsInputSchema, proposalFacetsResultSchema } from './schema.js';
+export async function proposalFacets(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = proposalFacetsInputSchema.parse(input);
+    const evaluation = await evaluateLabels(state, {
+        statesNeed: {
+            instruction: 'Does proposal describe the problem, gap, or population condition that the proposed work addresses?',
+            criteria: {
+                true: 'The proposal describes a specific problem or gap, with or without supporting figures, that the work is meant to address.',
+                false: 'The proposal describes only what it will do or who the applicant is, without saying what problem the work addresses.',
+            },
+        },
+        statesObjectives: {
+            instruction: 'Does proposal state at least one objective with a measurable target, such as a number served, a percentage change, or an observable outcome by a stated point?',
+            criteria: {
+                true: 'The proposal states at least one intended outcome with a number, percentage, or other observable target.',
+                false: 'The proposal states goals only in general terms, such as improving lives or raising awareness, with no measurable target.',
+            },
+        },
+        statesActivities: {
+            instruction: 'Does proposal describe the specific activities the applicant will carry out, such as sessions, services, events, or deliverables?',
+            criteria: {
+                true: 'The proposal names concrete activities the applicant will perform, with at least some detail on what, who, or how often.',
+                false: 'The proposal names no specific activities, or describes the work only as a program or initiative without saying what will be done.',
+            },
+        },
+        statesBudget: {
+            instruction: 'Does proposal give the cost of the work, as a requested amount, a total budget, line items, or a combination?',
+            criteria: {
+                true: 'The proposal states at least one monetary figure for what the work will cost or what is requested.',
+                false: 'The proposal gives no monetary figure for the work.',
+            },
+        },
+        statesEvaluation: {
+            instruction: 'Does proposal say how the applicant will measure or assess whether the objectives were achieved, such as assessments, surveys, data collection, or a comparison?',
+            criteria: {
+                true: 'The proposal describes at least one method, instrument, or data source it will use to judge whether the work achieved its objectives.',
+                false: 'The proposal states objectives or outcomes without saying how their achievement will be measured or assessed.',
+            },
+        },
+    }, options);
+    return proposalFacetsResultSchema.parse({
+        ...resolveLabels(evaluation.labels, minConfidence),
+        model: evaluation.model,
+        usage: evaluation.usage,
+    });
+}
+export { proposalFacetsInputSchema, proposalFacetsResultSchema, proposalFacetsLabelSchema, } from './schema.js';

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

@@ -0,0 +1,95 @@
+import { z } from 'zod';
+export declare const proposalFacetsLabelSchema: z.ZodEnum<{
+    statesBudget: "statesBudget";
+    statesNeed: "statesNeed";
+    statesObjectives: "statesObjectives";
+    statesActivities: "statesActivities";
+    statesEvaluation: "statesEvaluation";
+}>;
+export declare const proposalFacetsInputSchema: z.ZodObject<{
+    proposal: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const proposalFacetsResultSchema: 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<{
+        statesBudget: "statesBudget";
+        statesNeed: "statesNeed";
+        statesObjectives: "statesObjectives";
+        statesActivities: "statesActivities";
+        statesEvaluation: "statesEvaluation";
+    }>>;
+    labels: z.ZodObject<{
+        statesNeed: 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>;
+        statesObjectives: 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>;
+        statesActivities: 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>;
+        statesBudget: 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>;
+        statesEvaluation: 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 ProposalFacetsLabel = z.infer<typeof proposalFacetsLabelSchema>;
+export type ProposalFacetsInput = z.infer<typeof proposalFacetsInputSchema>;
+export type ProposalFacetsResult = z.infer<typeof proposalFacetsResultSchema>;

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

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+import { labelCheckSchema, labelsResultSchema, nonEmptyText, probability, } from '../../src/schema.js';
+export const proposalFacetsLabelSchema = z.enum([
+    'statesNeed',
+    'statesObjectives',
+    'statesActivities',
+    'statesBudget',
+    'statesEvaluation',
+]);
+export const proposalFacetsInputSchema = z.object({
+    proposal: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const proposalFacetsResultSchema = labelsResultSchema.extend({
+    detected: z.array(proposalFacetsLabelSchema),
+    labels: z.object({
+        statesNeed: labelCheckSchema,
+        statesObjectives: labelCheckSchema,
+        statesActivities: labelCheckSchema,
+        statesBudget: labelCheckSchema,
+        statesEvaluation: labelCheckSchema,
+    }),
+});

package/dist/recipes/qualification-evidence/demo.json

@@ -0,0 +1,12 @@
+{
+  "input": {
+    "requirement": "At least three years of experience operating Kubernetes clusters in production.",
+    "profile": "Platform Engineer, Northwind Logistics, 2020 to present. Own the production Kubernetes platform (EKS, 12 clusters, 400 services). Led the migration from self-managed clusters to EKS in 2022 with zero customer-facing downtime. On-call rotation for cluster incidents; wrote the runbooks for node pool upgrades and etcd recovery. Skills: Kubernetes, Terraform, Go, Prometheus.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": { "gate": { "type": "noul", "noul": 0.94 } },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/qualification-evidence/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { QualificationEvidenceInput, QualificationEvidenceResult } from './schema.js';
+export declare function qualificationEvidence(input: QualificationEvidenceInput, options?: RecipeOptions): Promise<QualificationEvidenceResult>;
+export { qualificationEvidenceInputSchema, qualificationEvidenceResultSchema, qualificationEvidenceVerdictSchema, } from './schema.js';
+export type { QualificationEvidenceInput, QualificationEvidenceResult, QualificationEvidenceVerdict, } from './schema.js';

package/dist/recipes/qualification-evidence/index.js

@@ -0,0 +1,15 @@
+import { evaluateGate } from '../../src/gates.js';
+import { qualificationEvidenceInputSchema, qualificationEvidenceResultSchema } from './schema.js';
+export async function qualificationEvidence(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = qualificationEvidenceInputSchema.parse(input);
+    const decision = await evaluateGate(state, 'Does profile contain concrete evidence that the candidate meets requirement? Count described work, projects, outcomes, credentials, or durations that demonstrate the requirement in practice. Do not count a bare keyword, a skills-list entry, or a self-description with nothing behind it. Judge only what profile states; do not infer unstated experience.', {
+        true: 'The profile describes specific work or credentials that demonstrate the requirement.',
+        false: 'The profile mentions the requirement only as a keyword or claim, or does not address it.',
+    }, options);
+    return qualificationEvidenceResultSchema.parse({
+        ...decision,
+        verdict: decision.probability >= 0.5 ? 'evidenced' : 'unevidenced',
+        status: decision.confidence < minConfidence ? 'review' : 'ready',
+    });
+}
+export { qualificationEvidenceInputSchema, qualificationEvidenceResultSchema, qualificationEvidenceVerdictSchema, } from './schema.js';

package/dist/recipes/qualification-evidence/schema.d.ts

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+export declare const qualificationEvidenceVerdictSchema: z.ZodEnum<{
+    evidenced: "evidenced";
+    unevidenced: "unevidenced";
+}>;
+export declare const qualificationEvidenceInputSchema: z.ZodObject<{
+    requirement: z.ZodString;
+    profile: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const qualificationEvidenceResultSchema: 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<{
+        evidenced: "evidenced";
+        unevidenced: "unevidenced";
+    }>;
+}, z.core.$strip>;
+export type QualificationEvidenceVerdict = z.infer<typeof qualificationEvidenceVerdictSchema>;
+export type QualificationEvidenceInput = z.infer<typeof qualificationEvidenceInputSchema>;
+export type QualificationEvidenceResult = z.infer<typeof qualificationEvidenceResultSchema>;

package/dist/recipes/qualification-evidence/schema.js

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { gateResultSchema, nonEmptyText, probability } from '../../src/schema.js';
+export const qualificationEvidenceVerdictSchema = z.enum(['evidenced', 'unevidenced']);
+export const qualificationEvidenceInputSchema = z.object({
+    requirement: nonEmptyText,
+    profile: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const qualificationEvidenceResultSchema = gateResultSchema.extend({
+    verdict: qualificationEvidenceVerdictSchema,
+});

package/dist/recipes/query-equivalence/schema.d.ts

@@ -2,8 +2,8 @@ import { z } from 'zod';
 export declare const queryEquivalenceVerdictSchema: z.ZodEnum<{
     related: "related";
     unclear: "unclear";
-    equivalent: "equivalent";
     different: "different";
+    equivalent: "equivalent";
 }>;
 export declare const queryEquivalenceInputSchema: z.ZodObject<{
     firstQuestion: z.ZodString;
@@ -24,15 +24,15 @@ export declare const queryEquivalenceResultSchema: z.ZodObject<{
     verdict: z.ZodEnum<{
         related: "related";
         unclear: "unclear";
-        equivalent: "equivalent";
         different: "different";
+        equivalent: "equivalent";
     }>;
     confidence: z.ZodNumber;
     probabilities: z.ZodRecord<z.ZodEnum<{
         related: "related";
         unclear: "unclear";
-        equivalent: "equivalent";
         different: "different";
+        equivalent: "equivalent";
     }>, z.ZodNumber>;
 }, z.core.$strip>;
 export type QueryEquivalenceInput = z.infer<typeof queryEquivalenceInputSchema>;

package/dist/recipes/question-relevance/demo.json

@@ -0,0 +1,12 @@
+{
+  "input": {
+    "question": "You mentioned you have young kids. How would you handle the on-call rotation, and do you plan to have more children in the next couple of years?",
+    "role": "Site Reliability Engineer. Requirements: 3+ years running production services, experience with incident response, participation in a weekly on-call rotation, strong Linux and networking fundamentals.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": { "gate": { "type": "noul", "noul": 0.05 } },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/question-relevance/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { QuestionRelevanceInput, QuestionRelevanceResult } from './schema.js';
+export declare function questionRelevance(input: QuestionRelevanceInput, options?: RecipeOptions): Promise<QuestionRelevanceResult>;
+export { questionRelevanceInputSchema, questionRelevanceResultSchema, questionRelevanceVerdictSchema, } from './schema.js';
+export type { QuestionRelevanceInput, QuestionRelevanceResult, QuestionRelevanceVerdict, } from './schema.js';

package/dist/recipes/question-relevance/index.js

@@ -0,0 +1,15 @@
+import { evaluateGate } from '../../src/gates.js';
+import { questionRelevanceInputSchema, questionRelevanceResultSchema } from './schema.js';
+export async function questionRelevance(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = questionRelevanceInputSchema.parse(input);
+    const decision = await evaluateGate(state, 'Does question ask only about matters relevant to the requirements of role? Count skills, experience, availability, work authorization, and ability to perform the stated duties as relevant. Count personal circumstances unrelated to the work, such as family plans, age, health, religion, origin, or private life, as unrelated. A question is unrelated if any part of it probes such circumstances, even when another part is about the work.', {
+        true: 'Every part of the question concerns the stated requirements or duties of the role.',
+        false: 'Some part of the question probes personal circumstances unrelated to the role.',
+    }, options);
+    return questionRelevanceResultSchema.parse({
+        ...decision,
+        verdict: decision.probability >= 0.5 ? 'relevant' : 'unrelated',
+        status: decision.confidence < minConfidence ? 'review' : 'ready',
+    });
+}
+export { questionRelevanceInputSchema, questionRelevanceResultSchema, questionRelevanceVerdictSchema, } from './schema.js';

package/dist/recipes/question-relevance/schema.d.ts

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+export declare const questionRelevanceVerdictSchema: z.ZodEnum<{
+    unrelated: "unrelated";
+    relevant: "relevant";
+}>;
+export declare const questionRelevanceInputSchema: z.ZodObject<{
+    question: z.ZodString;
+    role: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const questionRelevanceResultSchema: 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<{
+        unrelated: "unrelated";
+        relevant: "relevant";
+    }>;
+}, z.core.$strip>;
+export type QuestionRelevanceVerdict = z.infer<typeof questionRelevanceVerdictSchema>;
+export type QuestionRelevanceInput = z.infer<typeof questionRelevanceInputSchema>;
+export type QuestionRelevanceResult = z.infer<typeof questionRelevanceResultSchema>;

package/dist/recipes/question-relevance/schema.js

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { gateResultSchema, nonEmptyText, probability } from '../../src/schema.js';
+export const questionRelevanceVerdictSchema = z.enum(['relevant', 'unrelated']);
+export const questionRelevanceInputSchema = z.object({
+    question: nonEmptyText,
+    role: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const questionRelevanceResultSchema = gateResultSchema.extend({
+    verdict: questionRelevanceVerdictSchema,
+});

package/dist/recipes/reconciliation-match/demo.json

@@ -0,0 +1,12 @@
+{
+  "input": {
+    "record": "2024-03-14 | Adobe Creative Cloud team subscription, monthly, design team | Vendor: Adobe Inc.",
+    "statementLine": "03/16 ADOBE *CREATIVE CLD 800-833-6687 CA PURCHASE",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": { "gate": { "type": "noul", "noul": 0.9 } },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/reconciliation-match/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { ReconciliationMatchInput, ReconciliationMatchResult } from './schema.js';
+export declare function reconciliationMatch(input: ReconciliationMatchInput, options?: RecipeOptions): Promise<ReconciliationMatchResult>;
+export { reconciliationMatchInputSchema, reconciliationMatchResultSchema, reconciliationMatchVerdictSchema, } from './schema.js';
+export type { ReconciliationMatchInput, ReconciliationMatchResult, ReconciliationMatchVerdict, } from './schema.js';

package/dist/recipes/reconciliation-match/index.js

@@ -0,0 +1,15 @@
+import { evaluateGate } from '../../src/gates.js';
+import { reconciliationMatchInputSchema, reconciliationMatchResultSchema } from './schema.js';
+export async function reconciliationMatch(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = reconciliationMatchInputSchema.parse(input);
+    const decision = await evaluateGate(state, 'Read the ledger record and the statementLine from a bank or card statement. Decide whether they describe the same transaction by comparing who was paid, what the payment was for, and when it happened, as each is worded. Allow for abbreviations, processor names, and posting delays of a few days that are normal for statements. Do not rely on amounts or exact dates matching; the caller checks those separately.', {
+        true: 'The payee, purpose, and timing wording of the two entries are consistent with a single transaction, allowing for abbreviated descriptors, processor names, and normal posting delays.',
+        false: 'The wording points to different payees, different purposes, or timing too far apart to be the same transaction.',
+    }, options);
+    return reconciliationMatchResultSchema.parse({
+        ...decision,
+        verdict: decision.probability >= 0.5 ? 'same' : 'different',
+        status: decision.confidence < minConfidence ? 'review' : 'ready',
+    });
+}
+export { reconciliationMatchInputSchema, reconciliationMatchResultSchema, reconciliationMatchVerdictSchema, } from './schema.js';

package/dist/recipes/reconciliation-match/schema.d.ts

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+export declare const reconciliationMatchVerdictSchema: z.ZodEnum<{
+    same: "same";
+    different: "different";
+}>;
+export declare const reconciliationMatchInputSchema: z.ZodObject<{
+    record: z.ZodString;
+    statementLine: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const reconciliationMatchResultSchema: 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<{
+        same: "same";
+        different: "different";
+    }>;
+}, z.core.$strip>;
+export type ReconciliationMatchVerdict = z.infer<typeof reconciliationMatchVerdictSchema>;
+export type ReconciliationMatchInput = z.infer<typeof reconciliationMatchInputSchema>;
+export type ReconciliationMatchResult = z.infer<typeof reconciliationMatchResultSchema>;

package/dist/recipes/reconciliation-match/schema.js

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { gateResultSchema, nonEmptyText, probability } from '../../src/schema.js';
+export const reconciliationMatchVerdictSchema = z.enum(['same', 'different']);
+export const reconciliationMatchInputSchema = z.object({
+    record: nonEmptyText,
+    statementLine: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const reconciliationMatchResultSchema = gateResultSchema.extend({
+    verdict: reconciliationMatchVerdictSchema,
+});

package/dist/recipes/repetition-level/demo.json

@@ -0,0 +1,18 @@
+{
+  "input": {
+    "recentMaterial": "C4 E4 G4 E4 | C4 E4 G4 E4 | C4 E4 G4 E4 | C4 E4 G4 E4 | C4 E4 G4 E4 | C4 E4 G4 E4 (all quarter notes, same dynamic, no rests)",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": {
+      "score": {
+        "type": "score",
+        "score": 2.94,
+        "confidence": 0.85,
+        "probabilities": { "0": 0.01, "1": 0.01, "2": 0.07, "3": 0.85, "4": 0.06 }
+      }
+    },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/repetition-level/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { RepetitionLevelInput, RepetitionLevelResult } from './schema.js';
+export declare function repetitionLevel(input: RepetitionLevelInput, options?: RecipeOptions): Promise<RepetitionLevelResult>;
+export { repetitionLevelInputSchema, repetitionLevelResultSchema, repetitionLevelVerdictSchema, } from './schema.js';
+export type { RepetitionLevelInput, RepetitionLevelResult, RepetitionLevelVerdict, } from './schema.js';

package/dist/recipes/repetition-level/index.js

@@ -0,0 +1,18 @@
+import { evaluateScore } from '../../src/scores.js';
+import { repetitionLevelInputSchema, repetitionLevelResultSchema, repetitionLevelVerdictSchema, } from './schema.js';
+export async function repetitionLevel(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = repetitionLevelInputSchema.parse(input);
+    const decision = await evaluateScore(state, 'How repetitive is recentMaterial? Judge only the material supplied: how often the same pitches, figure, or rhythm return, whether repeats are exact or altered, and whether anything new appears between them. Varied material keeps changing contour, rhythm, or pitch content. Some repetition means a figure recurs but is answered by new material. Repetitive means the same figure or rhythm dominates with only small changes such as one altered note or a shift of register. Looping means the same figure repeats several times verbatim with nothing new between repeats. Stuck means the material has collapsed to a single note, interval, or chord with no other content at all. Ignore whether the repetition is stylistically appropriate.', [
+        'The material changes contour, rhythm, or pitch content from figure to figure, with at most an incidental echo.',
+        'A figure or rhythm recurs once or twice but is answered or followed by new material.',
+        'The same figure or rhythm returns for most of the material with only small changes, such as one altered note or a shift of register.',
+        'The same figure repeats several times verbatim with nothing new between the repeats.',
+        'The material has collapsed to a single note, interval, or chord repeated with no other content at all.',
+    ], options);
+    return repetitionLevelResultSchema.parse({
+        ...decision,
+        repetition: repetitionLevelVerdictSchema.options[decision.level],
+        status: decision.confidence < minConfidence ? 'review' : 'ready',
+    });
+}
+export { repetitionLevelInputSchema, repetitionLevelResultSchema, repetitionLevelVerdictSchema, } from './schema.js';

package/dist/recipes/repetition-level/schema.d.ts

@@ -0,0 +1,37 @@
+import { z } from 'zod';
+export declare const repetitionLevelVerdictSchema: z.ZodEnum<{
+    some: "some";
+    varied: "varied";
+    repetitive: "repetitive";
+    looping: "looping";
+    stuck: "stuck";
+}>;
+export declare const repetitionLevelInputSchema: z.ZodObject<{
+    recentMaterial: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const repetitionLevelResultSchema: 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>;
+    repetition: z.ZodEnum<{
+        some: "some";
+        varied: "varied";
+        repetitive: "repetitive";
+        looping: "looping";
+        stuck: "stuck";
+    }>;
+}, z.core.$strip>;
+export type RepetitionLevelVerdict = z.infer<typeof repetitionLevelVerdictSchema>;
+export type RepetitionLevelInput = z.infer<typeof repetitionLevelInputSchema>;
+export type RepetitionLevelResult = z.infer<typeof repetitionLevelResultSchema>;

package/dist/recipes/repetition-level/schema.js

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import { nonEmptyText, probability, scoreResultSchema } from '../../src/schema.js';
+export const repetitionLevelVerdictSchema = z.enum([
+    'varied',
+    'some',
+    'repetitive',
+    'looping',
+    'stuck',
+]);
+export const repetitionLevelInputSchema = z.object({
+    recentMaterial: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const repetitionLevelResultSchema = scoreResultSchema.extend({
+    repetition: repetitionLevelVerdictSchema,
+});

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

@@ -0,0 +1,17 @@
+{
+  "input": {
+    "report": "Migrated 4 of the 6 legacy endpoints to the new router; all 38 tests in tests/api pass (run log attached). The remaining two endpoints depend on the auth middleware rewrite, which is still blocked on the token format decision from the platform team. Next I will stub the middleware so the last two endpoints can be migrated behind a feature flag.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": {
+      "statesOutcome": { "type": "noul", "noul": 0.95 },
+      "providesEvidence": { "type": "noul", "noul": 0.88 },
+      "statesBlockers": { "type": "noul", "noul": 0.91 },
+      "statesNextStep": { "type": "noul", "noul": 0.93 },
+      "raisesQuestions": { "type": "noul", "noul": 0.12 }
+    },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

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

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { ReportFacetsInput, ReportFacetsResult } from './schema.js';
+export declare function reportFacets(input: ReportFacetsInput, options?: RecipeOptions): Promise<ReportFacetsResult>;
+export { reportFacetsInputSchema, reportFacetsResultSchema, reportFacetsLabelSchema, } from './schema.js';
+export type { ReportFacetsInput, ReportFacetsResult, ReportFacetsLabel } from './schema.js';

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

@@ -0,0 +1,48 @@
+import { evaluateLabels, resolveLabels } from '../../src/labels.js';
+import { reportFacetsInputSchema, reportFacetsResultSchema } from './schema.js';
+export async function reportFacets(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = reportFacetsInputSchema.parse(input);
+    const evaluation = await evaluateLabels(state, {
+        statesOutcome: {
+            instruction: 'Does report state an outcome: what was accomplished, what failed, or what the current result is?',
+            criteria: {
+                true: 'The report states what was achieved, what failed, or where the work stands.',
+                false: 'The report describes activity without stating an outcome.',
+            },
+        },
+        providesEvidence: {
+            instruction: 'Does report provide evidence that supports its claims, such as test output, measurements, file paths, quotes, or links?',
+            criteria: {
+                true: 'The report includes concrete evidence a reader could check.',
+                false: 'The report makes claims without supporting evidence.',
+            },
+        },
+        statesBlockers: {
+            instruction: 'Does report state a blocker: something preventing progress that the agent cannot resolve alone?',
+            criteria: {
+                true: 'The report names at least one blocker or obstacle to progress.',
+                false: 'The report names no blocker.',
+            },
+        },
+        statesNextStep: {
+            instruction: 'Does report state a next step: what the agent will do, or proposes to do, after this report?',
+            criteria: {
+                true: 'The report states a concrete next step.',
+                false: 'The report states no next step.',
+            },
+        },
+        raisesQuestions: {
+            instruction: 'Does report raise an open question or request a decision from the reader?',
+            criteria: {
+                true: 'The report asks at least one question or requests a decision.',
+                false: 'The report asks nothing of the reader.',
+            },
+        },
+    }, options);
+    return reportFacetsResultSchema.parse({
+        ...resolveLabels(evaluation.labels, minConfidence),
+        model: evaluation.model,
+        usage: evaluation.usage,
+    });
+}
+export { reportFacetsInputSchema, reportFacetsResultSchema, reportFacetsLabelSchema, } from './schema.js';