@claritylabs/cl-sdk 3.2.7 → 3.2.9

package/dist/index.js

@@ -3952,16 +3952,6 @@ var OPERATIONAL_COVERAGE_TERM_KINDS2 = [
   "other"
 ];
 var OperationalCoverageTermKindSchema = import_zod21.z.enum(OPERATIONAL_COVERAGE_TERM_KINDS2);
-var CleanupTermSchema = import_zod21.z.object({
-  kind: OperationalCoverageTermKindSchema,
-  label: import_zod21.z.string(),
-  value: import_zod21.z.string(),
-  amount: import_zod21.z.number().nullable().optional(),
-  appliesTo: import_zod21.z.string().nullable().optional(),
-  sourceNodeIds: import_zod21.z.array(import_zod21.z.string()).optional(),
-  sourceSpanIds: import_zod21.z.array(import_zod21.z.string()).optional(),
-  reason: import_zod21.z.string().optional()
-});
 var OperationalProfileCleanupSchema = import_zod21.z.object({
   coverageDecisions: import_zod21.z.array(import_zod21.z.object({
     coverageIndex: import_zod21.z.number().int().nonnegative(),
@@ -3985,8 +3975,7 @@ var OperationalProfileCleanupSchema = import_zod21.z.object({
       appliesTo: import_zod21.z.string().nullable().optional(),
       sourceNodeIds: import_zod21.z.array(import_zod21.z.string()).optional(),
       sourceSpanIds: import_zod21.z.array(import_zod21.z.string()).optional()
-    })).optional(),
-    termAdditions: import_zod21.z.array(CleanupTermSchema).optional()
+    })).optional()
   })).default([]),
   warnings: import_zod21.z.array(import_zod21.z.string()).default([])
 });
@@ -3994,7 +3983,6 @@ var CLEANUP_CANDIDATE_ID_LIMIT = 12;
 var CLEANUP_SOURCE_NODE_LIMIT = 90;
 var CLEANUP_SIBLING_WINDOW = 4;
 var CLEANUP_KEYWORD = /\b(coverage|limit|liability|deductible|retention|retroactive|premium|aggregate|sublimit|sub-limit|claim|occurrence|loss|proceeding|endorsement|declarations?)\b|\$[0-9]/i;
-var CLEANUP_CONTINUATION_KEYWORD = /\b(coverage part|limit of liability|deductible|retention|retroactive date|aggregate|sublimit|sub-limit|each claim|each occurrence|each loss|each proceeding|coinsurance)\b|\$[0-9]/i;
 function compactNode(node, maxText = 700) {
   return {
     id: node.id,
@@ -4123,15 +4111,11 @@ function selectCoverageCleanupNodes(sourceTree, coverages) {
     const children = childrenByParent.get(selectedNode.id) ?? [];
     for (const child of children.slice(0, 24)) addNode(child, 760);
   }
-  const continuationPages = new Set([...coveragePages].map((page) => page + 1));
   for (const node of sourceTree) {
     if (node.kind === "document") continue;
-    if (typeof node.pageStart !== "number") continue;
-    const samePage = coveragePages.has(node.pageStart);
-    const nearbyContinuationPage = continuationPages.has(node.pageStart);
-    if (!samePage && !nearbyContinuationPage) continue;
+    if (!node.pageStart || !coveragePages.has(node.pageStart)) continue;
     const text = nodeTextForSelection(node);
-    if (CLEANUP_KEYWORD.test(text) || nodeTextMatchesCoverage(node, coverageTerms) || nearbyContinuationPage && CLEANUP_CONTINUATION_KEYWORD.test(text)) {
+    if (CLEANUP_KEYWORD.test(text) || nodeTextMatchesCoverage(node, coverageTerms)) {
       addNode(node, 600);
     }
   }
@@ -4145,7 +4129,7 @@ function buildOperationalProfileCleanupPrompt(sourceTree, profile, options = {})
   const coverageEntries = coverageCleanupEntries(profile, options.coverageIndexes);
   const nodes = selectCoverageCleanupNodes(sourceTree, coverageEntries.map((entry) => entry.coverage)).map((node) => compactNode(
     node,
-    node.kind === "page" || node.kind === "page_group" ? 520 : node.kind === "table_row" || node.kind === "table_cell" ? 520 : 360
+    node.kind === "page" || node.kind === "page_group" ? 260 : node.kind === "table_row" || node.kind === "table_cell" ? 520 : 360
   ));
   const candidate = {
     documentType: profile.documentType,
@@ -4169,24 +4153,20 @@ Projection defects to look for:
 - 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.
-- Collapsed combined bases where one candidate term says "Each Claim / Aggregate", "Each Loss / Aggregate", "Each Proceeding / Aggregate", or a continuation line supplies a separate policy aggregate, sub-limit, deductible, retention, retroactive date, or coinsurance term.
 - Repeated schedule headings projected as separate coverages when they only introduce the next coverage group.
-- Generic policy form rows projected as scheduled coverages when their values only say "as stated in Item...", "shown in the Declarations", or similar cross-references instead of actual scheduled amounts.
 
 Rules:
 - Use internal reasoning, but return JSON decisions only.
-- Do not invent policy facts. Keep, drop, or update only existing coverageIndex and termIndex entries, except for source-backed termAdditions on an existing coverage.
+- 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.
+- Never drop a declaration or schedule coverage row that names a coverage and states policy-specific amounts, dates, deductibles, retentions, premiums, or coverage terms. Repair its terms instead.
 - When changing a term's semantic meaning, set kind to the corrected normalized term kind.
-- Do not add new coverage rows.
-- Add termAdditions only when a provided source node directly supports the missing term and the candidate already has the correct coverage row.
-- When replacing one combined term with split terms, drop the combined term and add one term per basis. For example, "$1,000,000 Each Claim / Aggregate" should become one each_claim_limit term and one aggregate_limit term, both with value "$1,000,000".
-- When a schedule continues onto the next page before the next item marker, attach continuation terms such as "Aggregate", "Policy Aggregate", coinsurance, deductible, or retroactive date to the previous coverage row.
-- Drop a coverage row when it is only generic policy wording that points back to a declarations item or schedule and does not itself state policy-specific limits, deductibles, retentions, premiums, dates, or coverage names.
+- Do not add new coverage rows or new terms; this pass cleans the existing projection.
+- If one existing term combines multiple real limit bases, such as "Each Claim / Aggregate", keep the combined term unless another existing term already represents the other basis. Do not relabel it to only one basis and lose information.
 - Include every JSON key in each decision. Use null for scalar fields you are not changing and [] for source ID lists you are not changing.
-- For each coverage decision, always include termDecisions and termAdditions. Use [] when no existing terms need cleanup or no new terms are needed.
+- For each coverage decision, always include termDecisions. Use [] when no terms need cleanup.
 - Keep reasons concise and factual.
 
 Candidate projection:
@@ -4327,50 +4307,9 @@ function applyTermCleanupDecision(term, decision, validNodeIds, validSpanIds) {
   }
   return next;
 }
-function termAdditionTouches(addition, predicate) {
-  return predicate({
-    kind: addition.kind,
-    label: cleanProfileValue(addition.label) ?? "",
-    value: cleanProfileValue(addition.value) ?? ""
-  });
-}
 function termDecisionsTouch(coverage, decisions, predicate) {
   return decisions.filter((decision) => decision.action !== "keep").some((decision) => termDecisionTouches(coverage, decision, predicate));
 }
-function termAdditionsTouch(additions, predicate) {
-  return additions.some((addition) => termAdditionTouches(addition, predicate));
-}
-function termKey(term) {
-  return [
-    term.kind,
-    cleanProfileValue(term.label)?.toLowerCase(),
-    cleanProfileValue(term.value)?.toLowerCase()
-  ].join("|");
-}
-function applyTermAddition(addition, validNodeIds, validSpanIds) {
-  const label = cleanProfileValue(addition.label);
-  const value = cleanProfileValue(addition.value);
-  if (!label || !value) return void 0;
-  const sourceNodeIds = validIds(addition.sourceNodeIds, validNodeIds);
-  const sourceSpanIds = validIds(addition.sourceSpanIds, validSpanIds);
-  if (sourceNodeIds.length === 0 && sourceSpanIds.length === 0) return void 0;
-  const term = {
-    kind: addition.kind,
-    label,
-    value,
-    sourceNodeIds,
-    sourceSpanIds
-  };
-  if (typeof addition.amount === "number" && Number.isFinite(addition.amount)) {
-    term.amount = addition.amount;
-  } else if (term.kind !== "retroactive_date") {
-    const amount = amountFromOperationalValue(value);
-    if (amount !== void 0) term.amount = amount;
-  }
-  const appliesTo = cleanProfileValue(addition.appliesTo);
-  if (appliesTo) term.appliesTo = appliesTo;
-  return term;
-}
 function applyCoverageCleanupDecision(coverage, decision, validNodeIds, validSpanIds) {
   if (!decision || decision.action === "keep") return coverage;
   if (decision.action === "drop") return void 0;
@@ -4401,31 +4340,23 @@ function applyCoverageCleanupDecision(coverage, decision, validNodeIds, validSpa
   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));
-  const termAdditions = (decision.termAdditions ?? []).map((addition) => applyTermAddition(addition, validNodeIds, validSpanIds)).filter((term) => Boolean(term));
-  const existingTermKeys = new Set(next.limits.map(termKey));
-  for (const term of termAdditions) {
-    const key = termKey(term);
-    if (existingTermKeys.has(key)) continue;
-    next.limits.push(term);
-    existingTermKeys.add(key);
-  }
-  if (termDecisions.length > 0 || termAdditions.length > 0) {
-    if (decision.limit == null && (termDecisionsTouch(coverage, termDecisions, isLimitTerm) || termAdditionsTouch(termAdditions, isLimitTerm))) {
+  if (termDecisions.length > 0) {
+    if (decision.limit == null && termDecisionsTouch(coverage, termDecisions, isLimitTerm)) {
       const value = primaryLimitFromTerms(next.limits);
       if (value) next.limit = value;
       else delete next.limit;
     }
-    if (decision.deductible == null && (termDecisionsTouch(coverage, termDecisions, isDeductibleTerm) || termAdditionsTouch(termAdditions, isDeductibleTerm))) {
+    if (decision.deductible == null && termDecisionsTouch(coverage, termDecisions, isDeductibleTerm)) {
       const value = deductibleFromTerms(next.limits);
       if (value) next.deductible = value;
       else delete next.deductible;
     }
-    if (decision.premium == null && (termDecisionsTouch(coverage, termDecisions, isPremiumTerm) || termAdditionsTouch(termAdditions, isPremiumTerm))) {
+    if (decision.premium == null && termDecisionsTouch(coverage, termDecisions, isPremiumTerm)) {
       const value = premiumFromTerms(next.limits);
       if (value) next.premium = value;
       else delete next.premium;
     }
-    if (decision.retroactiveDate == null && (termDecisionsTouch(coverage, termDecisions, isRetroactiveDateTerm) || termAdditionsTouch(termAdditions, isRetroactiveDateTerm))) {
+    if (decision.retroactiveDate == null && termDecisionsTouch(coverage, termDecisions, isRetroactiveDateTerm)) {
       const value = retroactiveDateFromTerms(next.limits);
       if (value) next.retroactiveDate = value;
       else delete next.retroactiveDate;
@@ -5765,6 +5696,7 @@ Rules:
 - A coverage schedule row's coverage name should come from the "Coverage Part" or equivalent row label. Limit, deductible, aggregate, sublimit, retention, and retroactive-date values belong as nested terms under that coverage, not in the coverage title.
 - If a coverage schedule continues onto the next page before the next item marker, include the continuation rows in the same coverage or declaration item.
 - If one schedule row or continuation row states the same amount with multiple bases, such as "$1,000,000 Each Claim / Aggregate", return separate limit terms for each basis using the same value instead of one combined "Each Claim / Aggregate" term.
+- LiteParse text can fragment visual table cells into adjacent lines. Before extracting coverage terms, mentally join adjacent lines in the same declaration item or schedule row. For example, "$2,000,000 Policy Each Claim" followed immediately by "Aggregate" means "$2,000,000 Policy Aggregate"; a line ending with "/" followed by "Aggregate ..." means the limit cell continues, not a new coverage.
 - Forms-and-endorsements schedules are operational form inventory evidence, not coverage limits. Do not turn form schedule rows into coverage units unless the row also states a coverage-specific limit or deductible.
 - Keep each coverage unit tied to one evidence scope: a declaration/core schedule row, a core policy form section, or one specific endorsement schedule. Do not merge declaration facts and endorsement schedule facts into the same coverage unit, even when they use the same coverage name.
 - If the declarations schedule and an endorsement schedule both list Network Security, Social Engineering Fraud, Regulatory Proceedings, or another same-named coverage, return separate coverage units for each supported source scope.