@claritylabs/cl-sdk 1.3.8 → 3.0.1

package/dist/index.mjs

@@ -567,14 +567,20 @@ var FormReferenceSchema = z3.object({
   title: z3.string().optional(),
   formType: z3.enum(["coverage", "endorsement", "declarations", "application", "notice", "other"]),
   pageStart: z3.number().optional(),
-  pageEnd: z3.number().optional()
+  pageEnd: z3.number().optional(),
+  documentNodeId: z3.string().optional(),
+  sourceSpanIds: z3.array(z3.string()).optional(),
+  sourceTextHash: z3.string().optional()
 });
 var TaxFeeItemSchema = z3.object({
   name: z3.string(),
   amount: z3.string(),
   amountValue: z3.number().optional(),
   type: z3.enum(["tax", "fee", "surcharge", "assessment"]).optional(),
-  description: z3.string().optional()
+  description: z3.string().optional(),
+  documentNodeId: z3.string().optional(),
+  sourceSpanIds: z3.array(z3.string()).optional(),
+  sourceTextHash: z3.string().optional()
 });
 var RatingBasisSchema = z3.object({
   type: RatingBasisTypeSchema,
@@ -630,6 +636,7 @@ var CoverageSchema = z4.object({
   sectionRef: z4.string().optional(),
   originalContent: z4.string().optional(),
   recordId: z4.string().optional(),
+  documentNodeId: z4.string().optional(),
   sourceSpanIds: z4.array(z4.string()).optional(),
   sourceTextHash: z4.string().optional()
 });
@@ -659,6 +666,7 @@ var EnrichedCoverageSchema = z4.object({
   sectionRef: z4.string().optional(),
   originalContent: z4.string().optional(),
   recordId: z4.string().optional(),
+  documentNodeId: z4.string().optional(),
   sourceSpanIds: z4.array(z4.string()).optional(),
   sourceTextHash: z4.string().optional()
 });
@@ -687,6 +695,7 @@ var EndorsementSchema = z5.object({
   pageStart: z5.number(),
   pageEnd: z5.number().optional(),
   recordId: z5.string().optional(),
+  documentNodeId: z5.string().optional(),
   sourceSpanIds: z5.array(z5.string()).optional(),
   sourceTextHash: z5.string().optional()
 });
@@ -705,6 +714,7 @@ var ExclusionSchema = z6.object({
   content: z6.string(),
   pageNumber: z6.number().optional(),
   recordId: z6.string().optional(),
+  documentNodeId: z6.string().optional(),
   sourceSpanIds: z6.array(z6.string()).optional(),
   sourceTextHash: z6.string().optional()
 });
@@ -722,6 +732,7 @@ var PolicyConditionSchema = z7.object({
   keyValues: z7.array(ConditionKeyValueSchema).optional(),
   pageNumber: z7.number().optional(),
   recordId: z7.string().optional(),
+  documentNodeId: z7.string().optional(),
   sourceSpanIds: z7.array(z7.string()).optional(),
   sourceTextHash: z7.string().optional()
 });
@@ -1298,6 +1309,7 @@ var SubsectionSchema = z16.object({
   pageNumber: z16.number().optional(),
   excerpt: z16.string().optional(),
   content: z16.string().optional(),
+  documentNodeId: z16.string().optional(),
   sourceSpanIds: z16.array(z16.string()).optional(),
   sourceTextHash: z16.string().optional()
 });
@@ -1312,6 +1324,7 @@ var SectionSchema = z16.object({
   content: z16.string().optional(),
   subsections: z16.array(SubsectionSchema).optional(),
   recordId: z16.string().optional(),
+  documentNodeId: z16.string().optional(),
   sourceSpanIds: z16.array(z16.string()).optional(),
   sourceTextHash: z16.string().optional()
 });
@@ -1325,13 +1338,19 @@ var UnderwritingConditionSchema = z16.object({
 var PremiumLineSchema = z16.object({
   line: z16.string(),
   amount: z16.string(),
-  amountValue: z16.number().optional()
+  amountValue: z16.number().optional(),
+  documentNodeId: z16.string().optional(),
+  sourceSpanIds: z16.array(z16.string()).optional(),
+  sourceTextHash: z16.string().optional()
 });
 var AuxiliaryFactSchema = z16.object({
   key: z16.string(),
   value: z16.string(),
   subject: z16.string().optional(),
-  context: z16.string().optional()
+  context: z16.string().optional(),
+  documentNodeId: z16.string().optional(),
+  sourceSpanIds: z16.array(z16.string()).optional(),
+  sourceTextHash: z16.string().optional()
 });
 var DefinitionSchema = z16.object({
   term: z16.string(),
@@ -1342,6 +1361,7 @@ var DefinitionSchema = z16.object({
   sectionRef: z16.string().optional(),
   originalContent: z16.string().optional(),
   recordId: z16.string().optional(),
+  documentNodeId: z16.string().optional(),
   sourceSpanIds: z16.array(z16.string()).optional(),
   sourceTextHash: z16.string().optional()
 });
@@ -1359,9 +1379,62 @@ var CoveredReasonSchema = z16.object({
   sectionRef: z16.string().optional(),
   originalContent: z16.string().optional(),
   recordId: z16.string().optional(),
+  documentNodeId: z16.string().optional(),
   sourceSpanIds: z16.array(z16.string()).optional(),
   sourceTextHash: z16.string().optional()
 });
+var DocumentTableOfContentsEntrySchema = z16.object({
+  title: z16.string(),
+  level: z16.number().int().positive().optional(),
+  pageStart: z16.number().optional(),
+  pageEnd: z16.number().optional(),
+  documentNodeId: z16.string().optional(),
+  sourceSpanIds: z16.array(z16.string()).optional()
+});
+var DocumentPageMapEntrySchema = z16.object({
+  page: z16.number().int().positive(),
+  label: z16.string().optional(),
+  formNumber: z16.string().optional(),
+  formTitle: z16.string().optional(),
+  sectionTitle: z16.string().optional(),
+  extractorNames: z16.array(z16.string()).optional(),
+  sourceSpanIds: z16.array(z16.string()).optional()
+});
+var DocumentAgentGuidanceSchema = z16.object({
+  kind: z16.string(),
+  title: z16.string(),
+  detail: z16.string(),
+  sourceSpanIds: z16.array(z16.string()).optional()
+});
+var DocumentMetadataSchema = z16.object({
+  sourceTreeVersion: z16.string().optional(),
+  sourceTreeCanonical: z16.boolean().optional(),
+  formInventory: z16.array(FormReferenceSchema).optional(),
+  tableOfContents: z16.array(DocumentTableOfContentsEntrySchema).optional(),
+  pageMap: z16.array(DocumentPageMapEntrySchema).optional(),
+  agentGuidance: z16.array(DocumentAgentGuidanceSchema).optional()
+});
+var DocumentNodeSchema = z16.lazy(
+  () => z16.object({
+    id: z16.string(),
+    title: z16.string(),
+    originalTitle: z16.string().optional(),
+    type: z16.string().optional(),
+    label: z16.string().optional(),
+    level: z16.number().int().positive().optional(),
+    sectionNumber: z16.string().optional(),
+    pageStart: z16.number().optional(),
+    pageEnd: z16.number().optional(),
+    formNumber: z16.string().optional(),
+    formTitle: z16.string().optional(),
+    excerpt: z16.string().optional(),
+    content: z16.string().optional(),
+    interpretationLabels: z16.array(z16.string()).optional(),
+    sourceSpanIds: z16.array(z16.string()).optional(),
+    sourceTextHash: z16.string().optional(),
+    children: z16.array(DocumentNodeSchema).optional()
+  })
+);
 var BaseDocumentFields = {
   id: z16.string(),
   carrier: z16.string(),
@@ -1372,6 +1445,8 @@ var BaseDocumentFields = {
   summary: z16.string().optional(),
   policyTypes: z16.array(z16.string()).optional(),
   coverages: z16.array(CoverageSchema),
+  documentMetadata: DocumentMetadataSchema,
+  documentOutline: z16.array(DocumentNodeSchema),
   sections: z16.array(SectionSchema).optional(),
   definitions: z16.array(DefinitionSchema).optional(),
   coveredReasons: z16.array(CoveredReasonSchema).optional(),
@@ -1933,6 +2008,86 @@ var SourceChunkSchema = z20.object({
   pageEnd: z20.number().int().positive().optional(),
   metadata: z20.record(z20.string(), z20.string()).default({})
 });
+var DocumentSourceNodeKindSchema = z20.enum([
+  "document",
+  "page_group",
+  "page",
+  "form",
+  "endorsement",
+  "section",
+  "schedule",
+  "clause",
+  "table",
+  "table_row",
+  "table_cell",
+  "text"
+]);
+var DocumentSourceNodeSchema = z20.object({
+  id: z20.string().min(1),
+  documentId: z20.string().min(1),
+  parentId: z20.string().optional(),
+  kind: DocumentSourceNodeKindSchema,
+  title: z20.string(),
+  description: z20.string(),
+  textExcerpt: z20.string().optional(),
+  sourceSpanIds: z20.array(z20.string().min(1)),
+  pageStart: z20.number().int().positive().optional(),
+  pageEnd: z20.number().int().positive().optional(),
+  bbox: z20.array(SourceSpanBBoxSchema).optional(),
+  order: z20.number().int().nonnegative(),
+  path: z20.string(),
+  metadata: z20.record(z20.string(), z20.unknown()).optional()
+});
+var SourceBackedValueSchema = z20.object({
+  value: z20.string(),
+  normalizedValue: z20.string().optional(),
+  confidence: z20.enum(["low", "medium", "high"]).default("medium"),
+  sourceNodeIds: z20.array(z20.string().min(1)).default([]),
+  sourceSpanIds: z20.array(z20.string().min(1)).default([])
+});
+var OperationalCoverageLineSchema = z20.object({
+  name: z20.string(),
+  coverageCode: z20.string().optional(),
+  limit: z20.string().optional(),
+  deductible: z20.string().optional(),
+  premium: z20.string().optional(),
+  formNumber: z20.string().optional(),
+  sectionRef: z20.string().optional(),
+  sourceNodeIds: z20.array(z20.string().min(1)).default([]),
+  sourceSpanIds: z20.array(z20.string().min(1)).default([])
+});
+var OperationalPartySchema = z20.object({
+  role: z20.string(),
+  name: z20.string(),
+  sourceNodeIds: z20.array(z20.string().min(1)).default([]),
+  sourceSpanIds: z20.array(z20.string().min(1)).default([])
+});
+var OperationalEndorsementSupportSchema = z20.object({
+  kind: z20.string(),
+  status: z20.enum(["supported", "excluded", "requires_review"]),
+  summary: z20.string(),
+  sourceNodeIds: z20.array(z20.string().min(1)).default([]),
+  sourceSpanIds: z20.array(z20.string().min(1)).default([])
+});
+var PolicyOperationalProfileSchema = z20.object({
+  documentType: z20.enum(["policy", "quote"]).default("policy"),
+  policyTypes: z20.array(z20.string()).default(["other"]),
+  policyNumber: SourceBackedValueSchema.optional(),
+  namedInsured: SourceBackedValueSchema.optional(),
+  insurer: SourceBackedValueSchema.optional(),
+  broker: SourceBackedValueSchema.optional(),
+  effectiveDate: SourceBackedValueSchema.optional(),
+  expirationDate: SourceBackedValueSchema.optional(),
+  retroactiveDate: SourceBackedValueSchema.optional(),
+  premium: SourceBackedValueSchema.optional(),
+  coverageTypes: z20.array(z20.string()).default([]),
+  coverages: z20.array(OperationalCoverageLineSchema).default([]),
+  parties: z20.array(OperationalPartySchema).default([]),
+  endorsementSupport: z20.array(OperationalEndorsementSupportSchema).default([]),
+  sourceNodeIds: z20.array(z20.string().min(1)).default([]),
+  sourceSpanIds: z20.array(z20.string().min(1)).default([]),
+  warnings: z20.array(z20.string()).default([])
+});
 
 // src/source/ids.ts
 function normalizeText(text) {
@@ -2116,8 +2271,8 @@ function chunkSourceSpans(spans, options = {}) {
     if (current.length === 0) return;
     const text = current.map((span) => span.text).join("\n\n");
     const textHash = sourceSpanTextHash(text);
-    const pageStart = firstNumber(current.map((span) => span.pageStart));
-    const pageEnd = lastNumber(current.map((span) => span.pageEnd ?? span.pageStart));
+    const pageStart2 = firstNumber(current.map((span) => span.pageStart));
+    const pageEnd2 = lastNumber(current.map((span) => span.pageEnd ?? span.pageStart));
     const chunk = {
       id: `${sanitizeIdPart(current[0].documentId)}:source_chunk:${chunks.length}:${stableHash2({
         sourceSpanIds: current.map((span) => span.id),
@@ -2127,8 +2282,8 @@ function chunkSourceSpans(spans, options = {}) {
       sourceSpanIds: current.map((span) => span.id),
       text,
       textHash,
-      pageStart,
-      pageEnd,
+      pageStart: pageStart2,
+      pageEnd: pageEnd2,
       metadata: mergeMetadata(current)
     };
     chunks.push(SourceChunkSchema.parse(chunk));
@@ -2281,6 +2436,542 @@ function matchesFilters(span, filters) {
   return true;
 }
 
+// src/source/tree.ts
+function normalizeWhitespace2(value) {
+  return value.replace(/\s+/g, " ").trim();
+}
+function sanitizeIdPart2(value) {
+  return value.replace(/[^a-zA-Z0-9_.:-]/g, "_");
+}
+function truncate(value, maxChars) {
+  const text = normalizeWhitespace2(value);
+  return text.length > maxChars ? `${text.slice(0, maxChars).trimEnd()}...` : text;
+}
+function pageStart(span) {
+  return span.pageStart ?? span.location?.page ?? span.location?.startPage;
+}
+function pageEnd(span) {
+  return span.pageEnd ?? span.location?.endPage ?? pageStart(span);
+}
+function sourceUnit2(span) {
+  return span.sourceUnit ?? span.metadata?.sourceUnit ?? span.metadata?.elementType;
+}
+function elementType(span) {
+  return span.metadata?.elementType ?? span.metadata?.sourceUnit ?? span.sourceUnit;
+}
+function tableId(span) {
+  return span.table?.tableId ?? span.metadata?.tableId;
+}
+function rowSpanId(span) {
+  return span.parentSpanId ?? span.table?.rowSpanId ?? span.metadata?.rowSpanId;
+}
+function nodeId(documentId, kind, parts) {
+  return [
+    sanitizeIdPart2(documentId),
+    "source_node",
+    kind,
+    stableHash2(parts.filter((part) => part !== void 0).join("|")).slice(0, 12)
+  ].join(":");
+}
+function titleCase(value) {
+  return value.replace(/[_-]+/g, " ").replace(/\b\w/g, (char) => char.toUpperCase()).trim();
+}
+function nodeTextDescription(params) {
+  return [
+    params.title,
+    params.kind.replace(/_/g, " "),
+    params.page ? `page ${params.page}` : void 0,
+    params.formNumber ? `form ${params.formNumber}` : void 0,
+    params.text ? truncate(params.text, 1200) : void 0
+  ].filter(Boolean).join(" | ");
+}
+function normalizeNodeKind(span) {
+  const unit = sourceUnit2(span);
+  const element = elementType(span);
+  if (unit === "page") return "page";
+  if (unit === "table") return "table";
+  if (unit === "table_row") return "table_row";
+  if (unit === "table_cell") return "table_cell";
+  if (unit === "key_value") return "schedule";
+  if (unit === "section") return "section";
+  if (element === "title" || element === "section_candidate") {
+    const text = span.text.toLowerCase();
+    if (/endorsement/.test(text)) return "endorsement";
+    if (/schedule|declarations?/.test(text)) return "schedule";
+    if (/clause|condition|exclusion|definition/.test(text)) return "clause";
+    return "section";
+  }
+  return "text";
+}
+function pageNodeTitle(page) {
+  return `Page ${page}`;
+}
+function makeNode(params) {
+  return {
+    id: params.id,
+    documentId: params.documentId,
+    parentId: params.parentId,
+    kind: params.kind,
+    title: params.title,
+    description: params.description ?? nodeTextDescription({
+      kind: params.kind,
+      title: params.title,
+      text: params.textExcerpt,
+      page: params.pageStart,
+      formNumber: typeof params.metadata?.formNumber === "string" ? params.metadata.formNumber : void 0
+    }),
+    textExcerpt: params.textExcerpt,
+    sourceSpanIds: params.sourceSpanIds ?? [],
+    pageStart: params.pageStart,
+    pageEnd: params.pageEnd,
+    bbox: params.bbox,
+    order: params.order,
+    path: "",
+    metadata: params.metadata
+  };
+}
+function sortSpans(left, right) {
+  const leftPage = pageStart(left) ?? 0;
+  const rightPage = pageStart(right) ?? 0;
+  if (leftPage !== rightPage) return leftPage - rightPage;
+  const leftRow = left.table?.rowIndex ?? Number(left.metadata?.rowIndex ?? 0);
+  const rightRow = right.table?.rowIndex ?? Number(right.metadata?.rowIndex ?? 0);
+  if (leftRow !== rightRow) return leftRow - rightRow;
+  const leftCol = left.table?.columnIndex ?? Number(left.metadata?.columnIndex ?? 0);
+  const rightCol = right.table?.columnIndex ?? Number(right.metadata?.columnIndex ?? 0);
+  if (leftCol !== rightCol) return leftCol - rightCol;
+  return left.id.localeCompare(right.id);
+}
+function normalizeDocumentSourceTreePaths(nodes) {
+  const byParent = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    const key = node.parentId;
+    const group = byParent.get(key) ?? [];
+    group.push(node);
+    byParent.set(key, group);
+  }
+  for (const group of byParent.values()) {
+    group.sort((left, right) => left.order - right.order || left.id.localeCompare(right.id));
+  }
+  const result = [];
+  const visit = (node, path) => {
+    const next = { ...node, path };
+    result.push(next);
+    const children = byParent.get(node.id) ?? [];
+    children.forEach((child, index) => visit(child, `${path}.${index + 1}`));
+  };
+  const roots = byParent.get(void 0) ?? [];
+  roots.forEach((root, index) => visit(root, String(index + 1)));
+  return result;
+}
+function buildDocumentSourceTree(sourceSpans, documentId) {
+  const orderedSpans = [...sourceSpans].sort(sortSpans);
+  const resolvedDocumentId = documentId ?? orderedSpans[0]?.documentId ?? "document";
+  const nodes = /* @__PURE__ */ new Map();
+  let order = 0;
+  const rootId = nodeId(resolvedDocumentId, "document", [resolvedDocumentId]);
+  nodes.set(rootId, makeNode({
+    id: rootId,
+    documentId: resolvedDocumentId,
+    kind: "document",
+    title: "Document",
+    description: "Document root for source-native policy hierarchy",
+    sourceSpanIds: orderedSpans.map((span) => span.id).slice(0, 200),
+    pageStart: orderedSpans.map(pageStart).find((value) => typeof value === "number"),
+    pageEnd: [...orderedSpans].reverse().map(pageEnd).find((value) => typeof value === "number"),
+    order: order++,
+    metadata: { sourceTreeVersion: "v3" }
+  }));
+  const pageNodeIds = /* @__PURE__ */ new Map();
+  const tableNodeIds = /* @__PURE__ */ new Map();
+  const rowNodeIds = /* @__PURE__ */ new Map();
+  const ensurePage = (page) => {
+    const existing = pageNodeIds.get(page);
+    if (existing) return existing;
+    const id = nodeId(resolvedDocumentId, "page", [page]);
+    const pageSpan = orderedSpans.find((span) => pageStart(span) === page && sourceUnit2(span) === "page");
+    nodes.set(id, makeNode({
+      id,
+      documentId: resolvedDocumentId,
+      parentId: rootId,
+      kind: "page",
+      title: pageNodeTitle(page),
+      description: pageSpan ? nodeTextDescription({ kind: "page", title: pageNodeTitle(page), text: pageSpan.text, page }) : pageNodeTitle(page),
+      textExcerpt: pageSpan ? truncate(pageSpan.text, 1600) : void 0,
+      sourceSpanIds: pageSpan ? [pageSpan.id] : [],
+      pageStart: page,
+      pageEnd: page,
+      bbox: pageSpan?.bbox,
+      order: order++,
+      metadata: { sourceUnit: "page" }
+    }));
+    pageNodeIds.set(page, id);
+    return id;
+  };
+  const ensureTable = (span, pageParentId) => {
+    const idSource = tableId(span) ?? `${span.documentId}:p${pageStart(span) ?? "na"}:table:${nodes.size}`;
+    const existing = tableNodeIds.get(idSource);
+    if (existing) return existing;
+    const id = nodeId(resolvedDocumentId, "table", [idSource]);
+    nodes.set(id, makeNode({
+      id,
+      documentId: resolvedDocumentId,
+      parentId: pageParentId,
+      kind: "table",
+      title: `Table ${tableNodeIds.size + 1}`,
+      description: `Table on page ${pageStart(span) ?? "unknown"} for source rows and cells`,
+      sourceSpanIds: [],
+      pageStart: pageStart(span),
+      pageEnd: pageEnd(span),
+      order: order++,
+      metadata: { tableId: idSource, sourceUnit: "table" }
+    }));
+    tableNodeIds.set(idSource, id);
+    return id;
+  };
+  const addStandaloneSpanNode = (span, parentId) => {
+    const kind = normalizeNodeKind(span);
+    if (kind === "page") return;
+    const page = pageStart(span);
+    const title = span.sectionId ?? span.formNumber ?? (kind === "table_cell" && span.table?.columnName ? String(span.table.columnName) : void 0) ?? titleCase(kind);
+    const id = nodeId(resolvedDocumentId, kind, [span.id]);
+    nodes.set(id, makeNode({
+      id,
+      documentId: resolvedDocumentId,
+      parentId,
+      kind,
+      title,
+      description: nodeTextDescription({ kind, title, text: span.text, page, formNumber: span.formNumber }),
+      textExcerpt: truncate(span.text, 1600),
+      sourceSpanIds: [span.id],
+      pageStart: page,
+      pageEnd: pageEnd(span),
+      bbox: span.bbox,
+      order: order++,
+      metadata: {
+        ...span.metadata ?? {},
+        formNumber: span.formNumber,
+        sourceUnit: sourceUnit2(span)
+      }
+    }));
+  };
+  for (const span of orderedSpans) {
+    const page = pageStart(span);
+    const pageParentId = page ? ensurePage(page) : rootId;
+    const kind = normalizeNodeKind(span);
+    if (kind === "page") continue;
+    if (kind === "table_row") {
+      const tableParentId = ensureTable(span, pageParentId);
+      const rowKey = span.id;
+      const id = nodeId(resolvedDocumentId, "table_row", [span.id]);
+      nodes.set(id, makeNode({
+        id,
+        documentId: resolvedDocumentId,
+        parentId: tableParentId,
+        kind,
+        title: span.table?.isHeader ? "Header row" : `Row ${(span.table?.rowIndex ?? 0) + 1}`,
+        description: nodeTextDescription({ kind, title: "Table row", text: span.text, page }),
+        textExcerpt: truncate(span.text, 1600),
+        sourceSpanIds: [span.id],
+        pageStart: page,
+        pageEnd: pageEnd(span),
+        bbox: span.bbox,
+        order: order++,
+        metadata: {
+          ...span.metadata ?? {},
+          ...span.table ?? {},
+          sourceUnit: "table_row"
+        }
+      }));
+      rowNodeIds.set(rowKey, id);
+      continue;
+    }
+    if (kind === "table_cell") {
+      const tableParentId = ensureTable(span, pageParentId);
+      const parentRowId2 = rowSpanId(span);
+      const parentId = parentRowId2 ? rowNodeIds.get(parentRowId2) ?? tableParentId : tableParentId;
+      addStandaloneSpanNode(span, parentId);
+      continue;
+    }
+    addStandaloneSpanNode(span, pageParentId);
+  }
+  return normalizeDocumentSourceTreePaths([...nodes.values()]);
+}
+
+// src/source/operational-profile.ts
+function normalizeWhitespace3(value) {
+  return value.replace(/\s+/g, " ").trim();
+}
+function cleanValue(value) {
+  if (!value) return void 0;
+  return normalizeWhitespace3(value.replace(/^[\s:;#-]+|[\s;,.]+$/g, ""));
+}
+function moneyValue(value) {
+  const clean = cleanValue(value);
+  if (!clean) return void 0;
+  if (/^\$/.test(clean)) return clean;
+  if (/^\d{1,3}(?:,\d{3})*(?:\.\d{2})?$/.test(clean)) return `$${clean}`;
+  return clean;
+}
+function nodeText(node) {
+  return normalizeWhitespace3([
+    node.title,
+    node.description,
+    node.textExcerpt
+  ].filter(Boolean).join(" "));
+}
+function valueFromNode(node, value, confidence = "medium") {
+  return {
+    value,
+    confidence,
+    sourceNodeIds: [node.id],
+    sourceSpanIds: node.sourceSpanIds
+  };
+}
+function firstMatch(nodes, patterns) {
+  for (const node of nodes) {
+    const text = nodeText(node);
+    for (const pattern of patterns) {
+      const match = text.match(pattern);
+      const value = cleanValue(match?.[1]);
+      if (value) return valueFromNode(node, value, "high");
+    }
+  }
+  return void 0;
+}
+function inferPolicyTypes(nodes) {
+  const text = nodes.slice(0, 40).map(nodeText).join(" ").toLowerCase();
+  const types = [];
+  const add = (pattern, type) => {
+    if (pattern.test(text) && !types.includes(type)) types.push(type);
+  };
+  add(/\b(cyber|network security|privacy liability|data breach)\b/i, "cyber");
+  add(/\b(professional liability|errors?\s*&?\s*omissions|e&o)\b/i, "professional_liability");
+  add(/\b(commercial general liability|general liability|cgl)\b/i, "general_liability");
+  add(/\b(umbrella|excess liability)\b/i, "umbrella");
+  add(/\b(workers'? compensation|employers'? liability)\b/i, "workers_comp");
+  add(/\b(commercial auto|business auto|automobile liability)\b/i, "commercial_auto");
+  add(/\b(commercial property|property coverage|building coverage)\b/i, "commercial_property");
+  return types.length ? types : ["other"];
+}
+function inferDocumentType(nodes) {
+  const text = nodes.slice(0, 25).map(nodeText).join(" ").toLowerCase();
+  if (/\b(quote|proposal|quotation|indication)\b/.test(text) && !/\bpolicy number\b/.test(text)) {
+    return "quote";
+  }
+  return "policy";
+}
+function coverageNameFromRow(text) {
+  const labelled = text.match(/\b(?:coverage|coverage part|line)\s*:?\s*([^|;$]{3,80})/i)?.[1];
+  if (labelled) return cleanValue(labelled);
+  const parts = text.split(/\s+\|\s+| {2,}|\t/).map(cleanValue).filter(Boolean);
+  const first = parts.find(
+    (part) => !/^(limit|limits?|deductible|premium|amount|basis|rate|retroactive|aggregate|each occurrence)$/i.test(part) && !/^\$?[\d,]+/.test(part)
+  );
+  return cleanValue(first);
+}
+function limitFromText(text) {
+  return moneyValue(
+    text.match(/\b(?:limit|liability|aggregate|occurrence|claim)\s*:?\s*(\$?\d[\d,]*(?:\.\d{2})?|\$?\d[\d,]*\s*(?:each|per|aggregate)[^|;]*)/i)?.[1] ?? text.match(/(\$\s?\d[\d,]*(?:\.\d{2})?)(?=.*\b(limit|aggregate|occurrence|claim|liability)\b)/i)?.[1]
+  );
+}
+function deductibleFromText(text) {
+  return moneyValue(text.match(/\b(?:deductible|retention|sir)\s*:?\s*(\$?\d[\d,]*(?:\.\d{2})?)/i)?.[1]);
+}
+function premiumFromText(text) {
+  return moneyValue(text.match(/\b(?:premium|total premium|total cost|amount due)\s*:?\s*(\$?\d[\d,]*(?:\.\d{2})?)/i)?.[1]);
+}
+function buildCoverages(nodes) {
+  const rows = nodes.filter((node) => {
+    const text = nodeText(node);
+    return (node.kind === "table_row" || node.kind === "schedule" || node.kind === "text") && /\b(coverage|limit|deductible|aggregate|occurrence|liability|premium)\b/i.test(text);
+  });
+  const coverages = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const row of rows) {
+    const text = nodeText(row);
+    const name = coverageNameFromRow(text);
+    const limit = limitFromText(text);
+    const deductible = deductibleFromText(text);
+    const premium = premiumFromText(text);
+    if (!name || !limit && !deductible && !premium) continue;
+    const key = [name.toLowerCase(), limit, deductible, premium].join("|");
+    if (seen.has(key)) continue;
+    seen.add(key);
+    coverages.push({
+      name,
+      limit,
+      deductible,
+      premium,
+      formNumber: typeof row.metadata?.formNumber === "string" ? row.metadata.formNumber : void 0,
+      sourceNodeIds: [row.id],
+      sourceSpanIds: row.sourceSpanIds
+    });
+    if (coverages.length >= 60) break;
+  }
+  return coverages;
+}
+function buildParties(profile) {
+  const parties = [];
+  if (profile.namedInsured) {
+    parties.push({
+      role: "named_insured",
+      name: profile.namedInsured.value,
+      sourceNodeIds: profile.namedInsured.sourceNodeIds,
+      sourceSpanIds: profile.namedInsured.sourceSpanIds
+    });
+  }
+  if (profile.insurer) {
+    parties.push({
+      role: "insurer",
+      name: profile.insurer.value,
+      sourceNodeIds: profile.insurer.sourceNodeIds,
+      sourceSpanIds: profile.insurer.sourceSpanIds
+    });
+  }
+  if (profile.broker) {
+    parties.push({
+      role: "broker",
+      name: profile.broker.value,
+      sourceNodeIds: profile.broker.sourceNodeIds,
+      sourceSpanIds: profile.broker.sourceSpanIds
+    });
+  }
+  return parties;
+}
+function buildEndorsementSupport(nodes) {
+  const support = [];
+  for (const node of nodes) {
+    const text = nodeText(node);
+    const add = (kind, status) => {
+      if (support.some((item) => item.kind === kind && item.status === status && item.sourceNodeIds.includes(node.id))) {
+        return;
+      }
+      support.push({
+        kind,
+        status,
+        summary: node.textExcerpt ?? node.description,
+        sourceNodeIds: [node.id],
+        sourceSpanIds: node.sourceSpanIds
+      });
+    };
+    if (/additional insured/i.test(text)) add("additional_insured", /not included|requires endorsement|only by endorsement/i.test(text) ? "requires_review" : "supported");
+    if (/waiver of subrogation|subrogation.*waived/i.test(text)) add("waiver_of_subrogation", /not included|requires endorsement|only by endorsement/i.test(text) ? "requires_review" : "supported");
+    if (/primary.*non[-\s]?contributory|non[-\s]?contributory/i.test(text)) add("primary_non_contributory", /not included|requires endorsement|only by endorsement/i.test(text) ? "requires_review" : "supported");
+    if (/loss payee|mortgagee/i.test(text)) add(/mortgagee/i.test(text) ? "mortgagee" : "loss_payee", "supported");
+    if (support.length >= 20) break;
+  }
+  return support;
+}
+function buildDeterministicOperationalProfile(params) {
+  const nodes = params.sourceTree.filter((node) => node.kind !== "document");
+  const partial = {
+    documentType: inferDocumentType(nodes),
+    policyTypes: inferPolicyTypes(nodes),
+    policyNumber: firstMatch(nodes, [
+      /\bpolicy\s*(?:number|no\.?|#)\s*:?\s*([A-Z0-9][A-Z0-9-]{4,})/i,
+      /\bpolicy\s*[:#]\s*([A-Z0-9][A-Z0-9-]{4,})/i
+    ]),
+    namedInsured: firstMatch(nodes, [
+      /\b(?:named insured|insured name|insured)\s*:?\s*(.+?)(?=\s+(?:coverage|policy number|insurer|carrier|premium|effective|expiration)\b|[|;\n]|$)/i,
+      /\b(?:applicant|policyholder)\s*:?\s*(.+?)(?=\s+(?:coverage|policy number|insurer|carrier|premium|effective|expiration)\b|[|;\n]|$)/i
+    ]),
+    insurer: firstMatch(nodes, [
+      /\b(?:insurer|carrier|company|security)\s*:?\s*([^|;\n]{3,120})/i,
+      /\bunderwritten by\s+([^|;\n]{3,120})/i
+    ]),
+    broker: firstMatch(nodes, [
+      /\b(?:broker|producer|agent)\s*:?\s*([^|;\n]{3,120})/i
+    ]),
+    effectiveDate: firstMatch(nodes, [
+      /\b(?:effective date|policy period from|from)\s*:?\s*([0-9]{1,2}[/-][0-9]{1,2}[/-][0-9]{2,4})/i,
+      /\b([0-9]{1,2}[/-][0-9]{1,2}[/-][0-9]{2,4})\s+(?:to|through|-)\s+[0-9]{1,2}[/-][0-9]{1,2}[/-][0-9]{2,4}/i
+    ]),
+    expirationDate: firstMatch(nodes, [
+      /\b(?:expiration date|expiry date|expires|to)\s*:?\s*([0-9]{1,2}[/-][0-9]{1,2}[/-][0-9]{2,4})/i,
+      /\b[0-9]{1,2}[/-][0-9]{1,2}[/-][0-9]{2,4}\s+(?:to|through|-)\s+([0-9]{1,2}[/-][0-9]{1,2}[/-][0-9]{2,4})/i
+    ]),
+    retroactiveDate: firstMatch(nodes, [
+      /\bretroactive date\s*:?\s*([0-9]{1,2}[/-][0-9]{1,2}[/-][0-9]{2,4}|full prior acts|none)/i
+    ]),
+    premium: firstMatch(nodes, [
+      /\b(?:total premium|premium|total cost|amount due)\s*:?\s*(\$?\d[\d,]*(?:\.\d{2})?)/i
+    ])
+  };
+  const coverages = buildCoverages(nodes);
+  const coverageTypes = [...new Set(coverages.map((coverage) => coverage.name))];
+  const sourceNodeIds = [.../* @__PURE__ */ new Set([
+    ...Object.values(partial).flatMap(
+      (value) => value && typeof value === "object" && "sourceNodeIds" in value ? value.sourceNodeIds : []
+    ),
+    ...coverages.flatMap((coverage) => coverage.sourceNodeIds)
+  ])];
+  const sourceSpanIds = [.../* @__PURE__ */ new Set([
+    ...Object.values(partial).flatMap(
+      (value) => value && typeof value === "object" && "sourceSpanIds" in value ? value.sourceSpanIds : []
+    ),
+    ...coverages.flatMap((coverage) => coverage.sourceSpanIds)
+  ])];
+  return PolicyOperationalProfileSchema.parse({
+    ...partial,
+    coverageTypes,
+    coverages,
+    parties: buildParties(partial),
+    endorsementSupport: buildEndorsementSupport(nodes),
+    sourceNodeIds,
+    sourceSpanIds,
+    warnings: [
+      ...coverages.length === 0 ? ["No source-backed coverage schedule rows were identified deterministically."] : [],
+      ...!partial.policyNumber ? ["No source-backed policy number was identified deterministically."] : [],
+      ...!partial.namedInsured ? ["No source-backed named insured was identified deterministically."] : []
+    ]
+  });
+}
+function mergeOperationalProfile(base, candidate, validNodeIds, validSpanIds) {
+  const keepIds = (ids, valid) => Array.isArray(ids) ? ids.filter((id) => typeof id === "string" && valid.has(id)) : [];
+  const mergeValue = (fallback, next) => {
+    if (!next || typeof next !== "object" || Array.isArray(next)) return fallback;
+    const record = next;
+    const value = typeof record.value === "string" ? cleanValue(record.value) : void 0;
+    if (!value) return fallback;
+    const sourceNodeIds = keepIds(record.sourceNodeIds, validNodeIds);
+    const sourceSpanIds = keepIds(record.sourceSpanIds, validSpanIds);
+    if (sourceNodeIds.length === 0 && sourceSpanIds.length === 0) return fallback;
+    return {
+      value,
+      normalizedValue: typeof record.normalizedValue === "string" ? record.normalizedValue : fallback?.normalizedValue,
+      confidence: record.confidence === "high" || record.confidence === "low" || record.confidence === "medium" ? record.confidence : "medium",
+      sourceNodeIds,
+      sourceSpanIds
+    };
+  };
+  const coverages = Array.isArray(candidate.coverages) ? candidate.coverages.map((coverage) => ({
+    ...coverage,
+    sourceNodeIds: keepIds(coverage.sourceNodeIds, validNodeIds),
+    sourceSpanIds: keepIds(coverage.sourceSpanIds, validSpanIds)
+  })).filter((coverage) => coverage.name && (coverage.sourceNodeIds.length > 0 || coverage.sourceSpanIds.length > 0)) : base.coverages;
+  return PolicyOperationalProfileSchema.parse({
+    ...base,
+    documentType: candidate.documentType === "quote" ? "quote" : candidate.documentType === "policy" ? "policy" : base.documentType,
+    policyTypes: Array.isArray(candidate.policyTypes) && candidate.policyTypes.length > 0 ? candidate.policyTypes : base.policyTypes,
+    policyNumber: mergeValue(base.policyNumber, candidate.policyNumber),
+    namedInsured: mergeValue(base.namedInsured, candidate.namedInsured),
+    insurer: mergeValue(base.insurer, candidate.insurer),
+    broker: mergeValue(base.broker, candidate.broker),
+    effectiveDate: mergeValue(base.effectiveDate, candidate.effectiveDate),
+    expirationDate: mergeValue(base.expirationDate, candidate.expirationDate),
+    retroactiveDate: mergeValue(base.retroactiveDate, candidate.retroactiveDate),
+    premium: mergeValue(base.premium, candidate.premium),
+    coverageTypes: Array.isArray(candidate.coverageTypes) && candidate.coverageTypes.length > 0 ? candidate.coverageTypes : base.coverageTypes,
+    coverages,
+    parties: base.parties,
+    endorsementSupport: base.endorsementSupport,
+    sourceNodeIds: [.../* @__PURE__ */ new Set([...base.sourceNodeIds, ...keepIds(candidate.sourceNodeIds, validNodeIds)])],
+    sourceSpanIds: [.../* @__PURE__ */ new Set([...base.sourceSpanIds, ...keepIds(candidate.sourceSpanIds, validSpanIds)])],
+    warnings: base.warnings
+  });
+}
+
 // src/extraction/pdf.ts
 import {
   PDFDocument,
@@ -2670,15 +3361,15 @@ function normalizeItem(ref, item) {
   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;
+  const pageStart2 = pages.length ? Math.min(...pages) : void 0;
+  const pageEnd2 = pages.length ? Math.max(...pages) : pageStart2;
   const bboxes = (item.prov ?? []).map((prov) => toSourceSpanBBox(prov)).filter((bbox) => Boolean(bbox));
   return {
     ref,
     label: typeof item.label === "string" ? item.label : void 0,
     text,
-    pageStart,
-    pageEnd,
+    pageStart: pageStart2,
+    pageEnd: pageEnd2,
     bboxes: bboxes.length ? bboxes : void 0,
     table
   };
@@ -2690,7 +3381,7 @@ function buildSourceSpansForUnit(unit, index, options) {
     doclingRef: unit.ref,
     ...unit.label ? { doclingLabel: unit.label } : {}
   };
-  const tableId = unit.table ? `${unit.ref}:table` : void 0;
+  const tableId2 = unit.table ? `${unit.ref}:table` : void 0;
   const tableSpan = withDoclingKind(buildSourceSpan(
     {
       documentId: options.documentId,
@@ -2700,7 +3391,7 @@ function buildSourceSpansForUnit(unit, index, options) {
       pageEnd: unit.pageEnd,
       sectionId: unit.label,
       sourceUnit: unit.table ? "table" : labelToSourceUnit(unit.label),
-      table: tableId ? { tableId } : void 0,
+      table: tableId2 ? { tableId: tableId2 } : void 0,
       metadata: baseMetadata
     },
     index * 1e3
@@ -2724,7 +3415,7 @@ function buildSourceSpansForUnit(unit, index, options) {
         sourceUnit: "table_row",
         parentSpanId: tableSpan.id,
         table: {
-          tableId,
+          tableId: tableId2,
           tableSpanId: tableSpan.id,
           rowIndex,
           isHeader
@@ -2732,7 +3423,7 @@ function buildSourceSpansForUnit(unit, index, options) {
         metadata: {
           ...baseMetadata,
           sourceUnit: "table_row",
-          tableId: tableId ?? "",
+          tableId: tableId2 ?? "",
           tableSpanId: tableSpan.id,
           rowIndex: String(rowIndex),
           isHeader: String(isHeader)
@@ -2756,7 +3447,7 @@ function buildSourceSpansForUnit(unit, index, options) {
           sourceUnit: "table_cell",
           parentSpanId: rowSpan.id,
           table: {
-            tableId,
+            tableId: tableId2,
             tableSpanId: tableSpan.id,
             rowSpanId: rowSpan.id,
             rowIndex,
@@ -2767,7 +3458,7 @@ function buildSourceSpansForUnit(unit, index, options) {
           metadata: {
             ...baseMetadata,
             sourceUnit: "table_cell",
-            tableId: tableId ?? "",
+            tableId: tableId2 ?? "",
             tableSpanId: tableSpan.id,
             rowSpanId: rowSpan.id,
             rowIndex: String(rowIndex),
@@ -2922,7 +3613,7 @@ function buildSourceContext(spans, maxChars = 12e3) {
   const lines = [];
   let length = 0;
   for (const span of orderSourceSpansForContext(spans)) {
-    const unit = sourceUnit2(span);
+    const unit = sourceUnit3(span);
     const table = span.table;
     const tableContext = [
       unit ? ` unit:${unit}` : "",
@@ -2946,11 +3637,11 @@ ${lines.join("\n\n")}
 
 Use sourceSpan IDs when grounding extracted contractual values.`;
 }
-function sourceUnit2(span) {
+function sourceUnit3(span) {
   return span.sourceUnit ?? span.metadata?.sourceUnit;
 }
 function sourceContextRank(span) {
-  switch (sourceUnit2(span)) {
+  switch (sourceUnit3(span)) {
     case "table_row":
       return 0;
     case "table":
@@ -2969,10 +3660,10 @@ function sourceContextRank(span) {
 }
 function orderSourceSpansForContext(spans) {
   const parentRows = new Set(
-    spans.filter((span) => sourceUnit2(span) === "table_row").map((span) => span.id)
+    spans.filter((span) => sourceUnit3(span) === "table_row").map((span) => span.id)
   );
   const filtered = spans.filter((span) => {
-    if (sourceUnit2(span) !== "table_cell") return true;
+    if (sourceUnit3(span) !== "table_cell") return true;
     const parent = span.parentSpanId ?? span.table?.rowSpanId ?? span.metadata?.rowSpanId;
     return !parent || !parentRows.has(parent);
   });
@@ -3279,6 +3970,8 @@ function assembleDocument(documentId, documentType, memory) {
     carrier: readRecordValue(carrier, "carrierName") ?? "Unknown",
     insuredName: readRecordValue(insured, "insuredName") ?? "Unknown",
     coverages: coverageRecords,
+    documentMetadata: {},
+    documentOutline: [],
     policyTypes: readRecordValue(classify, "policyTypes"),
     ...sanitizeNulls(carrier ?? {}),
     ...sanitizeNulls(insured ?? {}),
@@ -3330,6 +4023,247 @@ function assembleDocument(documentId, documentType, memory) {
   return doc;
 }
 
+// src/extraction/document-structure.ts
+var FACT_ARRAY_PATHS = [
+  "coverages",
+  "enrichedCoverages",
+  "endorsements",
+  "exclusions",
+  "conditions",
+  "definitions",
+  "coveredReasons",
+  "taxesAndFees",
+  "premiumBreakdown",
+  "supplementaryFacts"
+];
+function slugPart(value) {
+  const text = String(value ?? "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  return text || "node";
+}
+function numberValue(record, ...keys) {
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "number" && Number.isFinite(value)) return value;
+  }
+  return void 0;
+}
+function stringValue2(record, ...keys) {
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "string" && value.trim()) return value.trim();
+  }
+  return void 0;
+}
+function stringArray(value) {
+  return Array.isArray(value) ? value.filter((item) => typeof item === "string" && item.length > 0) : [];
+}
+function sourceUnit4(span) {
+  return span.sourceUnit ?? span.metadata?.sourceUnit;
+}
+function spanPage(span) {
+  return span.pageStart ?? span.location?.page ?? span.location?.startPage;
+}
+function spanPageEnd(span) {
+  return span.pageEnd ?? span.location?.endPage ?? spanPage(span);
+}
+function sourceSpansForPage(sourceSpans, page) {
+  return sourceSpans.filter((span) => spanPage(span) === page && sourceUnit4(span) === "page").map((span) => span.id);
+}
+function nodePageOverlaps(node, record) {
+  const recordStart = numberValue(record, "pageNumber", "pageStart", "resolvedFromPage");
+  const recordEnd = numberValue(record, "pageNumber", "pageEnd", "resolvedFromPage") ?? recordStart;
+  if (!recordStart) return false;
+  const nodeStart = node.pageStart ?? node.pageEnd;
+  const nodeEnd = node.pageEnd ?? node.pageStart;
+  if (!nodeStart) return false;
+  return recordStart <= (nodeEnd ?? nodeStart) && (recordEnd ?? recordStart) >= nodeStart;
+}
+function nodeFormMatches(node, record) {
+  const formNumber = stringValue2(record, "formNumber");
+  return Boolean(formNumber && node.formNumber && formNumber.toLowerCase() === node.formNumber.toLowerCase());
+}
+function nodeSourceOverlaps(node, record) {
+  const nodeSourceIds = new Set(node.sourceSpanIds ?? []);
+  if (nodeSourceIds.size === 0) return false;
+  return stringArray(record.sourceSpanIds).some((id) => nodeSourceIds.has(id));
+}
+function findBestNode(nodes, record) {
+  let best;
+  const visit = (node) => {
+    let score = 0;
+    if (nodeSourceOverlaps(node, record)) score += 8;
+    if (nodeFormMatches(node, record)) score += 4;
+    if (nodePageOverlaps(node, record)) score += 3;
+    if (score > 0 && (!best || score > best.score)) {
+      best = { node, score };
+    }
+    for (const child of node.children ?? []) visit(child);
+  };
+  for (const node of nodes) visit(node);
+  return best?.node;
+}
+function attachDocumentNodeIds(document, nodes) {
+  const doc = document;
+  for (const path of FACT_ARRAY_PATHS) {
+    const value = doc[path];
+    if (!Array.isArray(value)) continue;
+    doc[path] = value.map((item) => {
+      if (!item || typeof item !== "object" || Array.isArray(item)) return item;
+      const record = item;
+      if (typeof record.documentNodeId === "string" && record.documentNodeId.length > 0) return record;
+      const node = findBestNode(nodes, record);
+      return node ? { ...record, documentNodeId: node.id } : record;
+    });
+  }
+}
+function buildNodeFromSection(section, index) {
+  const title = stringValue2(section, "title", "name", "sectionRef") ?? `Section ${index + 1}`;
+  const id = stringValue2(section, "documentNodeId", "recordId") ?? `section:${index}:${slugPart(title)}`;
+  const pageStart2 = numberValue(section, "pageStart", "pageNumber");
+  const pageEnd2 = numberValue(section, "pageEnd", "pageNumber") ?? pageStart2;
+  const type = stringValue2(section, "type");
+  const coverageType = stringValue2(section, "coverageType");
+  const sourceSpanIds = stringArray(section.sourceSpanIds);
+  const children = Array.isArray(section.subsections) ? section.subsections.filter((item) => Boolean(item) && typeof item === "object" && !Array.isArray(item)).map((subsection, childIndex) => {
+    const childTitle = stringValue2(subsection, "title", "name") ?? `${title} ${childIndex + 1}`;
+    const childId = stringValue2(subsection, "documentNodeId", "recordId") ?? `${id}:subsection:${childIndex}:${slugPart(childTitle)}`;
+    return {
+      id: childId,
+      title: childTitle,
+      originalTitle: childTitle,
+      type,
+      label: type,
+      level: 2,
+      sectionNumber: stringValue2(subsection, "sectionNumber"),
+      pageStart: numberValue(subsection, "pageNumber") ?? pageStart2,
+      pageEnd: numberValue(subsection, "pageNumber") ?? pageStart2,
+      excerpt: stringValue2(subsection, "excerpt"),
+      content: stringValue2(subsection, "content"),
+      sourceSpanIds: stringArray(subsection.sourceSpanIds),
+      sourceTextHash: stringValue2(subsection, "sourceTextHash")
+    };
+  }) : void 0;
+  return {
+    id,
+    title,
+    originalTitle: title,
+    type,
+    label: type,
+    level: 1,
+    sectionNumber: stringValue2(section, "sectionNumber"),
+    pageStart: pageStart2,
+    pageEnd: pageEnd2,
+    formNumber: stringValue2(section, "formNumber"),
+    formTitle: stringValue2(section, "formTitle"),
+    excerpt: stringValue2(section, "excerpt"),
+    content: stringValue2(section, "content"),
+    interpretationLabels: [type, coverageType].filter((value) => Boolean(value)),
+    sourceSpanIds: sourceSpanIds.length > 0 ? sourceSpanIds : void 0,
+    sourceTextHash: stringValue2(section, "sourceTextHash"),
+    children: children && children.length > 0 ? children : void 0
+  };
+}
+function buildNodesFromSourceSpans(sourceSpans) {
+  const candidates = sourceSpans.filter((span) => {
+    const unit = sourceUnit4(span);
+    return unit === "section" || unit === "section_candidate" || unit === "page";
+  });
+  return candidates.sort((left, right) => (spanPage(left) ?? 0) - (spanPage(right) ?? 0) || left.id.localeCompare(right.id)).map((span, index) => {
+    const title = span.sectionId ?? span.formNumber ?? (sourceUnit4(span) === "page" && spanPage(span) ? `Page ${spanPage(span)}` : `Source unit ${index + 1}`);
+    return {
+      id: `source:${index}:${slugPart(span.id)}`,
+      title,
+      originalTitle: title,
+      type: sourceUnit4(span),
+      label: sourceUnit4(span),
+      level: 1,
+      pageStart: spanPage(span),
+      pageEnd: spanPageEnd(span),
+      formNumber: span.formNumber,
+      excerpt: span.text.slice(0, 500),
+      sourceSpanIds: [span.id],
+      sourceTextHash: span.textHash ?? span.hash
+    };
+  });
+}
+function flattenToc(nodes) {
+  const entries = [];
+  const visit = (node) => {
+    entries.push({
+      title: node.title,
+      level: node.level,
+      pageStart: node.pageStart,
+      pageEnd: node.pageEnd,
+      documentNodeId: node.id,
+      sourceSpanIds: node.sourceSpanIds
+    });
+    for (const child of node.children ?? []) visit(child);
+  };
+  for (const node of nodes) visit(node);
+  return entries;
+}
+function buildPageMap(pageAssignments, sourceSpans, document) {
+  const forms = document.formInventory ?? [];
+  return pageAssignments.sort((left, right) => left.localPageNumber - right.localPageNumber).map((assignment) => {
+    const form = forms.find((item) => {
+      const start = item.pageStart;
+      const end = item.pageEnd ?? start;
+      return start != null && end != null && assignment.localPageNumber >= start && assignment.localPageNumber <= end;
+    });
+    return {
+      page: assignment.localPageNumber,
+      label: assignment.notes,
+      formNumber: form?.formNumber,
+      formTitle: form?.title,
+      extractorNames: assignment.extractorNames,
+      sourceSpanIds: sourceSpansForPage(sourceSpans, assignment.localPageNumber)
+    };
+  });
+}
+function buildAgentGuidance(document) {
+  const guidance = [
+    {
+      kind: "source_structure",
+      title: "Use the source outline as navigation",
+      detail: "The documentOutline preserves source order and page ranges. Treat interpretation labels as hints, not as a replacement for the source document structure."
+    }
+  ];
+  if (document.declarations) {
+    guidance.push({
+      kind: "declarations",
+      title: "Declarations establish policy facts",
+      detail: "Declarations and schedules generally establish named insured, policy period, limits, deductibles, premium, and rating facts unless modified elsewhere."
+    });
+  }
+  if (document.endorsements?.length || document.formInventory?.some((form) => form.formType === "endorsement")) {
+    guidance.push({
+      kind: "endorsement_override",
+      title: "Endorsements may override base terms",
+      detail: "Endorsements and change forms can add, remove, or override base policy wording. When terms conflict, inspect the effective endorsement language and source page."
+    });
+  }
+  return guidance;
+}
+function attachDocumentStructure(params) {
+  const docRecord = params.document;
+  const sections = Array.isArray(params.document.sections) ? params.document.sections : [];
+  const existingOutline = Array.isArray(docRecord.documentOutline) ? docRecord.documentOutline : [];
+  const documentOutline = existingOutline.length > 0 ? existingOutline : sections.length > 0 ? sections.map((section, index) => buildNodeFromSection(section, index)) : buildNodesFromSourceSpans(params.sourceSpans);
+  if (documentOutline.length > 0) {
+    attachDocumentNodeIds(params.document, documentOutline);
+  }
+  const metadata = {
+    ...docRecord.documentMetadata && typeof docRecord.documentMetadata === "object" ? docRecord.documentMetadata : {},
+    ...params.document.formInventory?.length ? { formInventory: params.document.formInventory } : {},
+    ...documentOutline.length > 0 ? { tableOfContents: flattenToc(documentOutline) } : {},
+    ...params.pageAssignments.length > 0 ? { pageMap: buildPageMap(params.pageAssignments, params.sourceSpans, params.document) } : {},
+    agentGuidance: buildAgentGuidance(params.document)
+  };
+  docRecord.documentMetadata = metadata;
+  docRecord.documentOutline = documentOutline;
+  return params.document;
+}
+
 // src/prompts/coordinator/format.ts
 function buildFormatPrompt(entries) {
   const block = entries.map((e) => `===ENTRY ${e.id}===
@@ -3929,6 +4863,8 @@ function chunkDocument(doc) {
       {
         formNumber: form.formNumber,
         formType: form.formType,
+        documentNodeId: form.documentNodeId,
+        sourceSpanIds: form.sourceSpanIds?.join(","),
         documentType: doc.type
       }
     );
@@ -3955,6 +4891,7 @@ function chunkDocument(doc) {
         formNumber: end.formNumber,
         pageStart: end.pageStart,
         pageEnd: end.pageEnd,
+        documentNodeId: end.documentNodeId,
         sourceSpanIds: end.sourceSpanIds?.join(","),
         sourceTextHash: end.sourceTextHash,
         documentType: doc.type
@@ -3966,6 +4903,8 @@ function chunkDocument(doc) {
 ${exc.content}`.trim(), {
       formNumber: exc.formNumber,
       pageNumber: exc.pageNumber,
+      documentNodeId: exc.documentNodeId,
+      sourceSpanIds: exc.sourceSpanIds?.join(","),
       documentType: doc.type
     });
   });
@@ -3983,6 +4922,8 @@ ${exc.content}`.trim(), {
         conditionName: cond.name,
         conditionType: cond.conditionType,
         pageNumber: cond.pageNumber,
+        documentNodeId: cond.documentNodeId,
+        sourceSpanIds: cond.sourceSpanIds?.join(","),
         documentType: doc.type
       }
     );
@@ -4004,6 +4945,9 @@ ${exc.content}`.trim(), {
         formTitle: firstString2(definition, ["formTitle"]),
         pageNumber: typeof definition.pageNumber === "number" ? definition.pageNumber : void 0,
         sectionRef: firstString2(definition, ["sectionRef", "sectionTitle"]),
+        documentNodeId: firstString2(definition, ["documentNodeId"]),
+        sourceSpanIds: Array.isArray(definition.sourceSpanIds) ? definition.sourceSpanIds.join(",") : void 0,
+        sourceTextHash: firstString2(definition, ["sourceTextHash"]),
         documentType: doc.type
       }
     );
@@ -4032,6 +4976,9 @@ ${exc.content}`.trim(), {
         formTitle: firstString2(coveredReason, ["formTitle"]),
         pageNumber: typeof coveredReason.pageNumber === "number" ? coveredReason.pageNumber : void 0,
         sectionRef: firstString2(coveredReason, ["sectionRef", "sectionTitle"]),
+        documentNodeId: firstString2(coveredReason, ["documentNodeId"]),
+        sourceSpanIds: Array.isArray(coveredReason.sourceSpanIds) ? coveredReason.sourceSpanIds.join(",") : void 0,
+        sourceTextHash: firstString2(coveredReason, ["sourceTextHash"]),
         documentType: doc.type
       }
     );
@@ -4093,6 +5040,7 @@ ${declLines.join("\n")}`, declMeta);
         evidenceKind: "navigation",
         sectionType: sec.type,
         sectionNumber: sec.sectionNumber,
+        documentNodeId: sec.documentNodeId,
         pageStart: sec.pageStart,
         pageEnd: sec.pageEnd,
         sourceSpanIds: sec.sourceSpanIds?.join(","),
@@ -4116,6 +5064,7 @@ ${declLines.join("\n")}`, declMeta);
           sectionType: sec.type,
           parentSection: sec.title,
           sectionNumber: sub.sectionNumber,
+          documentNodeId: sub.documentNodeId,
           pageNumber: sub.pageNumber,
           sourceSpanIds: sub.sourceSpanIds?.join(","),
           sourceTextHash: sub.sourceTextHash,
@@ -4124,6 +5073,31 @@ ${declLines.join("\n")}`, declMeta);
       );
     });
   });
+  asRecordArray(extendedDoc.documentOutline).forEach((node, i) => {
+    const title = firstString2(node, ["title", "originalTitle"]) ?? `Document Node ${i + 1}`;
+    const children = asRecordArray(node.children);
+    pushChunk(
+      `section:outline:${i}`,
+      "section",
+      lines([
+        `Document Outline: ${title}`,
+        firstString2(node, ["label", "type"]) ? `Label: ${firstString2(node, ["label", "type"])}` : null,
+        typeof node.pageStart === "number" ? `Pages: ${node.pageStart}${typeof node.pageEnd === "number" ? `-${node.pageEnd}` : ""}` : null,
+        firstString2(node, ["excerpt", "content"]),
+        children.length > 0 ? `Children: ${children.map((child, childIndex) => firstString2(child, ["title", "originalTitle"]) ?? `Child ${childIndex + 1}`).join(", ")}` : null
+      ]),
+      {
+        evidenceKind: "navigation",
+        documentNodeId: firstString2(node, ["id"]),
+        sectionType: firstString2(node, ["type", "label"]),
+        pageStart: typeof node.pageStart === "number" ? node.pageStart : void 0,
+        pageEnd: typeof node.pageEnd === "number" ? node.pageEnd : void 0,
+        sourceSpanIds: Array.isArray(node.sourceSpanIds) ? node.sourceSpanIds.join(",") : void 0,
+        sourceTextHash: firstString2(node, ["sourceTextHash"]),
+        documentType: doc.type
+      }
+    );
+  });
   doc.locations?.forEach((loc, i) => {
     chunks.push({
       id: `${docId}:location:${i}`,
@@ -6947,13 +7921,13 @@ async function resolveReferentialCoverages(params) {
 function textValue(value) {
   return typeof value === "string" && value.trim() ? value.trim() : void 0;
 }
-function numberValue(value) {
+function numberValue2(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) {
+function sourceUnit5(span) {
   return span.sourceUnit ?? span.metadata?.sourceUnit;
 }
 function pageNumber(span) {
@@ -7023,7 +7997,7 @@ function firstField(fields, patterns) {
 }
 function coverageFromRow(span) {
   const rowText = span.text.trim();
-  if (!rowText || sourceUnit3(span) !== "table_row") return void 0;
+  if (!rowText || sourceUnit5(span) !== "table_row") return void 0;
   if (span.table?.isHeader || span.metadata?.isHeader === "true") return void 0;
   const fields = splitRowFields(rowText);
   let name;
@@ -7085,7 +8059,7 @@ function coverageKey(coverage) {
     textValue(coverage.name) ?? "",
     textValue(coverage.limit) ?? "",
     textValue(coverage.limitType) ?? "",
-    numberValue(coverage.pageNumber) ?? ""
+    numberValue2(coverage.pageNumber) ?? ""
   ].map((part) => normalize(String(part))).join("|");
 }
 function rowMatchesExisting(row, existing) {
@@ -7103,7 +8077,7 @@ 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 candidates = params.sourceSpans.filter((span) => sourceUnit5(span) === "table_row").filter((span) => {
     const page = pageNumber(span);
     return page !== void 0 && pages.has(page);
   }).map(coverageFromRow).filter((coverage) => Boolean(coverage));
@@ -7739,13 +8713,13 @@ function buildPlanFromPageAssignments(pageAssignments, pageCount, formInventory)
     const expanded = new Set(pages);
     for (const page of pages) {
       for (const form of contextualForms) {
-        const pageStart = form.pageStart;
-        const pageEnd = form.pageEnd ?? form.pageStart;
+        const pageStart2 = form.pageStart;
+        const pageEnd2 = form.pageEnd ?? form.pageStart;
         const formType = form.formType;
         const supportsContextualExpansion = extractorName === "endorsements" ? formType === "endorsement" : formType === "coverage" || formType === "endorsement";
         if (!supportsContextualExpansion) continue;
-        if (page < pageStart || page > pageEnd) continue;
-        for (let current = pageStart; current <= pageEnd; current += 1) {
+        if (page < pageStart2 || page > pageEnd2) continue;
+        for (let current = pageStart2; current <= pageEnd2; current += 1) {
           expanded.add(current);
         }
       }
@@ -7778,7 +8752,10 @@ var ARRAY_PATHS = [
   { memoryKey: "sections", arrayKeys: ["sections"] },
   { memoryKey: "definitions", arrayKeys: ["definitions"] },
   { memoryKey: "covered_reasons", arrayKeys: ["coveredReasons", "covered_reasons"] },
-  { memoryKey: "declarations", arrayKeys: ["fields"] }
+  { memoryKey: "declarations", arrayKeys: ["fields"] },
+  { memoryKey: "premium_breakdown", arrayKeys: ["premiumBreakdown", "taxesAndFees"] },
+  { memoryKey: "supplementary", arrayKeys: ["auxiliaryFacts", "supplementaryFacts"] },
+  { memoryKey: "form_inventory", arrayKeys: ["forms"] }
 ];
 function normalize2(value) {
   return value.replace(/\s+/g, " ").trim().toLowerCase();
@@ -7790,7 +8767,7 @@ function textValue2(record, ...keys) {
   }
   return void 0;
 }
-function numberValue2(record, ...keys) {
+function numberValue3(record, ...keys) {
   for (const key of keys) {
     const value = record[key];
     if (typeof value === "number" && Number.isFinite(value)) return value;
@@ -7823,11 +8800,11 @@ function textMatches(record, span) {
 function sourceHashFor(spans) {
   return spans.map((span) => span.textHash ?? span.hash).filter(Boolean).join(":") || void 0;
 }
-function sourceUnit4(span) {
+function sourceUnit6(span) {
   return span.sourceUnit ?? span.metadata?.sourceUnit;
 }
 function hierarchyScore(span) {
-  switch (sourceUnit4(span)) {
+  switch (sourceUnit6(span)) {
     case "table_row":
       return 5;
     case "table":
@@ -7850,8 +8827,8 @@ function preferParentRows(matches, sourceSpans) {
   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;
+    const parent = sourceUnit6(match) === "table_cell" ? byId.get(parentRowId(match) ?? "") : void 0;
+    const preferred = parent && sourceUnit6(parent) === "table_row" ? parent : match;
     if (seen.has(preferred.id)) continue;
     seen.add(preferred.id);
     expanded.push(preferred);
@@ -7860,11 +8837,11 @@ function preferParentRows(matches, sourceSpans) {
 }
 function findSourceSpansForRecord(record, sourceSpans) {
   if (sourceSpans.length === 0) return [];
-  const pageStart = numberValue2(record, "pageNumber", "pageStart");
-  const pageEnd = numberValue2(record, "pageNumber", "pageEnd");
+  const pageStart2 = numberValue3(record, "pageNumber", "pageStart");
+  const pageEnd2 = numberValue3(record, "pageNumber", "pageEnd");
   const scored = sourceSpans.map((span) => {
     let score = 0;
-    if (pageOverlaps(pageStart, pageEnd, span)) score += 4;
+    if (pageOverlaps(pageStart2, pageEnd2, span)) score += 4;
     if (formMatches(record, span)) score += 3;
     if (textMatches(record, span)) score += 2;
     if (score > 0) score += hierarchyScore(span);
@@ -7903,6 +8880,422 @@ function groundExtractionMemoryWithSourceSpans(memory, sourceSpans) {
   }
 }
 
+// src/extraction/source-tree-extractor.ts
+import { z as z41 } from "zod";
+var ORGANIZABLE_KINDS = [
+  "page_group",
+  "form",
+  "endorsement",
+  "section",
+  "schedule",
+  "clause"
+];
+var SourceTreeOrganizationSchema = z41.object({
+  labels: z41.array(z41.object({
+    nodeId: z41.string(),
+    kind: z41.enum([
+      "document",
+      "page_group",
+      "page",
+      "form",
+      "endorsement",
+      "section",
+      "schedule",
+      "clause",
+      "table",
+      "table_row",
+      "table_cell",
+      "text"
+    ]).optional(),
+    title: z41.string().optional(),
+    description: z41.string().optional()
+  })).default([]),
+  groups: z41.array(z41.object({
+    kind: z41.enum(ORGANIZABLE_KINDS),
+    title: z41.string(),
+    description: z41.string().optional(),
+    childNodeIds: z41.array(z41.string()).min(1)
+  })).default([])
+});
+var SourceBackedValueForPromptSchema = z41.object({
+  value: z41.string(),
+  normalizedValue: z41.string().optional(),
+  confidence: z41.enum(["low", "medium", "high"]).optional(),
+  sourceNodeIds: z41.array(z41.string()).default([]),
+  sourceSpanIds: z41.array(z41.string()).default([])
+});
+var OperationalProfilePromptSchema = z41.object({
+  documentType: z41.enum(["policy", "quote"]).optional(),
+  policyTypes: z41.array(z41.string()).optional(),
+  policyNumber: SourceBackedValueForPromptSchema.optional(),
+  namedInsured: SourceBackedValueForPromptSchema.optional(),
+  insurer: SourceBackedValueForPromptSchema.optional(),
+  broker: SourceBackedValueForPromptSchema.optional(),
+  effectiveDate: SourceBackedValueForPromptSchema.optional(),
+  expirationDate: SourceBackedValueForPromptSchema.optional(),
+  retroactiveDate: SourceBackedValueForPromptSchema.optional(),
+  premium: SourceBackedValueForPromptSchema.optional(),
+  coverageTypes: z41.array(z41.string()).optional(),
+  coverages: z41.array(z41.object({
+    name: z41.string(),
+    coverageCode: z41.string().optional(),
+    limit: z41.string().optional(),
+    deductible: z41.string().optional(),
+    premium: z41.string().optional(),
+    formNumber: z41.string().optional(),
+    sectionRef: z41.string().optional(),
+    sourceNodeIds: z41.array(z41.string()).default([]),
+    sourceSpanIds: z41.array(z41.string()).default([])
+  })).optional(),
+  sourceNodeIds: z41.array(z41.string()).optional(),
+  sourceSpanIds: z41.array(z41.string()).optional()
+});
+function cleanText(value, fallback) {
+  const text = value?.replace(/\s+/g, " ").trim();
+  return text || fallback;
+}
+function compactNode(node) {
+  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, 700)
+  };
+}
+function buildOrganizationPrompt(sourceTree) {
+  const nodes = sourceTree.filter((node) => node.kind !== "table_cell").slice(0, 180).map(compactNode);
+  return `You organize an insurance document source tree.
+
+Rules:
+- Use only node IDs from the provided list.
+- Do not invent text, page numbers, source spans, limits, or policy facts.
+- You may relabel existing nodes and group adjacent top-level/page nodes when they are clearly one form, endorsement, declarations set, schedule, or clause family.
+- Groups must list existing childNodeIds only.
+- Keep descriptions short and useful for search.
+
+Source nodes:
+${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);
+  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:
+- policy number, named insured, insurer/carrier/security, broker/producer, policy period, retroactive date, premium
+- coverage lines with limits, deductibles, premiums, and form references
+- coverage type labels
+
+Rules:
+- Every returned value must include sourceNodeIds or sourceSpanIds from the provided nodes.
+- If a value is not directly supported, omit it.
+- Prefer declarations, schedules, premium tables, and endorsement schedules over generic policy wording.
+- Do not copy entire policy wording into fields.
+
+Deterministic baseline:
+${JSON.stringify(fallback, null, 2)}
+
+Source nodes:
+${JSON.stringify(nodes, null, 2)}
+
+Return JSON for the operational profile.`;
+}
+function groupNodeId(documentId, group) {
+  return [
+    documentId.replace(/[^a-zA-Z0-9_.:-]/g, "_"),
+    "source_node",
+    group.kind,
+    group.childNodeIds.join("_").replace(/[^a-zA-Z0-9_.:-]/g, "_").slice(0, 80)
+  ].join(":");
+}
+function applyOrganization(sourceTree, organization) {
+  const byId = new Map(sourceTree.map((node) => [node.id, node]));
+  let nextTree = sourceTree.map((node) => {
+    const label = organization.labels.find((item) => item.nodeId === node.id);
+    if (!label) return node;
+    return {
+      ...node,
+      kind: label.kind ?? node.kind,
+      title: cleanText(label.title, node.title),
+      description: cleanText(label.description, node.description)
+    };
+  });
+  for (const group of organization.groups.slice(0, 40)) {
+    const children = group.childNodeIds.map((id2) => byId.get(id2)).filter((node2) => Boolean(node2));
+    if (children.length === 0) continue;
+    const parentId = children[0].parentId;
+    if (!children.every((child) => child.parentId === parentId)) continue;
+    const documentId = children[0].documentId;
+    const id = groupNodeId(documentId, group);
+    if (byId.has(id)) continue;
+    const sourceSpanIds = [...new Set(children.flatMap((child) => child.sourceSpanIds))];
+    const pageStarts = children.map((child) => child.pageStart).filter((page) => typeof page === "number");
+    const pageEnds = children.map((child) => child.pageEnd ?? child.pageStart).filter((page) => typeof page === "number");
+    const order = Math.min(...children.map((child) => child.order));
+    const node = {
+      id,
+      documentId,
+      parentId,
+      kind: group.kind,
+      title: group.title,
+      description: group.description ?? group.title,
+      textExcerpt: children.map((child) => child.textExcerpt ?? child.description).filter(Boolean).join("\n\n").slice(0, 1600),
+      sourceSpanIds,
+      pageStart: pageStarts.length ? Math.min(...pageStarts) : void 0,
+      pageEnd: pageEnds.length ? Math.max(...pageEnds) : void 0,
+      bbox: children.flatMap((child) => child.bbox ?? []).slice(0, 12),
+      order,
+      path: "",
+      metadata: { sourceTreeVersion: "v3", organizer: "llm_group" }
+    };
+    nextTree = [
+      ...nextTree.map(
+        (child) => group.childNodeIds.includes(child.id) ? { ...child, parentId: id, order: child.order + 1e-3 } : child
+      ),
+      node
+    ];
+    byId.set(id, node);
+  }
+  return normalizeDocumentSourceTreePaths(nextTree);
+}
+function sourceTreeToOutline(sourceTree) {
+  const byParent = /* @__PURE__ */ new Map();
+  for (const node of sourceTree.filter((item) => item.kind !== "document")) {
+    const group = byParent.get(node.parentId) ?? [];
+    group.push(node);
+    byParent.set(node.parentId, group);
+  }
+  const root = sourceTree.find((node) => node.kind === "document");
+  const visit = (node) => ({
+    id: node.id,
+    title: node.title,
+    type: node.kind,
+    label: node.kind,
+    pageStart: node.pageStart,
+    pageEnd: node.pageEnd,
+    excerpt: node.textExcerpt,
+    content: node.textExcerpt,
+    sourceSpanIds: node.sourceSpanIds,
+    sourceTextHash: node.sourceSpanIds.join(":") || void 0,
+    interpretationLabels: [node.kind],
+    children: (byParent.get(node.id) ?? []).map(visit)
+  });
+  return (byParent.get(root?.id) ?? []).map(visit);
+}
+function valueOf(profile, key) {
+  const value = profile[key];
+  return value && typeof value === "object" && !Array.isArray(value) && "value" in value ? String(value.value) : void 0;
+}
+function materializeDocument(params) {
+  const profile = params.operationalProfile;
+  const policyNumber = valueOf(profile, "policyNumber") ?? "Unknown";
+  const insuredName = valueOf(profile, "namedInsured") ?? "Unknown";
+  const carrier = valueOf(profile, "insurer") ?? "Unknown";
+  const effectiveDate = valueOf(profile, "effectiveDate") ?? "Unknown";
+  const expirationDate = valueOf(profile, "expirationDate") ?? "Unknown";
+  const premium = valueOf(profile, "premium");
+  const coverages = profile.coverages.map((coverage) => ({
+    name: coverage.name,
+    coverageCode: coverage.coverageCode,
+    limit: coverage.limit,
+    deductible: coverage.deductible,
+    premium: coverage.premium,
+    formNumber: coverage.formNumber,
+    sectionRef: coverage.sectionRef,
+    sourceSpanIds: coverage.sourceSpanIds,
+    documentNodeId: coverage.sourceNodeIds[0],
+    originalContent: [coverage.name, coverage.limit, coverage.deductible, coverage.premium].filter(Boolean).join(" | ")
+  }));
+  const documentOutline = sourceTreeToOutline(params.sourceTree);
+  const documentMetadata = {
+    sourceTreeVersion: "v3",
+    sourceTreeCanonical: true,
+    tableOfContents: documentOutline.map((node) => ({
+      title: node.title,
+      pageStart: node.pageStart,
+      pageEnd: node.pageEnd,
+      documentNodeId: node.id,
+      sourceSpanIds: node.sourceSpanIds
+    })),
+    agentGuidance: [
+      {
+        kind: "source_tree",
+        title: "Use the source tree as canonical evidence",
+        detail: "Operational fields are projections from source nodes and source spans. Use source nodes for policy wording and exact provenance."
+      }
+    ]
+  };
+  const summary = [
+    carrier !== "Unknown" ? carrier : void 0,
+    policyNumber !== "Unknown" ? `#${policyNumber}` : void 0,
+    insuredName !== "Unknown" ? `for ${insuredName}` : void 0,
+    profile.coverageTypes.length ? `covering ${profile.coverageTypes.slice(0, 5).join(", ")}` : void 0
+  ].filter(Boolean).join(" ");
+  const base = {
+    id: params.id,
+    type: profile.documentType,
+    carrier,
+    security: carrier,
+    insuredName,
+    premium,
+    policyTypes: profile.policyTypes,
+    coverages,
+    documentMetadata,
+    documentOutline,
+    declarations: {
+      fields: [
+        profile.policyNumber ? { field: "policyNumber", value: profile.policyNumber.value, sourceSpanIds: profile.policyNumber.sourceSpanIds } : void 0,
+        profile.namedInsured ? { field: "namedInsured", value: profile.namedInsured.value, sourceSpanIds: profile.namedInsured.sourceSpanIds } : void 0,
+        profile.insurer ? { field: "insurer", value: profile.insurer.value, sourceSpanIds: profile.insurer.sourceSpanIds } : void 0,
+        profile.effectiveDate ? { field: "policyPeriodStart", value: profile.effectiveDate.value, sourceSpanIds: profile.effectiveDate.sourceSpanIds } : void 0,
+        profile.expirationDate ? { field: "policyPeriodEnd", value: profile.expirationDate.value, sourceSpanIds: profile.expirationDate.sourceSpanIds } : void 0
+      ].filter(Boolean)
+    },
+    supplementaryFacts: profile.endorsementSupport.map((item) => ({
+      key: item.kind,
+      value: item.summary,
+      sourceSpanIds: item.sourceSpanIds,
+      documentNodeId: item.sourceNodeIds[0]
+    })),
+    summary: summary || void 0
+  };
+  if (profile.documentType === "quote") {
+    return {
+      ...base,
+      type: "quote",
+      quoteNumber: policyNumber,
+      proposedEffectiveDate: effectiveDate === "Unknown" ? void 0 : effectiveDate,
+      proposedExpirationDate: expirationDate === "Unknown" ? void 0 : expirationDate
+    };
+  }
+  return {
+    ...base,
+    type: "policy",
+    policyNumber,
+    effectiveDate,
+    expirationDate,
+    retroactiveDate: valueOf(profile, "retroactiveDate")
+  };
+}
+async function runSourceTreeExtraction(params) {
+  let sourceTree = buildDocumentSourceTree(params.sourceSpans, params.id);
+  const warnings = [];
+  let modelCalls = 0;
+  let callsWithUsage = 0;
+  let callsMissingUsage = 0;
+  const tokenUsage = { inputTokens: 0, outputTokens: 0 };
+  const performanceReport = { modelCalls: [], totalModelCallDurationMs: 0 };
+  const localTrack = (usage, report) => {
+    modelCalls += 1;
+    if (usage) {
+      callsWithUsage += 1;
+      tokenUsage.inputTokens += usage.inputTokens;
+      tokenUsage.outputTokens += usage.outputTokens;
+    } else {
+      callsMissingUsage += 1;
+    }
+    if (report) {
+      performanceReport.modelCalls.push({ ...report, usage, usageReported: !!usage });
+      if (report.durationMs != null) performanceReport.totalModelCallDurationMs += report.durationMs;
+    }
+    params.trackUsage(usage, report);
+  };
+  try {
+    const budget = params.resolveBudget("extraction_source_tree", 4096);
+    const startedAt = Date.now();
+    const response = await safeGenerateObject(
+      params.generateObject,
+      {
+        prompt: buildOrganizationPrompt(sourceTree),
+        schema: SourceTreeOrganizationSchema,
+        maxTokens: budget.maxTokens,
+        taskKind: "extraction_source_tree",
+        budgetDiagnostics: budget,
+        providerOptions: { ...params.providerOptions, sourceSpans: params.sourceSpans }
+      },
+      {
+        fallback: { labels: [], groups: [] },
+        log: params.log
+      }
+    );
+    localTrack(response.usage, {
+      taskKind: "extraction_source_tree",
+      label: "source_tree_organizer",
+      maxTokens: budget.maxTokens,
+      durationMs: Date.now() - startedAt
+    });
+    sourceTree = applyOrganization(sourceTree, response.object);
+  } catch (error) {
+    warnings.push(`Source-tree organizer failed; deterministic tree used (${error instanceof Error ? error.message : String(error)})`);
+  }
+  const deterministicProfile = buildDeterministicOperationalProfile({
+    sourceTree,
+    sourceSpans: params.sourceSpans
+  });
+  let operationalProfile = deterministicProfile;
+  try {
+    const validNodeIds = new Set(sourceTree.map((node) => node.id));
+    const validSpanIds = new Set(params.sourceSpans.map((span) => span.id));
+    const budget = params.resolveBudget("extraction_operational_profile", 8192);
+    const startedAt = Date.now();
+    const response = await safeGenerateObject(
+      params.generateObject,
+      {
+        prompt: buildOperationalProfilePrompt(sourceTree, deterministicProfile),
+        schema: OperationalProfilePromptSchema,
+        maxTokens: budget.maxTokens,
+        taskKind: "extraction_operational_profile",
+        budgetDiagnostics: budget,
+        providerOptions: { ...params.providerOptions, sourceSpans: params.sourceSpans, sourceTree }
+      },
+      {
+        fallback: deterministicProfile,
+        log: params.log
+      }
+    );
+    localTrack(response.usage, {
+      taskKind: "extraction_operational_profile",
+      label: "operational_profile",
+      maxTokens: budget.maxTokens,
+      durationMs: Date.now() - startedAt
+    });
+    operationalProfile = mergeOperationalProfile(
+      deterministicProfile,
+      response.object,
+      validNodeIds,
+      validSpanIds
+    );
+  } catch (error) {
+    warnings.push(`Operational profile model pass failed; deterministic profile used (${error instanceof Error ? error.message : String(error)})`);
+  }
+  const document = materializeDocument({
+    id: params.id,
+    sourceTree,
+    operationalProfile
+  });
+  return {
+    sourceTree,
+    sourceSpans: params.sourceSpans,
+    sourceChunks: chunkSourceSpans(params.sourceSpans),
+    operationalProfile,
+    document,
+    chunks: [],
+    warnings: [...warnings, ...operationalProfile.warnings],
+    tokenUsage,
+    usageReporting: {
+      modelCalls,
+      callsWithUsage,
+      callsMissingUsage
+    },
+    performanceReport
+  };
+}
+
 // src/extraction/coordinator.ts
 function createExtractor(config) {
   const {
@@ -8088,17 +9481,17 @@ ${span.text}` : span.text;
     const candidateSpans = spansForPageRange(spans, startPage, endPage).filter((span) => span.text.trim().length > 0).filter((span) => span.metadata?.sourceUnit === "section_candidate" || span.sectionId || span.text.length >= 160);
     return {
       sections: candidateSpans.map((span, index) => {
-        const pageStart = span.pageStart ?? span.location?.startPage ?? span.location?.page ?? startPage;
-        const pageEnd = span.pageEnd ?? span.location?.endPage ?? pageStart;
-        const title = span.sectionId ?? span.formNumber ?? firstHeadingLine(span.text) ?? `Policy text page ${pageStart}`;
+        const pageStart2 = span.pageStart ?? span.location?.startPage ?? span.location?.page ?? startPage;
+        const pageEnd2 = span.pageEnd ?? span.location?.endPage ?? pageStart2;
+        const title = span.sectionId ?? span.formNumber ?? firstHeadingLine(span.text) ?? `Policy text page ${pageStart2}`;
         return {
           title,
           sectionNumber: span.formNumber,
-          pageStart,
-          pageEnd,
+          pageStart: pageStart2,
+          pageEnd: pageEnd2,
           type: inferSectionType(title, span.text),
           excerpt: span.text.slice(0, 240),
-          recordId: `section_index_${pageStart}_${index}`,
+          recordId: `section_index_${pageStart2}_${index}`,
           sourceSpanIds: [span.id],
           sourceTextHash: span.textHash ?? sourceSpanTextHash(span.text)
         };
@@ -8237,6 +9630,51 @@ ${span.text}` : span.text;
         await sourceStore.addSourceChunks(sourceChunks);
       }
     }
+    if (sourceSpans.length > 0) {
+      onProgress?.("Building source-native document tree...");
+      const v3 = await runSourceTreeExtraction({
+        id,
+        sourceSpans,
+        generateObject,
+        providerOptions: activeProviderOptions,
+        resolveBudget,
+        trackUsage,
+        log
+      });
+      const reviewReport2 = {
+        issues: v3.warnings.map((warning) => ({
+          code: "source_tree_warning",
+          severity: "warning",
+          message: warning
+        })),
+        rounds: [],
+        artifacts: [
+          { kind: "source_tree", label: "Source Tree", itemCount: v3.sourceTree.length },
+          { kind: "source_spans", label: "Source Spans", itemCount: v3.sourceSpans.length },
+          { kind: "operational_profile", label: "Operational Profile", itemCount: v3.operationalProfile.coverages.length }
+        ],
+        reviewRoundRecords: [],
+        formInventory: [],
+        qualityGateStatus: v3.warnings.length > 0 ? "warning" : "passed"
+      };
+      if (shouldFailQualityGate(qualityGate, reviewReport2.qualityGateStatus)) {
+        throw new Error("Extraction quality gate failed. See reviewReport for blocking issues.");
+      }
+      onProgress?.("Source-tree extraction complete.");
+      return {
+        document: v3.document,
+        chunks: [],
+        sourceSpans: v3.sourceSpans,
+        sourceChunks: v3.sourceChunks,
+        sourceTree: v3.sourceTree,
+        operationalProfile: v3.operationalProfile,
+        warnings: v3.warnings,
+        tokenUsage: v3.tokenUsage,
+        usageReporting: v3.usageReporting,
+        performanceReport: v3.performanceReport,
+        reviewReport: reviewReport2
+      };
+    }
     const pipelineCtx = createPipelineContext({
       id,
       onSave: onCheckpointSave,
@@ -8804,6 +10242,7 @@ ${pageText}`;
     }));
     onProgress?.("Assembling document...");
     const document = assembleDocument(id, documentType, memory);
+    attachDocumentStructure({ document, pageAssignments, sourceSpans });
     await pipelineCtx.save("assemble", {
       id,
       pageCount,
@@ -9106,8 +10545,8 @@ Respond with JSON only:
 }`;
 
 // src/schemas/application.ts
-import { z as z41 } from "zod";
-var FieldTypeSchema = z41.enum([
+import { z as z42 } from "zod";
+var FieldTypeSchema = z42.enum([
   "text",
   "numeric",
   "currency",
@@ -9116,138 +10555,138 @@ var FieldTypeSchema = z41.enum([
   "table",
   "declaration"
 ]);
-var ApplicationFieldSchema = z41.object({
-  id: z41.string(),
-  label: z41.string(),
-  section: z41.string(),
+var ApplicationFieldSchema = z42.object({
+  id: z42.string(),
+  label: z42.string(),
+  section: z42.string(),
   fieldType: FieldTypeSchema,
-  required: z41.boolean(),
-  options: z41.array(z41.string()).optional(),
-  columns: z41.array(z41.string()).optional(),
-  requiresExplanationIfYes: z41.boolean().optional(),
-  condition: z41.object({
-    dependsOn: z41.string(),
-    whenValue: z41.string()
+  required: z42.boolean(),
+  options: z42.array(z42.string()).optional(),
+  columns: z42.array(z42.string()).optional(),
+  requiresExplanationIfYes: z42.boolean().optional(),
+  condition: z42.object({
+    dependsOn: z42.string(),
+    whenValue: z42.string()
   }).optional(),
-  value: z41.string().optional(),
-  source: z41.string().optional().describe("Where the value came from: auto-fill, user, lookup"),
-  confidence: z41.enum(["confirmed", "high", "medium", "low"]).optional(),
-  sourceSpanIds: z41.array(z41.string()).optional().describe("Stable source spans that support the field value or field anchor"),
-  userSourceSpanIds: z41.array(z41.string()).optional().describe("Message or attachment spans that support user-provided values"),
-  pageNumber: z41.number().int().positive().optional().describe("Application page where the field label or anchor appears"),
-  fieldAnchorId: z41.string().optional().describe("Stable field anchor ID derived from page, section, label, and form metadata"),
-  acroFormName: z41.string().optional().describe("Native PDF AcroForm field name when available"),
-  validationStatus: z41.enum(["valid", "needs_review", "unsupported", "missing"]).optional()
-});
-var ApplicationClassifyResultSchema = z41.object({
-  isApplication: z41.boolean(),
-  confidence: z41.number().min(0).max(1),
-  applicationType: z41.string().nullable()
-});
-var FieldExtractionResultSchema = z41.object({
-  fields: z41.array(ApplicationFieldSchema)
-});
-var AutoFillMatchSchema = z41.object({
-  fieldId: z41.string(),
-  value: z41.string(),
-  confidence: z41.enum(["confirmed"]),
-  contextKey: z41.string()
-});
-var AutoFillResultSchema = z41.object({
-  matches: z41.array(AutoFillMatchSchema)
-});
-var QuestionBatchResultSchema = z41.object({
-  batches: z41.array(z41.array(z41.string()).describe("Array of field IDs in this batch"))
-});
-var LookupRequestSchema = z41.object({
-  type: z41.string().describe("Type of lookup: 'records', 'website', 'policy'"),
-  description: z41.string(),
-  url: z41.string().optional(),
-  targetFieldIds: z41.array(z41.string())
-});
-var ReplyIntentSchema = z41.object({
-  primaryIntent: z41.enum(["answers_only", "question", "lookup_request", "mixed"]),
-  hasAnswers: z41.boolean(),
-  questionText: z41.string().optional(),
-  questionFieldIds: z41.array(z41.string()).optional(),
-  lookupRequests: z41.array(LookupRequestSchema).optional()
-});
-var ParsedAnswerSchema = z41.object({
-  fieldId: z41.string(),
-  value: z41.string(),
-  explanation: z41.string().optional()
-});
-var AnswerParsingResultSchema = z41.object({
-  answers: z41.array(ParsedAnswerSchema),
-  unanswered: z41.array(z41.string()).describe("Field IDs that were not answered")
-});
-var LookupFillSchema = z41.object({
-  fieldId: z41.string(),
-  value: z41.string(),
-  source: z41.string().describe("Specific citable reference, e.g. 'GL Policy #POL-12345 (Hartford)'"),
-  sourceSpanIds: z41.array(z41.string()).optional()
-});
-var LookupFillResultSchema = z41.object({
-  fills: z41.array(LookupFillSchema),
-  unfillable: z41.array(z41.string()),
-  explanation: z41.string().optional()
-});
-var FlatPdfPlacementSchema = z41.object({
-  fieldId: z41.string(),
-  page: z41.number(),
-  x: z41.number().describe("Percentage from left edge (0-100)"),
-  y: z41.number().describe("Percentage from top edge (0-100)"),
-  text: z41.string(),
-  fontSize: z41.number().optional(),
-  isCheckmark: z41.boolean().optional()
-});
-var AcroFormMappingSchema = z41.object({
-  fieldId: z41.string(),
-  acroFormName: z41.string(),
-  value: z41.string()
-});
-var QualityGateStatusSchema = z41.enum(["passed", "warning", "failed"]);
-var QualitySeveritySchema = z41.enum(["info", "warning", "blocking"]);
-var ApplicationQualityIssueSchema = z41.object({
-  code: z41.string(),
+  value: z42.string().optional(),
+  source: z42.string().optional().describe("Where the value came from: auto-fill, user, lookup"),
+  confidence: z42.enum(["confirmed", "high", "medium", "low"]).optional(),
+  sourceSpanIds: z42.array(z42.string()).optional().describe("Stable source spans that support the field value or field anchor"),
+  userSourceSpanIds: z42.array(z42.string()).optional().describe("Message or attachment spans that support user-provided values"),
+  pageNumber: z42.number().int().positive().optional().describe("Application page where the field label or anchor appears"),
+  fieldAnchorId: z42.string().optional().describe("Stable field anchor ID derived from page, section, label, and form metadata"),
+  acroFormName: z42.string().optional().describe("Native PDF AcroForm field name when available"),
+  validationStatus: z42.enum(["valid", "needs_review", "unsupported", "missing"]).optional()
+});
+var ApplicationClassifyResultSchema = z42.object({
+  isApplication: z42.boolean(),
+  confidence: z42.number().min(0).max(1),
+  applicationType: z42.string().nullable()
+});
+var FieldExtractionResultSchema = z42.object({
+  fields: z42.array(ApplicationFieldSchema)
+});
+var AutoFillMatchSchema = z42.object({
+  fieldId: z42.string(),
+  value: z42.string(),
+  confidence: z42.enum(["confirmed"]),
+  contextKey: z42.string()
+});
+var AutoFillResultSchema = z42.object({
+  matches: z42.array(AutoFillMatchSchema)
+});
+var QuestionBatchResultSchema = z42.object({
+  batches: z42.array(z42.array(z42.string()).describe("Array of field IDs in this batch"))
+});
+var LookupRequestSchema = z42.object({
+  type: z42.string().describe("Type of lookup: 'records', 'website', 'policy'"),
+  description: z42.string(),
+  url: z42.string().optional(),
+  targetFieldIds: z42.array(z42.string())
+});
+var ReplyIntentSchema = z42.object({
+  primaryIntent: z42.enum(["answers_only", "question", "lookup_request", "mixed"]),
+  hasAnswers: z42.boolean(),
+  questionText: z42.string().optional(),
+  questionFieldIds: z42.array(z42.string()).optional(),
+  lookupRequests: z42.array(LookupRequestSchema).optional()
+});
+var ParsedAnswerSchema = z42.object({
+  fieldId: z42.string(),
+  value: z42.string(),
+  explanation: z42.string().optional()
+});
+var AnswerParsingResultSchema = z42.object({
+  answers: z42.array(ParsedAnswerSchema),
+  unanswered: z42.array(z42.string()).describe("Field IDs that were not answered")
+});
+var LookupFillSchema = z42.object({
+  fieldId: z42.string(),
+  value: z42.string(),
+  source: z42.string().describe("Specific citable reference, e.g. 'GL Policy #POL-12345 (Hartford)'"),
+  sourceSpanIds: z42.array(z42.string()).optional()
+});
+var LookupFillResultSchema = z42.object({
+  fills: z42.array(LookupFillSchema),
+  unfillable: z42.array(z42.string()),
+  explanation: z42.string().optional()
+});
+var FlatPdfPlacementSchema = z42.object({
+  fieldId: z42.string(),
+  page: z42.number(),
+  x: z42.number().describe("Percentage from left edge (0-100)"),
+  y: z42.number().describe("Percentage from top edge (0-100)"),
+  text: z42.string(),
+  fontSize: z42.number().optional(),
+  isCheckmark: z42.boolean().optional()
+});
+var AcroFormMappingSchema = z42.object({
+  fieldId: z42.string(),
+  acroFormName: z42.string(),
+  value: z42.string()
+});
+var QualityGateStatusSchema = z42.enum(["passed", "warning", "failed"]);
+var QualitySeveritySchema = z42.enum(["info", "warning", "blocking"]);
+var ApplicationQualityIssueSchema = z42.object({
+  code: z42.string(),
   severity: QualitySeveritySchema,
-  message: z41.string(),
-  fieldId: z41.string().optional()
+  message: z42.string(),
+  fieldId: z42.string().optional()
 });
-var ApplicationQualityRoundSchema = z41.object({
-  round: z41.number(),
-  kind: z41.string(),
+var ApplicationQualityRoundSchema = z42.object({
+  round: z42.number(),
+  kind: z42.string(),
   status: QualityGateStatusSchema,
-  summary: z41.string().optional()
+  summary: z42.string().optional()
 });
-var ApplicationQualityArtifactSchema = z41.object({
-  kind: z41.string(),
-  label: z41.string().optional(),
-  itemCount: z41.number().optional()
+var ApplicationQualityArtifactSchema = z42.object({
+  kind: z42.string(),
+  label: z42.string().optional(),
+  itemCount: z42.number().optional()
 });
-var ApplicationEmailReviewSchema = z41.object({
-  issues: z41.array(ApplicationQualityIssueSchema),
+var ApplicationEmailReviewSchema = z42.object({
+  issues: z42.array(ApplicationQualityIssueSchema),
   qualityGateStatus: QualityGateStatusSchema
 });
-var ApplicationQualityReportSchema = z41.object({
-  issues: z41.array(ApplicationQualityIssueSchema),
-  rounds: z41.array(ApplicationQualityRoundSchema).optional(),
-  artifacts: z41.array(ApplicationQualityArtifactSchema).optional(),
+var ApplicationQualityReportSchema = z42.object({
+  issues: z42.array(ApplicationQualityIssueSchema),
+  rounds: z42.array(ApplicationQualityRoundSchema).optional(),
+  artifacts: z42.array(ApplicationQualityArtifactSchema).optional(),
   emailReview: ApplicationEmailReviewSchema.optional(),
   qualityGateStatus: QualityGateStatusSchema
 });
-var ApplicationStateSchema = z41.object({
-  id: z41.string(),
-  pdfBase64: z41.string().optional().describe("Original PDF, omitted after extraction"),
-  title: z41.string().optional(),
-  applicationType: z41.string().nullable().optional(),
-  fields: z41.array(ApplicationFieldSchema),
-  batches: z41.array(z41.array(z41.string())).optional(),
-  currentBatchIndex: z41.number().default(0),
+var ApplicationStateSchema = z42.object({
+  id: z42.string(),
+  pdfBase64: z42.string().optional().describe("Original PDF, omitted after extraction"),
+  title: z42.string().optional(),
+  applicationType: z42.string().nullable().optional(),
+  fields: z42.array(ApplicationFieldSchema),
+  batches: z42.array(z42.array(z42.string())).optional(),
+  currentBatchIndex: z42.number().default(0),
   qualityReport: ApplicationQualityReportSchema.optional(),
-  status: z41.enum(["classifying", "extracting", "auto_filling", "batching", "collecting", "confirming", "mapping", "complete"]),
-  createdAt: z41.number(),
-  updatedAt: z41.number()
+  status: z42.enum(["classifying", "extracting", "auto_filling", "batching", "collecting", "confirming", "mapping", "complete"]),
+  createdAt: z42.number(),
+  updatedAt: z42.number()
 });
 
 // src/application/agents/classifier.ts
@@ -10602,104 +12041,106 @@ Respond with the final answer, deduplicated citations array, overall confidence
 }
 
 // src/schemas/query.ts
-import { z as z42 } from "zod";
-var QueryIntentSchema = z42.enum([
+import { z as z43 } from "zod";
+var QueryIntentSchema = z43.enum([
   "policy_question",
   "coverage_comparison",
   "document_search",
   "claims_inquiry",
   "general_knowledge"
 ]);
-var QueryAttachmentKindSchema = z42.enum(["image", "pdf", "text"]);
-var QueryAttachmentSchema = z42.object({
-  id: z42.string().optional().describe("Optional stable attachment ID from the caller"),
+var QueryAttachmentKindSchema = z43.enum(["image", "pdf", "text"]);
+var QueryAttachmentSchema = z43.object({
+  id: z43.string().optional().describe("Optional stable attachment ID from the caller"),
   kind: QueryAttachmentKindSchema,
-  name: z42.string().optional().describe("Original filename or user-facing label"),
-  mimeType: z42.string().optional().describe("MIME type such as image/jpeg or application/pdf"),
-  base64: z42.string().optional().describe("Base64-encoded file content for image/pdf attachments"),
-  text: z42.string().optional().describe("Plain-text attachment content when available"),
-  description: z42.string().optional().describe("Caller-provided description of the attachment")
+  name: z43.string().optional().describe("Original filename or user-facing label"),
+  mimeType: z43.string().optional().describe("MIME type such as image/jpeg or application/pdf"),
+  base64: z43.string().optional().describe("Base64-encoded file content for image/pdf attachments"),
+  text: z43.string().optional().describe("Plain-text attachment content when available"),
+  description: z43.string().optional().describe("Caller-provided description of the attachment")
 });
-var QueryRetrievalModeSchema = z42.enum([
+var QueryRetrievalModeSchema = z43.enum([
   "graph_only",
   "source_rag",
   "long_context",
   "hybrid"
 ]);
-var SubQuestionSchema = z42.object({
-  question: z42.string().describe("Atomic sub-question to retrieve and answer independently"),
+var SubQuestionSchema = z43.object({
+  question: z43.string().describe("Atomic sub-question to retrieve and answer independently"),
   intent: QueryIntentSchema,
-  chunkTypes: z42.array(z42.string()).optional().describe("Chunk types to filter retrieval (e.g. coverage, endorsement, declaration)"),
-  documentFilters: z42.object({
-    type: z42.enum(["policy", "quote"]).optional(),
-    carrier: z42.string().optional(),
-    insuredName: z42.string().optional(),
-    policyNumber: z42.string().optional(),
-    quoteNumber: z42.string().optional(),
-    policyTypes: z42.array(PolicyTypeSchema).optional().describe("Filter by policy type (e.g. homeowners_ho3, renters_ho4, pet) to avoid mixing up similar policies")
+  chunkTypes: z43.array(z43.string()).optional().describe("Chunk types to filter retrieval (e.g. coverage, endorsement, declaration)"),
+  documentFilters: z43.object({
+    type: z43.enum(["policy", "quote"]).optional(),
+    carrier: z43.string().optional(),
+    insuredName: z43.string().optional(),
+    policyNumber: z43.string().optional(),
+    quoteNumber: z43.string().optional(),
+    policyTypes: z43.array(PolicyTypeSchema).optional().describe("Filter by policy type (e.g. homeowners_ho3, renters_ho4, pet) to avoid mixing up similar policies")
   }).optional().describe("Structured filters to narrow document lookup")
 });
-var QueryClassifyResultSchema = z42.object({
+var QueryClassifyResultSchema = z43.object({
   intent: QueryIntentSchema,
-  subQuestions: z42.array(SubQuestionSchema).min(1).describe("Decomposed atomic sub-questions"),
-  requiresDocumentLookup: z42.boolean().describe("Whether structured document lookup is needed"),
-  requiresChunkSearch: z42.boolean().describe("Whether semantic chunk search is needed"),
-  requiresConversationHistory: z42.boolean().describe("Whether conversation history is relevant"),
+  subQuestions: z43.array(SubQuestionSchema).min(1).describe("Decomposed atomic sub-questions"),
+  requiresDocumentLookup: z43.boolean().describe("Whether structured document lookup is needed"),
+  requiresChunkSearch: z43.boolean().describe("Whether semantic chunk search is needed"),
+  requiresConversationHistory: z43.boolean().describe("Whether conversation history is relevant"),
   retrievalMode: QueryRetrievalModeSchema.optional().describe("Preferred retrieval strategy for the query when source-span retrieval is available")
 });
-var EvidenceItemSchema = z42.object({
-  source: z42.enum(["chunk", "document", "conversation", "attachment", "source_span"]),
-  chunkId: z42.string().optional(),
-  sourceSpanId: z42.string().optional(),
-  documentId: z42.string().optional(),
-  turnId: z42.string().optional(),
-  attachmentId: z42.string().optional(),
-  text: z42.string().describe("Text excerpt from the source"),
-  relevance: z42.number().min(0).max(1),
+var EvidenceItemSchema = z43.object({
+  source: z43.enum(["chunk", "document", "conversation", "attachment", "source_span", "source_node"]),
+  chunkId: z43.string().optional(),
+  sourceNodeId: z43.string().optional(),
+  sourceSpanId: z43.string().optional(),
+  documentId: z43.string().optional(),
+  turnId: z43.string().optional(),
+  attachmentId: z43.string().optional(),
+  text: z43.string().describe("Text excerpt from the source"),
+  relevance: z43.number().min(0).max(1),
   retrievalMode: QueryRetrievalModeSchema.optional(),
   sourceLocation: SourceSpanLocationSchema.optional(),
-  metadata: z42.array(z42.object({ key: z42.string(), value: z42.string() })).optional()
-});
-var AttachmentInterpretationSchema = z42.object({
-  summary: z42.string().describe("Concise summary of what the attachment shows or contains"),
-  extractedFacts: z42.array(z42.string()).describe("Specific observable or document facts grounded in the attachment"),
-  recommendedFocus: z42.array(z42.string()).describe("Important details to incorporate when answering follow-up questions"),
-  confidence: z42.number().min(0).max(1)
-});
-var RetrievalResultSchema = z42.object({
-  subQuestion: z42.string(),
-  evidence: z42.array(EvidenceItemSchema)
-});
-var CitationSchema = z42.object({
-  index: z42.number().describe("Citation number [1], [2], etc."),
-  chunkId: z42.string().optional().describe("Source chunk ID, e.g. doc-123:coverage:2"),
-  sourceSpanId: z42.string().optional().describe("Precise source span ID when available"),
-  documentId: z42.string(),
-  documentType: z42.enum(["policy", "quote"]).optional(),
-  field: z42.string().optional().describe("Specific field path, e.g. coverages[0].deductible"),
-  quote: z42.string().describe("Exact text from source that supports the claim"),
-  relevance: z42.number().min(0).max(1),
+  metadata: z43.array(z43.object({ key: z43.string(), value: z43.string() })).optional()
+});
+var AttachmentInterpretationSchema = z43.object({
+  summary: z43.string().describe("Concise summary of what the attachment shows or contains"),
+  extractedFacts: z43.array(z43.string()).describe("Specific observable or document facts grounded in the attachment"),
+  recommendedFocus: z43.array(z43.string()).describe("Important details to incorporate when answering follow-up questions"),
+  confidence: z43.number().min(0).max(1)
+});
+var RetrievalResultSchema = z43.object({
+  subQuestion: z43.string(),
+  evidence: z43.array(EvidenceItemSchema)
+});
+var CitationSchema = z43.object({
+  index: z43.number().describe("Citation number [1], [2], etc."),
+  chunkId: z43.string().optional().describe("Source chunk ID, e.g. doc-123:coverage:2"),
+  sourceNodeId: z43.string().optional().describe("Source tree node ID when available"),
+  sourceSpanId: z43.string().optional().describe("Precise source span ID when available"),
+  documentId: z43.string(),
+  documentType: z43.enum(["policy", "quote"]).optional(),
+  field: z43.string().optional().describe("Specific field path, e.g. coverages[0].deductible"),
+  quote: z43.string().describe("Exact text from source that supports the claim"),
+  relevance: z43.number().min(0).max(1),
   retrievalMode: QueryRetrievalModeSchema.optional(),
   sourceLocation: SourceSpanLocationSchema.optional()
 });
-var SubAnswerSchema = z42.object({
-  subQuestion: z42.string(),
-  answer: z42.string(),
-  citations: z42.array(CitationSchema),
-  confidence: z42.number().min(0).max(1),
-  needsMoreContext: z42.boolean().describe("True if evidence was insufficient to answer fully")
-});
-var VerifyResultSchema = z42.object({
-  approved: z42.boolean().describe("Whether all sub-answers are adequately grounded"),
-  issues: z42.array(z42.string()).describe("Specific grounding or consistency issues found"),
-  retrySubQuestions: z42.array(z42.string()).optional().describe("Sub-questions that need additional retrieval or re-reasoning")
-});
-var QueryResultSchema = z42.object({
-  answer: z42.string(),
-  citations: z42.array(CitationSchema),
+var SubAnswerSchema = z43.object({
+  subQuestion: z43.string(),
+  answer: z43.string(),
+  citations: z43.array(CitationSchema),
+  confidence: z43.number().min(0).max(1),
+  needsMoreContext: z43.boolean().describe("True if evidence was insufficient to answer fully")
+});
+var VerifyResultSchema = z43.object({
+  approved: z43.boolean().describe("Whether all sub-answers are adequately grounded"),
+  issues: z43.array(z43.string()).describe("Specific grounding or consistency issues found"),
+  retrySubQuestions: z43.array(z43.string()).optional().describe("Sub-questions that need additional retrieval or re-reasoning")
+});
+var QueryResultSchema = z43.object({
+  answer: z43.string(),
+  citations: z43.array(CitationSchema),
   intent: QueryIntentSchema,
-  confidence: z42.number().min(0).max(1),
-  followUp: z42.string().optional().describe("Suggested follow-up question if applicable")
+  confidence: z43.number().min(0).max(1),
+  followUp: z43.string().optional().describe("Suggested follow-up question if applicable")
 });
 
 // src/query/retriever.ts
@@ -10714,6 +12155,35 @@ async function retrieve(subQuestion, conversationId, config) {
     tasks.push(
       (async () => {
         try {
+          const nodeResults = await sourceRetriever?.searchSourceNodes?.({
+            question: subQuestion.question,
+            limit: retrievalLimit,
+            mode: retrievalMode
+          }) ?? [];
+          for (const result of nodeResults) {
+            const hierarchyText = result.hierarchy.map((node) => `${node.path} ${node.title}: ${node.textExcerpt ?? node.description}`).join("\n");
+            const spanText = result.spans.map((span) => `[source-span:${span.id}${span.pageStart ? ` p.${span.pageStart}` : ""}]
+${span.text}`).join("\n\n");
+            evidence.push({
+              source: "source_node",
+              sourceNodeId: result.node.id,
+              sourceSpanId: result.spans[0]?.id,
+              documentId: result.node.documentId,
+              text: [hierarchyText, spanText].filter(Boolean).join("\n\n"),
+              relevance: result.relevance,
+              retrievalMode,
+              sourceLocation: result.spans[0]?.location ?? (result.node.pageStart ? { page: result.node.pageStart } : void 0),
+              metadata: [
+                { key: "kind", value: result.node.kind },
+                { key: "path", value: result.node.path },
+                { key: "title", value: result.node.title },
+                ...result.node.metadata ? recordToKVArray(Object.fromEntries(
+                  Object.entries(result.node.metadata).filter(([, value]) => typeof value === "string").map(([key, value]) => [key, value])
+                )) : []
+              ]
+            });
+          }
+          if (nodeResults.length > 0) return;
           const sourceResults = await sourceRetriever?.searchSourceSpans({
             question: subQuestion.question,
             limit: retrievalLimit,
@@ -10733,7 +12203,7 @@ async function retrieve(subQuestion, conversationId, config) {
             });
           }
         } catch (e) {
-          await log?.(`Source span search failed for "${subQuestion.question}": ${e}`);
+          await log?.(`Source tree search failed for "${subQuestion.question}": ${e}`);
         }
       })()
     );
@@ -10935,7 +12405,7 @@ Answer the sub-question based on the evidence above. For every factual claim, in
 async function reason(subQuestion, intent, evidence, config) {
   const { generateObject, providerOptions } = config;
   const evidenceText = evidence.map((e, i) => {
-    const sourceLabel = e.source === "source_span" ? `[source-span:${e.sourceSpanId}]` : e.source === "chunk" ? `[chunk:${e.chunkId}]` : e.source === "document" ? `[doc:${e.documentId}]` : e.source === "attachment" ? `[attachment:${e.attachmentId}]` : `[turn:${e.turnId}]`;
+    const sourceLabel = e.source === "source_node" ? `[source-node:${e.sourceNodeId} source-span:${e.sourceSpanId ?? "none"}]` : e.source === "source_span" ? `[source-span:${e.sourceSpanId}]` : e.source === "chunk" ? `[chunk:${e.chunkId}]` : e.source === "document" ? `[doc:${e.documentId}]` : e.source === "attachment" ? `[attachment:${e.attachmentId}]` : `[turn:${e.turnId}]`;
     return `Evidence ${i + 1} ${sourceLabel} (relevance: ${e.relevance.toFixed(2)}):
 ${e.text}`;
   }).join("\n\n");
@@ -11737,7 +13207,7 @@ ${sa.answer}`).join("\n\n"),
 }
 
 // src/pce/index.ts
-import { z as z43 } from "zod";
+import { z as z44 } from "zod";
 
 // src/prompts/pce/index.ts
 function buildPceNormalizePrompt(input) {
@@ -11771,11 +13241,11 @@ ${input.openQuestions.map((question) => `- ${question.id}${question.fieldPath ?
 }
 
 // src/pce/index.ts
-var ReplyAnswersSchema = z43.object({
-  answers: z43.array(z43.object({
-    questionId: z43.string().optional(),
-    fieldPath: z43.string().optional(),
-    answer: z43.string()
+var ReplyAnswersSchema = z44.object({
+  answers: z44.array(z44.object({
+    questionId: z44.string().optional(),
+    fieldPath: z44.string().optional(),
+    answer: z44.string()
   }))
 });
 function createPceAgent(config = {}) {
@@ -12601,6 +14071,13 @@ export {
   DeductibleTypeSchema,
   DefenseCostTreatmentSchema,
   DefinitionSchema,
+  DocumentAgentGuidanceSchema,
+  DocumentMetadataSchema,
+  DocumentNodeSchema,
+  DocumentPageMapEntrySchema,
+  DocumentSourceNodeKindSchema,
+  DocumentSourceNodeSchema,
+  DocumentTableOfContentsEntrySchema,
   DocumentTypeSchema,
   DriverRecordSchema,
   DwellingDetailsSchema,
@@ -12655,6 +14132,9 @@ export {
   MemorySourceStore,
   MissingInfoQuestionSchema,
   NamedInsuredSchema,
+  OperationalCoverageLineSchema,
+  OperationalEndorsementSupportSchema,
+  OperationalPartySchema,
   PERSONAL_AUTO_USAGES,
   PET_SPECIES,
   PLATFORM_CONFIGS,
@@ -12684,6 +14164,7 @@ export {
   PolicyChangeStatusSchema,
   PolicyConditionSchema,
   PolicyDocumentSchema,
+  PolicyOperationalProfileSchema,
   PolicySectionTypeSchema,
   PolicyTermTypeSchema,
   PolicyTypeSchema,
@@ -12715,6 +14196,7 @@ export {
   ScheduledItemCategorySchema,
   SectionSchema,
   SharedLimitSchema,
+  SourceBackedValueSchema,
   SourceChunkSchema,
   SourceKindSchema,
   SourceSpanBBoxSchema,
@@ -12756,7 +14238,9 @@ export {
   buildConfirmationSummaryPrompt,
   buildConversationMemoryGuidance,
   buildCoverageGapPrompt,
+  buildDeterministicOperationalProfile,
   buildDoclingProviderOptions,
+  buildDocumentSourceTree,
   buildFieldExplanationPrompt,
   buildFieldExtractionPrompt,
   buildFlatPdfMappingPrompt,
@@ -12805,9 +14289,11 @@ export {
   getTemplate,
   isDoclingExtractionInput,
   isFileReference,
+  mergeOperationalProfile,
   mergeQuestionAnswers,
   mergeSourceSpans,
   normalizeDoclingDocument,
+  normalizeDocumentSourceTreePaths,
   normalizeForMatch,
   orderSourceEvidence,
   overlayTextOnPdf,