@claritylabs/cl-sdk 0.3.1 → 0.5.0

package/dist/index.mjs

@@ -3185,6 +3185,129 @@ Respond with JSON only:
   "applicationType": string | null  // e.g. "General Liability", "Professional Liability", "Commercial Property", "Workers Compensation", "ACORD 125", etc.
 }`;
 
+// src/schemas/application.ts
+import { z as z31 } from "zod";
+var FieldTypeSchema = z31.enum([
+  "text",
+  "numeric",
+  "currency",
+  "date",
+  "yes_no",
+  "table",
+  "declaration"
+]);
+var ApplicationFieldSchema = z31.object({
+  id: z31.string(),
+  label: z31.string(),
+  section: z31.string(),
+  fieldType: FieldTypeSchema,
+  required: z31.boolean(),
+  options: z31.array(z31.string()).optional(),
+  columns: z31.array(z31.string()).optional(),
+  requiresExplanationIfYes: z31.boolean().optional(),
+  condition: z31.object({
+    dependsOn: z31.string(),
+    whenValue: z31.string()
+  }).optional(),
+  value: z31.string().optional(),
+  source: z31.string().optional().describe("Where the value came from: auto-fill, user, lookup"),
+  confidence: z31.enum(["confirmed", "high", "medium", "low"]).optional()
+});
+var ApplicationClassifyResultSchema = z31.object({
+  isApplication: z31.boolean(),
+  confidence: z31.number().min(0).max(1),
+  applicationType: z31.string().nullable()
+});
+var FieldExtractionResultSchema = z31.object({
+  fields: z31.array(ApplicationFieldSchema)
+});
+var AutoFillMatchSchema = z31.object({
+  fieldId: z31.string(),
+  value: z31.string(),
+  confidence: z31.enum(["confirmed"]),
+  contextKey: z31.string()
+});
+var AutoFillResultSchema = z31.object({
+  matches: z31.array(AutoFillMatchSchema)
+});
+var QuestionBatchResultSchema = z31.object({
+  batches: z31.array(z31.array(z31.string()).describe("Array of field IDs in this batch"))
+});
+var LookupRequestSchema = z31.object({
+  type: z31.string().describe("Type of lookup: 'records', 'website', 'policy'"),
+  description: z31.string(),
+  url: z31.string().optional(),
+  targetFieldIds: z31.array(z31.string())
+});
+var ReplyIntentSchema = z31.object({
+  primaryIntent: z31.enum(["answers_only", "question", "lookup_request", "mixed"]),
+  hasAnswers: z31.boolean(),
+  questionText: z31.string().optional(),
+  questionFieldIds: z31.array(z31.string()).optional(),
+  lookupRequests: z31.array(LookupRequestSchema).optional()
+});
+var ParsedAnswerSchema = z31.object({
+  fieldId: z31.string(),
+  value: z31.string(),
+  explanation: z31.string().optional()
+});
+var AnswerParsingResultSchema = z31.object({
+  answers: z31.array(ParsedAnswerSchema),
+  unanswered: z31.array(z31.string()).describe("Field IDs that were not answered")
+});
+var LookupFillSchema = z31.object({
+  fieldId: z31.string(),
+  value: z31.string(),
+  source: z31.string().describe("Specific citable reference, e.g. 'GL Policy #POL-12345 (Hartford)'")
+});
+var LookupFillResultSchema = z31.object({
+  fills: z31.array(LookupFillSchema),
+  unfillable: z31.array(z31.string()),
+  explanation: z31.string().optional()
+});
+var FlatPdfPlacementSchema = z31.object({
+  fieldId: z31.string(),
+  page: z31.number(),
+  x: z31.number().describe("Percentage from left edge (0-100)"),
+  y: z31.number().describe("Percentage from top edge (0-100)"),
+  text: z31.string(),
+  fontSize: z31.number().optional(),
+  isCheckmark: z31.boolean().optional()
+});
+var AcroFormMappingSchema = z31.object({
+  fieldId: z31.string(),
+  acroFormName: z31.string(),
+  value: z31.string()
+});
+var ApplicationStateSchema = z31.object({
+  id: z31.string(),
+  pdfBase64: z31.string().optional().describe("Original PDF, omitted after extraction"),
+  title: z31.string().optional(),
+  applicationType: z31.string().nullable().optional(),
+  fields: z31.array(ApplicationFieldSchema),
+  batches: z31.array(z31.array(z31.string())).optional(),
+  currentBatchIndex: z31.number().default(0),
+  status: z31.enum(["classifying", "extracting", "auto_filling", "batching", "collecting", "confirming", "mapping", "complete"]),
+  createdAt: z31.number(),
+  updatedAt: z31.number()
+});
+
+// src/application/agents/classifier.ts
+async function classifyApplication(pdfContent, generateObject, providerOptions) {
+  const { object, usage } = await withRetry(
+    () => generateObject({
+      prompt: `${APPLICATION_CLASSIFY_PROMPT}
+
+Analyze the following document content:
+${pdfContent}`,
+      schema: ApplicationClassifyResultSchema,
+      maxTokens: 512,
+      providerOptions
+    })
+  );
+  return { result: object, usage };
+}
+
 // src/prompts/application/field-extraction.ts
 function buildFieldExtractionPrompt() {
   return `Extract all fillable fields from this insurance application PDF as a JSON array. Be concise \u2014 use short IDs and minimal keys.
@@ -3217,6 +3340,24 @@ Example:
 Extract ALL fields. Respond with ONLY the JSON array, no other text.`;
 }
 
+// src/application/agents/field-extractor.ts
+async function extractFields(pdfContent, generateObject, providerOptions) {
+  const prompt = `${buildFieldExtractionPrompt()}
+
+Extract fields from this application:
+${pdfContent}`;
+  const { object, usage } = await withRetry(
+    () => generateObject({
+      prompt,
+      schema: FieldExtractionResultSchema,
+      maxTokens: 8192,
+      providerOptions
+    })
+  );
+  const result = object;
+  return { fields: result.fields, usage };
+}
+
 // src/prompts/application/auto-fill.ts
 function buildAutoFillPrompt(fields, orgContext) {
   const fieldList = fields.map((f) => `- ${f.id}: "${f.label}" (${f.fieldType}, section: ${f.section})`).join("\n");
@@ -3246,6 +3387,39 @@ Respond with JSON only:
 Only include fields you can confidently fill. Do not guess or fabricate values.`;
 }
 
+// src/application/agents/auto-filler.ts
+async function autoFillFromContext(fields, orgContext, generateObject, providerOptions) {
+  const fieldSummaries = fields.map((f) => ({
+    id: f.id,
+    label: f.label,
+    fieldType: f.fieldType,
+    section: f.section
+  }));
+  const prompt = buildAutoFillPrompt(fieldSummaries, orgContext);
+  const { object, usage } = await withRetry(
+    () => generateObject({
+      prompt,
+      schema: AutoFillResultSchema,
+      maxTokens: 4096,
+      providerOptions
+    })
+  );
+  return { result: object, usage };
+}
+async function backfillFromPriorAnswers(fields, backfillProvider) {
+  const unfilled = fields.filter((f) => !f.value);
+  if (unfilled.length === 0) return [];
+  return backfillProvider.searchPriorAnswers(
+    unfilled.map((f) => ({
+      id: f.id,
+      label: f.label,
+      section: f.section,
+      fieldType: f.fieldType
+    })),
+    { limit: unfilled.length * 2 }
+  );
+}
+
 // src/prompts/application/question-batch.ts
 function buildQuestionBatchPrompt(unfilledFields) {
   const fieldList = unfilledFields.map(
@@ -3280,120 +3454,27 @@ Respond with JSON only:
 }`;
 }
 
-// src/prompts/application/answer-parsing.ts
-function buildAnswerParsingPrompt(questions, emailBody) {
-  const questionList = questions.map(
-    (q, i) => `${i + 1}. ${q.id}: "${q.label ?? q.text}" (type: ${q.fieldType})`
-  ).join("\n");
-  return `You are parsing a user's email reply to extract answers for specific insurance application questions.
-
-QUESTIONS ASKED:
-${questionList}
-
-USER'S EMAIL REPLY:
-${emailBody}
-
-Extract answers for each question. Handle:
-- Direct numbered answers (1. answer, 2. answer)
-- Inline answers referencing the question
-- Table data provided as lists or comma-separated values
-- Yes/no answers with optional explanations
-- Partial responses (some questions answered, others skipped)
-
-Respond with JSON only:
-{
-  "answers": [
-    {
-      "fieldId": "company_name",
-      "value": "Acme Corp"
-    },
-    {
-      "fieldId": "prior_claims_decl",
-      "value": "yes",
-      "explanation": "One claim in 2024 for water damage, $15,000 paid"
-    }
-  ],
-  "unanswered": ["field_id_that_was_not_answered"]
-}
-
-Only include answers you are confident about. If a response is ambiguous, include the field in "unanswered".`;
-}
-
-// src/prompts/application/confirmation.ts
-function buildConfirmationSummaryPrompt(fields, applicationTitle) {
-  const fieldList = fields.map((f) => {
-    const label = f.label ?? f.text ?? f.id;
-    const value = f.value ?? "(not provided)";
-    return `[${f.section}] ${label}: ${value}`;
-  }).join("\n");
-  return `Format the following insurance application answers into a clean, readable summary grouped by section. This will be sent as an email for the user to review and confirm.
-
-APPLICATION: ${applicationTitle}
-
-FIELD VALUES:
-${fieldList}
-
-Format as a readable summary:
-- Group by section with section headers
-- Show each field as "Label: Value"
-- For declarations, show the question and the yes/no answer plus any explanation
-- Skip fields with no value unless they are required
-- End with a note asking the user to reply "Looks good" to confirm, or describe any changes needed
-
-Respond with the formatted summary text only (no JSON wrapper). Use markdown formatting (bold headers, bullet points).`;
-}
-
-// src/prompts/application/batch-email.ts
-function buildBatchEmailGenerationPrompt(batchFields, batchIndex, totalBatches, appTitle, totalFieldCount, filledFieldCount, previousBatchSummary, companyName) {
-  const nonConditionalFields = batchFields.filter((f) => !f.condition);
-  const conditionalFields = batchFields.filter((f) => f.condition);
-  const fieldList = nonConditionalFields.map((f, i) => {
-    let line = `${i + 1}. id="${f.id}" label="${f.label}" type=${f.fieldType}`;
-    if (f.options) line += ` options=[${f.options.join(", ")}]`;
-    return line;
-  }).join("\n");
-  const conditionalNote = conditionalFields.length > 0 ? `
-
-CONDITIONAL FIELDS (DO NOT include in this email \u2014 they will be asked as follow-ups in a separate email after the parent is answered):
-${conditionalFields.map((f) => `- id="${f.id}" label="${f.label}" depends on ${f.condition.dependsOn} = "${f.condition.whenValue}"`).join("\n")}` : "";
-  const company = companyName ?? "the company";
-  const remainingFields = totalFieldCount - filledFieldCount;
-  const estMinutes = Math.max(1, Math.round(remainingFields * 0.5));
-  return `You are an internal risk management assistant helping your colleague fill out an insurance application for ${company}. You work FOR ${company} \u2014 you are NOT the insurer, broker, or any external party.
-
-APPLICATION: ${appTitle ?? "Insurance Application"}
-COMPANY: ${company}
-PROGRESS: ${filledFieldCount} of ${totalFieldCount} fields done, ~${remainingFields} remaining (~${estMinutes} min of questions left)
-${previousBatchSummary ? `
-PREVIOUS ANSWERS RECEIVED:
-${previousBatchSummary}
-` : ""}
-FIELDS TO ASK ABOUT:
-${fieldList}${conditionalNote}
-
-Rules:
-- ${previousBatchSummary ? 'Start by acknowledging previous answers or auto-filled data. If fields were auto-filled, list each field with its value AND cite the specific source (e.g. "from your GL Policy #ABC123", "from vercel.com", "from your business context"). If a web lookup was done, name the URL that was checked. Ask them to reply with corrections if anything is wrong.' : "Start with a one-line intro."}
-- Mention progress once using estimated time remaining. Don't mention section/batch numbers or field counts.
-- Use "${company}" by name when referring to the company. Also fine: "we" or "our". Never "our company" or "the company".
-- Ask questions plainly. No em-dashes for dramatic effect, no filler phrases like "need to nail down" or "let's dive into". Just ask.
-- For yes/no questions, ask naturally in one sentence. Don't list "Yes / No" as options. Mention what you'll need if the answer triggers a follow-up (e.g. "If not, I'll need a brief explanation.").
-- For fields with 2-3 options, mention them inline. 4+ options can be a short list.
-- Group related fields (address, coverage limits) into single compound questions.
-- Do NOT include conditional/follow-up fields. They will be sent separately.
-- Number each question.
-- Note expected format where relevant: dollar amounts for currency, MM/DD/YYYY for dates, column descriptions for tables.
-- End with a short closing.
-- Tone: professional, brief, matter-of-fact. Write like a busy coworker, not a chatbot. No flourishes, no em-dashes between clauses, no editorializing about the questions.
-
-NEVER:
-- Sound like a salesperson or customer service agent
-- Use em-dashes for emphasis or dramatic pacing
-- Editorialize ("these two should wrap up this section", "just a couple more")
-- List "Yes / No / N/A" as bullet options
-- Include conditional follow-up questions
-- Mention section numbers, batch numbers, or field counts
-
-Output the email body text ONLY. No subject line, no JSON. Use markdown for numbered lists.`;
+// src/application/agents/batcher.ts
+async function batchQuestions(unfilledFields, generateObject, providerOptions) {
+  const fieldSummaries = unfilledFields.map((f) => ({
+    id: f.id,
+    label: f.label,
+    text: f.label,
+    fieldType: f.fieldType,
+    section: f.section,
+    required: f.required,
+    condition: f.condition
+  }));
+  const prompt = buildQuestionBatchPrompt(fieldSummaries);
+  const { object, usage } = await withRetry(
+    () => generateObject({
+      prompt,
+      schema: QuestionBatchResultSchema,
+      maxTokens: 2048,
+      providerOptions
+    })
+  );
+  return { result: object, usage };
 }
 
 // src/prompts/application/reply-intent.ts
@@ -3432,23 +3513,78 @@ Respond with JSON only:
 }`;
 }
 
-// src/prompts/application/field-explanation.ts
-function buildFieldExplanationPrompt(field, question, policyContext) {
-  return `You are an internal risk management assistant helping a colleague fill out an insurance application for your company. They asked a question about a field on the form.
+// src/application/agents/reply-router.ts
+async function classifyReplyIntent(fields, replyText, generateObject, providerOptions) {
+  const fieldSummaries = fields.map((f) => ({ id: f.id, label: f.label }));
+  const prompt = buildReplyIntentClassificationPrompt(fieldSummaries, replyText);
+  const { object, usage } = await withRetry(
+    () => generateObject({
+      prompt,
+      schema: ReplyIntentSchema,
+      maxTokens: 1024,
+      providerOptions
+    })
+  );
+  return { intent: object, usage };
+}
 
-FIELD: "${field.label}" (type: ${field.fieldType}${field.options ? `, options: ${field.options.join(", ")}` : ""})
+// src/prompts/application/answer-parsing.ts
+function buildAnswerParsingPrompt(questions, emailBody) {
+  const questionList = questions.map(
+    (q, i) => `${i + 1}. ${q.id}: "${q.label ?? q.text}" (type: ${q.fieldType})`
+  ).join("\n");
+  return `You are parsing a user's email reply to extract answers for specific insurance application questions.
 
-THEIR QUESTION: "${question}"
+QUESTIONS ASKED:
+${questionList}
 
-${policyContext ? `RELEVANT POLICY/CONTEXT INFO:
-${policyContext}
-` : ""}
+USER'S EMAIL REPLY:
+${emailBody}
 
-Provide a short, helpful explanation (2-3 sentences) as a coworker would. If the field has options, briefly explain what each means if relevant. If there's policy context that helps, cite the specific source (e.g. "According to our GL Policy #ABC123 with Hartford, our current aggregate limit is $2M").
+Extract answers for each question. Handle:
+- Direct numbered answers (1. answer, 2. answer)
+- Inline answers referencing the question
+- Table data provided as lists or comma-separated values
+- Yes/no answers with optional explanations
+- Partial responses (some questions answered, others skipped)
 
-End with: "Just reply with the answer when you're ready and I'll fill it in."
+Respond with JSON only:
+{
+  "answers": [
+    {
+      "fieldId": "company_name",
+      "value": "Acme Corp"
+    },
+    {
+      "fieldId": "prior_claims_decl",
+      "value": "yes",
+      "explanation": "One claim in 2024 for water damage, $15,000 paid"
+    }
+  ],
+  "unanswered": ["field_id_that_was_not_answered"]
+}
 
-Respond with the explanation text only \u2014 no JSON, no field ID, no extra formatting.`;
+Only include answers you are confident about. If a response is ambiguous, include the field in "unanswered".`;
+}
+
+// src/application/agents/answer-parser.ts
+async function parseAnswers(fields, replyText, generateObject, providerOptions) {
+  const questions = fields.map((f) => ({
+    id: f.id,
+    label: f.label,
+    text: f.label,
+    fieldType: f.fieldType
+  }));
+  const prompt = buildAnswerParsingPrompt(questions, replyText);
+  const { object, usage } = await withRetry(
+    () => generateObject({
+      prompt,
+      schema: AnswerParsingResultSchema,
+      maxTokens: 4096,
+      providerOptions
+    })
+  );
+  return { result: object, usage };
 }
 
 // src/prompts/application/pdf-mapping.ts
@@ -3555,6 +3691,1122 @@ Respond with JSON only:
 }`;
 }
 
+// src/application/agents/lookup-filler.ts
+async function fillFromLookup(requests, targetFields, availableData, generateObject, providerOptions) {
+  const requestSummaries = requests.map((r) => ({
+    type: r.type,
+    description: r.description,
+    targetFieldIds: r.targetFieldIds
+  }));
+  const fieldSummaries = targetFields.map((f) => ({
+    id: f.id,
+    label: f.label,
+    fieldType: f.fieldType
+  }));
+  const prompt = buildLookupFillPrompt(requestSummaries, fieldSummaries, availableData);
+  const { object, usage } = await withRetry(
+    () => generateObject({
+      prompt,
+      schema: LookupFillResultSchema,
+      maxTokens: 4096,
+      providerOptions
+    })
+  );
+  return { result: object, usage };
+}
+
+// src/prompts/application/batch-email.ts
+function buildBatchEmailGenerationPrompt(batchFields, batchIndex, totalBatches, appTitle, totalFieldCount, filledFieldCount, previousBatchSummary, companyName) {
+  const nonConditionalFields = batchFields.filter((f) => !f.condition);
+  const conditionalFields = batchFields.filter((f) => f.condition);
+  const fieldList = nonConditionalFields.map((f, i) => {
+    let line = `${i + 1}. id="${f.id}" label="${f.label}" type=${f.fieldType}`;
+    if (f.options) line += ` options=[${f.options.join(", ")}]`;
+    return line;
+  }).join("\n");
+  const conditionalNote = conditionalFields.length > 0 ? `
+
+CONDITIONAL FIELDS (DO NOT include in this email \u2014 they will be asked as follow-ups in a separate email after the parent is answered):
+${conditionalFields.map((f) => `- id="${f.id}" label="${f.label}" depends on ${f.condition.dependsOn} = "${f.condition.whenValue}"`).join("\n")}` : "";
+  const company = companyName ?? "the company";
+  const remainingFields = totalFieldCount - filledFieldCount;
+  const estMinutes = Math.max(1, Math.round(remainingFields * 0.5));
+  return `You are an internal risk management assistant helping your colleague fill out an insurance application for ${company}. You work FOR ${company} \u2014 you are NOT the insurer, broker, or any external party.
+
+APPLICATION: ${appTitle ?? "Insurance Application"}
+COMPANY: ${company}
+PROGRESS: ${filledFieldCount} of ${totalFieldCount} fields done, ~${remainingFields} remaining (~${estMinutes} min of questions left)
+${previousBatchSummary ? `
+PREVIOUS ANSWERS RECEIVED:
+${previousBatchSummary}
+` : ""}
+FIELDS TO ASK ABOUT:
+${fieldList}${conditionalNote}
+
+Rules:
+- ${previousBatchSummary ? 'Start by acknowledging previous answers or auto-filled data. If fields were auto-filled, list each field with its value AND cite the specific source (e.g. "from your GL Policy #ABC123", "from vercel.com", "from your business context"). If a web lookup was done, name the URL that was checked. Ask them to reply with corrections if anything is wrong.' : "Start with a one-line intro."}
+- Mention progress once using estimated time remaining. Don't mention section/batch numbers or field counts.
+- Use "${company}" by name when referring to the company. Also fine: "we" or "our". Never "our company" or "the company".
+- Ask questions plainly. No em-dashes for dramatic effect, no filler phrases like "need to nail down" or "let's dive into". Just ask.
+- For yes/no questions, ask naturally in one sentence. Don't list "Yes / No" as options. Mention what you'll need if the answer triggers a follow-up (e.g. "If not, I'll need a brief explanation.").
+- For fields with 2-3 options, mention them inline. 4+ options can be a short list.
+- Group related fields (address, coverage limits) into single compound questions.
+- Do NOT include conditional/follow-up fields. They will be sent separately.
+- Number each question.
+- Note expected format where relevant: dollar amounts for currency, MM/DD/YYYY for dates, column descriptions for tables.
+- End with a short closing.
+- Tone: professional, brief, matter-of-fact. Write like a busy coworker, not a chatbot. No flourishes, no em-dashes between clauses, no editorializing about the questions.
+
+NEVER:
+- Sound like a salesperson or customer service agent
+- Use em-dashes for emphasis or dramatic pacing
+- Editorialize ("these two should wrap up this section", "just a couple more")
+- List "Yes / No / N/A" as bullet options
+- Include conditional follow-up questions
+- Mention section numbers, batch numbers, or field counts
+
+Output the email body text ONLY. No subject line, no JSON. Use markdown for numbered lists.`;
+}
+
+// src/application/agents/email-generator.ts
+async function generateBatchEmail(batchFields, batchIndex, totalBatches, opts, generateText, providerOptions) {
+  const fieldSummaries = batchFields.map((f) => ({
+    id: f.id,
+    label: f.label,
+    fieldType: f.fieldType,
+    options: f.options,
+    condition: f.condition
+  }));
+  const prompt = buildBatchEmailGenerationPrompt(
+    fieldSummaries,
+    batchIndex,
+    totalBatches,
+    opts.appTitle,
+    opts.totalFieldCount,
+    opts.filledFieldCount,
+    opts.previousBatchSummary,
+    opts.companyName
+  );
+  const { text, usage } = await withRetry(
+    () => generateText({
+      prompt,
+      maxTokens: 2048,
+      providerOptions
+    })
+  );
+  return { text, usage };
+}
+
+// src/application/coordinator.ts
+function createApplicationPipeline(config) {
+  const {
+    generateText,
+    generateObject,
+    applicationStore,
+    documentStore,
+    memoryStore,
+    backfillProvider,
+    orgContext = [],
+    concurrency = 4,
+    onTokenUsage,
+    onProgress,
+    log,
+    providerOptions
+  } = config;
+  const limit = pLimit(concurrency);
+  let totalUsage = { inputTokens: 0, outputTokens: 0 };
+  function trackUsage(usage) {
+    if (usage) {
+      totalUsage.inputTokens += usage.inputTokens;
+      totalUsage.outputTokens += usage.outputTokens;
+      onTokenUsage?.(usage);
+    }
+  }
+  async function processApplication(input) {
+    totalUsage = { inputTokens: 0, outputTokens: 0 };
+    const { pdfBase64, context } = input;
+    const id = input.applicationId ?? `app-${Date.now()}`;
+    const now = Date.now();
+    let state = {
+      id,
+      pdfBase64: void 0,
+      // Don't persist the full PDF in state
+      title: void 0,
+      applicationType: null,
+      fields: [],
+      batches: void 0,
+      currentBatchIndex: 0,
+      status: "classifying",
+      createdAt: now,
+      updatedAt: now
+    };
+    onProgress?.("Classifying document...");
+    const { result: classifyResult, usage: classifyUsage } = await classifyApplication(
+      pdfBase64.slice(0, 2e3),
+      // Send truncated content for classification
+      generateObject,
+      providerOptions
+    );
+    trackUsage(classifyUsage);
+    if (!classifyResult.isApplication) {
+      state.status = "complete";
+      state.updatedAt = Date.now();
+      await applicationStore?.save(state);
+      return { state, tokenUsage: totalUsage };
+    }
+    state.applicationType = classifyResult.applicationType;
+    state.status = "extracting";
+    state.updatedAt = Date.now();
+    onProgress?.("Extracting form fields...");
+    const { fields, usage: extractUsage } = await extractFields(
+      pdfBase64,
+      generateObject,
+      providerOptions
+    );
+    trackUsage(extractUsage);
+    state.fields = fields;
+    state.title = classifyResult.applicationType ?? void 0;
+    state.status = "auto_filling";
+    state.updatedAt = Date.now();
+    await applicationStore?.save(state);
+    onProgress?.(`Auto-filling ${fields.length} fields...`);
+    const fillTasks = [];
+    if (backfillProvider) {
+      fillTasks.push(
+        (async () => {
+          try {
+            const priorAnswers = await backfillFromPriorAnswers(fields, backfillProvider);
+            for (const pa of priorAnswers) {
+              const field = state.fields.find((f) => f.id === pa.fieldId);
+              if (field && !field.value && pa.relevance > 0.8) {
+                field.value = pa.value;
+                field.source = `backfill: ${pa.source}`;
+                field.confidence = "high";
+              }
+            }
+          } catch (e) {
+            await log?.(`Backfill failed: ${e}`);
+          }
+        })()
+      );
+    }
+    if (orgContext.length > 0) {
+      fillTasks.push(
+        limit(async () => {
+          const unfilledFields2 = state.fields.filter((f) => !f.value);
+          if (unfilledFields2.length === 0) return;
+          const { result: autoFillResult, usage: afUsage } = await autoFillFromContext(
+            unfilledFields2,
+            orgContext,
+            generateObject,
+            providerOptions
+          );
+          trackUsage(afUsage);
+          for (const match of autoFillResult.matches) {
+            const field = state.fields.find((f) => f.id === match.fieldId);
+            if (field && !field.value) {
+              field.value = match.value;
+              field.source = `auto-fill: ${match.contextKey}`;
+              field.confidence = match.confidence;
+            }
+          }
+        })
+      );
+    }
+    if (documentStore && memoryStore) {
+      fillTasks.push(
+        (async () => {
+          try {
+            const unfilledFields2 = state.fields.filter((f) => !f.value);
+            const searchPromises = unfilledFields2.slice(0, 10).map(
+              (f) => limit(async () => {
+                const chunks = await memoryStore.search(f.label, { limit: 3 });
+                for (const chunk of chunks) {
+                  if (!state.fields.find((sf) => sf.id === f.id)?.value) {
+                  }
+                }
+              })
+            );
+            await Promise.all(searchPromises);
+          } catch (e) {
+            await log?.(`Document backfill search failed: ${e}`);
+          }
+        })()
+      );
+    }
+    await Promise.all(fillTasks);
+    state.updatedAt = Date.now();
+    await applicationStore?.save(state);
+    const unfilledFields = state.fields.filter((f) => !f.value);
+    if (unfilledFields.length > 0) {
+      onProgress?.(`Batching ${unfilledFields.length} remaining questions...`);
+      state.status = "batching";
+      const { result: batchResult, usage: batchUsage } = await batchQuestions(
+        unfilledFields,
+        generateObject,
+        providerOptions
+      );
+      trackUsage(batchUsage);
+      state.batches = batchResult.batches;
+      state.currentBatchIndex = 0;
+      state.status = "collecting";
+    } else {
+      state.status = "confirming";
+    }
+    state.updatedAt = Date.now();
+    await applicationStore?.save(state);
+    const filledCount = state.fields.filter((f) => f.value).length;
+    onProgress?.(`Application processed: ${filledCount}/${state.fields.length} fields filled, ${state.batches?.length ?? 0} batches to collect.`);
+    return { state, tokenUsage: totalUsage };
+  }
+  async function processReply(input) {
+    totalUsage = { inputTokens: 0, outputTokens: 0 };
+    const { applicationId, replyText, context } = input;
+    let state = null;
+    if (applicationStore) {
+      state = await applicationStore.get(applicationId);
+    }
+    if (!state) {
+      throw new Error(`Application ${applicationId} not found`);
+    }
+    const currentBatchFieldIds = state.batches?.[state.currentBatchIndex] ?? [];
+    const currentBatchFields = state.fields.filter(
+      (f) => currentBatchFieldIds.includes(f.id)
+    );
+    onProgress?.("Classifying reply...");
+    const { intent, usage: intentUsage } = await classifyReplyIntent(
+      currentBatchFields,
+      replyText,
+      generateObject,
+      providerOptions
+    );
+    trackUsage(intentUsage);
+    let fieldsFilled = 0;
+    let responseText;
+    if (intent.hasAnswers) {
+      onProgress?.("Parsing answers...");
+      const { result: parseResult, usage: parseUsage } = await parseAnswers(
+        currentBatchFields,
+        replyText,
+        generateObject,
+        providerOptions
+      );
+      trackUsage(parseUsage);
+      for (const answer of parseResult.answers) {
+        const field = state.fields.find((f) => f.id === answer.fieldId);
+        if (field) {
+          field.value = answer.value;
+          field.source = "user";
+          field.confidence = "confirmed";
+          fieldsFilled++;
+        }
+      }
+    }
+    if (intent.lookupRequests?.length) {
+      onProgress?.("Processing lookup requests...");
+      let availableData = "";
+      if (documentStore) {
+        try {
+          const docs = await documentStore.query({});
+          availableData = docs.map((d) => {
+            const doc = d;
+            return `Document ${doc.id}: ${doc.type} - ${doc.carrier ?? "unknown carrier"} - ${doc.insuredName ?? ""}`;
+          }).join("\n");
+        } catch (e) {
+          await log?.(`Document query for lookup failed: ${e}`);
+        }
+      }
+      if (availableData) {
+        const targetFields = state.fields.filter(
+          (f) => intent.lookupRequests.some((lr) => lr.targetFieldIds.includes(f.id))
+        );
+        const { result: lookupResult, usage: lookupUsage } = await fillFromLookup(
+          intent.lookupRequests,
+          targetFields,
+          availableData,
+          generateObject,
+          providerOptions
+        );
+        trackUsage(lookupUsage);
+        for (const fill of lookupResult.fills) {
+          const field = state.fields.find((f) => f.id === fill.fieldId);
+          if (field) {
+            field.value = fill.value;
+            field.source = `lookup: ${fill.source}`;
+            field.confidence = "high";
+            fieldsFilled++;
+          }
+        }
+      }
+    }
+    if (intent.primaryIntent === "question" || intent.primaryIntent === "mixed") {
+      if (intent.questionText) {
+        const { text, usage } = await generateText({
+          prompt: `The user is filling out an insurance application and asked: "${intent.questionText}"
+
+Provide a brief, helpful explanation (2-3 sentences). End with "Just reply with the answer when you're ready and I'll fill it in."`,
+          maxTokens: 512,
+          providerOptions
+        });
+        trackUsage(usage);
+        responseText = text;
+      }
+    }
+    const currentBatchComplete = currentBatchFieldIds.every(
+      (fid) => state.fields.find((f) => f.id === fid)?.value
+    );
+    if (currentBatchComplete && state.batches) {
+      if (state.currentBatchIndex < state.batches.length - 1) {
+        state.currentBatchIndex++;
+        const nextBatchFieldIds = state.batches[state.currentBatchIndex];
+        const nextBatchFields = state.fields.filter(
+          (f) => nextBatchFieldIds.includes(f.id)
+        );
+        const filledCount = state.fields.filter((f) => f.value).length;
+        const { text: emailText, usage: emailUsage } = await generateBatchEmail(
+          nextBatchFields,
+          state.currentBatchIndex,
+          state.batches.length,
+          {
+            appTitle: state.title,
+            totalFieldCount: state.fields.length,
+            filledFieldCount: filledCount,
+            companyName: context?.companyName
+          },
+          generateText,
+          providerOptions
+        );
+        trackUsage(emailUsage);
+        if (!responseText) {
+          responseText = emailText;
+        } else {
+          responseText += `
+
+${emailText}`;
+        }
+      } else {
+        state.status = "confirming";
+      }
+    }
+    state.updatedAt = Date.now();
+    await applicationStore?.save(state);
+    return {
+      state,
+      intent: intent.primaryIntent,
+      fieldsFilled,
+      responseText,
+      tokenUsage: totalUsage
+    };
+  }
+  async function generateCurrentBatchEmail(applicationId, opts) {
+    totalUsage = { inputTokens: 0, outputTokens: 0 };
+    const state = await applicationStore?.get(applicationId);
+    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 filledCount = state.fields.filter((f) => f.value).length;
+    const { text, usage } = await generateBatchEmail(
+      batchFields,
+      state.currentBatchIndex,
+      state.batches.length,
+      {
+        appTitle: state.title,
+        totalFieldCount: state.fields.length,
+        filledFieldCount: filledCount,
+        companyName: opts?.companyName,
+        previousBatchSummary: opts?.previousBatchSummary
+      },
+      generateText,
+      providerOptions
+    );
+    trackUsage(usage);
+    return { text, tokenUsage: totalUsage };
+  }
+  async function getConfirmationSummary(applicationId) {
+    totalUsage = { inputTokens: 0, outputTokens: 0 };
+    const state = await applicationStore?.get(applicationId);
+    if (!state) throw new Error(`Application ${applicationId} not found`);
+    const filledFields = state.fields.filter((f) => f.value);
+    const fieldSummary = filledFields.map((f) => `${f.section} > ${f.label}: ${f.value} (source: ${f.source ?? "unknown"})`).join("\n");
+    const { text, usage } = await generateText({
+      prompt: `Format these filled insurance application fields as a clean confirmation summary for the user to review. Group by section, show each field as "Label: Value". End with a note asking them to confirm or request changes.
+
+Application: ${state.title ?? "Insurance Application"}
+
+Fields:
+${fieldSummary}`,
+      maxTokens: 4096,
+      providerOptions
+    });
+    trackUsage(usage);
+    return { text, tokenUsage: totalUsage };
+  }
+  return {
+    processApplication,
+    processReply,
+    generateCurrentBatchEmail,
+    getConfirmationSummary
+  };
+}
+
+// src/prompts/application/confirmation.ts
+function buildConfirmationSummaryPrompt(fields, applicationTitle) {
+  const fieldList = fields.map((f) => {
+    const label = f.label ?? f.text ?? f.id;
+    const value = f.value ?? "(not provided)";
+    return `[${f.section}] ${label}: ${value}`;
+  }).join("\n");
+  return `Format the following insurance application answers into a clean, readable summary grouped by section. This will be sent as an email for the user to review and confirm.
+
+APPLICATION: ${applicationTitle}
+
+FIELD VALUES:
+${fieldList}
+
+Format as a readable summary:
+- Group by section with section headers
+- Show each field as "Label: Value"
+- For declarations, show the question and the yes/no answer plus any explanation
+- Skip fields with no value unless they are required
+- End with a note asking the user to reply "Looks good" to confirm, or describe any changes needed
+
+Respond with the formatted summary text only (no JSON wrapper). Use markdown formatting (bold headers, bullet points).`;
+}
+
+// src/prompts/application/field-explanation.ts
+function buildFieldExplanationPrompt(field, question, policyContext) {
+  return `You are an internal risk management assistant helping a colleague fill out an insurance application for your company. They asked a question about a field on the form.
+
+FIELD: "${field.label}" (type: ${field.fieldType}${field.options ? `, options: ${field.options.join(", ")}` : ""})
+
+THEIR QUESTION: "${question}"
+
+${policyContext ? `RELEVANT POLICY/CONTEXT INFO:
+${policyContext}
+` : ""}
+
+Provide a short, helpful explanation (2-3 sentences) as a coworker would. If the field has options, briefly explain what each means if relevant. If there's policy context that helps, cite the specific source (e.g. "According to our GL Policy #ABC123 with Hartford, our current aggregate limit is $2M").
+
+End with: "Just reply with the answer when you're ready and I'll fill it in."
+
+Respond with the explanation text only \u2014 no JSON, no field ID, no extra formatting.`;
+}
+
+// src/prompts/query/classify.ts
+function buildQueryClassifyPrompt(question, conversationContext) {
+  return `You are a query classifier for an insurance document intelligence system.
+
+Analyze the user's question and produce a structured classification.
+
+USER QUESTION:
+${question}
+${conversationContext ? `
+CONVERSATION CONTEXT:
+${conversationContext}` : ""}
+
+INSTRUCTIONS:
+
+1. Determine the primary intent:
+   - "policy_question": questions about specific coverage, limits, deductibles, endorsements, conditions
+   - "coverage_comparison": comparing coverages across multiple documents or policies
+   - "document_search": looking for a specific document by carrier, policy number, insured name
+   - "claims_inquiry": questions about claims history, loss runs, experience modification
+   - "general_knowledge": insurance concepts not tied to a specific document
+
+2. Decompose into atomic sub-questions:
+   - Each sub-question should be answerable from a single retrieval pass
+   - Simple questions produce exactly one sub-question (the question itself)
+   - Complex questions (comparisons, multi-policy, multi-field) decompose into 2-5 sub-questions
+   - Each sub-question should specify which chunk types are most relevant
+
+3. Determine which storage backends are needed:
+   - requiresDocumentLookup: true if a specific document needs to be fetched by ID/number/carrier
+   - requiresChunkSearch: true if semantic search over document chunks is needed
+   - requiresConversationHistory: true if the question references prior conversation
+
+CHUNK TYPES (for chunkTypes filter):
+carrier_info, named_insured, coverage, endorsement, exclusion, condition, section, declaration, loss_history, premium, supplementary
+
+Respond with the structured classification.`;
+}
+
+// src/prompts/query/respond.ts
+function buildRespondPrompt(originalQuestion, subAnswersJson, platform) {
+  const formatGuidance = platform === "email" ? "Format as a professional email response. Use plain text, no markdown." : platform === "sms" ? "Keep the response concise and conversational. No markdown." : "Format as clear, well-structured text. Use markdown for lists and emphasis where helpful.";
+  return `You are composing a final answer to an insurance question. You have verified sub-answers with citations that you need to merge into a single, natural response.
+
+ORIGINAL QUESTION:
+${originalQuestion}
+
+VERIFIED SUB-ANSWERS:
+${subAnswersJson}
+
+FORMATTING:
+${formatGuidance}
+
+INSTRUCTIONS:
+1. Write a natural, direct answer to the original question.
+2. Embed inline citation numbers [1], [2], etc. after each factual claim. These reference the citation objects from the sub-answers \u2014 preserve the original citation index numbers.
+3. If any sub-answer had low confidence or noted missing context, mention what information was unavailable rather than omitting silently.
+4. If the answer naturally leads to a follow-up question the user might want to ask, suggest it in the followUp field.
+5. Merge overlapping citations \u2014 if two sub-answers cite the same chunk, use one citation number.
+6. Keep the tone helpful and professional.
+
+Respond with the final answer, deduplicated citations array, overall confidence (weighted average of sub-answer confidences), and an optional follow-up suggestion.`;
+}
+
+// src/schemas/query.ts
+import { z as z32 } from "zod";
+var QueryIntentSchema = z32.enum([
+  "policy_question",
+  "coverage_comparison",
+  "document_search",
+  "claims_inquiry",
+  "general_knowledge"
+]);
+var SubQuestionSchema = z32.object({
+  question: z32.string().describe("Atomic sub-question to retrieve and answer independently"),
+  intent: QueryIntentSchema,
+  chunkTypes: z32.array(z32.string()).optional().describe("Chunk types to filter retrieval (e.g. coverage, endorsement, declaration)"),
+  documentFilters: z32.object({
+    type: z32.enum(["policy", "quote"]).optional(),
+    carrier: z32.string().optional(),
+    insuredName: z32.string().optional(),
+    policyNumber: z32.string().optional(),
+    quoteNumber: z32.string().optional()
+  }).optional().describe("Structured filters to narrow document lookup")
+});
+var QueryClassifyResultSchema = z32.object({
+  intent: QueryIntentSchema,
+  subQuestions: z32.array(SubQuestionSchema).min(1).describe("Decomposed atomic sub-questions"),
+  requiresDocumentLookup: z32.boolean().describe("Whether structured document lookup is needed"),
+  requiresChunkSearch: z32.boolean().describe("Whether semantic chunk search is needed"),
+  requiresConversationHistory: z32.boolean().describe("Whether conversation history is relevant")
+});
+var EvidenceItemSchema = z32.object({
+  source: z32.enum(["chunk", "document", "conversation"]),
+  chunkId: z32.string().optional(),
+  documentId: z32.string().optional(),
+  turnId: z32.string().optional(),
+  text: z32.string().describe("Text excerpt from the source"),
+  relevance: z32.number().min(0).max(1),
+  metadata: z32.record(z32.string(), z32.string()).optional()
+});
+var RetrievalResultSchema = z32.object({
+  subQuestion: z32.string(),
+  evidence: z32.array(EvidenceItemSchema)
+});
+var CitationSchema = z32.object({
+  index: z32.number().describe("Citation number [1], [2], etc."),
+  chunkId: z32.string().describe("Source chunk ID, e.g. doc-123:coverage:2"),
+  documentId: z32.string(),
+  documentType: z32.enum(["policy", "quote"]).optional(),
+  field: z32.string().optional().describe("Specific field path, e.g. coverages[0].deductible"),
+  quote: z32.string().describe("Exact text from source that supports the claim"),
+  relevance: z32.number().min(0).max(1)
+});
+var SubAnswerSchema = z32.object({
+  subQuestion: z32.string(),
+  answer: z32.string(),
+  citations: z32.array(CitationSchema),
+  confidence: z32.number().min(0).max(1),
+  needsMoreContext: z32.boolean().describe("True if evidence was insufficient to answer fully")
+});
+var VerifyResultSchema = z32.object({
+  approved: z32.boolean().describe("Whether all sub-answers are adequately grounded"),
+  issues: z32.array(z32.string()).describe("Specific grounding or consistency issues found"),
+  retrySubQuestions: z32.array(z32.string()).optional().describe("Sub-questions that need additional retrieval or re-reasoning")
+});
+var QueryResultSchema = z32.object({
+  answer: z32.string(),
+  citations: z32.array(CitationSchema),
+  intent: QueryIntentSchema,
+  confidence: z32.number().min(0).max(1),
+  followUp: z32.string().optional().describe("Suggested follow-up question if applicable")
+});
+
+// src/query/retriever.ts
+async function retrieve(subQuestion, conversationId, config) {
+  const { documentStore, memoryStore, retrievalLimit, log } = config;
+  const evidence = [];
+  const tasks = [];
+  tasks.push(
+    (async () => {
+      try {
+        const filter = {};
+        if (subQuestion.chunkTypes?.length) {
+          const chunkResults = await Promise.all(
+            subQuestion.chunkTypes.map(
+              (type) => memoryStore.search(subQuestion.question, {
+                limit: Math.ceil(retrievalLimit / subQuestion.chunkTypes.length),
+                filter: { ...filter, type }
+              })
+            )
+          );
+          for (const chunks of chunkResults) {
+            for (const chunk of chunks) {
+              evidence.push({
+                source: "chunk",
+                chunkId: chunk.id,
+                documentId: chunk.documentId,
+                text: chunk.text,
+                relevance: 0.8,
+                // Default — store doesn't expose scores directly
+                metadata: chunk.metadata
+              });
+            }
+          }
+        } else {
+          const chunks = await memoryStore.search(subQuestion.question, {
+            limit: retrievalLimit
+          });
+          for (const chunk of chunks) {
+            evidence.push({
+              source: "chunk",
+              chunkId: chunk.id,
+              documentId: chunk.documentId,
+              text: chunk.text,
+              relevance: 0.8,
+              metadata: chunk.metadata
+            });
+          }
+        }
+      } catch (e) {
+        await log?.(`Chunk search failed for "${subQuestion.question}": ${e}`);
+      }
+    })()
+  );
+  if (subQuestion.documentFilters) {
+    tasks.push(
+      (async () => {
+        try {
+          const filters = {};
+          if (subQuestion.documentFilters?.type) filters.type = subQuestion.documentFilters.type;
+          if (subQuestion.documentFilters?.carrier) filters.carrier = subQuestion.documentFilters.carrier;
+          if (subQuestion.documentFilters?.insuredName) filters.insuredName = subQuestion.documentFilters.insuredName;
+          if (subQuestion.documentFilters?.policyNumber) filters.policyNumber = subQuestion.documentFilters.policyNumber;
+          if (subQuestion.documentFilters?.quoteNumber) filters.quoteNumber = subQuestion.documentFilters.quoteNumber;
+          const docs = await documentStore.query(filters);
+          for (const doc of docs) {
+            const summary = buildDocumentSummary(doc);
+            evidence.push({
+              source: "document",
+              documentId: doc.id,
+              text: summary,
+              relevance: 0.9,
+              // Direct lookup is high relevance
+              metadata: {
+                type: doc.type,
+                carrier: doc.carrier ?? "",
+                insuredName: doc.insuredName ?? ""
+              }
+            });
+          }
+        } catch (e) {
+          await log?.(`Document lookup failed: ${e}`);
+        }
+      })()
+    );
+  }
+  if (conversationId) {
+    tasks.push(
+      (async () => {
+        try {
+          const turns = await memoryStore.searchHistory(
+            subQuestion.question,
+            conversationId
+          );
+          for (const turn of turns.slice(0, 5)) {
+            evidence.push({
+              source: "conversation",
+              turnId: turn.id,
+              text: `[${turn.role}]: ${turn.content}`,
+              relevance: 0.6
+              // Conversation context is lower relevance than documents
+            });
+          }
+        } catch (e) {
+          await log?.(`Conversation history search failed: ${e}`);
+        }
+      })()
+    );
+  }
+  await Promise.all(tasks);
+  evidence.sort((a, b) => b.relevance - a.relevance);
+  return {
+    subQuestion: subQuestion.question,
+    evidence: evidence.slice(0, retrievalLimit)
+  };
+}
+function buildDocumentSummary(doc) {
+  const parts = [];
+  const type = doc.type;
+  parts.push(`Document type: ${type}`);
+  if (doc.carrier) parts.push(`Carrier: ${doc.carrier}`);
+  if (doc.insuredName) parts.push(`Insured: ${doc.insuredName}`);
+  if (type === "policy") {
+    if (doc.policyNumber) parts.push(`Policy #: ${doc.policyNumber}`);
+    if (doc.effectiveDate) parts.push(`Effective: ${doc.effectiveDate}`);
+    if (doc.expirationDate) parts.push(`Expiration: ${doc.expirationDate}`);
+  } else if (type === "quote") {
+    if (doc.quoteNumber) parts.push(`Quote #: ${doc.quoteNumber}`);
+    if (doc.proposedEffectiveDate) parts.push(`Proposed effective: ${doc.proposedEffectiveDate}`);
+  }
+  if (doc.premium) parts.push(`Premium: ${doc.premium}`);
+  const coverages = doc.coverages;
+  if (coverages?.length) {
+    parts.push(`Coverages (${coverages.length}):`);
+    for (const cov of coverages.slice(0, 10)) {
+      const line = [cov.name, cov.limit ? `Limit: ${cov.limit}` : null, cov.deductible ? `Ded: ${cov.deductible}` : null].filter(Boolean).join(" | ");
+      parts.push(`  - ${line}`);
+    }
+  }
+  return parts.join("\n");
+}
+
+// src/prompts/query/reason.ts
+var INTENT_INSTRUCTIONS = {
+  policy_question: `You are answering a question about a specific insurance policy or quote.
+
+RULES:
+- Answer ONLY from the evidence provided. Do not use general knowledge.
+- When citing limits, deductibles, or amounts, use the exact values from the source.
+- If the evidence mentions an endorsement that modifies coverage, include that context.
+- If the evidence is insufficient, say what is missing rather than guessing.
+- Reference specific coverage names, form numbers, and endorsement titles when available.`,
+  coverage_comparison: `You are comparing coverages across insurance documents.
+
+RULES:
+- Answer ONLY from the evidence provided.
+- Structure your comparison around specific coverage attributes: limits, deductibles, forms, triggers.
+- Note differences clearly: "Policy A has X, while Policy B has Y."
+- Flag where one document has coverage the other lacks entirely.
+- If evidence for one side of the comparison is missing, state that explicitly.`,
+  document_search: `You are helping locate a specific insurance document.
+
+RULES:
+- Answer ONLY from the evidence provided.
+- Identify the document by carrier, policy/quote number, insured name, and effective dates.
+- If multiple documents match, list them with distinguishing details.
+- If no documents match, say so clearly.`,
+  claims_inquiry: `You are answering a question about claims history or loss experience.
+
+RULES:
+- Answer ONLY from the evidence provided.
+- Reference specific claim dates, amounts, descriptions, and statuses.
+- Include experience modification factors if available.
+- Be precise with dollar amounts and dates \u2014 do not approximate.
+- If the evidence shows no claims, state that explicitly.`,
+  general_knowledge: `You are answering a general insurance question using available document context.
+
+RULES:
+- You may use general insurance knowledge to frame your answer.
+- If the question can be answered from the evidence, prefer that over general knowledge.
+- When mixing general knowledge with document-specific data, make the distinction clear.
+- Still cite evidence when referencing specific documents.`
+};
+function buildReasonPrompt(subQuestion, intent, evidence) {
+  return `${INTENT_INSTRUCTIONS[intent]}
+
+SUB-QUESTION:
+${subQuestion}
+
+EVIDENCE:
+${evidence}
+
+Answer the sub-question based on the evidence above. For every factual claim, include a citation referencing the source evidence item by its chunkId or documentId. Rate your confidence from 0 to 1 based on how well the evidence supports your answer. Set needsMoreContext to true if the evidence was insufficient.`;
+}
+
+// src/query/reasoner.ts
+async function reason(subQuestion, intent, evidence, config) {
+  const { generateObject, providerOptions } = config;
+  const evidenceText = evidence.map((e, i) => {
+    const sourceLabel = e.source === "chunk" ? `[chunk:${e.chunkId}]` : e.source === "document" ? `[doc:${e.documentId}]` : `[turn:${e.turnId}]`;
+    return `Evidence ${i + 1} ${sourceLabel} (relevance: ${e.relevance.toFixed(2)}):
+${e.text}`;
+  }).join("\n\n");
+  const prompt = buildReasonPrompt(subQuestion, intent, evidenceText);
+  const { object, usage } = await withRetry(
+    () => generateObject({
+      prompt,
+      schema: SubAnswerSchema,
+      maxTokens: 4096,
+      providerOptions
+    })
+  );
+  return { subAnswer: object, usage };
+}
+
+// src/prompts/query/verify.ts
+function buildVerifyPrompt(originalQuestion, subAnswersJson, evidenceJson) {
+  return `You are a verification agent for an insurance document intelligence system. Your job is to check that answers are accurate, grounded, and complete.
+
+ORIGINAL QUESTION:
+${originalQuestion}
+
+SUB-ANSWERS:
+${subAnswersJson}
+
+AVAILABLE EVIDENCE:
+${evidenceJson}
+
+CHECK EACH SUB-ANSWER FOR:
+
+1. GROUNDING: Every factual claim must be supported by a citation that references actual evidence. Flag any claim that:
+   - Has no citation
+   - Cites a source that doesn't actually contain the claimed information
+   - Extrapolates beyond what the evidence states
+
+2. CONSISTENCY: Sub-answers should not contradict each other. Flag any contradictions, noting which sub-answers conflict and what the discrepancy is.
+
+3. COMPLETENESS: Did each sub-question get an adequate answer? Flag any sub-question where:
+   - The answer is vague or hedged when the evidence supports a specific answer
+   - Important details from the evidence were omitted
+   - The confidence rating seems miscalibrated (high confidence with weak evidence, or low confidence with strong evidence)
+
+RESPOND WITH:
+- approved: true only if ALL sub-answers pass all three checks
+- issues: list every specific issue found (empty array if approved)
+- retrySubQuestions: sub-questions that need re-retrieval or re-reasoning (only if not approved)`;
+}
+
+// src/query/verifier.ts
+async function verify(originalQuestion, subAnswers, allEvidence, config) {
+  const { generateObject, providerOptions } = config;
+  const subAnswersJson = JSON.stringify(
+    subAnswers.map((sa) => ({
+      subQuestion: sa.subQuestion,
+      answer: sa.answer,
+      citations: sa.citations,
+      confidence: sa.confidence,
+      needsMoreContext: sa.needsMoreContext
+    })),
+    null,
+    2
+  );
+  const evidenceJson = JSON.stringify(
+    allEvidence.map((e) => ({
+      source: e.source,
+      id: e.chunkId ?? e.documentId ?? e.turnId,
+      text: e.text.slice(0, 500),
+      // Truncate for context efficiency
+      relevance: e.relevance
+    })),
+    null,
+    2
+  );
+  const prompt = buildVerifyPrompt(originalQuestion, subAnswersJson, evidenceJson);
+  const { object, usage } = await withRetry(
+    () => generateObject({
+      prompt,
+      schema: VerifyResultSchema,
+      maxTokens: 2048,
+      providerOptions
+    })
+  );
+  return { result: object, usage };
+}
+
+// src/query/coordinator.ts
+function createQueryAgent(config) {
+  const {
+    generateText,
+    generateObject,
+    documentStore,
+    memoryStore,
+    concurrency = 3,
+    maxVerifyRounds = 1,
+    retrievalLimit = 10,
+    onTokenUsage,
+    onProgress,
+    log,
+    providerOptions
+  } = config;
+  const limit = pLimit(concurrency);
+  let totalUsage = { inputTokens: 0, outputTokens: 0 };
+  function trackUsage(usage) {
+    if (usage) {
+      totalUsage.inputTokens += usage.inputTokens;
+      totalUsage.outputTokens += usage.outputTokens;
+      onTokenUsage?.(usage);
+    }
+  }
+  async function query(input) {
+    totalUsage = { inputTokens: 0, outputTokens: 0 };
+    const { question, conversationId, context } = input;
+    onProgress?.("Classifying query...");
+    const classification = await classify(question, conversationId);
+    onProgress?.(`Retrieving evidence for ${classification.subQuestions.length} sub-question(s)...`);
+    const retrieverConfig = {
+      documentStore,
+      memoryStore,
+      retrievalLimit,
+      log
+    };
+    const retrievalResults = await Promise.all(
+      classification.subQuestions.map(
+        (sq) => limit(() => retrieve(sq, conversationId, retrieverConfig))
+      )
+    );
+    const allEvidence = retrievalResults.flatMap((r) => r.evidence);
+    onProgress?.("Reasoning over evidence...");
+    const reasonerConfig = { generateObject, providerOptions };
+    let subAnswers = await Promise.all(
+      classification.subQuestions.map(
+        (sq, i) => limit(async () => {
+          const { subAnswer, usage } = await reason(
+            sq.question,
+            sq.intent,
+            retrievalResults[i].evidence,
+            reasonerConfig
+          );
+          trackUsage(usage);
+          return subAnswer;
+        })
+      )
+    );
+    onProgress?.("Verifying answer grounding...");
+    const verifierConfig = { generateObject, providerOptions };
+    for (let round = 0; round < maxVerifyRounds; round++) {
+      const { result: verifyResult, usage } = await verify(
+        question,
+        subAnswers,
+        allEvidence,
+        verifierConfig
+      );
+      trackUsage(usage);
+      if (verifyResult.approved) {
+        onProgress?.("Verification passed.");
+        break;
+      }
+      onProgress?.(`Verification found ${verifyResult.issues.length} issue(s), round ${round + 1}/${maxVerifyRounds}`);
+      await log?.(`Verify issues: ${verifyResult.issues.join("; ")}`);
+      if (verifyResult.retrySubQuestions?.length) {
+        const retryQuestions = classification.subQuestions.filter(
+          (sq) => verifyResult.retrySubQuestions.includes(sq.question)
+        );
+        if (retryQuestions.length > 0) {
+          const retryRetrievals = await Promise.all(
+            retryQuestions.map(
+              (sq) => limit(
+                () => retrieve(sq, conversationId, {
+                  ...retrieverConfig,
+                  retrievalLimit: retrievalLimit * 2
+                  // Broader retrieval on retry
+                })
+              )
+            )
+          );
+          for (const r of retryRetrievals) {
+            allEvidence.push(...r.evidence);
+          }
+          const retrySubAnswers = await Promise.all(
+            retryQuestions.map(
+              (sq, i) => limit(async () => {
+                const { subAnswer, usage: u } = await reason(
+                  sq.question,
+                  sq.intent,
+                  retryRetrievals[i].evidence,
+                  reasonerConfig
+                );
+                trackUsage(u);
+                return subAnswer;
+              })
+            )
+          );
+          const retryQSet = new Set(retryQuestions.map((sq) => sq.question));
+          subAnswers = subAnswers.map((sa) => {
+            if (retryQSet.has(sa.subQuestion)) {
+              const replacement = retrySubAnswers.find((r) => r.subQuestion === sa.subQuestion);
+              return replacement ?? sa;
+            }
+            return sa;
+          });
+        }
+      }
+    }
+    onProgress?.("Composing final answer...");
+    const queryResult = await respond(
+      question,
+      subAnswers,
+      classification,
+      context?.platform
+    );
+    if (conversationId) {
+      try {
+        await memoryStore.addTurn({
+          id: `turn-${Date.now()}-q`,
+          conversationId,
+          role: "user",
+          content: question,
+          timestamp: Date.now()
+        });
+        await memoryStore.addTurn({
+          id: `turn-${Date.now()}-a`,
+          conversationId,
+          role: "assistant",
+          content: queryResult.answer,
+          timestamp: Date.now()
+        });
+      } catch (e) {
+        await log?.(`Failed to store conversation turn: ${e}`);
+      }
+    }
+    return { ...queryResult, tokenUsage: totalUsage };
+  }
+  async function classify(question, conversationId) {
+    let conversationContext;
+    if (conversationId) {
+      try {
+        const history = await memoryStore.getHistory(conversationId, { limit: 5 });
+        if (history.length > 0) {
+          conversationContext = history.map((t) => `[${t.role}]: ${t.content}`).join("\n");
+        }
+      } catch {
+      }
+    }
+    const prompt = buildQueryClassifyPrompt(question, conversationContext);
+    const { object, usage } = await withRetry(
+      () => generateObject({
+        prompt,
+        schema: QueryClassifyResultSchema,
+        maxTokens: 2048,
+        providerOptions
+      })
+    );
+    trackUsage(usage);
+    return object;
+  }
+  async function respond(originalQuestion, subAnswers, classification, platform) {
+    const subAnswersJson = JSON.stringify(
+      subAnswers.map((sa) => ({
+        subQuestion: sa.subQuestion,
+        answer: sa.answer,
+        citations: sa.citations,
+        confidence: sa.confidence,
+        needsMoreContext: sa.needsMoreContext
+      })),
+      null,
+      2
+    );
+    const prompt = buildRespondPrompt(originalQuestion, subAnswersJson, platform);
+    const { object, usage } = await withRetry(
+      () => generateObject({
+        prompt,
+        schema: QueryResultSchema,
+        maxTokens: 4096,
+        providerOptions
+      })
+    );
+    trackUsage(usage);
+    const result = object;
+    result.intent = classification.intent;
+    return result;
+  }
+  return { query };
+}
+
 // src/prompts/intent.ts
 function buildClassifyMessagePrompt(platform) {
   const platformFields = {
@@ -3680,9 +4932,16 @@ export {
   AGENT_TOOLS,
   APPLICATION_CLASSIFY_PROMPT,
   AUDIT_TYPES,
+  AcroFormMappingSchema,
   AddressSchema,
   AdmittedStatusSchema,
+  AnswerParsingResultSchema,
+  ApplicationClassifyResultSchema,
+  ApplicationFieldSchema,
+  ApplicationStateSchema,
   AuditTypeSchema,
+  AutoFillMatchSchema,
+  AutoFillResultSchema,
   BOAT_TYPES,
   BindingAuthoritySchema,
   BoatTypeSchema,
@@ -3696,6 +4955,7 @@ export {
   COVERAGE_FORMS,
   COVERAGE_TRIGGERS,
   ChunkTypeSchema,
+  CitationSchema,
   ClaimRecordSchema,
   ClaimStatusSchema,
   ClassificationCodeSchema,
@@ -3738,12 +4998,16 @@ export {
   EnrichedSubjectivitySchema,
   EnrichedUnderwritingConditionSchema,
   EntityTypeSchema,
+  EvidenceItemSchema,
   ExclusionSchema,
   ExperienceModSchema,
   ExtendedReportingPeriodSchema,
   FLOOD_ZONES,
   FOUNDATION_TYPES,
   FarmRanchDeclarationsSchema,
+  FieldExtractionResultSchema,
+  FieldTypeSchema,
+  FlatPdfPlacementSchema,
   FloodDeclarationsSchema,
   FloodZoneSchema,
   FormReferenceSchema,
@@ -3762,6 +5026,9 @@ export {
   LimitScheduleSchema,
   LimitTypeSchema,
   LocationPremiumSchema,
+  LookupFillResultSchema,
+  LookupFillSchema,
+  LookupRequestSchema,
   LossSettlementSchema,
   LossSummarySchema,
   NamedInsuredSchema,
@@ -3771,6 +5038,7 @@ export {
   POLICY_SECTION_TYPES,
   POLICY_TERM_TYPES,
   POLICY_TYPES,
+  ParsedAnswerSchema,
   PaymentInstallmentSchema,
   PaymentPlanSchema,
   PersonalArticlesDeclarationsSchema,
@@ -3790,6 +5058,10 @@ export {
   ProducerInfoSchema,
   ProfessionalLiabilityDeclarationsSchema,
   QUOTE_SECTION_TYPES,
+  QueryClassifyResultSchema,
+  QueryIntentSchema,
+  QueryResultSchema,
+  QuestionBatchResultSchema,
   QuoteDocumentSchema,
   QuoteSectionTypeSchema,
   RATING_BASIS_TYPES,
@@ -3799,12 +5071,16 @@ export {
   RatingBasisSchema,
   RatingBasisTypeSchema,
   RecreationalVehicleDeclarationsSchema,
+  ReplyIntentSchema,
+  RetrievalResultSchema,
   RoofTypeSchema,
   SCHEDULED_ITEM_CATEGORIES,
   SUBJECTIVITY_CATEGORIES,
   ScheduledItemCategorySchema,
   SectionSchema,
   SharedLimitSchema,
+  SubAnswerSchema,
+  SubQuestionSchema,
   SubjectivityCategorySchema,
   SubjectivitySchema,
   SublimitSchema,
@@ -3821,6 +5097,7 @@ export {
   ValuationMethodSchema,
   VehicleCoverageSchema,
   VehicleCoverageTypeSchema,
+  VerifyResultSchema,
   WatercraftDeclarationsSchema,
   WorkersCompDeclarationsSchema,
   buildAcroFormMappingPrompt,
@@ -3840,12 +5117,18 @@ export {
   buildIdentityPrompt,
   buildIntentPrompt,
   buildLookupFillPrompt,
+  buildQueryClassifyPrompt,
   buildQuestionBatchPrompt,
   buildQuotesPoliciesPrompt,
+  buildReasonPrompt,
   buildReplyIntentClassificationPrompt,
+  buildRespondPrompt,
   buildSafetyPrompt,
+  buildVerifyPrompt,
   chunkDocument,
+  createApplicationPipeline,
   createExtractor,
+  createQueryAgent,
   extractPageRange,
   fillAcroForm,
   getAcroFormFields,