jev-recipes 0.3.0 → 0.4.0

package/dist/recipes/constraint-strength/schema.js

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+import { decisionStatusSchema, nonEmptyText, probability, resultMetadataSchema, } from '../../src/schema.js';
+export const constraintStrengthVerdictSchema = z.enum([
+    'required',
+    'preferred',
+    'optional',
+    'unclear',
+]);
+export const constraintStrengthInputSchema = z.object({
+    statement: nonEmptyText.describe('One constraint or preference to interpret.'),
+    context: nonEmptyText
+        .describe('The surrounding request and any qualifications that clarify its force.')
+        .optional(),
+    minConfidence: probability.optional(),
+});
+export const constraintStrengthResultSchema = resultMetadataSchema.extend({
+    status: decisionStatusSchema,
+    verdict: constraintStrengthVerdictSchema,
+    confidence: probability,
+    probabilities: z.record(constraintStrengthVerdictSchema, probability),
+});

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

@@ -1,8 +1,8 @@
 import { z } from 'zod';
 export declare const evidenceConflictVerdictSchema: z.ZodEnum<{
+    compatible: "compatible";
     unclear: "unclear";
     conflicting: "conflicting";
-    compatible: "compatible";
     different_scope: "different_scope";
 }>;
 export declare const evidenceConflictInputSchema: z.ZodObject<{
@@ -22,16 +22,16 @@ export declare const evidenceConflictResultSchema: z.ZodObject<{
         review: "review";
     }>;
     verdict: z.ZodEnum<{
+        compatible: "compatible";
         unclear: "unclear";
         conflicting: "conflicting";
-        compatible: "compatible";
         different_scope: "different_scope";
     }>;
     confidence: z.ZodNumber;
     probabilities: z.ZodRecord<z.ZodEnum<{
+        compatible: "compatible";
         unclear: "unclear";
         conflicting: "conflicting";
-        compatible: "compatible";
         different_scope: "different_scope";
     }>, z.ZodNumber>;
 }, z.core.$strip>;

package/dist/recipes/instruction-conflict/demo.json

@@ -0,0 +1,27 @@
+{
+  "input": {
+    "firstInstruction": "Send the report as a PDF attachment.",
+    "secondInstruction": "Send the report only as plain text in the email body; do not attach any files.",
+    "context": "Both instructions apply to the same outgoing report email."
+  },
+  "response": {
+    "model": "demo-fixture",
+    "usage": {
+      "input_tokens": 0,
+      "output_tokens": 0
+    },
+    "answers": {
+      "decision": {
+        "type": "choice",
+        "choice": "conflicting",
+        "confidence": 0.96,
+        "probabilities": {
+          "compatible": 0.013333333333333334,
+          "conflicting": 0.96,
+          "different_scope": 0.013333333333333334,
+          "unclear": 0.013333333333333334
+        }
+      }
+    }
+  }
+}

package/dist/recipes/instruction-conflict/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { InstructionConflictInput, InstructionConflictResult } from './schema.js';
+export declare function instructionConflict(input: InstructionConflictInput, options?: RecipeOptions): Promise<InstructionConflictResult>;
+export { instructionConflictInputSchema, instructionConflictResultSchema, instructionConflictVerdictSchema, } from './schema.js';
+export type { InstructionConflictInput, InstructionConflictResult, InstructionConflictVerdict, } from './schema.js';

package/dist/recipes/instruction-conflict/index.js

@@ -0,0 +1,16 @@
+import { evaluateChoice } from '../../src/decisions.js';
+import { instructionConflictInputSchema, instructionConflictResultSchema } from './schema.js';
+export async function instructionConflict(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = instructionConflictInputSchema.parse(input);
+    const decision = await evaluateChoice(state, 'Can firstInstruction and secondInstruction both be followed in context? Compare their required behavior, including prohibitions, conditions, and exceptions. A preference is not a mandatory requirement. Different wording is not a conflict. Choose conflicting only when applicable requirements cannot both be followed under the same supplied circumstances. Do not choose which instruction wins or infer authority from its wording. If their applicable scope is unresolved, choose unclear.', {
+        compatible: 'The instructions share an applicable scope and their requirements can both be followed.',
+        conflicting: 'Both instructions apply under the same supplied circumstances and require mutually incompatible behavior.',
+        different_scope: 'The instructions explicitly apply to separate circumstances, so their requirements do not compete.',
+        unclear: 'Their meaning, scope, or conditions leave it unresolved whether both can be followed.',
+    }, options);
+    return instructionConflictResultSchema.parse({
+        ...decision,
+        status: decision.confidence < minConfidence || decision.verdict === 'unclear' ? 'review' : 'ready',
+    });
+}
+export { instructionConflictInputSchema, instructionConflictResultSchema, instructionConflictVerdictSchema, } from './schema.js';

package/dist/recipes/instruction-conflict/schema.d.ts

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+export declare const instructionConflictVerdictSchema: z.ZodEnum<{
+    compatible: "compatible";
+    unclear: "unclear";
+    conflicting: "conflicting";
+    different_scope: "different_scope";
+}>;
+export declare const instructionConflictInputSchema: z.ZodObject<{
+    firstInstruction: z.ZodString;
+    secondInstruction: z.ZodString;
+    context: z.ZodOptional<z.ZodString>;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const instructionConflictResultSchema: 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<{
+        compatible: "compatible";
+        unclear: "unclear";
+        conflicting: "conflicting";
+        different_scope: "different_scope";
+    }>;
+    confidence: z.ZodNumber;
+    probabilities: z.ZodRecord<z.ZodEnum<{
+        compatible: "compatible";
+        unclear: "unclear";
+        conflicting: "conflicting";
+        different_scope: "different_scope";
+    }>, z.ZodNumber>;
+}, z.core.$strip>;
+export type InstructionConflictInput = z.infer<typeof instructionConflictInputSchema>;
+export type InstructionConflictResult = z.infer<typeof instructionConflictResultSchema>;
+export type InstructionConflictVerdict = z.infer<typeof instructionConflictVerdictSchema>;

package/dist/recipes/instruction-conflict/schema.js

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+import { decisionStatusSchema, nonEmptyText, probability, resultMetadataSchema, } from '../../src/schema.js';
+export const instructionConflictVerdictSchema = z.enum([
+    'compatible',
+    'conflicting',
+    'different_scope',
+    'unclear',
+]);
+export const instructionConflictInputSchema = z.object({
+    firstInstruction: nonEmptyText.describe('The first instruction to compare.'),
+    secondInstruction: nonEmptyText.describe('The second instruction to compare.'),
+    context: nonEmptyText
+        .describe('The task and circumstances in which the instructions may apply.')
+        .optional(),
+    minConfidence: probability.optional(),
+});
+export const instructionConflictResultSchema = resultMetadataSchema.extend({
+    status: decisionStatusSchema,
+    verdict: instructionConflictVerdictSchema,
+    confidence: probability,
+    probabilities: z.record(instructionConflictVerdictSchema, probability),
+});

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

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 export declare const preferenceKindVerdictSchema: z.ZodEnum<{
-    fact: "fact";
     preference: "preference";
+    fact: "fact";
     unclear: "unclear";
     temporary_request: "temporary_request";
 }>;
@@ -21,15 +21,15 @@ export declare const preferenceKindResultSchema: z.ZodObject<{
         review: "review";
     }>;
     verdict: z.ZodEnum<{
-        fact: "fact";
         preference: "preference";
+        fact: "fact";
         unclear: "unclear";
         temporary_request: "temporary_request";
     }>;
     confidence: z.ZodNumber;
     probabilities: z.ZodRecord<z.ZodEnum<{
-        fact: "fact";
         preference: "preference";
+        fact: "fact";
         unclear: "unclear";
         temporary_request: "temporary_request";
     }>, z.ZodNumber>;

package/dist/recipes/requirement-testability/demo.json

@@ -0,0 +1,24 @@
+{
+  "input": {
+    "requirement": "The dashboard should load quickly."
+  },
+  "response": {
+    "model": "demo-fixture",
+    "usage": {
+      "input_tokens": 0,
+      "output_tokens": 0
+    },
+    "answers": {
+      "decision": {
+        "type": "choice",
+        "choice": "not_testable",
+        "confidence": 0.96,
+        "probabilities": {
+          "testable": 0.02,
+          "not_testable": 0.96,
+          "unclear": 0.02
+        }
+      }
+    }
+  }
+}

package/dist/recipes/requirement-testability/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { RequirementTestabilityInput, RequirementTestabilityResult } from './schema.js';
+export declare function requirementTestability(input: RequirementTestabilityInput, options?: RecipeOptions): Promise<RequirementTestabilityResult>;
+export { requirementTestabilityInputSchema, requirementTestabilityResultSchema, requirementTestabilityVerdictSchema, } from './schema.js';
+export type { RequirementTestabilityInput, RequirementTestabilityResult, RequirementTestabilityVerdict, } from './schema.js';

package/dist/recipes/requirement-testability/index.js

@@ -0,0 +1,15 @@
+import { evaluateChoice } from '../../src/decisions.js';
+import { requirementTestabilityInputSchema, requirementTestabilityResultSchema } from './schema.js';
+export async function requirementTestability(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = requirementTestabilityInputSchema.parse(input);
+    const decision = await evaluateChoice(state, 'Do requirement and context define an observable way to distinguish meeting this requirement from failing it? Judge the stated acceptance criteria, not feasibility, current implementation, or whether it already passes. A criterion can be qualitative if the supplied definitions make the expected observation clear. Do not invent thresholds, measurement conditions, definitions, or a test procedure. Choose not_testable when the intended requirement is understandable but its completion criteria remain subjective or unbounded; choose unclear when the requirement itself or a reference cannot be interpreted.', {
+        testable: 'The supplied requirement and definitions establish observable conditions for distinguishing pass from fail.',
+        not_testable: 'The intended requirement is understandable, but the supplied criteria do not define an observable pass/fail boundary.',
+        unclear: 'The requirement or its references are too ambiguous to determine what would need to be observed.',
+    }, options);
+    return requirementTestabilityResultSchema.parse({
+        ...decision,
+        status: decision.confidence < minConfidence || decision.verdict === 'unclear' ? 'review' : 'ready',
+    });
+}
+export { requirementTestabilityInputSchema, requirementTestabilityResultSchema, requirementTestabilityVerdictSchema, } from './schema.js';

package/dist/recipes/requirement-testability/schema.d.ts

@@ -0,0 +1,36 @@
+import { z } from 'zod';
+export declare const requirementTestabilityVerdictSchema: z.ZodEnum<{
+    testable: "testable";
+    unclear: "unclear";
+    not_testable: "not_testable";
+}>;
+export declare const requirementTestabilityInputSchema: z.ZodObject<{
+    requirement: z.ZodString;
+    context: z.ZodOptional<z.ZodString>;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const requirementTestabilityResultSchema: 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<{
+        testable: "testable";
+        unclear: "unclear";
+        not_testable: "not_testable";
+    }>;
+    confidence: z.ZodNumber;
+    probabilities: z.ZodRecord<z.ZodEnum<{
+        testable: "testable";
+        unclear: "unclear";
+        not_testable: "not_testable";
+    }>, z.ZodNumber>;
+}, z.core.$strip>;
+export type RequirementTestabilityInput = z.infer<typeof requirementTestabilityInputSchema>;
+export type RequirementTestabilityResult = z.infer<typeof requirementTestabilityResultSchema>;
+export type RequirementTestabilityVerdict = z.infer<typeof requirementTestabilityVerdictSchema>;

package/dist/recipes/requirement-testability/schema.js

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import { decisionStatusSchema, nonEmptyText, probability, resultMetadataSchema, } from '../../src/schema.js';
+export const requirementTestabilityVerdictSchema = z.enum(['testable', 'not_testable', 'unclear']);
+export const requirementTestabilityInputSchema = z.object({
+    requirement: nonEmptyText.describe('One requirement whose completion criteria need review.'),
+    context: nonEmptyText
+        .describe('Supplied definitions, acceptance criteria, and observation conditions.')
+        .optional(),
+    minConfidence: probability.optional(),
+});
+export const requirementTestabilityResultSchema = resultMetadataSchema.extend({
+    status: decisionStatusSchema,
+    verdict: requirementTestabilityVerdictSchema,
+    confidence: probability,
+    probabilities: z.record(requirementTestabilityVerdictSchema, probability),
+});

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

@@ -0,0 +1,28 @@
+{
+  "input": {
+    "firstTask": "Build the release archive from the source code.",
+    "secondTask": "Upload the completed release archive to the artifact store.",
+    "context": "The source code is available. No release archive exists yet, and uploading requires the completed archive."
+  },
+  "response": {
+    "model": "demo-fixture",
+    "usage": {
+      "input_tokens": 0,
+      "output_tokens": 0
+    },
+    "answers": {
+      "decision": {
+        "type": "choice",
+        "choice": "first_before_second",
+        "confidence": 0.96,
+        "probabilities": {
+          "first_before_second": 0.96,
+          "second_before_first": 0.01,
+          "independent": 0.01,
+          "cyclic": 0.01,
+          "unclear": 0.01
+        }
+      }
+    }
+  }
+}

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

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { TaskDependencyInput, TaskDependencyResult } from './schema.js';
+export declare function taskDependency(input: TaskDependencyInput, options?: RecipeOptions): Promise<TaskDependencyResult>;
+export { taskDependencyInputSchema, taskDependencyResultSchema, taskDependencyVerdictSchema, } from './schema.js';
+export type { TaskDependencyInput, TaskDependencyResult, TaskDependencyVerdict } from './schema.js';

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

@@ -0,0 +1,17 @@
+import { evaluateChoice } from '../../src/decisions.js';
+import { taskDependencyInputSchema, taskDependencyResultSchema } from './schema.js';
+export async function taskDependency(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = taskDependencyInputSchema.parse(input);
+    const decision = await evaluateChoice(state, 'Does either of firstTask and secondTask require the other to finish before it can start, using only their descriptions and context? Judge necessary prerequisites, not a preferred or convenient order. Never infer a dependency from the order in which tasks are supplied. Shared subject matter or duplicate work alone does not establish a dependency. Choose independent only when the supplied facts establish that both can start without the other finishing. Missing prerequisite information is unclear, not independence.', {
+        first_before_second: 'The second task needs the first task to finish, and the first does not need the second to finish.',
+        second_before_first: 'The first task needs the second task to finish, and the second does not need the first to finish.',
+        independent: 'Neither task needs the other to finish before it can start under the supplied conditions.',
+        cyclic: 'Each task requires the other to finish before it can start.',
+        unclear: 'The supplied descriptions do not establish the prerequisite relationship.',
+    }, options);
+    return taskDependencyResultSchema.parse({
+        ...decision,
+        status: decision.confidence < minConfidence || decision.verdict === 'unclear' ? 'review' : 'ready',
+    });
+}
+export { taskDependencyInputSchema, taskDependencyResultSchema, taskDependencyVerdictSchema, } from './schema.js';

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

@@ -0,0 +1,43 @@
+import { z } from 'zod';
+export declare const taskDependencyVerdictSchema: z.ZodEnum<{
+    unclear: "unclear";
+    first_before_second: "first_before_second";
+    second_before_first: "second_before_first";
+    independent: "independent";
+    cyclic: "cyclic";
+}>;
+export declare const taskDependencyInputSchema: z.ZodObject<{
+    firstTask: z.ZodString;
+    secondTask: z.ZodString;
+    context: z.ZodOptional<z.ZodString>;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const taskDependencyResultSchema: 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";
+        first_before_second: "first_before_second";
+        second_before_first: "second_before_first";
+        independent: "independent";
+        cyclic: "cyclic";
+    }>;
+    confidence: z.ZodNumber;
+    probabilities: z.ZodRecord<z.ZodEnum<{
+        unclear: "unclear";
+        first_before_second: "first_before_second";
+        second_before_first: "second_before_first";
+        independent: "independent";
+        cyclic: "cyclic";
+    }>, z.ZodNumber>;
+}, z.core.$strip>;
+export type TaskDependencyInput = z.infer<typeof taskDependencyInputSchema>;
+export type TaskDependencyResult = z.infer<typeof taskDependencyResultSchema>;
+export type TaskDependencyVerdict = z.infer<typeof taskDependencyVerdictSchema>;

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

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+import { decisionStatusSchema, nonEmptyText, probability, resultMetadataSchema, } from '../../src/schema.js';
+export const taskDependencyVerdictSchema = z.enum([
+    'first_before_second',
+    'second_before_first',
+    'independent',
+    'cyclic',
+    'unclear',
+]);
+export const taskDependencyInputSchema = z.object({
+    firstTask: nonEmptyText.describe('The first task, including its inputs and output when known.'),
+    secondTask: nonEmptyText.describe('The second task, including its inputs and output when known.'),
+    context: nonEmptyText
+        .describe('Known prerequisites, available inputs, and relevant workflow conditions.')
+        .optional(),
+    minConfidence: probability.optional(),
+});
+export const taskDependencyResultSchema = resultMetadataSchema.extend({
+    status: decisionStatusSchema,
+    verdict: taskDependencyVerdictSchema,
+    confidence: probability,
+    probabilities: z.record(taskDependencyVerdictSchema, probability),
+});

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

@@ -0,0 +1,27 @@
+{
+  "input": {
+    "firstTask": "Write a summary of the supplied onboarding guide for new hires.",
+    "secondTask": "Summarize the same supplied onboarding guide for new hires and translate the summary into Spanish.",
+    "context": "Both tasks require the same English summary; only the second also requires a Spanish translation."
+  },
+  "response": {
+    "model": "demo-fixture",
+    "usage": {
+      "input_tokens": 0,
+      "output_tokens": 0
+    },
+    "answers": {
+      "decision": {
+        "type": "choice",
+        "choice": "overlapping",
+        "confidence": 0.96,
+        "probabilities": {
+          "duplicate": 0.013333333333333334,
+          "overlapping": 0.96,
+          "distinct": 0.013333333333333334,
+          "unclear": 0.013333333333333334
+        }
+      }
+    }
+  }
+}

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

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { TaskDuplicateInput, TaskDuplicateResult } from './schema.js';
+export declare function taskDuplicate(input: TaskDuplicateInput, options?: RecipeOptions): Promise<TaskDuplicateResult>;
+export { taskDuplicateInputSchema, taskDuplicateResultSchema, taskDuplicateVerdictSchema, } from './schema.js';
+export type { TaskDuplicateInput, TaskDuplicateResult, TaskDuplicateVerdict } from './schema.js';

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

@@ -0,0 +1,16 @@
+import { evaluateChoice } from '../../src/decisions.js';
+import { taskDuplicateInputSchema, taskDuplicateResultSchema } from './schema.js';
+export async function taskDuplicate(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = taskDuplicateInputSchema.parse(input);
+    const decision = await evaluateChoice(state, 'Do firstTask and secondTask request the same completed outcome under the same scope in context? Compare targets, deliverables, time periods, and constraints, not just wording or methods. Different methods can produce the same requested outcome. The same method applied to different targets is not duplicate work. Choose duplicate only when completing either task would fully satisfy the other; use overlapping when shared requested work leaves a material requirement unique to at least one task. Do not assume that matching titles identify the same task.', {
+        duplicate: 'Completing either task would fully satisfy the other under the same scope and constraints.',
+        overlapping: 'The tasks share requested work, but at least one includes material work the other does not.',
+        distinct: 'The tasks have separate requested outcomes or incompatible scopes with no shared requested work.',
+        unclear: 'Their targets, scope, or intended outcomes cannot be compared from the supplied information.',
+    }, options);
+    return taskDuplicateResultSchema.parse({
+        ...decision,
+        status: decision.confidence < minConfidence || decision.verdict === 'unclear' ? 'review' : 'ready',
+    });
+}
+export { taskDuplicateInputSchema, taskDuplicateResultSchema, taskDuplicateVerdictSchema, } from './schema.js';

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

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+export declare const taskDuplicateVerdictSchema: z.ZodEnum<{
+    duplicate: "duplicate";
+    unclear: "unclear";
+    overlapping: "overlapping";
+    distinct: "distinct";
+}>;
+export declare const taskDuplicateInputSchema: z.ZodObject<{
+    firstTask: z.ZodString;
+    secondTask: z.ZodString;
+    context: z.ZodOptional<z.ZodString>;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const taskDuplicateResultSchema: 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<{
+        duplicate: "duplicate";
+        unclear: "unclear";
+        overlapping: "overlapping";
+        distinct: "distinct";
+    }>;
+    confidence: z.ZodNumber;
+    probabilities: z.ZodRecord<z.ZodEnum<{
+        duplicate: "duplicate";
+        unclear: "unclear";
+        overlapping: "overlapping";
+        distinct: "distinct";
+    }>, z.ZodNumber>;
+}, z.core.$strip>;
+export type TaskDuplicateInput = z.infer<typeof taskDuplicateInputSchema>;
+export type TaskDuplicateResult = z.infer<typeof taskDuplicateResultSchema>;
+export type TaskDuplicateVerdict = z.infer<typeof taskDuplicateVerdictSchema>;

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

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+import { decisionStatusSchema, nonEmptyText, probability, resultMetadataSchema, } from '../../src/schema.js';
+export const taskDuplicateVerdictSchema = z.enum([
+    'duplicate',
+    'overlapping',
+    'distinct',
+    'unclear',
+]);
+export const taskDuplicateInputSchema = z.object({
+    firstTask: nonEmptyText.describe('The first task and its intended outcome.'),
+    secondTask: nonEmptyText.describe('The second task and its intended outcome.'),
+    context: nonEmptyText
+        .describe('Relevant targets, scope, time periods, and constraints for the comparison.')
+        .optional(),
+    minConfidence: probability.optional(),
+});
+export const taskDuplicateResultSchema = resultMetadataSchema.extend({
+    status: decisionStatusSchema,
+    verdict: taskDuplicateVerdictSchema,
+    confidence: probability,
+    probabilities: z.record(taskDuplicateVerdictSchema, probability),
+});

package/dist/recipes/topic-shift/schema.d.ts

@@ -1,9 +1,9 @@
 import { z } from 'zod';
 export declare const topicShiftVerdictSchema: z.ZodEnum<{
     unclear: "unclear";
+    mixed: "mixed";
     same_topic: "same_topic";
     new_topic: "new_topic";
-    mixed: "mixed";
 }>;
 export declare const topicShiftInputSchema: z.ZodObject<{
     currentTopic: z.ZodString;
@@ -23,16 +23,16 @@ export declare const topicShiftResultSchema: z.ZodObject<{
     }>;
     verdict: z.ZodEnum<{
         unclear: "unclear";
+        mixed: "mixed";
         same_topic: "same_topic";
         new_topic: "new_topic";
-        mixed: "mixed";
     }>;
     confidence: z.ZodNumber;
     probabilities: z.ZodRecord<z.ZodEnum<{
         unclear: "unclear";
+        mixed: "mixed";
         same_topic: "same_topic";
         new_topic: "new_topic";
-        mixed: "mixed";
     }>, z.ZodNumber>;
 }, z.core.$strip>;
 export type TopicShiftInput = z.infer<typeof topicShiftInputSchema>;

package/dist/src/index.d.ts

@@ -32,10 +32,14 @@ export { citationMatch, citationMatchInputSchema, citationMatchResultSchema, } f
 export type { CitationMatchInput, CitationMatchResult } from '../recipes/citation-match/index.js';
 export { citationNeeded, citationNeededInputSchema, citationNeededResultSchema, citationNeededVerdictSchema, } from '../recipes/citation-needed/index.js';
 export type { CitationNeededInput, CitationNeededResult, CitationNeededVerdict, } from '../recipes/citation-needed/index.js';
+export { claimStance, claimStanceInputSchema, claimStanceResultSchema, claimStanceVerdictSchema, } from '../recipes/claim-stance/index.js';
+export type { ClaimStanceInput, ClaimStanceResult, ClaimStanceVerdict, } from '../recipes/claim-stance/index.js';
 export { clarify, clarifyInputSchema, clarifyResultSchema } from '../recipes/clarify/index.js';
 export type { ClarifyInput, ClarifyRequirement, ClarifyResult, RequirementVerdict, } from '../recipes/clarify/index.js';
 export { confirmationMatch, confirmationMatchInputSchema, confirmationMatchResultSchema, confirmationMatchVerdictSchema, } from '../recipes/confirmation-match/index.js';
 export type { ConfirmationMatchInput, ConfirmationMatchResult, ConfirmationMatchVerdict, } from '../recipes/confirmation-match/index.js';
+export { constraintStrength, constraintStrengthInputSchema, constraintStrengthResultSchema, constraintStrengthVerdictSchema, } from '../recipes/constraint-strength/index.js';
+export type { ConstraintStrengthInput, ConstraintStrengthResult, ConstraintStrengthVerdict, } from '../recipes/constraint-strength/index.js';
 export { contextRole, contextRoleInputSchema, contextRoleResultSchema, contextRoleVerdictSchema, } from '../recipes/context-role/index.js';
 export type { ContextRoleInput, ContextRoleResult, ContextRoleVerdict, } from '../recipes/context-role/index.js';
 export { correctionTarget, correctionTargetInputSchema, correctionTargetResultSchema, } from '../recipes/correction-target/index.js';
@@ -66,6 +70,8 @@ export { handoff, handoffInputSchema, handoffResultSchema } from '../recipes/han
 export type { HandoffInput, HandoffResult, HandoffRule, HandoffVerdict, } from '../recipes/handoff/index.js';
 export { incidentMatch, incidentMatchInputSchema, incidentMatchResultSchema, } from '../recipes/incident-match/index.js';
 export type { IncidentMatchInput, IncidentMatchResult } from '../recipes/incident-match/index.js';
+export { instructionConflict, instructionConflictInputSchema, instructionConflictResultSchema, instructionConflictVerdictSchema, } from '../recipes/instruction-conflict/index.js';
+export type { InstructionConflictInput, InstructionConflictResult, InstructionConflictVerdict, } from '../recipes/instruction-conflict/index.js';
 export { instructionFit, instructionFitInputSchema, instructionFitResultSchema, instructionFitVerdictSchema, } from '../recipes/instruction-fit/index.js';
 export type { InstructionFitInput, InstructionFitResult, InstructionFitVerdict, } from '../recipes/instruction-fit/index.js';
 export { intentChange, intentChangeInputSchema, intentChangeResultSchema, intentChangeVerdictSchema, } from '../recipes/intent-change/index.js';
@@ -94,6 +100,8 @@ export { repeatedAttempt, repeatedAttemptInputSchema, repeatedAttemptResultSchem
 export type { RepeatedAttemptInput, RepeatedAttemptResult, RepeatedAttemptVerdict, } from '../recipes/repeated-attempt/index.js';
 export { replyTemplateMatch, replyTemplateMatchInputSchema, replyTemplateMatchResultSchema, } from '../recipes/reply-template-match/index.js';
 export type { ReplyTemplateMatchInput, ReplyTemplateMatchResult, } from '../recipes/reply-template-match/index.js';
+export { requirementTestability, requirementTestabilityInputSchema, requirementTestabilityResultSchema, requirementTestabilityVerdictSchema, } from '../recipes/requirement-testability/index.js';
+export type { RequirementTestabilityInput, RequirementTestabilityResult, RequirementTestabilityVerdict, } from '../recipes/requirement-testability/index.js';
 export { rerank, rerankInputSchema, rerankResultSchema } from '../recipes/rerank/index.js';
 export type { RerankInput, RerankItem, RerankResult } from '../recipes/rerank/index.js';
 export { resolutionCheck, resolutionCheckInputSchema, resolutionCheckResultSchema, resolutionCheckVerdictSchema, } from '../recipes/resolution-check/index.js';
@@ -116,6 +124,10 @@ export { stepProgress, stepProgressInputSchema, stepProgressResultSchema, stepPr
 export type { StepProgressInput, StepProgressResult, StepProgressVerdict, } from '../recipes/step-progress/index.js';
 export { summaryCoverage, summaryCoverageInputSchema, summaryCoverageResultSchema, summaryCoverageVerdictSchema, } from '../recipes/summary-coverage/index.js';
 export type { SummaryCoverageInput, SummaryCoverageResult, SummaryCoverageVerdict, } from '../recipes/summary-coverage/index.js';
+export { taskDependency, taskDependencyInputSchema, taskDependencyResultSchema, taskDependencyVerdictSchema, } from '../recipes/task-dependency/index.js';
+export type { TaskDependencyInput, TaskDependencyResult, TaskDependencyVerdict, } from '../recipes/task-dependency/index.js';
+export { taskDuplicate, taskDuplicateInputSchema, taskDuplicateResultSchema, taskDuplicateVerdictSchema, } from '../recipes/task-duplicate/index.js';
+export type { TaskDuplicateInput, TaskDuplicateResult, TaskDuplicateVerdict, } from '../recipes/task-duplicate/index.js';
 export { ticketMatch, ticketMatchInputSchema, ticketMatchResultSchema, ticketMatchVerdictSchema, } from '../recipes/ticket-match/index.js';
 export type { TicketMatchInput, TicketMatchResult, TicketMatchVerdict, } from '../recipes/ticket-match/index.js';
 export { toneCheck, toneCheckInputSchema, toneCheckResultSchema, toneCheckVerdictSchema, } from '../recipes/tone-check/index.js';