@qulib/core 0.10.0 → 0.11.0

package/dist/schemas/bug-report-score.schema.js

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+export const BugReportSeveritySchema = z.enum(['critical', 'high', 'medium', 'low']);
+export const BugReportInputSchema = z.object({
+    title: z.string().min(1).max(500),
+    description: z.string().min(1).max(8000),
+    steps: z.string().min(1).max(8000),
+    severity: BugReportSeveritySchema,
+});
+export const BugReportTargetSchema = z.object({
+    description: z.string().min(1).max(8000),
+    type: z.string().min(1).max(200),
+    severity: BugReportSeveritySchema,
+    expectedBehavior: z.string().min(1).max(8000),
+});
+export const ScoreBugReportInputSchema = z.object({
+    report: BugReportInputSchema,
+    target: BugReportTargetSchema,
+});
+export const BugReportRubricSchema = z.object({
+    coverage: z.number().min(0).max(25),
+    severity: z.number().min(0).max(25),
+    repro: z.number().min(0).max(25),
+    evidence: z.number().min(0).max(25),
+});
+export const BugReportScoringPathSchema = z.enum(['llm-judge', 'deterministic-fallback']);
+export const BugReportScoreResultSchema = z.object({
+    matched: z.boolean(),
+    matchConfidence: z.number().min(0).max(1),
+    rubric: BugReportRubricSchema,
+    feedback: z.string(),
+    scoringPath: BugReportScoringPathSchema,
+});

package/dist/schemas/confidence.schema.d.ts

@@ -11,7 +11,7 @@
  * - tenantId on every record (CLAUDE.md rule 17 — multi-tenant from day one).
  */
 import { z } from 'zod';
-export declare const EvidenceSourceKindSchema: z.ZodEnum<["live-app-quality", "accessibility", "crawl-coverage", "test-automation", "api-coverage", "ci-results", "deploy-metadata", "error-telemetry", "feature-flags", "doc-health", "human-approval", "agent-evidence"]>;
+export declare const EvidenceSourceKindSchema: z.ZodEnum<["live-app-quality", "accessibility", "crawl-coverage", "test-automation", "api-coverage", "ci-results", "deploy-metadata", "error-telemetry", "feature-flags", "doc-health", "human-approval", "agent-evidence", "decision-quality"]>;
 export type EvidenceSourceKind = z.infer<typeof EvidenceSourceKindSchema>;
 export declare const ConfidencePolicySchema: z.ZodObject<{
     /**
@@ -30,28 +30,28 @@ export declare const ConfidencePolicySchema: z.ZodObject<{
      * Sources listed here produce verdict='caution' when their applicability is 'unknown'.
      * Empty by default — callers can require specific sources for stricter gates.
      */
-    requiredSources: z.ZodDefault<z.ZodArray<z.ZodEnum<["live-app-quality", "accessibility", "crawl-coverage", "test-automation", "api-coverage", "ci-results", "deploy-metadata", "error-telemetry", "feature-flags", "doc-health", "human-approval", "agent-evidence"]>, "many">>;
+    requiredSources: z.ZodDefault<z.ZodArray<z.ZodEnum<["live-app-quality", "accessibility", "crawl-coverage", "test-automation", "api-coverage", "ci-results", "deploy-metadata", "error-telemetry", "feature-flags", "doc-health", "human-approval", "agent-evidence", "decision-quality"]>, "many">>;
     /**
      * Per-source weight overrides. When provided, these replace the scorer's default weights
      * for the named sources; unmentioned sources keep their defaults.
      */
-    weights: z.ZodOptional<z.ZodRecord<z.ZodEnum<["live-app-quality", "accessibility", "crawl-coverage", "test-automation", "api-coverage", "ci-results", "deploy-metadata", "error-telemetry", "feature-flags", "doc-health", "human-approval", "agent-evidence"]>, z.ZodNumber>>;
+    weights: z.ZodOptional<z.ZodRecord<z.ZodEnum<["live-app-quality", "accessibility", "crawl-coverage", "test-automation", "api-coverage", "ci-results", "deploy-metadata", "error-telemetry", "feature-flags", "doc-health", "human-approval", "agent-evidence", "decision-quality"]>, z.ZodNumber>>;
 }, "strip", z.ZodTypeAny, {
     passThreshold: number;
     failThreshold: number;
     maxListLength: number;
-    requiredSources: ("accessibility" | "live-app-quality" | "crawl-coverage" | "test-automation" | "api-coverage" | "ci-results" | "deploy-metadata" | "error-telemetry" | "feature-flags" | "doc-health" | "human-approval" | "agent-evidence")[];
-    weights?: Partial<Record<"accessibility" | "live-app-quality" | "crawl-coverage" | "test-automation" | "api-coverage" | "ci-results" | "deploy-metadata" | "error-telemetry" | "feature-flags" | "doc-health" | "human-approval" | "agent-evidence", number>> | undefined;
+    requiredSources: ("accessibility" | "live-app-quality" | "crawl-coverage" | "test-automation" | "api-coverage" | "ci-results" | "deploy-metadata" | "error-telemetry" | "feature-flags" | "doc-health" | "human-approval" | "agent-evidence" | "decision-quality")[];
+    weights?: Partial<Record<"accessibility" | "live-app-quality" | "crawl-coverage" | "test-automation" | "api-coverage" | "ci-results" | "deploy-metadata" | "error-telemetry" | "feature-flags" | "doc-health" | "human-approval" | "agent-evidence" | "decision-quality", number>> | undefined;
 }, {
     passThreshold?: number | undefined;
     failThreshold?: number | undefined;
     maxListLength?: number | undefined;
-    requiredSources?: ("accessibility" | "live-app-quality" | "crawl-coverage" | "test-automation" | "api-coverage" | "ci-results" | "deploy-metadata" | "error-telemetry" | "feature-flags" | "doc-health" | "human-approval" | "agent-evidence")[] | undefined;
-    weights?: Partial<Record<"accessibility" | "live-app-quality" | "crawl-coverage" | "test-automation" | "api-coverage" | "ci-results" | "deploy-metadata" | "error-telemetry" | "feature-flags" | "doc-health" | "human-approval" | "agent-evidence", number>> | undefined;
+    requiredSources?: ("accessibility" | "live-app-quality" | "crawl-coverage" | "test-automation" | "api-coverage" | "ci-results" | "deploy-metadata" | "error-telemetry" | "feature-flags" | "doc-health" | "human-approval" | "agent-evidence" | "decision-quality")[] | undefined;
+    weights?: Partial<Record<"accessibility" | "live-app-quality" | "crawl-coverage" | "test-automation" | "api-coverage" | "ci-results" | "deploy-metadata" | "error-telemetry" | "feature-flags" | "doc-health" | "human-approval" | "agent-evidence" | "decision-quality", number>> | undefined;
 }>;
 export type ConfidencePolicy = z.infer<typeof ConfidencePolicySchema>;
 export declare const EvidenceItemSchema: z.ZodObject<{
-    source: z.ZodEnum<["live-app-quality", "accessibility", "crawl-coverage", "test-automation", "api-coverage", "ci-results", "deploy-metadata", "error-telemetry", "feature-flags", "doc-health", "human-approval", "agent-evidence"]>;
+    source: z.ZodEnum<["live-app-quality", "accessibility", "crawl-coverage", "test-automation", "api-coverage", "ci-results", "deploy-metadata", "error-telemetry", "feature-flags", "doc-health", "human-approval", "agent-evidence", "decision-quality"]>;
     /**
      * 0–100 normalized score, or null when the source ran but could not produce
      * an honest score (e.g. auth-blocked crawl). null → excluded from denominator
@@ -114,7 +114,7 @@ export declare const EvidenceItemSchema: z.ZodObject<{
         } | undefined;
     }>;
 }, "strip", z.ZodTypeAny, {
-    source: "accessibility" | "live-app-quality" | "crawl-coverage" | "test-automation" | "api-coverage" | "ci-results" | "deploy-metadata" | "error-telemetry" | "feature-flags" | "doc-health" | "human-approval" | "agent-evidence";
+    source: "accessibility" | "live-app-quality" | "crawl-coverage" | "test-automation" | "api-coverage" | "ci-results" | "deploy-metadata" | "error-telemetry" | "feature-flags" | "doc-health" | "human-approval" | "agent-evidence" | "decision-quality";
     recommendations: string[];
     score: number | null;
     weight: number;
@@ -133,7 +133,7 @@ export declare const EvidenceItemSchema: z.ZodObject<{
     };
     reason?: string | undefined;
 }, {
-    source: "accessibility" | "live-app-quality" | "crawl-coverage" | "test-automation" | "api-coverage" | "ci-results" | "deploy-metadata" | "error-telemetry" | "feature-flags" | "doc-health" | "human-approval" | "agent-evidence";
+    source: "accessibility" | "live-app-quality" | "crawl-coverage" | "test-automation" | "api-coverage" | "ci-results" | "deploy-metadata" | "error-telemetry" | "feature-flags" | "doc-health" | "human-approval" | "agent-evidence" | "decision-quality";
     score: number | null;
     weight: number;
     evidence: string[];
@@ -184,7 +184,7 @@ export declare const ConfidenceInputSchema: z.ZodObject<{
         tenantId?: string | undefined;
     }>;
     evidence: z.ZodArray<z.ZodObject<{
-        source: z.ZodEnum<["live-app-quality", "accessibility", "crawl-coverage", "test-automation", "api-coverage", "ci-results", "deploy-metadata", "error-telemetry", "feature-flags", "doc-health", "human-approval", "agent-evidence"]>;
+        source: z.ZodEnum<["live-app-quality", "accessibility", "crawl-coverage", "test-automation", "api-coverage", "ci-results", "deploy-metadata", "error-telemetry", "feature-flags", "doc-health", "human-approval", "agent-evidence", "decision-quality"]>;
         /**
          * 0–100 normalized score, or null when the source ran but could not produce
          * an honest score (e.g. auth-blocked crawl). null → excluded from denominator
@@ -247,7 +247,7 @@ export declare const ConfidenceInputSchema: z.ZodObject<{
             } | undefined;
         }>;
     }, "strip", z.ZodTypeAny, {
-        source: "accessibility" | "live-app-quality" | "crawl-coverage" | "test-automation" | "api-coverage" | "ci-results" | "deploy-metadata" | "error-telemetry" | "feature-flags" | "doc-health" | "human-approval" | "agent-evidence";
+        source: "accessibility" | "live-app-quality" | "crawl-coverage" | "test-automation" | "api-coverage" | "ci-results" | "deploy-metadata" | "error-telemetry" | "feature-flags" | "doc-health" | "human-approval" | "agent-evidence" | "decision-quality";
         recommendations: string[];
         score: number | null;
         weight: number;
@@ -266,7 +266,7 @@ export declare const ConfidenceInputSchema: z.ZodObject<{
         };
         reason?: string | undefined;
     }, {
-        source: "accessibility" | "live-app-quality" | "crawl-coverage" | "test-automation" | "api-coverage" | "ci-results" | "deploy-metadata" | "error-telemetry" | "feature-flags" | "doc-health" | "human-approval" | "agent-evidence";
+        source: "accessibility" | "live-app-quality" | "crawl-coverage" | "test-automation" | "api-coverage" | "ci-results" | "deploy-metadata" | "error-telemetry" | "feature-flags" | "doc-health" | "human-approval" | "agent-evidence" | "decision-quality";
         score: number | null;
         weight: number;
         evidence: string[];
@@ -302,28 +302,28 @@ export declare const ConfidenceInputSchema: z.ZodObject<{
          * Sources listed here produce verdict='caution' when their applicability is 'unknown'.
          * Empty by default — callers can require specific sources for stricter gates.
          */
-        requiredSources: z.ZodDefault<z.ZodArray<z.ZodEnum<["live-app-quality", "accessibility", "crawl-coverage", "test-automation", "api-coverage", "ci-results", "deploy-metadata", "error-telemetry", "feature-flags", "doc-health", "human-approval", "agent-evidence"]>, "many">>;
+        requiredSources: z.ZodDefault<z.ZodArray<z.ZodEnum<["live-app-quality", "accessibility", "crawl-coverage", "test-automation", "api-coverage", "ci-results", "deploy-metadata", "error-telemetry", "feature-flags", "doc-health", "human-approval", "agent-evidence", "decision-quality"]>, "many">>;
         /**
          * Per-source weight overrides. When provided, these replace the scorer's default weights
          * for the named sources; unmentioned sources keep their defaults.
          */
-        weights: z.ZodOptional<z.ZodRecord<z.ZodEnum<["live-app-quality", "accessibility", "crawl-coverage", "test-automation", "api-coverage", "ci-results", "deploy-metadata", "error-telemetry", "feature-flags", "doc-health", "human-approval", "agent-evidence"]>, z.ZodNumber>>;
+        weights: z.ZodOptional<z.ZodRecord<z.ZodEnum<["live-app-quality", "accessibility", "crawl-coverage", "test-automation", "api-coverage", "ci-results", "deploy-metadata", "error-telemetry", "feature-flags", "doc-health", "human-approval", "agent-evidence", "decision-quality"]>, z.ZodNumber>>;
     }, "strip", z.ZodTypeAny, {
         passThreshold: number;
         failThreshold: number;
         maxListLength: number;
-        requiredSources: ("accessibility" | "live-app-quality" | "crawl-coverage" | "test-automation" | "api-coverage" | "ci-results" | "deploy-metadata" | "error-telemetry" | "feature-flags" | "doc-health" | "human-approval" | "agent-evidence")[];
-        weights?: Partial<Record<"accessibility" | "live-app-quality" | "crawl-coverage" | "test-automation" | "api-coverage" | "ci-results" | "deploy-metadata" | "error-telemetry" | "feature-flags" | "doc-health" | "human-approval" | "agent-evidence", number>> | undefined;
+        requiredSources: ("accessibility" | "live-app-quality" | "crawl-coverage" | "test-automation" | "api-coverage" | "ci-results" | "deploy-metadata" | "error-telemetry" | "feature-flags" | "doc-health" | "human-approval" | "agent-evidence" | "decision-quality")[];
+        weights?: Partial<Record<"accessibility" | "live-app-quality" | "crawl-coverage" | "test-automation" | "api-coverage" | "ci-results" | "deploy-metadata" | "error-telemetry" | "feature-flags" | "doc-health" | "human-approval" | "agent-evidence" | "decision-quality", number>> | undefined;
     }, {
         passThreshold?: number | undefined;
         failThreshold?: number | undefined;
         maxListLength?: number | undefined;
-        requiredSources?: ("accessibility" | "live-app-quality" | "crawl-coverage" | "test-automation" | "api-coverage" | "ci-results" | "deploy-metadata" | "error-telemetry" | "feature-flags" | "doc-health" | "human-approval" | "agent-evidence")[] | undefined;
-        weights?: Partial<Record<"accessibility" | "live-app-quality" | "crawl-coverage" | "test-automation" | "api-coverage" | "ci-results" | "deploy-metadata" | "error-telemetry" | "feature-flags" | "doc-health" | "human-approval" | "agent-evidence", number>> | undefined;
+        requiredSources?: ("accessibility" | "live-app-quality" | "crawl-coverage" | "test-automation" | "api-coverage" | "ci-results" | "deploy-metadata" | "error-telemetry" | "feature-flags" | "doc-health" | "human-approval" | "agent-evidence" | "decision-quality")[] | undefined;
+        weights?: Partial<Record<"accessibility" | "live-app-quality" | "crawl-coverage" | "test-automation" | "api-coverage" | "ci-results" | "deploy-metadata" | "error-telemetry" | "feature-flags" | "doc-health" | "human-approval" | "agent-evidence" | "decision-quality", number>> | undefined;
     }>>;
 }, "strip", z.ZodTypeAny, {
     evidence: {
-        source: "accessibility" | "live-app-quality" | "crawl-coverage" | "test-automation" | "api-coverage" | "ci-results" | "deploy-metadata" | "error-telemetry" | "feature-flags" | "doc-health" | "human-approval" | "agent-evidence";
+        source: "accessibility" | "live-app-quality" | "crawl-coverage" | "test-automation" | "api-coverage" | "ci-results" | "deploy-metadata" | "error-telemetry" | "feature-flags" | "doc-health" | "human-approval" | "agent-evidence" | "decision-quality";
         recommendations: string[];
         score: number | null;
         weight: number;
@@ -351,12 +351,12 @@ export declare const ConfidenceInputSchema: z.ZodObject<{
         passThreshold: number;
         failThreshold: number;
         maxListLength: number;
-        requiredSources: ("accessibility" | "live-app-quality" | "crawl-coverage" | "test-automation" | "api-coverage" | "ci-results" | "deploy-metadata" | "error-telemetry" | "feature-flags" | "doc-health" | "human-approval" | "agent-evidence")[];
-        weights?: Partial<Record<"accessibility" | "live-app-quality" | "crawl-coverage" | "test-automation" | "api-coverage" | "ci-results" | "deploy-metadata" | "error-telemetry" | "feature-flags" | "doc-health" | "human-approval" | "agent-evidence", number>> | undefined;
+        requiredSources: ("accessibility" | "live-app-quality" | "crawl-coverage" | "test-automation" | "api-coverage" | "ci-results" | "deploy-metadata" | "error-telemetry" | "feature-flags" | "doc-health" | "human-approval" | "agent-evidence" | "decision-quality")[];
+        weights?: Partial<Record<"accessibility" | "live-app-quality" | "crawl-coverage" | "test-automation" | "api-coverage" | "ci-results" | "deploy-metadata" | "error-telemetry" | "feature-flags" | "doc-health" | "human-approval" | "agent-evidence" | "decision-quality", number>> | undefined;
     } | undefined;
 }, {
     evidence: {
-        source: "accessibility" | "live-app-quality" | "crawl-coverage" | "test-automation" | "api-coverage" | "ci-results" | "deploy-metadata" | "error-telemetry" | "feature-flags" | "doc-health" | "human-approval" | "agent-evidence";
+        source: "accessibility" | "live-app-quality" | "crawl-coverage" | "test-automation" | "api-coverage" | "ci-results" | "deploy-metadata" | "error-telemetry" | "feature-flags" | "doc-health" | "human-approval" | "agent-evidence" | "decision-quality";
         score: number | null;
         weight: number;
         evidence: string[];
@@ -384,15 +384,15 @@ export declare const ConfidenceInputSchema: z.ZodObject<{
         passThreshold?: number | undefined;
         failThreshold?: number | undefined;
         maxListLength?: number | undefined;
-        requiredSources?: ("accessibility" | "live-app-quality" | "crawl-coverage" | "test-automation" | "api-coverage" | "ci-results" | "deploy-metadata" | "error-telemetry" | "feature-flags" | "doc-health" | "human-approval" | "agent-evidence")[] | undefined;
-        weights?: Partial<Record<"accessibility" | "live-app-quality" | "crawl-coverage" | "test-automation" | "api-coverage" | "ci-results" | "deploy-metadata" | "error-telemetry" | "feature-flags" | "doc-health" | "human-approval" | "agent-evidence", number>> | undefined;
+        requiredSources?: ("accessibility" | "live-app-quality" | "crawl-coverage" | "test-automation" | "api-coverage" | "ci-results" | "deploy-metadata" | "error-telemetry" | "feature-flags" | "doc-health" | "human-approval" | "agent-evidence" | "decision-quality")[] | undefined;
+        weights?: Partial<Record<"accessibility" | "live-app-quality" | "crawl-coverage" | "test-automation" | "api-coverage" | "ci-results" | "deploy-metadata" | "error-telemetry" | "feature-flags" | "doc-health" | "human-approval" | "agent-evidence" | "decision-quality", number>> | undefined;
     } | undefined;
 }>;
 export type ConfidenceInput = z.infer<typeof ConfidenceInputSchema>;
 export declare const ConfidenceVerdictSchema: z.ZodEnum<["ship", "caution", "hold", "block"]>;
 export type ConfidenceVerdict = z.infer<typeof ConfidenceVerdictSchema>;
 export declare const ConfidenceContributionSchema: z.ZodObject<{
-    source: z.ZodEnum<["live-app-quality", "accessibility", "crawl-coverage", "test-automation", "api-coverage", "ci-results", "deploy-metadata", "error-telemetry", "feature-flags", "doc-health", "human-approval", "agent-evidence"]>;
+    source: z.ZodEnum<["live-app-quality", "accessibility", "crawl-coverage", "test-automation", "api-coverage", "ci-results", "deploy-metadata", "error-telemetry", "feature-flags", "doc-health", "human-approval", "agent-evidence", "decision-quality"]>;
     score: z.ZodNullable<z.ZodNumber>;
     weight: z.ZodNumber;
     /** Renormalized weight over the applicable set (sums to 1.0 across applicable items). */
@@ -400,14 +400,14 @@ export declare const ConfidenceContributionSchema: z.ZodObject<{
     applicability: z.ZodEnum<["applicable", "not_applicable", "unknown"]>;
     blocking: z.ZodBoolean;
 }, "strip", z.ZodTypeAny, {
-    source: "accessibility" | "live-app-quality" | "crawl-coverage" | "test-automation" | "api-coverage" | "ci-results" | "deploy-metadata" | "error-telemetry" | "feature-flags" | "doc-health" | "human-approval" | "agent-evidence";
+    source: "accessibility" | "live-app-quality" | "crawl-coverage" | "test-automation" | "api-coverage" | "ci-results" | "deploy-metadata" | "error-telemetry" | "feature-flags" | "doc-health" | "human-approval" | "agent-evidence" | "decision-quality";
     score: number | null;
     weight: number;
     applicability: "unknown" | "applicable" | "not_applicable";
     blocking: boolean;
     effectiveWeight: number;
 }, {
-    source: "accessibility" | "live-app-quality" | "crawl-coverage" | "test-automation" | "api-coverage" | "ci-results" | "deploy-metadata" | "error-telemetry" | "feature-flags" | "doc-health" | "human-approval" | "agent-evidence";
+    source: "accessibility" | "live-app-quality" | "crawl-coverage" | "test-automation" | "api-coverage" | "ci-results" | "deploy-metadata" | "error-telemetry" | "feature-flags" | "doc-health" | "human-approval" | "agent-evidence" | "decision-quality";
     score: number | null;
     weight: number;
     applicability: "unknown" | "applicable" | "not_applicable";
@@ -442,7 +442,7 @@ export declare const ReleaseConfidenceSchema: z.ZodObject<{
     label: z.ZodString;
     /** Per-source breakdown including excluded (not_applicable / unknown) items. */
     contributions: z.ZodArray<z.ZodObject<{
-        source: z.ZodEnum<["live-app-quality", "accessibility", "crawl-coverage", "test-automation", "api-coverage", "ci-results", "deploy-metadata", "error-telemetry", "feature-flags", "doc-health", "human-approval", "agent-evidence"]>;
+        source: z.ZodEnum<["live-app-quality", "accessibility", "crawl-coverage", "test-automation", "api-coverage", "ci-results", "deploy-metadata", "error-telemetry", "feature-flags", "doc-health", "human-approval", "agent-evidence", "decision-quality"]>;
         score: z.ZodNullable<z.ZodNumber>;
         weight: z.ZodNumber;
         /** Renormalized weight over the applicable set (sums to 1.0 across applicable items). */
@@ -450,14 +450,14 @@ export declare const ReleaseConfidenceSchema: z.ZodObject<{
         applicability: z.ZodEnum<["applicable", "not_applicable", "unknown"]>;
         blocking: z.ZodBoolean;
     }, "strip", z.ZodTypeAny, {
-        source: "accessibility" | "live-app-quality" | "crawl-coverage" | "test-automation" | "api-coverage" | "ci-results" | "deploy-metadata" | "error-telemetry" | "feature-flags" | "doc-health" | "human-approval" | "agent-evidence";
+        source: "accessibility" | "live-app-quality" | "crawl-coverage" | "test-automation" | "api-coverage" | "ci-results" | "deploy-metadata" | "error-telemetry" | "feature-flags" | "doc-health" | "human-approval" | "agent-evidence" | "decision-quality";
         score: number | null;
         weight: number;
         applicability: "unknown" | "applicable" | "not_applicable";
         blocking: boolean;
         effectiveWeight: number;
     }, {
-        source: "accessibility" | "live-app-quality" | "crawl-coverage" | "test-automation" | "api-coverage" | "ci-results" | "deploy-metadata" | "error-telemetry" | "feature-flags" | "doc-health" | "human-approval" | "agent-evidence";
+        source: "accessibility" | "live-app-quality" | "crawl-coverage" | "test-automation" | "api-coverage" | "ci-results" | "deploy-metadata" | "error-telemetry" | "feature-flags" | "doc-health" | "human-approval" | "agent-evidence" | "decision-quality";
         score: number | null;
         weight: number;
         applicability: "unknown" | "applicable" | "not_applicable";
@@ -476,16 +476,16 @@ export declare const ReleaseConfidenceSchema: z.ZodObject<{
     level: number;
     computedAt: string;
     scoreFormula: string;
+    schemaVersion: 1;
     subject: {
         kind: "app" | "repo" | "release" | "pr" | "deploy";
         ref: string;
         tenantId: string;
     };
-    schemaVersion: 1;
     confidenceScore: number | null;
     verdict: "ship" | "caution" | "hold" | "block";
     contributions: {
-        source: "accessibility" | "live-app-quality" | "crawl-coverage" | "test-automation" | "api-coverage" | "ci-results" | "deploy-metadata" | "error-telemetry" | "feature-flags" | "doc-health" | "human-approval" | "agent-evidence";
+        source: "accessibility" | "live-app-quality" | "crawl-coverage" | "test-automation" | "api-coverage" | "ci-results" | "deploy-metadata" | "error-telemetry" | "feature-flags" | "doc-health" | "human-approval" | "agent-evidence" | "decision-quality";
         score: number | null;
         weight: number;
         applicability: "unknown" | "applicable" | "not_applicable";
@@ -501,16 +501,16 @@ export declare const ReleaseConfidenceSchema: z.ZodObject<{
     level: number;
     computedAt: string;
     scoreFormula: string;
+    schemaVersion: 1;
     subject: {
         kind: "app" | "repo" | "release" | "pr" | "deploy";
         ref: string;
         tenantId?: string | undefined;
     };
-    schemaVersion: 1;
     confidenceScore: number | null;
     verdict: "ship" | "caution" | "hold" | "block";
     contributions: {
-        source: "accessibility" | "live-app-quality" | "crawl-coverage" | "test-automation" | "api-coverage" | "ci-results" | "deploy-metadata" | "error-telemetry" | "feature-flags" | "doc-health" | "human-approval" | "agent-evidence";
+        source: "accessibility" | "live-app-quality" | "crawl-coverage" | "test-automation" | "api-coverage" | "ci-results" | "deploy-metadata" | "error-telemetry" | "feature-flags" | "doc-health" | "human-approval" | "agent-evidence" | "decision-quality";
         score: number | null;
         weight: number;
         applicability: "unknown" | "applicable" | "not_applicable";

package/dist/schemas/confidence.schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"confidence.schema.d.ts","sourceRoot":"","sources":["../../src/schemas/confidence.schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,wBAAwB,8NAenC,CAAC;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAM1E,eAAO,MAAM,sBAAsB;IACjC;;;OAGG;;IAEH;;;OAGG;;IAEH,qFAAqF;;IAErF;;;OAGG;;IAEH;;;OAGG;;;;;;;;;;;;;;EAEH,CAAC;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAMtE,eAAO,MAAM,kBAAkB;;IAE7B;;;;OAIG;;;IAGH;;;;;;OAMG;;IAEH;;;OAGG;;IAEH,qDAAqD;;;IAGrD,0FAA0F;;IAE1F,0DAA0D;;IAE1D;;OAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAYH,CAAC;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAM9D,eAAO,MAAM,uBAAuB;;;IAGlC,qFAAqF;;;;;;;;;;EAErF,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAMxE,eAAO,MAAM,qBAAqB;;;;QAThC,qFAAqF;;;;;;;;;;;;;QAnDrF;;;;WAIG;;;QAGH;;;;;;WAMG;;QAEH;;;WAGG;;QAEH,qDAAqD;;;QAGrD,0FAA0F;;QAE1F,0DAA0D;;QAE1D;;WAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QA5DH;;;WAGG;;QAEH;;;WAGG;;QAEH,qFAAqF;;QAErF;;;WAGG;;QAEH;;;WAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2EH,CAAC;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAMpE,eAAO,MAAM,uBAAuB,iDAA+C,CAAC;AACpF,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAMxE,eAAO,MAAM,4BAA4B;;;;IAIvC,yFAAyF;;;;;;;;;;;;;;;;;;EAIzF,CAAC;AACH,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAElF,eAAO,MAAM,uBAAuB;;;;;;QAtClC,qFAAqF;;;;;;;;;;;IA0CrF;;;OAGG;;;;;IAKH,gFAAgF;;;;;QAnBhF,yFAAyF;;;;;;;;;;;;;;;;;;;;;IAuBzF,yEAAyE;;IAEzE,2EAA2E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAG3E,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC"}
+{"version":3,"file":"confidence.schema.d.ts","sourceRoot":"","sources":["../../src/schemas/confidence.schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,wBAAwB,kPAgBnC,CAAC;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAM1E,eAAO,MAAM,sBAAsB;IACjC;;;OAGG;;IAEH;;;OAGG;;IAEH,qFAAqF;;IAErF;;;OAGG;;IAEH;;;OAGG;;;;;;;;;;;;;;EAEH,CAAC;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAMtE,eAAO,MAAM,kBAAkB;;IAE7B;;;;OAIG;;;IAGH;;;;;;OAMG;;IAEH;;;OAGG;;IAEH,qDAAqD;;;IAGrD,0FAA0F;;IAE1F,0DAA0D;;IAE1D;;OAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAYH,CAAC;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAM9D,eAAO,MAAM,uBAAuB;;;IAGlC,qFAAqF;;;;;;;;;;EAErF,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAMxE,eAAO,MAAM,qBAAqB;;;;QAThC,qFAAqF;;;;;;;;;;;;;QAnDrF;;;;WAIG;;;QAGH;;;;;;WAMG;;QAEH;;;WAGG;;QAEH,qDAAqD;;;QAGrD,0FAA0F;;QAE1F,0DAA0D;;QAE1D;;WAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QA5DH;;;WAGG;;QAEH;;;WAGG;;QAEH,qFAAqF;;QAErF;;;WAGG;;QAEH;;;WAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2EH,CAAC;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAMpE,eAAO,MAAM,uBAAuB,iDAA+C,CAAC;AACpF,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAMxE,eAAO,MAAM,4BAA4B;;;;IAIvC,yFAAyF;;;;;;;;;;;;;;;;;;EAIzF,CAAC;AACH,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAElF,eAAO,MAAM,uBAAuB;;;;;;QAtClC,qFAAqF;;;;;;;;;;;IA0CrF;;;OAGG;;;;;IAKH,gFAAgF;;;;;QAnBhF,yFAAyF;;;;;;;;;;;;;;;;;;;;;IAuBzF,yEAAyE;;IAEzE,2EAA2E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAG3E,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC"}

package/dist/schemas/confidence.schema.js

@@ -29,6 +29,7 @@ export const EvidenceSourceKindSchema = z.enum([
     'doc-health',
     'human-approval',
     'agent-evidence',
+    'decision-quality',
 ]);
 // ---------------------------------------------------------------------------
 // Policy

package/dist/schemas/decision-score.schema.d.ts

@@ -0,0 +1,157 @@
+import { z } from 'zod';
+export declare const ForkKindSchema: z.ZodEnum<["gate_block_vs_pass", "stop_vs_continue", "escalate_vs_proceed"]>;
+export declare const DecisionForkSchema: z.ZodObject<{
+    fork_id: z.ZodString;
+    fork_kind: z.ZodEnum<["gate_block_vs_pass", "stop_vs_continue", "escalate_vs_proceed"]>;
+    options: z.ZodArray<z.ZodString, "many">;
+    choice: z.ZodString;
+    constraint: z.ZodString;
+    settleable: z.ZodBoolean;
+    source_event_id: z.ZodString;
+    ts: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    options: string[];
+    fork_id: string;
+    fork_kind: "gate_block_vs_pass" | "stop_vs_continue" | "escalate_vs_proceed";
+    choice: string;
+    constraint: string;
+    settleable: boolean;
+    source_event_id: string;
+    ts: string;
+}, {
+    options: string[];
+    fork_id: string;
+    fork_kind: "gate_block_vs_pass" | "stop_vs_continue" | "escalate_vs_proceed";
+    choice: string;
+    constraint: string;
+    settleable: boolean;
+    source_event_id: string;
+    ts: string;
+}>;
+export declare const ScoreDecisionsInputSchema: z.ZodObject<{
+    forksPath: z.ZodString;
+    enableLlmJudge: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    forksPath: string;
+    enableLlmJudge?: boolean | undefined;
+}, {
+    forksPath: string;
+    enableLlmJudge?: boolean | undefined;
+}>;
+export declare const DecisionScoringPathSchema: z.ZodEnum<["deterministic", "llm-refined"]>;
+export declare const ScoredDecisionForkSchema: z.ZodObject<{
+    fork_id: z.ZodString;
+    fork_kind: z.ZodEnum<["gate_block_vs_pass", "stop_vs_continue", "escalate_vs_proceed"]>;
+    choice: z.ZodString;
+    decisionQuality: z.ZodNumber;
+    seniorCorrect: z.ZodBoolean;
+    rationale: z.ZodString;
+    scoringPath: z.ZodEnum<["deterministic", "llm-refined"]>;
+}, "strip", z.ZodTypeAny, {
+    rationale: string;
+    scoringPath: "deterministic" | "llm-refined";
+    fork_id: string;
+    fork_kind: "gate_block_vs_pass" | "stop_vs_continue" | "escalate_vs_proceed";
+    choice: string;
+    decisionQuality: number;
+    seniorCorrect: boolean;
+}, {
+    rationale: string;
+    scoringPath: "deterministic" | "llm-refined";
+    fork_id: string;
+    fork_kind: "gate_block_vs_pass" | "stop_vs_continue" | "escalate_vs_proceed";
+    choice: string;
+    decisionQuality: number;
+    seniorCorrect: boolean;
+}>;
+export declare const DecisionScoreAggregateSchema: z.ZodObject<{
+    meanDecisionQuality: z.ZodNumber;
+    byKind: z.ZodRecord<z.ZodEnum<["gate_block_vs_pass", "stop_vs_continue", "escalate_vs_proceed"]>, z.ZodNumber>;
+    count: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    count: number;
+    meanDecisionQuality: number;
+    byKind: Partial<Record<"gate_block_vs_pass" | "stop_vs_continue" | "escalate_vs_proceed", number>>;
+}, {
+    count: number;
+    meanDecisionQuality: number;
+    byKind: Partial<Record<"gate_block_vs_pass" | "stop_vs_continue" | "escalate_vs_proceed", number>>;
+}>;
+export declare const DecisionScoreResultSchema: z.ZodObject<{
+    scored: z.ZodArray<z.ZodObject<{
+        fork_id: z.ZodString;
+        fork_kind: z.ZodEnum<["gate_block_vs_pass", "stop_vs_continue", "escalate_vs_proceed"]>;
+        choice: z.ZodString;
+        decisionQuality: z.ZodNumber;
+        seniorCorrect: z.ZodBoolean;
+        rationale: z.ZodString;
+        scoringPath: z.ZodEnum<["deterministic", "llm-refined"]>;
+    }, "strip", z.ZodTypeAny, {
+        rationale: string;
+        scoringPath: "deterministic" | "llm-refined";
+        fork_id: string;
+        fork_kind: "gate_block_vs_pass" | "stop_vs_continue" | "escalate_vs_proceed";
+        choice: string;
+        decisionQuality: number;
+        seniorCorrect: boolean;
+    }, {
+        rationale: string;
+        scoringPath: "deterministic" | "llm-refined";
+        fork_id: string;
+        fork_kind: "gate_block_vs_pass" | "stop_vs_continue" | "escalate_vs_proceed";
+        choice: string;
+        decisionQuality: number;
+        seniorCorrect: boolean;
+    }>, "many">;
+    aggregate: z.ZodObject<{
+        meanDecisionQuality: z.ZodNumber;
+        byKind: z.ZodRecord<z.ZodEnum<["gate_block_vs_pass", "stop_vs_continue", "escalate_vs_proceed"]>, z.ZodNumber>;
+        count: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        count: number;
+        meanDecisionQuality: number;
+        byKind: Partial<Record<"gate_block_vs_pass" | "stop_vs_continue" | "escalate_vs_proceed", number>>;
+    }, {
+        count: number;
+        meanDecisionQuality: number;
+        byKind: Partial<Record<"gate_block_vs_pass" | "stop_vs_continue" | "escalate_vs_proceed", number>>;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    scored: {
+        rationale: string;
+        scoringPath: "deterministic" | "llm-refined";
+        fork_id: string;
+        fork_kind: "gate_block_vs_pass" | "stop_vs_continue" | "escalate_vs_proceed";
+        choice: string;
+        decisionQuality: number;
+        seniorCorrect: boolean;
+    }[];
+    aggregate: {
+        count: number;
+        meanDecisionQuality: number;
+        byKind: Partial<Record<"gate_block_vs_pass" | "stop_vs_continue" | "escalate_vs_proceed", number>>;
+    };
+}, {
+    scored: {
+        rationale: string;
+        scoringPath: "deterministic" | "llm-refined";
+        fork_id: string;
+        fork_kind: "gate_block_vs_pass" | "stop_vs_continue" | "escalate_vs_proceed";
+        choice: string;
+        decisionQuality: number;
+        seniorCorrect: boolean;
+    }[];
+    aggregate: {
+        count: number;
+        meanDecisionQuality: number;
+        byKind: Partial<Record<"gate_block_vs_pass" | "stop_vs_continue" | "escalate_vs_proceed", number>>;
+    };
+}>;
+export type ForkKind = z.infer<typeof ForkKindSchema>;
+export type DecisionFork = z.infer<typeof DecisionForkSchema>;
+export type ScoreDecisionsInput = z.infer<typeof ScoreDecisionsInputSchema>;
+export type DecisionScoringPath = z.infer<typeof DecisionScoringPathSchema>;
+export type ScoredDecisionFork = z.infer<typeof ScoredDecisionForkSchema>;
+export type DecisionScoreAggregate = z.infer<typeof DecisionScoreAggregateSchema>;
+export type DecisionScoreResult = z.infer<typeof DecisionScoreResultSchema>;
+//# sourceMappingURL=decision-score.schema.d.ts.map

package/dist/schemas/decision-score.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decision-score.schema.d.ts","sourceRoot":"","sources":["../../src/schemas/decision-score.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,cAAc,8EAIzB,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;EAS7B,CAAC;AAEH,eAAO,MAAM,yBAAyB;;;;;;;;;EAGpC,CAAC;AAEH,eAAO,MAAM,yBAAyB,6CAA2C,CAAC;AAElF,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;EAQnC,CAAC;AAEH,eAAO,MAAM,4BAA4B;;;;;;;;;;;;EAIvC,CAAC;AAEH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGpC,CAAC;AAEH,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AACtD,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAC9D,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAC5E,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAC5E,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAC1E,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAClF,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC"}

package/dist/schemas/decision-score.schema.js

@@ -0,0 +1,39 @@
+import { z } from 'zod';
+export const ForkKindSchema = z.enum([
+    'gate_block_vs_pass',
+    'stop_vs_continue',
+    'escalate_vs_proceed',
+]);
+export const DecisionForkSchema = z.object({
+    fork_id: z.string().min(1).max(200),
+    fork_kind: ForkKindSchema,
+    options: z.array(z.string().min(1).max(500)).min(2).max(20),
+    choice: z.string().min(1).max(500),
+    constraint: z.string().min(1).max(8000),
+    settleable: z.boolean(),
+    source_event_id: z.string().min(1).max(200),
+    ts: z.string().min(1).max(100),
+});
+export const ScoreDecisionsInputSchema = z.object({
+    forksPath: z.string().min(1),
+    enableLlmJudge: z.boolean().optional(),
+});
+export const DecisionScoringPathSchema = z.enum(['deterministic', 'llm-refined']);
+export const ScoredDecisionForkSchema = z.object({
+    fork_id: z.string(),
+    fork_kind: ForkKindSchema,
+    choice: z.string(),
+    decisionQuality: z.number().min(0).max(1),
+    seniorCorrect: z.boolean(),
+    rationale: z.string(),
+    scoringPath: DecisionScoringPathSchema,
+});
+export const DecisionScoreAggregateSchema = z.object({
+    meanDecisionQuality: z.number().min(0).max(1),
+    byKind: z.record(ForkKindSchema, z.number().min(0).max(1)),
+    count: z.number().int().min(0),
+});
+export const DecisionScoreResultSchema = z.object({
+    scored: z.array(ScoredDecisionForkSchema),
+    aggregate: DecisionScoreAggregateSchema,
+});

package/dist/schemas/gap-analysis.schema.d.ts

@@ -4,7 +4,7 @@ export declare const GapSchema: z.ZodObject<{
     path: z.ZodString;
     severity: z.ZodEnum<["critical", "high", "medium", "low"]>;
     reason: z.ZodString;
-    category: z.ZodEnum<["untested-route", "a11y", "console-error", "broken-link", "auth-surface", "coverage", "untested-api-endpoint"]>;
+    category: z.ZodEnum<["untested-route", "a11y", "console-error", "broken-link", "auth-surface", "coverage", "untested-api-endpoint", "prompt-leakage"]>;
     description: z.ZodOptional<z.ZodString>;
     recommendation: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
@@ -12,7 +12,7 @@ export declare const GapSchema: z.ZodObject<{
     id: string;
     severity: "critical" | "high" | "medium" | "low";
     reason: string;
-    category: "untested-route" | "a11y" | "console-error" | "broken-link" | "auth-surface" | "coverage" | "untested-api-endpoint";
+    category: "untested-route" | "a11y" | "console-error" | "broken-link" | "auth-surface" | "coverage" | "untested-api-endpoint" | "prompt-leakage";
     recommendation?: string | undefined;
     description?: string | undefined;
 }, {
@@ -20,7 +20,7 @@ export declare const GapSchema: z.ZodObject<{
     id: string;
     severity: "critical" | "high" | "medium" | "low";
     reason: string;
-    category: "untested-route" | "a11y" | "console-error" | "broken-link" | "auth-surface" | "coverage" | "untested-api-endpoint";
+    category: "untested-route" | "a11y" | "console-error" | "broken-link" | "auth-surface" | "coverage" | "untested-api-endpoint" | "prompt-leakage";
     recommendation?: string | undefined;
     description?: string | undefined;
 }>;
@@ -163,7 +163,7 @@ export declare const GapAnalysisSchema: z.ZodObject<{
         path: z.ZodString;
         severity: z.ZodEnum<["critical", "high", "medium", "low"]>;
         reason: z.ZodString;
-        category: z.ZodEnum<["untested-route", "a11y", "console-error", "broken-link", "auth-surface", "coverage", "untested-api-endpoint"]>;
+        category: z.ZodEnum<["untested-route", "a11y", "console-error", "broken-link", "auth-surface", "coverage", "untested-api-endpoint", "prompt-leakage"]>;
         description: z.ZodOptional<z.ZodString>;
         recommendation: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
@@ -171,7 +171,7 @@ export declare const GapAnalysisSchema: z.ZodObject<{
         id: string;
         severity: "critical" | "high" | "medium" | "low";
         reason: string;
-        category: "untested-route" | "a11y" | "console-error" | "broken-link" | "auth-surface" | "coverage" | "untested-api-endpoint";
+        category: "untested-route" | "a11y" | "console-error" | "broken-link" | "auth-surface" | "coverage" | "untested-api-endpoint" | "prompt-leakage";
         recommendation?: string | undefined;
         description?: string | undefined;
     }, {
@@ -179,7 +179,7 @@ export declare const GapAnalysisSchema: z.ZodObject<{
         id: string;
         severity: "critical" | "high" | "medium" | "low";
         reason: string;
-        category: "untested-route" | "a11y" | "console-error" | "broken-link" | "auth-surface" | "coverage" | "untested-api-endpoint";
+        category: "untested-route" | "a11y" | "console-error" | "broken-link" | "auth-surface" | "coverage" | "untested-api-endpoint" | "prompt-leakage";
         recommendation?: string | undefined;
         description?: string | undefined;
     }>, "many">;
@@ -445,7 +445,7 @@ export declare const GapAnalysisSchema: z.ZodObject<{
         id: string;
         severity: "critical" | "high" | "medium" | "low";
         reason: string;
-        category: "untested-route" | "a11y" | "console-error" | "broken-link" | "auth-surface" | "coverage" | "untested-api-endpoint";
+        category: "untested-route" | "a11y" | "console-error" | "broken-link" | "auth-surface" | "coverage" | "untested-api-endpoint" | "prompt-leakage";
         recommendation?: string | undefined;
         description?: string | undefined;
     }[];
@@ -524,7 +524,7 @@ export declare const GapAnalysisSchema: z.ZodObject<{
         id: string;
         severity: "critical" | "high" | "medium" | "low";
         reason: string;
-        category: "untested-route" | "a11y" | "console-error" | "broken-link" | "auth-surface" | "coverage" | "untested-api-endpoint";
+        category: "untested-route" | "a11y" | "console-error" | "broken-link" | "auth-surface" | "coverage" | "untested-api-endpoint" | "prompt-leakage";
         recommendation?: string | undefined;
         description?: string | undefined;
     }[];

package/dist/schemas/gap-analysis.schema.js

@@ -5,7 +5,7 @@ export const GapSchema = z.object({
     path: z.string(),
     severity: z.enum(['critical', 'high', 'medium', 'low']),
     reason: z.string(),
-    category: z.enum(['untested-route', 'a11y', 'console-error', 'broken-link', 'auth-surface', 'coverage', 'untested-api-endpoint']),
+    category: z.enum(['untested-route', 'a11y', 'console-error', 'broken-link', 'auth-surface', 'coverage', 'untested-api-endpoint', 'prompt-leakage']),
     description: z.string().optional(),
     recommendation: z.string().optional(),
 });