@claritylabs/cl-sdk 0.10.2 → 0.11.0

package/dist/index.js

@@ -787,6 +787,7 @@ var CoverageValueTypeSchema = import_zod4.z.enum([
 var CoverageSchema = import_zod4.z.object({
   name: import_zod4.z.string(),
   limit: import_zod4.z.string(),
+  limitType: LimitTypeSchema.optional(),
   limitValueType: CoverageValueTypeSchema.optional(),
   deductible: import_zod4.z.string().optional(),
   deductibleValueType: CoverageValueTypeSchema.optional(),
@@ -1813,6 +1814,358 @@ async function runExtractor(params) {
   };
 }
 
+// src/extraction/promote.ts
+function getDeclarationFields(doc) {
+  const decl = doc.declarations;
+  return Array.isArray(decl?.fields) ? decl.fields : [];
+}
+function fieldMatches(fieldName, patterns) {
+  const lower = fieldName.toLowerCase().replace(/[\s_-]/g, "");
+  return patterns.some((p) => lower === p.toLowerCase().replace(/[\s_-]/g, ""));
+}
+function findFieldValue(fields, patterns) {
+  const match = fields.find((f) => fieldMatches(f.field, patterns));
+  return match?.value;
+}
+function promoteCarrierFields(doc) {
+  const raw = doc;
+  if (!raw.carrierNaicNumber && raw.naicNumber) {
+    raw.carrierNaicNumber = raw.naicNumber;
+  }
+  if (!raw.carrierAmBestRating && raw.amBestRating) {
+    raw.carrierAmBestRating = raw.amBestRating;
+  }
+  if (!raw.carrierAdmittedStatus && raw.admittedStatus) {
+    raw.carrierAdmittedStatus = raw.admittedStatus;
+  }
+  delete raw.naicNumber;
+  delete raw.amBestRating;
+  delete raw.admittedStatus;
+  if (!raw.insurer && raw.carrierLegalName) {
+    raw.insurer = {
+      legalName: raw.carrierLegalName,
+      ...raw.carrierNaicNumber ? { naicNumber: raw.carrierNaicNumber } : {},
+      ...raw.carrierAmBestRating ? { amBestRating: raw.carrierAmBestRating } : {},
+      ...raw.carrierAdmittedStatus ? { admittedStatus: raw.carrierAdmittedStatus } : {}
+    };
+  }
+}
+var BROKER_NAME_PATTERNS = [
+  "brokerName",
+  "broker",
+  "agentName",
+  "agent",
+  "producerName",
+  "producerAgency",
+  "agencyName",
+  "brokerAgency"
+];
+var BROKER_CONTACT_PATTERNS = [
+  "brokerContactName",
+  "brokerContact",
+  "agentContactName",
+  "producerContactName",
+  "producerContact"
+];
+var BROKER_LICENSE_PATTERNS = [
+  "brokerLicenseNumber",
+  "brokerNumber",
+  "agentLicenseNumber",
+  "producerLicenseNumber",
+  "producerNumber",
+  "agentNumber"
+];
+var BROKER_PHONE_PATTERNS = ["brokerPhone", "agentPhone", "producerPhone"];
+var BROKER_EMAIL_PATTERNS = ["brokerEmail", "agentEmail", "producerEmail"];
+var BROKER_ADDRESS_PATTERNS = ["brokerAddress", "agentAddress", "producerAddress"];
+function promoteBroker(doc) {
+  const raw = doc;
+  const fields = getDeclarationFields(doc);
+  const brokerAgency = raw.brokerAgency || findFieldValue(fields, BROKER_NAME_PATTERNS);
+  const brokerContact = raw.brokerContactName || findFieldValue(fields, BROKER_CONTACT_PATTERNS);
+  const brokerLicense = raw.brokerLicenseNumber || findFieldValue(fields, BROKER_LICENSE_PATTERNS);
+  const brokerPhone = findFieldValue(fields, BROKER_PHONE_PATTERNS);
+  const brokerEmail = findFieldValue(fields, BROKER_EMAIL_PATTERNS);
+  const brokerAddress = findFieldValue(fields, BROKER_ADDRESS_PATTERNS);
+  if (brokerAgency) raw.brokerAgency = brokerAgency;
+  if (brokerContact) raw.brokerContactName = brokerContact;
+  if (brokerLicense) raw.brokerLicenseNumber = brokerLicense;
+  if (!raw.producer && brokerAgency) {
+    raw.producer = {
+      agencyName: brokerAgency,
+      ...brokerContact ? { contactName: brokerContact } : {},
+      ...brokerLicense ? { licenseNumber: brokerLicense } : {},
+      ...brokerPhone ? { phone: brokerPhone } : {},
+      ...brokerEmail ? { email: brokerEmail } : {},
+      ...brokerAddress ? { address: { street1: brokerAddress } } : {}
+    };
+  }
+}
+var LOSS_PAYEE_NAME_PATTERNS = [
+  "lossPayeeName",
+  "lossPayee",
+  "lossPayeeHolder"
+];
+var LOSS_PAYEE_ADDRESS_PATTERNS = ["lossPayeeAddress"];
+var MORTGAGE_HOLDER_NAME_PATTERNS = [
+  "mortgagee",
+  "mortgageHolder",
+  "mortgageHolderName",
+  "mortgageeName",
+  "lienholder",
+  "lienholderName"
+];
+var MORTGAGE_HOLDER_ADDRESS_PATTERNS = [
+  "mortgageeAddress",
+  "mortgageHolderAddress",
+  "lienholderAddress"
+];
+function promoteLossPayees(doc) {
+  const raw = doc;
+  const fields = getDeclarationFields(doc);
+  if (!raw.lossPayees || Array.isArray(raw.lossPayees) && raw.lossPayees.length === 0) {
+    const name = findFieldValue(fields, LOSS_PAYEE_NAME_PATTERNS);
+    if (name) {
+      const address = findFieldValue(fields, LOSS_PAYEE_ADDRESS_PATTERNS);
+      raw.lossPayees = [{
+        name,
+        role: "loss_payee",
+        ...address ? { address: { street1: address } } : {}
+      }];
+    }
+  }
+  if (!raw.mortgageHolders || Array.isArray(raw.mortgageHolders) && raw.mortgageHolders.length === 0) {
+    const name = findFieldValue(fields, MORTGAGE_HOLDER_NAME_PATTERNS);
+    if (name) {
+      const address = findFieldValue(fields, MORTGAGE_HOLDER_ADDRESS_PATTERNS);
+      raw.mortgageHolders = [{
+        name,
+        role: "mortgage_holder",
+        ...address ? { address: { street1: address } } : {}
+      }];
+    }
+  }
+}
+function promoteLocations(doc) {
+  const raw = doc;
+  if (Array.isArray(raw.locations) && raw.locations.length > 0) return;
+  const fields = getDeclarationFields(doc);
+  if (fields.length === 0) return;
+  const locationGroups = /* @__PURE__ */ new Map();
+  for (const f of fields) {
+    const lower = f.field.toLowerCase().replace(/[\s_-]/g, "");
+    if (lower.includes("locationnumber") || lower.includes("locnumber") || lower.includes("locno")) {
+      const key = f.value;
+      if (!locationGroups.has(key)) locationGroups.set(key, /* @__PURE__ */ new Map());
+      locationGroups.get(key).set("number", f.value);
+      continue;
+    }
+    if (lower.includes("buildingnumber") || lower.includes("bldgnumber") || lower.includes("bldgno")) {
+      const lastKey2 = [...locationGroups.keys()].pop();
+      if (lastKey2) locationGroups.get(lastKey2).set("buildingNumber", f.value);
+      continue;
+    }
+    const section = (f.section ?? "").toLowerCase();
+    const isLocationField = section.includes("location") || section.includes("building") || section.includes("premises") || section.includes("schedule of locations");
+    if (!isLocationField) continue;
+    if (locationGroups.size === 0) {
+      locationGroups.set("1", /* @__PURE__ */ new Map([["number", "1"]]));
+    }
+    const lastKey = [...locationGroups.keys()].pop();
+    const group = locationGroups.get(lastKey);
+    if (lower.includes("construction") || lower.includes("constructiontype")) {
+      group.set("constructionType", f.value);
+    } else if (lower.includes("occupancy") || lower.includes("occupancytype")) {
+      group.set("occupancy", f.value);
+    } else if (lower.includes("yearbuilt")) {
+      group.set("yearBuilt", f.value);
+    } else if (lower.includes("squarefootage") || lower.includes("sqft") || lower.includes("area")) {
+      group.set("squareFootage", f.value);
+    } else if (lower.includes("protectionclass") || lower.includes("fireprotection")) {
+      group.set("protectionClass", f.value);
+    } else if (lower.includes("sprinkler")) {
+      group.set("sprinklered", f.value);
+    } else if (lower.includes("buildingvalue") || lower.includes("buildingamt") || lower.includes("buildingcoverage")) {
+      group.set("buildingValue", f.value);
+    } else if (lower.includes("contentsvalue") || lower.includes("contentsamt") || lower.includes("contentscoverage")) {
+      group.set("contentsValue", f.value);
+    } else if (lower.includes("businessincome") || lower.includes("bivalue") || lower.includes("businessincomevalue")) {
+      group.set("businessIncomeValue", f.value);
+    } else if (lower.includes("description") || lower.includes("buildingdescription") || lower.includes("locationdescription")) {
+      group.set("description", f.value);
+    } else if (lower.includes("address") || lower.includes("industryaddress") || lower.includes("locationaddress") || lower.includes("premisesaddress")) {
+      group.set("address", f.value);
+    } else if (lower.includes("alarm") || lower.includes("alarmtype")) {
+      group.set("alarmType", f.value);
+    }
+  }
+  if (locationGroups.size === 0) return;
+  const locations = [];
+  for (const [, group] of locationGroups) {
+    const num = parseInt(group.get("number") ?? "0", 10) || locations.length + 1;
+    const addressStr = group.get("address");
+    locations.push({
+      number: num,
+      address: addressStr ? { street1: addressStr } : { street1: "See declarations" },
+      ...group.get("description") ? { description: group.get("description") } : {},
+      ...group.get("constructionType") ? { constructionType: group.get("constructionType") } : {},
+      ...group.get("occupancy") ? { occupancy: group.get("occupancy") } : {},
+      ...group.get("yearBuilt") ? { yearBuilt: parseInt(group.get("yearBuilt"), 10) || void 0 } : {},
+      ...group.get("squareFootage") ? { squareFootage: parseInt(group.get("squareFootage").replace(/[^0-9]/g, ""), 10) || void 0 } : {},
+      ...group.get("protectionClass") ? { protectionClass: group.get("protectionClass") } : {},
+      ...group.get("sprinklered") ? { sprinklered: /yes|true/i.test(group.get("sprinklered")) } : {},
+      ...group.get("buildingValue") ? { buildingValue: group.get("buildingValue") } : {},
+      ...group.get("contentsValue") ? { contentsValue: group.get("contentsValue") } : {},
+      ...group.get("businessIncomeValue") ? { businessIncomeValue: group.get("businessIncomeValue") } : {},
+      ...group.get("alarmType") ? { alarmType: group.get("alarmType") } : {}
+    });
+  }
+  if (locations.length > 0) {
+    raw.locations = locations;
+  }
+}
+function normalizeName(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]/g, "");
+}
+var LIMIT_COVERAGE_MAP = [
+  // GL standard
+  [["eachoccurrence", "peroccurrence", "occurrencecombined"], "perOccurrence"],
+  [["generalaggregate"], "generalAggregate"],
+  [["productscompletedoperationsaggregate", "productscompletedopsaggregate", "prodcompopsagg"], "productsCompletedOpsAggregate"],
+  [["personaladvertisinginjury", "personaladvinjury", "pai"], "personalAdvertisingInjury"],
+  [["firedamage", "firedamagelegalliability", "damagetorentedpremises", "damagetopremisesrentedtoyou"], "fireDamage"],
+  [["medicalexpense", "medexp", "medicalexpenseanypersonanyperson", "medicalexpenseanyone"], "medicalExpense"],
+  // Auto
+  [["combinedsingle", "combinedsinglelimit", "csl"], "combinedSingleLimit"],
+  [["bodilyinjuryperperson", "biperperson"], "bodilyInjuryPerPerson"],
+  [["bodilyinjuryperaccident", "biperaccident"], "bodilyInjuryPerAccident"],
+  [["propertydamage", "pdperaccident"], "propertyDamage"],
+  // Umbrella/Excess
+  [["umbrellaoccurrence", "eachoccurrenceumbrella", "excessoccurrence", "excesseachoccurrence"], "eachOccurrenceUmbrella"],
+  [["umbrellaaggregate", "excessaggregate"], "umbrellaAggregate"],
+  [["umbrella retention", "selfinsuredretention", "sir", "excessretention"], "umbrellaRetention"]
+];
+function synthesizeLimits(doc) {
+  const raw = doc;
+  if (raw.limits && typeof raw.limits === "object" && Object.keys(raw.limits).length > 0) return;
+  const coverages = doc.coverages;
+  if (!coverages || coverages.length === 0) return;
+  const limits = {};
+  for (const cov of coverages) {
+    if (!cov.name || !cov.limit) continue;
+    const normalized = normalizeName(cov.name);
+    for (const [patterns, fieldName] of LIMIT_COVERAGE_MAP) {
+      if (patterns.some((p) => normalized.includes(p) || p.includes(normalized))) {
+        if (fieldName.includes("Aggregate") || fieldName.includes("aggregate")) {
+          if (!cov.limitType || cov.limitType === "aggregate") {
+            limits[fieldName] = cov.limit;
+          }
+        } else {
+          if (!limits[fieldName]) {
+            limits[fieldName] = cov.limit;
+          }
+        }
+        break;
+      }
+    }
+  }
+  const hasStatutory = coverages.some(
+    (c) => c.limitType === "statutory" || normalizeName(c.name ?? "").includes("statutory")
+  );
+  if (hasStatutory) {
+    limits.statutory = "true";
+  }
+  const elCoverages = coverages.filter(
+    (c) => normalizeName(c.name ?? "").includes("employersliability")
+  );
+  if (elCoverages.length > 0) {
+    const el = {};
+    for (const c of elCoverages) {
+      if (!c.limit) continue;
+      const n = normalizeName(c.name ?? "");
+      if (n.includes("accident") || n.includes("eachaccident")) el.eachAccident = c.limit;
+      else if (n.includes("diseasepolicy") || n.includes("diseasepolicylimit")) el.diseasePolicyLimit = c.limit;
+      else if (n.includes("diseaseemployee") || n.includes("diseaseeachemployee")) el.diseaseEachEmployee = c.limit;
+      else if (!el.eachAccident) el.eachAccident = c.limit;
+    }
+    if (Object.keys(el).length > 0) {
+      limits.employersLiability = el;
+    }
+  }
+  if (Object.keys(limits).length > 0) {
+    const result = { ...limits };
+    if (result.statutory === "true") result.statutory = true;
+    raw.limits = result;
+  }
+}
+function synthesizeDeductibles(doc) {
+  const raw = doc;
+  if (raw.deductibles && typeof raw.deductibles === "object" && Object.keys(raw.deductibles).length > 0) return;
+  const coverages = doc.coverages;
+  if (!coverages || coverages.length === 0) return;
+  const deductibleValues = coverages.filter((c) => c.deductible && c.deductible.trim() !== "" && c.deductible !== "N/A" && c.deductible !== "None").map((c) => c.deductible);
+  if (deductibleValues.length === 0) return;
+  const freq = /* @__PURE__ */ new Map();
+  for (const d of deductibleValues) {
+    freq.set(d, (freq.get(d) ?? 0) + 1);
+  }
+  let mostCommon = deductibleValues[0];
+  let maxFreq = 0;
+  for (const [val, count] of freq) {
+    if (count > maxFreq) {
+      mostCommon = val;
+      maxFreq = count;
+    }
+  }
+  const deductibles = {};
+  const hasPerClaim = coverages.some(
+    (c) => c.deductible && normalizeName(c.name ?? "").includes("perclaim")
+  );
+  if (hasPerClaim) {
+    deductibles.perClaim = mostCommon;
+  } else {
+    deductibles.perOccurrence = mostCommon;
+  }
+  const sirCoverage = coverages.find(
+    (c) => c.deductible && (normalizeName(c.name ?? "").includes("selfinsuredretention") || normalizeName(c.name ?? "").includes("sir"))
+  );
+  if (sirCoverage?.deductible) {
+    deductibles.selfInsuredRetention = sirCoverage.deductible;
+  }
+  const aggDed = coverages.find(
+    (c) => c.deductible && normalizeName(c.name ?? "").includes("aggregatedeductible")
+  );
+  if (aggDed?.deductible) {
+    deductibles.aggregateDeductible = aggDed.deductible;
+  }
+  if (Object.keys(deductibles).length > 0) {
+    raw.deductibles = deductibles;
+  }
+}
+var PREMIUM_PATTERNS = ["premium", "totalPremium", "annualPremium", "policyPremium", "basePremium"];
+var TOTAL_COST_PATTERNS = ["totalCost", "totalDue", "totalAmount", "totalPolicyPremium"];
+function promotePremium(doc) {
+  const raw = doc;
+  const fields = getDeclarationFields(doc);
+  if (!raw.premium) {
+    const premium = findFieldValue(fields, PREMIUM_PATTERNS);
+    if (premium) raw.premium = premium;
+  }
+  if (!raw.totalCost) {
+    const totalCost = findFieldValue(fields, TOTAL_COST_PATTERNS);
+    if (totalCost) raw.totalCost = totalCost;
+  }
+}
+function promoteExtractedFields(doc) {
+  promoteCarrierFields(doc);
+  promoteBroker(doc);
+  promoteLossPayees(doc);
+  promoteLocations(doc);
+  synthesizeLimits(doc);
+  synthesizeDeductibles(doc);
+  promotePremium(doc);
+}
+
 // src/extraction/assembler.ts
 function assembleDocument(documentId, documentType, memory) {
   const carrier = memory.get("carrier_info");
@@ -1836,6 +2189,9 @@ function assembleDocument(documentId, documentType, memory) {
     policyTypes: classify?.policyTypes,
     ...sanitizeNulls(carrier ?? {}),
     ...sanitizeNulls(insured ?? {}),
+    // Map named_insured extractor's loss payees/mortgage holders to EndorsementParty shape
+    ...Array.isArray(insured?.lossPayees) && insured.lossPayees.length > 0 ? { lossPayees: insured.lossPayees.map((lp) => ({ ...lp, role: "loss_payee" })) } : {},
+    ...Array.isArray(insured?.mortgageHolders) && insured.mortgageHolders.length > 0 ? { mortgageHolders: insured.mortgageHolders.map((mh) => ({ ...mh, role: "mortgage_holder" })) } : {},
     ...sanitizeNulls(coverages ?? {}),
     ...sanitizeNulls(premium ?? {}),
     ...sanitizeNulls(supplementary ?? {}),
@@ -1847,8 +2203,9 @@ function assembleDocument(documentId, documentType, memory) {
     declarations: declarations ? sanitizeNulls(declarations) : void 0,
     ...sanitizeNulls(lossHistory ?? {})
   };
+  let doc;
   if (documentType === "policy") {
-    return {
+    doc = {
       ...base,
       type: "policy",
       policyNumber: carrier?.policyNumber ?? insured?.policyNumber ?? "Unknown",
@@ -1856,17 +2213,20 @@ function assembleDocument(documentId, documentType, memory) {
       expirationDate: carrier?.expirationDate,
       policyTermType: carrier?.policyTermType
     };
+  } else {
+    doc = {
+      ...base,
+      type: "quote",
+      quoteNumber: carrier?.quoteNumber ?? "Unknown",
+      proposedEffectiveDate: carrier?.proposedEffectiveDate,
+      proposedExpirationDate: carrier?.proposedExpirationDate,
+      subjectivities: coverages?.subjectivities,
+      underwritingConditions: coverages?.underwritingConditions,
+      premiumBreakdown: premium?.premiumBreakdown
+    };
   }
-  return {
-    ...base,
-    type: "quote",
-    quoteNumber: carrier?.quoteNumber ?? "Unknown",
-    proposedEffectiveDate: carrier?.proposedEffectiveDate,
-    proposedExpirationDate: carrier?.proposedExpirationDate,
-    subjectivities: coverages?.subjectivities,
-    underwritingConditions: coverages?.underwritingConditions,
-    premiumBreakdown: premium?.premiumBreakdown
-  };
+  promoteExtractedFields(doc);
+  return doc;
 }
 
 // src/prompts/coordinator/format.ts
@@ -2238,6 +2598,7 @@ function mergeCoverageLimits(existing, incoming) {
   const incomingCoverages = Array.isArray(incoming.coverages) ? incoming.coverages : [];
   const coverageKey = (coverage) => [
     String(coverage.name ?? "").toLowerCase(),
+    String(coverage.limitType ?? "").toLowerCase(),
     String(coverage.limit ?? "").toLowerCase(),
     String(coverage.deductible ?? "").toLowerCase(),
     String(coverage.formNumber ?? "").toLowerCase()
@@ -3203,6 +3564,7 @@ Available extractors:
 - supplementary
 
 Rules:
+- Identify the broad section or form context first, then assign focused extractors within that context.
 - 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.
@@ -3213,6 +3575,8 @@ Rules:
 - 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.
+- Do not tag a page with "exclusions" or "conditions" if it only contains a table of contents, page-number reference, running header/footer, or a heading that points to another page without substantive wording.
+- If a page appears to be part of a larger exclusion, conditions, or endorsement section within the same form, keep the assignment consistent across nearby pages in that section rather than isolating a single page fragment.
 - Return every page in the supplied chunk exactly once.
 
 Return JSON:
@@ -3296,21 +3660,69 @@ Use the page map to target follow-up extraction pages precisely. Prefer narrow,
 Respond with JSON only.`;
 }
 
-// src/prompts/extractors/carrier-info.ts
+// src/prompts/coordinator/summarize.ts
 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)")
+var SummaryResultSchema = import_zod22.z.object({
+  summary: import_zod22.z.string().describe("A 1-3 sentence overview of this insurance document")
+});
+function buildSummaryPrompt(doc) {
+  const snapshot = {
+    type: doc.type,
+    carrier: doc.carrier,
+    insuredName: doc.insuredName,
+    policyTypes: doc.policyTypes,
+    premium: doc.premium,
+    coverageCount: doc.coverages?.length ?? 0
+  };
+  if (doc.type === "policy") {
+    snapshot.policyNumber = doc.policyNumber;
+    snapshot.effectiveDate = doc.effectiveDate;
+    snapshot.expirationDate = doc.expirationDate;
+  } else {
+    snapshot.quoteNumber = doc.quoteNumber;
+    snapshot.proposedEffectiveDate = doc.proposedEffectiveDate;
+  }
+  const raw = doc;
+  if (raw.limits) snapshot.limits = raw.limits;
+  if (raw.deductibles) snapshot.deductibles = raw.deductibles;
+  if (raw.brokerAgency) snapshot.brokerAgency = raw.brokerAgency;
+  if (doc.endorsements?.length) snapshot.endorsementCount = doc.endorsements.length;
+  if (doc.exclusions?.length) snapshot.exclusionCount = doc.exclusions.length;
+  if (doc.coverages?.length) {
+    snapshot.topCoverages = doc.coverages.slice(0, 5).map((c) => c.name);
+  }
+  return `You are an expert insurance document analyst. Generate a brief summary of this insurance document.
+
+Write 1-3 sentences that capture the essential facts a broker or underwriter would want at a glance:
+- Who is insured and by whom
+- What type of policy/quote and the key coverages
+- Policy period and premium if available
+- Any notable features (high limits, unusual exclusions, etc.)
+
+Document data:
+${JSON.stringify(snapshot, null, 2)}
+
+Return JSON only with a "summary" field.`;
+}
+
+// src/prompts/extractors/carrier-info.ts
+var import_zod23 = require("zod");
+var CarrierInfoSchema = import_zod23.z.object({
+  carrierName: import_zod23.z.string().describe("Primary insurance company name for display"),
+  carrierLegalName: import_zod23.z.string().optional().describe("Legal entity name of insurer"),
+  naicNumber: import_zod23.z.string().optional().describe("NAIC company code"),
+  amBestRating: import_zod23.z.string().optional().describe("AM Best rating, e.g. 'A+ XV'"),
+  admittedStatus: import_zod23.z.enum(["admitted", "non_admitted", "surplus_lines"]).optional().describe("Admitted status of the carrier"),
+  mga: import_zod23.z.string().optional().describe("Managing General Agent or Program Administrator name"),
+  underwriter: import_zod23.z.string().optional().describe("Named individual underwriter"),
+  brokerAgency: import_zod23.z.string().optional().describe("Broker or producer agency name"),
+  brokerContactName: import_zod23.z.string().optional().describe("Broker or producer contact person name"),
+  brokerLicenseNumber: import_zod23.z.string().optional().describe("Broker or producer license number"),
+  policyNumber: import_zod23.z.string().optional().describe("Policy or quote reference number"),
+  effectiveDate: import_zod23.z.string().optional().describe("Policy effective date (MM/DD/YYYY)"),
+  expirationDate: import_zod23.z.string().optional().describe("Policy expiration date (MM/DD/YYYY)"),
+  quoteNumber: import_zod23.z.string().optional().describe("Quote or proposal reference number"),
+  proposedEffectiveDate: import_zod23.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.
@@ -3321,27 +3733,30 @@ Focus on:
 - Whether the carrier is admitted, non-admitted, or surplus lines
 - Managing General Agent (MGA) or Program Administrator if applicable
 - Named individual underwriter if listed
+- Broker/producer/agent: agency name, contact person name, and license number
 - Policy number and effective/expiration dates
 - For quotes: quote number and proposed effective date
 
 For carrier vs. security distinction: "carrier" is the primary company name; the legal entity on risk (e.g. "Lloyd's Underwriters") may differ from the display name.
 
+Look for broker/producer/agent information near the carrier or on the declarations page. This may be labeled "Producer", "Agent", "Broker", or similar.
+
 Return JSON only.`;
 }
 
 // src/prompts/extractors/named-insured.ts
-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 import_zod24 = require("zod");
+var AddressSchema2 = import_zod24.z.object({
+  street1: import_zod24.z.string(),
+  city: import_zod24.z.string(),
+  state: import_zod24.z.string(),
+  zip: import_zod24.z.string()
 });
-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"),
+var NamedInsuredSchema2 = import_zod24.z.object({
+  insuredName: import_zod24.z.string().describe("Name of primary named insured"),
+  insuredDba: import_zod24.z.string().optional().describe("Doing-business-as name"),
   insuredAddress: AddressSchema2.optional().describe("Primary insured mailing address"),
-  insuredEntityType: import_zod23.z.enum([
+  insuredEntityType: import_zod24.z.enum([
     "corporation",
     "llc",
     "partnership",
@@ -3354,16 +3769,28 @@ var NamedInsuredSchema2 = import_zod23.z.object({
     "married_couple",
     "other"
   ]).optional().describe("Legal entity type of the insured"),
-  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"),
+  insuredFein: import_zod24.z.string().optional().describe("Federal Employer Identification Number"),
+  insuredSicCode: import_zod24.z.string().optional().describe("SIC code"),
+  insuredNaicsCode: import_zod24.z.string().optional().describe("NAICS code"),
+  additionalNamedInsureds: import_zod24.z.array(
+    import_zod24.z.object({
+      name: import_zod24.z.string(),
+      relationship: import_zod24.z.string().optional().describe("e.g. subsidiary, affiliate"),
       address: AddressSchema2.optional()
     })
-  ).optional().describe("Additional named insureds listed on the policy")
+  ).optional().describe("Additional named insureds listed on the policy"),
+  lossPayees: import_zod24.z.array(
+    import_zod24.z.object({
+      name: import_zod24.z.string(),
+      address: AddressSchema2.optional()
+    })
+  ).optional().describe("Loss payees listed on the policy"),
+  mortgageHolders: import_zod24.z.array(
+    import_zod24.z.object({
+      name: import_zod24.z.string(),
+      address: AddressSchema2.optional()
+    })
+  ).optional().describe("Mortgage holders / lienholders listed on the policy")
 });
 function buildNamedInsuredPrompt() {
   return `You are an expert insurance document analyst. Extract all named insured information from this document.
@@ -3374,21 +3801,23 @@ Focus on:
 - FEIN (Federal Employer Identification Number) if listed
 - SIC code and NAICS code if listed
 - ALL additional named insureds with their relationship (subsidiary, affiliate, etc.) and address if provided
+- ALL loss payees with name and address (e.g. "Loss Payee: BMO Bank of Montreal")
+- ALL mortgage holders / lienholders / mortgagees with name and address
 
-Look on the declarations page, named insured schedule, and any endorsements that add or modify named insureds.
+Look on the declarations page, named insured schedule, loss payee schedule, mortgagee schedule, and any endorsements that add or modify named insureds, loss payees, or mortgage holders.
 
 Return JSON only.`;
 }
 
 // src/prompts/extractors/coverage-limits.ts
-var import_zod24 = require("zod");
+var import_zod25 = require("zod");
 var ExtractorCoverageSchema = CoverageSchema.extend({
-  coverageCode: import_zod24.z.string().optional().describe("Coverage code or class code")
+  coverageCode: import_zod25.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)")
+var CoverageLimitsSchema = import_zod25.z.object({
+  coverages: import_zod25.z.array(ExtractorCoverageSchema).describe("All coverages with their limits"),
+  coverageForm: import_zod25.z.enum(["occurrence", "claims_made", "accident"]).optional().describe("Primary coverage trigger type"),
+  retroactiveDate: import_zod25.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.
@@ -3397,7 +3826,7 @@ Extract only insured-specific declaration, schedule, or endorsement entries that
 
 Focus on:
 - Every coverage listed on the declarations page or coverage schedule
-- Per-occurrence, aggregate, and sub-limits for each coverage
+- Per-occurrence, individual/occurrence, aggregate, and sub-limits for each coverage
 - Deductible or self-insured retention for each coverage
 - Coverage form type: occurrence-based, claims-made, or accident
 - Retroactive date for claims-made policies
@@ -3409,6 +3838,7 @@ 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
+- limitType: when applicable, classify the limit as per_occurrence, per_claim, aggregate, per_person, per_accident, statutory, blanket, or scheduled
 - 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
 
@@ -3420,19 +3850,20 @@ Critical rules:
 - 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.
+- Keep individual/per-occurrence limits separate from aggregate limits even when they have the same coverage name, limit amount, deductible, and form number. Use limitType to distinguish them.
 
 Return JSON only.`;
 }
 
 // src/prompts/extractors/endorsements.ts
-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([
+var import_zod26 = require("zod");
+var EndorsementsSchema = import_zod26.z.object({
+  endorsements: import_zod26.z.array(
+    import_zod26.z.object({
+      formNumber: import_zod26.z.string().describe("Form number, e.g. 'CG 21 47'"),
+      editionDate: import_zod26.z.string().optional().describe("Edition date, e.g. '12 07'"),
+      title: import_zod26.z.string().describe("Endorsement title"),
+      endorsementType: import_zod26.z.enum([
         "additional_insured",
         "waiver_of_subrogation",
         "primary_noncontributory",
@@ -3452,12 +3883,12 @@ var EndorsementsSchema = import_zod25.z.object({
         "territorial_extension",
         "other"
       ]).describe("Endorsement type classification"),
-      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([
+      effectiveDate: import_zod26.z.string().optional().describe("Endorsement effective date"),
+      affectedCoverageParts: import_zod26.z.array(import_zod26.z.string()).optional().describe("Coverage parts affected by this endorsement"),
+      namedParties: import_zod26.z.array(
+        import_zod26.z.object({
+          name: import_zod26.z.string().describe("Party name"),
+          role: import_zod26.z.enum([
             "additional_insured",
             "loss_payee",
             "mortgage_holder",
@@ -3466,15 +3897,15 @@ var EndorsementsSchema = import_zod25.z.object({
             "designated_person",
             "other"
           ]).describe("Party role"),
-          relationship: import_zod25.z.string().optional().describe("Relationship to insured"),
-          scope: import_zod25.z.string().optional().describe("Scope of coverage for this party")
+          relationship: import_zod26.z.string().optional().describe("Relationship to insured"),
+          scope: import_zod26.z.string().optional().describe("Scope of coverage for this party")
         })
       ).optional().describe("Named parties (additional insureds, loss payees, etc.)"),
-      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")
+      keyTerms: import_zod26.z.array(import_zod26.z.string()).optional().describe("Key terms or notable provisions in the endorsement"),
+      premiumImpact: import_zod26.z.string().optional().describe("Additional premium or credit"),
+      content: import_zod26.z.string().describe("Full verbatim text of the endorsement"),
+      pageStart: import_zod26.z.number().describe("Starting page number of this endorsement"),
+      pageEnd: import_zod26.z.number().optional().describe("Ending page number of this endorsement")
     })
   ).describe("All endorsements found in the document")
 });
@@ -3505,20 +3936,20 @@ Return JSON only.`;
 }
 
 // src/prompts/extractors/exclusions.ts
-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")
+var import_zod27 = require("zod");
+var ExclusionsSchema = import_zod27.z.object({
+  exclusions: import_zod27.z.array(
+    import_zod27.z.object({
+      name: import_zod27.z.string().describe("Exclusion title or short description"),
+      formNumber: import_zod27.z.string().optional().describe("Form number if part of a named endorsement"),
+      excludedPerils: import_zod27.z.array(import_zod27.z.string()).optional().describe("Specific perils excluded"),
+      isAbsolute: import_zod27.z.boolean().optional().describe("Whether the exclusion is absolute (no exceptions)"),
+      exceptions: import_zod27.z.array(import_zod27.z.string()).optional().describe("Exceptions to the exclusion, if any"),
+      buybackAvailable: import_zod27.z.boolean().optional().describe("Whether coverage can be bought back via endorsement"),
+      buybackEndorsement: import_zod27.z.string().optional().describe("Form number of the buyback endorsement if available"),
+      appliesTo: import_zod27.z.array(import_zod27.z.string()).optional().describe("Coverage types this exclusion applies to"),
+      content: import_zod27.z.string().describe("Full verbatim exclusion text"),
+      pageNumber: import_zod27.z.number().optional().describe("Page number where exclusion appears")
     })
   ).describe("All exclusions found in the document")
 });
@@ -3554,12 +3985,12 @@ Return JSON only.`;
 }
 
 // src/prompts/extractors/conditions.ts
-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([
+var import_zod28 = require("zod");
+var ConditionsSchema = import_zod28.z.object({
+  conditions: import_zod28.z.array(
+    import_zod28.z.object({
+      name: import_zod28.z.string().describe("Condition title"),
+      conditionType: import_zod28.z.enum([
         "duties_after_loss",
         "notice_requirements",
         "other_insurance",
@@ -3578,14 +4009,14 @@ var ConditionsSchema = import_zod27.z.object({
         "separation_of_insureds",
         "other"
       ]).describe("Condition category"),
-      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')")
+      content: import_zod28.z.string().describe("Full verbatim condition text"),
+      keyValues: import_zod28.z.array(
+        import_zod28.z.object({
+          key: import_zod28.z.string().describe("Key name (e.g. 'noticePeriod', 'suitDeadline')"),
+          value: import_zod28.z.string().describe("Value (e.g. '30 days', '2 years')")
         })
       ).optional().describe("Key values extracted from the condition (notice periods, deadlines, etc.)"),
-      pageNumber: import_zod27.z.number().optional().describe("Page number where condition appears")
+      pageNumber: import_zod28.z.number().optional().describe("Page number where condition appears")
     })
   ).describe("All policy conditions found in the document")
 });
@@ -3623,28 +4054,28 @@ Return JSON only.`;
 }
 
 // src/prompts/extractors/premium-breakdown.ts
-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")
+var import_zod29 = require("zod");
+var PremiumBreakdownSchema = import_zod29.z.object({
+  premium: import_zod29.z.string().optional().describe("Total premium amount, e.g. '$5,000'"),
+  totalCost: import_zod29.z.string().optional().describe("Total cost including taxes and fees, e.g. '$5,250'"),
+  premiumBreakdown: import_zod29.z.array(
+    import_zod29.z.object({
+      line: import_zod29.z.string().describe("Coverage line name"),
+      amount: import_zod29.z.string().describe("Premium amount for this line")
     })
   ).optional().describe("Per-coverage-line premium breakdown"),
-  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")
+  taxesAndFees: import_zod29.z.array(
+    import_zod29.z.object({
+      name: import_zod29.z.string().describe("Fee or tax name"),
+      amount: import_zod29.z.string().describe("Dollar amount"),
+      type: import_zod29.z.enum(["tax", "fee", "surcharge", "assessment"]).optional().describe("Fee category")
     })
   ).optional().describe("Taxes, fees, surcharges, and assessments"),
-  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")
+  minimumPremium: import_zod29.z.string().optional().describe("Minimum premium if stated"),
+  depositPremium: import_zod29.z.string().optional().describe("Deposit premium if stated"),
+  paymentPlan: import_zod29.z.string().optional().describe("Payment plan description"),
+  auditType: import_zod29.z.enum(["annual", "semi_annual", "quarterly", "monthly", "final", "self"]).optional().describe("Premium audit type"),
+  ratingBasis: import_zod29.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.
@@ -3664,14 +4095,14 @@ Return JSON only.`;
 }
 
 // src/prompts/extractors/declarations.ts
-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 import_zod30 = require("zod");
+var DeclarationsFieldSchema = import_zod30.z.object({
+  field: import_zod30.z.string().describe("Descriptive field name (e.g. 'policyNumber', 'effectiveDate', 'coverageALimit')"),
+  value: import_zod30.z.string().describe("Extracted value exactly as it appears in the document"),
+  section: import_zod30.z.string().optional().describe("Section or grouping this field belongs to (e.g. 'Coverage Limits', 'Vehicle Schedule')")
 });
-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.")
+var DeclarationsExtractSchema = import_zod30.z.object({
+  fields: import_zod30.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.
@@ -3711,21 +4142,21 @@ Preserve original values exactly as they appear. Return JSON only.`;
 }
 
 // src/prompts/extractors/loss-history.ts
-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")
+var import_zod31 = require("zod");
+var LossHistorySchema = import_zod31.z.object({
+  lossSummary: import_zod31.z.string().optional().describe("Summary of loss history, e.g. '3 claims in past 5 years totaling $125,000'"),
+  individualClaims: import_zod31.z.array(
+    import_zod31.z.object({
+      date: import_zod31.z.string().optional().describe("Date of loss or claim"),
+      type: import_zod31.z.string().optional().describe("Type of claim, e.g. 'property damage', 'bodily injury'"),
+      description: import_zod31.z.string().optional().describe("Brief description of the claim"),
+      amountPaid: import_zod31.z.string().optional().describe("Amount paid"),
+      amountReserved: import_zod31.z.string().optional().describe("Amount reserved"),
+      status: import_zod31.z.enum(["open", "closed", "reopened"]).optional().describe("Claim status"),
+      claimNumber: import_zod31.z.string().optional().describe("Claim reference number")
     })
   ).optional().describe("Individual claim records"),
-  experienceMod: import_zod30.z.string().optional().describe("Experience modification factor for workers comp, e.g. '0.85'")
+  experienceMod: import_zod31.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.
@@ -3742,18 +4173,18 @@ Return JSON only.`;
 }
 
 // src/prompts/extractors/sections.ts
-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 import_zod32 = require("zod");
+var SubsectionSchema2 = import_zod32.z.object({
+  title: import_zod32.z.string().describe("Subsection title"),
+  sectionNumber: import_zod32.z.string().optional().describe("Subsection number"),
+  pageNumber: import_zod32.z.number().optional().describe("Page number"),
+  content: import_zod32.z.string().describe("Full verbatim text")
 });
-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([
+var SectionsSchema = import_zod32.z.object({
+  sections: import_zod32.z.array(
+    import_zod32.z.object({
+      title: import_zod32.z.string().describe("Section title"),
+      type: import_zod32.z.enum([
         "declarations",
         "insuring_agreement",
         "policy_form",
@@ -3767,10 +4198,10 @@ var SectionsSchema = import_zod31.z.object({
         "regulatory",
         "other"
       ]).describe("Section type classification"),
-      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")
+      content: import_zod32.z.string().describe("Full verbatim text of the section"),
+      pageStart: import_zod32.z.number().describe("Starting page number"),
+      pageEnd: import_zod32.z.number().optional().describe("Ending page number"),
+      subsections: import_zod32.z.array(SubsectionSchema2).optional().describe("Subsections within this section")
     })
   ).describe("All document sections")
 });
@@ -3800,20 +4231,20 @@ Return JSON only.`;
 }
 
 // src/prompts/extractors/supplementary.ts
-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 import_zod33 = require("zod");
+var ContactSchema2 = import_zod33.z.object({
+  name: import_zod33.z.string().optional().describe("Organization or person name"),
+  phone: import_zod33.z.string().optional().describe("Phone number"),
+  email: import_zod33.z.string().optional().describe("Email address"),
+  address: import_zod33.z.string().optional().describe("Mailing address"),
+  type: import_zod33.z.string().optional().describe("Contact type, e.g. 'State Department of Insurance'")
 });
-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")
+var SupplementarySchema = import_zod33.z.object({
+  regulatoryContacts: import_zod33.z.array(ContactSchema2).optional().describe("Regulatory body contacts (state department of insurance, ombudsman)"),
+  claimsContacts: import_zod33.z.array(ContactSchema2).optional().describe("Claims reporting contacts and instructions"),
+  thirdPartyAdministrators: import_zod33.z.array(ContactSchema2).optional().describe("Third-party administrators for claims handling"),
+  cancellationNoticeDays: import_zod33.z.number().optional().describe("Required notice period for cancellation in days"),
+  nonrenewalNoticeDays: import_zod33.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.
@@ -4297,7 +4728,7 @@ function createExtractor(config) {
     ranges.push({ startPage: start, endPage: previous });
     return ranges;
   }
-  function buildPlanFromPageAssignments(pageAssignments, pageCount) {
+  function buildPlanFromPageAssignments(pageAssignments, pageCount, formInventory) {
     const extractorPages = /* @__PURE__ */ new Map();
     for (const assignment of pageAssignments) {
       const extractors = assignment.extractorNames.length > 0 ? assignment.extractorNames : ["sections"];
@@ -4314,8 +4745,30 @@ function createExtractor(config) {
         extractorPages.set("sections", [...extractorPages.get("sections") ?? [], page]);
       }
     }
+    const contextualExtractors = /* @__PURE__ */ new Set(["conditions", "exclusions", "endorsements"]);
+    const contextualForms = (formInventory?.forms ?? []).filter(
+      (form) => form.pageStart != null && (form.pageEnd ?? form.pageStart) != null
+    );
+    const expandPagesToFormRanges = (extractorName, pages) => {
+      if (!contextualExtractors.has(extractorName)) return pages;
+      const expanded = new Set(pages);
+      for (const page of pages) {
+        for (const form of contextualForms) {
+          const pageStart = form.pageStart;
+          const pageEnd = form.pageEnd ?? form.pageStart;
+          const formType = form.formType;
+          const supportsContextualExpansion = extractorName === "endorsements" ? formType === "endorsement" : formType === "coverage" || formType === "endorsement";
+          if (!supportsContextualExpansion) continue;
+          if (page < pageStart || page > pageEnd) continue;
+          for (let current = pageStart; current <= pageEnd; current += 1) {
+            expanded.add(current);
+          }
+        }
+      }
+      return [...expanded].sort((a, b) => a - b);
+    };
     const tasks = [...extractorPages.entries()].flatMap(
-      ([extractorName, pages]) => groupContiguousPages(pages).map(({ startPage, endPage }) => ({
+      ([extractorName, pages]) => groupContiguousPages(expandPagesToFormRanges(extractorName, pages)).map(({ startPage, endPage }) => ({
         extractorName,
         startPage,
         endPage,
@@ -4483,7 +4936,7 @@ function createExtractor(config) {
       onProgress?.("Resuming from checkpoint (plan complete)...");
     } else {
       onProgress?.(`Building extraction plan from page map for ${primaryType} ${documentType}...`);
-      plan = buildPlanFromPageAssignments(pageAssignments, pageCount);
+      plan = buildPlanFromPageAssignments(pageAssignments, pageCount, formInventory);
       await pipelineCtx.save("plan", {
         id,
         pageCount,
@@ -4650,6 +5103,31 @@ function createExtractor(config) {
       memory: Object.fromEntries(memory),
       document
     });
+    if (!document.summary) {
+      onProgress?.("Generating document summary...");
+      try {
+        const summaryResponse = await safeGenerateObject(
+          generateObject,
+          {
+            prompt: buildSummaryPrompt(document),
+            schema: SummaryResultSchema,
+            maxTokens: 512,
+            providerOptions
+          },
+          {
+            fallback: { summary: "" },
+            log,
+            onError: (err, attempt) => log?.(`Summary attempt ${attempt + 1} failed: ${err instanceof Error ? err.message : String(err)}`)
+          }
+        );
+        trackUsage(summaryResponse.usage);
+        if (summaryResponse.object.summary) {
+          document.summary = summaryResponse.object.summary;
+        }
+      } catch (error) {
+        await log?.(`Summary generation failed, skipping: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
     onProgress?.("Formatting extracted content...");
     const formatResult = await formatDocumentContent(document, generateText, {
       providerOptions,
@@ -4893,8 +5371,8 @@ Respond with JSON only:
 }`;
 
 // src/schemas/application.ts
-var import_zod33 = require("zod");
-var FieldTypeSchema = import_zod33.z.enum([
+var import_zod34 = require("zod");
+var FieldTypeSchema = import_zod34.z.enum([
   "text",
   "numeric",
   "currency",
@@ -4903,131 +5381,131 @@ var FieldTypeSchema = import_zod33.z.enum([
   "table",
   "declaration"
 ]);
-var ApplicationFieldSchema = import_zod33.z.object({
-  id: import_zod33.z.string(),
-  label: import_zod33.z.string(),
-  section: import_zod33.z.string(),
+var ApplicationFieldSchema = import_zod34.z.object({
+  id: import_zod34.z.string(),
+  label: import_zod34.z.string(),
+  section: import_zod34.z.string(),
   fieldType: FieldTypeSchema,
-  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()
+  required: import_zod34.z.boolean(),
+  options: import_zod34.z.array(import_zod34.z.string()).optional(),
+  columns: import_zod34.z.array(import_zod34.z.string()).optional(),
+  requiresExplanationIfYes: import_zod34.z.boolean().optional(),
+  condition: import_zod34.z.object({
+    dependsOn: import_zod34.z.string(),
+    whenValue: import_zod34.z.string()
   }).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()
+  value: import_zod34.z.string().optional(),
+  source: import_zod34.z.string().optional().describe("Where the value came from: auto-fill, user, lookup"),
+  confidence: import_zod34.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 ApplicationClassifyResultSchema = import_zod34.z.object({
+  isApplication: import_zod34.z.boolean(),
+  confidence: import_zod34.z.number().min(0).max(1),
+  applicationType: import_zod34.z.string().nullable()
 });
-var FieldExtractionResultSchema = import_zod33.z.object({
-  fields: import_zod33.z.array(ApplicationFieldSchema)
+var FieldExtractionResultSchema = import_zod34.z.object({
+  fields: import_zod34.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 AutoFillMatchSchema = import_zod34.z.object({
+  fieldId: import_zod34.z.string(),
+  value: import_zod34.z.string(),
+  confidence: import_zod34.z.enum(["confirmed"]),
+  contextKey: import_zod34.z.string()
 });
-var AutoFillResultSchema = import_zod33.z.object({
-  matches: import_zod33.z.array(AutoFillMatchSchema)
+var AutoFillResultSchema = import_zod34.z.object({
+  matches: import_zod34.z.array(AutoFillMatchSchema)
 });
-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 QuestionBatchResultSchema = import_zod34.z.object({
+  batches: import_zod34.z.array(import_zod34.z.array(import_zod34.z.string()).describe("Array of field IDs in this batch"))
 });
-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 LookupRequestSchema = import_zod34.z.object({
+  type: import_zod34.z.string().describe("Type of lookup: 'records', 'website', 'policy'"),
+  description: import_zod34.z.string(),
+  url: import_zod34.z.string().optional(),
+  targetFieldIds: import_zod34.z.array(import_zod34.z.string())
 });
-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 ReplyIntentSchema = import_zod34.z.object({
+  primaryIntent: import_zod34.z.enum(["answers_only", "question", "lookup_request", "mixed"]),
+  hasAnswers: import_zod34.z.boolean(),
+  questionText: import_zod34.z.string().optional(),
+  questionFieldIds: import_zod34.z.array(import_zod34.z.string()).optional(),
+  lookupRequests: import_zod34.z.array(LookupRequestSchema).optional()
 });
-var ParsedAnswerSchema = import_zod33.z.object({
-  fieldId: import_zod33.z.string(),
-  value: import_zod33.z.string(),
-  explanation: import_zod33.z.string().optional()
+var ParsedAnswerSchema = import_zod34.z.object({
+  fieldId: import_zod34.z.string(),
+  value: import_zod34.z.string(),
+  explanation: import_zod34.z.string().optional()
 });
-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 AnswerParsingResultSchema = import_zod34.z.object({
+  answers: import_zod34.z.array(ParsedAnswerSchema),
+  unanswered: import_zod34.z.array(import_zod34.z.string()).describe("Field IDs that were not answered")
 });
-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 LookupFillSchema = import_zod34.z.object({
+  fieldId: import_zod34.z.string(),
+  value: import_zod34.z.string(),
+  source: import_zod34.z.string().describe("Specific citable reference, e.g. 'GL Policy #POL-12345 (Hartford)'")
 });
-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 LookupFillResultSchema = import_zod34.z.object({
+  fills: import_zod34.z.array(LookupFillSchema),
+  unfillable: import_zod34.z.array(import_zod34.z.string()),
+  explanation: import_zod34.z.string().optional()
 });
-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 FlatPdfPlacementSchema = import_zod34.z.object({
+  fieldId: import_zod34.z.string(),
+  page: import_zod34.z.number(),
+  x: import_zod34.z.number().describe("Percentage from left edge (0-100)"),
+  y: import_zod34.z.number().describe("Percentage from top edge (0-100)"),
+  text: import_zod34.z.string(),
+  fontSize: import_zod34.z.number().optional(),
+  isCheckmark: import_zod34.z.boolean().optional()
 });
-var AcroFormMappingSchema = import_zod33.z.object({
-  fieldId: import_zod33.z.string(),
-  acroFormName: import_zod33.z.string(),
-  value: import_zod33.z.string()
+var AcroFormMappingSchema = import_zod34.z.object({
+  fieldId: import_zod34.z.string(),
+  acroFormName: import_zod34.z.string(),
+  value: import_zod34.z.string()
 });
-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(),
+var QualityGateStatusSchema = import_zod34.z.enum(["passed", "warning", "failed"]);
+var QualitySeveritySchema = import_zod34.z.enum(["info", "warning", "blocking"]);
+var ApplicationQualityIssueSchema = import_zod34.z.object({
+  code: import_zod34.z.string(),
   severity: QualitySeveritySchema,
-  message: import_zod33.z.string(),
-  fieldId: import_zod33.z.string().optional()
+  message: import_zod34.z.string(),
+  fieldId: import_zod34.z.string().optional()
 });
-var ApplicationQualityRoundSchema = import_zod33.z.object({
-  round: import_zod33.z.number(),
-  kind: import_zod33.z.string(),
+var ApplicationQualityRoundSchema = import_zod34.z.object({
+  round: import_zod34.z.number(),
+  kind: import_zod34.z.string(),
   status: QualityGateStatusSchema,
-  summary: import_zod33.z.string().optional()
+  summary: import_zod34.z.string().optional()
 });
-var ApplicationQualityArtifactSchema = import_zod33.z.object({
-  kind: import_zod33.z.string(),
-  label: import_zod33.z.string().optional(),
-  itemCount: import_zod33.z.number().optional()
+var ApplicationQualityArtifactSchema = import_zod34.z.object({
+  kind: import_zod34.z.string(),
+  label: import_zod34.z.string().optional(),
+  itemCount: import_zod34.z.number().optional()
 });
-var ApplicationEmailReviewSchema = import_zod33.z.object({
-  issues: import_zod33.z.array(ApplicationQualityIssueSchema),
+var ApplicationEmailReviewSchema = import_zod34.z.object({
+  issues: import_zod34.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(),
+var ApplicationQualityReportSchema = import_zod34.z.object({
+  issues: import_zod34.z.array(ApplicationQualityIssueSchema),
+  rounds: import_zod34.z.array(ApplicationQualityRoundSchema).optional(),
+  artifacts: import_zod34.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),
+var ApplicationStateSchema = import_zod34.z.object({
+  id: import_zod34.z.string(),
+  pdfBase64: import_zod34.z.string().optional().describe("Original PDF, omitted after extraction"),
+  title: import_zod34.z.string().optional(),
+  applicationType: import_zod34.z.string().nullable().optional(),
+  fields: import_zod34.z.array(ApplicationFieldSchema),
+  batches: import_zod34.z.array(import_zod34.z.array(import_zod34.z.string())).optional(),
+  currentBatchIndex: import_zod34.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()
+  status: import_zod34.z.enum(["classifying", "extracting", "auto_filling", "batching", "collecting", "confirming", "mapping", "complete"]),
+  createdAt: import_zod34.z.number(),
+  updatedAt: import_zod34.z.number()
 });
 
 // src/application/agents/classifier.ts
@@ -6160,73 +6638,73 @@ Respond with the final answer, deduplicated citations array, overall confidence
 }
 
 // src/schemas/query.ts
-var import_zod34 = require("zod");
-var QueryIntentSchema = import_zod34.z.enum([
+var import_zod35 = require("zod");
+var QueryIntentSchema = import_zod35.z.enum([
   "policy_question",
   "coverage_comparison",
   "document_search",
   "claims_inquiry",
   "general_knowledge"
 ]);
-var SubQuestionSchema = import_zod34.z.object({
-  question: import_zod34.z.string().describe("Atomic sub-question to retrieve and answer independently"),
+var SubQuestionSchema = import_zod35.z.object({
+  question: import_zod35.z.string().describe("Atomic sub-question to retrieve and answer independently"),
   intent: QueryIntentSchema,
-  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()
+  chunkTypes: import_zod35.z.array(import_zod35.z.string()).optional().describe("Chunk types to filter retrieval (e.g. coverage, endorsement, declaration)"),
+  documentFilters: import_zod35.z.object({
+    type: import_zod35.z.enum(["policy", "quote"]).optional(),
+    carrier: import_zod35.z.string().optional(),
+    insuredName: import_zod35.z.string().optional(),
+    policyNumber: import_zod35.z.string().optional(),
+    quoteNumber: import_zod35.z.string().optional()
   }).optional().describe("Structured filters to narrow document lookup")
 });
-var QueryClassifyResultSchema = import_zod34.z.object({
+var QueryClassifyResultSchema = import_zod35.z.object({
   intent: QueryIntentSchema,
-  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")
+  subQuestions: import_zod35.z.array(SubQuestionSchema).min(1).describe("Decomposed atomic sub-questions"),
+  requiresDocumentLookup: import_zod35.z.boolean().describe("Whether structured document lookup is needed"),
+  requiresChunkSearch: import_zod35.z.boolean().describe("Whether semantic chunk search is needed"),
+  requiresConversationHistory: import_zod35.z.boolean().describe("Whether conversation history is relevant")
 });
-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 EvidenceItemSchema = import_zod35.z.object({
+  source: import_zod35.z.enum(["chunk", "document", "conversation"]),
+  chunkId: import_zod35.z.string().optional(),
+  documentId: import_zod35.z.string().optional(),
+  turnId: import_zod35.z.string().optional(),
+  text: import_zod35.z.string().describe("Text excerpt from the source"),
+  relevance: import_zod35.z.number().min(0).max(1),
+  metadata: import_zod35.z.array(import_zod35.z.object({ key: import_zod35.z.string(), value: import_zod35.z.string() })).optional()
 });
-var RetrievalResultSchema = import_zod34.z.object({
-  subQuestion: import_zod34.z.string(),
-  evidence: import_zod34.z.array(EvidenceItemSchema)
+var RetrievalResultSchema = import_zod35.z.object({
+  subQuestion: import_zod35.z.string(),
+  evidence: import_zod35.z.array(EvidenceItemSchema)
 });
-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 CitationSchema = import_zod35.z.object({
+  index: import_zod35.z.number().describe("Citation number [1], [2], etc."),
+  chunkId: import_zod35.z.string().describe("Source chunk ID, e.g. doc-123:coverage:2"),
+  documentId: import_zod35.z.string(),
+  documentType: import_zod35.z.enum(["policy", "quote"]).optional(),
+  field: import_zod35.z.string().optional().describe("Specific field path, e.g. coverages[0].deductible"),
+  quote: import_zod35.z.string().describe("Exact text from source that supports the claim"),
+  relevance: import_zod35.z.number().min(0).max(1)
 });
-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 SubAnswerSchema = import_zod35.z.object({
+  subQuestion: import_zod35.z.string(),
+  answer: import_zod35.z.string(),
+  citations: import_zod35.z.array(CitationSchema),
+  confidence: import_zod35.z.number().min(0).max(1),
+  needsMoreContext: import_zod35.z.boolean().describe("True if evidence was insufficient to answer fully")
 });
-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 VerifyResultSchema = import_zod35.z.object({
+  approved: import_zod35.z.boolean().describe("Whether all sub-answers are adequately grounded"),
+  issues: import_zod35.z.array(import_zod35.z.string()).describe("Specific grounding or consistency issues found"),
+  retrySubQuestions: import_zod35.z.array(import_zod35.z.string()).optional().describe("Sub-questions that need additional retrieval or re-reasoning")
 });
-var QueryResultSchema = import_zod34.z.object({
-  answer: import_zod34.z.string(),
-  citations: import_zod34.z.array(CitationSchema),
+var QueryResultSchema = import_zod35.z.object({
+  answer: import_zod35.z.string(),
+  citations: import_zod35.z.array(CitationSchema),
   intent: QueryIntentSchema,
-  confidence: import_zod34.z.number().min(0).max(1),
-  followUp: import_zod34.z.string().optional().describe("Suggested follow-up question if applicable")
+  confidence: import_zod35.z.number().min(0).max(1),
+  followUp: import_zod35.z.string().optional().describe("Suggested follow-up question if applicable")
 });
 
 // src/query/retriever.ts