@iris-eval/mcp-server 0.9.0 → 0.10.0

package/dist/types/config.d.ts

@@ -54,6 +54,41 @@ export interface IrisConfig {
          * name in both lists is a config error: it does not say what you want.
          */
         nonCriticalRules?: string[];
+        /** `risk` composes by kind (gates, vetoes, unknown, then the risk); `legacy` runs the pre-0.10.0 weighted mean. */
+        composer?: 'risk' | 'legacy';
+        /**
+         * How many wrongly blocked builds one shipped failure is worth. The risk
+         * threshold is 1 / (1 + this), so 1 means a false pass and a false block
+         * cost the same; a continuous-integration gate that hates flakiness sets
+         * it low, a compliance gate sets it high.
+         */
+        falsePassCost?: number;
+        /**
+         * What a critical rule that was ASKED and could not answer does to the
+         * verdict — defeated by the output, or configured invalidly. Not the
+         * same as never asked, which is coverage. Today's behaviour is `pass`,
+         * which is the fail-open seam; the default is `unknown`.
+         */
+        onCriticalSkipped?: 'unknown' | 'fail' | 'pass';
+        /** Inputs every evaluation must carry; an absent one makes the verdict unknown rather than clean. */
+        requiredEvidence?: string[];
+        /**
+         * Whether a threshold IRIS ships decides the verdict, or only advises.
+         * A default is our guess about a deployment we have never seen; a
+         * threshold you set is your decision. A policy with no number in it —
+         * "the output is empty" — gates either way.
+         */
+        defaultsGate?: boolean;
+        /** The prior that an output is bad before any rule speaks. 0.5 matches the proof corpus, not your traffic. */
+        prior?: number;
+        /**
+         * How that prior is spread over the failure classes the detectors
+         * examine. `per-output` keeps it at the stated value for the output as a
+         * whole; `per-class` applies it to each class independently, which makes
+         * installing another detector raise the prior before that detector has
+         * looked at anything.
+         */
+        priorMode?: 'per-output' | 'per-class';
     };
     logging: {
         level: 'debug' | 'info' | 'warn' | 'error';

package/dist/types/eval.d.ts

@@ -59,6 +59,14 @@ export interface EvalRule {
     classes?: readonly FailureClass[];
     /** Bumped when the rule's meaning changes, so a stored result names the definition that produced it. */
     version?: number;
+    /**
+     * Who wrote this rule. `custom` marks anything `createCustomRule`
+     * produced — a deployed rule or one passed inline in the call. The
+     * composer needs it: for OUR rule a shipped threshold is a guess and only
+     * advises, while for THEIRS the severity they deployed it at is their own
+     * statement of how much it matters. Absent means built-in.
+     */
+    origin?: 'built-in' | 'custom';
     evaluate(context: EvalContext): EvalRuleResult;
 }
 export interface EvalContext {
@@ -97,6 +105,20 @@ export interface EvalContext {
     regexBudget?: {
         breaches: number;
     };
+    /**
+  
+     * Whether this evaluation may call a paid provider. Set ONLY by the tools
+  
+     * whose whole purpose is to do so — the LLM judge and the citation
+  
+     * verifier. The engine refuses to run a judgment rule without it, which
+  
+     * is what makes "evaluate_output never spends" a property of the engine
+  
+     * rather than a promise in a tool description.
+  
+     */
+    allowPaid?: boolean;
 }
 /**
  * What the composer DID with a result under this deployment's configuration
@@ -157,6 +179,11 @@ export type Evidence = {
     value: number;
     threshold?: number;
     thresholdSource?: 'default' | 'config' | 'call' | 'rule';
+} | {
+    type: 'sample';
+    score: number;
+    selfReportedPass?: boolean;
+    rationaleHash: string;
 };
 /** A measurement's statistic — the number the rule computed, with its unit, before any score transform. */
 export interface MeasuredValue {
@@ -194,6 +221,26 @@ export interface Coverage {
  * a detector's veto, nothing judged, or the score against the threshold.
  * `risk` is null until the compose-by-kind release computes it.
  */
+/**
+ * A sentence a reader needs that the verdict alone does not carry, with who
+ * it is for and what to change. The one that must exist: when a rule
+ * visibly FIRED and the verdict still passed, say why and name the setting
+ * that would change it — "cost_under_threshold failed" beside
+ * "passed: true" reads as a bug to anyone who has not read the composer.
+ *
+ * `suggestions` remains for now and is rendered from these; it is deprecated
+ * from 0.13.0 and removed at 1.0, per VERSIONING.md's two-minor rule.
+ */
+export interface Interpretation {
+    severity: 'block' | 'warn' | 'note';
+    addressee: 'agent' | 'operator' | 'author';
+    /** The rule this is about, when it is about one. */
+    rule?: string;
+    text: string;
+    /** The configuration key that changes this behaviour, when there is one. */
+    configKey?: string;
+}
+/** Placed on EvalResult by the engine; see Interpretation above. */
 export interface Verdict {
     state: 'pass' | 'fail' | 'unknown';
     passed: boolean;
@@ -303,6 +350,8 @@ export interface EvalRuleResult {
     classes?: FailureClass[];
     /** The version of the rule definition that produced this result. */
     ruleVersion?: number;
+    /** Who wrote the rule: `custom` for anything createCustomRule produced. See EvalRule.origin. */
+    origin?: 'built-in' | 'custom';
     /** Which of the rule's declared needs the call actually carried — what the rule SAW. */
     saw?: Need[];
     /** Present only when `skipped`; says whether the rule was never asked or was asked and could not answer. */
@@ -418,6 +467,8 @@ export interface EvalResult {
     categories?: Partial<Record<EvalType, EvalCategoryResult>>;
     /** The verdict with its basis (0.9.0) — computed by the engine, derived on read for stored rows that carry provenance. */
     verdict?: Verdict;
+    /** Sentences a reader needs that the verdict alone does not carry (0.10.0). */
+    interpretations?: Interpretation[];
     /** Coverage by evaluation question (0.9.0) — computed by the engine, derived on read from the stamped rule results. */
     coverage?: Coverage;
     /** What produced this verdict (0.9.0) — persisted; absent on rows written before it, never fabricated. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@iris-eval/mcp-server",
-  "version": "0.9.0",
+  "version": "0.10.0",
   "description": "Stop shipping agents on vibes. Score every agent output for quality, safety, and cost.",
   "mcpName": "io.github.iris-eval/mcp-server",
   "type": "module",

package/server.json

@@ -6,12 +6,12 @@
     "url": "https://github.com/iris-eval/mcp-server",
     "source": "github"
   },
-  "version": "0.9.0",
+  "version": "0.10.0",
   "packages": [
     {
       "registryType": "npm",
       "identifier": "@iris-eval/mcp-server",
-      "version": "0.9.0",
+      "version": "0.10.0",
       "transport": {
         "type": "stdio"
       },