@claritylabs/cl-sdk 0.9.0 → 0.10.0

package/dist/index.js

@@ -29,7 +29,12 @@ __export(index_exports, {
   AdmittedStatusSchema: () => AdmittedStatusSchema,
   AnswerParsingResultSchema: () => AnswerParsingResultSchema,
   ApplicationClassifyResultSchema: () => ApplicationClassifyResultSchema,
+  ApplicationEmailReviewSchema: () => ApplicationEmailReviewSchema,
   ApplicationFieldSchema: () => ApplicationFieldSchema,
+  ApplicationQualityArtifactSchema: () => ApplicationQualityArtifactSchema,
+  ApplicationQualityIssueSchema: () => ApplicationQualityIssueSchema,
+  ApplicationQualityReportSchema: () => ApplicationQualityReportSchema,
+  ApplicationQualityRoundSchema: () => ApplicationQualityRoundSchema,
   ApplicationStateSchema: () => ApplicationStateSchema,
   AuditTypeSchema: () => AuditTypeSchema,
   AutoFillMatchSchema: () => AutoFillMatchSchema,
@@ -61,6 +66,7 @@ __export(index_exports, {
   CoverageFormSchema: () => CoverageFormSchema,
   CoverageSchema: () => CoverageSchema,
   CoverageTriggerSchema: () => CoverageTriggerSchema,
+  CoverageValueTypeSchema: () => CoverageValueTypeSchema,
   CrimeDeclarationsSchema: () => CrimeDeclarationsSchema,
   CyberDeclarationsSchema: () => CyberDeclarationsSchema,
   DEDUCTIBLE_TYPES: () => DEDUCTIBLE_TYPES,
@@ -730,7 +736,9 @@ var FormReferenceSchema = import_zod3.z.object({
   formNumber: import_zod3.z.string(),
   editionDate: import_zod3.z.string().optional(),
   title: import_zod3.z.string().optional(),
-  formType: import_zod3.z.enum(["coverage", "endorsement", "declarations", "application", "notice", "other"])
+  formType: import_zod3.z.enum(["coverage", "endorsement", "declarations", "application", "notice", "other"]),
+  pageStart: import_zod3.z.number().optional(),
+  pageEnd: import_zod3.z.number().optional()
 });
 var TaxFeeItemSchema = import_zod3.z.object({
   name: import_zod3.z.string(),
@@ -767,12 +775,25 @@ var NamedInsuredSchema = import_zod3.z.object({
 
 // src/schemas/coverage.ts
 var import_zod4 = require("zod");
+var CoverageValueTypeSchema = import_zod4.z.enum([
+  "numeric",
+  "included",
+  "not_included",
+  "as_stated",
+  "waiting_period",
+  "referential",
+  "other"
+]);
 var CoverageSchema = import_zod4.z.object({
   name: import_zod4.z.string(),
   limit: import_zod4.z.string(),
+  limitValueType: CoverageValueTypeSchema.optional(),
   deductible: import_zod4.z.string().optional(),
+  deductibleValueType: CoverageValueTypeSchema.optional(),
+  formNumber: import_zod4.z.string().optional(),
   pageNumber: import_zod4.z.number().optional(),
-  sectionRef: import_zod4.z.string().optional()
+  sectionRef: import_zod4.z.string().optional(),
+  originalContent: import_zod4.z.string().optional()
 });
 var EnrichedCoverageSchema = import_zod4.z.object({
   name: import_zod4.z.string(),
@@ -781,8 +802,10 @@ var EnrichedCoverageSchema = import_zod4.z.object({
   formEditionDate: import_zod4.z.string().optional(),
   limit: import_zod4.z.string(),
   limitType: LimitTypeSchema.optional(),
+  limitValueType: CoverageValueTypeSchema.optional(),
   deductible: import_zod4.z.string().optional(),
   deductibleType: DeductibleTypeSchema.optional(),
+  deductibleValueType: CoverageValueTypeSchema.optional(),
   sir: import_zod4.z.string().optional(),
   sublimit: import_zod4.z.string().optional(),
   coinsurance: import_zod4.z.string().optional(),
@@ -793,7 +816,8 @@ var EnrichedCoverageSchema = import_zod4.z.object({
   included: import_zod4.z.boolean(),
   premium: import_zod4.z.string().optional(),
   pageNumber: import_zod4.z.number().optional(),
-  sectionRef: import_zod4.z.string().optional()
+  sectionRef: import_zod4.z.string().optional(),
+  originalContent: import_zod4.z.string().optional()
 });
 
 // src/schemas/endorsement.ts
@@ -1802,6 +1826,7 @@ function assembleDocument(documentId, documentType, memory) {
   const lossHistory = memory.get("loss_history");
   const sections = memory.get("sections");
   const supplementary = memory.get("supplementary");
+  const formInventory = memory.get("form_inventory");
   const classify = memory.get("classify");
   const base = {
     id: documentId,
@@ -1818,6 +1843,7 @@ function assembleDocument(documentId, documentType, memory) {
     exclusions: exclusions?.exclusions,
     conditions: conditions?.conditions,
     sections: sections?.sections,
+    formInventory: formInventory?.forms,
     declarations: declarations ? sanitizeNulls(declarations) : void 0,
     ...sanitizeNulls(lossHistory ?? {})
   };
@@ -2059,6 +2085,11 @@ async function formatDocumentContent(doc, generateText, options) {
 function chunkDocument(doc) {
   const chunks = [];
   const docId = doc.id;
+  function stringMetadata(entries) {
+    return Object.fromEntries(
+      Object.entries(entries).filter(([, value]) => value !== void 0 && value !== null && String(value).length > 0).map(([key, value]) => [key, String(value)])
+    );
+  }
   chunks.push({
     id: `${docId}:carrier_info:0`,
     documentId: docId,
@@ -2070,7 +2101,7 @@ function chunkDocument(doc) {
       doc.carrierAmBestRating ? `AM Best: ${doc.carrierAmBestRating}` : null,
       doc.mga ? `MGA: ${doc.mga}` : null
     ].filter(Boolean).join("\n"),
-    metadata: { carrier: doc.carrier, documentType: doc.type }
+    metadata: stringMetadata({ carrier: doc.carrier, documentType: doc.type })
   });
   chunks.push({
     id: `${docId}:named_insured:0`,
@@ -2082,17 +2113,32 @@ function chunkDocument(doc) {
       doc.insuredFein ? `FEIN: ${doc.insuredFein}` : null,
       doc.insuredAddress ? `Address: ${doc.insuredAddress.street1}, ${doc.insuredAddress.city}, ${doc.insuredAddress.state} ${doc.insuredAddress.zip}` : null
     ].filter(Boolean).join("\n"),
-    metadata: { insuredName: doc.insuredName, documentType: doc.type }
+    metadata: stringMetadata({ insuredName: doc.insuredName, documentType: doc.type })
   });
   doc.coverages.forEach((cov, i) => {
     chunks.push({
       id: `${docId}:coverage:${i}`,
       documentId: docId,
       type: "coverage",
-      text: `Coverage: ${cov.name}
-Limit: ${cov.limit}${cov.deductible ? `
-Deductible: ${cov.deductible}` : ""}`,
-      metadata: { coverageName: cov.name, limit: cov.limit, documentType: doc.type }
+      text: [
+        `Coverage: ${cov.name}`,
+        `Limit: ${cov.limit}`,
+        cov.limitValueType ? `Limit Type: ${cov.limitValueType}` : null,
+        cov.deductible ? `Deductible: ${cov.deductible}` : null,
+        cov.deductibleValueType ? `Deductible Type: ${cov.deductibleValueType}` : null,
+        cov.originalContent ? `Source: ${cov.originalContent}` : null
+      ].filter(Boolean).join("\n"),
+      metadata: stringMetadata({
+        coverageName: cov.name,
+        limit: cov.limit,
+        limitValueType: cov.limitValueType,
+        deductible: cov.deductible,
+        deductibleValueType: cov.deductibleValueType,
+        formNumber: cov.formNumber,
+        pageNumber: cov.pageNumber,
+        sectionRef: cov.sectionRef,
+        documentType: doc.type
+      })
     });
   });
   doc.endorsements?.forEach((end, i) => {
@@ -2102,7 +2148,13 @@ Deductible: ${cov.deductible}` : ""}`,
       type: "endorsement",
       text: `Endorsement: ${end.title}
 ${end.content}`.trim(),
-      metadata: { endorsementType: end.endorsementType, formNumber: end.formNumber, documentType: doc.type }
+      metadata: stringMetadata({
+        endorsementType: end.endorsementType,
+        formNumber: end.formNumber,
+        pageStart: end.pageStart,
+        pageEnd: end.pageEnd,
+        documentType: doc.type
+      })
     });
   });
   doc.exclusions?.forEach((exc, i) => {
@@ -2112,7 +2164,7 @@ ${end.content}`.trim(),
       type: "exclusion",
       text: `Exclusion: ${exc.name}
 ${exc.content}`.trim(),
-      metadata: { documentType: doc.type }
+      metadata: stringMetadata({ formNumber: exc.formNumber, pageNumber: exc.pageNumber, documentType: doc.type })
     });
   });
   doc.sections?.forEach((sec, i) => {
@@ -2122,7 +2174,7 @@ ${exc.content}`.trim(),
       type: "section",
       text: `Section: ${sec.title}
 ${sec.content}`,
-      metadata: { sectionType: sec.type, documentType: doc.type }
+      metadata: stringMetadata({ sectionType: sec.type, pageStart: sec.pageStart, pageEnd: sec.pageEnd, documentType: doc.type })
     });
   });
   if (doc.premium) {
@@ -2132,7 +2184,7 @@ ${sec.content}`,
       type: "premium",
       text: `Premium: ${doc.premium}${doc.totalCost ? `
 Total Cost: ${doc.totalCost}` : ""}`,
-      metadata: { premium: doc.premium, documentType: doc.type }
+      metadata: stringMetadata({ premium: doc.premium, documentType: doc.type })
     });
   }
   return chunks;
@@ -2184,12 +2236,19 @@ function mergeCoverageLimits(existing, incoming) {
   const merged = mergeShallowPreferPresent(existing, incoming);
   const existingCoverages = Array.isArray(existing.coverages) ? existing.coverages : [];
   const incomingCoverages = Array.isArray(incoming.coverages) ? incoming.coverages : [];
-  merged.coverages = mergeUniqueObjects(existingCoverages, incomingCoverages, (coverage) => [
+  const coverageKey = (coverage) => [
     String(coverage.name ?? "").toLowerCase(),
     String(coverage.limit ?? "").toLowerCase(),
     String(coverage.deductible ?? "").toLowerCase(),
     String(coverage.formNumber ?? "").toLowerCase()
-  ].join("|"));
+  ].join("|");
+  const byKey = /* @__PURE__ */ new Map();
+  for (const coverage of [...existingCoverages, ...incomingCoverages]) {
+    const key = coverageKey(coverage);
+    const current = byKey.get(key);
+    byKey.set(key, current ? mergeShallowPreferPresent(current, coverage) : coverage);
+  }
+  merged.coverages = [...byKey.values()];
   return merged;
 }
 function mergeDeclarations(existing, incoming) {
@@ -3046,9 +3105,45 @@ Return JSON only:
 }`;
 }
 
-// src/prompts/coordinator/page-map.ts
+// src/prompts/coordinator/form-inventory.ts
 var import_zod19 = require("zod");
-var PageExtractorSchema = import_zod19.z.enum([
+var FormInventoryEntrySchema = FormReferenceSchema.extend({
+  formNumber: FormReferenceSchema.shape.formNumber.describe("Form number or identifier, e.g. PR5070CF"),
+  pageStart: FormReferenceSchema.shape.pageStart.describe("Original document page where the form begins"),
+  pageEnd: FormReferenceSchema.shape.pageEnd.describe("Original document page where the form ends")
+});
+var FormInventorySchema = import_zod19.z.object({
+  forms: import_zod19.z.array(FormInventoryEntrySchema)
+});
+function buildFormInventoryPrompt(templateHints) {
+  return `You are building a form inventory for an insurance document.
+
+DOCUMENT TYPE HINTS:
+${templateHints}
+
+Extract every distinct declarations page set, policy form, coverage form, endorsement, application form, and notice form that appears in the document.
+
+For EACH form, extract:
+- formNumber: REQUIRED when present
+- editionDate: if shown
+- title: if shown
+- formType: one of coverage, endorsement, declarations, application, notice, other
+- pageStart: original page where the form begins
+- pageEnd: original page where the form ends
+
+Critical rules:
+- Include declarations page sets even if they do not show a standard form number.
+- Use original document page numbers, not local chunk page numbers.
+- Do not emit duplicate entries for repeated headers/footers.
+- Multi-page forms should be represented once with pageStart/pageEnd covering the full span when visible.
+- If a form number is visible in endorsements, schedules, or form headers, include it even if the full form title is partial.
+
+Respond with JSON only.`;
+}
+
+// src/prompts/coordinator/page-map.ts
+var import_zod20 = require("zod");
+var PageExtractorSchema = import_zod20.z.enum([
   "carrier_info",
   "named_insured",
   "coverage_limits",
@@ -3061,23 +3156,37 @@ var PageExtractorSchema = import_zod19.z.enum([
   "sections",
   "supplementary"
 ]);
-var PageAssignmentSchema = import_zod19.z.object({
-  localPageNumber: import_zod19.z.number().int().positive().describe("1-based page number within this supplied PDF chunk"),
-  extractorNames: import_zod19.z.array(PageExtractorSchema).describe("Focused extractors that should inspect this page"),
-  confidence: import_zod19.z.number().min(0).max(1).optional().describe("Confidence in the page assignment"),
-  notes: import_zod19.z.string().optional().describe("Short explanation of what appears on the page")
+var PageAssignmentSchema = import_zod20.z.object({
+  localPageNumber: import_zod20.z.number().int().positive().describe("1-based page number within this supplied PDF chunk"),
+  extractorNames: import_zod20.z.array(PageExtractorSchema).describe("Focused extractors that should inspect this page"),
+  pageRole: import_zod20.z.enum([
+    "declarations_schedule",
+    "endorsement_schedule",
+    "policy_form",
+    "endorsement_form",
+    "condition_exclusion_form",
+    "supplementary",
+    "other"
+  ]).optional().describe("Primary role of the page"),
+  hasScheduleValues: import_zod20.z.boolean().optional().describe("True only when the page contains insured-specific declaration or schedule values, tables, or rows to extract"),
+  confidence: import_zod20.z.number().min(0).max(1).optional().describe("Confidence in the page assignment"),
+  notes: import_zod20.z.string().optional().describe("Short explanation of what appears on the page")
 });
-var PageMapChunkSchema = import_zod19.z.object({
-  pages: import_zod19.z.array(PageAssignmentSchema)
+var PageMapChunkSchema = import_zod20.z.object({
+  pages: import_zod20.z.array(PageAssignmentSchema)
 });
-function buildPageMapPrompt(templateHints, startPage, endPage) {
+function buildPageMapPrompt(templateHints, startPage, endPage, formInventoryHint) {
+  const inventoryBlock = formInventoryHint ? `
+FORM INVENTORY (already identified \u2014 use this to constrain your assignments):
+${formInventoryHint}
+` : "";
   return `You are mapping insurance document pages to focused extractors.
 
 These supplied pages are ORIGINAL DOCUMENT PAGES ${startPage}-${endPage}.
 
 DOCUMENT TYPE HINTS:
 ${templateHints}
-
+${inventoryBlock}
 For each page in this supplied PDF chunk, decide which extractor(s) should inspect it.
 
 Available extractors:
@@ -3099,7 +3208,11 @@ Rules:
 - Avoid assigning broad ranges mentally; decide page by page.
 - A page may map to multiple extractors if it legitimately contains multiple relevant sections.
 - Prefer declarations and schedules for numeric limits/deductibles over later generic form wording.
-- If a page is mostly generic form language with no declaration-specific values, do not assign "coverage_limits" unless it clearly contains schedule-specific limits.
+- Assign "coverage_limits" only when the page itself contains insured-specific declaration or schedule values to capture, such as location/building rows, coverage tables, limits, deductibles, coinsurance percentages, or scheduled amounts tied to this policy.
+- Do NOT assign "coverage_limits" for generic policy-form or endorsement text that merely explains how limits, deductibles, waiting periods, or coinsurance work, or that says values are "shown in the declarations", "shown in the schedule", "as stated", or "if applicable".
+- Headings like "Limits of Insurance", "Deductible", "Coinsurance", "Loss Conditions", or "Definitions" inside a policy form usually indicate form language, not declarations or schedules.
+- Continuation pages near the end of a form should stay mapped to "sections" plus "conditions"/"exclusions" when applicable, even if they mention limits or deductibles.
+- When a form inventory entry identifies a page range as a specific form type (e.g., endorsement, coverage, application), use that classification to guide your extractor choice. Do not assign "coverage_limits" to pages the inventory identifies as endorsement or condition/exclusion forms unless the page contains actual schedule values.
 - Return every page in the supplied chunk exactly once.
 
 Return JSON:
@@ -3108,6 +3221,8 @@ Return JSON:
     {
       "localPageNumber": 1,
       "extractorNames": ["declarations", "carrier_info", "named_insured", "coverage_limits"],
+      "pageRole": "declarations_schedule",
+      "hasScheduleValues": true,
       "confidence": 0.96,
       "notes": "Declarations page with insured, policy period, and scheduled limits"
     }
@@ -3116,18 +3231,26 @@ Return JSON:
 
 Respond with JSON only.`;
 }
+function formatFormInventoryForPageMap(forms) {
+  if (forms.length === 0) return "";
+  return forms.filter((f) => f.pageStart != null).map((f) => {
+    const range = f.pageEnd && f.pageEnd !== f.pageStart ? `pages ${f.pageStart}-${f.pageEnd}` : `page ${f.pageStart}`;
+    const title = f.title ? ` "${f.title}"` : "";
+    return `- ${f.formNumber}${title} [${f.formType}] \u2192 ${range}`;
+  }).join("\n");
+}
 
 // src/prompts/coordinator/review.ts
-var import_zod20 = require("zod");
-var ReviewResultSchema = import_zod20.z.object({
-  complete: import_zod20.z.boolean(),
-  missingFields: import_zod20.z.array(import_zod20.z.string()),
-  qualityIssues: import_zod20.z.array(import_zod20.z.string()).optional(),
-  additionalTasks: import_zod20.z.array(import_zod20.z.object({
-    extractorName: import_zod20.z.string(),
-    startPage: import_zod20.z.number(),
-    endPage: import_zod20.z.number(),
-    description: import_zod20.z.string()
+var import_zod21 = require("zod");
+var ReviewResultSchema = import_zod21.z.object({
+  complete: import_zod21.z.boolean(),
+  missingFields: import_zod21.z.array(import_zod21.z.string()),
+  qualityIssues: import_zod21.z.array(import_zod21.z.string()).optional(),
+  additionalTasks: import_zod21.z.array(import_zod21.z.object({
+    extractorName: import_zod21.z.string(),
+    startPage: import_zod21.z.number(),
+    endPage: import_zod21.z.number(),
+    description: import_zod21.z.string()
   }))
 });
 function buildReviewPrompt(templateExpected, extractedKeys, extractionSummary, pageMapSummary) {
@@ -3174,20 +3297,20 @@ Respond with JSON only.`;
 }
 
 // src/prompts/extractors/carrier-info.ts
-var import_zod21 = require("zod");
-var CarrierInfoSchema = import_zod21.z.object({
-  carrierName: import_zod21.z.string().describe("Primary insurance company name for display"),
-  carrierLegalName: import_zod21.z.string().optional().describe("Legal entity name of insurer"),
-  naicNumber: import_zod21.z.string().optional().describe("NAIC company code"),
-  amBestRating: import_zod21.z.string().optional().describe("AM Best rating, e.g. 'A+ XV'"),
-  admittedStatus: import_zod21.z.enum(["admitted", "non_admitted", "surplus_lines"]).optional().describe("Admitted status of the carrier"),
-  mga: import_zod21.z.string().optional().describe("Managing General Agent or Program Administrator name"),
-  underwriter: import_zod21.z.string().optional().describe("Named individual underwriter"),
-  policyNumber: import_zod21.z.string().optional().describe("Policy or quote reference number"),
-  effectiveDate: import_zod21.z.string().optional().describe("Policy effective date (MM/DD/YYYY)"),
-  expirationDate: import_zod21.z.string().optional().describe("Policy expiration date (MM/DD/YYYY)"),
-  quoteNumber: import_zod21.z.string().optional().describe("Quote or proposal reference number"),
-  proposedEffectiveDate: import_zod21.z.string().optional().describe("Proposed effective date for quotes (MM/DD/YYYY)")
+var import_zod22 = require("zod");
+var CarrierInfoSchema = import_zod22.z.object({
+  carrierName: import_zod22.z.string().describe("Primary insurance company name for display"),
+  carrierLegalName: import_zod22.z.string().optional().describe("Legal entity name of insurer"),
+  naicNumber: import_zod22.z.string().optional().describe("NAIC company code"),
+  amBestRating: import_zod22.z.string().optional().describe("AM Best rating, e.g. 'A+ XV'"),
+  admittedStatus: import_zod22.z.enum(["admitted", "non_admitted", "surplus_lines"]).optional().describe("Admitted status of the carrier"),
+  mga: import_zod22.z.string().optional().describe("Managing General Agent or Program Administrator name"),
+  underwriter: import_zod22.z.string().optional().describe("Named individual underwriter"),
+  policyNumber: import_zod22.z.string().optional().describe("Policy or quote reference number"),
+  effectiveDate: import_zod22.z.string().optional().describe("Policy effective date (MM/DD/YYYY)"),
+  expirationDate: import_zod22.z.string().optional().describe("Policy expiration date (MM/DD/YYYY)"),
+  quoteNumber: import_zod22.z.string().optional().describe("Quote or proposal reference number"),
+  proposedEffectiveDate: import_zod22.z.string().optional().describe("Proposed effective date for quotes (MM/DD/YYYY)")
 });
 function buildCarrierInfoPrompt() {
   return `You are an expert insurance document analyst. Extract carrier and policy identification information from this document.
@@ -3207,18 +3330,18 @@ Return JSON only.`;
 }
 
 // src/prompts/extractors/named-insured.ts
-var import_zod22 = require("zod");
-var AddressSchema2 = import_zod22.z.object({
-  street1: import_zod22.z.string(),
-  city: import_zod22.z.string(),
-  state: import_zod22.z.string(),
-  zip: import_zod22.z.string()
+var import_zod23 = require("zod");
+var AddressSchema2 = import_zod23.z.object({
+  street1: import_zod23.z.string(),
+  city: import_zod23.z.string(),
+  state: import_zod23.z.string(),
+  zip: import_zod23.z.string()
 });
-var NamedInsuredSchema2 = import_zod22.z.object({
-  insuredName: import_zod22.z.string().describe("Name of primary named insured"),
-  insuredDba: import_zod22.z.string().optional().describe("Doing-business-as name"),
+var NamedInsuredSchema2 = import_zod23.z.object({
+  insuredName: import_zod23.z.string().describe("Name of primary named insured"),
+  insuredDba: import_zod23.z.string().optional().describe("Doing-business-as name"),
   insuredAddress: AddressSchema2.optional().describe("Primary insured mailing address"),
-  insuredEntityType: import_zod22.z.enum([
+  insuredEntityType: import_zod23.z.enum([
     "corporation",
     "llc",
     "partnership",
@@ -3231,13 +3354,13 @@ var NamedInsuredSchema2 = import_zod22.z.object({
     "married_couple",
     "other"
   ]).optional().describe("Legal entity type of the insured"),
-  insuredFein: import_zod22.z.string().optional().describe("Federal Employer Identification Number"),
-  insuredSicCode: import_zod22.z.string().optional().describe("SIC code"),
-  insuredNaicsCode: import_zod22.z.string().optional().describe("NAICS code"),
-  additionalNamedInsureds: import_zod22.z.array(
-    import_zod22.z.object({
-      name: import_zod22.z.string(),
-      relationship: import_zod22.z.string().optional().describe("e.g. subsidiary, affiliate"),
+  insuredFein: import_zod23.z.string().optional().describe("Federal Employer Identification Number"),
+  insuredSicCode: import_zod23.z.string().optional().describe("SIC code"),
+  insuredNaicsCode: import_zod23.z.string().optional().describe("NAICS code"),
+  additionalNamedInsureds: import_zod23.z.array(
+    import_zod23.z.object({
+      name: import_zod23.z.string(),
+      relationship: import_zod23.z.string().optional().describe("e.g. subsidiary, affiliate"),
       address: AddressSchema2.optional()
     })
   ).optional().describe("Additional named insureds listed on the policy")
@@ -3258,23 +3381,20 @@ Return JSON only.`;
 }
 
 // src/prompts/extractors/coverage-limits.ts
-var import_zod23 = require("zod");
-var CoverageLimitsSchema = import_zod23.z.object({
-  coverages: import_zod23.z.array(
-    import_zod23.z.object({
-      name: import_zod23.z.string().describe("Coverage name"),
-      limit: import_zod23.z.string().describe("Coverage limit, e.g. '$1,000,000'"),
-      deductible: import_zod23.z.string().optional().describe("Deductible amount"),
-      coverageCode: import_zod23.z.string().optional().describe("Coverage code or class code"),
-      formNumber: import_zod23.z.string().optional().describe("Associated form number, e.g. 'CG 00 01'")
-    })
-  ).describe("All coverages with their limits"),
-  coverageForm: import_zod23.z.enum(["occurrence", "claims_made", "accident"]).optional().describe("Primary coverage trigger type"),
-  retroactiveDate: import_zod23.z.string().optional().describe("Retroactive date for claims-made policies (MM/DD/YYYY)")
+var import_zod24 = require("zod");
+var ExtractorCoverageSchema = CoverageSchema.extend({
+  coverageCode: import_zod24.z.string().optional().describe("Coverage code or class code")
+});
+var CoverageLimitsSchema = import_zod24.z.object({
+  coverages: import_zod24.z.array(ExtractorCoverageSchema).describe("All coverages with their limits"),
+  coverageForm: import_zod24.z.enum(["occurrence", "claims_made", "accident"]).optional().describe("Primary coverage trigger type"),
+  retroactiveDate: import_zod24.z.string().optional().describe("Retroactive date for claims-made policies (MM/DD/YYYY)")
 });
 function buildCoverageLimitsPrompt() {
   return `You are an expert insurance document analyst. Extract all coverage limits and deductibles from this document.
 
+Extract only insured-specific declaration, schedule, or endorsement entries that state actual coverage terms for this policy.
+
 Focus on:
 - Every coverage listed on the declarations page or coverage schedule
 - Per-occurrence, aggregate, and sub-limits for each coverage
@@ -3285,20 +3405,34 @@ Focus on:
 - Standard limit fields: per occurrence, general aggregate, products/completed ops aggregate, personal & advertising injury, fire damage, medical expense, combined single limit, BI/PD splits, umbrella each occurrence/aggregate/retention, statutory (WC), employers liability
 - Defense cost treatment: inside limits, outside limits, or supplementary
 
-Extract ALL coverages \u2014 do not omit any coverage line that appears in the document.
+For EACH coverage, also extract:
+- pageNumber: the original page number where the coverage row/value appears
+- sectionRef: the declarations/schedule/endorsement section heading where it appears
+- originalContent: the verbatim row or short source snippet used for this coverage
+- limitValueType: classify the limit as numeric, included, not_included, as_stated, waiting_period, referential, or other
+- deductibleValueType: classify the deductible/value term similarly when deductible is present
+
+Critical rules:
+- Do not extract table-of-contents lines, index entries, headers, footers, page labels, or cross-references as coverages.
+- Do not create a coverage entry from generic policy-form text that only says a limit/deductible is "shown in the declarations", "shown in the Business Income Declarations", "as stated", "if applicable", or similar referential wording.
+- Do not treat a generic waiting period, deductible explanation, limits clause, coinsurance clause, or definitions text as a standalone coverage unless the page contains an actual policy-specific schedule row or declaration entry.
+- Values like "Included" or "Not Included" are valid only when they appear as an explicit declarations/schedule/endorsement entry for a named coverage. Do not infer them from narrative form language.
+- If a waiting period or hour deductible is shown as part of a specific declarations/schedule row, it may be captured in deductible. Otherwise omit it.
+- Use limitValueType or deductibleValueType to preserve non-numeric terms precisely instead of forcing them into numeric semantics.
+- Preserve one row per real coverage entry. Do not merge adjacent schedule rows into malformed names.
 
 Return JSON only.`;
 }
 
 // src/prompts/extractors/endorsements.ts
-var import_zod24 = require("zod");
-var EndorsementsSchema = import_zod24.z.object({
-  endorsements: import_zod24.z.array(
-    import_zod24.z.object({
-      formNumber: import_zod24.z.string().describe("Form number, e.g. 'CG 21 47'"),
-      editionDate: import_zod24.z.string().optional().describe("Edition date, e.g. '12 07'"),
-      title: import_zod24.z.string().describe("Endorsement title"),
-      endorsementType: import_zod24.z.enum([
+var import_zod25 = require("zod");
+var EndorsementsSchema = import_zod25.z.object({
+  endorsements: import_zod25.z.array(
+    import_zod25.z.object({
+      formNumber: import_zod25.z.string().describe("Form number, e.g. 'CG 21 47'"),
+      editionDate: import_zod25.z.string().optional().describe("Edition date, e.g. '12 07'"),
+      title: import_zod25.z.string().describe("Endorsement title"),
+      endorsementType: import_zod25.z.enum([
         "additional_insured",
         "waiver_of_subrogation",
         "primary_noncontributory",
@@ -3318,12 +3452,12 @@ var EndorsementsSchema = import_zod24.z.object({
         "territorial_extension",
         "other"
       ]).describe("Endorsement type classification"),
-      effectiveDate: import_zod24.z.string().optional().describe("Endorsement effective date"),
-      affectedCoverageParts: import_zod24.z.array(import_zod24.z.string()).optional().describe("Coverage parts affected by this endorsement"),
-      namedParties: import_zod24.z.array(
-        import_zod24.z.object({
-          name: import_zod24.z.string().describe("Party name"),
-          role: import_zod24.z.enum([
+      effectiveDate: import_zod25.z.string().optional().describe("Endorsement effective date"),
+      affectedCoverageParts: import_zod25.z.array(import_zod25.z.string()).optional().describe("Coverage parts affected by this endorsement"),
+      namedParties: import_zod25.z.array(
+        import_zod25.z.object({
+          name: import_zod25.z.string().describe("Party name"),
+          role: import_zod25.z.enum([
             "additional_insured",
             "loss_payee",
             "mortgage_holder",
@@ -3332,15 +3466,15 @@ var EndorsementsSchema = import_zod24.z.object({
             "designated_person",
             "other"
           ]).describe("Party role"),
-          relationship: import_zod24.z.string().optional().describe("Relationship to insured"),
-          scope: import_zod24.z.string().optional().describe("Scope of coverage for this party")
+          relationship: import_zod25.z.string().optional().describe("Relationship to insured"),
+          scope: import_zod25.z.string().optional().describe("Scope of coverage for this party")
         })
       ).optional().describe("Named parties (additional insureds, loss payees, etc.)"),
-      keyTerms: import_zod24.z.array(import_zod24.z.string()).optional().describe("Key terms or notable provisions in the endorsement"),
-      premiumImpact: import_zod24.z.string().optional().describe("Additional premium or credit"),
-      content: import_zod24.z.string().describe("Full verbatim text of the endorsement"),
-      pageStart: import_zod24.z.number().describe("Starting page number of this endorsement"),
-      pageEnd: import_zod24.z.number().optional().describe("Ending page number of this endorsement")
+      keyTerms: import_zod25.z.array(import_zod25.z.string()).optional().describe("Key terms or notable provisions in the endorsement"),
+      premiumImpact: import_zod25.z.string().optional().describe("Additional premium or credit"),
+      content: import_zod25.z.string().describe("Full verbatim text of the endorsement"),
+      pageStart: import_zod25.z.number().describe("Starting page number of this endorsement"),
+      pageEnd: import_zod25.z.number().optional().describe("Ending page number of this endorsement")
     })
   ).describe("All endorsements found in the document")
 });
@@ -3371,20 +3505,20 @@ Return JSON only.`;
 }
 
 // src/prompts/extractors/exclusions.ts
-var import_zod25 = require("zod");
-var ExclusionsSchema = import_zod25.z.object({
-  exclusions: import_zod25.z.array(
-    import_zod25.z.object({
-      name: import_zod25.z.string().describe("Exclusion title or short description"),
-      formNumber: import_zod25.z.string().optional().describe("Form number if part of a named endorsement"),
-      excludedPerils: import_zod25.z.array(import_zod25.z.string()).optional().describe("Specific perils excluded"),
-      isAbsolute: import_zod25.z.boolean().optional().describe("Whether the exclusion is absolute (no exceptions)"),
-      exceptions: import_zod25.z.array(import_zod25.z.string()).optional().describe("Exceptions to the exclusion, if any"),
-      buybackAvailable: import_zod25.z.boolean().optional().describe("Whether coverage can be bought back via endorsement"),
-      buybackEndorsement: import_zod25.z.string().optional().describe("Form number of the buyback endorsement if available"),
-      appliesTo: import_zod25.z.array(import_zod25.z.string()).optional().describe("Coverage types this exclusion applies to"),
-      content: import_zod25.z.string().describe("Full verbatim exclusion text"),
-      pageNumber: import_zod25.z.number().optional().describe("Page number where exclusion appears")
+var import_zod26 = require("zod");
+var ExclusionsSchema = import_zod26.z.object({
+  exclusions: import_zod26.z.array(
+    import_zod26.z.object({
+      name: import_zod26.z.string().describe("Exclusion title or short description"),
+      formNumber: import_zod26.z.string().optional().describe("Form number if part of a named endorsement"),
+      excludedPerils: import_zod26.z.array(import_zod26.z.string()).optional().describe("Specific perils excluded"),
+      isAbsolute: import_zod26.z.boolean().optional().describe("Whether the exclusion is absolute (no exceptions)"),
+      exceptions: import_zod26.z.array(import_zod26.z.string()).optional().describe("Exceptions to the exclusion, if any"),
+      buybackAvailable: import_zod26.z.boolean().optional().describe("Whether coverage can be bought back via endorsement"),
+      buybackEndorsement: import_zod26.z.string().optional().describe("Form number of the buyback endorsement if available"),
+      appliesTo: import_zod26.z.array(import_zod26.z.string()).optional().describe("Coverage types this exclusion applies to"),
+      content: import_zod26.z.string().describe("Full verbatim exclusion text"),
+      pageNumber: import_zod26.z.number().optional().describe("Page number where exclusion appears")
     })
   ).describe("All exclusions found in the document")
 });
@@ -3409,18 +3543,23 @@ Focus on:
 - Exclusions within insuring agreements or conditions if clearly labeled
 - Full verbatim exclusion text \u2014 do not summarize
 
+Critical rules:
+- Ignore table-of-contents entries, running headers/footers, and references that only point to another page or section.
+- Do not emit a standalone exclusion from a fragment unless the fragment itself contains substantive exclusion wording.
+- Always include pageNumber when the exclusion appears on a specific page in the supplied document chunk.
+
 Common personal lines exclusion patterns: animal liability, business pursuits, home daycare, watercraft, aircraft.
 
 Return JSON only.`;
 }
 
 // src/prompts/extractors/conditions.ts
-var import_zod26 = require("zod");
-var ConditionsSchema = import_zod26.z.object({
-  conditions: import_zod26.z.array(
-    import_zod26.z.object({
-      name: import_zod26.z.string().describe("Condition title"),
-      conditionType: import_zod26.z.enum([
+var import_zod27 = require("zod");
+var ConditionsSchema = import_zod27.z.object({
+  conditions: import_zod27.z.array(
+    import_zod27.z.object({
+      name: import_zod27.z.string().describe("Condition title"),
+      conditionType: import_zod27.z.enum([
         "duties_after_loss",
         "notice_requirements",
         "other_insurance",
@@ -3439,14 +3578,14 @@ var ConditionsSchema = import_zod26.z.object({
         "separation_of_insureds",
         "other"
       ]).describe("Condition category"),
-      content: import_zod26.z.string().describe("Full verbatim condition text"),
-      keyValues: import_zod26.z.array(
-        import_zod26.z.object({
-          key: import_zod26.z.string().describe("Key name (e.g. 'noticePeriod', 'suitDeadline')"),
-          value: import_zod26.z.string().describe("Value (e.g. '30 days', '2 years')")
+      content: import_zod27.z.string().describe("Full verbatim condition text"),
+      keyValues: import_zod27.z.array(
+        import_zod27.z.object({
+          key: import_zod27.z.string().describe("Key name (e.g. 'noticePeriod', 'suitDeadline')"),
+          value: import_zod27.z.string().describe("Value (e.g. '30 days', '2 years')")
         })
       ).optional().describe("Key values extracted from the condition (notice periods, deadlines, etc.)"),
-      pageNumber: import_zod26.z.number().optional().describe("Page number where condition appears")
+      pageNumber: import_zod27.z.number().optional().describe("Page number where condition appears")
     })
   ).describe("All policy conditions found in the document")
 });
@@ -3458,7 +3597,7 @@ For EACH condition, extract:
 - conditionType: classify as one of: duties_after_loss, notice_requirements, other_insurance, cancellation, nonrenewal, transfer_of_rights, liberalization, arbitration, concealment_fraud, examination_under_oath, legal_action, loss_payment, appraisal, mortgage_holders, policy_territory, separation_of_insureds, other \u2014 REQUIRED
 - content: full verbatim condition text \u2014 REQUIRED
 - keyValues: extract specific values as key-value pairs (e.g. noticePeriod: "30 days", suitDeadline: "2 years")
-- pageNumber: page number where the condition appears
+- pageNumber: original document page number where the substantive condition text appears
 
 Focus on:
 - Duties after loss / notice of occurrence conditions
@@ -3475,32 +3614,37 @@ Focus on:
 - Mortgage holders clause
 - Any other named conditions
 
+Critical rules:
+- Ignore table-of-contents entries, section indexes, running headers/footers, and page references such as "Appraisal ..... 19".
+- Do not emit a condition unless the page contains substantive condition text, not just a heading or reference.
+- If a condition continues from a prior page, keep the substantive text together and use the page where the condition text appears in this extracted chunk.
+
 Return JSON only.`;
 }
 
 // src/prompts/extractors/premium-breakdown.ts
-var import_zod27 = require("zod");
-var PremiumBreakdownSchema = import_zod27.z.object({
-  premium: import_zod27.z.string().optional().describe("Total premium amount, e.g. '$5,000'"),
-  totalCost: import_zod27.z.string().optional().describe("Total cost including taxes and fees, e.g. '$5,250'"),
-  premiumBreakdown: import_zod27.z.array(
-    import_zod27.z.object({
-      line: import_zod27.z.string().describe("Coverage line name"),
-      amount: import_zod27.z.string().describe("Premium amount for this line")
+var import_zod28 = require("zod");
+var PremiumBreakdownSchema = import_zod28.z.object({
+  premium: import_zod28.z.string().optional().describe("Total premium amount, e.g. '$5,000'"),
+  totalCost: import_zod28.z.string().optional().describe("Total cost including taxes and fees, e.g. '$5,250'"),
+  premiumBreakdown: import_zod28.z.array(
+    import_zod28.z.object({
+      line: import_zod28.z.string().describe("Coverage line name"),
+      amount: import_zod28.z.string().describe("Premium amount for this line")
     })
   ).optional().describe("Per-coverage-line premium breakdown"),
-  taxesAndFees: import_zod27.z.array(
-    import_zod27.z.object({
-      name: import_zod27.z.string().describe("Fee or tax name"),
-      amount: import_zod27.z.string().describe("Dollar amount"),
-      type: import_zod27.z.enum(["tax", "fee", "surcharge", "assessment"]).optional().describe("Fee category")
+  taxesAndFees: import_zod28.z.array(
+    import_zod28.z.object({
+      name: import_zod28.z.string().describe("Fee or tax name"),
+      amount: import_zod28.z.string().describe("Dollar amount"),
+      type: import_zod28.z.enum(["tax", "fee", "surcharge", "assessment"]).optional().describe("Fee category")
     })
   ).optional().describe("Taxes, fees, surcharges, and assessments"),
-  minimumPremium: import_zod27.z.string().optional().describe("Minimum premium if stated"),
-  depositPremium: import_zod27.z.string().optional().describe("Deposit premium if stated"),
-  paymentPlan: import_zod27.z.string().optional().describe("Payment plan description"),
-  auditType: import_zod27.z.enum(["annual", "semi_annual", "quarterly", "monthly", "final", "self"]).optional().describe("Premium audit type"),
-  ratingBasis: import_zod27.z.string().optional().describe("Rating basis, e.g. payroll, revenue, area, units")
+  minimumPremium: import_zod28.z.string().optional().describe("Minimum premium if stated"),
+  depositPremium: import_zod28.z.string().optional().describe("Deposit premium if stated"),
+  paymentPlan: import_zod28.z.string().optional().describe("Payment plan description"),
+  auditType: import_zod28.z.enum(["annual", "semi_annual", "quarterly", "monthly", "final", "self"]).optional().describe("Premium audit type"),
+  ratingBasis: import_zod28.z.string().optional().describe("Rating basis, e.g. payroll, revenue, area, units")
 });
 function buildPremiumBreakdownPrompt() {
   return `You are an expert insurance document analyst. Extract all premium and cost information from this document.
@@ -3520,14 +3664,14 @@ Return JSON only.`;
 }
 
 // src/prompts/extractors/declarations.ts
-var import_zod28 = require("zod");
-var DeclarationsFieldSchema = import_zod28.z.object({
-  field: import_zod28.z.string().describe("Descriptive field name (e.g. 'policyNumber', 'effectiveDate', 'coverageALimit')"),
-  value: import_zod28.z.string().describe("Extracted value exactly as it appears in the document"),
-  section: import_zod28.z.string().optional().describe("Section or grouping this field belongs to (e.g. 'Coverage Limits', 'Vehicle Schedule')")
+var import_zod29 = require("zod");
+var DeclarationsFieldSchema = import_zod29.z.object({
+  field: import_zod29.z.string().describe("Descriptive field name (e.g. 'policyNumber', 'effectiveDate', 'coverageALimit')"),
+  value: import_zod29.z.string().describe("Extracted value exactly as it appears in the document"),
+  section: import_zod29.z.string().optional().describe("Section or grouping this field belongs to (e.g. 'Coverage Limits', 'Vehicle Schedule')")
 });
-var DeclarationsExtractSchema = import_zod28.z.object({
-  fields: import_zod28.z.array(DeclarationsFieldSchema).describe("All declarations page fields extracted as key-value pairs. Structure varies by line of business.")
+var DeclarationsExtractSchema = import_zod29.z.object({
+  fields: import_zod29.z.array(DeclarationsFieldSchema).describe("All declarations page fields extracted as key-value pairs. Structure varies by line of business.")
 });
 function buildDeclarationsPrompt() {
   return `You are an expert insurance document analyst. Extract all declarations page data from this document into a flexible key-value structure.
@@ -3567,21 +3711,21 @@ Preserve original values exactly as they appear. Return JSON only.`;
 }
 
 // src/prompts/extractors/loss-history.ts
-var import_zod29 = require("zod");
-var LossHistorySchema = import_zod29.z.object({
-  lossSummary: import_zod29.z.string().optional().describe("Summary of loss history, e.g. '3 claims in past 5 years totaling $125,000'"),
-  individualClaims: import_zod29.z.array(
-    import_zod29.z.object({
-      date: import_zod29.z.string().optional().describe("Date of loss or claim"),
-      type: import_zod29.z.string().optional().describe("Type of claim, e.g. 'property damage', 'bodily injury'"),
-      description: import_zod29.z.string().optional().describe("Brief description of the claim"),
-      amountPaid: import_zod29.z.string().optional().describe("Amount paid"),
-      amountReserved: import_zod29.z.string().optional().describe("Amount reserved"),
-      status: import_zod29.z.enum(["open", "closed", "reopened"]).optional().describe("Claim status"),
-      claimNumber: import_zod29.z.string().optional().describe("Claim reference number")
+var import_zod30 = require("zod");
+var LossHistorySchema = import_zod30.z.object({
+  lossSummary: import_zod30.z.string().optional().describe("Summary of loss history, e.g. '3 claims in past 5 years totaling $125,000'"),
+  individualClaims: import_zod30.z.array(
+    import_zod30.z.object({
+      date: import_zod30.z.string().optional().describe("Date of loss or claim"),
+      type: import_zod30.z.string().optional().describe("Type of claim, e.g. 'property damage', 'bodily injury'"),
+      description: import_zod30.z.string().optional().describe("Brief description of the claim"),
+      amountPaid: import_zod30.z.string().optional().describe("Amount paid"),
+      amountReserved: import_zod30.z.string().optional().describe("Amount reserved"),
+      status: import_zod30.z.enum(["open", "closed", "reopened"]).optional().describe("Claim status"),
+      claimNumber: import_zod30.z.string().optional().describe("Claim reference number")
     })
   ).optional().describe("Individual claim records"),
-  experienceMod: import_zod29.z.string().optional().describe("Experience modification factor for workers comp, e.g. '0.85'")
+  experienceMod: import_zod30.z.string().optional().describe("Experience modification factor for workers comp, e.g. '0.85'")
 });
 function buildLossHistoryPrompt() {
   return `You are an expert insurance document analyst. Extract all loss history and claims information from this document.
@@ -3598,18 +3742,18 @@ Return JSON only.`;
 }
 
 // src/prompts/extractors/sections.ts
-var import_zod30 = require("zod");
-var SubsectionSchema2 = import_zod30.z.object({
-  title: import_zod30.z.string().describe("Subsection title"),
-  sectionNumber: import_zod30.z.string().optional().describe("Subsection number"),
-  pageNumber: import_zod30.z.number().optional().describe("Page number"),
-  content: import_zod30.z.string().describe("Full verbatim text")
+var import_zod31 = require("zod");
+var SubsectionSchema2 = import_zod31.z.object({
+  title: import_zod31.z.string().describe("Subsection title"),
+  sectionNumber: import_zod31.z.string().optional().describe("Subsection number"),
+  pageNumber: import_zod31.z.number().optional().describe("Page number"),
+  content: import_zod31.z.string().describe("Full verbatim text")
 });
-var SectionsSchema = import_zod30.z.object({
-  sections: import_zod30.z.array(
-    import_zod30.z.object({
-      title: import_zod30.z.string().describe("Section title"),
-      type: import_zod30.z.enum([
+var SectionsSchema = import_zod31.z.object({
+  sections: import_zod31.z.array(
+    import_zod31.z.object({
+      title: import_zod31.z.string().describe("Section title"),
+      type: import_zod31.z.enum([
         "declarations",
         "insuring_agreement",
         "policy_form",
@@ -3623,10 +3767,10 @@ var SectionsSchema = import_zod30.z.object({
         "regulatory",
         "other"
       ]).describe("Section type classification"),
-      content: import_zod30.z.string().describe("Full verbatim text of the section"),
-      pageStart: import_zod30.z.number().describe("Starting page number"),
-      pageEnd: import_zod30.z.number().optional().describe("Ending page number"),
-      subsections: import_zod30.z.array(SubsectionSchema2).optional().describe("Subsections within this section")
+      content: import_zod31.z.string().describe("Full verbatim text of the section"),
+      pageStart: import_zod31.z.number().describe("Starting page number"),
+      pageEnd: import_zod31.z.number().optional().describe("Ending page number"),
+      subsections: import_zod31.z.array(SubsectionSchema2).optional().describe("Subsections within this section")
     })
   ).describe("All document sections")
 });
@@ -3645,25 +3789,31 @@ For each section, classify its type:
 - "other" \u2014 anything that doesn't fit the above categories
 
 Include accurate page numbers for every section. Include subsections only if the section has clearly defined subsections with their own titles.
+If a page begins or ends in the middle of a section, treat it as a continuation of the existing section instead of creating a new orphan section from the fragment.
+
+Critical rules:
+- Ignore table-of-contents entries, page-number references, repeating headers/footers, and other navigational artifacts.
+- Do not create a new section from a lone continuation fragment such as a single paragraph tail or list item that clearly belongs to the previous page's section.
+- When a section spans multiple pages, keep it as one section with pageStart/pageEnd covering the full span represented in this extraction.
 
 Return JSON only.`;
 }
 
 // src/prompts/extractors/supplementary.ts
-var import_zod31 = require("zod");
-var ContactSchema2 = import_zod31.z.object({
-  name: import_zod31.z.string().optional().describe("Organization or person name"),
-  phone: import_zod31.z.string().optional().describe("Phone number"),
-  email: import_zod31.z.string().optional().describe("Email address"),
-  address: import_zod31.z.string().optional().describe("Mailing address"),
-  type: import_zod31.z.string().optional().describe("Contact type, e.g. 'State Department of Insurance'")
+var import_zod32 = require("zod");
+var ContactSchema2 = import_zod32.z.object({
+  name: import_zod32.z.string().optional().describe("Organization or person name"),
+  phone: import_zod32.z.string().optional().describe("Phone number"),
+  email: import_zod32.z.string().optional().describe("Email address"),
+  address: import_zod32.z.string().optional().describe("Mailing address"),
+  type: import_zod32.z.string().optional().describe("Contact type, e.g. 'State Department of Insurance'")
 });
-var SupplementarySchema = import_zod31.z.object({
-  regulatoryContacts: import_zod31.z.array(ContactSchema2).optional().describe("Regulatory body contacts (state department of insurance, ombudsman)"),
-  claimsContacts: import_zod31.z.array(ContactSchema2).optional().describe("Claims reporting contacts and instructions"),
-  thirdPartyAdministrators: import_zod31.z.array(ContactSchema2).optional().describe("Third-party administrators for claims handling"),
-  cancellationNoticeDays: import_zod31.z.number().optional().describe("Required notice period for cancellation in days"),
-  nonrenewalNoticeDays: import_zod31.z.number().optional().describe("Required notice period for nonrenewal in days")
+var SupplementarySchema = import_zod32.z.object({
+  regulatoryContacts: import_zod32.z.array(ContactSchema2).optional().describe("Regulatory body contacts (state department of insurance, ombudsman)"),
+  claimsContacts: import_zod32.z.array(ContactSchema2).optional().describe("Claims reporting contacts and instructions"),
+  thirdPartyAdministrators: import_zod32.z.array(ContactSchema2).optional().describe("Third-party administrators for claims handling"),
+  cancellationNoticeDays: import_zod32.z.number().optional().describe("Required notice period for cancellation in days"),
+  nonrenewalNoticeDays: import_zod32.z.number().optional().describe("Required notice period for nonrenewal in days")
 });
 function buildSupplementaryPrompt() {
   return `You are an expert insurance document analyst. Extract supplementary and regulatory information from this document.
@@ -3700,6 +3850,313 @@ function getExtractor(name) {
   return EXTRACTORS[name];
 }
 
+// src/core/quality.ts
+function evaluateQualityGate(params) {
+  const { issues, hasRoundWarnings = false } = params;
+  const hasBlocking = issues.some((issue) => issue.severity === "blocking");
+  const hasWarnings = issues.some((issue) => issue.severity === "warning") || hasRoundWarnings;
+  return hasBlocking ? "failed" : hasWarnings ? "warning" : "passed";
+}
+function shouldFailQualityGate(mode, status) {
+  return mode === "strict" && status === "failed";
+}
+
+// src/extraction/quality.ts
+function normalizeFormNumber(value) {
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  if (!trimmed) return void 0;
+  return trimmed;
+}
+function addFormEntry(inventory, formNumber, source, extra) {
+  if (!formNumber) return;
+  const existing = inventory.get(formNumber);
+  if (existing) {
+    if (!existing.title && extra?.title) existing.title = extra.title;
+    if (!existing.pageStart && extra?.pageStart) existing.pageStart = extra.pageStart;
+    if (!existing.pageEnd && extra?.pageEnd) existing.pageEnd = extra.pageEnd;
+    if (!existing.sources.includes(source)) existing.sources.push(source);
+    return;
+  }
+  inventory.set(formNumber, {
+    formNumber,
+    title: extra?.title,
+    pageStart: extra?.pageStart,
+    pageEnd: extra?.pageEnd,
+    sources: [source]
+  });
+}
+function looksReferential(value) {
+  if (typeof value !== "string") return false;
+  const normalized = value.toLowerCase();
+  return normalized.includes("shown in the declarations") || normalized.includes("shown in declarations") || normalized.includes("shown in the schedule") || normalized.includes("as stated") || normalized.includes("if applicable");
+}
+function looksTocArtifact(value) {
+  if (typeof value !== "string") return false;
+  return /\.{4,}\d{1,3}$/.test(value.trim()) || /^\d+\.\s+[A-Z][\s\S]*\.{3,}\d{1,3}$/.test(value.trim());
+}
+function sourcePrecedence(sectionRef) {
+  if (typeof sectionRef !== "string") return 0;
+  const normalized = sectionRef.toLowerCase();
+  if (normalized.includes("declaration") || normalized.includes("scheduled coverages") || normalized.includes("schedule")) return 4;
+  if (normalized.includes("endorsement")) return 3;
+  if (normalized.includes("additional coverages")) return 2;
+  if (normalized.includes("coverage form") || normalized.includes("policy form")) return 1;
+  return 0;
+}
+function buildExtractionReviewReport(params) {
+  const { memory, reviewRounds } = params;
+  const deterministicIssues = [];
+  const inventory = /* @__PURE__ */ new Map();
+  const extractedFormInventory = memory.get("form_inventory")?.forms ?? [];
+  const coverages = memory.get("coverage_limits")?.coverages ?? [];
+  const endorsements = memory.get("endorsements")?.endorsements ?? [];
+  const exclusions = memory.get("exclusions")?.exclusions ?? [];
+  const conditions = memory.get("conditions")?.conditions ?? [];
+  const sections = memory.get("sections")?.sections ?? [];
+  for (const form of extractedFormInventory) {
+    addFormEntry(
+      inventory,
+      normalizeFormNumber(form.formNumber),
+      "form_inventory",
+      {
+        title: form.title,
+        pageStart: form.pageStart,
+        pageEnd: form.pageEnd
+      }
+    );
+  }
+  for (const endorsement of endorsements) {
+    addFormEntry(
+      inventory,
+      normalizeFormNumber(endorsement.formNumber),
+      "endorsements",
+      {
+        title: typeof endorsement.title === "string" ? endorsement.title : void 0,
+        pageStart: typeof endorsement.pageStart === "number" ? endorsement.pageStart : void 0,
+        pageEnd: typeof endorsement.pageEnd === "number" ? endorsement.pageEnd : void 0
+      }
+    );
+    if (typeof endorsement.formNumber !== "string" || !endorsement.formNumber.trim()) {
+      deterministicIssues.push({
+        code: "endorsement_missing_form_number",
+        severity: "blocking",
+        message: "Endorsement is missing formNumber.",
+        extractorName: "endorsements",
+        pageNumber: typeof endorsement.pageStart === "number" ? endorsement.pageStart : void 0,
+        itemName: typeof endorsement.title === "string" ? endorsement.title : void 0
+      });
+    }
+    const endorsementFormNumber = normalizeFormNumber(endorsement.formNumber);
+    if (endorsementFormNumber && !inventory.has(endorsementFormNumber)) {
+      deterministicIssues.push({
+        code: "endorsement_form_missing_from_inventory",
+        severity: "warning",
+        message: `Endorsement "${String(endorsement.title ?? endorsementFormNumber)}" is not present in form inventory.`,
+        extractorName: "endorsements",
+        formNumber: endorsementFormNumber,
+        pageNumber: typeof endorsement.pageStart === "number" ? endorsement.pageStart : void 0,
+        itemName: typeof endorsement.title === "string" ? endorsement.title : void 0
+      });
+    }
+  }
+  for (const coverage of coverages) {
+    const formNumber = normalizeFormNumber(coverage.formNumber);
+    addFormEntry(inventory, formNumber, "coverage_limits", {
+      title: typeof coverage.name === "string" ? coverage.name : void 0,
+      pageStart: typeof coverage.pageNumber === "number" ? coverage.pageNumber : void 0,
+      pageEnd: typeof coverage.pageNumber === "number" ? coverage.pageNumber : void 0
+    });
+    if (typeof coverage.name === "string" && /coverage form$/i.test(coverage.name.trim())) {
+      deterministicIssues.push({
+        code: "generic_form_row_as_coverage",
+        severity: "blocking",
+        message: `Coverage "${coverage.name}" looks like a form header rather than a real coverage row.`,
+        extractorName: "coverage_limits",
+        formNumber,
+        pageNumber: typeof coverage.pageNumber === "number" ? coverage.pageNumber : void 0,
+        itemName: coverage.name
+      });
+    }
+    if (typeof coverage.pageNumber !== "number") {
+      deterministicIssues.push({
+        code: "coverage_missing_page_number",
+        severity: "warning",
+        message: `Coverage "${String(coverage.name ?? "unknown")}" is missing pageNumber provenance.`,
+        extractorName: "coverage_limits",
+        formNumber,
+        itemName: typeof coverage.name === "string" ? coverage.name : void 0
+      });
+    }
+    if (typeof coverage.sectionRef !== "string" || !coverage.sectionRef.trim()) {
+      deterministicIssues.push({
+        code: "coverage_missing_section_ref",
+        severity: "warning",
+        message: `Coverage "${String(coverage.name ?? "unknown")}" is missing sectionRef provenance.`,
+        extractorName: "coverage_limits",
+        formNumber,
+        pageNumber: typeof coverage.pageNumber === "number" ? coverage.pageNumber : void 0,
+        itemName: typeof coverage.name === "string" ? coverage.name : void 0
+      });
+    }
+    if (typeof coverage.originalContent !== "string" || !coverage.originalContent.trim()) {
+      deterministicIssues.push({
+        code: "coverage_missing_original_content",
+        severity: "warning",
+        message: `Coverage "${String(coverage.name ?? "unknown")}" is missing originalContent source text.`,
+        extractorName: "coverage_limits",
+        formNumber,
+        pageNumber: typeof coverage.pageNumber === "number" ? coverage.pageNumber : void 0,
+        itemName: typeof coverage.name === "string" ? coverage.name : void 0
+      });
+    }
+    if (looksReferential(coverage.limit) || looksReferential(coverage.deductible)) {
+      deterministicIssues.push({
+        code: "coverage_referential_value",
+        severity: "warning",
+        message: `Coverage "${String(coverage.name ?? "unknown")}" contains referential language instead of a concrete scheduled term.`,
+        extractorName: "coverage_limits",
+        formNumber,
+        pageNumber: typeof coverage.pageNumber === "number" ? coverage.pageNumber : void 0,
+        itemName: typeof coverage.name === "string" ? coverage.name : void 0
+      });
+    }
+    if (formNumber && !inventory.has(formNumber)) {
+      deterministicIssues.push({
+        code: "coverage_form_missing_from_inventory",
+        severity: "warning",
+        message: `Coverage "${String(coverage.name ?? "unknown")}" references form "${formNumber}" that is missing from form inventory.`,
+        extractorName: "coverage_limits",
+        formNumber,
+        pageNumber: typeof coverage.pageNumber === "number" ? coverage.pageNumber : void 0,
+        itemName: typeof coverage.name === "string" ? coverage.name : void 0
+      });
+    }
+  }
+  const coverageGroups = /* @__PURE__ */ new Map();
+  for (const coverage of coverages) {
+    const key = [
+      String(coverage.name ?? "").toLowerCase(),
+      String(coverage.formNumber ?? "").toLowerCase()
+    ].join("|");
+    coverageGroups.set(key, [...coverageGroups.get(key) ?? [], coverage]);
+  }
+  for (const [key, groupedCoverages] of coverageGroups.entries()) {
+    if (groupedCoverages.length < 2) continue;
+    const sorted = [...groupedCoverages].sort((a, b) => sourcePrecedence(b.sectionRef) - sourcePrecedence(a.sectionRef));
+    const highest = sorted[0];
+    for (const lower of sorted.slice(1)) {
+      const highestLimit = String(highest.limit ?? "").trim();
+      const lowerLimit = String(lower.limit ?? "").trim();
+      const highestDeductible = String(highest.deductible ?? "").trim();
+      const lowerDeductible = String(lower.deductible ?? "").trim();
+      if (highestLimit && lowerLimit && highestLimit !== lowerLimit || highestDeductible && lowerDeductible && highestDeductible !== lowerDeductible) {
+        deterministicIssues.push({
+          code: "coverage_precedence_conflict",
+          severity: "warning",
+          message: `Coverage "${String(highest.name ?? key)}" has conflicting extracted terms across sources with different precedence.`,
+          extractorName: "coverage_limits",
+          formNumber: normalizeFormNumber(highest.formNumber) ?? normalizeFormNumber(lower.formNumber),
+          pageNumber: typeof lower.pageNumber === "number" ? lower.pageNumber : void 0,
+          itemName: typeof highest.name === "string" ? highest.name : void 0
+        });
+      }
+    }
+  }
+  for (const exclusion of exclusions) {
+    addFormEntry(inventory, normalizeFormNumber(exclusion.formNumber), "exclusions", {
+      title: typeof exclusion.name === "string" ? exclusion.name : void 0,
+      pageStart: typeof exclusion.pageNumber === "number" ? exclusion.pageNumber : void 0,
+      pageEnd: typeof exclusion.pageNumber === "number" ? exclusion.pageNumber : void 0
+    });
+    if (typeof exclusion.pageNumber !== "number") {
+      deterministicIssues.push({
+        code: "exclusion_missing_page_number",
+        severity: "warning",
+        message: `Exclusion "${String(exclusion.name ?? "unknown")}" is missing pageNumber provenance.`,
+        extractorName: "exclusions",
+        formNumber: normalizeFormNumber(exclusion.formNumber),
+        itemName: typeof exclusion.name === "string" ? exclusion.name : void 0
+      });
+    }
+    if (looksTocArtifact(exclusion.content)) {
+      deterministicIssues.push({
+        code: "exclusion_toc_artifact",
+        severity: "blocking",
+        message: `Exclusion "${String(exclusion.name ?? "unknown")}" appears to be a table-of-contents artifact.`,
+        extractorName: "exclusions",
+        pageNumber: typeof exclusion.pageNumber === "number" ? exclusion.pageNumber : void 0,
+        itemName: typeof exclusion.name === "string" ? exclusion.name : void 0
+      });
+    }
+  }
+  for (const condition of conditions) {
+    if (typeof condition.pageNumber !== "number") {
+      deterministicIssues.push({
+        code: "condition_missing_page_number",
+        severity: "warning",
+        message: `Condition "${String(condition.name ?? "unknown")}" is missing pageNumber provenance.`,
+        extractorName: "conditions",
+        itemName: typeof condition.name === "string" ? condition.name : void 0
+      });
+    }
+    if (looksTocArtifact(condition.content)) {
+      deterministicIssues.push({
+        code: "condition_toc_artifact",
+        severity: "blocking",
+        message: `Condition "${String(condition.name ?? "unknown")}" appears to be a table-of-contents artifact.`,
+        extractorName: "conditions",
+        pageNumber: typeof condition.pageNumber === "number" ? condition.pageNumber : void 0,
+        itemName: typeof condition.name === "string" ? condition.name : void 0
+      });
+    }
+  }
+  for (const section of sections) {
+    if (typeof section.content === "string" && section.content.trim().length < 120 && typeof section.pageStart === "number" && (!("pageEnd" in section) || section.pageEnd === section.pageStart || section.pageEnd === void 0)) {
+      deterministicIssues.push({
+        code: "section_short_fragment",
+        severity: "warning",
+        message: `Section "${String(section.title ?? "unknown")}" may be an orphan continuation fragment.`,
+        extractorName: "sections",
+        pageNumber: typeof section.pageStart === "number" ? section.pageStart : void 0,
+        itemName: typeof section.title === "string" ? section.title : void 0
+      });
+    }
+  }
+  const formInventory = [...inventory.values()].sort((a, b) => a.formNumber.localeCompare(b.formNumber));
+  const rounds = reviewRounds.map((round) => ({
+    round: round.round,
+    kind: "llm_review",
+    status: round.complete && round.qualityIssues.length === 0 ? "passed" : "warning",
+    summary: round.qualityIssues[0] ?? (round.complete ? "Review passed." : "Review requested follow-up extraction.")
+  }));
+  const artifacts = [
+    { kind: "form_inventory", label: "Form Inventory", itemCount: formInventory.length },
+    { kind: "page_map", label: "Page Map", itemCount: params.pageAssignments.length }
+  ];
+  const qualityGateStatus = evaluateQualityGate({
+    issues: deterministicIssues,
+    hasRoundWarnings: reviewRounds.some((round) => round.qualityIssues.length > 0 || !round.complete)
+  });
+  return {
+    issues: deterministicIssues,
+    rounds,
+    artifacts,
+    reviewRoundRecords: reviewRounds,
+    formInventory,
+    qualityGateStatus
+  };
+}
+function toReviewRoundRecord(round, review) {
+  return {
+    round,
+    complete: review.complete,
+    missingFields: review.missingFields,
+    qualityIssues: review.qualityIssues ?? [],
+    additionalTasks: review.additionalTasks
+  };
+}
+
 // src/extraction/coordinator.ts
 function createExtractor(config) {
   const {
@@ -3712,6 +4169,7 @@ function createExtractor(config) {
     onProgress,
     log,
     providerOptions,
+    qualityGate = "warn",
     onCheckpointSave
   } = config;
   const limit = pLimit(concurrency);
@@ -3768,6 +4226,50 @@ function createExtractor(config) {
     if (extractorPages.size === 0) return "No page assignments available.";
     return [...extractorPages.entries()].map(([extractorName, pages]) => `${extractorName}: pages ${pages.join(", ")}`).join("\n");
   }
+  function normalizePageAssignments(pageAssignments, formInventory) {
+    const pageFormTypes = /* @__PURE__ */ new Map();
+    if (formInventory) {
+      for (const form of formInventory.forms) {
+        if (form.pageStart != null) {
+          const end = form.pageEnd ?? form.pageStart;
+          for (let p = form.pageStart; p <= end; p++) {
+            const types = pageFormTypes.get(p) ?? /* @__PURE__ */ new Set();
+            types.add(form.formType);
+            pageFormTypes.set(p, types);
+          }
+        }
+      }
+    }
+    return pageAssignments.map((assignment) => {
+      let extractorNames = [...new Set(
+        (assignment.extractorNames.length > 0 ? assignment.extractorNames : ["sections"]).filter(Boolean)
+      )];
+      const hasDeclarations = extractorNames.includes("declarations");
+      const hasConditions = extractorNames.includes("conditions");
+      const hasExclusions = extractorNames.includes("exclusions");
+      const hasEndorsements = extractorNames.includes("endorsements");
+      const looksLikeScheduleValues = assignment.hasScheduleValues === true;
+      const roleBlocksCoverageLimits = assignment.pageRole === "policy_form" || assignment.pageRole === "condition_exclusion_form" || assignment.pageRole === "endorsement_form";
+      const inventoryTypes = pageFormTypes.get(assignment.localPageNumber);
+      const inventoryBlocksCoverageLimits = inventoryTypes != null && !looksLikeScheduleValues && !hasDeclarations && (inventoryTypes.has("endorsement") || inventoryTypes.has("notice") || inventoryTypes.has("application"));
+      if (extractorNames.includes("coverage_limits")) {
+        const shouldDropCoverageLimits = inventoryBlocksCoverageLimits || !looksLikeScheduleValues && roleBlocksCoverageLimits || !hasDeclarations && !looksLikeScheduleValues && (hasConditions || hasExclusions) || !hasDeclarations && !looksLikeScheduleValues && hasEndorsements;
+        if (shouldDropCoverageLimits) {
+          extractorNames = extractorNames.filter((name) => name !== "coverage_limits");
+        }
+      }
+      if (inventoryTypes?.has("endorsement") && !extractorNames.includes("endorsements")) {
+        extractorNames = [...extractorNames, "endorsements"];
+      }
+      if (extractorNames.length === 0) {
+        extractorNames = ["sections"];
+      }
+      return {
+        ...assignment,
+        extractorNames
+      };
+    });
+  }
   function buildTemplateHints(primaryType, documentType, pageCount, template) {
     return [
       `Document type: ${primaryType} ${documentType}`,
@@ -3886,6 +4388,38 @@ function createExtractor(config) {
     const template = getTemplate(primaryType);
     const pageCount = resumed?.pageCount ?? await getPdfPageCount(pdfBase64);
     const templateHints = buildTemplateHints(primaryType, documentType, pageCount, template);
+    let formInventory;
+    if (resumed?.formInventory && pipelineCtx.isPhaseComplete("form_inventory")) {
+      formInventory = resumed.formInventory;
+      memory.set("form_inventory", formInventory);
+      onProgress?.("Resuming from checkpoint (form inventory complete)...");
+    } else {
+      onProgress?.(`Building form inventory for ${primaryType} ${documentType}...`);
+      const formInventoryResponse = await safeGenerateObject(
+        generateObject,
+        {
+          prompt: buildFormInventoryPrompt(templateHints),
+          schema: FormInventorySchema,
+          maxTokens: 2048,
+          providerOptions: { ...providerOptions, pdfBase64 }
+        },
+        {
+          fallback: { forms: [] },
+          log,
+          onError: (err, attempt) => log?.(`Form inventory attempt ${attempt + 1} failed: ${err instanceof Error ? err.message : String(err)}`)
+        }
+      );
+      trackUsage(formInventoryResponse.usage);
+      formInventory = formInventoryResponse.object;
+      memory.set("form_inventory", formInventory);
+      await pipelineCtx.save("form_inventory", {
+        id,
+        pageCount,
+        classifyResult,
+        formInventory,
+        memory: Object.fromEntries(memory)
+      });
+    }
     let pageAssignments;
     if (resumed?.pageAssignments && pipelineCtx.isPhaseComplete("page_map")) {
       pageAssignments = resumed.pageAssignments;
@@ -3894,13 +4428,14 @@ function createExtractor(config) {
       onProgress?.(`Mapping document pages for ${primaryType} ${documentType}...`);
       const chunkSize = 8;
       const collectedAssignments = [];
+      const formInventoryHint = formInventory?.forms.length ? formatFormInventoryForPageMap(formInventory.forms) : void 0;
       for (let startPage = 1; startPage <= pageCount; startPage += chunkSize) {
         const endPage = Math.min(pageCount, startPage + chunkSize - 1);
         const pagesPdf = await extractPageRange(pdfBase64, startPage, endPage);
         const mapResponse = await safeGenerateObject(
           generateObject,
           {
-            prompt: buildPageMapPrompt(templateHints, startPage, endPage),
+            prompt: buildPageMapPrompt(templateHints, startPage, endPage, formInventoryHint),
             schema: PageMapChunkSchema,
             maxTokens: 2048,
             providerOptions: { ...providerOptions, pdfBase64: pagesPdf }
@@ -3932,10 +4467,12 @@ function createExtractor(config) {
         confidence: 0,
         notes: "Full-document fallback page assignment"
       }));
+      pageAssignments = normalizePageAssignments(pageAssignments, formInventory);
       await pipelineCtx.save("page_map", {
         id,
         pageCount,
         classifyResult,
+        formInventory,
         pageAssignments,
         memory: Object.fromEntries(memory)
       });
@@ -3951,6 +4488,7 @@ function createExtractor(config) {
         id,
         pageCount,
         classifyResult,
+        formInventory,
         pageAssignments,
         plan,
         memory: Object.fromEntries(memory)
@@ -3999,12 +4537,16 @@ function createExtractor(config) {
         id,
         pageCount,
         classifyResult,
+        formInventory,
         pageAssignments,
         plan,
         memory: Object.fromEntries(memory)
       });
     }
+    let reviewRounds = resumed?.reviewReport?.reviewRoundRecords ?? [];
+    let reviewReport = resumed?.reviewReport;
     if (!pipelineCtx.isPhaseComplete("review")) {
+      reviewRounds = [];
       for (let round = 0; round < maxReviewRounds; round++) {
         const extractedKeys = [...memory.keys()].filter((k) => k !== "classify");
         const extractionSummary = summarizeExtraction(memory);
@@ -4024,6 +4566,7 @@ function createExtractor(config) {
           }
         );
         trackUsage(reviewResponse.usage);
+        reviewRounds.push(toReviewRoundRecord(round + 1, reviewResponse.object));
         if (reviewResponse.object.qualityIssues?.length) {
           await log?.(`Review round ${round + 1} quality issues: ${reviewResponse.object.qualityIssues.join("; ")}`);
         }
@@ -4065,23 +4608,45 @@ function createExtractor(config) {
           }
         }
       }
+      reviewReport = buildExtractionReviewReport({
+        memory,
+        pageAssignments,
+        reviewRounds
+      });
+      if (reviewReport.issues.length > 0) {
+        await log?.(
+          `Deterministic review issues: ${reviewReport.issues.map((issue) => issue.message).join("; ")}`
+        );
+      }
+      if (shouldFailQualityGate(qualityGate, reviewReport.qualityGateStatus)) {
+        throw new Error("Extraction quality gate failed. See reviewReport for blocking issues.");
+      }
       await pipelineCtx.save("review", {
         id,
         pageCount,
         classifyResult,
+        formInventory,
         pageAssignments,
         plan,
+        reviewReport,
         memory: Object.fromEntries(memory)
       });
     }
+    reviewReport ?? (reviewReport = buildExtractionReviewReport({
+      memory,
+      pageAssignments,
+      reviewRounds
+    }));
     onProgress?.("Assembling document...");
     const document = assembleDocument(id, documentType, memory);
     await pipelineCtx.save("assemble", {
       id,
       pageCount,
       classifyResult,
+      formInventory,
       pageAssignments,
       plan,
+      reviewReport,
       memory: Object.fromEntries(memory),
       document
     });
@@ -4107,7 +4672,8 @@ function createExtractor(config) {
         callsWithUsage,
         callsMissingUsage
       },
-      checkpoint: finalCheckpoint
+      checkpoint: finalCheckpoint,
+      reviewReport
     };
   }
   return { extract };
@@ -4327,8 +4893,8 @@ Respond with JSON only:
 }`;
 
 // src/schemas/application.ts
-var import_zod32 = require("zod");
-var FieldTypeSchema = import_zod32.z.enum([
+var import_zod33 = require("zod");
+var FieldTypeSchema = import_zod33.z.enum([
   "text",
   "numeric",
   "currency",
@@ -4337,100 +4903,131 @@ var FieldTypeSchema = import_zod32.z.enum([
   "table",
   "declaration"
 ]);
-var ApplicationFieldSchema = import_zod32.z.object({
-  id: import_zod32.z.string(),
-  label: import_zod32.z.string(),
-  section: import_zod32.z.string(),
+var ApplicationFieldSchema = import_zod33.z.object({
+  id: import_zod33.z.string(),
+  label: import_zod33.z.string(),
+  section: import_zod33.z.string(),
   fieldType: FieldTypeSchema,
-  required: import_zod32.z.boolean(),
-  options: import_zod32.z.array(import_zod32.z.string()).optional(),
-  columns: import_zod32.z.array(import_zod32.z.string()).optional(),
-  requiresExplanationIfYes: import_zod32.z.boolean().optional(),
-  condition: import_zod32.z.object({
-    dependsOn: import_zod32.z.string(),
-    whenValue: import_zod32.z.string()
+  required: import_zod33.z.boolean(),
+  options: import_zod33.z.array(import_zod33.z.string()).optional(),
+  columns: import_zod33.z.array(import_zod33.z.string()).optional(),
+  requiresExplanationIfYes: import_zod33.z.boolean().optional(),
+  condition: import_zod33.z.object({
+    dependsOn: import_zod33.z.string(),
+    whenValue: import_zod33.z.string()
   }).optional(),
-  value: import_zod32.z.string().optional(),
-  source: import_zod32.z.string().optional().describe("Where the value came from: auto-fill, user, lookup"),
-  confidence: import_zod32.z.enum(["confirmed", "high", "medium", "low"]).optional()
+  value: import_zod33.z.string().optional(),
+  source: import_zod33.z.string().optional().describe("Where the value came from: auto-fill, user, lookup"),
+  confidence: import_zod33.z.enum(["confirmed", "high", "medium", "low"]).optional()
 });
-var ApplicationClassifyResultSchema = import_zod32.z.object({
-  isApplication: import_zod32.z.boolean(),
-  confidence: import_zod32.z.number().min(0).max(1),
-  applicationType: import_zod32.z.string().nullable()
+var ApplicationClassifyResultSchema = import_zod33.z.object({
+  isApplication: import_zod33.z.boolean(),
+  confidence: import_zod33.z.number().min(0).max(1),
+  applicationType: import_zod33.z.string().nullable()
+});
+var FieldExtractionResultSchema = import_zod33.z.object({
+  fields: import_zod33.z.array(ApplicationFieldSchema)
+});
+var AutoFillMatchSchema = import_zod33.z.object({
+  fieldId: import_zod33.z.string(),
+  value: import_zod33.z.string(),
+  confidence: import_zod33.z.enum(["confirmed"]),
+  contextKey: import_zod33.z.string()
+});
+var AutoFillResultSchema = import_zod33.z.object({
+  matches: import_zod33.z.array(AutoFillMatchSchema)
 });
-var FieldExtractionResultSchema = import_zod32.z.object({
-  fields: import_zod32.z.array(ApplicationFieldSchema)
+var QuestionBatchResultSchema = import_zod33.z.object({
+  batches: import_zod33.z.array(import_zod33.z.array(import_zod33.z.string()).describe("Array of field IDs in this batch"))
 });
-var AutoFillMatchSchema = import_zod32.z.object({
-  fieldId: import_zod32.z.string(),
-  value: import_zod32.z.string(),
-  confidence: import_zod32.z.enum(["confirmed"]),
-  contextKey: import_zod32.z.string()
+var LookupRequestSchema = import_zod33.z.object({
+  type: import_zod33.z.string().describe("Type of lookup: 'records', 'website', 'policy'"),
+  description: import_zod33.z.string(),
+  url: import_zod33.z.string().optional(),
+  targetFieldIds: import_zod33.z.array(import_zod33.z.string())
 });
-var AutoFillResultSchema = import_zod32.z.object({
-  matches: import_zod32.z.array(AutoFillMatchSchema)
+var ReplyIntentSchema = import_zod33.z.object({
+  primaryIntent: import_zod33.z.enum(["answers_only", "question", "lookup_request", "mixed"]),
+  hasAnswers: import_zod33.z.boolean(),
+  questionText: import_zod33.z.string().optional(),
+  questionFieldIds: import_zod33.z.array(import_zod33.z.string()).optional(),
+  lookupRequests: import_zod33.z.array(LookupRequestSchema).optional()
 });
-var QuestionBatchResultSchema = import_zod32.z.object({
-  batches: import_zod32.z.array(import_zod32.z.array(import_zod32.z.string()).describe("Array of field IDs in this batch"))
+var ParsedAnswerSchema = import_zod33.z.object({
+  fieldId: import_zod33.z.string(),
+  value: import_zod33.z.string(),
+  explanation: import_zod33.z.string().optional()
 });
-var LookupRequestSchema = import_zod32.z.object({
-  type: import_zod32.z.string().describe("Type of lookup: 'records', 'website', 'policy'"),
-  description: import_zod32.z.string(),
-  url: import_zod32.z.string().optional(),
-  targetFieldIds: import_zod32.z.array(import_zod32.z.string())
+var AnswerParsingResultSchema = import_zod33.z.object({
+  answers: import_zod33.z.array(ParsedAnswerSchema),
+  unanswered: import_zod33.z.array(import_zod33.z.string()).describe("Field IDs that were not answered")
 });
-var ReplyIntentSchema = import_zod32.z.object({
-  primaryIntent: import_zod32.z.enum(["answers_only", "question", "lookup_request", "mixed"]),
-  hasAnswers: import_zod32.z.boolean(),
-  questionText: import_zod32.z.string().optional(),
-  questionFieldIds: import_zod32.z.array(import_zod32.z.string()).optional(),
-  lookupRequests: import_zod32.z.array(LookupRequestSchema).optional()
+var LookupFillSchema = import_zod33.z.object({
+  fieldId: import_zod33.z.string(),
+  value: import_zod33.z.string(),
+  source: import_zod33.z.string().describe("Specific citable reference, e.g. 'GL Policy #POL-12345 (Hartford)'")
 });
-var ParsedAnswerSchema = import_zod32.z.object({
-  fieldId: import_zod32.z.string(),
-  value: import_zod32.z.string(),
-  explanation: import_zod32.z.string().optional()
+var LookupFillResultSchema = import_zod33.z.object({
+  fills: import_zod33.z.array(LookupFillSchema),
+  unfillable: import_zod33.z.array(import_zod33.z.string()),
+  explanation: import_zod33.z.string().optional()
 });
-var AnswerParsingResultSchema = import_zod32.z.object({
-  answers: import_zod32.z.array(ParsedAnswerSchema),
-  unanswered: import_zod32.z.array(import_zod32.z.string()).describe("Field IDs that were not answered")
+var FlatPdfPlacementSchema = import_zod33.z.object({
+  fieldId: import_zod33.z.string(),
+  page: import_zod33.z.number(),
+  x: import_zod33.z.number().describe("Percentage from left edge (0-100)"),
+  y: import_zod33.z.number().describe("Percentage from top edge (0-100)"),
+  text: import_zod33.z.string(),
+  fontSize: import_zod33.z.number().optional(),
+  isCheckmark: import_zod33.z.boolean().optional()
 });
-var LookupFillSchema = import_zod32.z.object({
-  fieldId: import_zod32.z.string(),
-  value: import_zod32.z.string(),
-  source: import_zod32.z.string().describe("Specific citable reference, e.g. 'GL Policy #POL-12345 (Hartford)'")
+var AcroFormMappingSchema = import_zod33.z.object({
+  fieldId: import_zod33.z.string(),
+  acroFormName: import_zod33.z.string(),
+  value: import_zod33.z.string()
 });
-var LookupFillResultSchema = import_zod32.z.object({
-  fills: import_zod32.z.array(LookupFillSchema),
-  unfillable: import_zod32.z.array(import_zod32.z.string()),
-  explanation: import_zod32.z.string().optional()
+var QualityGateStatusSchema = import_zod33.z.enum(["passed", "warning", "failed"]);
+var QualitySeveritySchema = import_zod33.z.enum(["info", "warning", "blocking"]);
+var ApplicationQualityIssueSchema = import_zod33.z.object({
+  code: import_zod33.z.string(),
+  severity: QualitySeveritySchema,
+  message: import_zod33.z.string(),
+  fieldId: import_zod33.z.string().optional()
 });
-var FlatPdfPlacementSchema = import_zod32.z.object({
-  fieldId: import_zod32.z.string(),
-  page: import_zod32.z.number(),
-  x: import_zod32.z.number().describe("Percentage from left edge (0-100)"),
-  y: import_zod32.z.number().describe("Percentage from top edge (0-100)"),
-  text: import_zod32.z.string(),
-  fontSize: import_zod32.z.number().optional(),
-  isCheckmark: import_zod32.z.boolean().optional()
+var ApplicationQualityRoundSchema = import_zod33.z.object({
+  round: import_zod33.z.number(),
+  kind: import_zod33.z.string(),
+  status: QualityGateStatusSchema,
+  summary: import_zod33.z.string().optional()
 });
-var AcroFormMappingSchema = import_zod32.z.object({
-  fieldId: import_zod32.z.string(),
-  acroFormName: import_zod32.z.string(),
-  value: import_zod32.z.string()
+var ApplicationQualityArtifactSchema = import_zod33.z.object({
+  kind: import_zod33.z.string(),
+  label: import_zod33.z.string().optional(),
+  itemCount: import_zod33.z.number().optional()
 });
-var ApplicationStateSchema = import_zod32.z.object({
-  id: import_zod32.z.string(),
-  pdfBase64: import_zod32.z.string().optional().describe("Original PDF, omitted after extraction"),
-  title: import_zod32.z.string().optional(),
-  applicationType: import_zod32.z.string().nullable().optional(),
-  fields: import_zod32.z.array(ApplicationFieldSchema),
-  batches: import_zod32.z.array(import_zod32.z.array(import_zod32.z.string())).optional(),
-  currentBatchIndex: import_zod32.z.number().default(0),
-  status: import_zod32.z.enum(["classifying", "extracting", "auto_filling", "batching", "collecting", "confirming", "mapping", "complete"]),
-  createdAt: import_zod32.z.number(),
-  updatedAt: import_zod32.z.number()
+var ApplicationEmailReviewSchema = import_zod33.z.object({
+  issues: import_zod33.z.array(ApplicationQualityIssueSchema),
+  qualityGateStatus: QualityGateStatusSchema
+});
+var ApplicationQualityReportSchema = import_zod33.z.object({
+  issues: import_zod33.z.array(ApplicationQualityIssueSchema),
+  rounds: import_zod33.z.array(ApplicationQualityRoundSchema).optional(),
+  artifacts: import_zod33.z.array(ApplicationQualityArtifactSchema).optional(),
+  emailReview: ApplicationEmailReviewSchema.optional(),
+  qualityGateStatus: QualityGateStatusSchema
+});
+var ApplicationStateSchema = import_zod33.z.object({
+  id: import_zod33.z.string(),
+  pdfBase64: import_zod33.z.string().optional().describe("Original PDF, omitted after extraction"),
+  title: import_zod33.z.string().optional(),
+  applicationType: import_zod33.z.string().nullable().optional(),
+  fields: import_zod33.z.array(ApplicationFieldSchema),
+  batches: import_zod33.z.array(import_zod33.z.array(import_zod33.z.string())).optional(),
+  currentBatchIndex: import_zod33.z.number().default(0),
+  qualityReport: ApplicationQualityReportSchema.optional(),
+  status: import_zod33.z.enum(["classifying", "extracting", "auto_filling", "batching", "collecting", "confirming", "mapping", "complete"]),
+  createdAt: import_zod33.z.number(),
+  updatedAt: import_zod33.z.number()
 });
 
 // src/application/agents/classifier.ts
@@ -4938,6 +5535,87 @@ async function generateBatchEmail(batchFields, batchIndex, totalBatches, opts, g
   return { text, usage };
 }
 
+// src/application/quality.ts
+function isVagueSource(source) {
+  if (!source) return true;
+  const normalized = source.trim().toLowerCase();
+  return normalized === "unknown" || normalized.includes("existing records") || normalized.includes("available data") || normalized === "context" || normalized === "user provided";
+}
+function buildApplicationQualityReport(state) {
+  const issues = [];
+  const seenIds = /* @__PURE__ */ new Set();
+  for (const field of state.fields) {
+    if (seenIds.has(field.id)) {
+      issues.push({
+        code: "duplicate_field_id",
+        severity: "blocking",
+        message: `Field "${field.label}" has a duplicate id "${field.id}".`,
+        fieldId: field.id
+      });
+    }
+    seenIds.add(field.id);
+    if (field.required && !field.value) {
+      issues.push({
+        code: "required_field_unfilled",
+        severity: "warning",
+        message: `Required field "${field.label}" is still unfilled.`,
+        fieldId: field.id
+      });
+    }
+    if (field.value && !field.source) {
+      issues.push({
+        code: "filled_field_missing_source",
+        severity: "blocking",
+        message: `Filled field "${field.label}" is missing source provenance.`,
+        fieldId: field.id
+      });
+    }
+    if (field.value && isVagueSource(field.source)) {
+      issues.push({
+        code: "filled_field_vague_source",
+        severity: "warning",
+        message: `Filled field "${field.label}" has a vague or non-citable source.`,
+        fieldId: field.id
+      });
+    }
+    if (field.value && (!field.confidence || field.confidence === "low")) {
+      issues.push({
+        code: "filled_field_low_confidence",
+        severity: "warning",
+        message: `Filled field "${field.label}" has low or missing confidence.`,
+        fieldId: field.id
+      });
+    }
+  }
+  return {
+    issues,
+    rounds: [],
+    artifacts: [
+      { kind: "application_fields", label: "Application Fields", itemCount: state.fields.length }
+    ],
+    qualityGateStatus: evaluateQualityGate({ issues })
+  };
+}
+function reviewBatchEmail(text, batchFields) {
+  const issues = [];
+  const normalized = text.toLowerCase();
+  for (const field of batchFields) {
+    const label = field.label.trim().toLowerCase();
+    if (label.length >= 6 && !normalized.includes(label)) {
+      issues.push({
+        code: "email_missing_field_prompt",
+        severity: "warning",
+        message: `Generated email does not clearly mention field "${field.label}".`,
+        fieldId: field.id
+      });
+    }
+  }
+  return {
+    issues,
+    qualityGateStatus: evaluateQualityGate({ issues })
+  };
+}
+
 // src/application/coordinator.ts
 function createApplicationPipeline(config) {
   const {
@@ -4952,7 +5630,8 @@ function createApplicationPipeline(config) {
     onTokenUsage,
     onProgress,
     log,
-    providerOptions
+    providerOptions,
+    qualityGate = "warn"
   } = config;
   const limit = pLimit(concurrency);
   let totalUsage = { inputTokens: 0, outputTokens: 0 };
@@ -4974,6 +5653,7 @@ function createApplicationPipeline(config) {
       title: void 0,
       applicationType: null,
       fields: [],
+      qualityReport: void 0,
       batches: void 0,
       currentBatchIndex: 0,
       status: "classifying",
@@ -4998,8 +5678,9 @@ function createApplicationPipeline(config) {
     if (!classifyResult.isApplication) {
       state.status = "complete";
       state.updatedAt = Date.now();
+      state.qualityReport = buildApplicationQualityReport(state);
       await applicationStore?.save(state);
-      return { state, tokenUsage: totalUsage };
+      return { state, tokenUsage: totalUsage, reviewReport: state.qualityReport };
     }
     state.applicationType = classifyResult.applicationType;
     state.status = "extracting";
@@ -5023,8 +5704,9 @@ function createApplicationPipeline(config) {
       await log?.("No fields extracted, completing pipeline with empty result");
       state.status = "complete";
       state.updatedAt = Date.now();
+      state.qualityReport = buildApplicationQualityReport(state);
       await applicationStore?.save(state);
-      return { state, tokenUsage: totalUsage };
+      return { state, tokenUsage: totalUsage, reviewReport: state.qualityReport };
     }
     state.fields = fields;
     state.title = classifyResult.applicationType ?? void 0;
@@ -5124,11 +5806,15 @@ function createApplicationPipeline(config) {
     } else {
       state.status = "confirming";
     }
+    state.qualityReport = buildApplicationQualityReport(state);
     state.updatedAt = Date.now();
     await applicationStore?.save(state);
+    if (shouldFailQualityGate(qualityGate, state.qualityReport.qualityGateStatus)) {
+      throw new Error("Application quality gate failed. See state.qualityReport for blocking issues.");
+    }
     const filledCount = state.fields.filter((f) => f.value).length;
     onProgress?.(`Application processed: ${filledCount}/${state.fields.length} fields filled, ${state.batches?.length ?? 0} batches to collect.`);
-    return { state, tokenUsage: totalUsage };
+    return { state, tokenUsage: totalUsage, reviewReport: state.qualityReport };
   }
   async function processReply(input) {
     totalUsage = { inputTokens: 0, outputTokens: 0 };
@@ -5275,6 +5961,11 @@ Provide a brief, helpful explanation (2-3 sentences). End with "Just reply with
             providerOptions
           );
           trackUsage(emailUsage);
+          const emailReview = reviewBatchEmail(emailText, nextBatchFields);
+          state.qualityReport = {
+            ...buildApplicationQualityReport(state),
+            emailReview
+          };
           if (!responseText) {
             responseText = emailText;
           } else {
@@ -5290,13 +5981,18 @@ ${emailText}`;
       }
     }
     state.updatedAt = Date.now();
+    state.qualityReport = state.qualityReport ?? buildApplicationQualityReport(state);
     await applicationStore?.save(state);
+    if (shouldFailQualityGate(qualityGate, state.qualityReport.qualityGateStatus)) {
+      throw new Error("Application quality gate failed. See state.qualityReport for blocking issues.");
+    }
     return {
       state,
       intent: intent.primaryIntent,
       fieldsFilled,
       responseText,
-      tokenUsage: totalUsage
+      tokenUsage: totalUsage,
+      reviewReport: state.qualityReport
     };
   }
   async function generateCurrentBatchEmail(applicationId, opts) {
@@ -5322,6 +6018,12 @@ ${emailText}`;
       providerOptions
     );
     trackUsage(usage);
+    const emailReview = reviewBatchEmail(text, batchFields);
+    state.qualityReport = {
+      ...buildApplicationQualityReport(state),
+      emailReview
+    };
+    await applicationStore?.save(state);
     return { text, tokenUsage: totalUsage };
   }
   async function getConfirmationSummary(applicationId) {
@@ -5458,73 +6160,73 @@ Respond with the final answer, deduplicated citations array, overall confidence
 }
 
 // src/schemas/query.ts
-var import_zod33 = require("zod");
-var QueryIntentSchema = import_zod33.z.enum([
+var import_zod34 = require("zod");
+var QueryIntentSchema = import_zod34.z.enum([
   "policy_question",
   "coverage_comparison",
   "document_search",
   "claims_inquiry",
   "general_knowledge"
 ]);
-var SubQuestionSchema = import_zod33.z.object({
-  question: import_zod33.z.string().describe("Atomic sub-question to retrieve and answer independently"),
+var SubQuestionSchema = import_zod34.z.object({
+  question: import_zod34.z.string().describe("Atomic sub-question to retrieve and answer independently"),
   intent: QueryIntentSchema,
-  chunkTypes: import_zod33.z.array(import_zod33.z.string()).optional().describe("Chunk types to filter retrieval (e.g. coverage, endorsement, declaration)"),
-  documentFilters: import_zod33.z.object({
-    type: import_zod33.z.enum(["policy", "quote"]).optional(),
-    carrier: import_zod33.z.string().optional(),
-    insuredName: import_zod33.z.string().optional(),
-    policyNumber: import_zod33.z.string().optional(),
-    quoteNumber: import_zod33.z.string().optional()
+  chunkTypes: import_zod34.z.array(import_zod34.z.string()).optional().describe("Chunk types to filter retrieval (e.g. coverage, endorsement, declaration)"),
+  documentFilters: import_zod34.z.object({
+    type: import_zod34.z.enum(["policy", "quote"]).optional(),
+    carrier: import_zod34.z.string().optional(),
+    insuredName: import_zod34.z.string().optional(),
+    policyNumber: import_zod34.z.string().optional(),
+    quoteNumber: import_zod34.z.string().optional()
   }).optional().describe("Structured filters to narrow document lookup")
 });
-var QueryClassifyResultSchema = import_zod33.z.object({
+var QueryClassifyResultSchema = import_zod34.z.object({
   intent: QueryIntentSchema,
-  subQuestions: import_zod33.z.array(SubQuestionSchema).min(1).describe("Decomposed atomic sub-questions"),
-  requiresDocumentLookup: import_zod33.z.boolean().describe("Whether structured document lookup is needed"),
-  requiresChunkSearch: import_zod33.z.boolean().describe("Whether semantic chunk search is needed"),
-  requiresConversationHistory: import_zod33.z.boolean().describe("Whether conversation history is relevant")
+  subQuestions: import_zod34.z.array(SubQuestionSchema).min(1).describe("Decomposed atomic sub-questions"),
+  requiresDocumentLookup: import_zod34.z.boolean().describe("Whether structured document lookup is needed"),
+  requiresChunkSearch: import_zod34.z.boolean().describe("Whether semantic chunk search is needed"),
+  requiresConversationHistory: import_zod34.z.boolean().describe("Whether conversation history is relevant")
 });
-var EvidenceItemSchema = import_zod33.z.object({
-  source: import_zod33.z.enum(["chunk", "document", "conversation"]),
-  chunkId: import_zod33.z.string().optional(),
-  documentId: import_zod33.z.string().optional(),
-  turnId: import_zod33.z.string().optional(),
-  text: import_zod33.z.string().describe("Text excerpt from the source"),
-  relevance: import_zod33.z.number().min(0).max(1),
-  metadata: import_zod33.z.array(import_zod33.z.object({ key: import_zod33.z.string(), value: import_zod33.z.string() })).optional()
+var EvidenceItemSchema = import_zod34.z.object({
+  source: import_zod34.z.enum(["chunk", "document", "conversation"]),
+  chunkId: import_zod34.z.string().optional(),
+  documentId: import_zod34.z.string().optional(),
+  turnId: import_zod34.z.string().optional(),
+  text: import_zod34.z.string().describe("Text excerpt from the source"),
+  relevance: import_zod34.z.number().min(0).max(1),
+  metadata: import_zod34.z.array(import_zod34.z.object({ key: import_zod34.z.string(), value: import_zod34.z.string() })).optional()
 });
-var RetrievalResultSchema = import_zod33.z.object({
-  subQuestion: import_zod33.z.string(),
-  evidence: import_zod33.z.array(EvidenceItemSchema)
+var RetrievalResultSchema = import_zod34.z.object({
+  subQuestion: import_zod34.z.string(),
+  evidence: import_zod34.z.array(EvidenceItemSchema)
 });
-var CitationSchema = import_zod33.z.object({
-  index: import_zod33.z.number().describe("Citation number [1], [2], etc."),
-  chunkId: import_zod33.z.string().describe("Source chunk ID, e.g. doc-123:coverage:2"),
-  documentId: import_zod33.z.string(),
-  documentType: import_zod33.z.enum(["policy", "quote"]).optional(),
-  field: import_zod33.z.string().optional().describe("Specific field path, e.g. coverages[0].deductible"),
-  quote: import_zod33.z.string().describe("Exact text from source that supports the claim"),
-  relevance: import_zod33.z.number().min(0).max(1)
+var CitationSchema = import_zod34.z.object({
+  index: import_zod34.z.number().describe("Citation number [1], [2], etc."),
+  chunkId: import_zod34.z.string().describe("Source chunk ID, e.g. doc-123:coverage:2"),
+  documentId: import_zod34.z.string(),
+  documentType: import_zod34.z.enum(["policy", "quote"]).optional(),
+  field: import_zod34.z.string().optional().describe("Specific field path, e.g. coverages[0].deductible"),
+  quote: import_zod34.z.string().describe("Exact text from source that supports the claim"),
+  relevance: import_zod34.z.number().min(0).max(1)
 });
-var SubAnswerSchema = import_zod33.z.object({
-  subQuestion: import_zod33.z.string(),
-  answer: import_zod33.z.string(),
-  citations: import_zod33.z.array(CitationSchema),
-  confidence: import_zod33.z.number().min(0).max(1),
-  needsMoreContext: import_zod33.z.boolean().describe("True if evidence was insufficient to answer fully")
+var SubAnswerSchema = import_zod34.z.object({
+  subQuestion: import_zod34.z.string(),
+  answer: import_zod34.z.string(),
+  citations: import_zod34.z.array(CitationSchema),
+  confidence: import_zod34.z.number().min(0).max(1),
+  needsMoreContext: import_zod34.z.boolean().describe("True if evidence was insufficient to answer fully")
 });
-var VerifyResultSchema = import_zod33.z.object({
-  approved: import_zod33.z.boolean().describe("Whether all sub-answers are adequately grounded"),
-  issues: import_zod33.z.array(import_zod33.z.string()).describe("Specific grounding or consistency issues found"),
-  retrySubQuestions: import_zod33.z.array(import_zod33.z.string()).optional().describe("Sub-questions that need additional retrieval or re-reasoning")
+var VerifyResultSchema = import_zod34.z.object({
+  approved: import_zod34.z.boolean().describe("Whether all sub-answers are adequately grounded"),
+  issues: import_zod34.z.array(import_zod34.z.string()).describe("Specific grounding or consistency issues found"),
+  retrySubQuestions: import_zod34.z.array(import_zod34.z.string()).optional().describe("Sub-questions that need additional retrieval or re-reasoning")
 });
-var QueryResultSchema = import_zod33.z.object({
-  answer: import_zod33.z.string(),
-  citations: import_zod33.z.array(CitationSchema),
+var QueryResultSchema = import_zod34.z.object({
+  answer: import_zod34.z.string(),
+  citations: import_zod34.z.array(CitationSchema),
   intent: QueryIntentSchema,
-  confidence: import_zod33.z.number().min(0).max(1),
-  followUp: import_zod33.z.string().optional().describe("Suggested follow-up question if applicable")
+  confidence: import_zod34.z.number().min(0).max(1),
+  followUp: import_zod34.z.string().optional().describe("Suggested follow-up question if applicable")
 });
 
 // src/query/retriever.ts
@@ -5812,6 +6514,112 @@ async function verify(originalQuestion, subAnswers, allEvidence, config) {
   return { result: object, usage };
 }
 
+// src/query/quality.ts
+function sourceIdForEvidence(evidence) {
+  return evidence.chunkId ?? evidence.documentId ?? evidence.turnId;
+}
+function citationSourceId(citation) {
+  return citation.chunkId || citation.documentId;
+}
+function buildQueryReviewReport(params) {
+  const { subAnswers, evidence, finalResult, verifyRounds } = params;
+  const issues = [];
+  const evidenceBySource = /* @__PURE__ */ new Map();
+  for (const item of evidence) {
+    const sourceId = sourceIdForEvidence(item);
+    if (!sourceId) continue;
+    evidenceBySource.set(sourceId, [...evidenceBySource.get(sourceId) ?? [], item]);
+  }
+  for (const subAnswer of subAnswers) {
+    if (!subAnswer.needsMoreContext && subAnswer.citations.length === 0) {
+      issues.push({
+        code: "subanswer_missing_citations",
+        severity: "blocking",
+        message: `Sub-answer "${subAnswer.subQuestion}" has no citations despite claiming an answer.`,
+        subQuestion: subAnswer.subQuestion
+      });
+    }
+    if (subAnswer.confidence >= 0.85 && subAnswer.citations.length === 0) {
+      issues.push({
+        code: "subanswer_high_confidence_without_citations",
+        severity: "blocking",
+        message: `Sub-answer "${subAnswer.subQuestion}" has high confidence without citations.`,
+        subQuestion: subAnswer.subQuestion
+      });
+    }
+    for (const citation of subAnswer.citations) {
+      const sourceId = citationSourceId(citation);
+      const supportedEvidence = sourceId ? evidenceBySource.get(sourceId) ?? [] : [];
+      if (!sourceId || supportedEvidence.length === 0) {
+        issues.push({
+          code: "citation_missing_from_evidence",
+          severity: "blocking",
+          message: `Citation [${citation.index}] in "${subAnswer.subQuestion}" does not map to retrieved evidence.`,
+          subQuestion: subAnswer.subQuestion,
+          citationIndex: citation.index,
+          sourceId
+        });
+        continue;
+      }
+      const quoteFound = supportedEvidence.some((item) => item.text.includes(citation.quote));
+      if (!quoteFound) {
+        issues.push({
+          code: "citation_quote_not_in_evidence",
+          severity: "warning",
+          message: `Citation [${citation.index}] quote in "${subAnswer.subQuestion}" was not found verbatim in retrieved evidence.`,
+          subQuestion: subAnswer.subQuestion,
+          citationIndex: citation.index,
+          sourceId
+        });
+      }
+    }
+  }
+  if (finalResult) {
+    if (finalResult.answer.trim().length > 0 && finalResult.citations.length === 0 && finalResult.confidence > 0.4) {
+      issues.push({
+        code: "final_answer_missing_citations",
+        severity: "blocking",
+        message: "Final answer has non-trivial confidence but no citations."
+      });
+    }
+    const knownCitationIds = new Set(
+      subAnswers.flatMap((sa) => sa.citations.map((citation) => `${citation.index}|${citation.chunkId}|${citation.documentId}`))
+    );
+    for (const citation of finalResult.citations) {
+      const key = `${citation.index}|${citation.chunkId}|${citation.documentId}`;
+      if (!knownCitationIds.has(key)) {
+        issues.push({
+          code: "final_answer_unknown_citation",
+          severity: "warning",
+          message: `Final answer citation [${citation.index}] was not present in verified sub-answers.`,
+          citationIndex: citation.index,
+          sourceId: citationSourceId(citation)
+        });
+      }
+    }
+  }
+  const rounds = verifyRounds.map((round) => ({
+    round: round.round,
+    kind: "verification",
+    status: round.approved && round.issues.length === 0 ? "passed" : "warning",
+    summary: round.issues[0] ?? (round.approved ? "Verification passed." : "Verification requested retry.")
+  }));
+  const artifacts = [
+    { kind: "evidence", label: "Retrieved Evidence", itemCount: evidence.length },
+    { kind: "sub_answers", label: "Sub Answers", itemCount: subAnswers.length }
+  ];
+  return {
+    issues,
+    rounds,
+    artifacts,
+    verifyRounds,
+    qualityGateStatus: evaluateQualityGate({
+      issues,
+      hasRoundWarnings: verifyRounds.some((round) => !round.approved || round.issues.length > 0)
+    })
+  };
+}
+
 // src/query/coordinator.ts
 function createQueryAgent(config) {
   const {
@@ -5825,7 +6633,8 @@ function createQueryAgent(config) {
     onTokenUsage,
     onProgress,
     log,
-    providerOptions
+    providerOptions,
+    qualityGate = "warn"
   } = config;
   const limit = pLimit(concurrency);
   let totalUsage = { inputTokens: 0, outputTokens: 0 };
@@ -5894,6 +6703,7 @@ function createQueryAgent(config) {
     await pipelineCtx.save("reason", { classification, evidence: allEvidence, subAnswers });
     onProgress?.("Verifying answer grounding...");
     const verifierConfig = { generateObject, providerOptions };
+    const verifyRounds = [];
     for (let round = 0; round < maxVerifyRounds; round++) {
       const { result: verifyResult, usage } = await safeVerify(
         question,
@@ -5902,6 +6712,12 @@ function createQueryAgent(config) {
         verifierConfig
       );
       trackUsage(usage);
+      verifyRounds.push({
+        round: round + 1,
+        approved: verifyResult.approved,
+        issues: verifyResult.issues,
+        retrySubQuestions: verifyResult.retrySubQuestions
+      });
       if (verifyResult.approved) {
         onProgress?.("Verification passed.");
         break;
@@ -5959,6 +6775,24 @@ function createQueryAgent(config) {
       classification,
       context?.platform
     );
+    const reviewReport = buildQueryReviewReport({
+      subAnswers,
+      evidence: allEvidence,
+      finalResult: queryResult,
+      verifyRounds
+    });
+    await pipelineCtx.save("review", {
+      classification,
+      evidence: allEvidence,
+      subAnswers,
+      reviewReport
+    });
+    if (reviewReport.issues.length > 0) {
+      await log?.(`Query deterministic review issues: ${reviewReport.issues.map((issue) => issue.message).join("; ")}`);
+    }
+    if (shouldFailQualityGate(qualityGate, reviewReport.qualityGateStatus)) {
+      throw new Error("Query quality gate failed. See reviewReport for blocking issues.");
+    }
     if (conversationId) {
       try {
         await memoryStore.addTurn({
@@ -5979,7 +6813,7 @@ function createQueryAgent(config) {
         await log?.(`Failed to store conversation turn: ${e}`);
       }
     }
-    return { ...queryResult, tokenUsage: totalUsage };
+    return { ...queryResult, tokenUsage: totalUsage, reviewReport };
   }
   async function classify(question, conversationId) {
     let conversationContext;
@@ -6201,7 +7035,12 @@ var AGENT_TOOLS = [
   AdmittedStatusSchema,
   AnswerParsingResultSchema,
   ApplicationClassifyResultSchema,
+  ApplicationEmailReviewSchema,
   ApplicationFieldSchema,
+  ApplicationQualityArtifactSchema,
+  ApplicationQualityIssueSchema,
+  ApplicationQualityReportSchema,
+  ApplicationQualityRoundSchema,
   ApplicationStateSchema,
   AuditTypeSchema,
   AutoFillMatchSchema,
@@ -6233,6 +7072,7 @@ var AGENT_TOOLS = [
   CoverageFormSchema,
   CoverageSchema,
   CoverageTriggerSchema,
+  CoverageValueTypeSchema,
   CrimeDeclarationsSchema,
   CyberDeclarationsSchema,
   DEDUCTIBLE_TYPES,