@claritylabs/cl-sdk 0.8.1 → 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,12 +2184,138 @@ ${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;
 }
 
+// src/extraction/merge.ts
+function isPresent(value) {
+  if (value === void 0 || value === null) return false;
+  if (typeof value === "string") return value.trim().length > 0;
+  if (Array.isArray(value)) return value.length > 0;
+  return true;
+}
+function dedupeByKey(items, keyFn) {
+  const seen = /* @__PURE__ */ new Set();
+  const merged = [];
+  for (const item of items) {
+    const key = keyFn(item);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    merged.push(item);
+  }
+  return merged;
+}
+function mergeUniqueObjects(existing, incoming, keyFn) {
+  return dedupeByKey([...existing, ...incoming], keyFn);
+}
+function mergeShallowPreferPresent(existing, incoming) {
+  const merged = { ...existing };
+  for (const [key, value] of Object.entries(incoming)) {
+    const current = merged[key];
+    if (Array.isArray(current) && Array.isArray(value)) {
+      merged[key] = [...current, ...value];
+      continue;
+    }
+    if (current && value && typeof current === "object" && typeof value === "object" && !Array.isArray(current) && !Array.isArray(value)) {
+      merged[key] = mergeShallowPreferPresent(
+        current,
+        value
+      );
+      continue;
+    }
+    if (!isPresent(current) && isPresent(value)) {
+      merged[key] = value;
+    }
+  }
+  return merged;
+}
+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 : [];
+  const coverageKey = (coverage) => [
+    String(coverage.name ?? "").toLowerCase(),
+    String(coverage.limit ?? "").toLowerCase(),
+    String(coverage.deductible ?? "").toLowerCase(),
+    String(coverage.formNumber ?? "").toLowerCase()
+  ].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) {
+  const merged = mergeShallowPreferPresent(existing, incoming);
+  const existingFields = Array.isArray(existing.fields) ? existing.fields : [];
+  const incomingFields = Array.isArray(incoming.fields) ? incoming.fields : [];
+  merged.fields = mergeUniqueObjects(existingFields, incomingFields, (field) => [
+    String(field.field ?? "").toLowerCase(),
+    String(field.value ?? "").toLowerCase(),
+    String(field.section ?? "").toLowerCase()
+  ].join("|"));
+  return merged;
+}
+function mergeArrayPayload(existing, incoming, arrayKey, keyFn) {
+  const merged = mergeShallowPreferPresent(existing, incoming);
+  const existingItems = Array.isArray(existing[arrayKey]) ? existing[arrayKey] : [];
+  const incomingItems = Array.isArray(incoming[arrayKey]) ? incoming[arrayKey] : [];
+  merged[arrayKey] = mergeUniqueObjects(existingItems, incomingItems, keyFn);
+  return merged;
+}
+function mergeExtractorResult(extractorName, existing, incoming) {
+  if (!existing) return incoming;
+  if (!incoming) return existing;
+  if (typeof existing !== "object" || typeof incoming !== "object") return incoming;
+  const current = existing;
+  const next = incoming;
+  switch (extractorName) {
+    case "carrier_info":
+    case "named_insured":
+    case "loss_history":
+    case "supplementary":
+    case "premium_breakdown":
+      return mergeShallowPreferPresent(current, next);
+    case "coverage_limits":
+      return mergeCoverageLimits(current, next);
+    case "declarations":
+      return mergeDeclarations(current, next);
+    case "endorsements":
+      return mergeArrayPayload(current, next, "endorsements", (item) => [
+        String(item.formNumber ?? "").toLowerCase(),
+        String(item.title ?? "").toLowerCase(),
+        String(item.pageStart ?? "")
+      ].join("|"));
+    case "exclusions":
+      return mergeArrayPayload(current, next, "exclusions", (item) => [
+        String(item.name ?? "").toLowerCase(),
+        String(item.formNumber ?? "").toLowerCase(),
+        String(item.pageNumber ?? "")
+      ].join("|"));
+    case "conditions":
+      return mergeArrayPayload(current, next, "conditions", (item) => [
+        String(item.name ?? "").toLowerCase(),
+        String(item.conditionType ?? "").toLowerCase(),
+        String(item.pageNumber ?? "")
+      ].join("|"));
+    case "sections":
+      return mergeArrayPayload(current, next, "sections", (item) => [
+        String(item.title ?? "").toLowerCase(),
+        String(item.type ?? "").toLowerCase(),
+        String(item.pageStart ?? ""),
+        String(item.pageEnd ?? "")
+      ].join("|"));
+    default:
+      return mergeShallowPreferPresent(current, next);
+  }
+}
+
 // src/prompts/templates/homeowners.ts
 var HOMEOWNERS_TEMPLATE = {
   type: "homeowners",
@@ -2927,74 +3105,156 @@ Return JSON only:
 }`;
 }
 
-// src/prompts/coordinator/plan.ts
+// src/prompts/coordinator/form-inventory.ts
 var import_zod19 = require("zod");
-var ExtractionTaskSchema = import_zod19.z.object({
-  extractorName: import_zod19.z.string(),
-  startPage: import_zod19.z.number(),
-  endPage: import_zod19.z.number(),
-  description: import_zod19.z.string()
+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 PageMapEntrySchema = import_zod19.z.object({
-  section: import_zod19.z.string(),
-  pages: import_zod19.z.string()
+var FormInventorySchema = import_zod19.z.object({
+  forms: import_zod19.z.array(FormInventoryEntrySchema)
 });
-var ExtractionPlanSchema = import_zod19.z.object({
-  tasks: import_zod19.z.array(ExtractionTaskSchema),
-  pageMap: import_zod19.z.array(PageMapEntrySchema).optional()
-});
-function buildPlanPrompt(templateHints) {
-  return `You are planning the extraction of an insurance document. You have already classified this document. Now scan the full document and create a page map + extraction plan.
+function buildFormInventoryPrompt(templateHints) {
+  return `You are building a form inventory for an insurance document.
 
 DOCUMENT TYPE HINTS:
 ${templateHints}
 
-For each section of the document, decide which extractor should handle it and which pages to send.
+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",
+  "endorsements",
+  "exclusions",
+  "conditions",
+  "premium_breakdown",
+  "declarations",
+  "loss_history",
+  "sections",
+  "supplementary"
+]);
+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_zod20.z.object({
+  pages: import_zod20.z.array(PageAssignmentSchema)
+});
+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:
-- carrier_info: Carrier name, legal name, NAIC, AM Best rating, admitted status, MGA, underwriter
-- named_insured: Insured name, DBA, address, entity type, FEIN, SIC/NAICS codes, additional named insureds
-- coverage_limits: Coverage names, limits, deductibles, coverage form, triggers
-- endorsements: Endorsement forms, titles, types, content, affected parties
-- exclusions: Exclusion titles, content, applicability
-- conditions: Policy conditions (duties after loss, cancellation, etc.)
-- premium_breakdown: Premium amounts, taxes, fees, payment plans, rating basis
-- declarations: Line-specific structured declarations data (varies by policy type)
-- loss_history: Loss runs, claim records, experience modification
-- sections: Raw section content (for sections that don't fit other extractors)
-- supplementary: Regulatory context, contacts, claims contacts, third-party administrators
+- carrier_info
+- named_insured
+- coverage_limits
+- endorsements
+- exclusions
+- conditions
+- premium_breakdown
+- declarations
+- loss_history
+- sections
+- supplementary
+
+Rules:
+- Use specific extractors for declarations, schedules, endorsements, exclusions, conditions, premium pages, and loss runs.
+- Use "sections" for pages that contain substantive policy text or mixed content that should still be preserved as raw sections.
+- 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.
+- 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:
 {
-  "tasks": [
-    { "extractorName": "carrier_info", "startPage": 1, "endPage": 2, "description": "Extract carrier details from declarations page" },
-    ...
-  ],
-  "pageMap": [
-    { "section": "declarations", "pages": "pages 1-3" },
-    { "section": "endorsements", "pages": "pages 15-22" }
+  "pages": [
+    {
+      "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"
+    }
   ]
 }
 
-Create tasks that cover the entire document. Prefer specific extractors over generic "sections" where possible. Keep page ranges tight \u2014 only include pages relevant to each extractor.
-
 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()),
-  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) {
-  return `You are reviewing an extraction for completeness. Compare what was expected vs what was found.
+function buildReviewPrompt(templateExpected, extractedKeys, extractionSummary, pageMapSummary) {
+  return `You are reviewing an extraction for completeness and quality. Compare what was expected vs what was found.
 
 EXPECTED FIELDS (from document type template):
 ${templateExpected.map((f) => `- ${f}`).join("\n")}
@@ -3002,40 +3262,55 @@ ${templateExpected.map((f) => `- ${f}`).join("\n")}
 FIELDS ALREADY EXTRACTED:
 ${extractedKeys.map((f) => `- ${f}`).join("\n")}
 
+PAGE MAP SUMMARY:
+${pageMapSummary}
+
+CURRENT EXTRACTION SUMMARY:
+${extractionSummary}
+
 Determine:
-1. Is the extraction complete enough? (required fields present = complete)
+1. Is the extraction complete enough?
 2. What fields are missing?
-3. Should any additional extraction tasks be dispatched?
+3. What quality issues are present?
+4. Should any additional extraction tasks be dispatched?
+
+Mark the extraction as NOT complete if any of these are true:
+- required fields are missing
+- extracted values are generic placeholders like "shown in declarations", "per schedule", "if applicable", "as stated"
+- coverage limits or deductibles appear to come from generic form language instead of declaration/schedule-specific values
+- page assignments suggest declaration, schedule, endorsement, exclusion, or condition pages were not actually extracted with the matching focused extractor
+- a focused extractor exists but returned too little substance for the relevant pages
 
 Return JSON:
 {
   "complete": boolean,
   "missingFields": ["field1", "field2"],
+  "qualityIssues": ["issue 1", "issue 2"],
   "additionalTasks": [
     { "extractorName": "...", "startPage": N, "endPage": N, "description": "..." }
   ]
 }
 
-If all required fields are present, set complete=true even if some optional fields are missing.
+Use the page map to target follow-up extraction pages precisely. Prefer narrow, declaration/schedule-focused follow-up tasks over broad page ranges.
 
 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.
@@ -3055,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",
@@ -3079,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")
@@ -3106,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
@@ -3133,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",
@@ -3166,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",
@@ -3180,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")
 });
@@ -3219,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")
 });
@@ -3257,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",
@@ -3287,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")
 });
@@ -3306,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
@@ -3323,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.
@@ -3368,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.
@@ -3415,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.
@@ -3446,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",
@@ -3471,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")
 });
@@ -3493,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.
@@ -3548,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 {
@@ -3560,21 +4169,174 @@ function createExtractor(config) {
     onProgress,
     log,
     providerOptions,
+    qualityGate = "warn",
     onCheckpointSave
   } = config;
   const limit = pLimit(concurrency);
   let totalUsage = { inputTokens: 0, outputTokens: 0 };
+  let modelCalls = 0;
+  let callsWithUsage = 0;
+  let callsMissingUsage = 0;
   function trackUsage(usage) {
+    modelCalls += 1;
     if (usage) {
+      callsWithUsage += 1;
       totalUsage.inputTokens += usage.inputTokens;
       totalUsage.outputTokens += usage.outputTokens;
       onTokenUsage?.(usage);
+    } else {
+      callsMissingUsage += 1;
+    }
+  }
+  function mergeMemoryResult(name, data, memory) {
+    const existing = memory.get(name);
+    memory.set(name, mergeExtractorResult(name, existing, data));
+  }
+  function summarizeExtraction(memory) {
+    const coverageResult = memory.get("coverage_limits");
+    const declarationResult = memory.get("declarations");
+    const endorsementResult = memory.get("endorsements");
+    const exclusionResult = memory.get("exclusions");
+    const conditionResult = memory.get("conditions");
+    const sectionResult = memory.get("sections");
+    const coverageSummary = Array.isArray(coverageResult?.coverages) ? coverageResult.coverages.slice(0, 12).map((coverage) => ({
+      name: coverage.name,
+      limit: coverage.limit,
+      deductible: coverage.deductible,
+      formNumber: coverage.formNumber
+    })) : [];
+    return JSON.stringify({
+      extractedKeys: [...memory.keys()].filter((key) => key !== "classify"),
+      declarationFieldCount: Array.isArray(declarationResult?.fields) ? declarationResult.fields.length : 0,
+      coverageCount: Array.isArray(coverageResult?.coverages) ? coverageResult.coverages.length : 0,
+      coverageSamples: coverageSummary,
+      endorsementCount: Array.isArray(endorsementResult?.endorsements) ? endorsementResult.endorsements.length : 0,
+      exclusionCount: Array.isArray(exclusionResult?.exclusions) ? exclusionResult.exclusions.length : 0,
+      conditionCount: Array.isArray(conditionResult?.conditions) ? conditionResult.conditions.length : 0,
+      sectionCount: Array.isArray(sectionResult?.sections) ? sectionResult.sections.length : 0
+    }, null, 2);
+  }
+  function formatPageMapSummary(pageAssignments) {
+    const extractorPages = /* @__PURE__ */ new Map();
+    for (const assignment of pageAssignments) {
+      for (const extractorName of assignment.extractorNames) {
+        extractorPages.set(extractorName, [...extractorPages.get(extractorName) ?? [], assignment.localPageNumber]);
+      }
     }
+    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}`,
+      `Expected sections: ${template.expectedSections.join(", ")}`,
+      `Page hints: ${Object.entries(template.pageHints).map(([k, v]) => `${k}: ${v}`).join("; ")}`,
+      `Total pages: ${pageCount}`
+    ].join("\n");
+  }
+  function groupContiguousPages(pages) {
+    if (pages.length === 0) return [];
+    const sorted = [...new Set(pages)].sort((a, b) => a - b);
+    const ranges = [];
+    let start = sorted[0];
+    let previous = sorted[0];
+    for (let i = 1; i < sorted.length; i += 1) {
+      const current = sorted[i];
+      if (current === previous + 1) {
+        previous = current;
+        continue;
+      }
+      ranges.push({ startPage: start, endPage: previous });
+      start = current;
+      previous = current;
+    }
+    ranges.push({ startPage: start, endPage: previous });
+    return ranges;
+  }
+  function buildPlanFromPageAssignments(pageAssignments, pageCount) {
+    const extractorPages = /* @__PURE__ */ new Map();
+    for (const assignment of pageAssignments) {
+      const extractors = assignment.extractorNames.length > 0 ? assignment.extractorNames : ["sections"];
+      for (const extractorName of extractors) {
+        extractorPages.set(extractorName, [...extractorPages.get(extractorName) ?? [], assignment.localPageNumber]);
+      }
+    }
+    const coveredPages = /* @__PURE__ */ new Set();
+    for (const pages of extractorPages.values()) {
+      for (const page of pages) coveredPages.add(page);
+    }
+    for (let page = 1; page <= pageCount; page += 1) {
+      if (!coveredPages.has(page)) {
+        extractorPages.set("sections", [...extractorPages.get("sections") ?? [], page]);
+      }
+    }
+    const tasks = [...extractorPages.entries()].flatMap(
+      ([extractorName, pages]) => groupContiguousPages(pages).map(({ startPage, endPage }) => ({
+        extractorName,
+        startPage,
+        endPage,
+        description: `Page-mapped ${extractorName} extraction for pages ${startPage}-${endPage}`
+      }))
+    ).sort((a, b) => a.startPage - b.startPage || a.extractorName.localeCompare(b.extractorName));
+    return {
+      tasks,
+      pageMap: [...extractorPages.entries()].map(([section, pages]) => ({
+        section,
+        pages: `pages ${[...new Set(pages)].sort((a, b) => a - b).join(", ")}`
+      }))
+    };
   }
   async function extract(pdfBase64, documentId, options) {
     const id = documentId ?? `doc-${Date.now()}`;
     const memory = /* @__PURE__ */ new Map();
     totalUsage = { inputTokens: 0, outputTokens: 0 };
+    modelCalls = 0;
+    callsWithUsage = 0;
+    callsMissingUsage = 0;
     const pipelineCtx = createPipelineContext({
       id,
       onSave: onCheckpointSave,
@@ -3625,40 +4387,109 @@ function createExtractor(config) {
     const primaryType = policyTypes[0] ?? "other";
     const template = getTemplate(primaryType);
     const pageCount = resumed?.pageCount ?? await getPdfPageCount(pdfBase64);
-    let plan;
-    if (resumed?.plan && pipelineCtx.isPhaseComplete("plan")) {
-      plan = resumed.plan;
-      onProgress?.("Resuming from checkpoint (plan complete)...");
+    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?.(`Planning extraction for ${primaryType} ${documentType}...`);
-      const templateHints = [
-        `Document type: ${primaryType} ${documentType}`,
-        `Expected sections: ${template.expectedSections.join(", ")}`,
-        `Page hints: ${Object.entries(template.pageHints).map(([k, v]) => `${k}: ${v}`).join("; ")}`,
-        `Total pages: ${pageCount}`
-      ].join("\n");
-      const planResponse = await safeGenerateObject(
+      onProgress?.(`Building form inventory for ${primaryType} ${documentType}...`);
+      const formInventoryResponse = await safeGenerateObject(
         generateObject,
         {
-          prompt: buildPlanPrompt(templateHints),
-          schema: ExtractionPlanSchema,
+          prompt: buildFormInventoryPrompt(templateHints),
+          schema: FormInventorySchema,
           maxTokens: 2048,
           providerOptions: { ...providerOptions, pdfBase64 }
         },
         {
-          fallback: {
-            tasks: [{ extractorName: "sections", startPage: 1, endPage: pageCount, description: "Full document fallback extraction" }]
-          },
+          fallback: { forms: [] },
           log,
-          onError: (err, attempt) => log?.(`Plan attempt ${attempt + 1} failed: ${err}`)
+          onError: (err, attempt) => log?.(`Form inventory attempt ${attempt + 1} failed: ${err instanceof Error ? err.message : String(err)}`)
         }
       );
-      trackUsage(planResponse.usage);
-      plan = planResponse.object;
+      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;
+      onProgress?.("Resuming from checkpoint (page map complete)...");
+    } else {
+      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, formInventoryHint),
+            schema: PageMapChunkSchema,
+            maxTokens: 2048,
+            providerOptions: { ...providerOptions, pdfBase64: pagesPdf }
+          },
+          {
+            fallback: {
+              pages: Array.from({ length: endPage - startPage + 1 }, (_, index) => ({
+                localPageNumber: index + 1,
+                extractorNames: index === 0 && startPage === 1 ? ["carrier_info", "named_insured", "declarations", "coverage_limits"] : ["sections"],
+                confidence: 0,
+                notes: "Fallback page assignment"
+              }))
+            },
+            log,
+            onError: (err, attempt) => log?.(`Page map attempt ${attempt + 1} failed for pages ${startPage}-${endPage}: ${err}`)
+          }
+        );
+        trackUsage(mapResponse.usage);
+        for (const assignment of mapResponse.object.pages) {
+          collectedAssignments.push({
+            ...assignment,
+            localPageNumber: startPage + assignment.localPageNumber - 1
+          });
+        }
+      }
+      pageAssignments = collectedAssignments.length > 0 ? collectedAssignments : Array.from({ length: pageCount }, (_, index) => ({
+        localPageNumber: index + 1,
+        extractorNames: index === 0 ? ["carrier_info", "named_insured", "declarations", "coverage_limits"] : ["sections"],
+        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)
+      });
+    }
+    let plan;
+    if (resumed?.plan && pipelineCtx.isPhaseComplete("plan")) {
+      plan = resumed.plan;
+      onProgress?.("Resuming from checkpoint (plan complete)...");
+    } else {
+      onProgress?.(`Building extraction plan from page map for ${primaryType} ${documentType}...`);
+      plan = buildPlanFromPageAssignments(pageAssignments, pageCount);
       await pipelineCtx.save("plan", {
         id,
         pageCount,
         classifyResult,
+        formInventory,
+        pageAssignments,
         plan,
         memory: Object.fromEntries(memory)
       });
@@ -3699,35 +4530,46 @@ function createExtractor(config) {
       );
       for (const result of extractorResults) {
         if (result) {
-          memory.set(result.name, result.data);
+          mergeMemoryResult(result.name, result.data, memory);
         }
       }
       await pipelineCtx.save("extract", {
         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);
+        const pageMapSummary = formatPageMapSummary(pageAssignments);
         const reviewResponse = await safeGenerateObject(
           generateObject,
           {
-            prompt: buildReviewPrompt(template.required, extractedKeys),
+            prompt: buildReviewPrompt(template.required, extractedKeys, extractionSummary, pageMapSummary),
             schema: ReviewResultSchema,
-            maxTokens: 1024,
-            providerOptions
+            maxTokens: 1536,
+            providerOptions: { ...providerOptions, pdfBase64 }
           },
           {
-            fallback: { complete: true, missingFields: [], additionalTasks: [] },
+            fallback: { complete: true, missingFields: [], qualityIssues: [], additionalTasks: [] },
             log,
             onError: (err, attempt) => log?.(`Review round ${round + 1} attempt ${attempt + 1} failed: ${err}`)
           }
         );
         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("; ")}`);
+        }
         if (reviewResponse.object.complete || reviewResponse.object.additionalTasks.length === 0) {
           onProgress?.("Extraction complete.");
           break;
@@ -3762,25 +4604,49 @@ function createExtractor(config) {
         );
         for (const result of followUpResults) {
           if (result) {
-            memory.set(result.name, result.data);
+            mergeMemoryResult(result.name, result.data, memory);
           }
         }
       }
+      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
     });
@@ -3793,11 +4659,21 @@ function createExtractor(config) {
     trackUsage(formatResult.usage);
     const chunks = chunkDocument(formatResult.document);
     const finalCheckpoint = pipelineCtx.getCheckpoint();
+    if (callsMissingUsage > 0) {
+      await log?.(`Token usage was unavailable for ${callsMissingUsage}/${modelCalls} model calls. Check that your provider callbacks return usage.`);
+      onProgress?.(`Token usage unavailable for ${callsMissingUsage}/${modelCalls} model calls.`);
+    }
     return {
       document: formatResult.document,
       chunks,
       tokenUsage: totalUsage,
-      checkpoint: finalCheckpoint
+      usageReporting: {
+        modelCalls,
+        callsWithUsage,
+        callsMissingUsage
+      },
+      checkpoint: finalCheckpoint,
+      reviewReport
     };
   }
   return { extract };
@@ -4017,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",
@@ -4027,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_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 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 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
@@ -4628,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 {
@@ -4642,7 +5630,8 @@ function createApplicationPipeline(config) {
     onTokenUsage,
     onProgress,
     log,
-    providerOptions
+    providerOptions,
+    qualityGate = "warn"
   } = config;
   const limit = pLimit(concurrency);
   let totalUsage = { inputTokens: 0, outputTokens: 0 };
@@ -4664,6 +5653,7 @@ function createApplicationPipeline(config) {
       title: void 0,
       applicationType: null,
       fields: [],
+      qualityReport: void 0,
       batches: void 0,
       currentBatchIndex: 0,
       status: "classifying",
@@ -4688,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";
@@ -4713,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;
@@ -4814,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 };
@@ -4965,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 {
@@ -4980,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) {
@@ -5012,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) {
@@ -5148,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
@@ -5502,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 {
@@ -5515,7 +6633,8 @@ function createQueryAgent(config) {
     onTokenUsage,
     onProgress,
     log,
-    providerOptions
+    providerOptions,
+    qualityGate = "warn"
   } = config;
   const limit = pLimit(concurrency);
   let totalUsage = { inputTokens: 0, outputTokens: 0 };
@@ -5584,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,
@@ -5592,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;
@@ -5649,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({
@@ -5669,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;
@@ -5891,7 +7035,12 @@ var AGENT_TOOLS = [
   AdmittedStatusSchema,
   AnswerParsingResultSchema,
   ApplicationClassifyResultSchema,
+  ApplicationEmailReviewSchema,
   ApplicationFieldSchema,
+  ApplicationQualityArtifactSchema,
+  ApplicationQualityIssueSchema,
+  ApplicationQualityReportSchema,
+  ApplicationQualityRoundSchema,
   ApplicationStateSchema,
   AuditTypeSchema,
   AutoFillMatchSchema,
@@ -5923,6 +7072,7 @@ var AGENT_TOOLS = [
   CoverageFormSchema,
   CoverageSchema,
   CoverageTriggerSchema,
+  CoverageValueTypeSchema,
   CrimeDeclarationsSchema,
   CyberDeclarationsSchema,
   DEDUCTIBLE_TYPES,