@claritylabs/cl-sdk 3.1.0 → 3.1.3

package/dist/index.js

@@ -3611,6 +3611,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",
@@ -3631,6 +3637,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";
@@ -3657,9 +3664,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;
   }
@@ -3678,13 +3689,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) ?? [];
 }
@@ -3727,18 +3757,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);
@@ -3751,20 +3773,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 = [];
@@ -3790,11 +3830,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) {
@@ -3827,7 +3867,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();
@@ -3841,7 +3881,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;
@@ -3866,8 +3906,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;
@@ -10062,7 +10101,343 @@ function groundExtractionMemoryWithSourceSpans(memory, sourceSpans) {
 }
 
 // src/extraction/source-tree-extractor.ts
+var import_zod42 = require("zod");
+
+// src/extraction/operational-profile-cleanup.ts
 var import_zod41 = require("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 = import_zod41.z.enum(OPERATIONAL_COVERAGE_TERM_KINDS2);
+var OperationalProfileCleanupSchema = import_zod41.z.object({
+  coverageDecisions: import_zod41.z.array(import_zod41.z.object({
+    coverageIndex: import_zod41.z.number().int().nonnegative(),
+    action: import_zod41.z.enum(["keep", "drop", "update"]),
+    reason: import_zod41.z.string().optional(),
+    name: import_zod41.z.string().optional(),
+    limit: import_zod41.z.string().nullable().optional(),
+    deductible: import_zod41.z.string().nullable().optional(),
+    premium: import_zod41.z.string().nullable().optional(),
+    retroactiveDate: import_zod41.z.string().nullable().optional(),
+    coverageOrigin: import_zod41.z.enum(["core", "endorsement"]).optional(),
+    sourceNodeIds: import_zod41.z.array(import_zod41.z.string()).optional(),
+    sourceSpanIds: import_zod41.z.array(import_zod41.z.string()).optional(),
+    termDecisions: import_zod41.z.array(import_zod41.z.object({
+      termIndex: import_zod41.z.number().int().nonnegative(),
+      action: import_zod41.z.enum(["keep", "drop", "update"]),
+      reason: import_zod41.z.string().optional(),
+      kind: OperationalCoverageTermKindSchema.optional(),
+      label: import_zod41.z.string().optional(),
+      value: import_zod41.z.string().optional(),
+      amount: import_zod41.z.number().nullable().optional(),
+      appliesTo: import_zod41.z.string().nullable().optional(),
+      sourceNodeIds: import_zod41.z.array(import_zod41.z.string()).optional(),
+      sourceSpanIds: import_zod41.z.array(import_zod41.z.string()).optional()
+    })).optional()
+  })).default([]),
+  warnings: import_zod41.z.array(import_zod41.z.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",
@@ -10075,10 +10450,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 = import_zod41.z.object({
-  labels: import_zod41.z.array(import_zod41.z.object({
-    nodeId: import_zod41.z.string(),
-    kind: import_zod41.z.enum([
+var SourceTreeOrganizationSchema = import_zod42.z.object({
+  labels: import_zod42.z.array(import_zod42.z.object({
+    nodeId: import_zod42.z.string(),
+    kind: import_zod42.z.enum([
       "document",
       "page_group",
       "page",
@@ -10092,26 +10467,26 @@ var SourceTreeOrganizationSchema = import_zod41.z.object({
       "table_cell",
       "text"
     ]).optional(),
-    title: import_zod41.z.string().optional(),
-    description: import_zod41.z.string().optional()
+    title: import_zod42.z.string().optional(),
+    description: import_zod42.z.string().optional()
   })),
-  groups: import_zod41.z.array(import_zod41.z.object({
-    kind: import_zod41.z.enum(ORGANIZABLE_KINDS),
-    title: import_zod41.z.string(),
-    description: import_zod41.z.string().optional(),
-    childNodeIds: import_zod41.z.array(import_zod41.z.string()).min(1)
+  groups: import_zod42.z.array(import_zod42.z.object({
+    kind: import_zod42.z.enum(ORGANIZABLE_KINDS),
+    title: import_zod42.z.string(),
+    description: import_zod42.z.string().optional(),
+    childNodeIds: import_zod42.z.array(import_zod42.z.string()).min(1)
   }))
 });
-var SourceBackedValueForPromptSchema = import_zod41.z.object({
-  value: import_zod41.z.string(),
-  normalizedValue: import_zod41.z.string().optional(),
-  confidence: import_zod41.z.enum(["low", "medium", "high"]).optional(),
-  sourceNodeIds: import_zod41.z.array(import_zod41.z.string()),
-  sourceSpanIds: import_zod41.z.array(import_zod41.z.string())
+var SourceBackedValueForPromptSchema = import_zod42.z.object({
+  value: import_zod42.z.string(),
+  normalizedValue: import_zod42.z.string().optional(),
+  confidence: import_zod42.z.enum(["low", "medium", "high"]).optional(),
+  sourceNodeIds: import_zod42.z.array(import_zod42.z.string()),
+  sourceSpanIds: import_zod42.z.array(import_zod42.z.string())
 });
-var OperationalProfilePromptSchema = import_zod41.z.object({
-  documentType: import_zod41.z.enum(["policy", "quote"]).optional(),
-  policyTypes: import_zod41.z.array(import_zod41.z.string()).optional(),
+var OperationalProfilePromptSchema = import_zod42.z.object({
+  documentType: import_zod42.z.enum(["policy", "quote"]).optional(),
+  policyTypes: import_zod42.z.array(import_zod42.z.string()).optional(),
   policyNumber: SourceBackedValueForPromptSchema.optional(),
   namedInsured: SourceBackedValueForPromptSchema.optional(),
   insurer: SourceBackedValueForPromptSchema.optional(),
@@ -10120,43 +10495,32 @@ var OperationalProfilePromptSchema = import_zod41.z.object({
   expirationDate: SourceBackedValueForPromptSchema.optional(),
   retroactiveDate: SourceBackedValueForPromptSchema.optional(),
   premium: SourceBackedValueForPromptSchema.optional(),
-  coverageTypes: import_zod41.z.array(import_zod41.z.string()).optional(),
-  coverages: import_zod41.z.array(import_zod41.z.object({
-    name: import_zod41.z.string(),
-    coverageCode: import_zod41.z.string().optional(),
-    limit: import_zod41.z.string().optional(),
-    deductible: import_zod41.z.string().optional(),
-    premium: import_zod41.z.string().optional(),
-    retroactiveDate: import_zod41.z.string().optional(),
-    formNumber: import_zod41.z.string().optional(),
-    sectionRef: import_zod41.z.string().optional(),
-    coverageOrigin: import_zod41.z.enum(["core", "endorsement"]).optional(),
-    endorsementNumber: import_zod41.z.string().optional(),
-    limits: import_zod41.z.array(import_zod41.z.object({
-      kind: import_zod41.z.enum([
-        "each_claim_limit",
-        "each_occurrence_limit",
-        "each_loss_limit",
-        "aggregate_limit",
-        "sublimit",
-        "retention",
-        "deductible",
-        "retroactive_date",
-        "premium",
-        "other"
-      ]).optional(),
-      label: import_zod41.z.string(),
-      value: import_zod41.z.string(),
-      amount: import_zod41.z.number().optional(),
-      appliesTo: import_zod41.z.string().optional(),
-      sourceNodeIds: import_zod41.z.array(import_zod41.z.string()),
-      sourceSpanIds: import_zod41.z.array(import_zod41.z.string())
+  coverageTypes: import_zod42.z.array(import_zod42.z.string()).optional(),
+  coverages: import_zod42.z.array(import_zod42.z.object({
+    name: import_zod42.z.string(),
+    coverageCode: import_zod42.z.string().optional(),
+    limit: import_zod42.z.string().optional(),
+    deductible: import_zod42.z.string().optional(),
+    premium: import_zod42.z.string().optional(),
+    retroactiveDate: import_zod42.z.string().optional(),
+    formNumber: import_zod42.z.string().optional(),
+    sectionRef: import_zod42.z.string().optional(),
+    coverageOrigin: import_zod42.z.enum(["core", "endorsement"]).optional(),
+    endorsementNumber: import_zod42.z.string().optional(),
+    limits: import_zod42.z.array(import_zod42.z.object({
+      kind: OperationalCoverageTermKindSchema.optional(),
+      label: import_zod42.z.string(),
+      value: import_zod42.z.string(),
+      amount: import_zod42.z.number().optional(),
+      appliesTo: import_zod42.z.string().optional(),
+      sourceNodeIds: import_zod42.z.array(import_zod42.z.string()),
+      sourceSpanIds: import_zod42.z.array(import_zod42.z.string())
     })).optional(),
-    sourceNodeIds: import_zod41.z.array(import_zod41.z.string()),
-    sourceSpanIds: import_zod41.z.array(import_zod41.z.string())
+    sourceNodeIds: import_zod42.z.array(import_zod42.z.string()),
+    sourceSpanIds: import_zod42.z.array(import_zod42.z.string())
   })).optional(),
-  sourceNodeIds: import_zod41.z.array(import_zod41.z.string()).optional(),
-  sourceSpanIds: import_zod41.z.array(import_zod41.z.string()).optional()
+  sourceNodeIds: import_zod42.z.array(import_zod42.z.string()).optional(),
+  sourceSpanIds: import_zod42.z.array(import_zod42.z.string()).optional()
 });
 function formatFormHintsForPrompt(forms) {
   const usable = forms.filter((form) => typeof form.pageStart === "number" && typeof form.pageEnd === "number").slice(0, 120).map((form) => ({
@@ -11148,7 +11512,7 @@ function applyEndorsementGrouping(sourceTree) {
   }
   return normalizeSemanticHierarchy(nextTree);
 }
-function compactNode(node, maxText = 700) {
+function compactNode2(node, maxText = 700) {
   return {
     id: node.id,
     kind: node.kind,
@@ -11238,7 +11602,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:
@@ -11280,7 +11644,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:
@@ -11309,7 +11673,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:
@@ -11673,6 +12037,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,
@@ -12999,8 +13402,8 @@ Respond with JSON only:
 }`;
 
 // src/schemas/application.ts
-var import_zod42 = require("zod");
-var FieldTypeSchema = import_zod42.z.enum([
+var import_zod43 = require("zod");
+var FieldTypeSchema = import_zod43.z.enum([
   "text",
   "numeric",
   "currency",
@@ -13009,223 +13412,223 @@ var FieldTypeSchema = import_zod42.z.enum([
   "table",
   "declaration"
 ]);
-var ApplicationFieldSchema = import_zod42.z.object({
-  id: import_zod42.z.string(),
-  label: import_zod42.z.string(),
-  section: import_zod42.z.string(),
+var ApplicationFieldSchema = import_zod43.z.object({
+  id: import_zod43.z.string(),
+  label: import_zod43.z.string(),
+  section: import_zod43.z.string(),
   fieldType: FieldTypeSchema,
-  required: import_zod42.z.boolean(),
-  options: import_zod42.z.array(import_zod42.z.string()).optional(),
-  columns: import_zod42.z.array(import_zod42.z.string()).optional(),
-  requiresExplanationIfYes: import_zod42.z.boolean().optional(),
-  condition: import_zod42.z.object({
-    dependsOn: import_zod42.z.string(),
-    whenValue: import_zod42.z.string()
+  required: import_zod43.z.boolean(),
+  options: import_zod43.z.array(import_zod43.z.string()).optional(),
+  columns: import_zod43.z.array(import_zod43.z.string()).optional(),
+  requiresExplanationIfYes: import_zod43.z.boolean().optional(),
+  condition: import_zod43.z.object({
+    dependsOn: import_zod43.z.string(),
+    whenValue: import_zod43.z.string()
   }).optional(),
-  value: import_zod42.z.string().optional(),
-  source: import_zod42.z.string().optional().describe("Where the value came from: auto-fill, user, lookup"),
-  confidence: import_zod42.z.enum(["confirmed", "high", "medium", "low"]).optional(),
-  sourceSpanIds: import_zod42.z.array(import_zod42.z.string()).optional().describe("Stable source spans that support the field value or field anchor"),
-  userSourceSpanIds: import_zod42.z.array(import_zod42.z.string()).optional().describe("Message or attachment spans that support user-provided values"),
-  pageNumber: import_zod42.z.number().int().positive().optional().describe("Application page where the field label or anchor appears"),
-  fieldAnchorId: import_zod42.z.string().optional().describe("Stable field anchor ID derived from page, section, label, and form metadata"),
-  acroFormName: import_zod42.z.string().optional().describe("Native PDF AcroForm field name when available"),
-  validationStatus: import_zod42.z.enum(["valid", "needs_review", "unsupported", "missing"]).optional()
+  value: import_zod43.z.string().optional(),
+  source: import_zod43.z.string().optional().describe("Where the value came from: auto-fill, user, lookup"),
+  confidence: import_zod43.z.enum(["confirmed", "high", "medium", "low"]).optional(),
+  sourceSpanIds: import_zod43.z.array(import_zod43.z.string()).optional().describe("Stable source spans that support the field value or field anchor"),
+  userSourceSpanIds: import_zod43.z.array(import_zod43.z.string()).optional().describe("Message or attachment spans that support user-provided values"),
+  pageNumber: import_zod43.z.number().int().positive().optional().describe("Application page where the field label or anchor appears"),
+  fieldAnchorId: import_zod43.z.string().optional().describe("Stable field anchor ID derived from page, section, label, and form metadata"),
+  acroFormName: import_zod43.z.string().optional().describe("Native PDF AcroForm field name when available"),
+  validationStatus: import_zod43.z.enum(["valid", "needs_review", "unsupported", "missing"]).optional()
 });
-var ApplicationQuestionConditionSchema = import_zod42.z.object({
-  dependsOn: import_zod42.z.string(),
-  operator: import_zod42.z.enum(["equals", "not_equals", "in", "not_in", "exists"]).optional(),
-  value: import_zod42.z.string().optional(),
-  whenValue: import_zod42.z.string().optional(),
-  values: import_zod42.z.array(import_zod42.z.string()).optional()
+var ApplicationQuestionConditionSchema = import_zod43.z.object({
+  dependsOn: import_zod43.z.string(),
+  operator: import_zod43.z.enum(["equals", "not_equals", "in", "not_in", "exists"]).optional(),
+  value: import_zod43.z.string().optional(),
+  whenValue: import_zod43.z.string().optional(),
+  values: import_zod43.z.array(import_zod43.z.string()).optional()
 });
-var ApplicationRepeatSchema = import_zod42.z.object({
-  min: import_zod42.z.number().int().nonnegative().optional(),
-  max: import_zod42.z.number().int().positive().optional(),
-  label: import_zod42.z.string().optional()
+var ApplicationRepeatSchema = import_zod43.z.object({
+  min: import_zod43.z.number().int().nonnegative().optional(),
+  max: import_zod43.z.number().int().positive().optional(),
+  label: import_zod43.z.string().optional()
 });
-var ApplicationQuestionNodeSchema = import_zod42.z.lazy(
-  () => import_zod42.z.object({
-    id: import_zod42.z.string(),
-    nodeType: import_zod42.z.enum(["group", "question", "repeat_group", "table"]),
-    fieldId: import_zod42.z.string().optional(),
-    fieldPath: import_zod42.z.string().optional(),
-    parentId: import_zod42.z.string().optional(),
-    order: import_zod42.z.number().int().nonnegative().optional(),
-    label: import_zod42.z.string(),
-    section: import_zod42.z.string().optional(),
+var ApplicationQuestionNodeSchema = import_zod43.z.lazy(
+  () => import_zod43.z.object({
+    id: import_zod43.z.string(),
+    nodeType: import_zod43.z.enum(["group", "question", "repeat_group", "table"]),
+    fieldId: import_zod43.z.string().optional(),
+    fieldPath: import_zod43.z.string().optional(),
+    parentId: import_zod43.z.string().optional(),
+    order: import_zod43.z.number().int().nonnegative().optional(),
+    label: import_zod43.z.string(),
+    section: import_zod43.z.string().optional(),
     fieldType: FieldTypeSchema.optional(),
-    required: import_zod42.z.boolean().optional(),
-    prompt: import_zod42.z.string().optional(),
-    options: import_zod42.z.array(import_zod42.z.string()).optional(),
-    columns: import_zod42.z.array(import_zod42.z.string()).optional(),
+    required: import_zod43.z.boolean().optional(),
+    prompt: import_zod43.z.string().optional(),
+    options: import_zod43.z.array(import_zod43.z.string()).optional(),
+    columns: import_zod43.z.array(import_zod43.z.string()).optional(),
     condition: ApplicationQuestionConditionSchema.optional(),
     repeat: ApplicationRepeatSchema.optional(),
-    children: import_zod42.z.array(ApplicationQuestionNodeSchema).optional()
+    children: import_zod43.z.array(ApplicationQuestionNodeSchema).optional()
   })
 );
-var ApplicationQuestionGraphSchema = import_zod42.z.object({
-  id: import_zod42.z.string(),
-  version: import_zod42.z.string(),
-  title: import_zod42.z.string().optional(),
-  applicationType: import_zod42.z.string().nullable().optional(),
-  source: import_zod42.z.enum(["pdf", "manual", "imported", "generated"]).default("generated"),
-  rootNodeIds: import_zod42.z.array(import_zod42.z.string()).optional(),
-  nodes: import_zod42.z.array(ApplicationQuestionNodeSchema)
+var ApplicationQuestionGraphSchema = import_zod43.z.object({
+  id: import_zod43.z.string(),
+  version: import_zod43.z.string(),
+  title: import_zod43.z.string().optional(),
+  applicationType: import_zod43.z.string().nullable().optional(),
+  source: import_zod43.z.enum(["pdf", "manual", "imported", "generated"]).default("generated"),
+  rootNodeIds: import_zod43.z.array(import_zod43.z.string()).optional(),
+  nodes: import_zod43.z.array(ApplicationQuestionNodeSchema)
 });
-var ApplicationTemplateSchema = import_zod42.z.object({
-  id: import_zod42.z.string(),
-  version: import_zod42.z.string(),
-  title: import_zod42.z.string(),
-  applicationType: import_zod42.z.string().nullable().optional(),
+var ApplicationTemplateSchema = import_zod43.z.object({
+  id: import_zod43.z.string(),
+  version: import_zod43.z.string(),
+  title: import_zod43.z.string(),
+  applicationType: import_zod43.z.string().nullable().optional(),
   questionGraph: ApplicationQuestionGraphSchema,
-  fields: import_zod42.z.array(ApplicationFieldSchema).optional()
+  fields: import_zod43.z.array(ApplicationFieldSchema).optional()
 });
-var ApplicationClassifyResultSchema = import_zod42.z.object({
-  isApplication: import_zod42.z.boolean(),
-  confidence: import_zod42.z.number().min(0).max(1),
-  applicationType: import_zod42.z.string().nullable()
+var ApplicationClassifyResultSchema = import_zod43.z.object({
+  isApplication: import_zod43.z.boolean(),
+  confidence: import_zod43.z.number().min(0).max(1),
+  applicationType: import_zod43.z.string().nullable()
 });
-var FieldExtractionResultSchema = import_zod42.z.object({
-  fields: import_zod42.z.array(ApplicationFieldSchema)
+var FieldExtractionResultSchema = import_zod43.z.object({
+  fields: import_zod43.z.array(ApplicationFieldSchema)
 });
-var AutoFillMatchSchema = import_zod42.z.object({
-  fieldId: import_zod42.z.string(),
-  value: import_zod42.z.string(),
-  confidence: import_zod42.z.enum(["confirmed"]),
-  contextKey: import_zod42.z.string()
+var AutoFillMatchSchema = import_zod43.z.object({
+  fieldId: import_zod43.z.string(),
+  value: import_zod43.z.string(),
+  confidence: import_zod43.z.enum(["confirmed"]),
+  contextKey: import_zod43.z.string()
 });
-var AutoFillResultSchema = import_zod42.z.object({
-  matches: import_zod42.z.array(AutoFillMatchSchema)
+var AutoFillResultSchema = import_zod43.z.object({
+  matches: import_zod43.z.array(AutoFillMatchSchema)
 });
-var QuestionBatchResultSchema = import_zod42.z.object({
-  batches: import_zod42.z.array(import_zod42.z.array(import_zod42.z.string()).describe("Array of field IDs in this batch"))
+var QuestionBatchResultSchema = import_zod43.z.object({
+  batches: import_zod43.z.array(import_zod43.z.array(import_zod43.z.string()).describe("Array of field IDs in this batch"))
 });
-var LookupRequestSchema = import_zod42.z.object({
-  type: import_zod42.z.string().describe("Type of lookup: 'records', 'website', 'policy'"),
-  description: import_zod42.z.string(),
-  url: import_zod42.z.string().optional(),
-  targetFieldIds: import_zod42.z.array(import_zod42.z.string())
+var LookupRequestSchema = import_zod43.z.object({
+  type: import_zod43.z.string().describe("Type of lookup: 'records', 'website', 'policy'"),
+  description: import_zod43.z.string(),
+  url: import_zod43.z.string().optional(),
+  targetFieldIds: import_zod43.z.array(import_zod43.z.string())
 });
-var ReplyIntentSchema = import_zod42.z.object({
-  primaryIntent: import_zod42.z.enum(["answers_only", "question", "lookup_request", "mixed"]),
-  hasAnswers: import_zod42.z.boolean(),
-  questionText: import_zod42.z.string().optional(),
-  questionFieldIds: import_zod42.z.array(import_zod42.z.string()).optional(),
-  lookupRequests: import_zod42.z.array(LookupRequestSchema).optional()
+var ReplyIntentSchema = import_zod43.z.object({
+  primaryIntent: import_zod43.z.enum(["answers_only", "question", "lookup_request", "mixed"]),
+  hasAnswers: import_zod43.z.boolean(),
+  questionText: import_zod43.z.string().optional(),
+  questionFieldIds: import_zod43.z.array(import_zod43.z.string()).optional(),
+  lookupRequests: import_zod43.z.array(LookupRequestSchema).optional()
 });
-var ParsedAnswerSchema = import_zod42.z.object({
-  fieldId: import_zod42.z.string(),
-  value: import_zod42.z.string(),
-  explanation: import_zod42.z.string().optional()
+var ParsedAnswerSchema = import_zod43.z.object({
+  fieldId: import_zod43.z.string(),
+  value: import_zod43.z.string(),
+  explanation: import_zod43.z.string().optional()
 });
-var AnswerParsingResultSchema = import_zod42.z.object({
-  answers: import_zod42.z.array(ParsedAnswerSchema),
-  unanswered: import_zod42.z.array(import_zod42.z.string()).describe("Field IDs that were not answered")
+var AnswerParsingResultSchema = import_zod43.z.object({
+  answers: import_zod43.z.array(ParsedAnswerSchema),
+  unanswered: import_zod43.z.array(import_zod43.z.string()).describe("Field IDs that were not answered")
 });
-var LookupFillSchema = import_zod42.z.object({
-  fieldId: import_zod42.z.string(),
-  value: import_zod42.z.string(),
-  source: import_zod42.z.string().describe("Specific citable reference, e.g. 'GL Policy #POL-12345 (Hartford)'"),
-  sourceSpanIds: import_zod42.z.array(import_zod42.z.string()).optional()
+var LookupFillSchema = import_zod43.z.object({
+  fieldId: import_zod43.z.string(),
+  value: import_zod43.z.string(),
+  source: import_zod43.z.string().describe("Specific citable reference, e.g. 'GL Policy #POL-12345 (Hartford)'"),
+  sourceSpanIds: import_zod43.z.array(import_zod43.z.string()).optional()
 });
-var LookupFillResultSchema = import_zod42.z.object({
-  fills: import_zod42.z.array(LookupFillSchema),
-  unfillable: import_zod42.z.array(import_zod42.z.string()),
-  explanation: import_zod42.z.string().optional()
+var LookupFillResultSchema = import_zod43.z.object({
+  fills: import_zod43.z.array(LookupFillSchema),
+  unfillable: import_zod43.z.array(import_zod43.z.string()),
+  explanation: import_zod43.z.string().optional()
 });
-var FlatPdfPlacementSchema = import_zod42.z.object({
-  fieldId: import_zod42.z.string(),
-  page: import_zod42.z.number(),
-  x: import_zod42.z.number().describe("Percentage from left edge (0-100)"),
-  y: import_zod42.z.number().describe("Percentage from top edge (0-100)"),
-  text: import_zod42.z.string(),
-  fontSize: import_zod42.z.number().optional(),
-  isCheckmark: import_zod42.z.boolean().optional()
+var FlatPdfPlacementSchema = import_zod43.z.object({
+  fieldId: import_zod43.z.string(),
+  page: import_zod43.z.number(),
+  x: import_zod43.z.number().describe("Percentage from left edge (0-100)"),
+  y: import_zod43.z.number().describe("Percentage from top edge (0-100)"),
+  text: import_zod43.z.string(),
+  fontSize: import_zod43.z.number().optional(),
+  isCheckmark: import_zod43.z.boolean().optional()
 });
-var AcroFormMappingSchema = import_zod42.z.object({
-  fieldId: import_zod42.z.string(),
-  acroFormName: import_zod42.z.string(),
-  value: import_zod42.z.string()
+var AcroFormMappingSchema = import_zod43.z.object({
+  fieldId: import_zod43.z.string(),
+  acroFormName: import_zod43.z.string(),
+  value: import_zod43.z.string()
 });
-var QualityGateStatusSchema = import_zod42.z.enum(["passed", "warning", "failed"]);
-var QualitySeveritySchema = import_zod42.z.enum(["info", "warning", "blocking"]);
-var ApplicationQualityIssueSchema = import_zod42.z.object({
-  code: import_zod42.z.string(),
+var QualityGateStatusSchema = import_zod43.z.enum(["passed", "warning", "failed"]);
+var QualitySeveritySchema = import_zod43.z.enum(["info", "warning", "blocking"]);
+var ApplicationQualityIssueSchema = import_zod43.z.object({
+  code: import_zod43.z.string(),
   severity: QualitySeveritySchema,
-  message: import_zod42.z.string(),
-  fieldId: import_zod42.z.string().optional()
+  message: import_zod43.z.string(),
+  fieldId: import_zod43.z.string().optional()
 });
-var ApplicationQualityRoundSchema = import_zod42.z.object({
-  round: import_zod42.z.number(),
-  kind: import_zod42.z.string(),
+var ApplicationQualityRoundSchema = import_zod43.z.object({
+  round: import_zod43.z.number(),
+  kind: import_zod43.z.string(),
   status: QualityGateStatusSchema,
-  summary: import_zod42.z.string().optional()
+  summary: import_zod43.z.string().optional()
 });
-var ApplicationQualityArtifactSchema = import_zod42.z.object({
-  kind: import_zod42.z.string(),
-  label: import_zod42.z.string().optional(),
-  itemCount: import_zod42.z.number().optional()
+var ApplicationQualityArtifactSchema = import_zod43.z.object({
+  kind: import_zod43.z.string(),
+  label: import_zod43.z.string().optional(),
+  itemCount: import_zod43.z.number().optional()
 });
-var ApplicationEmailReviewSchema = import_zod42.z.object({
-  issues: import_zod42.z.array(ApplicationQualityIssueSchema),
+var ApplicationEmailReviewSchema = import_zod43.z.object({
+  issues: import_zod43.z.array(ApplicationQualityIssueSchema),
   qualityGateStatus: QualityGateStatusSchema
 });
-var ApplicationQualityReportSchema = import_zod42.z.object({
-  issues: import_zod42.z.array(ApplicationQualityIssueSchema),
-  rounds: import_zod42.z.array(ApplicationQualityRoundSchema).optional(),
-  artifacts: import_zod42.z.array(ApplicationQualityArtifactSchema).optional(),
+var ApplicationQualityReportSchema = import_zod43.z.object({
+  issues: import_zod43.z.array(ApplicationQualityIssueSchema),
+  rounds: import_zod43.z.array(ApplicationQualityRoundSchema).optional(),
+  artifacts: import_zod43.z.array(ApplicationQualityArtifactSchema).optional(),
   emailReview: ApplicationEmailReviewSchema.optional(),
   qualityGateStatus: QualityGateStatusSchema
 });
-var ApplicationContextProposalSchema = import_zod42.z.object({
-  id: import_zod42.z.string(),
-  fieldId: import_zod42.z.string().optional(),
-  key: import_zod42.z.string(),
-  value: import_zod42.z.string(),
-  category: import_zod42.z.string(),
-  source: import_zod42.z.enum(["application", "user", "lookup", "policy", "email", "chat", "imessage", "mcp"]),
-  confidence: import_zod42.z.enum(["confirmed", "high", "medium", "low"]),
-  sourceSpanIds: import_zod42.z.array(import_zod42.z.string()).optional(),
-  userSourceSpanIds: import_zod42.z.array(import_zod42.z.string()).optional()
+var ApplicationContextProposalSchema = import_zod43.z.object({
+  id: import_zod43.z.string(),
+  fieldId: import_zod43.z.string().optional(),
+  key: import_zod43.z.string(),
+  value: import_zod43.z.string(),
+  category: import_zod43.z.string(),
+  source: import_zod43.z.enum(["application", "user", "lookup", "policy", "email", "chat", "imessage", "mcp"]),
+  confidence: import_zod43.z.enum(["confirmed", "high", "medium", "low"]),
+  sourceSpanIds: import_zod43.z.array(import_zod43.z.string()).optional(),
+  userSourceSpanIds: import_zod43.z.array(import_zod43.z.string()).optional()
 });
-var ApplicationPacketAnswerSchema = import_zod42.z.object({
-  fieldId: import_zod42.z.string(),
-  label: import_zod42.z.string(),
-  section: import_zod42.z.string(),
-  value: import_zod42.z.string(),
-  source: import_zod42.z.string(),
-  confidence: import_zod42.z.enum(["confirmed", "high", "medium", "low"]).optional(),
-  sourceSpanIds: import_zod42.z.array(import_zod42.z.string()).optional(),
-  userSourceSpanIds: import_zod42.z.array(import_zod42.z.string()).optional()
+var ApplicationPacketAnswerSchema = import_zod43.z.object({
+  fieldId: import_zod43.z.string(),
+  label: import_zod43.z.string(),
+  section: import_zod43.z.string(),
+  value: import_zod43.z.string(),
+  source: import_zod43.z.string(),
+  confidence: import_zod43.z.enum(["confirmed", "high", "medium", "low"]).optional(),
+  sourceSpanIds: import_zod43.z.array(import_zod43.z.string()).optional(),
+  userSourceSpanIds: import_zod43.z.array(import_zod43.z.string()).optional()
 });
-var ApplicationPacketSchema = import_zod42.z.object({
-  id: import_zod42.z.string(),
-  applicationId: import_zod42.z.string(),
-  title: import_zod42.z.string(),
-  status: import_zod42.z.enum(["draft", "broker_ready", "submitted"]),
-  answers: import_zod42.z.array(ApplicationPacketAnswerSchema),
-  missingFieldIds: import_zod42.z.array(import_zod42.z.string()),
+var ApplicationPacketSchema = import_zod43.z.object({
+  id: import_zod43.z.string(),
+  applicationId: import_zod43.z.string(),
+  title: import_zod43.z.string(),
+  status: import_zod43.z.enum(["draft", "broker_ready", "submitted"]),
+  answers: import_zod43.z.array(ApplicationPacketAnswerSchema),
+  missingFieldIds: import_zod43.z.array(import_zod43.z.string()),
   qualityReport: ApplicationQualityReportSchema,
-  submissionNotes: import_zod42.z.string().optional(),
-  createdAt: import_zod42.z.number()
+  submissionNotes: import_zod43.z.string().optional(),
+  createdAt: import_zod43.z.number()
 });
-var ApplicationStateSchema = import_zod42.z.object({
-  id: import_zod42.z.string(),
-  pdfBase64: import_zod42.z.string().optional().describe("Original PDF, omitted after extraction"),
-  templateId: import_zod42.z.string().optional(),
-  templateVersion: import_zod42.z.string().optional(),
+var ApplicationStateSchema = import_zod43.z.object({
+  id: import_zod43.z.string(),
+  pdfBase64: import_zod43.z.string().optional().describe("Original PDF, omitted after extraction"),
+  templateId: import_zod43.z.string().optional(),
+  templateVersion: import_zod43.z.string().optional(),
   templateSnapshot: ApplicationTemplateSchema.optional(),
-  title: import_zod42.z.string().optional(),
-  applicationType: import_zod42.z.string().nullable().optional(),
+  title: import_zod43.z.string().optional(),
+  applicationType: import_zod43.z.string().nullable().optional(),
   questionGraph: ApplicationQuestionGraphSchema.optional(),
-  fields: import_zod42.z.array(ApplicationFieldSchema),
-  batches: import_zod42.z.array(import_zod42.z.array(import_zod42.z.string())).optional(),
-  currentBatchIndex: import_zod42.z.number().default(0),
-  contextProposals: import_zod42.z.array(ApplicationContextProposalSchema).optional(),
+  fields: import_zod43.z.array(ApplicationFieldSchema),
+  batches: import_zod43.z.array(import_zod43.z.array(import_zod43.z.string())).optional(),
+  currentBatchIndex: import_zod43.z.number().default(0),
+  contextProposals: import_zod43.z.array(ApplicationContextProposalSchema).optional(),
   packet: ApplicationPacketSchema.optional(),
   qualityReport: ApplicationQualityReportSchema.optional(),
-  status: import_zod42.z.enum([
+  status: import_zod43.z.enum([
     "classifying",
     "extracting",
     "auto_filling",
@@ -13239,8 +13642,8 @@ var ApplicationStateSchema = import_zod42.z.object({
     "cancelled",
     "complete"
   ]),
-  createdAt: import_zod42.z.number(),
-  updatedAt: import_zod42.z.number()
+  createdAt: import_zod43.z.number(),
+  updatedAt: import_zod43.z.number()
 });
 
 // src/application/agents/classifier.ts
@@ -14974,106 +15377,106 @@ Respond with the final answer, deduplicated citations array, overall confidence
 }
 
 // src/schemas/query.ts
-var import_zod43 = require("zod");
-var QueryIntentSchema = import_zod43.z.enum([
+var import_zod44 = require("zod");
+var QueryIntentSchema = import_zod44.z.enum([
   "policy_question",
   "coverage_comparison",
   "document_search",
   "claims_inquiry",
   "general_knowledge"
 ]);
-var QueryAttachmentKindSchema = import_zod43.z.enum(["image", "pdf", "text"]);
-var QueryAttachmentSchema = import_zod43.z.object({
-  id: import_zod43.z.string().optional().describe("Optional stable attachment ID from the caller"),
+var QueryAttachmentKindSchema = import_zod44.z.enum(["image", "pdf", "text"]);
+var QueryAttachmentSchema = import_zod44.z.object({
+  id: import_zod44.z.string().optional().describe("Optional stable attachment ID from the caller"),
   kind: QueryAttachmentKindSchema,
-  name: import_zod43.z.string().optional().describe("Original filename or user-facing label"),
-  mimeType: import_zod43.z.string().optional().describe("MIME type such as image/jpeg or application/pdf"),
-  base64: import_zod43.z.string().optional().describe("Base64-encoded file content for image/pdf attachments"),
-  text: import_zod43.z.string().optional().describe("Plain-text attachment content when available"),
-  description: import_zod43.z.string().optional().describe("Caller-provided description of the attachment")
+  name: import_zod44.z.string().optional().describe("Original filename or user-facing label"),
+  mimeType: import_zod44.z.string().optional().describe("MIME type such as image/jpeg or application/pdf"),
+  base64: import_zod44.z.string().optional().describe("Base64-encoded file content for image/pdf attachments"),
+  text: import_zod44.z.string().optional().describe("Plain-text attachment content when available"),
+  description: import_zod44.z.string().optional().describe("Caller-provided description of the attachment")
 });
-var QueryRetrievalModeSchema = import_zod43.z.enum([
+var QueryRetrievalModeSchema = import_zod44.z.enum([
   "graph_only",
   "source_rag",
   "long_context",
   "hybrid"
 ]);
-var SubQuestionSchema = import_zod43.z.object({
-  question: import_zod43.z.string().describe("Atomic sub-question to retrieve and answer independently"),
+var SubQuestionSchema = import_zod44.z.object({
+  question: import_zod44.z.string().describe("Atomic sub-question to retrieve and answer independently"),
   intent: QueryIntentSchema,
-  chunkTypes: import_zod43.z.array(import_zod43.z.string()).optional().describe("Chunk types to filter retrieval (e.g. coverage, endorsement, declaration)"),
-  documentFilters: import_zod43.z.object({
-    type: import_zod43.z.enum(["policy", "quote"]).optional(),
-    carrier: import_zod43.z.string().optional(),
-    insuredName: import_zod43.z.string().optional(),
-    policyNumber: import_zod43.z.string().optional(),
-    quoteNumber: import_zod43.z.string().optional(),
-    policyTypes: import_zod43.z.array(PolicyTypeSchema).optional().describe("Filter by policy type (e.g. homeowners_ho3, renters_ho4, pet) to avoid mixing up similar policies")
+  chunkTypes: import_zod44.z.array(import_zod44.z.string()).optional().describe("Chunk types to filter retrieval (e.g. coverage, endorsement, declaration)"),
+  documentFilters: import_zod44.z.object({
+    type: import_zod44.z.enum(["policy", "quote"]).optional(),
+    carrier: import_zod44.z.string().optional(),
+    insuredName: import_zod44.z.string().optional(),
+    policyNumber: import_zod44.z.string().optional(),
+    quoteNumber: import_zod44.z.string().optional(),
+    policyTypes: import_zod44.z.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 = import_zod43.z.object({
+var QueryClassifyResultSchema = import_zod44.z.object({
   intent: QueryIntentSchema,
-  subQuestions: import_zod43.z.array(SubQuestionSchema).min(1).describe("Decomposed atomic sub-questions"),
-  requiresDocumentLookup: import_zod43.z.boolean().describe("Whether structured document lookup is needed"),
-  requiresChunkSearch: import_zod43.z.boolean().describe("Whether semantic chunk search is needed"),
-  requiresConversationHistory: import_zod43.z.boolean().describe("Whether conversation history is relevant"),
+  subQuestions: import_zod44.z.array(SubQuestionSchema).min(1).describe("Decomposed atomic sub-questions"),
+  requiresDocumentLookup: import_zod44.z.boolean().describe("Whether structured document lookup is needed"),
+  requiresChunkSearch: import_zod44.z.boolean().describe("Whether semantic chunk search is needed"),
+  requiresConversationHistory: import_zod44.z.boolean().describe("Whether conversation history is relevant"),
   retrievalMode: QueryRetrievalModeSchema.optional().describe("Preferred retrieval strategy for the query when source-span retrieval is available")
 });
-var EvidenceItemSchema = import_zod43.z.object({
-  source: import_zod43.z.enum(["chunk", "document", "conversation", "attachment", "source_span", "source_node"]),
-  chunkId: import_zod43.z.string().optional(),
-  sourceNodeId: import_zod43.z.string().optional(),
-  sourceSpanId: import_zod43.z.string().optional(),
-  documentId: import_zod43.z.string().optional(),
-  turnId: import_zod43.z.string().optional(),
-  attachmentId: import_zod43.z.string().optional(),
-  text: import_zod43.z.string().describe("Text excerpt from the source"),
-  relevance: import_zod43.z.number().min(0).max(1),
+var EvidenceItemSchema = import_zod44.z.object({
+  source: import_zod44.z.enum(["chunk", "document", "conversation", "attachment", "source_span", "source_node"]),
+  chunkId: import_zod44.z.string().optional(),
+  sourceNodeId: import_zod44.z.string().optional(),
+  sourceSpanId: import_zod44.z.string().optional(),
+  documentId: import_zod44.z.string().optional(),
+  turnId: import_zod44.z.string().optional(),
+  attachmentId: import_zod44.z.string().optional(),
+  text: import_zod44.z.string().describe("Text excerpt from the source"),
+  relevance: import_zod44.z.number().min(0).max(1),
   retrievalMode: QueryRetrievalModeSchema.optional(),
   sourceLocation: SourceSpanLocationSchema.optional(),
-  metadata: import_zod43.z.array(import_zod43.z.object({ key: import_zod43.z.string(), value: import_zod43.z.string() })).optional()
+  metadata: import_zod44.z.array(import_zod44.z.object({ key: import_zod44.z.string(), value: import_zod44.z.string() })).optional()
 });
-var AttachmentInterpretationSchema = import_zod43.z.object({
-  summary: import_zod43.z.string().describe("Concise summary of what the attachment shows or contains"),
-  extractedFacts: import_zod43.z.array(import_zod43.z.string()).describe("Specific observable or document facts grounded in the attachment"),
-  recommendedFocus: import_zod43.z.array(import_zod43.z.string()).describe("Important details to incorporate when answering follow-up questions"),
-  confidence: import_zod43.z.number().min(0).max(1)
+var AttachmentInterpretationSchema = import_zod44.z.object({
+  summary: import_zod44.z.string().describe("Concise summary of what the attachment shows or contains"),
+  extractedFacts: import_zod44.z.array(import_zod44.z.string()).describe("Specific observable or document facts grounded in the attachment"),
+  recommendedFocus: import_zod44.z.array(import_zod44.z.string()).describe("Important details to incorporate when answering follow-up questions"),
+  confidence: import_zod44.z.number().min(0).max(1)
 });
-var RetrievalResultSchema = import_zod43.z.object({
-  subQuestion: import_zod43.z.string(),
-  evidence: import_zod43.z.array(EvidenceItemSchema)
+var RetrievalResultSchema = import_zod44.z.object({
+  subQuestion: import_zod44.z.string(),
+  evidence: import_zod44.z.array(EvidenceItemSchema)
 });
-var CitationSchema = import_zod43.z.object({
-  index: import_zod43.z.number().describe("Citation number [1], [2], etc."),
-  chunkId: import_zod43.z.string().optional().describe("Source chunk ID, e.g. doc-123:coverage:2"),
-  sourceNodeId: import_zod43.z.string().optional().describe("Source tree node ID when available"),
-  sourceSpanId: import_zod43.z.string().optional().describe("Precise source span ID when available"),
-  documentId: import_zod43.z.string(),
-  documentType: import_zod43.z.enum(["policy", "quote"]).optional(),
-  field: import_zod43.z.string().optional().describe("Specific field path, e.g. coverages[0].deductible"),
-  quote: import_zod43.z.string().describe("Exact text from source that supports the claim"),
-  relevance: import_zod43.z.number().min(0).max(1),
+var CitationSchema = import_zod44.z.object({
+  index: import_zod44.z.number().describe("Citation number [1], [2], etc."),
+  chunkId: import_zod44.z.string().optional().describe("Source chunk ID, e.g. doc-123:coverage:2"),
+  sourceNodeId: import_zod44.z.string().optional().describe("Source tree node ID when available"),
+  sourceSpanId: import_zod44.z.string().optional().describe("Precise source span ID when available"),
+  documentId: import_zod44.z.string(),
+  documentType: import_zod44.z.enum(["policy", "quote"]).optional(),
+  field: import_zod44.z.string().optional().describe("Specific field path, e.g. coverages[0].deductible"),
+  quote: import_zod44.z.string().describe("Exact text from source that supports the claim"),
+  relevance: import_zod44.z.number().min(0).max(1),
   retrievalMode: QueryRetrievalModeSchema.optional(),
   sourceLocation: SourceSpanLocationSchema.optional()
 });
-var SubAnswerSchema = import_zod43.z.object({
-  subQuestion: import_zod43.z.string(),
-  answer: import_zod43.z.string(),
-  citations: import_zod43.z.array(CitationSchema),
-  confidence: import_zod43.z.number().min(0).max(1),
-  needsMoreContext: import_zod43.z.boolean().describe("True if evidence was insufficient to answer fully")
+var SubAnswerSchema = import_zod44.z.object({
+  subQuestion: import_zod44.z.string(),
+  answer: import_zod44.z.string(),
+  citations: import_zod44.z.array(CitationSchema),
+  confidence: import_zod44.z.number().min(0).max(1),
+  needsMoreContext: import_zod44.z.boolean().describe("True if evidence was insufficient to answer fully")
 });
-var VerifyResultSchema = import_zod43.z.object({
-  approved: import_zod43.z.boolean().describe("Whether all sub-answers are adequately grounded"),
-  issues: import_zod43.z.array(import_zod43.z.string()).describe("Specific grounding or consistency issues found"),
-  retrySubQuestions: import_zod43.z.array(import_zod43.z.string()).optional().describe("Sub-questions that need additional retrieval or re-reasoning")
+var VerifyResultSchema = import_zod44.z.object({
+  approved: import_zod44.z.boolean().describe("Whether all sub-answers are adequately grounded"),
+  issues: import_zod44.z.array(import_zod44.z.string()).describe("Specific grounding or consistency issues found"),
+  retrySubQuestions: import_zod44.z.array(import_zod44.z.string()).optional().describe("Sub-questions that need additional retrieval or re-reasoning")
 });
-var QueryResultSchema = import_zod43.z.object({
-  answer: import_zod43.z.string(),
-  citations: import_zod43.z.array(CitationSchema),
+var QueryResultSchema = import_zod44.z.object({
+  answer: import_zod44.z.string(),
+  citations: import_zod44.z.array(CitationSchema),
   intent: QueryIntentSchema,
-  confidence: import_zod43.z.number().min(0).max(1),
-  followUp: import_zod43.z.string().optional().describe("Suggested follow-up question if applicable")
+  confidence: import_zod44.z.number().min(0).max(1),
+  followUp: import_zod44.z.string().optional().describe("Suggested follow-up question if applicable")
 });
 
 // src/query/retriever.ts
@@ -16140,7 +16543,7 @@ ${sa.answer}`).join("\n\n"),
 }
 
 // src/pce/index.ts
-var import_zod44 = require("zod");
+var import_zod45 = require("zod");
 
 // src/prompts/pce/index.ts
 function buildPceNormalizePrompt(input) {
@@ -16174,11 +16577,11 @@ ${input.openQuestions.map((question) => `- ${question.id}${question.fieldPath ?
 }
 
 // src/pce/index.ts
-var ReplyAnswersSchema = import_zod44.z.object({
-  answers: import_zod44.z.array(import_zod44.z.object({
-    questionId: import_zod44.z.string().optional(),
-    fieldPath: import_zod44.z.string().optional(),
-    answer: import_zod44.z.string()
+var ReplyAnswersSchema = import_zod45.z.object({
+  answers: import_zod45.z.array(import_zod45.z.object({
+    questionId: import_zod45.z.string().optional(),
+    fieldPath: import_zod45.z.string().optional(),
+    answer: import_zod45.z.string()
   }))
 });
 function createPceAgent(config = {}) {