@claritylabs/cl-sdk 0.3.1 → 0.6.0

package/dist/index.mjs

@@ -1471,6 +1471,206 @@ function assembleDocument(documentId, documentType, memory) {
   };
 }
 
+// src/prompts/coordinator/format.ts
+function buildFormatPrompt(entries) {
+  const block = entries.map((e) => `===ENTRY ${e.id}===
+${e.text}`).join("\n\n");
+  return `You are a markdown formatting specialist for insurance document content. You will receive numbered content entries extracted from insurance policies, quotes, and endorsements. Your job is to clean up the formatting so every entry renders correctly as standard markdown.
+
+## Primary issues to fix
+
+### 1. Pipe-delimited data missing table syntax
+The most common issue. Content uses pipe characters as column separators but is missing the separator row required for markdown table rendering.
+
+Before (broken \u2014 won't render as a table):
+COVERAGE | FORM # | LIMIT | DEDUCTIBLE
+Employee Theft | | $10,000 | $1,000
+
+After (valid markdown table):
+| COVERAGE | FORM # | LIMIT | DEDUCTIBLE |
+| --- | --- | --- | --- |
+| Employee Theft | | $10,000 | $1,000 |
+
+Rules for pipe tables:
+- Add leading and trailing pipes to every row
+- Add the separator row (| --- | --- |) after the header row
+- Every row must have the same number of pipe-separated columns as the header
+- Empty cells are fine \u2014 just keep the pipes: | | $10,000 |
+
+### 2. Sub-items indented within pipe tables
+Insurance schedules often have indented sub-items that belong to the previous coverage line. These break table column counts.
+
+Before (broken):
+COVERAGE | LIMIT | DEDUCTIBLE
+Causes Of Loss - Equipment Breakdown | PR650END
+  Described Premises Limit | | $350,804 |
+  Diagnostic Equipment | | $100,000 |
+  Deductible Type - Business Income: Waiting Period - Hours
+  Waiting Period (Hours): 24
+
+After: Pull sub-items out of the table. End the table before the sub-items, show them as an indented list, then start a new table if tabular data resumes:
+| COVERAGE | LIMIT | DEDUCTIBLE |
+| --- | --- | --- |
+| Causes Of Loss - Equipment Breakdown | PR650END | |
+
+- Described Premises Limit: $350,804
+- Diagnostic Equipment: $100,000
+- Deductible Type - Business Income: Waiting Period - Hours
+- Waiting Period (Hours): 24
+
+### 3. Space-aligned tables
+Declarations often align columns with spaces instead of pipes. These render as plain monospace text and lose structure.
+
+Before:
+Coverage                               Limit of Liability    Retention
+A. Network Security Liability          $500,000              $10,000
+B. Privacy Liability                   $500,000              $10,000
+
+After (convert to proper markdown table):
+| Coverage | Limit of Liability | Retention |
+| --- | --- | --- |
+| A. Network Security Liability | $500,000 | $10,000 |
+| B. Privacy Liability | $500,000 | $10,000 |
+
+### 4. Mixed table/prose content
+A single entry often contains prose paragraphs followed by tabular data followed by more prose. Handle each segment independently \u2014 don't try to force everything into one table.
+
+### 5. General markdown cleanup
+- **Line spacing**: Remove excessive blank lines (3+ consecutive newlines \u2192 2). Ensure one blank line before and after tables and headings.
+- **Trailing whitespace**: Remove trailing spaces on all lines.
+- **Broken lists**: Ensure list items use consistent markers (-, *, or 1.) with proper nesting indentation.
+- **Orphaned formatting**: Close any unclosed bold (**), italic (*), or code (\`) markers.
+- **Heading levels**: Ensure heading markers (##) have a space after the hashes.
+
+## Rules
+- Do NOT change the meaning or substance of any content. Only fix formatting.
+- Do NOT add new information, headers, or commentary.
+- Do NOT wrap entries in code fences.
+- Preserve all dollar amounts, dates, policy numbers, form numbers, and technical terms exactly as they appear.
+- If an entry is already well-formatted, return it unchanged.
+- When in doubt about whether something is a table, prefer table formatting for structured data with multiple columns.
+
+Return your output in this exact format \u2014 one block per entry, in the same order:
+
+===ENTRY 0===
+(cleaned content for entry 0)
+
+===ENTRY 1===
+(cleaned content for entry 1)
+
+...and so on for each entry.
+
+Here are the entries to format:
+
+${block}`;
+}
+
+// src/extraction/formatter.ts
+function collectContentFields(doc) {
+  const entries = [];
+  let id = 0;
+  function add(path, text) {
+    if (text && text.length > 20) {
+      entries.push({ id: id++, path, text });
+    }
+  }
+  add("summary", doc.summary);
+  if (doc.sections) {
+    for (let i = 0; i < doc.sections.length; i++) {
+      const s = doc.sections[i];
+      add(`sections[${i}].content`, s.content);
+      if (s.subsections) {
+        for (let j = 0; j < s.subsections.length; j++) {
+          add(`sections[${i}].subsections[${j}].content`, s.subsections[j].content);
+        }
+      }
+    }
+  }
+  if (doc.endorsements) {
+    for (let i = 0; i < doc.endorsements.length; i++) {
+      add(`endorsements[${i}].content`, doc.endorsements[i].content);
+    }
+  }
+  if (doc.exclusions) {
+    for (let i = 0; i < doc.exclusions.length; i++) {
+      add(`exclusions[${i}].content`, doc.exclusions[i].content);
+    }
+  }
+  if (doc.conditions) {
+    for (let i = 0; i < doc.conditions.length; i++) {
+      add(`conditions[${i}].content`, doc.conditions[i].content);
+    }
+  }
+  return entries;
+}
+function parseFormatResponse(response) {
+  const results = /* @__PURE__ */ new Map();
+  const parts = response.split(/===ENTRY (\d+)===/);
+  for (let i = 1; i < parts.length; i += 2) {
+    const entryId = parseInt(parts[i], 10);
+    const content = parts[i + 1]?.trim();
+    if (!isNaN(entryId) && content !== void 0) {
+      results.set(entryId, content);
+    }
+  }
+  return results;
+}
+function applyFormattedContent(doc, entries, formatted) {
+  for (const entry of entries) {
+    const cleaned = formatted.get(entry.id);
+    if (!cleaned) continue;
+    const segments = entry.path.match(/^(\w+)(?:\[(\d+)\])?(?:\.(\w+)(?:\[(\d+)\])?(?:\.(\w+))?)?$/);
+    if (!segments) continue;
+    const [, field, idx1, sub1, idx2, sub2] = segments;
+    if (!sub1) {
+      doc[field] = cleaned;
+    } else if (!sub2) {
+      const arr = doc[field];
+      if (arr && arr[Number(idx1)]) {
+        arr[Number(idx1)][sub1] = cleaned;
+      }
+    } else {
+      const arr = doc[field];
+      if (arr && arr[Number(idx1)]) {
+        const nested = arr[Number(idx1)][sub1];
+        if (nested && nested[Number(idx2)]) {
+          nested[Number(idx2)][sub2] = cleaned;
+        }
+      }
+    }
+  }
+}
+var MAX_ENTRIES_PER_BATCH = 20;
+async function formatDocumentContent(doc, generateText, options) {
+  const entries = collectContentFields(doc);
+  const totalUsage = { inputTokens: 0, outputTokens: 0 };
+  if (entries.length === 0) {
+    return { document: doc, usage: totalUsage };
+  }
+  options?.onProgress?.(`Formatting ${entries.length} content fields...`);
+  const batches = [];
+  for (let i = 0; i < entries.length; i += MAX_ENTRIES_PER_BATCH) {
+    batches.push(entries.slice(i, i + MAX_ENTRIES_PER_BATCH));
+  }
+  for (const batch of batches) {
+    const prompt = buildFormatPrompt(batch.map((e) => ({ id: e.id, text: e.text })));
+    const result = await withRetry(
+      () => generateText({
+        prompt,
+        maxTokens: 16384,
+        providerOptions: options?.providerOptions
+      })
+    );
+    if (result.usage) {
+      totalUsage.inputTokens += result.usage.inputTokens;
+      totalUsage.outputTokens += result.usage.outputTokens;
+    }
+    const formatted = parseFormatResponse(result.text);
+    applyFormattedContent(doc, batch, formatted);
+  }
+  return { document: doc, usage: totalUsage };
+}
+
 // src/extraction/chunking.ts
 function chunkDocument(doc) {
   const chunks = [];
@@ -2966,8 +3166,14 @@ function createExtractor(config) {
     }
     onProgress?.("Assembling document...");
     const document = assembleDocument(id, documentType, memory);
-    const chunks = chunkDocument(document);
-    return { document, chunks, tokenUsage: totalUsage };
+    onProgress?.("Formatting extracted content...");
+    const formatResult = await formatDocumentContent(document, generateText, {
+      providerOptions,
+      onProgress
+    });
+    trackUsage(formatResult.usage);
+    const chunks = chunkDocument(formatResult.document);
+    return { document: formatResult.document, chunks, tokenUsage: totalUsage };
   }
   return { extract };
 }
@@ -3185,6 +3391,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 +3546,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 +3593,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 +3660,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 +3719,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 +3897,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 +5138,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 +5161,7 @@ export {
   COVERAGE_FORMS,
   COVERAGE_TRIGGERS,
   ChunkTypeSchema,
+  CitationSchema,
   ClaimRecordSchema,
   ClaimStatusSchema,
   ClassificationCodeSchema,
@@ -3738,12 +5204,16 @@ export {
   EnrichedSubjectivitySchema,
   EnrichedUnderwritingConditionSchema,
   EntityTypeSchema,
+  EvidenceItemSchema,
   ExclusionSchema,
   ExperienceModSchema,
   ExtendedReportingPeriodSchema,
   FLOOD_ZONES,
   FOUNDATION_TYPES,
   FarmRanchDeclarationsSchema,
+  FieldExtractionResultSchema,
+  FieldTypeSchema,
+  FlatPdfPlacementSchema,
   FloodDeclarationsSchema,
   FloodZoneSchema,
   FormReferenceSchema,
@@ -3762,6 +5232,9 @@ export {
   LimitScheduleSchema,
   LimitTypeSchema,
   LocationPremiumSchema,
+  LookupFillResultSchema,
+  LookupFillSchema,
+  LookupRequestSchema,
   LossSettlementSchema,
   LossSummarySchema,
   NamedInsuredSchema,
@@ -3771,6 +5244,7 @@ export {
   POLICY_SECTION_TYPES,
   POLICY_TERM_TYPES,
   POLICY_TYPES,
+  ParsedAnswerSchema,
   PaymentInstallmentSchema,
   PaymentPlanSchema,
   PersonalArticlesDeclarationsSchema,
@@ -3790,6 +5264,10 @@ export {
   ProducerInfoSchema,
   ProfessionalLiabilityDeclarationsSchema,
   QUOTE_SECTION_TYPES,
+  QueryClassifyResultSchema,
+  QueryIntentSchema,
+  QueryResultSchema,
+  QuestionBatchResultSchema,
   QuoteDocumentSchema,
   QuoteSectionTypeSchema,
   RATING_BASIS_TYPES,
@@ -3799,12 +5277,16 @@ export {
   RatingBasisSchema,
   RatingBasisTypeSchema,
   RecreationalVehicleDeclarationsSchema,
+  ReplyIntentSchema,
+  RetrievalResultSchema,
   RoofTypeSchema,
   SCHEDULED_ITEM_CATEGORIES,
   SUBJECTIVITY_CATEGORIES,
   ScheduledItemCategorySchema,
   SectionSchema,
   SharedLimitSchema,
+  SubAnswerSchema,
+  SubQuestionSchema,
   SubjectivityCategorySchema,
   SubjectivitySchema,
   SublimitSchema,
@@ -3821,6 +5303,7 @@ export {
   ValuationMethodSchema,
   VehicleCoverageSchema,
   VehicleCoverageTypeSchema,
+  VerifyResultSchema,
   WatercraftDeclarationsSchema,
   WorkersCompDeclarationsSchema,
   buildAcroFormMappingPrompt,
@@ -3840,12 +5323,18 @@ export {
   buildIdentityPrompt,
   buildIntentPrompt,
   buildLookupFillPrompt,
+  buildQueryClassifyPrompt,
   buildQuestionBatchPrompt,
   buildQuotesPoliciesPrompt,
+  buildReasonPrompt,
   buildReplyIntentClassificationPrompt,
+  buildRespondPrompt,
   buildSafetyPrompt,
+  buildVerifyPrompt,
   chunkDocument,
+  createApplicationPipeline,
   createExtractor,
+  createQueryAgent,
   extractPageRange,
   fillAcroForm,
   getAcroFormFields,