@claritylabs/cl-sdk 4.3.0 → 4.4.0

package/dist/index.js

@@ -179,10 +179,15 @@ __export(src_exports, {
   NamedInsuredSchema: () => NamedInsuredSchema,
   OperationalAddressSchema: () => OperationalAddressSchema,
   OperationalCoverageLineSchema: () => OperationalCoverageLineSchema,
+  OperationalCoverageScheduleItemSchema: () => OperationalCoverageScheduleItemSchema,
+  OperationalCoverageScheduleSchema: () => OperationalCoverageScheduleSchema,
+  OperationalCoverageScheduleValueSchema: () => OperationalCoverageScheduleValueSchema,
   OperationalCoverageTermSchema: () => OperationalCoverageTermSchema,
   OperationalDeclarationFactSchema: () => OperationalDeclarationFactSchema,
   OperationalEndorsementSupportSchema: () => OperationalEndorsementSupportSchema,
   OperationalPartySchema: () => OperationalPartySchema,
+  OperationalPremiumLineSchema: () => OperationalPremiumLineSchema,
+  OperationalTaxFeeItemSchema: () => OperationalTaxFeeItemSchema,
   PERSONAL_AUTO_USAGES: () => PERSONAL_AUTO_USAGES,
   PERSONAL_LOB_CODES: () => PERSONAL_LOB_CODES,
   PET_SPECIES: () => PET_SPECIES,
@@ -369,6 +374,8 @@ __export(src_exports, {
   proposeContextWrites: () => proposeContextWrites,
   resolveModelBudget: () => resolveModelBudget,
   resolveOperationalProfileLinesOfBusiness: () => resolveOperationalProfileLinesOfBusiness,
+  runCoverageRecovery: () => runCoverageRecovery,
+  runSourceTreeExtraction: () => runSourceTreeExtraction,
   safeGenerateObject: () => safeGenerateObject,
   sanitizeNulls: () => sanitizeNulls,
   scoreCaseProposal: () => scoreCaseProposal,
@@ -2009,251 +2016,541 @@ var DeclarationsSchema = import_zod16.z.discriminatedUnion("line", [
 ]);
 
 // src/schemas/document.ts
+var import_zod18 = require("zod");
+
+// src/source/schemas.ts
 var import_zod17 = require("zod");
-var SubsectionSchema = import_zod17.z.object({
-  title: import_zod17.z.string(),
-  sectionNumber: import_zod17.z.string().optional(),
-  pageNumber: import_zod17.z.number().optional(),
-  excerpt: import_zod17.z.string().optional(),
-  content: import_zod17.z.string().optional(),
-  documentNodeId: import_zod17.z.string().optional(),
-  sourceSpanIds: import_zod17.z.array(import_zod17.z.string()).optional(),
-  sourceTextHash: import_zod17.z.string().optional()
-});
-var SectionSchema = import_zod17.z.object({
+var SourceSpanKindSchema = import_zod17.z.enum([
+  "pdf_text",
+  "pdf_image",
+  "html",
+  "markdown",
+  "plain_text",
+  "structured_field"
+]);
+var SourceSpanUnitSchema = import_zod17.z.enum([
+  "page",
+  "section",
+  "table",
+  "table_row",
+  "table_cell",
+  "key_value",
+  "text"
+]);
+var SourceKindSchema = import_zod17.z.enum([
+  "policy_pdf",
+  "application_pdf",
+  "email",
+  "attachment",
+  "manual_note"
+]);
+var SourceSpanBBoxSchema = import_zod17.z.object({
+  page: import_zod17.z.number().int().positive(),
+  x: import_zod17.z.number(),
+  y: import_zod17.z.number(),
+  width: import_zod17.z.number(),
+  height: import_zod17.z.number()
+});
+var SourceSpanLocationSchema = import_zod17.z.object({
+  page: import_zod17.z.number().int().positive().optional(),
+  startPage: import_zod17.z.number().int().positive().optional(),
+  endPage: import_zod17.z.number().int().positive().optional(),
+  charStart: import_zod17.z.number().int().nonnegative().optional(),
+  charEnd: import_zod17.z.number().int().nonnegative().optional(),
+  lineStart: import_zod17.z.number().int().positive().optional(),
+  lineEnd: import_zod17.z.number().int().positive().optional(),
+  fieldPath: import_zod17.z.string().optional()
+});
+var SourceSpanTableLocationSchema = import_zod17.z.object({
+  tableId: import_zod17.z.string().optional(),
+  rowIndex: import_zod17.z.number().int().nonnegative().optional(),
+  columnIndex: import_zod17.z.number().int().nonnegative().optional(),
+  columnName: import_zod17.z.string().optional(),
+  rowSpanId: import_zod17.z.string().optional(),
+  tableSpanId: import_zod17.z.string().optional(),
+  isHeader: import_zod17.z.boolean().optional()
+});
+var SourceSpanSchema = import_zod17.z.object({
+  id: import_zod17.z.string().min(1),
+  documentId: import_zod17.z.string().min(1),
+  sourceKind: SourceKindSchema.optional(),
+  chunkId: import_zod17.z.string().optional(),
+  kind: SourceSpanKindSchema,
+  text: import_zod17.z.string(),
+  hash: import_zod17.z.string().min(1),
+  textHash: import_zod17.z.string().optional(),
+  pageStart: import_zod17.z.number().int().positive().optional(),
+  pageEnd: import_zod17.z.number().int().positive().optional(),
+  sectionId: import_zod17.z.string().optional(),
+  formNumber: import_zod17.z.string().optional(),
+  sourceUnit: SourceSpanUnitSchema.optional(),
+  parentSpanId: import_zod17.z.string().optional(),
+  table: SourceSpanTableLocationSchema.optional(),
+  bbox: import_zod17.z.array(SourceSpanBBoxSchema).optional(),
+  location: SourceSpanLocationSchema.optional(),
+  metadata: import_zod17.z.record(import_zod17.z.string(), import_zod17.z.string()).optional()
+});
+var SourceSpanRefSchema = import_zod17.z.object({
+  sourceSpanId: import_zod17.z.string().min(1),
+  documentId: import_zod17.z.string().min(1).optional(),
+  chunkId: import_zod17.z.string().optional(),
+  quote: import_zod17.z.string().optional(),
+  hash: import_zod17.z.string().optional(),
+  location: SourceSpanLocationSchema.optional()
+});
+var SourceChunkSchema = import_zod17.z.object({
+  id: import_zod17.z.string().min(1),
+  documentId: import_zod17.z.string().min(1),
+  sourceSpanIds: import_zod17.z.array(import_zod17.z.string().min(1)),
+  text: import_zod17.z.string(),
+  textHash: import_zod17.z.string().min(1),
+  pageStart: import_zod17.z.number().int().positive().optional(),
+  pageEnd: import_zod17.z.number().int().positive().optional(),
+  metadata: import_zod17.z.record(import_zod17.z.string(), import_zod17.z.string()).default({})
+});
+var DocumentSourceNodeKindSchema = import_zod17.z.enum([
+  "document",
+  "page_group",
+  "page",
+  "form",
+  "endorsement",
+  "section",
+  "schedule",
+  "clause",
+  "table",
+  "table_row",
+  "table_cell",
+  "text"
+]);
+var DocumentSourceNodeSchema = import_zod17.z.object({
+  id: import_zod17.z.string().min(1),
+  documentId: import_zod17.z.string().min(1),
+  parentId: import_zod17.z.string().optional(),
+  kind: DocumentSourceNodeKindSchema,
   title: import_zod17.z.string(),
-  sectionNumber: import_zod17.z.string().optional(),
-  pageStart: import_zod17.z.number(),
-  pageEnd: import_zod17.z.number().optional(),
-  type: import_zod17.z.string(),
-  coverageType: import_zod17.z.string().optional(),
-  excerpt: import_zod17.z.string().optional(),
-  content: import_zod17.z.string().optional(),
-  subsections: import_zod17.z.array(SubsectionSchema).optional(),
-  recordId: import_zod17.z.string().optional(),
-  documentNodeId: import_zod17.z.string().optional(),
-  sourceSpanIds: import_zod17.z.array(import_zod17.z.string()).optional(),
-  sourceTextHash: import_zod17.z.string().optional()
-});
-var SubjectivitySchema = import_zod17.z.object({
   description: import_zod17.z.string(),
-  category: import_zod17.z.string().optional()
+  textExcerpt: import_zod17.z.string().optional(),
+  sourceSpanIds: import_zod17.z.array(import_zod17.z.string().min(1)),
+  pageStart: import_zod17.z.number().int().positive().optional(),
+  pageEnd: import_zod17.z.number().int().positive().optional(),
+  bbox: import_zod17.z.array(SourceSpanBBoxSchema).optional(),
+  order: import_zod17.z.number().int().nonnegative(),
+  path: import_zod17.z.string(),
+  metadata: import_zod17.z.record(import_zod17.z.string(), import_zod17.z.unknown()).optional()
+});
+var SourceBackedValueSchema = import_zod17.z.object({
+  value: import_zod17.z.string(),
+  normalizedValue: import_zod17.z.string().optional(),
+  confidence: import_zod17.z.enum(["low", "medium", "high"]).default("medium"),
+  sourceNodeIds: import_zod17.z.array(import_zod17.z.string().min(1)).default([]),
+  sourceSpanIds: import_zod17.z.array(import_zod17.z.string().min(1)).default([])
+});
+var OperationalAddressSchema = import_zod17.z.object({
+  street1: import_zod17.z.string().optional(),
+  street2: import_zod17.z.string().optional(),
+  city: import_zod17.z.string().optional(),
+  state: import_zod17.z.string().optional(),
+  zip: import_zod17.z.string().optional(),
+  country: import_zod17.z.string().optional(),
+  formatted: import_zod17.z.string().optional()
+});
+var OperationalDeclarationFactSchema = import_zod17.z.object({
+  field: import_zod17.z.enum([
+    "namedInsured",
+    "mailingAddress",
+    "dba",
+    "entityType",
+    "taxId",
+    "additionalNamedInsured",
+    "policyNumber",
+    "insurer",
+    "broker",
+    "effectiveDate",
+    "expirationDate",
+    "premium",
+    "other"
+  ]),
+  label: import_zod17.z.string().optional(),
+  value: import_zod17.z.string(),
+  normalizedValue: import_zod17.z.string().optional(),
+  valueKind: import_zod17.z.enum(["string", "number", "date", "money", "address", "list", "unknown"]).default("string"),
+  address: OperationalAddressSchema.optional(),
+  confidence: import_zod17.z.enum(["low", "medium", "high"]).default("medium"),
+  sourceNodeIds: import_zod17.z.array(import_zod17.z.string().min(1)).default([]),
+  sourceSpanIds: import_zod17.z.array(import_zod17.z.string().min(1)).default([])
 });
-var UnderwritingConditionSchema = import_zod17.z.object({
-  description: import_zod17.z.string()
+var OperationalCoverageTermSchema = import_zod17.z.object({
+  kind: import_zod17.z.enum([
+    "each_claim_limit",
+    "each_occurrence_limit",
+    "each_loss_limit",
+    "aggregate_limit",
+    "sublimit",
+    "retention",
+    "deductible",
+    "retroactive_date",
+    "premium",
+    "other"
+  ]).default("other"),
+  label: import_zod17.z.string(),
+  value: import_zod17.z.string(),
+  amount: import_zod17.z.number().optional(),
+  appliesTo: import_zod17.z.string().optional(),
+  sourceNodeIds: import_zod17.z.array(import_zod17.z.string().min(1)).default([]),
+  sourceSpanIds: import_zod17.z.array(import_zod17.z.string().min(1)).default([])
 });
-var PremiumLineSchema = import_zod17.z.object({
+var OperationalCoverageLineSchema = import_zod17.z.object({
+  name: import_zod17.z.string(),
+  lineOfBusiness: AcordLobCodeSchema.optional(),
+  coverageCode: import_zod17.z.string().optional(),
+  limit: import_zod17.z.string().optional(),
+  deductible: import_zod17.z.string().optional(),
+  premium: import_zod17.z.string().optional(),
+  retroactiveDate: import_zod17.z.string().optional(),
+  formNumber: import_zod17.z.string().optional(),
+  sectionRef: import_zod17.z.string().optional(),
+  endorsementNumber: import_zod17.z.string().optional(),
+  limits: import_zod17.z.array(OperationalCoverageTermSchema).default([]),
+  sourceNodeIds: import_zod17.z.array(import_zod17.z.string().min(1)).default([]),
+  sourceSpanIds: import_zod17.z.array(import_zod17.z.string().min(1)).default([])
+});
+var OperationalCoverageScheduleValueSchema = import_zod17.z.object({
+  label: import_zod17.z.string(),
+  value: import_zod17.z.string()
+});
+var OperationalCoverageScheduleItemSchema = import_zod17.z.object({
+  label: import_zod17.z.string(),
+  description: import_zod17.z.string().optional(),
+  values: import_zod17.z.array(OperationalCoverageScheduleValueSchema).default([]),
+  sourceSpanIds: import_zod17.z.array(import_zod17.z.string().min(1)).default([])
+});
+var OperationalCoverageScheduleSchema = import_zod17.z.object({
+  name: import_zod17.z.string(),
+  kind: import_zod17.z.enum(["vehicle", "property", "location", "other"]),
+  description: import_zod17.z.string().optional(),
+  items: import_zod17.z.array(OperationalCoverageScheduleItemSchema).default([]),
+  sourceSpanIds: import_zod17.z.array(import_zod17.z.string().min(1)).default([]),
+  pageStart: import_zod17.z.number().int().positive().optional(),
+  pageEnd: import_zod17.z.number().int().positive().optional()
+});
+var OperationalPremiumLineSchema = import_zod17.z.object({
   line: import_zod17.z.string(),
   amount: import_zod17.z.string(),
   amountValue: import_zod17.z.number().optional(),
-  documentNodeId: import_zod17.z.string().optional(),
-  sourceSpanIds: import_zod17.z.array(import_zod17.z.string()).optional(),
-  sourceTextHash: import_zod17.z.string().optional()
+  sourceNodeIds: import_zod17.z.array(import_zod17.z.string().min(1)).default([]),
+  sourceSpanIds: import_zod17.z.array(import_zod17.z.string().min(1)).default([])
 });
-var AuxiliaryFactSchema = import_zod17.z.object({
-  key: import_zod17.z.string(),
-  value: import_zod17.z.string(),
-  subject: import_zod17.z.string().optional(),
-  context: import_zod17.z.string().optional(),
-  documentNodeId: import_zod17.z.string().optional(),
-  sourceSpanIds: import_zod17.z.array(import_zod17.z.string()).optional(),
-  sourceTextHash: import_zod17.z.string().optional()
-});
-var DefinitionSchema = import_zod17.z.object({
-  term: import_zod17.z.string(),
-  definition: import_zod17.z.string(),
-  pageNumber: import_zod17.z.number().optional(),
-  formNumber: import_zod17.z.string().optional(),
-  formTitle: import_zod17.z.string().optional(),
-  sectionRef: import_zod17.z.string().optional(),
-  originalContent: import_zod17.z.string().optional(),
-  recordId: import_zod17.z.string().optional(),
-  documentNodeId: import_zod17.z.string().optional(),
-  sourceSpanIds: import_zod17.z.array(import_zod17.z.string()).optional(),
-  sourceTextHash: import_zod17.z.string().optional()
-});
-var CoveredReasonSchema = import_zod17.z.object({
-  coverageName: import_zod17.z.string(),
-  reasonNumber: import_zod17.z.string().optional(),
-  title: import_zod17.z.string().optional(),
-  content: import_zod17.z.string(),
-  conditions: import_zod17.z.array(import_zod17.z.string()).optional(),
-  exceptions: import_zod17.z.array(import_zod17.z.string()).optional(),
-  appliesTo: import_zod17.z.array(import_zod17.z.string()).optional(),
-  pageNumber: import_zod17.z.number().optional(),
-  formNumber: import_zod17.z.string().optional(),
-  formTitle: import_zod17.z.string().optional(),
-  sectionRef: import_zod17.z.string().optional(),
-  originalContent: import_zod17.z.string().optional(),
-  recordId: import_zod17.z.string().optional(),
-  documentNodeId: import_zod17.z.string().optional(),
-  sourceSpanIds: import_zod17.z.array(import_zod17.z.string()).optional(),
-  sourceTextHash: import_zod17.z.string().optional()
-});
-var DocumentTableOfContentsEntrySchema = import_zod17.z.object({
-  title: import_zod17.z.string(),
-  level: import_zod17.z.number().int().positive().optional(),
-  pageStart: import_zod17.z.number().optional(),
-  pageEnd: import_zod17.z.number().optional(),
-  documentNodeId: import_zod17.z.string().optional(),
-  sourceSpanIds: import_zod17.z.array(import_zod17.z.string()).optional()
-});
-var DocumentPageMapEntrySchema = import_zod17.z.object({
-  page: import_zod17.z.number().int().positive(),
-  label: import_zod17.z.string().optional(),
-  formNumber: import_zod17.z.string().optional(),
-  formTitle: import_zod17.z.string().optional(),
-  sectionTitle: import_zod17.z.string().optional(),
-  extractorNames: import_zod17.z.array(import_zod17.z.string()).optional(),
-  sourceSpanIds: import_zod17.z.array(import_zod17.z.string()).optional()
+var OperationalTaxFeeItemSchema = import_zod17.z.object({
+  name: import_zod17.z.string(),
+  amount: import_zod17.z.string(),
+  amountValue: import_zod17.z.number().optional(),
+  type: import_zod17.z.string().optional(),
+  description: import_zod17.z.string().optional(),
+  sourceNodeIds: import_zod17.z.array(import_zod17.z.string().min(1)).default([]),
+  sourceSpanIds: import_zod17.z.array(import_zod17.z.string().min(1)).default([])
+});
+var OperationalPartySchema = import_zod17.z.object({
+  role: import_zod17.z.string(),
+  name: import_zod17.z.string(),
+  address: OperationalAddressSchema.optional(),
+  sourceNodeIds: import_zod17.z.array(import_zod17.z.string().min(1)).default([]),
+  sourceSpanIds: import_zod17.z.array(import_zod17.z.string().min(1)).default([])
 });
-var DocumentAgentGuidanceSchema = import_zod17.z.object({
+var OperationalEndorsementSupportSchema = import_zod17.z.object({
   kind: import_zod17.z.string(),
-  title: import_zod17.z.string(),
-  detail: import_zod17.z.string(),
-  sourceSpanIds: import_zod17.z.array(import_zod17.z.string()).optional()
-});
-var DocumentMetadataSchema = import_zod17.z.object({
-  sourceTreeVersion: import_zod17.z.string().optional(),
-  sourceTreeCanonical: import_zod17.z.boolean().optional(),
-  formInventory: import_zod17.z.array(FormReferenceSchema).optional(),
-  tableOfContents: import_zod17.z.array(DocumentTableOfContentsEntrySchema).optional(),
-  pageMap: import_zod17.z.array(DocumentPageMapEntrySchema).optional(),
-  agentGuidance: import_zod17.z.array(DocumentAgentGuidanceSchema).optional()
-});
-var DocumentNodeSchema = import_zod17.z.lazy(
-  () => import_zod17.z.object({
-    id: import_zod17.z.string(),
-    title: import_zod17.z.string(),
-    originalTitle: import_zod17.z.string().optional(),
-    type: import_zod17.z.string().optional(),
-    label: import_zod17.z.string().optional(),
-    level: import_zod17.z.number().int().positive().optional(),
-    sectionNumber: import_zod17.z.string().optional(),
-    pageStart: import_zod17.z.number().optional(),
-    pageEnd: import_zod17.z.number().optional(),
-    formNumber: import_zod17.z.string().optional(),
-    formTitle: import_zod17.z.string().optional(),
-    excerpt: import_zod17.z.string().optional(),
-    content: import_zod17.z.string().optional(),
-    interpretationLabels: import_zod17.z.array(import_zod17.z.string()).optional(),
-    sourceSpanIds: import_zod17.z.array(import_zod17.z.string()).optional(),
-    sourceTextHash: import_zod17.z.string().optional(),
-    children: import_zod17.z.array(DocumentNodeSchema).optional()
+  status: import_zod17.z.enum(["supported", "excluded", "requires_review"]),
+  summary: import_zod17.z.string(),
+  sourceNodeIds: import_zod17.z.array(import_zod17.z.string().min(1)).default([]),
+  sourceSpanIds: import_zod17.z.array(import_zod17.z.string().min(1)).default([])
+});
+function legacyOperationalProfileInput(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return value;
+  const record = value;
+  if ("linesOfBusiness" in record) return value;
+  if (!("policyTypes" in record)) return value;
+  return {
+    ...record,
+    linesOfBusiness: record.policyTypes
+  };
+}
+var OperationalLinesOfBusinessSchema = import_zod17.z.preprocess(
+  (value) => Array.isArray(value) ? toLobCodes(value.filter((item) => typeof item === "string")) : void 0,
+  import_zod17.z.array(AcordLobCodeSchema).default(["UN"])
+);
+var PolicyOperationalProfileSchema = import_zod17.z.preprocess(
+  legacyOperationalProfileInput,
+  import_zod17.z.object({
+    documentType: import_zod17.z.enum(["policy", "quote"]).default("policy"),
+    linesOfBusiness: OperationalLinesOfBusinessSchema,
+    policyNumber: SourceBackedValueSchema.optional(),
+    namedInsured: SourceBackedValueSchema.optional(),
+    insurer: SourceBackedValueSchema.optional(),
+    broker: SourceBackedValueSchema.optional(),
+    effectiveDate: SourceBackedValueSchema.optional(),
+    expirationDate: SourceBackedValueSchema.optional(),
+    retroactiveDate: SourceBackedValueSchema.optional(),
+    premium: SourceBackedValueSchema.optional(),
+    operationsDescription: SourceBackedValueSchema.optional(),
+    declarationFacts: import_zod17.z.array(OperationalDeclarationFactSchema).default([]),
+    coverages: import_zod17.z.array(OperationalCoverageLineSchema).default([]),
+    coverageSchedules: import_zod17.z.array(OperationalCoverageScheduleSchema).optional(),
+    premiumBreakdown: import_zod17.z.array(OperationalPremiumLineSchema).optional(),
+    taxesAndFees: import_zod17.z.array(OperationalTaxFeeItemSchema).optional(),
+    totalCost: SourceBackedValueSchema.optional(),
+    parties: import_zod17.z.array(OperationalPartySchema).default([]),
+    endorsementSupport: import_zod17.z.array(OperationalEndorsementSupportSchema).default([]),
+    sourceNodeIds: import_zod17.z.array(import_zod17.z.string().min(1)).default([]),
+    sourceSpanIds: import_zod17.z.array(import_zod17.z.string().min(1)).default([]),
+    warnings: import_zod17.z.array(import_zod17.z.string()).default([])
+  })
+);
+
+// src/schemas/document.ts
+var SubsectionSchema = import_zod18.z.object({
+  title: import_zod18.z.string(),
+  sectionNumber: import_zod18.z.string().optional(),
+  pageNumber: import_zod18.z.number().optional(),
+  excerpt: import_zod18.z.string().optional(),
+  content: import_zod18.z.string().optional(),
+  documentNodeId: import_zod18.z.string().optional(),
+  sourceSpanIds: import_zod18.z.array(import_zod18.z.string()).optional(),
+  sourceTextHash: import_zod18.z.string().optional()
+});
+var SectionSchema = import_zod18.z.object({
+  title: import_zod18.z.string(),
+  sectionNumber: import_zod18.z.string().optional(),
+  pageStart: import_zod18.z.number(),
+  pageEnd: import_zod18.z.number().optional(),
+  type: import_zod18.z.string(),
+  coverageType: import_zod18.z.string().optional(),
+  excerpt: import_zod18.z.string().optional(),
+  content: import_zod18.z.string().optional(),
+  subsections: import_zod18.z.array(SubsectionSchema).optional(),
+  recordId: import_zod18.z.string().optional(),
+  documentNodeId: import_zod18.z.string().optional(),
+  sourceSpanIds: import_zod18.z.array(import_zod18.z.string()).optional(),
+  sourceTextHash: import_zod18.z.string().optional()
+});
+var SubjectivitySchema = import_zod18.z.object({
+  description: import_zod18.z.string(),
+  category: import_zod18.z.string().optional()
+});
+var UnderwritingConditionSchema = import_zod18.z.object({
+  description: import_zod18.z.string()
+});
+var PremiumLineSchema = import_zod18.z.object({
+  line: import_zod18.z.string(),
+  amount: import_zod18.z.string(),
+  amountValue: import_zod18.z.number().optional(),
+  documentNodeId: import_zod18.z.string().optional(),
+  sourceSpanIds: import_zod18.z.array(import_zod18.z.string()).optional(),
+  sourceTextHash: import_zod18.z.string().optional()
+});
+var AuxiliaryFactSchema = import_zod18.z.object({
+  key: import_zod18.z.string(),
+  value: import_zod18.z.string(),
+  subject: import_zod18.z.string().optional(),
+  context: import_zod18.z.string().optional(),
+  documentNodeId: import_zod18.z.string().optional(),
+  sourceSpanIds: import_zod18.z.array(import_zod18.z.string()).optional(),
+  sourceTextHash: import_zod18.z.string().optional()
+});
+var DefinitionSchema = import_zod18.z.object({
+  term: import_zod18.z.string(),
+  definition: import_zod18.z.string(),
+  pageNumber: import_zod18.z.number().optional(),
+  formNumber: import_zod18.z.string().optional(),
+  formTitle: import_zod18.z.string().optional(),
+  sectionRef: import_zod18.z.string().optional(),
+  originalContent: import_zod18.z.string().optional(),
+  recordId: import_zod18.z.string().optional(),
+  documentNodeId: import_zod18.z.string().optional(),
+  sourceSpanIds: import_zod18.z.array(import_zod18.z.string()).optional(),
+  sourceTextHash: import_zod18.z.string().optional()
+});
+var CoveredReasonSchema = import_zod18.z.object({
+  coverageName: import_zod18.z.string(),
+  reasonNumber: import_zod18.z.string().optional(),
+  title: import_zod18.z.string().optional(),
+  content: import_zod18.z.string(),
+  conditions: import_zod18.z.array(import_zod18.z.string()).optional(),
+  exceptions: import_zod18.z.array(import_zod18.z.string()).optional(),
+  appliesTo: import_zod18.z.array(import_zod18.z.string()).optional(),
+  pageNumber: import_zod18.z.number().optional(),
+  formNumber: import_zod18.z.string().optional(),
+  formTitle: import_zod18.z.string().optional(),
+  sectionRef: import_zod18.z.string().optional(),
+  originalContent: import_zod18.z.string().optional(),
+  recordId: import_zod18.z.string().optional(),
+  documentNodeId: import_zod18.z.string().optional(),
+  sourceSpanIds: import_zod18.z.array(import_zod18.z.string()).optional(),
+  sourceTextHash: import_zod18.z.string().optional()
+});
+var DocumentTableOfContentsEntrySchema = import_zod18.z.object({
+  title: import_zod18.z.string(),
+  level: import_zod18.z.number().int().positive().optional(),
+  pageStart: import_zod18.z.number().optional(),
+  pageEnd: import_zod18.z.number().optional(),
+  documentNodeId: import_zod18.z.string().optional(),
+  sourceSpanIds: import_zod18.z.array(import_zod18.z.string()).optional()
+});
+var DocumentPageMapEntrySchema = import_zod18.z.object({
+  page: import_zod18.z.number().int().positive(),
+  label: import_zod18.z.string().optional(),
+  formNumber: import_zod18.z.string().optional(),
+  formTitle: import_zod18.z.string().optional(),
+  sectionTitle: import_zod18.z.string().optional(),
+  extractorNames: import_zod18.z.array(import_zod18.z.string()).optional(),
+  sourceSpanIds: import_zod18.z.array(import_zod18.z.string()).optional()
+});
+var DocumentAgentGuidanceSchema = import_zod18.z.object({
+  kind: import_zod18.z.string(),
+  title: import_zod18.z.string(),
+  detail: import_zod18.z.string(),
+  sourceSpanIds: import_zod18.z.array(import_zod18.z.string()).optional()
+});
+var DocumentMetadataSchema = import_zod18.z.object({
+  sourceTreeVersion: import_zod18.z.string().optional(),
+  sourceTreeCanonical: import_zod18.z.boolean().optional(),
+  formInventory: import_zod18.z.array(FormReferenceSchema).optional(),
+  tableOfContents: import_zod18.z.array(DocumentTableOfContentsEntrySchema).optional(),
+  pageMap: import_zod18.z.array(DocumentPageMapEntrySchema).optional(),
+  agentGuidance: import_zod18.z.array(DocumentAgentGuidanceSchema).optional()
+});
+var DocumentNodeSchema = import_zod18.z.lazy(
+  () => import_zod18.z.object({
+    id: import_zod18.z.string(),
+    title: import_zod18.z.string(),
+    originalTitle: import_zod18.z.string().optional(),
+    type: import_zod18.z.string().optional(),
+    label: import_zod18.z.string().optional(),
+    level: import_zod18.z.number().int().positive().optional(),
+    sectionNumber: import_zod18.z.string().optional(),
+    pageStart: import_zod18.z.number().optional(),
+    pageEnd: import_zod18.z.number().optional(),
+    formNumber: import_zod18.z.string().optional(),
+    formTitle: import_zod18.z.string().optional(),
+    excerpt: import_zod18.z.string().optional(),
+    content: import_zod18.z.string().optional(),
+    interpretationLabels: import_zod18.z.array(import_zod18.z.string()).optional(),
+    sourceSpanIds: import_zod18.z.array(import_zod18.z.string()).optional(),
+    sourceTextHash: import_zod18.z.string().optional(),
+    children: import_zod18.z.array(DocumentNodeSchema).optional()
   })
 );
 var BaseDocumentFields = {
-  id: import_zod17.z.string(),
-  carrier: import_zod17.z.string(),
-  security: import_zod17.z.string().optional(),
-  insuredName: import_zod17.z.string(),
-  premium: import_zod17.z.string().optional(),
-  premiumAmount: import_zod17.z.number().optional(),
-  summary: import_zod17.z.string().optional(),
-  linesOfBusiness: import_zod17.z.array(import_zod17.z.string()).optional(),
-  coverages: import_zod17.z.array(CoverageSchema),
+  id: import_zod18.z.string(),
+  carrier: import_zod18.z.string(),
+  security: import_zod18.z.string().optional(),
+  insuredName: import_zod18.z.string(),
+  premium: import_zod18.z.string().optional(),
+  premiumAmount: import_zod18.z.number().optional(),
+  premiumBreakdown: import_zod18.z.array(PremiumLineSchema).optional(),
+  summary: import_zod18.z.string().optional(),
+  linesOfBusiness: import_zod18.z.array(import_zod18.z.string()).optional(),
+  coverages: import_zod18.z.array(CoverageSchema),
   documentMetadata: DocumentMetadataSchema,
-  documentOutline: import_zod17.z.array(DocumentNodeSchema),
-  sections: import_zod17.z.array(SectionSchema).optional(),
-  definitions: import_zod17.z.array(DefinitionSchema).optional(),
-  coveredReasons: import_zod17.z.array(CoveredReasonSchema).optional(),
+  documentOutline: import_zod18.z.array(DocumentNodeSchema),
+  sections: import_zod18.z.array(SectionSchema).optional(),
+  definitions: import_zod18.z.array(DefinitionSchema).optional(),
+  coveredReasons: import_zod18.z.array(CoveredReasonSchema).optional(),
   // Enriched fields (v1.2+)
-  carrierLegalName: import_zod17.z.string().optional(),
-  carrierNaicNumber: import_zod17.z.string().optional(),
-  carrierAmBestRating: import_zod17.z.string().optional(),
-  carrierAdmittedStatus: import_zod17.z.string().optional(),
-  mga: import_zod17.z.string().optional(),
-  underwriter: import_zod17.z.string().optional(),
-  brokerAgency: import_zod17.z.string().optional(),
-  brokerContactName: import_zod17.z.string().optional(),
-  brokerLicenseNumber: import_zod17.z.string().optional(),
-  priorPolicyNumber: import_zod17.z.string().optional(),
-  programName: import_zod17.z.string().optional(),
-  isRenewal: import_zod17.z.boolean().optional(),
-  isPackage: import_zod17.z.boolean().optional(),
-  insuredDba: import_zod17.z.string().optional(),
+  carrierLegalName: import_zod18.z.string().optional(),
+  carrierNaicNumber: import_zod18.z.string().optional(),
+  carrierAmBestRating: import_zod18.z.string().optional(),
+  carrierAdmittedStatus: import_zod18.z.string().optional(),
+  mga: import_zod18.z.string().optional(),
+  underwriter: import_zod18.z.string().optional(),
+  brokerAgency: import_zod18.z.string().optional(),
+  brokerContactName: import_zod18.z.string().optional(),
+  brokerLicenseNumber: import_zod18.z.string().optional(),
+  priorPolicyNumber: import_zod18.z.string().optional(),
+  programName: import_zod18.z.string().optional(),
+  isRenewal: import_zod18.z.boolean().optional(),
+  isPackage: import_zod18.z.boolean().optional(),
+  insuredDba: import_zod18.z.string().optional(),
   insuredAddress: SourceBackedAddressSchema.optional(),
   insuredEntityType: EntityTypeSchema.optional(),
-  additionalNamedInsureds: import_zod17.z.array(NamedInsuredSchema).optional(),
-  insuredSicCode: import_zod17.z.string().optional(),
-  insuredNaicsCode: import_zod17.z.string().optional(),
-  insuredFein: import_zod17.z.string().optional(),
-  enrichedCoverages: import_zod17.z.array(EnrichedCoverageSchema).optional(),
-  endorsements: import_zod17.z.array(EndorsementSchema).optional(),
-  exclusions: import_zod17.z.array(ExclusionSchema).optional(),
-  conditions: import_zod17.z.array(PolicyConditionSchema).optional(),
+  additionalNamedInsureds: import_zod18.z.array(NamedInsuredSchema).optional(),
+  insuredSicCode: import_zod18.z.string().optional(),
+  insuredNaicsCode: import_zod18.z.string().optional(),
+  insuredFein: import_zod18.z.string().optional(),
+  enrichedCoverages: import_zod18.z.array(EnrichedCoverageSchema).optional(),
+  endorsements: import_zod18.z.array(EndorsementSchema).optional(),
+  exclusions: import_zod18.z.array(ExclusionSchema).optional(),
+  conditions: import_zod18.z.array(PolicyConditionSchema).optional(),
   limits: LimitScheduleSchema.optional(),
   deductibles: DeductibleScheduleSchema.optional(),
-  locations: import_zod17.z.array(InsuredLocationSchema).optional(),
-  vehicles: import_zod17.z.array(InsuredVehicleSchema).optional(),
-  classifications: import_zod17.z.array(ClassificationCodeSchema).optional(),
-  formInventory: import_zod17.z.array(FormReferenceSchema).optional(),
+  locations: import_zod18.z.array(InsuredLocationSchema).optional(),
+  vehicles: import_zod18.z.array(InsuredVehicleSchema).optional(),
+  classifications: import_zod18.z.array(ClassificationCodeSchema).optional(),
+  coverageSchedules: import_zod18.z.array(OperationalCoverageScheduleSchema).optional(),
+  formInventory: import_zod18.z.array(FormReferenceSchema).optional(),
   declarations: DeclarationsSchema.optional(),
   coverageForm: CoverageFormSchema.optional(),
-  retroactiveDate: import_zod17.z.string().optional(),
+  retroactiveDate: import_zod18.z.string().optional(),
   extendedReportingPeriod: ExtendedReportingPeriodSchema.optional(),
   insurer: InsurerInfoSchema.optional(),
   producer: ProducerInfoSchema.optional(),
-  claimsContacts: import_zod17.z.array(ContactSchema).optional(),
-  regulatoryContacts: import_zod17.z.array(ContactSchema).optional(),
-  thirdPartyAdministrators: import_zod17.z.array(ContactSchema).optional(),
-  additionalInsureds: import_zod17.z.array(EndorsementPartySchema).optional(),
-  lossPayees: import_zod17.z.array(EndorsementPartySchema).optional(),
-  mortgageHolders: import_zod17.z.array(EndorsementPartySchema).optional(),
-  taxesAndFees: import_zod17.z.array(TaxFeeItemSchema).optional(),
-  totalCost: import_zod17.z.string().optional(),
-  totalCostAmount: import_zod17.z.number().optional(),
-  minimumPremium: import_zod17.z.string().optional(),
-  minimumPremiumAmount: import_zod17.z.number().optional(),
-  depositPremium: import_zod17.z.string().optional(),
-  depositPremiumAmount: import_zod17.z.number().optional(),
+  claimsContacts: import_zod18.z.array(ContactSchema).optional(),
+  regulatoryContacts: import_zod18.z.array(ContactSchema).optional(),
+  thirdPartyAdministrators: import_zod18.z.array(ContactSchema).optional(),
+  additionalInsureds: import_zod18.z.array(EndorsementPartySchema).optional(),
+  lossPayees: import_zod18.z.array(EndorsementPartySchema).optional(),
+  mortgageHolders: import_zod18.z.array(EndorsementPartySchema).optional(),
+  taxesAndFees: import_zod18.z.array(TaxFeeItemSchema).optional(),
+  totalCost: import_zod18.z.string().optional(),
+  totalCostAmount: import_zod18.z.number().optional(),
+  minimumPremium: import_zod18.z.string().optional(),
+  minimumPremiumAmount: import_zod18.z.number().optional(),
+  depositPremium: import_zod18.z.string().optional(),
+  depositPremiumAmount: import_zod18.z.number().optional(),
   paymentPlan: PaymentPlanSchema.optional(),
   auditType: AuditTypeSchema.optional(),
-  ratingBasis: import_zod17.z.array(RatingBasisSchema).optional(),
-  premiumByLocation: import_zod17.z.array(LocationPremiumSchema).optional(),
+  ratingBasis: import_zod18.z.array(RatingBasisSchema).optional(),
+  premiumByLocation: import_zod18.z.array(LocationPremiumSchema).optional(),
   lossSummary: LossSummarySchema.optional(),
-  individualClaims: import_zod17.z.array(ClaimRecordSchema).optional(),
+  individualClaims: import_zod18.z.array(ClaimRecordSchema).optional(),
   experienceMod: ExperienceModSchema.optional(),
-  cancellationNoticeDays: import_zod17.z.number().optional(),
-  nonrenewalNoticeDays: import_zod17.z.number().optional(),
-  supplementaryFacts: import_zod17.z.array(AuxiliaryFactSchema).optional()
+  cancellationNoticeDays: import_zod18.z.number().optional(),
+  nonrenewalNoticeDays: import_zod18.z.number().optional(),
+  supplementaryFacts: import_zod18.z.array(AuxiliaryFactSchema).optional()
 };
-var PolicyDocumentSchema = import_zod17.z.object({
+var PolicyDocumentSchema = import_zod18.z.object({
   ...BaseDocumentFields,
-  type: import_zod17.z.literal("policy"),
-  policyNumber: import_zod17.z.string(),
-  effectiveDate: import_zod17.z.string(),
-  expirationDate: import_zod17.z.string().optional(),
+  type: import_zod18.z.literal("policy"),
+  policyNumber: import_zod18.z.string(),
+  effectiveDate: import_zod18.z.string(),
+  expirationDate: import_zod18.z.string().optional(),
   policyTermType: PolicyTermTypeSchema.optional(),
-  nextReviewDate: import_zod17.z.string().optional(),
-  effectiveTime: import_zod17.z.string().optional()
+  nextReviewDate: import_zod18.z.string().optional(),
+  effectiveTime: import_zod18.z.string().optional()
 });
-var QuoteDocumentSchema = import_zod17.z.object({
+var QuoteDocumentSchema = import_zod18.z.object({
   ...BaseDocumentFields,
-  type: import_zod17.z.literal("quote"),
-  quoteNumber: import_zod17.z.string(),
-  proposedEffectiveDate: import_zod17.z.string().optional(),
-  proposedExpirationDate: import_zod17.z.string().optional(),
-  quoteExpirationDate: import_zod17.z.string().optional(),
-  subjectivities: import_zod17.z.array(SubjectivitySchema).optional(),
-  underwritingConditions: import_zod17.z.array(UnderwritingConditionSchema).optional(),
-  premiumBreakdown: import_zod17.z.array(PremiumLineSchema).optional(),
+  type: import_zod18.z.literal("quote"),
+  quoteNumber: import_zod18.z.string(),
+  proposedEffectiveDate: import_zod18.z.string().optional(),
+  proposedExpirationDate: import_zod18.z.string().optional(),
+  quoteExpirationDate: import_zod18.z.string().optional(),
+  subjectivities: import_zod18.z.array(SubjectivitySchema).optional(),
+  underwritingConditions: import_zod18.z.array(UnderwritingConditionSchema).optional(),
   // Enriched quote fields (v1.2+)
-  enrichedSubjectivities: import_zod17.z.array(EnrichedSubjectivitySchema).optional(),
-  enrichedUnderwritingConditions: import_zod17.z.array(EnrichedUnderwritingConditionSchema).optional(),
-  warrantyRequirements: import_zod17.z.array(import_zod17.z.string()).optional(),
-  lossControlRecommendations: import_zod17.z.array(import_zod17.z.string()).optional(),
+  enrichedSubjectivities: import_zod18.z.array(EnrichedSubjectivitySchema).optional(),
+  enrichedUnderwritingConditions: import_zod18.z.array(EnrichedUnderwritingConditionSchema).optional(),
+  warrantyRequirements: import_zod18.z.array(import_zod18.z.string()).optional(),
+  lossControlRecommendations: import_zod18.z.array(import_zod18.z.string()).optional(),
   bindingAuthority: BindingAuthoritySchema.optional()
 });
-var InsuranceDocumentSchema = import_zod17.z.discriminatedUnion("type", [
+var InsuranceDocumentSchema = import_zod18.z.discriminatedUnion("type", [
   PolicyDocumentSchema,
   QuoteDocumentSchema
 ]);
 
 // src/schemas/platform.ts
-var import_zod18 = require("zod");
-var PlatformSchema = import_zod18.z.enum(["email", "chat", "sms", "slack", "discord"]);
-var CommunicationIntentSchema = import_zod18.z.enum(["direct", "mediated", "observed"]);
+var import_zod19 = require("zod");
+var PlatformSchema = import_zod19.z.enum(["email", "chat", "sms", "slack", "discord"]);
+var CommunicationIntentSchema = import_zod19.z.enum(["direct", "mediated", "observed"]);
 var PLATFORM_CONFIGS = {
   email: {
     supportsMarkdown: false,
@@ -2286,65 +2583,65 @@ var PLATFORM_CONFIGS = {
 };
 
 // src/schemas/pce.ts
-var import_zod20 = require("zod");
+var import_zod21 = require("zod");
 
 // src/case/index.ts
-var import_zod19 = require("zod");
-var CaseEvidenceSourceSchema = import_zod19.z.object({
-  id: import_zod19.z.string(),
-  label: import_zod19.z.string().optional(),
-  documentId: import_zod19.z.string().optional(),
-  page: import_zod19.z.number().optional(),
-  fieldPath: import_zod19.z.string().optional(),
-  text: import_zod19.z.string().describe("Source text available for span validation and citation"),
-  metadata: import_zod19.z.record(import_zod19.z.string(), import_zod19.z.string()).optional()
-});
-var CaseCitationSchema = import_zod19.z.object({
-  sourceId: import_zod19.z.string(),
-  quote: import_zod19.z.string(),
-  page: import_zod19.z.number().optional(),
-  fieldPath: import_zod19.z.string().optional()
-});
-var ValidationIssueSeveritySchema = import_zod19.z.enum(["info", "warning", "blocking"]);
-var CaseValidationIssueSchema = import_zod19.z.object({
-  code: import_zod19.z.string(),
+var import_zod20 = require("zod");
+var CaseEvidenceSourceSchema = import_zod20.z.object({
+  id: import_zod20.z.string(),
+  label: import_zod20.z.string().optional(),
+  documentId: import_zod20.z.string().optional(),
+  page: import_zod20.z.number().optional(),
+  fieldPath: import_zod20.z.string().optional(),
+  text: import_zod20.z.string().describe("Source text available for span validation and citation"),
+  metadata: import_zod20.z.record(import_zod20.z.string(), import_zod20.z.string()).optional()
+});
+var CaseCitationSchema = import_zod20.z.object({
+  sourceId: import_zod20.z.string(),
+  quote: import_zod20.z.string(),
+  page: import_zod20.z.number().optional(),
+  fieldPath: import_zod20.z.string().optional()
+});
+var ValidationIssueSeveritySchema = import_zod20.z.enum(["info", "warning", "blocking"]);
+var CaseValidationIssueSchema = import_zod20.z.object({
+  code: import_zod20.z.string(),
   severity: ValidationIssueSeveritySchema,
-  message: import_zod19.z.string(),
-  itemId: import_zod19.z.string().optional(),
-  fieldPath: import_zod19.z.string().optional(),
-  sourceId: import_zod19.z.string().optional()
-});
-var MissingInfoQuestionSchema = import_zod19.z.object({
-  id: import_zod19.z.string(),
-  itemId: import_zod19.z.string().optional(),
-  fieldPath: import_zod19.z.string().optional(),
-  question: import_zod19.z.string(),
-  reason: import_zod19.z.string(),
-  answer: import_zod19.z.string().optional()
-});
-var CasePacketArtifactKindSchema = import_zod19.z.enum([
+  message: import_zod20.z.string(),
+  itemId: import_zod20.z.string().optional(),
+  fieldPath: import_zod20.z.string().optional(),
+  sourceId: import_zod20.z.string().optional()
+});
+var MissingInfoQuestionSchema = import_zod20.z.object({
+  id: import_zod20.z.string(),
+  itemId: import_zod20.z.string().optional(),
+  fieldPath: import_zod20.z.string().optional(),
+  question: import_zod20.z.string(),
+  reason: import_zod20.z.string(),
+  answer: import_zod20.z.string().optional()
+});
+var CasePacketArtifactKindSchema = import_zod20.z.enum([
   "underwriter_summary",
   "carrier_email",
   "missing_info_request",
   "json_packet",
   "validation_report"
 ]);
-var CasePacketArtifactSchema = import_zod19.z.object({
-  id: import_zod19.z.string(),
+var CasePacketArtifactSchema = import_zod20.z.object({
+  id: import_zod20.z.string(),
   kind: CasePacketArtifactKindSchema,
-  title: import_zod19.z.string(),
-  content: import_zod19.z.string(),
-  citations: import_zod19.z.array(CaseCitationSchema).default([])
-});
-var CaseSubmissionPacketSchema = import_zod19.z.object({
-  id: import_zod19.z.string(),
-  caseId: import_zod19.z.string(),
-  artifacts: import_zod19.z.array(CasePacketArtifactSchema),
-  validationIssues: import_zod19.z.array(CaseValidationIssueSchema),
-  missingInfoQuestions: import_zod19.z.array(MissingInfoQuestionSchema),
-  createdAt: import_zod19.z.number()
-});
-var CaseActionSchema = import_zod19.z.enum([
+  title: import_zod20.z.string(),
+  content: import_zod20.z.string(),
+  citations: import_zod20.z.array(CaseCitationSchema).default([])
+});
+var CaseSubmissionPacketSchema = import_zod20.z.object({
+  id: import_zod20.z.string(),
+  caseId: import_zod20.z.string(),
+  artifacts: import_zod20.z.array(CasePacketArtifactSchema),
+  validationIssues: import_zod20.z.array(CaseValidationIssueSchema),
+  missingInfoQuestions: import_zod20.z.array(MissingInfoQuestionSchema),
+  createdAt: import_zod20.z.number()
+});
+var CaseActionSchema = import_zod20.z.enum([
   "inspect_attachments",
   "retrieve_policy_evidence",
   "retrieve_prior_applications",
@@ -2357,23 +2654,23 @@ var CaseActionSchema = import_zod19.z.enum([
   "generate_packet",
   "answer_field_or_case_question"
 ]);
-var AgenticExecutionModeSchema = import_zod19.z.enum(["deterministic_tree", "market_eval", "hybrid"]);
-var CaseProposalScoreSchema = import_zod19.z.object({
-  grounding: import_zod19.z.number().min(0).max(1),
-  completeness: import_zod19.z.number().min(0).max(1),
-  consistency: import_zod19.z.number().min(0).max(1),
-  determinism: import_zod19.z.number().min(0).max(1),
-  risk: import_zod19.z.number().min(0).max(1),
-  cost: import_zod19.z.number().min(0).max(1)
-});
-var CaseProposalSchema = import_zod19.z.object({
-  id: import_zod19.z.string(),
-  sourceSpanIds: import_zod19.z.array(import_zod19.z.string()).default([]),
-  confidence: import_zod19.z.number().min(0).max(1),
-  missingInfo: import_zod19.z.array(import_zod19.z.string()).default([]),
-  validationIssues: import_zod19.z.array(CaseValidationIssueSchema).default([]),
-  estimatedRisk: import_zod19.z.number().min(0).max(1).default(0.5),
-  estimatedCost: import_zod19.z.number().min(0).max(1).default(0.5),
+var AgenticExecutionModeSchema = import_zod20.z.enum(["deterministic_tree", "market_eval", "hybrid"]);
+var CaseProposalScoreSchema = import_zod20.z.object({
+  grounding: import_zod20.z.number().min(0).max(1),
+  completeness: import_zod20.z.number().min(0).max(1),
+  consistency: import_zod20.z.number().min(0).max(1),
+  determinism: import_zod20.z.number().min(0).max(1),
+  risk: import_zod20.z.number().min(0).max(1),
+  cost: import_zod20.z.number().min(0).max(1)
+});
+var CaseProposalSchema = import_zod20.z.object({
+  id: import_zod20.z.string(),
+  sourceSpanIds: import_zod20.z.array(import_zod20.z.string()).default([]),
+  confidence: import_zod20.z.number().min(0).max(1),
+  missingInfo: import_zod20.z.array(import_zod20.z.string()).default([]),
+  validationIssues: import_zod20.z.array(CaseValidationIssueSchema).default([]),
+  estimatedRisk: import_zod20.z.number().min(0).max(1).default(0.5),
+  estimatedCost: import_zod20.z.number().min(0).max(1).default(0.5),
   score: CaseProposalScoreSchema.optional()
 });
 function stableCaseId(prefix, parts) {
@@ -2492,8 +2789,8 @@ function totalProposalScore(score) {
 }
 
 // src/schemas/pce.ts
-var PolicyChangeActionSchema = import_zod20.z.enum(["add", "remove", "update", "replace", "clarify"]);
-var PolicyChangeKindSchema = import_zod20.z.enum([
+var PolicyChangeActionSchema = import_zod21.z.enum(["add", "remove", "update", "replace", "clarify"]);
+var PolicyChangeKindSchema = import_zod21.z.enum([
   "named_insured_change",
   "additional_insured_change",
   "coverage_change",
@@ -2507,70 +2804,70 @@ var PolicyChangeKindSchema = import_zod20.z.enum([
   "renewal_submission_update",
   "general_endorsement"
 ]);
-var PolicyChangeConfidenceSchema = import_zod20.z.enum(["high", "medium", "low"]);
-var PolicyChangeStatusSchema = import_zod20.z.enum(["draft", "needs_info", "ready", "blocked"]);
-var PolicyChangeItemSchema = import_zod20.z.object({
-  id: import_zod20.z.string(),
+var PolicyChangeConfidenceSchema = import_zod21.z.enum(["high", "medium", "low"]);
+var PolicyChangeStatusSchema = import_zod21.z.enum(["draft", "needs_info", "ready", "blocked"]);
+var PolicyChangeItemSchema = import_zod21.z.object({
+  id: import_zod21.z.string(),
   kind: PolicyChangeKindSchema.default("general_endorsement"),
   action: PolicyChangeActionSchema,
-  affectedPolicyId: import_zod20.z.string().default("unknown"),
-  fieldPath: import_zod20.z.string().describe("Stable policy field path or business field name"),
-  label: import_zod20.z.string(),
-  beforeValue: import_zod20.z.string().optional().describe("Existing policy value, when cited from policy evidence"),
-  afterValue: import_zod20.z.string().optional().describe("Requested new value"),
-  requestedValue: import_zod20.z.string().optional().describe("Alias for afterValue used by policy-change workflows"),
-  effectiveDate: import_zod20.z.string().optional(),
-  reason: import_zod20.z.string().optional(),
-  sourceIds: import_zod20.z.array(import_zod20.z.string()).default([]),
-  sourceSpanIds: import_zod20.z.array(import_zod20.z.string()).default([]),
-  userSourceSpanIds: import_zod20.z.array(import_zod20.z.string()).optional(),
-  citations: import_zod20.z.array(CaseCitationSchema).default([]),
+  affectedPolicyId: import_zod21.z.string().default("unknown"),
+  fieldPath: import_zod21.z.string().describe("Stable policy field path or business field name"),
+  label: import_zod21.z.string(),
+  beforeValue: import_zod21.z.string().optional().describe("Existing policy value, when cited from policy evidence"),
+  afterValue: import_zod21.z.string().optional().describe("Requested new value"),
+  requestedValue: import_zod21.z.string().optional().describe("Alias for afterValue used by policy-change workflows"),
+  effectiveDate: import_zod21.z.string().optional(),
+  reason: import_zod21.z.string().optional(),
+  sourceIds: import_zod21.z.array(import_zod21.z.string()).default([]),
+  sourceSpanIds: import_zod21.z.array(import_zod21.z.string()).default([]),
+  userSourceSpanIds: import_zod21.z.array(import_zod21.z.string()).optional(),
+  citations: import_zod21.z.array(CaseCitationSchema).default([]),
   confidence: PolicyChangeConfidenceSchema.default("medium"),
-  confidenceScore: import_zod20.z.number().min(0).max(1).optional(),
+  confidenceScore: import_zod21.z.number().min(0).max(1).optional(),
   status: PolicyChangeStatusSchema.default("ready")
 });
-var PceNormalizationResultSchema = import_zod20.z.object({
-  summary: import_zod20.z.string(),
-  items: import_zod20.z.array(PolicyChangeItemSchema.omit({ id: true, status: true }).extend({
-    id: import_zod20.z.string().optional(),
+var PceNormalizationResultSchema = import_zod21.z.object({
+  summary: import_zod21.z.string(),
+  items: import_zod21.z.array(PolicyChangeItemSchema.omit({ id: true, status: true }).extend({
+    id: import_zod21.z.string().optional(),
     status: PolicyChangeStatusSchema.optional()
   })),
-  missingInfoQuestions: import_zod20.z.array(MissingInfoQuestionSchema.omit({ id: true }).extend({
-    id: import_zod20.z.string().optional()
+  missingInfoQuestions: import_zod21.z.array(MissingInfoQuestionSchema.omit({ id: true }).extend({
+    id: import_zod21.z.string().optional()
   })).default([])
 });
-var PolicyChangeImpactSchema = import_zod20.z.object({
-  itemId: import_zod20.z.string(),
-  beforeValue: import_zod20.z.string().optional(),
-  requestedValue: import_zod20.z.string().optional(),
-  likelyEndorsementRequired: import_zod20.z.boolean().default(true),
-  carrierApprovalLikelyRequired: import_zod20.z.boolean().default(true),
-  affectedCoverageForms: import_zod20.z.array(import_zod20.z.string()).default([]),
-  sourceSpanIds: import_zod20.z.array(import_zod20.z.string()).default([])
-});
-var PceCaseStateSchema = import_zod20.z.object({
-  id: import_zod20.z.string(),
-  requestText: import_zod20.z.string(),
-  summary: import_zod20.z.string(),
+var PolicyChangeImpactSchema = import_zod21.z.object({
+  itemId: import_zod21.z.string(),
+  beforeValue: import_zod21.z.string().optional(),
+  requestedValue: import_zod21.z.string().optional(),
+  likelyEndorsementRequired: import_zod21.z.boolean().default(true),
+  carrierApprovalLikelyRequired: import_zod21.z.boolean().default(true),
+  affectedCoverageForms: import_zod21.z.array(import_zod21.z.string()).default([]),
+  sourceSpanIds: import_zod21.z.array(import_zod21.z.string()).default([])
+});
+var PceCaseStateSchema = import_zod21.z.object({
+  id: import_zod21.z.string(),
+  requestText: import_zod21.z.string(),
+  summary: import_zod21.z.string(),
   executionMode: AgenticExecutionModeSchema.default("deterministic_tree"),
-  items: import_zod20.z.array(PolicyChangeItemSchema),
-  impacts: import_zod20.z.array(PolicyChangeImpactSchema),
-  evidenceSources: import_zod20.z.array(CaseEvidenceSourceSchema),
-  validationIssues: import_zod20.z.array(CaseValidationIssueSchema),
-  missingInfoQuestions: import_zod20.z.array(MissingInfoQuestionSchema),
-  createdAt: import_zod20.z.number(),
-  updatedAt: import_zod20.z.number()
-});
-var PolicyChangeRequestSchema = import_zod20.z.object({
-  id: import_zod20.z.string(),
-  text: import_zod20.z.string(),
+  items: import_zod21.z.array(PolicyChangeItemSchema),
+  impacts: import_zod21.z.array(PolicyChangeImpactSchema),
+  evidenceSources: import_zod21.z.array(CaseEvidenceSourceSchema),
+  validationIssues: import_zod21.z.array(CaseValidationIssueSchema),
+  missingInfoQuestions: import_zod21.z.array(MissingInfoQuestionSchema),
+  createdAt: import_zod21.z.number(),
+  updatedAt: import_zod21.z.number()
+});
+var PolicyChangeRequestSchema = import_zod21.z.object({
+  id: import_zod21.z.string(),
+  text: import_zod21.z.string(),
   executionMode: AgenticExecutionModeSchema.optional(),
-  userSourceSpanIds: import_zod20.z.array(import_zod20.z.string()).optional(),
-  createdAt: import_zod20.z.number().optional()
+  userSourceSpanIds: import_zod21.z.array(import_zod21.z.string()).optional(),
+  createdAt: import_zod21.z.number().optional()
 });
 var PceSubmissionPacketSchema = CaseSubmissionPacketSchema.extend({
   pceCase: PceCaseStateSchema,
-  artifacts: import_zod20.z.array(CasePacketArtifactSchema)
+  artifacts: import_zod21.z.array(CasePacketArtifactSchema)
 });
 
 // src/schemas/context-keys.ts
@@ -2625,254 +2922,6 @@ var CONTEXT_KEY_MAP = [
   { extractedField: "declarations.breed", category: "pet_info", contextKey: "pet_breed", description: "Pet breed" }
 ];
 
-// src/source/schemas.ts
-var import_zod21 = require("zod");
-var SourceSpanKindSchema = import_zod21.z.enum([
-  "pdf_text",
-  "pdf_image",
-  "html",
-  "markdown",
-  "plain_text",
-  "structured_field"
-]);
-var SourceSpanUnitSchema = import_zod21.z.enum([
-  "page",
-  "section",
-  "table",
-  "table_row",
-  "table_cell",
-  "key_value",
-  "text"
-]);
-var SourceKindSchema = import_zod21.z.enum([
-  "policy_pdf",
-  "application_pdf",
-  "email",
-  "attachment",
-  "manual_note"
-]);
-var SourceSpanBBoxSchema = import_zod21.z.object({
-  page: import_zod21.z.number().int().positive(),
-  x: import_zod21.z.number(),
-  y: import_zod21.z.number(),
-  width: import_zod21.z.number(),
-  height: import_zod21.z.number()
-});
-var SourceSpanLocationSchema = import_zod21.z.object({
-  page: import_zod21.z.number().int().positive().optional(),
-  startPage: import_zod21.z.number().int().positive().optional(),
-  endPage: import_zod21.z.number().int().positive().optional(),
-  charStart: import_zod21.z.number().int().nonnegative().optional(),
-  charEnd: import_zod21.z.number().int().nonnegative().optional(),
-  lineStart: import_zod21.z.number().int().positive().optional(),
-  lineEnd: import_zod21.z.number().int().positive().optional(),
-  fieldPath: import_zod21.z.string().optional()
-});
-var SourceSpanTableLocationSchema = import_zod21.z.object({
-  tableId: import_zod21.z.string().optional(),
-  rowIndex: import_zod21.z.number().int().nonnegative().optional(),
-  columnIndex: import_zod21.z.number().int().nonnegative().optional(),
-  columnName: import_zod21.z.string().optional(),
-  rowSpanId: import_zod21.z.string().optional(),
-  tableSpanId: import_zod21.z.string().optional(),
-  isHeader: import_zod21.z.boolean().optional()
-});
-var SourceSpanSchema = import_zod21.z.object({
-  id: import_zod21.z.string().min(1),
-  documentId: import_zod21.z.string().min(1),
-  sourceKind: SourceKindSchema.optional(),
-  chunkId: import_zod21.z.string().optional(),
-  kind: SourceSpanKindSchema,
-  text: import_zod21.z.string(),
-  hash: import_zod21.z.string().min(1),
-  textHash: import_zod21.z.string().optional(),
-  pageStart: import_zod21.z.number().int().positive().optional(),
-  pageEnd: import_zod21.z.number().int().positive().optional(),
-  sectionId: import_zod21.z.string().optional(),
-  formNumber: import_zod21.z.string().optional(),
-  sourceUnit: SourceSpanUnitSchema.optional(),
-  parentSpanId: import_zod21.z.string().optional(),
-  table: SourceSpanTableLocationSchema.optional(),
-  bbox: import_zod21.z.array(SourceSpanBBoxSchema).optional(),
-  location: SourceSpanLocationSchema.optional(),
-  metadata: import_zod21.z.record(import_zod21.z.string(), import_zod21.z.string()).optional()
-});
-var SourceSpanRefSchema = import_zod21.z.object({
-  sourceSpanId: import_zod21.z.string().min(1),
-  documentId: import_zod21.z.string().min(1).optional(),
-  chunkId: import_zod21.z.string().optional(),
-  quote: import_zod21.z.string().optional(),
-  hash: import_zod21.z.string().optional(),
-  location: SourceSpanLocationSchema.optional()
-});
-var SourceChunkSchema = import_zod21.z.object({
-  id: import_zod21.z.string().min(1),
-  documentId: import_zod21.z.string().min(1),
-  sourceSpanIds: import_zod21.z.array(import_zod21.z.string().min(1)),
-  text: import_zod21.z.string(),
-  textHash: import_zod21.z.string().min(1),
-  pageStart: import_zod21.z.number().int().positive().optional(),
-  pageEnd: import_zod21.z.number().int().positive().optional(),
-  metadata: import_zod21.z.record(import_zod21.z.string(), import_zod21.z.string()).default({})
-});
-var DocumentSourceNodeKindSchema = import_zod21.z.enum([
-  "document",
-  "page_group",
-  "page",
-  "form",
-  "endorsement",
-  "section",
-  "schedule",
-  "clause",
-  "table",
-  "table_row",
-  "table_cell",
-  "text"
-]);
-var DocumentSourceNodeSchema = import_zod21.z.object({
-  id: import_zod21.z.string().min(1),
-  documentId: import_zod21.z.string().min(1),
-  parentId: import_zod21.z.string().optional(),
-  kind: DocumentSourceNodeKindSchema,
-  title: import_zod21.z.string(),
-  description: import_zod21.z.string(),
-  textExcerpt: import_zod21.z.string().optional(),
-  sourceSpanIds: import_zod21.z.array(import_zod21.z.string().min(1)),
-  pageStart: import_zod21.z.number().int().positive().optional(),
-  pageEnd: import_zod21.z.number().int().positive().optional(),
-  bbox: import_zod21.z.array(SourceSpanBBoxSchema).optional(),
-  order: import_zod21.z.number().int().nonnegative(),
-  path: import_zod21.z.string(),
-  metadata: import_zod21.z.record(import_zod21.z.string(), import_zod21.z.unknown()).optional()
-});
-var SourceBackedValueSchema = import_zod21.z.object({
-  value: import_zod21.z.string(),
-  normalizedValue: import_zod21.z.string().optional(),
-  confidence: import_zod21.z.enum(["low", "medium", "high"]).default("medium"),
-  sourceNodeIds: import_zod21.z.array(import_zod21.z.string().min(1)).default([]),
-  sourceSpanIds: import_zod21.z.array(import_zod21.z.string().min(1)).default([])
-});
-var OperationalAddressSchema = import_zod21.z.object({
-  street1: import_zod21.z.string().optional(),
-  street2: import_zod21.z.string().optional(),
-  city: import_zod21.z.string().optional(),
-  state: import_zod21.z.string().optional(),
-  zip: import_zod21.z.string().optional(),
-  country: import_zod21.z.string().optional(),
-  formatted: import_zod21.z.string().optional()
-});
-var OperationalDeclarationFactSchema = import_zod21.z.object({
-  field: import_zod21.z.enum([
-    "namedInsured",
-    "mailingAddress",
-    "dba",
-    "entityType",
-    "taxId",
-    "additionalNamedInsured",
-    "policyNumber",
-    "insurer",
-    "broker",
-    "effectiveDate",
-    "expirationDate",
-    "premium",
-    "other"
-  ]),
-  label: import_zod21.z.string().optional(),
-  value: import_zod21.z.string(),
-  normalizedValue: import_zod21.z.string().optional(),
-  valueKind: import_zod21.z.enum(["string", "number", "date", "money", "address", "list", "unknown"]).default("string"),
-  address: OperationalAddressSchema.optional(),
-  confidence: import_zod21.z.enum(["low", "medium", "high"]).default("medium"),
-  sourceNodeIds: import_zod21.z.array(import_zod21.z.string().min(1)).default([]),
-  sourceSpanIds: import_zod21.z.array(import_zod21.z.string().min(1)).default([])
-});
-var OperationalCoverageTermSchema = import_zod21.z.object({
-  kind: import_zod21.z.enum([
-    "each_claim_limit",
-    "each_occurrence_limit",
-    "each_loss_limit",
-    "aggregate_limit",
-    "sublimit",
-    "retention",
-    "deductible",
-    "retroactive_date",
-    "premium",
-    "other"
-  ]).default("other"),
-  label: import_zod21.z.string(),
-  value: import_zod21.z.string(),
-  amount: import_zod21.z.number().optional(),
-  appliesTo: import_zod21.z.string().optional(),
-  sourceNodeIds: import_zod21.z.array(import_zod21.z.string().min(1)).default([]),
-  sourceSpanIds: import_zod21.z.array(import_zod21.z.string().min(1)).default([])
-});
-var OperationalCoverageLineSchema = import_zod21.z.object({
-  name: import_zod21.z.string(),
-  lineOfBusiness: AcordLobCodeSchema.optional(),
-  coverageCode: import_zod21.z.string().optional(),
-  limit: import_zod21.z.string().optional(),
-  deductible: import_zod21.z.string().optional(),
-  premium: import_zod21.z.string().optional(),
-  retroactiveDate: import_zod21.z.string().optional(),
-  formNumber: import_zod21.z.string().optional(),
-  sectionRef: import_zod21.z.string().optional(),
-  endorsementNumber: import_zod21.z.string().optional(),
-  limits: import_zod21.z.array(OperationalCoverageTermSchema).default([]),
-  sourceNodeIds: import_zod21.z.array(import_zod21.z.string().min(1)).default([]),
-  sourceSpanIds: import_zod21.z.array(import_zod21.z.string().min(1)).default([])
-});
-var OperationalPartySchema = import_zod21.z.object({
-  role: import_zod21.z.string(),
-  name: import_zod21.z.string(),
-  address: OperationalAddressSchema.optional(),
-  sourceNodeIds: import_zod21.z.array(import_zod21.z.string().min(1)).default([]),
-  sourceSpanIds: import_zod21.z.array(import_zod21.z.string().min(1)).default([])
-});
-var OperationalEndorsementSupportSchema = import_zod21.z.object({
-  kind: import_zod21.z.string(),
-  status: import_zod21.z.enum(["supported", "excluded", "requires_review"]),
-  summary: import_zod21.z.string(),
-  sourceNodeIds: import_zod21.z.array(import_zod21.z.string().min(1)).default([]),
-  sourceSpanIds: import_zod21.z.array(import_zod21.z.string().min(1)).default([])
-});
-function legacyOperationalProfileInput(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return value;
-  const record = value;
-  if ("linesOfBusiness" in record) return value;
-  if (!("policyTypes" in record)) return value;
-  return {
-    ...record,
-    linesOfBusiness: record.policyTypes
-  };
-}
-var OperationalLinesOfBusinessSchema = import_zod21.z.preprocess(
-  (value) => Array.isArray(value) ? toLobCodes(value.filter((item) => typeof item === "string")) : void 0,
-  import_zod21.z.array(AcordLobCodeSchema).default(["UN"])
-);
-var PolicyOperationalProfileSchema = import_zod21.z.preprocess(
-  legacyOperationalProfileInput,
-  import_zod21.z.object({
-    documentType: import_zod21.z.enum(["policy", "quote"]).default("policy"),
-    linesOfBusiness: OperationalLinesOfBusinessSchema,
-    policyNumber: SourceBackedValueSchema.optional(),
-    namedInsured: SourceBackedValueSchema.optional(),
-    insurer: SourceBackedValueSchema.optional(),
-    broker: SourceBackedValueSchema.optional(),
-    effectiveDate: SourceBackedValueSchema.optional(),
-    expirationDate: SourceBackedValueSchema.optional(),
-    retroactiveDate: SourceBackedValueSchema.optional(),
-    premium: SourceBackedValueSchema.optional(),
-    operationsDescription: SourceBackedValueSchema.optional(),
-    declarationFacts: import_zod21.z.array(OperationalDeclarationFactSchema).default([]),
-    coverages: import_zod21.z.array(OperationalCoverageLineSchema).default([]),
-    parties: import_zod21.z.array(OperationalPartySchema).default([]),
-    endorsementSupport: import_zod21.z.array(OperationalEndorsementSupportSchema).default([]),
-    sourceNodeIds: import_zod21.z.array(import_zod21.z.string().min(1)).default([]),
-    sourceSpanIds: import_zod21.z.array(import_zod21.z.string().min(1)).default([]),
-    warnings: import_zod21.z.array(import_zod21.z.string()).default([])
-  })
-);
-
 // src/source/policy-types.ts
 var LOB_TEXT_PATTERNS = [
   { codes: ["CGL"], pattern: /\b(?:commercial\s+)?general\s+liability\b|\bcgl\b/i },
@@ -4223,7 +4272,7 @@ function shouldFailQualityGate(mode, status) {
 }
 
 // src/extraction/source-tree-extractor.ts
-var import_zod23 = require("zod");
+var import_zod24 = require("zod");
 
 // src/source/operational-profile.ts
 function normalizeWhitespace4(value) {
@@ -4966,116 +5015,831 @@ function applyCoverageCleanupDecision(coverage, decision, validNodeIds, validSpa
     const value = cleanProfileValue(decision.retroactiveDate);
     if (value) next.retroactiveDate = value;
   }
-  const termDecisions = (decision.termDecisions ?? []).filter((termDecision) => termDecision.termIndex < coverage.limits.length);
-  const termDecisionByIndex = new Map(termDecisions.map((termDecision) => [termDecision.termIndex, termDecision]));
-  next.limits = coverage.limits.map((term, index) => applyTermCleanupDecision(term, termDecisionByIndex.get(index), validNodeIds, validSpanIds)).filter((term) => Boolean(term));
-  if (termDecisions.length > 0) {
-    if (decision.limit == null && termDecisionsTouch(coverage, termDecisions, isLimitTerm)) {
-      const value = primaryLimitFromTerms(next.limits);
-      if (value) next.limit = value;
-      else delete next.limit;
+  const termDecisions = (decision.termDecisions ?? []).filter((termDecision) => termDecision.termIndex < coverage.limits.length);
+  const termDecisionByIndex = new Map(termDecisions.map((termDecision) => [termDecision.termIndex, termDecision]));
+  next.limits = coverage.limits.map((term, index) => applyTermCleanupDecision(term, termDecisionByIndex.get(index), validNodeIds, validSpanIds)).filter((term) => Boolean(term));
+  if (termDecisions.length > 0) {
+    if (decision.limit == null && termDecisionsTouch(coverage, termDecisions, isLimitTerm)) {
+      const value = primaryLimitFromTerms(next.limits);
+      if (value) next.limit = value;
+      else delete next.limit;
+    }
+    if (decision.deductible == null && termDecisionsTouch(coverage, termDecisions, isDeductibleTerm)) {
+      const value = deductibleFromTerms(next.limits);
+      if (value) next.deductible = value;
+      else delete next.deductible;
+    }
+    if (decision.premium == null && termDecisionsTouch(coverage, termDecisions, isPremiumTerm)) {
+      const value = premiumFromTerms(next.limits);
+      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;
+    }
+  }
+  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
+var import_zod23 = require("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 = import_zod23.z.object({
+  pageStart: import_zod23.z.number().int().positive(),
+  pageEnd: import_zod23.z.number().int().positive(),
+  reason: import_zod23.z.string(),
+  priorContext: import_zod23.z.string().optional(),
+  sourceNodeIds: import_zod23.z.array(import_zod23.z.string()).default([]),
+  sourceSpanIds: import_zod23.z.array(import_zod23.z.string()).default([])
+});
+var RecoveryRegionDiscoverySchema = import_zod23.z.object({
+  regions: import_zod23.z.array(RecoveryRegionSchema).default([]),
+  warnings: import_zod23.z.array(import_zod23.z.string()).default([])
+});
+var CoverageRecoveryCandidateSchema = import_zod23.z.object({
+  coverages: import_zod23.z.array(OperationalCoverageLineSchema).default([]),
+  coverageSchedules: import_zod23.z.array(OperationalCoverageScheduleSchema).default([]),
+  premiumBreakdown: import_zod23.z.array(OperationalPremiumLineSchema).default([]),
+  taxesAndFees: import_zod23.z.array(OperationalTaxFeeItemSchema).default([]),
+  totalCost: SourceBackedValueSchema.optional(),
+  warnings: import_zod23.z.array(import_zod23.z.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;
     }
-    if (decision.deductible == null && termDecisionsTouch(coverage, termDecisions, isDeductibleTerm)) {
-      const value = deductibleFromTerms(next.limits);
-      if (value) next.deductible = value;
-      else delete next.deductible;
+    const evidenceText = citedText(spans, spansById);
+    if (values.some((value) => !valueGroundedInText(value, evidenceText))) {
+      citationRejectionCount += 1;
+      return void 0;
     }
-    if (decision.premium == null && termDecisionsTouch(coverage, termDecisions, isPremiumTerm)) {
-      const value = premiumFromTerms(next.limits);
-      if (value) next.premium = value;
-      else delete next.premium;
+    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 [];
     }
-    if (decision.retroactiveDate == null && termDecisionsTouch(coverage, termDecisions, isRetroactiveDateTerm)) {
-      const value = retroactiveDateFromTerms(next.limits);
-      if (value) next.retroactiveDate = value;
-      else delete next.retroactiveDate;
+    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,
-    profile.operationsDescription
-  ].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 = import_zod23.z.object({
-  value: import_zod23.z.string(),
-  normalizedValue: import_zod23.z.string().optional(),
-  confidence: import_zod23.z.enum(["low", "medium", "high"]).optional(),
-  sourceNodeIds: import_zod23.z.array(import_zod23.z.string()),
-  sourceSpanIds: import_zod23.z.array(import_zod23.z.string())
-});
-var OperationalAddressForPromptSchema = import_zod23.z.object({
-  street1: import_zod23.z.string().optional(),
-  street2: import_zod23.z.string().optional(),
-  city: import_zod23.z.string().optional(),
-  state: import_zod23.z.string().optional(),
-  zip: import_zod23.z.string().optional(),
-  country: import_zod23.z.string().optional(),
-  formatted: import_zod23.z.string().optional()
-});
-var OperationalDeclarationFactForPromptSchema = import_zod23.z.object({
-  field: import_zod23.z.enum([
+var SourceBackedValueForPromptSchema = import_zod24.z.object({
+  value: import_zod24.z.string(),
+  normalizedValue: import_zod24.z.string().optional(),
+  confidence: import_zod24.z.enum(["low", "medium", "high"]).optional(),
+  sourceNodeIds: import_zod24.z.array(import_zod24.z.string()),
+  sourceSpanIds: import_zod24.z.array(import_zod24.z.string())
+});
+var OperationalAddressForPromptSchema = import_zod24.z.object({
+  street1: import_zod24.z.string().optional(),
+  street2: import_zod24.z.string().optional(),
+  city: import_zod24.z.string().optional(),
+  state: import_zod24.z.string().optional(),
+  zip: import_zod24.z.string().optional(),
+  country: import_zod24.z.string().optional(),
+  formatted: import_zod24.z.string().optional()
+});
+var OperationalDeclarationFactForPromptSchema = import_zod24.z.object({
+  field: import_zod24.z.enum([
     "namedInsured",
     "mailingAddress",
     "dba",
@@ -5090,17 +5854,17 @@ var OperationalDeclarationFactForPromptSchema = import_zod23.z.object({
     "premium",
     "other"
   ]),
-  label: import_zod23.z.string().optional(),
-  value: import_zod23.z.string(),
-  normalizedValue: import_zod23.z.string().optional(),
-  valueKind: import_zod23.z.enum(["string", "number", "date", "money", "address", "list", "unknown"]).optional(),
+  label: import_zod24.z.string().optional(),
+  value: import_zod24.z.string(),
+  normalizedValue: import_zod24.z.string().optional(),
+  valueKind: import_zod24.z.enum(["string", "number", "date", "money", "address", "list", "unknown"]).optional(),
   address: OperationalAddressForPromptSchema.optional(),
-  confidence: import_zod23.z.enum(["low", "medium", "high"]).optional(),
-  sourceNodeIds: import_zod23.z.array(import_zod23.z.string()),
-  sourceSpanIds: import_zod23.z.array(import_zod23.z.string())
+  confidence: import_zod24.z.enum(["low", "medium", "high"]).optional(),
+  sourceNodeIds: import_zod24.z.array(import_zod24.z.string()),
+  sourceSpanIds: import_zod24.z.array(import_zod24.z.string())
 });
-var OperationalPartyForPromptSchema = import_zod23.z.object({
-  role: import_zod23.z.enum([
+var OperationalPartyForPromptSchema = import_zod24.z.object({
+  role: import_zod24.z.enum([
     "named_insured",
     "producer",
     "broker",
@@ -5109,14 +5873,14 @@ var OperationalPartyForPromptSchema = import_zod23.z.object({
     "mga",
     "administrator"
   ]),
-  name: import_zod23.z.string(),
+  name: import_zod24.z.string(),
   address: OperationalAddressForPromptSchema.optional(),
-  sourceNodeIds: import_zod23.z.array(import_zod23.z.string()),
-  sourceSpanIds: import_zod23.z.array(import_zod23.z.string())
+  sourceNodeIds: import_zod24.z.array(import_zod24.z.string()),
+  sourceSpanIds: import_zod24.z.array(import_zod24.z.string())
 });
-var OperationalProfilePromptSchema = import_zod23.z.object({
-  documentType: import_zod23.z.enum(["policy", "quote"]).optional(),
-  linesOfBusiness: import_zod23.z.array(import_zod23.z.string()).optional(),
+var OperationalProfilePromptSchema = import_zod24.z.object({
+  documentType: import_zod24.z.enum(["policy", "quote"]).optional(),
+  linesOfBusiness: import_zod24.z.array(import_zod24.z.string()).optional(),
   policyNumber: SourceBackedValueForPromptSchema.optional(),
   namedInsured: SourceBackedValueForPromptSchema.optional(),
   insurer: SourceBackedValueForPromptSchema.optional(),
@@ -5126,40 +5890,40 @@ var OperationalProfilePromptSchema = import_zod23.z.object({
   retroactiveDate: SourceBackedValueForPromptSchema.optional(),
   premium: SourceBackedValueForPromptSchema.optional(),
   operationsDescription: SourceBackedValueForPromptSchema.optional(),
-  declarationFacts: import_zod23.z.array(OperationalDeclarationFactForPromptSchema).optional(),
-  parties: import_zod23.z.array(OperationalPartyForPromptSchema).optional(),
-  coverages: import_zod23.z.array(import_zod23.z.object({
-    name: import_zod23.z.string(),
-    lineOfBusiness: import_zod23.z.string().optional(),
-    coverageCode: import_zod23.z.string().optional(),
-    limit: import_zod23.z.string().optional(),
-    deductible: import_zod23.z.string().optional(),
-    premium: import_zod23.z.string().optional(),
-    retroactiveDate: import_zod23.z.string().optional(),
-    formNumber: import_zod23.z.string().optional(),
-    sectionRef: import_zod23.z.string().optional(),
-    endorsementNumber: import_zod23.z.string().optional(),
-    limits: import_zod23.z.array(import_zod23.z.object({
+  declarationFacts: import_zod24.z.array(OperationalDeclarationFactForPromptSchema).optional(),
+  parties: import_zod24.z.array(OperationalPartyForPromptSchema).optional(),
+  coverages: import_zod24.z.array(import_zod24.z.object({
+    name: import_zod24.z.string(),
+    lineOfBusiness: import_zod24.z.string().optional(),
+    coverageCode: import_zod24.z.string().optional(),
+    limit: import_zod24.z.string().optional(),
+    deductible: import_zod24.z.string().optional(),
+    premium: import_zod24.z.string().optional(),
+    retroactiveDate: import_zod24.z.string().optional(),
+    formNumber: import_zod24.z.string().optional(),
+    sectionRef: import_zod24.z.string().optional(),
+    endorsementNumber: import_zod24.z.string().optional(),
+    limits: import_zod24.z.array(import_zod24.z.object({
       kind: OperationalCoverageTermKindSchema.optional(),
-      label: import_zod23.z.string(),
-      value: import_zod23.z.string(),
-      amount: import_zod23.z.number().optional(),
-      appliesTo: import_zod23.z.string().optional(),
-      sourceNodeIds: import_zod23.z.array(import_zod23.z.string()),
-      sourceSpanIds: import_zod23.z.array(import_zod23.z.string())
+      label: import_zod24.z.string(),
+      value: import_zod24.z.string(),
+      amount: import_zod24.z.number().optional(),
+      appliesTo: import_zod24.z.string().optional(),
+      sourceNodeIds: import_zod24.z.array(import_zod24.z.string()),
+      sourceSpanIds: import_zod24.z.array(import_zod24.z.string())
     })).optional(),
-    sourceNodeIds: import_zod23.z.array(import_zod23.z.string()),
-    sourceSpanIds: import_zod23.z.array(import_zod23.z.string())
+    sourceNodeIds: import_zod24.z.array(import_zod24.z.string()),
+    sourceSpanIds: import_zod24.z.array(import_zod24.z.string())
   })).optional(),
-  sourceNodeIds: import_zod23.z.array(import_zod23.z.string()).optional(),
-  sourceSpanIds: import_zod23.z.array(import_zod23.z.string()).optional()
+  sourceNodeIds: import_zod24.z.array(import_zod24.z.string()).optional(),
+  sourceSpanIds: import_zod24.z.array(import_zod24.z.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";
@@ -5172,23 +5936,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;
@@ -5197,7 +5961,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);
 }
@@ -5205,7 +5969,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
   );
@@ -5213,7 +5977,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) {
@@ -5257,17 +6021,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,
@@ -5281,7 +6045,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;
 }
@@ -5289,12 +6053,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);
@@ -5302,7 +6066,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);
 }
@@ -5391,7 +6155,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" }
       };
     }
@@ -5399,7 +6163,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" }
       };
     }
@@ -5667,7 +6431,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;
@@ -5683,7 +6447,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;
@@ -5757,7 +6521,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",
@@ -5805,7 +6569,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"
@@ -5835,7 +6599,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",
@@ -6014,7 +6778,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) {
@@ -6026,7 +6790,7 @@ function sourceNodeIdsBySpanId(sourceTree) {
   return bySpan;
 }
 function operationalEvidenceScore(span) {
-  const text = cleanText([
+  const text = cleanText2([
     span.text,
     span.formNumber,
     span.sourceUnit,
@@ -6052,13 +6816,13 @@ 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|mailing address|mga|administrator|description of operations|nature of business|business description)\b/i.test(text);
@@ -6075,9 +6839,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;
@@ -6096,7 +6860,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();
@@ -6106,7 +6870,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);
@@ -6114,9 +6878,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);
     }
@@ -6125,31 +6889,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;
@@ -6169,6 +6933,9 @@ function emptyOperationalProfile() {
     linesOfBusiness: ["UN"],
     declarationFacts: [],
     coverages: [],
+    coverageSchedules: [],
+    premiumBreakdown: [],
+    taxesAndFees: [],
     parties: [],
     endorsementSupport: [],
     sourceNodeIds: [],
@@ -6324,7 +7091,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";
   }
@@ -6350,6 +7117,65 @@ 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";
@@ -6394,6 +7220,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",
@@ -6426,6 +7276,10 @@ 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,
@@ -6456,6 +7310,9 @@ function materializeDocument(params) {
       pageEnd: form.pageEnd
     })),
     coverages,
+    ...coverageSchedules.length > 0 ? { coverageSchedules } : {},
+    ...vehicles.length > 0 ? { vehicles } : {},
+    ...locations.length > 0 ? { locations } : {},
     documentMetadata,
     documentOutline,
     declarations: {
@@ -6587,6 +7444,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));
@@ -6624,6 +7482,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({
@@ -6656,6 +7529,7 @@ async function runSourceTreeExtraction(params) {
     sourceChunks: chunkSourceSpans(sourceSpans),
     formInventory: formHints,
     operationalProfile,
+    coverageRecovery,
     document,
     chunks: [],
     warnings: [...warnings, ...operationalProfile.warnings],
@@ -6758,7 +7632,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() : "";
@@ -6798,6 +7673,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,
@@ -8204,8 +9080,8 @@ Respond with JSON only:
 }`;
 
 // src/schemas/application.ts
-var import_zod24 = require("zod");
-var FieldTypeSchema = import_zod24.z.enum([
+var import_zod25 = require("zod");
+var FieldTypeSchema = import_zod25.z.enum([
   "text",
   "numeric",
   "currency",
@@ -8214,223 +9090,223 @@ var FieldTypeSchema = import_zod24.z.enum([
   "table",
   "declaration"
 ]);
-var ApplicationFieldSchema = import_zod24.z.object({
-  id: import_zod24.z.string(),
-  label: import_zod24.z.string(),
-  section: import_zod24.z.string(),
+var ApplicationFieldSchema = import_zod25.z.object({
+  id: import_zod25.z.string(),
+  label: import_zod25.z.string(),
+  section: import_zod25.z.string(),
   fieldType: FieldTypeSchema,
-  required: import_zod24.z.boolean(),
-  options: import_zod24.z.array(import_zod24.z.string()).optional(),
-  columns: import_zod24.z.array(import_zod24.z.string()).optional(),
-  requiresExplanationIfYes: import_zod24.z.boolean().optional(),
-  condition: import_zod24.z.object({
-    dependsOn: import_zod24.z.string(),
-    whenValue: import_zod24.z.string()
+  required: import_zod25.z.boolean(),
+  options: import_zod25.z.array(import_zod25.z.string()).optional(),
+  columns: import_zod25.z.array(import_zod25.z.string()).optional(),
+  requiresExplanationIfYes: import_zod25.z.boolean().optional(),
+  condition: import_zod25.z.object({
+    dependsOn: import_zod25.z.string(),
+    whenValue: import_zod25.z.string()
   }).optional(),
-  value: import_zod24.z.string().optional(),
-  source: import_zod24.z.string().optional().describe("Where the value came from: auto-fill, user, lookup"),
-  confidence: import_zod24.z.enum(["confirmed", "high", "medium", "low"]).optional(),
-  sourceSpanIds: import_zod24.z.array(import_zod24.z.string()).optional().describe("Stable source spans that support the field value or field anchor"),
-  userSourceSpanIds: import_zod24.z.array(import_zod24.z.string()).optional().describe("Message or attachment spans that support user-provided values"),
-  pageNumber: import_zod24.z.number().int().positive().optional().describe("Application page where the field label or anchor appears"),
-  fieldAnchorId: import_zod24.z.string().optional().describe("Stable field anchor ID derived from page, section, label, and form metadata"),
-  acroFormName: import_zod24.z.string().optional().describe("Native PDF AcroForm field name when available"),
-  validationStatus: import_zod24.z.enum(["valid", "needs_review", "unsupported", "missing"]).optional()
-});
-var ApplicationQuestionConditionSchema = import_zod24.z.object({
-  dependsOn: import_zod24.z.string(),
-  operator: import_zod24.z.enum(["equals", "not_equals", "in", "not_in", "exists"]).optional(),
-  value: import_zod24.z.string().optional(),
-  whenValue: import_zod24.z.string().optional(),
-  values: import_zod24.z.array(import_zod24.z.string()).optional()
-});
-var ApplicationRepeatSchema = import_zod24.z.object({
-  min: import_zod24.z.number().int().nonnegative().optional(),
-  max: import_zod24.z.number().int().positive().optional(),
-  label: import_zod24.z.string().optional()
-});
-var ApplicationQuestionNodeSchema = import_zod24.z.lazy(
-  () => import_zod24.z.object({
-    id: import_zod24.z.string(),
-    nodeType: import_zod24.z.enum(["group", "question", "repeat_group", "table"]),
-    fieldId: import_zod24.z.string().optional(),
-    fieldPath: import_zod24.z.string().optional(),
-    parentId: import_zod24.z.string().optional(),
-    order: import_zod24.z.number().int().nonnegative().optional(),
-    label: import_zod24.z.string(),
-    section: import_zod24.z.string().optional(),
+  value: import_zod25.z.string().optional(),
+  source: import_zod25.z.string().optional().describe("Where the value came from: auto-fill, user, lookup"),
+  confidence: import_zod25.z.enum(["confirmed", "high", "medium", "low"]).optional(),
+  sourceSpanIds: import_zod25.z.array(import_zod25.z.string()).optional().describe("Stable source spans that support the field value or field anchor"),
+  userSourceSpanIds: import_zod25.z.array(import_zod25.z.string()).optional().describe("Message or attachment spans that support user-provided values"),
+  pageNumber: import_zod25.z.number().int().positive().optional().describe("Application page where the field label or anchor appears"),
+  fieldAnchorId: import_zod25.z.string().optional().describe("Stable field anchor ID derived from page, section, label, and form metadata"),
+  acroFormName: import_zod25.z.string().optional().describe("Native PDF AcroForm field name when available"),
+  validationStatus: import_zod25.z.enum(["valid", "needs_review", "unsupported", "missing"]).optional()
+});
+var ApplicationQuestionConditionSchema = import_zod25.z.object({
+  dependsOn: import_zod25.z.string(),
+  operator: import_zod25.z.enum(["equals", "not_equals", "in", "not_in", "exists"]).optional(),
+  value: import_zod25.z.string().optional(),
+  whenValue: import_zod25.z.string().optional(),
+  values: import_zod25.z.array(import_zod25.z.string()).optional()
+});
+var ApplicationRepeatSchema = import_zod25.z.object({
+  min: import_zod25.z.number().int().nonnegative().optional(),
+  max: import_zod25.z.number().int().positive().optional(),
+  label: import_zod25.z.string().optional()
+});
+var ApplicationQuestionNodeSchema = import_zod25.z.lazy(
+  () => import_zod25.z.object({
+    id: import_zod25.z.string(),
+    nodeType: import_zod25.z.enum(["group", "question", "repeat_group", "table"]),
+    fieldId: import_zod25.z.string().optional(),
+    fieldPath: import_zod25.z.string().optional(),
+    parentId: import_zod25.z.string().optional(),
+    order: import_zod25.z.number().int().nonnegative().optional(),
+    label: import_zod25.z.string(),
+    section: import_zod25.z.string().optional(),
     fieldType: FieldTypeSchema.optional(),
-    required: import_zod24.z.boolean().optional(),
-    prompt: import_zod24.z.string().optional(),
-    options: import_zod24.z.array(import_zod24.z.string()).optional(),
-    columns: import_zod24.z.array(import_zod24.z.string()).optional(),
+    required: import_zod25.z.boolean().optional(),
+    prompt: import_zod25.z.string().optional(),
+    options: import_zod25.z.array(import_zod25.z.string()).optional(),
+    columns: import_zod25.z.array(import_zod25.z.string()).optional(),
     condition: ApplicationQuestionConditionSchema.optional(),
     repeat: ApplicationRepeatSchema.optional(),
-    children: import_zod24.z.array(ApplicationQuestionNodeSchema).optional()
+    children: import_zod25.z.array(ApplicationQuestionNodeSchema).optional()
   })
 );
-var ApplicationQuestionGraphSchema = import_zod24.z.object({
-  id: import_zod24.z.string(),
-  version: import_zod24.z.string(),
-  title: import_zod24.z.string().optional(),
-  applicationType: import_zod24.z.string().nullable().optional(),
-  source: import_zod24.z.enum(["pdf", "manual", "imported", "generated"]).default("generated"),
-  rootNodeIds: import_zod24.z.array(import_zod24.z.string()).optional(),
-  nodes: import_zod24.z.array(ApplicationQuestionNodeSchema)
-});
-var ApplicationTemplateSchema = import_zod24.z.object({
-  id: import_zod24.z.string(),
-  version: import_zod24.z.string(),
-  title: import_zod24.z.string(),
-  applicationType: import_zod24.z.string().nullable().optional(),
+var ApplicationQuestionGraphSchema = import_zod25.z.object({
+  id: import_zod25.z.string(),
+  version: import_zod25.z.string(),
+  title: import_zod25.z.string().optional(),
+  applicationType: import_zod25.z.string().nullable().optional(),
+  source: import_zod25.z.enum(["pdf", "manual", "imported", "generated"]).default("generated"),
+  rootNodeIds: import_zod25.z.array(import_zod25.z.string()).optional(),
+  nodes: import_zod25.z.array(ApplicationQuestionNodeSchema)
+});
+var ApplicationTemplateSchema = import_zod25.z.object({
+  id: import_zod25.z.string(),
+  version: import_zod25.z.string(),
+  title: import_zod25.z.string(),
+  applicationType: import_zod25.z.string().nullable().optional(),
   questionGraph: ApplicationQuestionGraphSchema,
-  fields: import_zod24.z.array(ApplicationFieldSchema).optional()
-});
-var ApplicationClassifyResultSchema = import_zod24.z.object({
-  isApplication: import_zod24.z.boolean(),
-  confidence: import_zod24.z.number().min(0).max(1),
-  applicationType: import_zod24.z.string().nullable()
-});
-var FieldExtractionResultSchema = import_zod24.z.object({
-  fields: import_zod24.z.array(ApplicationFieldSchema)
-});
-var AutoFillMatchSchema = import_zod24.z.object({
-  fieldId: import_zod24.z.string(),
-  value: import_zod24.z.string(),
-  confidence: import_zod24.z.enum(["confirmed"]),
-  contextKey: import_zod24.z.string()
-});
-var AutoFillResultSchema = import_zod24.z.object({
-  matches: import_zod24.z.array(AutoFillMatchSchema)
-});
-var QuestionBatchResultSchema = import_zod24.z.object({
-  batches: import_zod24.z.array(import_zod24.z.array(import_zod24.z.string()).describe("Array of field IDs in this batch"))
-});
-var LookupRequestSchema = import_zod24.z.object({
-  type: import_zod24.z.string().describe("Type of lookup: 'records', 'website', 'policy'"),
-  description: import_zod24.z.string(),
-  url: import_zod24.z.string().optional(),
-  targetFieldIds: import_zod24.z.array(import_zod24.z.string())
-});
-var ReplyIntentSchema = import_zod24.z.object({
-  primaryIntent: import_zod24.z.enum(["answers_only", "question", "lookup_request", "mixed"]),
-  hasAnswers: import_zod24.z.boolean(),
-  questionText: import_zod24.z.string().optional(),
-  questionFieldIds: import_zod24.z.array(import_zod24.z.string()).optional(),
-  lookupRequests: import_zod24.z.array(LookupRequestSchema).optional()
-});
-var ParsedAnswerSchema = import_zod24.z.object({
-  fieldId: import_zod24.z.string(),
-  value: import_zod24.z.string(),
-  explanation: import_zod24.z.string().optional()
-});
-var AnswerParsingResultSchema = import_zod24.z.object({
-  answers: import_zod24.z.array(ParsedAnswerSchema),
-  unanswered: import_zod24.z.array(import_zod24.z.string()).describe("Field IDs that were not answered")
-});
-var LookupFillSchema = import_zod24.z.object({
-  fieldId: import_zod24.z.string(),
-  value: import_zod24.z.string(),
-  source: import_zod24.z.string().describe("Specific citable reference, e.g. 'GL Policy #POL-12345 (Hartford)'"),
-  sourceSpanIds: import_zod24.z.array(import_zod24.z.string()).optional()
+  fields: import_zod25.z.array(ApplicationFieldSchema).optional()
 });
-var LookupFillResultSchema = import_zod24.z.object({
-  fills: import_zod24.z.array(LookupFillSchema),
-  unfillable: import_zod24.z.array(import_zod24.z.string()),
-  explanation: import_zod24.z.string().optional()
-});
-var FlatPdfPlacementSchema = import_zod24.z.object({
-  fieldId: import_zod24.z.string(),
-  page: import_zod24.z.number(),
-  x: import_zod24.z.number().describe("Percentage from left edge (0-100)"),
-  y: import_zod24.z.number().describe("Percentage from top edge (0-100)"),
-  text: import_zod24.z.string(),
-  fontSize: import_zod24.z.number().optional(),
-  isCheckmark: import_zod24.z.boolean().optional()
-});
-var AcroFormMappingSchema = import_zod24.z.object({
-  fieldId: import_zod24.z.string(),
-  acroFormName: import_zod24.z.string(),
-  value: import_zod24.z.string()
-});
-var QualityGateStatusSchema = import_zod24.z.enum(["passed", "warning", "failed"]);
-var QualitySeveritySchema = import_zod24.z.enum(["info", "warning", "blocking"]);
-var ApplicationQualityIssueSchema = import_zod24.z.object({
-  code: import_zod24.z.string(),
+var ApplicationClassifyResultSchema = import_zod25.z.object({
+  isApplication: import_zod25.z.boolean(),
+  confidence: import_zod25.z.number().min(0).max(1),
+  applicationType: import_zod25.z.string().nullable()
+});
+var FieldExtractionResultSchema = import_zod25.z.object({
+  fields: import_zod25.z.array(ApplicationFieldSchema)
+});
+var AutoFillMatchSchema = import_zod25.z.object({
+  fieldId: import_zod25.z.string(),
+  value: import_zod25.z.string(),
+  confidence: import_zod25.z.enum(["confirmed"]),
+  contextKey: import_zod25.z.string()
+});
+var AutoFillResultSchema = import_zod25.z.object({
+  matches: import_zod25.z.array(AutoFillMatchSchema)
+});
+var QuestionBatchResultSchema = import_zod25.z.object({
+  batches: import_zod25.z.array(import_zod25.z.array(import_zod25.z.string()).describe("Array of field IDs in this batch"))
+});
+var LookupRequestSchema = import_zod25.z.object({
+  type: import_zod25.z.string().describe("Type of lookup: 'records', 'website', 'policy'"),
+  description: import_zod25.z.string(),
+  url: import_zod25.z.string().optional(),
+  targetFieldIds: import_zod25.z.array(import_zod25.z.string())
+});
+var ReplyIntentSchema = import_zod25.z.object({
+  primaryIntent: import_zod25.z.enum(["answers_only", "question", "lookup_request", "mixed"]),
+  hasAnswers: import_zod25.z.boolean(),
+  questionText: import_zod25.z.string().optional(),
+  questionFieldIds: import_zod25.z.array(import_zod25.z.string()).optional(),
+  lookupRequests: import_zod25.z.array(LookupRequestSchema).optional()
+});
+var ParsedAnswerSchema = import_zod25.z.object({
+  fieldId: import_zod25.z.string(),
+  value: import_zod25.z.string(),
+  explanation: import_zod25.z.string().optional()
+});
+var AnswerParsingResultSchema = import_zod25.z.object({
+  answers: import_zod25.z.array(ParsedAnswerSchema),
+  unanswered: import_zod25.z.array(import_zod25.z.string()).describe("Field IDs that were not answered")
+});
+var LookupFillSchema = import_zod25.z.object({
+  fieldId: import_zod25.z.string(),
+  value: import_zod25.z.string(),
+  source: import_zod25.z.string().describe("Specific citable reference, e.g. 'GL Policy #POL-12345 (Hartford)'"),
+  sourceSpanIds: import_zod25.z.array(import_zod25.z.string()).optional()
+});
+var LookupFillResultSchema = import_zod25.z.object({
+  fills: import_zod25.z.array(LookupFillSchema),
+  unfillable: import_zod25.z.array(import_zod25.z.string()),
+  explanation: import_zod25.z.string().optional()
+});
+var FlatPdfPlacementSchema = import_zod25.z.object({
+  fieldId: import_zod25.z.string(),
+  page: import_zod25.z.number(),
+  x: import_zod25.z.number().describe("Percentage from left edge (0-100)"),
+  y: import_zod25.z.number().describe("Percentage from top edge (0-100)"),
+  text: import_zod25.z.string(),
+  fontSize: import_zod25.z.number().optional(),
+  isCheckmark: import_zod25.z.boolean().optional()
+});
+var AcroFormMappingSchema = import_zod25.z.object({
+  fieldId: import_zod25.z.string(),
+  acroFormName: import_zod25.z.string(),
+  value: import_zod25.z.string()
+});
+var QualityGateStatusSchema = import_zod25.z.enum(["passed", "warning", "failed"]);
+var QualitySeveritySchema = import_zod25.z.enum(["info", "warning", "blocking"]);
+var ApplicationQualityIssueSchema = import_zod25.z.object({
+  code: import_zod25.z.string(),
   severity: QualitySeveritySchema,
-  message: import_zod24.z.string(),
-  fieldId: import_zod24.z.string().optional()
+  message: import_zod25.z.string(),
+  fieldId: import_zod25.z.string().optional()
 });
-var ApplicationQualityRoundSchema = import_zod24.z.object({
-  round: import_zod24.z.number(),
-  kind: import_zod24.z.string(),
+var ApplicationQualityRoundSchema = import_zod25.z.object({
+  round: import_zod25.z.number(),
+  kind: import_zod25.z.string(),
   status: QualityGateStatusSchema,
-  summary: import_zod24.z.string().optional()
+  summary: import_zod25.z.string().optional()
 });
-var ApplicationQualityArtifactSchema = import_zod24.z.object({
-  kind: import_zod24.z.string(),
-  label: import_zod24.z.string().optional(),
-  itemCount: import_zod24.z.number().optional()
+var ApplicationQualityArtifactSchema = import_zod25.z.object({
+  kind: import_zod25.z.string(),
+  label: import_zod25.z.string().optional(),
+  itemCount: import_zod25.z.number().optional()
 });
-var ApplicationEmailReviewSchema = import_zod24.z.object({
-  issues: import_zod24.z.array(ApplicationQualityIssueSchema),
+var ApplicationEmailReviewSchema = import_zod25.z.object({
+  issues: import_zod25.z.array(ApplicationQualityIssueSchema),
   qualityGateStatus: QualityGateStatusSchema
 });
-var ApplicationQualityReportSchema = import_zod24.z.object({
-  issues: import_zod24.z.array(ApplicationQualityIssueSchema),
-  rounds: import_zod24.z.array(ApplicationQualityRoundSchema).optional(),
-  artifacts: import_zod24.z.array(ApplicationQualityArtifactSchema).optional(),
+var ApplicationQualityReportSchema = import_zod25.z.object({
+  issues: import_zod25.z.array(ApplicationQualityIssueSchema),
+  rounds: import_zod25.z.array(ApplicationQualityRoundSchema).optional(),
+  artifacts: import_zod25.z.array(ApplicationQualityArtifactSchema).optional(),
   emailReview: ApplicationEmailReviewSchema.optional(),
   qualityGateStatus: QualityGateStatusSchema
 });
-var ApplicationContextProposalSchema = import_zod24.z.object({
-  id: import_zod24.z.string(),
-  fieldId: import_zod24.z.string().optional(),
-  key: import_zod24.z.string(),
-  value: import_zod24.z.string(),
-  category: import_zod24.z.string(),
-  source: import_zod24.z.enum(["application", "user", "lookup", "policy", "email", "chat", "imessage", "mcp"]),
-  confidence: import_zod24.z.enum(["confirmed", "high", "medium", "low"]),
-  sourceSpanIds: import_zod24.z.array(import_zod24.z.string()).optional(),
-  userSourceSpanIds: import_zod24.z.array(import_zod24.z.string()).optional()
-});
-var ApplicationPacketAnswerSchema = import_zod24.z.object({
-  fieldId: import_zod24.z.string(),
-  label: import_zod24.z.string(),
-  section: import_zod24.z.string(),
-  value: import_zod24.z.string(),
-  source: import_zod24.z.string(),
-  confidence: import_zod24.z.enum(["confirmed", "high", "medium", "low"]).optional(),
-  sourceSpanIds: import_zod24.z.array(import_zod24.z.string()).optional(),
-  userSourceSpanIds: import_zod24.z.array(import_zod24.z.string()).optional()
-});
-var ApplicationPacketSchema = import_zod24.z.object({
-  id: import_zod24.z.string(),
-  applicationId: import_zod24.z.string(),
-  title: import_zod24.z.string(),
-  status: import_zod24.z.enum(["draft", "broker_ready", "submitted"]),
-  answers: import_zod24.z.array(ApplicationPacketAnswerSchema),
-  missingFieldIds: import_zod24.z.array(import_zod24.z.string()),
+var ApplicationContextProposalSchema = import_zod25.z.object({
+  id: import_zod25.z.string(),
+  fieldId: import_zod25.z.string().optional(),
+  key: import_zod25.z.string(),
+  value: import_zod25.z.string(),
+  category: import_zod25.z.string(),
+  source: import_zod25.z.enum(["application", "user", "lookup", "policy", "email", "chat", "imessage", "mcp"]),
+  confidence: import_zod25.z.enum(["confirmed", "high", "medium", "low"]),
+  sourceSpanIds: import_zod25.z.array(import_zod25.z.string()).optional(),
+  userSourceSpanIds: import_zod25.z.array(import_zod25.z.string()).optional()
+});
+var ApplicationPacketAnswerSchema = import_zod25.z.object({
+  fieldId: import_zod25.z.string(),
+  label: import_zod25.z.string(),
+  section: import_zod25.z.string(),
+  value: import_zod25.z.string(),
+  source: import_zod25.z.string(),
+  confidence: import_zod25.z.enum(["confirmed", "high", "medium", "low"]).optional(),
+  sourceSpanIds: import_zod25.z.array(import_zod25.z.string()).optional(),
+  userSourceSpanIds: import_zod25.z.array(import_zod25.z.string()).optional()
+});
+var ApplicationPacketSchema = import_zod25.z.object({
+  id: import_zod25.z.string(),
+  applicationId: import_zod25.z.string(),
+  title: import_zod25.z.string(),
+  status: import_zod25.z.enum(["draft", "broker_ready", "submitted"]),
+  answers: import_zod25.z.array(ApplicationPacketAnswerSchema),
+  missingFieldIds: import_zod25.z.array(import_zod25.z.string()),
   qualityReport: ApplicationQualityReportSchema,
-  submissionNotes: import_zod24.z.string().optional(),
-  createdAt: import_zod24.z.number()
-});
-var ApplicationStateSchema = import_zod24.z.object({
-  id: import_zod24.z.string(),
-  pdfBase64: import_zod24.z.string().optional().describe("Original PDF, omitted after extraction"),
-  templateId: import_zod24.z.string().optional(),
-  templateVersion: import_zod24.z.string().optional(),
+  submissionNotes: import_zod25.z.string().optional(),
+  createdAt: import_zod25.z.number()
+});
+var ApplicationStateSchema = import_zod25.z.object({
+  id: import_zod25.z.string(),
+  pdfBase64: import_zod25.z.string().optional().describe("Original PDF, omitted after extraction"),
+  templateId: import_zod25.z.string().optional(),
+  templateVersion: import_zod25.z.string().optional(),
   templateSnapshot: ApplicationTemplateSchema.optional(),
-  title: import_zod24.z.string().optional(),
-  applicationType: import_zod24.z.string().nullable().optional(),
+  title: import_zod25.z.string().optional(),
+  applicationType: import_zod25.z.string().nullable().optional(),
   questionGraph: ApplicationQuestionGraphSchema.optional(),
-  fields: import_zod24.z.array(ApplicationFieldSchema),
-  batches: import_zod24.z.array(import_zod24.z.array(import_zod24.z.string())).optional(),
-  currentBatchIndex: import_zod24.z.number().default(0),
-  contextProposals: import_zod24.z.array(ApplicationContextProposalSchema).optional(),
+  fields: import_zod25.z.array(ApplicationFieldSchema),
+  batches: import_zod25.z.array(import_zod25.z.array(import_zod25.z.string())).optional(),
+  currentBatchIndex: import_zod25.z.number().default(0),
+  contextProposals: import_zod25.z.array(ApplicationContextProposalSchema).optional(),
   packet: ApplicationPacketSchema.optional(),
   qualityReport: ApplicationQualityReportSchema.optional(),
-  status: import_zod24.z.enum([
+  status: import_zod25.z.enum([
     "classifying",
     "extracting",
     "auto_filling",
@@ -8444,8 +9320,8 @@ var ApplicationStateSchema = import_zod24.z.object({
     "cancelled",
     "complete"
   ]),
-  createdAt: import_zod24.z.number(),
-  updatedAt: import_zod24.z.number()
+  createdAt: import_zod25.z.number(),
+  updatedAt: import_zod25.z.number()
 });
 
 // src/application/agents/classifier.ts
@@ -10179,106 +11055,106 @@ Respond with the final answer, deduplicated citations array, overall confidence
 }
 
 // src/schemas/query.ts
-var import_zod25 = require("zod");
-var QueryIntentSchema = import_zod25.z.enum([
+var import_zod26 = require("zod");
+var QueryIntentSchema = import_zod26.z.enum([
   "policy_question",
   "coverage_comparison",
   "document_search",
   "claims_inquiry",
   "general_knowledge"
 ]);
-var QueryAttachmentKindSchema = import_zod25.z.enum(["image", "pdf", "text"]);
-var QueryAttachmentSchema = import_zod25.z.object({
-  id: import_zod25.z.string().optional().describe("Optional stable attachment ID from the caller"),
+var QueryAttachmentKindSchema = import_zod26.z.enum(["image", "pdf", "text"]);
+var QueryAttachmentSchema = import_zod26.z.object({
+  id: import_zod26.z.string().optional().describe("Optional stable attachment ID from the caller"),
   kind: QueryAttachmentKindSchema,
-  name: import_zod25.z.string().optional().describe("Original filename or user-facing label"),
-  mimeType: import_zod25.z.string().optional().describe("MIME type such as image/jpeg or application/pdf"),
-  base64: import_zod25.z.string().optional().describe("Base64-encoded file content for image/pdf attachments"),
-  text: import_zod25.z.string().optional().describe("Plain-text attachment content when available"),
-  description: import_zod25.z.string().optional().describe("Caller-provided description of the attachment")
+  name: import_zod26.z.string().optional().describe("Original filename or user-facing label"),
+  mimeType: import_zod26.z.string().optional().describe("MIME type such as image/jpeg or application/pdf"),
+  base64: import_zod26.z.string().optional().describe("Base64-encoded file content for image/pdf attachments"),
+  text: import_zod26.z.string().optional().describe("Plain-text attachment content when available"),
+  description: import_zod26.z.string().optional().describe("Caller-provided description of the attachment")
 });
-var QueryRetrievalModeSchema = import_zod25.z.enum([
+var QueryRetrievalModeSchema = import_zod26.z.enum([
   "graph_only",
   "source_rag",
   "long_context",
   "hybrid"
 ]);
-var SubQuestionSchema = import_zod25.z.object({
-  question: import_zod25.z.string().describe("Atomic sub-question to retrieve and answer independently"),
+var SubQuestionSchema = import_zod26.z.object({
+  question: import_zod26.z.string().describe("Atomic sub-question to retrieve and answer independently"),
   intent: QueryIntentSchema,
-  chunkTypes: import_zod25.z.array(import_zod25.z.string()).optional().describe("Chunk types to filter retrieval (e.g. coverage, endorsement, declaration)"),
-  documentFilters: import_zod25.z.object({
-    type: import_zod25.z.enum(["policy", "quote"]).optional(),
-    carrier: import_zod25.z.string().optional(),
-    insuredName: import_zod25.z.string().optional(),
-    policyNumber: import_zod25.z.string().optional(),
-    quoteNumber: import_zod25.z.string().optional(),
-    linesOfBusiness: import_zod25.z.array(AcordLobCodeSchema).optional().describe("Filter by ACORD line of business code (e.g. HOME, AUTOP, DISAB) to avoid mixing up similar policies")
+  chunkTypes: import_zod26.z.array(import_zod26.z.string()).optional().describe("Chunk types to filter retrieval (e.g. coverage, endorsement, declaration)"),
+  documentFilters: import_zod26.z.object({
+    type: import_zod26.z.enum(["policy", "quote"]).optional(),
+    carrier: import_zod26.z.string().optional(),
+    insuredName: import_zod26.z.string().optional(),
+    policyNumber: import_zod26.z.string().optional(),
+    quoteNumber: import_zod26.z.string().optional(),
+    linesOfBusiness: import_zod26.z.array(AcordLobCodeSchema).optional().describe("Filter by ACORD line of business code (e.g. HOME, AUTOP, DISAB) to avoid mixing up similar policies")
   }).optional().describe("Structured filters to narrow document lookup")
 });
-var QueryClassifyResultSchema = import_zod25.z.object({
+var QueryClassifyResultSchema = import_zod26.z.object({
   intent: QueryIntentSchema,
-  subQuestions: import_zod25.z.array(SubQuestionSchema).min(1).describe("Decomposed atomic sub-questions"),
-  requiresDocumentLookup: import_zod25.z.boolean().describe("Whether structured document lookup is needed"),
-  requiresChunkSearch: import_zod25.z.boolean().describe("Whether semantic chunk search is needed"),
-  requiresConversationHistory: import_zod25.z.boolean().describe("Whether conversation history is relevant"),
+  subQuestions: import_zod26.z.array(SubQuestionSchema).min(1).describe("Decomposed atomic sub-questions"),
+  requiresDocumentLookup: import_zod26.z.boolean().describe("Whether structured document lookup is needed"),
+  requiresChunkSearch: import_zod26.z.boolean().describe("Whether semantic chunk search is needed"),
+  requiresConversationHistory: import_zod26.z.boolean().describe("Whether conversation history is relevant"),
   retrievalMode: QueryRetrievalModeSchema.optional().describe("Preferred retrieval strategy for the query when source-span retrieval is available")
 });
-var EvidenceItemSchema = import_zod25.z.object({
-  source: import_zod25.z.enum(["chunk", "document", "conversation", "attachment", "source_span", "source_node"]),
-  chunkId: import_zod25.z.string().optional(),
-  sourceNodeId: import_zod25.z.string().optional(),
-  sourceSpanId: import_zod25.z.string().optional(),
-  documentId: import_zod25.z.string().optional(),
-  turnId: import_zod25.z.string().optional(),
-  attachmentId: import_zod25.z.string().optional(),
-  text: import_zod25.z.string().describe("Text excerpt from the source"),
-  relevance: import_zod25.z.number().min(0).max(1),
+var EvidenceItemSchema = import_zod26.z.object({
+  source: import_zod26.z.enum(["chunk", "document", "conversation", "attachment", "source_span", "source_node"]),
+  chunkId: import_zod26.z.string().optional(),
+  sourceNodeId: import_zod26.z.string().optional(),
+  sourceSpanId: import_zod26.z.string().optional(),
+  documentId: import_zod26.z.string().optional(),
+  turnId: import_zod26.z.string().optional(),
+  attachmentId: import_zod26.z.string().optional(),
+  text: import_zod26.z.string().describe("Text excerpt from the source"),
+  relevance: import_zod26.z.number().min(0).max(1),
   retrievalMode: QueryRetrievalModeSchema.optional(),
   sourceLocation: SourceSpanLocationSchema.optional(),
-  metadata: import_zod25.z.array(import_zod25.z.object({ key: import_zod25.z.string(), value: import_zod25.z.string() })).optional()
-});
-var AttachmentInterpretationSchema = import_zod25.z.object({
-  summary: import_zod25.z.string().describe("Concise summary of what the attachment shows or contains"),
-  extractedFacts: import_zod25.z.array(import_zod25.z.string()).describe("Specific observable or document facts grounded in the attachment"),
-  recommendedFocus: import_zod25.z.array(import_zod25.z.string()).describe("Important details to incorporate when answering follow-up questions"),
-  confidence: import_zod25.z.number().min(0).max(1)
-});
-var RetrievalResultSchema = import_zod25.z.object({
-  subQuestion: import_zod25.z.string(),
-  evidence: import_zod25.z.array(EvidenceItemSchema)
-});
-var CitationSchema = import_zod25.z.object({
-  index: import_zod25.z.number().describe("Citation number [1], [2], etc."),
-  chunkId: import_zod25.z.string().optional().describe("Source chunk ID, e.g. doc-123:coverage:2"),
-  sourceNodeId: import_zod25.z.string().optional().describe("Source tree node ID when available"),
-  sourceSpanId: import_zod25.z.string().optional().describe("Precise source span ID when available"),
-  documentId: import_zod25.z.string(),
-  documentType: import_zod25.z.enum(["policy", "quote"]).optional(),
-  field: import_zod25.z.string().optional().describe("Specific field path, e.g. coverages[0].deductible"),
-  quote: import_zod25.z.string().describe("Exact text from source that supports the claim"),
-  relevance: import_zod25.z.number().min(0).max(1),
+  metadata: import_zod26.z.array(import_zod26.z.object({ key: import_zod26.z.string(), value: import_zod26.z.string() })).optional()
+});
+var AttachmentInterpretationSchema = import_zod26.z.object({
+  summary: import_zod26.z.string().describe("Concise summary of what the attachment shows or contains"),
+  extractedFacts: import_zod26.z.array(import_zod26.z.string()).describe("Specific observable or document facts grounded in the attachment"),
+  recommendedFocus: import_zod26.z.array(import_zod26.z.string()).describe("Important details to incorporate when answering follow-up questions"),
+  confidence: import_zod26.z.number().min(0).max(1)
+});
+var RetrievalResultSchema = import_zod26.z.object({
+  subQuestion: import_zod26.z.string(),
+  evidence: import_zod26.z.array(EvidenceItemSchema)
+});
+var CitationSchema = import_zod26.z.object({
+  index: import_zod26.z.number().describe("Citation number [1], [2], etc."),
+  chunkId: import_zod26.z.string().optional().describe("Source chunk ID, e.g. doc-123:coverage:2"),
+  sourceNodeId: import_zod26.z.string().optional().describe("Source tree node ID when available"),
+  sourceSpanId: import_zod26.z.string().optional().describe("Precise source span ID when available"),
+  documentId: import_zod26.z.string(),
+  documentType: import_zod26.z.enum(["policy", "quote"]).optional(),
+  field: import_zod26.z.string().optional().describe("Specific field path, e.g. coverages[0].deductible"),
+  quote: import_zod26.z.string().describe("Exact text from source that supports the claim"),
+  relevance: import_zod26.z.number().min(0).max(1),
   retrievalMode: QueryRetrievalModeSchema.optional(),
   sourceLocation: SourceSpanLocationSchema.optional()
 });
-var SubAnswerSchema = import_zod25.z.object({
-  subQuestion: import_zod25.z.string(),
-  answer: import_zod25.z.string(),
-  citations: import_zod25.z.array(CitationSchema),
-  confidence: import_zod25.z.number().min(0).max(1),
-  needsMoreContext: import_zod25.z.boolean().describe("True if evidence was insufficient to answer fully")
-});
-var VerifyResultSchema = import_zod25.z.object({
-  approved: import_zod25.z.boolean().describe("Whether all sub-answers are adequately grounded"),
-  issues: import_zod25.z.array(import_zod25.z.string()).describe("Specific grounding or consistency issues found"),
-  retrySubQuestions: import_zod25.z.array(import_zod25.z.string()).optional().describe("Sub-questions that need additional retrieval or re-reasoning")
-});
-var QueryResultSchema = import_zod25.z.object({
-  answer: import_zod25.z.string(),
-  citations: import_zod25.z.array(CitationSchema),
+var SubAnswerSchema = import_zod26.z.object({
+  subQuestion: import_zod26.z.string(),
+  answer: import_zod26.z.string(),
+  citations: import_zod26.z.array(CitationSchema),
+  confidence: import_zod26.z.number().min(0).max(1),
+  needsMoreContext: import_zod26.z.boolean().describe("True if evidence was insufficient to answer fully")
+});
+var VerifyResultSchema = import_zod26.z.object({
+  approved: import_zod26.z.boolean().describe("Whether all sub-answers are adequately grounded"),
+  issues: import_zod26.z.array(import_zod26.z.string()).describe("Specific grounding or consistency issues found"),
+  retrySubQuestions: import_zod26.z.array(import_zod26.z.string()).optional().describe("Sub-questions that need additional retrieval or re-reasoning")
+});
+var QueryResultSchema = import_zod26.z.object({
+  answer: import_zod26.z.string(),
+  citations: import_zod26.z.array(CitationSchema),
   intent: QueryIntentSchema,
-  confidence: import_zod25.z.number().min(0).max(1),
-  followUp: import_zod25.z.string().optional().describe("Suggested follow-up question if applicable")
+  confidence: import_zod26.z.number().min(0).max(1),
+  followUp: import_zod26.z.string().optional().describe("Suggested follow-up question if applicable")
 });
 
 // src/query/retriever.ts
@@ -11345,7 +12221,7 @@ ${sa.answer}`).join("\n\n"),
 }
 
 // src/pce/index.ts
-var import_zod26 = require("zod");
+var import_zod27 = require("zod");
 
 // src/prompts/pce/index.ts
 function buildPceNormalizePrompt(input) {
@@ -11379,11 +12255,11 @@ ${input.openQuestions.map((question) => `- ${question.id}${question.fieldPath ?
 }
 
 // src/pce/index.ts
-var ReplyAnswersSchema = import_zod26.z.object({
-  answers: import_zod26.z.array(import_zod26.z.object({
-    questionId: import_zod26.z.string().optional(),
-    fieldPath: import_zod26.z.string().optional(),
-    answer: import_zod26.z.string()
+var ReplyAnswersSchema = import_zod27.z.object({
+  answers: import_zod27.z.array(import_zod27.z.object({
+    questionId: import_zod27.z.string().optional(),
+    fieldPath: import_zod27.z.string().optional(),
+    answer: import_zod27.z.string()
   }))
 });
 function createPceAgent(config = {}) {
@@ -12137,23 +13013,23 @@ var AGENT_TOOLS = [
 ];
 
 // src/prompts/extractors/carrier-info.ts
-var import_zod27 = require("zod");
-var CarrierInfoSchema = import_zod27.z.object({
-  carrierName: import_zod27.z.string().describe("Primary insurance company name for display"),
-  carrierLegalName: import_zod27.z.string().optional().describe("Legal entity name of insurer"),
-  naicNumber: import_zod27.z.string().optional().describe("NAIC company code"),
-  amBestRating: import_zod27.z.string().optional().describe("AM Best rating, e.g. 'A+ XV'"),
-  admittedStatus: import_zod27.z.enum(["admitted", "non_admitted", "surplus_lines"]).optional().describe("Admitted status of the carrier"),
-  mga: import_zod27.z.string().optional().describe("Managing General Agent or Program Administrator name"),
-  underwriter: import_zod27.z.string().optional().describe("Named individual underwriter"),
-  brokerAgency: import_zod27.z.string().optional().describe("Broker or producer agency name"),
-  brokerContactName: import_zod27.z.string().optional().describe("Broker or producer contact person name"),
-  brokerLicenseNumber: import_zod27.z.string().optional().describe("Broker or producer license number"),
-  policyNumber: import_zod27.z.string().optional().describe("Policy or quote reference number"),
-  effectiveDate: import_zod27.z.string().optional().describe("Policy effective date (MM/DD/YYYY)"),
-  expirationDate: import_zod27.z.string().optional().describe("Policy expiration date (MM/DD/YYYY)"),
-  quoteNumber: import_zod27.z.string().optional().describe("Quote or proposal reference number"),
-  proposedEffectiveDate: import_zod27.z.string().optional().describe("Proposed effective date for quotes (MM/DD/YYYY)")
+var import_zod28 = require("zod");
+var CarrierInfoSchema = import_zod28.z.object({
+  carrierName: import_zod28.z.string().describe("Primary insurance company name for display"),
+  carrierLegalName: import_zod28.z.string().optional().describe("Legal entity name of insurer"),
+  naicNumber: import_zod28.z.string().optional().describe("NAIC company code"),
+  amBestRating: import_zod28.z.string().optional().describe("AM Best rating, e.g. 'A+ XV'"),
+  admittedStatus: import_zod28.z.enum(["admitted", "non_admitted", "surplus_lines"]).optional().describe("Admitted status of the carrier"),
+  mga: import_zod28.z.string().optional().describe("Managing General Agent or Program Administrator name"),
+  underwriter: import_zod28.z.string().optional().describe("Named individual underwriter"),
+  brokerAgency: import_zod28.z.string().optional().describe("Broker or producer agency name"),
+  brokerContactName: import_zod28.z.string().optional().describe("Broker or producer contact person name"),
+  brokerLicenseNumber: import_zod28.z.string().optional().describe("Broker or producer license number"),
+  policyNumber: import_zod28.z.string().optional().describe("Policy or quote reference number"),
+  effectiveDate: import_zod28.z.string().optional().describe("Policy effective date (MM/DD/YYYY)"),
+  expirationDate: import_zod28.z.string().optional().describe("Policy expiration date (MM/DD/YYYY)"),
+  quoteNumber: import_zod28.z.string().optional().describe("Quote or proposal reference number"),
+  proposedEffectiveDate: import_zod28.z.string().optional().describe("Proposed effective date for quotes (MM/DD/YYYY)")
 });
 function buildCarrierInfoPrompt() {
   return `You are an expert insurance document analyst. Extract carrier and policy identification information from this document.
@@ -12176,21 +13052,21 @@ Return JSON only.`;
 }
 
 // src/prompts/extractors/named-insured.ts
-var import_zod28 = require("zod");
-var AdditionalNamedInsuredSchema = import_zod28.z.object({
-  name: import_zod28.z.string(),
-  relationship: import_zod28.z.string().optional().describe("e.g. subsidiary, affiliate"),
+var import_zod29 = require("zod");
+var AdditionalNamedInsuredSchema = import_zod29.z.object({
+  name: import_zod29.z.string(),
+  relationship: import_zod29.z.string().optional().describe("e.g. subsidiary, affiliate"),
   address: SourceBackedAddressSchema.optional()
 }).merge(SourceProvenanceSchema);
-var ScheduledPartySchema = import_zod28.z.object({
-  name: import_zod28.z.string(),
+var ScheduledPartySchema = import_zod29.z.object({
+  name: import_zod29.z.string(),
   address: SourceBackedAddressSchema.optional()
 }).merge(SourceProvenanceSchema);
-var NamedInsuredSchema2 = import_zod28.z.object({
-  insuredName: import_zod28.z.string().describe("Name of primary named insured"),
-  insuredDba: import_zod28.z.string().optional().describe("Doing-business-as name"),
+var NamedInsuredSchema2 = import_zod29.z.object({
+  insuredName: import_zod29.z.string().describe("Name of primary named insured"),
+  insuredDba: import_zod29.z.string().optional().describe("Doing-business-as name"),
   insuredAddress: SourceBackedAddressSchema.optional().describe("Primary insured mailing address"),
-  insuredEntityType: import_zod28.z.enum([
+  insuredEntityType: import_zod29.z.enum([
     "corporation",
     "llc",
     "partnership",
@@ -12203,12 +13079,12 @@ var NamedInsuredSchema2 = import_zod28.z.object({
     "married_couple",
     "other"
   ]).optional().describe("Legal entity type of the insured"),
-  insuredFein: import_zod28.z.string().optional().describe("Federal Employer Identification Number"),
-  insuredSicCode: import_zod28.z.string().optional().describe("SIC code"),
-  insuredNaicsCode: import_zod28.z.string().optional().describe("NAICS code"),
-  additionalNamedInsureds: import_zod28.z.array(AdditionalNamedInsuredSchema).optional().describe("Additional named insureds listed on the policy"),
-  lossPayees: import_zod28.z.array(ScheduledPartySchema).optional().describe("Loss payees listed on the policy"),
-  mortgageHolders: import_zod28.z.array(ScheduledPartySchema).optional().describe("Mortgage holders / lienholders listed on the policy")
+  insuredFein: import_zod29.z.string().optional().describe("Federal Employer Identification Number"),
+  insuredSicCode: import_zod29.z.string().optional().describe("SIC code"),
+  insuredNaicsCode: import_zod29.z.string().optional().describe("NAICS code"),
+  additionalNamedInsureds: import_zod29.z.array(AdditionalNamedInsuredSchema).optional().describe("Additional named insureds listed on the policy"),
+  lossPayees: import_zod29.z.array(ScheduledPartySchema).optional().describe("Loss payees listed on the policy"),
+  mortgageHolders: import_zod29.z.array(ScheduledPartySchema).optional().describe("Mortgage holders / lienholders listed on the policy")
 });
 function buildNamedInsuredPrompt() {
   return `You are an expert insurance document analyst. Extract all named insured information from this document.
@@ -12235,14 +13111,14 @@ Return JSON only.`;
 }
 
 // src/prompts/extractors/coverage-limits.ts
-var import_zod29 = require("zod");
+var import_zod30 = require("zod");
 var ExtractorCoverageSchema = CoverageSchema.extend({
-  coverageCode: import_zod29.z.string().optional().describe("Coverage code or class code")
+  coverageCode: import_zod30.z.string().optional().describe("Coverage code or class code")
 });
-var CoverageLimitsSchema = import_zod29.z.object({
-  coverages: import_zod29.z.array(ExtractorCoverageSchema).describe("All coverages with their limits"),
-  coverageForm: import_zod29.z.enum(["occurrence", "claims_made", "accident"]).optional().describe("Primary coverage trigger type"),
-  retroactiveDate: import_zod29.z.string().optional().describe("Retroactive date for claims-made policies (MM/DD/YYYY)")
+var CoverageLimitsSchema = import_zod30.z.object({
+  coverages: import_zod30.z.array(ExtractorCoverageSchema).describe("All coverages with their limits"),
+  coverageForm: import_zod30.z.enum(["occurrence", "claims_made", "accident"]).optional().describe("Primary coverage trigger type"),
+  retroactiveDate: import_zod30.z.string().optional().describe("Retroactive date for claims-made policies (MM/DD/YYYY)")
 });
 function buildCoverageLimitsPrompt() {
   return `You are an expert insurance document analyst. Extract all coverage limits and deductibles from this document.
@@ -12284,14 +13160,14 @@ Return JSON only.`;
 }
 
 // src/prompts/extractors/endorsements.ts
-var import_zod30 = require("zod");
-var EndorsementsSchema = import_zod30.z.object({
-  endorsements: import_zod30.z.array(
-    import_zod30.z.object({
-      formNumber: import_zod30.z.string().describe("Form number, e.g. 'CG 21 47'"),
-      editionDate: import_zod30.z.string().optional().describe("Edition date, e.g. '12 07'"),
-      title: import_zod30.z.string().describe("Endorsement title"),
-      endorsementType: import_zod30.z.enum([
+var import_zod31 = require("zod");
+var EndorsementsSchema = import_zod31.z.object({
+  endorsements: import_zod31.z.array(
+    import_zod31.z.object({
+      formNumber: import_zod31.z.string().describe("Form number, e.g. 'CG 21 47'"),
+      editionDate: import_zod31.z.string().optional().describe("Edition date, e.g. '12 07'"),
+      title: import_zod31.z.string().describe("Endorsement title"),
+      endorsementType: import_zod31.z.enum([
         "additional_insured",
         "waiver_of_subrogation",
         "primary_noncontributory",
@@ -12311,12 +13187,12 @@ var EndorsementsSchema = import_zod30.z.object({
         "territorial_extension",
         "other"
       ]).describe("Endorsement type classification"),
-      effectiveDate: import_zod30.z.string().optional().describe("Endorsement effective date"),
-      affectedCoverageParts: import_zod30.z.array(import_zod30.z.string()).optional().describe("Coverage parts affected by this endorsement"),
-      namedParties: import_zod30.z.array(
-        import_zod30.z.object({
-          name: import_zod30.z.string().describe("Party name"),
-          role: import_zod30.z.enum([
+      effectiveDate: import_zod31.z.string().optional().describe("Endorsement effective date"),
+      affectedCoverageParts: import_zod31.z.array(import_zod31.z.string()).optional().describe("Coverage parts affected by this endorsement"),
+      namedParties: import_zod31.z.array(
+        import_zod31.z.object({
+          name: import_zod31.z.string().describe("Party name"),
+          role: import_zod31.z.enum([
             "additional_insured",
             "loss_payee",
             "mortgage_holder",
@@ -12325,18 +13201,18 @@ var EndorsementsSchema = import_zod30.z.object({
             "designated_person",
             "other"
           ]).describe("Party role"),
-          relationship: import_zod30.z.string().optional().describe("Relationship to insured"),
-          scope: import_zod30.z.string().optional().describe("Scope of coverage for this party")
+          relationship: import_zod31.z.string().optional().describe("Relationship to insured"),
+          scope: import_zod31.z.string().optional().describe("Scope of coverage for this party")
         })
       ).optional().describe("Named parties (additional insureds, loss payees, etc.)"),
-      keyTerms: import_zod30.z.array(import_zod30.z.string()).optional().describe("Key terms or notable provisions in the endorsement"),
-      premiumImpact: import_zod30.z.string().optional().describe("Additional premium or credit"),
-      excerpt: import_zod30.z.string().optional().describe("Short source excerpt, not full verbatim text"),
-      content: import_zod30.z.string().optional().describe("Legacy fallback only; do not return full text when sourceSpanIds are available"),
-      pageStart: import_zod30.z.number().describe("Starting page number of this endorsement"),
-      pageEnd: import_zod30.z.number().optional().describe("Ending page number of this endorsement"),
-      sourceSpanIds: import_zod30.z.array(import_zod30.z.string()).optional().describe("Source span IDs grounding this endorsement"),
-      sourceTextHash: import_zod30.z.string().optional().describe("Hash of the source text when available")
+      keyTerms: import_zod31.z.array(import_zod31.z.string()).optional().describe("Key terms or notable provisions in the endorsement"),
+      premiumImpact: import_zod31.z.string().optional().describe("Additional premium or credit"),
+      excerpt: import_zod31.z.string().optional().describe("Short source excerpt, not full verbatim text"),
+      content: import_zod31.z.string().optional().describe("Legacy fallback only; do not return full text when sourceSpanIds are available"),
+      pageStart: import_zod31.z.number().describe("Starting page number of this endorsement"),
+      pageEnd: import_zod31.z.number().optional().describe("Ending page number of this endorsement"),
+      sourceSpanIds: import_zod31.z.array(import_zod31.z.string()).optional().describe("Source span IDs grounding this endorsement"),
+      sourceTextHash: import_zod31.z.string().optional().describe("Hash of the source text when available")
     })
   ).describe("All endorsements found in the document")
 });
@@ -12374,20 +13250,20 @@ Return JSON only.`;
 }
 
 // src/prompts/extractors/exclusions.ts
-var import_zod31 = require("zod");
-var ExclusionsSchema = import_zod31.z.object({
-  exclusions: import_zod31.z.array(
-    import_zod31.z.object({
-      name: import_zod31.z.string().describe("Exclusion title or short description"),
-      formNumber: import_zod31.z.string().optional().describe("Form number if part of a named endorsement"),
-      excludedPerils: import_zod31.z.array(import_zod31.z.string()).optional().describe("Specific perils excluded"),
-      isAbsolute: import_zod31.z.boolean().optional().describe("Whether the exclusion is absolute (no exceptions)"),
-      exceptions: import_zod31.z.array(import_zod31.z.string()).optional().describe("Exceptions to the exclusion, if any"),
-      buybackAvailable: import_zod31.z.boolean().optional().describe("Whether coverage can be bought back via endorsement"),
-      buybackEndorsement: import_zod31.z.string().optional().describe("Form number of the buyback endorsement if available"),
-      appliesTo: import_zod31.z.array(import_zod31.z.string()).optional().describe("Policy types this exclusion applies to"),
-      content: import_zod31.z.string().describe("Full verbatim exclusion text"),
-      pageNumber: import_zod31.z.number().optional().describe("Page number where exclusion appears")
+var import_zod32 = require("zod");
+var ExclusionsSchema = import_zod32.z.object({
+  exclusions: import_zod32.z.array(
+    import_zod32.z.object({
+      name: import_zod32.z.string().describe("Exclusion title or short description"),
+      formNumber: import_zod32.z.string().optional().describe("Form number if part of a named endorsement"),
+      excludedPerils: import_zod32.z.array(import_zod32.z.string()).optional().describe("Specific perils excluded"),
+      isAbsolute: import_zod32.z.boolean().optional().describe("Whether the exclusion is absolute (no exceptions)"),
+      exceptions: import_zod32.z.array(import_zod32.z.string()).optional().describe("Exceptions to the exclusion, if any"),
+      buybackAvailable: import_zod32.z.boolean().optional().describe("Whether coverage can be bought back via endorsement"),
+      buybackEndorsement: import_zod32.z.string().optional().describe("Form number of the buyback endorsement if available"),
+      appliesTo: import_zod32.z.array(import_zod32.z.string()).optional().describe("Policy types this exclusion applies to"),
+      content: import_zod32.z.string().describe("Full verbatim exclusion text"),
+      pageNumber: import_zod32.z.number().optional().describe("Page number where exclusion appears")
     })
   ).describe("All exclusions found in the document")
 });
@@ -12423,12 +13299,12 @@ Return JSON only.`;
 }
 
 // src/prompts/extractors/conditions.ts
-var import_zod32 = require("zod");
-var ConditionsSchema = import_zod32.z.object({
-  conditions: import_zod32.z.array(
-    import_zod32.z.object({
-      name: import_zod32.z.string().describe("Condition title"),
-      conditionType: import_zod32.z.enum([
+var import_zod33 = require("zod");
+var ConditionsSchema = import_zod33.z.object({
+  conditions: import_zod33.z.array(
+    import_zod33.z.object({
+      name: import_zod33.z.string().describe("Condition title"),
+      conditionType: import_zod33.z.enum([
         "duties_after_loss",
         "notice_requirements",
         "other_insurance",
@@ -12447,14 +13323,14 @@ var ConditionsSchema = import_zod32.z.object({
         "separation_of_insureds",
         "other"
       ]).describe("Condition category"),
-      content: import_zod32.z.string().describe("Full verbatim condition text"),
-      keyValues: import_zod32.z.array(
-        import_zod32.z.object({
-          key: import_zod32.z.string().describe("Key name (e.g. 'noticePeriod', 'suitDeadline')"),
-          value: import_zod32.z.string().describe("Value (e.g. '30 days', '2 years')")
+      content: import_zod33.z.string().describe("Full verbatim condition text"),
+      keyValues: import_zod33.z.array(
+        import_zod33.z.object({
+          key: import_zod33.z.string().describe("Key name (e.g. 'noticePeriod', 'suitDeadline')"),
+          value: import_zod33.z.string().describe("Value (e.g. '30 days', '2 years')")
         })
       ).optional().describe("Key values extracted from the condition (notice periods, deadlines, etc.)"),
-      pageNumber: import_zod32.z.number().optional().describe("Page number where condition appears")
+      pageNumber: import_zod33.z.number().optional().describe("Page number where condition appears")
     })
   ).describe("All policy conditions found in the document")
 });
@@ -12492,34 +13368,34 @@ Return JSON only.`;
 }
 
 // src/prompts/extractors/premium-breakdown.ts
-var import_zod33 = require("zod");
-var PremiumBreakdownSchema = import_zod33.z.object({
-  premium: import_zod33.z.string().optional().describe("Total premium amount, e.g. '$5,000'"),
-  premiumAmount: import_zod33.z.number().optional().describe("Total premium as a plain number with no currency symbols or commas"),
-  totalCost: import_zod33.z.string().optional().describe("Total cost including taxes and fees, e.g. '$5,250'"),
-  totalCostAmount: import_zod33.z.number().optional().describe("Total cost as a plain number with no currency symbols or commas"),
-  premiumBreakdown: import_zod33.z.array(
-    import_zod33.z.object({
-      line: import_zod33.z.string().describe("Coverage line name"),
-      amount: import_zod33.z.string().describe("Premium amount for this line"),
-      amountValue: import_zod33.z.number().optional().describe("Premium amount as a plain number with no currency symbols or commas")
+var import_zod34 = require("zod");
+var PremiumBreakdownSchema = import_zod34.z.object({
+  premium: import_zod34.z.string().optional().describe("Total premium amount, e.g. '$5,000'"),
+  premiumAmount: import_zod34.z.number().optional().describe("Total premium as a plain number with no currency symbols or commas"),
+  totalCost: import_zod34.z.string().optional().describe("Total cost including taxes and fees, e.g. '$5,250'"),
+  totalCostAmount: import_zod34.z.number().optional().describe("Total cost as a plain number with no currency symbols or commas"),
+  premiumBreakdown: import_zod34.z.array(
+    import_zod34.z.object({
+      line: import_zod34.z.string().describe("Coverage line name"),
+      amount: import_zod34.z.string().describe("Premium amount for this line"),
+      amountValue: import_zod34.z.number().optional().describe("Premium amount as a plain number with no currency symbols or commas")
     })
   ).optional().describe("Per-coverage-line premium breakdown"),
-  taxesAndFees: import_zod33.z.array(
-    import_zod33.z.object({
-      name: import_zod33.z.string().describe("Fee or tax name"),
-      amount: import_zod33.z.string().describe("Dollar amount"),
-      amountValue: import_zod33.z.number().optional().describe("Fee or tax amount as a plain number with no currency symbols or commas"),
-      type: import_zod33.z.enum(["tax", "fee", "surcharge", "assessment"]).optional().describe("Fee category")
+  taxesAndFees: import_zod34.z.array(
+    import_zod34.z.object({
+      name: import_zod34.z.string().describe("Fee or tax name"),
+      amount: import_zod34.z.string().describe("Dollar amount"),
+      amountValue: import_zod34.z.number().optional().describe("Fee or tax amount as a plain number with no currency symbols or commas"),
+      type: import_zod34.z.enum(["tax", "fee", "surcharge", "assessment"]).optional().describe("Fee category")
     })
   ).optional().describe("Taxes, fees, surcharges, and assessments"),
-  minimumPremium: import_zod33.z.string().optional().describe("Minimum premium if stated"),
-  minimumPremiumAmount: import_zod33.z.number().optional().describe("Minimum premium as a plain number when the source states a fixed amount"),
-  depositPremium: import_zod33.z.string().optional().describe("Deposit premium if stated"),
-  depositPremiumAmount: import_zod33.z.number().optional().describe("Deposit premium as a plain number when the source states a fixed amount"),
-  paymentPlan: import_zod33.z.string().optional().describe("Payment plan description"),
-  auditType: import_zod33.z.enum(["annual", "semi_annual", "quarterly", "monthly", "final", "self"]).optional().describe("Premium audit type"),
-  ratingBasis: import_zod33.z.string().optional().describe("Rating basis, e.g. payroll, revenue, area, units")
+  minimumPremium: import_zod34.z.string().optional().describe("Minimum premium if stated"),
+  minimumPremiumAmount: import_zod34.z.number().optional().describe("Minimum premium as a plain number when the source states a fixed amount"),
+  depositPremium: import_zod34.z.string().optional().describe("Deposit premium if stated"),
+  depositPremiumAmount: import_zod34.z.number().optional().describe("Deposit premium as a plain number when the source states a fixed amount"),
+  paymentPlan: import_zod34.z.string().optional().describe("Payment plan description"),
+  auditType: import_zod34.z.enum(["annual", "semi_annual", "quarterly", "monthly", "final", "self"]).optional().describe("Premium audit type"),
+  ratingBasis: import_zod34.z.string().optional().describe("Rating basis, e.g. payroll, revenue, area, units")
 });
 function buildPremiumBreakdownPrompt() {
   return `You are an expert insurance document analyst. Extract all premium and cost information from this document.
@@ -12541,14 +13417,14 @@ Return JSON only.`;
 }
 
 // src/prompts/extractors/declarations.ts
-var import_zod34 = require("zod");
-var DeclarationsFieldSchema = import_zod34.z.object({
-  field: import_zod34.z.string().describe("Descriptive field name (e.g. 'policyNumber', 'effectiveDate', 'coverageALimit')"),
-  value: import_zod34.z.string().describe("Extracted value exactly as it appears in the document"),
-  section: import_zod34.z.string().optional().describe("Section or grouping this field belongs to (e.g. 'Coverage Limits', 'Vehicle Schedule')")
+var import_zod35 = require("zod");
+var DeclarationsFieldSchema = import_zod35.z.object({
+  field: import_zod35.z.string().describe("Descriptive field name (e.g. 'policyNumber', 'effectiveDate', 'coverageALimit')"),
+  value: import_zod35.z.string().describe("Extracted value exactly as it appears in the document"),
+  section: import_zod35.z.string().optional().describe("Section or grouping this field belongs to (e.g. 'Coverage Limits', 'Vehicle Schedule')")
 });
-var DeclarationsExtractSchema = import_zod34.z.object({
-  fields: import_zod34.z.array(DeclarationsFieldSchema).describe("All declarations page fields extracted as key-value pairs. Structure varies by line of business.")
+var DeclarationsExtractSchema = import_zod35.z.object({
+  fields: import_zod35.z.array(DeclarationsFieldSchema).describe("All declarations page fields extracted as key-value pairs. Structure varies by line of business.")
 });
 function buildDeclarationsPrompt() {
   return `You are an expert insurance document analyst. Extract all declarations page data from this document into a flexible key-value structure.
@@ -12588,21 +13464,21 @@ Preserve original values exactly as they appear. Return JSON only.`;
 }
 
 // src/prompts/extractors/loss-history.ts
-var import_zod35 = require("zod");
-var LossHistorySchema = import_zod35.z.object({
-  lossSummary: import_zod35.z.string().optional().describe("Summary of loss history, e.g. '3 claims in past 5 years totaling $125,000'"),
-  individualClaims: import_zod35.z.array(
-    import_zod35.z.object({
-      date: import_zod35.z.string().optional().describe("Date of loss or claim"),
-      type: import_zod35.z.string().optional().describe("Type of claim, e.g. 'property damage', 'bodily injury'"),
-      description: import_zod35.z.string().optional().describe("Brief description of the claim"),
-      amountPaid: import_zod35.z.string().optional().describe("Amount paid"),
-      amountReserved: import_zod35.z.string().optional().describe("Amount reserved"),
-      status: import_zod35.z.enum(["open", "closed", "reopened"]).optional().describe("Claim status"),
-      claimNumber: import_zod35.z.string().optional().describe("Claim reference number")
+var import_zod36 = require("zod");
+var LossHistorySchema = import_zod36.z.object({
+  lossSummary: import_zod36.z.string().optional().describe("Summary of loss history, e.g. '3 claims in past 5 years totaling $125,000'"),
+  individualClaims: import_zod36.z.array(
+    import_zod36.z.object({
+      date: import_zod36.z.string().optional().describe("Date of loss or claim"),
+      type: import_zod36.z.string().optional().describe("Type of claim, e.g. 'property damage', 'bodily injury'"),
+      description: import_zod36.z.string().optional().describe("Brief description of the claim"),
+      amountPaid: import_zod36.z.string().optional().describe("Amount paid"),
+      amountReserved: import_zod36.z.string().optional().describe("Amount reserved"),
+      status: import_zod36.z.enum(["open", "closed", "reopened"]).optional().describe("Claim status"),
+      claimNumber: import_zod36.z.string().optional().describe("Claim reference number")
     })
   ).optional().describe("Individual claim records"),
-  experienceMod: import_zod35.z.string().optional().describe("Experience modification factor for workers comp, e.g. '0.85'")
+  experienceMod: import_zod36.z.string().optional().describe("Experience modification factor for workers comp, e.g. '0.85'")
 });
 function buildLossHistoryPrompt() {
   return `You are an expert insurance document analyst. Extract all loss history and claims information from this document.
@@ -12619,21 +13495,21 @@ Return JSON only.`;
 }
 
 // src/prompts/extractors/sections.ts
-var import_zod36 = require("zod");
-var SubsectionSchema2 = import_zod36.z.object({
-  title: import_zod36.z.string().describe("Subsection title"),
-  sectionNumber: import_zod36.z.string().optional().describe("Subsection number"),
-  pageNumber: import_zod36.z.number().optional().describe("Page number"),
-  excerpt: import_zod36.z.string().optional().describe("Short source excerpt, not full verbatim text"),
-  content: import_zod36.z.string().optional().describe("Legacy fallback only; do not return full text when sourceSpanIds are available"),
-  sourceSpanIds: import_zod36.z.array(import_zod36.z.string()).optional().describe("Source span IDs grounding this subsection"),
-  sourceTextHash: import_zod36.z.string().optional().describe("Hash of the source text when available")
-});
-var SectionsSchema = import_zod36.z.object({
-  sections: import_zod36.z.array(
-    import_zod36.z.object({
-      title: import_zod36.z.string().describe("Section title"),
-      type: import_zod36.z.enum([
+var import_zod37 = require("zod");
+var SubsectionSchema2 = import_zod37.z.object({
+  title: import_zod37.z.string().describe("Subsection title"),
+  sectionNumber: import_zod37.z.string().optional().describe("Subsection number"),
+  pageNumber: import_zod37.z.number().optional().describe("Page number"),
+  excerpt: import_zod37.z.string().optional().describe("Short source excerpt, not full verbatim text"),
+  content: import_zod37.z.string().optional().describe("Legacy fallback only; do not return full text when sourceSpanIds are available"),
+  sourceSpanIds: import_zod37.z.array(import_zod37.z.string()).optional().describe("Source span IDs grounding this subsection"),
+  sourceTextHash: import_zod37.z.string().optional().describe("Hash of the source text when available")
+});
+var SectionsSchema = import_zod37.z.object({
+  sections: import_zod37.z.array(
+    import_zod37.z.object({
+      title: import_zod37.z.string().describe("Section title"),
+      type: import_zod37.z.enum([
         "declarations",
         "insuring_agreement",
         "policy_form",
@@ -12648,13 +13524,13 @@ var SectionsSchema = import_zod36.z.object({
         "regulatory",
         "other"
       ]).describe("Section type classification"),
-      excerpt: import_zod36.z.string().optional().describe("Short source excerpt, not full verbatim text"),
-      content: import_zod36.z.string().optional().describe("Legacy fallback only; do not return full text when sourceSpanIds are available"),
-      pageStart: import_zod36.z.number().describe("Starting page number"),
-      pageEnd: import_zod36.z.number().optional().describe("Ending page number"),
-      sourceSpanIds: import_zod36.z.array(import_zod36.z.string()).optional().describe("Source span IDs grounding this section"),
-      sourceTextHash: import_zod36.z.string().optional().describe("Hash of the source text when available"),
-      subsections: import_zod36.z.array(SubsectionSchema2).optional().describe("Subsections within this section")
+      excerpt: import_zod37.z.string().optional().describe("Short source excerpt, not full verbatim text"),
+      content: import_zod37.z.string().optional().describe("Legacy fallback only; do not return full text when sourceSpanIds are available"),
+      pageStart: import_zod37.z.number().describe("Starting page number"),
+      pageEnd: import_zod37.z.number().optional().describe("Ending page number"),
+      sourceSpanIds: import_zod37.z.array(import_zod37.z.string()).optional().describe("Source span IDs grounding this section"),
+      sourceTextHash: import_zod37.z.string().optional().describe("Hash of the source text when available"),
+      subsections: import_zod37.z.array(SubsectionSchema2).optional().describe("Subsections within this section")
     })
   ).describe("All document sections")
 });
@@ -12688,20 +13564,20 @@ Return JSON only.`;
 }
 
 // src/prompts/extractors/supplementary.ts
-var import_zod37 = require("zod");
-var AuxiliaryFactSchema2 = import_zod37.z.object({
-  key: import_zod37.z.string().describe("Normalized machine-readable fact key, e.g. 'policyholder_age' or 'insured_name'"),
-  value: import_zod37.z.string().describe("Concrete extracted fact value"),
-  subject: import_zod37.z.string().optional().describe("Person, entity, vehicle, property, or schedule item this fact belongs to"),
-  context: import_zod37.z.string().optional().describe("Short disambiguating context, such as 'Driver Schedule' or 'Named Insured'")
-});
-var SupplementarySchema = import_zod37.z.object({
-  regulatoryContacts: import_zod37.z.array(ContactSchema).optional().describe("Regulatory body contacts (state department of insurance, ombudsman)"),
-  claimsContacts: import_zod37.z.array(ContactSchema).optional().describe("Claims reporting contacts and instructions"),
-  thirdPartyAdministrators: import_zod37.z.array(ContactSchema).optional().describe("Third-party administrators for claims handling"),
-  cancellationNoticeDays: import_zod37.z.number().optional().describe("Required notice period for cancellation in days"),
-  nonrenewalNoticeDays: import_zod37.z.number().optional().describe("Required notice period for nonrenewal in days"),
-  auxiliaryFacts: import_zod37.z.array(AuxiliaryFactSchema2).optional().describe("Additional retrieval-only facts that do not fit the strict primary schema")
+var import_zod38 = require("zod");
+var AuxiliaryFactSchema2 = import_zod38.z.object({
+  key: import_zod38.z.string().describe("Normalized machine-readable fact key, e.g. 'policyholder_age' or 'insured_name'"),
+  value: import_zod38.z.string().describe("Concrete extracted fact value"),
+  subject: import_zod38.z.string().optional().describe("Person, entity, vehicle, property, or schedule item this fact belongs to"),
+  context: import_zod38.z.string().optional().describe("Short disambiguating context, such as 'Driver Schedule' or 'Named Insured'")
+});
+var SupplementarySchema = import_zod38.z.object({
+  regulatoryContacts: import_zod38.z.array(ContactSchema).optional().describe("Regulatory body contacts (state department of insurance, ombudsman)"),
+  claimsContacts: import_zod38.z.array(ContactSchema).optional().describe("Claims reporting contacts and instructions"),
+  thirdPartyAdministrators: import_zod38.z.array(ContactSchema).optional().describe("Third-party administrators for claims handling"),
+  cancellationNoticeDays: import_zod38.z.number().optional().describe("Required notice period for cancellation in days"),
+  nonrenewalNoticeDays: import_zod38.z.number().optional().describe("Required notice period for nonrenewal in days"),
+  auxiliaryFacts: import_zod38.z.array(AuxiliaryFactSchema2).optional().describe("Additional retrieval-only facts that do not fit the strict primary schema")
 });
 function buildSupplementaryPrompt(alreadyExtractedSummary) {
   const exclusionBlock = alreadyExtractedSummary ? `
@@ -12741,17 +13617,17 @@ Return JSON only.`;
 }
 
 // src/prompts/extractors/definitions.ts
-var import_zod38 = require("zod");
-var DefinitionsSchema = import_zod38.z.object({
-  definitions: import_zod38.z.array(
-    import_zod38.z.object({
-      term: import_zod38.z.string().describe("Defined term exactly as shown in the document"),
-      definition: import_zod38.z.string().describe("Full verbatim definition text, preserving original wording"),
-      pageNumber: import_zod38.z.number().optional().describe("Original document page number"),
-      formNumber: import_zod38.z.string().optional().describe("Form number where this definition appears"),
-      formTitle: import_zod38.z.string().optional().describe("Form title where this definition appears"),
-      sectionRef: import_zod38.z.string().optional().describe("Definition section heading or subsection reference"),
-      originalContent: import_zod38.z.string().optional().describe("Short verbatim source snippet containing the term and definition")
+var import_zod39 = require("zod");
+var DefinitionsSchema = import_zod39.z.object({
+  definitions: import_zod39.z.array(
+    import_zod39.z.object({
+      term: import_zod39.z.string().describe("Defined term exactly as shown in the document"),
+      definition: import_zod39.z.string().describe("Full verbatim definition text, preserving original wording"),
+      pageNumber: import_zod39.z.number().optional().describe("Original document page number"),
+      formNumber: import_zod39.z.string().optional().describe("Form number where this definition appears"),
+      formTitle: import_zod39.z.string().optional().describe("Form title where this definition appears"),
+      sectionRef: import_zod39.z.string().optional().describe("Definition section heading or subsection reference"),
+      originalContent: import_zod39.z.string().optional().describe("Short verbatim source snippet containing the term and definition")
     })
   ).describe("All substantive insurance definitions found in the document")
 });
@@ -12785,22 +13661,22 @@ Return JSON only.`;
 }
 
 // src/prompts/extractors/covered-reasons.ts
-var import_zod39 = require("zod");
-var CoveredReasonsSchema = import_zod39.z.object({
-  coveredReasons: import_zod39.z.array(
-    import_zod39.z.object({
-      coverageName: import_zod39.z.string().describe("Coverage, coverage part, or form this covered reason belongs to"),
-      reasonNumber: import_zod39.z.string().optional().describe("Source number or letter for the covered reason, if shown"),
-      title: import_zod39.z.string().optional().describe("Covered reason title, peril, cause of loss, trigger, or short name"),
-      content: import_zod39.z.string().describe("Full verbatim covered-reason or insuring-agreement text"),
-      conditions: import_zod39.z.array(import_zod39.z.string()).optional().describe("Conditions, timing rules, documentation requirements, or prerequisites attached to this covered reason"),
-      exceptions: import_zod39.z.array(import_zod39.z.string()).optional().describe("Exceptions or limitations attached to this covered reason"),
-      appliesTo: import_zod39.z.array(import_zod39.z.string()).optional().describe("Covered property, persons, autos, locations, operations, or coverage parts this reason applies to"),
-      pageNumber: import_zod39.z.number().optional().describe("Original document page number"),
-      formNumber: import_zod39.z.string().optional().describe("Form number where this covered reason appears"),
-      formTitle: import_zod39.z.string().optional().describe("Form title where this covered reason appears"),
-      sectionRef: import_zod39.z.string().optional().describe("Section heading where this covered reason appears"),
-      originalContent: import_zod39.z.string().optional().describe("Short verbatim source snippet used for this covered reason")
+var import_zod40 = require("zod");
+var CoveredReasonsSchema = import_zod40.z.object({
+  coveredReasons: import_zod40.z.array(
+    import_zod40.z.object({
+      coverageName: import_zod40.z.string().describe("Coverage, coverage part, or form this covered reason belongs to"),
+      reasonNumber: import_zod40.z.string().optional().describe("Source number or letter for the covered reason, if shown"),
+      title: import_zod40.z.string().optional().describe("Covered reason title, peril, cause of loss, trigger, or short name"),
+      content: import_zod40.z.string().describe("Full verbatim covered-reason or insuring-agreement text"),
+      conditions: import_zod40.z.array(import_zod40.z.string()).optional().describe("Conditions, timing rules, documentation requirements, or prerequisites attached to this covered reason"),
+      exceptions: import_zod40.z.array(import_zod40.z.string()).optional().describe("Exceptions or limitations attached to this covered reason"),
+      appliesTo: import_zod40.z.array(import_zod40.z.string()).optional().describe("Covered property, persons, autos, locations, operations, or coverage parts this reason applies to"),
+      pageNumber: import_zod40.z.number().optional().describe("Original document page number"),
+      formNumber: import_zod40.z.string().optional().describe("Form number where this covered reason appears"),
+      formTitle: import_zod40.z.string().optional().describe("Form title where this covered reason appears"),
+      sectionRef: import_zod40.z.string().optional().describe("Section heading where this covered reason appears"),
+      originalContent: import_zod40.z.string().optional().describe("Short verbatim source snippet used for this covered reason")
     })
   ).describe("Covered causes, perils, triggers, or reasons that affirmatively grant coverage")
 });
@@ -13793,10 +14669,15 @@ function getTemplate(policyType) {
   NamedInsuredSchema,
   OperationalAddressSchema,
   OperationalCoverageLineSchema,
+  OperationalCoverageScheduleItemSchema,
+  OperationalCoverageScheduleSchema,
+  OperationalCoverageScheduleValueSchema,
   OperationalCoverageTermSchema,
   OperationalDeclarationFactSchema,
   OperationalEndorsementSupportSchema,
   OperationalPartySchema,
+  OperationalPremiumLineSchema,
+  OperationalTaxFeeItemSchema,
   PERSONAL_AUTO_USAGES,
   PERSONAL_LOB_CODES,
   PET_SPECIES,
@@ -13983,6 +14864,8 @@ function getTemplate(policyType) {
   proposeContextWrites,
   resolveModelBudget,
   resolveOperationalProfileLinesOfBusiness,
+  runCoverageRecovery,
+  runSourceTreeExtraction,
   safeGenerateObject,
   sanitizeNulls,
   scoreCaseProposal,