@claritylabs/cl-sdk 3.0.33 → 3.1.0

package/dist/index.mjs

@@ -12664,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),
@@ -12761,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()
 });
@@ -13469,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
   };
 }
@@ -13508,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,
@@ -13550,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,
@@ -13614,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();
@@ -13634,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) {
@@ -13685,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);
@@ -13705,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";
@@ -13727,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);
@@ -13754,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...");
@@ -13877,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;
@@ -13940,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.");
@@ -13960,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,
@@ -14008,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) {
@@ -16094,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,
@@ -16315,9 +16802,11 @@ export {
   VerifyResultSchema,
   WatercraftDeclarationsSchema,
   WorkersCompDeclarationsSchema,
+  applyApplicationAnswers,
   buildAcroFormMappingPrompt,
   buildAgentSystemPrompt,
   buildAnswerParsingPrompt,
+  buildApplicationPacket,
   buildAutoFillPrompt,
   buildBatchEmailGenerationPrompt,
   buildClassifyMessagePrompt,
@@ -16344,6 +16833,7 @@ export {
   buildPdfProviderOptions,
   buildQueryClassifyPrompt,
   buildQuestionBatchPrompt,
+  buildQuestionGraphFromFields,
   buildQuotesPoliciesPrompt,
   buildReasonPrompt,
   buildReplyIntentClassificationPrompt,
@@ -16359,6 +16849,7 @@ export {
   collectPceEvidenceSources,
   compareSourceEvidence,
   createApplicationPipeline,
+  createApplicationRun,
   createExtractor,
   createPceAgent,
   createPipelineContext,
@@ -16366,12 +16857,16 @@ export {
   evaluateCaseProposals,
   evidenceContainsQuote,
   extractPageRange,
+  extractQuestionGraphFromFields,
   fillAcroForm,
+  flattenQuestionGraph,
   generateNextMessage,
   getAcroFormFields,
+  getActiveApplicationFields,
   getDoclingPageRangeText,
   getExtractor,
   getFileIdentifier,
+  getNextApplicationQuestions,
   getPdfPageCount,
   getTemplate,
   isDoclingExtractionInput,
@@ -16379,6 +16874,7 @@ export {
   mergeOperationalProfile,
   mergeQuestionAnswers,
   mergeSourceSpans,
+  normalizeApplicationQuestionGraph,
   normalizeDoclingDocument,
   normalizeDocumentSourceTreePaths,
   normalizeForMatch,
@@ -16388,7 +16884,9 @@ export {
   pLimit,
   pdfInputToBase64,
   pdfInputToBytes,
+  planNextApplicationQuestions,
   processReply,
+  proposeContextWrites,
   resolveModelBudget,
   safeGenerateObject,
   sanitizeNulls,
@@ -16401,6 +16899,7 @@ export {
   stableStringify,
   stripFences,
   toStrictSchema,
+  validateApplicationPacket,
   validateEvidence,
   validatePceItems,
   validateQuotedEvidence,