jev-recipes 0.5.2 → 0.6.0

package/dist/recipes/review-comment-kind/schema.js

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+import { decisionStatusSchema, nonEmptyText, probability, resultMetadataSchema, } from '../../src/schema.js';
+export const reviewCommentKindVerdictSchema = z.enum([
+    'bug',
+    'design',
+    'style',
+    'question',
+    'nit',
+    'praise',
+    'unclear',
+]);
+export const reviewCommentKindInputSchema = z.object({
+    comment: nonEmptyText,
+    context: nonEmptyText.optional(),
+    minConfidence: probability.optional(),
+});
+export const reviewCommentKindResultSchema = resultMetadataSchema.extend({
+    status: decisionStatusSchema,
+    verdict: reviewCommentKindVerdictSchema,
+    confidence: probability,
+    probabilities: z.record(reviewCommentKindVerdictSchema, probability),
+});

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

@@ -0,0 +1,17 @@
+{
+  "input": {
+    "review": "The blender itself is solid and crushes ice with no trouble, and for the sale price it was a steal. Unfortunately the box arrived dented and the lid gasket was torn, so it leaks. Support sent a replacement gasket within two days, which I appreciated.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": {
+      "mentionsQuality": { "type": "noul", "noul": 0.95 },
+      "mentionsPrice": { "type": "noul", "noul": 0.93 },
+      "mentionsShipping": { "type": "noul", "noul": 0.88 },
+      "mentionsService": { "type": "noul", "noul": 0.96 },
+      "reportsDefect": { "type": "noul", "noul": 0.94 }
+    },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

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

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { ReviewFacetsInput, ReviewFacetsResult } from './schema.js';
+export declare function reviewFacets(input: ReviewFacetsInput, options?: RecipeOptions): Promise<ReviewFacetsResult>;
+export { reviewFacetsInputSchema, reviewFacetsResultSchema, reviewFacetsLabelSchema, } from './schema.js';
+export type { ReviewFacetsInput, ReviewFacetsResult, ReviewFacetsLabel } from './schema.js';

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

@@ -0,0 +1,48 @@
+import { evaluateLabels, resolveLabels } from '../../src/labels.js';
+import { reviewFacetsInputSchema, reviewFacetsResultSchema } from './schema.js';
+export async function reviewFacets(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = reviewFacetsInputSchema.parse(input);
+    const evaluation = await evaluateLabels(state, {
+        mentionsQuality: {
+            instruction: 'Does review comment on the quality of the product itself, such as materials, build, durability, performance, taste, or how well it works?',
+            criteria: {
+                true: 'The review comments on the quality or performance of the product.',
+                false: 'The review says nothing about product quality or performance.',
+            },
+        },
+        mentionsPrice: {
+            instruction: 'Does review comment on the price, cost, value for money, or a discount or deal?',
+            criteria: {
+                true: 'The review comments on price or value for money.',
+                false: 'The review says nothing about price or value.',
+            },
+        },
+        mentionsShipping: {
+            instruction: 'Does review comment on shipping, delivery speed, packaging, or the condition the parcel arrived in?',
+            criteria: {
+                true: 'The review comments on shipping, delivery, or packaging.',
+                false: 'The review says nothing about shipping, delivery, or packaging.',
+            },
+        },
+        mentionsService: {
+            instruction: 'Does review comment on customer service, support, returns handling, or interaction with the seller or staff?',
+            criteria: {
+                true: 'The review comments on customer service or the seller interaction.',
+                false: 'The review says nothing about customer service or the seller.',
+            },
+        },
+        reportsDefect: {
+            instruction: 'Does review report that the product was broken, damaged, missing parts, malfunctioning, or otherwise not working as intended?',
+            criteria: {
+                true: 'The review reports a specific defect or malfunction in the product received.',
+                false: 'The review reports no defect; general dissatisfaction alone does not count.',
+            },
+        },
+    }, options);
+    return reviewFacetsResultSchema.parse({
+        ...resolveLabels(evaluation.labels, minConfidence),
+        model: evaluation.model,
+        usage: evaluation.usage,
+    });
+}
+export { reviewFacetsInputSchema, reviewFacetsResultSchema, reviewFacetsLabelSchema, } from './schema.js';

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

@@ -0,0 +1,95 @@
+import { z } from 'zod';
+export declare const reviewFacetsLabelSchema: z.ZodEnum<{
+    mentionsQuality: "mentionsQuality";
+    mentionsPrice: "mentionsPrice";
+    mentionsShipping: "mentionsShipping";
+    mentionsService: "mentionsService";
+    reportsDefect: "reportsDefect";
+}>;
+export declare const reviewFacetsInputSchema: z.ZodObject<{
+    review: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const reviewFacetsResultSchema: 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<{
+        mentionsQuality: "mentionsQuality";
+        mentionsPrice: "mentionsPrice";
+        mentionsShipping: "mentionsShipping";
+        mentionsService: "mentionsService";
+        reportsDefect: "reportsDefect";
+    }>>;
+    labels: z.ZodObject<{
+        mentionsQuality: 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>;
+        mentionsPrice: 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>;
+        mentionsShipping: 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>;
+        mentionsService: 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>;
+        reportsDefect: 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 ReviewFacetsLabel = z.infer<typeof reviewFacetsLabelSchema>;
+export type ReviewFacetsInput = z.infer<typeof reviewFacetsInputSchema>;
+export type ReviewFacetsResult = z.infer<typeof reviewFacetsResultSchema>;

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

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+import { labelCheckSchema, labelsResultSchema, nonEmptyText, probability, } from '../../src/schema.js';
+export const reviewFacetsLabelSchema = z.enum([
+    'mentionsQuality',
+    'mentionsPrice',
+    'mentionsShipping',
+    'mentionsService',
+    'reportsDefect',
+]);
+export const reviewFacetsInputSchema = z.object({
+    review: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const reviewFacetsResultSchema = labelsResultSchema.extend({
+    detected: z.array(reviewFacetsLabelSchema),
+    labels: z.object({
+        mentionsQuality: labelCheckSchema,
+        mentionsPrice: labelCheckSchema,
+        mentionsShipping: labelCheckSchema,
+        mentionsService: labelCheckSchema,
+        reportsDefect: labelCheckSchema,
+    }),
+});

package/dist/recipes/review-recommendation-kind/demo.json

@@ -0,0 +1,24 @@
+{
+  "input": {
+    "review": "The paper addresses an important question and the experimental setup is generally careful. However, the central claim in Section 5 rests on the independence assumption introduced in Section 3, which the authors never test, and the baseline comparison omits the two strongest recent methods. I would need to see the assumption validated and the comparison extended before I could support publication. The writing issues I noted in the margins are secondary and easy to fix.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": {
+      "decision": {
+        "type": "choice",
+        "choice": "major_revision",
+        "confidence": 0.86,
+        "probabilities": {
+          "accept": 0.01,
+          "minor_revision": 0.04,
+          "major_revision": 0.86,
+          "reject": 0.07,
+          "unclear": 0.02
+        }
+      }
+    },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/review-recommendation-kind/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { ReviewRecommendationKindInput, ReviewRecommendationKindResult } from './schema.js';
+export declare function reviewRecommendationKind(input: ReviewRecommendationKindInput, options?: RecipeOptions): Promise<ReviewRecommendationKindResult>;
+export { reviewRecommendationKindInputSchema, reviewRecommendationKindResultSchema, reviewRecommendationKindVerdictSchema, } from './schema.js';
+export type { ReviewRecommendationKindInput, ReviewRecommendationKindResult, ReviewRecommendationKindVerdict, } from './schema.js';

package/dist/recipes/review-recommendation-kind/index.js

@@ -0,0 +1,17 @@
+import { evaluateChoice } from '../../src/decisions.js';
+import { reviewRecommendationKindInputSchema, reviewRecommendationKindResultSchema, } from './schema.js';
+export async function reviewRecommendationKind(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = reviewRecommendationKindInputSchema.parse(input);
+    const decision = await evaluateChoice(state, "Read review and decide which recommendation its wording expresses about the manuscript. Judge by what the reviewer says must happen before publication: nothing, small fixes, substantial new work or rewriting, or that it should not be published. Weigh the reviewer's stated conditions over the amount of praise or criticism. Use unclear when the text lists observations without committing to any disposition.", {
+        accept: 'The reviewer says the manuscript can be published as is or with only optional or cosmetic changes.',
+        minor_revision: 'The reviewer supports publication once specific small fixes are made, such as clarifications, typos, missing references, or presentation changes, without new experiments or analysis.',
+        major_revision: 'The reviewer withholds support until substantial new work is done, such as new experiments, reanalysis, addressing a flawed assumption, or significant restructuring, but does not rule out eventual publication.',
+        reject: 'The reviewer says the manuscript should not be published, or describes flaws it says cannot be fixed by revision.',
+        unclear: 'The review lists observations, questions, or mixed remarks without committing to what should happen to the manuscript.',
+    }, options);
+    return reviewRecommendationKindResultSchema.parse({
+        ...decision,
+        status: decision.confidence < minConfidence || decision.verdict === 'unclear' ? 'review' : 'ready',
+    });
+}
+export { reviewRecommendationKindInputSchema, reviewRecommendationKindResultSchema, reviewRecommendationKindVerdictSchema, } from './schema.js';

package/dist/recipes/review-recommendation-kind/schema.d.ts

@@ -0,0 +1,41 @@
+import { z } from 'zod';
+export declare const reviewRecommendationKindVerdictSchema: z.ZodEnum<{
+    unclear: "unclear";
+    accept: "accept";
+    minor_revision: "minor_revision";
+    major_revision: "major_revision";
+    reject: "reject";
+}>;
+export declare const reviewRecommendationKindInputSchema: z.ZodObject<{
+    review: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const reviewRecommendationKindResultSchema: 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";
+        accept: "accept";
+        minor_revision: "minor_revision";
+        major_revision: "major_revision";
+        reject: "reject";
+    }>;
+    confidence: z.ZodNumber;
+    probabilities: z.ZodRecord<z.ZodEnum<{
+        unclear: "unclear";
+        accept: "accept";
+        minor_revision: "minor_revision";
+        major_revision: "major_revision";
+        reject: "reject";
+    }>, z.ZodNumber>;
+}, z.core.$strip>;
+export type ReviewRecommendationKindVerdict = z.infer<typeof reviewRecommendationKindVerdictSchema>;
+export type ReviewRecommendationKindInput = z.infer<typeof reviewRecommendationKindInputSchema>;
+export type ReviewRecommendationKindResult = z.infer<typeof reviewRecommendationKindResultSchema>;

package/dist/recipes/review-recommendation-kind/schema.js

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+import { decisionStatusSchema, nonEmptyText, probability, resultMetadataSchema, } from '../../src/schema.js';
+export const reviewRecommendationKindVerdictSchema = z.enum([
+    'accept',
+    'minor_revision',
+    'major_revision',
+    'reject',
+    'unclear',
+]);
+export const reviewRecommendationKindInputSchema = z.object({
+    review: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const reviewRecommendationKindResultSchema = resultMetadataSchema.extend({
+    status: decisionStatusSchema,
+    verdict: reviewRecommendationKindVerdictSchema,
+    confidence: probability,
+    probabilities: z.record(reviewRecommendationKindVerdictSchema, probability),
+});

package/dist/recipes/review-response-fit/demo.json

@@ -0,0 +1,12 @@
+{
+  "input": {
+    "review": "Three stars. The rooftop pool and the breakfast were genuinely excellent, and the front desk upgraded us without asking. But the air conditioning in room 412 rattled all night and maintenance never showed up after we called twice. We also waited 40 minutes for the airport shuttle that was supposed to run every 15.",
+    "response": "Thank you for staying with us and for the kind words about the rooftop pool and breakfast; I have passed your compliment to the front desk team. I am sorry about the noisy air conditioning unit in 412 and that maintenance did not respond after two calls; that unit has now been replaced and we are reviewing how after-hours requests are dispatched. The shuttle delay is not the service we promise, and we have added a second vehicle during peak hours. I hope you will give us another chance.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": { "gate": { "type": "noul", "noul": 0.94 } },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/review-response-fit/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { ReviewResponseFitInput, ReviewResponseFitResult } from './schema.js';
+export declare function reviewResponseFit(input: ReviewResponseFitInput, options?: RecipeOptions): Promise<ReviewResponseFitResult>;
+export { reviewResponseFitInputSchema, reviewResponseFitResultSchema, reviewResponseFitVerdictSchema, } from './schema.js';
+export type { ReviewResponseFitInput, ReviewResponseFitResult, ReviewResponseFitVerdict, } from './schema.js';

package/dist/recipes/review-response-fit/index.js

@@ -0,0 +1,15 @@
+import { evaluateGate } from '../../src/gates.js';
+import { reviewResponseFitInputSchema, reviewResponseFitResultSchema } from './schema.js';
+export async function reviewResponseFit(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = reviewResponseFitInputSchema.parse(input);
+    const decision = await evaluateGate(state, 'Judge whether response addresses the specific complaints and praise raised in review. A response addresses the review when it refers to the particular issues or compliments the reviewer raised, even briefly. A response is generic when it could be posted under any review: a thank-you, a general apology, or an invitation to return with no reference to what this reviewer said. Ignore tone, length, and whether the response offers compensation.', {
+        true: 'The response refers to the specific complaints or praise in the review, such as naming the problem the reviewer described or the thing they liked.',
+        false: 'The response contains only general thanks, apology, or marketing language that does not refer to anything particular in the review.',
+    }, options);
+    return reviewResponseFitResultSchema.parse({
+        ...decision,
+        verdict: decision.probability >= 0.5 ? 'addresses' : 'generic',
+        status: decision.confidence < minConfidence ? 'review' : 'ready',
+    });
+}
+export { reviewResponseFitInputSchema, reviewResponseFitResultSchema, reviewResponseFitVerdictSchema, } from './schema.js';

package/dist/recipes/review-response-fit/schema.d.ts

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+export declare const reviewResponseFitVerdictSchema: z.ZodEnum<{
+    addresses: "addresses";
+    generic: "generic";
+}>;
+export declare const reviewResponseFitInputSchema: z.ZodObject<{
+    review: z.ZodString;
+    response: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const reviewResponseFitResultSchema: 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";
+        generic: "generic";
+    }>;
+}, z.core.$strip>;
+export type ReviewResponseFitVerdict = z.infer<typeof reviewResponseFitVerdictSchema>;
+export type ReviewResponseFitInput = z.infer<typeof reviewResponseFitInputSchema>;
+export type ReviewResponseFitResult = z.infer<typeof reviewResponseFitResultSchema>;

package/dist/recipes/review-response-fit/schema.js

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { gateResultSchema, nonEmptyText, probability } from '../../src/schema.js';
+export const reviewResponseFitVerdictSchema = z.enum(['addresses', 'generic']);
+export const reviewResponseFitInputSchema = z.object({
+    review: nonEmptyText,
+    response: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const reviewResponseFitResultSchema = gateResultSchema.extend({
+    verdict: reviewResponseFitVerdictSchema,
+});

package/dist/recipes/rollback-signal/demo.json

@@ -0,0 +1,12 @@
+{
+  "input": {
+    "symptoms": "Starting at 09:42 UTC the error rate on POST /orders jumped from 0.2% to 8%. Every failure is a null reference in PricingService.applyDiscount. GET endpoints and the cart service are unaffected.",
+    "change": "Deployed at 09:40 UTC: PricingService now loads discount rules lazily from the new promotions table instead of the in-memory cache. Only the pricing module was touched; no schema or infrastructure changes.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": { "gate": { "type": "noul", "noul": 0.94 } },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/rollback-signal/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { RollbackSignalInput, RollbackSignalResult } from './schema.js';
+export declare function rollbackSignal(input: RollbackSignalInput, options?: RecipeOptions): Promise<RollbackSignalResult>;
+export { rollbackSignalInputSchema, rollbackSignalResultSchema, rollbackSignalVerdictSchema, } from './schema.js';
+export type { RollbackSignalInput, RollbackSignalResult, RollbackSignalVerdict } from './schema.js';

package/dist/recipes/rollback-signal/index.js

@@ -0,0 +1,15 @@
+import { evaluateGate } from '../../src/gates.js';
+import { rollbackSignalInputSchema, rollbackSignalResultSchema } from './schema.js';
+export async function rollbackSignal(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = rollbackSignalInputSchema.parse(input);
+    const decision = await evaluateGate(state, 'Do symptoms plausibly point at change as the cause? Answer yes only when the onset described in symptoms follows the deploy described in change and the affected functionality overlaps the code, service, or configuration the change touched. Judge only the timing and scope stated in the two texts. Ignore how risky the change sounds in general, and do not assume a cause the texts do not describe.', {
+        true: 'The onset in symptoms follows the deploy in change, and the failing functionality overlaps the area the change touched.',
+        false: 'The symptoms began before the change, affect an area the change did not touch, or describe a failure mode the change could not plausibly produce.',
+    }, options);
+    return rollbackSignalResultSchema.parse({
+        ...decision,
+        verdict: decision.probability >= 0.5 ? 'implicated' : 'unrelated',
+        status: decision.confidence < minConfidence ? 'review' : 'ready',
+    });
+}
+export { rollbackSignalInputSchema, rollbackSignalResultSchema, rollbackSignalVerdictSchema, } from './schema.js';

package/dist/recipes/rollback-signal/schema.d.ts

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+export declare const rollbackSignalVerdictSchema: z.ZodEnum<{
+    unrelated: "unrelated";
+    implicated: "implicated";
+}>;
+export declare const rollbackSignalInputSchema: z.ZodObject<{
+    symptoms: z.ZodString;
+    change: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const rollbackSignalResultSchema: 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";
+        implicated: "implicated";
+    }>;
+}, z.core.$strip>;
+export type RollbackSignalVerdict = z.infer<typeof rollbackSignalVerdictSchema>;
+export type RollbackSignalInput = z.infer<typeof rollbackSignalInputSchema>;
+export type RollbackSignalResult = z.infer<typeof rollbackSignalResultSchema>;

package/dist/recipes/rollback-signal/schema.js

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { gateResultSchema, nonEmptyText, probability } from '../../src/schema.js';
+export const rollbackSignalVerdictSchema = z.enum(['implicated', 'unrelated']);
+export const rollbackSignalInputSchema = z.object({
+    symptoms: nonEmptyText,
+    change: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const rollbackSignalResultSchema = gateResultSchema.extend({
+    verdict: rollbackSignalVerdictSchema,
+});

package/dist/recipes/root-cause-depth/demo.json

@@ -0,0 +1,18 @@
+{
+  "input": {
+    "analysis": "Line 3 stopped twice this week because the conveyor drive motor tripped on overtemperature. The motor overheated because the cooling fan intake was packed with cardboard dust. The intake was clogged because the weekly intake cleaning task was not performed for about eleven weeks. That task was dropped when the preventive maintenance schedule was migrated to the new CMMS in June: the migration checklist had no step to reconcile task counts between the old and new systems, and no one was assigned to own the migration, so the missing task was never noticed.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": {
+      "score": {
+        "type": "score",
+        "score": 2.88,
+        "confidence": 0.82,
+        "probabilities": { "0": 0.01, "1": 0.02, "2": 0.1, "3": 0.82, "4": 0.05 }
+      }
+    },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/root-cause-depth/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { RootCauseDepthInput, RootCauseDepthResult } from './schema.js';
+export declare function rootCauseDepth(input: RootCauseDepthInput, options?: RecipeOptions): Promise<RootCauseDepthResult>;
+export { rootCauseDepthInputSchema, rootCauseDepthResultSchema, rootCauseDepthVerdictSchema, } from './schema.js';
+export type { RootCauseDepthInput, RootCauseDepthResult, RootCauseDepthVerdict } from './schema.js';

package/dist/recipes/root-cause-depth/index.js

@@ -0,0 +1,18 @@
+import { evaluateScore } from '../../src/scores.js';
+import { rootCauseDepthInputSchema, rootCauseDepthResultSchema, rootCauseDepthVerdictSchema, } from './schema.js';
+export async function rootCauseDepth(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = rootCauseDepthInputSchema.parse(input);
+    const decision = await evaluateScore(state, 'How deep does analysis go in explaining the failure it describes? Judge only the chain of causes that analysis states. A symptom is what was observed. An immediate cause is the direct mechanism that produced it. A contributing cause is a condition that allowed the immediate cause to occur. A systemic cause is a process, design, or organizational condition that would produce the failure again if unchanged. Verification is a stated check that confirmed the cause, such as a test, a data review, or a reproduction. Ignore length, formatting, whether a named method like 5 Whys is mentioned, and whether the causes named are actually correct.', [
+        'The analysis restates what went wrong or where it was observed without naming any cause.',
+        'The analysis names the direct mechanism that produced the failure, such as a worn tool or a wrong setting, and stops there.',
+        'The analysis names the immediate cause and at least one condition that allowed it, such as a skipped check or an unclear instruction, without reaching a process or design condition.',
+        'The analysis traces the chain to a process, design, or organizational condition that would produce the failure again if left unchanged.',
+        'The analysis names a systemic cause and states how that cause was confirmed, such as a test, a data review, or reproducing the failure.',
+    ], options);
+    return rootCauseDepthResultSchema.parse({
+        ...decision,
+        depth: rootCauseDepthVerdictSchema.options[decision.level],
+        status: decision.confidence < minConfidence ? 'review' : 'ready',
+    });
+}
+export { rootCauseDepthInputSchema, rootCauseDepthResultSchema, rootCauseDepthVerdictSchema, } from './schema.js';

package/dist/recipes/root-cause-depth/schema.d.ts

@@ -0,0 +1,37 @@
+import { z } from 'zod';
+export declare const rootCauseDepthVerdictSchema: z.ZodEnum<{
+    symptom: "symptom";
+    immediate: "immediate";
+    contributing: "contributing";
+    systemic: "systemic";
+    verified: "verified";
+}>;
+export declare const rootCauseDepthInputSchema: z.ZodObject<{
+    analysis: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const rootCauseDepthResultSchema: 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>;
+    depth: z.ZodEnum<{
+        symptom: "symptom";
+        immediate: "immediate";
+        contributing: "contributing";
+        systemic: "systemic";
+        verified: "verified";
+    }>;
+}, z.core.$strip>;
+export type RootCauseDepthVerdict = z.infer<typeof rootCauseDepthVerdictSchema>;
+export type RootCauseDepthInput = z.infer<typeof rootCauseDepthInputSchema>;
+export type RootCauseDepthResult = z.infer<typeof rootCauseDepthResultSchema>;

package/dist/recipes/root-cause-depth/schema.js

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import { nonEmptyText, probability, scoreResultSchema } from '../../src/schema.js';
+export const rootCauseDepthVerdictSchema = z.enum([
+    'symptom',
+    'immediate',
+    'contributing',
+    'systemic',
+    'verified',
+]);
+export const rootCauseDepthInputSchema = z.object({
+    analysis: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const rootCauseDepthResultSchema = scoreResultSchema.extend({
+    depth: rootCauseDepthVerdictSchema,
+});

package/dist/recipes/rule-compliance/demo.json

@@ -0,0 +1,12 @@
+{
+  "input": {
+    "action": "On my turn I play a Draw Two card on top of a red 7 that is showing on the discard pile. My Draw Two is blue.",
+    "rules": "UNO. On your turn you must play a card that matches the top discard by color, number, or symbol. Draw Two, Reverse, and Skip cards may be played on a top card of the same color or on another card of the same symbol. Wild cards may be played on anything. If you cannot play, draw one card; if it is playable you may play it immediately.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": { "gate": { "type": "noul", "noul": 0.05 } },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/rule-compliance/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { RuleComplianceInput, RuleComplianceResult } from './schema.js';
+export declare function ruleCompliance(input: RuleComplianceInput, options?: RecipeOptions): Promise<RuleComplianceResult>;
+export { ruleComplianceInputSchema, ruleComplianceResultSchema, ruleComplianceVerdictSchema, } from './schema.js';
+export type { RuleComplianceInput, RuleComplianceResult, RuleComplianceVerdict } from './schema.js';

package/dist/recipes/rule-compliance/index.js

@@ -0,0 +1,15 @@
+import { evaluateGate } from '../../src/gates.js';
+import { ruleComplianceInputSchema, ruleComplianceResultSchema } from './schema.js';
+export async function ruleCompliance(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = ruleComplianceInputSchema.parse(input);
+    const decision = await evaluateGate(state, 'Is action permitted by rules? Read rules as the complete authority. Treat the action as legal when nothing in rules forbids it and any conditions rules place on that kind of action are met by the details given in action. Treat it as illegal when rules forbid it outright, require a condition that action states is not met, or describe the action as available only in a situation action does not match. Do not apply rules that are not written in rules, and do not judge whether the action is wise.', {
+        true: 'Nothing in the written rules forbids the action, and every condition the rules attach to that kind of action is satisfied by the details given.',
+        false: 'The written rules forbid the action, or attach a condition to it that the described situation does not satisfy.',
+    }, options);
+    return ruleComplianceResultSchema.parse({
+        ...decision,
+        verdict: decision.probability >= 0.5 ? 'legal' : 'illegal',
+        status: decision.confidence < minConfidence ? 'review' : 'ready',
+    });
+}
+export { ruleComplianceInputSchema, ruleComplianceResultSchema, ruleComplianceVerdictSchema, } from './schema.js';