@claritylabs/cl-sdk 3.0.33 → 3.1.2

package/dist/index.js

@@ -28,8 +28,8 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
-var index_exports = {};
-__export(index_exports, {
+var src_exports = {};
+__export(src_exports, {
   ADMITTED_STATUSES: () => ADMITTED_STATUSES,
   AGENT_TOOLS: () => AGENT_TOOLS,
   APPLICATION_CLASSIFY_PROMPT: () => APPLICATION_CLASSIFY_PROMPT,
@@ -40,13 +40,21 @@ __export(index_exports, {
   AgenticExecutionModeSchema: () => AgenticExecutionModeSchema,
   AnswerParsingResultSchema: () => AnswerParsingResultSchema,
   ApplicationClassifyResultSchema: () => ApplicationClassifyResultSchema,
+  ApplicationContextProposalSchema: () => ApplicationContextProposalSchema,
   ApplicationEmailReviewSchema: () => ApplicationEmailReviewSchema,
   ApplicationFieldSchema: () => ApplicationFieldSchema,
+  ApplicationPacketAnswerSchema: () => ApplicationPacketAnswerSchema,
+  ApplicationPacketSchema: () => ApplicationPacketSchema,
   ApplicationQualityArtifactSchema: () => ApplicationQualityArtifactSchema,
   ApplicationQualityIssueSchema: () => ApplicationQualityIssueSchema,
   ApplicationQualityReportSchema: () => ApplicationQualityReportSchema,
   ApplicationQualityRoundSchema: () => ApplicationQualityRoundSchema,
+  ApplicationQuestionConditionSchema: () => ApplicationQuestionConditionSchema,
+  ApplicationQuestionGraphSchema: () => ApplicationQuestionGraphSchema,
+  ApplicationQuestionNodeSchema: () => ApplicationQuestionNodeSchema,
+  ApplicationRepeatSchema: () => ApplicationRepeatSchema,
   ApplicationStateSchema: () => ApplicationStateSchema,
+  ApplicationTemplateSchema: () => ApplicationTemplateSchema,
   AttachmentInterpretationSchema: () => AttachmentInterpretationSchema,
   AuditTypeSchema: () => AuditTypeSchema,
   AutoFillMatchSchema: () => AutoFillMatchSchema,
@@ -261,9 +269,11 @@ __export(index_exports, {
   VerifyResultSchema: () => VerifyResultSchema,
   WatercraftDeclarationsSchema: () => WatercraftDeclarationsSchema,
   WorkersCompDeclarationsSchema: () => WorkersCompDeclarationsSchema,
+  applyApplicationAnswers: () => applyApplicationAnswers,
   buildAcroFormMappingPrompt: () => buildAcroFormMappingPrompt,
   buildAgentSystemPrompt: () => buildAgentSystemPrompt,
   buildAnswerParsingPrompt: () => buildAnswerParsingPrompt,
+  buildApplicationPacket: () => buildApplicationPacket,
   buildAutoFillPrompt: () => buildAutoFillPrompt,
   buildBatchEmailGenerationPrompt: () => buildBatchEmailGenerationPrompt,
   buildClassifyMessagePrompt: () => buildClassifyMessagePrompt,
@@ -290,6 +300,7 @@ __export(index_exports, {
   buildPdfProviderOptions: () => buildPdfProviderOptions,
   buildQueryClassifyPrompt: () => buildQueryClassifyPrompt,
   buildQuestionBatchPrompt: () => buildQuestionBatchPrompt,
+  buildQuestionGraphFromFields: () => buildQuestionGraphFromFields,
   buildQuotesPoliciesPrompt: () => buildQuotesPoliciesPrompt,
   buildReasonPrompt: () => buildReasonPrompt,
   buildReplyIntentClassificationPrompt: () => buildReplyIntentClassificationPrompt,
@@ -305,6 +316,7 @@ __export(index_exports, {
   collectPceEvidenceSources: () => collectPceEvidenceSources,
   compareSourceEvidence: () => compareSourceEvidence,
   createApplicationPipeline: () => createApplicationPipeline,
+  createApplicationRun: () => createApplicationRun,
   createExtractor: () => createExtractor,
   createPceAgent: () => createPceAgent,
   createPipelineContext: () => createPipelineContext,
@@ -312,12 +324,16 @@ __export(index_exports, {
   evaluateCaseProposals: () => evaluateCaseProposals,
   evidenceContainsQuote: () => evidenceContainsQuote,
   extractPageRange: () => extractPageRange,
+  extractQuestionGraphFromFields: () => extractQuestionGraphFromFields,
   fillAcroForm: () => fillAcroForm,
+  flattenQuestionGraph: () => flattenQuestionGraph,
   generateNextMessage: () => generateNextMessage,
   getAcroFormFields: () => getAcroFormFields,
+  getActiveApplicationFields: () => getActiveApplicationFields,
   getDoclingPageRangeText: () => getDoclingPageRangeText,
   getExtractor: () => getExtractor,
   getFileIdentifier: () => getFileIdentifier,
+  getNextApplicationQuestions: () => getNextApplicationQuestions,
   getPdfPageCount: () => getPdfPageCount,
   getTemplate: () => getTemplate,
   isDoclingExtractionInput: () => isDoclingExtractionInput,
@@ -325,6 +341,7 @@ __export(index_exports, {
   mergeOperationalProfile: () => mergeOperationalProfile,
   mergeQuestionAnswers: () => mergeQuestionAnswers,
   mergeSourceSpans: () => mergeSourceSpans,
+  normalizeApplicationQuestionGraph: () => normalizeApplicationQuestionGraph,
   normalizeDoclingDocument: () => normalizeDoclingDocument,
   normalizeDocumentSourceTreePaths: () => normalizeDocumentSourceTreePaths,
   normalizeForMatch: () => normalizeForMatch,
@@ -334,7 +351,9 @@ __export(index_exports, {
   pLimit: () => pLimit,
   pdfInputToBase64: () => pdfInputToBase64,
   pdfInputToBytes: () => pdfInputToBytes,
+  planNextApplicationQuestions: () => planNextApplicationQuestions,
   processReply: () => processReply,
+  proposeContextWrites: () => proposeContextWrites,
   resolveModelBudget: () => resolveModelBudget,
   safeGenerateObject: () => safeGenerateObject,
   sanitizeNulls: () => sanitizeNulls,
@@ -347,12 +366,13 @@ __export(index_exports, {
   stableStringify: () => stableStringify,
   stripFences: () => stripFences,
   toStrictSchema: () => toStrictSchema,
+  validateApplicationPacket: () => validateApplicationPacket,
   validateEvidence: () => validateEvidence,
   validatePceItems: () => validatePceItems,
   validateQuotedEvidence: () => validateQuotedEvidence,
   withRetry: () => withRetry
 });
-module.exports = __toCommonJS(index_exports);
+module.exports = __toCommonJS(src_exports);
 
 // src/core/retry.ts
 var MAX_RETRIES = 5;
@@ -3591,6 +3611,12 @@ function moneyAmount(value) {
 function normalizeLabel(value) {
   return normalizeWhitespace3(value ?? "").toLowerCase();
 }
+function isGenericColumnLabel(value) {
+  return /^column\s+\d+$/i.test(cleanValue(value) ?? "");
+}
+function isHeaderRow(row) {
+  return row.metadata?.isHeader === true || row.metadata?.isHeader === "true";
+}
 var OPERATIONAL_COVERAGE_TERM_KINDS = /* @__PURE__ */ new Set([
   "each_claim_limit",
   "each_occurrence_limit",
@@ -3611,6 +3637,7 @@ function termKind(label, value) {
   if (/\bpremium\b/.test(text)) return "premium";
   if (/\bsub[-\s]?limit\b/.test(text)) return "sublimit";
   if (/\baggregate\b/.test(text)) return "aggregate_limit";
+  if (/\beach\s+proceeding|per\s+proceeding\b/.test(text)) return "sublimit";
   if (/\beach\s+claim|per\s+claim\b/.test(text)) return "each_claim_limit";
   if (/\beach\s+occurrence|per\s+occurrence\b/.test(text)) return "each_occurrence_limit";
   if (/\beach\s+loss|per\s+loss\b/.test(text)) return "each_loss_limit";
@@ -3637,9 +3664,13 @@ function isNameCell(label, value) {
   const normalizedLabel = normalizeLabel(label);
   const normalizedValue = normalizeLabel(value);
   if (!value || moneyAmount(value) !== void 0) return false;
+  if (/^item\s+\d+[.)]?\s*limits?\s+of\s+liability\b/.test(normalizedValue)) return false;
   if (/\b(coverage|coverage part|insuring agreement|description|item|name)\b/.test(normalizedLabel)) {
     return true;
   }
+  if (/\b(sub[-\s]?limit|aggregate(?:\s+policy)?\s+limit|limit\s+of\s+liability)\b/.test(normalizedLabel) && /\b[a-z][a-z0-9&/ -]{2,}\b/.test(normalizedValue) && !/\bcoverage\s+part\s+[a-z]\)?$/.test(normalizedValue)) {
+    return true;
+  }
   if (/^column\s+1$/.test(normalizedLabel) && !/^(item\s+\d+|nwc-|iso-|cg |il |form\b|page\b)/i.test(normalizedValue)) {
     return true;
   }
@@ -3658,13 +3689,32 @@ function childMap(nodes) {
   for (const group of children.values()) group.sort((left, right) => left.order - right.order);
   return children;
 }
-function cellRows(row, children) {
+function rawCellRows(row, children) {
   return (children.get(row.id) ?? []).filter((child) => child.kind === "table_cell").map((cell) => ({
     label: cleanValue(cell.title) ?? "Value",
     value: cleanValue(cell.textExcerpt ?? cell.description ?? cell.title) ?? "",
     node: cell
   })).filter((cell) => cell.value);
 }
+function headerLabelsForRow(row, children) {
+  if (!row.parentId) return [];
+  const labels = [];
+  const siblingRows = (children.get(row.parentId) ?? []).filter((candidate) => candidate.kind === "table_row" && candidate.order < row.order).sort((left, right) => left.order - right.order);
+  for (const sibling of siblingRows) {
+    if (!isHeaderRow(sibling)) continue;
+    for (const [index, cell] of rawCellRows(sibling, children).entries()) {
+      const label = cleanValue(cell.value) ?? cleanValue(cell.label);
+      if (label && !isGenericColumnLabel(label)) labels[index] = label;
+    }
+  }
+  return labels;
+}
+function cellRows(row, children, headerLabels = []) {
+  return rawCellRows(row, children).map((cell, index) => ({
+    ...cell,
+    label: isGenericColumnLabel(cell.label) && headerLabels[index] ? headerLabels[index] : cell.label
+  }));
+}
 function directChildren(parent, children) {
   return children.get(parent.id) ?? [];
 }
@@ -3717,8 +3767,9 @@ function relabelGenericTerm(term, label) {
   };
 }
 function termFromCell(params) {
-  const value = cleanValue(params.value);
+  const value = cleanCoverageTermValue(params.value);
   if (!value) return void 0;
+  if (isRejectedCoverageTermValue(params.label, value)) return void 0;
   const nodes = [params.row, params.cell].filter((node) => Boolean(node));
   const kind = termKind(params.label, value);
   const amount = moneyAmount(value);
@@ -3731,20 +3782,38 @@ function termFromCell(params) {
     ...sourceIds(nodes)
   };
 }
+function cleanCoverageTermValue(value) {
+  return cleanValue(value)?.replace(/\s+\/\s*$/, "").trim();
+}
+function isRejectedCoverageTermValue(label, value) {
+  if (/\bshown\s+in\s+item\s*\d+\b/i.test(value) && moneyAmount(value) === void 0) return true;
+  if (/\b(does not afford coverage|doesn't afford coverage|no coverage|remains excluded|is excluded|are excluded|shall not cover|will not cover)\b/i.test(value) && moneyAmount(value) === void 0) {
+    return true;
+  }
+  if (/^for:\s*\(\d+\)/i.test(label) && moneyAmount(value) === void 0) return true;
+  if (value.length > 80 && /\b(exclusion|excluded|shall not|will not|does not|failure to)\b/i.test(value) && moneyAmount(value) === void 0) return true;
+  return false;
+}
 function termsFromRow(row, children) {
-  const cells = cellRows(row, children);
+  const cells = cellRows(row, children, headerLabelsForRow(row, children));
   if (cells.length > 0) {
     const pairedTerms = [];
+    const pairedIndexes = /* @__PURE__ */ new Set();
     for (const [index, cell] of cells.entries()) {
       const next = cells[index + 1];
       if (!next) continue;
+      if (!isGenericColumnLabel(cell.label) && isNameCell(cell.label, cell.value)) continue;
       if (!isCoverageTermLabel(cell.value)) continue;
       if (isCoverageTermLabel(next.value) && moneyAmount(next.value) === void 0) continue;
       const term = termFromCell({ row, cell: next.node, label: cell.value, value: next.value });
-      if (term) pairedTerms.push(term);
+      if (term) {
+        pairedTerms.push(term);
+        pairedIndexes.add(index);
+        pairedIndexes.add(index + 1);
+      }
     }
-    if (pairedTerms.length > 0) return pairedTerms;
-    return cells.filter((cell) => isValueCell(cell.label, cell.value)).map((cell) => termFromCell({ row, cell: cell.node, label: cell.label, value: cell.value })).filter((term) => Boolean(term));
+    const valueTerms = cells.filter((_, index) => !pairedIndexes.has(index)).filter((cell) => isValueCell(cell.label, cell.value)).map((cell) => termFromCell({ row, cell: cell.node, label: cell.label, value: cell.value })).filter((term) => Boolean(term));
+    return [...pairedTerms, ...valueTerms];
   }
   const text = normalizeWhitespace3(row.textExcerpt ?? row.description ?? nodeText(row));
   const terms = [];
@@ -3770,11 +3839,11 @@ function termsFromRow(row, children) {
   return terms;
 }
 function nameFromRow(row, children) {
-  const declarationName = declarationCoverageNameFromRow(row, children);
-  if (declarationName) return declarationName;
-  const cells = cellRows(row, children);
+  const cells = cellRows(row, children, headerLabelsForRow(row, children));
   const named = cells.find((cell) => isNameCell(cell.label, cell.value));
   if (named) return cleanValue(named.value);
+  const declarationName = declarationCoverageNameFromRow(row, children);
+  if (declarationName) return declarationName;
   return coverageNameFromRow(row.textExcerpt ?? row.description ?? nodeText(row));
 }
 function legacyLimit(terms) {
@@ -3807,7 +3876,7 @@ function isOperationalCoverageRow(coverage) {
   if (coverage.name.split(/\s+/).length > 16 && !/\b(coverage|liability|sub[-\s]?limit|aggregate|each\s+(claim|loss|occurrence)|limit)\b/i.test(coverage.name)) {
     return false;
   }
-  return /\b(coverage|coverage part|liability|sub[-\s]?limit|aggregate|each\s+(claim|loss|occurrence)|bricking|cyber|privacy|media|regulatory|defense|ai\/ml|errors?\s*&?\s*omissions|technology)\b/i.test(coverage.name);
+  return /\b(coverage|coverage part|liability|sub[-\s]?limit|aggregate|each\s+(claim|loss|occurrence|proceeding)|bricking|cyber|privacy|media|regulatory|defense|fraud|social engineering|ai\/ml|errors?\s*&?\s*omissions|technology)\b/i.test(coverage.name);
 }
 function uniqueTerms(terms) {
   const seen = /* @__PURE__ */ new Set();
@@ -3821,7 +3890,7 @@ function uniqueTerms(terms) {
   return result;
 }
 function coverageFromTableRow(row, children, byId) {
-  if (row.metadata?.isHeader === true || row.metadata?.isHeader === "true") return void 0;
+  if (isHeaderRow(row)) return void 0;
   const name = nameFromRow(row, children);
   const terms = uniqueTerms(termsFromRow(row, children));
   if (!name || terms.length === 0) return void 0;
@@ -13012,6 +13081,55 @@ var ApplicationFieldSchema = import_zod42.z.object({
   acroFormName: import_zod42.z.string().optional().describe("Native PDF AcroForm field name when available"),
   validationStatus: import_zod42.z.enum(["valid", "needs_review", "unsupported", "missing"]).optional()
 });
+var ApplicationQuestionConditionSchema = import_zod42.z.object({
+  dependsOn: import_zod42.z.string(),
+  operator: import_zod42.z.enum(["equals", "not_equals", "in", "not_in", "exists"]).optional(),
+  value: import_zod42.z.string().optional(),
+  whenValue: import_zod42.z.string().optional(),
+  values: import_zod42.z.array(import_zod42.z.string()).optional()
+});
+var ApplicationRepeatSchema = import_zod42.z.object({
+  min: import_zod42.z.number().int().nonnegative().optional(),
+  max: import_zod42.z.number().int().positive().optional(),
+  label: import_zod42.z.string().optional()
+});
+var ApplicationQuestionNodeSchema = import_zod42.z.lazy(
+  () => import_zod42.z.object({
+    id: import_zod42.z.string(),
+    nodeType: import_zod42.z.enum(["group", "question", "repeat_group", "table"]),
+    fieldId: import_zod42.z.string().optional(),
+    fieldPath: import_zod42.z.string().optional(),
+    parentId: import_zod42.z.string().optional(),
+    order: import_zod42.z.number().int().nonnegative().optional(),
+    label: import_zod42.z.string(),
+    section: import_zod42.z.string().optional(),
+    fieldType: FieldTypeSchema.optional(),
+    required: import_zod42.z.boolean().optional(),
+    prompt: import_zod42.z.string().optional(),
+    options: import_zod42.z.array(import_zod42.z.string()).optional(),
+    columns: import_zod42.z.array(import_zod42.z.string()).optional(),
+    condition: ApplicationQuestionConditionSchema.optional(),
+    repeat: ApplicationRepeatSchema.optional(),
+    children: import_zod42.z.array(ApplicationQuestionNodeSchema).optional()
+  })
+);
+var ApplicationQuestionGraphSchema = import_zod42.z.object({
+  id: import_zod42.z.string(),
+  version: import_zod42.z.string(),
+  title: import_zod42.z.string().optional(),
+  applicationType: import_zod42.z.string().nullable().optional(),
+  source: import_zod42.z.enum(["pdf", "manual", "imported", "generated"]).default("generated"),
+  rootNodeIds: import_zod42.z.array(import_zod42.z.string()).optional(),
+  nodes: import_zod42.z.array(ApplicationQuestionNodeSchema)
+});
+var ApplicationTemplateSchema = import_zod42.z.object({
+  id: import_zod42.z.string(),
+  version: import_zod42.z.string(),
+  title: import_zod42.z.string(),
+  applicationType: import_zod42.z.string().nullable().optional(),
+  questionGraph: ApplicationQuestionGraphSchema,
+  fields: import_zod42.z.array(ApplicationFieldSchema).optional()
+});
 var ApplicationClassifyResultSchema = import_zod42.z.object({
   isApplication: import_zod42.z.boolean(),
   confidence: import_zod42.z.number().min(0).max(1),
@@ -13109,16 +13227,67 @@ var ApplicationQualityReportSchema = import_zod42.z.object({
   emailReview: ApplicationEmailReviewSchema.optional(),
   qualityGateStatus: QualityGateStatusSchema
 });
+var ApplicationContextProposalSchema = import_zod42.z.object({
+  id: import_zod42.z.string(),
+  fieldId: import_zod42.z.string().optional(),
+  key: import_zod42.z.string(),
+  value: import_zod42.z.string(),
+  category: import_zod42.z.string(),
+  source: import_zod42.z.enum(["application", "user", "lookup", "policy", "email", "chat", "imessage", "mcp"]),
+  confidence: import_zod42.z.enum(["confirmed", "high", "medium", "low"]),
+  sourceSpanIds: import_zod42.z.array(import_zod42.z.string()).optional(),
+  userSourceSpanIds: import_zod42.z.array(import_zod42.z.string()).optional()
+});
+var ApplicationPacketAnswerSchema = import_zod42.z.object({
+  fieldId: import_zod42.z.string(),
+  label: import_zod42.z.string(),
+  section: import_zod42.z.string(),
+  value: import_zod42.z.string(),
+  source: import_zod42.z.string(),
+  confidence: import_zod42.z.enum(["confirmed", "high", "medium", "low"]).optional(),
+  sourceSpanIds: import_zod42.z.array(import_zod42.z.string()).optional(),
+  userSourceSpanIds: import_zod42.z.array(import_zod42.z.string()).optional()
+});
+var ApplicationPacketSchema = import_zod42.z.object({
+  id: import_zod42.z.string(),
+  applicationId: import_zod42.z.string(),
+  title: import_zod42.z.string(),
+  status: import_zod42.z.enum(["draft", "broker_ready", "submitted"]),
+  answers: import_zod42.z.array(ApplicationPacketAnswerSchema),
+  missingFieldIds: import_zod42.z.array(import_zod42.z.string()),
+  qualityReport: ApplicationQualityReportSchema,
+  submissionNotes: import_zod42.z.string().optional(),
+  createdAt: import_zod42.z.number()
+});
 var ApplicationStateSchema = import_zod42.z.object({
   id: import_zod42.z.string(),
   pdfBase64: import_zod42.z.string().optional().describe("Original PDF, omitted after extraction"),
+  templateId: import_zod42.z.string().optional(),
+  templateVersion: import_zod42.z.string().optional(),
+  templateSnapshot: ApplicationTemplateSchema.optional(),
   title: import_zod42.z.string().optional(),
   applicationType: import_zod42.z.string().nullable().optional(),
+  questionGraph: ApplicationQuestionGraphSchema.optional(),
   fields: import_zod42.z.array(ApplicationFieldSchema),
   batches: import_zod42.z.array(import_zod42.z.array(import_zod42.z.string())).optional(),
   currentBatchIndex: import_zod42.z.number().default(0),
+  contextProposals: import_zod42.z.array(ApplicationContextProposalSchema).optional(),
+  packet: ApplicationPacketSchema.optional(),
   qualityReport: ApplicationQualityReportSchema.optional(),
-  status: import_zod42.z.enum(["classifying", "extracting", "auto_filling", "batching", "collecting", "confirming", "mapping", "complete"]),
+  status: import_zod42.z.enum([
+    "classifying",
+    "extracting",
+    "auto_filling",
+    "batching",
+    "collecting",
+    "confirming",
+    "mapping",
+    "broker_review",
+    "packet_ready",
+    "submitted",
+    "cancelled",
+    "complete"
+  ]),
   createdAt: import_zod42.z.number(),
   updatedAt: import_zod42.z.number()
 });
@@ -13817,7 +13986,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
   };
 }
@@ -13856,12 +14025,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,
@@ -13898,11 +14342,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,
@@ -13962,6 +14413,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();
@@ -13982,8 +14439,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) {
@@ -14033,7 +14492,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);
@@ -14053,7 +14523,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";
@@ -14075,6 +14545,7 @@ function createApplicationPipeline(config) {
     } else {
       state.status = "confirming";
     }
+    state.contextProposals = proposeContextWrites(state);
     state.qualityReport = buildApplicationQualityReport(state);
     state.updatedAt = Date.now();
     await applicationStore?.save(state);
@@ -14102,7 +14573,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...");
@@ -14225,14 +14697,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;
@@ -14288,7 +14762,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.");
@@ -14308,7 +14783,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,
@@ -14356,13 +14831,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) {
@@ -16443,13 +16991,21 @@ var AGENT_TOOLS = [
   AgenticExecutionModeSchema,
   AnswerParsingResultSchema,
   ApplicationClassifyResultSchema,
+  ApplicationContextProposalSchema,
   ApplicationEmailReviewSchema,
   ApplicationFieldSchema,
+  ApplicationPacketAnswerSchema,
+  ApplicationPacketSchema,
   ApplicationQualityArtifactSchema,
   ApplicationQualityIssueSchema,
   ApplicationQualityReportSchema,
   ApplicationQualityRoundSchema,
+  ApplicationQuestionConditionSchema,
+  ApplicationQuestionGraphSchema,
+  ApplicationQuestionNodeSchema,
+  ApplicationRepeatSchema,
   ApplicationStateSchema,
+  ApplicationTemplateSchema,
   AttachmentInterpretationSchema,
   AuditTypeSchema,
   AutoFillMatchSchema,
@@ -16664,9 +17220,11 @@ var AGENT_TOOLS = [
   VerifyResultSchema,
   WatercraftDeclarationsSchema,
   WorkersCompDeclarationsSchema,
+  applyApplicationAnswers,
   buildAcroFormMappingPrompt,
   buildAgentSystemPrompt,
   buildAnswerParsingPrompt,
+  buildApplicationPacket,
   buildAutoFillPrompt,
   buildBatchEmailGenerationPrompt,
   buildClassifyMessagePrompt,
@@ -16693,6 +17251,7 @@ var AGENT_TOOLS = [
   buildPdfProviderOptions,
   buildQueryClassifyPrompt,
   buildQuestionBatchPrompt,
+  buildQuestionGraphFromFields,
   buildQuotesPoliciesPrompt,
   buildReasonPrompt,
   buildReplyIntentClassificationPrompt,
@@ -16708,6 +17267,7 @@ var AGENT_TOOLS = [
   collectPceEvidenceSources,
   compareSourceEvidence,
   createApplicationPipeline,
+  createApplicationRun,
   createExtractor,
   createPceAgent,
   createPipelineContext,
@@ -16715,12 +17275,16 @@ var AGENT_TOOLS = [
   evaluateCaseProposals,
   evidenceContainsQuote,
   extractPageRange,
+  extractQuestionGraphFromFields,
   fillAcroForm,
+  flattenQuestionGraph,
   generateNextMessage,
   getAcroFormFields,
+  getActiveApplicationFields,
   getDoclingPageRangeText,
   getExtractor,
   getFileIdentifier,
+  getNextApplicationQuestions,
   getPdfPageCount,
   getTemplate,
   isDoclingExtractionInput,
@@ -16728,6 +17292,7 @@ var AGENT_TOOLS = [
   mergeOperationalProfile,
   mergeQuestionAnswers,
   mergeSourceSpans,
+  normalizeApplicationQuestionGraph,
   normalizeDoclingDocument,
   normalizeDocumentSourceTreePaths,
   normalizeForMatch,
@@ -16737,7 +17302,9 @@ var AGENT_TOOLS = [
   pLimit,
   pdfInputToBase64,
   pdfInputToBytes,
+  planNextApplicationQuestions,
   processReply,
+  proposeContextWrites,
   resolveModelBudget,
   safeGenerateObject,
   sanitizeNulls,
@@ -16750,6 +17317,7 @@ var AGENT_TOOLS = [
   stableStringify,
   stripFences,
   toStrictSchema,
+  validateApplicationPacket,
   validateEvidence,
   validatePceItems,
   validateQuotedEvidence,