jev-recipes 0.5.0 → 0.5.2

package/dist/recipes/issue-recurrence/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { IssueRecurrenceInput, IssueRecurrenceResult } from './schema.js';
+export declare function issueRecurrence(input: IssueRecurrenceInput, options?: RecipeOptions): Promise<IssueRecurrenceResult>;
+export { issueRecurrenceInputSchema, issueRecurrenceResultSchema, issueRecurrenceVerdictSchema, } from './schema.js';
+export type { IssueRecurrenceInput, IssueRecurrenceResult, IssueRecurrenceVerdict, } from './schema.js';

package/dist/recipes/issue-recurrence/index.js

@@ -0,0 +1,16 @@
+import { evaluateChoice } from '../../src/decisions.js';
+import { issueRecurrenceInputSchema, issueRecurrenceResultSchema } from './schema.js';
+export async function issueRecurrence(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = issueRecurrenceInputSchema.parse(input);
+    const decision = await evaluateChoice(state, 'For the supplied issue, does the latest customer message report a first occurrence, uninterrupted persistence, or a return after reported recovery? Interpret optional history oldest first and keep different issues separate. Use explicit customer reports, including a timeline within message. Choose new only when a first occurrence is explicitly established; missing history is not evidence that an issue is new. Choose ongoing when the customer reports that the issue persisted or never stopped. Choose returned only when the same issue is reported active now after an explicit customer report of recovery or working operation. The word "again" alone does not establish an intervening recovery. An attempted fix, deployment, closed ticket, provider assurance, or thanks alone does not establish observed recovery. If the latest message clearly corrects an earlier mistaken recovery report by saying the issue never stopped, choose ongoing. Otherwise conflicting reports or unclear chronology require unclear. Also choose unclear when current presence, the link to the same issue, or the distinction between persistence and recurrence is unresolved, or when the issue is reported resolved now and no current problem is reported. Do not infer a shared root cause from similar symptoms. Classify supplied reports, not verified system state, and do not reopen or update tickets.', {
+        new: 'The customer explicitly reports a first occurrence of the supplied issue, without conflicting history.',
+        ongoing: 'The customer reports that the supplied issue is still present and has persisted without recovery.',
+        returned: 'The same issue is reported active again after an explicit customer report of recovery.',
+        unclear: 'The reports do not establish one recurrence state, conflict without correction, concern a different issue, or do not report a current problem.',
+    }, options);
+    return issueRecurrenceResultSchema.parse({
+        ...decision,
+        status: decision.confidence < minConfidence || decision.verdict === 'unclear' ? 'review' : 'ready',
+    });
+}
+export { issueRecurrenceInputSchema, issueRecurrenceResultSchema, issueRecurrenceVerdictSchema, } from './schema.js';

package/dist/recipes/issue-recurrence/schema.d.ts

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+export declare const issueRecurrenceVerdictSchema: z.ZodEnum<{
+    unclear: "unclear";
+    new: "new";
+    ongoing: "ongoing";
+    returned: "returned";
+}>;
+export declare const issueRecurrenceInputSchema: z.ZodObject<{
+    issue: z.ZodString;
+    message: z.ZodString;
+    history: z.ZodOptional<z.ZodString>;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const issueRecurrenceResultSchema: 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";
+        new: "new";
+        ongoing: "ongoing";
+        returned: "returned";
+    }>;
+    confidence: z.ZodNumber;
+    probabilities: z.ZodRecord<z.ZodEnum<{
+        unclear: "unclear";
+        new: "new";
+        ongoing: "ongoing";
+        returned: "returned";
+    }>, z.ZodNumber>;
+}, z.core.$strip>;
+export type IssueRecurrenceInput = z.infer<typeof issueRecurrenceInputSchema>;
+export type IssueRecurrenceResult = z.infer<typeof issueRecurrenceResultSchema>;
+export type IssueRecurrenceVerdict = z.infer<typeof issueRecurrenceVerdictSchema>;

package/dist/recipes/issue-recurrence/schema.js

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import { nonEmptyText, probability, decisionStatusSchema, resultMetadataSchema, } from '../../src/schema.js';
+export const issueRecurrenceVerdictSchema = z.enum(['new', 'ongoing', 'returned', 'unclear']);
+export const issueRecurrenceInputSchema = z.object({
+    issue: nonEmptyText.describe('One specific problem whose reported recurrence should be assessed.'),
+    message: nonEmptyText.describe('The latest customer report about the issue.'),
+    history: nonEmptyText
+        .describe('Earlier reports in chronological order, oldest first, with speaker identities and reported outcomes.')
+        .optional(),
+    minConfidence: probability.optional(),
+});
+export const issueRecurrenceResultSchema = resultMetadataSchema.extend({
+    status: decisionStatusSchema,
+    verdict: issueRecurrenceVerdictSchema,
+    confidence: probability,
+    probabilities: z.record(issueRecurrenceVerdictSchema, probability),
+});

package/dist/recipes/memory-subject/demo.json

@@ -0,0 +1,26 @@
+{
+  "input": {
+    "statement": "My brother is vegetarian.",
+    "user": "Alex, the speaker of the statement."
+  },
+  "response": {
+    "model": "demo-fixture",
+    "usage": {
+      "input_tokens": 0,
+      "output_tokens": 0
+    },
+    "answers": {
+      "decision": {
+        "type": "choice",
+        "choice": "other",
+        "confidence": 0.97,
+        "probabilities": {
+          "user": 0.01,
+          "other": 0.97,
+          "shared": 0.01,
+          "unclear": 0.01
+        }
+      }
+    }
+  }
+}

package/dist/recipes/memory-subject/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { MemorySubjectInput, MemorySubjectResult } from './schema.js';
+export declare function memorySubject(input: MemorySubjectInput, options?: RecipeOptions): Promise<MemorySubjectResult>;
+export { memorySubjectInputSchema, memorySubjectResultSchema, memorySubjectVerdictSchema, } from './schema.js';
+export type { MemorySubjectInput, MemorySubjectResult, MemorySubjectVerdict } from './schema.js';

package/dist/recipes/memory-subject/index.js

@@ -0,0 +1,16 @@
+import { evaluateChoice } from '../../src/decisions.js';
+import { memorySubjectInputSchema, memorySubjectResultSchema } from './schema.js';
+export async function memorySubject(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = memorySubjectInputSchema.parse(input);
+    const decision = await evaluateChoice(state, 'Whom does the property described in statement apply to relative to the identified user? Use user and optional context to resolve speakers and references. Identify who is being described, not merely who authored the statement, who is named, or who possesses something mentioned. For example, when the user is the speaker, "My brother is vegetarian" describes other; "I admire my brother" describes user; "My brother and I are vegetarian" describes shared. Quoted first-person wording belongs to its quoted speaker, not automatically the user. Choose shared only when the same property explicitly applies to a group including the user. If separate assertions describe different subjects or properties, choose unclear and leave splitting them to the caller. Choose unclear for unresolved identities, references, or statements with no attributable property. Negated or hypothetical properties can still have a clear subject: classify that subject without turning the statement into an affirmative fact. Do not judge truth, permanence, usefulness, or permission to store the memory.', {
+        user: 'The described property applies to the identified user alone.',
+        other: 'The described property applies to someone or something other than the identified user, excluding that user.',
+        shared: 'The same described property explicitly applies to a group including the identified user.',
+        unclear: 'Unresolved identities, missing references, no attributable property, or separate assertions with different subjects prevent one attribution.',
+    }, options);
+    return memorySubjectResultSchema.parse({
+        ...decision,
+        status: decision.confidence < minConfidence || decision.verdict === 'unclear' ? 'review' : 'ready',
+    });
+}
+export { memorySubjectInputSchema, memorySubjectResultSchema, memorySubjectVerdictSchema, } from './schema.js';

package/dist/recipes/memory-subject/schema.d.ts

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+export declare const memorySubjectVerdictSchema: z.ZodEnum<{
+    unclear: "unclear";
+    other: "other";
+    user: "user";
+    shared: "shared";
+}>;
+export declare const memorySubjectInputSchema: z.ZodObject<{
+    statement: z.ZodString;
+    user: z.ZodString;
+    context: z.ZodOptional<z.ZodString>;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const memorySubjectResultSchema: 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";
+        other: "other";
+        user: "user";
+        shared: "shared";
+    }>;
+    confidence: z.ZodNumber;
+    probabilities: z.ZodRecord<z.ZodEnum<{
+        unclear: "unclear";
+        other: "other";
+        user: "user";
+        shared: "shared";
+    }>, z.ZodNumber>;
+}, z.core.$strip>;
+export type MemorySubjectInput = z.infer<typeof memorySubjectInputSchema>;
+export type MemorySubjectResult = z.infer<typeof memorySubjectResultSchema>;
+export type MemorySubjectVerdict = z.infer<typeof memorySubjectVerdictSchema>;

package/dist/recipes/memory-subject/schema.js

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import { nonEmptyText, probability, decisionStatusSchema, resultMetadataSchema, } from '../../src/schema.js';
+export const memorySubjectVerdictSchema = z.enum(['user', 'other', 'shared', 'unclear']);
+export const memorySubjectInputSchema = z.object({
+    statement: nonEmptyText.describe('One atomic statement or candidate memory whose subject should be identified.'),
+    user: nonEmptyText.describe('The person whose memory profile is being considered, including their speaker role when relevant.'),
+    context: nonEmptyText
+        .describe('Supplied speaker identities or surrounding text needed to resolve references.')
+        .optional(),
+    minConfidence: probability.optional(),
+});
+export const memorySubjectResultSchema = resultMetadataSchema.extend({
+    status: decisionStatusSchema,
+    verdict: memorySubjectVerdictSchema,
+    confidence: probability,
+    probabilities: z.record(memorySubjectVerdictSchema, probability),
+});

package/dist/recipes/motivation-source/demo.json

@@ -0,0 +1,27 @@
+{
+  "input": {
+    "activity": "Alex solves puzzles.",
+    "statement": "Alex says: \"I solve puzzles because I enjoy the challenge itself.\""
+  },
+  "response": {
+    "model": "demo-fixture",
+    "usage": {
+      "input_tokens": 0,
+      "output_tokens": 0
+    },
+    "answers": {
+      "decision": {
+        "type": "choice",
+        "choice": "intrinsic",
+        "confidence": 0.96,
+        "probabilities": {
+          "intrinsic": 0.96,
+          "extrinsic": 0.01,
+          "mixed": 0.01,
+          "not_stated": 0.01,
+          "unclear": 0.01
+        }
+      }
+    }
+  }
+}

package/dist/recipes/motivation-source/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { MotivationSourceInput, MotivationSourceResult } from './schema.js';
+export declare function motivationSource(input: MotivationSourceInput, options?: RecipeOptions): Promise<MotivationSourceResult>;
+export { motivationSourceInputSchema, motivationSourceResultSchema, motivationSourceVerdictSchema, } from './schema.js';
+export type { MotivationSourceInput, MotivationSourceResult, MotivationSourceVerdict, } from './schema.js';

package/dist/recipes/motivation-source/index.js

@@ -0,0 +1,17 @@
+import { evaluateChoice } from '../../src/decisions.js';
+import { motivationSourceInputSchema, motivationSourceResultSchema } from './schema.js';
+export async function motivationSource(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = motivationSourceInputSchema.parse(input);
+    const decision = await evaluateChoice(state, "What kind of reason does statement give for the focal activity? Classify the explicitly stated or reported reason, not the actor's hidden motives or level of motivation. Intrinsic means engaging in the activity for its own interest, enjoyment, or satisfaction while doing it. Extrinsic means doing it to obtain or avoid an outcome separate from the activity, such as a prize, a grade, approval, guilt, or a valued practical result. Extrinsic does not mean only externally imposed: a freely chosen or personally valued outcome can still be extrinsic. Feeling pride afterward is not automatically enjoyment of the activity itself. Choose mixed only when both intrinsic and extrinsic reasons are offered together; unresolved alternatives between them are unclear. Do not count reasons that are negated, rejected, only hypothesized, or presented as possible incentives without being given as the actor's reason. A quoted or reported reason can be classified for its identified actor without assuming that actor is the speaker or that the report is true. Choose not_stated when the focal activity is clear but no reason is given, including only describing participation, naming a possible reward, or rejecting a motive without supplying another. Enjoyment mentioned without a link to why the actor participates is not automatically a reason. Choose unclear when the actor, activity, causal link, or distinction between the activity and a separate outcome cannot be resolved. Context can resolve references but cannot add a motive absent from statement. Do not infer permanence, intensity, autonomy, moral worth, or human-like motivation in an AI.", {
+        intrinsic: 'The stated reason is interest, enjoyment, or satisfaction in doing the activity itself.',
+        extrinsic: 'The stated reason is obtaining or avoiding an outcome separate from the activity.',
+        mixed: 'Both intrinsic and extrinsic reasons are offered together for the focal activity.',
+        not_stated: 'The activity is clear but no reason for doing it is stated.',
+        unclear: 'Ambiguous references, unresolved alternatives, or an unclear reason or activity boundary prevents classification.',
+    }, options);
+    return motivationSourceResultSchema.parse({
+        ...decision,
+        status: decision.confidence < minConfidence || decision.verdict === 'unclear' ? 'review' : 'ready',
+    });
+}
+export { motivationSourceInputSchema, motivationSourceResultSchema, motivationSourceVerdictSchema, } from './schema.js';

package/dist/recipes/motivation-source/schema.d.ts

@@ -0,0 +1,43 @@
+import { z } from 'zod';
+export declare const motivationSourceVerdictSchema: z.ZodEnum<{
+    intrinsic: "intrinsic";
+    extrinsic: "extrinsic";
+    unclear: "unclear";
+    mixed: "mixed";
+    not_stated: "not_stated";
+}>;
+export declare const motivationSourceInputSchema: z.ZodObject<{
+    activity: z.ZodString;
+    statement: z.ZodString;
+    context: z.ZodOptional<z.ZodString>;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const motivationSourceResultSchema: 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<{
+        intrinsic: "intrinsic";
+        extrinsic: "extrinsic";
+        unclear: "unclear";
+        mixed: "mixed";
+        not_stated: "not_stated";
+    }>;
+    confidence: z.ZodNumber;
+    probabilities: z.ZodRecord<z.ZodEnum<{
+        intrinsic: "intrinsic";
+        extrinsic: "extrinsic";
+        unclear: "unclear";
+        mixed: "mixed";
+        not_stated: "not_stated";
+    }>, z.ZodNumber>;
+}, z.core.$strip>;
+export type MotivationSourceInput = z.infer<typeof motivationSourceInputSchema>;
+export type MotivationSourceResult = z.infer<typeof motivationSourceResultSchema>;
+export type MotivationSourceVerdict = z.infer<typeof motivationSourceVerdictSchema>;

package/dist/recipes/motivation-source/schema.js

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+import { nonEmptyText, probability, decisionStatusSchema, resultMetadataSchema, } from '../../src/schema.js';
+export const motivationSourceVerdictSchema = z.enum([
+    'intrinsic',
+    'extrinsic',
+    'mixed',
+    'not_stated',
+    'unclear',
+]);
+export const motivationSourceInputSchema = z.object({
+    activity: nonEmptyText.describe('One focal activity and its actor when needed to distinguish whose stated reason is being classified.'),
+    statement: nonEmptyText.describe('Text stating or reporting why the actor does the activity.'),
+    context: nonEmptyText
+        .describe('Supplied speaker identities or references needed to interpret the stated reason.')
+        .optional(),
+    minConfidence: probability.optional(),
+});
+export const motivationSourceResultSchema = resultMetadataSchema.extend({
+    status: decisionStatusSchema,
+    verdict: motivationSourceVerdictSchema,
+    confidence: probability,
+    probabilities: z.record(motivationSourceVerdictSchema, probability),
+});

package/dist/recipes/outcome-framing/demo.json

@@ -0,0 +1,27 @@
+{
+  "input": {
+    "text": "You keep 80 of your 100 points.",
+    "outcome": "The player's points after the round; more points are better."
+  },
+  "response": {
+    "model": "demo-fixture",
+    "usage": {
+      "input_tokens": 0,
+      "output_tokens": 0
+    },
+    "answers": {
+      "decision": {
+        "type": "choice",
+        "choice": "gain",
+        "confidence": 0.96,
+        "probabilities": {
+          "gain": 0.96,
+          "loss": 0.01,
+          "mixed": 0.01,
+          "neutral": 0.01,
+          "unclear": 0.01
+        }
+      }
+    }
+  }
+}

package/dist/recipes/outcome-framing/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { OutcomeFramingInput, OutcomeFramingResult } from './schema.js';
+export declare function outcomeFraming(input: OutcomeFramingInput, options?: RecipeOptions): Promise<OutcomeFramingResult>;
+export { outcomeFramingInputSchema, outcomeFramingResultSchema, outcomeFramingVerdictSchema, } from './schema.js';
+export type { OutcomeFramingInput, OutcomeFramingResult, OutcomeFramingVerdict } from './schema.js';

package/dist/recipes/outcome-framing/index.js

@@ -0,0 +1,17 @@
+import { evaluateChoice } from '../../src/decisions.js';
+import { outcomeFramingInputSchema, outcomeFramingResultSchema } from './schema.js';
+export async function outcomeFraming(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = outcomeFramingInputSchema.parse(input);
+    const decision = await evaluateChoice(state, 'How does text frame the specified outcome? Classify the presented wording, not the actual utility, arithmetic change, or effect on a decision maker. Gain framing emphasizes obtaining or retaining benefits or avoiding harm; loss framing emphasizes costs, forfeited benefits, or harm incurred. For a round starting with 100 desirable points, "Keep 80 points" is gain framing and "Lose 20 points" is loss framing, although both can describe the same final balance. A bare final amount such as "Final balance: 80 points" is neutral without additional evaluative wording. Choose mixed only when both frames are actually presented for the focal outcome; do not infer an unmentioned complementary frame. Interpret negation by its meaning: "avoid losing points" emphasizes avoiding harm, not loss merely because the word losing appears. Attend to whose outcome is specified; a loss for an opponent need not be a loss for the focal player. Ignore frames about unrelated outcomes and words mentioned only as terminology rather than applied to the outcome. Context resolves references or benefit direction but cannot add framing absent from text. Choose neutral when the focal outcome is clearly described without gain or loss framing; choose unclear when it is missing, references or benefit direction cannot be resolved, or incompatible outcomes cannot be separated. Do not verify that two descriptions are equivalent, recommend a choice, or infer loss aversion or bias.', {
+        gain: 'The wording emphasizes benefits obtained or retained, or harm avoided, for the focal outcome.',
+        loss: 'The wording emphasizes costs, benefits forfeited, or harm incurred for the focal outcome.',
+        mixed: 'Both gain and loss framing are presented for the focal outcome.',
+        neutral: 'The focal outcome is described without gain or loss framing.',
+        unclear: 'A missing outcome, unresolved perspective or benefit direction, or ambiguous wording prevents classification.',
+    }, options);
+    return outcomeFramingResultSchema.parse({
+        ...decision,
+        status: decision.confidence < minConfidence || decision.verdict === 'unclear' ? 'review' : 'ready',
+    });
+}
+export { outcomeFramingInputSchema, outcomeFramingResultSchema, outcomeFramingVerdictSchema, } from './schema.js';

package/dist/recipes/outcome-framing/schema.d.ts

@@ -0,0 +1,43 @@
+import { z } from 'zod';
+export declare const outcomeFramingVerdictSchema: z.ZodEnum<{
+    unclear: "unclear";
+    mixed: "mixed";
+    gain: "gain";
+    loss: "loss";
+    neutral: "neutral";
+}>;
+export declare const outcomeFramingInputSchema: z.ZodObject<{
+    text: z.ZodString;
+    outcome: z.ZodString;
+    context: z.ZodOptional<z.ZodString>;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const outcomeFramingResultSchema: 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";
+        mixed: "mixed";
+        gain: "gain";
+        loss: "loss";
+        neutral: "neutral";
+    }>;
+    confidence: z.ZodNumber;
+    probabilities: z.ZodRecord<z.ZodEnum<{
+        unclear: "unclear";
+        mixed: "mixed";
+        gain: "gain";
+        loss: "loss";
+        neutral: "neutral";
+    }>, z.ZodNumber>;
+}, z.core.$strip>;
+export type OutcomeFramingInput = z.infer<typeof outcomeFramingInputSchema>;
+export type OutcomeFramingResult = z.infer<typeof outcomeFramingResultSchema>;
+export type OutcomeFramingVerdict = z.infer<typeof outcomeFramingVerdictSchema>;

package/dist/recipes/outcome-framing/schema.js

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import { nonEmptyText, probability, decisionStatusSchema, resultMetadataSchema, } from '../../src/schema.js';
+export const outcomeFramingVerdictSchema = z.enum(['gain', 'loss', 'mixed', 'neutral', 'unclear']);
+export const outcomeFramingInputSchema = z.object({
+    text: nonEmptyText.describe('The wording presented to the decision maker.'),
+    outcome: nonEmptyText.describe('One focal outcome, including whose outcome it is and what counts as a benefit or harm.'),
+    context: nonEmptyText
+        .describe('Supplied references or baseline information needed to interpret the wording.')
+        .optional(),
+    minConfidence: probability.optional(),
+});
+export const outcomeFramingResultSchema = resultMetadataSchema.extend({
+    status: decisionStatusSchema,
+    verdict: outcomeFramingVerdictSchema,
+    confidence: probability,
+    probabilities: z.record(outcomeFramingVerdictSchema, probability),
+});

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

@@ -0,0 +1,25 @@
+{
+  "input": {
+    "question": "Why did you delete the file?",
+    "claim": "You deleted the file."
+  },
+  "response": {
+    "model": "demo-fixture",
+    "usage": {
+      "input_tokens": 0,
+      "output_tokens": 0
+    },
+    "answers": {
+      "decision": {
+        "type": "choice",
+        "choice": "assumed",
+        "confidence": 0.98,
+        "probabilities": {
+          "assumed": 0.98,
+          "not_assumed": 0.01,
+          "unclear": 0.01
+        }
+      }
+    }
+  }
+}

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

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { QuestionAssumptionInput, QuestionAssumptionResult } from './schema.js';
+export declare function questionAssumption(input: QuestionAssumptionInput, options?: RecipeOptions): Promise<QuestionAssumptionResult>;
+export { questionAssumptionInputSchema, questionAssumptionResultSchema, questionAssumptionVerdictSchema, } from './schema.js';
+export type { QuestionAssumptionInput, QuestionAssumptionResult, QuestionAssumptionVerdict, } from './schema.js';

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

@@ -0,0 +1,15 @@
+import { evaluateChoice } from '../../src/decisions.js';
+import { questionAssumptionInputSchema, questionAssumptionResultSchema } from './schema.js';
+export async function questionAssumption(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = questionAssumptionInputSchema.parse(input);
+    const decision = await evaluateChoice(state, 'Does the wording of question take claim for granted? Assess the supplied proposition, including its negation and who it refers to. Choose assumed when the wording treats the claim as established, asks why, when, or how about it without leaving whether it holds open, or states it as fact in the respondent-visible framing. Choose not_assumed when the question openly asks whether the claim holds, conditionally supposes it, or clearly concerns an unrelated claim. A why, when, or how word alone is not sufficient: explicit uncertainty such as "if at all" leaves the claim open. Merely quoting or discussing someone else\'s question does not adopt its premise unless the surrounding framing also adopts it. Pressure toward an answer is not by itself an assumption: "I would prefer yes: did you delete the file?" still leaves whether deletion occurred open. "Why did you delete the file?" assumes deletion; "Did you delete the file?" and "If you deleted it, why?" do not. "Why did you not delete it?" does not assume the positive deletion claim. Use optional context to resolve references, not as an independent reason to call an open question assumed, even if that context supports the claim. Choose unclear for unresolved references, ambiguous question scope, or conflicting framing. Label wording, not whether the claim is true, author intent, or actual influence on answers.', {
+        assumed: 'The question or its visible framing treats the supplied claim as already established.',
+        not_assumed: 'The question leaves the claim open, supposes it only conditionally, merely quotes it without adoption, or clearly does not concern it.',
+        unclear: 'Unresolved references, ambiguous scope, or conflicting framing prevents determining whether the claim is taken for granted.',
+    }, options);
+    return questionAssumptionResultSchema.parse({
+        ...decision,
+        status: decision.confidence < minConfidence || decision.verdict === 'unclear' ? 'review' : 'ready',
+    });
+}
+export { questionAssumptionInputSchema, questionAssumptionResultSchema, questionAssumptionVerdictSchema, } from './schema.js';

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

@@ -0,0 +1,37 @@
+import { z } from 'zod';
+export declare const questionAssumptionVerdictSchema: z.ZodEnum<{
+    unclear: "unclear";
+    assumed: "assumed";
+    not_assumed: "not_assumed";
+}>;
+export declare const questionAssumptionInputSchema: z.ZodObject<{
+    question: z.ZodString;
+    claim: z.ZodString;
+    context: z.ZodOptional<z.ZodString>;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const questionAssumptionResultSchema: 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";
+        assumed: "assumed";
+        not_assumed: "not_assumed";
+    }>;
+    confidence: z.ZodNumber;
+    probabilities: z.ZodRecord<z.ZodEnum<{
+        unclear: "unclear";
+        assumed: "assumed";
+        not_assumed: "not_assumed";
+    }>, z.ZodNumber>;
+}, z.core.$strip>;
+export type QuestionAssumptionInput = z.infer<typeof questionAssumptionInputSchema>;
+export type QuestionAssumptionResult = z.infer<typeof questionAssumptionResultSchema>;
+export type QuestionAssumptionVerdict = z.infer<typeof questionAssumptionVerdictSchema>;

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

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import { nonEmptyText, probability, decisionStatusSchema, resultMetadataSchema, } from '../../src/schema.js';
+export const questionAssumptionVerdictSchema = z.enum(['assumed', 'not_assumed', 'unclear']);
+export const questionAssumptionInputSchema = z.object({
+    question: nonEmptyText.describe('One question, including any framing visible to the respondent.'),
+    claim: nonEmptyText.describe('One specific proposition to check for an assumption in the question.'),
+    context: nonEmptyText
+        .describe('Supplied context needed to resolve references and interpret the question and claim.')
+        .optional(),
+    minConfidence: probability.optional(),
+});
+export const questionAssumptionResultSchema = resultMetadataSchema.extend({
+    status: decisionStatusSchema,
+    verdict: questionAssumptionVerdictSchema,
+    confidence: probability,
+    probabilities: z.record(questionAssumptionVerdictSchema, probability),
+});

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

@@ -1,9 +1,9 @@
 import { z } from 'zod';
 export declare const questionLeadingVerdictSchema: z.ZodEnum<{
     unclear: "unclear";
+    neutral: "neutral";
     favors: "favors";
     disfavors: "disfavors";
-    neutral: "neutral";
 }>;
 export declare const questionLeadingInputSchema: z.ZodObject<{
     question: z.ZodString;
@@ -23,16 +23,16 @@ export declare const questionLeadingResultSchema: z.ZodObject<{
     }>;
     verdict: z.ZodEnum<{
         unclear: "unclear";
+        neutral: "neutral";
         favors: "favors";
         disfavors: "disfavors";
-        neutral: "neutral";
     }>;
     confidence: z.ZodNumber;
     probabilities: z.ZodRecord<z.ZodEnum<{
         unclear: "unclear";
+        neutral: "neutral";
         favors: "favors";
         disfavors: "disfavors";
-        neutral: "neutral";
     }>, z.ZodNumber>;
 }, z.core.$strip>;
 export type QuestionLeadingInput = z.infer<typeof questionLeadingInputSchema>;

package/dist/src/index.d.ts

@@ -26,6 +26,8 @@ export { cacheMatch, cacheMatchInputSchema, cacheMatchResultSchema, cacheMatchVe
 export type { CacheMatchInput, CacheMatchResult, CacheMatchVerdict, } from '../recipes/cache-match/index.js';
 export { cancellationCheck, cancellationCheckInputSchema, cancellationCheckResultSchema, cancellationCheckVerdictSchema, } from '../recipes/cancellation-check/index.js';
 export type { CancellationCheckInput, CancellationCheckResult, CancellationCheckVerdict, } from '../recipes/cancellation-check/index.js';
+export { causalAttribution, causalAttributionInputSchema, causalAttributionResultSchema, causalAttributionVerdictSchema, } from '../recipes/causal-attribution/index.js';
+export type { CausalAttributionInput, CausalAttributionResult, CausalAttributionVerdict, } from '../recipes/causal-attribution/index.js';
 export { certaintyMatch, certaintyMatchInputSchema, certaintyMatchResultSchema, certaintyMatchVerdictSchema, } from '../recipes/certainty-match/index.js';
 export type { CertaintyMatchInput, CertaintyMatchResult, CertaintyMatchVerdict, } from '../recipes/certainty-match/index.js';
 export { changeMeaning, changeMeaningInputSchema, changeMeaningResultSchema, changeMeaningVerdictSchema, } from '../recipes/change-meaning/index.js';
@@ -88,12 +90,20 @@ export { intentChange, intentChangeInputSchema, intentChangeResultSchema, intent
 export type { IntentChangeInput, IntentChangeResult, IntentChangeVerdict, } from '../recipes/intent-change/index.js';
 export { issueImpact, issueImpactInputSchema, issueImpactResultSchema, issueImpactVerdictSchema, } from '../recipes/issue-impact/index.js';
 export type { IssueImpactInput, IssueImpactResult, IssueImpactVerdict, } from '../recipes/issue-impact/index.js';
+export { issueRecurrence, issueRecurrenceInputSchema, issueRecurrenceResultSchema, issueRecurrenceVerdictSchema, } from '../recipes/issue-recurrence/index.js';
+export type { IssueRecurrenceInput, IssueRecurrenceResult, IssueRecurrenceVerdict, } from '../recipes/issue-recurrence/index.js';
 export { memoryRelation, memoryRelationInputSchema, memoryRelationResultSchema, memoryRelationVerdictSchema, } from '../recipes/memory-relation/index.js';
 export type { MemoryRelationInput, MemoryRelationResult, MemoryRelationVerdict, } from '../recipes/memory-relation/index.js';
 export { memoryScope, memoryScopeInputSchema, memoryScopeResultSchema, memoryScopeVerdictSchema, } from '../recipes/memory-scope/index.js';
 export type { MemoryScopeInput, MemoryScopeResult, MemoryScopeVerdict, } from '../recipes/memory-scope/index.js';
+export { memorySubject, memorySubjectInputSchema, memorySubjectResultSchema, memorySubjectVerdictSchema, } from '../recipes/memory-subject/index.js';
+export type { MemorySubjectInput, MemorySubjectResult, MemorySubjectVerdict, } from '../recipes/memory-subject/index.js';
 export { memoryValue, memoryValueInputSchema, memoryValueResultSchema, memoryValueVerdictSchema, } from '../recipes/memory-value/index.js';
 export type { MemoryValueInput, MemoryValueResult, MemoryValueVerdict, } from '../recipes/memory-value/index.js';
+export { motivationSource, motivationSourceInputSchema, motivationSourceResultSchema, motivationSourceVerdictSchema, } from '../recipes/motivation-source/index.js';
+export type { MotivationSourceInput, MotivationSourceResult, MotivationSourceVerdict, } from '../recipes/motivation-source/index.js';
+export { outcomeFraming, outcomeFramingInputSchema, outcomeFramingResultSchema, outcomeFramingVerdictSchema, } from '../recipes/outcome-framing/index.js';
+export type { OutcomeFramingInput, OutcomeFramingResult, OutcomeFramingVerdict, } from '../recipes/outcome-framing/index.js';
 export { passageDuplicate, passageDuplicateInputSchema, passageDuplicateResultSchema, passageDuplicateVerdictSchema, } from '../recipes/passage-duplicate/index.js';
 export type { PassageDuplicateInput, PassageDuplicateResult, PassageDuplicateVerdict, } from '../recipes/passage-duplicate/index.js';
 export { preferenceKind, preferenceKindInputSchema, preferenceKindResultSchema, preferenceKindVerdictSchema, } from '../recipes/preference-kind/index.js';
@@ -104,6 +114,8 @@ export { queryEquivalence, queryEquivalenceInputSchema, queryEquivalenceResultSc
 export type { QueryEquivalenceInput, QueryEquivalenceResult, QueryEquivalenceVerdict, } from '../recipes/query-equivalence/index.js';
 export { querySpecificity, querySpecificityInputSchema, querySpecificityResultSchema, querySpecificityVerdictSchema, } from '../recipes/query-specificity/index.js';
 export type { QuerySpecificityInput, QuerySpecificityResult, QuerySpecificityVerdict, } from '../recipes/query-specificity/index.js';
+export { questionAssumption, questionAssumptionInputSchema, questionAssumptionResultSchema, questionAssumptionVerdictSchema, } from '../recipes/question-assumption/index.js';
+export type { QuestionAssumptionInput, QuestionAssumptionResult, QuestionAssumptionVerdict, } from '../recipes/question-assumption/index.js';
 export { questionLeading, questionLeadingInputSchema, questionLeadingResultSchema, questionLeadingVerdictSchema, } from '../recipes/question-leading/index.js';
 export type { QuestionLeadingInput, QuestionLeadingResult, QuestionLeadingVerdict, } from '../recipes/question-leading/index.js';
 export { referenceResolve, referenceResolveInputSchema, referenceResolveResultSchema, } from '../recipes/reference-resolve/index.js';