@claritylabs/cl-sdk 3.2.13 → 4.0.1

package/dist/index.js

@@ -30,10 +30,13 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
+  ACORD_LOB_CODES: () => ACORD_LOB_CODES,
+  ACORD_LOB_LABELS: () => ACORD_LOB_LABELS,
   ADMITTED_STATUSES: () => ADMITTED_STATUSES,
   AGENT_TOOLS: () => AGENT_TOOLS,
   APPLICATION_CLASSIFY_PROMPT: () => APPLICATION_CLASSIFY_PROMPT,
   AUDIT_TYPES: () => AUDIT_TYPES,
+  AcordLobCodeSchema: () => AcordLobCodeSchema,
   AcroFormMappingSchema: () => AcroFormMappingSchema,
   AddressSchema: () => AddressSchema,
   AdmittedStatusSchema: () => AdmittedStatusSchema,
@@ -126,6 +129,7 @@ __export(src_exports, {
   ENDORSEMENT_PARTY_ROLES: () => ENDORSEMENT_PARTY_ROLES,
   ENDORSEMENT_TYPES: () => ENDORSEMENT_TYPES,
   ENTITY_TYPES: () => ENTITY_TYPES,
+  EXCLUDED_ACORD_LOB_CODES: () => EXCLUDED_ACORD_LOB_CODES,
   EarthquakeDeclarationsSchema: () => EarthquakeDeclarationsSchema,
   EmployersLiabilityLimitsSchema: () => EmployersLiabilityLimitsSchema,
   EndorsementPartyRoleSchema: () => EndorsementPartyRoleSchema,
@@ -159,6 +163,7 @@ __export(src_exports, {
   InsuredLocationSchema: () => InsuredLocationSchema,
   InsuredVehicleSchema: () => InsuredVehicleSchema,
   InsurerInfoSchema: () => InsurerInfoSchema,
+  LEGACY_POLICY_TYPE_TO_LOB: () => LEGACY_POLICY_TYPE_TO_LOB,
   LIMIT_TYPES: () => LIMIT_TYPES,
   LOSS_SETTLEMENTS: () => LOSS_SETTLEMENTS,
   LimitScheduleSchema: () => LimitScheduleSchema,
@@ -177,11 +182,11 @@ __export(src_exports, {
   OperationalEndorsementSupportSchema: () => OperationalEndorsementSupportSchema,
   OperationalPartySchema: () => OperationalPartySchema,
   PERSONAL_AUTO_USAGES: () => PERSONAL_AUTO_USAGES,
+  PERSONAL_LOB_CODES: () => PERSONAL_LOB_CODES,
   PET_SPECIES: () => PET_SPECIES,
   PLATFORM_CONFIGS: () => PLATFORM_CONFIGS,
   POLICY_SECTION_TYPES: () => POLICY_SECTION_TYPES,
   POLICY_TERM_TYPES: () => POLICY_TERM_TYPES,
-  POLICY_TYPES: () => POLICY_TYPES,
   ParsedAnswerSchema: () => ParsedAnswerSchema,
   PaymentInstallmentSchema: () => PaymentInstallmentSchema,
   PaymentPlanSchema: () => PaymentPlanSchema,
@@ -208,7 +213,6 @@ __export(src_exports, {
   PolicyOperationalProfileSchema: () => PolicyOperationalProfileSchema,
   PolicySectionTypeSchema: () => PolicySectionTypeSchema,
   PolicyTermTypeSchema: () => PolicyTermTypeSchema,
-  PolicyTypeSchema: () => PolicyTypeSchema,
   PremiumLineSchema: () => PremiumLineSchema,
   ProducerInfoSchema: () => ProducerInfoSchema,
   ProfessionalLiabilityDeclarationsSchema: () => ProfessionalLiabilityDeclarationsSchema,
@@ -337,16 +341,19 @@ __export(src_exports, {
   getNextApplicationQuestions: () => getNextApplicationQuestions,
   getPdfPageCount: () => getPdfPageCount,
   getTemplate: () => getTemplate,
-  inferPolicyTypesFromOperationalCoverages: () => inferPolicyTypesFromOperationalCoverages,
+  inferLinesOfBusinessFromOperationalCoverages: () => inferLinesOfBusinessFromOperationalCoverages,
   isDoclingExtractionInput: () => isDoclingExtractionInput,
   isFileReference: () => isFileReference,
+  isLobCode: () => isLobCode,
+  isPersonalLob: () => isPersonalLob,
+  lobLabel: () => lobLabel,
   mergeQuestionAnswers: () => mergeQuestionAnswers,
   mergeSourceSpans: () => mergeSourceSpans,
   normalizeApplicationQuestionGraph: () => normalizeApplicationQuestionGraph,
   normalizeDoclingDocument: () => normalizeDoclingDocument,
   normalizeDocumentSourceTreePaths: () => normalizeDocumentSourceTreePaths,
   normalizeForMatch: () => normalizeForMatch,
-  normalizeOperationalPolicyTypes: () => normalizeOperationalPolicyTypes,
+  normalizeOperationalLinesOfBusiness: () => normalizeOperationalLinesOfBusiness,
   normalizeSourceSpans: () => normalizeSourceSpans,
   orderSourceEvidence: () => orderSourceEvidence,
   overlayTextOnPdf: () => overlayTextOnPdf,
@@ -357,7 +364,7 @@ __export(src_exports, {
   processReply: () => processReply,
   proposeContextWrites: () => proposeContextWrites,
   resolveModelBudget: () => resolveModelBudget,
-  resolveOperationalProfilePolicyTypes: () => resolveOperationalProfilePolicyTypes,
+  resolveOperationalProfileLinesOfBusiness: () => resolveOperationalProfileLinesOfBusiness,
   safeGenerateObject: () => safeGenerateObject,
   sanitizeNulls: () => sanitizeNulls,
   scoreCaseProposal: () => scoreCaseProposal,
@@ -368,6 +375,7 @@ __export(src_exports, {
   stablePolicyChangeItemId: () => stablePolicyChangeItemId,
   stableStringify: () => stableStringify,
   stripFences: () => stripFences,
+  toLobCodes: () => toLobCodes,
   toStrictSchema: () => toStrictSchema,
   validateApplicationPacket: () => validateApplicationPacket,
   validateEvidence: () => validateEvidence,
@@ -673,57 +681,6 @@ function expectedOutputTokensFloor(taskKind, schemaTokens, expectedListLength, h
 
 // src/schemas/enums.ts
 var import_zod2 = require("zod");
-var PolicyTypeSchema = import_zod2.z.enum([
-  // Commercial lines
-  "general_liability",
-  "commercial_property",
-  "commercial_auto",
-  "non_owned_auto",
-  "workers_comp",
-  "umbrella",
-  "excess_liability",
-  "professional_liability",
-  "cyber",
-  "epli",
-  "directors_officers",
-  "fiduciary_liability",
-  "crime_fidelity",
-  "inland_marine",
-  "builders_risk",
-  "environmental",
-  "ocean_marine",
-  "surety",
-  "product_liability",
-  "bop",
-  "management_liability_package",
-  "property",
-  // Personal lines
-  "homeowners_ho3",
-  "homeowners_ho5",
-  "renters_ho4",
-  "condo_ho6",
-  "dwelling_fire",
-  "mobile_home",
-  "personal_auto",
-  "personal_umbrella",
-  "flood_nfip",
-  "flood_private",
-  "earthquake",
-  "personal_inland_marine",
-  "watercraft",
-  "recreational_vehicle",
-  "farm_ranch",
-  "life",
-  "critical_illness",
-  "disability",
-  "long_term_care",
-  "pet",
-  "travel",
-  "identity_theft",
-  "title",
-  "other"
-]);
-var POLICY_TYPES = PolicyTypeSchema.options;
 var EndorsementTypeSchema = import_zod2.z.enum([
   "additional_insured",
   "waiver_of_subrogation",
@@ -944,85 +901,419 @@ var TITLE_POLICY_TYPES = TitlePolicyTypeSchema.options;
 var PetSpeciesSchema = import_zod2.z.enum(["dog", "cat", "other"]);
 var PET_SPECIES = PetSpeciesSchema.options;
 
-// src/schemas/shared.ts
+// src/schemas/lines-of-business.ts
 var import_zod3 = require("zod");
-var SourceProvenanceSchema = import_zod3.z.object({
-  sourceSpanIds: import_zod3.z.array(import_zod3.z.string().min(1)).min(1),
-  documentNodeId: import_zod3.z.string().optional(),
-  sourceTextHash: import_zod3.z.string().optional(),
-  pageStart: import_zod3.z.number().int().positive().optional(),
-  pageEnd: import_zod3.z.number().int().positive().optional()
-});
-var AddressSchema = import_zod3.z.object({
-  street1: import_zod3.z.string(),
-  street2: import_zod3.z.string().optional(),
-  city: import_zod3.z.string(),
-  state: import_zod3.z.string(),
-  zip: import_zod3.z.string(),
-  country: import_zod3.z.string().optional()
+var ACORD_LOB_CODES = [
+  "AAPPL",
+  "AGLIA",
+  "AGPP",
+  "AGPR",
+  "AIRC",
+  "AIRPFB",
+  "APKG",
+  "APKGE",
+  "APROD",
+  "ARVP",
+  "AUTO",
+  "AUTOB",
+  "AUTOP",
+  "AVPKG",
+  "BANDM",
+  "BLANK",
+  "BMISC",
+  "BOAT",
+  "BOP",
+  "BOPGL",
+  "BOPPR",
+  "CAVN",
+  "CEQFL",
+  "CFIRE",
+  "CFRM",
+  "CGL",
+  "COMAR",
+  "COMR",
+  "CONTR",
+  "CPKGE",
+  "CPMP",
+  "CRIME",
+  "DFIRE",
+  "DISAB",
+  "DO",
+  "EDP",
+  "EL",
+  "EO",
+  "EPLI",
+  "EQ",
+  "EQPFL",
+  "EXLIA",
+  "FIDTY",
+  "FIDUC",
+  "FINEA",
+  "FLOOD",
+  "GARAG",
+  "GL",
+  "GLASS",
+  "HANG",
+  "HBB",
+  "HOME",
+  "INBR",
+  "INMAR",
+  "INMRC",
+  "INMRP",
+  "JUDCL",
+  "KIDRA",
+  "LL",
+  "MHOME",
+  "MMAL",
+  "Motorcycle",
+  "MTRTK",
+  "OLIB",
+  "PHYS",
+  "PKG",
+  "PL",
+  "PLMSC",
+  "PPKGE",
+  "PROP",
+  "PROPC",
+  "PUBOF",
+  "RECV",
+  "SCHPR",
+  "SIGNS",
+  "SMP",
+  "SURE",
+  "TRANS",
+  "TRUCK",
+  "UMBRC",
+  "UMBRL",
+  "UMBRP",
+  "UN",
+  "WCMA",
+  "WIND",
+  "WORK",
+  "WORKP",
+  "WORKV"
+];
+var AcordLobCodeSchema = import_zod3.z.enum(ACORD_LOB_CODES);
+var ACORD_LOB_LABELS = {
+  AAPPL: "Aircraft / Aerial Applicator",
+  AGLIA: "Agricultural Liability",
+  AGPP: "Agricultural Personal Property",
+  AGPR: "Agricultural Property",
+  AIRC: "Aircraft",
+  AIRPFB: "Airport / Fixed Base Operator",
+  APKG: "Agricultural Package",
+  APKGE: "Agricultural Package (Extended)",
+  APROD: "Agricultural Products",
+  ARVP: "Recreational Vehicle Package",
+  AUTO: "Automobile",
+  AUTOB: "Business Auto",
+  AUTOP: "Personal Auto",
+  AVPKG: "Aviation Package",
+  BANDM: "Boiler & Machinery",
+  BLANK: "Blanket",
+  BMISC: "Business Miscellaneous",
+  BOAT: "Boat",
+  BOP: "Businessowners Policy",
+  BOPGL: "BOP - General Liability",
+  BOPPR: "BOP - Property",
+  CAVN: "Commercial Aviation",
+  CEQFL: "Contractors Equipment Floater",
+  CFIRE: "Commercial Fire",
+  CFRM: "Commercial Farm",
+  CGL: "Commercial General Liability",
+  COMAR: "Commercial Marine / Ocean Marine",
+  COMR: "Commercial (misc.)",
+  CONTR: "Contractors",
+  CPKGE: "Commercial Package",
+  CPMP: "Commercial Package (multi-peril)",
+  CRIME: "Crime",
+  DFIRE: "Dwelling Fire",
+  DISAB: "Disability",
+  DO: "Directors & Officers Liability",
+  EDP: "Electronic Data Processing",
+  EL: "Employers Liability",
+  EO: "Errors & Omissions",
+  EPLI: "Employment Practices Liability",
+  EQ: "Earthquake",
+  EQPFL: "Equipment Floater",
+  EXLIA: "Excess Liability",
+  FIDTY: "Fidelity",
+  FIDUC: "Fiduciary Liability",
+  FINEA: "Fine Arts",
+  FLOOD: "Flood",
+  GARAG: "Garage",
+  GL: "General Liability",
+  GLASS: "Glass",
+  HANG: "Hangar (Aviation)",
+  HBB: "Home-Based Business",
+  HOME: "Homeowners",
+  INBR: "Inland Marine - Brokers",
+  INMAR: "Inland Marine",
+  INMRC: "Inland Marine - Commercial",
+  INMRP: "Inland Marine - Personal",
+  JUDCL: "Judicial Bonds",
+  KIDRA: "Kidnap & Ransom",
+  LL: "Liquor Liability",
+  MHOME: "Mobile Home",
+  MMAL: "Medical Malpractice",
+  Motorcycle: "Motorcycle",
+  MTRTK: "Motor Truck Cargo",
+  OLIB: "Other Liability",
+  PHYS: "Physical Damage",
+  PKG: "Package",
+  PL: "Professional Liability",
+  PLMSC: "Personal Lines Miscellaneous",
+  PPKGE: "Personal Package",
+  PROP: "Property",
+  PROPC: "Property - Commercial",
+  PUBOF: "Public Officials Liability",
+  RECV: "Recreational Vehicle",
+  SCHPR: "Scheduled Property",
+  SIGNS: "Signs",
+  SMP: "Special Multi-Peril",
+  SURE: "Surety",
+  TRANS: "Transportation",
+  TRUCK: "Trucking",
+  UMBRC: "Umbrella - Commercial",
+  UMBRL: "Umbrella",
+  UMBRP: "Umbrella - Personal",
+  UN: "Unspecified / Unknown",
+  WCMA: "Workers Comp - Monopolistic/State",
+  WIND: "Wind",
+  WORK: "Workers Compensation",
+  WORKP: "Workers Compensation (Personal/Package)",
+  WORKV: "Workers Compensation (Voluntary)"
+};
+var EXCLUDED_ACORD_LOB_CODES = /* @__PURE__ */ new Set([
+  "ACHE",
+  "INTER",
+  "LICPT",
+  "LSTIN",
+  "NWFGR",
+  "PAPER",
+  "SCAP",
+  "SFRNC"
+]);
+var LEGACY_POLICY_TYPE_TO_LOB = {
+  general_liability: ["CGL"],
+  commercial_property: ["PROPC"],
+  commercial_auto: ["AUTOB"],
+  non_owned_auto: ["AUTOB"],
+  workers_comp: ["WORK"],
+  umbrella: ["UMBRC"],
+  excess_liability: ["EXLIA"],
+  professional_liability: ["EO"],
+  cyber: ["OLIB"],
+  epli: ["EPLI"],
+  directors_officers: ["DO"],
+  fiduciary_liability: ["FIDUC"],
+  crime_fidelity: ["CRIME"],
+  inland_marine: ["INMRC"],
+  builders_risk: ["INMRC"],
+  environmental: ["OLIB"],
+  ocean_marine: ["COMAR"],
+  surety: ["SURE"],
+  product_liability: ["OLIB"],
+  bop: ["BOP"],
+  management_liability_package: ["DO", "EPLI", "FIDUC"],
+  property: ["PROP"],
+  homeowners_ho3: ["HOME"],
+  homeowners_ho5: ["HOME"],
+  renters_ho4: ["HOME"],
+  condo_ho6: ["HOME"],
+  dwelling_fire: ["DFIRE"],
+  mobile_home: ["MHOME"],
+  personal_auto: ["AUTOP"],
+  personal_umbrella: ["UMBRP"],
+  flood_nfip: ["FLOOD"],
+  flood_private: ["FLOOD"],
+  earthquake: ["EQ"],
+  personal_inland_marine: ["INMRP"],
+  watercraft: ["BOAT"],
+  recreational_vehicle: ["RECV"],
+  farm_ranch: ["CFRM"],
+  life: ["UN"],
+  critical_illness: ["DISAB"],
+  disability: ["DISAB"],
+  long_term_care: ["UN"],
+  pet: ["UN"],
+  travel: ["UN"],
+  identity_theft: ["UN"],
+  title: ["UN"],
+  other: ["UN"],
+  unknown: ["UN"],
+  auto: ["AUTOB"],
+  crime: ["CRIME"],
+  crim: ["CRIME"],
+  fiduciary: ["FIDUC"],
+  d_and_o: ["DO"],
+  d_o: ["DO"],
+  homeowners: ["HOME"],
+  renters: ["HOME"],
+  flood: ["FLOOD"],
+  boat: ["BOAT"],
+  motorcycle: ["Motorcycle"]
+};
+var PERSONAL_LOB_CODES = /* @__PURE__ */ new Set([
+  "AUTOP",
+  "HOME",
+  "MHOME",
+  "DFIRE",
+  "FLOOD",
+  "EQ",
+  "INMRP",
+  "UMBRP",
+  "BOAT",
+  "RECV",
+  "Motorcycle",
+  "PPKGE",
+  "DISAB",
+  "PLMSC",
+  "HBB"
+]);
+function hasOwn(object, key) {
+  return Object.prototype.hasOwnProperty.call(object, key);
+}
+function canonicalLegacyKey(value) {
+  return value.trim().toLowerCase().replace(/&/g, " and ").replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "").replace(/_+/g, "_");
+}
+function humanize(value) {
+  return value.trim().replace(/[_-]+/g, " ").replace(/\b\w/g, (char) => char.toUpperCase());
+}
+function isLobCode(value) {
+  return typeof value === "string" && hasOwn(ACORD_LOB_LABELS, value);
+}
+function resolveLobCode(value) {
+  const trimmed = value.trim();
+  if (!trimmed) return void 0;
+  if (isLobCode(trimmed)) return trimmed;
+  if (trimmed.toLowerCase() === "motorcycle") return "Motorcycle";
+  const legacy = LEGACY_POLICY_TYPE_TO_LOB[canonicalLegacyKey(trimmed)];
+  if (legacy?.[0]) return legacy[0];
+  const upper = trimmed.toUpperCase();
+  if (upper === "CRIM") return "CRIME";
+  if (isLobCode(upper)) return upper;
+  return void 0;
+}
+function normalizeOperationalLinesOfBusiness(values) {
+  const source = Array.isArray(values) ? values.filter((value) => typeof value === "string" && value.trim().length > 0) : [];
+  return toLobCodes(source);
+}
+function toLobCodes(values) {
+  const source = values?.filter((value) => typeof value === "string" && value.trim()) ?? [];
+  if (source.length === 0) return ["UN"];
+  const codes = [];
+  for (const value of source) {
+    const trimmed = value.trim();
+    if (isLobCode(trimmed)) {
+      codes.push(trimmed);
+      continue;
+    }
+    if (trimmed.toUpperCase() === "CRIM") {
+      codes.push("CRIME");
+      continue;
+    }
+    const mapped = LEGACY_POLICY_TYPE_TO_LOB[canonicalLegacyKey(trimmed)];
+    if (mapped) {
+      codes.push(...mapped);
+      continue;
+    }
+    const upper = trimmed.toUpperCase();
+    if (isLobCode(upper)) {
+      codes.push(upper);
+      continue;
+    }
+    codes.push("UN");
+  }
+  return Array.from(new Set(codes));
+}
+function lobLabel(value) {
+  const code = resolveLobCode(value);
+  return code ? ACORD_LOB_LABELS[code] : humanize(value);
+}
+function isPersonalLob(code) {
+  return isLobCode(code) && PERSONAL_LOB_CODES.has(code);
+}
+
+// src/schemas/shared.ts
+var import_zod4 = require("zod");
+var SourceProvenanceSchema = import_zod4.z.object({
+  sourceSpanIds: import_zod4.z.array(import_zod4.z.string().min(1)).min(1),
+  documentNodeId: import_zod4.z.string().optional(),
+  sourceTextHash: import_zod4.z.string().optional(),
+  pageStart: import_zod4.z.number().int().positive().optional(),
+  pageEnd: import_zod4.z.number().int().positive().optional()
+});
+var AddressSchema = import_zod4.z.object({
+  street1: import_zod4.z.string(),
+  street2: import_zod4.z.string().optional(),
+  city: import_zod4.z.string(),
+  state: import_zod4.z.string(),
+  zip: import_zod4.z.string(),
+  country: import_zod4.z.string().optional()
 });
 var SourceBackedAddressSchema = AddressSchema.merge(SourceProvenanceSchema);
-var ContactSchema = import_zod3.z.object({
-  name: import_zod3.z.string().optional(),
-  title: import_zod3.z.string().optional(),
-  type: import_zod3.z.string().optional(),
-  phone: import_zod3.z.string().optional(),
-  fax: import_zod3.z.string().optional(),
-  email: import_zod3.z.string().optional(),
+var ContactSchema = import_zod4.z.object({
+  name: import_zod4.z.string().optional(),
+  title: import_zod4.z.string().optional(),
+  type: import_zod4.z.string().optional(),
+  phone: import_zod4.z.string().optional(),
+  fax: import_zod4.z.string().optional(),
+  email: import_zod4.z.string().optional(),
   address: AddressSchema.optional(),
-  hours: import_zod3.z.string().optional()
+  hours: import_zod4.z.string().optional()
 }).merge(SourceProvenanceSchema);
-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"]),
-  pageStart: import_zod3.z.number().optional(),
-  pageEnd: import_zod3.z.number().optional(),
-  documentNodeId: import_zod3.z.string().optional(),
-  sourceSpanIds: import_zod3.z.array(import_zod3.z.string()).optional(),
-  sourceTextHash: import_zod3.z.string().optional()
-});
-var TaxFeeItemSchema = import_zod3.z.object({
-  name: import_zod3.z.string(),
-  amount: import_zod3.z.string(),
-  amountValue: import_zod3.z.number().optional(),
-  type: import_zod3.z.enum(["tax", "fee", "surcharge", "assessment"]).optional(),
-  description: import_zod3.z.string().optional(),
-  documentNodeId: import_zod3.z.string().optional(),
-  sourceSpanIds: import_zod3.z.array(import_zod3.z.string()).optional(),
-  sourceTextHash: import_zod3.z.string().optional()
-});
-var RatingBasisSchema = import_zod3.z.object({
+var FormReferenceSchema = import_zod4.z.object({
+  formNumber: import_zod4.z.string(),
+  editionDate: import_zod4.z.string().optional(),
+  title: import_zod4.z.string().optional(),
+  formType: import_zod4.z.enum(["coverage", "endorsement", "declarations", "application", "notice", "other"]),
+  pageStart: import_zod4.z.number().optional(),
+  pageEnd: import_zod4.z.number().optional(),
+  documentNodeId: import_zod4.z.string().optional(),
+  sourceSpanIds: import_zod4.z.array(import_zod4.z.string()).optional(),
+  sourceTextHash: import_zod4.z.string().optional()
+});
+var TaxFeeItemSchema = import_zod4.z.object({
+  name: import_zod4.z.string(),
+  amount: import_zod4.z.string(),
+  amountValue: import_zod4.z.number().optional(),
+  type: import_zod4.z.enum(["tax", "fee", "surcharge", "assessment"]).optional(),
+  description: import_zod4.z.string().optional(),
+  documentNodeId: import_zod4.z.string().optional(),
+  sourceSpanIds: import_zod4.z.array(import_zod4.z.string()).optional(),
+  sourceTextHash: import_zod4.z.string().optional()
+});
+var RatingBasisSchema = import_zod4.z.object({
   type: RatingBasisTypeSchema,
-  amount: import_zod3.z.string().optional(),
-  description: import_zod3.z.string().optional()
-});
-var SublimitSchema = import_zod3.z.object({
-  name: import_zod3.z.string(),
-  limit: import_zod3.z.string(),
-  appliesTo: import_zod3.z.string().optional(),
-  deductible: import_zod3.z.string().optional()
-});
-var SharedLimitSchema = import_zod3.z.object({
-  description: import_zod3.z.string(),
-  limit: import_zod3.z.string(),
-  coverageParts: import_zod3.z.array(import_zod3.z.string())
-});
-var ExtendedReportingPeriodSchema = import_zod3.z.object({
-  basicDays: import_zod3.z.number().optional(),
-  supplementalYears: import_zod3.z.number().optional(),
-  supplementalPremium: import_zod3.z.string().optional()
-});
-var NamedInsuredSchema = import_zod3.z.object({
-  name: import_zod3.z.string(),
-  relationship: import_zod3.z.string().optional(),
+  amount: import_zod4.z.string().optional(),
+  description: import_zod4.z.string().optional()
+});
+var SublimitSchema = import_zod4.z.object({
+  name: import_zod4.z.string(),
+  limit: import_zod4.z.string(),
+  appliesTo: import_zod4.z.string().optional(),
+  deductible: import_zod4.z.string().optional()
+});
+var SharedLimitSchema = import_zod4.z.object({
+  description: import_zod4.z.string(),
+  limit: import_zod4.z.string(),
+  coverageParts: import_zod4.z.array(import_zod4.z.string())
+});
+var ExtendedReportingPeriodSchema = import_zod4.z.object({
+  basicDays: import_zod4.z.number().optional(),
+  supplementalYears: import_zod4.z.number().optional(),
+  supplementalPremium: import_zod4.z.string().optional()
+});
+var NamedInsuredSchema = import_zod4.z.object({
+  name: import_zod4.z.string(),
+  relationship: import_zod4.z.string().optional(),
   address: AddressSchema.optional()
 }).merge(SourceProvenanceSchema);
 
 // src/schemas/coverage.ts
-var import_zod4 = require("zod");
-var CoverageValueTypeSchema = import_zod4.z.enum([
+var import_zod5 = require("zod");
+var CoverageValueTypeSchema = import_zod5.z.enum([
   "numeric",
   "included",
   "not_included",
@@ -1031,116 +1322,98 @@ var CoverageValueTypeSchema = import_zod4.z.enum([
   "referential",
   "other"
 ]);
-var CoverageSchema = import_zod4.z.object({
-  name: import_zod4.z.string(),
-  limit: import_zod4.z.string(),
-  limitAmount: import_zod4.z.number().optional(),
+var CoverageSchema = import_zod5.z.object({
+  name: import_zod5.z.string(),
+  limit: import_zod5.z.string(),
+  limitAmount: import_zod5.z.number().optional(),
   limitType: LimitTypeSchema.optional(),
   limitValueType: CoverageValueTypeSchema.optional(),
-  deductible: import_zod4.z.string().optional(),
-  deductibleAmount: import_zod4.z.number().optional(),
+  deductible: import_zod5.z.string().optional(),
+  deductibleAmount: import_zod5.z.number().optional(),
   deductibleValueType: CoverageValueTypeSchema.optional(),
   trigger: CoverageTriggerSchema.optional(),
-  retroactiveDate: import_zod4.z.string().optional(),
-  formNumber: import_zod4.z.string().optional(),
-  pageNumber: import_zod4.z.number().optional(),
-  sectionRef: import_zod4.z.string().optional(),
-  originalContent: import_zod4.z.string().optional(),
-  recordId: import_zod4.z.string().optional(),
-  documentNodeId: import_zod4.z.string().optional(),
-  sourceSpanIds: import_zod4.z.array(import_zod4.z.string()).optional(),
-  sourceTextHash: import_zod4.z.string().optional()
+  retroactiveDate: import_zod5.z.string().optional(),
+  formNumber: import_zod5.z.string().optional(),
+  pageNumber: import_zod5.z.number().optional(),
+  sectionRef: import_zod5.z.string().optional(),
+  originalContent: import_zod5.z.string().optional(),
+  recordId: import_zod5.z.string().optional(),
+  documentNodeId: import_zod5.z.string().optional(),
+  sourceSpanIds: import_zod5.z.array(import_zod5.z.string()).optional(),
+  sourceTextHash: import_zod5.z.string().optional()
 });
-var EnrichedCoverageSchema = import_zod4.z.object({
-  name: import_zod4.z.string(),
-  coverageCode: import_zod4.z.string().optional(),
-  formNumber: import_zod4.z.string().optional(),
-  formEditionDate: import_zod4.z.string().optional(),
-  limit: import_zod4.z.string(),
-  limitAmount: import_zod4.z.number().optional(),
+var EnrichedCoverageSchema = import_zod5.z.object({
+  name: import_zod5.z.string(),
+  coverageCode: import_zod5.z.string().optional(),
+  formNumber: import_zod5.z.string().optional(),
+  formEditionDate: import_zod5.z.string().optional(),
+  limit: import_zod5.z.string(),
+  limitAmount: import_zod5.z.number().optional(),
   limitType: LimitTypeSchema.optional(),
   limitValueType: CoverageValueTypeSchema.optional(),
-  deductible: import_zod4.z.string().optional(),
-  deductibleAmount: import_zod4.z.number().optional(),
+  deductible: import_zod5.z.string().optional(),
+  deductibleAmount: import_zod5.z.number().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(),
+  sir: import_zod5.z.string().optional(),
+  sublimit: import_zod5.z.string().optional(),
+  coinsurance: import_zod5.z.string().optional(),
   valuation: ValuationMethodSchema.optional(),
-  territory: import_zod4.z.string().optional(),
+  territory: import_zod5.z.string().optional(),
   trigger: CoverageTriggerSchema.optional(),
-  retroactiveDate: import_zod4.z.string().optional(),
-  included: import_zod4.z.boolean(),
-  premium: import_zod4.z.string().optional(),
-  pageNumber: import_zod4.z.number().optional(),
-  sectionRef: import_zod4.z.string().optional(),
-  originalContent: import_zod4.z.string().optional(),
-  recordId: import_zod4.z.string().optional(),
-  documentNodeId: import_zod4.z.string().optional(),
-  sourceSpanIds: import_zod4.z.array(import_zod4.z.string()).optional(),
-  sourceTextHash: import_zod4.z.string().optional()
-});
-
-// src/schemas/endorsement.ts
-var import_zod5 = require("zod");
-var EndorsementPartySchema = import_zod5.z.object({
-  name: import_zod5.z.string(),
-  role: EndorsementPartyRoleSchema,
-  address: AddressSchema.optional(),
-  relationship: import_zod5.z.string().optional(),
-  scope: import_zod5.z.string().optional()
-}).merge(SourceProvenanceSchema);
-var EndorsementSchema = import_zod5.z.object({
-  formNumber: import_zod5.z.string(),
-  editionDate: import_zod5.z.string().optional(),
-  title: import_zod5.z.string(),
-  endorsementType: EndorsementTypeSchema,
-  effectiveDate: import_zod5.z.string().optional(),
-  affectedCoverageParts: import_zod5.z.array(import_zod5.z.string()).optional(),
-  namedParties: import_zod5.z.array(EndorsementPartySchema).optional(),
-  keyTerms: import_zod5.z.array(import_zod5.z.string()).optional(),
-  premiumImpact: import_zod5.z.string().optional(),
-  excerpt: import_zod5.z.string().optional(),
-  content: import_zod5.z.string().optional(),
-  pageStart: import_zod5.z.number(),
-  pageEnd: import_zod5.z.number().optional(),
+  retroactiveDate: import_zod5.z.string().optional(),
+  included: import_zod5.z.boolean(),
+  premium: import_zod5.z.string().optional(),
+  pageNumber: import_zod5.z.number().optional(),
+  sectionRef: import_zod5.z.string().optional(),
+  originalContent: import_zod5.z.string().optional(),
   recordId: import_zod5.z.string().optional(),
   documentNodeId: import_zod5.z.string().optional(),
   sourceSpanIds: import_zod5.z.array(import_zod5.z.string()).optional(),
   sourceTextHash: import_zod5.z.string().optional()
 });
 
-// src/schemas/exclusion.ts
+// src/schemas/endorsement.ts
 var import_zod6 = require("zod");
-var ExclusionSchema = import_zod6.z.object({
+var EndorsementPartySchema = import_zod6.z.object({
   name: import_zod6.z.string(),
-  formNumber: import_zod6.z.string().optional(),
-  excludedPerils: import_zod6.z.array(import_zod6.z.string()).optional(),
-  isAbsolute: import_zod6.z.boolean().optional(),
-  exceptions: import_zod6.z.array(import_zod6.z.string()).optional(),
-  buybackAvailable: import_zod6.z.boolean().optional(),
-  buybackEndorsement: import_zod6.z.string().optional(),
-  appliesTo: import_zod6.z.array(import_zod6.z.string()).optional(),
-  content: import_zod6.z.string(),
-  pageNumber: import_zod6.z.number().optional(),
+  role: EndorsementPartyRoleSchema,
+  address: AddressSchema.optional(),
+  relationship: import_zod6.z.string().optional(),
+  scope: import_zod6.z.string().optional()
+}).merge(SourceProvenanceSchema);
+var EndorsementSchema = import_zod6.z.object({
+  formNumber: import_zod6.z.string(),
+  editionDate: import_zod6.z.string().optional(),
+  title: import_zod6.z.string(),
+  endorsementType: EndorsementTypeSchema,
+  effectiveDate: import_zod6.z.string().optional(),
+  affectedCoverageParts: import_zod6.z.array(import_zod6.z.string()).optional(),
+  namedParties: import_zod6.z.array(EndorsementPartySchema).optional(),
+  keyTerms: import_zod6.z.array(import_zod6.z.string()).optional(),
+  premiumImpact: import_zod6.z.string().optional(),
+  excerpt: import_zod6.z.string().optional(),
+  content: import_zod6.z.string().optional(),
+  pageStart: import_zod6.z.number(),
+  pageEnd: import_zod6.z.number().optional(),
   recordId: import_zod6.z.string().optional(),
   documentNodeId: import_zod6.z.string().optional(),
   sourceSpanIds: import_zod6.z.array(import_zod6.z.string()).optional(),
   sourceTextHash: import_zod6.z.string().optional()
 });
 
-// src/schemas/condition.ts
+// src/schemas/exclusion.ts
 var import_zod7 = require("zod");
-var ConditionKeyValueSchema = import_zod7.z.object({
-  key: import_zod7.z.string(),
-  value: import_zod7.z.string()
-});
-var PolicyConditionSchema = import_zod7.z.object({
+var ExclusionSchema = import_zod7.z.object({
   name: import_zod7.z.string(),
-  conditionType: ConditionTypeSchema,
+  formNumber: import_zod7.z.string().optional(),
+  excludedPerils: import_zod7.z.array(import_zod7.z.string()).optional(),
+  isAbsolute: import_zod7.z.boolean().optional(),
+  exceptions: import_zod7.z.array(import_zod7.z.string()).optional(),
+  buybackAvailable: import_zod7.z.boolean().optional(),
+  buybackEndorsement: import_zod7.z.string().optional(),
+  appliesTo: import_zod7.z.array(import_zod7.z.string()).optional(),
   content: import_zod7.z.string(),
-  keyValues: import_zod7.z.array(ConditionKeyValueSchema).optional(),
   pageNumber: import_zod7.z.number().optional(),
   recordId: import_zod7.z.string().optional(),
   documentNodeId: import_zod7.z.string().optional(),
@@ -1148,543 +1421,561 @@ var PolicyConditionSchema = import_zod7.z.object({
   sourceTextHash: import_zod7.z.string().optional()
 });
 
-// src/schemas/parties.ts
+// src/schemas/condition.ts
 var import_zod8 = require("zod");
-var InsurerInfoSchema = import_zod8.z.object({
-  legalName: import_zod8.z.string(),
-  naicNumber: import_zod8.z.string().optional(),
-  amBestRating: import_zod8.z.string().optional(),
-  amBestNumber: import_zod8.z.string().optional(),
+var ConditionKeyValueSchema = import_zod8.z.object({
+  key: import_zod8.z.string(),
+  value: import_zod8.z.string()
+});
+var PolicyConditionSchema = import_zod8.z.object({
+  name: import_zod8.z.string(),
+  conditionType: ConditionTypeSchema,
+  content: import_zod8.z.string(),
+  keyValues: import_zod8.z.array(ConditionKeyValueSchema).optional(),
+  pageNumber: import_zod8.z.number().optional(),
+  recordId: import_zod8.z.string().optional(),
+  documentNodeId: import_zod8.z.string().optional(),
+  sourceSpanIds: import_zod8.z.array(import_zod8.z.string()).optional(),
+  sourceTextHash: import_zod8.z.string().optional()
+});
+
+// src/schemas/parties.ts
+var import_zod9 = require("zod");
+var InsurerInfoSchema = import_zod9.z.object({
+  legalName: import_zod9.z.string(),
+  naicNumber: import_zod9.z.string().optional(),
+  amBestRating: import_zod9.z.string().optional(),
+  amBestNumber: import_zod9.z.string().optional(),
   admittedStatus: AdmittedStatusSchema.optional(),
-  stateOfDomicile: import_zod8.z.string().optional()
+  stateOfDomicile: import_zod9.z.string().optional()
 }).merge(SourceProvenanceSchema);
-var ProducerInfoSchema = import_zod8.z.object({
-  agencyName: import_zod8.z.string(),
-  contactName: import_zod8.z.string().optional(),
-  licenseNumber: import_zod8.z.string().optional(),
-  phone: import_zod8.z.string().optional(),
-  email: import_zod8.z.string().optional(),
+var ProducerInfoSchema = import_zod9.z.object({
+  agencyName: import_zod9.z.string(),
+  contactName: import_zod9.z.string().optional(),
+  licenseNumber: import_zod9.z.string().optional(),
+  phone: import_zod9.z.string().optional(),
+  email: import_zod9.z.string().optional(),
   address: AddressSchema.optional()
 }).merge(SourceProvenanceSchema);
 
 // src/schemas/financial.ts
-var import_zod9 = require("zod");
-var PaymentInstallmentSchema = import_zod9.z.object({
-  dueDate: import_zod9.z.string(),
-  amount: import_zod9.z.string(),
-  description: import_zod9.z.string().optional()
+var import_zod10 = require("zod");
+var PaymentInstallmentSchema = import_zod10.z.object({
+  dueDate: import_zod10.z.string(),
+  amount: import_zod10.z.string(),
+  description: import_zod10.z.string().optional()
 });
-var PaymentPlanSchema = import_zod9.z.object({
-  installments: import_zod9.z.array(PaymentInstallmentSchema),
-  financeCharge: import_zod9.z.string().optional()
+var PaymentPlanSchema = import_zod10.z.object({
+  installments: import_zod10.z.array(PaymentInstallmentSchema),
+  financeCharge: import_zod10.z.string().optional()
 });
-var LocationPremiumSchema = import_zod9.z.object({
-  locationNumber: import_zod9.z.number(),
-  premium: import_zod9.z.string(),
-  description: import_zod9.z.string().optional()
+var LocationPremiumSchema = import_zod10.z.object({
+  locationNumber: import_zod10.z.number(),
+  premium: import_zod10.z.string(),
+  description: import_zod10.z.string().optional()
 });
 
 // src/schemas/loss-history.ts
-var import_zod10 = require("zod");
-var ClaimRecordSchema = import_zod10.z.object({
-  dateOfLoss: import_zod10.z.string(),
-  claimNumber: import_zod10.z.string().optional(),
-  description: import_zod10.z.string(),
+var import_zod11 = require("zod");
+var ClaimRecordSchema = import_zod11.z.object({
+  dateOfLoss: import_zod11.z.string(),
+  claimNumber: import_zod11.z.string().optional(),
+  description: import_zod11.z.string(),
   status: ClaimStatusSchema,
-  paid: import_zod10.z.string().optional(),
-  reserved: import_zod10.z.string().optional(),
-  incurred: import_zod10.z.string().optional(),
-  claimant: import_zod10.z.string().optional(),
-  coverageLine: import_zod10.z.string().optional()
-});
-var LossSummarySchema = import_zod10.z.object({
-  period: import_zod10.z.string().optional(),
-  totalClaims: import_zod10.z.number().optional(),
-  totalIncurred: import_zod10.z.string().optional(),
-  totalPaid: import_zod10.z.string().optional(),
-  totalReserved: import_zod10.z.string().optional(),
-  lossRatio: import_zod10.z.string().optional()
-});
-var ExperienceModSchema = import_zod10.z.object({
-  factor: import_zod10.z.number(),
-  effectiveDate: import_zod10.z.string().optional(),
-  state: import_zod10.z.string().optional()
+  paid: import_zod11.z.string().optional(),
+  reserved: import_zod11.z.string().optional(),
+  incurred: import_zod11.z.string().optional(),
+  claimant: import_zod11.z.string().optional(),
+  coverageLine: import_zod11.z.string().optional()
+});
+var LossSummarySchema = import_zod11.z.object({
+  period: import_zod11.z.string().optional(),
+  totalClaims: import_zod11.z.number().optional(),
+  totalIncurred: import_zod11.z.string().optional(),
+  totalPaid: import_zod11.z.string().optional(),
+  totalReserved: import_zod11.z.string().optional(),
+  lossRatio: import_zod11.z.string().optional()
+});
+var ExperienceModSchema = import_zod11.z.object({
+  factor: import_zod11.z.number(),
+  effectiveDate: import_zod11.z.string().optional(),
+  state: import_zod11.z.string().optional()
 });
 
 // src/schemas/underwriting.ts
-var import_zod11 = require("zod");
-var EnrichedSubjectivitySchema = import_zod11.z.object({
-  description: import_zod11.z.string(),
+var import_zod12 = require("zod");
+var EnrichedSubjectivitySchema = import_zod12.z.object({
+  description: import_zod12.z.string(),
   category: SubjectivityCategorySchema.optional(),
-  dueDate: import_zod11.z.string().optional(),
-  status: import_zod11.z.enum(["open", "satisfied", "waived"]).optional(),
-  pageNumber: import_zod11.z.number().optional()
+  dueDate: import_zod12.z.string().optional(),
+  status: import_zod12.z.enum(["open", "satisfied", "waived"]).optional(),
+  pageNumber: import_zod12.z.number().optional()
 });
-var EnrichedUnderwritingConditionSchema = import_zod11.z.object({
-  description: import_zod11.z.string(),
-  category: import_zod11.z.string().optional(),
-  pageNumber: import_zod11.z.number().optional()
+var EnrichedUnderwritingConditionSchema = import_zod12.z.object({
+  description: import_zod12.z.string(),
+  category: import_zod12.z.string().optional(),
+  pageNumber: import_zod12.z.number().optional()
 });
-var BindingAuthoritySchema = import_zod11.z.object({
-  authorizedBy: import_zod11.z.string().optional(),
-  method: import_zod11.z.string().optional(),
-  expiration: import_zod11.z.string().optional(),
-  conditions: import_zod11.z.array(import_zod11.z.string()).optional()
+var BindingAuthoritySchema = import_zod12.z.object({
+  authorizedBy: import_zod12.z.string().optional(),
+  method: import_zod12.z.string().optional(),
+  expiration: import_zod12.z.string().optional(),
+  conditions: import_zod12.z.array(import_zod12.z.string()).optional()
 });
 
 // src/schemas/declarations/index.ts
-var import_zod15 = require("zod");
+var import_zod16 = require("zod");
 
 // src/schemas/declarations/personal.ts
-var import_zod13 = require("zod");
+var import_zod14 = require("zod");
 
 // src/schemas/declarations/shared.ts
-var import_zod12 = require("zod");
-var EmployersLiabilityLimitsSchema = import_zod12.z.object({
-  eachAccident: import_zod12.z.string(),
-  diseasePolicyLimit: import_zod12.z.string(),
-  diseaseEachEmployee: import_zod12.z.string()
-});
-var LimitScheduleSchema = import_zod12.z.object({
-  perOccurrence: import_zod12.z.string().optional(),
-  generalAggregate: import_zod12.z.string().optional(),
-  productsCompletedOpsAggregate: import_zod12.z.string().optional(),
-  personalAdvertisingInjury: import_zod12.z.string().optional(),
-  eachEmployee: import_zod12.z.string().optional(),
-  fireDamage: import_zod12.z.string().optional(),
-  medicalExpense: import_zod12.z.string().optional(),
-  combinedSingleLimit: import_zod12.z.string().optional(),
-  bodilyInjuryPerPerson: import_zod12.z.string().optional(),
-  bodilyInjuryPerAccident: import_zod12.z.string().optional(),
-  propertyDamage: import_zod12.z.string().optional(),
-  eachOccurrenceUmbrella: import_zod12.z.string().optional(),
-  umbrellaAggregate: import_zod12.z.string().optional(),
-  umbrellaRetention: import_zod12.z.string().optional(),
-  statutory: import_zod12.z.boolean().optional(),
+var import_zod13 = require("zod");
+var EmployersLiabilityLimitsSchema = import_zod13.z.object({
+  eachAccident: import_zod13.z.string(),
+  diseasePolicyLimit: import_zod13.z.string(),
+  diseaseEachEmployee: import_zod13.z.string()
+});
+var LimitScheduleSchema = import_zod13.z.object({
+  perOccurrence: import_zod13.z.string().optional(),
+  generalAggregate: import_zod13.z.string().optional(),
+  productsCompletedOpsAggregate: import_zod13.z.string().optional(),
+  personalAdvertisingInjury: import_zod13.z.string().optional(),
+  eachEmployee: import_zod13.z.string().optional(),
+  fireDamage: import_zod13.z.string().optional(),
+  medicalExpense: import_zod13.z.string().optional(),
+  combinedSingleLimit: import_zod13.z.string().optional(),
+  bodilyInjuryPerPerson: import_zod13.z.string().optional(),
+  bodilyInjuryPerAccident: import_zod13.z.string().optional(),
+  propertyDamage: import_zod13.z.string().optional(),
+  eachOccurrenceUmbrella: import_zod13.z.string().optional(),
+  umbrellaAggregate: import_zod13.z.string().optional(),
+  umbrellaRetention: import_zod13.z.string().optional(),
+  statutory: import_zod13.z.boolean().optional(),
   employersLiability: EmployersLiabilityLimitsSchema.optional(),
-  sublimits: import_zod12.z.array(SublimitSchema).optional(),
-  sharedLimits: import_zod12.z.array(SharedLimitSchema).optional(),
+  sublimits: import_zod13.z.array(SublimitSchema).optional(),
+  sharedLimits: import_zod13.z.array(SharedLimitSchema).optional(),
   defenseCostTreatment: DefenseCostTreatmentSchema.optional()
 });
-var DeductibleScheduleSchema = import_zod12.z.object({
-  perClaim: import_zod12.z.string().optional(),
-  perOccurrence: import_zod12.z.string().optional(),
-  aggregateDeductible: import_zod12.z.string().optional(),
-  selfInsuredRetention: import_zod12.z.string().optional(),
-  corridorDeductible: import_zod12.z.string().optional(),
-  waitingPeriod: import_zod12.z.string().optional(),
-  appliesTo: import_zod12.z.enum(["damages_only", "damages_and_defense", "defense_only"]).optional()
-});
-var InsuredLocationSchema = import_zod12.z.object({
-  number: import_zod12.z.number(),
+var DeductibleScheduleSchema = import_zod13.z.object({
+  perClaim: import_zod13.z.string().optional(),
+  perOccurrence: import_zod13.z.string().optional(),
+  aggregateDeductible: import_zod13.z.string().optional(),
+  selfInsuredRetention: import_zod13.z.string().optional(),
+  corridorDeductible: import_zod13.z.string().optional(),
+  waitingPeriod: import_zod13.z.string().optional(),
+  appliesTo: import_zod13.z.enum(["damages_only", "damages_and_defense", "defense_only"]).optional()
+});
+var InsuredLocationSchema = import_zod13.z.object({
+  number: import_zod13.z.number(),
   address: AddressSchema,
-  description: import_zod12.z.string().optional(),
-  buildingValue: import_zod12.z.string().optional(),
-  contentsValue: import_zod12.z.string().optional(),
-  businessIncomeValue: import_zod12.z.string().optional(),
-  constructionType: import_zod12.z.string().optional(),
-  yearBuilt: import_zod12.z.number().optional(),
-  squareFootage: import_zod12.z.number().optional(),
-  protectionClass: import_zod12.z.string().optional(),
-  sprinklered: import_zod12.z.boolean().optional(),
-  alarmType: import_zod12.z.string().optional(),
-  occupancy: import_zod12.z.string().optional()
-});
-var VehicleCoverageSchema = import_zod12.z.object({
+  description: import_zod13.z.string().optional(),
+  buildingValue: import_zod13.z.string().optional(),
+  contentsValue: import_zod13.z.string().optional(),
+  businessIncomeValue: import_zod13.z.string().optional(),
+  constructionType: import_zod13.z.string().optional(),
+  yearBuilt: import_zod13.z.number().optional(),
+  squareFootage: import_zod13.z.number().optional(),
+  protectionClass: import_zod13.z.string().optional(),
+  sprinklered: import_zod13.z.boolean().optional(),
+  alarmType: import_zod13.z.string().optional(),
+  occupancy: import_zod13.z.string().optional()
+});
+var VehicleCoverageSchema = import_zod13.z.object({
   type: VehicleCoverageTypeSchema,
-  limit: import_zod12.z.string().optional(),
-  deductible: import_zod12.z.string().optional(),
-  included: import_zod12.z.boolean()
-});
-var InsuredVehicleSchema = import_zod12.z.object({
-  number: import_zod12.z.number(),
-  year: import_zod12.z.number(),
-  make: import_zod12.z.string(),
-  model: import_zod12.z.string(),
-  vin: import_zod12.z.string(),
-  costNew: import_zod12.z.string().optional(),
-  statedValue: import_zod12.z.string().optional(),
-  garageLocation: import_zod12.z.number().optional(),
-  coverages: import_zod12.z.array(VehicleCoverageSchema).optional(),
-  radius: import_zod12.z.string().optional(),
-  vehicleType: import_zod12.z.string().optional()
-});
-var ClassificationCodeSchema = import_zod12.z.object({
-  code: import_zod12.z.string(),
-  description: import_zod12.z.string(),
-  premiumBasis: import_zod12.z.string(),
-  basisAmount: import_zod12.z.string().optional(),
-  rate: import_zod12.z.string().optional(),
-  premium: import_zod12.z.string().optional(),
-  locationNumber: import_zod12.z.number().optional()
-});
-var DwellingDetailsSchema = import_zod12.z.object({
+  limit: import_zod13.z.string().optional(),
+  deductible: import_zod13.z.string().optional(),
+  included: import_zod13.z.boolean()
+});
+var InsuredVehicleSchema = import_zod13.z.object({
+  number: import_zod13.z.number(),
+  year: import_zod13.z.number(),
+  make: import_zod13.z.string(),
+  model: import_zod13.z.string(),
+  vin: import_zod13.z.string(),
+  costNew: import_zod13.z.string().optional(),
+  statedValue: import_zod13.z.string().optional(),
+  garageLocation: import_zod13.z.number().optional(),
+  coverages: import_zod13.z.array(VehicleCoverageSchema).optional(),
+  radius: import_zod13.z.string().optional(),
+  vehicleType: import_zod13.z.string().optional()
+});
+var ClassificationCodeSchema = import_zod13.z.object({
+  code: import_zod13.z.string(),
+  description: import_zod13.z.string(),
+  premiumBasis: import_zod13.z.string(),
+  basisAmount: import_zod13.z.string().optional(),
+  rate: import_zod13.z.string().optional(),
+  premium: import_zod13.z.string().optional(),
+  locationNumber: import_zod13.z.number().optional()
+});
+var DwellingDetailsSchema = import_zod13.z.object({
   constructionType: ConstructionTypeSchema.optional(),
-  yearBuilt: import_zod12.z.number().optional(),
-  squareFootage: import_zod12.z.number().optional(),
-  stories: import_zod12.z.number().optional(),
+  yearBuilt: import_zod13.z.number().optional(),
+  squareFootage: import_zod13.z.number().optional(),
+  stories: import_zod13.z.number().optional(),
   roofType: RoofTypeSchema.optional(),
-  roofAge: import_zod12.z.number().optional(),
-  heatingType: import_zod12.z.enum(["central", "baseboard", "radiant", "space_heater", "heat_pump", "other"]).optional(),
+  roofAge: import_zod13.z.number().optional(),
+  heatingType: import_zod13.z.enum(["central", "baseboard", "radiant", "space_heater", "heat_pump", "other"]).optional(),
   foundationType: FoundationTypeSchema.optional(),
-  plumbingType: import_zod12.z.enum(["copper", "pex", "galvanized", "polybutylene", "cpvc", "other"]).optional(),
-  electricalType: import_zod12.z.enum(["circuit_breaker", "fuse_box", "knob_and_tube", "other"]).optional(),
-  electricalAmps: import_zod12.z.number().optional(),
-  hasSwimmingPool: import_zod12.z.boolean().optional(),
-  poolType: import_zod12.z.enum(["in_ground", "above_ground"]).optional(),
-  hasTrampoline: import_zod12.z.boolean().optional(),
-  hasDog: import_zod12.z.boolean().optional(),
-  dogBreed: import_zod12.z.string().optional(),
-  protectiveDevices: import_zod12.z.array(import_zod12.z.string()).optional(),
-  distanceToFireStation: import_zod12.z.string().optional(),
-  distanceToHydrant: import_zod12.z.string().optional(),
-  fireProtectionClass: import_zod12.z.string().optional()
-});
-var DriverRecordSchema = import_zod12.z.object({
-  name: import_zod12.z.string(),
-  dateOfBirth: import_zod12.z.string().optional(),
-  licenseNumber: import_zod12.z.string().optional(),
-  licenseState: import_zod12.z.string().optional(),
-  relationship: import_zod12.z.enum(["named_insured", "spouse", "child", "other_household", "other"]).optional(),
-  yearsLicensed: import_zod12.z.number().optional(),
-  gender: import_zod12.z.string().optional(),
-  maritalStatus: import_zod12.z.string().optional(),
-  goodStudentDiscount: import_zod12.z.boolean().optional(),
-  defensiveDriverDiscount: import_zod12.z.boolean().optional(),
-  violations: import_zod12.z.array(import_zod12.z.object({
-    date: import_zod12.z.string().optional(),
-    type: import_zod12.z.string().optional(),
-    description: import_zod12.z.string().optional()
+  plumbingType: import_zod13.z.enum(["copper", "pex", "galvanized", "polybutylene", "cpvc", "other"]).optional(),
+  electricalType: import_zod13.z.enum(["circuit_breaker", "fuse_box", "knob_and_tube", "other"]).optional(),
+  electricalAmps: import_zod13.z.number().optional(),
+  hasSwimmingPool: import_zod13.z.boolean().optional(),
+  poolType: import_zod13.z.enum(["in_ground", "above_ground"]).optional(),
+  hasTrampoline: import_zod13.z.boolean().optional(),
+  hasDog: import_zod13.z.boolean().optional(),
+  dogBreed: import_zod13.z.string().optional(),
+  protectiveDevices: import_zod13.z.array(import_zod13.z.string()).optional(),
+  distanceToFireStation: import_zod13.z.string().optional(),
+  distanceToHydrant: import_zod13.z.string().optional(),
+  fireProtectionClass: import_zod13.z.string().optional()
+});
+var DriverRecordSchema = import_zod13.z.object({
+  name: import_zod13.z.string(),
+  dateOfBirth: import_zod13.z.string().optional(),
+  licenseNumber: import_zod13.z.string().optional(),
+  licenseState: import_zod13.z.string().optional(),
+  relationship: import_zod13.z.enum(["named_insured", "spouse", "child", "other_household", "other"]).optional(),
+  yearsLicensed: import_zod13.z.number().optional(),
+  gender: import_zod13.z.string().optional(),
+  maritalStatus: import_zod13.z.string().optional(),
+  goodStudentDiscount: import_zod13.z.boolean().optional(),
+  defensiveDriverDiscount: import_zod13.z.boolean().optional(),
+  violations: import_zod13.z.array(import_zod13.z.object({
+    date: import_zod13.z.string().optional(),
+    type: import_zod13.z.string().optional(),
+    description: import_zod13.z.string().optional()
   })).optional(),
-  accidents: import_zod12.z.array(import_zod12.z.object({
-    date: import_zod12.z.string().optional(),
-    atFault: import_zod12.z.boolean().optional(),
-    description: import_zod12.z.string().optional(),
-    amountPaid: import_zod12.z.string().optional()
+  accidents: import_zod13.z.array(import_zod13.z.object({
+    date: import_zod13.z.string().optional(),
+    atFault: import_zod13.z.boolean().optional(),
+    description: import_zod13.z.string().optional(),
+    amountPaid: import_zod13.z.string().optional()
   })).optional(),
-  sr22Required: import_zod12.z.boolean().optional()
-});
-var PersonalVehicleDetailsSchema = import_zod12.z.object({
-  number: import_zod12.z.number().optional(),
-  year: import_zod12.z.number().optional(),
-  make: import_zod12.z.string().optional(),
-  model: import_zod12.z.string().optional(),
-  vin: import_zod12.z.string().optional(),
-  bodyType: import_zod12.z.string().optional(),
+  sr22Required: import_zod13.z.boolean().optional()
+});
+var PersonalVehicleDetailsSchema = import_zod13.z.object({
+  number: import_zod13.z.number().optional(),
+  year: import_zod13.z.number().optional(),
+  make: import_zod13.z.string().optional(),
+  model: import_zod13.z.string().optional(),
+  vin: import_zod13.z.string().optional(),
+  bodyType: import_zod13.z.string().optional(),
   garagingAddress: AddressSchema.optional(),
   usage: PersonalAutoUsageSchema.optional(),
-  annualMileage: import_zod12.z.number().optional(),
-  odometerReading: import_zod12.z.number().optional(),
-  driverAssignment: import_zod12.z.string().optional(),
+  annualMileage: import_zod13.z.number().optional(),
+  odometerReading: import_zod13.z.number().optional(),
+  driverAssignment: import_zod13.z.string().optional(),
   lienHolder: EndorsementPartySchema.optional(),
-  collisionDeductible: import_zod12.z.string().optional(),
-  comprehensiveDeductible: import_zod12.z.string().optional(),
-  rentalReimbursement: import_zod12.z.boolean().optional(),
-  towing: import_zod12.z.boolean().optional()
+  collisionDeductible: import_zod13.z.string().optional(),
+  comprehensiveDeductible: import_zod13.z.string().optional(),
+  rentalReimbursement: import_zod13.z.boolean().optional(),
+  towing: import_zod13.z.boolean().optional()
 });
 
 // src/schemas/declarations/personal.ts
-var HomeownersDeclarationsSchema = import_zod13.z.object({
-  line: import_zod13.z.literal("homeowners"),
+var HomeownersDeclarationsSchema = import_zod14.z.object({
+  line: import_zod14.z.literal("homeowners"),
   formType: HomeownersFormTypeSchema,
-  coverageA: import_zod13.z.string().optional(),
-  coverageB: import_zod13.z.string().optional(),
-  coverageC: import_zod13.z.string().optional(),
-  coverageD: import_zod13.z.string().optional(),
-  coverageE: import_zod13.z.string().optional(),
-  coverageF: import_zod13.z.string().optional(),
-  allPerilDeductible: import_zod13.z.string().optional(),
-  windHailDeductible: import_zod13.z.string().optional(),
-  hurricaneDeductible: import_zod13.z.string().optional(),
+  coverageA: import_zod14.z.string().optional(),
+  coverageB: import_zod14.z.string().optional(),
+  coverageC: import_zod14.z.string().optional(),
+  coverageD: import_zod14.z.string().optional(),
+  coverageE: import_zod14.z.string().optional(),
+  coverageF: import_zod14.z.string().optional(),
+  allPerilDeductible: import_zod14.z.string().optional(),
+  windHailDeductible: import_zod14.z.string().optional(),
+  hurricaneDeductible: import_zod14.z.string().optional(),
   lossSettlement: LossSettlementSchema.optional(),
   dwelling: DwellingDetailsSchema,
   mortgagee: EndorsementPartySchema.optional(),
-  additionalMortgagees: import_zod13.z.array(EndorsementPartySchema).optional()
-});
-var PersonalAutoDeclarationsSchema = import_zod13.z.object({
-  line: import_zod13.z.literal("personal_auto"),
-  vehicles: import_zod13.z.array(PersonalVehicleDetailsSchema),
-  drivers: import_zod13.z.array(DriverRecordSchema),
-  liabilityLimits: import_zod13.z.object({
-    bodilyInjuryPerPerson: import_zod13.z.string().optional(),
-    bodilyInjuryPerAccident: import_zod13.z.string().optional(),
-    propertyDamage: import_zod13.z.string().optional(),
-    combinedSingleLimit: import_zod13.z.string().optional()
+  additionalMortgagees: import_zod14.z.array(EndorsementPartySchema).optional()
+});
+var PersonalAutoDeclarationsSchema = import_zod14.z.object({
+  line: import_zod14.z.literal("personal_auto"),
+  vehicles: import_zod14.z.array(PersonalVehicleDetailsSchema),
+  drivers: import_zod14.z.array(DriverRecordSchema),
+  liabilityLimits: import_zod14.z.object({
+    bodilyInjuryPerPerson: import_zod14.z.string().optional(),
+    bodilyInjuryPerAccident: import_zod14.z.string().optional(),
+    propertyDamage: import_zod14.z.string().optional(),
+    combinedSingleLimit: import_zod14.z.string().optional()
   }).optional(),
-  umLimits: import_zod13.z.object({
-    bodilyInjuryPerPerson: import_zod13.z.string().optional(),
-    bodilyInjuryPerAccident: import_zod13.z.string().optional()
+  umLimits: import_zod14.z.object({
+    bodilyInjuryPerPerson: import_zod14.z.string().optional(),
+    bodilyInjuryPerAccident: import_zod14.z.string().optional()
   }).optional(),
-  uimLimits: import_zod13.z.object({
-    bodilyInjuryPerPerson: import_zod13.z.string().optional(),
-    bodilyInjuryPerAccident: import_zod13.z.string().optional()
+  uimLimits: import_zod14.z.object({
+    bodilyInjuryPerPerson: import_zod14.z.string().optional(),
+    bodilyInjuryPerAccident: import_zod14.z.string().optional()
   }).optional(),
-  pipLimit: import_zod13.z.string().optional(),
-  medPayLimit: import_zod13.z.string().optional()
+  pipLimit: import_zod14.z.string().optional(),
+  medPayLimit: import_zod14.z.string().optional()
 });
-var DwellingFireDeclarationsSchema = import_zod13.z.object({
-  line: import_zod13.z.literal("dwelling_fire"),
+var DwellingFireDeclarationsSchema = import_zod14.z.object({
+  line: import_zod14.z.literal("dwelling_fire"),
   formType: DwellingFireFormTypeSchema,
-  dwellingLimit: import_zod13.z.string().optional(),
-  otherStructuresLimit: import_zod13.z.string().optional(),
-  personalPropertyLimit: import_zod13.z.string().optional(),
-  fairRentalValueLimit: import_zod13.z.string().optional(),
-  liabilityLimit: import_zod13.z.string().optional(),
-  medicalPaymentsLimit: import_zod13.z.string().optional(),
-  deductible: import_zod13.z.string().optional(),
+  dwellingLimit: import_zod14.z.string().optional(),
+  otherStructuresLimit: import_zod14.z.string().optional(),
+  personalPropertyLimit: import_zod14.z.string().optional(),
+  fairRentalValueLimit: import_zod14.z.string().optional(),
+  liabilityLimit: import_zod14.z.string().optional(),
+  medicalPaymentsLimit: import_zod14.z.string().optional(),
+  deductible: import_zod14.z.string().optional(),
   dwelling: DwellingDetailsSchema
 });
-var FloodDeclarationsSchema = import_zod13.z.object({
-  line: import_zod13.z.literal("flood"),
-  programType: import_zod13.z.enum(["nfip", "private"]),
+var FloodDeclarationsSchema = import_zod14.z.object({
+  line: import_zod14.z.literal("flood"),
+  programType: import_zod14.z.enum(["nfip", "private"]),
   floodZone: FloodZoneSchema.optional(),
-  communityNumber: import_zod13.z.string().optional(),
-  communityRating: import_zod13.z.number().optional(),
-  buildingCoverage: import_zod13.z.string().optional(),
-  contentsCoverage: import_zod13.z.string().optional(),
-  iccCoverage: import_zod13.z.string().optional(),
-  deductible: import_zod13.z.string().optional(),
-  waitingPeriodDays: import_zod13.z.number().optional(),
-  elevationCertificate: import_zod13.z.boolean().optional(),
-  elevationDifference: import_zod13.z.string().optional(),
-  buildingDiagramNumber: import_zod13.z.number().optional(),
-  basementOrEnclosure: import_zod13.z.boolean().optional(),
-  postFirmConstruction: import_zod13.z.boolean().optional()
-});
-var EarthquakeDeclarationsSchema = import_zod13.z.object({
-  line: import_zod13.z.literal("earthquake"),
-  dwellingCoverage: import_zod13.z.string().optional(),
-  contentsCoverage: import_zod13.z.string().optional(),
-  lossOfUseCoverage: import_zod13.z.string().optional(),
-  deductiblePercent: import_zod13.z.number().optional(),
-  retrofitDiscount: import_zod13.z.boolean().optional(),
-  masonryVeneerCoverage: import_zod13.z.boolean().optional()
-});
-var PersonalUmbrellaDeclarationsSchema = import_zod13.z.object({
-  line: import_zod13.z.literal("personal_umbrella"),
-  perOccurrenceLimit: import_zod13.z.string().optional(),
-  aggregateLimit: import_zod13.z.string().optional(),
-  retainedLimit: import_zod13.z.string().optional(),
-  underlyingPolicies: import_zod13.z.array(import_zod13.z.object({
-    carrier: import_zod13.z.string().optional(),
-    policyNumber: import_zod13.z.string().optional(),
-    policyType: import_zod13.z.string().optional(),
-    limits: import_zod13.z.string().optional()
+  communityNumber: import_zod14.z.string().optional(),
+  communityRating: import_zod14.z.number().optional(),
+  buildingCoverage: import_zod14.z.string().optional(),
+  contentsCoverage: import_zod14.z.string().optional(),
+  iccCoverage: import_zod14.z.string().optional(),
+  deductible: import_zod14.z.string().optional(),
+  waitingPeriodDays: import_zod14.z.number().optional(),
+  elevationCertificate: import_zod14.z.boolean().optional(),
+  elevationDifference: import_zod14.z.string().optional(),
+  buildingDiagramNumber: import_zod14.z.number().optional(),
+  basementOrEnclosure: import_zod14.z.boolean().optional(),
+  postFirmConstruction: import_zod14.z.boolean().optional()
+});
+var EarthquakeDeclarationsSchema = import_zod14.z.object({
+  line: import_zod14.z.literal("earthquake"),
+  dwellingCoverage: import_zod14.z.string().optional(),
+  contentsCoverage: import_zod14.z.string().optional(),
+  lossOfUseCoverage: import_zod14.z.string().optional(),
+  deductiblePercent: import_zod14.z.number().optional(),
+  retrofitDiscount: import_zod14.z.boolean().optional(),
+  masonryVeneerCoverage: import_zod14.z.boolean().optional()
+});
+var PersonalUmbrellaDeclarationsSchema = import_zod14.z.object({
+  line: import_zod14.z.literal("personal_umbrella"),
+  perOccurrenceLimit: import_zod14.z.string().optional(),
+  aggregateLimit: import_zod14.z.string().optional(),
+  retainedLimit: import_zod14.z.string().optional(),
+  underlyingPolicies: import_zod14.z.array(import_zod14.z.object({
+    carrier: import_zod14.z.string().optional(),
+    policyNumber: import_zod14.z.string().optional(),
+    policyType: import_zod14.z.string().optional(),
+    limits: import_zod14.z.string().optional()
   }))
 });
-var PersonalArticlesDeclarationsSchema = import_zod13.z.object({
-  line: import_zod13.z.literal("personal_articles"),
-  scheduledItems: import_zod13.z.array(import_zod13.z.object({
-    itemNumber: import_zod13.z.number().optional(),
+var PersonalArticlesDeclarationsSchema = import_zod14.z.object({
+  line: import_zod14.z.literal("personal_articles"),
+  scheduledItems: import_zod14.z.array(import_zod14.z.object({
+    itemNumber: import_zod14.z.number().optional(),
     category: ScheduledItemCategorySchema.optional(),
-    description: import_zod13.z.string(),
-    appraisedValue: import_zod13.z.string(),
-    appraisalDate: import_zod13.z.string().optional()
+    description: import_zod14.z.string(),
+    appraisedValue: import_zod14.z.string(),
+    appraisalDate: import_zod14.z.string().optional()
   })),
-  blanketCoverage: import_zod13.z.string().optional(),
-  deductible: import_zod13.z.string().optional(),
-  worldwideCoverage: import_zod13.z.boolean().optional(),
-  breakageCoverage: import_zod13.z.boolean().optional()
+  blanketCoverage: import_zod14.z.string().optional(),
+  deductible: import_zod14.z.string().optional(),
+  worldwideCoverage: import_zod14.z.boolean().optional(),
+  breakageCoverage: import_zod14.z.boolean().optional()
 });
-var WatercraftDeclarationsSchema = import_zod13.z.object({
-  line: import_zod13.z.literal("watercraft"),
+var WatercraftDeclarationsSchema = import_zod14.z.object({
+  line: import_zod14.z.literal("watercraft"),
   boatType: BoatTypeSchema.optional(),
-  year: import_zod13.z.number().optional(),
-  make: import_zod13.z.string().optional(),
-  model: import_zod13.z.string().optional(),
-  length: import_zod13.z.string().optional(),
-  hullMaterial: import_zod13.z.enum(["fiberglass", "aluminum", "wood", "steel", "inflatable", "other"]).optional(),
-  hullValue: import_zod13.z.string().optional(),
-  motorHorsepower: import_zod13.z.number().optional(),
-  motorType: import_zod13.z.enum(["outboard", "inboard", "inboard_outboard", "jet"]).optional(),
-  navigationLimits: import_zod13.z.string().optional(),
-  layupPeriod: import_zod13.z.string().optional(),
-  liabilityLimit: import_zod13.z.string().optional(),
-  medicalPaymentsLimit: import_zod13.z.string().optional(),
-  physicalDamageDeductible: import_zod13.z.string().optional(),
-  uninsuredBoaterLimit: import_zod13.z.string().optional(),
-  trailerCovered: import_zod13.z.boolean().optional(),
-  trailerValue: import_zod13.z.string().optional()
-});
-var RecreationalVehicleDeclarationsSchema = import_zod13.z.object({
-  line: import_zod13.z.literal("recreational_vehicle"),
+  year: import_zod14.z.number().optional(),
+  make: import_zod14.z.string().optional(),
+  model: import_zod14.z.string().optional(),
+  length: import_zod14.z.string().optional(),
+  hullMaterial: import_zod14.z.enum(["fiberglass", "aluminum", "wood", "steel", "inflatable", "other"]).optional(),
+  hullValue: import_zod14.z.string().optional(),
+  motorHorsepower: import_zod14.z.number().optional(),
+  motorType: import_zod14.z.enum(["outboard", "inboard", "inboard_outboard", "jet"]).optional(),
+  navigationLimits: import_zod14.z.string().optional(),
+  layupPeriod: import_zod14.z.string().optional(),
+  liabilityLimit: import_zod14.z.string().optional(),
+  medicalPaymentsLimit: import_zod14.z.string().optional(),
+  physicalDamageDeductible: import_zod14.z.string().optional(),
+  uninsuredBoaterLimit: import_zod14.z.string().optional(),
+  trailerCovered: import_zod14.z.boolean().optional(),
+  trailerValue: import_zod14.z.string().optional()
+});
+var RecreationalVehicleDeclarationsSchema = import_zod14.z.object({
+  line: import_zod14.z.literal("recreational_vehicle"),
   vehicleType: RVTypeSchema,
-  year: import_zod13.z.number().optional(),
-  make: import_zod13.z.string().optional(),
-  model: import_zod13.z.string().optional(),
-  vin: import_zod13.z.string().optional(),
-  value: import_zod13.z.string().optional(),
-  liabilityLimit: import_zod13.z.string().optional(),
-  collisionDeductible: import_zod13.z.string().optional(),
-  comprehensiveDeductible: import_zod13.z.string().optional(),
-  personalEffectsCoverage: import_zod13.z.string().optional(),
-  fullTimerCoverage: import_zod13.z.boolean().optional()
-});
-var FarmRanchDeclarationsSchema = import_zod13.z.object({
-  line: import_zod13.z.literal("farm_ranch"),
-  dwellingCoverage: import_zod13.z.string().optional(),
-  farmPersonalPropertyCoverage: import_zod13.z.string().optional(),
-  farmLiabilityLimit: import_zod13.z.string().optional(),
-  farmAutoIncluded: import_zod13.z.boolean().optional(),
-  livestock: import_zod13.z.array(import_zod13.z.object({
-    type: import_zod13.z.string(),
-    headCount: import_zod13.z.number(),
-    value: import_zod13.z.string().optional()
+  year: import_zod14.z.number().optional(),
+  make: import_zod14.z.string().optional(),
+  model: import_zod14.z.string().optional(),
+  vin: import_zod14.z.string().optional(),
+  value: import_zod14.z.string().optional(),
+  liabilityLimit: import_zod14.z.string().optional(),
+  collisionDeductible: import_zod14.z.string().optional(),
+  comprehensiveDeductible: import_zod14.z.string().optional(),
+  personalEffectsCoverage: import_zod14.z.string().optional(),
+  fullTimerCoverage: import_zod14.z.boolean().optional()
+});
+var FarmRanchDeclarationsSchema = import_zod14.z.object({
+  line: import_zod14.z.literal("farm_ranch"),
+  dwellingCoverage: import_zod14.z.string().optional(),
+  farmPersonalPropertyCoverage: import_zod14.z.string().optional(),
+  farmLiabilityLimit: import_zod14.z.string().optional(),
+  farmAutoIncluded: import_zod14.z.boolean().optional(),
+  livestock: import_zod14.z.array(import_zod14.z.object({
+    type: import_zod14.z.string(),
+    headCount: import_zod14.z.number(),
+    value: import_zod14.z.string().optional()
   })).optional(),
-  equipmentSchedule: import_zod13.z.array(import_zod13.z.object({
-    description: import_zod13.z.string(),
-    value: import_zod13.z.string()
+  equipmentSchedule: import_zod14.z.array(import_zod14.z.object({
+    description: import_zod14.z.string(),
+    value: import_zod14.z.string()
   })).optional(),
-  acreage: import_zod13.z.number().optional(),
+  acreage: import_zod14.z.number().optional(),
   dwelling: DwellingDetailsSchema.optional()
 });
-var TitleDeclarationsSchema = import_zod13.z.object({
-  line: import_zod13.z.literal("title"),
+var TitleDeclarationsSchema = import_zod14.z.object({
+  line: import_zod14.z.literal("title"),
   policyType: TitlePolicyTypeSchema,
-  policyAmount: import_zod13.z.string(),
-  legalDescription: import_zod13.z.string().optional(),
+  policyAmount: import_zod14.z.string(),
+  legalDescription: import_zod14.z.string().optional(),
   propertyAddress: AddressSchema.optional(),
-  effectiveDate: import_zod13.z.string().optional(),
-  exceptions: import_zod13.z.array(import_zod13.z.object({
-    number: import_zod13.z.number(),
-    description: import_zod13.z.string()
+  effectiveDate: import_zod14.z.string().optional(),
+  exceptions: import_zod14.z.array(import_zod14.z.object({
+    number: import_zod14.z.number(),
+    description: import_zod14.z.string()
   })).optional(),
-  underwriter: import_zod13.z.string().optional()
+  underwriter: import_zod14.z.string().optional()
 });
-var PetDeclarationsSchema = import_zod13.z.object({
-  line: import_zod13.z.literal("pet"),
+var PetDeclarationsSchema = import_zod14.z.object({
+  line: import_zod14.z.literal("pet"),
   species: PetSpeciesSchema,
-  breed: import_zod13.z.string().optional(),
-  petName: import_zod13.z.string().optional(),
-  age: import_zod13.z.number().optional(),
-  annualLimit: import_zod13.z.string().optional(),
-  perIncidentLimit: import_zod13.z.string().optional(),
-  deductible: import_zod13.z.string().optional(),
-  reimbursementPercent: import_zod13.z.number().optional(),
-  waitingPeriodDays: import_zod13.z.number().optional(),
-  preExistingConditionsExcluded: import_zod13.z.boolean().optional(),
-  wellnessCoverage: import_zod13.z.boolean().optional()
-});
-var TravelDeclarationsSchema = import_zod13.z.object({
-  line: import_zod13.z.literal("travel"),
-  tripDepartureDate: import_zod13.z.string().optional(),
-  tripReturnDate: import_zod13.z.string().optional(),
-  destinations: import_zod13.z.array(import_zod13.z.string()).optional(),
-  travelers: import_zod13.z.array(import_zod13.z.object({
-    name: import_zod13.z.string(),
-    age: import_zod13.z.number().optional()
+  breed: import_zod14.z.string().optional(),
+  petName: import_zod14.z.string().optional(),
+  age: import_zod14.z.number().optional(),
+  annualLimit: import_zod14.z.string().optional(),
+  perIncidentLimit: import_zod14.z.string().optional(),
+  deductible: import_zod14.z.string().optional(),
+  reimbursementPercent: import_zod14.z.number().optional(),
+  waitingPeriodDays: import_zod14.z.number().optional(),
+  preExistingConditionsExcluded: import_zod14.z.boolean().optional(),
+  wellnessCoverage: import_zod14.z.boolean().optional()
+});
+var TravelDeclarationsSchema = import_zod14.z.object({
+  line: import_zod14.z.literal("travel"),
+  tripDepartureDate: import_zod14.z.string().optional(),
+  tripReturnDate: import_zod14.z.string().optional(),
+  destinations: import_zod14.z.array(import_zod14.z.string()).optional(),
+  travelers: import_zod14.z.array(import_zod14.z.object({
+    name: import_zod14.z.string(),
+    age: import_zod14.z.number().optional()
   })).optional(),
-  tripCost: import_zod13.z.string().optional(),
-  tripCancellationLimit: import_zod13.z.string().optional(),
-  medicalLimit: import_zod13.z.string().optional(),
-  evacuationLimit: import_zod13.z.string().optional(),
-  baggageLimit: import_zod13.z.string().optional()
+  tripCost: import_zod14.z.string().optional(),
+  tripCancellationLimit: import_zod14.z.string().optional(),
+  medicalLimit: import_zod14.z.string().optional(),
+  evacuationLimit: import_zod14.z.string().optional(),
+  baggageLimit: import_zod14.z.string().optional()
 });
-var IdentityTheftDeclarationsSchema = import_zod13.z.object({
-  line: import_zod13.z.literal("identity_theft"),
-  coverageLimit: import_zod13.z.string().optional(),
-  expenseReimbursement: import_zod13.z.string().optional(),
-  creditMonitoring: import_zod13.z.boolean().optional(),
-  restorationServices: import_zod13.z.boolean().optional(),
-  lostWagesLimit: import_zod13.z.string().optional()
+var IdentityTheftDeclarationsSchema = import_zod14.z.object({
+  line: import_zod14.z.literal("identity_theft"),
+  coverageLimit: import_zod14.z.string().optional(),
+  expenseReimbursement: import_zod14.z.string().optional(),
+  creditMonitoring: import_zod14.z.boolean().optional(),
+  restorationServices: import_zod14.z.boolean().optional(),
+  lostWagesLimit: import_zod14.z.string().optional()
 });
 
 // src/schemas/declarations/commercial.ts
-var import_zod14 = require("zod");
-var GLDeclarationsSchema = import_zod14.z.object({
-  line: import_zod14.z.literal("gl"),
+var import_zod15 = require("zod");
+var GLDeclarationsSchema = import_zod15.z.object({
+  line: import_zod15.z.literal("gl"),
   coverageForm: CoverageFormSchema.optional(),
-  perOccurrenceLimit: import_zod14.z.string().optional(),
-  generalAggregate: import_zod14.z.string().optional(),
-  productsCompletedOpsAggregate: import_zod14.z.string().optional(),
-  personalAdvertisingInjury: import_zod14.z.string().optional(),
-  fireDamage: import_zod14.z.string().optional(),
-  medicalExpense: import_zod14.z.string().optional(),
+  perOccurrenceLimit: import_zod15.z.string().optional(),
+  generalAggregate: import_zod15.z.string().optional(),
+  productsCompletedOpsAggregate: import_zod15.z.string().optional(),
+  personalAdvertisingInjury: import_zod15.z.string().optional(),
+  fireDamage: import_zod15.z.string().optional(),
+  medicalExpense: import_zod15.z.string().optional(),
   defenseCostTreatment: DefenseCostTreatmentSchema.optional(),
-  deductible: import_zod14.z.string().optional(),
-  classifications: import_zod14.z.array(ClassificationCodeSchema).optional(),
-  retroactiveDate: import_zod14.z.string().optional()
-});
-var CommercialPropertyDeclarationsSchema = import_zod14.z.object({
-  line: import_zod14.z.literal("commercial_property"),
-  causesOfLossForm: import_zod14.z.enum(["basic", "broad", "special"]).optional(),
-  coinsurancePercent: import_zod14.z.number().optional(),
+  deductible: import_zod15.z.string().optional(),
+  classifications: import_zod15.z.array(ClassificationCodeSchema).optional(),
+  retroactiveDate: import_zod15.z.string().optional()
+});
+var CommercialPropertyDeclarationsSchema = import_zod15.z.object({
+  line: import_zod15.z.literal("commercial_property"),
+  causesOfLossForm: import_zod15.z.enum(["basic", "broad", "special"]).optional(),
+  coinsurancePercent: import_zod15.z.number().optional(),
   valuationMethod: ValuationMethodSchema.optional(),
-  locations: import_zod14.z.array(InsuredLocationSchema),
-  blanketLimit: import_zod14.z.string().optional(),
-  businessIncomeLimit: import_zod14.z.string().optional(),
-  extraExpenseLimit: import_zod14.z.string().optional()
-});
-var CommercialAutoDeclarationsSchema = import_zod14.z.object({
-  line: import_zod14.z.literal("commercial_auto"),
-  vehicles: import_zod14.z.array(InsuredVehicleSchema),
-  coveredAutoSymbols: import_zod14.z.array(import_zod14.z.number()).optional(),
-  liabilityLimit: import_zod14.z.string().optional(),
-  umLimit: import_zod14.z.string().optional(),
-  uimLimit: import_zod14.z.string().optional(),
-  hiredAutoLiability: import_zod14.z.boolean().optional(),
-  nonOwnedAutoLiability: import_zod14.z.boolean().optional()
-});
-var WorkersCompDeclarationsSchema = import_zod14.z.object({
-  line: import_zod14.z.literal("workers_comp"),
-  coveredStates: import_zod14.z.array(import_zod14.z.string()).optional(),
-  classifications: import_zod14.z.array(ClassificationCodeSchema),
+  locations: import_zod15.z.array(InsuredLocationSchema),
+  blanketLimit: import_zod15.z.string().optional(),
+  businessIncomeLimit: import_zod15.z.string().optional(),
+  extraExpenseLimit: import_zod15.z.string().optional()
+});
+var CommercialAutoDeclarationsSchema = import_zod15.z.object({
+  line: import_zod15.z.literal("commercial_auto"),
+  vehicles: import_zod15.z.array(InsuredVehicleSchema),
+  coveredAutoSymbols: import_zod15.z.array(import_zod15.z.number()).optional(),
+  liabilityLimit: import_zod15.z.string().optional(),
+  umLimit: import_zod15.z.string().optional(),
+  uimLimit: import_zod15.z.string().optional(),
+  hiredAutoLiability: import_zod15.z.boolean().optional(),
+  nonOwnedAutoLiability: import_zod15.z.boolean().optional()
+});
+var WorkersCompDeclarationsSchema = import_zod15.z.object({
+  line: import_zod15.z.literal("workers_comp"),
+  coveredStates: import_zod15.z.array(import_zod15.z.string()).optional(),
+  classifications: import_zod15.z.array(ClassificationCodeSchema),
   experienceMod: ExperienceModSchema.optional(),
   employersLiability: EmployersLiabilityLimitsSchema.optional()
 });
-var UmbrellaExcessDeclarationsSchema = import_zod14.z.object({
-  line: import_zod14.z.literal("umbrella_excess"),
-  perOccurrenceLimit: import_zod14.z.string().optional(),
-  aggregateLimit: import_zod14.z.string().optional(),
-  retention: import_zod14.z.string().optional(),
-  underlyingPolicies: import_zod14.z.array(import_zod14.z.object({
-    carrier: import_zod14.z.string().optional(),
-    policyNumber: import_zod14.z.string().optional(),
-    policyType: import_zod14.z.string().optional(),
-    limits: import_zod14.z.string().optional()
+var UmbrellaExcessDeclarationsSchema = import_zod15.z.object({
+  line: import_zod15.z.literal("umbrella_excess"),
+  perOccurrenceLimit: import_zod15.z.string().optional(),
+  aggregateLimit: import_zod15.z.string().optional(),
+  retention: import_zod15.z.string().optional(),
+  underlyingPolicies: import_zod15.z.array(import_zod15.z.object({
+    carrier: import_zod15.z.string().optional(),
+    policyNumber: import_zod15.z.string().optional(),
+    policyType: import_zod15.z.string().optional(),
+    limits: import_zod15.z.string().optional()
   }))
 });
-var ProfessionalLiabilityDeclarationsSchema = import_zod14.z.object({
-  line: import_zod14.z.literal("professional_liability"),
-  perClaimLimit: import_zod14.z.string().optional(),
-  aggregateLimit: import_zod14.z.string().optional(),
-  retroactiveDate: import_zod14.z.string().optional(),
+var ProfessionalLiabilityDeclarationsSchema = import_zod15.z.object({
+  line: import_zod15.z.literal("professional_liability"),
+  perClaimLimit: import_zod15.z.string().optional(),
+  aggregateLimit: import_zod15.z.string().optional(),
+  retroactiveDate: import_zod15.z.string().optional(),
   defenseCostTreatment: DefenseCostTreatmentSchema.optional(),
   extendedReportingPeriod: ExtendedReportingPeriodSchema.optional()
 });
-var CyberDeclarationsSchema = import_zod14.z.object({
-  line: import_zod14.z.literal("cyber"),
-  aggregateLimit: import_zod14.z.string().optional(),
-  retroactiveDate: import_zod14.z.string().optional(),
-  waitingPeriodHours: import_zod14.z.number().optional(),
-  sublimits: import_zod14.z.array(import_zod14.z.object({
-    coverageName: import_zod14.z.string(),
-    limit: import_zod14.z.string()
+var CyberDeclarationsSchema = import_zod15.z.object({
+  line: import_zod15.z.literal("cyber"),
+  aggregateLimit: import_zod15.z.string().optional(),
+  retroactiveDate: import_zod15.z.string().optional(),
+  waitingPeriodHours: import_zod15.z.number().optional(),
+  sublimits: import_zod15.z.array(import_zod15.z.object({
+    coverageName: import_zod15.z.string(),
+    limit: import_zod15.z.string()
   })).optional()
 });
-var DODeclarationsSchema = import_zod14.z.object({
-  line: import_zod14.z.literal("directors_officers"),
-  sideALimit: import_zod14.z.string().optional(),
-  sideBLimit: import_zod14.z.string().optional(),
-  sideCLimit: import_zod14.z.string().optional(),
-  sideARetention: import_zod14.z.string().optional(),
-  sideBRetention: import_zod14.z.string().optional(),
-  sideCRetention: import_zod14.z.string().optional(),
-  continuityDate: import_zod14.z.string().optional()
-});
-var CrimeDeclarationsSchema = import_zod14.z.object({
-  line: import_zod14.z.literal("crime"),
-  formType: import_zod14.z.enum(["discovery", "loss_sustained"]).optional(),
-  agreements: import_zod14.z.array(import_zod14.z.object({
-    agreement: import_zod14.z.string(),
-    coverageName: import_zod14.z.string(),
-    limit: import_zod14.z.string(),
-    deductible: import_zod14.z.string()
+var DODeclarationsSchema = import_zod15.z.object({
+  line: import_zod15.z.literal("directors_officers"),
+  sideALimit: import_zod15.z.string().optional(),
+  sideBLimit: import_zod15.z.string().optional(),
+  sideCLimit: import_zod15.z.string().optional(),
+  sideARetention: import_zod15.z.string().optional(),
+  sideBRetention: import_zod15.z.string().optional(),
+  sideCRetention: import_zod15.z.string().optional(),
+  continuityDate: import_zod15.z.string().optional()
+});
+var CrimeDeclarationsSchema = import_zod15.z.object({
+  line: import_zod15.z.literal("crime"),
+  formType: import_zod15.z.enum(["discovery", "loss_sustained"]).optional(),
+  agreements: import_zod15.z.array(import_zod15.z.object({
+    agreement: import_zod15.z.string(),
+    coverageName: import_zod15.z.string(),
+    limit: import_zod15.z.string(),
+    deductible: import_zod15.z.string()
   }))
 });
 
 // src/schemas/declarations/index.ts
-var DeclarationsSchema = import_zod15.z.discriminatedUnion("line", [
+var DeclarationsSchema = import_zod16.z.discriminatedUnion("line", [
   // Personal lines
   HomeownersDeclarationsSchema,
   PersonalAutoDeclarationsSchema,
@@ -1713,251 +2004,251 @@ var DeclarationsSchema = import_zod15.z.discriminatedUnion("line", [
 ]);
 
 // src/schemas/document.ts
-var import_zod16 = require("zod");
-var SubsectionSchema = import_zod16.z.object({
-  title: import_zod16.z.string(),
-  sectionNumber: import_zod16.z.string().optional(),
-  pageNumber: import_zod16.z.number().optional(),
-  excerpt: import_zod16.z.string().optional(),
-  content: import_zod16.z.string().optional(),
-  documentNodeId: import_zod16.z.string().optional(),
-  sourceSpanIds: import_zod16.z.array(import_zod16.z.string()).optional(),
-  sourceTextHash: import_zod16.z.string().optional()
-});
-var SectionSchema = import_zod16.z.object({
-  title: import_zod16.z.string(),
-  sectionNumber: import_zod16.z.string().optional(),
-  pageStart: import_zod16.z.number(),
-  pageEnd: import_zod16.z.number().optional(),
-  type: import_zod16.z.string(),
-  coverageType: import_zod16.z.string().optional(),
-  excerpt: import_zod16.z.string().optional(),
-  content: import_zod16.z.string().optional(),
-  subsections: import_zod16.z.array(SubsectionSchema).optional(),
-  recordId: import_zod16.z.string().optional(),
-  documentNodeId: import_zod16.z.string().optional(),
-  sourceSpanIds: import_zod16.z.array(import_zod16.z.string()).optional(),
-  sourceTextHash: import_zod16.z.string().optional()
-});
-var SubjectivitySchema = import_zod16.z.object({
-  description: import_zod16.z.string(),
-  category: import_zod16.z.string().optional()
-});
-var UnderwritingConditionSchema = import_zod16.z.object({
-  description: import_zod16.z.string()
-});
-var PremiumLineSchema = import_zod16.z.object({
-  line: import_zod16.z.string(),
-  amount: import_zod16.z.string(),
-  amountValue: import_zod16.z.number().optional(),
-  documentNodeId: import_zod16.z.string().optional(),
-  sourceSpanIds: import_zod16.z.array(import_zod16.z.string()).optional(),
-  sourceTextHash: import_zod16.z.string().optional()
-});
-var AuxiliaryFactSchema = import_zod16.z.object({
-  key: import_zod16.z.string(),
-  value: import_zod16.z.string(),
-  subject: import_zod16.z.string().optional(),
-  context: import_zod16.z.string().optional(),
-  documentNodeId: import_zod16.z.string().optional(),
-  sourceSpanIds: import_zod16.z.array(import_zod16.z.string()).optional(),
-  sourceTextHash: import_zod16.z.string().optional()
-});
-var DefinitionSchema = import_zod16.z.object({
-  term: import_zod16.z.string(),
-  definition: import_zod16.z.string(),
-  pageNumber: import_zod16.z.number().optional(),
-  formNumber: import_zod16.z.string().optional(),
-  formTitle: import_zod16.z.string().optional(),
-  sectionRef: import_zod16.z.string().optional(),
-  originalContent: import_zod16.z.string().optional(),
-  recordId: import_zod16.z.string().optional(),
-  documentNodeId: import_zod16.z.string().optional(),
-  sourceSpanIds: import_zod16.z.array(import_zod16.z.string()).optional(),
-  sourceTextHash: import_zod16.z.string().optional()
-});
-var CoveredReasonSchema = import_zod16.z.object({
-  coverageName: import_zod16.z.string(),
-  reasonNumber: import_zod16.z.string().optional(),
-  title: import_zod16.z.string().optional(),
-  content: import_zod16.z.string(),
-  conditions: import_zod16.z.array(import_zod16.z.string()).optional(),
-  exceptions: import_zod16.z.array(import_zod16.z.string()).optional(),
-  appliesTo: import_zod16.z.array(import_zod16.z.string()).optional(),
-  pageNumber: import_zod16.z.number().optional(),
-  formNumber: import_zod16.z.string().optional(),
-  formTitle: import_zod16.z.string().optional(),
-  sectionRef: import_zod16.z.string().optional(),
-  originalContent: import_zod16.z.string().optional(),
-  recordId: import_zod16.z.string().optional(),
-  documentNodeId: import_zod16.z.string().optional(),
-  sourceSpanIds: import_zod16.z.array(import_zod16.z.string()).optional(),
-  sourceTextHash: import_zod16.z.string().optional()
-});
-var DocumentTableOfContentsEntrySchema = import_zod16.z.object({
-  title: import_zod16.z.string(),
-  level: import_zod16.z.number().int().positive().optional(),
-  pageStart: import_zod16.z.number().optional(),
-  pageEnd: import_zod16.z.number().optional(),
-  documentNodeId: import_zod16.z.string().optional(),
-  sourceSpanIds: import_zod16.z.array(import_zod16.z.string()).optional()
-});
-var DocumentPageMapEntrySchema = import_zod16.z.object({
-  page: import_zod16.z.number().int().positive(),
-  label: import_zod16.z.string().optional(),
-  formNumber: import_zod16.z.string().optional(),
-  formTitle: import_zod16.z.string().optional(),
-  sectionTitle: import_zod16.z.string().optional(),
-  extractorNames: import_zod16.z.array(import_zod16.z.string()).optional(),
-  sourceSpanIds: import_zod16.z.array(import_zod16.z.string()).optional()
-});
-var DocumentAgentGuidanceSchema = import_zod16.z.object({
-  kind: import_zod16.z.string(),
-  title: import_zod16.z.string(),
-  detail: import_zod16.z.string(),
-  sourceSpanIds: import_zod16.z.array(import_zod16.z.string()).optional()
-});
-var DocumentMetadataSchema = import_zod16.z.object({
-  sourceTreeVersion: import_zod16.z.string().optional(),
-  sourceTreeCanonical: import_zod16.z.boolean().optional(),
-  formInventory: import_zod16.z.array(FormReferenceSchema).optional(),
-  tableOfContents: import_zod16.z.array(DocumentTableOfContentsEntrySchema).optional(),
-  pageMap: import_zod16.z.array(DocumentPageMapEntrySchema).optional(),
-  agentGuidance: import_zod16.z.array(DocumentAgentGuidanceSchema).optional()
-});
-var DocumentNodeSchema = import_zod16.z.lazy(
-  () => import_zod16.z.object({
-    id: import_zod16.z.string(),
-    title: import_zod16.z.string(),
-    originalTitle: import_zod16.z.string().optional(),
-    type: import_zod16.z.string().optional(),
-    label: import_zod16.z.string().optional(),
-    level: import_zod16.z.number().int().positive().optional(),
-    sectionNumber: import_zod16.z.string().optional(),
-    pageStart: import_zod16.z.number().optional(),
-    pageEnd: import_zod16.z.number().optional(),
-    formNumber: import_zod16.z.string().optional(),
-    formTitle: import_zod16.z.string().optional(),
-    excerpt: import_zod16.z.string().optional(),
-    content: import_zod16.z.string().optional(),
-    interpretationLabels: import_zod16.z.array(import_zod16.z.string()).optional(),
-    sourceSpanIds: import_zod16.z.array(import_zod16.z.string()).optional(),
-    sourceTextHash: import_zod16.z.string().optional(),
-    children: import_zod16.z.array(DocumentNodeSchema).optional()
+var import_zod17 = require("zod");
+var SubsectionSchema = import_zod17.z.object({
+  title: import_zod17.z.string(),
+  sectionNumber: import_zod17.z.string().optional(),
+  pageNumber: import_zod17.z.number().optional(),
+  excerpt: import_zod17.z.string().optional(),
+  content: import_zod17.z.string().optional(),
+  documentNodeId: import_zod17.z.string().optional(),
+  sourceSpanIds: import_zod17.z.array(import_zod17.z.string()).optional(),
+  sourceTextHash: import_zod17.z.string().optional()
+});
+var SectionSchema = import_zod17.z.object({
+  title: import_zod17.z.string(),
+  sectionNumber: import_zod17.z.string().optional(),
+  pageStart: import_zod17.z.number(),
+  pageEnd: import_zod17.z.number().optional(),
+  type: import_zod17.z.string(),
+  coverageType: import_zod17.z.string().optional(),
+  excerpt: import_zod17.z.string().optional(),
+  content: import_zod17.z.string().optional(),
+  subsections: import_zod17.z.array(SubsectionSchema).optional(),
+  recordId: import_zod17.z.string().optional(),
+  documentNodeId: import_zod17.z.string().optional(),
+  sourceSpanIds: import_zod17.z.array(import_zod17.z.string()).optional(),
+  sourceTextHash: import_zod17.z.string().optional()
+});
+var SubjectivitySchema = import_zod17.z.object({
+  description: import_zod17.z.string(),
+  category: import_zod17.z.string().optional()
+});
+var UnderwritingConditionSchema = import_zod17.z.object({
+  description: import_zod17.z.string()
+});
+var PremiumLineSchema = import_zod17.z.object({
+  line: import_zod17.z.string(),
+  amount: import_zod17.z.string(),
+  amountValue: import_zod17.z.number().optional(),
+  documentNodeId: import_zod17.z.string().optional(),
+  sourceSpanIds: import_zod17.z.array(import_zod17.z.string()).optional(),
+  sourceTextHash: import_zod17.z.string().optional()
+});
+var AuxiliaryFactSchema = import_zod17.z.object({
+  key: import_zod17.z.string(),
+  value: import_zod17.z.string(),
+  subject: import_zod17.z.string().optional(),
+  context: import_zod17.z.string().optional(),
+  documentNodeId: import_zod17.z.string().optional(),
+  sourceSpanIds: import_zod17.z.array(import_zod17.z.string()).optional(),
+  sourceTextHash: import_zod17.z.string().optional()
+});
+var DefinitionSchema = import_zod17.z.object({
+  term: import_zod17.z.string(),
+  definition: import_zod17.z.string(),
+  pageNumber: import_zod17.z.number().optional(),
+  formNumber: import_zod17.z.string().optional(),
+  formTitle: import_zod17.z.string().optional(),
+  sectionRef: import_zod17.z.string().optional(),
+  originalContent: import_zod17.z.string().optional(),
+  recordId: import_zod17.z.string().optional(),
+  documentNodeId: import_zod17.z.string().optional(),
+  sourceSpanIds: import_zod17.z.array(import_zod17.z.string()).optional(),
+  sourceTextHash: import_zod17.z.string().optional()
+});
+var CoveredReasonSchema = import_zod17.z.object({
+  coverageName: import_zod17.z.string(),
+  reasonNumber: import_zod17.z.string().optional(),
+  title: import_zod17.z.string().optional(),
+  content: import_zod17.z.string(),
+  conditions: import_zod17.z.array(import_zod17.z.string()).optional(),
+  exceptions: import_zod17.z.array(import_zod17.z.string()).optional(),
+  appliesTo: import_zod17.z.array(import_zod17.z.string()).optional(),
+  pageNumber: import_zod17.z.number().optional(),
+  formNumber: import_zod17.z.string().optional(),
+  formTitle: import_zod17.z.string().optional(),
+  sectionRef: import_zod17.z.string().optional(),
+  originalContent: import_zod17.z.string().optional(),
+  recordId: import_zod17.z.string().optional(),
+  documentNodeId: import_zod17.z.string().optional(),
+  sourceSpanIds: import_zod17.z.array(import_zod17.z.string()).optional(),
+  sourceTextHash: import_zod17.z.string().optional()
+});
+var DocumentTableOfContentsEntrySchema = import_zod17.z.object({
+  title: import_zod17.z.string(),
+  level: import_zod17.z.number().int().positive().optional(),
+  pageStart: import_zod17.z.number().optional(),
+  pageEnd: import_zod17.z.number().optional(),
+  documentNodeId: import_zod17.z.string().optional(),
+  sourceSpanIds: import_zod17.z.array(import_zod17.z.string()).optional()
+});
+var DocumentPageMapEntrySchema = import_zod17.z.object({
+  page: import_zod17.z.number().int().positive(),
+  label: import_zod17.z.string().optional(),
+  formNumber: import_zod17.z.string().optional(),
+  formTitle: import_zod17.z.string().optional(),
+  sectionTitle: import_zod17.z.string().optional(),
+  extractorNames: import_zod17.z.array(import_zod17.z.string()).optional(),
+  sourceSpanIds: import_zod17.z.array(import_zod17.z.string()).optional()
+});
+var DocumentAgentGuidanceSchema = import_zod17.z.object({
+  kind: import_zod17.z.string(),
+  title: import_zod17.z.string(),
+  detail: import_zod17.z.string(),
+  sourceSpanIds: import_zod17.z.array(import_zod17.z.string()).optional()
+});
+var DocumentMetadataSchema = import_zod17.z.object({
+  sourceTreeVersion: import_zod17.z.string().optional(),
+  sourceTreeCanonical: import_zod17.z.boolean().optional(),
+  formInventory: import_zod17.z.array(FormReferenceSchema).optional(),
+  tableOfContents: import_zod17.z.array(DocumentTableOfContentsEntrySchema).optional(),
+  pageMap: import_zod17.z.array(DocumentPageMapEntrySchema).optional(),
+  agentGuidance: import_zod17.z.array(DocumentAgentGuidanceSchema).optional()
+});
+var DocumentNodeSchema = import_zod17.z.lazy(
+  () => import_zod17.z.object({
+    id: import_zod17.z.string(),
+    title: import_zod17.z.string(),
+    originalTitle: import_zod17.z.string().optional(),
+    type: import_zod17.z.string().optional(),
+    label: import_zod17.z.string().optional(),
+    level: import_zod17.z.number().int().positive().optional(),
+    sectionNumber: import_zod17.z.string().optional(),
+    pageStart: import_zod17.z.number().optional(),
+    pageEnd: import_zod17.z.number().optional(),
+    formNumber: import_zod17.z.string().optional(),
+    formTitle: import_zod17.z.string().optional(),
+    excerpt: import_zod17.z.string().optional(),
+    content: import_zod17.z.string().optional(),
+    interpretationLabels: import_zod17.z.array(import_zod17.z.string()).optional(),
+    sourceSpanIds: import_zod17.z.array(import_zod17.z.string()).optional(),
+    sourceTextHash: import_zod17.z.string().optional(),
+    children: import_zod17.z.array(DocumentNodeSchema).optional()
   })
 );
 var BaseDocumentFields = {
-  id: import_zod16.z.string(),
-  carrier: import_zod16.z.string(),
-  security: import_zod16.z.string().optional(),
-  insuredName: import_zod16.z.string(),
-  premium: import_zod16.z.string().optional(),
-  premiumAmount: import_zod16.z.number().optional(),
-  summary: import_zod16.z.string().optional(),
-  policyTypes: import_zod16.z.array(import_zod16.z.string()).optional(),
-  coverages: import_zod16.z.array(CoverageSchema),
+  id: import_zod17.z.string(),
+  carrier: import_zod17.z.string(),
+  security: import_zod17.z.string().optional(),
+  insuredName: import_zod17.z.string(),
+  premium: import_zod17.z.string().optional(),
+  premiumAmount: import_zod17.z.number().optional(),
+  summary: import_zod17.z.string().optional(),
+  linesOfBusiness: import_zod17.z.array(import_zod17.z.string()).optional(),
+  coverages: import_zod17.z.array(CoverageSchema),
   documentMetadata: DocumentMetadataSchema,
-  documentOutline: import_zod16.z.array(DocumentNodeSchema),
-  sections: import_zod16.z.array(SectionSchema).optional(),
-  definitions: import_zod16.z.array(DefinitionSchema).optional(),
-  coveredReasons: import_zod16.z.array(CoveredReasonSchema).optional(),
+  documentOutline: import_zod17.z.array(DocumentNodeSchema),
+  sections: import_zod17.z.array(SectionSchema).optional(),
+  definitions: import_zod17.z.array(DefinitionSchema).optional(),
+  coveredReasons: import_zod17.z.array(CoveredReasonSchema).optional(),
   // Enriched fields (v1.2+)
-  carrierLegalName: import_zod16.z.string().optional(),
-  carrierNaicNumber: import_zod16.z.string().optional(),
-  carrierAmBestRating: import_zod16.z.string().optional(),
-  carrierAdmittedStatus: import_zod16.z.string().optional(),
-  mga: import_zod16.z.string().optional(),
-  underwriter: import_zod16.z.string().optional(),
-  brokerAgency: import_zod16.z.string().optional(),
-  brokerContactName: import_zod16.z.string().optional(),
-  brokerLicenseNumber: import_zod16.z.string().optional(),
-  priorPolicyNumber: import_zod16.z.string().optional(),
-  programName: import_zod16.z.string().optional(),
-  isRenewal: import_zod16.z.boolean().optional(),
-  isPackage: import_zod16.z.boolean().optional(),
-  insuredDba: import_zod16.z.string().optional(),
+  carrierLegalName: import_zod17.z.string().optional(),
+  carrierNaicNumber: import_zod17.z.string().optional(),
+  carrierAmBestRating: import_zod17.z.string().optional(),
+  carrierAdmittedStatus: import_zod17.z.string().optional(),
+  mga: import_zod17.z.string().optional(),
+  underwriter: import_zod17.z.string().optional(),
+  brokerAgency: import_zod17.z.string().optional(),
+  brokerContactName: import_zod17.z.string().optional(),
+  brokerLicenseNumber: import_zod17.z.string().optional(),
+  priorPolicyNumber: import_zod17.z.string().optional(),
+  programName: import_zod17.z.string().optional(),
+  isRenewal: import_zod17.z.boolean().optional(),
+  isPackage: import_zod17.z.boolean().optional(),
+  insuredDba: import_zod17.z.string().optional(),
   insuredAddress: SourceBackedAddressSchema.optional(),
   insuredEntityType: EntityTypeSchema.optional(),
-  additionalNamedInsureds: import_zod16.z.array(NamedInsuredSchema).optional(),
-  insuredSicCode: import_zod16.z.string().optional(),
-  insuredNaicsCode: import_zod16.z.string().optional(),
-  insuredFein: import_zod16.z.string().optional(),
-  enrichedCoverages: import_zod16.z.array(EnrichedCoverageSchema).optional(),
-  endorsements: import_zod16.z.array(EndorsementSchema).optional(),
-  exclusions: import_zod16.z.array(ExclusionSchema).optional(),
-  conditions: import_zod16.z.array(PolicyConditionSchema).optional(),
+  additionalNamedInsureds: import_zod17.z.array(NamedInsuredSchema).optional(),
+  insuredSicCode: import_zod17.z.string().optional(),
+  insuredNaicsCode: import_zod17.z.string().optional(),
+  insuredFein: import_zod17.z.string().optional(),
+  enrichedCoverages: import_zod17.z.array(EnrichedCoverageSchema).optional(),
+  endorsements: import_zod17.z.array(EndorsementSchema).optional(),
+  exclusions: import_zod17.z.array(ExclusionSchema).optional(),
+  conditions: import_zod17.z.array(PolicyConditionSchema).optional(),
   limits: LimitScheduleSchema.optional(),
   deductibles: DeductibleScheduleSchema.optional(),
-  locations: import_zod16.z.array(InsuredLocationSchema).optional(),
-  vehicles: import_zod16.z.array(InsuredVehicleSchema).optional(),
-  classifications: import_zod16.z.array(ClassificationCodeSchema).optional(),
-  formInventory: import_zod16.z.array(FormReferenceSchema).optional(),
+  locations: import_zod17.z.array(InsuredLocationSchema).optional(),
+  vehicles: import_zod17.z.array(InsuredVehicleSchema).optional(),
+  classifications: import_zod17.z.array(ClassificationCodeSchema).optional(),
+  formInventory: import_zod17.z.array(FormReferenceSchema).optional(),
   declarations: DeclarationsSchema.optional(),
   coverageForm: CoverageFormSchema.optional(),
-  retroactiveDate: import_zod16.z.string().optional(),
+  retroactiveDate: import_zod17.z.string().optional(),
   extendedReportingPeriod: ExtendedReportingPeriodSchema.optional(),
   insurer: InsurerInfoSchema.optional(),
   producer: ProducerInfoSchema.optional(),
-  claimsContacts: import_zod16.z.array(ContactSchema).optional(),
-  regulatoryContacts: import_zod16.z.array(ContactSchema).optional(),
-  thirdPartyAdministrators: import_zod16.z.array(ContactSchema).optional(),
-  additionalInsureds: import_zod16.z.array(EndorsementPartySchema).optional(),
-  lossPayees: import_zod16.z.array(EndorsementPartySchema).optional(),
-  mortgageHolders: import_zod16.z.array(EndorsementPartySchema).optional(),
-  taxesAndFees: import_zod16.z.array(TaxFeeItemSchema).optional(),
-  totalCost: import_zod16.z.string().optional(),
-  totalCostAmount: import_zod16.z.number().optional(),
-  minimumPremium: import_zod16.z.string().optional(),
-  minimumPremiumAmount: import_zod16.z.number().optional(),
-  depositPremium: import_zod16.z.string().optional(),
-  depositPremiumAmount: import_zod16.z.number().optional(),
+  claimsContacts: import_zod17.z.array(ContactSchema).optional(),
+  regulatoryContacts: import_zod17.z.array(ContactSchema).optional(),
+  thirdPartyAdministrators: import_zod17.z.array(ContactSchema).optional(),
+  additionalInsureds: import_zod17.z.array(EndorsementPartySchema).optional(),
+  lossPayees: import_zod17.z.array(EndorsementPartySchema).optional(),
+  mortgageHolders: import_zod17.z.array(EndorsementPartySchema).optional(),
+  taxesAndFees: import_zod17.z.array(TaxFeeItemSchema).optional(),
+  totalCost: import_zod17.z.string().optional(),
+  totalCostAmount: import_zod17.z.number().optional(),
+  minimumPremium: import_zod17.z.string().optional(),
+  minimumPremiumAmount: import_zod17.z.number().optional(),
+  depositPremium: import_zod17.z.string().optional(),
+  depositPremiumAmount: import_zod17.z.number().optional(),
   paymentPlan: PaymentPlanSchema.optional(),
   auditType: AuditTypeSchema.optional(),
-  ratingBasis: import_zod16.z.array(RatingBasisSchema).optional(),
-  premiumByLocation: import_zod16.z.array(LocationPremiumSchema).optional(),
+  ratingBasis: import_zod17.z.array(RatingBasisSchema).optional(),
+  premiumByLocation: import_zod17.z.array(LocationPremiumSchema).optional(),
   lossSummary: LossSummarySchema.optional(),
-  individualClaims: import_zod16.z.array(ClaimRecordSchema).optional(),
+  individualClaims: import_zod17.z.array(ClaimRecordSchema).optional(),
   experienceMod: ExperienceModSchema.optional(),
-  cancellationNoticeDays: import_zod16.z.number().optional(),
-  nonrenewalNoticeDays: import_zod16.z.number().optional(),
-  supplementaryFacts: import_zod16.z.array(AuxiliaryFactSchema).optional()
+  cancellationNoticeDays: import_zod17.z.number().optional(),
+  nonrenewalNoticeDays: import_zod17.z.number().optional(),
+  supplementaryFacts: import_zod17.z.array(AuxiliaryFactSchema).optional()
 };
-var PolicyDocumentSchema = import_zod16.z.object({
+var PolicyDocumentSchema = import_zod17.z.object({
   ...BaseDocumentFields,
-  type: import_zod16.z.literal("policy"),
-  policyNumber: import_zod16.z.string(),
-  effectiveDate: import_zod16.z.string(),
-  expirationDate: import_zod16.z.string().optional(),
+  type: import_zod17.z.literal("policy"),
+  policyNumber: import_zod17.z.string(),
+  effectiveDate: import_zod17.z.string(),
+  expirationDate: import_zod17.z.string().optional(),
   policyTermType: PolicyTermTypeSchema.optional(),
-  nextReviewDate: import_zod16.z.string().optional(),
-  effectiveTime: import_zod16.z.string().optional()
+  nextReviewDate: import_zod17.z.string().optional(),
+  effectiveTime: import_zod17.z.string().optional()
 });
-var QuoteDocumentSchema = import_zod16.z.object({
+var QuoteDocumentSchema = import_zod17.z.object({
   ...BaseDocumentFields,
-  type: import_zod16.z.literal("quote"),
-  quoteNumber: import_zod16.z.string(),
-  proposedEffectiveDate: import_zod16.z.string().optional(),
-  proposedExpirationDate: import_zod16.z.string().optional(),
-  quoteExpirationDate: import_zod16.z.string().optional(),
-  subjectivities: import_zod16.z.array(SubjectivitySchema).optional(),
-  underwritingConditions: import_zod16.z.array(UnderwritingConditionSchema).optional(),
-  premiumBreakdown: import_zod16.z.array(PremiumLineSchema).optional(),
+  type: import_zod17.z.literal("quote"),
+  quoteNumber: import_zod17.z.string(),
+  proposedEffectiveDate: import_zod17.z.string().optional(),
+  proposedExpirationDate: import_zod17.z.string().optional(),
+  quoteExpirationDate: import_zod17.z.string().optional(),
+  subjectivities: import_zod17.z.array(SubjectivitySchema).optional(),
+  underwritingConditions: import_zod17.z.array(UnderwritingConditionSchema).optional(),
+  premiumBreakdown: import_zod17.z.array(PremiumLineSchema).optional(),
   // Enriched quote fields (v1.2+)
-  enrichedSubjectivities: import_zod16.z.array(EnrichedSubjectivitySchema).optional(),
-  enrichedUnderwritingConditions: import_zod16.z.array(EnrichedUnderwritingConditionSchema).optional(),
-  warrantyRequirements: import_zod16.z.array(import_zod16.z.string()).optional(),
-  lossControlRecommendations: import_zod16.z.array(import_zod16.z.string()).optional(),
+  enrichedSubjectivities: import_zod17.z.array(EnrichedSubjectivitySchema).optional(),
+  enrichedUnderwritingConditions: import_zod17.z.array(EnrichedUnderwritingConditionSchema).optional(),
+  warrantyRequirements: import_zod17.z.array(import_zod17.z.string()).optional(),
+  lossControlRecommendations: import_zod17.z.array(import_zod17.z.string()).optional(),
   bindingAuthority: BindingAuthoritySchema.optional()
 });
-var InsuranceDocumentSchema = import_zod16.z.discriminatedUnion("type", [
+var InsuranceDocumentSchema = import_zod17.z.discriminatedUnion("type", [
   PolicyDocumentSchema,
   QuoteDocumentSchema
 ]);
 
 // src/schemas/platform.ts
-var import_zod17 = require("zod");
-var PlatformSchema = import_zod17.z.enum(["email", "chat", "sms", "slack", "discord"]);
-var CommunicationIntentSchema = import_zod17.z.enum(["direct", "mediated", "observed"]);
+var import_zod18 = require("zod");
+var PlatformSchema = import_zod18.z.enum(["email", "chat", "sms", "slack", "discord"]);
+var CommunicationIntentSchema = import_zod18.z.enum(["direct", "mediated", "observed"]);
 var PLATFORM_CONFIGS = {
   email: {
     supportsMarkdown: false,
@@ -1990,65 +2281,65 @@ var PLATFORM_CONFIGS = {
 };
 
 // src/schemas/pce.ts
-var import_zod19 = require("zod");
+var import_zod20 = require("zod");
 
 // src/case/index.ts
-var import_zod18 = require("zod");
-var CaseEvidenceSourceSchema = import_zod18.z.object({
-  id: import_zod18.z.string(),
-  label: import_zod18.z.string().optional(),
-  documentId: import_zod18.z.string().optional(),
-  page: import_zod18.z.number().optional(),
-  fieldPath: import_zod18.z.string().optional(),
-  text: import_zod18.z.string().describe("Source text available for span validation and citation"),
-  metadata: import_zod18.z.record(import_zod18.z.string(), import_zod18.z.string()).optional()
-});
-var CaseCitationSchema = import_zod18.z.object({
-  sourceId: import_zod18.z.string(),
-  quote: import_zod18.z.string(),
-  page: import_zod18.z.number().optional(),
-  fieldPath: import_zod18.z.string().optional()
-});
-var ValidationIssueSeveritySchema = import_zod18.z.enum(["info", "warning", "blocking"]);
-var CaseValidationIssueSchema = import_zod18.z.object({
-  code: import_zod18.z.string(),
+var import_zod19 = require("zod");
+var CaseEvidenceSourceSchema = import_zod19.z.object({
+  id: import_zod19.z.string(),
+  label: import_zod19.z.string().optional(),
+  documentId: import_zod19.z.string().optional(),
+  page: import_zod19.z.number().optional(),
+  fieldPath: import_zod19.z.string().optional(),
+  text: import_zod19.z.string().describe("Source text available for span validation and citation"),
+  metadata: import_zod19.z.record(import_zod19.z.string(), import_zod19.z.string()).optional()
+});
+var CaseCitationSchema = import_zod19.z.object({
+  sourceId: import_zod19.z.string(),
+  quote: import_zod19.z.string(),
+  page: import_zod19.z.number().optional(),
+  fieldPath: import_zod19.z.string().optional()
+});
+var ValidationIssueSeveritySchema = import_zod19.z.enum(["info", "warning", "blocking"]);
+var CaseValidationIssueSchema = import_zod19.z.object({
+  code: import_zod19.z.string(),
   severity: ValidationIssueSeveritySchema,
-  message: import_zod18.z.string(),
-  itemId: import_zod18.z.string().optional(),
-  fieldPath: import_zod18.z.string().optional(),
-  sourceId: import_zod18.z.string().optional()
-});
-var MissingInfoQuestionSchema = import_zod18.z.object({
-  id: import_zod18.z.string(),
-  itemId: import_zod18.z.string().optional(),
-  fieldPath: import_zod18.z.string().optional(),
-  question: import_zod18.z.string(),
-  reason: import_zod18.z.string(),
-  answer: import_zod18.z.string().optional()
-});
-var CasePacketArtifactKindSchema = import_zod18.z.enum([
+  message: import_zod19.z.string(),
+  itemId: import_zod19.z.string().optional(),
+  fieldPath: import_zod19.z.string().optional(),
+  sourceId: import_zod19.z.string().optional()
+});
+var MissingInfoQuestionSchema = import_zod19.z.object({
+  id: import_zod19.z.string(),
+  itemId: import_zod19.z.string().optional(),
+  fieldPath: import_zod19.z.string().optional(),
+  question: import_zod19.z.string(),
+  reason: import_zod19.z.string(),
+  answer: import_zod19.z.string().optional()
+});
+var CasePacketArtifactKindSchema = import_zod19.z.enum([
   "underwriter_summary",
   "carrier_email",
   "missing_info_request",
   "json_packet",
   "validation_report"
 ]);
-var CasePacketArtifactSchema = import_zod18.z.object({
-  id: import_zod18.z.string(),
+var CasePacketArtifactSchema = import_zod19.z.object({
+  id: import_zod19.z.string(),
   kind: CasePacketArtifactKindSchema,
-  title: import_zod18.z.string(),
-  content: import_zod18.z.string(),
-  citations: import_zod18.z.array(CaseCitationSchema).default([])
-});
-var CaseSubmissionPacketSchema = import_zod18.z.object({
-  id: import_zod18.z.string(),
-  caseId: import_zod18.z.string(),
-  artifacts: import_zod18.z.array(CasePacketArtifactSchema),
-  validationIssues: import_zod18.z.array(CaseValidationIssueSchema),
-  missingInfoQuestions: import_zod18.z.array(MissingInfoQuestionSchema),
-  createdAt: import_zod18.z.number()
-});
-var CaseActionSchema = import_zod18.z.enum([
+  title: import_zod19.z.string(),
+  content: import_zod19.z.string(),
+  citations: import_zod19.z.array(CaseCitationSchema).default([])
+});
+var CaseSubmissionPacketSchema = import_zod19.z.object({
+  id: import_zod19.z.string(),
+  caseId: import_zod19.z.string(),
+  artifacts: import_zod19.z.array(CasePacketArtifactSchema),
+  validationIssues: import_zod19.z.array(CaseValidationIssueSchema),
+  missingInfoQuestions: import_zod19.z.array(MissingInfoQuestionSchema),
+  createdAt: import_zod19.z.number()
+});
+var CaseActionSchema = import_zod19.z.enum([
   "inspect_attachments",
   "retrieve_policy_evidence",
   "retrieve_prior_applications",
@@ -2061,23 +2352,23 @@ var CaseActionSchema = import_zod18.z.enum([
   "generate_packet",
   "answer_field_or_case_question"
 ]);
-var AgenticExecutionModeSchema = import_zod18.z.enum(["deterministic_tree", "market_eval", "hybrid"]);
-var CaseProposalScoreSchema = import_zod18.z.object({
-  grounding: import_zod18.z.number().min(0).max(1),
-  completeness: import_zod18.z.number().min(0).max(1),
-  consistency: import_zod18.z.number().min(0).max(1),
-  determinism: import_zod18.z.number().min(0).max(1),
-  risk: import_zod18.z.number().min(0).max(1),
-  cost: import_zod18.z.number().min(0).max(1)
-});
-var CaseProposalSchema = import_zod18.z.object({
-  id: import_zod18.z.string(),
-  sourceSpanIds: import_zod18.z.array(import_zod18.z.string()).default([]),
-  confidence: import_zod18.z.number().min(0).max(1),
-  missingInfo: import_zod18.z.array(import_zod18.z.string()).default([]),
-  validationIssues: import_zod18.z.array(CaseValidationIssueSchema).default([]),
-  estimatedRisk: import_zod18.z.number().min(0).max(1).default(0.5),
-  estimatedCost: import_zod18.z.number().min(0).max(1).default(0.5),
+var AgenticExecutionModeSchema = import_zod19.z.enum(["deterministic_tree", "market_eval", "hybrid"]);
+var CaseProposalScoreSchema = import_zod19.z.object({
+  grounding: import_zod19.z.number().min(0).max(1),
+  completeness: import_zod19.z.number().min(0).max(1),
+  consistency: import_zod19.z.number().min(0).max(1),
+  determinism: import_zod19.z.number().min(0).max(1),
+  risk: import_zod19.z.number().min(0).max(1),
+  cost: import_zod19.z.number().min(0).max(1)
+});
+var CaseProposalSchema = import_zod19.z.object({
+  id: import_zod19.z.string(),
+  sourceSpanIds: import_zod19.z.array(import_zod19.z.string()).default([]),
+  confidence: import_zod19.z.number().min(0).max(1),
+  missingInfo: import_zod19.z.array(import_zod19.z.string()).default([]),
+  validationIssues: import_zod19.z.array(CaseValidationIssueSchema).default([]),
+  estimatedRisk: import_zod19.z.number().min(0).max(1).default(0.5),
+  estimatedCost: import_zod19.z.number().min(0).max(1).default(0.5),
   score: CaseProposalScoreSchema.optional()
 });
 function stableCaseId(prefix, parts) {
@@ -2196,8 +2487,8 @@ function totalProposalScore(score) {
 }
 
 // src/schemas/pce.ts
-var PolicyChangeActionSchema = import_zod19.z.enum(["add", "remove", "update", "replace", "clarify"]);
-var PolicyChangeKindSchema = import_zod19.z.enum([
+var PolicyChangeActionSchema = import_zod20.z.enum(["add", "remove", "update", "replace", "clarify"]);
+var PolicyChangeKindSchema = import_zod20.z.enum([
   "named_insured_change",
   "additional_insured_change",
   "coverage_change",
@@ -2211,70 +2502,70 @@ var PolicyChangeKindSchema = import_zod19.z.enum([
   "renewal_submission_update",
   "general_endorsement"
 ]);
-var PolicyChangeConfidenceSchema = import_zod19.z.enum(["high", "medium", "low"]);
-var PolicyChangeStatusSchema = import_zod19.z.enum(["draft", "needs_info", "ready", "blocked"]);
-var PolicyChangeItemSchema = import_zod19.z.object({
-  id: import_zod19.z.string(),
+var PolicyChangeConfidenceSchema = import_zod20.z.enum(["high", "medium", "low"]);
+var PolicyChangeStatusSchema = import_zod20.z.enum(["draft", "needs_info", "ready", "blocked"]);
+var PolicyChangeItemSchema = import_zod20.z.object({
+  id: import_zod20.z.string(),
   kind: PolicyChangeKindSchema.default("general_endorsement"),
   action: PolicyChangeActionSchema,
-  affectedPolicyId: import_zod19.z.string().default("unknown"),
-  fieldPath: import_zod19.z.string().describe("Stable policy field path or business field name"),
-  label: import_zod19.z.string(),
-  beforeValue: import_zod19.z.string().optional().describe("Existing policy value, when cited from policy evidence"),
-  afterValue: import_zod19.z.string().optional().describe("Requested new value"),
-  requestedValue: import_zod19.z.string().optional().describe("Alias for afterValue used by policy-change workflows"),
-  effectiveDate: import_zod19.z.string().optional(),
-  reason: import_zod19.z.string().optional(),
-  sourceIds: import_zod19.z.array(import_zod19.z.string()).default([]),
-  sourceSpanIds: import_zod19.z.array(import_zod19.z.string()).default([]),
-  userSourceSpanIds: import_zod19.z.array(import_zod19.z.string()).optional(),
-  citations: import_zod19.z.array(CaseCitationSchema).default([]),
+  affectedPolicyId: import_zod20.z.string().default("unknown"),
+  fieldPath: import_zod20.z.string().describe("Stable policy field path or business field name"),
+  label: import_zod20.z.string(),
+  beforeValue: import_zod20.z.string().optional().describe("Existing policy value, when cited from policy evidence"),
+  afterValue: import_zod20.z.string().optional().describe("Requested new value"),
+  requestedValue: import_zod20.z.string().optional().describe("Alias for afterValue used by policy-change workflows"),
+  effectiveDate: import_zod20.z.string().optional(),
+  reason: import_zod20.z.string().optional(),
+  sourceIds: import_zod20.z.array(import_zod20.z.string()).default([]),
+  sourceSpanIds: import_zod20.z.array(import_zod20.z.string()).default([]),
+  userSourceSpanIds: import_zod20.z.array(import_zod20.z.string()).optional(),
+  citations: import_zod20.z.array(CaseCitationSchema).default([]),
   confidence: PolicyChangeConfidenceSchema.default("medium"),
-  confidenceScore: import_zod19.z.number().min(0).max(1).optional(),
+  confidenceScore: import_zod20.z.number().min(0).max(1).optional(),
   status: PolicyChangeStatusSchema.default("ready")
 });
-var PceNormalizationResultSchema = import_zod19.z.object({
-  summary: import_zod19.z.string(),
-  items: import_zod19.z.array(PolicyChangeItemSchema.omit({ id: true, status: true }).extend({
-    id: import_zod19.z.string().optional(),
+var PceNormalizationResultSchema = import_zod20.z.object({
+  summary: import_zod20.z.string(),
+  items: import_zod20.z.array(PolicyChangeItemSchema.omit({ id: true, status: true }).extend({
+    id: import_zod20.z.string().optional(),
     status: PolicyChangeStatusSchema.optional()
   })),
-  missingInfoQuestions: import_zod19.z.array(MissingInfoQuestionSchema.omit({ id: true }).extend({
-    id: import_zod19.z.string().optional()
+  missingInfoQuestions: import_zod20.z.array(MissingInfoQuestionSchema.omit({ id: true }).extend({
+    id: import_zod20.z.string().optional()
   })).default([])
 });
-var PolicyChangeImpactSchema = import_zod19.z.object({
-  itemId: import_zod19.z.string(),
-  beforeValue: import_zod19.z.string().optional(),
-  requestedValue: import_zod19.z.string().optional(),
-  likelyEndorsementRequired: import_zod19.z.boolean().default(true),
-  carrierApprovalLikelyRequired: import_zod19.z.boolean().default(true),
-  affectedCoverageForms: import_zod19.z.array(import_zod19.z.string()).default([]),
-  sourceSpanIds: import_zod19.z.array(import_zod19.z.string()).default([])
-});
-var PceCaseStateSchema = import_zod19.z.object({
-  id: import_zod19.z.string(),
-  requestText: import_zod19.z.string(),
-  summary: import_zod19.z.string(),
+var PolicyChangeImpactSchema = import_zod20.z.object({
+  itemId: import_zod20.z.string(),
+  beforeValue: import_zod20.z.string().optional(),
+  requestedValue: import_zod20.z.string().optional(),
+  likelyEndorsementRequired: import_zod20.z.boolean().default(true),
+  carrierApprovalLikelyRequired: import_zod20.z.boolean().default(true),
+  affectedCoverageForms: import_zod20.z.array(import_zod20.z.string()).default([]),
+  sourceSpanIds: import_zod20.z.array(import_zod20.z.string()).default([])
+});
+var PceCaseStateSchema = import_zod20.z.object({
+  id: import_zod20.z.string(),
+  requestText: import_zod20.z.string(),
+  summary: import_zod20.z.string(),
   executionMode: AgenticExecutionModeSchema.default("deterministic_tree"),
-  items: import_zod19.z.array(PolicyChangeItemSchema),
-  impacts: import_zod19.z.array(PolicyChangeImpactSchema),
-  evidenceSources: import_zod19.z.array(CaseEvidenceSourceSchema),
-  validationIssues: import_zod19.z.array(CaseValidationIssueSchema),
-  missingInfoQuestions: import_zod19.z.array(MissingInfoQuestionSchema),
-  createdAt: import_zod19.z.number(),
-  updatedAt: import_zod19.z.number()
-});
-var PolicyChangeRequestSchema = import_zod19.z.object({
-  id: import_zod19.z.string(),
-  text: import_zod19.z.string(),
+  items: import_zod20.z.array(PolicyChangeItemSchema),
+  impacts: import_zod20.z.array(PolicyChangeImpactSchema),
+  evidenceSources: import_zod20.z.array(CaseEvidenceSourceSchema),
+  validationIssues: import_zod20.z.array(CaseValidationIssueSchema),
+  missingInfoQuestions: import_zod20.z.array(MissingInfoQuestionSchema),
+  createdAt: import_zod20.z.number(),
+  updatedAt: import_zod20.z.number()
+});
+var PolicyChangeRequestSchema = import_zod20.z.object({
+  id: import_zod20.z.string(),
+  text: import_zod20.z.string(),
   executionMode: AgenticExecutionModeSchema.optional(),
-  userSourceSpanIds: import_zod19.z.array(import_zod19.z.string()).optional(),
-  createdAt: import_zod19.z.number().optional()
+  userSourceSpanIds: import_zod20.z.array(import_zod20.z.string()).optional(),
+  createdAt: import_zod20.z.number().optional()
 });
 var PceSubmissionPacketSchema = CaseSubmissionPacketSchema.extend({
   pceCase: PceCaseStateSchema,
-  artifacts: import_zod19.z.array(CasePacketArtifactSchema)
+  artifacts: import_zod20.z.array(CasePacketArtifactSchema)
 });
 
 // src/schemas/context-keys.ts
@@ -2292,7 +2583,7 @@ var CONTEXT_KEY_MAP = [
   { extractedField: "totalPremium", category: "financial", contextKey: "current_premium", description: "Total policy premium" },
   { extractedField: "locations[].buildingValue", category: "financial", contextKey: "total_property_values", description: "Sum of building values" },
   { extractedField: "locations[].contentsValue", category: "financial", contextKey: "total_contents_values", description: "Sum of contents values" },
-  { extractedField: "policyTypes", category: "coverage", contextKey: "coverage_types", description: "Lines of business covered" },
+  { extractedField: "linesOfBusiness", category: "coverage", contextKey: "coverage_types", description: "ACORD lines of business covered" },
   { extractedField: "coverages[].limit", category: "coverage", contextKey: "current_limits", description: "Current coverage limits" },
   { extractedField: "coverages[].deductible", category: "coverage", contextKey: "current_deductibles", description: "Current deductibles" },
   { extractedField: "experienceMod.factor", category: "loss_history", contextKey: "experience_mod", description: "Workers comp experience modification factor" },
@@ -2330,8 +2621,8 @@ var CONTEXT_KEY_MAP = [
 ];
 
 // src/source/schemas.ts
-var import_zod20 = require("zod");
-var SourceSpanKindSchema = import_zod20.z.enum([
+var import_zod21 = require("zod");
+var SourceSpanKindSchema = import_zod21.z.enum([
   "pdf_text",
   "pdf_image",
   "html",
@@ -2339,7 +2630,7 @@ var SourceSpanKindSchema = import_zod20.z.enum([
   "plain_text",
   "structured_field"
 ]);
-var SourceSpanUnitSchema = import_zod20.z.enum([
+var SourceSpanUnitSchema = import_zod21.z.enum([
   "page",
   "section",
   "table",
@@ -2348,78 +2639,78 @@ var SourceSpanUnitSchema = import_zod20.z.enum([
   "key_value",
   "text"
 ]);
-var SourceKindSchema = import_zod20.z.enum([
+var SourceKindSchema = import_zod21.z.enum([
   "policy_pdf",
   "application_pdf",
   "email",
   "attachment",
   "manual_note"
 ]);
-var SourceSpanBBoxSchema = import_zod20.z.object({
-  page: import_zod20.z.number().int().positive(),
-  x: import_zod20.z.number(),
-  y: import_zod20.z.number(),
-  width: import_zod20.z.number(),
-  height: import_zod20.z.number()
-});
-var SourceSpanLocationSchema = import_zod20.z.object({
-  page: import_zod20.z.number().int().positive().optional(),
-  startPage: import_zod20.z.number().int().positive().optional(),
-  endPage: import_zod20.z.number().int().positive().optional(),
-  charStart: import_zod20.z.number().int().nonnegative().optional(),
-  charEnd: import_zod20.z.number().int().nonnegative().optional(),
-  lineStart: import_zod20.z.number().int().positive().optional(),
-  lineEnd: import_zod20.z.number().int().positive().optional(),
-  fieldPath: import_zod20.z.string().optional()
-});
-var SourceSpanTableLocationSchema = import_zod20.z.object({
-  tableId: import_zod20.z.string().optional(),
-  rowIndex: import_zod20.z.number().int().nonnegative().optional(),
-  columnIndex: import_zod20.z.number().int().nonnegative().optional(),
-  columnName: import_zod20.z.string().optional(),
-  rowSpanId: import_zod20.z.string().optional(),
-  tableSpanId: import_zod20.z.string().optional(),
-  isHeader: import_zod20.z.boolean().optional()
-});
-var SourceSpanSchema = import_zod20.z.object({
-  id: import_zod20.z.string().min(1),
-  documentId: import_zod20.z.string().min(1),
+var SourceSpanBBoxSchema = import_zod21.z.object({
+  page: import_zod21.z.number().int().positive(),
+  x: import_zod21.z.number(),
+  y: import_zod21.z.number(),
+  width: import_zod21.z.number(),
+  height: import_zod21.z.number()
+});
+var SourceSpanLocationSchema = import_zod21.z.object({
+  page: import_zod21.z.number().int().positive().optional(),
+  startPage: import_zod21.z.number().int().positive().optional(),
+  endPage: import_zod21.z.number().int().positive().optional(),
+  charStart: import_zod21.z.number().int().nonnegative().optional(),
+  charEnd: import_zod21.z.number().int().nonnegative().optional(),
+  lineStart: import_zod21.z.number().int().positive().optional(),
+  lineEnd: import_zod21.z.number().int().positive().optional(),
+  fieldPath: import_zod21.z.string().optional()
+});
+var SourceSpanTableLocationSchema = import_zod21.z.object({
+  tableId: import_zod21.z.string().optional(),
+  rowIndex: import_zod21.z.number().int().nonnegative().optional(),
+  columnIndex: import_zod21.z.number().int().nonnegative().optional(),
+  columnName: import_zod21.z.string().optional(),
+  rowSpanId: import_zod21.z.string().optional(),
+  tableSpanId: import_zod21.z.string().optional(),
+  isHeader: import_zod21.z.boolean().optional()
+});
+var SourceSpanSchema = import_zod21.z.object({
+  id: import_zod21.z.string().min(1),
+  documentId: import_zod21.z.string().min(1),
   sourceKind: SourceKindSchema.optional(),
-  chunkId: import_zod20.z.string().optional(),
+  chunkId: import_zod21.z.string().optional(),
   kind: SourceSpanKindSchema,
-  text: import_zod20.z.string(),
-  hash: import_zod20.z.string().min(1),
-  textHash: import_zod20.z.string().optional(),
-  pageStart: import_zod20.z.number().int().positive().optional(),
-  pageEnd: import_zod20.z.number().int().positive().optional(),
-  sectionId: import_zod20.z.string().optional(),
-  formNumber: import_zod20.z.string().optional(),
+  text: import_zod21.z.string(),
+  hash: import_zod21.z.string().min(1),
+  textHash: import_zod21.z.string().optional(),
+  pageStart: import_zod21.z.number().int().positive().optional(),
+  pageEnd: import_zod21.z.number().int().positive().optional(),
+  sectionId: import_zod21.z.string().optional(),
+  formNumber: import_zod21.z.string().optional(),
   sourceUnit: SourceSpanUnitSchema.optional(),
-  parentSpanId: import_zod20.z.string().optional(),
+  parentSpanId: import_zod21.z.string().optional(),
   table: SourceSpanTableLocationSchema.optional(),
-  bbox: import_zod20.z.array(SourceSpanBBoxSchema).optional(),
+  bbox: import_zod21.z.array(SourceSpanBBoxSchema).optional(),
   location: SourceSpanLocationSchema.optional(),
-  metadata: import_zod20.z.record(import_zod20.z.string(), import_zod20.z.string()).optional()
-});
-var SourceSpanRefSchema = import_zod20.z.object({
-  sourceSpanId: import_zod20.z.string().min(1),
-  documentId: import_zod20.z.string().min(1).optional(),
-  chunkId: import_zod20.z.string().optional(),
-  quote: import_zod20.z.string().optional(),
-  hash: import_zod20.z.string().optional(),
+  metadata: import_zod21.z.record(import_zod21.z.string(), import_zod21.z.string()).optional()
+});
+var SourceSpanRefSchema = import_zod21.z.object({
+  sourceSpanId: import_zod21.z.string().min(1),
+  documentId: import_zod21.z.string().min(1).optional(),
+  chunkId: import_zod21.z.string().optional(),
+  quote: import_zod21.z.string().optional(),
+  hash: import_zod21.z.string().optional(),
   location: SourceSpanLocationSchema.optional()
 });
-var SourceChunkSchema = import_zod20.z.object({
-  id: import_zod20.z.string().min(1),
-  documentId: import_zod20.z.string().min(1),
-  sourceSpanIds: import_zod20.z.array(import_zod20.z.string().min(1)),
-  text: import_zod20.z.string(),
-  textHash: import_zod20.z.string().min(1),
-  pageStart: import_zod20.z.number().int().positive().optional(),
-  pageEnd: import_zod20.z.number().int().positive().optional(),
-  metadata: import_zod20.z.record(import_zod20.z.string(), import_zod20.z.string()).default({})
-});
-var DocumentSourceNodeKindSchema = import_zod20.z.enum([
+var SourceChunkSchema = import_zod21.z.object({
+  id: import_zod21.z.string().min(1),
+  documentId: import_zod21.z.string().min(1),
+  sourceSpanIds: import_zod21.z.array(import_zod21.z.string().min(1)),
+  text: import_zod21.z.string(),
+  textHash: import_zod21.z.string().min(1),
+  pageStart: import_zod21.z.number().int().positive().optional(),
+  pageEnd: import_zod21.z.number().int().positive().optional(),
+  metadata: import_zod21.z.record(import_zod21.z.string(), import_zod21.z.string()).default({})
+});
+var DocumentSourceNodeKindSchema = import_zod21.z.enum([
   "document",
   "page_group",
   "page",
@@ -2433,31 +2724,31 @@ var DocumentSourceNodeKindSchema = import_zod20.z.enum([
   "table_cell",
   "text"
 ]);
-var DocumentSourceNodeSchema = import_zod20.z.object({
-  id: import_zod20.z.string().min(1),
-  documentId: import_zod20.z.string().min(1),
-  parentId: import_zod20.z.string().optional(),
+var DocumentSourceNodeSchema = import_zod21.z.object({
+  id: import_zod21.z.string().min(1),
+  documentId: import_zod21.z.string().min(1),
+  parentId: import_zod21.z.string().optional(),
   kind: DocumentSourceNodeKindSchema,
-  title: import_zod20.z.string(),
-  description: import_zod20.z.string(),
-  textExcerpt: import_zod20.z.string().optional(),
-  sourceSpanIds: import_zod20.z.array(import_zod20.z.string().min(1)),
-  pageStart: import_zod20.z.number().int().positive().optional(),
-  pageEnd: import_zod20.z.number().int().positive().optional(),
-  bbox: import_zod20.z.array(SourceSpanBBoxSchema).optional(),
-  order: import_zod20.z.number().int().nonnegative(),
-  path: import_zod20.z.string(),
-  metadata: import_zod20.z.record(import_zod20.z.string(), import_zod20.z.unknown()).optional()
-});
-var SourceBackedValueSchema = import_zod20.z.object({
-  value: import_zod20.z.string(),
-  normalizedValue: import_zod20.z.string().optional(),
-  confidence: import_zod20.z.enum(["low", "medium", "high"]).default("medium"),
-  sourceNodeIds: import_zod20.z.array(import_zod20.z.string().min(1)).default([]),
-  sourceSpanIds: import_zod20.z.array(import_zod20.z.string().min(1)).default([])
-});
-var OperationalCoverageTermSchema = import_zod20.z.object({
-  kind: import_zod20.z.enum([
+  title: import_zod21.z.string(),
+  description: import_zod21.z.string(),
+  textExcerpt: import_zod21.z.string().optional(),
+  sourceSpanIds: import_zod21.z.array(import_zod21.z.string().min(1)),
+  pageStart: import_zod21.z.number().int().positive().optional(),
+  pageEnd: import_zod21.z.number().int().positive().optional(),
+  bbox: import_zod21.z.array(SourceSpanBBoxSchema).optional(),
+  order: import_zod21.z.number().int().nonnegative(),
+  path: import_zod21.z.string(),
+  metadata: import_zod21.z.record(import_zod21.z.string(), import_zod21.z.unknown()).optional()
+});
+var SourceBackedValueSchema = import_zod21.z.object({
+  value: import_zod21.z.string(),
+  normalizedValue: import_zod21.z.string().optional(),
+  confidence: import_zod21.z.enum(["low", "medium", "high"]).default("medium"),
+  sourceNodeIds: import_zod21.z.array(import_zod21.z.string().min(1)).default([]),
+  sourceSpanIds: import_zod21.z.array(import_zod21.z.string().min(1)).default([])
+});
+var OperationalCoverageTermSchema = import_zod21.z.object({
+  kind: import_zod21.z.enum([
     "each_claim_limit",
     "each_occurrence_limit",
     "each_loss_limit",
@@ -2469,182 +2760,132 @@ var OperationalCoverageTermSchema = import_zod20.z.object({
     "premium",
     "other"
   ]).default("other"),
-  label: import_zod20.z.string(),
-  value: import_zod20.z.string(),
-  amount: import_zod20.z.number().optional(),
-  appliesTo: import_zod20.z.string().optional(),
-  sourceNodeIds: import_zod20.z.array(import_zod20.z.string().min(1)).default([]),
-  sourceSpanIds: import_zod20.z.array(import_zod20.z.string().min(1)).default([])
-});
-var OperationalCoverageLineSchema = import_zod20.z.object({
-  name: import_zod20.z.string(),
-  coverageCode: import_zod20.z.string().optional(),
-  limit: import_zod20.z.string().optional(),
-  deductible: import_zod20.z.string().optional(),
-  premium: import_zod20.z.string().optional(),
-  retroactiveDate: import_zod20.z.string().optional(),
-  formNumber: import_zod20.z.string().optional(),
-  sectionRef: import_zod20.z.string().optional(),
-  endorsementNumber: import_zod20.z.string().optional(),
-  limits: import_zod20.z.array(OperationalCoverageTermSchema).default([]),
-  sourceNodeIds: import_zod20.z.array(import_zod20.z.string().min(1)).default([]),
-  sourceSpanIds: import_zod20.z.array(import_zod20.z.string().min(1)).default([])
-});
-var OperationalPartySchema = import_zod20.z.object({
-  role: import_zod20.z.string(),
-  name: import_zod20.z.string(),
-  sourceNodeIds: import_zod20.z.array(import_zod20.z.string().min(1)).default([]),
-  sourceSpanIds: import_zod20.z.array(import_zod20.z.string().min(1)).default([])
-});
-var OperationalEndorsementSupportSchema = import_zod20.z.object({
-  kind: import_zod20.z.string(),
-  status: import_zod20.z.enum(["supported", "excluded", "requires_review"]),
-  summary: import_zod20.z.string(),
-  sourceNodeIds: import_zod20.z.array(import_zod20.z.string().min(1)).default([]),
-  sourceSpanIds: import_zod20.z.array(import_zod20.z.string().min(1)).default([])
-});
-var PolicyOperationalProfileSchema = import_zod20.z.object({
-  documentType: import_zod20.z.enum(["policy", "quote"]).default("policy"),
-  policyTypes: import_zod20.z.array(import_zod20.z.string()).default(["other"]),
-  policyNumber: SourceBackedValueSchema.optional(),
-  namedInsured: SourceBackedValueSchema.optional(),
-  insurer: SourceBackedValueSchema.optional(),
-  broker: SourceBackedValueSchema.optional(),
-  effectiveDate: SourceBackedValueSchema.optional(),
-  expirationDate: SourceBackedValueSchema.optional(),
-  retroactiveDate: SourceBackedValueSchema.optional(),
-  premium: SourceBackedValueSchema.optional(),
-  coverages: import_zod20.z.array(OperationalCoverageLineSchema).default([]),
-  parties: import_zod20.z.array(OperationalPartySchema).default([]),
-  endorsementSupport: import_zod20.z.array(OperationalEndorsementSupportSchema).default([]),
-  sourceNodeIds: import_zod20.z.array(import_zod20.z.string().min(1)).default([]),
-  sourceSpanIds: import_zod20.z.array(import_zod20.z.string().min(1)).default([]),
-  warnings: import_zod20.z.array(import_zod20.z.string()).default([])
-});
+  label: import_zod21.z.string(),
+  value: import_zod21.z.string(),
+  amount: import_zod21.z.number().optional(),
+  appliesTo: import_zod21.z.string().optional(),
+  sourceNodeIds: import_zod21.z.array(import_zod21.z.string().min(1)).default([]),
+  sourceSpanIds: import_zod21.z.array(import_zod21.z.string().min(1)).default([])
+});
+var OperationalCoverageLineSchema = import_zod21.z.object({
+  name: import_zod21.z.string(),
+  coverageCode: import_zod21.z.string().optional(),
+  limit: import_zod21.z.string().optional(),
+  deductible: import_zod21.z.string().optional(),
+  premium: import_zod21.z.string().optional(),
+  retroactiveDate: import_zod21.z.string().optional(),
+  formNumber: import_zod21.z.string().optional(),
+  sectionRef: import_zod21.z.string().optional(),
+  endorsementNumber: import_zod21.z.string().optional(),
+  limits: import_zod21.z.array(OperationalCoverageTermSchema).default([]),
+  sourceNodeIds: import_zod21.z.array(import_zod21.z.string().min(1)).default([]),
+  sourceSpanIds: import_zod21.z.array(import_zod21.z.string().min(1)).default([])
+});
+var OperationalPartySchema = import_zod21.z.object({
+  role: import_zod21.z.string(),
+  name: import_zod21.z.string(),
+  sourceNodeIds: import_zod21.z.array(import_zod21.z.string().min(1)).default([]),
+  sourceSpanIds: import_zod21.z.array(import_zod21.z.string().min(1)).default([])
+});
+var OperationalEndorsementSupportSchema = import_zod21.z.object({
+  kind: import_zod21.z.string(),
+  status: import_zod21.z.enum(["supported", "excluded", "requires_review"]),
+  summary: import_zod21.z.string(),
+  sourceNodeIds: import_zod21.z.array(import_zod21.z.string().min(1)).default([]),
+  sourceSpanIds: import_zod21.z.array(import_zod21.z.string().min(1)).default([])
+});
+function legacyOperationalProfileInput(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return value;
+  const record = value;
+  if ("linesOfBusiness" in record) return value;
+  if (!("policyTypes" in record)) return value;
+  return {
+    ...record,
+    linesOfBusiness: record.policyTypes
+  };
+}
+var OperationalLinesOfBusinessSchema = import_zod21.z.preprocess(
+  (value) => Array.isArray(value) ? toLobCodes(value.filter((item) => typeof item === "string")) : void 0,
+  import_zod21.z.array(AcordLobCodeSchema).default(["UN"])
+);
+var PolicyOperationalProfileSchema = import_zod21.z.preprocess(
+  legacyOperationalProfileInput,
+  import_zod21.z.object({
+    documentType: import_zod21.z.enum(["policy", "quote"]).default("policy"),
+    linesOfBusiness: OperationalLinesOfBusinessSchema,
+    policyNumber: SourceBackedValueSchema.optional(),
+    namedInsured: SourceBackedValueSchema.optional(),
+    insurer: SourceBackedValueSchema.optional(),
+    broker: SourceBackedValueSchema.optional(),
+    effectiveDate: SourceBackedValueSchema.optional(),
+    expirationDate: SourceBackedValueSchema.optional(),
+    retroactiveDate: SourceBackedValueSchema.optional(),
+    premium: SourceBackedValueSchema.optional(),
+    coverages: import_zod21.z.array(OperationalCoverageLineSchema).default([]),
+    parties: import_zod21.z.array(OperationalPartySchema).default([]),
+    endorsementSupport: import_zod21.z.array(OperationalEndorsementSupportSchema).default([]),
+    sourceNodeIds: import_zod21.z.array(import_zod21.z.string().min(1)).default([]),
+    sourceSpanIds: import_zod21.z.array(import_zod21.z.string().min(1)).default([]),
+    warnings: import_zod21.z.array(import_zod21.z.string()).default([])
+  })
+);
 
 // src/source/policy-types.ts
-var POLICY_TYPE_KEYS = new Set(POLICY_TYPES);
-var POLICY_TYPE_ALIASES = {
-  "general liability": "general_liability",
-  "commercial general liability": "general_liability",
-  cgl: "general_liability",
-  "commercial property": "commercial_property",
-  property: "property",
-  "property insurance": "commercial_property",
-  "commercial auto": "commercial_auto",
-  "commercial automobile": "commercial_auto",
-  "business auto": "commercial_auto",
-  "business automobile": "commercial_auto",
-  "auto physical damage": "commercial_auto",
-  "automobile physical damage": "commercial_auto",
-  "hired non owned auto": "non_owned_auto",
-  "hired non-owned auto": "non_owned_auto",
-  "non owned auto": "non_owned_auto",
-  "non-owned auto": "non_owned_auto",
-  "workers comp": "workers_comp",
-  "workers compensation": "workers_comp",
-  "workers' compensation": "workers_comp",
-  umbrella: "umbrella",
-  "excess liability": "excess_liability",
-  "professional liability": "professional_liability",
-  "errors and omissions": "professional_liability",
-  "e&o": "professional_liability",
-  cyber: "cyber",
-  "cyber liability": "cyber",
-  "network security": "cyber",
-  "privacy liability": "cyber",
-  epli: "epli",
-  "employment practices liability": "epli",
-  "directors and officers": "directors_officers",
-  "directors & officers": "directors_officers",
-  "d&o": "directors_officers",
-  "fiduciary liability insurance": "fiduciary_liability",
-  "crime insurance": "crime_fidelity",
-  "fidelity bond": "crime_fidelity",
-  "inland marine insurance": "inland_marine",
-  "motor truck cargo": "inland_marine",
-  "motor truck cargo legal liability": "inland_marine",
-  "builders risk insurance": "builders_risk",
-  "pollution liability": "environmental",
-  "premises pollution liability": "environmental",
-  "environmental liability": "environmental",
-  "ocean marine insurance": "ocean_marine",
-  "surety bond": "surety",
-  "product liability insurance": "product_liability",
-  "life insurance": "life",
-  "permanent life": "life",
-  "term life": "life",
-  "whole life": "life",
-  "universal life": "life",
-  "critical illness": "critical_illness",
-  "critical illness insurance": "critical_illness",
-  "disability insurance": "disability",
-  "long term care": "long_term_care",
-  "long-term care": "long_term_care"
-};
-var POLICY_TYPE_TEXT_PATTERNS = [
-  { type: "general_liability", pattern: /\b(?:commercial\s+)?general\s+liability\b|\bcgl\b/i },
-  { type: "commercial_property", pattern: /\bcommercial\s+property\b|\bproperty\s+insurance\b/i },
-  { type: "commercial_auto", pattern: /\bcommercial\s+auto(?:mobile)?\b|\bbusiness\s+auto(?:mobile)?\b|\bauto(?:mobile)?\s+physical\s+damage\b/i },
-  { type: "non_owned_auto", pattern: /\b(?:hired\s+(?:and\s+)?)?non[-\s]?owned\s+auto\b/i },
-  { type: "workers_comp", pattern: /\bworkers['’]?\s+comp(?:ensation)?\b/i },
-  { type: "umbrella", pattern: /\bcommercial\s+umbrella\b|\bumbrella\s+liability\b/i },
-  { type: "excess_liability", pattern: /\bexcess\s+liability\b/i },
-  { type: "professional_liability", pattern: /\bprofessional\s+liability\b|\berrors?\s*(?:and|&)\s*omissions?\b|\be&o\b/i },
-  { type: "cyber", pattern: /\bcyber\b|\bnetwork\s+security\b|\bprivacy\s+liability\b/i },
-  { type: "epli", pattern: /\bemployment\s+practices?\s+liability\b|\bepli\b/i },
-  { type: "directors_officers", pattern: /\bdirectors?\s*(?:and|&)\s*officers?\b|\bd&o\b/i },
-  { type: "fiduciary_liability", pattern: /\bfiduciary\s+liability\b/i },
-  { type: "crime_fidelity", pattern: /\bcrime\b|\bfidelity\b/i },
-  { type: "inland_marine", pattern: /\binland\s+marine\b|\bmotor\s+truck\s+cargo\b|\bcargo\s+legal\s+liability\b/i },
-  { type: "builders_risk", pattern: /\bbuilders?\s+risk\b/i },
-  { type: "environmental", pattern: /\bpollution\s+liability\b|\benvironmental\s+liability\b/i },
-  { type: "ocean_marine", pattern: /\bocean\s+marine\b/i },
-  { type: "surety", pattern: /\bsurety\b/i },
-  { type: "product_liability", pattern: /\bproduct\s+liability\b|\bproducts?\s+completed\s+operations\b/i },
-  { type: "bop", pattern: /\bbusiness\s*owners?\s+policy\b|\bbop\b/i },
-  { type: "homeowners_ho3", pattern: /\bhomeowners?\s*(?:ho[-\s]?3)?\b/i },
-  { type: "homeowners_ho5", pattern: /\bho[-\s]?5\b/i },
-  { type: "renters_ho4", pattern: /\brenters?\b|\bho[-\s]?4\b/i },
-  { type: "condo_ho6", pattern: /\bcondo(?:minium)?\b|\bho[-\s]?6\b/i },
-  { type: "dwelling_fire", pattern: /\bdwelling\s+fire\b/i },
-  { type: "personal_auto", pattern: /\bpersonal\s+auto\b/i },
-  { type: "personal_umbrella", pattern: /\bpersonal\s+umbrella\b/i },
-  { type: "flood_private", pattern: /\bflood\b/i },
-  { type: "earthquake", pattern: /\bearthquake\b/i },
-  { type: "personal_inland_marine", pattern: /\bpersonal\s+(?:articles|inland\s+marine)\b/i },
-  { type: "watercraft", pattern: /\bwatercraft\b|\bboat\s+insurance\b/i },
-  { type: "recreational_vehicle", pattern: /\brecreational\s+vehicle\b|\brv\s+insurance\b/i },
-  { type: "farm_ranch", pattern: /\bfarm\b|\branch\b/i },
-  { type: "life", pattern: /\blife\s+insurance\b|\bterm\s+life\b|\bwhole\s+life\b|\buniversal\s+life\b/i },
-  { type: "critical_illness", pattern: /\bcritical\s+illness\b/i },
-  { type: "disability", pattern: /\bdisability\s+insurance\b|\btotal\s+disability\b/i },
-  { type: "long_term_care", pattern: /\blong[-\s]?term\s+care\b/i },
-  { type: "pet", pattern: /\bpet\s+insurance\b/i },
-  { type: "travel", pattern: /\btravel\s+insurance\b/i },
-  { type: "identity_theft", pattern: /\bidentity\s+theft\b/i },
-  { type: "title", pattern: /\btitle\s+insurance\b/i }
+var LOB_TEXT_PATTERNS = [
+  { codes: ["CGL"], pattern: /\b(?:commercial\s+)?general\s+liability\b|\bcgl\b/i },
+  { codes: ["PROPC"], pattern: /\bcommercial\s+property\b|\bproperty\s+insurance\b/i },
+  { codes: ["PROP"], pattern: /\bproperty\b/i },
+  { codes: ["AUTOB"], pattern: /\bcommercial\s+auto(?:mobile)?\b|\bbusiness\s+auto(?:mobile)?\b|\bauto(?:mobile)?\s+physical\s+damage\b/i },
+  { codes: ["AUTOB"], pattern: /\b(?:hired\s+(?:and\s+)?)?non[-\s]?owned\s+auto\b/i },
+  { codes: ["WORK"], pattern: /\bworkers['’]?\s+comp(?:ensation)?\b/i },
+  { codes: ["UMBRC"], pattern: /\bcommercial\s+umbrella\b|\bumbrella\s+liability\b/i },
+  { codes: ["EXLIA"], pattern: /\bexcess\s+liability\b/i },
+  { codes: ["EO"], pattern: /\bprofessional\s+liability\b|\berrors?\s*(?:and|&)\s*omissions?\b|\be&o\b/i },
+  { codes: ["OLIB"], pattern: /\bcyber\b|\bnetwork\s+security\b|\bprivacy\s+liability\b/i },
+  { codes: ["EPLI"], pattern: /\bemployment\s+practices?\s+liability\b|\bepli\b/i },
+  { codes: ["DO"], pattern: /\bdirectors?\s*(?:and|&)\s*officers?\b|\bd&o\b/i },
+  { codes: ["FIDUC"], pattern: /\bfiduciary\s+liability\b/i },
+  { codes: ["CRIME"], pattern: /\bcrime\b|\bfidelity\b/i },
+  { codes: ["INMRC"], pattern: /\binland\s+marine\b|\bmotor\s+truck\s+cargo\b|\bcargo\s+legal\s+liability\b/i },
+  { codes: ["INMRC"], pattern: /\bbuilders?\s+risk\b/i },
+  { codes: ["OLIB"], pattern: /\bpollution\s+liability\b|\benvironmental\s+liability\b/i },
+  { codes: ["COMAR"], pattern: /\bocean\s+marine\b/i },
+  { codes: ["SURE"], pattern: /\bsurety\b/i },
+  { codes: ["OLIB"], pattern: /\bproduct\s+liability\b|\bproducts?\s+completed\s+operations\b/i },
+  { codes: ["BOP"], pattern: /\bbusiness\s*owners?\s+policy\b|\bbop\b/i },
+  { codes: ["DO", "EPLI", "FIDUC"], pattern: /\bmanagement\s+liability\b/i },
+  { codes: ["HOME"], pattern: /\bhomeowners?\s*(?:ho[-\s]?[35])?\b|\bho[-\s]?[35]\b/i },
+  { codes: ["HOME"], pattern: /\brenters?\b|\bho[-\s]?4\b/i },
+  { codes: ["HOME"], pattern: /\bcondo(?:minium)?\b|\bho[-\s]?6\b/i },
+  { codes: ["DFIRE"], pattern: /\bdwelling\s+fire\b/i },
+  { codes: ["MHOME"], pattern: /\bmobile\s+home\b|\bmanufactured\s+home\b/i },
+  { codes: ["AUTOP"], pattern: /\bpersonal\s+auto\b/i },
+  { codes: ["UMBRP"], pattern: /\bpersonal\s+umbrella\b/i },
+  { codes: ["FLOOD"], pattern: /\bflood\b/i },
+  { codes: ["EQ"], pattern: /\bearthquake\b/i },
+  { codes: ["INMRP"], pattern: /\bpersonal\s+(?:articles|inland\s+marine)\b/i },
+  { codes: ["BOAT"], pattern: /\bwatercraft\b|\bboat\s+insurance\b/i },
+  { codes: ["RECV"], pattern: /\brecreational\s+vehicle\b|\brv\s+insurance\b/i },
+  { codes: ["CFRM"], pattern: /\bfarm\b|\branch\b/i },
+  { codes: ["UN"], pattern: /\blife\s+insurance\b|\bterm\s+life\b|\bwhole\s+life\b|\buniversal\s+life\b/i },
+  { codes: ["DISAB"], pattern: /\bcritical\s+illness\b|\bdisability\s+insurance\b|\btotal\s+disability\b/i },
+  { codes: ["UN"], pattern: /\blong[-\s]?term\s+care\b|\bpet\s+insurance\b|\btravel\s+insurance\b|\bidentity\s+theft\b|\btitle\s+insurance\b/i }
 ];
 function normalizeWhitespace(value) {
   return value.replace(/\s+/g, " ").trim();
 }
-function normalizeOperationalPolicyTypes(values) {
-  const types = Array.isArray(values) ? values.filter((value) => typeof value === "string") : [];
-  const controlled = types.map((type) => type.trim().toLowerCase().replace(/\s+/g, " ")).map((type) => POLICY_TYPE_ALIASES[type] ?? type.replace(/[\s-]+/g, "_")).filter((type) => POLICY_TYPE_KEYS.has(type));
-  const unique = [...new Set(controlled)].slice(0, 6);
-  return unique.length ? unique : ["other"];
+function hasSpecificLineOfBusiness(codes) {
+  return codes.some((code) => code !== "UN");
 }
-function hasSpecificPolicyType(types) {
-  return types.some((type) => type !== "other");
-}
-function policyTypesFromText(value) {
+function linesOfBusinessFromText(value) {
   const text = normalizeWhitespace(value ?? "");
   if (!text) return [];
-  const aliasType = POLICY_TYPE_ALIASES[text.toLowerCase()];
-  if (aliasType && POLICY_TYPE_KEYS.has(aliasType)) return [aliasType];
-  return POLICY_TYPE_TEXT_PATTERNS.filter(({ pattern }) => pattern.test(text)).map(({ type }) => type).filter((type) => POLICY_TYPE_KEYS.has(type));
+  const direct = toLobCodes([text]);
+  if (direct.some((code) => code !== "UN") || isLobCode(text) || text.toUpperCase() === "UN") return direct;
+  const inferred = LOB_TEXT_PATTERNS.flatMap(({ codes, pattern }) => pattern.test(text) ? codes : []);
+  return Array.from(new Set(inferred));
 }
-function inferPolicyTypesFromOperationalCoverages(coverages) {
+function inferLinesOfBusinessFromOperationalCoverages(coverages) {
   const inferred = [];
   for (const coverage of coverages) {
     const limits = coverage.limits ?? [];
@@ -2655,23 +2896,23 @@ function inferPolicyTypesFromOperationalCoverages(coverages) {
       ...limits.flatMap((term) => [term.appliesTo, term.label])
     ].filter((value) => typeof value === "string" && value.trim().length > 0);
     for (const value of text) {
-      for (const type of policyTypesFromText(value)) {
-        if (!inferred.includes(type)) inferred.push(type);
+      for (const code of linesOfBusinessFromText(value)) {
+        if (!inferred.includes(code)) inferred.push(code);
       }
     }
   }
   return inferred.slice(0, 6);
 }
-function resolveOperationalProfilePolicyTypes(params) {
-  const inferred = inferPolicyTypesFromOperationalCoverages(params.coverages ?? []);
-  if (inferred.length > 0) {
-    return { policyTypes: inferred, source: "coverage" };
+function resolveOperationalProfileLinesOfBusiness(params) {
+  const inferred = inferLinesOfBusinessFromOperationalCoverages(params.coverages ?? []);
+  if (inferred.some((code) => code !== "UN")) {
+    return { linesOfBusiness: inferred, source: "coverage" };
   }
-  const controlled = normalizeOperationalPolicyTypes(params.profileTypes);
-  if (hasSpecificPolicyType(controlled)) return { policyTypes: controlled, source: "profile_hint" };
-  const existingControlled = normalizeOperationalPolicyTypes(params.existingTypes);
-  if (hasSpecificPolicyType(existingControlled)) return { policyTypes: existingControlled, source: "existing_hint" };
-  return { policyTypes: controlled, source: "default" };
+  const controlled = normalizeOperationalLinesOfBusiness(params.profileLinesOfBusiness);
+  if (hasSpecificLineOfBusiness(controlled)) return { linesOfBusiness: controlled, source: "profile_hint" };
+  const existingControlled = normalizeOperationalLinesOfBusiness(params.existingLinesOfBusiness);
+  if (hasSpecificLineOfBusiness(existingControlled)) return { linesOfBusiness: existingControlled, source: "existing_hint" };
+  return { linesOfBusiness: controlled, source: "default" };
 }
 
 // src/source/ids.ts
@@ -3903,7 +4144,7 @@ function shouldFailQualityGate(mode, status) {
 }
 
 // src/extraction/source-tree-extractor.ts
-var import_zod22 = require("zod");
+var import_zod23 = require("zod");
 
 // src/source/operational-profile.ts
 function normalizeWhitespace4(value) {
@@ -4076,15 +4317,17 @@ function mergeOperationalProfile(base, candidate, validNodeIds, validSpanIds) {
     ...base.warnings,
     ...Array.isArray(candidate.warnings) ? candidate.warnings.filter((warning) => typeof warning === "string" && warning.trim().length > 0) : []
   ];
-  const resolvedPolicyTypes = resolveOperationalProfilePolicyTypes({
-    profileTypes: candidate.policyTypes,
-    existingTypes: base.policyTypes,
+  const candidateLinesOfBusiness = candidate.linesOfBusiness ?? candidate.policyTypes;
+  const baseLinesOfBusiness = base.linesOfBusiness ?? base.policyTypes;
+  const resolvedLinesOfBusiness = resolveOperationalProfileLinesOfBusiness({
+    profileLinesOfBusiness: candidateLinesOfBusiness,
+    existingLinesOfBusiness: baseLinesOfBusiness,
     coverages
   });
   return PolicyOperationalProfileSchema.parse({
     ...base,
     documentType: candidate.documentType === "policy" ? "policy" : base.documentType,
-    policyTypes: resolvedPolicyTypes.policyTypes,
+    linesOfBusiness: resolvedLinesOfBusiness.linesOfBusiness,
     policyNumber,
     namedInsured,
     insurer,
@@ -4103,7 +4346,7 @@ function mergeOperationalProfile(base, candidate, validNodeIds, validSpanIds) {
 }
 
 // src/extraction/operational-profile-cleanup.ts
-var import_zod21 = require("zod");
+var import_zod22 = require("zod");
 var OPERATIONAL_COVERAGE_TERM_KINDS2 = [
   "each_claim_limit",
   "each_occurrence_limit",
@@ -4116,33 +4359,33 @@ var OPERATIONAL_COVERAGE_TERM_KINDS2 = [
   "premium",
   "other"
 ];
-var OperationalCoverageTermKindSchema = import_zod21.z.enum(OPERATIONAL_COVERAGE_TERM_KINDS2);
-var OperationalProfileCleanupSchema = import_zod21.z.object({
-  coverageDecisions: import_zod21.z.array(import_zod21.z.object({
-    coverageIndex: import_zod21.z.number().int().nonnegative(),
-    action: import_zod21.z.enum(["keep", "drop", "update"]),
-    reason: import_zod21.z.string().optional(),
-    name: import_zod21.z.string().optional(),
-    limit: import_zod21.z.string().nullable().optional(),
-    deductible: import_zod21.z.string().nullable().optional(),
-    premium: import_zod21.z.string().nullable().optional(),
-    retroactiveDate: import_zod21.z.string().nullable().optional(),
-    sourceNodeIds: import_zod21.z.array(import_zod21.z.string()).optional(),
-    sourceSpanIds: import_zod21.z.array(import_zod21.z.string()).optional(),
-    termDecisions: import_zod21.z.array(import_zod21.z.object({
-      termIndex: import_zod21.z.number().int().nonnegative(),
-      action: import_zod21.z.enum(["keep", "drop", "update"]),
-      reason: import_zod21.z.string().optional(),
+var OperationalCoverageTermKindSchema = import_zod22.z.enum(OPERATIONAL_COVERAGE_TERM_KINDS2);
+var OperationalProfileCleanupSchema = import_zod22.z.object({
+  coverageDecisions: import_zod22.z.array(import_zod22.z.object({
+    coverageIndex: import_zod22.z.number().int().nonnegative(),
+    action: import_zod22.z.enum(["keep", "drop", "update"]),
+    reason: import_zod22.z.string().optional(),
+    name: import_zod22.z.string().optional(),
+    limit: import_zod22.z.string().nullable().optional(),
+    deductible: import_zod22.z.string().nullable().optional(),
+    premium: import_zod22.z.string().nullable().optional(),
+    retroactiveDate: import_zod22.z.string().nullable().optional(),
+    sourceNodeIds: import_zod22.z.array(import_zod22.z.string()).optional(),
+    sourceSpanIds: import_zod22.z.array(import_zod22.z.string()).optional(),
+    termDecisions: import_zod22.z.array(import_zod22.z.object({
+      termIndex: import_zod22.z.number().int().nonnegative(),
+      action: import_zod22.z.enum(["keep", "drop", "update"]),
+      reason: import_zod22.z.string().optional(),
       kind: OperationalCoverageTermKindSchema.optional(),
-      label: import_zod21.z.string().optional(),
-      value: import_zod21.z.string().optional(),
-      amount: import_zod21.z.number().nullable().optional(),
-      appliesTo: import_zod21.z.string().nullable().optional(),
-      sourceNodeIds: import_zod21.z.array(import_zod21.z.string()).optional(),
-      sourceSpanIds: import_zod21.z.array(import_zod21.z.string()).optional()
+      label: import_zod22.z.string().optional(),
+      value: import_zod22.z.string().optional(),
+      amount: import_zod22.z.number().nullable().optional(),
+      appliesTo: import_zod22.z.string().nullable().optional(),
+      sourceNodeIds: import_zod22.z.array(import_zod22.z.string()).optional(),
+      sourceSpanIds: import_zod22.z.array(import_zod22.z.string()).optional()
     })).optional()
   })).default([]),
-  warnings: import_zod21.z.array(import_zod21.z.string()).default([])
+  warnings: import_zod22.z.array(import_zod22.z.string()).default([])
 });
 var CLEANUP_CANDIDATE_ID_LIMIT = 12;
 var CLEANUP_SOURCE_NODE_LIMIT = 90;
@@ -4298,7 +4541,7 @@ function buildOperationalProfileCleanupPrompt(sourceTree, profile, options = {})
   ));
   const candidate = {
     documentType: profile.documentType,
-    policyTypes: profile.policyTypes,
+    linesOfBusiness: profile.linesOfBusiness,
     coverages: coverageEntries.map(({ coverage, coverageIndex }) => compactCoverageForCleanup(coverage, coverageIndex))
   };
   return `Review and clean a source-backed operational profile projection for an insurance policy.
@@ -4596,16 +4839,16 @@ function applyOperationalProfileCleanup(profile, cleanup, validNodeIds, validSpa
 }
 
 // src/extraction/source-tree-extractor.ts
-var SourceBackedValueForPromptSchema = import_zod22.z.object({
-  value: import_zod22.z.string(),
-  normalizedValue: import_zod22.z.string().optional(),
-  confidence: import_zod22.z.enum(["low", "medium", "high"]).optional(),
-  sourceNodeIds: import_zod22.z.array(import_zod22.z.string()),
-  sourceSpanIds: import_zod22.z.array(import_zod22.z.string())
-});
-var OperationalProfilePromptSchema = import_zod22.z.object({
-  documentType: import_zod22.z.enum(["policy", "quote"]).optional(),
-  policyTypes: import_zod22.z.array(import_zod22.z.string()).optional(),
+var SourceBackedValueForPromptSchema = import_zod23.z.object({
+  value: import_zod23.z.string(),
+  normalizedValue: import_zod23.z.string().optional(),
+  confidence: import_zod23.z.enum(["low", "medium", "high"]).optional(),
+  sourceNodeIds: import_zod23.z.array(import_zod23.z.string()),
+  sourceSpanIds: import_zod23.z.array(import_zod23.z.string())
+});
+var OperationalProfilePromptSchema = import_zod23.z.object({
+  documentType: import_zod23.z.enum(["policy", "quote"]).optional(),
+  linesOfBusiness: import_zod23.z.array(import_zod23.z.string()).optional(),
   policyNumber: SourceBackedValueForPromptSchema.optional(),
   namedInsured: SourceBackedValueForPromptSchema.optional(),
   insurer: SourceBackedValueForPromptSchema.optional(),
@@ -4614,30 +4857,30 @@ var OperationalProfilePromptSchema = import_zod22.z.object({
   expirationDate: SourceBackedValueForPromptSchema.optional(),
   retroactiveDate: SourceBackedValueForPromptSchema.optional(),
   premium: SourceBackedValueForPromptSchema.optional(),
-  coverages: import_zod22.z.array(import_zod22.z.object({
-    name: import_zod22.z.string(),
-    coverageCode: import_zod22.z.string().optional(),
-    limit: import_zod22.z.string().optional(),
-    deductible: import_zod22.z.string().optional(),
-    premium: import_zod22.z.string().optional(),
-    retroactiveDate: import_zod22.z.string().optional(),
-    formNumber: import_zod22.z.string().optional(),
-    sectionRef: import_zod22.z.string().optional(),
-    endorsementNumber: import_zod22.z.string().optional(),
-    limits: import_zod22.z.array(import_zod22.z.object({
+  coverages: import_zod23.z.array(import_zod23.z.object({
+    name: import_zod23.z.string(),
+    coverageCode: import_zod23.z.string().optional(),
+    limit: import_zod23.z.string().optional(),
+    deductible: import_zod23.z.string().optional(),
+    premium: import_zod23.z.string().optional(),
+    retroactiveDate: import_zod23.z.string().optional(),
+    formNumber: import_zod23.z.string().optional(),
+    sectionRef: import_zod23.z.string().optional(),
+    endorsementNumber: import_zod23.z.string().optional(),
+    limits: import_zod23.z.array(import_zod23.z.object({
       kind: OperationalCoverageTermKindSchema.optional(),
-      label: import_zod22.z.string(),
-      value: import_zod22.z.string(),
-      amount: import_zod22.z.number().optional(),
-      appliesTo: import_zod22.z.string().optional(),
-      sourceNodeIds: import_zod22.z.array(import_zod22.z.string()),
-      sourceSpanIds: import_zod22.z.array(import_zod22.z.string())
+      label: import_zod23.z.string(),
+      value: import_zod23.z.string(),
+      amount: import_zod23.z.number().optional(),
+      appliesTo: import_zod23.z.string().optional(),
+      sourceNodeIds: import_zod23.z.array(import_zod23.z.string()),
+      sourceSpanIds: import_zod23.z.array(import_zod23.z.string())
     })).optional(),
-    sourceNodeIds: import_zod22.z.array(import_zod22.z.string()),
-    sourceSpanIds: import_zod22.z.array(import_zod22.z.string())
+    sourceNodeIds: import_zod23.z.array(import_zod23.z.string()),
+    sourceSpanIds: import_zod23.z.array(import_zod23.z.string())
   })).optional(),
-  sourceNodeIds: import_zod22.z.array(import_zod22.z.string()).optional(),
-  sourceSpanIds: import_zod22.z.array(import_zod22.z.string()).optional()
+  sourceNodeIds: import_zod23.z.array(import_zod23.z.string()).optional(),
+  sourceSpanIds: import_zod23.z.array(import_zod23.z.string()).optional()
 });
 function cleanText(value, fallback) {
   const text = value?.replace(/\s+/g, " ").trim();
@@ -5644,7 +5887,7 @@ function operationalProfilePromptNodes(sourceTree) {
 function emptyOperationalProfile() {
   return {
     documentType: "policy",
-    policyTypes: ["other"],
+    linesOfBusiness: ["UN"],
     coverages: [],
     parties: [],
     endorsementSupport: [],
@@ -5795,7 +6038,7 @@ function materializeDocument(params) {
     carrier !== "Unknown" ? carrier : void 0,
     policyNumber !== "Unknown" ? `#${policyNumber}` : void 0,
     insuredName !== "Unknown" ? `for ${insuredName}` : void 0,
-    profile.policyTypes.length ? `covering ${profile.policyTypes.slice(0, 5).join(", ")}` : void 0
+    profile.linesOfBusiness.length ? `covering ${profile.linesOfBusiness.slice(0, 5).join(", ")}` : void 0
   ].filter(Boolean).join(" ");
   const base = {
     id: params.id,
@@ -5809,7 +6052,7 @@ function materializeDocument(params) {
       brokerAgency: broker,
       producer: { agencyName: broker, ...brokerProvenance }
     } : {},
-    policyTypes: profile.policyTypes,
+    linesOfBusiness: profile.linesOfBusiness,
     formInventory: params.formInventory.filter((form) => typeof form.formNumber === "string" && form.formNumber.trim().length > 0).map((form) => ({
       formNumber: form.formNumber,
       editionDate: form.editionDate,
@@ -6195,13 +6438,13 @@ function chunkDocument(doc) {
   };
   const chunks = [];
   const docId = doc.id;
-  const policyTypesStr = doc.policyTypes?.length ? doc.policyTypes.join(",") : void 0;
+  const linesOfBusinessStr = doc.linesOfBusiness?.length ? doc.linesOfBusiness.join(",") : void 0;
   const extendedDoc = doc;
   function stringMetadata(entries) {
     const base = Object.fromEntries(
       Object.entries(entries).filter(([, value]) => value !== void 0 && value !== null && String(value).length > 0).map(([key, value]) => [key, String(value)])
     );
-    if (policyTypesStr) base.policyTypes = policyTypesStr;
+    if (linesOfBusinessStr) base.linesOfBusiness = linesOfBusinessStr;
     return base;
   }
   function lines(values) {
@@ -6235,7 +6478,7 @@ function chunkDocument(doc) {
       doc.isRenewal != null ? `Renewal: ${doc.isRenewal ? "Yes" : "No"}` : null,
       doc.isPackage != null ? `Package: ${doc.isPackage ? "Yes" : "No"}` : null,
       doc.security ? `Security: ${doc.security}` : null,
-      doc.policyTypes?.length ? `Policy Types: ${doc.policyTypes.join(", ")}` : null
+      doc.linesOfBusiness?.length ? `Lines of Business: ${doc.linesOfBusiness.join(", ")}` : null
     ]),
     { carrier: doc.carrier, documentType: doc.type }
   );
@@ -7562,8 +7805,8 @@ Respond with JSON only:
 }`;
 
 // src/schemas/application.ts
-var import_zod23 = require("zod");
-var FieldTypeSchema = import_zod23.z.enum([
+var import_zod24 = require("zod");
+var FieldTypeSchema = import_zod24.z.enum([
   "text",
   "numeric",
   "currency",
@@ -7572,223 +7815,223 @@ var FieldTypeSchema = import_zod23.z.enum([
   "table",
   "declaration"
 ]);
-var ApplicationFieldSchema = import_zod23.z.object({
-  id: import_zod23.z.string(),
-  label: import_zod23.z.string(),
-  section: import_zod23.z.string(),
+var ApplicationFieldSchema = import_zod24.z.object({
+  id: import_zod24.z.string(),
+  label: import_zod24.z.string(),
+  section: import_zod24.z.string(),
   fieldType: FieldTypeSchema,
-  required: import_zod23.z.boolean(),
-  options: import_zod23.z.array(import_zod23.z.string()).optional(),
-  columns: import_zod23.z.array(import_zod23.z.string()).optional(),
-  requiresExplanationIfYes: import_zod23.z.boolean().optional(),
-  condition: import_zod23.z.object({
-    dependsOn: import_zod23.z.string(),
-    whenValue: import_zod23.z.string()
+  required: import_zod24.z.boolean(),
+  options: import_zod24.z.array(import_zod24.z.string()).optional(),
+  columns: import_zod24.z.array(import_zod24.z.string()).optional(),
+  requiresExplanationIfYes: import_zod24.z.boolean().optional(),
+  condition: import_zod24.z.object({
+    dependsOn: import_zod24.z.string(),
+    whenValue: import_zod24.z.string()
   }).optional(),
-  value: import_zod23.z.string().optional(),
-  source: import_zod23.z.string().optional().describe("Where the value came from: auto-fill, user, lookup"),
-  confidence: import_zod23.z.enum(["confirmed", "high", "medium", "low"]).optional(),
-  sourceSpanIds: import_zod23.z.array(import_zod23.z.string()).optional().describe("Stable source spans that support the field value or field anchor"),
-  userSourceSpanIds: import_zod23.z.array(import_zod23.z.string()).optional().describe("Message or attachment spans that support user-provided values"),
-  pageNumber: import_zod23.z.number().int().positive().optional().describe("Application page where the field label or anchor appears"),
-  fieldAnchorId: import_zod23.z.string().optional().describe("Stable field anchor ID derived from page, section, label, and form metadata"),
-  acroFormName: import_zod23.z.string().optional().describe("Native PDF AcroForm field name when available"),
-  validationStatus: import_zod23.z.enum(["valid", "needs_review", "unsupported", "missing"]).optional()
-});
-var ApplicationQuestionConditionSchema = import_zod23.z.object({
-  dependsOn: import_zod23.z.string(),
-  operator: import_zod23.z.enum(["equals", "not_equals", "in", "not_in", "exists"]).optional(),
-  value: import_zod23.z.string().optional(),
-  whenValue: import_zod23.z.string().optional(),
-  values: import_zod23.z.array(import_zod23.z.string()).optional()
-});
-var ApplicationRepeatSchema = import_zod23.z.object({
-  min: import_zod23.z.number().int().nonnegative().optional(),
-  max: import_zod23.z.number().int().positive().optional(),
-  label: import_zod23.z.string().optional()
-});
-var ApplicationQuestionNodeSchema = import_zod23.z.lazy(
-  () => import_zod23.z.object({
-    id: import_zod23.z.string(),
-    nodeType: import_zod23.z.enum(["group", "question", "repeat_group", "table"]),
-    fieldId: import_zod23.z.string().optional(),
-    fieldPath: import_zod23.z.string().optional(),
-    parentId: import_zod23.z.string().optional(),
-    order: import_zod23.z.number().int().nonnegative().optional(),
-    label: import_zod23.z.string(),
-    section: import_zod23.z.string().optional(),
+  value: import_zod24.z.string().optional(),
+  source: import_zod24.z.string().optional().describe("Where the value came from: auto-fill, user, lookup"),
+  confidence: import_zod24.z.enum(["confirmed", "high", "medium", "low"]).optional(),
+  sourceSpanIds: import_zod24.z.array(import_zod24.z.string()).optional().describe("Stable source spans that support the field value or field anchor"),
+  userSourceSpanIds: import_zod24.z.array(import_zod24.z.string()).optional().describe("Message or attachment spans that support user-provided values"),
+  pageNumber: import_zod24.z.number().int().positive().optional().describe("Application page where the field label or anchor appears"),
+  fieldAnchorId: import_zod24.z.string().optional().describe("Stable field anchor ID derived from page, section, label, and form metadata"),
+  acroFormName: import_zod24.z.string().optional().describe("Native PDF AcroForm field name when available"),
+  validationStatus: import_zod24.z.enum(["valid", "needs_review", "unsupported", "missing"]).optional()
+});
+var ApplicationQuestionConditionSchema = import_zod24.z.object({
+  dependsOn: import_zod24.z.string(),
+  operator: import_zod24.z.enum(["equals", "not_equals", "in", "not_in", "exists"]).optional(),
+  value: import_zod24.z.string().optional(),
+  whenValue: import_zod24.z.string().optional(),
+  values: import_zod24.z.array(import_zod24.z.string()).optional()
+});
+var ApplicationRepeatSchema = import_zod24.z.object({
+  min: import_zod24.z.number().int().nonnegative().optional(),
+  max: import_zod24.z.number().int().positive().optional(),
+  label: import_zod24.z.string().optional()
+});
+var ApplicationQuestionNodeSchema = import_zod24.z.lazy(
+  () => import_zod24.z.object({
+    id: import_zod24.z.string(),
+    nodeType: import_zod24.z.enum(["group", "question", "repeat_group", "table"]),
+    fieldId: import_zod24.z.string().optional(),
+    fieldPath: import_zod24.z.string().optional(),
+    parentId: import_zod24.z.string().optional(),
+    order: import_zod24.z.number().int().nonnegative().optional(),
+    label: import_zod24.z.string(),
+    section: import_zod24.z.string().optional(),
     fieldType: FieldTypeSchema.optional(),
-    required: import_zod23.z.boolean().optional(),
-    prompt: import_zod23.z.string().optional(),
-    options: import_zod23.z.array(import_zod23.z.string()).optional(),
-    columns: import_zod23.z.array(import_zod23.z.string()).optional(),
+    required: import_zod24.z.boolean().optional(),
+    prompt: import_zod24.z.string().optional(),
+    options: import_zod24.z.array(import_zod24.z.string()).optional(),
+    columns: import_zod24.z.array(import_zod24.z.string()).optional(),
     condition: ApplicationQuestionConditionSchema.optional(),
     repeat: ApplicationRepeatSchema.optional(),
-    children: import_zod23.z.array(ApplicationQuestionNodeSchema).optional()
+    children: import_zod24.z.array(ApplicationQuestionNodeSchema).optional()
   })
 );
-var ApplicationQuestionGraphSchema = import_zod23.z.object({
-  id: import_zod23.z.string(),
-  version: import_zod23.z.string(),
-  title: import_zod23.z.string().optional(),
-  applicationType: import_zod23.z.string().nullable().optional(),
-  source: import_zod23.z.enum(["pdf", "manual", "imported", "generated"]).default("generated"),
-  rootNodeIds: import_zod23.z.array(import_zod23.z.string()).optional(),
-  nodes: import_zod23.z.array(ApplicationQuestionNodeSchema)
-});
-var ApplicationTemplateSchema = import_zod23.z.object({
-  id: import_zod23.z.string(),
-  version: import_zod23.z.string(),
-  title: import_zod23.z.string(),
-  applicationType: import_zod23.z.string().nullable().optional(),
+var ApplicationQuestionGraphSchema = import_zod24.z.object({
+  id: import_zod24.z.string(),
+  version: import_zod24.z.string(),
+  title: import_zod24.z.string().optional(),
+  applicationType: import_zod24.z.string().nullable().optional(),
+  source: import_zod24.z.enum(["pdf", "manual", "imported", "generated"]).default("generated"),
+  rootNodeIds: import_zod24.z.array(import_zod24.z.string()).optional(),
+  nodes: import_zod24.z.array(ApplicationQuestionNodeSchema)
+});
+var ApplicationTemplateSchema = import_zod24.z.object({
+  id: import_zod24.z.string(),
+  version: import_zod24.z.string(),
+  title: import_zod24.z.string(),
+  applicationType: import_zod24.z.string().nullable().optional(),
   questionGraph: ApplicationQuestionGraphSchema,
-  fields: import_zod23.z.array(ApplicationFieldSchema).optional()
-});
-var ApplicationClassifyResultSchema = import_zod23.z.object({
-  isApplication: import_zod23.z.boolean(),
-  confidence: import_zod23.z.number().min(0).max(1),
-  applicationType: import_zod23.z.string().nullable()
-});
-var FieldExtractionResultSchema = import_zod23.z.object({
-  fields: import_zod23.z.array(ApplicationFieldSchema)
-});
-var AutoFillMatchSchema = import_zod23.z.object({
-  fieldId: import_zod23.z.string(),
-  value: import_zod23.z.string(),
-  confidence: import_zod23.z.enum(["confirmed"]),
-  contextKey: import_zod23.z.string()
-});
-var AutoFillResultSchema = import_zod23.z.object({
-  matches: import_zod23.z.array(AutoFillMatchSchema)
-});
-var QuestionBatchResultSchema = import_zod23.z.object({
-  batches: import_zod23.z.array(import_zod23.z.array(import_zod23.z.string()).describe("Array of field IDs in this batch"))
-});
-var LookupRequestSchema = import_zod23.z.object({
-  type: import_zod23.z.string().describe("Type of lookup: 'records', 'website', 'policy'"),
-  description: import_zod23.z.string(),
-  url: import_zod23.z.string().optional(),
-  targetFieldIds: import_zod23.z.array(import_zod23.z.string())
-});
-var ReplyIntentSchema = import_zod23.z.object({
-  primaryIntent: import_zod23.z.enum(["answers_only", "question", "lookup_request", "mixed"]),
-  hasAnswers: import_zod23.z.boolean(),
-  questionText: import_zod23.z.string().optional(),
-  questionFieldIds: import_zod23.z.array(import_zod23.z.string()).optional(),
-  lookupRequests: import_zod23.z.array(LookupRequestSchema).optional()
-});
-var ParsedAnswerSchema = import_zod23.z.object({
-  fieldId: import_zod23.z.string(),
-  value: import_zod23.z.string(),
-  explanation: import_zod23.z.string().optional()
-});
-var AnswerParsingResultSchema = import_zod23.z.object({
-  answers: import_zod23.z.array(ParsedAnswerSchema),
-  unanswered: import_zod23.z.array(import_zod23.z.string()).describe("Field IDs that were not answered")
+  fields: import_zod24.z.array(ApplicationFieldSchema).optional()
 });
-var LookupFillSchema = import_zod23.z.object({
-  fieldId: import_zod23.z.string(),
-  value: import_zod23.z.string(),
-  source: import_zod23.z.string().describe("Specific citable reference, e.g. 'GL Policy #POL-12345 (Hartford)'"),
-  sourceSpanIds: import_zod23.z.array(import_zod23.z.string()).optional()
-});
-var LookupFillResultSchema = import_zod23.z.object({
-  fills: import_zod23.z.array(LookupFillSchema),
-  unfillable: import_zod23.z.array(import_zod23.z.string()),
-  explanation: import_zod23.z.string().optional()
-});
-var FlatPdfPlacementSchema = import_zod23.z.object({
-  fieldId: import_zod23.z.string(),
-  page: import_zod23.z.number(),
-  x: import_zod23.z.number().describe("Percentage from left edge (0-100)"),
-  y: import_zod23.z.number().describe("Percentage from top edge (0-100)"),
-  text: import_zod23.z.string(),
-  fontSize: import_zod23.z.number().optional(),
-  isCheckmark: import_zod23.z.boolean().optional()
-});
-var AcroFormMappingSchema = import_zod23.z.object({
-  fieldId: import_zod23.z.string(),
-  acroFormName: import_zod23.z.string(),
-  value: import_zod23.z.string()
-});
-var QualityGateStatusSchema = import_zod23.z.enum(["passed", "warning", "failed"]);
-var QualitySeveritySchema = import_zod23.z.enum(["info", "warning", "blocking"]);
-var ApplicationQualityIssueSchema = import_zod23.z.object({
-  code: import_zod23.z.string(),
+var ApplicationClassifyResultSchema = import_zod24.z.object({
+  isApplication: import_zod24.z.boolean(),
+  confidence: import_zod24.z.number().min(0).max(1),
+  applicationType: import_zod24.z.string().nullable()
+});
+var FieldExtractionResultSchema = import_zod24.z.object({
+  fields: import_zod24.z.array(ApplicationFieldSchema)
+});
+var AutoFillMatchSchema = import_zod24.z.object({
+  fieldId: import_zod24.z.string(),
+  value: import_zod24.z.string(),
+  confidence: import_zod24.z.enum(["confirmed"]),
+  contextKey: import_zod24.z.string()
+});
+var AutoFillResultSchema = import_zod24.z.object({
+  matches: import_zod24.z.array(AutoFillMatchSchema)
+});
+var QuestionBatchResultSchema = import_zod24.z.object({
+  batches: import_zod24.z.array(import_zod24.z.array(import_zod24.z.string()).describe("Array of field IDs in this batch"))
+});
+var LookupRequestSchema = import_zod24.z.object({
+  type: import_zod24.z.string().describe("Type of lookup: 'records', 'website', 'policy'"),
+  description: import_zod24.z.string(),
+  url: import_zod24.z.string().optional(),
+  targetFieldIds: import_zod24.z.array(import_zod24.z.string())
+});
+var ReplyIntentSchema = import_zod24.z.object({
+  primaryIntent: import_zod24.z.enum(["answers_only", "question", "lookup_request", "mixed"]),
+  hasAnswers: import_zod24.z.boolean(),
+  questionText: import_zod24.z.string().optional(),
+  questionFieldIds: import_zod24.z.array(import_zod24.z.string()).optional(),
+  lookupRequests: import_zod24.z.array(LookupRequestSchema).optional()
+});
+var ParsedAnswerSchema = import_zod24.z.object({
+  fieldId: import_zod24.z.string(),
+  value: import_zod24.z.string(),
+  explanation: import_zod24.z.string().optional()
+});
+var AnswerParsingResultSchema = import_zod24.z.object({
+  answers: import_zod24.z.array(ParsedAnswerSchema),
+  unanswered: import_zod24.z.array(import_zod24.z.string()).describe("Field IDs that were not answered")
+});
+var LookupFillSchema = import_zod24.z.object({
+  fieldId: import_zod24.z.string(),
+  value: import_zod24.z.string(),
+  source: import_zod24.z.string().describe("Specific citable reference, e.g. 'GL Policy #POL-12345 (Hartford)'"),
+  sourceSpanIds: import_zod24.z.array(import_zod24.z.string()).optional()
+});
+var LookupFillResultSchema = import_zod24.z.object({
+  fills: import_zod24.z.array(LookupFillSchema),
+  unfillable: import_zod24.z.array(import_zod24.z.string()),
+  explanation: import_zod24.z.string().optional()
+});
+var FlatPdfPlacementSchema = import_zod24.z.object({
+  fieldId: import_zod24.z.string(),
+  page: import_zod24.z.number(),
+  x: import_zod24.z.number().describe("Percentage from left edge (0-100)"),
+  y: import_zod24.z.number().describe("Percentage from top edge (0-100)"),
+  text: import_zod24.z.string(),
+  fontSize: import_zod24.z.number().optional(),
+  isCheckmark: import_zod24.z.boolean().optional()
+});
+var AcroFormMappingSchema = import_zod24.z.object({
+  fieldId: import_zod24.z.string(),
+  acroFormName: import_zod24.z.string(),
+  value: import_zod24.z.string()
+});
+var QualityGateStatusSchema = import_zod24.z.enum(["passed", "warning", "failed"]);
+var QualitySeveritySchema = import_zod24.z.enum(["info", "warning", "blocking"]);
+var ApplicationQualityIssueSchema = import_zod24.z.object({
+  code: import_zod24.z.string(),
   severity: QualitySeveritySchema,
-  message: import_zod23.z.string(),
-  fieldId: import_zod23.z.string().optional()
+  message: import_zod24.z.string(),
+  fieldId: import_zod24.z.string().optional()
 });
-var ApplicationQualityRoundSchema = import_zod23.z.object({
-  round: import_zod23.z.number(),
-  kind: import_zod23.z.string(),
+var ApplicationQualityRoundSchema = import_zod24.z.object({
+  round: import_zod24.z.number(),
+  kind: import_zod24.z.string(),
   status: QualityGateStatusSchema,
-  summary: import_zod23.z.string().optional()
+  summary: import_zod24.z.string().optional()
 });
-var ApplicationQualityArtifactSchema = import_zod23.z.object({
-  kind: import_zod23.z.string(),
-  label: import_zod23.z.string().optional(),
-  itemCount: import_zod23.z.number().optional()
+var ApplicationQualityArtifactSchema = import_zod24.z.object({
+  kind: import_zod24.z.string(),
+  label: import_zod24.z.string().optional(),
+  itemCount: import_zod24.z.number().optional()
 });
-var ApplicationEmailReviewSchema = import_zod23.z.object({
-  issues: import_zod23.z.array(ApplicationQualityIssueSchema),
+var ApplicationEmailReviewSchema = import_zod24.z.object({
+  issues: import_zod24.z.array(ApplicationQualityIssueSchema),
   qualityGateStatus: QualityGateStatusSchema
 });
-var ApplicationQualityReportSchema = import_zod23.z.object({
-  issues: import_zod23.z.array(ApplicationQualityIssueSchema),
-  rounds: import_zod23.z.array(ApplicationQualityRoundSchema).optional(),
-  artifacts: import_zod23.z.array(ApplicationQualityArtifactSchema).optional(),
+var ApplicationQualityReportSchema = import_zod24.z.object({
+  issues: import_zod24.z.array(ApplicationQualityIssueSchema),
+  rounds: import_zod24.z.array(ApplicationQualityRoundSchema).optional(),
+  artifacts: import_zod24.z.array(ApplicationQualityArtifactSchema).optional(),
   emailReview: ApplicationEmailReviewSchema.optional(),
   qualityGateStatus: QualityGateStatusSchema
 });
-var ApplicationContextProposalSchema = import_zod23.z.object({
-  id: import_zod23.z.string(),
-  fieldId: import_zod23.z.string().optional(),
-  key: import_zod23.z.string(),
-  value: import_zod23.z.string(),
-  category: import_zod23.z.string(),
-  source: import_zod23.z.enum(["application", "user", "lookup", "policy", "email", "chat", "imessage", "mcp"]),
-  confidence: import_zod23.z.enum(["confirmed", "high", "medium", "low"]),
-  sourceSpanIds: import_zod23.z.array(import_zod23.z.string()).optional(),
-  userSourceSpanIds: import_zod23.z.array(import_zod23.z.string()).optional()
-});
-var ApplicationPacketAnswerSchema = import_zod23.z.object({
-  fieldId: import_zod23.z.string(),
-  label: import_zod23.z.string(),
-  section: import_zod23.z.string(),
-  value: import_zod23.z.string(),
-  source: import_zod23.z.string(),
-  confidence: import_zod23.z.enum(["confirmed", "high", "medium", "low"]).optional(),
-  sourceSpanIds: import_zod23.z.array(import_zod23.z.string()).optional(),
-  userSourceSpanIds: import_zod23.z.array(import_zod23.z.string()).optional()
-});
-var ApplicationPacketSchema = import_zod23.z.object({
-  id: import_zod23.z.string(),
-  applicationId: import_zod23.z.string(),
-  title: import_zod23.z.string(),
-  status: import_zod23.z.enum(["draft", "broker_ready", "submitted"]),
-  answers: import_zod23.z.array(ApplicationPacketAnswerSchema),
-  missingFieldIds: import_zod23.z.array(import_zod23.z.string()),
+var ApplicationContextProposalSchema = import_zod24.z.object({
+  id: import_zod24.z.string(),
+  fieldId: import_zod24.z.string().optional(),
+  key: import_zod24.z.string(),
+  value: import_zod24.z.string(),
+  category: import_zod24.z.string(),
+  source: import_zod24.z.enum(["application", "user", "lookup", "policy", "email", "chat", "imessage", "mcp"]),
+  confidence: import_zod24.z.enum(["confirmed", "high", "medium", "low"]),
+  sourceSpanIds: import_zod24.z.array(import_zod24.z.string()).optional(),
+  userSourceSpanIds: import_zod24.z.array(import_zod24.z.string()).optional()
+});
+var ApplicationPacketAnswerSchema = import_zod24.z.object({
+  fieldId: import_zod24.z.string(),
+  label: import_zod24.z.string(),
+  section: import_zod24.z.string(),
+  value: import_zod24.z.string(),
+  source: import_zod24.z.string(),
+  confidence: import_zod24.z.enum(["confirmed", "high", "medium", "low"]).optional(),
+  sourceSpanIds: import_zod24.z.array(import_zod24.z.string()).optional(),
+  userSourceSpanIds: import_zod24.z.array(import_zod24.z.string()).optional()
+});
+var ApplicationPacketSchema = import_zod24.z.object({
+  id: import_zod24.z.string(),
+  applicationId: import_zod24.z.string(),
+  title: import_zod24.z.string(),
+  status: import_zod24.z.enum(["draft", "broker_ready", "submitted"]),
+  answers: import_zod24.z.array(ApplicationPacketAnswerSchema),
+  missingFieldIds: import_zod24.z.array(import_zod24.z.string()),
   qualityReport: ApplicationQualityReportSchema,
-  submissionNotes: import_zod23.z.string().optional(),
-  createdAt: import_zod23.z.number()
-});
-var ApplicationStateSchema = import_zod23.z.object({
-  id: import_zod23.z.string(),
-  pdfBase64: import_zod23.z.string().optional().describe("Original PDF, omitted after extraction"),
-  templateId: import_zod23.z.string().optional(),
-  templateVersion: import_zod23.z.string().optional(),
+  submissionNotes: import_zod24.z.string().optional(),
+  createdAt: import_zod24.z.number()
+});
+var ApplicationStateSchema = import_zod24.z.object({
+  id: import_zod24.z.string(),
+  pdfBase64: import_zod24.z.string().optional().describe("Original PDF, omitted after extraction"),
+  templateId: import_zod24.z.string().optional(),
+  templateVersion: import_zod24.z.string().optional(),
   templateSnapshot: ApplicationTemplateSchema.optional(),
-  title: import_zod23.z.string().optional(),
-  applicationType: import_zod23.z.string().nullable().optional(),
+  title: import_zod24.z.string().optional(),
+  applicationType: import_zod24.z.string().nullable().optional(),
   questionGraph: ApplicationQuestionGraphSchema.optional(),
-  fields: import_zod23.z.array(ApplicationFieldSchema),
-  batches: import_zod23.z.array(import_zod23.z.array(import_zod23.z.string())).optional(),
-  currentBatchIndex: import_zod23.z.number().default(0),
-  contextProposals: import_zod23.z.array(ApplicationContextProposalSchema).optional(),
+  fields: import_zod24.z.array(ApplicationFieldSchema),
+  batches: import_zod24.z.array(import_zod24.z.array(import_zod24.z.string())).optional(),
+  currentBatchIndex: import_zod24.z.number().default(0),
+  contextProposals: import_zod24.z.array(ApplicationContextProposalSchema).optional(),
   packet: ApplicationPacketSchema.optional(),
   qualityReport: ApplicationQualityReportSchema.optional(),
-  status: import_zod23.z.enum([
+  status: import_zod24.z.enum([
     "classifying",
     "extracting",
     "auto_filling",
@@ -7802,8 +8045,8 @@ var ApplicationStateSchema = import_zod23.z.object({
     "cancelled",
     "complete"
   ]),
-  createdAt: import_zod23.z.number(),
-  updatedAt: import_zod23.z.number()
+  createdAt: import_zod24.z.number(),
+  updatedAt: import_zod24.z.number()
 });
 
 // src/application/agents/classifier.ts
@@ -9537,106 +9780,106 @@ Respond with the final answer, deduplicated citations array, overall confidence
 }
 
 // src/schemas/query.ts
-var import_zod24 = require("zod");
-var QueryIntentSchema = import_zod24.z.enum([
+var import_zod25 = require("zod");
+var QueryIntentSchema = import_zod25.z.enum([
   "policy_question",
   "coverage_comparison",
   "document_search",
   "claims_inquiry",
   "general_knowledge"
 ]);
-var QueryAttachmentKindSchema = import_zod24.z.enum(["image", "pdf", "text"]);
-var QueryAttachmentSchema = import_zod24.z.object({
-  id: import_zod24.z.string().optional().describe("Optional stable attachment ID from the caller"),
+var QueryAttachmentKindSchema = import_zod25.z.enum(["image", "pdf", "text"]);
+var QueryAttachmentSchema = import_zod25.z.object({
+  id: import_zod25.z.string().optional().describe("Optional stable attachment ID from the caller"),
   kind: QueryAttachmentKindSchema,
-  name: import_zod24.z.string().optional().describe("Original filename or user-facing label"),
-  mimeType: import_zod24.z.string().optional().describe("MIME type such as image/jpeg or application/pdf"),
-  base64: import_zod24.z.string().optional().describe("Base64-encoded file content for image/pdf attachments"),
-  text: import_zod24.z.string().optional().describe("Plain-text attachment content when available"),
-  description: import_zod24.z.string().optional().describe("Caller-provided description of the attachment")
+  name: import_zod25.z.string().optional().describe("Original filename or user-facing label"),
+  mimeType: import_zod25.z.string().optional().describe("MIME type such as image/jpeg or application/pdf"),
+  base64: import_zod25.z.string().optional().describe("Base64-encoded file content for image/pdf attachments"),
+  text: import_zod25.z.string().optional().describe("Plain-text attachment content when available"),
+  description: import_zod25.z.string().optional().describe("Caller-provided description of the attachment")
 });
-var QueryRetrievalModeSchema = import_zod24.z.enum([
+var QueryRetrievalModeSchema = import_zod25.z.enum([
   "graph_only",
   "source_rag",
   "long_context",
   "hybrid"
 ]);
-var SubQuestionSchema = import_zod24.z.object({
-  question: import_zod24.z.string().describe("Atomic sub-question to retrieve and answer independently"),
+var SubQuestionSchema = import_zod25.z.object({
+  question: import_zod25.z.string().describe("Atomic sub-question to retrieve and answer independently"),
   intent: QueryIntentSchema,
-  chunkTypes: import_zod24.z.array(import_zod24.z.string()).optional().describe("Chunk types to filter retrieval (e.g. coverage, endorsement, declaration)"),
-  documentFilters: import_zod24.z.object({
-    type: import_zod24.z.enum(["policy", "quote"]).optional(),
-    carrier: import_zod24.z.string().optional(),
-    insuredName: import_zod24.z.string().optional(),
-    policyNumber: import_zod24.z.string().optional(),
-    quoteNumber: import_zod24.z.string().optional(),
-    policyTypes: import_zod24.z.array(PolicyTypeSchema).optional().describe("Filter by policy type (e.g. homeowners_ho3, renters_ho4, pet) to avoid mixing up similar policies")
+  chunkTypes: import_zod25.z.array(import_zod25.z.string()).optional().describe("Chunk types to filter retrieval (e.g. coverage, endorsement, declaration)"),
+  documentFilters: import_zod25.z.object({
+    type: import_zod25.z.enum(["policy", "quote"]).optional(),
+    carrier: import_zod25.z.string().optional(),
+    insuredName: import_zod25.z.string().optional(),
+    policyNumber: import_zod25.z.string().optional(),
+    quoteNumber: import_zod25.z.string().optional(),
+    linesOfBusiness: import_zod25.z.array(AcordLobCodeSchema).optional().describe("Filter by ACORD line of business code (e.g. HOME, AUTOP, DISAB) to avoid mixing up similar policies")
   }).optional().describe("Structured filters to narrow document lookup")
 });
-var QueryClassifyResultSchema = import_zod24.z.object({
+var QueryClassifyResultSchema = import_zod25.z.object({
   intent: QueryIntentSchema,
-  subQuestions: import_zod24.z.array(SubQuestionSchema).min(1).describe("Decomposed atomic sub-questions"),
-  requiresDocumentLookup: import_zod24.z.boolean().describe("Whether structured document lookup is needed"),
-  requiresChunkSearch: import_zod24.z.boolean().describe("Whether semantic chunk search is needed"),
-  requiresConversationHistory: import_zod24.z.boolean().describe("Whether conversation history is relevant"),
+  subQuestions: import_zod25.z.array(SubQuestionSchema).min(1).describe("Decomposed atomic sub-questions"),
+  requiresDocumentLookup: import_zod25.z.boolean().describe("Whether structured document lookup is needed"),
+  requiresChunkSearch: import_zod25.z.boolean().describe("Whether semantic chunk search is needed"),
+  requiresConversationHistory: import_zod25.z.boolean().describe("Whether conversation history is relevant"),
   retrievalMode: QueryRetrievalModeSchema.optional().describe("Preferred retrieval strategy for the query when source-span retrieval is available")
 });
-var EvidenceItemSchema = import_zod24.z.object({
-  source: import_zod24.z.enum(["chunk", "document", "conversation", "attachment", "source_span", "source_node"]),
-  chunkId: import_zod24.z.string().optional(),
-  sourceNodeId: import_zod24.z.string().optional(),
-  sourceSpanId: import_zod24.z.string().optional(),
-  documentId: import_zod24.z.string().optional(),
-  turnId: import_zod24.z.string().optional(),
-  attachmentId: import_zod24.z.string().optional(),
-  text: import_zod24.z.string().describe("Text excerpt from the source"),
-  relevance: import_zod24.z.number().min(0).max(1),
+var EvidenceItemSchema = import_zod25.z.object({
+  source: import_zod25.z.enum(["chunk", "document", "conversation", "attachment", "source_span", "source_node"]),
+  chunkId: import_zod25.z.string().optional(),
+  sourceNodeId: import_zod25.z.string().optional(),
+  sourceSpanId: import_zod25.z.string().optional(),
+  documentId: import_zod25.z.string().optional(),
+  turnId: import_zod25.z.string().optional(),
+  attachmentId: import_zod25.z.string().optional(),
+  text: import_zod25.z.string().describe("Text excerpt from the source"),
+  relevance: import_zod25.z.number().min(0).max(1),
   retrievalMode: QueryRetrievalModeSchema.optional(),
   sourceLocation: SourceSpanLocationSchema.optional(),
-  metadata: import_zod24.z.array(import_zod24.z.object({ key: import_zod24.z.string(), value: import_zod24.z.string() })).optional()
-});
-var AttachmentInterpretationSchema = import_zod24.z.object({
-  summary: import_zod24.z.string().describe("Concise summary of what the attachment shows or contains"),
-  extractedFacts: import_zod24.z.array(import_zod24.z.string()).describe("Specific observable or document facts grounded in the attachment"),
-  recommendedFocus: import_zod24.z.array(import_zod24.z.string()).describe("Important details to incorporate when answering follow-up questions"),
-  confidence: import_zod24.z.number().min(0).max(1)
-});
-var RetrievalResultSchema = import_zod24.z.object({
-  subQuestion: import_zod24.z.string(),
-  evidence: import_zod24.z.array(EvidenceItemSchema)
-});
-var CitationSchema = import_zod24.z.object({
-  index: import_zod24.z.number().describe("Citation number [1], [2], etc."),
-  chunkId: import_zod24.z.string().optional().describe("Source chunk ID, e.g. doc-123:coverage:2"),
-  sourceNodeId: import_zod24.z.string().optional().describe("Source tree node ID when available"),
-  sourceSpanId: import_zod24.z.string().optional().describe("Precise source span ID when available"),
-  documentId: import_zod24.z.string(),
-  documentType: import_zod24.z.enum(["policy", "quote"]).optional(),
-  field: import_zod24.z.string().optional().describe("Specific field path, e.g. coverages[0].deductible"),
-  quote: import_zod24.z.string().describe("Exact text from source that supports the claim"),
-  relevance: import_zod24.z.number().min(0).max(1),
+  metadata: import_zod25.z.array(import_zod25.z.object({ key: import_zod25.z.string(), value: import_zod25.z.string() })).optional()
+});
+var AttachmentInterpretationSchema = import_zod25.z.object({
+  summary: import_zod25.z.string().describe("Concise summary of what the attachment shows or contains"),
+  extractedFacts: import_zod25.z.array(import_zod25.z.string()).describe("Specific observable or document facts grounded in the attachment"),
+  recommendedFocus: import_zod25.z.array(import_zod25.z.string()).describe("Important details to incorporate when answering follow-up questions"),
+  confidence: import_zod25.z.number().min(0).max(1)
+});
+var RetrievalResultSchema = import_zod25.z.object({
+  subQuestion: import_zod25.z.string(),
+  evidence: import_zod25.z.array(EvidenceItemSchema)
+});
+var CitationSchema = import_zod25.z.object({
+  index: import_zod25.z.number().describe("Citation number [1], [2], etc."),
+  chunkId: import_zod25.z.string().optional().describe("Source chunk ID, e.g. doc-123:coverage:2"),
+  sourceNodeId: import_zod25.z.string().optional().describe("Source tree node ID when available"),
+  sourceSpanId: import_zod25.z.string().optional().describe("Precise source span ID when available"),
+  documentId: import_zod25.z.string(),
+  documentType: import_zod25.z.enum(["policy", "quote"]).optional(),
+  field: import_zod25.z.string().optional().describe("Specific field path, e.g. coverages[0].deductible"),
+  quote: import_zod25.z.string().describe("Exact text from source that supports the claim"),
+  relevance: import_zod25.z.number().min(0).max(1),
   retrievalMode: QueryRetrievalModeSchema.optional(),
   sourceLocation: SourceSpanLocationSchema.optional()
 });
-var SubAnswerSchema = import_zod24.z.object({
-  subQuestion: import_zod24.z.string(),
-  answer: import_zod24.z.string(),
-  citations: import_zod24.z.array(CitationSchema),
-  confidence: import_zod24.z.number().min(0).max(1),
-  needsMoreContext: import_zod24.z.boolean().describe("True if evidence was insufficient to answer fully")
-});
-var VerifyResultSchema = import_zod24.z.object({
-  approved: import_zod24.z.boolean().describe("Whether all sub-answers are adequately grounded"),
-  issues: import_zod24.z.array(import_zod24.z.string()).describe("Specific grounding or consistency issues found"),
-  retrySubQuestions: import_zod24.z.array(import_zod24.z.string()).optional().describe("Sub-questions that need additional retrieval or re-reasoning")
-});
-var QueryResultSchema = import_zod24.z.object({
-  answer: import_zod24.z.string(),
-  citations: import_zod24.z.array(CitationSchema),
+var SubAnswerSchema = import_zod25.z.object({
+  subQuestion: import_zod25.z.string(),
+  answer: import_zod25.z.string(),
+  citations: import_zod25.z.array(CitationSchema),
+  confidence: import_zod25.z.number().min(0).max(1),
+  needsMoreContext: import_zod25.z.boolean().describe("True if evidence was insufficient to answer fully")
+});
+var VerifyResultSchema = import_zod25.z.object({
+  approved: import_zod25.z.boolean().describe("Whether all sub-answers are adequately grounded"),
+  issues: import_zod25.z.array(import_zod25.z.string()).describe("Specific grounding or consistency issues found"),
+  retrySubQuestions: import_zod25.z.array(import_zod25.z.string()).optional().describe("Sub-questions that need additional retrieval or re-reasoning")
+});
+var QueryResultSchema = import_zod25.z.object({
+  answer: import_zod25.z.string(),
+  citations: import_zod25.z.array(CitationSchema),
   intent: QueryIntentSchema,
-  confidence: import_zod24.z.number().min(0).max(1),
-  followUp: import_zod24.z.string().optional().describe("Suggested follow-up question if applicable")
+  confidence: import_zod25.z.number().min(0).max(1),
+  followUp: import_zod25.z.string().optional().describe("Suggested follow-up question if applicable")
 });
 
 // src/query/retriever.ts
@@ -10703,7 +10946,7 @@ ${sa.answer}`).join("\n\n"),
 }
 
 // src/pce/index.ts
-var import_zod25 = require("zod");
+var import_zod26 = require("zod");
 
 // src/prompts/pce/index.ts
 function buildPceNormalizePrompt(input) {
@@ -10737,11 +10980,11 @@ ${input.openQuestions.map((question) => `- ${question.id}${question.fieldPath ?
 }
 
 // src/pce/index.ts
-var ReplyAnswersSchema = import_zod25.z.object({
-  answers: import_zod25.z.array(import_zod25.z.object({
-    questionId: import_zod25.z.string().optional(),
-    fieldPath: import_zod25.z.string().optional(),
-    answer: import_zod25.z.string()
+var ReplyAnswersSchema = import_zod26.z.object({
+  answers: import_zod26.z.array(import_zod26.z.object({
+    questionId: import_zod26.z.string().optional(),
+    fieldPath: import_zod26.z.string().optional(),
+    answer: import_zod26.z.string()
   }))
 });
 function createPceAgent(config = {}) {
@@ -11470,7 +11713,7 @@ var COI_GENERATION_TOOL = {
 };
 var COVERAGE_COMPARISON_TOOL = {
   name: "coverage_comparison",
-  description: "Compare coverages across two or more insurance documents (policies and/or quotes). Returns a side-by-side comparison of policy types, limits, and deductibles.",
+  description: "Compare coverages across two or more insurance documents (policies and/or quotes). Returns a side-by-side comparison of lines of business, limits, and deductibles.",
   input_schema: {
     type: "object",
     properties: {
@@ -11479,10 +11722,10 @@ var COVERAGE_COMPARISON_TOOL = {
         items: { type: "string" },
         description: "Array of document IDs (policies or quotes) to compare."
       },
-      policyTypes: {
+      linesOfBusiness: {
         type: "array",
         items: { type: "string" },
-        description: "Optional filter: only compare these policy types (e.g. 'General Liability', 'Workers Compensation'). Omit to compare all."
+        description: "Optional filter: only compare these ACORD line of business codes or labels (e.g. 'CGL', 'WORK'). Omit to compare all."
       }
     },
     required: ["documentIds"]
@@ -11495,23 +11738,23 @@ var AGENT_TOOLS = [
 ];
 
 // src/prompts/extractors/carrier-info.ts
-var import_zod26 = require("zod");
-var CarrierInfoSchema = import_zod26.z.object({
-  carrierName: import_zod26.z.string().describe("Primary insurance company name for display"),
-  carrierLegalName: import_zod26.z.string().optional().describe("Legal entity name of insurer"),
-  naicNumber: import_zod26.z.string().optional().describe("NAIC company code"),
-  amBestRating: import_zod26.z.string().optional().describe("AM Best rating, e.g. 'A+ XV'"),
-  admittedStatus: import_zod26.z.enum(["admitted", "non_admitted", "surplus_lines"]).optional().describe("Admitted status of the carrier"),
-  mga: import_zod26.z.string().optional().describe("Managing General Agent or Program Administrator name"),
-  underwriter: import_zod26.z.string().optional().describe("Named individual underwriter"),
-  brokerAgency: import_zod26.z.string().optional().describe("Broker or producer agency name"),
-  brokerContactName: import_zod26.z.string().optional().describe("Broker or producer contact person name"),
-  brokerLicenseNumber: import_zod26.z.string().optional().describe("Broker or producer license number"),
-  policyNumber: import_zod26.z.string().optional().describe("Policy or quote reference number"),
-  effectiveDate: import_zod26.z.string().optional().describe("Policy effective date (MM/DD/YYYY)"),
-  expirationDate: import_zod26.z.string().optional().describe("Policy expiration date (MM/DD/YYYY)"),
-  quoteNumber: import_zod26.z.string().optional().describe("Quote or proposal reference number"),
-  proposedEffectiveDate: import_zod26.z.string().optional().describe("Proposed effective date for quotes (MM/DD/YYYY)")
+var import_zod27 = require("zod");
+var CarrierInfoSchema = import_zod27.z.object({
+  carrierName: import_zod27.z.string().describe("Primary insurance company name for display"),
+  carrierLegalName: import_zod27.z.string().optional().describe("Legal entity name of insurer"),
+  naicNumber: import_zod27.z.string().optional().describe("NAIC company code"),
+  amBestRating: import_zod27.z.string().optional().describe("AM Best rating, e.g. 'A+ XV'"),
+  admittedStatus: import_zod27.z.enum(["admitted", "non_admitted", "surplus_lines"]).optional().describe("Admitted status of the carrier"),
+  mga: import_zod27.z.string().optional().describe("Managing General Agent or Program Administrator name"),
+  underwriter: import_zod27.z.string().optional().describe("Named individual underwriter"),
+  brokerAgency: import_zod27.z.string().optional().describe("Broker or producer agency name"),
+  brokerContactName: import_zod27.z.string().optional().describe("Broker or producer contact person name"),
+  brokerLicenseNumber: import_zod27.z.string().optional().describe("Broker or producer license number"),
+  policyNumber: import_zod27.z.string().optional().describe("Policy or quote reference number"),
+  effectiveDate: import_zod27.z.string().optional().describe("Policy effective date (MM/DD/YYYY)"),
+  expirationDate: import_zod27.z.string().optional().describe("Policy expiration date (MM/DD/YYYY)"),
+  quoteNumber: import_zod27.z.string().optional().describe("Quote or proposal reference number"),
+  proposedEffectiveDate: import_zod27.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.
@@ -11534,21 +11777,21 @@ Return JSON only.`;
 }
 
 // src/prompts/extractors/named-insured.ts
-var import_zod27 = require("zod");
-var AdditionalNamedInsuredSchema = import_zod27.z.object({
-  name: import_zod27.z.string(),
-  relationship: import_zod27.z.string().optional().describe("e.g. subsidiary, affiliate"),
+var import_zod28 = require("zod");
+var AdditionalNamedInsuredSchema = import_zod28.z.object({
+  name: import_zod28.z.string(),
+  relationship: import_zod28.z.string().optional().describe("e.g. subsidiary, affiliate"),
   address: SourceBackedAddressSchema.optional()
 }).merge(SourceProvenanceSchema);
-var ScheduledPartySchema = import_zod27.z.object({
-  name: import_zod27.z.string(),
+var ScheduledPartySchema = import_zod28.z.object({
+  name: import_zod28.z.string(),
   address: SourceBackedAddressSchema.optional()
 }).merge(SourceProvenanceSchema);
-var NamedInsuredSchema2 = import_zod27.z.object({
-  insuredName: import_zod27.z.string().describe("Name of primary named insured"),
-  insuredDba: import_zod27.z.string().optional().describe("Doing-business-as name"),
+var NamedInsuredSchema2 = import_zod28.z.object({
+  insuredName: import_zod28.z.string().describe("Name of primary named insured"),
+  insuredDba: import_zod28.z.string().optional().describe("Doing-business-as name"),
   insuredAddress: SourceBackedAddressSchema.optional().describe("Primary insured mailing address"),
-  insuredEntityType: import_zod27.z.enum([
+  insuredEntityType: import_zod28.z.enum([
     "corporation",
     "llc",
     "partnership",
@@ -11561,12 +11804,12 @@ var NamedInsuredSchema2 = import_zod27.z.object({
     "married_couple",
     "other"
   ]).optional().describe("Legal entity type of the insured"),
-  insuredFein: import_zod27.z.string().optional().describe("Federal Employer Identification Number"),
-  insuredSicCode: import_zod27.z.string().optional().describe("SIC code"),
-  insuredNaicsCode: import_zod27.z.string().optional().describe("NAICS code"),
-  additionalNamedInsureds: import_zod27.z.array(AdditionalNamedInsuredSchema).optional().describe("Additional named insureds listed on the policy"),
-  lossPayees: import_zod27.z.array(ScheduledPartySchema).optional().describe("Loss payees listed on the policy"),
-  mortgageHolders: import_zod27.z.array(ScheduledPartySchema).optional().describe("Mortgage holders / lienholders listed on the policy")
+  insuredFein: import_zod28.z.string().optional().describe("Federal Employer Identification Number"),
+  insuredSicCode: import_zod28.z.string().optional().describe("SIC code"),
+  insuredNaicsCode: import_zod28.z.string().optional().describe("NAICS code"),
+  additionalNamedInsureds: import_zod28.z.array(AdditionalNamedInsuredSchema).optional().describe("Additional named insureds listed on the policy"),
+  lossPayees: import_zod28.z.array(ScheduledPartySchema).optional().describe("Loss payees listed on the policy"),
+  mortgageHolders: import_zod28.z.array(ScheduledPartySchema).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.
@@ -11593,14 +11836,14 @@ Return JSON only.`;
 }
 
 // src/prompts/extractors/coverage-limits.ts
-var import_zod28 = require("zod");
+var import_zod29 = require("zod");
 var ExtractorCoverageSchema = CoverageSchema.extend({
-  coverageCode: import_zod28.z.string().optional().describe("Coverage code or class code")
+  coverageCode: import_zod29.z.string().optional().describe("Coverage code or class code")
 });
-var CoverageLimitsSchema = import_zod28.z.object({
-  coverages: import_zod28.z.array(ExtractorCoverageSchema).describe("All coverages with their limits"),
-  coverageForm: import_zod28.z.enum(["occurrence", "claims_made", "accident"]).optional().describe("Primary coverage trigger type"),
-  retroactiveDate: import_zod28.z.string().optional().describe("Retroactive date for claims-made policies (MM/DD/YYYY)")
+var CoverageLimitsSchema = import_zod29.z.object({
+  coverages: import_zod29.z.array(ExtractorCoverageSchema).describe("All coverages with their limits"),
+  coverageForm: import_zod29.z.enum(["occurrence", "claims_made", "accident"]).optional().describe("Primary coverage trigger type"),
+  retroactiveDate: import_zod29.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.
@@ -11642,14 +11885,14 @@ Return JSON only.`;
 }
 
 // src/prompts/extractors/endorsements.ts
-var import_zod29 = require("zod");
-var EndorsementsSchema = import_zod29.z.object({
-  endorsements: import_zod29.z.array(
-    import_zod29.z.object({
-      formNumber: import_zod29.z.string().describe("Form number, e.g. 'CG 21 47'"),
-      editionDate: import_zod29.z.string().optional().describe("Edition date, e.g. '12 07'"),
-      title: import_zod29.z.string().describe("Endorsement title"),
-      endorsementType: import_zod29.z.enum([
+var import_zod30 = require("zod");
+var EndorsementsSchema = import_zod30.z.object({
+  endorsements: import_zod30.z.array(
+    import_zod30.z.object({
+      formNumber: import_zod30.z.string().describe("Form number, e.g. 'CG 21 47'"),
+      editionDate: import_zod30.z.string().optional().describe("Edition date, e.g. '12 07'"),
+      title: import_zod30.z.string().describe("Endorsement title"),
+      endorsementType: import_zod30.z.enum([
         "additional_insured",
         "waiver_of_subrogation",
         "primary_noncontributory",
@@ -11669,12 +11912,12 @@ var EndorsementsSchema = import_zod29.z.object({
         "territorial_extension",
         "other"
       ]).describe("Endorsement type classification"),
-      effectiveDate: import_zod29.z.string().optional().describe("Endorsement effective date"),
-      affectedCoverageParts: import_zod29.z.array(import_zod29.z.string()).optional().describe("Coverage parts affected by this endorsement"),
-      namedParties: import_zod29.z.array(
-        import_zod29.z.object({
-          name: import_zod29.z.string().describe("Party name"),
-          role: import_zod29.z.enum([
+      effectiveDate: import_zod30.z.string().optional().describe("Endorsement effective date"),
+      affectedCoverageParts: import_zod30.z.array(import_zod30.z.string()).optional().describe("Coverage parts affected by this endorsement"),
+      namedParties: import_zod30.z.array(
+        import_zod30.z.object({
+          name: import_zod30.z.string().describe("Party name"),
+          role: import_zod30.z.enum([
             "additional_insured",
             "loss_payee",
             "mortgage_holder",
@@ -11683,18 +11926,18 @@ var EndorsementsSchema = import_zod29.z.object({
             "designated_person",
             "other"
           ]).describe("Party role"),
-          relationship: import_zod29.z.string().optional().describe("Relationship to insured"),
-          scope: import_zod29.z.string().optional().describe("Scope of coverage for this party")
+          relationship: import_zod30.z.string().optional().describe("Relationship to insured"),
+          scope: import_zod30.z.string().optional().describe("Scope of coverage for this party")
         })
       ).optional().describe("Named parties (additional insureds, loss payees, etc.)"),
-      keyTerms: import_zod29.z.array(import_zod29.z.string()).optional().describe("Key terms or notable provisions in the endorsement"),
-      premiumImpact: import_zod29.z.string().optional().describe("Additional premium or credit"),
-      excerpt: import_zod29.z.string().optional().describe("Short source excerpt, not full verbatim text"),
-      content: import_zod29.z.string().optional().describe("Legacy fallback only; do not return full text when sourceSpanIds are available"),
-      pageStart: import_zod29.z.number().describe("Starting page number of this endorsement"),
-      pageEnd: import_zod29.z.number().optional().describe("Ending page number of this endorsement"),
-      sourceSpanIds: import_zod29.z.array(import_zod29.z.string()).optional().describe("Source span IDs grounding this endorsement"),
-      sourceTextHash: import_zod29.z.string().optional().describe("Hash of the source text when available")
+      keyTerms: import_zod30.z.array(import_zod30.z.string()).optional().describe("Key terms or notable provisions in the endorsement"),
+      premiumImpact: import_zod30.z.string().optional().describe("Additional premium or credit"),
+      excerpt: import_zod30.z.string().optional().describe("Short source excerpt, not full verbatim text"),
+      content: import_zod30.z.string().optional().describe("Legacy fallback only; do not return full text when sourceSpanIds are available"),
+      pageStart: import_zod30.z.number().describe("Starting page number of this endorsement"),
+      pageEnd: import_zod30.z.number().optional().describe("Ending page number of this endorsement"),
+      sourceSpanIds: import_zod30.z.array(import_zod30.z.string()).optional().describe("Source span IDs grounding this endorsement"),
+      sourceTextHash: import_zod30.z.string().optional().describe("Hash of the source text when available")
     })
   ).describe("All endorsements found in the document")
 });
@@ -11732,20 +11975,20 @@ Return JSON only.`;
 }
 
 // src/prompts/extractors/exclusions.ts
-var import_zod30 = require("zod");
-var ExclusionsSchema = import_zod30.z.object({
-  exclusions: import_zod30.z.array(
-    import_zod30.z.object({
-      name: import_zod30.z.string().describe("Exclusion title or short description"),
-      formNumber: import_zod30.z.string().optional().describe("Form number if part of a named endorsement"),
-      excludedPerils: import_zod30.z.array(import_zod30.z.string()).optional().describe("Specific perils excluded"),
-      isAbsolute: import_zod30.z.boolean().optional().describe("Whether the exclusion is absolute (no exceptions)"),
-      exceptions: import_zod30.z.array(import_zod30.z.string()).optional().describe("Exceptions to the exclusion, if any"),
-      buybackAvailable: import_zod30.z.boolean().optional().describe("Whether coverage can be bought back via endorsement"),
-      buybackEndorsement: import_zod30.z.string().optional().describe("Form number of the buyback endorsement if available"),
-      appliesTo: import_zod30.z.array(import_zod30.z.string()).optional().describe("Policy types this exclusion applies to"),
-      content: import_zod30.z.string().describe("Full verbatim exclusion text"),
-      pageNumber: import_zod30.z.number().optional().describe("Page number where exclusion appears")
+var import_zod31 = require("zod");
+var ExclusionsSchema = import_zod31.z.object({
+  exclusions: import_zod31.z.array(
+    import_zod31.z.object({
+      name: import_zod31.z.string().describe("Exclusion title or short description"),
+      formNumber: import_zod31.z.string().optional().describe("Form number if part of a named endorsement"),
+      excludedPerils: import_zod31.z.array(import_zod31.z.string()).optional().describe("Specific perils excluded"),
+      isAbsolute: import_zod31.z.boolean().optional().describe("Whether the exclusion is absolute (no exceptions)"),
+      exceptions: import_zod31.z.array(import_zod31.z.string()).optional().describe("Exceptions to the exclusion, if any"),
+      buybackAvailable: import_zod31.z.boolean().optional().describe("Whether coverage can be bought back via endorsement"),
+      buybackEndorsement: import_zod31.z.string().optional().describe("Form number of the buyback endorsement if available"),
+      appliesTo: import_zod31.z.array(import_zod31.z.string()).optional().describe("Policy types this exclusion applies to"),
+      content: import_zod31.z.string().describe("Full verbatim exclusion text"),
+      pageNumber: import_zod31.z.number().optional().describe("Page number where exclusion appears")
     })
   ).describe("All exclusions found in the document")
 });
@@ -11760,7 +12003,7 @@ For EACH exclusion, extract:
 - exceptions: any exceptions to the exclusion (things still covered despite the exclusion)
 - buybackAvailable: whether coverage can be purchased back via endorsement
 - buybackEndorsement: the form number of the buyback endorsement if known
-- appliesTo: which policy types or lines this exclusion applies to (as an array)
+- appliesTo: which lines of business or coverages this exclusion applies to (as an array)
 - content: full verbatim exclusion text \u2014 REQUIRED
 - pageNumber: page number where the exclusion appears
 
@@ -11781,12 +12024,12 @@ Return JSON only.`;
 }
 
 // src/prompts/extractors/conditions.ts
-var import_zod31 = require("zod");
-var ConditionsSchema = import_zod31.z.object({
-  conditions: import_zod31.z.array(
-    import_zod31.z.object({
-      name: import_zod31.z.string().describe("Condition title"),
-      conditionType: import_zod31.z.enum([
+var import_zod32 = require("zod");
+var ConditionsSchema = import_zod32.z.object({
+  conditions: import_zod32.z.array(
+    import_zod32.z.object({
+      name: import_zod32.z.string().describe("Condition title"),
+      conditionType: import_zod32.z.enum([
         "duties_after_loss",
         "notice_requirements",
         "other_insurance",
@@ -11805,14 +12048,14 @@ var ConditionsSchema = import_zod31.z.object({
         "separation_of_insureds",
         "other"
       ]).describe("Condition category"),
-      content: import_zod31.z.string().describe("Full verbatim condition text"),
-      keyValues: import_zod31.z.array(
-        import_zod31.z.object({
-          key: import_zod31.z.string().describe("Key name (e.g. 'noticePeriod', 'suitDeadline')"),
-          value: import_zod31.z.string().describe("Value (e.g. '30 days', '2 years')")
+      content: import_zod32.z.string().describe("Full verbatim condition text"),
+      keyValues: import_zod32.z.array(
+        import_zod32.z.object({
+          key: import_zod32.z.string().describe("Key name (e.g. 'noticePeriod', 'suitDeadline')"),
+          value: import_zod32.z.string().describe("Value (e.g. '30 days', '2 years')")
         })
       ).optional().describe("Key values extracted from the condition (notice periods, deadlines, etc.)"),
-      pageNumber: import_zod31.z.number().optional().describe("Page number where condition appears")
+      pageNumber: import_zod32.z.number().optional().describe("Page number where condition appears")
     })
   ).describe("All policy conditions found in the document")
 });
@@ -11850,34 +12093,34 @@ Return JSON only.`;
 }
 
 // src/prompts/extractors/premium-breakdown.ts
-var import_zod32 = require("zod");
-var PremiumBreakdownSchema = import_zod32.z.object({
-  premium: import_zod32.z.string().optional().describe("Total premium amount, e.g. '$5,000'"),
-  premiumAmount: import_zod32.z.number().optional().describe("Total premium as a plain number with no currency symbols or commas"),
-  totalCost: import_zod32.z.string().optional().describe("Total cost including taxes and fees, e.g. '$5,250'"),
-  totalCostAmount: import_zod32.z.number().optional().describe("Total cost as a plain number with no currency symbols or commas"),
-  premiumBreakdown: import_zod32.z.array(
-    import_zod32.z.object({
-      line: import_zod32.z.string().describe("Coverage line name"),
-      amount: import_zod32.z.string().describe("Premium amount for this line"),
-      amountValue: import_zod32.z.number().optional().describe("Premium amount as a plain number with no currency symbols or commas")
+var import_zod33 = require("zod");
+var PremiumBreakdownSchema = import_zod33.z.object({
+  premium: import_zod33.z.string().optional().describe("Total premium amount, e.g. '$5,000'"),
+  premiumAmount: import_zod33.z.number().optional().describe("Total premium as a plain number with no currency symbols or commas"),
+  totalCost: import_zod33.z.string().optional().describe("Total cost including taxes and fees, e.g. '$5,250'"),
+  totalCostAmount: import_zod33.z.number().optional().describe("Total cost as a plain number with no currency symbols or commas"),
+  premiumBreakdown: import_zod33.z.array(
+    import_zod33.z.object({
+      line: import_zod33.z.string().describe("Coverage line name"),
+      amount: import_zod33.z.string().describe("Premium amount for this line"),
+      amountValue: import_zod33.z.number().optional().describe("Premium amount as a plain number with no currency symbols or commas")
     })
   ).optional().describe("Per-coverage-line premium breakdown"),
-  taxesAndFees: import_zod32.z.array(
-    import_zod32.z.object({
-      name: import_zod32.z.string().describe("Fee or tax name"),
-      amount: import_zod32.z.string().describe("Dollar amount"),
-      amountValue: import_zod32.z.number().optional().describe("Fee or tax amount as a plain number with no currency symbols or commas"),
-      type: import_zod32.z.enum(["tax", "fee", "surcharge", "assessment"]).optional().describe("Fee category")
+  taxesAndFees: import_zod33.z.array(
+    import_zod33.z.object({
+      name: import_zod33.z.string().describe("Fee or tax name"),
+      amount: import_zod33.z.string().describe("Dollar amount"),
+      amountValue: import_zod33.z.number().optional().describe("Fee or tax amount as a plain number with no currency symbols or commas"),
+      type: import_zod33.z.enum(["tax", "fee", "surcharge", "assessment"]).optional().describe("Fee category")
     })
   ).optional().describe("Taxes, fees, surcharges, and assessments"),
-  minimumPremium: import_zod32.z.string().optional().describe("Minimum premium if stated"),
-  minimumPremiumAmount: import_zod32.z.number().optional().describe("Minimum premium as a plain number when the source states a fixed amount"),
-  depositPremium: import_zod32.z.string().optional().describe("Deposit premium if stated"),
-  depositPremiumAmount: import_zod32.z.number().optional().describe("Deposit premium as a plain number when the source states a fixed amount"),
-  paymentPlan: import_zod32.z.string().optional().describe("Payment plan description"),
-  auditType: import_zod32.z.enum(["annual", "semi_annual", "quarterly", "monthly", "final", "self"]).optional().describe("Premium audit type"),
-  ratingBasis: import_zod32.z.string().optional().describe("Rating basis, e.g. payroll, revenue, area, units")
+  minimumPremium: import_zod33.z.string().optional().describe("Minimum premium if stated"),
+  minimumPremiumAmount: import_zod33.z.number().optional().describe("Minimum premium as a plain number when the source states a fixed amount"),
+  depositPremium: import_zod33.z.string().optional().describe("Deposit premium if stated"),
+  depositPremiumAmount: import_zod33.z.number().optional().describe("Deposit premium as a plain number when the source states a fixed amount"),
+  paymentPlan: import_zod33.z.string().optional().describe("Payment plan description"),
+  auditType: import_zod33.z.enum(["annual", "semi_annual", "quarterly", "monthly", "final", "self"]).optional().describe("Premium audit type"),
+  ratingBasis: import_zod33.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.
@@ -11899,14 +12142,14 @@ Return JSON only.`;
 }
 
 // src/prompts/extractors/declarations.ts
-var import_zod33 = require("zod");
-var DeclarationsFieldSchema = import_zod33.z.object({
-  field: import_zod33.z.string().describe("Descriptive field name (e.g. 'policyNumber', 'effectiveDate', 'coverageALimit')"),
-  value: import_zod33.z.string().describe("Extracted value exactly as it appears in the document"),
-  section: import_zod33.z.string().optional().describe("Section or grouping this field belongs to (e.g. 'Coverage Limits', 'Vehicle Schedule')")
+var import_zod34 = require("zod");
+var DeclarationsFieldSchema = import_zod34.z.object({
+  field: import_zod34.z.string().describe("Descriptive field name (e.g. 'policyNumber', 'effectiveDate', 'coverageALimit')"),
+  value: import_zod34.z.string().describe("Extracted value exactly as it appears in the document"),
+  section: import_zod34.z.string().optional().describe("Section or grouping this field belongs to (e.g. 'Coverage Limits', 'Vehicle Schedule')")
 });
-var DeclarationsExtractSchema = import_zod33.z.object({
-  fields: import_zod33.z.array(DeclarationsFieldSchema).describe("All declarations page fields extracted as key-value pairs. Structure varies by line of business.")
+var DeclarationsExtractSchema = import_zod34.z.object({
+  fields: import_zod34.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.
@@ -11946,21 +12189,21 @@ Preserve original values exactly as they appear. Return JSON only.`;
 }
 
 // src/prompts/extractors/loss-history.ts
-var import_zod34 = require("zod");
-var LossHistorySchema = import_zod34.z.object({
-  lossSummary: import_zod34.z.string().optional().describe("Summary of loss history, e.g. '3 claims in past 5 years totaling $125,000'"),
-  individualClaims: import_zod34.z.array(
-    import_zod34.z.object({
-      date: import_zod34.z.string().optional().describe("Date of loss or claim"),
-      type: import_zod34.z.string().optional().describe("Type of claim, e.g. 'property damage', 'bodily injury'"),
-      description: import_zod34.z.string().optional().describe("Brief description of the claim"),
-      amountPaid: import_zod34.z.string().optional().describe("Amount paid"),
-      amountReserved: import_zod34.z.string().optional().describe("Amount reserved"),
-      status: import_zod34.z.enum(["open", "closed", "reopened"]).optional().describe("Claim status"),
-      claimNumber: import_zod34.z.string().optional().describe("Claim reference number")
+var import_zod35 = require("zod");
+var LossHistorySchema = import_zod35.z.object({
+  lossSummary: import_zod35.z.string().optional().describe("Summary of loss history, e.g. '3 claims in past 5 years totaling $125,000'"),
+  individualClaims: import_zod35.z.array(
+    import_zod35.z.object({
+      date: import_zod35.z.string().optional().describe("Date of loss or claim"),
+      type: import_zod35.z.string().optional().describe("Type of claim, e.g. 'property damage', 'bodily injury'"),
+      description: import_zod35.z.string().optional().describe("Brief description of the claim"),
+      amountPaid: import_zod35.z.string().optional().describe("Amount paid"),
+      amountReserved: import_zod35.z.string().optional().describe("Amount reserved"),
+      status: import_zod35.z.enum(["open", "closed", "reopened"]).optional().describe("Claim status"),
+      claimNumber: import_zod35.z.string().optional().describe("Claim reference number")
     })
   ).optional().describe("Individual claim records"),
-  experienceMod: import_zod34.z.string().optional().describe("Experience modification factor for workers comp, e.g. '0.85'")
+  experienceMod: import_zod35.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.
@@ -11977,21 +12220,21 @@ Return JSON only.`;
 }
 
 // src/prompts/extractors/sections.ts
-var import_zod35 = require("zod");
-var SubsectionSchema2 = import_zod35.z.object({
-  title: import_zod35.z.string().describe("Subsection title"),
-  sectionNumber: import_zod35.z.string().optional().describe("Subsection number"),
-  pageNumber: import_zod35.z.number().optional().describe("Page number"),
-  excerpt: import_zod35.z.string().optional().describe("Short source excerpt, not full verbatim text"),
-  content: import_zod35.z.string().optional().describe("Legacy fallback only; do not return full text when sourceSpanIds are available"),
-  sourceSpanIds: import_zod35.z.array(import_zod35.z.string()).optional().describe("Source span IDs grounding this subsection"),
-  sourceTextHash: import_zod35.z.string().optional().describe("Hash of the source text when available")
-});
-var SectionsSchema = import_zod35.z.object({
-  sections: import_zod35.z.array(
-    import_zod35.z.object({
-      title: import_zod35.z.string().describe("Section title"),
-      type: import_zod35.z.enum([
+var import_zod36 = require("zod");
+var SubsectionSchema2 = import_zod36.z.object({
+  title: import_zod36.z.string().describe("Subsection title"),
+  sectionNumber: import_zod36.z.string().optional().describe("Subsection number"),
+  pageNumber: import_zod36.z.number().optional().describe("Page number"),
+  excerpt: import_zod36.z.string().optional().describe("Short source excerpt, not full verbatim text"),
+  content: import_zod36.z.string().optional().describe("Legacy fallback only; do not return full text when sourceSpanIds are available"),
+  sourceSpanIds: import_zod36.z.array(import_zod36.z.string()).optional().describe("Source span IDs grounding this subsection"),
+  sourceTextHash: import_zod36.z.string().optional().describe("Hash of the source text when available")
+});
+var SectionsSchema = import_zod36.z.object({
+  sections: import_zod36.z.array(
+    import_zod36.z.object({
+      title: import_zod36.z.string().describe("Section title"),
+      type: import_zod36.z.enum([
         "declarations",
         "insuring_agreement",
         "policy_form",
@@ -12006,13 +12249,13 @@ var SectionsSchema = import_zod35.z.object({
         "regulatory",
         "other"
       ]).describe("Section type classification"),
-      excerpt: import_zod35.z.string().optional().describe("Short source excerpt, not full verbatim text"),
-      content: import_zod35.z.string().optional().describe("Legacy fallback only; do not return full text when sourceSpanIds are available"),
-      pageStart: import_zod35.z.number().describe("Starting page number"),
-      pageEnd: import_zod35.z.number().optional().describe("Ending page number"),
-      sourceSpanIds: import_zod35.z.array(import_zod35.z.string()).optional().describe("Source span IDs grounding this section"),
-      sourceTextHash: import_zod35.z.string().optional().describe("Hash of the source text when available"),
-      subsections: import_zod35.z.array(SubsectionSchema2).optional().describe("Subsections within this section")
+      excerpt: import_zod36.z.string().optional().describe("Short source excerpt, not full verbatim text"),
+      content: import_zod36.z.string().optional().describe("Legacy fallback only; do not return full text when sourceSpanIds are available"),
+      pageStart: import_zod36.z.number().describe("Starting page number"),
+      pageEnd: import_zod36.z.number().optional().describe("Ending page number"),
+      sourceSpanIds: import_zod36.z.array(import_zod36.z.string()).optional().describe("Source span IDs grounding this section"),
+      sourceTextHash: import_zod36.z.string().optional().describe("Hash of the source text when available"),
+      subsections: import_zod36.z.array(SubsectionSchema2).optional().describe("Subsections within this section")
     })
   ).describe("All document sections")
 });
@@ -12046,20 +12289,20 @@ Return JSON only.`;
 }
 
 // src/prompts/extractors/supplementary.ts
-var import_zod36 = require("zod");
-var AuxiliaryFactSchema2 = import_zod36.z.object({
-  key: import_zod36.z.string().describe("Normalized machine-readable fact key, e.g. 'policyholder_age' or 'insured_name'"),
-  value: import_zod36.z.string().describe("Concrete extracted fact value"),
-  subject: import_zod36.z.string().optional().describe("Person, entity, vehicle, property, or schedule item this fact belongs to"),
-  context: import_zod36.z.string().optional().describe("Short disambiguating context, such as 'Driver Schedule' or 'Named Insured'")
-});
-var SupplementarySchema = import_zod36.z.object({
-  regulatoryContacts: import_zod36.z.array(ContactSchema).optional().describe("Regulatory body contacts (state department of insurance, ombudsman)"),
-  claimsContacts: import_zod36.z.array(ContactSchema).optional().describe("Claims reporting contacts and instructions"),
-  thirdPartyAdministrators: import_zod36.z.array(ContactSchema).optional().describe("Third-party administrators for claims handling"),
-  cancellationNoticeDays: import_zod36.z.number().optional().describe("Required notice period for cancellation in days"),
-  nonrenewalNoticeDays: import_zod36.z.number().optional().describe("Required notice period for nonrenewal in days"),
-  auxiliaryFacts: import_zod36.z.array(AuxiliaryFactSchema2).optional().describe("Additional retrieval-only facts that do not fit the strict primary schema")
+var import_zod37 = require("zod");
+var AuxiliaryFactSchema2 = import_zod37.z.object({
+  key: import_zod37.z.string().describe("Normalized machine-readable fact key, e.g. 'policyholder_age' or 'insured_name'"),
+  value: import_zod37.z.string().describe("Concrete extracted fact value"),
+  subject: import_zod37.z.string().optional().describe("Person, entity, vehicle, property, or schedule item this fact belongs to"),
+  context: import_zod37.z.string().optional().describe("Short disambiguating context, such as 'Driver Schedule' or 'Named Insured'")
+});
+var SupplementarySchema = import_zod37.z.object({
+  regulatoryContacts: import_zod37.z.array(ContactSchema).optional().describe("Regulatory body contacts (state department of insurance, ombudsman)"),
+  claimsContacts: import_zod37.z.array(ContactSchema).optional().describe("Claims reporting contacts and instructions"),
+  thirdPartyAdministrators: import_zod37.z.array(ContactSchema).optional().describe("Third-party administrators for claims handling"),
+  cancellationNoticeDays: import_zod37.z.number().optional().describe("Required notice period for cancellation in days"),
+  nonrenewalNoticeDays: import_zod37.z.number().optional().describe("Required notice period for nonrenewal in days"),
+  auxiliaryFacts: import_zod37.z.array(AuxiliaryFactSchema2).optional().describe("Additional retrieval-only facts that do not fit the strict primary schema")
 });
 function buildSupplementaryPrompt(alreadyExtractedSummary) {
   const exclusionBlock = alreadyExtractedSummary ? `
@@ -12099,17 +12342,17 @@ Return JSON only.`;
 }
 
 // src/prompts/extractors/definitions.ts
-var import_zod37 = require("zod");
-var DefinitionsSchema = import_zod37.z.object({
-  definitions: import_zod37.z.array(
-    import_zod37.z.object({
-      term: import_zod37.z.string().describe("Defined term exactly as shown in the document"),
-      definition: import_zod37.z.string().describe("Full verbatim definition text, preserving original wording"),
-      pageNumber: import_zod37.z.number().optional().describe("Original document page number"),
-      formNumber: import_zod37.z.string().optional().describe("Form number where this definition appears"),
-      formTitle: import_zod37.z.string().optional().describe("Form title where this definition appears"),
-      sectionRef: import_zod37.z.string().optional().describe("Definition section heading or subsection reference"),
-      originalContent: import_zod37.z.string().optional().describe("Short verbatim source snippet containing the term and definition")
+var import_zod38 = require("zod");
+var DefinitionsSchema = import_zod38.z.object({
+  definitions: import_zod38.z.array(
+    import_zod38.z.object({
+      term: import_zod38.z.string().describe("Defined term exactly as shown in the document"),
+      definition: import_zod38.z.string().describe("Full verbatim definition text, preserving original wording"),
+      pageNumber: import_zod38.z.number().optional().describe("Original document page number"),
+      formNumber: import_zod38.z.string().optional().describe("Form number where this definition appears"),
+      formTitle: import_zod38.z.string().optional().describe("Form title where this definition appears"),
+      sectionRef: import_zod38.z.string().optional().describe("Definition section heading or subsection reference"),
+      originalContent: import_zod38.z.string().optional().describe("Short verbatim source snippet containing the term and definition")
     })
   ).describe("All substantive insurance definitions found in the document")
 });
@@ -12143,22 +12386,22 @@ Return JSON only.`;
 }
 
 // src/prompts/extractors/covered-reasons.ts
-var import_zod38 = require("zod");
-var CoveredReasonsSchema = import_zod38.z.object({
-  coveredReasons: import_zod38.z.array(
-    import_zod38.z.object({
-      coverageName: import_zod38.z.string().describe("Coverage, coverage part, or form this covered reason belongs to"),
-      reasonNumber: import_zod38.z.string().optional().describe("Source number or letter for the covered reason, if shown"),
-      title: import_zod38.z.string().optional().describe("Covered reason title, peril, cause of loss, trigger, or short name"),
-      content: import_zod38.z.string().describe("Full verbatim covered-reason or insuring-agreement text"),
-      conditions: import_zod38.z.array(import_zod38.z.string()).optional().describe("Conditions, timing rules, documentation requirements, or prerequisites attached to this covered reason"),
-      exceptions: import_zod38.z.array(import_zod38.z.string()).optional().describe("Exceptions or limitations attached to this covered reason"),
-      appliesTo: import_zod38.z.array(import_zod38.z.string()).optional().describe("Covered property, persons, autos, locations, operations, or coverage parts this reason applies to"),
-      pageNumber: import_zod38.z.number().optional().describe("Original document page number"),
-      formNumber: import_zod38.z.string().optional().describe("Form number where this covered reason appears"),
-      formTitle: import_zod38.z.string().optional().describe("Form title where this covered reason appears"),
-      sectionRef: import_zod38.z.string().optional().describe("Section heading where this covered reason appears"),
-      originalContent: import_zod38.z.string().optional().describe("Short verbatim source snippet used for this covered reason")
+var import_zod39 = require("zod");
+var CoveredReasonsSchema = import_zod39.z.object({
+  coveredReasons: import_zod39.z.array(
+    import_zod39.z.object({
+      coverageName: import_zod39.z.string().describe("Coverage, coverage part, or form this covered reason belongs to"),
+      reasonNumber: import_zod39.z.string().optional().describe("Source number or letter for the covered reason, if shown"),
+      title: import_zod39.z.string().optional().describe("Covered reason title, peril, cause of loss, trigger, or short name"),
+      content: import_zod39.z.string().describe("Full verbatim covered-reason or insuring-agreement text"),
+      conditions: import_zod39.z.array(import_zod39.z.string()).optional().describe("Conditions, timing rules, documentation requirements, or prerequisites attached to this covered reason"),
+      exceptions: import_zod39.z.array(import_zod39.z.string()).optional().describe("Exceptions or limitations attached to this covered reason"),
+      appliesTo: import_zod39.z.array(import_zod39.z.string()).optional().describe("Covered property, persons, autos, locations, operations, or coverage parts this reason applies to"),
+      pageNumber: import_zod39.z.number().optional().describe("Original document page number"),
+      formNumber: import_zod39.z.string().optional().describe("Form number where this covered reason appears"),
+      formTitle: import_zod39.z.string().optional().describe("Form title where this covered reason appears"),
+      sectionRef: import_zod39.z.string().optional().describe("Section heading where this covered reason appears"),
+      originalContent: import_zod39.z.string().optional().describe("Short verbatim source snippet used for this covered reason")
     })
   ).describe("Covered causes, perils, triggers, or reasons that affirmatively grant coverage")
 });
@@ -13002,10 +13245,13 @@ function getTemplate(policyType) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  ACORD_LOB_CODES,
+  ACORD_LOB_LABELS,
   ADMITTED_STATUSES,
   AGENT_TOOLS,
   APPLICATION_CLASSIFY_PROMPT,
   AUDIT_TYPES,
+  AcordLobCodeSchema,
   AcroFormMappingSchema,
   AddressSchema,
   AdmittedStatusSchema,
@@ -13098,6 +13344,7 @@ function getTemplate(policyType) {
   ENDORSEMENT_PARTY_ROLES,
   ENDORSEMENT_TYPES,
   ENTITY_TYPES,
+  EXCLUDED_ACORD_LOB_CODES,
   EarthquakeDeclarationsSchema,
   EmployersLiabilityLimitsSchema,
   EndorsementPartyRoleSchema,
@@ -13131,6 +13378,7 @@ function getTemplate(policyType) {
   InsuredLocationSchema,
   InsuredVehicleSchema,
   InsurerInfoSchema,
+  LEGACY_POLICY_TYPE_TO_LOB,
   LIMIT_TYPES,
   LOSS_SETTLEMENTS,
   LimitScheduleSchema,
@@ -13149,11 +13397,11 @@ function getTemplate(policyType) {
   OperationalEndorsementSupportSchema,
   OperationalPartySchema,
   PERSONAL_AUTO_USAGES,
+  PERSONAL_LOB_CODES,
   PET_SPECIES,
   PLATFORM_CONFIGS,
   POLICY_SECTION_TYPES,
   POLICY_TERM_TYPES,
-  POLICY_TYPES,
   ParsedAnswerSchema,
   PaymentInstallmentSchema,
   PaymentPlanSchema,
@@ -13180,7 +13428,6 @@ function getTemplate(policyType) {
   PolicyOperationalProfileSchema,
   PolicySectionTypeSchema,
   PolicyTermTypeSchema,
-  PolicyTypeSchema,
   PremiumLineSchema,
   ProducerInfoSchema,
   ProfessionalLiabilityDeclarationsSchema,
@@ -13309,16 +13556,19 @@ function getTemplate(policyType) {
   getNextApplicationQuestions,
   getPdfPageCount,
   getTemplate,
-  inferPolicyTypesFromOperationalCoverages,
+  inferLinesOfBusinessFromOperationalCoverages,
   isDoclingExtractionInput,
   isFileReference,
+  isLobCode,
+  isPersonalLob,
+  lobLabel,
   mergeQuestionAnswers,
   mergeSourceSpans,
   normalizeApplicationQuestionGraph,
   normalizeDoclingDocument,
   normalizeDocumentSourceTreePaths,
   normalizeForMatch,
-  normalizeOperationalPolicyTypes,
+  normalizeOperationalLinesOfBusiness,
   normalizeSourceSpans,
   orderSourceEvidence,
   overlayTextOnPdf,
@@ -13329,7 +13579,7 @@ function getTemplate(policyType) {
   processReply,
   proposeContextWrites,
   resolveModelBudget,
-  resolveOperationalProfilePolicyTypes,
+  resolveOperationalProfileLinesOfBusiness,
   safeGenerateObject,
   sanitizeNulls,
   scoreCaseProposal,
@@ -13340,6 +13590,7 @@ function getTemplate(policyType) {
   stablePolicyChangeItemId,
   stableStringify,
   stripFences,
+  toLobCodes,
   toStrictSchema,
   validateApplicationPacket,
   validateEvidence,