@claritylabs/cl-sdk 4.2.0 → 4.4.0

package/dist/index.mjs

@@ -1060,7 +1060,8 @@ var InsurerInfoSchema = z9.object({
   amBestRating: z9.string().optional(),
   amBestNumber: z9.string().optional(),
   admittedStatus: AdmittedStatusSchema.optional(),
-  stateOfDomicile: z9.string().optional()
+  stateOfDomicile: z9.string().optional(),
+  address: AddressSchema.optional()
 }).merge(SourceProvenanceSchema);
 var ProducerInfoSchema = z9.object({
   agencyName: z9.string(),
@@ -1617,251 +1618,541 @@ var DeclarationsSchema = z16.discriminatedUnion("line", [
 ]);
 
 // src/schemas/document.ts
+import { z as z18 } from "zod";
+
+// src/source/schemas.ts
 import { z as z17 } from "zod";
-var SubsectionSchema = z17.object({
-  title: z17.string(),
-  sectionNumber: z17.string().optional(),
-  pageNumber: z17.number().optional(),
-  excerpt: z17.string().optional(),
-  content: z17.string().optional(),
-  documentNodeId: z17.string().optional(),
-  sourceSpanIds: z17.array(z17.string()).optional(),
-  sourceTextHash: z17.string().optional()
-});
-var SectionSchema = z17.object({
+var SourceSpanKindSchema = z17.enum([
+  "pdf_text",
+  "pdf_image",
+  "html",
+  "markdown",
+  "plain_text",
+  "structured_field"
+]);
+var SourceSpanUnitSchema = z17.enum([
+  "page",
+  "section",
+  "table",
+  "table_row",
+  "table_cell",
+  "key_value",
+  "text"
+]);
+var SourceKindSchema = z17.enum([
+  "policy_pdf",
+  "application_pdf",
+  "email",
+  "attachment",
+  "manual_note"
+]);
+var SourceSpanBBoxSchema = z17.object({
+  page: z17.number().int().positive(),
+  x: z17.number(),
+  y: z17.number(),
+  width: z17.number(),
+  height: z17.number()
+});
+var SourceSpanLocationSchema = z17.object({
+  page: z17.number().int().positive().optional(),
+  startPage: z17.number().int().positive().optional(),
+  endPage: z17.number().int().positive().optional(),
+  charStart: z17.number().int().nonnegative().optional(),
+  charEnd: z17.number().int().nonnegative().optional(),
+  lineStart: z17.number().int().positive().optional(),
+  lineEnd: z17.number().int().positive().optional(),
+  fieldPath: z17.string().optional()
+});
+var SourceSpanTableLocationSchema = z17.object({
+  tableId: z17.string().optional(),
+  rowIndex: z17.number().int().nonnegative().optional(),
+  columnIndex: z17.number().int().nonnegative().optional(),
+  columnName: z17.string().optional(),
+  rowSpanId: z17.string().optional(),
+  tableSpanId: z17.string().optional(),
+  isHeader: z17.boolean().optional()
+});
+var SourceSpanSchema = z17.object({
+  id: z17.string().min(1),
+  documentId: z17.string().min(1),
+  sourceKind: SourceKindSchema.optional(),
+  chunkId: z17.string().optional(),
+  kind: SourceSpanKindSchema,
+  text: z17.string(),
+  hash: z17.string().min(1),
+  textHash: z17.string().optional(),
+  pageStart: z17.number().int().positive().optional(),
+  pageEnd: z17.number().int().positive().optional(),
+  sectionId: z17.string().optional(),
+  formNumber: z17.string().optional(),
+  sourceUnit: SourceSpanUnitSchema.optional(),
+  parentSpanId: z17.string().optional(),
+  table: SourceSpanTableLocationSchema.optional(),
+  bbox: z17.array(SourceSpanBBoxSchema).optional(),
+  location: SourceSpanLocationSchema.optional(),
+  metadata: z17.record(z17.string(), z17.string()).optional()
+});
+var SourceSpanRefSchema = z17.object({
+  sourceSpanId: z17.string().min(1),
+  documentId: z17.string().min(1).optional(),
+  chunkId: z17.string().optional(),
+  quote: z17.string().optional(),
+  hash: z17.string().optional(),
+  location: SourceSpanLocationSchema.optional()
+});
+var SourceChunkSchema = z17.object({
+  id: z17.string().min(1),
+  documentId: z17.string().min(1),
+  sourceSpanIds: z17.array(z17.string().min(1)),
+  text: z17.string(),
+  textHash: z17.string().min(1),
+  pageStart: z17.number().int().positive().optional(),
+  pageEnd: z17.number().int().positive().optional(),
+  metadata: z17.record(z17.string(), z17.string()).default({})
+});
+var DocumentSourceNodeKindSchema = z17.enum([
+  "document",
+  "page_group",
+  "page",
+  "form",
+  "endorsement",
+  "section",
+  "schedule",
+  "clause",
+  "table",
+  "table_row",
+  "table_cell",
+  "text"
+]);
+var DocumentSourceNodeSchema = z17.object({
+  id: z17.string().min(1),
+  documentId: z17.string().min(1),
+  parentId: z17.string().optional(),
+  kind: DocumentSourceNodeKindSchema,
   title: z17.string(),
-  sectionNumber: z17.string().optional(),
-  pageStart: z17.number(),
-  pageEnd: z17.number().optional(),
-  type: z17.string(),
-  coverageType: z17.string().optional(),
-  excerpt: z17.string().optional(),
-  content: z17.string().optional(),
-  subsections: z17.array(SubsectionSchema).optional(),
-  recordId: z17.string().optional(),
-  documentNodeId: z17.string().optional(),
-  sourceSpanIds: z17.array(z17.string()).optional(),
-  sourceTextHash: z17.string().optional()
-});
-var SubjectivitySchema = z17.object({
   description: z17.string(),
-  category: z17.string().optional()
+  textExcerpt: z17.string().optional(),
+  sourceSpanIds: z17.array(z17.string().min(1)),
+  pageStart: z17.number().int().positive().optional(),
+  pageEnd: z17.number().int().positive().optional(),
+  bbox: z17.array(SourceSpanBBoxSchema).optional(),
+  order: z17.number().int().nonnegative(),
+  path: z17.string(),
+  metadata: z17.record(z17.string(), z17.unknown()).optional()
+});
+var SourceBackedValueSchema = z17.object({
+  value: z17.string(),
+  normalizedValue: z17.string().optional(),
+  confidence: z17.enum(["low", "medium", "high"]).default("medium"),
+  sourceNodeIds: z17.array(z17.string().min(1)).default([]),
+  sourceSpanIds: z17.array(z17.string().min(1)).default([])
+});
+var OperationalAddressSchema = z17.object({
+  street1: z17.string().optional(),
+  street2: z17.string().optional(),
+  city: z17.string().optional(),
+  state: z17.string().optional(),
+  zip: z17.string().optional(),
+  country: z17.string().optional(),
+  formatted: z17.string().optional()
+});
+var OperationalDeclarationFactSchema = z17.object({
+  field: z17.enum([
+    "namedInsured",
+    "mailingAddress",
+    "dba",
+    "entityType",
+    "taxId",
+    "additionalNamedInsured",
+    "policyNumber",
+    "insurer",
+    "broker",
+    "effectiveDate",
+    "expirationDate",
+    "premium",
+    "other"
+  ]),
+  label: z17.string().optional(),
+  value: z17.string(),
+  normalizedValue: z17.string().optional(),
+  valueKind: z17.enum(["string", "number", "date", "money", "address", "list", "unknown"]).default("string"),
+  address: OperationalAddressSchema.optional(),
+  confidence: z17.enum(["low", "medium", "high"]).default("medium"),
+  sourceNodeIds: z17.array(z17.string().min(1)).default([]),
+  sourceSpanIds: z17.array(z17.string().min(1)).default([])
 });
-var UnderwritingConditionSchema = z17.object({
-  description: z17.string()
+var OperationalCoverageTermSchema = z17.object({
+  kind: z17.enum([
+    "each_claim_limit",
+    "each_occurrence_limit",
+    "each_loss_limit",
+    "aggregate_limit",
+    "sublimit",
+    "retention",
+    "deductible",
+    "retroactive_date",
+    "premium",
+    "other"
+  ]).default("other"),
+  label: z17.string(),
+  value: z17.string(),
+  amount: z17.number().optional(),
+  appliesTo: z17.string().optional(),
+  sourceNodeIds: z17.array(z17.string().min(1)).default([]),
+  sourceSpanIds: z17.array(z17.string().min(1)).default([])
 });
-var PremiumLineSchema = z17.object({
+var OperationalCoverageLineSchema = z17.object({
+  name: z17.string(),
+  lineOfBusiness: AcordLobCodeSchema.optional(),
+  coverageCode: z17.string().optional(),
+  limit: z17.string().optional(),
+  deductible: z17.string().optional(),
+  premium: z17.string().optional(),
+  retroactiveDate: z17.string().optional(),
+  formNumber: z17.string().optional(),
+  sectionRef: z17.string().optional(),
+  endorsementNumber: z17.string().optional(),
+  limits: z17.array(OperationalCoverageTermSchema).default([]),
+  sourceNodeIds: z17.array(z17.string().min(1)).default([]),
+  sourceSpanIds: z17.array(z17.string().min(1)).default([])
+});
+var OperationalCoverageScheduleValueSchema = z17.object({
+  label: z17.string(),
+  value: z17.string()
+});
+var OperationalCoverageScheduleItemSchema = z17.object({
+  label: z17.string(),
+  description: z17.string().optional(),
+  values: z17.array(OperationalCoverageScheduleValueSchema).default([]),
+  sourceSpanIds: z17.array(z17.string().min(1)).default([])
+});
+var OperationalCoverageScheduleSchema = z17.object({
+  name: z17.string(),
+  kind: z17.enum(["vehicle", "property", "location", "other"]),
+  description: z17.string().optional(),
+  items: z17.array(OperationalCoverageScheduleItemSchema).default([]),
+  sourceSpanIds: z17.array(z17.string().min(1)).default([]),
+  pageStart: z17.number().int().positive().optional(),
+  pageEnd: z17.number().int().positive().optional()
+});
+var OperationalPremiumLineSchema = z17.object({
   line: z17.string(),
   amount: z17.string(),
   amountValue: z17.number().optional(),
-  documentNodeId: z17.string().optional(),
-  sourceSpanIds: z17.array(z17.string()).optional(),
-  sourceTextHash: z17.string().optional()
+  sourceNodeIds: z17.array(z17.string().min(1)).default([]),
+  sourceSpanIds: z17.array(z17.string().min(1)).default([])
 });
-var AuxiliaryFactSchema = z17.object({
-  key: z17.string(),
-  value: z17.string(),
-  subject: z17.string().optional(),
-  context: z17.string().optional(),
-  documentNodeId: z17.string().optional(),
-  sourceSpanIds: z17.array(z17.string()).optional(),
-  sourceTextHash: z17.string().optional()
-});
-var DefinitionSchema = z17.object({
-  term: z17.string(),
-  definition: z17.string(),
-  pageNumber: z17.number().optional(),
-  formNumber: z17.string().optional(),
-  formTitle: z17.string().optional(),
-  sectionRef: z17.string().optional(),
-  originalContent: z17.string().optional(),
-  recordId: z17.string().optional(),
-  documentNodeId: z17.string().optional(),
-  sourceSpanIds: z17.array(z17.string()).optional(),
-  sourceTextHash: z17.string().optional()
-});
-var CoveredReasonSchema = z17.object({
-  coverageName: z17.string(),
-  reasonNumber: z17.string().optional(),
-  title: z17.string().optional(),
-  content: z17.string(),
-  conditions: z17.array(z17.string()).optional(),
-  exceptions: z17.array(z17.string()).optional(),
-  appliesTo: z17.array(z17.string()).optional(),
-  pageNumber: z17.number().optional(),
-  formNumber: z17.string().optional(),
-  formTitle: z17.string().optional(),
-  sectionRef: z17.string().optional(),
-  originalContent: z17.string().optional(),
-  recordId: z17.string().optional(),
-  documentNodeId: z17.string().optional(),
-  sourceSpanIds: z17.array(z17.string()).optional(),
-  sourceTextHash: z17.string().optional()
-});
-var DocumentTableOfContentsEntrySchema = z17.object({
-  title: z17.string(),
-  level: z17.number().int().positive().optional(),
-  pageStart: z17.number().optional(),
-  pageEnd: z17.number().optional(),
-  documentNodeId: z17.string().optional(),
-  sourceSpanIds: z17.array(z17.string()).optional()
-});
-var DocumentPageMapEntrySchema = z17.object({
-  page: z17.number().int().positive(),
-  label: z17.string().optional(),
-  formNumber: z17.string().optional(),
-  formTitle: z17.string().optional(),
-  sectionTitle: z17.string().optional(),
-  extractorNames: z17.array(z17.string()).optional(),
-  sourceSpanIds: z17.array(z17.string()).optional()
+var OperationalTaxFeeItemSchema = z17.object({
+  name: z17.string(),
+  amount: z17.string(),
+  amountValue: z17.number().optional(),
+  type: z17.string().optional(),
+  description: z17.string().optional(),
+  sourceNodeIds: z17.array(z17.string().min(1)).default([]),
+  sourceSpanIds: z17.array(z17.string().min(1)).default([])
+});
+var OperationalPartySchema = z17.object({
+  role: z17.string(),
+  name: z17.string(),
+  address: OperationalAddressSchema.optional(),
+  sourceNodeIds: z17.array(z17.string().min(1)).default([]),
+  sourceSpanIds: z17.array(z17.string().min(1)).default([])
 });
-var DocumentAgentGuidanceSchema = z17.object({
+var OperationalEndorsementSupportSchema = z17.object({
   kind: z17.string(),
-  title: z17.string(),
-  detail: z17.string(),
-  sourceSpanIds: z17.array(z17.string()).optional()
-});
-var DocumentMetadataSchema = z17.object({
-  sourceTreeVersion: z17.string().optional(),
-  sourceTreeCanonical: z17.boolean().optional(),
-  formInventory: z17.array(FormReferenceSchema).optional(),
-  tableOfContents: z17.array(DocumentTableOfContentsEntrySchema).optional(),
-  pageMap: z17.array(DocumentPageMapEntrySchema).optional(),
-  agentGuidance: z17.array(DocumentAgentGuidanceSchema).optional()
-});
-var DocumentNodeSchema = z17.lazy(
-  () => z17.object({
-    id: z17.string(),
-    title: z17.string(),
-    originalTitle: z17.string().optional(),
-    type: z17.string().optional(),
-    label: z17.string().optional(),
-    level: z17.number().int().positive().optional(),
-    sectionNumber: z17.string().optional(),
-    pageStart: z17.number().optional(),
-    pageEnd: z17.number().optional(),
-    formNumber: z17.string().optional(),
-    formTitle: z17.string().optional(),
-    excerpt: z17.string().optional(),
-    content: z17.string().optional(),
-    interpretationLabels: z17.array(z17.string()).optional(),
-    sourceSpanIds: z17.array(z17.string()).optional(),
-    sourceTextHash: z17.string().optional(),
-    children: z17.array(DocumentNodeSchema).optional()
+  status: z17.enum(["supported", "excluded", "requires_review"]),
+  summary: z17.string(),
+  sourceNodeIds: z17.array(z17.string().min(1)).default([]),
+  sourceSpanIds: z17.array(z17.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 = z17.preprocess(
+  (value) => Array.isArray(value) ? toLobCodes(value.filter((item) => typeof item === "string")) : void 0,
+  z17.array(AcordLobCodeSchema).default(["UN"])
+);
+var PolicyOperationalProfileSchema = z17.preprocess(
+  legacyOperationalProfileInput,
+  z17.object({
+    documentType: z17.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(),
+    operationsDescription: SourceBackedValueSchema.optional(),
+    declarationFacts: z17.array(OperationalDeclarationFactSchema).default([]),
+    coverages: z17.array(OperationalCoverageLineSchema).default([]),
+    coverageSchedules: z17.array(OperationalCoverageScheduleSchema).optional(),
+    premiumBreakdown: z17.array(OperationalPremiumLineSchema).optional(),
+    taxesAndFees: z17.array(OperationalTaxFeeItemSchema).optional(),
+    totalCost: SourceBackedValueSchema.optional(),
+    parties: z17.array(OperationalPartySchema).default([]),
+    endorsementSupport: z17.array(OperationalEndorsementSupportSchema).default([]),
+    sourceNodeIds: z17.array(z17.string().min(1)).default([]),
+    sourceSpanIds: z17.array(z17.string().min(1)).default([]),
+    warnings: z17.array(z17.string()).default([])
+  })
+);
+
+// src/schemas/document.ts
+var SubsectionSchema = z18.object({
+  title: z18.string(),
+  sectionNumber: z18.string().optional(),
+  pageNumber: z18.number().optional(),
+  excerpt: z18.string().optional(),
+  content: z18.string().optional(),
+  documentNodeId: z18.string().optional(),
+  sourceSpanIds: z18.array(z18.string()).optional(),
+  sourceTextHash: z18.string().optional()
+});
+var SectionSchema = z18.object({
+  title: z18.string(),
+  sectionNumber: z18.string().optional(),
+  pageStart: z18.number(),
+  pageEnd: z18.number().optional(),
+  type: z18.string(),
+  coverageType: z18.string().optional(),
+  excerpt: z18.string().optional(),
+  content: z18.string().optional(),
+  subsections: z18.array(SubsectionSchema).optional(),
+  recordId: z18.string().optional(),
+  documentNodeId: z18.string().optional(),
+  sourceSpanIds: z18.array(z18.string()).optional(),
+  sourceTextHash: z18.string().optional()
+});
+var SubjectivitySchema = z18.object({
+  description: z18.string(),
+  category: z18.string().optional()
+});
+var UnderwritingConditionSchema = z18.object({
+  description: z18.string()
+});
+var PremiumLineSchema = z18.object({
+  line: z18.string(),
+  amount: z18.string(),
+  amountValue: z18.number().optional(),
+  documentNodeId: z18.string().optional(),
+  sourceSpanIds: z18.array(z18.string()).optional(),
+  sourceTextHash: z18.string().optional()
+});
+var AuxiliaryFactSchema = z18.object({
+  key: z18.string(),
+  value: z18.string(),
+  subject: z18.string().optional(),
+  context: z18.string().optional(),
+  documentNodeId: z18.string().optional(),
+  sourceSpanIds: z18.array(z18.string()).optional(),
+  sourceTextHash: z18.string().optional()
+});
+var DefinitionSchema = z18.object({
+  term: z18.string(),
+  definition: z18.string(),
+  pageNumber: z18.number().optional(),
+  formNumber: z18.string().optional(),
+  formTitle: z18.string().optional(),
+  sectionRef: z18.string().optional(),
+  originalContent: z18.string().optional(),
+  recordId: z18.string().optional(),
+  documentNodeId: z18.string().optional(),
+  sourceSpanIds: z18.array(z18.string()).optional(),
+  sourceTextHash: z18.string().optional()
+});
+var CoveredReasonSchema = z18.object({
+  coverageName: z18.string(),
+  reasonNumber: z18.string().optional(),
+  title: z18.string().optional(),
+  content: z18.string(),
+  conditions: z18.array(z18.string()).optional(),
+  exceptions: z18.array(z18.string()).optional(),
+  appliesTo: z18.array(z18.string()).optional(),
+  pageNumber: z18.number().optional(),
+  formNumber: z18.string().optional(),
+  formTitle: z18.string().optional(),
+  sectionRef: z18.string().optional(),
+  originalContent: z18.string().optional(),
+  recordId: z18.string().optional(),
+  documentNodeId: z18.string().optional(),
+  sourceSpanIds: z18.array(z18.string()).optional(),
+  sourceTextHash: z18.string().optional()
+});
+var DocumentTableOfContentsEntrySchema = z18.object({
+  title: z18.string(),
+  level: z18.number().int().positive().optional(),
+  pageStart: z18.number().optional(),
+  pageEnd: z18.number().optional(),
+  documentNodeId: z18.string().optional(),
+  sourceSpanIds: z18.array(z18.string()).optional()
+});
+var DocumentPageMapEntrySchema = z18.object({
+  page: z18.number().int().positive(),
+  label: z18.string().optional(),
+  formNumber: z18.string().optional(),
+  formTitle: z18.string().optional(),
+  sectionTitle: z18.string().optional(),
+  extractorNames: z18.array(z18.string()).optional(),
+  sourceSpanIds: z18.array(z18.string()).optional()
+});
+var DocumentAgentGuidanceSchema = z18.object({
+  kind: z18.string(),
+  title: z18.string(),
+  detail: z18.string(),
+  sourceSpanIds: z18.array(z18.string()).optional()
+});
+var DocumentMetadataSchema = z18.object({
+  sourceTreeVersion: z18.string().optional(),
+  sourceTreeCanonical: z18.boolean().optional(),
+  formInventory: z18.array(FormReferenceSchema).optional(),
+  tableOfContents: z18.array(DocumentTableOfContentsEntrySchema).optional(),
+  pageMap: z18.array(DocumentPageMapEntrySchema).optional(),
+  agentGuidance: z18.array(DocumentAgentGuidanceSchema).optional()
+});
+var DocumentNodeSchema = z18.lazy(
+  () => z18.object({
+    id: z18.string(),
+    title: z18.string(),
+    originalTitle: z18.string().optional(),
+    type: z18.string().optional(),
+    label: z18.string().optional(),
+    level: z18.number().int().positive().optional(),
+    sectionNumber: z18.string().optional(),
+    pageStart: z18.number().optional(),
+    pageEnd: z18.number().optional(),
+    formNumber: z18.string().optional(),
+    formTitle: z18.string().optional(),
+    excerpt: z18.string().optional(),
+    content: z18.string().optional(),
+    interpretationLabels: z18.array(z18.string()).optional(),
+    sourceSpanIds: z18.array(z18.string()).optional(),
+    sourceTextHash: z18.string().optional(),
+    children: z18.array(DocumentNodeSchema).optional()
   })
 );
 var BaseDocumentFields = {
-  id: z17.string(),
-  carrier: z17.string(),
-  security: z17.string().optional(),
-  insuredName: z17.string(),
-  premium: z17.string().optional(),
-  premiumAmount: z17.number().optional(),
-  summary: z17.string().optional(),
-  linesOfBusiness: z17.array(z17.string()).optional(),
-  coverages: z17.array(CoverageSchema),
+  id: z18.string(),
+  carrier: z18.string(),
+  security: z18.string().optional(),
+  insuredName: z18.string(),
+  premium: z18.string().optional(),
+  premiumAmount: z18.number().optional(),
+  premiumBreakdown: z18.array(PremiumLineSchema).optional(),
+  summary: z18.string().optional(),
+  linesOfBusiness: z18.array(z18.string()).optional(),
+  coverages: z18.array(CoverageSchema),
   documentMetadata: DocumentMetadataSchema,
-  documentOutline: z17.array(DocumentNodeSchema),
-  sections: z17.array(SectionSchema).optional(),
-  definitions: z17.array(DefinitionSchema).optional(),
-  coveredReasons: z17.array(CoveredReasonSchema).optional(),
+  documentOutline: z18.array(DocumentNodeSchema),
+  sections: z18.array(SectionSchema).optional(),
+  definitions: z18.array(DefinitionSchema).optional(),
+  coveredReasons: z18.array(CoveredReasonSchema).optional(),
   // Enriched fields (v1.2+)
-  carrierLegalName: z17.string().optional(),
-  carrierNaicNumber: z17.string().optional(),
-  carrierAmBestRating: z17.string().optional(),
-  carrierAdmittedStatus: z17.string().optional(),
-  mga: z17.string().optional(),
-  underwriter: z17.string().optional(),
-  brokerAgency: z17.string().optional(),
-  brokerContactName: z17.string().optional(),
-  brokerLicenseNumber: z17.string().optional(),
-  priorPolicyNumber: z17.string().optional(),
-  programName: z17.string().optional(),
-  isRenewal: z17.boolean().optional(),
-  isPackage: z17.boolean().optional(),
-  insuredDba: z17.string().optional(),
+  carrierLegalName: z18.string().optional(),
+  carrierNaicNumber: z18.string().optional(),
+  carrierAmBestRating: z18.string().optional(),
+  carrierAdmittedStatus: z18.string().optional(),
+  mga: z18.string().optional(),
+  underwriter: z18.string().optional(),
+  brokerAgency: z18.string().optional(),
+  brokerContactName: z18.string().optional(),
+  brokerLicenseNumber: z18.string().optional(),
+  priorPolicyNumber: z18.string().optional(),
+  programName: z18.string().optional(),
+  isRenewal: z18.boolean().optional(),
+  isPackage: z18.boolean().optional(),
+  insuredDba: z18.string().optional(),
   insuredAddress: SourceBackedAddressSchema.optional(),
   insuredEntityType: EntityTypeSchema.optional(),
-  additionalNamedInsureds: z17.array(NamedInsuredSchema).optional(),
-  insuredSicCode: z17.string().optional(),
-  insuredNaicsCode: z17.string().optional(),
-  insuredFein: z17.string().optional(),
-  enrichedCoverages: z17.array(EnrichedCoverageSchema).optional(),
-  endorsements: z17.array(EndorsementSchema).optional(),
-  exclusions: z17.array(ExclusionSchema).optional(),
-  conditions: z17.array(PolicyConditionSchema).optional(),
+  additionalNamedInsureds: z18.array(NamedInsuredSchema).optional(),
+  insuredSicCode: z18.string().optional(),
+  insuredNaicsCode: z18.string().optional(),
+  insuredFein: z18.string().optional(),
+  enrichedCoverages: z18.array(EnrichedCoverageSchema).optional(),
+  endorsements: z18.array(EndorsementSchema).optional(),
+  exclusions: z18.array(ExclusionSchema).optional(),
+  conditions: z18.array(PolicyConditionSchema).optional(),
   limits: LimitScheduleSchema.optional(),
   deductibles: DeductibleScheduleSchema.optional(),
-  locations: z17.array(InsuredLocationSchema).optional(),
-  vehicles: z17.array(InsuredVehicleSchema).optional(),
-  classifications: z17.array(ClassificationCodeSchema).optional(),
-  formInventory: z17.array(FormReferenceSchema).optional(),
+  locations: z18.array(InsuredLocationSchema).optional(),
+  vehicles: z18.array(InsuredVehicleSchema).optional(),
+  classifications: z18.array(ClassificationCodeSchema).optional(),
+  coverageSchedules: z18.array(OperationalCoverageScheduleSchema).optional(),
+  formInventory: z18.array(FormReferenceSchema).optional(),
   declarations: DeclarationsSchema.optional(),
   coverageForm: CoverageFormSchema.optional(),
-  retroactiveDate: z17.string().optional(),
+  retroactiveDate: z18.string().optional(),
   extendedReportingPeriod: ExtendedReportingPeriodSchema.optional(),
   insurer: InsurerInfoSchema.optional(),
   producer: ProducerInfoSchema.optional(),
-  claimsContacts: z17.array(ContactSchema).optional(),
-  regulatoryContacts: z17.array(ContactSchema).optional(),
-  thirdPartyAdministrators: z17.array(ContactSchema).optional(),
-  additionalInsureds: z17.array(EndorsementPartySchema).optional(),
-  lossPayees: z17.array(EndorsementPartySchema).optional(),
-  mortgageHolders: z17.array(EndorsementPartySchema).optional(),
-  taxesAndFees: z17.array(TaxFeeItemSchema).optional(),
-  totalCost: z17.string().optional(),
-  totalCostAmount: z17.number().optional(),
-  minimumPremium: z17.string().optional(),
-  minimumPremiumAmount: z17.number().optional(),
-  depositPremium: z17.string().optional(),
-  depositPremiumAmount: z17.number().optional(),
+  claimsContacts: z18.array(ContactSchema).optional(),
+  regulatoryContacts: z18.array(ContactSchema).optional(),
+  thirdPartyAdministrators: z18.array(ContactSchema).optional(),
+  additionalInsureds: z18.array(EndorsementPartySchema).optional(),
+  lossPayees: z18.array(EndorsementPartySchema).optional(),
+  mortgageHolders: z18.array(EndorsementPartySchema).optional(),
+  taxesAndFees: z18.array(TaxFeeItemSchema).optional(),
+  totalCost: z18.string().optional(),
+  totalCostAmount: z18.number().optional(),
+  minimumPremium: z18.string().optional(),
+  minimumPremiumAmount: z18.number().optional(),
+  depositPremium: z18.string().optional(),
+  depositPremiumAmount: z18.number().optional(),
   paymentPlan: PaymentPlanSchema.optional(),
   auditType: AuditTypeSchema.optional(),
-  ratingBasis: z17.array(RatingBasisSchema).optional(),
-  premiumByLocation: z17.array(LocationPremiumSchema).optional(),
+  ratingBasis: z18.array(RatingBasisSchema).optional(),
+  premiumByLocation: z18.array(LocationPremiumSchema).optional(),
   lossSummary: LossSummarySchema.optional(),
-  individualClaims: z17.array(ClaimRecordSchema).optional(),
+  individualClaims: z18.array(ClaimRecordSchema).optional(),
   experienceMod: ExperienceModSchema.optional(),
-  cancellationNoticeDays: z17.number().optional(),
-  nonrenewalNoticeDays: z17.number().optional(),
-  supplementaryFacts: z17.array(AuxiliaryFactSchema).optional()
+  cancellationNoticeDays: z18.number().optional(),
+  nonrenewalNoticeDays: z18.number().optional(),
+  supplementaryFacts: z18.array(AuxiliaryFactSchema).optional()
 };
-var PolicyDocumentSchema = z17.object({
+var PolicyDocumentSchema = z18.object({
   ...BaseDocumentFields,
-  type: z17.literal("policy"),
-  policyNumber: z17.string(),
-  effectiveDate: z17.string(),
-  expirationDate: z17.string().optional(),
+  type: z18.literal("policy"),
+  policyNumber: z18.string(),
+  effectiveDate: z18.string(),
+  expirationDate: z18.string().optional(),
   policyTermType: PolicyTermTypeSchema.optional(),
-  nextReviewDate: z17.string().optional(),
-  effectiveTime: z17.string().optional()
+  nextReviewDate: z18.string().optional(),
+  effectiveTime: z18.string().optional()
 });
-var QuoteDocumentSchema = z17.object({
+var QuoteDocumentSchema = z18.object({
   ...BaseDocumentFields,
-  type: z17.literal("quote"),
-  quoteNumber: z17.string(),
-  proposedEffectiveDate: z17.string().optional(),
-  proposedExpirationDate: z17.string().optional(),
-  quoteExpirationDate: z17.string().optional(),
-  subjectivities: z17.array(SubjectivitySchema).optional(),
-  underwritingConditions: z17.array(UnderwritingConditionSchema).optional(),
-  premiumBreakdown: z17.array(PremiumLineSchema).optional(),
+  type: z18.literal("quote"),
+  quoteNumber: z18.string(),
+  proposedEffectiveDate: z18.string().optional(),
+  proposedExpirationDate: z18.string().optional(),
+  quoteExpirationDate: z18.string().optional(),
+  subjectivities: z18.array(SubjectivitySchema).optional(),
+  underwritingConditions: z18.array(UnderwritingConditionSchema).optional(),
   // Enriched quote fields (v1.2+)
-  enrichedSubjectivities: z17.array(EnrichedSubjectivitySchema).optional(),
-  enrichedUnderwritingConditions: z17.array(EnrichedUnderwritingConditionSchema).optional(),
-  warrantyRequirements: z17.array(z17.string()).optional(),
-  lossControlRecommendations: z17.array(z17.string()).optional(),
+  enrichedSubjectivities: z18.array(EnrichedSubjectivitySchema).optional(),
+  enrichedUnderwritingConditions: z18.array(EnrichedUnderwritingConditionSchema).optional(),
+  warrantyRequirements: z18.array(z18.string()).optional(),
+  lossControlRecommendations: z18.array(z18.string()).optional(),
   bindingAuthority: BindingAuthoritySchema.optional()
 });
-var InsuranceDocumentSchema = z17.discriminatedUnion("type", [
+var InsuranceDocumentSchema = z18.discriminatedUnion("type", [
   PolicyDocumentSchema,
   QuoteDocumentSchema
 ]);
 
 // src/schemas/platform.ts
-import { z as z18 } from "zod";
-var PlatformSchema = z18.enum(["email", "chat", "sms", "slack", "discord"]);
-var CommunicationIntentSchema = z18.enum(["direct", "mediated", "observed"]);
+import { z as z19 } from "zod";
+var PlatformSchema = z19.enum(["email", "chat", "sms", "slack", "discord"]);
+var CommunicationIntentSchema = z19.enum(["direct", "mediated", "observed"]);
 var PLATFORM_CONFIGS = {
   email: {
     supportsMarkdown: false,
@@ -1894,65 +2185,65 @@ var PLATFORM_CONFIGS = {
 };
 
 // src/schemas/pce.ts
-import { z as z20 } from "zod";
+import { z as z21 } from "zod";
 
 // src/case/index.ts
-import { z as z19 } from "zod";
-var CaseEvidenceSourceSchema = z19.object({
-  id: z19.string(),
-  label: z19.string().optional(),
-  documentId: z19.string().optional(),
-  page: z19.number().optional(),
-  fieldPath: z19.string().optional(),
-  text: z19.string().describe("Source text available for span validation and citation"),
-  metadata: z19.record(z19.string(), z19.string()).optional()
-});
-var CaseCitationSchema = z19.object({
-  sourceId: z19.string(),
-  quote: z19.string(),
-  page: z19.number().optional(),
-  fieldPath: z19.string().optional()
-});
-var ValidationIssueSeveritySchema = z19.enum(["info", "warning", "blocking"]);
-var CaseValidationIssueSchema = z19.object({
-  code: z19.string(),
+import { z as z20 } from "zod";
+var CaseEvidenceSourceSchema = z20.object({
+  id: z20.string(),
+  label: z20.string().optional(),
+  documentId: z20.string().optional(),
+  page: z20.number().optional(),
+  fieldPath: z20.string().optional(),
+  text: z20.string().describe("Source text available for span validation and citation"),
+  metadata: z20.record(z20.string(), z20.string()).optional()
+});
+var CaseCitationSchema = z20.object({
+  sourceId: z20.string(),
+  quote: z20.string(),
+  page: z20.number().optional(),
+  fieldPath: z20.string().optional()
+});
+var ValidationIssueSeveritySchema = z20.enum(["info", "warning", "blocking"]);
+var CaseValidationIssueSchema = z20.object({
+  code: z20.string(),
   severity: ValidationIssueSeveritySchema,
-  message: z19.string(),
-  itemId: z19.string().optional(),
-  fieldPath: z19.string().optional(),
-  sourceId: z19.string().optional()
-});
-var MissingInfoQuestionSchema = z19.object({
-  id: z19.string(),
-  itemId: z19.string().optional(),
-  fieldPath: z19.string().optional(),
-  question: z19.string(),
-  reason: z19.string(),
-  answer: z19.string().optional()
-});
-var CasePacketArtifactKindSchema = z19.enum([
+  message: z20.string(),
+  itemId: z20.string().optional(),
+  fieldPath: z20.string().optional(),
+  sourceId: z20.string().optional()
+});
+var MissingInfoQuestionSchema = z20.object({
+  id: z20.string(),
+  itemId: z20.string().optional(),
+  fieldPath: z20.string().optional(),
+  question: z20.string(),
+  reason: z20.string(),
+  answer: z20.string().optional()
+});
+var CasePacketArtifactKindSchema = z20.enum([
   "underwriter_summary",
   "carrier_email",
   "missing_info_request",
   "json_packet",
   "validation_report"
 ]);
-var CasePacketArtifactSchema = z19.object({
-  id: z19.string(),
+var CasePacketArtifactSchema = z20.object({
+  id: z20.string(),
   kind: CasePacketArtifactKindSchema,
-  title: z19.string(),
-  content: z19.string(),
-  citations: z19.array(CaseCitationSchema).default([])
-});
-var CaseSubmissionPacketSchema = z19.object({
-  id: z19.string(),
-  caseId: z19.string(),
-  artifacts: z19.array(CasePacketArtifactSchema),
-  validationIssues: z19.array(CaseValidationIssueSchema),
-  missingInfoQuestions: z19.array(MissingInfoQuestionSchema),
-  createdAt: z19.number()
-});
-var CaseActionSchema = z19.enum([
+  title: z20.string(),
+  content: z20.string(),
+  citations: z20.array(CaseCitationSchema).default([])
+});
+var CaseSubmissionPacketSchema = z20.object({
+  id: z20.string(),
+  caseId: z20.string(),
+  artifacts: z20.array(CasePacketArtifactSchema),
+  validationIssues: z20.array(CaseValidationIssueSchema),
+  missingInfoQuestions: z20.array(MissingInfoQuestionSchema),
+  createdAt: z20.number()
+});
+var CaseActionSchema = z20.enum([
   "inspect_attachments",
   "retrieve_policy_evidence",
   "retrieve_prior_applications",
@@ -1965,23 +2256,23 @@ var CaseActionSchema = z19.enum([
   "generate_packet",
   "answer_field_or_case_question"
 ]);
-var AgenticExecutionModeSchema = z19.enum(["deterministic_tree", "market_eval", "hybrid"]);
-var CaseProposalScoreSchema = z19.object({
-  grounding: z19.number().min(0).max(1),
-  completeness: z19.number().min(0).max(1),
-  consistency: z19.number().min(0).max(1),
-  determinism: z19.number().min(0).max(1),
-  risk: z19.number().min(0).max(1),
-  cost: z19.number().min(0).max(1)
-});
-var CaseProposalSchema = z19.object({
-  id: z19.string(),
-  sourceSpanIds: z19.array(z19.string()).default([]),
-  confidence: z19.number().min(0).max(1),
-  missingInfo: z19.array(z19.string()).default([]),
-  validationIssues: z19.array(CaseValidationIssueSchema).default([]),
-  estimatedRisk: z19.number().min(0).max(1).default(0.5),
-  estimatedCost: z19.number().min(0).max(1).default(0.5),
+var AgenticExecutionModeSchema = z20.enum(["deterministic_tree", "market_eval", "hybrid"]);
+var CaseProposalScoreSchema = z20.object({
+  grounding: z20.number().min(0).max(1),
+  completeness: z20.number().min(0).max(1),
+  consistency: z20.number().min(0).max(1),
+  determinism: z20.number().min(0).max(1),
+  risk: z20.number().min(0).max(1),
+  cost: z20.number().min(0).max(1)
+});
+var CaseProposalSchema = z20.object({
+  id: z20.string(),
+  sourceSpanIds: z20.array(z20.string()).default([]),
+  confidence: z20.number().min(0).max(1),
+  missingInfo: z20.array(z20.string()).default([]),
+  validationIssues: z20.array(CaseValidationIssueSchema).default([]),
+  estimatedRisk: z20.number().min(0).max(1).default(0.5),
+  estimatedCost: z20.number().min(0).max(1).default(0.5),
   score: CaseProposalScoreSchema.optional()
 });
 function stableCaseId(prefix, parts) {
@@ -2100,8 +2391,8 @@ function totalProposalScore(score) {
 }
 
 // src/schemas/pce.ts
-var PolicyChangeActionSchema = z20.enum(["add", "remove", "update", "replace", "clarify"]);
-var PolicyChangeKindSchema = z20.enum([
+var PolicyChangeActionSchema = z21.enum(["add", "remove", "update", "replace", "clarify"]);
+var PolicyChangeKindSchema = z21.enum([
   "named_insured_change",
   "additional_insured_change",
   "coverage_change",
@@ -2115,70 +2406,70 @@ var PolicyChangeKindSchema = z20.enum([
   "renewal_submission_update",
   "general_endorsement"
 ]);
-var PolicyChangeConfidenceSchema = z20.enum(["high", "medium", "low"]);
-var PolicyChangeStatusSchema = z20.enum(["draft", "needs_info", "ready", "blocked"]);
-var PolicyChangeItemSchema = z20.object({
-  id: z20.string(),
+var PolicyChangeConfidenceSchema = z21.enum(["high", "medium", "low"]);
+var PolicyChangeStatusSchema = z21.enum(["draft", "needs_info", "ready", "blocked"]);
+var PolicyChangeItemSchema = z21.object({
+  id: z21.string(),
   kind: PolicyChangeKindSchema.default("general_endorsement"),
   action: PolicyChangeActionSchema,
-  affectedPolicyId: z20.string().default("unknown"),
-  fieldPath: z20.string().describe("Stable policy field path or business field name"),
-  label: z20.string(),
-  beforeValue: z20.string().optional().describe("Existing policy value, when cited from policy evidence"),
-  afterValue: z20.string().optional().describe("Requested new value"),
-  requestedValue: z20.string().optional().describe("Alias for afterValue used by policy-change workflows"),
-  effectiveDate: z20.string().optional(),
-  reason: z20.string().optional(),
-  sourceIds: z20.array(z20.string()).default([]),
-  sourceSpanIds: z20.array(z20.string()).default([]),
-  userSourceSpanIds: z20.array(z20.string()).optional(),
-  citations: z20.array(CaseCitationSchema).default([]),
+  affectedPolicyId: z21.string().default("unknown"),
+  fieldPath: z21.string().describe("Stable policy field path or business field name"),
+  label: z21.string(),
+  beforeValue: z21.string().optional().describe("Existing policy value, when cited from policy evidence"),
+  afterValue: z21.string().optional().describe("Requested new value"),
+  requestedValue: z21.string().optional().describe("Alias for afterValue used by policy-change workflows"),
+  effectiveDate: z21.string().optional(),
+  reason: z21.string().optional(),
+  sourceIds: z21.array(z21.string()).default([]),
+  sourceSpanIds: z21.array(z21.string()).default([]),
+  userSourceSpanIds: z21.array(z21.string()).optional(),
+  citations: z21.array(CaseCitationSchema).default([]),
   confidence: PolicyChangeConfidenceSchema.default("medium"),
-  confidenceScore: z20.number().min(0).max(1).optional(),
+  confidenceScore: z21.number().min(0).max(1).optional(),
   status: PolicyChangeStatusSchema.default("ready")
 });
-var PceNormalizationResultSchema = z20.object({
-  summary: z20.string(),
-  items: z20.array(PolicyChangeItemSchema.omit({ id: true, status: true }).extend({
-    id: z20.string().optional(),
+var PceNormalizationResultSchema = z21.object({
+  summary: z21.string(),
+  items: z21.array(PolicyChangeItemSchema.omit({ id: true, status: true }).extend({
+    id: z21.string().optional(),
     status: PolicyChangeStatusSchema.optional()
   })),
-  missingInfoQuestions: z20.array(MissingInfoQuestionSchema.omit({ id: true }).extend({
-    id: z20.string().optional()
+  missingInfoQuestions: z21.array(MissingInfoQuestionSchema.omit({ id: true }).extend({
+    id: z21.string().optional()
   })).default([])
 });
-var PolicyChangeImpactSchema = z20.object({
-  itemId: z20.string(),
-  beforeValue: z20.string().optional(),
-  requestedValue: z20.string().optional(),
-  likelyEndorsementRequired: z20.boolean().default(true),
-  carrierApprovalLikelyRequired: z20.boolean().default(true),
-  affectedCoverageForms: z20.array(z20.string()).default([]),
-  sourceSpanIds: z20.array(z20.string()).default([])
-});
-var PceCaseStateSchema = z20.object({
-  id: z20.string(),
-  requestText: z20.string(),
-  summary: z20.string(),
+var PolicyChangeImpactSchema = z21.object({
+  itemId: z21.string(),
+  beforeValue: z21.string().optional(),
+  requestedValue: z21.string().optional(),
+  likelyEndorsementRequired: z21.boolean().default(true),
+  carrierApprovalLikelyRequired: z21.boolean().default(true),
+  affectedCoverageForms: z21.array(z21.string()).default([]),
+  sourceSpanIds: z21.array(z21.string()).default([])
+});
+var PceCaseStateSchema = z21.object({
+  id: z21.string(),
+  requestText: z21.string(),
+  summary: z21.string(),
   executionMode: AgenticExecutionModeSchema.default("deterministic_tree"),
-  items: z20.array(PolicyChangeItemSchema),
-  impacts: z20.array(PolicyChangeImpactSchema),
-  evidenceSources: z20.array(CaseEvidenceSourceSchema),
-  validationIssues: z20.array(CaseValidationIssueSchema),
-  missingInfoQuestions: z20.array(MissingInfoQuestionSchema),
-  createdAt: z20.number(),
-  updatedAt: z20.number()
-});
-var PolicyChangeRequestSchema = z20.object({
-  id: z20.string(),
-  text: z20.string(),
+  items: z21.array(PolicyChangeItemSchema),
+  impacts: z21.array(PolicyChangeImpactSchema),
+  evidenceSources: z21.array(CaseEvidenceSourceSchema),
+  validationIssues: z21.array(CaseValidationIssueSchema),
+  missingInfoQuestions: z21.array(MissingInfoQuestionSchema),
+  createdAt: z21.number(),
+  updatedAt: z21.number()
+});
+var PolicyChangeRequestSchema = z21.object({
+  id: z21.string(),
+  text: z21.string(),
   executionMode: AgenticExecutionModeSchema.optional(),
-  userSourceSpanIds: z20.array(z20.string()).optional(),
-  createdAt: z20.number().optional()
+  userSourceSpanIds: z21.array(z21.string()).optional(),
+  createdAt: z21.number().optional()
 });
 var PceSubmissionPacketSchema = CaseSubmissionPacketSchema.extend({
   pceCase: PceCaseStateSchema,
-  artifacts: z20.array(CasePacketArtifactSchema)
+  artifacts: z21.array(CasePacketArtifactSchema)
 });
 
 // src/schemas/context-keys.ts
@@ -2233,252 +2524,6 @@ var CONTEXT_KEY_MAP = [
   { extractedField: "declarations.breed", category: "pet_info", contextKey: "pet_breed", description: "Pet breed" }
 ];
 
-// src/source/schemas.ts
-import { z as z21 } from "zod";
-var SourceSpanKindSchema = z21.enum([
-  "pdf_text",
-  "pdf_image",
-  "html",
-  "markdown",
-  "plain_text",
-  "structured_field"
-]);
-var SourceSpanUnitSchema = z21.enum([
-  "page",
-  "section",
-  "table",
-  "table_row",
-  "table_cell",
-  "key_value",
-  "text"
-]);
-var SourceKindSchema = z21.enum([
-  "policy_pdf",
-  "application_pdf",
-  "email",
-  "attachment",
-  "manual_note"
-]);
-var SourceSpanBBoxSchema = z21.object({
-  page: z21.number().int().positive(),
-  x: z21.number(),
-  y: z21.number(),
-  width: z21.number(),
-  height: z21.number()
-});
-var SourceSpanLocationSchema = z21.object({
-  page: z21.number().int().positive().optional(),
-  startPage: z21.number().int().positive().optional(),
-  endPage: z21.number().int().positive().optional(),
-  charStart: z21.number().int().nonnegative().optional(),
-  charEnd: z21.number().int().nonnegative().optional(),
-  lineStart: z21.number().int().positive().optional(),
-  lineEnd: z21.number().int().positive().optional(),
-  fieldPath: z21.string().optional()
-});
-var SourceSpanTableLocationSchema = z21.object({
-  tableId: z21.string().optional(),
-  rowIndex: z21.number().int().nonnegative().optional(),
-  columnIndex: z21.number().int().nonnegative().optional(),
-  columnName: z21.string().optional(),
-  rowSpanId: z21.string().optional(),
-  tableSpanId: z21.string().optional(),
-  isHeader: z21.boolean().optional()
-});
-var SourceSpanSchema = z21.object({
-  id: z21.string().min(1),
-  documentId: z21.string().min(1),
-  sourceKind: SourceKindSchema.optional(),
-  chunkId: z21.string().optional(),
-  kind: SourceSpanKindSchema,
-  text: z21.string(),
-  hash: z21.string().min(1),
-  textHash: z21.string().optional(),
-  pageStart: z21.number().int().positive().optional(),
-  pageEnd: z21.number().int().positive().optional(),
-  sectionId: z21.string().optional(),
-  formNumber: z21.string().optional(),
-  sourceUnit: SourceSpanUnitSchema.optional(),
-  parentSpanId: z21.string().optional(),
-  table: SourceSpanTableLocationSchema.optional(),
-  bbox: z21.array(SourceSpanBBoxSchema).optional(),
-  location: SourceSpanLocationSchema.optional(),
-  metadata: z21.record(z21.string(), z21.string()).optional()
-});
-var SourceSpanRefSchema = z21.object({
-  sourceSpanId: z21.string().min(1),
-  documentId: z21.string().min(1).optional(),
-  chunkId: z21.string().optional(),
-  quote: z21.string().optional(),
-  hash: z21.string().optional(),
-  location: SourceSpanLocationSchema.optional()
-});
-var SourceChunkSchema = z21.object({
-  id: z21.string().min(1),
-  documentId: z21.string().min(1),
-  sourceSpanIds: z21.array(z21.string().min(1)),
-  text: z21.string(),
-  textHash: z21.string().min(1),
-  pageStart: z21.number().int().positive().optional(),
-  pageEnd: z21.number().int().positive().optional(),
-  metadata: z21.record(z21.string(), z21.string()).default({})
-});
-var DocumentSourceNodeKindSchema = z21.enum([
-  "document",
-  "page_group",
-  "page",
-  "form",
-  "endorsement",
-  "section",
-  "schedule",
-  "clause",
-  "table",
-  "table_row",
-  "table_cell",
-  "text"
-]);
-var DocumentSourceNodeSchema = z21.object({
-  id: z21.string().min(1),
-  documentId: z21.string().min(1),
-  parentId: z21.string().optional(),
-  kind: DocumentSourceNodeKindSchema,
-  title: z21.string(),
-  description: z21.string(),
-  textExcerpt: z21.string().optional(),
-  sourceSpanIds: z21.array(z21.string().min(1)),
-  pageStart: z21.number().int().positive().optional(),
-  pageEnd: z21.number().int().positive().optional(),
-  bbox: z21.array(SourceSpanBBoxSchema).optional(),
-  order: z21.number().int().nonnegative(),
-  path: z21.string(),
-  metadata: z21.record(z21.string(), z21.unknown()).optional()
-});
-var SourceBackedValueSchema = z21.object({
-  value: z21.string(),
-  normalizedValue: z21.string().optional(),
-  confidence: z21.enum(["low", "medium", "high"]).default("medium"),
-  sourceNodeIds: z21.array(z21.string().min(1)).default([]),
-  sourceSpanIds: z21.array(z21.string().min(1)).default([])
-});
-var OperationalAddressSchema = z21.object({
-  street1: z21.string().optional(),
-  street2: z21.string().optional(),
-  city: z21.string().optional(),
-  state: z21.string().optional(),
-  zip: z21.string().optional(),
-  country: z21.string().optional(),
-  formatted: z21.string().optional()
-});
-var OperationalDeclarationFactSchema = z21.object({
-  field: z21.enum([
-    "namedInsured",
-    "mailingAddress",
-    "dba",
-    "entityType",
-    "taxId",
-    "additionalNamedInsured",
-    "policyNumber",
-    "insurer",
-    "broker",
-    "effectiveDate",
-    "expirationDate",
-    "premium",
-    "other"
-  ]),
-  label: z21.string().optional(),
-  value: z21.string(),
-  normalizedValue: z21.string().optional(),
-  valueKind: z21.enum(["string", "number", "date", "money", "address", "list", "unknown"]).default("string"),
-  address: OperationalAddressSchema.optional(),
-  confidence: z21.enum(["low", "medium", "high"]).default("medium"),
-  sourceNodeIds: z21.array(z21.string().min(1)).default([]),
-  sourceSpanIds: z21.array(z21.string().min(1)).default([])
-});
-var OperationalCoverageTermSchema = z21.object({
-  kind: z21.enum([
-    "each_claim_limit",
-    "each_occurrence_limit",
-    "each_loss_limit",
-    "aggregate_limit",
-    "sublimit",
-    "retention",
-    "deductible",
-    "retroactive_date",
-    "premium",
-    "other"
-  ]).default("other"),
-  label: z21.string(),
-  value: z21.string(),
-  amount: z21.number().optional(),
-  appliesTo: z21.string().optional(),
-  sourceNodeIds: z21.array(z21.string().min(1)).default([]),
-  sourceSpanIds: z21.array(z21.string().min(1)).default([])
-});
-var OperationalCoverageLineSchema = z21.object({
-  name: z21.string(),
-  lineOfBusiness: AcordLobCodeSchema.optional(),
-  coverageCode: z21.string().optional(),
-  limit: z21.string().optional(),
-  deductible: z21.string().optional(),
-  premium: z21.string().optional(),
-  retroactiveDate: z21.string().optional(),
-  formNumber: z21.string().optional(),
-  sectionRef: z21.string().optional(),
-  endorsementNumber: z21.string().optional(),
-  limits: z21.array(OperationalCoverageTermSchema).default([]),
-  sourceNodeIds: z21.array(z21.string().min(1)).default([]),
-  sourceSpanIds: z21.array(z21.string().min(1)).default([])
-});
-var OperationalPartySchema = z21.object({
-  role: z21.string(),
-  name: z21.string(),
-  sourceNodeIds: z21.array(z21.string().min(1)).default([]),
-  sourceSpanIds: z21.array(z21.string().min(1)).default([])
-});
-var OperationalEndorsementSupportSchema = z21.object({
-  kind: z21.string(),
-  status: z21.enum(["supported", "excluded", "requires_review"]),
-  summary: z21.string(),
-  sourceNodeIds: z21.array(z21.string().min(1)).default([]),
-  sourceSpanIds: z21.array(z21.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 = z21.preprocess(
-  (value) => Array.isArray(value) ? toLobCodes(value.filter((item) => typeof item === "string")) : void 0,
-  z21.array(AcordLobCodeSchema).default(["UN"])
-);
-var PolicyOperationalProfileSchema = z21.preprocess(
-  legacyOperationalProfileInput,
-  z21.object({
-    documentType: z21.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(),
-    declarationFacts: z21.array(OperationalDeclarationFactSchema).default([]),
-    coverages: z21.array(OperationalCoverageLineSchema).default([]),
-    parties: z21.array(OperationalPartySchema).default([]),
-    endorsementSupport: z21.array(OperationalEndorsementSupportSchema).default([]),
-    sourceNodeIds: z21.array(z21.string().min(1)).default([]),
-    sourceSpanIds: z21.array(z21.string().min(1)).default([]),
-    warnings: z21.array(z21.string()).default([])
-  })
-);
-
 // src/source/policy-types.ts
 var LOB_TEXT_PATTERNS = [
   { codes: ["CGL"], pattern: /\b(?:commercial\s+)?general\s+liability\b|\bcgl\b/i },
@@ -3829,7 +3874,7 @@ function shouldFailQualityGate(mode, status) {
 }
 
 // src/extraction/source-tree-extractor.ts
-import { z as z23 } from "zod";
+import { z as z24 } from "zod";
 
 // src/source/operational-profile.ts
 function normalizeWhitespace4(value) {
@@ -3847,6 +3892,34 @@ function cleanCoverageLineOfBusiness(value) {
 function normalizedFactValue(value) {
   return value.toLowerCase().replace(/&/g, " and ").replace(/[.,#]/g, " ").replace(/\s+/g, " ").trim();
 }
+var OPERATIONAL_ADDRESS_FIELDS = [
+  "street1",
+  "street2",
+  "city",
+  "state",
+  "zip",
+  "country",
+  "formatted"
+];
+function normalizeOperationalAddress(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const record = value;
+  const address = Object.fromEntries(
+    OPERATIONAL_ADDRESS_FIELDS.flatMap((field) => {
+      const cleaned = typeof record[field] === "string" ? cleanValue(record[field]) : void 0;
+      return cleaned ? [[field, cleaned]] : [];
+    })
+  );
+  return Object.keys(address).length > 0 ? address : void 0;
+}
+function normalizeOperationalPartyRole(value) {
+  const normalized = value.toLowerCase().replace(/[\s-]+/g, "_");
+  if (normalized === "namedinsured" || normalized === "insured") return "named_insured";
+  if (normalized === "managing_general_agent") return "mga";
+  if (normalized === "managing_general_underwriter") return "mga";
+  if (normalized === "third_party_administrator") return "administrator";
+  return normalized;
+}
 var OPERATIONAL_COVERAGE_TERM_KINDS = /* @__PURE__ */ new Set([
   "each_claim_limit",
   "each_occurrence_limit",
@@ -3945,6 +4018,7 @@ function mergeOperationalProfile(base, candidate, validNodeIds, validSpanIds) {
   const expirationDate = mergeValue(base.expirationDate, candidate.expirationDate);
   const retroactiveDate = mergeValue(base.retroactiveDate, candidate.retroactiveDate);
   const premium = mergeValue(base.premium, candidate.premium);
+  const operationsDescription = mergeValue(base.operationsDescription, candidate.operationsDescription);
   const candidateDeclarationFacts = Array.isArray(candidate.declarationFacts) ? candidate.declarationFacts.map(mergeDeclarationFact).filter((fact) => Boolean(fact)) : [];
   const declarationFacts = [
     ...base.declarationFacts,
@@ -3969,7 +4043,8 @@ function mergeOperationalProfile(base, candidate, validNodeIds, validSpanIds) {
     effectiveDate,
     expirationDate,
     retroactiveDate,
-    premium
+    premium,
+    operationsDescription
   ].filter((value) => Boolean(value));
   const coverages = base.coverages.length > 0 ? base.coverages : Array.isArray(candidate.coverages) ? candidate.coverages.map((coverage) => {
     const record = coverage;
@@ -4028,14 +4103,21 @@ function mergeOperationalProfile(base, candidate, validNodeIds, validSpanIds) {
     const record = party;
     const role = typeof record.role === "string" ? cleanValue(record.role) : void 0;
     const name = typeof record.name === "string" ? cleanValue(record.name) : void 0;
+    const address = normalizeOperationalAddress(record.address);
     const sourceNodeIds2 = keepIds(record.sourceNodeIds, validNodeIds);
     const sourceSpanIds2 = keepIds(record.sourceSpanIds, validSpanIds);
     if (!role || !name || sourceNodeIds2.length === 0 && sourceSpanIds2.length === 0) return [];
-    return [{ role, name, sourceNodeIds: sourceNodeIds2, sourceSpanIds: sourceSpanIds2 }];
+    return [{
+      role: normalizeOperationalPartyRole(role),
+      name,
+      address,
+      sourceNodeIds: sourceNodeIds2,
+      sourceSpanIds: sourceSpanIds2
+    }];
   }) : [];
   const parties = [
-    ...base.parties,
     ...candidateParties,
+    ...base.parties,
     sourceBackedParty("named_insured", namedInsured),
     sourceBackedParty("insurer", insurer),
     sourceBackedParty("broker", broker)
@@ -4109,6 +4191,7 @@ function mergeOperationalProfile(base, candidate, validNodeIds, validSpanIds) {
     expirationDate,
     retroactiveDate,
     premium,
+    operationsDescription,
     declarationFacts,
     coverages: annotatedCoverages,
     parties,
@@ -4553,96 +4636,812 @@ function applyCoverageCleanupDecision(coverage, decision, validNodeIds, validSpa
       if (value) next.premium = value;
       else delete next.premium;
     }
-    if (decision.retroactiveDate == null && termDecisionsTouch(coverage, termDecisions, isRetroactiveDateTerm)) {
-      const value = retroactiveDateFromTerms(next.limits);
-      if (value) next.retroactiveDate = value;
-      else delete next.retroactiveDate;
+    if (decision.retroactiveDate == null && termDecisionsTouch(coverage, termDecisions, isRetroactiveDateTerm)) {
+      const value = retroactiveDateFromTerms(next.limits);
+      if (value) next.retroactiveDate = value;
+      else delete next.retroactiveDate;
+    }
+  }
+  const termLimit = primaryLimitFromTerms(next.limits);
+  if (termLimit && shouldUseTermLimitDisplay(next.limit, termLimit)) {
+    next.limit = termLimit;
+  }
+  next.sourceNodeIds = uniqueStrings([
+    ...next.sourceNodeIds,
+    ...next.limits.flatMap((term) => term.sourceNodeIds)
+  ]);
+  next.sourceSpanIds = uniqueStrings([
+    ...next.sourceSpanIds,
+    ...next.limits.flatMap((term) => term.sourceSpanIds)
+  ]);
+  return next.name ? next : coverage;
+}
+function sourceIdsFromOperationalProfile(profile) {
+  const backedValues = [
+    profile.policyNumber,
+    profile.namedInsured,
+    profile.insurer,
+    profile.broker,
+    profile.effectiveDate,
+    profile.expirationDate,
+    profile.retroactiveDate,
+    profile.premium,
+    profile.totalCost,
+    profile.operationsDescription
+  ].filter(Boolean);
+  return {
+    sourceNodeIds: uniqueStrings([
+      ...backedValues.flatMap((value) => value?.sourceNodeIds ?? []),
+      ...profile.coverages.flatMap((coverage) => coverage.sourceNodeIds),
+      ...profile.coverages.flatMap((coverage) => coverage.limits.flatMap((term) => term.sourceNodeIds)),
+      ...(profile.premiumBreakdown ?? []).flatMap((row) => row.sourceNodeIds),
+      ...(profile.taxesAndFees ?? []).flatMap((row) => row.sourceNodeIds),
+      ...profile.parties.flatMap((party) => party.sourceNodeIds),
+      ...profile.endorsementSupport.flatMap((support) => support.sourceNodeIds)
+    ]),
+    sourceSpanIds: uniqueStrings([
+      ...backedValues.flatMap((value) => value?.sourceSpanIds ?? []),
+      ...profile.coverages.flatMap((coverage) => coverage.sourceSpanIds),
+      ...profile.coverages.flatMap((coverage) => coverage.limits.flatMap((term) => term.sourceSpanIds)),
+      ...(profile.coverageSchedules ?? []).flatMap((schedule) => [
+        ...schedule.sourceSpanIds,
+        ...schedule.items.flatMap((item) => item.sourceSpanIds)
+      ]),
+      ...(profile.premiumBreakdown ?? []).flatMap((row) => row.sourceSpanIds),
+      ...(profile.taxesAndFees ?? []).flatMap((row) => row.sourceSpanIds),
+      ...profile.parties.flatMap((party) => party.sourceSpanIds),
+      ...profile.endorsementSupport.flatMap((support) => support.sourceSpanIds)
+    ])
+  };
+}
+function applyOperationalProfileCleanup(profile, cleanup, validNodeIds, validSpanIds) {
+  const coverageDecisionByIndex = /* @__PURE__ */ new Map();
+  for (const decision of cleanup.coverageDecisions) {
+    if (decision.coverageIndex < profile.coverages.length) coverageDecisionByIndex.set(decision.coverageIndex, decision);
+  }
+  const coverages = profile.coverages.map(
+    (coverage, index) => applyCoverageCleanupDecision(coverage, coverageDecisionByIndex.get(index), validNodeIds, validSpanIds)
+  ).filter((coverage) => Boolean(coverage));
+  const cleanupWarnings = cleanup.warnings.map((warning) => cleanProfileValue(warning)).filter((warning) => Boolean(warning));
+  const nextProfile = {
+    ...profile,
+    coverages,
+    warnings: uniqueStrings([
+      ...profile.warnings,
+      ...cleanupWarnings.map((warning) => `Operational profile cleanup warning: ${warning}`)
+    ])
+  };
+  return PolicyOperationalProfileSchema.parse({
+    ...nextProfile,
+    ...sourceIdsFromOperationalProfile(nextProfile)
+  });
+}
+
+// src/extraction/coverage-recovery.ts
+import { z as z23 } from "zod";
+var COVERAGE_RECOVERY_VERSION = "coverage-recovery-v2";
+var DISCOVERY_PAGE_BATCH_SIZE = 32;
+var REGION_PAGE_BATCH_SIZE = 4;
+var RECOVERY_EVIDENCE_CHAR_LIMIT = 42e3;
+var RecoveryRegionSchema = z23.object({
+  pageStart: z23.number().int().positive(),
+  pageEnd: z23.number().int().positive(),
+  reason: z23.string(),
+  priorContext: z23.string().optional(),
+  sourceNodeIds: z23.array(z23.string()).default([]),
+  sourceSpanIds: z23.array(z23.string()).default([])
+});
+var RecoveryRegionDiscoverySchema = z23.object({
+  regions: z23.array(RecoveryRegionSchema).default([]),
+  warnings: z23.array(z23.string()).default([])
+});
+var CoverageRecoveryCandidateSchema = z23.object({
+  coverages: z23.array(OperationalCoverageLineSchema).default([]),
+  coverageSchedules: z23.array(OperationalCoverageScheduleSchema).default([]),
+  premiumBreakdown: z23.array(OperationalPremiumLineSchema).default([]),
+  taxesAndFees: z23.array(OperationalTaxFeeItemSchema).default([]),
+  totalCost: SourceBackedValueSchema.optional(),
+  warnings: z23.array(z23.string()).default([])
+});
+function cleanText(value) {
+  if (typeof value !== "string") return void 0;
+  const text = value.replace(/\s+/g, " ").trim();
+  return text || void 0;
+}
+function uniqueStrings2(values) {
+  return [...new Set(values.filter((value) => Boolean(value)))];
+}
+function spanPageStart(span) {
+  return span.pageStart ?? span.location?.startPage ?? span.location?.page;
+}
+function spanPageEnd(span) {
+  return span.pageEnd ?? span.location?.endPage ?? span.location?.page ?? spanPageStart(span);
+}
+function spanSourceUnit(span) {
+  return span.sourceUnit ?? span.metadata?.sourceUnit;
+}
+function overlapsPageRange(value, pageStart2, pageEnd2) {
+  const start = value.pageStart ?? value.pageEnd;
+  const end = value.pageEnd ?? value.pageStart;
+  return typeof start === "number" && typeof end === "number" && start <= pageEnd2 && end >= pageStart2;
+}
+function chunkValues(values, size) {
+  const chunks = [];
+  for (let index = 0; index < values.length; index += size) {
+    chunks.push(values.slice(index, index + size));
+  }
+  return chunks;
+}
+function evenlySample(values, limit) {
+  if (values.length <= limit) return values;
+  if (limit <= 1) return [values[0]];
+  return Array.from(
+    { length: limit },
+    (_, index) => values[Math.round(index * (values.length - 1) / (limit - 1))]
+  );
+}
+function sourceNodeIdsBySpanId(sourceTree) {
+  const result = /* @__PURE__ */ new Map();
+  for (const node of sourceTree) {
+    for (const sourceSpanId of node.sourceSpanIds) {
+      const ids = result.get(sourceSpanId) ?? [];
+      ids.push(node.id);
+      result.set(sourceSpanId, ids);
+    }
+  }
+  return result;
+}
+function documentPages(sourceTree, sourceSpans) {
+  const pages = /* @__PURE__ */ new Set();
+  for (const span of sourceSpans) {
+    const start = spanPageStart(span);
+    const end = spanPageEnd(span) ?? start;
+    if (!start || !end) continue;
+    for (let page = start; page <= end; page += 1) pages.add(page);
+  }
+  for (const node of sourceTree) {
+    if (node.pageStart) pages.add(node.pageStart);
+    if (node.pageEnd) pages.add(node.pageEnd);
+  }
+  return [...pages].sort((left, right) => left - right);
+}
+function pageSketch(page, sourceTree, sourceSpans) {
+  const pageNodes = sourceTree.filter((node) => node.kind !== "document" && overlapsPageRange(node, page, page)).sort((left, right) => left.order - right.order || left.id.localeCompare(right.id));
+  const pageSpans = sourceSpans.filter((span) => overlapsPageRange({ pageStart: spanPageStart(span), pageEnd: spanPageEnd(span) }, page, page)).sort(
+    (left, right) => (left.location?.charStart ?? Number.MAX_SAFE_INTEGER) - (right.location?.charStart ?? Number.MAX_SAFE_INTEGER) || left.id.localeCompare(right.id)
+  );
+  const tableIds = uniqueStrings2(pageSpans.map((span) => span.table?.tableId ?? span.metadata?.tableId));
+  const units = pageSpans.reduce((counts, span) => {
+    const unit = spanSourceUnit(span) ?? "unknown";
+    counts[unit] = (counts[unit] ?? 0) + 1;
+    return counts;
+  }, {});
+  const textSamples = evenlySample(
+    pageSpans.filter((span) => cleanText(span.text)).map((span) => ({
+      sourceSpanId: span.id,
+      sourceUnit: spanSourceUnit(span),
+      tableId: span.table?.tableId ?? span.metadata?.tableId,
+      rowIndex: span.table?.rowIndex,
+      columnIndex: span.table?.columnIndex,
+      columnName: span.table?.columnName,
+      bbox: span.bbox?.[0],
+      text: cleanText(span.text)?.slice(0, 280)
+    })),
+    18
+  );
+  return {
+    page,
+    forms: uniqueStrings2(pageSpans.map((span) => span.formNumber)),
+    structure: evenlySample(pageNodes.map((node) => ({
+      id: node.id,
+      kind: node.kind,
+      title: node.title,
+      path: node.path,
+      sourceSpanIds: node.sourceSpanIds.slice(0, 6)
+    })), 20),
+    layout: {
+      units,
+      tableCount: tableIds.length,
+      rowCount: pageSpans.filter((span) => spanSourceUnit(span) === "table_row").length,
+      cellCount: pageSpans.filter((span) => spanSourceUnit(span) === "table_cell").length
+    },
+    textSamples
+  };
+}
+function discoveryPrompt(sketches) {
+  return `Discover every document region that may contain policy-specific coverage facts, asset schedules, or financial facts.
+
+This is semantic region discovery, not keyword or heading matching. Inspect the layout and source-tree sketch for every supplied page, including unusual terminology and late-document schedules.
+
+Select regions containing or continuing any of:
+- coverage, benefit, insuring-agreement, limit, sublimit, deductible, retention, or per-asset terms
+- covered-auto, vehicle, property, location, building, equipment, or similar asset schedules
+- premium breakdowns, taxes, fees, surcharges, assessments, or total payable
+- declarations, forms, endorsements, options, exclusions, or cross-references that establish the status or scope of those facts
+
+Continuation rules:
+- A repeated heading is not required. Carry prior section and table-header context onto continuation pages.
+- Continue through compatible row numbering, column geometry, form identity, and table shape.
+- Stop at a new form, incompatible table structure, terminal language, or unrelated section.
+- Include declined, excluded, and unselected-option regions so the extraction pass can keep them out of active coverage rows.
+
+Use only page numbers and source IDs from the sketches. Return no region for pages that contain no relevant policy-specific evidence.
+
+Page sketches:
+${JSON.stringify(sketches, null, 2)}`;
+}
+function normalizeRegions(regions, pages) {
+  if (pages.length === 0) return [];
+  const minPage = pages[0];
+  const maxPage = pages[pages.length - 1];
+  const normalized = regions.flatMap((region) => {
+    const start = Math.max(minPage, Math.min(maxPage, region.pageStart));
+    const end = Math.max(start, Math.min(maxPage, region.pageEnd));
+    if (!pages.some((page) => page >= start && page <= end)) return [];
+    return [{ ...region, pageStart: start, pageEnd: end }];
+  });
+  normalized.sort((left, right) => left.pageStart - right.pageStart || left.pageEnd - right.pageEnd);
+  return normalized.reduce((rows, region) => {
+    const previous = rows[rows.length - 1];
+    if (!previous || region.pageStart > previous.pageEnd + 1) {
+      rows.push(region);
+      return rows;
+    }
+    previous.pageEnd = Math.max(previous.pageEnd, region.pageEnd);
+    previous.reason = uniqueStrings2([previous.reason, region.reason]).join("; ");
+    previous.priorContext = uniqueStrings2([previous.priorContext, region.priorContext]).join("; ") || void 0;
+    previous.sourceNodeIds = uniqueStrings2([...previous.sourceNodeIds, ...region.sourceNodeIds]);
+    previous.sourceSpanIds = uniqueStrings2([...previous.sourceSpanIds, ...region.sourceSpanIds]);
+    return rows;
+  }, []);
+}
+function splitRegions(regions) {
+  return regions.flatMap((region) => {
+    const result = [];
+    for (let page = region.pageStart; page <= region.pageEnd; page += REGION_PAGE_BATCH_SIZE) {
+      result.push({
+        ...region,
+        pageStart: page,
+        pageEnd: Math.min(region.pageEnd, page + REGION_PAGE_BATCH_SIZE - 1)
+      });
+    }
+    return result;
+  });
+}
+function priorStructuralContext(region, sourceTree, sourceSpans) {
+  const precedingNodes = sourceTree.filter((node) => node.kind !== "document" && (node.pageStart ?? 0) <= region.pageStart).filter((node) => ["page_group", "form", "endorsement", "section", "schedule", "table"].includes(node.kind)).sort(
+    (left, right) => (right.pageStart ?? 0) - (left.pageStart ?? 0) || right.order - left.order
+  ).slice(0, 12).map((node) => ({
+    id: node.id,
+    kind: node.kind,
+    title: node.title,
+    path: node.path,
+    pageStart: node.pageStart,
+    pageEnd: node.pageEnd,
+    sourceSpanIds: node.sourceSpanIds.slice(0, 8)
+  }));
+  const headerSpans = sourceSpans.filter((span) => {
+    const page = spanPageStart(span);
+    return typeof page === "number" && page >= Math.max(1, region.pageStart - 2) && page <= region.pageStart && (span.table?.isHeader || span.table?.columnName || span.metadata?.isHeader === "true");
+  }).map((span) => ({
+    sourceSpanId: span.id,
+    pageStart: spanPageStart(span),
+    table: span.table,
+    text: cleanText(span.text)?.slice(0, 600)
+  }));
+  return { priorContext: region.priorContext, precedingNodes, tableHeaders: headerSpans };
+}
+function regionEvidence(region, sourceTree, sourceSpans) {
+  const nodeIdsBySpanId = sourceNodeIdsBySpanId(sourceTree);
+  const spans = sourceSpans.filter((span) => overlapsPageRange(
+    { pageStart: spanPageStart(span), pageEnd: spanPageEnd(span) },
+    region.pageStart,
+    region.pageEnd
+  )).sort(
+    (left, right) => (spanPageStart(left) ?? Number.MAX_SAFE_INTEGER) - (spanPageStart(right) ?? Number.MAX_SAFE_INTEGER) || (left.location?.charStart ?? Number.MAX_SAFE_INTEGER) - (right.location?.charStart ?? Number.MAX_SAFE_INTEGER) || left.id.localeCompare(right.id)
+  );
+  return spans.flatMap((span) => {
+    const text = cleanText(span.text);
+    if (!text) return [];
+    const parts = text.match(/[\s\S]{1,1400}/g) ?? [text];
+    return parts.map((part) => ({
+      sourceSpanId: span.id,
+      sourceNodeIds: (nodeIdsBySpanId.get(span.id) ?? []).slice(0, 6),
+      pageStart: spanPageStart(span),
+      pageEnd: spanPageEnd(span),
+      sourceUnit: spanSourceUnit(span),
+      formNumber: span.formNumber,
+      table: span.table,
+      text: part
+    }));
+  });
+}
+function evidenceBatches(entries) {
+  const batches = [];
+  let current = [];
+  let chars = 0;
+  for (const entry of entries) {
+    const size = entry.text.length + 260;
+    if (current.length > 0 && chars + size > RECOVERY_EVIDENCE_CHAR_LIMIT) {
+      batches.push(current);
+      current = [];
+      chars = 0;
+    }
+    current.push(entry);
+    chars += size;
+  }
+  if (current.length > 0) batches.push(current);
+  return batches;
+}
+function recoveryPrompt(params) {
+  return `Recover missing source-backed policy coverage, schedule, and financial facts from one semantically selected document region.
+
+Region: pages ${params.region.pageStart}-${params.region.pageEnd}
+Reason: ${params.region.reason}
+Evidence batch: ${params.batchIndex}/${params.batchCount}
+
+Rules:
+- Preserve the source's coverage terminology as coverages[].name. ACORD lineOfBusiness and coverageCode may supplement it but may not replace it with unsupported wording.
+- A repeated heading is not required. Use the prior section and table-header context to interpret compatible continuation rows.
+- Keep declaration/core-form and endorsement facts separate when their source scopes differ, even if names match.
+- Put per occurrence, per claim, aggregate, per vehicle, per location, retention, deductible, sublimit, and similar values in coverages[].limits with the source label preserved.
+- Do not emit premium, taxes, fees, surcharges, assessments, rating bases, insured values, or exposures as coverage rows or coverage terms.
+- Do not emit declined, excluded, not-covered, or optional-unselected entries as active coverages.
+- Store covered-auto, vehicle, property, location, building, and equipment listings in coverageSchedules. Partial or redacted items are allowed there.
+- Put premium rows in premiumBreakdown, taxes/fees/surcharges/assessments in taxesAndFees, and total payable in totalCost.
+- Every returned fact must cite existing sourceSpanIds or sourceNodeIds from the supplied evidence. Prefer exact row/cell sourceSpanIds.
+- Numeric, monetary, percentage, date, VIN, form, and policy identifiers must be copied exactly enough to appear in their cited evidence after punctuation and spacing normalization.
+- Omit ambiguous or unsupported facts. Do not replace or rewrite source values.
+
+Prior structural context:
+${JSON.stringify(params.context, null, 2)}
+
+Source evidence:
+${JSON.stringify(params.evidence, null, 2)}`;
+}
+function normalizedText(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]+/g, "");
+}
+function mechanicallyCheckableTokens(value) {
+  const numeric = [...value.matchAll(/\d[\d,./:%-]*/g)].map((match) => match[0].replace(/^0+(?=\d)/, "").replace(/[^0-9a-z]/gi, "")).filter((token) => token.length >= 2);
+  const identifiers = [...value.matchAll(/\b(?=[A-Z0-9-]*\d)[A-Z0-9-]{5,}\b/gi)].map((match) => normalizedText(match[0]));
+  return uniqueStrings2([...numeric, ...identifiers]);
+}
+function valueGroundedInText(value, evidenceText) {
+  if (!value) return true;
+  const tokens = mechanicallyCheckableTokens(value);
+  if (tokens.length === 0) return true;
+  const normalizedEvidence = normalizedText(evidenceText);
+  return tokens.every((token) => normalizedEvidence.includes(normalizedText(token)));
+}
+function citedText(ids, spansById) {
+  return ids.map((id) => spansById.get(id)?.text ?? "").join(" ");
+}
+function validIds2(ids, valid) {
+  return uniqueStrings2(ids.filter((id) => valid.has(id)));
+}
+function validateCandidate(candidate, sourceTree, sourceSpans) {
+  const validNodeIds = new Set(sourceTree.map((node) => node.id));
+  const validSpanIds = new Set(sourceSpans.map((span) => span.id));
+  const spansById = new Map(sourceSpans.map((span) => [span.id, span]));
+  let citationRejectionCount = 0;
+  const validateCitation = (sourceNodeIds, sourceSpanIds, values) => {
+    const nodes = validIds2(sourceNodeIds, validNodeIds);
+    const spans = validIds2(sourceSpanIds, validSpanIds);
+    if (nodes.length === 0 && spans.length === 0) {
+      citationRejectionCount += 1;
+      return void 0;
+    }
+    const evidenceText = citedText(spans, spansById);
+    if (values.some((value) => !valueGroundedInText(value, evidenceText))) {
+      citationRejectionCount += 1;
+      return void 0;
+    }
+    return { sourceNodeIds: nodes, sourceSpanIds: spans };
+  };
+  const coverages = candidate.coverages.flatMap((coverage) => {
+    const coverageCitation = validateCitation(
+      coverage.sourceNodeIds,
+      coverage.sourceSpanIds,
+      [coverage.name, coverage.limit, coverage.deductible, coverage.premium, coverage.retroactiveDate, coverage.formNumber, coverage.endorsementNumber]
+    );
+    if (!coverageCitation) return [];
+    if (/\b(?:declined|excluded|not covered|not selected|optional\s*[-:]?\s*no)\b/i.test(coverage.name)) return [];
+    if (/\b(?:premium|tax|fee|surcharge|assessment|rating basis|exposure|insured value)\b/i.test(coverage.name) && coverage.limits.length === 0 && !coverage.limit && !coverage.deductible) return [];
+    const limits = coverage.limits.flatMap((term) => {
+      if (term.kind === "premium") return [];
+      const citation = validateCitation(
+        term.sourceNodeIds,
+        term.sourceSpanIds,
+        [term.label, term.value, term.appliesTo]
+      );
+      return citation ? [{ ...term, ...citation }] : [];
+    });
+    const hasCoverageFact = limits.length > 0 || coverage.limit || coverage.deductible || coverage.retroactiveDate || coverage.formNumber || coverage.endorsementNumber;
+    return hasCoverageFact ? [{ ...coverage, ...coverageCitation, limits }] : [];
+  });
+  const coverageSchedules = candidate.coverageSchedules.flatMap((schedule) => {
+    const sourceSpanIds = validIds2(schedule.sourceSpanIds, validSpanIds);
+    if (sourceSpanIds.length === 0 || !valueGroundedInText(schedule.name, citedText(sourceSpanIds, spansById))) {
+      citationRejectionCount += 1;
+      return [];
+    }
+    const items = schedule.items.flatMap((item) => {
+      const itemSpanIds = validIds2(item.sourceSpanIds, validSpanIds);
+      if (itemSpanIds.length === 0) {
+        citationRejectionCount += 1;
+        return [];
+      }
+      const evidenceText = citedText(itemSpanIds, spansById);
+      const values = item.values.filter((value) => {
+        const valid = valueGroundedInText(value.value, evidenceText);
+        if (!valid) citationRejectionCount += 1;
+        return valid;
+      });
+      return values.length > 0 && valueGroundedInText(item.label, evidenceText) ? [{ ...item, values, sourceSpanIds: itemSpanIds }] : [];
+    });
+    return items.length > 0 ? [{ ...schedule, items, sourceSpanIds }] : [];
+  });
+  const premiumBreakdown = candidate.premiumBreakdown.flatMap((row) => {
+    const citation = validateCitation(row.sourceNodeIds, row.sourceSpanIds, [row.line, row.amount]);
+    return citation ? [{ ...row, ...citation }] : [];
+  });
+  const taxesAndFees = candidate.taxesAndFees.flatMap((row) => {
+    const citation = validateCitation(row.sourceNodeIds, row.sourceSpanIds, [row.name, row.amount]);
+    return citation ? [{ ...row, ...citation }] : [];
+  });
+  const totalCostCitation = candidate.totalCost ? validateCitation(candidate.totalCost.sourceNodeIds, candidate.totalCost.sourceSpanIds, [candidate.totalCost.value]) : void 0;
+  return {
+    candidate: {
+      ...candidate,
+      coverages,
+      coverageSchedules,
+      premiumBreakdown,
+      taxesAndFees,
+      totalCost: candidate.totalCost && totalCostCitation ? { ...candidate.totalCost, ...totalCostCitation } : void 0
+    },
+    citationRejectionCount
+  };
+}
+function normalizedLabel(value) {
+  return value.toLowerCase().replace(/&/g, " and ").replace(/[^a-z0-9]+/g, " ").trim();
+}
+function sourcePages(ids, spansById) {
+  const pages = ids.flatMap((id) => {
+    const span = spansById.get(id);
+    const start = span ? spanPageStart(span) : void 0;
+    const end = span ? spanPageEnd(span) : void 0;
+    return [start, end].filter((page) => typeof page === "number");
+  });
+  return pages.length > 0 ? [Math.min(...pages), Math.max(...pages)] : void 0;
+}
+function sameCoverageScope(primary, recovery, spansById) {
+  if (normalizedLabel(primary.name) !== normalizedLabel(recovery.name)) return false;
+  if (primary.lineOfBusiness && recovery.lineOfBusiness && primary.lineOfBusiness !== recovery.lineOfBusiness) return false;
+  for (const key of ["formNumber", "sectionRef", "endorsementNumber"]) {
+    const left = cleanText(primary[key]);
+    const right = cleanText(recovery[key]);
+    if (left && right && normalizedLabel(left) !== normalizedLabel(right)) return false;
+    if (key === "endorsementNumber" && Boolean(left) !== Boolean(right)) return false;
+  }
+  const primaryPages = sourcePages(primary.sourceSpanIds, spansById);
+  const recoveryPages = sourcePages(recovery.sourceSpanIds, spansById);
+  if (!primaryPages || !recoveryPages) return true;
+  return primaryPages[0] <= recoveryPages[1] + 1 && recoveryPages[0] <= primaryPages[1] + 1;
+}
+function termIdentity(term) {
+  return [term.kind, normalizedLabel(term.label), normalizedLabel(term.value), normalizedLabel(term.appliesTo ?? "")].join("|");
+}
+function mergeCoverage(primary, recovery, warnings) {
+  const limits = [...primary.limits];
+  const identities = new Set(limits.map(termIdentity));
+  for (const term of recovery.limits) {
+    const identity = termIdentity(term);
+    if (identities.has(identity)) continue;
+    const conflict = limits.find(
+      (current) => current.kind === term.kind && normalizedLabel(current.label) === normalizedLabel(term.label) && normalizedLabel(current.appliesTo ?? "") === normalizedLabel(term.appliesTo ?? "") && normalizedLabel(current.value) !== normalizedLabel(term.value)
+    );
+    if (conflict) {
+      warnings.push(`Coverage recovery preserved conflicting cited ${term.label} terms for ${primary.name}.`);
     }
+    limits.push(term);
+    identities.add(identity);
   }
-  const termLimit = primaryLimitFromTerms(next.limits);
-  if (termLimit && shouldUseTermLimitDisplay(next.limit, termLimit)) {
-    next.limit = termLimit;
+  return {
+    ...recovery,
+    ...primary,
+    limit: primary.limit ?? recovery.limit,
+    deductible: primary.deductible ?? recovery.deductible,
+    premium: primary.premium ?? recovery.premium,
+    retroactiveDate: primary.retroactiveDate ?? recovery.retroactiveDate,
+    formNumber: primary.formNumber ?? recovery.formNumber,
+    sectionRef: primary.sectionRef ?? recovery.sectionRef,
+    endorsementNumber: primary.endorsementNumber ?? recovery.endorsementNumber,
+    limits,
+    sourceNodeIds: uniqueStrings2([...primary.sourceNodeIds, ...recovery.sourceNodeIds]),
+    sourceSpanIds: uniqueStrings2([...primary.sourceSpanIds, ...recovery.sourceSpanIds])
+  };
+}
+function appendUnique(primary, additions, key) {
+  const result = [...primary];
+  const seen = new Set(primary.map(key));
+  for (const value of additions) {
+    const identity = key(value);
+    if (seen.has(identity)) continue;
+    seen.add(identity);
+    result.push(value);
   }
-  next.sourceNodeIds = uniqueStrings([
-    ...next.sourceNodeIds,
-    ...next.limits.flatMap((term) => term.sourceNodeIds)
+  return result;
+}
+function mergeRecoveryCandidate(profile, candidate, sourceSpans) {
+  const warnings = [...candidate.warnings];
+  const spansById = new Map(sourceSpans.map((span) => [span.id, span]));
+  const coverages = [...profile.coverages];
+  let recoveredCoverageCount = 0;
+  let recoveredTermCount = 0;
+  for (const recovery of candidate.coverages) {
+    const matchIndex = coverages.findIndex((primary) => sameCoverageScope(primary, recovery, spansById));
+    if (matchIndex < 0) {
+      coverages.push(recovery);
+      recoveredCoverageCount += 1;
+      recoveredTermCount += recovery.limits.length;
+      continue;
+    }
+    const before = coverages[matchIndex].limits.length;
+    coverages[matchIndex] = mergeCoverage(coverages[matchIndex], recovery, warnings);
+    recoveredTermCount += coverages[matchIndex].limits.length - before;
+  }
+  const coverageSchedules = appendUnique(
+    profile.coverageSchedules ?? [],
+    candidate.coverageSchedules,
+    (schedule) => `${schedule.kind}|${normalizedLabel(schedule.name)}|${schedule.pageStart ?? ""}|${schedule.pageEnd ?? ""}`
+  );
+  const premiumBreakdown = appendUnique(
+    profile.premiumBreakdown ?? [],
+    candidate.premiumBreakdown,
+    (row) => `${normalizedLabel(row.line)}|${normalizedLabel(row.amount)}|${row.sourceSpanIds.join(",")}`
+  );
+  const taxesAndFees = appendUnique(
+    profile.taxesAndFees ?? [],
+    candidate.taxesAndFees,
+    (row) => `${normalizedLabel(row.name)}|${normalizedLabel(row.amount)}|${row.sourceSpanIds.join(",")}`
+  );
+  const totalCost = profile.totalCost ?? candidate.totalCost;
+  const sourceNodeIds = uniqueStrings2([
+    ...profile.sourceNodeIds,
+    ...coverages.flatMap((coverage) => [
+      ...coverage.sourceNodeIds,
+      ...coverage.limits.flatMap((term) => term.sourceNodeIds)
+    ]),
+    ...premiumBreakdown.flatMap((row) => row.sourceNodeIds),
+    ...taxesAndFees.flatMap((row) => row.sourceNodeIds),
+    ...totalCost?.sourceNodeIds ?? []
   ]);
-  next.sourceSpanIds = uniqueStrings([
-    ...next.sourceSpanIds,
-    ...next.limits.flatMap((term) => term.sourceSpanIds)
+  const sourceSpanIds = uniqueStrings2([
+    ...profile.sourceSpanIds,
+    ...coverages.flatMap((coverage) => [
+      ...coverage.sourceSpanIds,
+      ...coverage.limits.flatMap((term) => term.sourceSpanIds)
+    ]),
+    ...coverageSchedules.flatMap((schedule) => [
+      ...schedule.sourceSpanIds,
+      ...schedule.items.flatMap((item) => item.sourceSpanIds)
+    ]),
+    ...premiumBreakdown.flatMap((row) => row.sourceSpanIds),
+    ...taxesAndFees.flatMap((row) => row.sourceSpanIds),
+    ...totalCost?.sourceSpanIds ?? []
   ]);
-  return next.name ? next : coverage;
+  return {
+    operationalProfile: {
+      ...profile,
+      coverages,
+      coverageSchedules,
+      premiumBreakdown,
+      taxesAndFees,
+      totalCost,
+      sourceNodeIds,
+      sourceSpanIds,
+      warnings: uniqueStrings2([...profile.warnings, ...warnings])
+    },
+    warnings,
+    recoveredCoverageCount,
+    recoveredTermCount,
+    recoveredScheduleCount: coverageSchedules.length - (profile.coverageSchedules?.length ?? 0),
+    recoveredFinancialFactCount: premiumBreakdown.length - (profile.premiumBreakdown?.length ?? 0) + taxesAndFees.length - (profile.taxesAndFees?.length ?? 0) + (!profile.totalCost && totalCost ? 1 : 0)
+  };
 }
-function sourceIdsFromOperationalProfile(profile) {
-  const backedValues = [
-    profile.policyNumber,
-    profile.namedInsured,
-    profile.insurer,
-    profile.broker,
-    profile.effectiveDate,
-    profile.expirationDate,
-    profile.retroactiveDate,
-    profile.premium
-  ].filter(Boolean);
+function emptyDiagnostics(status) {
   return {
-    sourceNodeIds: uniqueStrings([
-      ...backedValues.flatMap((value) => value?.sourceNodeIds ?? []),
-      ...profile.coverages.flatMap((coverage) => coverage.sourceNodeIds),
-      ...profile.coverages.flatMap((coverage) => coverage.limits.flatMap((term) => term.sourceNodeIds)),
-      ...profile.parties.flatMap((party) => party.sourceNodeIds),
-      ...profile.endorsementSupport.flatMap((support) => support.sourceNodeIds)
-    ]),
-    sourceSpanIds: uniqueStrings([
-      ...backedValues.flatMap((value) => value?.sourceSpanIds ?? []),
-      ...profile.coverages.flatMap((coverage) => coverage.sourceSpanIds),
-      ...profile.coverages.flatMap((coverage) => coverage.limits.flatMap((term) => term.sourceSpanIds)),
-      ...profile.parties.flatMap((party) => party.sourceSpanIds),
-      ...profile.endorsementSupport.flatMap((support) => support.sourceSpanIds)
-    ])
+    version: COVERAGE_RECOVERY_VERSION,
+    status,
+    regionCount: 0,
+    modelCallCount: 0,
+    recoveredCoverageCount: 0,
+    recoveredTermCount: 0,
+    recoveredScheduleCount: 0,
+    recoveredFinancialFactCount: 0,
+    citationRejectionCount: 0,
+    warnings: []
   };
 }
-function applyOperationalProfileCleanup(profile, cleanup, validNodeIds, validSpanIds) {
-  const coverageDecisionByIndex = /* @__PURE__ */ new Map();
-  for (const decision of cleanup.coverageDecisions) {
-    if (decision.coverageIndex < profile.coverages.length) coverageDecisionByIndex.set(decision.coverageIndex, decision);
+function disabledCoverageRecoveryDiagnostics() {
+  return emptyDiagnostics("disabled");
+}
+async function recoverOperationalProfileCoverage(params) {
+  const diagnostics = emptyDiagnostics("succeeded");
+  try {
+    const pages = documentPages(params.sourceTree, params.sourceSpans);
+    const discoveredRegions = [];
+    for (const [batchIndex, pageBatch] of chunkValues(pages, DISCOVERY_PAGE_BATCH_SIZE).entries()) {
+      const sketches = pageBatch.map((page) => pageSketch(page, params.sourceTree, params.sourceSpans));
+      const budget = params.resolveBudget("extraction_coverage_recovery", 8192);
+      const startedAt = Date.now();
+      diagnostics.modelCallCount += 1;
+      const response = await safeGenerateObject(
+        params.generateObject,
+        {
+          prompt: discoveryPrompt(sketches),
+          schema: RecoveryRegionDiscoverySchema,
+          maxTokens: budget.maxTokens,
+          taskKind: "extraction_coverage_recovery",
+          budgetDiagnostics: budget,
+          providerOptions: params.providerOptions,
+          trace: {
+            phase: "coverage_recovery_discovery",
+            label: "coverage_recovery_discovery",
+            startPage: pageBatch[0],
+            endPage: pageBatch[pageBatch.length - 1],
+            batchIndex: batchIndex + 1,
+            batchCount: Math.ceil(pages.length / DISCOVERY_PAGE_BATCH_SIZE),
+            sourceBacked: true
+          }
+        },
+        { maxRetries: 0, log: params.log, retry: false }
+      );
+      params.trackUsage(response.usage, {
+        taskKind: "extraction_coverage_recovery",
+        label: "coverage_recovery_discovery",
+        maxTokens: budget.maxTokens,
+        durationMs: Date.now() - startedAt
+      });
+      const discovery = response.object;
+      discoveredRegions.push(...discovery.regions);
+      diagnostics.warnings.push(...discovery.warnings);
+    }
+    const regions = splitRegions(normalizeRegions(discoveredRegions, pages));
+    diagnostics.regionCount = regions.length;
+    let operationalProfile = params.operationalProfile;
+    for (const [regionIndex, region] of regions.entries()) {
+      const evidence = regionEvidence(region, params.sourceTree, params.sourceSpans);
+      const batches = evidenceBatches(evidence);
+      const context = priorStructuralContext(region, params.sourceTree, params.sourceSpans);
+      for (const [batchIndex, batch] of batches.entries()) {
+        const budget = params.resolveBudget("extraction_coverage_recovery", 12288);
+        const startedAt = Date.now();
+        diagnostics.modelCallCount += 1;
+        const response = await safeGenerateObject(
+          params.generateObject,
+          {
+            prompt: recoveryPrompt({
+              region,
+              context,
+              evidence: batch,
+              batchIndex: batchIndex + 1,
+              batchCount: batches.length
+            }),
+            schema: CoverageRecoveryCandidateSchema,
+            maxTokens: budget.maxTokens,
+            taskKind: "extraction_coverage_recovery",
+            budgetDiagnostics: budget,
+            providerOptions: params.providerOptions,
+            trace: {
+              phase: "coverage_recovery",
+              label: "coverage_recovery",
+              startPage: region.pageStart,
+              endPage: region.pageEnd,
+              batchIndex: batchIndex + 1,
+              batchCount: batches.length,
+              sourceBacked: true
+            }
+          },
+          { maxRetries: 0, log: params.log, retry: false }
+        );
+        params.trackUsage(response.usage, {
+          taskKind: "extraction_coverage_recovery",
+          label: `coverage_recovery_${regionIndex + 1}`,
+          maxTokens: budget.maxTokens,
+          durationMs: Date.now() - startedAt
+        });
+        const validated = validateCandidate(
+          response.object,
+          params.sourceTree,
+          params.sourceSpans
+        );
+        diagnostics.citationRejectionCount += validated.citationRejectionCount;
+        const merged = mergeRecoveryCandidate(operationalProfile, validated.candidate, params.sourceSpans);
+        operationalProfile = merged.operationalProfile;
+        diagnostics.recoveredCoverageCount += merged.recoveredCoverageCount;
+        diagnostics.recoveredTermCount += merged.recoveredTermCount;
+        diagnostics.recoveredScheduleCount += merged.recoveredScheduleCount;
+        diagnostics.recoveredFinancialFactCount += merged.recoveredFinancialFactCount;
+        diagnostics.warnings.push(...merged.warnings);
+      }
+    }
+    diagnostics.warnings = uniqueStrings2(diagnostics.warnings);
+    return { operationalProfile, diagnostics };
+  } catch (error) {
+    diagnostics.status = "failed";
+    diagnostics.warnings = uniqueStrings2([
+      ...diagnostics.warnings,
+      `Coverage recovery failed: ${error instanceof Error ? error.message : String(error)}`
+    ]);
+    await params.log?.(diagnostics.warnings[diagnostics.warnings.length - 1]);
+    return { operationalProfile: params.operationalProfile, diagnostics };
   }
-  const coverages = profile.coverages.map(
-    (coverage, index) => applyCoverageCleanupDecision(coverage, coverageDecisionByIndex.get(index), validNodeIds, validSpanIds)
-  ).filter((coverage) => Boolean(coverage));
-  const cleanupWarnings = cleanup.warnings.map((warning) => cleanProfileValue(warning)).filter((warning) => Boolean(warning));
-  const nextProfile = {
-    ...profile,
-    coverages,
-    warnings: uniqueStrings([
-      ...profile.warnings,
-      ...cleanupWarnings.map((warning) => `Operational profile cleanup warning: ${warning}`)
-    ])
+}
+async function runCoverageRecovery(params) {
+  const tokenUsage = { inputTokens: 0, outputTokens: 0 };
+  const performanceReport = {
+    modelCalls: [],
+    totalModelCallDurationMs: 0
   };
-  return PolicyOperationalProfileSchema.parse({
-    ...nextProfile,
-    ...sourceIdsFromOperationalProfile(nextProfile)
+  const recovery = await recoverOperationalProfileCoverage({
+    sourceTree: params.sourceTree,
+    sourceSpans: params.sourceSpans,
+    operationalProfile: params.operationalProfile,
+    generateObject: params.generateObject,
+    providerOptions: params.providerOptions,
+    resolveBudget: (taskKind, hintTokens) => resolveModelBudget({
+      taskKind,
+      hintTokens,
+      modelCapabilities: params.modelCapabilities,
+      constraint: params.modelBudgetConstraint
+    }),
+    trackUsage: (usage, report) => {
+      if (usage) {
+        tokenUsage.inputTokens += usage.inputTokens;
+        tokenUsage.outputTokens += usage.outputTokens;
+        params.onTokenUsage?.(usage);
+      }
+      if (report) {
+        performanceReport.modelCalls.push({
+          ...report,
+          usage,
+          usageReported: Boolean(usage)
+        });
+        if (report.durationMs != null) {
+          performanceReport.totalModelCallDurationMs += report.durationMs;
+        }
+      }
+    },
+    log: params.log
   });
+  return {
+    ...recovery,
+    tokenUsage,
+    performanceReport
+  };
 }
 
 // src/extraction/source-tree-extractor.ts
-var SourceBackedValueForPromptSchema = z23.object({
-  value: z23.string(),
-  normalizedValue: z23.string().optional(),
-  confidence: z23.enum(["low", "medium", "high"]).optional(),
-  sourceNodeIds: z23.array(z23.string()),
-  sourceSpanIds: z23.array(z23.string())
-});
-var OperationalAddressForPromptSchema = z23.object({
-  street1: z23.string().optional(),
-  street2: z23.string().optional(),
-  city: z23.string().optional(),
-  state: z23.string().optional(),
-  zip: z23.string().optional(),
-  country: z23.string().optional(),
-  formatted: z23.string().optional()
-});
-var OperationalDeclarationFactForPromptSchema = z23.object({
-  field: z23.enum([
+var SourceBackedValueForPromptSchema = z24.object({
+  value: z24.string(),
+  normalizedValue: z24.string().optional(),
+  confidence: z24.enum(["low", "medium", "high"]).optional(),
+  sourceNodeIds: z24.array(z24.string()),
+  sourceSpanIds: z24.array(z24.string())
+});
+var OperationalAddressForPromptSchema = z24.object({
+  street1: z24.string().optional(),
+  street2: z24.string().optional(),
+  city: z24.string().optional(),
+  state: z24.string().optional(),
+  zip: z24.string().optional(),
+  country: z24.string().optional(),
+  formatted: z24.string().optional()
+});
+var OperationalDeclarationFactForPromptSchema = z24.object({
+  field: z24.enum([
     "namedInsured",
     "mailingAddress",
     "dba",
@@ -4657,18 +5456,33 @@ var OperationalDeclarationFactForPromptSchema = z23.object({
     "premium",
     "other"
   ]),
-  label: z23.string().optional(),
-  value: z23.string(),
-  normalizedValue: z23.string().optional(),
-  valueKind: z23.enum(["string", "number", "date", "money", "address", "list", "unknown"]).optional(),
+  label: z24.string().optional(),
+  value: z24.string(),
+  normalizedValue: z24.string().optional(),
+  valueKind: z24.enum(["string", "number", "date", "money", "address", "list", "unknown"]).optional(),
+  address: OperationalAddressForPromptSchema.optional(),
+  confidence: z24.enum(["low", "medium", "high"]).optional(),
+  sourceNodeIds: z24.array(z24.string()),
+  sourceSpanIds: z24.array(z24.string())
+});
+var OperationalPartyForPromptSchema = z24.object({
+  role: z24.enum([
+    "named_insured",
+    "producer",
+    "broker",
+    "insurer",
+    "carrier",
+    "mga",
+    "administrator"
+  ]),
+  name: z24.string(),
   address: OperationalAddressForPromptSchema.optional(),
-  confidence: z23.enum(["low", "medium", "high"]).optional(),
-  sourceNodeIds: z23.array(z23.string()),
-  sourceSpanIds: z23.array(z23.string())
+  sourceNodeIds: z24.array(z24.string()),
+  sourceSpanIds: z24.array(z24.string())
 });
-var OperationalProfilePromptSchema = z23.object({
-  documentType: z23.enum(["policy", "quote"]).optional(),
-  linesOfBusiness: z23.array(z23.string()).optional(),
+var OperationalProfilePromptSchema = z24.object({
+  documentType: z24.enum(["policy", "quote"]).optional(),
+  linesOfBusiness: z24.array(z24.string()).optional(),
   policyNumber: SourceBackedValueForPromptSchema.optional(),
   namedInsured: SourceBackedValueForPromptSchema.optional(),
   insurer: SourceBackedValueForPromptSchema.optional(),
@@ -4677,39 +5491,41 @@ var OperationalProfilePromptSchema = z23.object({
   expirationDate: SourceBackedValueForPromptSchema.optional(),
   retroactiveDate: SourceBackedValueForPromptSchema.optional(),
   premium: SourceBackedValueForPromptSchema.optional(),
-  declarationFacts: z23.array(OperationalDeclarationFactForPromptSchema).optional(),
-  coverages: z23.array(z23.object({
-    name: z23.string(),
-    lineOfBusiness: z23.string().optional(),
-    coverageCode: z23.string().optional(),
-    limit: z23.string().optional(),
-    deductible: z23.string().optional(),
-    premium: z23.string().optional(),
-    retroactiveDate: z23.string().optional(),
-    formNumber: z23.string().optional(),
-    sectionRef: z23.string().optional(),
-    endorsementNumber: z23.string().optional(),
-    limits: z23.array(z23.object({
+  operationsDescription: SourceBackedValueForPromptSchema.optional(),
+  declarationFacts: z24.array(OperationalDeclarationFactForPromptSchema).optional(),
+  parties: z24.array(OperationalPartyForPromptSchema).optional(),
+  coverages: z24.array(z24.object({
+    name: z24.string(),
+    lineOfBusiness: z24.string().optional(),
+    coverageCode: z24.string().optional(),
+    limit: z24.string().optional(),
+    deductible: z24.string().optional(),
+    premium: z24.string().optional(),
+    retroactiveDate: z24.string().optional(),
+    formNumber: z24.string().optional(),
+    sectionRef: z24.string().optional(),
+    endorsementNumber: z24.string().optional(),
+    limits: z24.array(z24.object({
       kind: OperationalCoverageTermKindSchema.optional(),
-      label: z23.string(),
-      value: z23.string(),
-      amount: z23.number().optional(),
-      appliesTo: z23.string().optional(),
-      sourceNodeIds: z23.array(z23.string()),
-      sourceSpanIds: z23.array(z23.string())
+      label: z24.string(),
+      value: z24.string(),
+      amount: z24.number().optional(),
+      appliesTo: z24.string().optional(),
+      sourceNodeIds: z24.array(z24.string()),
+      sourceSpanIds: z24.array(z24.string())
     })).optional(),
-    sourceNodeIds: z23.array(z23.string()),
-    sourceSpanIds: z23.array(z23.string())
+    sourceNodeIds: z24.array(z24.string()),
+    sourceSpanIds: z24.array(z24.string())
   })).optional(),
-  sourceNodeIds: z23.array(z23.string()).optional(),
-  sourceSpanIds: z23.array(z23.string()).optional()
+  sourceNodeIds: z24.array(z24.string()).optional(),
+  sourceSpanIds: z24.array(z24.string()).optional()
 });
-function cleanText(value, fallback) {
+function cleanText2(value, fallback) {
   const text = value?.replace(/\s+/g, " ").trim();
   return text || fallback;
 }
 function simplifyOrganizerTitle(value, fallback, kind) {
-  const title = cleanText(value, fallback);
+  const title = cleanText2(value, fallback);
   if (/^declarations\b/i.test(title)) return "Declarations";
   if (/^policy\s+form\b/i.test(title)) return "Policy Form";
   if (/^definitions\b/i.test(title)) return "Definitions";
@@ -4722,23 +5538,23 @@ function simplifyOrganizerTitle(value, fallback, kind) {
   return title;
 }
 function endorsementReference(value) {
-  const text = cleanText(value, "");
+  const text = cleanText2(value, "");
   const explicit = text.match(/\bendorsement\s+(?:no\.?|number|#)?\s*([A-Z0-9][A-Z0-9.-]*)\b/i)?.[1]?.toUpperCase();
   if (explicit) return explicit;
   return text.match(/\b(?:[A-Z]{2,}-)?END\s+0*([0-9]{1,4})\b/i)?.[1]?.toUpperCase();
 }
 function endorsementTitle(value) {
-  const text = cleanText(value, "");
+  const text = cleanText2(value, "");
   const explicit = text.match(/\bendorsement\s+(?:no\.?|number|#)\s*([A-Z0-9][A-Z0-9.-]*)\b/i)?.[1]?.toUpperCase();
   const number = explicit ?? text.match(/\b(?:[A-Z]{2,}-)?END\s+0*([0-9]{1,4})\b/i)?.[1]?.toUpperCase();
   return number ? `Endorsement No. ${number}` : void 0;
 }
 function sourceNodeText(node) {
-  return cleanText([node.title, node.description, node.textExcerpt].filter(Boolean).join(" "), "");
+  return cleanText2([node.title, node.description, node.textExcerpt].filter(Boolean).join(" "), "");
 }
 function looksLikeEndorsementStart(node) {
-  const title = cleanText(node.title, "");
-  const body = cleanText([node.textExcerpt, node.description].filter(Boolean).join(" "), "");
+  const title = cleanText2(node.title, "");
+  const body = cleanText2([node.textExcerpt, node.description].filter(Boolean).join(" "), "");
   const start = body.slice(0, 260);
   if (/\bthis endorsement changes the policy\b/i.test(start) && endorsementReference(start)) return true;
   if (/^(?:[A-Z]{2,}-)?END\s+0*[0-9]{1,4}\b/i.test(start)) return true;
@@ -4747,7 +5563,7 @@ function looksLikeEndorsementStart(node) {
 }
 function looksLikeEndorsementContinuation(node) {
   if (looksLikeEndorsementStart(node)) return false;
-  const title = cleanText(node.title, "");
+  const title = cleanText2(node.title, "");
   const text = sourceNodeText(node);
   return /\bendorsement\b/i.test(text) || /\bcontinuation\b/i.test(title) || /\ball\s+other\s+terms\s+and\s+conditions\b/i.test(text);
 }
@@ -4755,7 +5571,7 @@ function endorsementStartTitle(node) {
   return looksLikeEndorsementStart(node) ? endorsementTitle(sourceNodeText(node)) : void 0;
 }
 function endorsementDescription(title, node) {
-  return cleanText(
+  return cleanText2(
     [title, "endorsement", node.pageStart ? `page ${node.pageStart}` : void 0].filter(Boolean).join(" | "),
     title
   );
@@ -4763,7 +5579,7 @@ function endorsementDescription(title, node) {
 function endorsementTitleKey(node) {
   const title = endorsementTitle(sourceNodeText(node));
   if (title) return title.toLowerCase();
-  const fallback = cleanText(node.title, "");
+  const fallback = cleanText2(node.title, "");
   return fallback ? fallback.toLowerCase() : void 0;
 }
 function nodePageEnd2(node) {
@@ -4807,17 +5623,17 @@ function semanticGroupNodeId(documentId, kind, title, childNodeIds) {
     childNodeIds.join("_").replace(/[^a-zA-Z0-9_.:-]/g, "_").slice(0, 80)
   ].join(":");
 }
-function spanPageStart(span) {
+function spanPageStart2(span) {
   return span.pageStart ?? span.location?.page ?? span.location?.startPage;
 }
-function spanPageEnd(span) {
-  return span.pageEnd ?? span.location?.endPage ?? spanPageStart(span);
+function spanPageEnd2(span) {
+  return span.pageEnd ?? span.location?.endPage ?? spanPageStart2(span);
 }
-function spanSourceUnit(span) {
+function spanSourceUnit2(span) {
   return span.sourceUnit ?? span.metadata?.sourceUnit ?? span.metadata?.elementType;
 }
 function pageHeadingTitleFromText(text, fallback) {
-  const normalized = cleanText(text, "");
+  const normalized = cleanText2(text, "");
   const headingText = normalized.replace(/^page\s+\d+\s*(?:\|\s*page\s*\|\s*page\s+\d+\s*\|?)?/i, "").slice(0, 700);
   const patterns = [
     /\bIMPORTANT NOTICE\s+[—-]\s+HOW TO REPORT A CLAIM\b/i,
@@ -4831,7 +5647,7 @@ function pageHeadingTitleFromText(text, fallback) {
   ];
   for (const pattern of patterns) {
     const match = headingText.match(pattern)?.[0];
-    if (match) return cleanText(match, fallback);
+    if (match) return cleanText2(match, fallback);
   }
   return fallback;
 }
@@ -4839,12 +5655,12 @@ function hasSubstantiveDeclarationsScheduleText(text) {
   return /\bitem\s+\d+\.?\s*(?:named insured|policy number|policy period|renewal|form of business|coverage parts?|limits?|premium|extended reporting|producer|forms? and endorsements?)\b/i.test(text) || /\bforms? and endorsements attached at inception\b/i.test(text) || /\bcoverage parts?,?\s+limits? of liability,?\s+deductibles?,?\s+and retroactive dates\b/i.test(text) || /\bannual premium\s*\(all coverage parts?\)\b/i.test(text) || /\berp option\b/i.test(text) || /\bproducer\b[\s\S]{0,240}\blicense\b/i.test(text);
 }
 function looksLikeDeclarationsStart(node) {
-  const title = cleanText(node.title, "");
+  const title = cleanText2(node.title, "");
   const text = sourceNodeText(node);
   if (/\b(important notice|privacy notice|ofac advisory|terrorism risk insurance act|how to report a claim)\b/i.test(text)) {
     return false;
   }
-  return /^declarations?$/i.test(title) || /\bdeclarations?\s+(page|schedule|section)\b/i.test(text) || /^declarations?\b/i.test(cleanText(node.textExcerpt, ""));
+  return /^declarations?$/i.test(title) || /\bdeclarations?\s+(page|schedule|section)\b/i.test(text) || /^declarations?\b/i.test(cleanText2(node.textExcerpt, ""));
 }
 function looksLikeDeclarationsContinuation(node) {
   const text = sourceNodeText(node);
@@ -4852,7 +5668,7 @@ function looksLikeDeclarationsContinuation(node) {
 }
 function looksLikePolicyFormStart(node) {
   const text = sourceNodeText(node);
-  const excerpt = cleanText(node.textExcerpt, "");
+  const excerpt = cleanText2(node.textExcerpt, "");
   if (isAdministrativeNoticeNode(node) || looksLikeDeclarationsStart(node)) return false;
   return /\bpolicy form\b/i.test(node.title) || /^policy\s+form\b/i.test(excerpt) || /\btechnology errors?\s*&?\s*omissions\b/i.test(text) && /\bplease read this entire policy carefully\b/i.test(text) || /\bsection\s+[IVX0-9]+\s*[—-]\s*(insuring agreements?|definitions?|exclusions?|conditions?)\b/i.test(text) || /\bform\s+[A-Z]{2,}-[A-Z0-9-]+\s+\d{2}\s+\d{2}\b/i.test(text);
 }
@@ -4941,7 +5757,7 @@ function applySemanticPageGrouping(sourceTree) {
       return {
         ...nextNode,
         title: "Declarations",
-        description: cleanText([nextNode.description, "Declarations"].join(" "), "Declarations"),
+        description: cleanText2([nextNode.description, "Declarations"].join(" "), "Declarations"),
         metadata: { ...nextNode.metadata, organizerRepair: "semantic_page_grouping" }
       };
     }
@@ -4949,7 +5765,7 @@ function applySemanticPageGrouping(sourceTree) {
       return {
         ...nextNode,
         title: "Policy Form",
-        description: cleanText([nextNode.description, "Policy Form"].join(" "), "Policy Form"),
+        description: cleanText2([nextNode.description, "Policy Form"].join(" "), "Policy Form"),
         metadata: { ...nextNode.metadata, organizerRepair: "semantic_page_grouping" }
       };
     }
@@ -5217,7 +6033,7 @@ function isTitleBlockNode(node) {
   return metadataText(node, "organizer") === "title_block" || metadataText(node, "elementType") === "title" || metadataText(node, "sourceUnit") === "title";
 }
 function isRejectableSectionHeading(text, container) {
-  const normalized = cleanText(text, "");
+  const normalized = cleanText2(text, "");
   if (!normalized) return true;
   if (normalized.length > 160) return true;
   if (/^page\s+\d+$/i.test(normalized)) return true;
@@ -5233,7 +6049,7 @@ function isRejectableSectionHeading(text, container) {
 }
 function sectionHeadingTitle(node, container) {
   if (!isTitleBlockNode(node)) return void 0;
-  const text = cleanText(node.title || node.textExcerpt, "");
+  const text = cleanText2(node.title || node.textExcerpt, "");
   if (isRejectableSectionHeading(text, container)) return void 0;
   const words = text.split(/\s+/);
   if (words.length > 18) return void 0;
@@ -5307,7 +6123,7 @@ function applyTitleSectionHierarchy(sourceTree) {
           parentId: container.id,
           kind: sectionKindForTitle(heading),
           title: heading,
-          description: descriptionWithPages(cleanText([heading, "section"].join(" "), heading), [current, ...descendants]),
+          description: descriptionWithPages(cleanText2([heading, "section"].join(" "), heading), [current, ...descendants]),
           metadata: {
             ...current.metadata,
             organizer: "title_section",
@@ -5355,7 +6171,7 @@ function applyEndorsementGrouping(sourceTree) {
       return {
         ...node,
         kind: "page",
-        title: node.pageStart ? `Page ${node.pageStart}` : cleanText(node.title, "Page"),
+        title: node.pageStart ? `Page ${node.pageStart}` : cleanText2(node.title, "Page"),
         metadata: {
           ...node.metadata,
           organizerRepair: "demote_incidental_endorsement_reference"
@@ -5385,7 +6201,7 @@ function applyEndorsementGrouping(sourceTree) {
       ...node,
       kind: "page_group",
       title: "Endorsements",
-      description: descriptionWithPages(cleanText(node.description, "Endorsement forms grouped by source order"), byParent.get(node.id) ?? [node]),
+      description: descriptionWithPages(cleanText2(node.description, "Endorsement forms grouped by source order"), byParent.get(node.id) ?? [node]),
       metadata: {
         ...node.metadata,
         sourceTreeVersion: "v3",
@@ -5564,7 +6380,7 @@ function nodesByParent(sourceTree) {
   }
   return byParent;
 }
-function sourceNodeIdsBySpanId(sourceTree) {
+function sourceNodeIdsBySpanId2(sourceTree) {
   const bySpan = /* @__PURE__ */ new Map();
   for (const node of sourceTree) {
     for (const spanId of node.sourceSpanIds) {
@@ -5576,7 +6392,7 @@ function sourceNodeIdsBySpanId(sourceTree) {
   return bySpan;
 }
 function operationalEvidenceScore(span) {
-  const text = cleanText([
+  const text = cleanText2([
     span.text,
     span.formNumber,
     span.sourceUnit,
@@ -5589,6 +6405,9 @@ function operationalEvidenceScore(span) {
   if (span.metadata?.elementType === "title") score += 4;
   if (span.sourceUnit === "page") score -= 3;
   if (/\b(policy\s*(number|period|term)|effective date|expiration date|expiry date|named insured|insurer|carrier|security|broker|producer|premium|total due)\b/i.test(text)) score += 12;
+  if (/\b(mailing address|business address|address|managing general (?:agent|underwriter)|mga|administrator|description of operations|operations description|nature of business|business description)\b/i.test(text)) score += 12;
+  if (/\b\d{1,6}\s+[A-Z0-9][^\n,]{1,80}\b(?:street|st|avenue|ave|road|rd|boulevard|blvd|drive|dr|lane|ln|way|court|ct|highway|hwy)\b/i.test(text)) score += 10;
+  if (/\b[A-Za-z][A-Za-z .'-]+,\s*[A-Z]{2}\s+\d{5}(?:-\d{4})?\b/.test(text)) score += 10;
   if (/\b(coverage part|limit(?:s)? of liability|deductible|retention|retroactive date|aggregate|sublimit|sub-limit|each claim|each loss|each occurrence|coinsurance)\b/i.test(text)) score += 14;
   if (/\bendorsement\s+(?:no\.?|number|#)?\s*[A-Z0-9]|forms? and endorsements?|attached at inception|schedule\b/i.test(text)) score += 8;
   if (/\bitem\s+\d+\.?\s*(?:named insured|policy number|policy period|renewal|form of business|coverage parts?|premium|extended reporting|producer|forms? and endorsements?)\b/i.test(text)) score += 10;
@@ -5599,19 +6418,22 @@ function spanTableId(span) {
   return span.table?.tableId ?? span.metadata?.tableId;
 }
 function isTableCellSpan(span) {
-  return spanSourceUnit(span) === "table_cell";
+  return spanSourceUnit2(span) === "table_cell";
 }
 function isOperationalEvidenceAnchor(span) {
-  const sourceUnit3 = spanSourceUnit(span);
+  const sourceUnit3 = spanSourceUnit2(span);
   if (sourceUnit3 === "table_cell") return false;
   if (sourceUnit3 === "table" || sourceUnit3 === "table_row") return true;
-  const text = cleanText([span.text, span.formNumber].filter(Boolean).join(" "), "");
+  const text = cleanText2([span.text, span.formNumber].filter(Boolean).join(" "), "");
   if (!text) return false;
   if (sourceUnit3 === "page") {
-    return hasSubstantiveDeclarationsScheduleText(text) || /\b(declarations?|named insured|policy number|policy period|effective date|expiration date|premium|total due|producer)\b/i.test(text);
+    return hasSubstantiveDeclarationsScheduleText(text) || /\b(declarations?|named insured|policy number|policy period|effective date|expiration date|premium|total due|producer|mailing address|mga|administrator|description of operations|nature of business|business description)\b/i.test(text);
   }
   if (/\bitem\s+\d+\.?\s*(?:named insured|policy number|policy period|renewal|form of business|coverage parts?|premium|extended reporting|producer|forms? and endorsements?)\b/i.test(text)) return true;
   if (/\b(policy\s*(number|period)|effective date|expiration date|expiry date|named insured|insurer|carrier|broker|producer|premium|total due)\b/i.test(text)) return true;
+  if (/\b(mailing address|business address|address|managing general (?:agent|underwriter)|mga|administrator|description of operations|operations description|nature of business|business description)\b/i.test(text)) return true;
+  if (/\b\d{1,6}\s+[A-Z0-9][^\n,]{1,80}\b(?:street|st|avenue|ave|road|rd|boulevard|blvd|drive|dr|lane|ln|way|court|ct|highway|hwy)\b/i.test(text)) return true;
+  if (/\b[A-Za-z][A-Za-z .'-]+,\s*[A-Z]{2}\s+\d{5}(?:-\d{4})?\b/.test(text)) return true;
   if (/\b(coverage part|forms? and endorsements?|attached at inception|endorsement\s+(?:no\.?|number|#)?\s*[A-Z0-9])\b/i.test(text)) return true;
   if (/\$[\d,.]+|[0-9]{1,2}\/[0-9]{1,2}\/[0-9]{2,4}|[0-9]{1,2}\s+[A-Za-z]{3,9}\s+[0-9]{4}/.test(text)) return true;
   return false;
@@ -5619,9 +6441,9 @@ function isOperationalEvidenceAnchor(span) {
 function operationalEvidencePages(sourceSpans) {
   const scores = /* @__PURE__ */ new Map();
   for (const span of sourceSpans) {
-    const page = spanPageStart(span);
+    const page = spanPageStart2(span);
     if (typeof page !== "number") continue;
-    const text = cleanText([span.text, span.formNumber, spanSourceUnit(span)].filter(Boolean).join(" "), "");
+    const text = cleanText2([span.text, span.formNumber, spanSourceUnit2(span)].filter(Boolean).join(" "), "");
     if (!text) continue;
     let score = Math.max(0, operationalEvidenceScore(span));
     if (/\bdeclarations?\s+(page|schedule)?\b/i.test(text)) score += 24;
@@ -5629,6 +6451,7 @@ function operationalEvidencePages(sourceSpans) {
     if (/\bcoverage parts?,?\s+limits? of liability,?\s+deductibles?,?\s+and retroactive dates\b/i.test(text)) score += 24;
     if (/\b(policy\s*(number|period|term)|effective date|expiration date|expiry date|named insured|insurer|carrier|security)\b/i.test(text)) score += 12;
     if (/\b(premium|total due|tax|fee|producer|broker)\b/i.test(text)) score += 10;
+    if (/\b(mailing address|business address|managing general (?:agent|underwriter)|mga|administrator|description of operations|operations description|nature of business|business description)\b/i.test(text)) score += 16;
     if (/\b(endorsement\s+(?:no\.?|number|#)?\s*[A-Z0-9]|attached at inception|forms? and endorsements?)\b/i.test(text)) score += 8;
     if (/\b(definitions?|exclusions?|conditions?|duties in the event|action against|cancellation by)\b/i.test(text)) score -= 12;
     if (score > 0) scores.set(page, (scores.get(page) ?? 0) + score);
@@ -5639,7 +6462,7 @@ function operationalEvidencePages(sourceSpans) {
 }
 function operationalProfileEvidence(sourceTree, sourceSpans) {
   const sorted = [...sourceSpans].sort(
-    (left, right) => (spanPageStart(left) ?? Number.MAX_SAFE_INTEGER) - (spanPageStart(right) ?? Number.MAX_SAFE_INTEGER) || (left.location?.charStart ?? Number.MAX_SAFE_INTEGER) - (right.location?.charStart ?? Number.MAX_SAFE_INTEGER) || left.id.localeCompare(right.id)
+    (left, right) => (spanPageStart2(left) ?? Number.MAX_SAFE_INTEGER) - (spanPageStart2(right) ?? Number.MAX_SAFE_INTEGER) || (left.location?.charStart ?? Number.MAX_SAFE_INTEGER) - (right.location?.charStart ?? Number.MAX_SAFE_INTEGER) || left.id.localeCompare(right.id)
   );
   const selectedPages = operationalEvidencePages(sorted);
   const selected = /* @__PURE__ */ new Set();
@@ -5649,7 +6472,7 @@ function operationalProfileEvidence(sourceTree, sourceSpans) {
     const score = operationalEvidenceScore(span);
     if (score < 8) continue;
     if (!isOperationalEvidenceAnchor(span)) continue;
-    const page = spanPageStart(span);
+    const page = spanPageStart2(span);
     if (selectedPages.size > 0 && typeof page === "number" && !selectedPages.has(page) && score < 30) continue;
     const tableId2 = spanTableId(span);
     if (tableId2 && !isTableCellSpan(span)) selectedTableIds.add(tableId2);
@@ -5657,9 +6480,9 @@ function operationalProfileEvidence(sourceTree, sourceSpans) {
     for (let offset = -neighborWindow; offset <= neighborWindow; offset += 1) {
       const neighborIndex = index + offset;
       const neighbor = sorted[neighborIndex];
-      if (!neighbor || spanPageStart(neighbor) !== page) continue;
+      if (!neighbor || spanPageStart2(neighbor) !== page) continue;
       if (selectedPages.size > 0 && typeof page === "number" && !selectedPages.has(page) && operationalEvidenceScore(neighbor) < 30) continue;
-      const neighborText = cleanText(neighbor.text, "");
+      const neighborText = cleanText2(neighbor.text, "");
       if (!neighborText || neighborText.length > 3e3) continue;
       selected.add(neighborIndex);
     }
@@ -5668,31 +6491,31 @@ function operationalProfileEvidence(sourceTree, sourceSpans) {
     sorted.forEach((span, index) => {
       const tableId2 = spanTableId(span);
       if (!tableId2 || !selectedTableIds.has(tableId2) || isTableCellSpan(span)) return;
-      const text = cleanText(span.text, "");
+      const text = cleanText2(span.text, "");
       if (text && text.length <= 3e3) selected.add(index);
     });
   }
-  const nodeIdsBySpanId = sourceNodeIdsBySpanId(sourceTree);
+  const nodeIdsBySpanId = sourceNodeIdsBySpanId2(sourceTree);
   const seenText = /* @__PURE__ */ new Set();
   const entries = [...selected].sort((left, right) => left - right).map((index) => sorted[index]).filter((span) => !isTableCellSpan(span)).flatMap((span) => {
-    const text = cleanText(span.text, "");
+    const text = cleanText2(span.text, "");
     if (!text) return [];
-    const key = `${spanPageStart(span) ?? "na"}:${text.toLowerCase().slice(0, 240)}`;
+    const key = `${spanPageStart2(span) ?? "na"}:${text.toLowerCase().slice(0, 240)}`;
     if (seenText.has(key)) return [];
     seenText.add(key);
     return [{
       sourceSpanId: span.id,
       sourceNodeIds: [...new Set(nodeIdsBySpanId.get(span.id) ?? [])].slice(0, 4),
-      pageStart: spanPageStart(span),
-      pageEnd: spanPageEnd(span),
-      sourceUnit: spanSourceUnit(span),
+      pageStart: spanPageStart2(span),
+      pageEnd: spanPageEnd2(span),
+      sourceUnit: spanSourceUnit2(span),
       formNumber: span.formNumber,
       text: text.slice(0, span.sourceUnit === "page" ? 900 : 700)
     }];
   });
   const detailEntries = entries.filter((entry) => entry.sourceUnit !== "page");
   const pageEntries = entries.filter((entry) => entry.sourceUnit === "page");
-  return [...detailEntries.slice(0, 80), ...pageEntries.slice(0, 8)];
+  return [...detailEntries, ...pageEntries];
 }
 function sourceTreeRootId(sourceTree) {
   return sourceTree.find((node) => node.kind === "document")?.id;
@@ -5703,7 +6526,7 @@ function operationalProfilePromptNodes(sourceTree) {
       return true;
     }
     const text = [node.title, node.path, node.description, node.textExcerpt].filter(Boolean).join(" ");
-    return /\b(policy\s*(number|period)|named insured|insurer|carrier|broker|producer|premium|coverage|limit|liability|deductible|retention|retroactive|aggregate|sublimit|sub-limit|endorsement)\b/i.test(text);
+    return /\b(policy\s*(number|period)|named insured|insurer|carrier|broker|producer|managing general (?:agent|underwriter)|mga|administrator|mailing address|description of operations|operations description|nature of business|business description|premium|coverage|limit|liability|deductible|retention|retroactive|aggregate|sublimit|sub-limit|endorsement)\b/i.test(text);
   }).slice(0, 420);
 }
 function emptyOperationalProfile() {
@@ -5712,6 +6535,9 @@ function emptyOperationalProfile() {
     linesOfBusiness: ["UN"],
     declarationFacts: [],
     coverages: [],
+    coverageSchedules: [],
+    premiumBreakdown: [],
+    taxesAndFees: [],
     parties: [],
     endorsementSupport: [],
     sourceNodeIds: [],
@@ -5727,7 +6553,8 @@ function buildOperationalProfilePrompt(sourceTree, sourceSpans) {
   return `Extract a source-backed operational profile for an insurance policy.
 
 Return only high-value operational facts needed for policy lists, Q&A, compliance, and certificate generation:
-- policy number, named insured, insurer/carrier/security, broker/producer, policy period, retroactive date, premium
+- policy number, named insured, insurer/carrier/security, broker/producer, policy period, retroactive date, premium, and the insured's description of operations
+- parties[] rows for named insured, producer/broker, insurer/carrier, and MGA/administrator identities and their mailing addresses
 - source-backed declarationFacts for named-insured identity details: named insured, mailing address, DBA, entity type, tax ID/FEIN, additional named insureds, and other durable declaration-page identity facts
 - coverage units with their own nested limit terms, deductibles/retentions, retroactive dates, premiums, and form references
 - coverage type labels
@@ -5739,6 +6566,9 @@ Rules:
 - If a value is not directly supported, omit it.
 - Prefer declarations, schedules, premium tables, and endorsement schedules over generic policy wording.
 - Put named-insured mailing address in declarationFacts[] with field "mailingAddress", valueKind "address", a user-facing value string, and structured address fields when present. Do not put producer, broker, insurer, mortgagee, loss-payee, or certificate-holder addresses in mailingAddress.
+- Put every source-backed policy party in parties[] using only these canonical roles: "named_insured", "producer", "broker", "insurer", "carrier", "mga", or "administrator". Keep producer/broker, insurer/carrier, and MGA/administrator addresses policy-scoped in parties[]; never represent them as the named-insured mailingAddress declaration fact.
+- When a party's address is present, return its available street1, street2, city, state, zip, country, and formatted parts under parties[].address. Partial addresses are allowed in parties[], but never guess a missing component. The party row must cite the source node or source span that supports both the identity and address.
+- Put the insured's directly stated business or operations description in operationsDescription. Do not synthesize it from coverages, industry inference, website research, or generic policy wording.
 - Put DBA or trade name in declarationFacts[] with field "dba"; entity/legal form in field "entityType"; FEIN/tax ID in field "taxId"; each additional named insured in field "additionalNamedInsured".
 - For effective, expiration, retroactive, and other date fields, return a normalized YYYY-MM-DD value when the source date is unambiguous, including month-name dates such as "20 Feb 2026". Do not emit fragmented date text such as "20 2 2026".
 - For broker/producer, extract the agency or company legal name, not the license role, credential, or type. In a block like "Bayshore Insurance Brokers, LLC" followed by "Surplus Lines Broker - CA License No. ...", broker.value must be "Bayshore Insurance Brokers, LLC"; the surplus-lines role and license number are not the broker name.
@@ -5808,13 +6638,6 @@ function valueOf(profile, key) {
   }
   return String(value.value);
 }
-function provenanceOf(value) {
-  if (!value?.sourceSpanIds.length) return void 0;
-  return {
-    sourceSpanIds: value.sourceSpanIds,
-    ...value.sourceNodeIds[0] ? { documentNodeId: value.sourceNodeIds[0] } : {}
-  };
-}
 function provenanceFromIds(sourceSpanIds, sourceNodeIds) {
   if (sourceSpanIds.length === 0) return void 0;
   return {
@@ -5822,6 +6645,33 @@ function provenanceFromIds(sourceSpanIds, sourceNodeIds) {
     ...sourceNodeIds[0] ? { documentNodeId: sourceNodeIds[0] } : {}
   };
 }
+function combinedProvenance(...values) {
+  const sourceSpanIds = [...new Set(values.flatMap((value) => value?.sourceSpanIds ?? []))];
+  const sourceNodeIds = [...new Set(values.flatMap((value) => value?.sourceNodeIds ?? []))];
+  return provenanceFromIds(sourceSpanIds, sourceNodeIds);
+}
+function firstOperationalParty(profile, roles) {
+  const candidates = roles.flatMap(
+    (role) => profile.parties.filter((candidate) => candidate.role === role && candidate.name.trim())
+  );
+  return candidates.find((candidate) => candidate.address) ?? candidates[0];
+}
+function completeOperationalAddress(address) {
+  if (!address?.street1 || !address.city || !address.state || !address.zip) return void 0;
+  return {
+    street1: address.street1,
+    street2: address.street2,
+    city: address.city,
+    state: address.state,
+    zip: address.zip,
+    country: address.country
+  };
+}
+function sourceBackedAddressFromParty(party) {
+  const address = completeOperationalAddress(party?.address);
+  const provenance = party ? provenanceFromIds(party.sourceSpanIds, party.sourceNodeIds) : void 0;
+  return address && provenance ? { ...address, ...provenance } : void 0;
+}
 function declarationFactsByField(profile, field) {
   return profile.declarationFacts.filter((fact) => fact.field === field && fact.value.trim());
 }
@@ -5843,7 +6693,7 @@ function sourceBackedAddressFromFact(fact) {
   };
 }
 function normalizedEntityType(value) {
-  const normalized = cleanText(value, "").toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+  const normalized = cleanText2(value, "").toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
   if (normalized === "inc" || normalized === "incorporated" || normalized === "c_corporation" || normalized === "s_corporation") {
     return "corporation";
   }
@@ -5869,19 +6719,83 @@ function declarationFieldName(fact) {
   if (fact.field === "additionalNamedInsured") return "additionalNamedInsured";
   return fact.field;
 }
+function scheduleValueMap(item) {
+  return new Map(item.values.map((value) => [
+    value.label.toLowerCase().replace(/[^a-z0-9]+/g, " ").trim(),
+    value.value
+  ]));
+}
+function firstScheduleValue(values, labels) {
+  for (const label of labels) {
+    const direct = values.get(label);
+    if (direct) return direct;
+    const match = [...values.entries()].find(([key]) => key.includes(label));
+    if (match?.[1]) return match[1];
+  }
+  return void 0;
+}
+function positiveInteger2(value) {
+  const parsed = Number.parseInt(value?.match(/\d+/)?.[0] ?? "", 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : void 0;
+}
+function structuredVehicles(profile) {
+  return (profile.coverageSchedules ?? []).filter((schedule) => schedule.kind === "vehicle").flatMap((schedule) => schedule.items).flatMap((item, index) => {
+    const values = scheduleValueMap(item);
+    const year = positiveInteger2(firstScheduleValue(values, ["year", "model year"]));
+    const make = firstScheduleValue(values, ["make"]);
+    const model = firstScheduleValue(values, ["model"]);
+    const vin = firstScheduleValue(values, ["vin", "vehicle identification number"]);
+    if (!year || !make || !model || !vin) return [];
+    return [{
+      number: positiveInteger2(item.label) ?? index + 1,
+      year,
+      make,
+      model,
+      vin
+    }];
+  });
+}
+function structuredLocations(profile) {
+  return (profile.coverageSchedules ?? []).filter((schedule) => schedule.kind === "location" || schedule.kind === "property").flatMap((schedule) => schedule.items).flatMap((item, index) => {
+    const values = scheduleValueMap(item);
+    const street1 = firstScheduleValue(values, ["street 1", "street address", "address"]);
+    const city = firstScheduleValue(values, ["city"]);
+    const state = firstScheduleValue(values, ["state", "province"]);
+    const zip = firstScheduleValue(values, ["zip", "postal code"]);
+    if (!street1 || !city || !state || !zip) return [];
+    return [{
+      number: positiveInteger2(item.label) ?? index + 1,
+      address: {
+        street1,
+        city,
+        state,
+        zip,
+        country: firstScheduleValue(values, ["country"])
+      },
+      description: item.description,
+      buildingValue: firstScheduleValue(values, ["building value", "building"]),
+      contentsValue: firstScheduleValue(values, ["contents value", "contents"])
+    }];
+  });
+}
 function materializeDocument(params) {
   const profile = params.operationalProfile;
   const policyNumber = valueOf(profile, "policyNumber") ?? "Unknown";
-  const insuredName = valueOf(profile, "namedInsured") ?? "Unknown";
-  const carrier = valueOf(profile, "insurer") ?? "Unknown";
+  const namedInsuredParty = firstOperationalParty(profile, ["named_insured"]);
+  const insurerParty = firstOperationalParty(profile, ["insurer", "carrier"]);
+  const producerParty = firstOperationalParty(profile, ["producer", "broker"]);
+  const insuredName = valueOf(profile, "namedInsured") ?? namedInsuredParty?.name ?? "Unknown";
+  const carrier = valueOf(profile, "insurer") ?? insurerParty?.name ?? "Unknown";
   const effectiveDate = valueOf(profile, "effectiveDate") ?? "Unknown";
   const expirationDate = valueOf(profile, "expirationDate") ?? "Unknown";
   const premium = valueOf(profile, "premium");
-  const insurerProvenance = provenanceOf(profile.insurer);
-  const broker = valueOf(profile, "broker");
-  const brokerProvenance = provenanceOf(profile.broker);
+  const insurerProvenance = combinedProvenance(profile.insurer, insurerParty);
+  const insurerAddress = completeOperationalAddress(insurerParty?.address);
+  const broker = valueOf(profile, "broker") ?? producerParty?.name;
+  const brokerProvenance = combinedProvenance(profile.broker, producerParty);
+  const producerAddress = completeOperationalAddress(producerParty?.address);
   const mailingAddressFact = firstDeclarationFact(profile, "mailingAddress");
-  const insuredAddress = sourceBackedAddressFromFact(mailingAddressFact);
+  const insuredAddress = sourceBackedAddressFromParty(namedInsuredParty) ?? sourceBackedAddressFromFact(mailingAddressFact);
   const insuredDba = firstDeclarationFact(profile, "dba")?.value;
   const insuredEntityType = normalizedEntityType(firstDeclarationFact(profile, "entityType")?.value);
   const insuredFein = firstDeclarationFact(profile, "taxId")?.value;
@@ -5908,6 +6822,30 @@ function materializeDocument(params) {
       ...coverage.limits?.length ? coverage.limits.map((term) => `${term.label}: ${term.value}`) : [coverage.limit, coverage.deductible, coverage.premium]
     ].filter(Boolean).join(" | ")
   }));
+  const coverageSchedules = (profile.coverageSchedules ?? []).map((schedule) => ({
+    ...schedule,
+    items: schedule.items.map((item) => ({ ...item }))
+  }));
+  const premiumBreakdown = (profile.premiumBreakdown ?? []).map((row) => ({
+    line: row.line,
+    amount: row.amount,
+    amountValue: row.amountValue,
+    documentNodeId: row.sourceNodeIds[0],
+    sourceSpanIds: row.sourceSpanIds
+  }));
+  const taxesAndFees = (profile.taxesAndFees ?? []).map((row) => ({
+    name: row.name,
+    amount: row.amount,
+    amountValue: row.amountValue,
+    type: row.type,
+    description: row.description,
+    documentNodeId: row.sourceNodeIds[0],
+    sourceSpanIds: row.sourceSpanIds
+  }));
+  const totalCost = valueOf(profile, "totalCost");
+  const totalCostAmount = totalCost ? Number(totalCost.replace(/[^0-9.-]/g, "")) : void 0;
+  const vehicles = structuredVehicles(profile);
+  const locations = structuredLocations(profile);
   const documentOutline = sourceTreeToOutline(params.sourceTree);
   const documentMetadata = {
     sourceTreeVersion: "v3",
@@ -5940,15 +6878,29 @@ function materializeDocument(params) {
     security: carrier,
     insuredName,
     premium,
+    ...premiumBreakdown.length > 0 ? { premiumBreakdown } : {},
+    ...taxesAndFees.length > 0 ? { taxesAndFees } : {},
+    ...totalCost ? { totalCost } : {},
+    ...typeof totalCostAmount === "number" && Number.isFinite(totalCostAmount) ? { totalCostAmount } : {},
     insuredDba,
     insuredAddress,
     insuredEntityType,
     insuredFein,
     ...additionalNamedInsureds.length > 0 ? { additionalNamedInsureds } : {},
-    ...insurerProvenance ? { insurer: { legalName: carrier, ...insurerProvenance } } : {},
+    ...insurerProvenance ? {
+      insurer: {
+        legalName: carrier,
+        ...insurerAddress ? { address: insurerAddress } : {},
+        ...insurerProvenance
+      }
+    } : {},
     ...broker && brokerProvenance ? {
       brokerAgency: broker,
-      producer: { agencyName: broker, ...brokerProvenance }
+      producer: {
+        agencyName: broker,
+        ...producerAddress ? { address: producerAddress } : {},
+        ...brokerProvenance
+      }
     } : {},
     linesOfBusiness: profile.linesOfBusiness,
     formInventory: params.formInventory.filter((form) => typeof form.formNumber === "string" && form.formNumber.trim().length > 0).map((form) => ({
@@ -5960,6 +6912,9 @@ function materializeDocument(params) {
       pageEnd: form.pageEnd
     })),
     coverages,
+    ...coverageSchedules.length > 0 ? { coverageSchedules } : {},
+    ...vehicles.length > 0 ? { vehicles } : {},
+    ...locations.length > 0 ? { locations } : {},
     documentMetadata,
     documentOutline,
     declarations: {
@@ -6091,6 +7046,7 @@ async function runSourceTreeExtraction(params) {
   };
   const emptyProfile = emptyOperationalProfile();
   let operationalProfile = emptyProfile;
+  let coverageRecovery = disabledCoverageRecoveryDiagnostics();
   try {
     const validNodeIds = new Set(sourceTree.map((node) => node.id));
     const validSpanIds = new Set(sourceSpans.map((span) => span.id));
@@ -6128,6 +7084,21 @@ async function runSourceTreeExtraction(params) {
   } catch (error) {
     warnings.push(`Operational profile model pass failed; coverage rows omitted (${error instanceof Error ? error.message : String(error)})`);
   }
+  if (params.coverageRecovery?.enabled) {
+    const recovery = await recoverOperationalProfileCoverage({
+      sourceTree,
+      sourceSpans,
+      operationalProfile,
+      generateObject: params.generateObject,
+      providerOptions: params.providerOptions,
+      resolveBudget: params.resolveBudget,
+      trackUsage: localTrack,
+      log: params.log
+    });
+    operationalProfile = recovery.operationalProfile;
+    coverageRecovery = recovery.diagnostics;
+    warnings.push(...coverageRecovery.warnings);
+  }
   if (operationalProfile.coverages.length > 0) {
     try {
       const cleanup = await cleanupOperationalCoverageSchedules({
@@ -6160,6 +7131,7 @@ async function runSourceTreeExtraction(params) {
     sourceChunks: chunkSourceSpans(sourceSpans),
     formInventory: formHints,
     operationalProfile,
+    coverageRecovery,
     document,
     chunks: [],
     warnings: [...warnings, ...operationalProfile.warnings],
@@ -6262,7 +7234,8 @@ function createExtractor(config) {
         providerOptions: activeProviderOptions,
         resolveBudget,
         trackUsage,
-        log
+        log,
+        coverageRecovery: options?.coverageRecovery
       });
       const sourceTreeFormInventory = v3.formInventory.flatMap((form) => {
         const formNumber = typeof form.formNumber === "string" ? form.formNumber.trim() : "";
@@ -6302,6 +7275,7 @@ function createExtractor(config) {
         sourceChunks: v3.sourceChunks,
         sourceTree: v3.sourceTree,
         operationalProfile: v3.operationalProfile,
+        coverageRecovery: v3.coverageRecovery,
         warnings: v3.warnings,
         tokenUsage: v3.tokenUsage,
         usageReporting: v3.usageReporting,
@@ -7716,8 +8690,8 @@ Respond with JSON only:
 }`;
 
 // src/schemas/application.ts
-import { z as z24 } from "zod";
-var FieldTypeSchema = z24.enum([
+import { z as z25 } from "zod";
+var FieldTypeSchema = z25.enum([
   "text",
   "numeric",
   "currency",
@@ -7726,223 +8700,223 @@ var FieldTypeSchema = z24.enum([
   "table",
   "declaration"
 ]);
-var ApplicationFieldSchema = z24.object({
-  id: z24.string(),
-  label: z24.string(),
-  section: z24.string(),
+var ApplicationFieldSchema = z25.object({
+  id: z25.string(),
+  label: z25.string(),
+  section: z25.string(),
   fieldType: FieldTypeSchema,
-  required: z24.boolean(),
-  options: z24.array(z24.string()).optional(),
-  columns: z24.array(z24.string()).optional(),
-  requiresExplanationIfYes: z24.boolean().optional(),
-  condition: z24.object({
-    dependsOn: z24.string(),
-    whenValue: z24.string()
+  required: z25.boolean(),
+  options: z25.array(z25.string()).optional(),
+  columns: z25.array(z25.string()).optional(),
+  requiresExplanationIfYes: z25.boolean().optional(),
+  condition: z25.object({
+    dependsOn: z25.string(),
+    whenValue: z25.string()
   }).optional(),
-  value: z24.string().optional(),
-  source: z24.string().optional().describe("Where the value came from: auto-fill, user, lookup"),
-  confidence: z24.enum(["confirmed", "high", "medium", "low"]).optional(),
-  sourceSpanIds: z24.array(z24.string()).optional().describe("Stable source spans that support the field value or field anchor"),
-  userSourceSpanIds: z24.array(z24.string()).optional().describe("Message or attachment spans that support user-provided values"),
-  pageNumber: z24.number().int().positive().optional().describe("Application page where the field label or anchor appears"),
-  fieldAnchorId: z24.string().optional().describe("Stable field anchor ID derived from page, section, label, and form metadata"),
-  acroFormName: z24.string().optional().describe("Native PDF AcroForm field name when available"),
-  validationStatus: z24.enum(["valid", "needs_review", "unsupported", "missing"]).optional()
-});
-var ApplicationQuestionConditionSchema = z24.object({
-  dependsOn: z24.string(),
-  operator: z24.enum(["equals", "not_equals", "in", "not_in", "exists"]).optional(),
-  value: z24.string().optional(),
-  whenValue: z24.string().optional(),
-  values: z24.array(z24.string()).optional()
-});
-var ApplicationRepeatSchema = z24.object({
-  min: z24.number().int().nonnegative().optional(),
-  max: z24.number().int().positive().optional(),
-  label: z24.string().optional()
-});
-var ApplicationQuestionNodeSchema = z24.lazy(
-  () => z24.object({
-    id: z24.string(),
-    nodeType: z24.enum(["group", "question", "repeat_group", "table"]),
-    fieldId: z24.string().optional(),
-    fieldPath: z24.string().optional(),
-    parentId: z24.string().optional(),
-    order: z24.number().int().nonnegative().optional(),
-    label: z24.string(),
-    section: z24.string().optional(),
+  value: z25.string().optional(),
+  source: z25.string().optional().describe("Where the value came from: auto-fill, user, lookup"),
+  confidence: z25.enum(["confirmed", "high", "medium", "low"]).optional(),
+  sourceSpanIds: z25.array(z25.string()).optional().describe("Stable source spans that support the field value or field anchor"),
+  userSourceSpanIds: z25.array(z25.string()).optional().describe("Message or attachment spans that support user-provided values"),
+  pageNumber: z25.number().int().positive().optional().describe("Application page where the field label or anchor appears"),
+  fieldAnchorId: z25.string().optional().describe("Stable field anchor ID derived from page, section, label, and form metadata"),
+  acroFormName: z25.string().optional().describe("Native PDF AcroForm field name when available"),
+  validationStatus: z25.enum(["valid", "needs_review", "unsupported", "missing"]).optional()
+});
+var ApplicationQuestionConditionSchema = z25.object({
+  dependsOn: z25.string(),
+  operator: z25.enum(["equals", "not_equals", "in", "not_in", "exists"]).optional(),
+  value: z25.string().optional(),
+  whenValue: z25.string().optional(),
+  values: z25.array(z25.string()).optional()
+});
+var ApplicationRepeatSchema = z25.object({
+  min: z25.number().int().nonnegative().optional(),
+  max: z25.number().int().positive().optional(),
+  label: z25.string().optional()
+});
+var ApplicationQuestionNodeSchema = z25.lazy(
+  () => z25.object({
+    id: z25.string(),
+    nodeType: z25.enum(["group", "question", "repeat_group", "table"]),
+    fieldId: z25.string().optional(),
+    fieldPath: z25.string().optional(),
+    parentId: z25.string().optional(),
+    order: z25.number().int().nonnegative().optional(),
+    label: z25.string(),
+    section: z25.string().optional(),
     fieldType: FieldTypeSchema.optional(),
-    required: z24.boolean().optional(),
-    prompt: z24.string().optional(),
-    options: z24.array(z24.string()).optional(),
-    columns: z24.array(z24.string()).optional(),
+    required: z25.boolean().optional(),
+    prompt: z25.string().optional(),
+    options: z25.array(z25.string()).optional(),
+    columns: z25.array(z25.string()).optional(),
     condition: ApplicationQuestionConditionSchema.optional(),
     repeat: ApplicationRepeatSchema.optional(),
-    children: z24.array(ApplicationQuestionNodeSchema).optional()
+    children: z25.array(ApplicationQuestionNodeSchema).optional()
   })
 );
-var ApplicationQuestionGraphSchema = z24.object({
-  id: z24.string(),
-  version: z24.string(),
-  title: z24.string().optional(),
-  applicationType: z24.string().nullable().optional(),
-  source: z24.enum(["pdf", "manual", "imported", "generated"]).default("generated"),
-  rootNodeIds: z24.array(z24.string()).optional(),
-  nodes: z24.array(ApplicationQuestionNodeSchema)
-});
-var ApplicationTemplateSchema = z24.object({
-  id: z24.string(),
-  version: z24.string(),
-  title: z24.string(),
-  applicationType: z24.string().nullable().optional(),
+var ApplicationQuestionGraphSchema = z25.object({
+  id: z25.string(),
+  version: z25.string(),
+  title: z25.string().optional(),
+  applicationType: z25.string().nullable().optional(),
+  source: z25.enum(["pdf", "manual", "imported", "generated"]).default("generated"),
+  rootNodeIds: z25.array(z25.string()).optional(),
+  nodes: z25.array(ApplicationQuestionNodeSchema)
+});
+var ApplicationTemplateSchema = z25.object({
+  id: z25.string(),
+  version: z25.string(),
+  title: z25.string(),
+  applicationType: z25.string().nullable().optional(),
   questionGraph: ApplicationQuestionGraphSchema,
-  fields: z24.array(ApplicationFieldSchema).optional()
-});
-var ApplicationClassifyResultSchema = z24.object({
-  isApplication: z24.boolean(),
-  confidence: z24.number().min(0).max(1),
-  applicationType: z24.string().nullable()
-});
-var FieldExtractionResultSchema = z24.object({
-  fields: z24.array(ApplicationFieldSchema)
-});
-var AutoFillMatchSchema = z24.object({
-  fieldId: z24.string(),
-  value: z24.string(),
-  confidence: z24.enum(["confirmed"]),
-  contextKey: z24.string()
-});
-var AutoFillResultSchema = z24.object({
-  matches: z24.array(AutoFillMatchSchema)
-});
-var QuestionBatchResultSchema = z24.object({
-  batches: z24.array(z24.array(z24.string()).describe("Array of field IDs in this batch"))
-});
-var LookupRequestSchema = z24.object({
-  type: z24.string().describe("Type of lookup: 'records', 'website', 'policy'"),
-  description: z24.string(),
-  url: z24.string().optional(),
-  targetFieldIds: z24.array(z24.string())
-});
-var ReplyIntentSchema = z24.object({
-  primaryIntent: z24.enum(["answers_only", "question", "lookup_request", "mixed"]),
-  hasAnswers: z24.boolean(),
-  questionText: z24.string().optional(),
-  questionFieldIds: z24.array(z24.string()).optional(),
-  lookupRequests: z24.array(LookupRequestSchema).optional()
-});
-var ParsedAnswerSchema = z24.object({
-  fieldId: z24.string(),
-  value: z24.string(),
-  explanation: z24.string().optional()
-});
-var AnswerParsingResultSchema = z24.object({
-  answers: z24.array(ParsedAnswerSchema),
-  unanswered: z24.array(z24.string()).describe("Field IDs that were not answered")
-});
-var LookupFillSchema = z24.object({
-  fieldId: z24.string(),
-  value: z24.string(),
-  source: z24.string().describe("Specific citable reference, e.g. 'GL Policy #POL-12345 (Hartford)'"),
-  sourceSpanIds: z24.array(z24.string()).optional()
+  fields: z25.array(ApplicationFieldSchema).optional()
 });
-var LookupFillResultSchema = z24.object({
-  fills: z24.array(LookupFillSchema),
-  unfillable: z24.array(z24.string()),
-  explanation: z24.string().optional()
-});
-var FlatPdfPlacementSchema = z24.object({
-  fieldId: z24.string(),
-  page: z24.number(),
-  x: z24.number().describe("Percentage from left edge (0-100)"),
-  y: z24.number().describe("Percentage from top edge (0-100)"),
-  text: z24.string(),
-  fontSize: z24.number().optional(),
-  isCheckmark: z24.boolean().optional()
-});
-var AcroFormMappingSchema = z24.object({
-  fieldId: z24.string(),
-  acroFormName: z24.string(),
-  value: z24.string()
-});
-var QualityGateStatusSchema = z24.enum(["passed", "warning", "failed"]);
-var QualitySeveritySchema = z24.enum(["info", "warning", "blocking"]);
-var ApplicationQualityIssueSchema = z24.object({
-  code: z24.string(),
+var ApplicationClassifyResultSchema = z25.object({
+  isApplication: z25.boolean(),
+  confidence: z25.number().min(0).max(1),
+  applicationType: z25.string().nullable()
+});
+var FieldExtractionResultSchema = z25.object({
+  fields: z25.array(ApplicationFieldSchema)
+});
+var AutoFillMatchSchema = z25.object({
+  fieldId: z25.string(),
+  value: z25.string(),
+  confidence: z25.enum(["confirmed"]),
+  contextKey: z25.string()
+});
+var AutoFillResultSchema = z25.object({
+  matches: z25.array(AutoFillMatchSchema)
+});
+var QuestionBatchResultSchema = z25.object({
+  batches: z25.array(z25.array(z25.string()).describe("Array of field IDs in this batch"))
+});
+var LookupRequestSchema = z25.object({
+  type: z25.string().describe("Type of lookup: 'records', 'website', 'policy'"),
+  description: z25.string(),
+  url: z25.string().optional(),
+  targetFieldIds: z25.array(z25.string())
+});
+var ReplyIntentSchema = z25.object({
+  primaryIntent: z25.enum(["answers_only", "question", "lookup_request", "mixed"]),
+  hasAnswers: z25.boolean(),
+  questionText: z25.string().optional(),
+  questionFieldIds: z25.array(z25.string()).optional(),
+  lookupRequests: z25.array(LookupRequestSchema).optional()
+});
+var ParsedAnswerSchema = z25.object({
+  fieldId: z25.string(),
+  value: z25.string(),
+  explanation: z25.string().optional()
+});
+var AnswerParsingResultSchema = z25.object({
+  answers: z25.array(ParsedAnswerSchema),
+  unanswered: z25.array(z25.string()).describe("Field IDs that were not answered")
+});
+var LookupFillSchema = z25.object({
+  fieldId: z25.string(),
+  value: z25.string(),
+  source: z25.string().describe("Specific citable reference, e.g. 'GL Policy #POL-12345 (Hartford)'"),
+  sourceSpanIds: z25.array(z25.string()).optional()
+});
+var LookupFillResultSchema = z25.object({
+  fills: z25.array(LookupFillSchema),
+  unfillable: z25.array(z25.string()),
+  explanation: z25.string().optional()
+});
+var FlatPdfPlacementSchema = z25.object({
+  fieldId: z25.string(),
+  page: z25.number(),
+  x: z25.number().describe("Percentage from left edge (0-100)"),
+  y: z25.number().describe("Percentage from top edge (0-100)"),
+  text: z25.string(),
+  fontSize: z25.number().optional(),
+  isCheckmark: z25.boolean().optional()
+});
+var AcroFormMappingSchema = z25.object({
+  fieldId: z25.string(),
+  acroFormName: z25.string(),
+  value: z25.string()
+});
+var QualityGateStatusSchema = z25.enum(["passed", "warning", "failed"]);
+var QualitySeveritySchema = z25.enum(["info", "warning", "blocking"]);
+var ApplicationQualityIssueSchema = z25.object({
+  code: z25.string(),
   severity: QualitySeveritySchema,
-  message: z24.string(),
-  fieldId: z24.string().optional()
+  message: z25.string(),
+  fieldId: z25.string().optional()
 });
-var ApplicationQualityRoundSchema = z24.object({
-  round: z24.number(),
-  kind: z24.string(),
+var ApplicationQualityRoundSchema = z25.object({
+  round: z25.number(),
+  kind: z25.string(),
   status: QualityGateStatusSchema,
-  summary: z24.string().optional()
+  summary: z25.string().optional()
 });
-var ApplicationQualityArtifactSchema = z24.object({
-  kind: z24.string(),
-  label: z24.string().optional(),
-  itemCount: z24.number().optional()
+var ApplicationQualityArtifactSchema = z25.object({
+  kind: z25.string(),
+  label: z25.string().optional(),
+  itemCount: z25.number().optional()
 });
-var ApplicationEmailReviewSchema = z24.object({
-  issues: z24.array(ApplicationQualityIssueSchema),
+var ApplicationEmailReviewSchema = z25.object({
+  issues: z25.array(ApplicationQualityIssueSchema),
   qualityGateStatus: QualityGateStatusSchema
 });
-var ApplicationQualityReportSchema = z24.object({
-  issues: z24.array(ApplicationQualityIssueSchema),
-  rounds: z24.array(ApplicationQualityRoundSchema).optional(),
-  artifacts: z24.array(ApplicationQualityArtifactSchema).optional(),
+var ApplicationQualityReportSchema = z25.object({
+  issues: z25.array(ApplicationQualityIssueSchema),
+  rounds: z25.array(ApplicationQualityRoundSchema).optional(),
+  artifacts: z25.array(ApplicationQualityArtifactSchema).optional(),
   emailReview: ApplicationEmailReviewSchema.optional(),
   qualityGateStatus: QualityGateStatusSchema
 });
-var ApplicationContextProposalSchema = z24.object({
-  id: z24.string(),
-  fieldId: z24.string().optional(),
-  key: z24.string(),
-  value: z24.string(),
-  category: z24.string(),
-  source: z24.enum(["application", "user", "lookup", "policy", "email", "chat", "imessage", "mcp"]),
-  confidence: z24.enum(["confirmed", "high", "medium", "low"]),
-  sourceSpanIds: z24.array(z24.string()).optional(),
-  userSourceSpanIds: z24.array(z24.string()).optional()
-});
-var ApplicationPacketAnswerSchema = z24.object({
-  fieldId: z24.string(),
-  label: z24.string(),
-  section: z24.string(),
-  value: z24.string(),
-  source: z24.string(),
-  confidence: z24.enum(["confirmed", "high", "medium", "low"]).optional(),
-  sourceSpanIds: z24.array(z24.string()).optional(),
-  userSourceSpanIds: z24.array(z24.string()).optional()
-});
-var ApplicationPacketSchema = z24.object({
-  id: z24.string(),
-  applicationId: z24.string(),
-  title: z24.string(),
-  status: z24.enum(["draft", "broker_ready", "submitted"]),
-  answers: z24.array(ApplicationPacketAnswerSchema),
-  missingFieldIds: z24.array(z24.string()),
+var ApplicationContextProposalSchema = z25.object({
+  id: z25.string(),
+  fieldId: z25.string().optional(),
+  key: z25.string(),
+  value: z25.string(),
+  category: z25.string(),
+  source: z25.enum(["application", "user", "lookup", "policy", "email", "chat", "imessage", "mcp"]),
+  confidence: z25.enum(["confirmed", "high", "medium", "low"]),
+  sourceSpanIds: z25.array(z25.string()).optional(),
+  userSourceSpanIds: z25.array(z25.string()).optional()
+});
+var ApplicationPacketAnswerSchema = z25.object({
+  fieldId: z25.string(),
+  label: z25.string(),
+  section: z25.string(),
+  value: z25.string(),
+  source: z25.string(),
+  confidence: z25.enum(["confirmed", "high", "medium", "low"]).optional(),
+  sourceSpanIds: z25.array(z25.string()).optional(),
+  userSourceSpanIds: z25.array(z25.string()).optional()
+});
+var ApplicationPacketSchema = z25.object({
+  id: z25.string(),
+  applicationId: z25.string(),
+  title: z25.string(),
+  status: z25.enum(["draft", "broker_ready", "submitted"]),
+  answers: z25.array(ApplicationPacketAnswerSchema),
+  missingFieldIds: z25.array(z25.string()),
   qualityReport: ApplicationQualityReportSchema,
-  submissionNotes: z24.string().optional(),
-  createdAt: z24.number()
-});
-var ApplicationStateSchema = z24.object({
-  id: z24.string(),
-  pdfBase64: z24.string().optional().describe("Original PDF, omitted after extraction"),
-  templateId: z24.string().optional(),
-  templateVersion: z24.string().optional(),
+  submissionNotes: z25.string().optional(),
+  createdAt: z25.number()
+});
+var ApplicationStateSchema = z25.object({
+  id: z25.string(),
+  pdfBase64: z25.string().optional().describe("Original PDF, omitted after extraction"),
+  templateId: z25.string().optional(),
+  templateVersion: z25.string().optional(),
   templateSnapshot: ApplicationTemplateSchema.optional(),
-  title: z24.string().optional(),
-  applicationType: z24.string().nullable().optional(),
+  title: z25.string().optional(),
+  applicationType: z25.string().nullable().optional(),
   questionGraph: ApplicationQuestionGraphSchema.optional(),
-  fields: z24.array(ApplicationFieldSchema),
-  batches: z24.array(z24.array(z24.string())).optional(),
-  currentBatchIndex: z24.number().default(0),
-  contextProposals: z24.array(ApplicationContextProposalSchema).optional(),
+  fields: z25.array(ApplicationFieldSchema),
+  batches: z25.array(z25.array(z25.string())).optional(),
+  currentBatchIndex: z25.number().default(0),
+  contextProposals: z25.array(ApplicationContextProposalSchema).optional(),
   packet: ApplicationPacketSchema.optional(),
   qualityReport: ApplicationQualityReportSchema.optional(),
-  status: z24.enum([
+  status: z25.enum([
     "classifying",
     "extracting",
     "auto_filling",
@@ -7956,8 +8930,8 @@ var ApplicationStateSchema = z24.object({
     "cancelled",
     "complete"
   ]),
-  createdAt: z24.number(),
-  updatedAt: z24.number()
+  createdAt: z25.number(),
+  updatedAt: z25.number()
 });
 
 // src/application/agents/classifier.ts
@@ -9691,106 +10665,106 @@ Respond with the final answer, deduplicated citations array, overall confidence
 }
 
 // src/schemas/query.ts
-import { z as z25 } from "zod";
-var QueryIntentSchema = z25.enum([
+import { z as z26 } from "zod";
+var QueryIntentSchema = z26.enum([
   "policy_question",
   "coverage_comparison",
   "document_search",
   "claims_inquiry",
   "general_knowledge"
 ]);
-var QueryAttachmentKindSchema = z25.enum(["image", "pdf", "text"]);
-var QueryAttachmentSchema = z25.object({
-  id: z25.string().optional().describe("Optional stable attachment ID from the caller"),
+var QueryAttachmentKindSchema = z26.enum(["image", "pdf", "text"]);
+var QueryAttachmentSchema = z26.object({
+  id: z26.string().optional().describe("Optional stable attachment ID from the caller"),
   kind: QueryAttachmentKindSchema,
-  name: z25.string().optional().describe("Original filename or user-facing label"),
-  mimeType: z25.string().optional().describe("MIME type such as image/jpeg or application/pdf"),
-  base64: z25.string().optional().describe("Base64-encoded file content for image/pdf attachments"),
-  text: z25.string().optional().describe("Plain-text attachment content when available"),
-  description: z25.string().optional().describe("Caller-provided description of the attachment")
+  name: z26.string().optional().describe("Original filename or user-facing label"),
+  mimeType: z26.string().optional().describe("MIME type such as image/jpeg or application/pdf"),
+  base64: z26.string().optional().describe("Base64-encoded file content for image/pdf attachments"),
+  text: z26.string().optional().describe("Plain-text attachment content when available"),
+  description: z26.string().optional().describe("Caller-provided description of the attachment")
 });
-var QueryRetrievalModeSchema = z25.enum([
+var QueryRetrievalModeSchema = z26.enum([
   "graph_only",
   "source_rag",
   "long_context",
   "hybrid"
 ]);
-var SubQuestionSchema = z25.object({
-  question: z25.string().describe("Atomic sub-question to retrieve and answer independently"),
+var SubQuestionSchema = z26.object({
+  question: z26.string().describe("Atomic sub-question to retrieve and answer independently"),
   intent: QueryIntentSchema,
-  chunkTypes: z25.array(z25.string()).optional().describe("Chunk types to filter retrieval (e.g. coverage, endorsement, declaration)"),
-  documentFilters: z25.object({
-    type: z25.enum(["policy", "quote"]).optional(),
-    carrier: z25.string().optional(),
-    insuredName: z25.string().optional(),
-    policyNumber: z25.string().optional(),
-    quoteNumber: z25.string().optional(),
-    linesOfBusiness: z25.array(AcordLobCodeSchema).optional().describe("Filter by ACORD line of business code (e.g. HOME, AUTOP, DISAB) to avoid mixing up similar policies")
+  chunkTypes: z26.array(z26.string()).optional().describe("Chunk types to filter retrieval (e.g. coverage, endorsement, declaration)"),
+  documentFilters: z26.object({
+    type: z26.enum(["policy", "quote"]).optional(),
+    carrier: z26.string().optional(),
+    insuredName: z26.string().optional(),
+    policyNumber: z26.string().optional(),
+    quoteNumber: z26.string().optional(),
+    linesOfBusiness: z26.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 = z25.object({
+var QueryClassifyResultSchema = z26.object({
   intent: QueryIntentSchema,
-  subQuestions: z25.array(SubQuestionSchema).min(1).describe("Decomposed atomic sub-questions"),
-  requiresDocumentLookup: z25.boolean().describe("Whether structured document lookup is needed"),
-  requiresChunkSearch: z25.boolean().describe("Whether semantic chunk search is needed"),
-  requiresConversationHistory: z25.boolean().describe("Whether conversation history is relevant"),
+  subQuestions: z26.array(SubQuestionSchema).min(1).describe("Decomposed atomic sub-questions"),
+  requiresDocumentLookup: z26.boolean().describe("Whether structured document lookup is needed"),
+  requiresChunkSearch: z26.boolean().describe("Whether semantic chunk search is needed"),
+  requiresConversationHistory: z26.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 = z25.object({
-  source: z25.enum(["chunk", "document", "conversation", "attachment", "source_span", "source_node"]),
-  chunkId: z25.string().optional(),
-  sourceNodeId: z25.string().optional(),
-  sourceSpanId: z25.string().optional(),
-  documentId: z25.string().optional(),
-  turnId: z25.string().optional(),
-  attachmentId: z25.string().optional(),
-  text: z25.string().describe("Text excerpt from the source"),
-  relevance: z25.number().min(0).max(1),
+var EvidenceItemSchema = z26.object({
+  source: z26.enum(["chunk", "document", "conversation", "attachment", "source_span", "source_node"]),
+  chunkId: z26.string().optional(),
+  sourceNodeId: z26.string().optional(),
+  sourceSpanId: z26.string().optional(),
+  documentId: z26.string().optional(),
+  turnId: z26.string().optional(),
+  attachmentId: z26.string().optional(),
+  text: z26.string().describe("Text excerpt from the source"),
+  relevance: z26.number().min(0).max(1),
   retrievalMode: QueryRetrievalModeSchema.optional(),
   sourceLocation: SourceSpanLocationSchema.optional(),
-  metadata: z25.array(z25.object({ key: z25.string(), value: z25.string() })).optional()
-});
-var AttachmentInterpretationSchema = z25.object({
-  summary: z25.string().describe("Concise summary of what the attachment shows or contains"),
-  extractedFacts: z25.array(z25.string()).describe("Specific observable or document facts grounded in the attachment"),
-  recommendedFocus: z25.array(z25.string()).describe("Important details to incorporate when answering follow-up questions"),
-  confidence: z25.number().min(0).max(1)
-});
-var RetrievalResultSchema = z25.object({
-  subQuestion: z25.string(),
-  evidence: z25.array(EvidenceItemSchema)
-});
-var CitationSchema = z25.object({
-  index: z25.number().describe("Citation number [1], [2], etc."),
-  chunkId: z25.string().optional().describe("Source chunk ID, e.g. doc-123:coverage:2"),
-  sourceNodeId: z25.string().optional().describe("Source tree node ID when available"),
-  sourceSpanId: z25.string().optional().describe("Precise source span ID when available"),
-  documentId: z25.string(),
-  documentType: z25.enum(["policy", "quote"]).optional(),
-  field: z25.string().optional().describe("Specific field path, e.g. coverages[0].deductible"),
-  quote: z25.string().describe("Exact text from source that supports the claim"),
-  relevance: z25.number().min(0).max(1),
+  metadata: z26.array(z26.object({ key: z26.string(), value: z26.string() })).optional()
+});
+var AttachmentInterpretationSchema = z26.object({
+  summary: z26.string().describe("Concise summary of what the attachment shows or contains"),
+  extractedFacts: z26.array(z26.string()).describe("Specific observable or document facts grounded in the attachment"),
+  recommendedFocus: z26.array(z26.string()).describe("Important details to incorporate when answering follow-up questions"),
+  confidence: z26.number().min(0).max(1)
+});
+var RetrievalResultSchema = z26.object({
+  subQuestion: z26.string(),
+  evidence: z26.array(EvidenceItemSchema)
+});
+var CitationSchema = z26.object({
+  index: z26.number().describe("Citation number [1], [2], etc."),
+  chunkId: z26.string().optional().describe("Source chunk ID, e.g. doc-123:coverage:2"),
+  sourceNodeId: z26.string().optional().describe("Source tree node ID when available"),
+  sourceSpanId: z26.string().optional().describe("Precise source span ID when available"),
+  documentId: z26.string(),
+  documentType: z26.enum(["policy", "quote"]).optional(),
+  field: z26.string().optional().describe("Specific field path, e.g. coverages[0].deductible"),
+  quote: z26.string().describe("Exact text from source that supports the claim"),
+  relevance: z26.number().min(0).max(1),
   retrievalMode: QueryRetrievalModeSchema.optional(),
   sourceLocation: SourceSpanLocationSchema.optional()
 });
-var SubAnswerSchema = z25.object({
-  subQuestion: z25.string(),
-  answer: z25.string(),
-  citations: z25.array(CitationSchema),
-  confidence: z25.number().min(0).max(1),
-  needsMoreContext: z25.boolean().describe("True if evidence was insufficient to answer fully")
-});
-var VerifyResultSchema = z25.object({
-  approved: z25.boolean().describe("Whether all sub-answers are adequately grounded"),
-  issues: z25.array(z25.string()).describe("Specific grounding or consistency issues found"),
-  retrySubQuestions: z25.array(z25.string()).optional().describe("Sub-questions that need additional retrieval or re-reasoning")
-});
-var QueryResultSchema = z25.object({
-  answer: z25.string(),
-  citations: z25.array(CitationSchema),
+var SubAnswerSchema = z26.object({
+  subQuestion: z26.string(),
+  answer: z26.string(),
+  citations: z26.array(CitationSchema),
+  confidence: z26.number().min(0).max(1),
+  needsMoreContext: z26.boolean().describe("True if evidence was insufficient to answer fully")
+});
+var VerifyResultSchema = z26.object({
+  approved: z26.boolean().describe("Whether all sub-answers are adequately grounded"),
+  issues: z26.array(z26.string()).describe("Specific grounding or consistency issues found"),
+  retrySubQuestions: z26.array(z26.string()).optional().describe("Sub-questions that need additional retrieval or re-reasoning")
+});
+var QueryResultSchema = z26.object({
+  answer: z26.string(),
+  citations: z26.array(CitationSchema),
   intent: QueryIntentSchema,
-  confidence: z25.number().min(0).max(1),
-  followUp: z25.string().optional().describe("Suggested follow-up question if applicable")
+  confidence: z26.number().min(0).max(1),
+  followUp: z26.string().optional().describe("Suggested follow-up question if applicable")
 });
 
 // src/query/retriever.ts
@@ -10857,7 +11831,7 @@ ${sa.answer}`).join("\n\n"),
 }
 
 // src/pce/index.ts
-import { z as z26 } from "zod";
+import { z as z27 } from "zod";
 
 // src/prompts/pce/index.ts
 function buildPceNormalizePrompt(input) {
@@ -10891,11 +11865,11 @@ ${input.openQuestions.map((question) => `- ${question.id}${question.fieldPath ?
 }
 
 // src/pce/index.ts
-var ReplyAnswersSchema = z26.object({
-  answers: z26.array(z26.object({
-    questionId: z26.string().optional(),
-    fieldPath: z26.string().optional(),
-    answer: z26.string()
+var ReplyAnswersSchema = z27.object({
+  answers: z27.array(z27.object({
+    questionId: z27.string().optional(),
+    fieldPath: z27.string().optional(),
+    answer: z27.string()
   }))
 });
 function createPceAgent(config = {}) {
@@ -11649,23 +12623,23 @@ var AGENT_TOOLS = [
 ];
 
 // src/prompts/extractors/carrier-info.ts
-import { z as z27 } from "zod";
-var CarrierInfoSchema = z27.object({
-  carrierName: z27.string().describe("Primary insurance company name for display"),
-  carrierLegalName: z27.string().optional().describe("Legal entity name of insurer"),
-  naicNumber: z27.string().optional().describe("NAIC company code"),
-  amBestRating: z27.string().optional().describe("AM Best rating, e.g. 'A+ XV'"),
-  admittedStatus: z27.enum(["admitted", "non_admitted", "surplus_lines"]).optional().describe("Admitted status of the carrier"),
-  mga: z27.string().optional().describe("Managing General Agent or Program Administrator name"),
-  underwriter: z27.string().optional().describe("Named individual underwriter"),
-  brokerAgency: z27.string().optional().describe("Broker or producer agency name"),
-  brokerContactName: z27.string().optional().describe("Broker or producer contact person name"),
-  brokerLicenseNumber: z27.string().optional().describe("Broker or producer license number"),
-  policyNumber: z27.string().optional().describe("Policy or quote reference number"),
-  effectiveDate: z27.string().optional().describe("Policy effective date (MM/DD/YYYY)"),
-  expirationDate: z27.string().optional().describe("Policy expiration date (MM/DD/YYYY)"),
-  quoteNumber: z27.string().optional().describe("Quote or proposal reference number"),
-  proposedEffectiveDate: z27.string().optional().describe("Proposed effective date for quotes (MM/DD/YYYY)")
+import { z as z28 } from "zod";
+var CarrierInfoSchema = z28.object({
+  carrierName: z28.string().describe("Primary insurance company name for display"),
+  carrierLegalName: z28.string().optional().describe("Legal entity name of insurer"),
+  naicNumber: z28.string().optional().describe("NAIC company code"),
+  amBestRating: z28.string().optional().describe("AM Best rating, e.g. 'A+ XV'"),
+  admittedStatus: z28.enum(["admitted", "non_admitted", "surplus_lines"]).optional().describe("Admitted status of the carrier"),
+  mga: z28.string().optional().describe("Managing General Agent or Program Administrator name"),
+  underwriter: z28.string().optional().describe("Named individual underwriter"),
+  brokerAgency: z28.string().optional().describe("Broker or producer agency name"),
+  brokerContactName: z28.string().optional().describe("Broker or producer contact person name"),
+  brokerLicenseNumber: z28.string().optional().describe("Broker or producer license number"),
+  policyNumber: z28.string().optional().describe("Policy or quote reference number"),
+  effectiveDate: z28.string().optional().describe("Policy effective date (MM/DD/YYYY)"),
+  expirationDate: z28.string().optional().describe("Policy expiration date (MM/DD/YYYY)"),
+  quoteNumber: z28.string().optional().describe("Quote or proposal reference number"),
+  proposedEffectiveDate: z28.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.
@@ -11688,21 +12662,21 @@ Return JSON only.`;
 }
 
 // src/prompts/extractors/named-insured.ts
-import { z as z28 } from "zod";
-var AdditionalNamedInsuredSchema = z28.object({
-  name: z28.string(),
-  relationship: z28.string().optional().describe("e.g. subsidiary, affiliate"),
+import { z as z29 } from "zod";
+var AdditionalNamedInsuredSchema = z29.object({
+  name: z29.string(),
+  relationship: z29.string().optional().describe("e.g. subsidiary, affiliate"),
   address: SourceBackedAddressSchema.optional()
 }).merge(SourceProvenanceSchema);
-var ScheduledPartySchema = z28.object({
-  name: z28.string(),
+var ScheduledPartySchema = z29.object({
+  name: z29.string(),
   address: SourceBackedAddressSchema.optional()
 }).merge(SourceProvenanceSchema);
-var NamedInsuredSchema2 = z28.object({
-  insuredName: z28.string().describe("Name of primary named insured"),
-  insuredDba: z28.string().optional().describe("Doing-business-as name"),
+var NamedInsuredSchema2 = z29.object({
+  insuredName: z29.string().describe("Name of primary named insured"),
+  insuredDba: z29.string().optional().describe("Doing-business-as name"),
   insuredAddress: SourceBackedAddressSchema.optional().describe("Primary insured mailing address"),
-  insuredEntityType: z28.enum([
+  insuredEntityType: z29.enum([
     "corporation",
     "llc",
     "partnership",
@@ -11715,12 +12689,12 @@ var NamedInsuredSchema2 = z28.object({
     "married_couple",
     "other"
   ]).optional().describe("Legal entity type of the insured"),
-  insuredFein: z28.string().optional().describe("Federal Employer Identification Number"),
-  insuredSicCode: z28.string().optional().describe("SIC code"),
-  insuredNaicsCode: z28.string().optional().describe("NAICS code"),
-  additionalNamedInsureds: z28.array(AdditionalNamedInsuredSchema).optional().describe("Additional named insureds listed on the policy"),
-  lossPayees: z28.array(ScheduledPartySchema).optional().describe("Loss payees listed on the policy"),
-  mortgageHolders: z28.array(ScheduledPartySchema).optional().describe("Mortgage holders / lienholders listed on the policy")
+  insuredFein: z29.string().optional().describe("Federal Employer Identification Number"),
+  insuredSicCode: z29.string().optional().describe("SIC code"),
+  insuredNaicsCode: z29.string().optional().describe("NAICS code"),
+  additionalNamedInsureds: z29.array(AdditionalNamedInsuredSchema).optional().describe("Additional named insureds listed on the policy"),
+  lossPayees: z29.array(ScheduledPartySchema).optional().describe("Loss payees listed on the policy"),
+  mortgageHolders: z29.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.
@@ -11747,14 +12721,14 @@ Return JSON only.`;
 }
 
 // src/prompts/extractors/coverage-limits.ts
-import { z as z29 } from "zod";
+import { z as z30 } from "zod";
 var ExtractorCoverageSchema = CoverageSchema.extend({
-  coverageCode: z29.string().optional().describe("Coverage code or class code")
+  coverageCode: z30.string().optional().describe("Coverage code or class code")
 });
-var CoverageLimitsSchema = z29.object({
-  coverages: z29.array(ExtractorCoverageSchema).describe("All coverages with their limits"),
-  coverageForm: z29.enum(["occurrence", "claims_made", "accident"]).optional().describe("Primary coverage trigger type"),
-  retroactiveDate: z29.string().optional().describe("Retroactive date for claims-made policies (MM/DD/YYYY)")
+var CoverageLimitsSchema = z30.object({
+  coverages: z30.array(ExtractorCoverageSchema).describe("All coverages with their limits"),
+  coverageForm: z30.enum(["occurrence", "claims_made", "accident"]).optional().describe("Primary coverage trigger type"),
+  retroactiveDate: z30.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.
@@ -11796,14 +12770,14 @@ Return JSON only.`;
 }
 
 // src/prompts/extractors/endorsements.ts
-import { z as z30 } from "zod";
-var EndorsementsSchema = z30.object({
-  endorsements: z30.array(
-    z30.object({
-      formNumber: z30.string().describe("Form number, e.g. 'CG 21 47'"),
-      editionDate: z30.string().optional().describe("Edition date, e.g. '12 07'"),
-      title: z30.string().describe("Endorsement title"),
-      endorsementType: z30.enum([
+import { z as z31 } from "zod";
+var EndorsementsSchema = z31.object({
+  endorsements: z31.array(
+    z31.object({
+      formNumber: z31.string().describe("Form number, e.g. 'CG 21 47'"),
+      editionDate: z31.string().optional().describe("Edition date, e.g. '12 07'"),
+      title: z31.string().describe("Endorsement title"),
+      endorsementType: z31.enum([
         "additional_insured",
         "waiver_of_subrogation",
         "primary_noncontributory",
@@ -11823,12 +12797,12 @@ var EndorsementsSchema = z30.object({
         "territorial_extension",
         "other"
       ]).describe("Endorsement type classification"),
-      effectiveDate: z30.string().optional().describe("Endorsement effective date"),
-      affectedCoverageParts: z30.array(z30.string()).optional().describe("Coverage parts affected by this endorsement"),
-      namedParties: z30.array(
-        z30.object({
-          name: z30.string().describe("Party name"),
-          role: z30.enum([
+      effectiveDate: z31.string().optional().describe("Endorsement effective date"),
+      affectedCoverageParts: z31.array(z31.string()).optional().describe("Coverage parts affected by this endorsement"),
+      namedParties: z31.array(
+        z31.object({
+          name: z31.string().describe("Party name"),
+          role: z31.enum([
             "additional_insured",
             "loss_payee",
             "mortgage_holder",
@@ -11837,18 +12811,18 @@ var EndorsementsSchema = z30.object({
             "designated_person",
             "other"
           ]).describe("Party role"),
-          relationship: z30.string().optional().describe("Relationship to insured"),
-          scope: z30.string().optional().describe("Scope of coverage for this party")
+          relationship: z31.string().optional().describe("Relationship to insured"),
+          scope: z31.string().optional().describe("Scope of coverage for this party")
         })
       ).optional().describe("Named parties (additional insureds, loss payees, etc.)"),
-      keyTerms: z30.array(z30.string()).optional().describe("Key terms or notable provisions in the endorsement"),
-      premiumImpact: z30.string().optional().describe("Additional premium or credit"),
-      excerpt: z30.string().optional().describe("Short source excerpt, not full verbatim text"),
-      content: z30.string().optional().describe("Legacy fallback only; do not return full text when sourceSpanIds are available"),
-      pageStart: z30.number().describe("Starting page number of this endorsement"),
-      pageEnd: z30.number().optional().describe("Ending page number of this endorsement"),
-      sourceSpanIds: z30.array(z30.string()).optional().describe("Source span IDs grounding this endorsement"),
-      sourceTextHash: z30.string().optional().describe("Hash of the source text when available")
+      keyTerms: z31.array(z31.string()).optional().describe("Key terms or notable provisions in the endorsement"),
+      premiumImpact: z31.string().optional().describe("Additional premium or credit"),
+      excerpt: z31.string().optional().describe("Short source excerpt, not full verbatim text"),
+      content: z31.string().optional().describe("Legacy fallback only; do not return full text when sourceSpanIds are available"),
+      pageStart: z31.number().describe("Starting page number of this endorsement"),
+      pageEnd: z31.number().optional().describe("Ending page number of this endorsement"),
+      sourceSpanIds: z31.array(z31.string()).optional().describe("Source span IDs grounding this endorsement"),
+      sourceTextHash: z31.string().optional().describe("Hash of the source text when available")
     })
   ).describe("All endorsements found in the document")
 });
@@ -11886,20 +12860,20 @@ Return JSON only.`;
 }
 
 // src/prompts/extractors/exclusions.ts
-import { z as z31 } from "zod";
-var ExclusionsSchema = z31.object({
-  exclusions: z31.array(
-    z31.object({
-      name: z31.string().describe("Exclusion title or short description"),
-      formNumber: z31.string().optional().describe("Form number if part of a named endorsement"),
-      excludedPerils: z31.array(z31.string()).optional().describe("Specific perils excluded"),
-      isAbsolute: z31.boolean().optional().describe("Whether the exclusion is absolute (no exceptions)"),
-      exceptions: z31.array(z31.string()).optional().describe("Exceptions to the exclusion, if any"),
-      buybackAvailable: z31.boolean().optional().describe("Whether coverage can be bought back via endorsement"),
-      buybackEndorsement: z31.string().optional().describe("Form number of the buyback endorsement if available"),
-      appliesTo: z31.array(z31.string()).optional().describe("Policy types this exclusion applies to"),
-      content: z31.string().describe("Full verbatim exclusion text"),
-      pageNumber: z31.number().optional().describe("Page number where exclusion appears")
+import { z as z32 } from "zod";
+var ExclusionsSchema = z32.object({
+  exclusions: z32.array(
+    z32.object({
+      name: z32.string().describe("Exclusion title or short description"),
+      formNumber: z32.string().optional().describe("Form number if part of a named endorsement"),
+      excludedPerils: z32.array(z32.string()).optional().describe("Specific perils excluded"),
+      isAbsolute: z32.boolean().optional().describe("Whether the exclusion is absolute (no exceptions)"),
+      exceptions: z32.array(z32.string()).optional().describe("Exceptions to the exclusion, if any"),
+      buybackAvailable: z32.boolean().optional().describe("Whether coverage can be bought back via endorsement"),
+      buybackEndorsement: z32.string().optional().describe("Form number of the buyback endorsement if available"),
+      appliesTo: z32.array(z32.string()).optional().describe("Policy types this exclusion applies to"),
+      content: z32.string().describe("Full verbatim exclusion text"),
+      pageNumber: z32.number().optional().describe("Page number where exclusion appears")
     })
   ).describe("All exclusions found in the document")
 });
@@ -11935,12 +12909,12 @@ Return JSON only.`;
 }
 
 // src/prompts/extractors/conditions.ts
-import { z as z32 } from "zod";
-var ConditionsSchema = z32.object({
-  conditions: z32.array(
-    z32.object({
-      name: z32.string().describe("Condition title"),
-      conditionType: z32.enum([
+import { z as z33 } from "zod";
+var ConditionsSchema = z33.object({
+  conditions: z33.array(
+    z33.object({
+      name: z33.string().describe("Condition title"),
+      conditionType: z33.enum([
         "duties_after_loss",
         "notice_requirements",
         "other_insurance",
@@ -11959,14 +12933,14 @@ var ConditionsSchema = z32.object({
         "separation_of_insureds",
         "other"
       ]).describe("Condition category"),
-      content: z32.string().describe("Full verbatim condition text"),
-      keyValues: z32.array(
-        z32.object({
-          key: z32.string().describe("Key name (e.g. 'noticePeriod', 'suitDeadline')"),
-          value: z32.string().describe("Value (e.g. '30 days', '2 years')")
+      content: z33.string().describe("Full verbatim condition text"),
+      keyValues: z33.array(
+        z33.object({
+          key: z33.string().describe("Key name (e.g. 'noticePeriod', 'suitDeadline')"),
+          value: z33.string().describe("Value (e.g. '30 days', '2 years')")
         })
       ).optional().describe("Key values extracted from the condition (notice periods, deadlines, etc.)"),
-      pageNumber: z32.number().optional().describe("Page number where condition appears")
+      pageNumber: z33.number().optional().describe("Page number where condition appears")
     })
   ).describe("All policy conditions found in the document")
 });
@@ -12004,34 +12978,34 @@ Return JSON only.`;
 }
 
 // src/prompts/extractors/premium-breakdown.ts
-import { z as z33 } from "zod";
-var PremiumBreakdownSchema = z33.object({
-  premium: z33.string().optional().describe("Total premium amount, e.g. '$5,000'"),
-  premiumAmount: z33.number().optional().describe("Total premium as a plain number with no currency symbols or commas"),
-  totalCost: z33.string().optional().describe("Total cost including taxes and fees, e.g. '$5,250'"),
-  totalCostAmount: z33.number().optional().describe("Total cost as a plain number with no currency symbols or commas"),
-  premiumBreakdown: z33.array(
-    z33.object({
-      line: z33.string().describe("Coverage line name"),
-      amount: z33.string().describe("Premium amount for this line"),
-      amountValue: z33.number().optional().describe("Premium amount as a plain number with no currency symbols or commas")
+import { z as z34 } from "zod";
+var PremiumBreakdownSchema = z34.object({
+  premium: z34.string().optional().describe("Total premium amount, e.g. '$5,000'"),
+  premiumAmount: z34.number().optional().describe("Total premium as a plain number with no currency symbols or commas"),
+  totalCost: z34.string().optional().describe("Total cost including taxes and fees, e.g. '$5,250'"),
+  totalCostAmount: z34.number().optional().describe("Total cost as a plain number with no currency symbols or commas"),
+  premiumBreakdown: z34.array(
+    z34.object({
+      line: z34.string().describe("Coverage line name"),
+      amount: z34.string().describe("Premium amount for this line"),
+      amountValue: z34.number().optional().describe("Premium amount as a plain number with no currency symbols or commas")
     })
   ).optional().describe("Per-coverage-line premium breakdown"),
-  taxesAndFees: z33.array(
-    z33.object({
-      name: z33.string().describe("Fee or tax name"),
-      amount: z33.string().describe("Dollar amount"),
-      amountValue: z33.number().optional().describe("Fee or tax amount as a plain number with no currency symbols or commas"),
-      type: z33.enum(["tax", "fee", "surcharge", "assessment"]).optional().describe("Fee category")
+  taxesAndFees: z34.array(
+    z34.object({
+      name: z34.string().describe("Fee or tax name"),
+      amount: z34.string().describe("Dollar amount"),
+      amountValue: z34.number().optional().describe("Fee or tax amount as a plain number with no currency symbols or commas"),
+      type: z34.enum(["tax", "fee", "surcharge", "assessment"]).optional().describe("Fee category")
     })
   ).optional().describe("Taxes, fees, surcharges, and assessments"),
-  minimumPremium: z33.string().optional().describe("Minimum premium if stated"),
-  minimumPremiumAmount: z33.number().optional().describe("Minimum premium as a plain number when the source states a fixed amount"),
-  depositPremium: z33.string().optional().describe("Deposit premium if stated"),
-  depositPremiumAmount: z33.number().optional().describe("Deposit premium as a plain number when the source states a fixed amount"),
-  paymentPlan: z33.string().optional().describe("Payment plan description"),
-  auditType: z33.enum(["annual", "semi_annual", "quarterly", "monthly", "final", "self"]).optional().describe("Premium audit type"),
-  ratingBasis: z33.string().optional().describe("Rating basis, e.g. payroll, revenue, area, units")
+  minimumPremium: z34.string().optional().describe("Minimum premium if stated"),
+  minimumPremiumAmount: z34.number().optional().describe("Minimum premium as a plain number when the source states a fixed amount"),
+  depositPremium: z34.string().optional().describe("Deposit premium if stated"),
+  depositPremiumAmount: z34.number().optional().describe("Deposit premium as a plain number when the source states a fixed amount"),
+  paymentPlan: z34.string().optional().describe("Payment plan description"),
+  auditType: z34.enum(["annual", "semi_annual", "quarterly", "monthly", "final", "self"]).optional().describe("Premium audit type"),
+  ratingBasis: z34.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.
@@ -12053,14 +13027,14 @@ Return JSON only.`;
 }
 
 // src/prompts/extractors/declarations.ts
-import { z as z34 } from "zod";
-var DeclarationsFieldSchema = z34.object({
-  field: z34.string().describe("Descriptive field name (e.g. 'policyNumber', 'effectiveDate', 'coverageALimit')"),
-  value: z34.string().describe("Extracted value exactly as it appears in the document"),
-  section: z34.string().optional().describe("Section or grouping this field belongs to (e.g. 'Coverage Limits', 'Vehicle Schedule')")
+import { z as z35 } from "zod";
+var DeclarationsFieldSchema = z35.object({
+  field: z35.string().describe("Descriptive field name (e.g. 'policyNumber', 'effectiveDate', 'coverageALimit')"),
+  value: z35.string().describe("Extracted value exactly as it appears in the document"),
+  section: z35.string().optional().describe("Section or grouping this field belongs to (e.g. 'Coverage Limits', 'Vehicle Schedule')")
 });
-var DeclarationsExtractSchema = z34.object({
-  fields: z34.array(DeclarationsFieldSchema).describe("All declarations page fields extracted as key-value pairs. Structure varies by line of business.")
+var DeclarationsExtractSchema = z35.object({
+  fields: z35.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.
@@ -12100,21 +13074,21 @@ Preserve original values exactly as they appear. Return JSON only.`;
 }
 
 // src/prompts/extractors/loss-history.ts
-import { z as z35 } from "zod";
-var LossHistorySchema = z35.object({
-  lossSummary: z35.string().optional().describe("Summary of loss history, e.g. '3 claims in past 5 years totaling $125,000'"),
-  individualClaims: z35.array(
-    z35.object({
-      date: z35.string().optional().describe("Date of loss or claim"),
-      type: z35.string().optional().describe("Type of claim, e.g. 'property damage', 'bodily injury'"),
-      description: z35.string().optional().describe("Brief description of the claim"),
-      amountPaid: z35.string().optional().describe("Amount paid"),
-      amountReserved: z35.string().optional().describe("Amount reserved"),
-      status: z35.enum(["open", "closed", "reopened"]).optional().describe("Claim status"),
-      claimNumber: z35.string().optional().describe("Claim reference number")
+import { z as z36 } from "zod";
+var LossHistorySchema = z36.object({
+  lossSummary: z36.string().optional().describe("Summary of loss history, e.g. '3 claims in past 5 years totaling $125,000'"),
+  individualClaims: z36.array(
+    z36.object({
+      date: z36.string().optional().describe("Date of loss or claim"),
+      type: z36.string().optional().describe("Type of claim, e.g. 'property damage', 'bodily injury'"),
+      description: z36.string().optional().describe("Brief description of the claim"),
+      amountPaid: z36.string().optional().describe("Amount paid"),
+      amountReserved: z36.string().optional().describe("Amount reserved"),
+      status: z36.enum(["open", "closed", "reopened"]).optional().describe("Claim status"),
+      claimNumber: z36.string().optional().describe("Claim reference number")
     })
   ).optional().describe("Individual claim records"),
-  experienceMod: z35.string().optional().describe("Experience modification factor for workers comp, e.g. '0.85'")
+  experienceMod: z36.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.
@@ -12131,21 +13105,21 @@ Return JSON only.`;
 }
 
 // src/prompts/extractors/sections.ts
-import { z as z36 } from "zod";
-var SubsectionSchema2 = z36.object({
-  title: z36.string().describe("Subsection title"),
-  sectionNumber: z36.string().optional().describe("Subsection number"),
-  pageNumber: z36.number().optional().describe("Page number"),
-  excerpt: z36.string().optional().describe("Short source excerpt, not full verbatim text"),
-  content: z36.string().optional().describe("Legacy fallback only; do not return full text when sourceSpanIds are available"),
-  sourceSpanIds: z36.array(z36.string()).optional().describe("Source span IDs grounding this subsection"),
-  sourceTextHash: z36.string().optional().describe("Hash of the source text when available")
-});
-var SectionsSchema = z36.object({
-  sections: z36.array(
-    z36.object({
-      title: z36.string().describe("Section title"),
-      type: z36.enum([
+import { z as z37 } from "zod";
+var SubsectionSchema2 = z37.object({
+  title: z37.string().describe("Subsection title"),
+  sectionNumber: z37.string().optional().describe("Subsection number"),
+  pageNumber: z37.number().optional().describe("Page number"),
+  excerpt: z37.string().optional().describe("Short source excerpt, not full verbatim text"),
+  content: z37.string().optional().describe("Legacy fallback only; do not return full text when sourceSpanIds are available"),
+  sourceSpanIds: z37.array(z37.string()).optional().describe("Source span IDs grounding this subsection"),
+  sourceTextHash: z37.string().optional().describe("Hash of the source text when available")
+});
+var SectionsSchema = z37.object({
+  sections: z37.array(
+    z37.object({
+      title: z37.string().describe("Section title"),
+      type: z37.enum([
         "declarations",
         "insuring_agreement",
         "policy_form",
@@ -12160,13 +13134,13 @@ var SectionsSchema = z36.object({
         "regulatory",
         "other"
       ]).describe("Section type classification"),
-      excerpt: z36.string().optional().describe("Short source excerpt, not full verbatim text"),
-      content: z36.string().optional().describe("Legacy fallback only; do not return full text when sourceSpanIds are available"),
-      pageStart: z36.number().describe("Starting page number"),
-      pageEnd: z36.number().optional().describe("Ending page number"),
-      sourceSpanIds: z36.array(z36.string()).optional().describe("Source span IDs grounding this section"),
-      sourceTextHash: z36.string().optional().describe("Hash of the source text when available"),
-      subsections: z36.array(SubsectionSchema2).optional().describe("Subsections within this section")
+      excerpt: z37.string().optional().describe("Short source excerpt, not full verbatim text"),
+      content: z37.string().optional().describe("Legacy fallback only; do not return full text when sourceSpanIds are available"),
+      pageStart: z37.number().describe("Starting page number"),
+      pageEnd: z37.number().optional().describe("Ending page number"),
+      sourceSpanIds: z37.array(z37.string()).optional().describe("Source span IDs grounding this section"),
+      sourceTextHash: z37.string().optional().describe("Hash of the source text when available"),
+      subsections: z37.array(SubsectionSchema2).optional().describe("Subsections within this section")
     })
   ).describe("All document sections")
 });
@@ -12200,20 +13174,20 @@ Return JSON only.`;
 }
 
 // src/prompts/extractors/supplementary.ts
-import { z as z37 } from "zod";
-var AuxiliaryFactSchema2 = z37.object({
-  key: z37.string().describe("Normalized machine-readable fact key, e.g. 'policyholder_age' or 'insured_name'"),
-  value: z37.string().describe("Concrete extracted fact value"),
-  subject: z37.string().optional().describe("Person, entity, vehicle, property, or schedule item this fact belongs to"),
-  context: z37.string().optional().describe("Short disambiguating context, such as 'Driver Schedule' or 'Named Insured'")
-});
-var SupplementarySchema = z37.object({
-  regulatoryContacts: z37.array(ContactSchema).optional().describe("Regulatory body contacts (state department of insurance, ombudsman)"),
-  claimsContacts: z37.array(ContactSchema).optional().describe("Claims reporting contacts and instructions"),
-  thirdPartyAdministrators: z37.array(ContactSchema).optional().describe("Third-party administrators for claims handling"),
-  cancellationNoticeDays: z37.number().optional().describe("Required notice period for cancellation in days"),
-  nonrenewalNoticeDays: z37.number().optional().describe("Required notice period for nonrenewal in days"),
-  auxiliaryFacts: z37.array(AuxiliaryFactSchema2).optional().describe("Additional retrieval-only facts that do not fit the strict primary schema")
+import { z as z38 } from "zod";
+var AuxiliaryFactSchema2 = z38.object({
+  key: z38.string().describe("Normalized machine-readable fact key, e.g. 'policyholder_age' or 'insured_name'"),
+  value: z38.string().describe("Concrete extracted fact value"),
+  subject: z38.string().optional().describe("Person, entity, vehicle, property, or schedule item this fact belongs to"),
+  context: z38.string().optional().describe("Short disambiguating context, such as 'Driver Schedule' or 'Named Insured'")
+});
+var SupplementarySchema = z38.object({
+  regulatoryContacts: z38.array(ContactSchema).optional().describe("Regulatory body contacts (state department of insurance, ombudsman)"),
+  claimsContacts: z38.array(ContactSchema).optional().describe("Claims reporting contacts and instructions"),
+  thirdPartyAdministrators: z38.array(ContactSchema).optional().describe("Third-party administrators for claims handling"),
+  cancellationNoticeDays: z38.number().optional().describe("Required notice period for cancellation in days"),
+  nonrenewalNoticeDays: z38.number().optional().describe("Required notice period for nonrenewal in days"),
+  auxiliaryFacts: z38.array(AuxiliaryFactSchema2).optional().describe("Additional retrieval-only facts that do not fit the strict primary schema")
 });
 function buildSupplementaryPrompt(alreadyExtractedSummary) {
   const exclusionBlock = alreadyExtractedSummary ? `
@@ -12253,17 +13227,17 @@ Return JSON only.`;
 }
 
 // src/prompts/extractors/definitions.ts
-import { z as z38 } from "zod";
-var DefinitionsSchema = z38.object({
-  definitions: z38.array(
-    z38.object({
-      term: z38.string().describe("Defined term exactly as shown in the document"),
-      definition: z38.string().describe("Full verbatim definition text, preserving original wording"),
-      pageNumber: z38.number().optional().describe("Original document page number"),
-      formNumber: z38.string().optional().describe("Form number where this definition appears"),
-      formTitle: z38.string().optional().describe("Form title where this definition appears"),
-      sectionRef: z38.string().optional().describe("Definition section heading or subsection reference"),
-      originalContent: z38.string().optional().describe("Short verbatim source snippet containing the term and definition")
+import { z as z39 } from "zod";
+var DefinitionsSchema = z39.object({
+  definitions: z39.array(
+    z39.object({
+      term: z39.string().describe("Defined term exactly as shown in the document"),
+      definition: z39.string().describe("Full verbatim definition text, preserving original wording"),
+      pageNumber: z39.number().optional().describe("Original document page number"),
+      formNumber: z39.string().optional().describe("Form number where this definition appears"),
+      formTitle: z39.string().optional().describe("Form title where this definition appears"),
+      sectionRef: z39.string().optional().describe("Definition section heading or subsection reference"),
+      originalContent: z39.string().optional().describe("Short verbatim source snippet containing the term and definition")
     })
   ).describe("All substantive insurance definitions found in the document")
 });
@@ -12297,22 +13271,22 @@ Return JSON only.`;
 }
 
 // src/prompts/extractors/covered-reasons.ts
-import { z as z39 } from "zod";
-var CoveredReasonsSchema = z39.object({
-  coveredReasons: z39.array(
-    z39.object({
-      coverageName: z39.string().describe("Coverage, coverage part, or form this covered reason belongs to"),
-      reasonNumber: z39.string().optional().describe("Source number or letter for the covered reason, if shown"),
-      title: z39.string().optional().describe("Covered reason title, peril, cause of loss, trigger, or short name"),
-      content: z39.string().describe("Full verbatim covered-reason or insuring-agreement text"),
-      conditions: z39.array(z39.string()).optional().describe("Conditions, timing rules, documentation requirements, or prerequisites attached to this covered reason"),
-      exceptions: z39.array(z39.string()).optional().describe("Exceptions or limitations attached to this covered reason"),
-      appliesTo: z39.array(z39.string()).optional().describe("Covered property, persons, autos, locations, operations, or coverage parts this reason applies to"),
-      pageNumber: z39.number().optional().describe("Original document page number"),
-      formNumber: z39.string().optional().describe("Form number where this covered reason appears"),
-      formTitle: z39.string().optional().describe("Form title where this covered reason appears"),
-      sectionRef: z39.string().optional().describe("Section heading where this covered reason appears"),
-      originalContent: z39.string().optional().describe("Short verbatim source snippet used for this covered reason")
+import { z as z40 } from "zod";
+var CoveredReasonsSchema = z40.object({
+  coveredReasons: z40.array(
+    z40.object({
+      coverageName: z40.string().describe("Coverage, coverage part, or form this covered reason belongs to"),
+      reasonNumber: z40.string().optional().describe("Source number or letter for the covered reason, if shown"),
+      title: z40.string().optional().describe("Covered reason title, peril, cause of loss, trigger, or short name"),
+      content: z40.string().describe("Full verbatim covered-reason or insuring-agreement text"),
+      conditions: z40.array(z40.string()).optional().describe("Conditions, timing rules, documentation requirements, or prerequisites attached to this covered reason"),
+      exceptions: z40.array(z40.string()).optional().describe("Exceptions or limitations attached to this covered reason"),
+      appliesTo: z40.array(z40.string()).optional().describe("Covered property, persons, autos, locations, operations, or coverage parts this reason applies to"),
+      pageNumber: z40.number().optional().describe("Original document page number"),
+      formNumber: z40.string().optional().describe("Form number where this covered reason appears"),
+      formTitle: z40.string().optional().describe("Form title where this covered reason appears"),
+      sectionRef: z40.string().optional().describe("Section heading where this covered reason appears"),
+      originalContent: z40.string().optional().describe("Short verbatim source snippet used for this covered reason")
     })
   ).describe("Covered causes, perils, triggers, or reasons that affirmatively grant coverage")
 });
@@ -13304,10 +14278,15 @@ export {
   NamedInsuredSchema,
   OperationalAddressSchema,
   OperationalCoverageLineSchema,
+  OperationalCoverageScheduleItemSchema,
+  OperationalCoverageScheduleSchema,
+  OperationalCoverageScheduleValueSchema,
   OperationalCoverageTermSchema,
   OperationalDeclarationFactSchema,
   OperationalEndorsementSupportSchema,
   OperationalPartySchema,
+  OperationalPremiumLineSchema,
+  OperationalTaxFeeItemSchema,
   PERSONAL_AUTO_USAGES,
   PERSONAL_LOB_CODES,
   PET_SPECIES,
@@ -13494,6 +14473,8 @@ export {
   proposeContextWrites,
   resolveModelBudget,
   resolveOperationalProfileLinesOfBusiness,
+  runCoverageRecovery,
+  runSourceTreeExtraction,
   safeGenerateObject,
   sanitizeNulls,
   scoreCaseProposal,