@skastr0/prism-linux-x64 0.5.0 → 0.7.1

package/bin/prism

@@ -1,4 +1,4 @@
 [diffend] Oversized file quarantined before diffing.
 name: package/bin/prism
-size: 128313472 bytes
-sha256: c3f3b145783ed51055b3d44063d1c8760effa404360663289677544ce6e86e46
+size: 128292992 bytes
+sha256: 356a51f5881c6ee77ad7ecf65ab7a10736348bd226d9a3e9f5196a40054e2680

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skastr0/prism-linux-x64",
-  "version": "0.5.0",
+  "version": "0.7.1",
   "type": "module",
   "description": "Prism standalone CLI binary for Linux x64.",
   "license": "MIT",
@@ -18,8 +18,8 @@
   },
   "dependencies": {
     "@opencode-ai/plugin": "^1.15.13",
-    "@skastr0/prism-sdk": "0.5.0",
-    "effect": "^3.21.1",
+    "@skastr0/prism-sdk": "0.7.1",
+    "effect": "4.0.0-rc.115",
     "typescript": "^5.8.3",
     "zod": "4.4.3"
   },

package/types/compile/errors.d.ts

@@ -8,105 +8,83 @@
  */
 import { Schema } from "effect";
 import type { PluginManifestError } from "../errors.js";
-declare const SourceParseError_base: Schema.TaggedErrorClass<SourceParseError, "SourceParseError", {
-    readonly _tag: Schema.tag<"SourceParseError">;
-} & {
-    sourcePath: typeof Schema.String;
-    kind: Schema.Literal<["identity", "personality", "agent", "modelspace", "skillspace", "sop", "tool", "hook"]>;
-    message: typeof Schema.String;
-}>;
+declare const SourceParseError_base: Schema.Class<SourceParseError, Schema.TaggedStruct<"SourceParseError", {
+    readonly sourcePath: Schema.String;
+    readonly kind: Schema.Literals<readonly ["identity", "personality", "agent", "modelspace", "skillspace", "sop", "tool", "hook"]>;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
 export declare class SourceParseError extends SourceParseError_base {
 }
-declare const UnknownReferenceError_base: Schema.TaggedErrorClass<UnknownReferenceError, "UnknownReferenceError", {
-    readonly _tag: Schema.tag<"UnknownReferenceError">;
-} & {
-    agentName: typeof Schema.String;
-    sourcePath: typeof Schema.String;
-    field: Schema.Literal<["identity", "personality", "model", "skill", "phase.agent"]>;
-    referenceName: typeof Schema.String;
-}>;
+declare const UnknownReferenceError_base: Schema.Class<UnknownReferenceError, Schema.TaggedStruct<"UnknownReferenceError", {
+    readonly agentName: Schema.String;
+    readonly sourcePath: Schema.String;
+    readonly field: Schema.Literals<readonly ["identity", "personality", "model", "skill", "phase.agent"]>;
+    readonly referenceName: Schema.String;
+}>, import("effect/Cause").YieldableError>;
 export declare class UnknownReferenceError extends UnknownReferenceError_base {
 }
-declare const UnknownDependencyError_base: Schema.TaggedErrorClass<UnknownDependencyError, "UnknownDependencyError", {
-    readonly _tag: Schema.tag<"UnknownDependencyError">;
-} & {
-    sourcePath: typeof Schema.String;
-    referenceName: typeof Schema.String;
-    depPrefix: typeof Schema.String;
-    declaredDeps: Schema.Array$<typeof Schema.String>;
-}>;
+declare const UnknownDependencyError_base: Schema.Class<UnknownDependencyError, Schema.TaggedStruct<"UnknownDependencyError", {
+    readonly sourcePath: Schema.String;
+    readonly referenceName: Schema.String;
+    readonly depPrefix: Schema.String;
+    readonly declaredDeps: Schema.$Array<Schema.String>;
+}>, import("effect/Cause").YieldableError>;
 export declare class UnknownDependencyError extends UnknownDependencyError_base {
 }
-declare const DependencyCycleError_base: Schema.TaggedErrorClass<DependencyCycleError, "DependencyCycleError", {
-    readonly _tag: Schema.tag<"DependencyCycleError">;
-} & {
-    cycle: Schema.Array$<typeof Schema.String>;
-}>;
+declare const DependencyCycleError_base: Schema.Class<DependencyCycleError, Schema.TaggedStruct<"DependencyCycleError", {
+    readonly cycle: Schema.$Array<Schema.String>;
+}>, import("effect/Cause").YieldableError>;
 export declare class DependencyCycleError extends DependencyCycleError_base {
 }
-declare const UnknownTargetError_base: Schema.TaggedErrorClass<UnknownTargetError, "UnknownTargetError", {
-    readonly _tag: Schema.tag<"UnknownTargetError">;
-} & {
-    target: typeof Schema.String;
-    supportedTargets: Schema.Array$<typeof Schema.String>;
-}>;
+declare const UnknownTargetError_base: Schema.Class<UnknownTargetError, Schema.TaggedStruct<"UnknownTargetError", {
+    readonly target: Schema.String;
+    readonly supportedTargets: Schema.$Array<Schema.String>;
+}>, import("effect/Cause").YieldableError>;
 export declare class UnknownTargetError extends UnknownTargetError_base {
 }
-declare const InvalidTargetScopeError_base: Schema.TaggedErrorClass<InvalidTargetScopeError, "InvalidTargetScopeError", {
-    readonly _tag: Schema.tag<"InvalidTargetScopeError">;
-} & {
-    target: typeof Schema.String;
-    scope: typeof Schema.String;
-    message: typeof Schema.String;
-}>;
+declare const InvalidTargetScopeError_base: Schema.Class<InvalidTargetScopeError, Schema.TaggedStruct<"InvalidTargetScopeError", {
+    readonly target: Schema.String;
+    readonly scope: Schema.String;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
 export declare class InvalidTargetScopeError extends InvalidTargetScopeError_base {
 }
-declare const UnsupportedTargetCapabilityError_base: Schema.TaggedErrorClass<UnsupportedTargetCapabilityError, "UnsupportedTargetCapabilityError", {
-    readonly _tag: Schema.tag<"UnsupportedTargetCapabilityError">;
-} & {
-    target: typeof Schema.String;
-    capability: Schema.Literal<["compiled-agents", "hooks"]>;
-    message: typeof Schema.String;
-}>;
+declare const UnsupportedTargetCapabilityError_base: Schema.Class<UnsupportedTargetCapabilityError, Schema.TaggedStruct<"UnsupportedTargetCapabilityError", {
+    readonly target: Schema.String;
+    readonly capability: Schema.Literals<readonly ["compiled-agents", "hooks"]>;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
 export declare class UnsupportedTargetCapabilityError extends UnsupportedTargetCapabilityError_base {
 }
-declare const AgentValidationError_base: Schema.TaggedErrorClass<AgentValidationError, "AgentValidationError", {
-    readonly _tag: Schema.tag<"AgentValidationError">;
-} & {
-    sourcePath: typeof Schema.String;
-    agentName: typeof Schema.String;
-    field: typeof Schema.String;
-    message: typeof Schema.String;
-}>;
+declare const AgentValidationError_base: Schema.Class<AgentValidationError, Schema.TaggedStruct<"AgentValidationError", {
+    readonly sourcePath: Schema.String;
+    readonly agentName: Schema.String;
+    readonly field: Schema.String;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
 export declare class AgentValidationError extends AgentValidationError_base {
 }
-declare const DuplicateNameError_base: Schema.TaggedErrorClass<DuplicateNameError, "DuplicateNameError", {
-    readonly _tag: Schema.tag<"DuplicateNameError">;
-} & {
-    kind: Schema.Literal<["identity", "personality", "agent", "modelspace", "skillspace", "sop", "tool", "hook"]>;
-    name: typeof Schema.String;
-    firstPath: typeof Schema.String;
-    secondPath: typeof Schema.String;
-}>;
+declare const DuplicateNameError_base: Schema.Class<DuplicateNameError, Schema.TaggedStruct<"DuplicateNameError", {
+    readonly kind: Schema.Literals<readonly ["identity", "personality", "agent", "modelspace", "skillspace", "sop", "tool", "hook"]>;
+    readonly name: Schema.String;
+    readonly firstPath: Schema.String;
+    readonly secondPath: Schema.String;
+}>, import("effect/Cause").YieldableError>;
 export declare class DuplicateNameError extends DuplicateNameError_base {
 }
-declare const AgentNameMismatchError_base: Schema.TaggedErrorClass<AgentNameMismatchError, "AgentNameMismatchError", {
-    readonly _tag: Schema.tag<"AgentNameMismatchError">;
-} & {
-    sourcePath: typeof Schema.String;
-    fileStem: typeof Schema.String;
-    agentName: typeof Schema.String;
-}>;
+declare const AgentNameMismatchError_base: Schema.Class<AgentNameMismatchError, Schema.TaggedStruct<"AgentNameMismatchError", {
+    readonly sourcePath: Schema.String;
+    readonly fileStem: Schema.String;
+    readonly agentName: Schema.String;
+}>, import("effect/Cause").YieldableError>;
 export declare class AgentNameMismatchError extends AgentNameMismatchError_base {
 }
-declare const MissingTargetResolutionError_base: Schema.TaggedErrorClass<MissingTargetResolutionError, "MissingTargetResolutionError", {
-    readonly _tag: Schema.tag<"MissingTargetResolutionError">;
-} & {
-    agentName: typeof Schema.String;
-    referenceKind: Schema.Literal<["model-profile", "skill"]>;
-    referenceName: typeof Schema.String;
-    target: typeof Schema.String;
-}>;
+declare const MissingTargetResolutionError_base: Schema.Class<MissingTargetResolutionError, Schema.TaggedStruct<"MissingTargetResolutionError", {
+    readonly agentName: Schema.String;
+    readonly referenceKind: Schema.Literals<readonly ["model-profile", "skill"]>;
+    readonly referenceName: Schema.String;
+    readonly target: Schema.String;
+}>, import("effect/Cause").YieldableError>;
 export declare class MissingTargetResolutionError extends MissingTargetResolutionError_base {
 }
 export type CompileError = SourceParseError | UnknownReferenceError | AgentValidationError | UnknownTargetError | InvalidTargetScopeError | UnsupportedTargetCapabilityError | DuplicateNameError | AgentNameMismatchError | MissingTargetResolutionError | UnknownDependencyError | DependencyCycleError | PluginManifestError;

package/types/compile/runtime/schema-bridge.d.ts

@@ -5,16 +5,18 @@
  *
  * Supports the bounded schema feature set used in contracts:
  *
- *   - StringKeyword, NumberKeyword, BooleanKeyword, UnknownKeyword
- *   - Literal (single) and Union of Literals (enum)
- *   - TupleType with rest (arrays)
- *   - TypeLiteral (nested structs)
- *   - Refinement and Transformation (unwrapped; brands preserved via description)
- *   - optional fields
+ *   - String, Number, Boolean, Null
+ *   - Unknown, Any (rendered honestly as z.unknown(): any JSON value)
+ *   - Literal (single), Union of Literals (enum), and general unions (z.union)
+ *   - Arrays with a single rest element (arrays)
+ *   - Objects (nested structs), including optional fields
+ *   - Records (`Schema.Record`) including mixed struct+index objects (catchall)
+ *   - checks (refinements) and encodings (transformations) are rendered as
+ *     their wire shape
+ *   - nominal brands add no runtime validation and are not emitted
  *
- * Annotations flow through: a field's Schema.annotations({ description }) is
- * emitted as .describe(...) on the tool schema node so the LLM sees the
- * contract's own documentation.
+ * A field's Schema.annotate({ description }) is emitted as .describe(...) on the
+ * tool schema node so the LLM sees the contract's own documentation.
  */
 import { tool } from "@opencode-ai/plugin";
 import { Schema } from "effect";
@@ -51,11 +53,12 @@ export interface ToolRuntimeContext {
  * Convert a top-level Schema.Struct to the args record opencode expects.
  * Throws at plugin load time if the top-level schema is not a struct.
  */
-export declare const toolArgsFromSchema: (schema: Schema.Schema.Any) => Record<string, ZodNode>;
+export declare const toolArgsFromSchema: (schema: Schema.Top) => Record<string, ZodNode>;
 /**
  * Decode raw tool-call args against the contract's Input schema. Throws a
  * clear error if decoding fails; the error propagates back to the LLM as the
- * tool call's failure message.
+ * tool call's failure message. Strict on excess properties: a misspelled
+ * field is a typo to surface, not noise to strip.
  */
-export declare const decodeInput: <A, I, R>(schema: Schema.Schema<A, I, R>, raw: unknown) => A;
+export declare const decodeInput: <S extends Schema.Codec<unknown, unknown, never, never>>(schema: S, raw: unknown) => S["Type"];
 export {};

package/types/errors.d.ts

@@ -16,15 +16,13 @@
  */
 import { Schema } from "effect";
 import { type CompileError } from "./compile/errors.js";
-declare const PluginManifestError_base: Schema.TaggedErrorClass<PluginManifestError, "PluginManifestError", {
-    readonly _tag: Schema.tag<"PluginManifestError">;
-} & {
-    pluginPath: typeof Schema.String;
-    manifestPath: typeof Schema.String;
-    pluginLabel: typeof Schema.String;
-    summary: typeof Schema.String;
-    details: Schema.Array$<typeof Schema.String>;
-}>;
+declare const PluginManifestError_base: Schema.Class<PluginManifestError, Schema.TaggedStruct<"PluginManifestError", {
+    readonly pluginPath: Schema.String;
+    readonly manifestPath: Schema.String;
+    readonly pluginLabel: Schema.String;
+    readonly summary: Schema.String;
+    readonly details: Schema.$Array<Schema.String>;
+}>, import("effect/Cause").YieldableError>;
 export declare class PluginManifestError extends PluginManifestError_base {
     /**
      * Build a manifest error from just a plugin path + summary, deriving the
@@ -35,39 +33,31 @@ export declare class PluginManifestError extends PluginManifestError_base {
     }): PluginManifestError;
     get message(): string;
 }
-declare const PrismConfigError_base: Schema.TaggedErrorClass<PrismConfigError, "PrismConfigError", {
-    readonly _tag: Schema.tag<"PrismConfigError">;
-} & {
-    message: typeof Schema.String;
-}>;
+declare const PrismConfigError_base: Schema.Class<PrismConfigError, Schema.TaggedStruct<"PrismConfigError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
 export declare class PrismConfigError extends PrismConfigError_base {
 }
-declare const BundleBuildError_base: Schema.TaggedErrorClass<BundleBuildError, "BundleBuildError", {
-    readonly _tag: Schema.tag<"BundleBuildError">;
-} & {
-    bundleKind: typeof Schema.String;
-    diagnostics: typeof Schema.String;
-}>;
+declare const BundleBuildError_base: Schema.Class<BundleBuildError, Schema.TaggedStruct<"BundleBuildError", {
+    readonly bundleKind: Schema.String;
+    readonly diagnostics: Schema.String;
+}>, import("effect/Cause").YieldableError>;
 export declare class BundleBuildError extends BundleBuildError_base {
     get message(): string;
 }
-declare const BlockedTargetError_base: Schema.TaggedErrorClass<BlockedTargetError, "BlockedTargetError", {
-    readonly _tag: Schema.tag<"BlockedTargetError">;
-} & {
-    targetPath: typeof Schema.String;
-    plugin: typeof Schema.String;
-    hint: typeof Schema.String;
-}>;
+declare const BlockedTargetError_base: Schema.Class<BlockedTargetError, Schema.TaggedStruct<"BlockedTargetError", {
+    readonly targetPath: Schema.String;
+    readonly plugin: Schema.String;
+    readonly hint: Schema.String;
+}>, import("effect/Cause").YieldableError>;
 export declare class BlockedTargetError extends BlockedTargetError_base {
     get message(): string;
 }
-declare const PathConflictError_base: Schema.TaggedErrorClass<PathConflictError, "PathConflictError", {
-    readonly _tag: Schema.tag<"PathConflictError">;
-} & {
-    targetPath: typeof Schema.String;
-    firstPlugin: typeof Schema.String;
-    secondPlugin: typeof Schema.String;
-}>;
+declare const PathConflictError_base: Schema.Class<PathConflictError, Schema.TaggedStruct<"PathConflictError", {
+    readonly targetPath: Schema.String;
+    readonly firstPlugin: Schema.String;
+    readonly secondPlugin: Schema.String;
+}>, import("effect/Cause").YieldableError>;
 export declare class PathConflictError extends PathConflictError_base {
     get message(): string;
 }

package/types/index.d.ts

@@ -10,6 +10,7 @@
  *
  * These helpers are identity constructors for authoring ergonomics.
  */
+export * from "./jev.js";
 export * from "./workflow-errors.js";
 export * from "./workflow-harness-detection.js";
 export * from "./workflows.js";
@@ -43,7 +44,7 @@ export interface SkillspaceRefDefinition {
 export type AgentRefInput = string | AgentRefDefinition;
 export type ModelProfileRefInput = string | ModelProfileRefDefinition;
 export type SkillRefInput = SkillRefDefinition | SkillspaceRefDefinition;
-export type EffectSchemaValue = import("effect").Schema.Schema.AnyNoContext;
+export type EffectSchemaValue = import("effect").Schema.Top;
 export interface AgentDefinition {
     readonly name: string;
     readonly description: string;

package/types/jev.d.ts

@@ -0,0 +1,254 @@
+/**
+ * Jev (TypeSafe System One) vocabulary for Prism: question constructors,
+ * request validation/normalization, and request-correlated result codecs.
+ *
+ * This module is pure: no services, no environment access, no network. The
+ * wire contract is verified against `@typesafe-ai/sdk` v0.6.0 (`src/types.ts`)
+ * — these types are readonly mirrors of that contract, not a second
+ * interpretation of System One.
+ *
+ * Terminology follows the SDK and docs.typesafe.ai verbatim:
+ * - A *state* is the content evaluated (`EntryType`): string, JSON object,
+ *   JSON array, or null — never a bare boolean/number at the top level.
+ * - *Questions* are named, independent judgments over one shared state:
+ *   `choice` (which option), `score` (which rubric level), `noul`
+ *   (probability of yes). All questions in one request see the same state and
+ *   are evaluated independently — batching many questions per request is the
+ *   platform idiom (docs: 13 questions in one call = 12.2x cheaper, 10x
+ *   faster, byte-identical answers).
+ * - Answers are typed per question and constrained to the supplied criteria:
+ *   choice `{choice, confidence, probabilities}`, score `{score, confidence,
+ *   legend, probabilities}`, noul `{noul}`. Noul has no separate confidence.
+ *
+ * The request's token budget (~32k tokens, state and questions share it) is
+ * enforced pre-flight by the service layer in `src/services/jev.ts`; this
+ * module owns the estimator so tool handlers and workflows share one oracle.
+ */
+import { Schema } from "effect";
+/** Any JSON value. Readonly because decoded workflow data is readonly. */
+export type JevJson = null | boolean | number | string | readonly JevJson[] | {
+    readonly [key: string]: JevJson;
+};
+/**
+ * A System One entry: text, a JSON object or array, or null. Bare booleans
+ * and numbers are excluded at the top level, matching the SDK's `EntryType`.
+ */
+export type JevEntry = null | string | readonly JevJson[] | {
+    readonly [key: string]: JevJson;
+};
+/** Choice labels mapped to descriptions (`null` leaves a label undescribed). */
+export type JevChoiceCriteria = Readonly<Record<string, JevEntry>>;
+/** An ordered rubric with at least two levels. */
+export type JevScoreCriteria = readonly [JevEntry, JevEntry, ...JevEntry[]];
+/** A question that selects between named alternatives. */
+export interface JevChoiceQuestion<Criteria extends JevChoiceCriteria = JevChoiceCriteria> {
+    readonly type: "choice";
+    readonly instructions?: JevEntry;
+    readonly criteria: Criteria;
+}
+/** A question that assigns an ordered-rubric score. */
+export interface JevScoreQuestion<Criteria extends JevScoreCriteria = JevScoreCriteria> {
+    readonly type: "score";
+    readonly instructions?: JevEntry;
+    readonly criteria: Criteria;
+}
+/** A yes/no question answered as a probability of yes. */
+export interface JevNoulQuestion {
+    readonly type: "noul";
+    readonly instructions?: JevEntry;
+    readonly criteria?: {
+        readonly true?: JevEntry;
+        readonly false?: JevEntry;
+    } | null;
+}
+export type JevQuestion = JevChoiceQuestion | JevScoreQuestion | JevNoulQuestion;
+/** Questions keyed by the author-chosen IDs identifying their answers. */
+export type JevQuestions = Readonly<Record<string, JevQuestion>>;
+/** Rubric index keys for a concrete score criteria tuple. */
+export type JevScoreKey<C extends JevScoreCriteria> = number extends C["length"] ? number : Extract<keyof C, `${number}`>;
+/** The answer type for a question, preserving its criteria keys. */
+export type JevResultFor<Q extends JevQuestion> = Q extends JevChoiceQuestion<infer C> ? {
+    readonly type: "choice";
+    readonly choice: `${keyof C & (string | number)}`;
+    readonly confidence: number;
+    readonly probabilities: {
+        readonly [K in keyof C]: number;
+    };
+} : Q extends JevScoreQuestion<infer C> ? {
+    readonly type: "score";
+    readonly score: number;
+    readonly confidence: number;
+    readonly legend: {
+        readonly [K in JevScoreKey<C>]: C[K];
+    };
+    readonly probabilities: {
+        readonly [K in JevScoreKey<C>]: number;
+    };
+} : Q extends JevNoulQuestion ? {
+    readonly type: "noul";
+    readonly noul: number;
+} : never;
+/** Answers keyed by question ID, typed per question. */
+export type JevAnswers<Q extends JevQuestions> = {
+    readonly [K in keyof Q]: JevResultFor<Q[K]>;
+};
+/** Token usage for a request. */
+export interface JevUsage {
+    readonly input_tokens: number;
+    readonly output_tokens: number;
+}
+/** The full System One result: answers with model and usage metadata. */
+export interface JevResult<Q extends JevQuestions> {
+    readonly model: string;
+    readonly answers: JevAnswers<Q>;
+    readonly usage: JevUsage;
+}
+/** State and named questions for one System One call. */
+export interface JevRequest<Q extends JevQuestions = JevQuestions> {
+    readonly state: JevEntry;
+    readonly questions: Q;
+    readonly model?: string;
+}
+export declare class JevRequestValidationError extends Error {
+    readonly reason: string;
+    readonly path?: string | undefined;
+    readonly name = "JevRequestValidationError";
+    constructor(reason: string, path?: string | undefined);
+}
+/**
+ * Validate a System One entry (state, instructions, criterion description),
+ * returning a deep-frozen deep copy. Mirrors the SDK's `EntryType`: string,
+ * plain JSON object/array, or null.
+ */
+export declare const normalizeJevEntry: (value: unknown, path?: string) => JevEntry;
+/**
+ * Validate a questions map and return a deep-frozen deep copy with the same
+ * static type. At least one question is required.
+ */
+export declare const normalizeJevQuestions: <const Q extends JevQuestions>(questions: Q) => Q;
+/**
+ * Validate and freeze a full request (state + questions + optional model).
+ * Unexpected top-level fields are rejected rather than silently dropped so
+ * worker-task fields (prompt/worker/finish) can never leak into a Jev call.
+ */
+export declare const normalizeJevRequest: <const Q extends JevQuestions>(request: JevRequest<Q>) => JevRequest<Q>;
+/** Decode an unknown value (e.g. tool CLI input) into a normalized request. */
+export declare const parseJevRequest: (input: unknown) => JevRequest<JevQuestions>;
+/**
+ * Documented per-request token budget shared by state and questions
+ * (docs.typesafe.ai: "around 32,000 tokens").
+ */
+export declare const JEV_TOKEN_BUDGET = 32000;
+/**
+ * Soft target Prism enforces pre-flight. Below the hard budget so a request
+ * that passes locally still fits after SDK serialization differences.
+ */
+export declare const JEV_TOKEN_REQUEST_TARGET = 28000;
+/**
+ * Rough request token estimate: JSON payload characters / 4, the standard
+ * heuristic. Used only for pre-flight guidance, never as billing data.
+ */
+export declare const estimateJevRequestTokens: (request: JevRequest<JevQuestions>) => number;
+export declare function choice<const C extends JevChoiceCriteria>(definition: Omit<JevChoiceQuestion<C>, "type">): JevChoiceQuestion<C>;
+export declare function score<const C extends JevScoreCriteria>(definition: Omit<JevScoreQuestion<C>, "type">): JevScoreQuestion<C>;
+export declare function noul(definition?: Omit<JevNoulQuestion, "type">): JevNoulQuestion;
+/**
+ * Result contract version, folded into workflow identity hashing so a change
+ * in these codecs invalidates cached outputs deliberately rather than
+ * silently.
+ */
+export declare const JEV_RESULT_CONTRACT_VERSION: 1;
+/** A service-free codec for the full request-correlated System One result. */
+export type JevResultCodec<Q extends JevQuestions> = Schema.Codec<JevResult<Q>, JevResult<Q>, never, never>;
+/**
+ * Derive the result codec for a questions map. Answer keys, choice labels,
+ * probability keys, and score legends all come from the request, so a
+ * response disagreeing with its own questions fails decode.
+ *
+ * Localized assertion: the struct is built from runtime key maps whose key
+ * sets provably equal `keyof Q` / the criteria keys (same construction loop
+ * as `normalizeJevQuestions`), but TypeScript cannot see through
+ * `Object.fromEntries`; the cast maps the runtime struct onto
+ * `JevResultCodec<Q>`. Covered by runtime decode tests and dsl-type tests.
+ */
+export declare const jevResultSchema: <const Q extends JevQuestions>(questions: Q) => JevResultCodec<Q>;
+export declare const JEV_PROBE_MODEL = "jev-probe";
+/**
+ * A deterministic, schema-valid System One result used by workflow validation
+ * probes, where no live API call is made: every answer selects the first
+ * declared criterion (score index 0, noul 0) with a concentrated probability
+ * distribution, so branch-sensitive `run:` graphs walk the same stable path on
+ * every probe. Always decodes against `jevResultSchema(questions)`. This is a
+ * witness, not a simulation of what System One would answer.
+ */
+export declare const jevProbeResult: <const Q extends JevQuestions>(questions: Q) => JevResult<Q>;
+export declare const JevQuestionPresentation: Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"choice">;
+    readonly instructions: Schema.optionalKey<Schema.Unknown>;
+    readonly criteria: Schema.$Record<Schema.String, Schema.Unknown>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"score">;
+    readonly instructions: Schema.optionalKey<Schema.Unknown>;
+    readonly criteria: Schema.$Array<Schema.Unknown>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"noul">;
+    readonly instructions: Schema.optionalKey<Schema.Unknown>;
+    readonly criteria: Schema.optionalKey<Schema.NullOr<Schema.Struct<{
+        readonly true: Schema.optionalKey<Schema.Unknown>;
+        readonly false: Schema.optionalKey<Schema.Unknown>;
+    }>>>;
+}>]>;
+export declare const JevSystemOneInputSchema: Schema.Struct<{
+    readonly state: Schema.Unknown;
+    readonly questions: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"choice">;
+        readonly instructions: Schema.optionalKey<Schema.Unknown>;
+        readonly criteria: Schema.$Record<Schema.String, Schema.Unknown>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"score">;
+        readonly instructions: Schema.optionalKey<Schema.Unknown>;
+        readonly criteria: Schema.$Array<Schema.Unknown>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"noul">;
+        readonly instructions: Schema.optionalKey<Schema.Unknown>;
+        readonly criteria: Schema.optionalKey<Schema.NullOr<Schema.Struct<{
+            readonly true: Schema.optionalKey<Schema.Unknown>;
+            readonly false: Schema.optionalKey<Schema.Unknown>;
+        }>>>;
+    }>]>>;
+    readonly model: Schema.optionalKey<Schema.String>;
+}>;
+/**
+ * Jev decode boundaries fail on excess properties rather than stripping
+ * them: a misspelled question field (`instruction` vs `instructions`) must
+ * not silently vanish from the request, and an answer with extra IDs or
+ * probability labels is not a response to the request that was sent. The
+ * presentation/result schemas below describe Records partly (probability
+ * maps are `Record(String, Number)`), so only struct-level strictness takes
+ * effect — the request-correlated literal keys do the rest.
+ */
+export declare const JEV_STRICT_PARSE_OPTIONS: {
+    onExcessProperty: "error";
+};
+export declare const JevSystemOneResultSchema: Schema.Struct<{
+    readonly model: Schema.String;
+    readonly answers: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"choice">;
+        readonly choice: Schema.String;
+        readonly confidence: Schema.Number;
+        readonly probabilities: Schema.$Record<Schema.String, Schema.Number>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"score">;
+        readonly score: Schema.Number;
+        readonly confidence: Schema.Number;
+        readonly legend: Schema.$Record<Schema.String, Schema.Unknown>;
+        readonly probabilities: Schema.$Record<Schema.String, Schema.Number>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"noul">;
+        readonly noul: Schema.Number;
+    }>]>>;
+    readonly usage: Schema.Struct<{
+        readonly input_tokens: Schema.Number;
+        readonly output_tokens: Schema.Number;
+    }>;
+}>;