@claritylabs/cl-sdk 1.3.2 → 1.3.4

package/dist/index.js

@@ -908,6 +908,7 @@ var FormReferenceSchema = import_zod3.z.object({
 var TaxFeeItemSchema = import_zod3.z.object({
   name: import_zod3.z.string(),
   amount: import_zod3.z.string(),
+  amountValue: import_zod3.z.number().optional(),
   type: import_zod3.z.enum(["tax", "fee", "surcharge", "assessment"]).optional(),
   description: import_zod3.z.string().optional()
 });
@@ -952,9 +953,11 @@ var CoverageValueTypeSchema = import_zod4.z.enum([
 var CoverageSchema = import_zod4.z.object({
   name: import_zod4.z.string(),
   limit: import_zod4.z.string(),
+  limitAmount: import_zod4.z.number().optional(),
   limitType: LimitTypeSchema.optional(),
   limitValueType: CoverageValueTypeSchema.optional(),
   deductible: import_zod4.z.string().optional(),
+  deductibleAmount: import_zod4.z.number().optional(),
   deductibleValueType: CoverageValueTypeSchema.optional(),
   formNumber: import_zod4.z.string().optional(),
   pageNumber: import_zod4.z.number().optional(),
@@ -970,9 +973,11 @@ var EnrichedCoverageSchema = import_zod4.z.object({
   formNumber: import_zod4.z.string().optional(),
   formEditionDate: import_zod4.z.string().optional(),
   limit: import_zod4.z.string(),
+  limitAmount: import_zod4.z.number().optional(),
   limitType: LimitTypeSchema.optional(),
   limitValueType: CoverageValueTypeSchema.optional(),
   deductible: import_zod4.z.string().optional(),
+  deductibleAmount: import_zod4.z.number().optional(),
   deductibleType: DeductibleTypeSchema.optional(),
   deductibleValueType: CoverageValueTypeSchema.optional(),
   sir: import_zod4.z.string().optional(),
@@ -1653,7 +1658,8 @@ var UnderwritingConditionSchema = import_zod16.z.object({
 });
 var PremiumLineSchema = import_zod16.z.object({
   line: import_zod16.z.string(),
-  amount: import_zod16.z.string()
+  amount: import_zod16.z.string(),
+  amountValue: import_zod16.z.number().optional()
 });
 var AuxiliaryFactSchema = import_zod16.z.object({
   key: import_zod16.z.string(),
@@ -1696,6 +1702,7 @@ var BaseDocumentFields = {
   security: import_zod16.z.string().optional(),
   insuredName: import_zod16.z.string(),
   premium: import_zod16.z.string().optional(),
+  premiumAmount: import_zod16.z.number().optional(),
   summary: import_zod16.z.string().optional(),
   policyTypes: import_zod16.z.array(import_zod16.z.string()).optional(),
   coverages: import_zod16.z.array(CoverageSchema),
@@ -1747,8 +1754,11 @@ var BaseDocumentFields = {
   mortgageHolders: import_zod16.z.array(EndorsementPartySchema).optional(),
   taxesAndFees: import_zod16.z.array(TaxFeeItemSchema).optional(),
   totalCost: import_zod16.z.string().optional(),
+  totalCostAmount: import_zod16.z.number().optional(),
   minimumPremium: import_zod16.z.string().optional(),
+  minimumPremiumAmount: import_zod16.z.number().optional(),
   depositPremium: import_zod16.z.string().optional(),
+  depositPremiumAmount: import_zod16.z.number().optional(),
   paymentPlan: PaymentPlanSchema.optional(),
   auditType: AuditTypeSchema.optional(),
   ratingBasis: import_zod16.z.array(RatingBasisSchema).optional(),
@@ -3229,16 +3239,6 @@ function findFieldValue(fields, patterns, reject) {
   const match = fields.find((f) => fieldMatches(f.field, patterns) && !reject?.(f));
   return match?.value;
 }
-function stringValue(value) {
-  return typeof value === "string" && value.trim() ? value : void 0;
-}
-function findRawString(raw, keys) {
-  for (const key of keys) {
-    const value = stringValue(raw[key]);
-    if (value) return value;
-  }
-  return void 0;
-}
 function promoteRawFields(raw, mappings) {
   for (const { from, to } of mappings) {
     if (!raw[to] && raw[from]) {
@@ -3250,11 +3250,6 @@ function promoteRawFields(raw, mappings) {
 function findRawOrDeclarationValue(raw, fields, lookup) {
   return (lookup.rawKey ? raw[lookup.rawKey] : void 0) || findFieldValue(fields, lookup.patterns, lookup.reject);
 }
-function promoteRawOrDeclarationString(raw, fields, targetKey, rawKeys, lookup) {
-  if (raw[targetKey]) return;
-  const value = findRawString(raw, rawKeys) ?? findFieldValue(fields, lookup.patterns, lookup.reject);
-  if (value) raw[targetKey] = value;
-}
 function promoteCarrierFields(doc) {
   const raw = doc;
   promoteRawFields(raw, [
@@ -3454,298 +3449,11 @@ function promoteLocations(doc) {
     raw.locations = locations;
   }
 }
-function normalizeName(name) {
-  return name.toLowerCase().replace(/[^a-z0-9]/g, "");
-}
-var LIMIT_COVERAGE_MAP = [
-  // GL standard
-  [["eachoccurrence", "peroccurrence", "occurrencecombined"], "perOccurrence"],
-  [["generalaggregate"], "generalAggregate"],
-  [["productscompletedoperationsaggregate", "productscompletedopsaggregate", "prodcompopsagg"], "productsCompletedOpsAggregate"],
-  [["personaladvertisinginjury", "personaladvinjury", "pai"], "personalAdvertisingInjury"],
-  [["firedamage", "firedamagelegalliability", "damagetorentedpremises", "damagetopremisesrentedtoyou"], "fireDamage"],
-  [["medicalexpense", "medexp", "medicalexpenseanypersonanyperson", "medicalexpenseanyone"], "medicalExpense"],
-  // Auto
-  [["combinedsingle", "combinedsinglelimit", "csl"], "combinedSingleLimit"],
-  [["bodilyinjuryperperson", "biperperson"], "bodilyInjuryPerPerson"],
-  [["bodilyinjuryperaccident", "biperaccident"], "bodilyInjuryPerAccident"],
-  [["propertydamage", "pdperaccident"], "propertyDamage"],
-  // Umbrella/Excess
-  [["umbrellaoccurrence", "eachoccurrenceumbrella", "excessoccurrence", "excesseachoccurrence"], "eachOccurrenceUmbrella"],
-  [["umbrellaaggregate", "excessaggregate"], "umbrellaAggregate"],
-  [["umbrella retention", "selfinsuredretention", "sir", "excessretention"], "umbrellaRetention"]
-];
-function synthesizeLimits(doc) {
-  const raw = doc;
-  if (raw.limits && typeof raw.limits === "object" && Object.keys(raw.limits).length > 0) return;
-  const coverages = doc.coverages;
-  if (!coverages || coverages.length === 0) return;
-  const limits = {};
-  for (const cov of coverages) {
-    if (!cov.name || !cov.limit) continue;
-    const normalized = normalizeName(cov.name);
-    for (const [patterns, fieldName] of LIMIT_COVERAGE_MAP) {
-      if (patterns.some((p) => normalized.includes(p) || p.includes(normalized))) {
-        if (fieldName.includes("Aggregate") || fieldName.includes("aggregate")) {
-          if (!cov.limitType || cov.limitType === "aggregate") {
-            limits[fieldName] = cov.limit;
-          }
-        } else {
-          if (!limits[fieldName]) {
-            limits[fieldName] = cov.limit;
-          }
-        }
-        break;
-      }
-    }
-  }
-  const hasStatutory = coverages.some(
-    (c) => c.limitType === "statutory" || normalizeName(c.name ?? "").includes("statutory")
-  );
-  if (hasStatutory) {
-    limits.statutory = "true";
-  }
-  const elCoverages = coverages.filter(
-    (c) => normalizeName(c.name ?? "").includes("employersliability")
-  );
-  if (elCoverages.length > 0) {
-    const el = {};
-    for (const c of elCoverages) {
-      if (!c.limit) continue;
-      const n = normalizeName(c.name ?? "");
-      if (n.includes("accident") || n.includes("eachaccident")) el.eachAccident = c.limit;
-      else if (n.includes("diseasepolicy") || n.includes("diseasepolicylimit")) el.diseasePolicyLimit = c.limit;
-      else if (n.includes("diseaseemployee") || n.includes("diseaseeachemployee")) el.diseaseEachEmployee = c.limit;
-      else if (!el.eachAccident) el.eachAccident = c.limit;
-    }
-    if (Object.keys(el).length > 0) {
-      limits.employersLiability = el;
-    }
-  }
-  if (Object.keys(limits).length > 0) {
-    const result = { ...limits };
-    if (result.statutory === "true") result.statutory = true;
-    raw.limits = result;
-  }
-}
-function synthesizeDeductibles(doc) {
-  const raw = doc;
-  if (raw.deductibles && typeof raw.deductibles === "object" && Object.keys(raw.deductibles).length > 0) return;
-  const coverages = doc.coverages;
-  if (!coverages || coverages.length === 0) return;
-  const deductibleValues = coverages.filter((c) => c.deductible && c.deductible.trim() !== "" && c.deductible !== "N/A" && c.deductible !== "None").map((c) => c.deductible);
-  if (deductibleValues.length === 0) return;
-  const freq = /* @__PURE__ */ new Map();
-  for (const d of deductibleValues) {
-    freq.set(d, (freq.get(d) ?? 0) + 1);
-  }
-  let mostCommon = deductibleValues[0];
-  let maxFreq = 0;
-  for (const [val, count] of freq) {
-    if (count > maxFreq) {
-      mostCommon = val;
-      maxFreq = count;
-    }
-  }
-  const deductibles = {};
-  const hasPerClaim = coverages.some(
-    (c) => c.deductible && normalizeName(c.name ?? "").includes("perclaim")
-  );
-  if (hasPerClaim) {
-    deductibles.perClaim = mostCommon;
-  } else {
-    deductibles.perOccurrence = mostCommon;
-  }
-  const sirCoverage = coverages.find(
-    (c) => c.deductible && (normalizeName(c.name ?? "").includes("selfinsuredretention") || normalizeName(c.name ?? "").includes("sir"))
-  );
-  if (sirCoverage?.deductible) {
-    deductibles.selfInsuredRetention = sirCoverage.deductible;
-  }
-  const aggDed = coverages.find(
-    (c) => c.deductible && normalizeName(c.name ?? "").includes("aggregatedeductible")
-  );
-  if (aggDed?.deductible) {
-    deductibles.aggregateDeductible = aggDed.deductible;
-  }
-  if (Object.keys(deductibles).length > 0) {
-    raw.deductibles = deductibles;
-  }
-}
-var PREMIUM_PATTERNS = [
-  "premium",
-  "premiumAmount",
-  "premium amount",
-  "totalPremium",
-  "total premium",
-  "totalPolicyPremium",
-  "total policy premium",
-  "annualPremium",
-  "annual premium",
-  "estimatedAnnualPremium",
-  "estimated annual premium",
-  "policyPremium",
-  "policy premium",
-  "basePremium",
-  "base premium",
-  "planCost",
-  "plan cost",
-  "policyCost",
-  "policy cost",
-  "premiumSubtotal",
-  "premium subtotal",
-  "subtotalPremium",
-  "subtotal premium",
-  "quotedPremium",
-  "quoted premium"
-];
-var TOTAL_COST_PATTERNS = [
-  "totalCost",
-  "total cost",
-  "total",
-  "totalDue",
-  "total due",
-  "amountPaid",
-  "amount paid",
-  "totalPaid",
-  "total paid",
-  "totalPrice",
-  "total price",
-  "totalTripCost",
-  "total trip cost",
-  "amountCharged",
-  "amount charged",
-  "amountDue",
-  "amount due",
-  "totalAmountDue",
-  "total amount due",
-  "totalAmount",
-  "total amount",
-  "grandTotal",
-  "grand total",
-  "totalPayable",
-  "total payable",
-  "totalCharges",
-  "total charges",
-  "totalPolicyCost",
-  "total policy cost"
-];
-var PREMIUM_RAW_KEYS = [
-  "premium",
-  "premiumAmount",
-  "premium_amount",
-  "totalPremium",
-  "totalPolicyPremium",
-  "annualPremium",
-  "estimatedAnnualPremium",
-  "policyPremium",
-  "basePremium",
-  "planCost",
-  "policyCost",
-  "premiumSubtotal",
-  "subtotalPremium",
-  "quotedPremium"
-];
-var TOTAL_COST_RAW_KEYS = [
-  "totalCost",
-  "total_cost",
-  "total",
-  "totalDue",
-  "amountPaid",
-  "amount_paid",
-  "totalPaid",
-  "total_paid",
-  "totalPrice",
-  "totalTripCost",
-  "amountCharged",
-  "amountDue",
-  "totalAmountDue",
-  "totalAmount",
-  "grandTotal",
-  "totalPayable",
-  "totalCharges",
-  "totalPolicyCost"
-];
-function isTaxOrFeeField(fieldName) {
-  const normalized = normalizeFieldName(fieldName);
-  return /tax|gst|hst|pst|qst|fee|surcharge|assessment|stamp|filing|inspection/.test(normalized);
-}
-function isTotalCostField(fieldName) {
-  return fieldMatches(fieldName, TOTAL_COST_PATTERNS);
-}
-function taxFeeType(fieldName) {
-  const normalized = normalizeFieldName(fieldName);
-  if (normalized.includes("tax") || ["gst", "hst", "pst", "qst"].some((token) => normalized.includes(token))) return "tax";
-  if (normalized.includes("surcharge")) return "surcharge";
-  if (normalized.includes("assessment")) return "assessment";
-  if (normalized.includes("fee") || normalized.includes("stamp") || normalized.includes("filing")) return "fee";
-  return void 0;
-}
-function titleizeFieldName(fieldName) {
-  const spaced = fieldName.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[_-]+/g, " ").replace(/\s+/g, " ").trim();
-  return spaced.replace(/\b\w/g, (letter) => letter.toUpperCase());
-}
-function taxFeeKey(item) {
-  return [
-    normalizeFieldName(item.name),
-    normalizeFieldName(item.amount),
-    item.type ?? ""
-  ].join("|");
-}
-function taxFeeItemFromField(field) {
-  const type = taxFeeType(field.field);
-  return {
-    name: titleizeFieldName(field.field),
-    amount: absorbNegative(field.value),
-    ...type ? { type } : {}
-  };
-}
-function absorbNegative(value) {
-  return value.replace(/^-\s*/, "").replace(/^\(\s*(.*?)\s*\)$/, "$1");
-}
-function promotePremium(doc) {
-  const raw = doc;
-  const fields = getDeclarationFields(doc);
-  promoteRawOrDeclarationString(raw, fields, "premium", PREMIUM_RAW_KEYS, {
-    patterns: PREMIUM_PATTERNS,
-    reject: (field) => isTaxOrFeeField(field.field)
-  });
-  promoteRawOrDeclarationString(raw, fields, "totalCost", TOTAL_COST_RAW_KEYS, {
-    patterns: TOTAL_COST_PATTERNS
-  });
-  if (typeof raw.premium === "string") raw.premium = absorbNegative(raw.premium);
-  if (typeof raw.totalCost === "string") raw.totalCost = absorbNegative(raw.totalCost);
-}
-function synthesizeTaxesAndFees(doc) {
-  const raw = doc;
-  const fields = getDeclarationFields(doc);
-  if (fields.length === 0) return;
-  const existing = Array.isArray(raw.taxesAndFees) ? raw.taxesAndFees : [];
-  const byKey = /* @__PURE__ */ new Map();
-  for (const item of existing) {
-    if (!item?.name || !item?.amount) continue;
-    byKey.set(taxFeeKey(item), item);
-  }
-  for (const field of fields) {
-    if (!field.value?.trim()) continue;
-    if (!isTaxOrFeeField(field.field)) continue;
-    if (isTotalCostField(field.field)) continue;
-    const item = taxFeeItemFromField(field);
-    byKey.set(taxFeeKey(item), item);
-  }
-  if (byKey.size > 0) {
-    raw.taxesAndFees = [...byKey.values()];
-  }
-}
 function promoteExtractedFields(doc) {
   promoteCarrierFields(doc);
   promoteBroker(doc);
   promoteLossPayees(doc);
   promoteLocations(doc);
-  synthesizeLimits(doc);
-  synthesizeDeductibles(doc);
-  synthesizeTaxesAndFees(doc);
-  promotePremium(doc);
 }
 
 // src/extraction/alignment.ts
@@ -6468,6 +6176,12 @@ Focus on:
 
 Look on the declarations page, named insured schedule, loss payee schedule, mortgagee schedule, and any endorsements that add or modify named insureds, loss payees, or mortgage holders.
 
+Critical rules:
+- Prefer declaration-table labels such as "Named Insured", "Named Insured and Address", "Applicant", or "Insured" over contact blocks, notice contacts, authorized officers, licensing statements, signatures, and corporate-authority wording.
+- Do not use an authorized officer, broker, producer, contact person, officer title, email address owner, or licensing/entity-status statement as the primary insured unless that exact person/entity is explicitly labeled as the named insured.
+- If a row combines the insured name with a mailing address, put the legal name in insuredName and the mailing address in insuredAddress.
+- Entity type must come from the insured's own legal suffix or an explicit declaration field, not from generic incorporation/licensing notices elsewhere in the policy.
+
 Return JSON only.`;
 }
 
@@ -6501,7 +6215,9 @@ For EACH coverage, also extract:
 - sectionRef: the declarations/schedule/endorsement section heading where it appears
 - originalContent: the verbatim row or short source snippet used for this coverage
 - limitType: when applicable, classify the limit as per_occurrence, per_claim, aggregate, per_person, per_accident, statutory, blanket, or scheduled
+- limitAmount: the limit as a plain number with no currency symbols or commas when the source states a fixed numeric currency amount
 - limitValueType: classify the limit as numeric, included, not_included, as_stated, waiting_period, referential, or other
+- deductibleAmount: the deductible or retention as a plain number with no currency symbols or commas when the source states a fixed numeric currency amount
 - deductibleValueType: classify the deductible/value term similarly when deductible is present
 
 Critical rules:
@@ -6510,6 +6226,7 @@ Critical rules:
 - Do not treat a generic waiting period, deductible explanation, limits clause, coinsurance clause, or definitions text as a standalone coverage unless the page contains an actual policy-specific schedule row or declaration entry.
 - Values like "Included" or "Not Included" are valid only when they appear as an explicit declarations/schedule/endorsement entry for a named coverage. Do not infer them from narrative form language.
 - If a waiting period or hour deductible is shown as part of a specific declarations/schedule row, it may be captured in deductible. Otherwise omit it.
+- Only populate limitAmount and deductibleAmount from actual policy-specific declaration, schedule, or endorsement values. Do not calculate them from examples, definitions, rating narratives, or generic form language.
 - Use limitValueType or deductibleValueType to preserve non-numeric terms precisely instead of forcing them into numeric semantics.
 - Preserve one row per real coverage entry. Do not merge adjacent schedule rows into malformed names.
 - Keep individual/per-occurrence limits separate from aggregate limits even when they have the same coverage name, limit amount, deductible, and form number. Use limitType to distinguish them.
@@ -6729,22 +6446,28 @@ Return JSON only.`;
 var import_zod32 = require("zod");
 var PremiumBreakdownSchema = import_zod32.z.object({
   premium: import_zod32.z.string().optional().describe("Total premium amount, e.g. '$5,000'"),
+  premiumAmount: import_zod32.z.number().optional().describe("Total premium as a plain number with no currency symbols or commas"),
   totalCost: import_zod32.z.string().optional().describe("Total cost including taxes and fees, e.g. '$5,250'"),
+  totalCostAmount: import_zod32.z.number().optional().describe("Total cost as a plain number with no currency symbols or commas"),
   premiumBreakdown: import_zod32.z.array(
     import_zod32.z.object({
       line: import_zod32.z.string().describe("Coverage line name"),
-      amount: import_zod32.z.string().describe("Premium amount for this line")
+      amount: import_zod32.z.string().describe("Premium amount for this line"),
+      amountValue: import_zod32.z.number().optional().describe("Premium amount as a plain number with no currency symbols or commas")
     })
   ).optional().describe("Per-coverage-line premium breakdown"),
   taxesAndFees: import_zod32.z.array(
     import_zod32.z.object({
       name: import_zod32.z.string().describe("Fee or tax name"),
       amount: import_zod32.z.string().describe("Dollar amount"),
+      amountValue: import_zod32.z.number().optional().describe("Fee or tax amount as a plain number with no currency symbols or commas"),
       type: import_zod32.z.enum(["tax", "fee", "surcharge", "assessment"]).optional().describe("Fee category")
     })
   ).optional().describe("Taxes, fees, surcharges, and assessments"),
   minimumPremium: import_zod32.z.string().optional().describe("Minimum premium if stated"),
+  minimumPremiumAmount: import_zod32.z.number().optional().describe("Minimum premium as a plain number when the source states a fixed amount"),
   depositPremium: import_zod32.z.string().optional().describe("Deposit premium if stated"),
+  depositPremiumAmount: import_zod32.z.number().optional().describe("Deposit premium as a plain number when the source states a fixed amount"),
   paymentPlan: import_zod32.z.string().optional().describe("Payment plan description"),
   auditType: import_zod32.z.enum(["annual", "semi_annual", "quarterly", "monthly", "final", "self"]).optional().describe("Premium audit type"),
   ratingBasis: import_zod32.z.string().optional().describe("Rating basis, e.g. payroll, revenue, area, units")
@@ -6754,6 +6477,7 @@ function buildPremiumBreakdownPrompt() {
 
 Focus on:
 - Total premium and total cost (including taxes/fees)
+- Plain numeric amount fields for stated money values, without currency symbols or commas
 - Per-coverage-line premium breakdown if available
 - Taxes, fees, surcharges, and assessments with their amounts and types
 - Minimum premium and deposit premium if stated
@@ -6762,6 +6486,7 @@ Focus on:
 - Rating basis: payroll, revenue, area, units, or other
 
 Look on the declarations page, premium summary, and any premium/cost schedules.
+Prefer premium tables and schedules over definitions, exclusions, rating-basis narratives, licensing statements, or descriptions of premium trust funds. Do not use unrelated business volume, controlled written premium, deductible, limit, tax-only, fee-only, or percentage-only values as the policy premium.
 
 Return JSON only.`;
 }
@@ -8169,44 +7894,11 @@ function toReviewRoundRecord(round, review) {
 }
 
 // src/extraction/planning.ts
-function normalizePageAssignments(pageAssignments, formInventory) {
-  const pageFormTypes = /* @__PURE__ */ new Map();
-  if (formInventory) {
-    for (const form of formInventory.forms) {
-      if (form.pageStart != null) {
-        const end = form.pageEnd ?? form.pageStart;
-        for (let p = form.pageStart; p <= end; p += 1) {
-          const types = pageFormTypes.get(p) ?? /* @__PURE__ */ new Set();
-          types.add(form.formType);
-          pageFormTypes.set(p, types);
-        }
-      }
-    }
-  }
+function normalizePageAssignments(pageAssignments, _formInventory) {
   return pageAssignments.map((assignment) => {
-    let extractorNames = [...new Set(
-      (assignment.extractorNames.length > 0 ? assignment.extractorNames : ["sections"]).filter(Boolean)
+    const extractorNames = [...new Set(
+      assignment.extractorNames.filter(Boolean)
     )];
-    const hasDeclarations = extractorNames.includes("declarations");
-    const hasConditions = extractorNames.includes("conditions");
-    const hasExclusions = extractorNames.includes("exclusions");
-    const hasEndorsements = extractorNames.includes("endorsements");
-    const looksLikeScheduleValues = assignment.hasScheduleValues === true;
-    const roleBlocksCoverageLimits = assignment.pageRole === "policy_form" || assignment.pageRole === "condition_exclusion_form" || assignment.pageRole === "endorsement_form";
-    const inventoryTypes = pageFormTypes.get(assignment.localPageNumber);
-    const inventoryBlocksCoverageLimits = inventoryTypes != null && !looksLikeScheduleValues && !hasDeclarations && (inventoryTypes.has("endorsement") || inventoryTypes.has("notice") || inventoryTypes.has("application"));
-    if (extractorNames.includes("coverage_limits")) {
-      const shouldDropCoverageLimits = inventoryBlocksCoverageLimits || !looksLikeScheduleValues && roleBlocksCoverageLimits || !hasDeclarations && !looksLikeScheduleValues && (hasConditions || hasExclusions) || !hasDeclarations && !looksLikeScheduleValues && hasEndorsements;
-      if (shouldDropCoverageLimits) {
-        extractorNames = extractorNames.filter((name) => name !== "coverage_limits");
-      }
-    }
-    if (inventoryTypes?.has("endorsement") && !extractorNames.includes("endorsements")) {
-      extractorNames = [...extractorNames, "endorsements"];
-    }
-    if (extractorNames.length === 0) {
-      extractorNames = ["sections"];
-    }
     return {
       ...assignment,
       extractorNames
@@ -8243,20 +7935,12 @@ function groupContiguousPages(pages) {
 function buildPlanFromPageAssignments(pageAssignments, pageCount, formInventory) {
   const extractorPages = /* @__PURE__ */ new Map();
   for (const assignment of pageAssignments) {
-    const extractors = assignment.extractorNames.length > 0 ? assignment.extractorNames : ["sections"];
+    const focusedExtractors = assignment.extractorNames.filter((name) => name !== "sections");
+    const extractors = focusedExtractors.length > 0 ? focusedExtractors : assignment.extractorNames;
     for (const extractorName of extractors) {
       extractorPages.set(extractorName, [...extractorPages.get(extractorName) ?? [], assignment.localPageNumber]);
     }
   }
-  const coveredPages = /* @__PURE__ */ new Set();
-  for (const pages of extractorPages.values()) {
-    for (const page of pages) coveredPages.add(page);
-  }
-  for (let page = 1; page <= pageCount; page += 1) {
-    if (!coveredPages.has(page)) {
-      extractorPages.set("sections", [...extractorPages.get("sections") ?? [], page]);
-    }
-  }
   const contextualExtractors = /* @__PURE__ */ new Set(["conditions", "covered_reasons", "definitions", "exclusions", "endorsements"]);
   const contextualForms = (formInventory?.forms ?? []).filter(
     (form) => form.pageStart != null && (form.pageEnd ?? form.pageStart) != null
@@ -8543,6 +8227,64 @@ function createExtractor(config) {
     ranges.push({ startPage, endPage: previousPage });
     return ranges;
   }
+  function pageNumberForSpan(span) {
+    return span.pageStart ?? span.location?.startPage ?? span.location?.page;
+  }
+  function spansForPageRange(spans, startPage, endPage) {
+    return spans.filter((span) => {
+      const start = span.pageStart ?? span.location?.startPage ?? span.location?.page;
+      const end = span.pageEnd ?? span.location?.endPage ?? start;
+      return typeof start === "number" && typeof end === "number" && start <= endPage && end >= startPage;
+    });
+  }
+  function formatSourceSpanText(spans) {
+    return spans.filter((span) => span.text.trim().length > 0).map((span) => {
+      const page = pageNumberForSpan(span);
+      const label = [
+        page ? `Page ${page}` : void 0,
+        span.sectionId,
+        span.formNumber
+      ].filter(Boolean).join(" | ");
+      return label ? `${label}
+${span.text}` : span.text;
+    }).join("\n\n---\n\n");
+  }
+  function inferSectionType(title, text) {
+    const value = `${title} ${text.slice(0, 500)}`.toLowerCase();
+    if (/\bdefinition|defined terms?\b/.test(value)) return "definition";
+    if (/\bexclusion|not covered|does not apply\b/.test(value)) return "exclusion";
+    if (/\bcondition|duties|loss condition|general condition\b/.test(value)) return "condition";
+    if (/\bendorsement|amend|additional insured\b/.test(value)) return "endorsement";
+    if (/\bcovered cause|covered reason|covered peril|cause of loss|perils insured\b/.test(value)) return "covered_reason";
+    if (/\bdeclaration|schedule\b/.test(value)) return "declarations";
+    return "policy_form";
+  }
+  function buildSourceBackedSectionIndex(spans, startPage, endPage) {
+    const candidateSpans = spansForPageRange(spans, startPage, endPage).filter((span) => span.text.trim().length > 0).filter((span) => span.metadata?.sourceUnit === "section_candidate" || span.sectionId || span.text.length >= 160);
+    return {
+      sections: candidateSpans.map((span, index) => {
+        const pageStart = span.pageStart ?? span.location?.startPage ?? span.location?.page ?? startPage;
+        const pageEnd = span.pageEnd ?? span.location?.endPage ?? pageStart;
+        const title = span.sectionId ?? span.formNumber ?? firstHeadingLine(span.text) ?? `Policy text page ${pageStart}`;
+        return {
+          title,
+          sectionNumber: span.formNumber,
+          pageStart,
+          pageEnd,
+          type: inferSectionType(title, span.text),
+          excerpt: span.text.slice(0, 240),
+          recordId: `section_index_${pageStart}_${index}`,
+          sourceSpanIds: [span.id],
+          sourceTextHash: span.textHash ?? sourceSpanTextHash(span.text)
+        };
+      })
+    };
+  }
+  function firstHeadingLine(text) {
+    const line = text.split(/\r?\n/).map((item) => item.trim()).find((item) => item.length > 0);
+    if (!line) return void 0;
+    return line.slice(0, 100);
+  }
   function shouldRunLlmReview(mode, report, sourceSpansAvailable) {
     if (mode === "skip" || maxReviewRounds <= 0) return false;
     if (mode === "always") return true;
@@ -8578,7 +8320,14 @@ function createExtractor(config) {
     }
     return lines.length > 0 ? lines.join("\n") : "";
   }
-  async function runFocusedExtractorTask(task, pdfInput, memory, pageRangeCache, getPageRangePdf, getPageImages, getPageRangeText) {
+  async function runFocusedExtractorTask(task, pdfInput, memory, sourceSpansForSections, pageRangeCache, getPageRangePdf, getPageImages, getPageRangeText) {
+    if (task.extractorName === "sections" && sourceSpansForSections.length > 0) {
+      return {
+        name: "sections",
+        data: buildSourceBackedSectionIndex(sourceSpansForSections, task.startPage, task.endPage),
+        usage: void 0
+      };
+    }
     if (task.extractorName === "supplementary") {
       const alreadyExtractedSummary = buildAlreadyExtractedSummary(memory);
       const budget = resolveBudget("extraction_focused", 4096);
@@ -8756,21 +8505,28 @@ function createExtractor(config) {
       return promise;
     }
     async function getPageRangeText(startPage, endPage) {
-      return doclingDocument ? getDoclingPageRangeText(doclingDocument, startPage, endPage) : "";
+      if (doclingDocument) return getDoclingPageRangeText(doclingDocument, startPage, endPage);
+      return formatSourceSpanText(spansForPageRange(sourceSpans, startPage, endPage));
     }
     function withFullDocumentTextContext(prompt) {
-      if (!doclingDocument) return prompt;
-      return `${prompt}
+      if (doclingDocument) return `${prompt}
 
 DOCLING DOCUMENT TEXT:
 ${doclingDocument.fullText}`;
+      const sourceText = formatSourceSpanText(sourceSpans);
+      if (!sourceText) return prompt;
+      return `${prompt}
+
+SOURCE SPAN DOCUMENT TEXT:
+${sourceText}`;
     }
     function withPageRangeTextContext(prompt, startPage, endPage, pageText) {
-      if (!doclingDocument) return prompt;
+      if (!pageText) return prompt;
+      const label = doclingDocument ? "DOCLING DOCUMENT" : "SOURCE SPAN DOCUMENT";
       return `${prompt}
 
-DOCLING DOCUMENT PAGES ${startPage}-${endPage}:
-${pageText || "(No Docling text was available for this page range.)"}`;
+${label} PAGES ${startPage}-${endPage}:
+${pageText}`;
     }
     let classifyResult;
     if (resumed?.classifyResult && pipelineCtx.isPhaseComplete("classify")) {
@@ -8883,7 +8639,7 @@ ${pageText || "(No Docling text was available for this page range.)"}`;
         pageMapChunks.map(
           ({ startPage, endPage }) => pageMapLimit(async () => {
             const pagesPdf = doclingDocument ? void 0 : await getPageRangePdf(startPage, endPage);
-            const pagesText = doclingDocument ? await getPageRangeText(startPage, endPage) : "";
+            const pagesText = await getPageRangeText(startPage, endPage);
             const budget = resolveBudget("extraction_page_map", 2048);
             const startedAt = Date.now();
             const mapResponse = await safeGenerateObject(
@@ -8986,10 +8742,11 @@ ${pageText || "(No Docling text was available for this page range.)"}`;
               task,
               extractionPdfInput,
               memory,
+              sourceSpans,
               completedPageRangePdfCache,
               getPageRangePdf,
               convertPdfToImages ? getPageImages : void 0,
-              doclingDocument ? getPageRangeText : void 0
+              sourceSpans.length > 0 || doclingDocument ? getPageRangeText : void 0
             );
           })
         )
@@ -9022,7 +8779,7 @@ ${pageText || "(No Docling text was available for this page range.)"}`;
             pageRangeCache: completedPageRangePdfCache,
             getPageRangePdf,
             getPageImages: convertPdfToImages ? getPageImages : void 0,
-            getPageRangeText: doclingDocument ? getPageRangeText : void 0
+            getPageRangeText: sourceSpans.length > 0 || doclingDocument ? getPageRangeText : void 0
           });
           trackUsage(supplementaryResult.usage, {
             taskKind: "extraction_focused",
@@ -9058,7 +8815,7 @@ ${pageText || "(No Docling text was available for this page range.)"}`;
           concurrency,
           getPageRangePdf,
           getPageImages: convertPdfToImages ? getPageImages : void 0,
-          getPageRangeText: doclingDocument ? getPageRangeText : void 0,
+          getPageRangeText: sourceSpans.length > 0 || doclingDocument ? getPageRangeText : void 0,
           providerOptions: activeProviderOptions,
           modelCapabilities,
           modelBudgetConstraints,
@@ -9150,10 +8907,11 @@ ${pageText || "(No Docling text was available for this page range.)"}`;
                   task,
                   extractionPdfInput,
                   memory,
+                  sourceSpans,
                   completedPageRangePdfCache,
                   getPageRangePdf,
                   convertPdfToImages ? getPageImages : void 0,
-                  doclingDocument ? getPageRangeText : void 0
+                  sourceSpans.length > 0 || doclingDocument ? getPageRangeText : void 0
                 );
               })
             )