@claritylabs/cl-sdk 3.1.0 → 3.1.3

package/dist/index.mjs

@@ -3235,6 +3235,12 @@ function moneyAmount(value) {
 function normalizeLabel(value) {
   return normalizeWhitespace3(value ?? "").toLowerCase();
 }
+function isGenericColumnLabel(value) {
+  return /^column\s+\d+$/i.test(cleanValue(value) ?? "");
+}
+function isHeaderRow(row) {
+  return row.metadata?.isHeader === true || row.metadata?.isHeader === "true";
+}
 var OPERATIONAL_COVERAGE_TERM_KINDS = /* @__PURE__ */ new Set([
   "each_claim_limit",
   "each_occurrence_limit",
@@ -3255,6 +3261,7 @@ function termKind(label, value) {
   if (/\bpremium\b/.test(text)) return "premium";
   if (/\bsub[-\s]?limit\b/.test(text)) return "sublimit";
   if (/\baggregate\b/.test(text)) return "aggregate_limit";
+  if (/\beach\s+proceeding|per\s+proceeding\b/.test(text)) return "sublimit";
   if (/\beach\s+claim|per\s+claim\b/.test(text)) return "each_claim_limit";
   if (/\beach\s+occurrence|per\s+occurrence\b/.test(text)) return "each_occurrence_limit";
   if (/\beach\s+loss|per\s+loss\b/.test(text)) return "each_loss_limit";
@@ -3281,9 +3288,13 @@ function isNameCell(label, value) {
   const normalizedLabel = normalizeLabel(label);
   const normalizedValue = normalizeLabel(value);
   if (!value || moneyAmount(value) !== void 0) return false;
+  if (/^item\s+\d+[.)]?\s*limits?\s+of\s+liability\b/.test(normalizedValue)) return false;
   if (/\b(coverage|coverage part|insuring agreement|description|item|name)\b/.test(normalizedLabel)) {
     return true;
   }
+  if (/\b(sub[-\s]?limit|aggregate(?:\s+policy)?\s+limit|limit\s+of\s+liability)\b/.test(normalizedLabel) && /\b[a-z][a-z0-9&/ -]{2,}\b/.test(normalizedValue) && !/\bcoverage\s+part\s+[a-z]\)?$/.test(normalizedValue)) {
+    return true;
+  }
   if (/^column\s+1$/.test(normalizedLabel) && !/^(item\s+\d+|nwc-|iso-|cg |il |form\b|page\b)/i.test(normalizedValue)) {
     return true;
   }
@@ -3302,13 +3313,32 @@ function childMap(nodes) {
   for (const group of children.values()) group.sort((left, right) => left.order - right.order);
   return children;
 }
-function cellRows(row, children) {
+function rawCellRows(row, children) {
   return (children.get(row.id) ?? []).filter((child) => child.kind === "table_cell").map((cell) => ({
     label: cleanValue(cell.title) ?? "Value",
     value: cleanValue(cell.textExcerpt ?? cell.description ?? cell.title) ?? "",
     node: cell
   })).filter((cell) => cell.value);
 }
+function headerLabelsForRow(row, children) {
+  if (!row.parentId) return [];
+  const labels = [];
+  const siblingRows = (children.get(row.parentId) ?? []).filter((candidate) => candidate.kind === "table_row" && candidate.order < row.order).sort((left, right) => left.order - right.order);
+  for (const sibling of siblingRows) {
+    if (!isHeaderRow(sibling)) continue;
+    for (const [index, cell] of rawCellRows(sibling, children).entries()) {
+      const label = cleanValue(cell.value) ?? cleanValue(cell.label);
+      if (label && !isGenericColumnLabel(label)) labels[index] = label;
+    }
+  }
+  return labels;
+}
+function cellRows(row, children, headerLabels = []) {
+  return rawCellRows(row, children).map((cell, index) => ({
+    ...cell,
+    label: isGenericColumnLabel(cell.label) && headerLabels[index] ? headerLabels[index] : cell.label
+  }));
+}
 function directChildren(parent, children) {
   return children.get(parent.id) ?? [];
 }
@@ -3351,18 +3381,10 @@ function sourceIds(nodes) {
     sourceSpanIds: [...new Set(nodes.flatMap((node) => node.sourceSpanIds))]
   };
 }
-function relabelGenericTerm(term, label) {
-  const cleanLabel = cleanValue(label);
-  if (!cleanLabel || !/^column\s+\d+$/i.test(term.label)) return term;
-  return {
-    ...term,
-    kind: termKind(cleanLabel, term.value),
-    label: cleanLabel
-  };
-}
 function termFromCell(params) {
-  const value = cleanValue(params.value);
+  const value = cleanCoverageTermValue(params.value);
   if (!value) return void 0;
+  if (isRejectedCoverageTermValue(params.label, value)) return void 0;
   const nodes = [params.row, params.cell].filter((node) => Boolean(node));
   const kind = termKind(params.label, value);
   const amount = moneyAmount(value);
@@ -3375,20 +3397,38 @@ function termFromCell(params) {
     ...sourceIds(nodes)
   };
 }
+function cleanCoverageTermValue(value) {
+  return cleanValue(value)?.replace(/\s+\/\s*$/, "").trim();
+}
+function isRejectedCoverageTermValue(label, value) {
+  if (/\bshown\s+in\s+item\s*\d+\b/i.test(value) && moneyAmount(value) === void 0) return true;
+  if (/\b(does not afford coverage|doesn't afford coverage|no coverage|remains excluded|is excluded|are excluded|shall not cover|will not cover)\b/i.test(value) && moneyAmount(value) === void 0) {
+    return true;
+  }
+  if (/^for:\s*\(\d+\)/i.test(label) && moneyAmount(value) === void 0) return true;
+  if (value.length > 80 && /\b(exclusion|excluded|shall not|will not|does not|failure to)\b/i.test(value) && moneyAmount(value) === void 0) return true;
+  return false;
+}
 function termsFromRow(row, children) {
-  const cells = cellRows(row, children);
+  const cells = cellRows(row, children, headerLabelsForRow(row, children));
   if (cells.length > 0) {
     const pairedTerms = [];
+    const pairedIndexes = /* @__PURE__ */ new Set();
     for (const [index, cell] of cells.entries()) {
       const next = cells[index + 1];
       if (!next) continue;
+      if (!isGenericColumnLabel(cell.label) && isNameCell(cell.label, cell.value)) continue;
       if (!isCoverageTermLabel(cell.value)) continue;
       if (isCoverageTermLabel(next.value) && moneyAmount(next.value) === void 0) continue;
       const term = termFromCell({ row, cell: next.node, label: cell.value, value: next.value });
-      if (term) pairedTerms.push(term);
+      if (term) {
+        pairedTerms.push(term);
+        pairedIndexes.add(index);
+        pairedIndexes.add(index + 1);
+      }
     }
-    if (pairedTerms.length > 0) return pairedTerms;
-    return cells.filter((cell) => isValueCell(cell.label, cell.value)).map((cell) => termFromCell({ row, cell: cell.node, label: cell.label, value: cell.value })).filter((term) => Boolean(term));
+    const valueTerms = cells.filter((_, index) => !pairedIndexes.has(index)).filter((cell) => isValueCell(cell.label, cell.value)).map((cell) => termFromCell({ row, cell: cell.node, label: cell.label, value: cell.value })).filter((term) => Boolean(term));
+    return [...pairedTerms, ...valueTerms];
   }
   const text = normalizeWhitespace3(row.textExcerpt ?? row.description ?? nodeText(row));
   const terms = [];
@@ -3414,11 +3454,11 @@ function termsFromRow(row, children) {
   return terms;
 }
 function nameFromRow(row, children) {
-  const declarationName = declarationCoverageNameFromRow(row, children);
-  if (declarationName) return declarationName;
-  const cells = cellRows(row, children);
+  const cells = cellRows(row, children, headerLabelsForRow(row, children));
   const named = cells.find((cell) => isNameCell(cell.label, cell.value));
   if (named) return cleanValue(named.value);
+  const declarationName = declarationCoverageNameFromRow(row, children);
+  if (declarationName) return declarationName;
   return coverageNameFromRow(row.textExcerpt ?? row.description ?? nodeText(row));
 }
 function legacyLimit(terms) {
@@ -3451,7 +3491,7 @@ function isOperationalCoverageRow(coverage) {
   if (coverage.name.split(/\s+/).length > 16 && !/\b(coverage|liability|sub[-\s]?limit|aggregate|each\s+(claim|loss|occurrence)|limit)\b/i.test(coverage.name)) {
     return false;
   }
-  return /\b(coverage|coverage part|liability|sub[-\s]?limit|aggregate|each\s+(claim|loss|occurrence)|bricking|cyber|privacy|media|regulatory|defense|ai\/ml|errors?\s*&?\s*omissions|technology)\b/i.test(coverage.name);
+  return /\b(coverage|coverage part|liability|sub[-\s]?limit|aggregate|each\s+(claim|loss|occurrence|proceeding)|bricking|cyber|privacy|media|regulatory|defense|fraud|social engineering|ai\/ml|errors?\s*&?\s*omissions|technology)\b/i.test(coverage.name);
 }
 function uniqueTerms(terms) {
   const seen = /* @__PURE__ */ new Set();
@@ -3465,7 +3505,7 @@ function uniqueTerms(terms) {
   return result;
 }
 function coverageFromTableRow(row, children, byId) {
-  if (row.metadata?.isHeader === true || row.metadata?.isHeader === "true") return void 0;
+  if (isHeaderRow(row)) return void 0;
   const name = nameFromRow(row, children);
   const terms = uniqueTerms(termsFromRow(row, children));
   if (!name || terms.length === 0) return void 0;
@@ -3490,8 +3530,7 @@ function coverageFromEndorsement(endorsement, children) {
   const terms = uniqueTerms(rows.flatMap(
     (row) => termsFromRow(row, children).map((term) => {
       const appliesTo = nameFromRow(row, children);
-      const labelled = relabelGenericTerm(term, appliesTo);
-      return appliesTo && labelled.label !== appliesTo ? { ...labelled, appliesTo } : labelled;
+      return appliesTo && term.label !== appliesTo ? { ...term, appliesTo } : term;
     })
   ));
   if (terms.length === 0) return void 0;
@@ -9694,7 +9733,343 @@ function groundExtractionMemoryWithSourceSpans(memory, sourceSpans) {
 }
 
 // src/extraction/source-tree-extractor.ts
+import { z as z42 } from "zod";
+
+// src/extraction/operational-profile-cleanup.ts
 import { z as z41 } from "zod";
+var OPERATIONAL_COVERAGE_TERM_KINDS2 = [
+  "each_claim_limit",
+  "each_occurrence_limit",
+  "each_loss_limit",
+  "aggregate_limit",
+  "sublimit",
+  "retention",
+  "deductible",
+  "retroactive_date",
+  "premium",
+  "other"
+];
+var OperationalCoverageTermKindSchema = z41.enum(OPERATIONAL_COVERAGE_TERM_KINDS2);
+var OperationalProfileCleanupSchema = z41.object({
+  coverageDecisions: z41.array(z41.object({
+    coverageIndex: z41.number().int().nonnegative(),
+    action: z41.enum(["keep", "drop", "update"]),
+    reason: z41.string().optional(),
+    name: z41.string().optional(),
+    limit: z41.string().nullable().optional(),
+    deductible: z41.string().nullable().optional(),
+    premium: z41.string().nullable().optional(),
+    retroactiveDate: z41.string().nullable().optional(),
+    coverageOrigin: z41.enum(["core", "endorsement"]).optional(),
+    sourceNodeIds: z41.array(z41.string()).optional(),
+    sourceSpanIds: z41.array(z41.string()).optional(),
+    termDecisions: z41.array(z41.object({
+      termIndex: z41.number().int().nonnegative(),
+      action: z41.enum(["keep", "drop", "update"]),
+      reason: z41.string().optional(),
+      kind: OperationalCoverageTermKindSchema.optional(),
+      label: z41.string().optional(),
+      value: z41.string().optional(),
+      amount: z41.number().nullable().optional(),
+      appliesTo: z41.string().nullable().optional(),
+      sourceNodeIds: z41.array(z41.string()).optional(),
+      sourceSpanIds: z41.array(z41.string()).optional()
+    })).optional()
+  })).default([]),
+  warnings: z41.array(z41.string()).default([])
+});
+function compactNode(node, maxText = 700) {
+  return {
+    id: node.id,
+    kind: node.kind,
+    title: node.title,
+    path: node.path,
+    pageStart: node.pageStart,
+    pageEnd: node.pageEnd,
+    sourceSpanIds: node.sourceSpanIds.slice(0, 8),
+    text: (node.textExcerpt ?? node.description).slice(0, maxText)
+  };
+}
+function compactCoverageForCleanup(coverage, coverageIndex) {
+  return {
+    coverageIndex,
+    name: coverage.name,
+    limit: coverage.limit,
+    deductible: coverage.deductible,
+    premium: coverage.premium,
+    retroactiveDate: coverage.retroactiveDate,
+    coverageOrigin: coverage.coverageOrigin,
+    sourceNodeIds: coverage.sourceNodeIds,
+    sourceSpanIds: coverage.sourceSpanIds,
+    terms: coverage.limits.map((term, termIndex) => ({
+      termIndex,
+      kind: term.kind,
+      label: term.label,
+      value: term.value,
+      amount: term.amount,
+      appliesTo: term.appliesTo,
+      sourceNodeIds: term.sourceNodeIds,
+      sourceSpanIds: term.sourceSpanIds
+    }))
+  };
+}
+function buildOperationalProfileCleanupPrompt(sourceTree, profile) {
+  const nodes = sourceTree.filter((node) => node.kind !== "document").slice(0, 320).map((node) => compactNode(node, node.kind === "page" ? 900 : 700));
+  const candidate = {
+    documentType: profile.documentType,
+    policyTypes: profile.policyTypes,
+    coverageTypes: profile.coverageTypes,
+    coverages: profile.coverages.map(compactCoverageForCleanup)
+  };
+  return `Review and clean a source-backed operational profile projection for an insurance policy.
+
+Task:
+- Inspect the candidate coverage projection against the source nodes.
+- Return cleanup decisions only for coverage rows or terms that are malformed, unsupported, mismatched, or misleading.
+- If the projection is already acceptable, return an empty coverageDecisions array.
+
+Projection defects to look for:
+- Generic labels such as "Column 3" that should be renamed from nearby row/header evidence.
+- Declaration or section headers projected as coverage names when the row evidence is actually a specific coverage, sub-limit, deductible, retention, retroactive date, or premium.
+- Dangling continuation punctuation such as a trailing "/" copied into values.
+- Item references such as "shown in Item 7" or bare item numbers treated as money amounts.
+- Policy wording, exclusions, or unsupported prose copied into operational limit/deductible fields.
+- Header/value splits where "Limit of Liability", "Deductible", "Retroactive Date", "Aggregate", "Each Claim", or similar terms are attached to the wrong coverage row.
+- Repeated schedule headings projected as separate coverages when they only introduce the next coverage group.
+
+Rules:
+- Use internal reasoning, but return JSON decisions only.
+- Do not invent policy facts. Keep, drop, or update only existing coverageIndex and termIndex entries.
+- Use sourceNodeIds and sourceSpanIds only from the provided source nodes or from the existing candidate entry.
+- Prefer dropping a malformed fact over speculative rewriting.
+- Keep a coverage when it is a real operational coverage/benefit even if only one term needs cleanup.
+- When changing a term's semantic meaning, set kind to the corrected normalized term kind.
+- Do not add new coverage rows or new terms; this pass cleans the existing projection.
+- Keep reasons concise and factual.
+
+Candidate projection:
+${JSON.stringify(candidate, null, 2)}
+
+Source nodes:
+${JSON.stringify(nodes, null, 2)}
+
+Return JSON with coverageDecisions and warnings only.`;
+}
+function hasOwn(object, key) {
+  return Object.prototype.hasOwnProperty.call(object, key);
+}
+function uniqueStrings(values) {
+  return [...new Set(values.filter((value) => value.length > 0))];
+}
+function cleanProfileValue(value) {
+  if (typeof value !== "string") return void 0;
+  const cleaned = value.replace(/\s+\/\s*$/, "").replace(/\s+/g, " ").replace(/^[\s:;#-]+|[\s;,.]+$/g, "").trim();
+  return cleaned || void 0;
+}
+function validIds(ids, valid) {
+  return uniqueStrings((ids ?? []).filter((id) => valid.has(id)));
+}
+function cleanupIds(ids, valid, fallback) {
+  if (ids === void 0) return validIds(fallback, valid);
+  const next = validIds(ids, valid);
+  return next.length > 0 ? next : validIds(fallback, valid);
+}
+function amountFromOperationalValue(value) {
+  const match = value.match(/\$\s*([0-9][0-9,]*(?:\.\d+)?)/) ?? value.match(/\b([0-9][0-9,]*(?:\.\d+)?)\s*%/);
+  if (!match) return void 0;
+  const amount = Number(match[1].replace(/,/g, ""));
+  return Number.isFinite(amount) ? amount : void 0;
+}
+function normalizedTermText(term) {
+  return `${term.kind} ${term.label} ${term.value}`.toLowerCase();
+}
+function isLimitTerm(term) {
+  return ["each_claim_limit", "each_occurrence_limit", "each_loss_limit", "aggregate_limit", "sublimit"].includes(term.kind) || term.kind === "other" && /\b(limit|aggregate|claim|occurrence|loss|proceeding)\b/i.test(normalizedTermText(term));
+}
+function isDeductibleTerm(term) {
+  return term.kind === "deductible" || term.kind === "retention" || /\b(deductible|retention|sir)\b/i.test(normalizedTermText(term));
+}
+function isPremiumTerm(term) {
+  return term.kind === "premium" || /\bpremium\b/i.test(normalizedTermText(term));
+}
+function isRetroactiveDateTerm(term) {
+  return term.kind === "retroactive_date" || /\bretroactive\b/i.test(normalizedTermText(term));
+}
+function primaryLimitFromTerms(terms) {
+  return terms.find(isLimitTerm)?.value;
+}
+function deductibleFromTerms(terms) {
+  return terms.find(isDeductibleTerm)?.value;
+}
+function premiumFromTerms(terms) {
+  return terms.find(isPremiumTerm)?.value;
+}
+function retroactiveDateFromTerms(terms) {
+  return terms.find(isRetroactiveDateTerm)?.value;
+}
+function termDecisionTouches(coverage, decision, predicate) {
+  const existing = coverage.limits[decision.termIndex];
+  if (existing && predicate(existing)) return true;
+  if (!decision.kind && !decision.label && !decision.value) return false;
+  return predicate({
+    kind: decision.kind ?? existing?.kind ?? "other",
+    label: cleanProfileValue(decision.label) ?? existing?.label ?? "",
+    value: cleanProfileValue(decision.value) ?? existing?.value ?? ""
+  });
+}
+function applyTermCleanupDecision(term, decision, validNodeIds, validSpanIds) {
+  if (!decision || decision.action === "keep") return term;
+  if (decision.action === "drop") return void 0;
+  const label = cleanProfileValue(decision.label) ?? term.label;
+  const value = cleanProfileValue(decision.value) ?? term.value;
+  if (!label || !value) return term;
+  const next = {
+    ...term,
+    kind: decision.kind ?? term.kind,
+    label,
+    value,
+    sourceNodeIds: cleanupIds(decision.sourceNodeIds, validNodeIds, term.sourceNodeIds),
+    sourceSpanIds: cleanupIds(decision.sourceSpanIds, validSpanIds, term.sourceSpanIds)
+  };
+  if (next.sourceNodeIds.length === 0 && next.sourceSpanIds.length === 0) return term;
+  if (hasOwn(decision, "amount")) {
+    if (typeof decision.amount === "number" && Number.isFinite(decision.amount)) next.amount = decision.amount;
+    else delete next.amount;
+  } else if (decision.value || decision.kind) {
+    const amount = next.kind === "retroactive_date" ? void 0 : amountFromOperationalValue(next.value);
+    if (amount === void 0) delete next.amount;
+    else next.amount = amount;
+  }
+  if (hasOwn(decision, "appliesTo")) {
+    const appliesTo = cleanProfileValue(decision.appliesTo);
+    if (appliesTo) next.appliesTo = appliesTo;
+    else delete next.appliesTo;
+  }
+  return next;
+}
+function termDecisionsTouch(coverage, decisions, predicate) {
+  return decisions.filter((decision) => decision.action !== "keep").some((decision) => termDecisionTouches(coverage, decision, predicate));
+}
+function applyCoverageCleanupDecision(coverage, decision, validNodeIds, validSpanIds) {
+  if (!decision || decision.action === "keep") return coverage;
+  if (decision.action === "drop") return void 0;
+  const next = {
+    ...coverage,
+    limits: [...coverage.limits],
+    sourceNodeIds: cleanupIds(decision.sourceNodeIds, validNodeIds, coverage.sourceNodeIds),
+    sourceSpanIds: cleanupIds(decision.sourceSpanIds, validSpanIds, coverage.sourceSpanIds)
+  };
+  const name = cleanProfileValue(decision.name);
+  if (name) next.name = name;
+  if (decision.coverageOrigin) next.coverageOrigin = decision.coverageOrigin;
+  if (hasOwn(decision, "limit")) {
+    const value = cleanProfileValue(decision.limit);
+    if (value) next.limit = value;
+    else delete next.limit;
+  }
+  if (hasOwn(decision, "deductible")) {
+    const value = cleanProfileValue(decision.deductible);
+    if (value) next.deductible = value;
+    else delete next.deductible;
+  }
+  if (hasOwn(decision, "premium")) {
+    const value = cleanProfileValue(decision.premium);
+    if (value) next.premium = value;
+    else delete next.premium;
+  }
+  if (hasOwn(decision, "retroactiveDate")) {
+    const value = cleanProfileValue(decision.retroactiveDate);
+    if (value) next.retroactiveDate = value;
+    else delete next.retroactiveDate;
+  }
+  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 (!hasOwn(decision, "limit") && termDecisionsTouch(coverage, termDecisions, isLimitTerm)) {
+      const value = primaryLimitFromTerms(next.limits);
+      if (value) next.limit = value;
+      else delete next.limit;
+    }
+    if (!hasOwn(decision, "deductible") && termDecisionsTouch(coverage, termDecisions, isDeductibleTerm)) {
+      const value = deductibleFromTerms(next.limits);
+      if (value) next.deductible = value;
+      else delete next.deductible;
+    }
+    if (!hasOwn(decision, "premium") && termDecisionsTouch(coverage, termDecisions, isPremiumTerm)) {
+      const value = premiumFromTerms(next.limits);
+      if (value) next.premium = value;
+      else delete next.premium;
+    }
+    if (!hasOwn(decision, "retroactiveDate") && termDecisionsTouch(coverage, termDecisions, isRetroactiveDateTerm)) {
+      const value = retroactiveDateFromTerms(next.limits);
+      if (value) next.retroactiveDate = value;
+      else delete next.retroactiveDate;
+    }
+  }
+  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
+  ].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.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)
+    ])
+  };
+}
+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,
+    coverageTypes: uniqueStrings(coverages.map((coverage) => coverage.name)),
+    warnings: uniqueStrings([
+      ...profile.warnings,
+      ...cleanupWarnings.map((warning) => `Operational profile cleanup warning: ${warning}`)
+    ])
+  };
+  return PolicyOperationalProfileSchema.parse({
+    ...nextProfile,
+    ...sourceIdsFromOperationalProfile(nextProfile)
+  });
+}
+
+// src/extraction/source-tree-extractor.ts
 var ORGANIZABLE_KINDS = [
   "page_group",
   "form",
@@ -9707,10 +10082,10 @@ var ORGANIZATION_TOP_LEVEL_BATCH_SIZE = 80;
 var ORGANIZER_MAX_SOURCE_SPANS = 400;
 var ORGANIZER_MAX_TOP_LEVEL_NODES = 18;
 var OUTLINE_CLEANUP_MAX_TOP_LEVEL_NODES = 80;
-var SourceTreeOrganizationSchema = z41.object({
-  labels: z41.array(z41.object({
-    nodeId: z41.string(),
-    kind: z41.enum([
+var SourceTreeOrganizationSchema = z42.object({
+  labels: z42.array(z42.object({
+    nodeId: z42.string(),
+    kind: z42.enum([
       "document",
       "page_group",
       "page",
@@ -9724,26 +10099,26 @@ var SourceTreeOrganizationSchema = z41.object({
       "table_cell",
       "text"
     ]).optional(),
-    title: z41.string().optional(),
-    description: z41.string().optional()
+    title: z42.string().optional(),
+    description: z42.string().optional()
   })),
-  groups: z41.array(z41.object({
-    kind: z41.enum(ORGANIZABLE_KINDS),
-    title: z41.string(),
-    description: z41.string().optional(),
-    childNodeIds: z41.array(z41.string()).min(1)
+  groups: z42.array(z42.object({
+    kind: z42.enum(ORGANIZABLE_KINDS),
+    title: z42.string(),
+    description: z42.string().optional(),
+    childNodeIds: z42.array(z42.string()).min(1)
   }))
 });
-var SourceBackedValueForPromptSchema = z41.object({
-  value: z41.string(),
-  normalizedValue: z41.string().optional(),
-  confidence: z41.enum(["low", "medium", "high"]).optional(),
-  sourceNodeIds: z41.array(z41.string()),
-  sourceSpanIds: z41.array(z41.string())
+var SourceBackedValueForPromptSchema = z42.object({
+  value: z42.string(),
+  normalizedValue: z42.string().optional(),
+  confidence: z42.enum(["low", "medium", "high"]).optional(),
+  sourceNodeIds: z42.array(z42.string()),
+  sourceSpanIds: z42.array(z42.string())
 });
-var OperationalProfilePromptSchema = z41.object({
-  documentType: z41.enum(["policy", "quote"]).optional(),
-  policyTypes: z41.array(z41.string()).optional(),
+var OperationalProfilePromptSchema = z42.object({
+  documentType: z42.enum(["policy", "quote"]).optional(),
+  policyTypes: z42.array(z42.string()).optional(),
   policyNumber: SourceBackedValueForPromptSchema.optional(),
   namedInsured: SourceBackedValueForPromptSchema.optional(),
   insurer: SourceBackedValueForPromptSchema.optional(),
@@ -9752,43 +10127,32 @@ var OperationalProfilePromptSchema = z41.object({
   expirationDate: SourceBackedValueForPromptSchema.optional(),
   retroactiveDate: SourceBackedValueForPromptSchema.optional(),
   premium: SourceBackedValueForPromptSchema.optional(),
-  coverageTypes: z41.array(z41.string()).optional(),
-  coverages: z41.array(z41.object({
-    name: z41.string(),
-    coverageCode: z41.string().optional(),
-    limit: z41.string().optional(),
-    deductible: z41.string().optional(),
-    premium: z41.string().optional(),
-    retroactiveDate: z41.string().optional(),
-    formNumber: z41.string().optional(),
-    sectionRef: z41.string().optional(),
-    coverageOrigin: z41.enum(["core", "endorsement"]).optional(),
-    endorsementNumber: z41.string().optional(),
-    limits: z41.array(z41.object({
-      kind: z41.enum([
-        "each_claim_limit",
-        "each_occurrence_limit",
-        "each_loss_limit",
-        "aggregate_limit",
-        "sublimit",
-        "retention",
-        "deductible",
-        "retroactive_date",
-        "premium",
-        "other"
-      ]).optional(),
-      label: z41.string(),
-      value: z41.string(),
-      amount: z41.number().optional(),
-      appliesTo: z41.string().optional(),
-      sourceNodeIds: z41.array(z41.string()),
-      sourceSpanIds: z41.array(z41.string())
+  coverageTypes: z42.array(z42.string()).optional(),
+  coverages: z42.array(z42.object({
+    name: z42.string(),
+    coverageCode: z42.string().optional(),
+    limit: z42.string().optional(),
+    deductible: z42.string().optional(),
+    premium: z42.string().optional(),
+    retroactiveDate: z42.string().optional(),
+    formNumber: z42.string().optional(),
+    sectionRef: z42.string().optional(),
+    coverageOrigin: z42.enum(["core", "endorsement"]).optional(),
+    endorsementNumber: z42.string().optional(),
+    limits: z42.array(z42.object({
+      kind: OperationalCoverageTermKindSchema.optional(),
+      label: z42.string(),
+      value: z42.string(),
+      amount: z42.number().optional(),
+      appliesTo: z42.string().optional(),
+      sourceNodeIds: z42.array(z42.string()),
+      sourceSpanIds: z42.array(z42.string())
     })).optional(),
-    sourceNodeIds: z41.array(z41.string()),
-    sourceSpanIds: z41.array(z41.string())
+    sourceNodeIds: z42.array(z42.string()),
+    sourceSpanIds: z42.array(z42.string())
   })).optional(),
-  sourceNodeIds: z41.array(z41.string()).optional(),
-  sourceSpanIds: z41.array(z41.string()).optional()
+  sourceNodeIds: z42.array(z42.string()).optional(),
+  sourceSpanIds: z42.array(z42.string()).optional()
 });
 function formatFormHintsForPrompt(forms) {
   const usable = forms.filter((form) => typeof form.pageStart === "number" && typeof form.pageEnd === "number").slice(0, 120).map((form) => ({
@@ -10780,7 +11144,7 @@ function applyEndorsementGrouping(sourceTree) {
   }
   return normalizeSemanticHierarchy(nextTree);
 }
-function compactNode(node, maxText = 700) {
+function compactNode2(node, maxText = 700) {
   return {
     id: node.id,
     kind: node.kind,
@@ -10870,7 +11234,7 @@ function mergeOrganizationResults(results) {
   };
 }
 function buildOrganizationPrompt(batch, formHints) {
-  const nodes = batch.nodes.map((node) => compactNode(node, node.kind === "page" ? 900 : 320));
+  const nodes = batch.nodes.map((node) => compactNode2(node, node.kind === "page" ? 900 : 320));
   return `You organize an insurance document source tree.
 
 Scope:
@@ -10912,7 +11276,7 @@ function shouldRunOutlineCleanup(sourceTree) {
 }
 function buildOutlineCleanupPrompt(sourceTree, formHints) {
   const topLevel = rootChildren(sourceTree).slice(0, OUTLINE_CLEANUP_MAX_TOP_LEVEL_NODES);
-  const nodes = topLevel.map((node) => compactNode(node, 900));
+  const nodes = topLevel.map((node) => compactNode2(node, 900));
   return `You clean a top-level source outline for an insurance policy.
 
 Expected product-facing order:
@@ -10941,7 +11305,7 @@ ${JSON.stringify(nodes, null, 2)}
 Return JSON with labels and groups only.`;
 }
 function buildOperationalProfilePrompt(sourceTree, fallback) {
-  const nodes = sourceTree.filter((node) => node.kind !== "document").slice(0, 240).map(compactNode);
+  const nodes = sourceTree.filter((node) => node.kind !== "document").slice(0, 240).map(compactNode2);
   return `Extract a source-backed operational profile for an insurance policy or quote.
 
 Return only high-value operational facts needed for policy lists, Q&A, compliance, and certificate generation:
@@ -11305,6 +11669,45 @@ async function runSourceTreeExtraction(params) {
   } catch (error) {
     warnings.push(`Operational profile model pass failed; deterministic profile used (${error instanceof Error ? error.message : String(error)})`);
   }
+  if (operationalProfile.coverages.length > 0) {
+    try {
+      const validNodeIds = new Set(sourceTree.map((node) => node.id));
+      const validSpanIds = new Set(sourceSpans.map((span) => span.id));
+      const budget = params.resolveBudget("extraction_operational_profile", 4096);
+      const startedAt = Date.now();
+      const response = await safeGenerateObject(
+        params.generateObject,
+        {
+          prompt: buildOperationalProfileCleanupPrompt(sourceTree, operationalProfile),
+          schema: OperationalProfileCleanupSchema,
+          maxTokens: budget.maxTokens,
+          taskKind: "extraction_operational_profile",
+          budgetDiagnostics: budget,
+          providerOptions: params.providerOptions
+        },
+        {
+          fallback: { coverageDecisions: [], warnings: [] },
+          log: params.log
+        }
+      );
+      localTrack(response.usage, {
+        taskKind: "extraction_operational_profile",
+        label: "operational_profile_cleanup",
+        maxTokens: budget.maxTokens,
+        durationMs: Date.now() - startedAt
+      });
+      operationalProfile = applyOperationalProfileCleanup(
+        operationalProfile,
+        response.object,
+        validNodeIds,
+        validSpanIds
+      );
+    } catch (error) {
+      warnings.push(`Operational profile cleanup pass failed; uncleaned profile used (${error instanceof Error ? error.message : String(error)})`);
+    }
+  } else {
+    await params.log?.("Operational profile has no coverage rows; skipped model cleanup");
+  }
   const document = materializeDocument({
     id: params.id,
     sourceTree,
@@ -12631,8 +13034,8 @@ Respond with JSON only:
 }`;
 
 // src/schemas/application.ts
-import { z as z42 } from "zod";
-var FieldTypeSchema = z42.enum([
+import { z as z43 } from "zod";
+var FieldTypeSchema = z43.enum([
   "text",
   "numeric",
   "currency",
@@ -12641,223 +13044,223 @@ var FieldTypeSchema = z42.enum([
   "table",
   "declaration"
 ]);
-var ApplicationFieldSchema = z42.object({
-  id: z42.string(),
-  label: z42.string(),
-  section: z42.string(),
+var ApplicationFieldSchema = z43.object({
+  id: z43.string(),
+  label: z43.string(),
+  section: z43.string(),
   fieldType: FieldTypeSchema,
-  required: z42.boolean(),
-  options: z42.array(z42.string()).optional(),
-  columns: z42.array(z42.string()).optional(),
-  requiresExplanationIfYes: z42.boolean().optional(),
-  condition: z42.object({
-    dependsOn: z42.string(),
-    whenValue: z42.string()
+  required: z43.boolean(),
+  options: z43.array(z43.string()).optional(),
+  columns: z43.array(z43.string()).optional(),
+  requiresExplanationIfYes: z43.boolean().optional(),
+  condition: z43.object({
+    dependsOn: z43.string(),
+    whenValue: z43.string()
   }).optional(),
-  value: z42.string().optional(),
-  source: z42.string().optional().describe("Where the value came from: auto-fill, user, lookup"),
-  confidence: z42.enum(["confirmed", "high", "medium", "low"]).optional(),
-  sourceSpanIds: z42.array(z42.string()).optional().describe("Stable source spans that support the field value or field anchor"),
-  userSourceSpanIds: z42.array(z42.string()).optional().describe("Message or attachment spans that support user-provided values"),
-  pageNumber: z42.number().int().positive().optional().describe("Application page where the field label or anchor appears"),
-  fieldAnchorId: z42.string().optional().describe("Stable field anchor ID derived from page, section, label, and form metadata"),
-  acroFormName: z42.string().optional().describe("Native PDF AcroForm field name when available"),
-  validationStatus: z42.enum(["valid", "needs_review", "unsupported", "missing"]).optional()
+  value: z43.string().optional(),
+  source: z43.string().optional().describe("Where the value came from: auto-fill, user, lookup"),
+  confidence: z43.enum(["confirmed", "high", "medium", "low"]).optional(),
+  sourceSpanIds: z43.array(z43.string()).optional().describe("Stable source spans that support the field value or field anchor"),
+  userSourceSpanIds: z43.array(z43.string()).optional().describe("Message or attachment spans that support user-provided values"),
+  pageNumber: z43.number().int().positive().optional().describe("Application page where the field label or anchor appears"),
+  fieldAnchorId: z43.string().optional().describe("Stable field anchor ID derived from page, section, label, and form metadata"),
+  acroFormName: z43.string().optional().describe("Native PDF AcroForm field name when available"),
+  validationStatus: z43.enum(["valid", "needs_review", "unsupported", "missing"]).optional()
 });
-var ApplicationQuestionConditionSchema = z42.object({
-  dependsOn: z42.string(),
-  operator: z42.enum(["equals", "not_equals", "in", "not_in", "exists"]).optional(),
-  value: z42.string().optional(),
-  whenValue: z42.string().optional(),
-  values: z42.array(z42.string()).optional()
+var ApplicationQuestionConditionSchema = z43.object({
+  dependsOn: z43.string(),
+  operator: z43.enum(["equals", "not_equals", "in", "not_in", "exists"]).optional(),
+  value: z43.string().optional(),
+  whenValue: z43.string().optional(),
+  values: z43.array(z43.string()).optional()
 });
-var ApplicationRepeatSchema = z42.object({
-  min: z42.number().int().nonnegative().optional(),
-  max: z42.number().int().positive().optional(),
-  label: z42.string().optional()
+var ApplicationRepeatSchema = z43.object({
+  min: z43.number().int().nonnegative().optional(),
+  max: z43.number().int().positive().optional(),
+  label: z43.string().optional()
 });
-var ApplicationQuestionNodeSchema = z42.lazy(
-  () => z42.object({
-    id: z42.string(),
-    nodeType: z42.enum(["group", "question", "repeat_group", "table"]),
-    fieldId: z42.string().optional(),
-    fieldPath: z42.string().optional(),
-    parentId: z42.string().optional(),
-    order: z42.number().int().nonnegative().optional(),
-    label: z42.string(),
-    section: z42.string().optional(),
+var ApplicationQuestionNodeSchema = z43.lazy(
+  () => z43.object({
+    id: z43.string(),
+    nodeType: z43.enum(["group", "question", "repeat_group", "table"]),
+    fieldId: z43.string().optional(),
+    fieldPath: z43.string().optional(),
+    parentId: z43.string().optional(),
+    order: z43.number().int().nonnegative().optional(),
+    label: z43.string(),
+    section: z43.string().optional(),
     fieldType: FieldTypeSchema.optional(),
-    required: z42.boolean().optional(),
-    prompt: z42.string().optional(),
-    options: z42.array(z42.string()).optional(),
-    columns: z42.array(z42.string()).optional(),
+    required: z43.boolean().optional(),
+    prompt: z43.string().optional(),
+    options: z43.array(z43.string()).optional(),
+    columns: z43.array(z43.string()).optional(),
     condition: ApplicationQuestionConditionSchema.optional(),
     repeat: ApplicationRepeatSchema.optional(),
-    children: z42.array(ApplicationQuestionNodeSchema).optional()
+    children: z43.array(ApplicationQuestionNodeSchema).optional()
   })
 );
-var ApplicationQuestionGraphSchema = z42.object({
-  id: z42.string(),
-  version: z42.string(),
-  title: z42.string().optional(),
-  applicationType: z42.string().nullable().optional(),
-  source: z42.enum(["pdf", "manual", "imported", "generated"]).default("generated"),
-  rootNodeIds: z42.array(z42.string()).optional(),
-  nodes: z42.array(ApplicationQuestionNodeSchema)
+var ApplicationQuestionGraphSchema = z43.object({
+  id: z43.string(),
+  version: z43.string(),
+  title: z43.string().optional(),
+  applicationType: z43.string().nullable().optional(),
+  source: z43.enum(["pdf", "manual", "imported", "generated"]).default("generated"),
+  rootNodeIds: z43.array(z43.string()).optional(),
+  nodes: z43.array(ApplicationQuestionNodeSchema)
 });
-var ApplicationTemplateSchema = z42.object({
-  id: z42.string(),
-  version: z42.string(),
-  title: z42.string(),
-  applicationType: z42.string().nullable().optional(),
+var ApplicationTemplateSchema = z43.object({
+  id: z43.string(),
+  version: z43.string(),
+  title: z43.string(),
+  applicationType: z43.string().nullable().optional(),
   questionGraph: ApplicationQuestionGraphSchema,
-  fields: z42.array(ApplicationFieldSchema).optional()
+  fields: z43.array(ApplicationFieldSchema).optional()
 });
-var ApplicationClassifyResultSchema = z42.object({
-  isApplication: z42.boolean(),
-  confidence: z42.number().min(0).max(1),
-  applicationType: z42.string().nullable()
+var ApplicationClassifyResultSchema = z43.object({
+  isApplication: z43.boolean(),
+  confidence: z43.number().min(0).max(1),
+  applicationType: z43.string().nullable()
 });
-var FieldExtractionResultSchema = z42.object({
-  fields: z42.array(ApplicationFieldSchema)
+var FieldExtractionResultSchema = z43.object({
+  fields: z43.array(ApplicationFieldSchema)
 });
-var AutoFillMatchSchema = z42.object({
-  fieldId: z42.string(),
-  value: z42.string(),
-  confidence: z42.enum(["confirmed"]),
-  contextKey: z42.string()
+var AutoFillMatchSchema = z43.object({
+  fieldId: z43.string(),
+  value: z43.string(),
+  confidence: z43.enum(["confirmed"]),
+  contextKey: z43.string()
 });
-var AutoFillResultSchema = z42.object({
-  matches: z42.array(AutoFillMatchSchema)
+var AutoFillResultSchema = z43.object({
+  matches: z43.array(AutoFillMatchSchema)
 });
-var QuestionBatchResultSchema = z42.object({
-  batches: z42.array(z42.array(z42.string()).describe("Array of field IDs in this batch"))
+var QuestionBatchResultSchema = z43.object({
+  batches: z43.array(z43.array(z43.string()).describe("Array of field IDs in this batch"))
 });
-var LookupRequestSchema = z42.object({
-  type: z42.string().describe("Type of lookup: 'records', 'website', 'policy'"),
-  description: z42.string(),
-  url: z42.string().optional(),
-  targetFieldIds: z42.array(z42.string())
+var LookupRequestSchema = z43.object({
+  type: z43.string().describe("Type of lookup: 'records', 'website', 'policy'"),
+  description: z43.string(),
+  url: z43.string().optional(),
+  targetFieldIds: z43.array(z43.string())
 });
-var ReplyIntentSchema = z42.object({
-  primaryIntent: z42.enum(["answers_only", "question", "lookup_request", "mixed"]),
-  hasAnswers: z42.boolean(),
-  questionText: z42.string().optional(),
-  questionFieldIds: z42.array(z42.string()).optional(),
-  lookupRequests: z42.array(LookupRequestSchema).optional()
+var ReplyIntentSchema = z43.object({
+  primaryIntent: z43.enum(["answers_only", "question", "lookup_request", "mixed"]),
+  hasAnswers: z43.boolean(),
+  questionText: z43.string().optional(),
+  questionFieldIds: z43.array(z43.string()).optional(),
+  lookupRequests: z43.array(LookupRequestSchema).optional()
 });
-var ParsedAnswerSchema = z42.object({
-  fieldId: z42.string(),
-  value: z42.string(),
-  explanation: z42.string().optional()
+var ParsedAnswerSchema = z43.object({
+  fieldId: z43.string(),
+  value: z43.string(),
+  explanation: z43.string().optional()
 });
-var AnswerParsingResultSchema = z42.object({
-  answers: z42.array(ParsedAnswerSchema),
-  unanswered: z42.array(z42.string()).describe("Field IDs that were not answered")
+var AnswerParsingResultSchema = z43.object({
+  answers: z43.array(ParsedAnswerSchema),
+  unanswered: z43.array(z43.string()).describe("Field IDs that were not answered")
 });
-var LookupFillSchema = z42.object({
-  fieldId: z42.string(),
-  value: z42.string(),
-  source: z42.string().describe("Specific citable reference, e.g. 'GL Policy #POL-12345 (Hartford)'"),
-  sourceSpanIds: z42.array(z42.string()).optional()
+var LookupFillSchema = z43.object({
+  fieldId: z43.string(),
+  value: z43.string(),
+  source: z43.string().describe("Specific citable reference, e.g. 'GL Policy #POL-12345 (Hartford)'"),
+  sourceSpanIds: z43.array(z43.string()).optional()
 });
-var LookupFillResultSchema = z42.object({
-  fills: z42.array(LookupFillSchema),
-  unfillable: z42.array(z42.string()),
-  explanation: z42.string().optional()
+var LookupFillResultSchema = z43.object({
+  fills: z43.array(LookupFillSchema),
+  unfillable: z43.array(z43.string()),
+  explanation: z43.string().optional()
 });
-var FlatPdfPlacementSchema = z42.object({
-  fieldId: z42.string(),
-  page: z42.number(),
-  x: z42.number().describe("Percentage from left edge (0-100)"),
-  y: z42.number().describe("Percentage from top edge (0-100)"),
-  text: z42.string(),
-  fontSize: z42.number().optional(),
-  isCheckmark: z42.boolean().optional()
+var FlatPdfPlacementSchema = z43.object({
+  fieldId: z43.string(),
+  page: z43.number(),
+  x: z43.number().describe("Percentage from left edge (0-100)"),
+  y: z43.number().describe("Percentage from top edge (0-100)"),
+  text: z43.string(),
+  fontSize: z43.number().optional(),
+  isCheckmark: z43.boolean().optional()
 });
-var AcroFormMappingSchema = z42.object({
-  fieldId: z42.string(),
-  acroFormName: z42.string(),
-  value: z42.string()
+var AcroFormMappingSchema = z43.object({
+  fieldId: z43.string(),
+  acroFormName: z43.string(),
+  value: z43.string()
 });
-var QualityGateStatusSchema = z42.enum(["passed", "warning", "failed"]);
-var QualitySeveritySchema = z42.enum(["info", "warning", "blocking"]);
-var ApplicationQualityIssueSchema = z42.object({
-  code: z42.string(),
+var QualityGateStatusSchema = z43.enum(["passed", "warning", "failed"]);
+var QualitySeveritySchema = z43.enum(["info", "warning", "blocking"]);
+var ApplicationQualityIssueSchema = z43.object({
+  code: z43.string(),
   severity: QualitySeveritySchema,
-  message: z42.string(),
-  fieldId: z42.string().optional()
+  message: z43.string(),
+  fieldId: z43.string().optional()
 });
-var ApplicationQualityRoundSchema = z42.object({
-  round: z42.number(),
-  kind: z42.string(),
+var ApplicationQualityRoundSchema = z43.object({
+  round: z43.number(),
+  kind: z43.string(),
   status: QualityGateStatusSchema,
-  summary: z42.string().optional()
+  summary: z43.string().optional()
 });
-var ApplicationQualityArtifactSchema = z42.object({
-  kind: z42.string(),
-  label: z42.string().optional(),
-  itemCount: z42.number().optional()
+var ApplicationQualityArtifactSchema = z43.object({
+  kind: z43.string(),
+  label: z43.string().optional(),
+  itemCount: z43.number().optional()
 });
-var ApplicationEmailReviewSchema = z42.object({
-  issues: z42.array(ApplicationQualityIssueSchema),
+var ApplicationEmailReviewSchema = z43.object({
+  issues: z43.array(ApplicationQualityIssueSchema),
   qualityGateStatus: QualityGateStatusSchema
 });
-var ApplicationQualityReportSchema = z42.object({
-  issues: z42.array(ApplicationQualityIssueSchema),
-  rounds: z42.array(ApplicationQualityRoundSchema).optional(),
-  artifacts: z42.array(ApplicationQualityArtifactSchema).optional(),
+var ApplicationQualityReportSchema = z43.object({
+  issues: z43.array(ApplicationQualityIssueSchema),
+  rounds: z43.array(ApplicationQualityRoundSchema).optional(),
+  artifacts: z43.array(ApplicationQualityArtifactSchema).optional(),
   emailReview: ApplicationEmailReviewSchema.optional(),
   qualityGateStatus: QualityGateStatusSchema
 });
-var ApplicationContextProposalSchema = z42.object({
-  id: z42.string(),
-  fieldId: z42.string().optional(),
-  key: z42.string(),
-  value: z42.string(),
-  category: z42.string(),
-  source: z42.enum(["application", "user", "lookup", "policy", "email", "chat", "imessage", "mcp"]),
-  confidence: z42.enum(["confirmed", "high", "medium", "low"]),
-  sourceSpanIds: z42.array(z42.string()).optional(),
-  userSourceSpanIds: z42.array(z42.string()).optional()
+var ApplicationContextProposalSchema = z43.object({
+  id: z43.string(),
+  fieldId: z43.string().optional(),
+  key: z43.string(),
+  value: z43.string(),
+  category: z43.string(),
+  source: z43.enum(["application", "user", "lookup", "policy", "email", "chat", "imessage", "mcp"]),
+  confidence: z43.enum(["confirmed", "high", "medium", "low"]),
+  sourceSpanIds: z43.array(z43.string()).optional(),
+  userSourceSpanIds: z43.array(z43.string()).optional()
 });
-var ApplicationPacketAnswerSchema = z42.object({
-  fieldId: z42.string(),
-  label: z42.string(),
-  section: z42.string(),
-  value: z42.string(),
-  source: z42.string(),
-  confidence: z42.enum(["confirmed", "high", "medium", "low"]).optional(),
-  sourceSpanIds: z42.array(z42.string()).optional(),
-  userSourceSpanIds: z42.array(z42.string()).optional()
+var ApplicationPacketAnswerSchema = z43.object({
+  fieldId: z43.string(),
+  label: z43.string(),
+  section: z43.string(),
+  value: z43.string(),
+  source: z43.string(),
+  confidence: z43.enum(["confirmed", "high", "medium", "low"]).optional(),
+  sourceSpanIds: z43.array(z43.string()).optional(),
+  userSourceSpanIds: z43.array(z43.string()).optional()
 });
-var ApplicationPacketSchema = z42.object({
-  id: z42.string(),
-  applicationId: z42.string(),
-  title: z42.string(),
-  status: z42.enum(["draft", "broker_ready", "submitted"]),
-  answers: z42.array(ApplicationPacketAnswerSchema),
-  missingFieldIds: z42.array(z42.string()),
+var ApplicationPacketSchema = z43.object({
+  id: z43.string(),
+  applicationId: z43.string(),
+  title: z43.string(),
+  status: z43.enum(["draft", "broker_ready", "submitted"]),
+  answers: z43.array(ApplicationPacketAnswerSchema),
+  missingFieldIds: z43.array(z43.string()),
   qualityReport: ApplicationQualityReportSchema,
-  submissionNotes: z42.string().optional(),
-  createdAt: z42.number()
+  submissionNotes: z43.string().optional(),
+  createdAt: z43.number()
 });
-var ApplicationStateSchema = z42.object({
-  id: z42.string(),
-  pdfBase64: z42.string().optional().describe("Original PDF, omitted after extraction"),
-  templateId: z42.string().optional(),
-  templateVersion: z42.string().optional(),
+var ApplicationStateSchema = z43.object({
+  id: z43.string(),
+  pdfBase64: z43.string().optional().describe("Original PDF, omitted after extraction"),
+  templateId: z43.string().optional(),
+  templateVersion: z43.string().optional(),
   templateSnapshot: ApplicationTemplateSchema.optional(),
-  title: z42.string().optional(),
-  applicationType: z42.string().nullable().optional(),
+  title: z43.string().optional(),
+  applicationType: z43.string().nullable().optional(),
   questionGraph: ApplicationQuestionGraphSchema.optional(),
-  fields: z42.array(ApplicationFieldSchema),
-  batches: z42.array(z42.array(z42.string())).optional(),
-  currentBatchIndex: z42.number().default(0),
-  contextProposals: z42.array(ApplicationContextProposalSchema).optional(),
+  fields: z43.array(ApplicationFieldSchema),
+  batches: z43.array(z43.array(z43.string())).optional(),
+  currentBatchIndex: z43.number().default(0),
+  contextProposals: z43.array(ApplicationContextProposalSchema).optional(),
   packet: ApplicationPacketSchema.optional(),
   qualityReport: ApplicationQualityReportSchema.optional(),
-  status: z42.enum([
+  status: z43.enum([
     "classifying",
     "extracting",
     "auto_filling",
@@ -12871,8 +13274,8 @@ var ApplicationStateSchema = z42.object({
     "cancelled",
     "complete"
   ]),
-  createdAt: z42.number(),
-  updatedAt: z42.number()
+  createdAt: z43.number(),
+  updatedAt: z43.number()
 });
 
 // src/application/agents/classifier.ts
@@ -14606,106 +15009,106 @@ Respond with the final answer, deduplicated citations array, overall confidence
 }
 
 // src/schemas/query.ts
-import { z as z43 } from "zod";
-var QueryIntentSchema = z43.enum([
+import { z as z44 } from "zod";
+var QueryIntentSchema = z44.enum([
   "policy_question",
   "coverage_comparison",
   "document_search",
   "claims_inquiry",
   "general_knowledge"
 ]);
-var QueryAttachmentKindSchema = z43.enum(["image", "pdf", "text"]);
-var QueryAttachmentSchema = z43.object({
-  id: z43.string().optional().describe("Optional stable attachment ID from the caller"),
+var QueryAttachmentKindSchema = z44.enum(["image", "pdf", "text"]);
+var QueryAttachmentSchema = z44.object({
+  id: z44.string().optional().describe("Optional stable attachment ID from the caller"),
   kind: QueryAttachmentKindSchema,
-  name: z43.string().optional().describe("Original filename or user-facing label"),
-  mimeType: z43.string().optional().describe("MIME type such as image/jpeg or application/pdf"),
-  base64: z43.string().optional().describe("Base64-encoded file content for image/pdf attachments"),
-  text: z43.string().optional().describe("Plain-text attachment content when available"),
-  description: z43.string().optional().describe("Caller-provided description of the attachment")
+  name: z44.string().optional().describe("Original filename or user-facing label"),
+  mimeType: z44.string().optional().describe("MIME type such as image/jpeg or application/pdf"),
+  base64: z44.string().optional().describe("Base64-encoded file content for image/pdf attachments"),
+  text: z44.string().optional().describe("Plain-text attachment content when available"),
+  description: z44.string().optional().describe("Caller-provided description of the attachment")
 });
-var QueryRetrievalModeSchema = z43.enum([
+var QueryRetrievalModeSchema = z44.enum([
   "graph_only",
   "source_rag",
   "long_context",
   "hybrid"
 ]);
-var SubQuestionSchema = z43.object({
-  question: z43.string().describe("Atomic sub-question to retrieve and answer independently"),
+var SubQuestionSchema = z44.object({
+  question: z44.string().describe("Atomic sub-question to retrieve and answer independently"),
   intent: QueryIntentSchema,
-  chunkTypes: z43.array(z43.string()).optional().describe("Chunk types to filter retrieval (e.g. coverage, endorsement, declaration)"),
-  documentFilters: z43.object({
-    type: z43.enum(["policy", "quote"]).optional(),
-    carrier: z43.string().optional(),
-    insuredName: z43.string().optional(),
-    policyNumber: z43.string().optional(),
-    quoteNumber: z43.string().optional(),
-    policyTypes: z43.array(PolicyTypeSchema).optional().describe("Filter by policy type (e.g. homeowners_ho3, renters_ho4, pet) to avoid mixing up similar policies")
+  chunkTypes: z44.array(z44.string()).optional().describe("Chunk types to filter retrieval (e.g. coverage, endorsement, declaration)"),
+  documentFilters: z44.object({
+    type: z44.enum(["policy", "quote"]).optional(),
+    carrier: z44.string().optional(),
+    insuredName: z44.string().optional(),
+    policyNumber: z44.string().optional(),
+    quoteNumber: z44.string().optional(),
+    policyTypes: z44.array(PolicyTypeSchema).optional().describe("Filter by policy type (e.g. homeowners_ho3, renters_ho4, pet) to avoid mixing up similar policies")
   }).optional().describe("Structured filters to narrow document lookup")
 });
-var QueryClassifyResultSchema = z43.object({
+var QueryClassifyResultSchema = z44.object({
   intent: QueryIntentSchema,
-  subQuestions: z43.array(SubQuestionSchema).min(1).describe("Decomposed atomic sub-questions"),
-  requiresDocumentLookup: z43.boolean().describe("Whether structured document lookup is needed"),
-  requiresChunkSearch: z43.boolean().describe("Whether semantic chunk search is needed"),
-  requiresConversationHistory: z43.boolean().describe("Whether conversation history is relevant"),
+  subQuestions: z44.array(SubQuestionSchema).min(1).describe("Decomposed atomic sub-questions"),
+  requiresDocumentLookup: z44.boolean().describe("Whether structured document lookup is needed"),
+  requiresChunkSearch: z44.boolean().describe("Whether semantic chunk search is needed"),
+  requiresConversationHistory: z44.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 = z43.object({
-  source: z43.enum(["chunk", "document", "conversation", "attachment", "source_span", "source_node"]),
-  chunkId: z43.string().optional(),
-  sourceNodeId: z43.string().optional(),
-  sourceSpanId: z43.string().optional(),
-  documentId: z43.string().optional(),
-  turnId: z43.string().optional(),
-  attachmentId: z43.string().optional(),
-  text: z43.string().describe("Text excerpt from the source"),
-  relevance: z43.number().min(0).max(1),
+var EvidenceItemSchema = z44.object({
+  source: z44.enum(["chunk", "document", "conversation", "attachment", "source_span", "source_node"]),
+  chunkId: z44.string().optional(),
+  sourceNodeId: z44.string().optional(),
+  sourceSpanId: z44.string().optional(),
+  documentId: z44.string().optional(),
+  turnId: z44.string().optional(),
+  attachmentId: z44.string().optional(),
+  text: z44.string().describe("Text excerpt from the source"),
+  relevance: z44.number().min(0).max(1),
   retrievalMode: QueryRetrievalModeSchema.optional(),
   sourceLocation: SourceSpanLocationSchema.optional(),
-  metadata: z43.array(z43.object({ key: z43.string(), value: z43.string() })).optional()
+  metadata: z44.array(z44.object({ key: z44.string(), value: z44.string() })).optional()
 });
-var AttachmentInterpretationSchema = z43.object({
-  summary: z43.string().describe("Concise summary of what the attachment shows or contains"),
-  extractedFacts: z43.array(z43.string()).describe("Specific observable or document facts grounded in the attachment"),
-  recommendedFocus: z43.array(z43.string()).describe("Important details to incorporate when answering follow-up questions"),
-  confidence: z43.number().min(0).max(1)
+var AttachmentInterpretationSchema = z44.object({
+  summary: z44.string().describe("Concise summary of what the attachment shows or contains"),
+  extractedFacts: z44.array(z44.string()).describe("Specific observable or document facts grounded in the attachment"),
+  recommendedFocus: z44.array(z44.string()).describe("Important details to incorporate when answering follow-up questions"),
+  confidence: z44.number().min(0).max(1)
 });
-var RetrievalResultSchema = z43.object({
-  subQuestion: z43.string(),
-  evidence: z43.array(EvidenceItemSchema)
+var RetrievalResultSchema = z44.object({
+  subQuestion: z44.string(),
+  evidence: z44.array(EvidenceItemSchema)
 });
-var CitationSchema = z43.object({
-  index: z43.number().describe("Citation number [1], [2], etc."),
-  chunkId: z43.string().optional().describe("Source chunk ID, e.g. doc-123:coverage:2"),
-  sourceNodeId: z43.string().optional().describe("Source tree node ID when available"),
-  sourceSpanId: z43.string().optional().describe("Precise source span ID when available"),
-  documentId: z43.string(),
-  documentType: z43.enum(["policy", "quote"]).optional(),
-  field: z43.string().optional().describe("Specific field path, e.g. coverages[0].deductible"),
-  quote: z43.string().describe("Exact text from source that supports the claim"),
-  relevance: z43.number().min(0).max(1),
+var CitationSchema = z44.object({
+  index: z44.number().describe("Citation number [1], [2], etc."),
+  chunkId: z44.string().optional().describe("Source chunk ID, e.g. doc-123:coverage:2"),
+  sourceNodeId: z44.string().optional().describe("Source tree node ID when available"),
+  sourceSpanId: z44.string().optional().describe("Precise source span ID when available"),
+  documentId: z44.string(),
+  documentType: z44.enum(["policy", "quote"]).optional(),
+  field: z44.string().optional().describe("Specific field path, e.g. coverages[0].deductible"),
+  quote: z44.string().describe("Exact text from source that supports the claim"),
+  relevance: z44.number().min(0).max(1),
   retrievalMode: QueryRetrievalModeSchema.optional(),
   sourceLocation: SourceSpanLocationSchema.optional()
 });
-var SubAnswerSchema = z43.object({
-  subQuestion: z43.string(),
-  answer: z43.string(),
-  citations: z43.array(CitationSchema),
-  confidence: z43.number().min(0).max(1),
-  needsMoreContext: z43.boolean().describe("True if evidence was insufficient to answer fully")
+var SubAnswerSchema = z44.object({
+  subQuestion: z44.string(),
+  answer: z44.string(),
+  citations: z44.array(CitationSchema),
+  confidence: z44.number().min(0).max(1),
+  needsMoreContext: z44.boolean().describe("True if evidence was insufficient to answer fully")
 });
-var VerifyResultSchema = z43.object({
-  approved: z43.boolean().describe("Whether all sub-answers are adequately grounded"),
-  issues: z43.array(z43.string()).describe("Specific grounding or consistency issues found"),
-  retrySubQuestions: z43.array(z43.string()).optional().describe("Sub-questions that need additional retrieval or re-reasoning")
+var VerifyResultSchema = z44.object({
+  approved: z44.boolean().describe("Whether all sub-answers are adequately grounded"),
+  issues: z44.array(z44.string()).describe("Specific grounding or consistency issues found"),
+  retrySubQuestions: z44.array(z44.string()).optional().describe("Sub-questions that need additional retrieval or re-reasoning")
 });
-var QueryResultSchema = z43.object({
-  answer: z43.string(),
-  citations: z43.array(CitationSchema),
+var QueryResultSchema = z44.object({
+  answer: z44.string(),
+  citations: z44.array(CitationSchema),
   intent: QueryIntentSchema,
-  confidence: z43.number().min(0).max(1),
-  followUp: z43.string().optional().describe("Suggested follow-up question if applicable")
+  confidence: z44.number().min(0).max(1),
+  followUp: z44.string().optional().describe("Suggested follow-up question if applicable")
 });
 
 // src/query/retriever.ts
@@ -15772,7 +16175,7 @@ ${sa.answer}`).join("\n\n"),
 }
 
 // src/pce/index.ts
-import { z as z44 } from "zod";
+import { z as z45 } from "zod";
 
 // src/prompts/pce/index.ts
 function buildPceNormalizePrompt(input) {
@@ -15806,11 +16209,11 @@ ${input.openQuestions.map((question) => `- ${question.id}${question.fieldPath ?
 }
 
 // src/pce/index.ts
-var ReplyAnswersSchema = z44.object({
-  answers: z44.array(z44.object({
-    questionId: z44.string().optional(),
-    fieldPath: z44.string().optional(),
-    answer: z44.string()
+var ReplyAnswersSchema = z45.object({
+  answers: z45.array(z45.object({
+    questionId: z45.string().optional(),
+    fieldPath: z45.string().optional(),
+    answer: z45.string()
   }))
 });
 function createPceAgent(config = {}) {