@claritylabs/cl-sdk 1.3.6 → 1.3.8

package/dist/index.js

@@ -224,6 +224,8 @@ __export(index_exports, {
   SourceSpanLocationSchema: () => SourceSpanLocationSchema,
   SourceSpanRefSchema: () => SourceSpanRefSchema,
   SourceSpanSchema: () => SourceSpanSchema,
+  SourceSpanTableLocationSchema: () => SourceSpanTableLocationSchema,
+  SourceSpanUnitSchema: () => SourceSpanUnitSchema,
   SubAnswerSchema: () => SubAnswerSchema,
   SubQuestionSchema: () => SubQuestionSchema,
   SubjectivityCategorySchema: () => SubjectivityCategorySchema,
@@ -959,6 +961,8 @@ var CoverageSchema = import_zod4.z.object({
   deductible: import_zod4.z.string().optional(),
   deductibleAmount: import_zod4.z.number().optional(),
   deductibleValueType: CoverageValueTypeSchema.optional(),
+  trigger: CoverageTriggerSchema.optional(),
+  retroactiveDate: import_zod4.z.string().optional(),
   formNumber: import_zod4.z.string().optional(),
   pageNumber: import_zod4.z.number().optional(),
   sectionRef: import_zod4.z.string().optional(),
@@ -2187,6 +2191,15 @@ var SourceSpanKindSchema = import_zod20.z.enum([
   "plain_text",
   "structured_field"
 ]);
+var SourceSpanUnitSchema = import_zod20.z.enum([
+  "page",
+  "section",
+  "table",
+  "table_row",
+  "table_cell",
+  "key_value",
+  "text"
+]);
 var SourceKindSchema = import_zod20.z.enum([
   "policy_pdf",
   "application_pdf",
@@ -2211,6 +2224,15 @@ var SourceSpanLocationSchema = import_zod20.z.object({
   lineEnd: import_zod20.z.number().int().positive().optional(),
   fieldPath: import_zod20.z.string().optional()
 });
+var SourceSpanTableLocationSchema = import_zod20.z.object({
+  tableId: import_zod20.z.string().optional(),
+  rowIndex: import_zod20.z.number().int().nonnegative().optional(),
+  columnIndex: import_zod20.z.number().int().nonnegative().optional(),
+  columnName: import_zod20.z.string().optional(),
+  rowSpanId: import_zod20.z.string().optional(),
+  tableSpanId: import_zod20.z.string().optional(),
+  isHeader: import_zod20.z.boolean().optional()
+});
 var SourceSpanSchema = import_zod20.z.object({
   id: import_zod20.z.string().min(1),
   documentId: import_zod20.z.string().min(1),
@@ -2224,6 +2246,9 @@ var SourceSpanSchema = import_zod20.z.object({
   pageEnd: import_zod20.z.number().int().positive().optional(),
   sectionId: import_zod20.z.string().optional(),
   formNumber: import_zod20.z.string().optional(),
+  sourceUnit: SourceSpanUnitSchema.optional(),
+  parentSpanId: import_zod20.z.string().optional(),
+  table: SourceSpanTableLocationSchema.optional(),
   bbox: import_zod20.z.array(SourceSpanBBoxSchema).optional(),
   location: SourceSpanLocationSchema.optional(),
   metadata: import_zod20.z.record(import_zod20.z.string(), import_zod20.z.string()).optional()
@@ -2342,6 +2367,9 @@ function buildSourceSpan(input, localIndex = 0) {
     pageEnd: input.pageEnd,
     sectionId: input.sectionId,
     formNumber: input.formNumber,
+    sourceUnit: input.sourceUnit,
+    parentSpanId: input.parentSpanId,
+    table: input.table,
     location: {
       page: input.pageStart === input.pageEnd ? input.pageStart : void 0,
       startPage: input.pageStart,
@@ -2362,7 +2390,11 @@ function buildPageSourceSpans(pages) {
         pageEnd: page.pageNumber,
         sectionId: page.sectionId,
         formNumber: page.formNumber,
-        metadata: page.metadata
+        sourceUnit: "page",
+        metadata: {
+          ...page.metadata ?? {},
+          sourceUnit: page.metadata?.sourceUnit ?? "page"
+        }
       },
       index
     )
@@ -2384,6 +2416,7 @@ function buildSectionSourceSpans(pages, options = {}) {
           pageEnd: page.pageNumber,
           sectionId: section.title,
           formNumber: inferFormNumber(section.text),
+          sourceUnit: "section",
           metadata: {
             ...page.metadata ?? {},
             sourceUnit: "section_candidate"
@@ -2416,6 +2449,7 @@ function chunkSourceSpans(spans, options = {}) {
   const chunks = [];
   let current = [];
   let currentLength = 0;
+  const spansForChunking = filterChunkableSourceSpans(spans);
   const flush = () => {
     if (current.length === 0) return;
     const text = current.map((span) => span.text).join("\n\n");
@@ -2439,7 +2473,7 @@ function chunkSourceSpans(spans, options = {}) {
     current = [];
     currentLength = 0;
   };
-  for (const span of spans) {
+  for (const span of spansForChunking) {
     const nextLength = currentLength + span.text.length + (current.length > 0 ? 2 : 0);
     if (current.length > 0 && nextLength > maxChars) {
       flush();
@@ -2450,6 +2484,20 @@ function chunkSourceSpans(spans, options = {}) {
   flush();
   return chunks;
 }
+function sourceUnit(span) {
+  return span.sourceUnit ?? span.metadata?.sourceUnit;
+}
+function filterChunkableSourceSpans(spans) {
+  const rowIds = new Set(
+    spans.filter((span) => sourceUnit(span) === "table_row").map((span) => span.id)
+  );
+  if (rowIds.size === 0) return spans;
+  return spans.filter((span) => {
+    if (sourceUnit(span) !== "table_cell") return true;
+    const rowId = span.parentSpanId ?? span.table?.rowSpanId ?? span.metadata?.rowSpanId;
+    return !rowId || !rowIds.has(rowId);
+  });
+}
 function splitPageIntoSections(text, headingPattern, minSectionChars) {
   const lines = text.split(/\r?\n/);
   const sections = [];
@@ -2834,36 +2882,18 @@ function normalizeDoclingDocument(document, options) {
     pageTexts.set(page, appendText(pageTexts.get(page), unit.text));
   }
   const fullText = Array.from({ length: pageCount }, (_, index) => {
-    const pageNumber = index + 1;
-    const text = pageTexts.get(pageNumber)?.trim();
-    return text ? `Page ${pageNumber}
+    const pageNumber2 = index + 1;
+    const text = pageTexts.get(pageNumber2)?.trim();
+    return text ? `Page ${pageNumber2}
 ${text}` : "";
   }).filter(Boolean).join("\n\n");
   const sourceKind = options.sourceKind ?? "policy_pdf";
-  const sourceSpans = units.map((unit, index) => {
-    const span = buildSourceSpan(
-      {
-        documentId: options.documentId,
-        sourceKind,
-        text: unit.text,
-        pageStart: unit.pageStart,
-        pageEnd: unit.pageEnd,
-        sectionId: unit.label,
-        metadata: {
-          sourceSystem: "docling",
-          sourceUnit: "docling_item",
-          doclingRef: unit.ref,
-          ...unit.label ? { doclingLabel: unit.label } : {}
-        }
-      },
-      index
-    );
-    return {
-      ...span,
-      kind: "plain_text",
-      bbox: unit.bboxes?.length ? unit.bboxes : void 0
-    };
-  });
+  const sourceSpans = units.flatMap(
+    (unit, index) => buildSourceSpansForUnit(unit, index, {
+      documentId: options.documentId,
+      sourceKind
+    })
+  );
   return {
     pageCount,
     fullText,
@@ -2901,6 +2931,11 @@ function mergeSourceSpans(spans) {
       span.pageStart ?? span.location?.startPage ?? span.location?.page ?? "na",
       span.pageEnd ?? span.location?.endPage ?? span.pageStart ?? "na",
       span.sectionId ?? span.location?.fieldPath ?? "na",
+      span.sourceUnit ?? span.metadata?.sourceUnit ?? "na",
+      span.parentSpanId ?? "na",
+      span.table?.tableId ?? span.metadata?.tableId ?? "na",
+      span.table?.rowIndex ?? span.metadata?.rowIndex ?? "na",
+      span.table?.columnIndex ?? span.metadata?.columnIndex ?? "na",
       span.textHash ?? sourceSpanTextHash(span.text)
     ].join(":");
     if (seen.has(key)) continue;
@@ -2963,6 +2998,7 @@ function getOrderedBodyRefs(document, itemMap) {
 function normalizeItem(ref, item) {
   const text = getItemText(item).trim();
   if (!text) return void 0;
+  const table = getItemTable(item);
   const pages = (item.prov ?? []).map((prov) => getPageNumber(prov)).filter((page) => typeof page === "number" && page > 0);
   const pageStart = pages.length ? Math.min(...pages) : void 0;
   const pageEnd = pages.length ? Math.max(...pages) : pageStart;
@@ -2973,17 +3009,143 @@ function normalizeItem(ref, item) {
     text,
     pageStart,
     pageEnd,
-    bboxes: bboxes.length ? bboxes : void 0
+    bboxes: bboxes.length ? bboxes : void 0,
+    table
+  };
+}
+function buildSourceSpansForUnit(unit, index, options) {
+  const baseMetadata = {
+    sourceSystem: "docling",
+    sourceUnit: unit.table ? "table" : "docling_item",
+    doclingRef: unit.ref,
+    ...unit.label ? { doclingLabel: unit.label } : {}
+  };
+  const tableId = unit.table ? `${unit.ref}:table` : void 0;
+  const tableSpan = withDoclingKind(buildSourceSpan(
+    {
+      documentId: options.documentId,
+      sourceKind: options.sourceKind,
+      text: unit.text,
+      pageStart: unit.pageStart,
+      pageEnd: unit.pageEnd,
+      sectionId: unit.label,
+      sourceUnit: unit.table ? "table" : labelToSourceUnit(unit.label),
+      table: tableId ? { tableId } : void 0,
+      metadata: baseMetadata
+    },
+    index * 1e3
+  ), unit);
+  if (!unit.table) return [tableSpan];
+  const spans = [tableSpan];
+  const table = unit.table;
+  for (let rowIndex = 0; rowIndex < table.rows.length; rowIndex += 1) {
+    const row = table.rows[rowIndex];
+    const isHeader = rowIndex === 0 && table.headers.length > 0;
+    const rowText = tableRowText(table, rowIndex);
+    if (!rowText) continue;
+    const rowSpan = withDoclingKind(buildSourceSpan(
+      {
+        documentId: options.documentId,
+        sourceKind: options.sourceKind,
+        text: rowText,
+        pageStart: unit.pageStart,
+        pageEnd: unit.pageEnd,
+        sectionId: unit.label,
+        sourceUnit: "table_row",
+        parentSpanId: tableSpan.id,
+        table: {
+          tableId,
+          tableSpanId: tableSpan.id,
+          rowIndex,
+          isHeader
+        },
+        metadata: {
+          ...baseMetadata,
+          sourceUnit: "table_row",
+          tableId: tableId ?? "",
+          tableSpanId: tableSpan.id,
+          rowIndex: String(rowIndex),
+          isHeader: String(isHeader)
+        }
+      },
+      index * 1e3 + 1 + rowIndex
+    ), unit);
+    spans.push(rowSpan);
+    for (let columnIndex = 0; columnIndex < row.length; columnIndex += 1) {
+      const text = row[columnIndex]?.trim();
+      if (!text) continue;
+      const columnName = table.headers[columnIndex]?.trim() || void 0;
+      const cellSpan = withDoclingKind(buildSourceSpan(
+        {
+          documentId: options.documentId,
+          sourceKind: options.sourceKind,
+          text,
+          pageStart: unit.pageStart,
+          pageEnd: unit.pageEnd,
+          sectionId: unit.label,
+          sourceUnit: "table_cell",
+          parentSpanId: rowSpan.id,
+          table: {
+            tableId,
+            tableSpanId: tableSpan.id,
+            rowSpanId: rowSpan.id,
+            rowIndex,
+            columnIndex,
+            columnName,
+            isHeader
+          },
+          metadata: {
+            ...baseMetadata,
+            sourceUnit: "table_cell",
+            tableId: tableId ?? "",
+            tableSpanId: tableSpan.id,
+            rowSpanId: rowSpan.id,
+            rowIndex: String(rowIndex),
+            columnIndex: String(columnIndex),
+            ...columnName ? { columnName } : {},
+            isHeader: String(isHeader)
+          }
+        },
+        index * 1e3 + 100 + rowIndex * 100 + columnIndex
+      ), unit);
+      spans.push(cellSpan);
+    }
+  }
+  return spans;
+}
+function withDoclingKind(span, unit) {
+  return {
+    ...span,
+    kind: "plain_text",
+    bbox: unit.bboxes?.length ? unit.bboxes : void 0
   };
 }
+function labelToSourceUnit(label) {
+  const normalized = label?.toLowerCase() ?? "";
+  if (normalized.includes("table")) return "table";
+  if (normalized.includes("key")) return "key_value";
+  if (normalized.includes("section") || normalized.includes("header")) return "section";
+  return "text";
+}
+function tableRowText(table, rowIndex) {
+  const row = table.rows[rowIndex] ?? [];
+  const headers = table.headers;
+  if (rowIndex === 0 && headers.length > 0) return row.filter(Boolean).join(" | ");
+  return row.map((value, columnIndex) => {
+    const trimmed = value.trim();
+    if (!trimmed) return "";
+    const header = headers[columnIndex]?.trim();
+    return header ? `${header}: ${trimmed}` : trimmed;
+  }).filter(Boolean).join(" | ");
+}
 function getItemText(item) {
   if (typeof item.text === "string" && item.text.trim()) return item.text;
   if (typeof item.orig === "string" && item.orig.trim()) return item.orig;
-  const table = tableToMarkdown(item.data);
-  if (table) return table;
+  const table = parseTableData(item.data);
+  if (table) return table.markdown;
   return "";
 }
-function tableToMarkdown(data) {
+function parseTableData(data) {
   const record = asRecord(data);
   const cells = Array.isArray(record?.table_cells) ? record.table_cells : Array.isArray(record?.tableCells) ? record.tableCells : void 0;
   if (!cells) return void 0;
@@ -2999,10 +3161,20 @@ function tableToMarkdown(data) {
   for (const cell of parsedCells) {
     rows[cell.row][cell.col] = cell.text;
   }
-  if (rows.length === 1) return rows[0].filter(Boolean).join(" | ");
+  if (rows.length === 1) {
+    const markdown2 = rows[0].filter(Boolean).join(" | ");
+    return { markdown: markdown2, headers: [], rows, cells: parsedCells };
+  }
   const header = rows[0];
   const separator = header.map(() => "---");
-  return [header, separator, ...rows.slice(1)].map((row) => `| ${row.map((value) => value.trim()).join(" | ")} |`).join("\n");
+  const markdown = [header, separator, ...rows.slice(1)].map((row) => `| ${row.map((value) => value.trim()).join(" | ")} |`).join("\n");
+  return { markdown, headers: header, rows, cells: parsedCells };
+}
+function getItemTable(item) {
+  if (typeof item.text === "string" && item.text.trim() || typeof item.orig === "string" && item.orig.trim()) {
+    return void 0;
+  }
+  return parseTableData(item.data);
 }
 function inferPageCount(document, units) {
   const pages = document.pages;
@@ -3079,8 +3251,18 @@ function buildSourceContext(spans, maxChars = 12e3) {
   if (spans.length === 0) return "";
   const lines = [];
   let length = 0;
-  for (const span of spans) {
-    const header = `[sourceSpan:${span.id}${span.pageStart ? ` page:${span.pageStart}${span.pageEnd && span.pageEnd !== span.pageStart ? `-${span.pageEnd}` : ""}` : ""}${span.sectionId ? ` section:${span.sectionId}` : ""}${span.formNumber ? ` form:${span.formNumber}` : ""}]`;
+  for (const span of orderSourceSpansForContext(spans)) {
+    const unit = sourceUnit2(span);
+    const table = span.table;
+    const tableContext = [
+      unit ? ` unit:${unit}` : "",
+      table?.tableId ? ` table:${table.tableId}` : "",
+      table?.rowIndex != null ? ` row:${table.rowIndex}` : "",
+      table?.columnIndex != null ? ` col:${table.columnIndex}` : "",
+      table?.columnName ? ` column:${table.columnName}` : "",
+      span.parentSpanId ? ` parent:${span.parentSpanId}` : ""
+    ].join("");
+    const header = `[sourceSpan:${span.id}${span.pageStart ? ` page:${span.pageStart}${span.pageEnd && span.pageEnd !== span.pageStart ? `-${span.pageEnd}` : ""}` : ""}${span.sectionId ? ` section:${span.sectionId}` : ""}${span.formNumber ? ` form:${span.formNumber}` : ""}${tableContext}]`;
     const text = `${header}
 ${span.text}`;
     if (length + text.length > maxChars && lines.length > 0) break;
@@ -3094,6 +3276,49 @@ ${lines.join("\n\n")}
 
 Use sourceSpan IDs when grounding extracted contractual values.`;
 }
+function sourceUnit2(span) {
+  return span.sourceUnit ?? span.metadata?.sourceUnit;
+}
+function sourceContextRank(span) {
+  switch (sourceUnit2(span)) {
+    case "table_row":
+      return 0;
+    case "table":
+      return 1;
+    case "section":
+      return 2;
+    case "page":
+      return 3;
+    case "key_value":
+      return 4;
+    case "table_cell":
+      return 8;
+    default:
+      return 5;
+  }
+}
+function orderSourceSpansForContext(spans) {
+  const parentRows = new Set(
+    spans.filter((span) => sourceUnit2(span) === "table_row").map((span) => span.id)
+  );
+  const filtered = spans.filter((span) => {
+    if (sourceUnit2(span) !== "table_cell") return true;
+    const parent = span.parentSpanId ?? span.table?.rowSpanId ?? span.metadata?.rowSpanId;
+    return !parent || !parentRows.has(parent);
+  });
+  return [...filtered].sort((left, right) => {
+    const leftPage = left.pageStart ?? left.location?.startPage ?? left.location?.page ?? 0;
+    const rightPage = right.pageStart ?? right.location?.startPage ?? right.location?.page ?? 0;
+    if (leftPage !== rightPage) return leftPage - rightPage;
+    const leftRank = sourceContextRank(left);
+    const rightRank = sourceContextRank(right);
+    if (leftRank !== rightRank) return leftRank - rightRank;
+    const leftRow = left.table?.rowIndex ?? Number(left.metadata?.rowIndex ?? Number.NaN);
+    const rightRow = right.table?.rowIndex ?? Number(right.metadata?.rowIndex ?? Number.NaN);
+    if (Number.isFinite(leftRow) && Number.isFinite(rightRow) && leftRow !== rightRow) return leftRow - rightRow;
+    return left.id.localeCompare(right.id);
+  });
+}
 async function runExtractor(params) {
   const {
     name,
@@ -4692,7 +4917,7 @@ function mergeCoverageLimits(existing, incoming) {
   const merged = mergeShallowPreferPresent(existing, incoming);
   const existingCoverages = Array.isArray(existing.coverages) ? existing.coverages : [];
   const incomingCoverages = Array.isArray(incoming.coverages) ? incoming.coverages : [];
-  const coverageKey = (coverage) => keyFromParts(
+  const coverageKey2 = (coverage) => keyFromParts(
     coverage.name,
     coverage.limitType,
     coverage.limit,
@@ -4701,7 +4926,7 @@ function mergeCoverageLimits(existing, incoming) {
   );
   const byKey = /* @__PURE__ */ new Map();
   for (const coverage of [...existingCoverages, ...incomingCoverages]) {
-    const key = coverageKey(coverage);
+    const key = coverageKey2(coverage);
     const current = byKey.get(key);
     byKey.set(key, current ? mergeShallowPreferPresent(current, coverage) : coverage);
   }
@@ -7048,6 +7273,190 @@ async function resolveReferentialCoverages(params) {
   };
 }
 
+// src/extraction/coverage-schedule-recovery.ts
+function textValue(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function numberValue(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function normalize(value) {
+  return value.toLowerCase().replace(/&/g, "and").replace(/[^a-z0-9]+/g, " ").trim();
+}
+function sourceUnit3(span) {
+  return span.sourceUnit ?? span.metadata?.sourceUnit;
+}
+function pageNumber(span) {
+  return span.pageStart ?? span.location?.page ?? span.location?.startPage;
+}
+function coveragePages(pageAssignments) {
+  const pages = /* @__PURE__ */ new Set();
+  for (const assignment of pageAssignments) {
+    if (assignment.extractorNames.includes("coverage_limits") || assignment.hasScheduleValues) {
+      pages.add(assignment.localPageNumber);
+    }
+  }
+  return pages;
+}
+function parseCurrencyAmount(value) {
+  const match = value.match(/(?:CAD|USD|US)?\s*\$?\s*([0-9][0-9,]*(?:\.\d+)?)/i);
+  if (!match) return void 0;
+  const amount = Number(match[1].replace(/,/g, ""));
+  return Number.isFinite(amount) ? amount : void 0;
+}
+function limitTypeFrom(value) {
+  const normalized = normalize(value);
+  if (normalized.includes("/") || normalized.includes("each claim") && normalized.includes("aggregate")) return "scheduled";
+  if (normalized.includes("each claim") || normalized.includes("per claim")) return "per_claim";
+  if (normalized.includes("each occurrence") || normalized.includes("per occurrence")) return "per_occurrence";
+  if (normalized.includes("aggregate")) return "aggregate";
+  if (normalized.includes("shared within") || normalized.includes("within coverage")) return "scheduled";
+  if (normalized.includes("/")) return "scheduled";
+  return void 0;
+}
+function limitValueTypeFrom(value) {
+  const normalized = normalize(value);
+  if (parseCurrencyAmount(value) !== void 0) return "numeric";
+  if (normalized.includes("shared within") || normalized.includes("within coverage") || normalized.includes("shown above")) {
+    return "referential";
+  }
+  if (normalized.includes("included")) return "included";
+  if (normalized.includes("not included") || normalized === "nil" || normalized === "none") return "not_included";
+  if (normalized.includes("as stated")) return "as_stated";
+  return "other";
+}
+function cleanName(value) {
+  return value.replace(/\s*\([^)]*part of and not in addition to[^)]*\)\s*/gi, " ").replace(/\s+/g, " ").trim().replace(/[.:;-]+$/, "").trim();
+}
+function isDeductibleOnly(name, rowText) {
+  const normalizedName = normalize(name);
+  const normalizedRow = normalize(rowText);
+  if (!/\b(deductible|retention|sir)\b/.test(`${normalizedName} ${normalizedRow}`)) return false;
+  if (/\b(coverage|sub limit|sublimit|limit)\b/.test(normalizedName) && !/\b(enhanced|standard)\s+deductible\b/.test(normalizedName)) {
+    return false;
+  }
+  return /\b(enhanced|standard)?\s*(deductible|retention|sir)\b/.test(normalizedName) || /^\s*(deductible|retention|sir)\b/.test(normalizedRow);
+}
+function splitRowFields(rowText) {
+  return rowText.split(/\s+\|\s+/).map((part) => part.trim()).filter(Boolean).map((part) => {
+    const match = part.match(/^([^:]{1,100}):\s*(.*)$/);
+    if (!match) return { value: part };
+    return { key: match[1].trim(), value: match[2].trim() };
+  });
+}
+function firstField(fields, patterns) {
+  for (const field of fields) {
+    const target = `${field.key ?? ""} ${field.value}`;
+    if (patterns.some((pattern) => pattern.test(target))) return field.value || field.key;
+  }
+  return void 0;
+}
+function coverageFromRow(span) {
+  const rowText = span.text.trim();
+  if (!rowText || sourceUnit3(span) !== "table_row") return void 0;
+  if (span.table?.isHeader || span.metadata?.isHeader === "true") return void 0;
+  const fields = splitRowFields(rowText);
+  let name;
+  let limit;
+  for (const field of fields) {
+    const key = field.key?.trim();
+    const value = field.value.trim();
+    if (!key || !value) continue;
+    if (!name && /^coverage$/i.test(key)) name = cleanName(value);
+    if (!limit && /\blimit\b/i.test(key)) limit = value;
+    if (!name && /\b(sub[-\s]?limit|aggregate|each claim)\b/i.test(key) && parseCurrencyAmount(value) !== void 0) {
+      name = cleanName(key);
+      limit = limit ?? value;
+    }
+  }
+  if (!name || !limit) {
+    for (const field of fields) {
+      const key = field.key?.trim();
+      const value = field.value.trim();
+      if (!key || !value) continue;
+      if (!name && /\b(sub[-\s]?limit|coverage|aggregate|each claim)\b/i.test(key) && !parseCurrencyAmount(key)) {
+        name = cleanName(key);
+        limit = limit ?? value;
+      }
+    }
+  }
+  if (!name || !limit) return void 0;
+  if (isDeductibleOnly(name, rowText)) return void 0;
+  const normalizedLimit = normalize(limit);
+  const hasUsableLimit = parseCurrencyAmount(limit) !== void 0 || /\b(shared within|within coverage|as stated|included|not included)\b/i.test(normalizedLimit);
+  if (!hasUsableLimit) return void 0;
+  const deductible = firstField(fields, [/\bdeductible\b/i, /\bretention\b/i, /\bsir\b/i]);
+  const basis = firstField(fields, [/\bbasis\b/i]);
+  const retroactiveDate = firstField(fields, [/\bretroactive date\b/i, /\bretro date\b/i]);
+  const page = pageNumber(span);
+  const limitAmount = parseCurrencyAmount(limit);
+  const deductibleAmount = deductible ? parseCurrencyAmount(deductible) : void 0;
+  return {
+    name,
+    limit,
+    ...limitAmount !== void 0 ? { limitAmount } : {},
+    ...limitTypeFrom(`${name} ${limit}`) ? { limitType: limitTypeFrom(`${name} ${limit}`) } : {},
+    limitValueType: limitValueTypeFrom(limit),
+    ...deductible && !/^nil|none$/i.test(deductible.trim()) ? { deductible } : {},
+    ...deductibleAmount !== void 0 ? { deductibleAmount } : {},
+    ...deductible ? { deductibleValueType: limitValueTypeFrom(deductible) } : {},
+    ...basis && /claims[- ]made/i.test(basis) ? { trigger: "claims_made" } : {},
+    ...retroactiveDate ? { retroactiveDate } : {},
+    ...span.formNumber ? { formNumber: span.formNumber } : {},
+    ...page ? { pageNumber: page } : {},
+    sectionRef: span.sectionId ?? "SCHEDULE",
+    originalContent: rowText,
+    sourceSpanIds: [span.id],
+    sourceTextHash: span.textHash ?? span.hash
+  };
+}
+function coverageKey(coverage) {
+  return [
+    textValue(coverage.name) ?? "",
+    textValue(coverage.limit) ?? "",
+    textValue(coverage.limitType) ?? "",
+    numberValue(coverage.pageNumber) ?? ""
+  ].map((part) => normalize(String(part))).join("|");
+}
+function rowMatchesExisting(row, existing) {
+  const rowKey = coverageKey(row);
+  const rowName = normalize(textValue(row.name) ?? "");
+  const rowLimit = normalize(textValue(row.limit) ?? "");
+  return existing.some((coverage) => {
+    if (coverageKey(coverage) === rowKey) return true;
+    const name = normalize(textValue(coverage.name) ?? "");
+    const limit = normalize(textValue(coverage.limit) ?? "");
+    return Boolean(rowName && rowLimit && name === rowName && limit === rowLimit);
+  });
+}
+function recoverCoverageScheduleRows(params) {
+  const payload = params.memory.get("coverage_limits");
+  const existing = Array.isArray(payload?.coverages) ? payload.coverages : [];
+  const pages = coveragePages(params.pageAssignments);
+  const candidates = params.sourceSpans.filter((span) => sourceUnit3(span) === "table_row").filter((span) => {
+    const page = pageNumber(span);
+    return page !== void 0 && pages.has(page);
+  }).map(coverageFromRow).filter((coverage) => Boolean(coverage));
+  const recovered = [];
+  for (const coverage of candidates) {
+    if (rowMatchesExisting(coverage, [...existing, ...recovered])) continue;
+    recovered.push(coverage);
+  }
+  if (recovered.length > 0) {
+    params.memory.set("coverage_limits", {
+      ...payload ?? {},
+      coverages: [...existing, ...recovered]
+    });
+  }
+  return {
+    recovered,
+    missingSourceRows: recovered.map((coverage) => {
+      const id = Array.isArray(coverage.sourceSpanIds) ? coverage.sourceSpanIds[0] : void 0;
+      return params.sourceSpans.find((span) => span.id === id);
+    }).filter((span) => Boolean(span))
+  };
+}
+
 // src/extraction/focused-dispatch.ts
 async function runFocusedExtractorWithFallback(params) {
   const {
@@ -7211,6 +7620,20 @@ function sourcePrecedence(sectionRef) {
   if (normalized.includes("coverage form") || normalized.includes("policy form")) return 1;
   return 0;
 }
+function looksDeductibleOnlyCoverageRow(coverage) {
+  const name = typeof coverage.name === "string" ? coverage.name : "";
+  const originalContent = typeof coverage.originalContent === "string" ? coverage.originalContent : "";
+  const evidenceText = originalContent || name;
+  const normalizedEvidence = evidenceText.toLowerCase();
+  const normalizedName = name.toLowerCase();
+  if (!/\b(deductible|retention|self[-\s]?insured retention|sir)\b/.test(`${normalizedName} ${normalizedEvidence}`)) return false;
+  if (coverage.deductible || coverage.deductibleAmount !== void 0) return false;
+  if (!coverage.limit && coverage.limitAmount === void 0) return false;
+  if (originalContent && /\b(deductible|retention|self[-\s]?insured retention|sir)\b/.test(normalizedEvidence) && !/\b(?:sub[-\s]?limit|limit|coverage)\b/.test(normalizedEvidence)) {
+    return true;
+  }
+  return /[-–—]\s*(?:enhanced\s+|standard\s+)?(?:deductible|retention|sir)\b/.test(normalizedName);
+}
 function buildExtractionReviewReport(params) {
   const { memory, reviewRounds } = params;
   const deterministicIssues = [];
@@ -7236,6 +7659,29 @@ function buildExtractionReviewReport(params) {
     addMissingSourceGroundingIssues(deterministicIssues, "definitions", "definitions", definitions, "term");
     addMissingSourceGroundingIssues(deterministicIssues, "covered_reasons", "coveredReasons", coveredReasons, "name");
   }
+  if (params.sourceSpans?.length) {
+    const tempCoveragePayload = {
+      ...memory.get("coverage_limits") ?? {},
+      coverages: coverages.map((coverage) => ({ ...coverage }))
+    };
+    const tempMemory = new Map(memory);
+    tempMemory.set("coverage_limits", tempCoveragePayload);
+    const scheduleRecovery = recoverCoverageScheduleRows({
+      memory: tempMemory,
+      sourceSpans: params.sourceSpans,
+      pageAssignments: params.pageAssignments
+    });
+    for (const recovered of scheduleRecovery.recovered) {
+      deterministicIssues.push({
+        code: "coverage_schedule_row_missing",
+        severity: "blocking",
+        message: `Coverage schedule row "${String(recovered.name ?? "unknown")}" is present in source table evidence but missing from extracted coverages.`,
+        extractorName: "coverage_limits",
+        pageNumber: typeof recovered.pageNumber === "number" ? recovered.pageNumber : void 0,
+        itemName: typeof recovered.name === "string" ? recovered.name : void 0
+      });
+    }
+  }
   if (mappedDefinitions && definitions.length === 0) {
     deterministicIssues.push({
       code: "definitions_mapped_but_empty",
@@ -7316,6 +7762,17 @@ function buildExtractionReviewReport(params) {
         itemName: coverage.name
       });
     }
+    if (looksDeductibleOnlyCoverageRow(coverage)) {
+      deterministicIssues.push({
+        code: "deductible_row_as_coverage_limit",
+        severity: "blocking",
+        message: `Coverage "${String(coverage.name ?? "unknown")}" appears to store a deductible or retention value as a coverage limit.`,
+        extractorName: "coverage_limits",
+        formNumber,
+        pageNumber: typeof coverage.pageNumber === "number" ? coverage.pageNumber : void 0,
+        itemName: typeof coverage.name === "string" ? coverage.name : void 0
+      });
+    }
     if (typeof coverage.pageNumber !== "number") {
       deterministicIssues.push({
         code: "coverage_missing_page_number",
@@ -7653,17 +8110,17 @@ var ARRAY_PATHS = [
   { memoryKey: "covered_reasons", arrayKeys: ["coveredReasons", "covered_reasons"] },
   { memoryKey: "declarations", arrayKeys: ["fields"] }
 ];
-function normalize(value) {
+function normalize2(value) {
   return value.replace(/\s+/g, " ").trim().toLowerCase();
 }
-function textValue(record, ...keys) {
+function textValue2(record, ...keys) {
   for (const key of keys) {
     const value = record[key];
     if (typeof value === "string" && value.trim()) return value.trim();
   }
   return void 0;
 }
-function numberValue(record, ...keys) {
+function numberValue2(record, ...keys) {
   for (const key of keys) {
     const value = record[key];
     if (typeof value === "number" && Number.isFinite(value)) return value;
@@ -7680,37 +8137,73 @@ function pageOverlaps(recordStart, recordEnd, span) {
   return start <= (spanEnd ?? spanStart) && end >= spanStart;
 }
 function formMatches(record, span) {
-  const formNumber = textValue(record, "formNumber");
+  const formNumber = textValue2(record, "formNumber");
   if (!formNumber || !span.formNumber) return false;
-  return normalize(formNumber) === normalize(span.formNumber);
+  return normalize2(formNumber) === normalize2(span.formNumber);
 }
 function textMatches(record, span) {
-  const spanText = normalize(span.text);
+  const spanText = normalize2(span.text);
   const candidates = [
-    textValue(record, "originalContent", "content", "definition", "value"),
-    textValue(record, "name", "title", "term", "field", "coverageName"),
-    textValue(record, "limit", "deductible", "premium")
+    textValue2(record, "originalContent", "content", "definition", "value"),
+    textValue2(record, "name", "title", "term", "field", "coverageName"),
+    textValue2(record, "limit", "deductible", "premium")
   ].filter((value) => !!value && value.length >= 3);
-  return candidates.some((candidate) => spanText.includes(normalize(candidate)));
+  return candidates.some((candidate) => spanText.includes(normalize2(candidate)));
 }
 function sourceHashFor(spans) {
   return spans.map((span) => span.textHash ?? span.hash).filter(Boolean).join(":") || void 0;
 }
+function sourceUnit4(span) {
+  return span.sourceUnit ?? span.metadata?.sourceUnit;
+}
+function hierarchyScore(span) {
+  switch (sourceUnit4(span)) {
+    case "table_row":
+      return 5;
+    case "table":
+      return 3;
+    case "section":
+    case "page":
+      return 2;
+    case "table_cell":
+      return -2;
+    default:
+      return 0;
+  }
+}
+function parentRowId(span) {
+  return span.parentSpanId ?? span.table?.rowSpanId ?? span.metadata?.rowSpanId;
+}
+function preferParentRows(matches, sourceSpans) {
+  if (matches.length === 0) return matches;
+  const byId = new Map(sourceSpans.map((span) => [span.id, span]));
+  const expanded = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const match of matches) {
+    const parent = sourceUnit4(match) === "table_cell" ? byId.get(parentRowId(match) ?? "") : void 0;
+    const preferred = parent && sourceUnit4(parent) === "table_row" ? parent : match;
+    if (seen.has(preferred.id)) continue;
+    seen.add(preferred.id);
+    expanded.push(preferred);
+  }
+  return expanded;
+}
 function findSourceSpansForRecord(record, sourceSpans) {
   if (sourceSpans.length === 0) return [];
-  const pageStart = numberValue(record, "pageNumber", "pageStart");
-  const pageEnd = numberValue(record, "pageNumber", "pageEnd");
+  const pageStart = numberValue2(record, "pageNumber", "pageStart");
+  const pageEnd = numberValue2(record, "pageNumber", "pageEnd");
   const scored = sourceSpans.map((span) => {
     let score = 0;
     if (pageOverlaps(pageStart, pageEnd, span)) score += 4;
     if (formMatches(record, span)) score += 3;
     if (textMatches(record, span)) score += 2;
+    if (score > 0) score += hierarchyScore(span);
     return { span, score };
   }).filter((item) => item.score >= 2).sort((left, right) => {
     if (right.score !== left.score) return right.score - left.score;
     return left.span.id.localeCompare(right.span.id);
   });
-  return scored.slice(0, 3).map((item) => item.span);
+  return preferParentRows(scored.slice(0, 5).map((item) => item.span), sourceSpans).slice(0, 3);
 }
 function groundRecord(record, sourceSpans) {
   if (Array.isArray(record.sourceSpanIds) && record.sourceSpanIds.length > 0 && record.sourceTextHash) {
@@ -8418,6 +8911,14 @@ ${pageText}`;
           mergeMemoryResult(result.name, result.data, memory);
         }
       }
+      const recoveredCoverages = recoverCoverageScheduleRows({
+        memory,
+        sourceSpans,
+        pageAssignments
+      });
+      if (recoveredCoverages.recovered.length > 0) {
+        await log?.(`Recovered ${recoveredCoverages.recovered.length} source-backed coverage schedule row(s) from table evidence`);
+      }
       const planIncludesSupplementary = tasks.some((task) => task.extractorName === "supplementary");
       if (!planIncludesSupplementary && hasSupplementaryExtractionSignal(pageAssignments, formInventory, memory)) {
         onProgress?.("Extracting supplementary retrieval facts...");
@@ -8514,7 +9015,8 @@ ${pageText}`;
         memory,
         pageAssignments,
         reviewRounds,
-        sourceSpansAvailable: sourceSpans.length > 0
+        sourceSpansAvailable: sourceSpans.length > 0,
+        sourceSpans
       });
       if (shouldRunLlmReview(reviewMode, preReviewReport, sourceSpans.length > 0)) {
         for (let round = 0; round < maxReviewRounds; round++) {
@@ -8583,6 +9085,14 @@ ${pageText}`;
               mergeMemoryResult(result.name, result.data, memory);
             }
           }
+          const recoveredCoverages = recoverCoverageScheduleRows({
+            memory,
+            sourceSpans,
+            pageAssignments
+          });
+          if (recoveredCoverages.recovered.length > 0) {
+            await log?.(`Recovered ${recoveredCoverages.recovered.length} source-backed coverage schedule row(s) from follow-up table evidence`);
+          }
         }
       } else {
         onProgress?.("Skipping LLM extraction review; deterministic checks passed.");
@@ -8592,7 +9102,8 @@ ${pageText}`;
         memory,
         pageAssignments,
         reviewRounds,
-        sourceSpansAvailable: sourceSpans.length > 0
+        sourceSpansAvailable: sourceSpans.length > 0,
+        sourceSpans
       });
       if (reviewReport.issues.length > 0) {
         await log?.(
@@ -8618,7 +9129,8 @@ ${pageText}`;
       memory,
       pageAssignments,
       reviewRounds,
-      sourceSpansAvailable: sourceSpans.length > 0
+      sourceSpansAvailable: sourceSpans.length > 0,
+      sourceSpans
     }));
     onProgress?.("Assembling document...");
     const document = assembleDocument(id, documentType, memory);
@@ -12541,6 +13053,8 @@ var AGENT_TOOLS = [
   SourceSpanLocationSchema,
   SourceSpanRefSchema,
   SourceSpanSchema,
+  SourceSpanTableLocationSchema,
+  SourceSpanUnitSchema,
   SubAnswerSchema,
   SubQuestionSchema,
   SubjectivityCategorySchema,