@claritylabs/cl-sdk 3.0.32 → 3.1.0

package/dist/index.mjs

@@ -2981,6 +2981,14 @@ function valueFromNode(node, value, confidence = "medium") {
     sourceSpanIds: node.sourceSpanIds
   };
 }
+function valueFromNodes(nodes, value, confidence = "medium", normalizedValue) {
+  return {
+    value,
+    ...normalizedValue ? { normalizedValue } : {},
+    confidence,
+    ...sourceIds(nodes)
+  };
+}
 function firstMatch(nodes, patterns) {
   for (const node of nodes) {
     const text = nodeText(node);
@@ -3057,8 +3065,65 @@ function cleanNamedInsured(value) {
   }
   return clean;
 }
+var PARTY_LABEL_PATTERNS = {
+  namedInsured: /^(?:item\s*\d+[.)]?\s*)?(?:named insured(?:\s+and\s+address)?|insured name)$/i,
+  insurer: /^(?:carrier|insurer|security)$/i,
+  broker: /^(?:broker(?:\s+of\s+record)?|producer|agent)$/i
+};
+function partyLabelKind(value) {
+  const clean = cleanValue(value.replace(/^\s*column\s+\d+\s*:\s*/i, ""));
+  if (!clean) return void 0;
+  if (PARTY_LABEL_PATTERNS.namedInsured.test(clean)) return "namedInsured";
+  if (PARTY_LABEL_PATTERNS.insurer.test(clean)) return "insurer";
+  if (PARTY_LABEL_PATTERNS.broker.test(clean)) return "broker";
+  return void 0;
+}
+function isRejectedPartyValue(value) {
+  const clean = normalizeWhitespace3(value);
+  return /^(?:and address|of record|insurer|carrier|security|broker|producer|agent|the|a|an|is|are|was|were|agrees?|means?|includes?|shall|will)\b/i.test(clean);
+}
+function identityWithoutAddress(value) {
+  const clean = cleanValue(value.replace(/\b(?:phone|tel|telephone|email|e-mail)\b.*$/i, "").replace(/\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b.*$/i, ""));
+  if (!clean) return void 0;
+  const beforeStreet = clean.match(/^(.+?)\s+\d{1,6}\s+[A-Za-z0-9.'-]+(?:\s+[A-Za-z0-9.'-]+){0,5}\s+(?:street|st\.?|avenue|ave\.?|road|rd\.?|drive|dr\.?|lane|ln\.?|boulevard|blvd\.?|suite|ste\.?|floor|fl\.?|way|court|ct\.?)\b/i)?.[1];
+  const beforeCityState = clean.match(/^(.+?)\s+[A-Z][A-Za-z.'-]+(?:\s+[A-Z][A-Za-z.'-]+)*,\s*[A-Z]{2}\s+\d{5}(?:-\d{4})?\b/)?.[1];
+  return cleanValue(beforeStreet ?? beforeCityState ?? clean);
+}
+function cleanPartyIdentity(value, clean) {
+  const raw = cleanValue(value);
+  if (!raw || isRejectedPartyValue(raw)) return void 0;
+  const identity = identityWithoutAddress(raw);
+  const cleaned = identity ? clean(identity) : void 0;
+  if (!cleaned || isRejectedPartyValue(cleaned)) return void 0;
+  return {
+    value: cleaned,
+    ...cleaned !== raw ? { normalizedValue: cleaned } : {}
+  };
+}
+function partyFromTableRows(nodes, wanted, clean) {
+  const children = childMap(nodes);
+  for (const row of compactFactNodes(nodes).filter((node) => node.kind === "table_row")) {
+    const cells = cellRows(row, children);
+    for (const [index, cell] of cells.entries()) {
+      const labelKind = partyLabelKind(cell.value) ?? partyLabelKind(cell.label);
+      if (labelKind !== wanted) continue;
+      const valueCell = cells.slice(index + 1).find((candidate) => !partyLabelKind(candidate.value) && !partyLabelKind(candidate.label));
+      if (!valueCell) continue;
+      const cleaned = cleanPartyIdentity(valueCell.value, clean);
+      if (cleaned) return valueFromNodes([row, valueCell.node], cleaned.value, "high", cleaned.normalizedValue);
+    }
+    const parts = normalizeWhitespace3(row.textExcerpt ?? row.description ?? nodeText(row)).split(/\s+\|\s+|\t/).map(cleanValue).filter((part) => Boolean(part));
+    for (const [index, part] of parts.entries()) {
+      const labelKind = partyLabelKind(part);
+      if (labelKind !== wanted) continue;
+      const cleaned = cleanPartyIdentity(parts[index + 1] ?? "", clean);
+      if (cleaned) return valueFromNodes([row], cleaned.value, "high", cleaned.normalizedValue);
+    }
+  }
+  return void 0;
+}
 function namedInsuredFromNodes(nodes) {
-  return firstCleanMatch(nodes, [
+  return partyFromTableRows(nodes, "namedInsured", cleanNamedInsured) ?? firstCleanMatch(nodes, [
     /\b(?:named insured|insured name)\s*:?\s*(.+?)(?=\s+(?:insurance amount|benefit amount|policy number|policy date|owner|beneficiary|premium|coverage|risk classification|date this)\b|[|;\n]|$)/i,
     /\b(?:insured persons?|insured person)\s*:\s*(.+?)(?=\s+(?:insurance amount|benefit amount|policy number|policy date|owner|beneficiary|premium|coverage|risk classification|date this)\b|[|;\n]|$)/i,
     /\b(?:applicant|policyholder)\s*:?\s*(.+?)(?=\s+(?:coverage|policy number|insurer|carrier|premium|effective|expiration)\b|[|;\n]|$)/i
@@ -3067,12 +3132,19 @@ function namedInsuredFromNodes(nodes) {
 function cleanInsurer(value) {
   const clean = cleanValue(value);
   if (!clean || clean.length > 140) return void 0;
-  if (/^(mean|means|we|us|our)\b/i.test(clean)) return void 0;
+  if (/^(mean|means|we|us|our|the|a|an|agrees?|shall|will)\b/i.test(clean)) return void 0;
   if (/\b(table of contents|policy wording|provided solely|convenience)\b/i.test(clean)) return void 0;
   const known = clean.match(/\b(Sun Life Assurance Company of Canada|Manulife|The Manufacturers Life Insurance Company)\b/i)?.[1];
   return known ?? clean;
 }
 function insurerFromNodes(nodes) {
+  const tableValue = partyFromTableRows(nodes, "insurer", cleanInsurer);
+  if (tableValue) return tableValue;
+  for (const node of compactFactNodes(nodes)) {
+    const text = nodeText(node);
+    const value = cleanInsurer(text.match(/\b([A-Z][A-Za-z&.,' -]{2,120}?(?:Insurance|Assurance|Indemnity|Casualty|Underwriting|Mutual|Risk|Reinsurance)\s+Company(?:\s+of\s+[A-Z][A-Za-z .'-]+)?)\s*\(\s*the\s+["']?Insurer["']?\s*\)/i)?.[1] ?? "");
+    if (value) return valueFromNode(node, value, "high");
+  }
   return firstCleanMatch(nodes, [
     /\bunderwritten by\s+([^|;\n.]{3,160})/i,
     /\b(?:insurer|carrier|company|security)\s*:?\s*([^|;\n]{3,120})/i,
@@ -3118,6 +3190,19 @@ function coverageNameFromRow(text) {
   );
   return cleanCoverageLabel(first);
 }
+function isDeclarationLimitLabel(value) {
+  const label = normalizeLabel(value);
+  return /\bitem\s*\d+[.)]?\s*limits?\s+of\s+liability\b/.test(label) || /^limits?\s+of\s+liability$/.test(label) || /^policy\s+limits?$/.test(label);
+}
+function declarationCoverageNameFromRow(row, children) {
+  const cells = cellRows(row, children);
+  const candidates = [
+    row.title,
+    ...cells.flatMap((cell) => [cell.label, cell.value])
+  ];
+  if (!candidates.some(isDeclarationLimitLabel)) return void 0;
+  return candidates.some((candidate) => /\blimits?\s+of\s+liability\b/i.test(candidate ?? "")) ? "Limits of Liability" : "Policy Limits";
+}
 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]
@@ -3137,7 +3222,12 @@ function premiumFromNodes(nodes) {
   return void 0;
 }
 function moneyAmount(value) {
-  const match = value?.match(/\$?\s*([0-9][0-9,]*(?:\.\d+)?)/);
+  const clean = cleanValue(value);
+  if (!clean) return void 0;
+  const currency = clean.match(/\$\s*([0-9][0-9,]*(?:\.\d+)?)/);
+  const percent = clean.match(/\b([0-9][0-9,]*(?:\.\d+)?)\s*%/);
+  const explicitNumeric = !/\bitem\s*\d+\b/i.test(clean) && /\b(?:limit|aggregate|claim|occurrence|loss|retention|deductible|sir|premium|amount)\b/i.test(clean) ? clean.match(/\b([0-9][0-9,]*(?:\.\d+)?)\b/) : void 0;
+  const match = currency ?? percent ?? explicitNumeric;
   if (!match) return void 0;
   const amount = Number(match[1].replace(/,/g, ""));
   return Number.isFinite(amount) ? amount : void 0;
@@ -3183,6 +3273,10 @@ function isValueCell(label, value) {
   }
   return /\b(limit|aggregate|retention|deductible|sir|retroactive|premium|amount)\b/.test(normalizedLabel) || moneyAmount(value) !== void 0 || /\b(full prior acts|none|included|not included|as stated)\b/.test(normalizedValue);
 }
+function isCoverageTermLabel(value) {
+  const label = normalizeLabel(value);
+  return /\b(limit|aggregate|retention|deductible|sir|retroactive|premium|amount|sub[-\s]?limit)\b/.test(label);
+}
 function isNameCell(label, value) {
   const normalizedLabel = normalizeLabel(label);
   const normalizedValue = normalizeLabel(value);
@@ -3284,6 +3378,16 @@ function termFromCell(params) {
 function termsFromRow(row, children) {
   const cells = cellRows(row, children);
   if (cells.length > 0) {
+    const pairedTerms = [];
+    for (const [index, cell] of cells.entries()) {
+      const next = cells[index + 1];
+      if (!next) continue;
+      if (!isCoverageTermLabel(cell.value)) continue;
+      if (isCoverageTermLabel(next.value) && moneyAmount(next.value) === void 0) continue;
+      const term = termFromCell({ row, cell: next.node, label: cell.value, value: next.value });
+      if (term) pairedTerms.push(term);
+    }
+    if (pairedTerms.length > 0) return pairedTerms;
     return cells.filter((cell) => isValueCell(cell.label, cell.value)).map((cell) => termFromCell({ row, cell: cell.node, label: cell.label, value: cell.value })).filter((term) => Boolean(term));
   }
   const text = normalizeWhitespace3(row.textExcerpt ?? row.description ?? nodeText(row));
@@ -3310,6 +3414,8 @@ function termsFromRow(row, children) {
   return terms;
 }
 function nameFromRow(row, children) {
+  const declarationName = declarationCoverageNameFromRow(row, children);
+  if (declarationName) return declarationName;
   const cells = cellRows(row, children);
   const named = cells.find((cell) => isNameCell(cell.label, cell.value));
   if (named) return cleanValue(named.value);
@@ -3487,7 +3593,7 @@ function buildParties(profile) {
   if (profile.namedInsured) {
     parties.push({
       role: "named_insured",
-      name: profile.namedInsured.value,
+      name: profile.namedInsured.normalizedValue ?? profile.namedInsured.value,
       sourceNodeIds: profile.namedInsured.sourceNodeIds,
       sourceSpanIds: profile.namedInsured.sourceSpanIds
     });
@@ -3495,7 +3601,7 @@ function buildParties(profile) {
   if (profile.insurer) {
     parties.push({
       role: "insurer",
-      name: profile.insurer.value,
+      name: profile.insurer.normalizedValue ?? profile.insurer.value,
       sourceNodeIds: profile.insurer.sourceNodeIds,
       sourceSpanIds: profile.insurer.sourceSpanIds
     });
@@ -3503,7 +3609,7 @@ function buildParties(profile) {
   if (profile.broker) {
     parties.push({
       role: "broker",
-      name: profile.broker.value,
+      name: profile.broker.normalizedValue ?? profile.broker.value,
       sourceNodeIds: profile.broker.sourceNodeIds,
       sourceSpanIds: profile.broker.sourceSpanIds
     });
@@ -10948,9 +11054,19 @@ function sourceTreeToOutline(sourceTree) {
   });
   return (byParent.get(root?.id) ?? []).map(visit);
 }
+var NORMALIZED_COMPATIBILITY_FIELDS = /* @__PURE__ */ new Set([
+  "policyNumber",
+  "namedInsured",
+  "insurer",
+  "broker"
+]);
 function valueOf(profile, key) {
   const value = profile[key];
-  return value && typeof value === "object" && !Array.isArray(value) && "value" in value ? String(value.value) : void 0;
+  if (!value || typeof value !== "object" || Array.isArray(value) || !("value" in value)) return void 0;
+  if (NORMALIZED_COMPATIBILITY_FIELDS.has(key) && "normalizedValue" in value && typeof value.normalizedValue === "string" && value.normalizedValue.trim()) {
+    return value.normalizedValue;
+  }
+  return String(value.value);
 }
 function materializeDocument(params) {
   const profile = params.operationalProfile;
@@ -12548,6 +12664,55 @@ var ApplicationFieldSchema = z42.object({
   acroFormName: z42.string().optional().describe("Native PDF AcroForm field name when available"),
   validationStatus: z42.enum(["valid", "needs_review", "unsupported", "missing"]).optional()
 });
+var ApplicationQuestionConditionSchema = z42.object({
+  dependsOn: z42.string(),
+  operator: z42.enum(["equals", "not_equals", "in", "not_in", "exists"]).optional(),
+  value: z42.string().optional(),
+  whenValue: z42.string().optional(),
+  values: z42.array(z42.string()).optional()
+});
+var ApplicationRepeatSchema = z42.object({
+  min: z42.number().int().nonnegative().optional(),
+  max: z42.number().int().positive().optional(),
+  label: z42.string().optional()
+});
+var ApplicationQuestionNodeSchema = z42.lazy(
+  () => z42.object({
+    id: z42.string(),
+    nodeType: z42.enum(["group", "question", "repeat_group", "table"]),
+    fieldId: z42.string().optional(),
+    fieldPath: z42.string().optional(),
+    parentId: z42.string().optional(),
+    order: z42.number().int().nonnegative().optional(),
+    label: z42.string(),
+    section: z42.string().optional(),
+    fieldType: FieldTypeSchema.optional(),
+    required: z42.boolean().optional(),
+    prompt: z42.string().optional(),
+    options: z42.array(z42.string()).optional(),
+    columns: z42.array(z42.string()).optional(),
+    condition: ApplicationQuestionConditionSchema.optional(),
+    repeat: ApplicationRepeatSchema.optional(),
+    children: z42.array(ApplicationQuestionNodeSchema).optional()
+  })
+);
+var ApplicationQuestionGraphSchema = z42.object({
+  id: z42.string(),
+  version: z42.string(),
+  title: z42.string().optional(),
+  applicationType: z42.string().nullable().optional(),
+  source: z42.enum(["pdf", "manual", "imported", "generated"]).default("generated"),
+  rootNodeIds: z42.array(z42.string()).optional(),
+  nodes: z42.array(ApplicationQuestionNodeSchema)
+});
+var ApplicationTemplateSchema = z42.object({
+  id: z42.string(),
+  version: z42.string(),
+  title: z42.string(),
+  applicationType: z42.string().nullable().optional(),
+  questionGraph: ApplicationQuestionGraphSchema,
+  fields: z42.array(ApplicationFieldSchema).optional()
+});
 var ApplicationClassifyResultSchema = z42.object({
   isApplication: z42.boolean(),
   confidence: z42.number().min(0).max(1),
@@ -12645,16 +12810,67 @@ var ApplicationQualityReportSchema = z42.object({
   emailReview: ApplicationEmailReviewSchema.optional(),
   qualityGateStatus: QualityGateStatusSchema
 });
+var ApplicationContextProposalSchema = z42.object({
+  id: z42.string(),
+  fieldId: z42.string().optional(),
+  key: z42.string(),
+  value: z42.string(),
+  category: z42.string(),
+  source: z42.enum(["application", "user", "lookup", "policy", "email", "chat", "imessage", "mcp"]),
+  confidence: z42.enum(["confirmed", "high", "medium", "low"]),
+  sourceSpanIds: z42.array(z42.string()).optional(),
+  userSourceSpanIds: z42.array(z42.string()).optional()
+});
+var ApplicationPacketAnswerSchema = z42.object({
+  fieldId: z42.string(),
+  label: z42.string(),
+  section: z42.string(),
+  value: z42.string(),
+  source: z42.string(),
+  confidence: z42.enum(["confirmed", "high", "medium", "low"]).optional(),
+  sourceSpanIds: z42.array(z42.string()).optional(),
+  userSourceSpanIds: z42.array(z42.string()).optional()
+});
+var ApplicationPacketSchema = z42.object({
+  id: z42.string(),
+  applicationId: z42.string(),
+  title: z42.string(),
+  status: z42.enum(["draft", "broker_ready", "submitted"]),
+  answers: z42.array(ApplicationPacketAnswerSchema),
+  missingFieldIds: z42.array(z42.string()),
+  qualityReport: ApplicationQualityReportSchema,
+  submissionNotes: z42.string().optional(),
+  createdAt: z42.number()
+});
 var ApplicationStateSchema = z42.object({
   id: z42.string(),
   pdfBase64: z42.string().optional().describe("Original PDF, omitted after extraction"),
+  templateId: z42.string().optional(),
+  templateVersion: z42.string().optional(),
+  templateSnapshot: ApplicationTemplateSchema.optional(),
   title: z42.string().optional(),
   applicationType: z42.string().nullable().optional(),
+  questionGraph: ApplicationQuestionGraphSchema.optional(),
   fields: z42.array(ApplicationFieldSchema),
   batches: z42.array(z42.array(z42.string())).optional(),
   currentBatchIndex: z42.number().default(0),
+  contextProposals: z42.array(ApplicationContextProposalSchema).optional(),
+  packet: ApplicationPacketSchema.optional(),
   qualityReport: ApplicationQualityReportSchema.optional(),
-  status: z42.enum(["classifying", "extracting", "auto_filling", "batching", "collecting", "confirming", "mapping", "complete"]),
+  status: z42.enum([
+    "classifying",
+    "extracting",
+    "auto_filling",
+    "batching",
+    "collecting",
+    "confirming",
+    "mapping",
+    "broker_review",
+    "packet_ready",
+    "submitted",
+    "cancelled",
+    "complete"
+  ]),
   createdAt: z42.number(),
   updatedAt: z42.number()
 });
@@ -13353,7 +13569,7 @@ function planReplyActions(input) {
     parseAnswers: input.intent.hasAnswers && hasCurrentFields,
     runLookup: hasLookupRequests && input.hasDocumentStore,
     answerQuestion: Boolean(input.intent.questionText) && (input.intent.primaryIntent === "question" || input.intent.primaryIntent === "mixed"),
-    advanceBatch: hasCurrentFields && input.currentBatchFields.every((field) => !isUnfilled(field)),
+    advanceBatch: hasCurrentFields && input.currentBatchFields.every((field) => !isUnfilled(field)) || !hasCurrentFields && nextBatchNeedsAnswers,
     generateNextEmail: nextBatchNeedsAnswers
   };
 }
@@ -13392,12 +13608,287 @@ function isHighValueLookupField(field) {
   ].some((term) => text.includes(term));
 }
 
+// src/application/question-graph.ts
+function buildQuestionGraphFromFields(fields, options) {
+  const sectionNodes = /* @__PURE__ */ new Map();
+  const nodes = [];
+  for (const [index, field] of fields.entries()) {
+    const sectionId = stableNodeId(["section", field.section]);
+    let sectionNode = sectionNodes.get(sectionId);
+    if (!sectionNode) {
+      sectionNode = {
+        id: sectionId,
+        nodeType: "group",
+        label: field.section,
+        order: sectionNodes.size,
+        children: []
+      };
+      sectionNodes.set(sectionId, sectionNode);
+      nodes.push(sectionNode);
+    }
+    const child = {
+      id: field.fieldAnchorId ?? stableNodeId(["field", field.section, field.id || field.label]),
+      nodeType: field.fieldType === "table" ? "table" : "question",
+      fieldId: field.id,
+      fieldPath: `${field.section}.${field.id}`,
+      parentId: sectionId,
+      order: index,
+      label: field.label,
+      section: field.section,
+      fieldType: field.fieldType,
+      required: field.required,
+      options: field.options,
+      columns: field.columns,
+      condition: field.condition ? {
+        dependsOn: field.condition.dependsOn,
+        operator: "equals",
+        value: field.condition.whenValue,
+        whenValue: field.condition.whenValue
+      } : void 0
+    };
+    sectionNode.children = [...sectionNode.children ?? [], child];
+  }
+  return normalizeApplicationQuestionGraph({
+    id: options.id,
+    version: options.version ?? "v1",
+    title: options.title,
+    applicationType: options.applicationType,
+    source: options.source ?? "generated",
+    rootNodeIds: nodes.map((node) => node.id),
+    nodes
+  });
+}
+function normalizeApplicationQuestionGraph(graph) {
+  const normalizedNodes = graph.nodes.map((node, index) => normalizeNode(node, void 0, index)).sort(compareNodes);
+  return {
+    ...graph,
+    rootNodeIds: graph.rootNodeIds?.length ? graph.rootNodeIds : normalizedNodes.map((node) => node.id),
+    nodes: normalizedNodes
+  };
+}
+function flattenQuestionGraph(graph) {
+  const fields = [];
+  for (const node of graph.nodes.sort(compareNodes)) {
+    collectFields(node, fields);
+  }
+  return fields;
+}
+function getActiveApplicationFields(state) {
+  const valueByFieldId = new Map(
+    state.fields.filter((field) => field.value !== void 0 && field.value.trim() !== "").map((field) => [field.id, field.value ?? ""])
+  );
+  const graphConditions = /* @__PURE__ */ new Map();
+  for (const node of state.questionGraph?.nodes ?? []) {
+    collectNodeConditions(node, graphConditions);
+  }
+  return state.fields.filter((field) => {
+    const graphCondition = graphConditions.get(field.id);
+    return isConditionSatisfied(field.condition, valueByFieldId) && isQuestionConditionSatisfied(graphCondition, valueByFieldId);
+  });
+}
+function getNextApplicationQuestions(state, limit = 8) {
+  const activeUnfilled = getActiveApplicationFields(state).filter((field) => !field.value);
+  if (activeUnfilled.length === 0) return [];
+  const currentBatchIds = state.batches?.[state.currentBatchIndex] ?? [];
+  const currentBatchFields = activeUnfilled.filter((field) => currentBatchIds.includes(field.id));
+  return (currentBatchFields.length > 0 ? currentBatchFields : activeUnfilled).slice(0, limit);
+}
+function normalizeNode(node, parentId, index) {
+  const children = node.children?.map((child, childIndex) => normalizeNode(child, node.id, childIndex));
+  return {
+    ...node,
+    parentId: node.parentId ?? parentId,
+    order: node.order ?? index,
+    fieldPath: node.fieldPath ?? (node.fieldId ? [node.section, node.fieldId].filter(Boolean).join(".") : void 0),
+    children
+  };
+}
+function collectFields(node, fields) {
+  if ((node.nodeType === "question" || node.nodeType === "table") && node.fieldId) {
+    fields.push({
+      id: node.fieldId,
+      label: node.label,
+      section: node.section ?? "General",
+      fieldType: node.fieldType ?? (node.nodeType === "table" ? "table" : "text"),
+      required: node.required ?? false,
+      options: node.options,
+      columns: node.columns,
+      condition: node.condition ? {
+        dependsOn: node.condition.dependsOn,
+        whenValue: node.condition.value ?? node.condition.whenValue ?? ""
+      } : void 0,
+      fieldAnchorId: node.id
+    });
+  }
+  for (const child of node.children ?? []) {
+    collectFields(child, fields);
+  }
+}
+function collectNodeConditions(node, conditions) {
+  if (node.fieldId && node.condition) {
+    conditions.set(node.fieldId, node.condition);
+  }
+  for (const child of node.children ?? []) {
+    collectNodeConditions(child, conditions);
+  }
+}
+function isConditionSatisfied(condition, valueByFieldId) {
+  if (!condition) return true;
+  const current = valueByFieldId.get(condition.dependsOn);
+  return normalizeValue(current) === normalizeValue(condition.whenValue);
+}
+function isQuestionConditionSatisfied(condition, valueByFieldId) {
+  if (!condition) return true;
+  const current = valueByFieldId.get(condition.dependsOn);
+  const expected = condition.value ?? condition.whenValue;
+  const values = condition.values ?? (expected !== void 0 ? [expected] : []);
+  switch (condition.operator) {
+    case "exists":
+      return current !== void 0 && current.trim() !== "";
+    case "not_equals":
+      return normalizeValue(current) !== normalizeValue(expected);
+    case "in":
+      return values.map(normalizeValue).includes(normalizeValue(current));
+    case "not_in":
+      return !values.map(normalizeValue).includes(normalizeValue(current));
+    case "equals":
+    default:
+      return normalizeValue(current) === normalizeValue(expected);
+  }
+}
+function compareNodes(a, b) {
+  return (a.order ?? 0) - (b.order ?? 0) || a.id.localeCompare(b.id);
+}
+function normalizeValue(value) {
+  return (value ?? "").trim().toLowerCase();
+}
+function stableNodeId(parts) {
+  return parts.join(":").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "node";
+}
+
+// src/application/intake.ts
+function extractQuestionGraphFromFields(fields, options) {
+  return buildQuestionGraphFromFields(fields, options);
+}
+function createApplicationRun(params) {
+  const now = params.now ?? Date.now();
+  const graph = normalizeApplicationQuestionGraph(params.template.questionGraph);
+  const fields = params.template.fields?.length ? params.template.fields : flattenQuestionGraph(graph);
+  return {
+    id: params.applicationId,
+    templateId: params.template.id,
+    templateVersion: params.template.version,
+    templateSnapshot: params.template,
+    title: params.template.title,
+    applicationType: params.template.applicationType,
+    questionGraph: graph,
+    fields,
+    currentBatchIndex: 0,
+    status: "collecting",
+    createdAt: now,
+    updatedAt: now
+  };
+}
+function planNextApplicationQuestions(state, limit) {
+  const fields = getNextApplicationQuestions(state, limit);
+  return {
+    status: fields.length === 0 ? "complete" : "needs_answers",
+    fieldIds: fields.map((field) => field.id),
+    fields
+  };
+}
+function applyApplicationAnswers(state, answers, now = Date.now()) {
+  const answerByFieldId = new Map(answers.map((answer) => [answer.fieldId, answer]));
+  const fields = state.fields.map((field) => {
+    const answer = answerByFieldId.get(field.id);
+    if (!answer) return field;
+    return {
+      ...field,
+      value: answer.value,
+      source: answer.source ?? "user",
+      confidence: answer.confidence ?? "confirmed",
+      sourceSpanIds: answer.sourceSpanIds ?? field.sourceSpanIds,
+      userSourceSpanIds: answer.userSourceSpanIds ?? field.userSourceSpanIds,
+      validationStatus: "valid"
+    };
+  });
+  const nextState = {
+    ...state,
+    fields,
+    updatedAt: now
+  };
+  const nextQuestions = planNextApplicationQuestions(nextState);
+  return {
+    ...nextState,
+    status: nextQuestions.status === "complete" ? "confirming" : nextState.status,
+    qualityReport: buildApplicationQualityReport(nextState)
+  };
+}
+function proposeContextWrites(state) {
+  return getActiveApplicationFields(state).filter((field) => field.value && field.confidence && field.confidence !== "low").map((field) => ({
+    id: `${state.id}:${field.id}:context`,
+    fieldId: field.id,
+    key: stableContextKey(field),
+    value: field.value ?? "",
+    category: field.section,
+    source: field.source?.startsWith("lookup:") ? "lookup" : "application",
+    confidence: field.confidence ?? "medium",
+    sourceSpanIds: field.sourceSpanIds,
+    userSourceSpanIds: field.userSourceSpanIds
+  }));
+}
+function buildApplicationPacket(state, options = {}) {
+  const qualityReport = buildApplicationQualityReport(state);
+  const activeFields = getActiveApplicationFields(state);
+  const answers = activeFields.filter((field) => field.value).map((field) => ({
+    fieldId: field.id,
+    label: field.label,
+    section: field.section,
+    value: field.value ?? "",
+    source: field.source ?? "unknown",
+    confidence: field.confidence,
+    sourceSpanIds: field.sourceSpanIds,
+    userSourceSpanIds: field.userSourceSpanIds
+  }));
+  const missingFieldIds = activeFields.filter((field) => field.required && !field.value).map((field) => field.id);
+  return {
+    id: `${state.id}:packet`,
+    applicationId: state.id,
+    title: state.title ?? state.applicationType ?? "Insurance Application",
+    status: qualityReport.qualityGateStatus === "failed" || missingFieldIds.length > 0 ? "draft" : "broker_ready",
+    answers,
+    missingFieldIds,
+    qualityReport,
+    submissionNotes: options.submissionNotes,
+    createdAt: options.now ?? Date.now()
+  };
+}
+function validateApplicationPacket(packet) {
+  const issues = [...packet.qualityReport.issues];
+  if (packet.missingFieldIds.length > 0) {
+    issues.push({
+      code: "packet_missing_required_answers",
+      severity: "blocking",
+      message: "Packet still has required unanswered application fields."
+    });
+  }
+  return {
+    ...packet.qualityReport,
+    issues,
+    qualityGateStatus: issues.some((issue) => issue.severity === "blocking") ? "failed" : packet.qualityReport.qualityGateStatus
+  };
+}
+function stableContextKey(field) {
+  return `${field.section}.${field.label}`.trim().toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+}
+
 // src/application/coordinator.ts
 function createApplicationPipeline(config) {
   const {
     generateText,
     generateObject,
     applicationStore,
+    templateStore,
     documentStore,
     memoryStore,
     backfillProvider,
@@ -13434,11 +13925,18 @@ function createApplicationPipeline(config) {
     const applicationProviderOptions = input.sourceSpans?.length ? { ...providerOptions, sourceSpans: input.sourceSpans } : providerOptions;
     const id = input.applicationId ?? `app-${Date.now()}`;
     const now = Date.now();
+    if (input.template) {
+      await templateStore?.saveTemplate(input.template);
+    }
     let state = {
       id,
+      templateId: input.template?.id,
+      templateVersion: input.template?.version,
+      templateSnapshot: input.template,
       pdfBase64: void 0,
       title: void 0,
       applicationType: null,
+      questionGraph: input.questionGraph ?? input.template?.questionGraph,
       fields: [],
       qualityReport: void 0,
       batches: void 0,
@@ -13498,6 +13996,12 @@ function createApplicationPipeline(config) {
       return { state, tokenUsage: totalUsage, reviewReport: state.qualityReport };
     }
     state.fields = fields;
+    state.questionGraph = input.questionGraph ?? input.template?.questionGraph ?? buildQuestionGraphFromFields(fields, {
+      id: `${id}:graph`,
+      title: classifyResult.applicationType ?? void 0,
+      applicationType: classifyResult.applicationType,
+      source: "pdf"
+    });
     state.title = classifyResult.applicationType ?? void 0;
     state.status = "auto_filling";
     state.updatedAt = Date.now();
@@ -13518,8 +14022,10 @@ function createApplicationPipeline(config) {
           if (field && !field.value && pa.relevance > 0.8) {
             field.value = pa.value;
             field.source = `backfill: ${pa.source}`;
-            field.confidence = "high";
-            field.validationStatus = "needs_review";
+            field.confidence = pa.confidence ?? "high";
+            field.validationStatus = pa.sourceSpanIds?.length ? "valid" : "needs_review";
+            field.sourceSpanIds = pa.sourceSpanIds;
+            field.userSourceSpanIds = pa.userSourceSpanIds;
           }
         }
       } catch (e) {
@@ -13569,7 +14075,18 @@ function createApplicationPipeline(config) {
           try {
             const searchPromises = workflowPlan.documentSearchFields.map(
               (f) => limit(async () => {
-                await memoryStore.search(f.label, { limit: 3 });
+                const chunks = await memoryStore.search(`${f.section} ${f.label}`, { limit: 3 });
+                const match = selectMemoryBackfillMatch(f, chunks);
+                if (match) {
+                  const field = state.fields.find((candidate) => candidate.id === f.id);
+                  if (field && !field.value) {
+                    field.value = match.value;
+                    field.source = match.source;
+                    field.confidence = match.confidence;
+                    field.validationStatus = match.sourceSpanIds.length > 0 ? "valid" : "needs_review";
+                    field.sourceSpanIds = match.sourceSpanIds.length > 0 ? match.sourceSpanIds : void 0;
+                  }
+                }
               })
             );
             await Promise.all(searchPromises);
@@ -13589,7 +14106,7 @@ function createApplicationPipeline(config) {
       hasDocumentStore: false,
       hasMemoryStore: false
     });
-    const unfilledFields = workflowPlan.unfilledFields;
+    const unfilledFields = getActiveApplicationFields(state).filter((field) => !field.value);
     if (workflowPlan.runBatching) {
       onProgress?.(`Batching ${unfilledFields.length} remaining questions...`);
       state.status = "batching";
@@ -13611,6 +14128,7 @@ function createApplicationPipeline(config) {
     } else {
       state.status = "confirming";
     }
+    state.contextProposals = proposeContextWrites(state);
     state.qualityReport = buildApplicationQualityReport(state);
     state.updatedAt = Date.now();
     await applicationStore?.save(state);
@@ -13638,7 +14156,8 @@ function createApplicationPipeline(config) {
       throw new Error(`Application ${applicationId} not found`);
     }
     const currentBatchFieldIds = state.batches?.[state.currentBatchIndex] ?? [];
-    const currentBatchFields = state.fields.filter(
+    const activeFields = getActiveApplicationFields(state);
+    const currentBatchFields = activeFields.filter(
       (f) => currentBatchFieldIds.includes(f.id)
     );
     onProgress?.("Classifying reply...");
@@ -13761,14 +14280,16 @@ Provide a brief, helpful explanation (2-3 sentences). End with "Just reply with
         responseText = `I wasn't able to generate an explanation for your question. Could you rephrase it, or just provide the answer directly?`;
       }
     }
-    const currentBatchComplete = currentBatchFieldIds.every(
+    const activeCurrentBatchFieldIds = currentBatchFields.map((field) => field.id);
+    const currentBatchComplete = activeCurrentBatchFieldIds.every(
       (fid) => state.fields.find((f) => f.id === fid)?.value
     );
     let nextBatchIndex;
     let nextBatchFields;
     if (state.batches) {
       for (let index = state.currentBatchIndex + 1; index < state.batches.length; index++) {
-        const candidateFields = state.fields.filter((f) => state.batches[index].includes(f.id));
+        const activeCandidateFields = getActiveApplicationFields(state);
+        const candidateFields = activeCandidateFields.filter((f) => state.batches[index].includes(f.id));
         if (candidateFields.some((f) => !f.value)) {
           nextBatchIndex = index;
           nextBatchFields = candidateFields;
@@ -13824,7 +14345,8 @@ ${emailText}`;
       }
     }
     state.updatedAt = Date.now();
-    state.qualityReport = state.qualityReport ?? buildApplicationQualityReport(state);
+    state.contextProposals = proposeContextWrites(state);
+    state.qualityReport = buildApplicationQualityReport(state);
     await applicationStore?.save(state);
     if (shouldFailQualityGate(qualityGate, state.qualityReport.qualityGateStatus)) {
       throw new Error("Application quality gate failed. See state.qualityReport for blocking issues.");
@@ -13844,7 +14366,7 @@ ${emailText}`;
     if (!state) throw new Error(`Application ${applicationId} not found`);
     if (!state.batches?.length) throw new Error("No batches available");
     const batchFieldIds = state.batches[state.currentBatchIndex];
-    const batchFields = state.fields.filter((f) => batchFieldIds.includes(f.id));
+    const batchFields = getActiveApplicationFields(state).filter((f) => batchFieldIds.includes(f.id));
     const filledCount = state.fields.filter((f) => f.value).length;
     const { text, usage } = await generateBatchEmail(
       batchFields,
@@ -13892,13 +14414,86 @@ ${fieldSummary}`,
     trackUsage(usage);
     return { text, tokenUsage: totalUsage };
   }
+  async function createApplicationRun2(input) {
+    const state = createApplicationRun(input);
+    await applicationStore?.save(state);
+    return state;
+  }
+  async function planNextQuestions(applicationId, limit2) {
+    const state = await applicationStore?.get(applicationId);
+    if (!state) throw new Error(`Application ${applicationId} not found`);
+    return planNextApplicationQuestions(state, limit2);
+  }
+  async function proposeContextWrites2(applicationId) {
+    const state = await applicationStore?.get(applicationId);
+    if (!state) throw new Error(`Application ${applicationId} not found`);
+    const proposals = proposeContextWrites(state);
+    await applicationStore?.save({
+      ...state,
+      contextProposals: proposals,
+      updatedAt: Date.now()
+    });
+    return { proposals };
+  }
+  async function buildApplicationPacket2(input) {
+    const state = await applicationStore?.get(input.applicationId);
+    if (!state) throw new Error(`Application ${input.applicationId} not found`);
+    const packet = buildApplicationPacket(state, {
+      submissionNotes: input.submissionNotes,
+      now: input.now
+    });
+    const reviewReport = validateApplicationPacket(packet);
+    await applicationStore?.save({
+      ...state,
+      packet: { ...packet, qualityReport: reviewReport },
+      status: reviewReport.qualityGateStatus === "failed" ? "broker_review" : "packet_ready",
+      qualityReport: reviewReport,
+      updatedAt: Date.now()
+    });
+    return { packet: { ...packet, qualityReport: reviewReport }, reviewReport };
+  }
   return {
     processApplication,
     processReply: processReply2,
     generateCurrentBatchEmail,
-    getConfirmationSummary
+    getConfirmationSummary,
+    createApplicationRun: createApplicationRun2,
+    planNextQuestions,
+    proposeContextWrites: proposeContextWrites2,
+    buildApplicationPacket: buildApplicationPacket2
   };
 }
+function selectMemoryBackfillMatch(field, chunks) {
+  for (const chunk of chunks) {
+    const value = chunk.metadata.value ?? chunk.metadata.answer ?? chunk.metadata.fieldValue;
+    if (!value) continue;
+    const metadataFieldId = chunk.metadata.fieldId ?? chunk.metadata.applicationFieldId;
+    const metadataLabel = chunk.metadata.fieldLabel?.toLowerCase();
+    const labelMatches = metadataLabel === field.label.toLowerCase();
+    if (metadataFieldId && metadataFieldId !== field.id && !labelMatches) continue;
+    return {
+      value,
+      source: chunk.metadata.source ?? `memory: ${chunk.documentId}`,
+      confidence: metadataFieldId === field.id || labelMatches ? "high" : "medium",
+      sourceSpanIds: parseSourceSpanIds(chunk.metadata.sourceSpanIds)
+    };
+  }
+  return null;
+}
+function parseSourceSpanIds(value) {
+  if (!value) return [];
+  const trimmed = value.trim();
+  if (!trimmed) return [];
+  if (trimmed.startsWith("[")) {
+    try {
+      const parsed = JSON.parse(trimmed);
+      return Array.isArray(parsed) ? parsed.filter((item) => typeof item === "string") : [];
+    } catch {
+      return [];
+    }
+  }
+  return trimmed.split(",").map((item) => item.trim()).filter(Boolean);
+}
 
 // src/prompts/application/confirmation.ts
 function buildConfirmationSummaryPrompt(fields, applicationTitle) {
@@ -15978,13 +16573,21 @@ export {
   AgenticExecutionModeSchema,
   AnswerParsingResultSchema,
   ApplicationClassifyResultSchema,
+  ApplicationContextProposalSchema,
   ApplicationEmailReviewSchema,
   ApplicationFieldSchema,
+  ApplicationPacketAnswerSchema,
+  ApplicationPacketSchema,
   ApplicationQualityArtifactSchema,
   ApplicationQualityIssueSchema,
   ApplicationQualityReportSchema,
   ApplicationQualityRoundSchema,
+  ApplicationQuestionConditionSchema,
+  ApplicationQuestionGraphSchema,
+  ApplicationQuestionNodeSchema,
+  ApplicationRepeatSchema,
   ApplicationStateSchema,
+  ApplicationTemplateSchema,
   AttachmentInterpretationSchema,
   AuditTypeSchema,
   AutoFillMatchSchema,
@@ -16199,9 +16802,11 @@ export {
   VerifyResultSchema,
   WatercraftDeclarationsSchema,
   WorkersCompDeclarationsSchema,
+  applyApplicationAnswers,
   buildAcroFormMappingPrompt,
   buildAgentSystemPrompt,
   buildAnswerParsingPrompt,
+  buildApplicationPacket,
   buildAutoFillPrompt,
   buildBatchEmailGenerationPrompt,
   buildClassifyMessagePrompt,
@@ -16228,6 +16833,7 @@ export {
   buildPdfProviderOptions,
   buildQueryClassifyPrompt,
   buildQuestionBatchPrompt,
+  buildQuestionGraphFromFields,
   buildQuotesPoliciesPrompt,
   buildReasonPrompt,
   buildReplyIntentClassificationPrompt,
@@ -16243,6 +16849,7 @@ export {
   collectPceEvidenceSources,
   compareSourceEvidence,
   createApplicationPipeline,
+  createApplicationRun,
   createExtractor,
   createPceAgent,
   createPipelineContext,
@@ -16250,12 +16857,16 @@ export {
   evaluateCaseProposals,
   evidenceContainsQuote,
   extractPageRange,
+  extractQuestionGraphFromFields,
   fillAcroForm,
+  flattenQuestionGraph,
   generateNextMessage,
   getAcroFormFields,
+  getActiveApplicationFields,
   getDoclingPageRangeText,
   getExtractor,
   getFileIdentifier,
+  getNextApplicationQuestions,
   getPdfPageCount,
   getTemplate,
   isDoclingExtractionInput,
@@ -16263,6 +16874,7 @@ export {
   mergeOperationalProfile,
   mergeQuestionAnswers,
   mergeSourceSpans,
+  normalizeApplicationQuestionGraph,
   normalizeDoclingDocument,
   normalizeDocumentSourceTreePaths,
   normalizeForMatch,
@@ -16272,7 +16884,9 @@ export {
   pLimit,
   pdfInputToBase64,
   pdfInputToBytes,
+  planNextApplicationQuestions,
   processReply,
+  proposeContextWrites,
   resolveModelBudget,
   safeGenerateObject,
   sanitizeNulls,
@@ -16285,6 +16899,7 @@ export {
   stableStringify,
   stripFences,
   toStrictSchema,
+  validateApplicationPacket,
   validateEvidence,
   validatePceItems,
   validateQuotedEvidence,