@warmdrift/kgauto-compiler 2.0.0-alpha.97 → 2.0.0-alpha.98

package/dist/{chunk-IEEROFZW.mjs → chunk-KENTOSJO.mjs}

@@ -1,5 +1,5 @@
 // src/version.ts
-var LIBRARY_VERSION = "2.0.0-alpha.97";
+var LIBRARY_VERSION = "2.0.0-alpha.98";
 
 // src/key-health.ts
 var JSON_HEADERS = { "Content-Type": "application/json" };

package/dist/{chunk-AFYBZRQV.mjs → chunk-KZNTCMGM.mjs}

@@ -1146,12 +1146,19 @@ function mapRows(rows) {
     if (!isRawFailureRow(row)) continue;
     const n = coerceCount(row.n);
     const nFail = coerceCount(row.n_fail) ?? 0;
-    if (n === null || n <= 0) continue;
+    const nAttempted = coerceCount(row.n_attempted);
+    const nUnavailable = coerceCount(row.n_unavailable) ?? 0;
+    const nUnclassified = coerceCount(row.n_unclassified) ?? 0;
+    if (n === null) continue;
+    if (n <= 0 && nUnavailable <= 0) continue;
     out.push({
       archetype: row.intent_archetype,
       model: row.model,
       n,
-      nFail
+      nFail,
+      nAttempted: nAttempted ?? n,
+      nUnavailable,
+      nUnclassified
     });
   }
   return out;
@@ -1175,7 +1182,24 @@ var MEASURED_FAILURE_CFG = {
   /** 95% one-sided-ish confidence (standard two-sided z at α=0.05). */
   z: 1.96,
   /** Must match the view's window. Documented here for the advisory text. */
-  windowDays: 28
+  windowDays: 28,
+  /**
+   * alpha.98 — the AVAILABILITY axis. Same statistic, separate vocabulary,
+   * separate verdict, because a 429 and a parse-failure send an operator in
+   * opposite directions (fund or throttle the account vs. distrust the
+   * model's declared structuredOutput). Merging them into one "failure rate"
+   * is the s75 normalization defect.
+   *
+   * Thresholds match the quality axis deliberately: "we are 95% confident
+   * this model is unreachable more often than not" is the same unarguable
+   * bar, and a de-rank is the same remedy. Kept as a distinct config block
+   * so the two can be tuned apart when evidence says they should be.
+   */
+  availability: {
+    minSample: 5,
+    lowerBoundThreshold: 0.5,
+    z: 1.96
+  }
 };
 function wilsonLowerBound(failures, n, z = MEASURED_FAILURE_CFG.z) {
   if (n <= 0) return 0;
@@ -1192,15 +1216,53 @@ function mapMeasuredFailureRows(rows) {
 }
 function judgeMeasuredFailure(row, cfg = MEASURED_FAILURE_CFG) {
   if (!row) return void 0;
-  const normalized = "nFail" in row && typeof row.n === "number" ? row : mapRows([row])[0];
-  if (!normalized || normalized.n < cfg.minSample) return void 0;
-  const lowerBound = wilsonLowerBound(normalized.nFail, normalized.n, cfg.z);
+  const raw = "nFail" in row && typeof row.n === "number" ? row : mapRows([row])[0];
+  if (!raw) return void 0;
+  const normalized = {
+    ...raw,
+    nAttempted: typeof raw.nAttempted === "number" ? raw.nAttempted : raw.n,
+    nUnavailable: typeof raw.nUnavailable === "number" ? raw.nUnavailable : 0,
+    nUnclassified: typeof raw.nUnclassified === "number" ? raw.nUnclassified : 0
+  };
+  const quality = judgeAxis(
+    normalized.nFail,
+    normalized.n,
+    cfg.minSample,
+    cfg.lowerBoundThreshold,
+    cfg.z
+  );
+  const availability = judgeAxis(
+    normalized.nUnavailable,
+    normalized.nAttempted,
+    cfg.availability.minSample,
+    cfg.availability.lowerBoundThreshold,
+    cfg.availability.z
+  );
+  if (normalized.n < cfg.minSample && normalized.nAttempted < cfg.availability.minSample) {
+    return void 0;
+  }
+  const axis = quality.gated ? "quality" : availability.gated ? "availability" : void 0;
+  const lead = axis === "availability" ? availability : quality;
   return {
-    gated: lowerBound > cfg.lowerBoundThreshold,
-    rate: normalized.nFail / normalized.n,
+    gated: quality.gated || availability.gated,
+    axis,
+    rate: lead.rate,
+    lowerBound: lead.lowerBound,
+    n: lead.n,
+    nFail: lead.nFail,
+    quality,
+    availability,
+    nUnclassified: normalized.nUnclassified
+  };
+}
+function judgeAxis(failures, n, minSample, threshold, z) {
+  const lowerBound = wilsonLowerBound(failures, n, z);
+  return {
+    rate: n > 0 ? failures / n : 0,
     lowerBound,
-    n: normalized.n,
-    nFail: normalized.nFail
+    n,
+    nFail: failures,
+    gated: n >= minSample && lowerBound > threshold
   };
 }
 var snapshots2 = /* @__PURE__ */ new Map();
@@ -2242,9 +2304,13 @@ function detectSingleModelArray(ir, policy) {
   ];
 }
 function suppressedRecommendationReason(ir, archetype, altProfile) {
-  if (getMeasuredFailureVerdict({ appId: ir.appId, archetype, model: altProfile.id })?.gated === true) {
-    return "measured-failure-gate";
-  }
+  const measured = getMeasuredFailureVerdict({
+    appId: ir.appId,
+    archetype,
+    model: altProfile.id
+  });
+  if (measured?.quality.gated === true) return "measured-failure-gate";
+  if (measured?.availability.gated === true) return "measured-unavailable-gate";
   if (ir.constraints?.structuredOutput && effectiveConventions(altProfile).some(
     (c) => c.archetype === archetype && c.structuredOutputHint === "avoid"
   )) {
@@ -3057,7 +3123,8 @@ function compile(ir, opts = {}) {
         rate: verdict.rate,
         lowerBound: verdict.lowerBound,
         n: verdict.n,
-        nFail: verdict.nFail
+        nFail: verdict.nFail,
+        axis: verdict.axis ?? "quality"
       });
     }
   }

package/dist/index.d.mts

@@ -1241,7 +1241,7 @@ declare function runStrategyEvalWithAttribution(opts: Omit<GoldenEvalOptions, 'a
  * guard in `tests/version.test.ts` fails the suite (and therefore
  * `prepublishOnly`) when they diverge — a stale constant cannot reach npm.
  */
-declare const LIBRARY_VERSION = "2.0.0-alpha.97";
+declare const LIBRARY_VERSION = "2.0.0-alpha.98";
 
 /**
  * Oracle contract — how an app tells the brain whether a response was good.
@@ -3735,10 +3735,26 @@ declare function _testWaitForPromotionsRefresh(): Promise<void>;
 interface SurfaceFailureRow {
     archetype: string;
     model: string;
-    /** Total attempts in-window (served + quality walkaways). */
+    /**
+     * QUALITY-axis denominator: attempts that produced something judgeable
+     * (served + quality walkaways). Excludes calls that never reached an
+     * answer — a 429 is not a trial of the model's quality. See migration 071.
+     */
     n: number;
     /** Attempts that failed on the quality axis. */
     nFail: number;
+    /**
+     * alpha.98 — AVAILABILITY-axis denominator: every served attempt is a
+     * trial of whether the model can be reached at all.
+     */
+    nAttempted: number;
+    /** Attempts that never reached an answer — 429, auth, timeout, transport. */
+    nUnavailable: number;
+    /**
+     * Failures in NEITHER vocabulary. Carried so the taxonomy's blind spot is
+     * a number rather than silence; not gated on.
+     */
+    nUnclassified: number;
 }
 declare const MEASURED_FAILURE_CFG: {
     /**
@@ -3760,6 +3776,23 @@ declare const MEASURED_FAILURE_CFG: {
     readonly z: 1.96;
     /** Must match the view's window. Documented here for the advisory text. */
     readonly windowDays: 28;
+    /**
+     * alpha.98 — the AVAILABILITY axis. Same statistic, separate vocabulary,
+     * separate verdict, because a 429 and a parse-failure send an operator in
+     * opposite directions (fund or throttle the account vs. distrust the
+     * model's declared structuredOutput). Merging them into one "failure rate"
+     * is the s75 normalization defect.
+     *
+     * Thresholds match the quality axis deliberately: "we are 95% confident
+     * this model is unreachable more often than not" is the same unarguable
+     * bar, and a de-rank is the same remedy. Kept as a distinct config block
+     * so the two can be tuned apart when evidence says they should be.
+     */
+    readonly availability: {
+        readonly minSample: 5;
+        readonly lowerBoundThreshold: 0.5;
+        readonly z: 1.96;
+    };
 };
 /**
  * Wilson score interval, lower bound. Preferred over the normal
@@ -3771,16 +3804,45 @@ declare const MEASURED_FAILURE_CFG: {
  * Returns 0 for n <= 0.
  */
 declare function wilsonLowerBound(failures: number, n: number, z?: number): number;
+/** One axis's numbers. Same statistic, different vocabulary. */
+interface FailureAxisVerdict {
+    /** Observed failure rate in-window on this axis. */
+    rate: number;
+    /** 95% lower confidence bound on that rate — what the gate tests. */
+    lowerBound: number;
+    /** Attempts backing this axis. */
+    n: number;
+    /** Failures on this axis. */
+    nFail: number;
+    /** Whether this axis on its own clears the bar. */
+    gated: boolean;
+}
 interface MeasuredFailureVerdict {
-    /** Whether the measured-failure quality gate fires for this tuple. */
+    /** Whether a measured-failure gate fires for this tuple, on EITHER axis. */
     gated: boolean;
-    /** Observed failure rate in-window. */
+    /**
+     * alpha.98 — which axis fired. Undefined when `gated` is false. Read this
+     * before rendering `rate`/`n`: the same number means "answered badly" on
+     * one axis and "could not be reached" on the other, and the fixes differ.
+     * When both axes fire, `'quality'` wins the label — the model is reachable
+     * enough to have been judged, so its answers are the actionable half.
+     */
+    axis?: 'quality' | 'availability';
+    /**
+     * The numbers that JUSTIFY the gate — i.e. drawn from `axis` when gated,
+     * and from the quality axis otherwise. Deliberately not always-quality:
+     * a consumer printing "gated: 0% over 16" for a model that 429'd 42 times
+     * would be reporting a true number as an explanation of the wrong thing.
+     */
     rate: number;
-    /** 95% lower confidence bound on that rate — what the gate tests. */
     lowerBound: number;
-    /** Attempts backing the verdict. */
     n: number;
     nFail: number;
+    /** Both axes, always present, so a caller never has to infer one. */
+    quality: FailureAxisVerdict;
+    availability: FailureAxisVerdict;
+    /** Failures in neither vocabulary. Not gated on; surfaced for visibility. */
+    nUnclassified: number;
 }
 /**
  * alpha.78 — public row normalizer (PB 2026-07-25 trap): the counts
@@ -3805,6 +3867,9 @@ declare function judgeMeasuredFailure(row: SurfaceFailureRow | {
     model: string;
     n: number | string;
     n_fail: number | string;
+    n_attempted?: number | string;
+    n_unavailable?: number | string;
+    n_unclassified?: number | string;
 } | undefined, cfg?: typeof MEASURED_FAILURE_CFG): MeasuredFailureVerdict | undefined;
 interface MeasuredFailureRuntime {
     /** Endpoint base URL. The library appends `?app_id=<id>`. */

package/dist/index.d.ts

@@ -1241,7 +1241,7 @@ declare function runStrategyEvalWithAttribution(opts: Omit<GoldenEvalOptions, 'a
  * guard in `tests/version.test.ts` fails the suite (and therefore
  * `prepublishOnly`) when they diverge — a stale constant cannot reach npm.
  */
-declare const LIBRARY_VERSION = "2.0.0-alpha.97";
+declare const LIBRARY_VERSION = "2.0.0-alpha.98";
 
 /**
  * Oracle contract — how an app tells the brain whether a response was good.
@@ -3735,10 +3735,26 @@ declare function _testWaitForPromotionsRefresh(): Promise<void>;
 interface SurfaceFailureRow {
     archetype: string;
     model: string;
-    /** Total attempts in-window (served + quality walkaways). */
+    /**
+     * QUALITY-axis denominator: attempts that produced something judgeable
+     * (served + quality walkaways). Excludes calls that never reached an
+     * answer — a 429 is not a trial of the model's quality. See migration 071.
+     */
     n: number;
     /** Attempts that failed on the quality axis. */
     nFail: number;
+    /**
+     * alpha.98 — AVAILABILITY-axis denominator: every served attempt is a
+     * trial of whether the model can be reached at all.
+     */
+    nAttempted: number;
+    /** Attempts that never reached an answer — 429, auth, timeout, transport. */
+    nUnavailable: number;
+    /**
+     * Failures in NEITHER vocabulary. Carried so the taxonomy's blind spot is
+     * a number rather than silence; not gated on.
+     */
+    nUnclassified: number;
 }
 declare const MEASURED_FAILURE_CFG: {
     /**
@@ -3760,6 +3776,23 @@ declare const MEASURED_FAILURE_CFG: {
     readonly z: 1.96;
     /** Must match the view's window. Documented here for the advisory text. */
     readonly windowDays: 28;
+    /**
+     * alpha.98 — the AVAILABILITY axis. Same statistic, separate vocabulary,
+     * separate verdict, because a 429 and a parse-failure send an operator in
+     * opposite directions (fund or throttle the account vs. distrust the
+     * model's declared structuredOutput). Merging them into one "failure rate"
+     * is the s75 normalization defect.
+     *
+     * Thresholds match the quality axis deliberately: "we are 95% confident
+     * this model is unreachable more often than not" is the same unarguable
+     * bar, and a de-rank is the same remedy. Kept as a distinct config block
+     * so the two can be tuned apart when evidence says they should be.
+     */
+    readonly availability: {
+        readonly minSample: 5;
+        readonly lowerBoundThreshold: 0.5;
+        readonly z: 1.96;
+    };
 };
 /**
  * Wilson score interval, lower bound. Preferred over the normal
@@ -3771,16 +3804,45 @@ declare const MEASURED_FAILURE_CFG: {
  * Returns 0 for n <= 0.
  */
 declare function wilsonLowerBound(failures: number, n: number, z?: number): number;
+/** One axis's numbers. Same statistic, different vocabulary. */
+interface FailureAxisVerdict {
+    /** Observed failure rate in-window on this axis. */
+    rate: number;
+    /** 95% lower confidence bound on that rate — what the gate tests. */
+    lowerBound: number;
+    /** Attempts backing this axis. */
+    n: number;
+    /** Failures on this axis. */
+    nFail: number;
+    /** Whether this axis on its own clears the bar. */
+    gated: boolean;
+}
 interface MeasuredFailureVerdict {
-    /** Whether the measured-failure quality gate fires for this tuple. */
+    /** Whether a measured-failure gate fires for this tuple, on EITHER axis. */
     gated: boolean;
-    /** Observed failure rate in-window. */
+    /**
+     * alpha.98 — which axis fired. Undefined when `gated` is false. Read this
+     * before rendering `rate`/`n`: the same number means "answered badly" on
+     * one axis and "could not be reached" on the other, and the fixes differ.
+     * When both axes fire, `'quality'` wins the label — the model is reachable
+     * enough to have been judged, so its answers are the actionable half.
+     */
+    axis?: 'quality' | 'availability';
+    /**
+     * The numbers that JUSTIFY the gate — i.e. drawn from `axis` when gated,
+     * and from the quality axis otherwise. Deliberately not always-quality:
+     * a consumer printing "gated: 0% over 16" for a model that 429'd 42 times
+     * would be reporting a true number as an explanation of the wrong thing.
+     */
     rate: number;
-    /** 95% lower confidence bound on that rate — what the gate tests. */
     lowerBound: number;
-    /** Attempts backing the verdict. */
     n: number;
     nFail: number;
+    /** Both axes, always present, so a caller never has to infer one. */
+    quality: FailureAxisVerdict;
+    availability: FailureAxisVerdict;
+    /** Failures in neither vocabulary. Not gated on; surfaced for visibility. */
+    nUnclassified: number;
 }
 /**
  * alpha.78 — public row normalizer (PB 2026-07-25 trap): the counts
@@ -3805,6 +3867,9 @@ declare function judgeMeasuredFailure(row: SurfaceFailureRow | {
     model: string;
     n: number | string;
     n_fail: number | string;
+    n_attempted?: number | string;
+    n_unavailable?: number | string;
+    n_unclassified?: number | string;
 } | undefined, cfg?: typeof MEASURED_FAILURE_CFG): MeasuredFailureVerdict | undefined;
 interface MeasuredFailureRuntime {
     /** Endpoint base URL. The library appends `?app_id=<id>`. */

package/dist/index.js

@@ -4843,12 +4843,19 @@ function mapRows(rows) {
     if (!isRawFailureRow(row)) continue;
     const n = coerceCount(row.n);
     const nFail = coerceCount(row.n_fail) ?? 0;
-    if (n === null || n <= 0) continue;
+    const nAttempted = coerceCount(row.n_attempted);
+    const nUnavailable = coerceCount(row.n_unavailable) ?? 0;
+    const nUnclassified = coerceCount(row.n_unclassified) ?? 0;
+    if (n === null) continue;
+    if (n <= 0 && nUnavailable <= 0) continue;
     out.push({
       archetype: row.intent_archetype,
       model: row.model,
       n,
-      nFail
+      nFail,
+      nAttempted: nAttempted ?? n,
+      nUnavailable,
+      nUnclassified
     });
   }
   return out;
@@ -4872,7 +4879,24 @@ var MEASURED_FAILURE_CFG = {
   /** 95% one-sided-ish confidence (standard two-sided z at α=0.05). */
   z: 1.96,
   /** Must match the view's window. Documented here for the advisory text. */
-  windowDays: 28
+  windowDays: 28,
+  /**
+   * alpha.98 — the AVAILABILITY axis. Same statistic, separate vocabulary,
+   * separate verdict, because a 429 and a parse-failure send an operator in
+   * opposite directions (fund or throttle the account vs. distrust the
+   * model's declared structuredOutput). Merging them into one "failure rate"
+   * is the s75 normalization defect.
+   *
+   * Thresholds match the quality axis deliberately: "we are 95% confident
+   * this model is unreachable more often than not" is the same unarguable
+   * bar, and a de-rank is the same remedy. Kept as a distinct config block
+   * so the two can be tuned apart when evidence says they should be.
+   */
+  availability: {
+    minSample: 5,
+    lowerBoundThreshold: 0.5,
+    z: 1.96
+  }
 };
 function wilsonLowerBound(failures, n, z = MEASURED_FAILURE_CFG.z) {
   if (n <= 0) return 0;
@@ -4889,15 +4913,53 @@ function mapMeasuredFailureRows(rows) {
 }
 function judgeMeasuredFailure(row, cfg = MEASURED_FAILURE_CFG) {
   if (!row) return void 0;
-  const normalized = "nFail" in row && typeof row.n === "number" ? row : mapRows([row])[0];
-  if (!normalized || normalized.n < cfg.minSample) return void 0;
-  const lowerBound = wilsonLowerBound(normalized.nFail, normalized.n, cfg.z);
+  const raw = "nFail" in row && typeof row.n === "number" ? row : mapRows([row])[0];
+  if (!raw) return void 0;
+  const normalized = {
+    ...raw,
+    nAttempted: typeof raw.nAttempted === "number" ? raw.nAttempted : raw.n,
+    nUnavailable: typeof raw.nUnavailable === "number" ? raw.nUnavailable : 0,
+    nUnclassified: typeof raw.nUnclassified === "number" ? raw.nUnclassified : 0
+  };
+  const quality = judgeAxis(
+    normalized.nFail,
+    normalized.n,
+    cfg.minSample,
+    cfg.lowerBoundThreshold,
+    cfg.z
+  );
+  const availability = judgeAxis(
+    normalized.nUnavailable,
+    normalized.nAttempted,
+    cfg.availability.minSample,
+    cfg.availability.lowerBoundThreshold,
+    cfg.availability.z
+  );
+  if (normalized.n < cfg.minSample && normalized.nAttempted < cfg.availability.minSample) {
+    return void 0;
+  }
+  const axis = quality.gated ? "quality" : availability.gated ? "availability" : void 0;
+  const lead = axis === "availability" ? availability : quality;
   return {
-    gated: lowerBound > cfg.lowerBoundThreshold,
-    rate: normalized.nFail / normalized.n,
+    gated: quality.gated || availability.gated,
+    axis,
+    rate: lead.rate,
+    lowerBound: lead.lowerBound,
+    n: lead.n,
+    nFail: lead.nFail,
+    quality,
+    availability,
+    nUnclassified: normalized.nUnclassified
+  };
+}
+function judgeAxis(failures, n, minSample, threshold, z) {
+  const lowerBound = wilsonLowerBound(failures, n, z);
+  return {
+    rate: n > 0 ? failures / n : 0,
     lowerBound,
-    n: normalized.n,
-    nFail: normalized.nFail
+    n,
+    nFail: failures,
+    gated: n >= minSample && lowerBound > threshold
   };
 }
 var snapshots2 = /* @__PURE__ */ new Map();
@@ -5939,9 +6001,13 @@ function detectSingleModelArray(ir, policy) {
   ];
 }
 function suppressedRecommendationReason(ir, archetype, altProfile) {
-  if (getMeasuredFailureVerdict({ appId: ir.appId, archetype, model: altProfile.id })?.gated === true) {
-    return "measured-failure-gate";
-  }
+  const measured = getMeasuredFailureVerdict({
+    appId: ir.appId,
+    archetype,
+    model: altProfile.id
+  });
+  if (measured?.quality.gated === true) return "measured-failure-gate";
+  if (measured?.availability.gated === true) return "measured-unavailable-gate";
   if (ir.constraints?.structuredOutput && effectiveConventions(altProfile).some(
     (c) => c.archetype === archetype && c.structuredOutputHint === "avoid"
   )) {
@@ -6326,7 +6392,8 @@ function compile(ir, opts = {}) {
         rate: verdict.rate,
         lowerBound: verdict.lowerBound,
         n: verdict.n,
-        nFail: verdict.nFail
+        nFail: verdict.nFail,
+        axis: verdict.axis ?? "quality"
       });
     }
   }
@@ -6670,7 +6737,7 @@ function validateFinalFit(ir, profile, tokens) {
 }
 
 // src/version.ts
-var LIBRARY_VERSION = "2.0.0-alpha.97";
+var LIBRARY_VERSION = "2.0.0-alpha.98";
 
 // src/pricing-brain.ts
 function isPricingRow(x) {
@@ -8816,8 +8883,8 @@ async function call(ir, opts = {}) {
       appId: ir.appId,
       archetype: ir.intent.archetype,
       model: targetModel
-    })?.gated === true) {
-      retrySuppressionNote = " [sameModelRetry suppressed: this model carries an active measured-failure gate for this archetype \u2014 retrying it would near-certainly bill a second doomed inference; walking the chain instead]";
+    })?.quality.gated === true) {
+      retrySuppressionNote = " [sameModelRetry suppressed: this model carries an active measured-failure gate (quality axis) for this archetype \u2014 retrying it would near-certainly bill a second doomed inference; walking the chain instead]";
     }
     if (!validated.ok && isStructuredContractViolation(validated.errorCode) && sameModelRetryEnabled && !retriedSameModel && !retrySuppressionNote) {
       retriedSameModel = true;

package/dist/index.mjs

@@ -7,7 +7,7 @@ import {
   LIBRARY_VERSION,
   createKeyHealthRoute,
   keyFingerprint
-} from "./chunk-IEEROFZW.mjs";
+} from "./chunk-KENTOSJO.mjs";
 import {
   ARCHETYPE_FAMILY_FITS,
   BLOCKED_MODEL_FAMILY_SIBLING_SERVED_CODE,
@@ -63,7 +63,7 @@ import {
   runAdvisor,
   setTokenizer,
   wilsonLowerBound
-} from "./chunk-AFYBZRQV.mjs";
+} from "./chunk-KZNTCMGM.mjs";
 import {
   ABSOLUTE_FLOOR,
   ARCHETYPE_FLOOR_DEFAULT,
@@ -1980,8 +1980,8 @@ async function call(ir, opts = {}) {
       appId: ir.appId,
       archetype: ir.intent.archetype,
       model: targetModel
-    })?.gated === true) {
-      retrySuppressionNote = " [sameModelRetry suppressed: this model carries an active measured-failure gate for this archetype \u2014 retrying it would near-certainly bill a second doomed inference; walking the chain instead]";
+    })?.quality.gated === true) {
+      retrySuppressionNote = " [sameModelRetry suppressed: this model carries an active measured-failure gate (quality axis) for this archetype \u2014 retrying it would near-certainly bill a second doomed inference; walking the chain instead]";
     }
     if (!validated.ok && isStructuredContractViolation(validated.errorCode) && sameModelRetryEnabled && !retriedSameModel && !retrySuppressionNote) {
       retriedSameModel = true;

package/dist/key-health.js

@@ -28,7 +28,7 @@ __export(key_health_exports, {
 module.exports = __toCommonJS(key_health_exports);
 
 // src/version.ts
-var LIBRARY_VERSION = "2.0.0-alpha.97";
+var LIBRARY_VERSION = "2.0.0-alpha.98";
 
 // src/key-health.ts
 var JSON_HEADERS = { "Content-Type": "application/json" };

package/dist/key-health.mjs

@@ -3,7 +3,7 @@ import {
   KEY_FINGERPRINT_LENGTH,
   createKeyHealthRoute,
   keyFingerprint
-} from "./chunk-IEEROFZW.mjs";
+} from "./chunk-KENTOSJO.mjs";
 export {
   KEY_FINGERPRINT_DOMAIN,
   KEY_FINGERPRINT_LENGTH,

package/dist/probe.js

@@ -4284,12 +4284,19 @@ function mapRows(rows) {
     if (!isRawFailureRow(row)) continue;
     const n = coerceCount(row.n);
     const nFail = coerceCount(row.n_fail) ?? 0;
-    if (n === null || n <= 0) continue;
+    const nAttempted = coerceCount(row.n_attempted);
+    const nUnavailable = coerceCount(row.n_unavailable) ?? 0;
+    const nUnclassified = coerceCount(row.n_unclassified) ?? 0;
+    if (n === null) continue;
+    if (n <= 0 && nUnavailable <= 0) continue;
     out.push({
       archetype: row.intent_archetype,
       model: row.model,
       n,
-      nFail
+      nFail,
+      nAttempted: nAttempted ?? n,
+      nUnavailable,
+      nUnclassified
     });
   }
   return out;
@@ -4313,7 +4320,24 @@ var MEASURED_FAILURE_CFG = {
   /** 95% one-sided-ish confidence (standard two-sided z at α=0.05). */
   z: 1.96,
   /** Must match the view's window. Documented here for the advisory text. */
-  windowDays: 28
+  windowDays: 28,
+  /**
+   * alpha.98 — the AVAILABILITY axis. Same statistic, separate vocabulary,
+   * separate verdict, because a 429 and a parse-failure send an operator in
+   * opposite directions (fund or throttle the account vs. distrust the
+   * model's declared structuredOutput). Merging them into one "failure rate"
+   * is the s75 normalization defect.
+   *
+   * Thresholds match the quality axis deliberately: "we are 95% confident
+   * this model is unreachable more often than not" is the same unarguable
+   * bar, and a de-rank is the same remedy. Kept as a distinct config block
+   * so the two can be tuned apart when evidence says they should be.
+   */
+  availability: {
+    minSample: 5,
+    lowerBoundThreshold: 0.5,
+    z: 1.96
+  }
 };
 function wilsonLowerBound(failures, n, z = MEASURED_FAILURE_CFG.z) {
   if (n <= 0) return 0;
@@ -4327,15 +4351,53 @@ function wilsonLowerBound(failures, n, z = MEASURED_FAILURE_CFG.z) {
 }
 function judgeMeasuredFailure(row, cfg = MEASURED_FAILURE_CFG) {
   if (!row) return void 0;
-  const normalized = "nFail" in row && typeof row.n === "number" ? row : mapRows([row])[0];
-  if (!normalized || normalized.n < cfg.minSample) return void 0;
-  const lowerBound = wilsonLowerBound(normalized.nFail, normalized.n, cfg.z);
+  const raw = "nFail" in row && typeof row.n === "number" ? row : mapRows([row])[0];
+  if (!raw) return void 0;
+  const normalized = {
+    ...raw,
+    nAttempted: typeof raw.nAttempted === "number" ? raw.nAttempted : raw.n,
+    nUnavailable: typeof raw.nUnavailable === "number" ? raw.nUnavailable : 0,
+    nUnclassified: typeof raw.nUnclassified === "number" ? raw.nUnclassified : 0
+  };
+  const quality = judgeAxis(
+    normalized.nFail,
+    normalized.n,
+    cfg.minSample,
+    cfg.lowerBoundThreshold,
+    cfg.z
+  );
+  const availability = judgeAxis(
+    normalized.nUnavailable,
+    normalized.nAttempted,
+    cfg.availability.minSample,
+    cfg.availability.lowerBoundThreshold,
+    cfg.availability.z
+  );
+  if (normalized.n < cfg.minSample && normalized.nAttempted < cfg.availability.minSample) {
+    return void 0;
+  }
+  const axis = quality.gated ? "quality" : availability.gated ? "availability" : void 0;
+  const lead = axis === "availability" ? availability : quality;
   return {
-    gated: lowerBound > cfg.lowerBoundThreshold,
-    rate: normalized.nFail / normalized.n,
+    gated: quality.gated || availability.gated,
+    axis,
+    rate: lead.rate,
+    lowerBound: lead.lowerBound,
+    n: lead.n,
+    nFail: lead.nFail,
+    quality,
+    availability,
+    nUnclassified: normalized.nUnclassified
+  };
+}
+function judgeAxis(failures, n, minSample, threshold, z) {
+  const lowerBound = wilsonLowerBound(failures, n, z);
+  return {
+    rate: n > 0 ? failures / n : 0,
     lowerBound,
-    n: normalized.n,
-    nFail: normalized.nFail
+    n,
+    nFail: failures,
+    gated: n >= minSample && lowerBound > threshold
   };
 }
 var snapshots2 = /* @__PURE__ */ new Map();
@@ -5199,9 +5261,13 @@ function detectSingleModelArray(ir, policy) {
   ];
 }
 function suppressedRecommendationReason(ir, archetype, altProfile) {
-  if (getMeasuredFailureVerdict({ appId: ir.appId, archetype, model: altProfile.id })?.gated === true) {
-    return "measured-failure-gate";
-  }
+  const measured = getMeasuredFailureVerdict({
+    appId: ir.appId,
+    archetype,
+    model: altProfile.id
+  });
+  if (measured?.quality.gated === true) return "measured-failure-gate";
+  if (measured?.availability.gated === true) return "measured-unavailable-gate";
   if (ir.constraints?.structuredOutput && effectiveConventions(altProfile).some(
     (c) => c.archetype === archetype && c.structuredOutputHint === "avoid"
   )) {
@@ -5586,7 +5652,8 @@ function compile(ir, opts = {}) {
         rate: verdict.rate,
         lowerBound: verdict.lowerBound,
         n: verdict.n,
-        nFail: verdict.nFail
+        nFail: verdict.nFail,
+        axis: verdict.axis ?? "quality"
       });
     }
   }

package/dist/probe.mjs

@@ -1,6 +1,6 @@
 import {
   compile
-} from "./chunk-AFYBZRQV.mjs";
+} from "./chunk-KZNTCMGM.mjs";
 import "./chunk-77AHSX6Y.mjs";
 import "./chunk-FEMPY6EC.mjs";
 import {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@warmdrift/kgauto-compiler",
-  "version": "2.0.0-alpha.97",
+  "version": "2.0.0-alpha.98",
   "description": "Prompt compiler with executable provider knowledge for multi-model AI apps: normalized multi-provider transport with fallback chains, compile-time cliff guards, a curated model registry, and a telemetry flight recorder. Swap models without rewriting prompts.",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",