@claritylabs/cl-sdk 0.17.1 → 0.18.0

package/dist/index.mjs

@@ -203,6 +203,72 @@ function createPipelineContext(opts) {
   };
 }
 
+// src/core/model-budget.ts
+function positiveInteger(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.floor(value) : void 0;
+}
+function resolveModelBudget(params) {
+  const { taskKind, modelCapabilities, constraint } = params;
+  const hintTokens = positiveInteger(params.hintTokens) ?? 4096;
+  const taskCapability = positiveInteger(modelCapabilities?.taskOutputTokens?.[taskKind]);
+  const longListCapability = taskKind === "extraction_long_list" ? positiveInteger(modelCapabilities?.longListOutputTokens) : void 0;
+  const defaultCapability = positiveInteger(modelCapabilities?.defaultOutputTokens);
+  const constrainedPreference = positiveInteger(constraint?.outputTokens);
+  const minOutputTokens = positiveInteger(constraint?.minOutputTokens);
+  const modelMaxOutputTokens = positiveInteger(modelCapabilities?.maxOutputTokens);
+  const providerMaxOutputTokens = positiveInteger(params.providerMaxOutputTokens);
+  const hardMaxOutputTokens = positiveInteger(constraint?.maxOutputTokens) ?? providerMaxOutputTokens;
+  const estimatedInputTokens = estimateTokens(params.inputContextBytes);
+  const schemaTokens = estimateTokens(params.schemaSizeBytes) ?? 0;
+  const expectedListLength = positiveInteger(params.expectedListLength) ?? 0;
+  const warnings = [];
+  let maxTokens = constrainedPreference ?? taskCapability ?? longListCapability ?? defaultCapability ?? hintTokens;
+  if (minOutputTokens) {
+    maxTokens = Math.max(maxTokens, minOutputTokens);
+  }
+  if (modelMaxOutputTokens) {
+    if (maxTokens > modelMaxOutputTokens) {
+      warnings.push(`Resolved ${taskKind} budget was capped by model max output tokens.`);
+    }
+    maxTokens = Math.min(maxTokens, modelMaxOutputTokens);
+  }
+  if (hardMaxOutputTokens) {
+    if (maxTokens > hardMaxOutputTokens) {
+      warnings.push(`Resolved ${taskKind} budget was capped by an explicit hard max output token constraint.`);
+    }
+    maxTokens = Math.min(maxTokens, hardMaxOutputTokens);
+  }
+  const expectedOutputFloor = expectedOutputTokensFloor(taskKind, schemaTokens, expectedListLength, hintTokens);
+  const outputTruncationRisk = maxTokens < expectedOutputFloor * 0.65 ? "high" : maxTokens < expectedOutputFloor ? "medium" : "low";
+  if (outputTruncationRisk !== "low") {
+    warnings.push(`Resolved ${taskKind} budget may be under-sized for the expected output shape.`);
+  }
+  const maxInputTokens = positiveInteger(modelCapabilities?.maxInputTokens);
+  if (estimatedInputTokens && maxInputTokens && estimatedInputTokens > maxInputTokens * 0.9) {
+    warnings.push(`Estimated ${taskKind} input context is close to or above the configured model input limit.`);
+  }
+  return {
+    taskKind,
+    maxTokens,
+    hintTokens,
+    modelMaxOutputTokens,
+    hardMaxOutputTokens,
+    estimatedInputTokens,
+    outputTruncationRisk,
+    warnings
+  };
+}
+function estimateTokens(bytes) {
+  const positive = positiveInteger(bytes);
+  if (!positive) return void 0;
+  return Math.ceil(positive / 4);
+}
+function expectedOutputTokensFloor(taskKind, schemaTokens, expectedListLength, hintTokens) {
+  const listMultiplier = taskKind === "extraction_long_list" ? 90 : 45;
+  const listFloor = expectedListLength > 0 ? expectedListLength * listMultiplier : 0;
+  return Math.max(Math.ceil(schemaTokens * 1.5), listFloor, Math.floor(hintTokens * 0.75));
+}
+
 // src/schemas/enums.ts
 import { z as z2 } from "zod";
 var PolicyTypeSchema = z2.enum([
@@ -554,7 +620,10 @@ var CoverageSchema = z4.object({
   formNumber: z4.string().optional(),
   pageNumber: z4.number().optional(),
   sectionRef: z4.string().optional(),
-  originalContent: z4.string().optional()
+  originalContent: z4.string().optional(),
+  recordId: z4.string().optional(),
+  sourceSpanIds: z4.array(z4.string()).optional(),
+  sourceTextHash: z4.string().optional()
 });
 var EnrichedCoverageSchema = z4.object({
   name: z4.string(),
@@ -578,7 +647,10 @@ var EnrichedCoverageSchema = z4.object({
   premium: z4.string().optional(),
   pageNumber: z4.number().optional(),
   sectionRef: z4.string().optional(),
-  originalContent: z4.string().optional()
+  originalContent: z4.string().optional(),
+  recordId: z4.string().optional(),
+  sourceSpanIds: z4.array(z4.string()).optional(),
+  sourceTextHash: z4.string().optional()
 });
 
 // src/schemas/endorsement.ts
@@ -602,7 +674,10 @@ var EndorsementSchema = z5.object({
   premiumImpact: z5.string().optional(),
   content: z5.string(),
   pageStart: z5.number(),
-  pageEnd: z5.number().optional()
+  pageEnd: z5.number().optional(),
+  recordId: z5.string().optional(),
+  sourceSpanIds: z5.array(z5.string()).optional(),
+  sourceTextHash: z5.string().optional()
 });
 
 // src/schemas/exclusion.ts
@@ -617,7 +692,10 @@ var ExclusionSchema = z6.object({
   buybackEndorsement: z6.string().optional(),
   appliesTo: z6.array(z6.string()).optional(),
   content: z6.string(),
-  pageNumber: z6.number().optional()
+  pageNumber: z6.number().optional(),
+  recordId: z6.string().optional(),
+  sourceSpanIds: z6.array(z6.string()).optional(),
+  sourceTextHash: z6.string().optional()
 });
 
 // src/schemas/condition.ts
@@ -631,7 +709,10 @@ var PolicyConditionSchema = z7.object({
   conditionType: ConditionTypeSchema,
   content: z7.string(),
   keyValues: z7.array(ConditionKeyValueSchema).optional(),
-  pageNumber: z7.number().optional()
+  pageNumber: z7.number().optional(),
+  recordId: z7.string().optional(),
+  sourceSpanIds: z7.array(z7.string()).optional(),
+  sourceTextHash: z7.string().optional()
 });
 
 // src/schemas/parties.ts
@@ -1214,7 +1295,10 @@ var SectionSchema = z16.object({
   type: z16.string(),
   coverageType: z16.string().optional(),
   content: z16.string(),
-  subsections: z16.array(SubsectionSchema).optional()
+  subsections: z16.array(SubsectionSchema).optional(),
+  recordId: z16.string().optional(),
+  sourceSpanIds: z16.array(z16.string()).optional(),
+  sourceTextHash: z16.string().optional()
 });
 var SubjectivitySchema = z16.object({
   description: z16.string(),
@@ -1240,7 +1324,10 @@ var DefinitionSchema = z16.object({
   formNumber: z16.string().optional(),
   formTitle: z16.string().optional(),
   sectionRef: z16.string().optional(),
-  originalContent: z16.string().optional()
+  originalContent: z16.string().optional(),
+  recordId: z16.string().optional(),
+  sourceSpanIds: z16.array(z16.string()).optional(),
+  sourceTextHash: z16.string().optional()
 });
 var CoveredReasonSchema = z16.object({
   coverageName: z16.string(),
@@ -1254,7 +1341,10 @@ var CoveredReasonSchema = z16.object({
   formNumber: z16.string().optional(),
   formTitle: z16.string().optional(),
   sectionRef: z16.string().optional(),
-  originalContent: z16.string().optional()
+  originalContent: z16.string().optional(),
+  recordId: z16.string().optional(),
+  sourceSpanIds: z16.array(z16.string()).optional(),
+  sourceTextHash: z16.string().optional()
 });
 var BaseDocumentFields = {
   id: z16.string(),
@@ -1393,6 +1483,294 @@ var PLATFORM_CONFIGS = {
   }
 };
 
+// src/schemas/pce.ts
+import { z as z19 } from "zod";
+
+// src/case/index.ts
+import { z as z18 } from "zod";
+var CaseEvidenceSourceSchema = z18.object({
+  id: z18.string(),
+  label: z18.string().optional(),
+  documentId: z18.string().optional(),
+  page: z18.number().optional(),
+  fieldPath: z18.string().optional(),
+  text: z18.string().describe("Source text available for span validation and citation"),
+  metadata: z18.record(z18.string()).optional()
+});
+var CaseCitationSchema = z18.object({
+  sourceId: z18.string(),
+  quote: z18.string(),
+  page: z18.number().optional(),
+  fieldPath: z18.string().optional()
+});
+var ValidationIssueSeveritySchema = z18.enum(["info", "warning", "blocking"]);
+var CaseValidationIssueSchema = z18.object({
+  code: z18.string(),
+  severity: ValidationIssueSeveritySchema,
+  message: z18.string(),
+  itemId: z18.string().optional(),
+  fieldPath: z18.string().optional(),
+  sourceId: z18.string().optional()
+});
+var MissingInfoQuestionSchema = z18.object({
+  id: z18.string(),
+  itemId: z18.string().optional(),
+  fieldPath: z18.string().optional(),
+  question: z18.string(),
+  reason: z18.string(),
+  answer: z18.string().optional()
+});
+var CasePacketArtifactKindSchema = z18.enum([
+  "underwriter_summary",
+  "carrier_email",
+  "missing_info_request",
+  "json_packet",
+  "validation_report"
+]);
+var CasePacketArtifactSchema = z18.object({
+  id: z18.string(),
+  kind: CasePacketArtifactKindSchema,
+  title: z18.string(),
+  content: z18.string(),
+  citations: z18.array(CaseCitationSchema).default([])
+});
+var CaseSubmissionPacketSchema = z18.object({
+  id: z18.string(),
+  caseId: z18.string(),
+  artifacts: z18.array(CasePacketArtifactSchema),
+  validationIssues: z18.array(CaseValidationIssueSchema),
+  missingInfoQuestions: z18.array(MissingInfoQuestionSchema),
+  createdAt: z18.number()
+});
+var CaseActionSchema = z18.enum([
+  "inspect_attachments",
+  "retrieve_policy_evidence",
+  "retrieve_prior_applications",
+  "normalize_requested_change",
+  "extract_application_fields",
+  "fill_from_org_context",
+  "fill_from_source_spans",
+  "ask_missing_info_questions",
+  "run_validation",
+  "generate_packet",
+  "answer_field_or_case_question"
+]);
+var AgenticExecutionModeSchema = z18.enum(["deterministic_tree", "market_eval", "hybrid"]);
+var CaseProposalScoreSchema = z18.object({
+  grounding: z18.number().min(0).max(1),
+  completeness: z18.number().min(0).max(1),
+  consistency: z18.number().min(0).max(1),
+  determinism: z18.number().min(0).max(1),
+  risk: z18.number().min(0).max(1),
+  cost: z18.number().min(0).max(1)
+});
+var CaseProposalSchema = z18.object({
+  id: z18.string(),
+  sourceSpanIds: z18.array(z18.string()).default([]),
+  confidence: z18.number().min(0).max(1),
+  missingInfo: z18.array(z18.string()).default([]),
+  validationIssues: z18.array(CaseValidationIssueSchema).default([]),
+  estimatedRisk: z18.number().min(0).max(1).default(0.5),
+  estimatedCost: z18.number().min(0).max(1).default(0.5),
+  score: CaseProposalScoreSchema.optional()
+});
+function stableCaseId(prefix, parts) {
+  return `${prefix}-${stableHash(stableStringify(parts)).slice(0, 12)}`;
+}
+function stableStringify(value) {
+  if (Array.isArray(value)) {
+    return `[${value.map((entry) => stableStringify(entry)).join(",")}]`;
+  }
+  if (value && typeof value === "object") {
+    const record = value;
+    return `{${Object.keys(record).sort().map((key) => `${JSON.stringify(key)}:${stableStringify(record[key])}`).join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
+function stableHash(input) {
+  let hashA = 2166136261;
+  let hashB = 2654435769;
+  for (let index = 0; index < input.length; index++) {
+    const char = input.charCodeAt(index);
+    hashA ^= char;
+    hashA = Math.imul(hashA, 16777619);
+    hashB ^= char + index;
+    hashB = Math.imul(hashB, 2246822507);
+  }
+  return `${(hashA >>> 0).toString(16).padStart(8, "0")}${(hashB >>> 0).toString(16).padStart(8, "0")}`;
+}
+function normalizeForMatch(value) {
+  return value.replace(/\s+/g, " ").trim().toLowerCase();
+}
+function evidenceContainsQuote(source, quote) {
+  if (!source || !quote.trim()) return false;
+  return normalizeForMatch(source.text).includes(normalizeForMatch(quote));
+}
+function validateQuotedEvidence(params) {
+  const quote = params.quote?.trim();
+  if (!quote) return [];
+  const citation = params.citation;
+  if (!citation) {
+    return [{
+      code: "missing_citation",
+      severity: params.severity ?? "blocking",
+      message: `Quoted value for ${params.fieldPath} is missing a citation.`,
+      itemId: params.itemId,
+      fieldPath: params.fieldPath
+    }];
+  }
+  const source = params.sources.find((candidate) => candidate.id === citation.sourceId);
+  if (!source) {
+    return [{
+      code: "unknown_source",
+      severity: params.severity ?? "blocking",
+      message: `Citation source ${citation.sourceId} was not provided for ${params.fieldPath}.`,
+      itemId: params.itemId,
+      fieldPath: params.fieldPath,
+      sourceId: citation.sourceId
+    }];
+  }
+  const citedQuote = citation.quote.trim() || quote;
+  if (!evidenceContainsQuote(source, citedQuote) || !evidenceContainsQuote(source, quote)) {
+    return [{
+      code: "quote_not_found",
+      severity: params.severity ?? "blocking",
+      message: `Quoted value for ${params.fieldPath} was not found in source ${source.id}.`,
+      itemId: params.itemId,
+      fieldPath: params.fieldPath,
+      sourceId: source.id
+    }];
+  }
+  return [];
+}
+var validateEvidence = validateQuotedEvidence;
+function mergeQuestionAnswers(questions, answers) {
+  let answeredCount = 0;
+  const merged = questions.map((question) => {
+    const answer = answers.find(
+      (candidate) => candidate.questionId && candidate.questionId === question.id || candidate.fieldPath && candidate.fieldPath === question.fieldPath
+    );
+    if (!answer?.answer.trim()) return question;
+    answeredCount += question.answer === answer.answer ? 0 : 1;
+    return { ...question, answer: answer.answer };
+  });
+  return { questions: merged, answeredCount };
+}
+var processReply = mergeQuestionAnswers;
+function generateNextMessage(questions) {
+  const openQuestions = questions.filter((question) => !question.answer?.trim());
+  if (openQuestions.length === 0) return "No missing information questions are open.";
+  return openQuestions.map((question) => question.question).join("\n");
+}
+function scoreCaseProposal(proposal) {
+  if (proposal.score) return proposal.score;
+  const hasBlockingIssue = proposal.validationIssues.some((issue) => issue.severity === "blocking");
+  const grounding = proposal.sourceSpanIds.length > 0 ? 1 : 0;
+  return {
+    grounding,
+    completeness: proposal.missingInfo.length === 0 ? 1 : 0.4,
+    consistency: hasBlockingIssue ? 0 : 1,
+    determinism: proposal.id.trim().length > 0 ? 1 : 0,
+    risk: 1 - proposal.estimatedRisk,
+    cost: 1 - proposal.estimatedCost
+  };
+}
+function evaluateCaseProposals(proposals) {
+  return proposals.filter((proposal) => !proposal.validationIssues.some(
+    (issue) => issue.severity === "blocking" && (issue.code === "missing_citation" || issue.code === "unknown_source" || issue.code === "quote_not_found")
+  )).map((proposal) => ({ proposal, score: scoreCaseProposal(proposal) })).sort((left, right) => {
+    const leftTotal = totalProposalScore(left.score);
+    const rightTotal = totalProposalScore(right.score);
+    if (rightTotal !== leftTotal) return rightTotal - leftTotal;
+    return left.proposal.id.localeCompare(right.proposal.id);
+  })[0]?.proposal;
+}
+function totalProposalScore(score) {
+  return score.grounding * 3 + score.completeness * 2 + score.consistency * 3 + score.determinism + score.risk + score.cost;
+}
+
+// src/schemas/pce.ts
+var PolicyChangeActionSchema = z19.enum(["add", "remove", "update", "replace", "clarify"]);
+var PolicyChangeKindSchema = z19.enum([
+  "named_insured_change",
+  "additional_insured_change",
+  "coverage_change",
+  "limit_change",
+  "deductible_change",
+  "location_change",
+  "vehicle_change",
+  "certificate_endorsement_request",
+  "cancellation",
+  "nonrenewal",
+  "renewal_submission_update",
+  "general_endorsement"
+]);
+var PolicyChangeConfidenceSchema = z19.enum(["high", "medium", "low"]);
+var PolicyChangeStatusSchema = z19.enum(["draft", "needs_info", "ready", "blocked"]);
+var PolicyChangeItemSchema = z19.object({
+  id: z19.string(),
+  kind: PolicyChangeKindSchema.default("general_endorsement"),
+  action: PolicyChangeActionSchema,
+  affectedPolicyId: z19.string().default("unknown"),
+  fieldPath: z19.string().describe("Stable policy field path or business field name"),
+  label: z19.string(),
+  beforeValue: z19.string().optional().describe("Existing policy value, when cited from policy evidence"),
+  afterValue: z19.string().optional().describe("Requested new value"),
+  requestedValue: z19.string().optional().describe("Alias for afterValue used by policy-change workflows"),
+  effectiveDate: z19.string().optional(),
+  reason: z19.string().optional(),
+  sourceIds: z19.array(z19.string()).default([]),
+  sourceSpanIds: z19.array(z19.string()).default([]),
+  userSourceSpanIds: z19.array(z19.string()).optional(),
+  citations: z19.array(CaseCitationSchema).default([]),
+  confidence: PolicyChangeConfidenceSchema.default("medium"),
+  confidenceScore: z19.number().min(0).max(1).optional(),
+  status: PolicyChangeStatusSchema.default("ready")
+});
+var PceNormalizationResultSchema = z19.object({
+  summary: z19.string(),
+  items: z19.array(PolicyChangeItemSchema.omit({ id: true, status: true }).extend({
+    id: z19.string().optional(),
+    status: PolicyChangeStatusSchema.optional()
+  })),
+  missingInfoQuestions: z19.array(MissingInfoQuestionSchema.omit({ id: true }).extend({
+    id: z19.string().optional()
+  })).default([])
+});
+var PolicyChangeImpactSchema = z19.object({
+  itemId: z19.string(),
+  beforeValue: z19.string().optional(),
+  requestedValue: z19.string().optional(),
+  likelyEndorsementRequired: z19.boolean().default(true),
+  carrierApprovalLikelyRequired: z19.boolean().default(true),
+  affectedCoverageForms: z19.array(z19.string()).default([]),
+  sourceSpanIds: z19.array(z19.string()).default([])
+});
+var PceCaseStateSchema = z19.object({
+  id: z19.string(),
+  requestText: z19.string(),
+  summary: z19.string(),
+  executionMode: AgenticExecutionModeSchema.default("deterministic_tree"),
+  items: z19.array(PolicyChangeItemSchema),
+  impacts: z19.array(PolicyChangeImpactSchema),
+  evidenceSources: z19.array(CaseEvidenceSourceSchema),
+  validationIssues: z19.array(CaseValidationIssueSchema),
+  missingInfoQuestions: z19.array(MissingInfoQuestionSchema),
+  createdAt: z19.number(),
+  updatedAt: z19.number()
+});
+var PolicyChangeRequestSchema = z19.object({
+  id: z19.string(),
+  text: z19.string(),
+  executionMode: AgenticExecutionModeSchema.optional(),
+  userSourceSpanIds: z19.array(z19.string()).optional(),
+  createdAt: z19.number().optional()
+});
+var PceSubmissionPacketSchema = CaseSubmissionPacketSchema.extend({
+  pceCase: PceCaseStateSchema,
+  artifacts: z19.array(CasePacketArtifactSchema)
+});
+
 // src/schemas/context-keys.ts
 var CONTEXT_KEY_MAP = [
   { extractedField: "insuredName", category: "company_info", contextKey: "company_name", description: "Primary named insured" },
@@ -1445,6 +1823,400 @@ var CONTEXT_KEY_MAP = [
   { extractedField: "declarations.breed", category: "pet_info", contextKey: "pet_breed", description: "Pet breed" }
 ];
 
+// src/source/schemas.ts
+import { z as z20 } from "zod";
+var SourceSpanKindSchema = z20.enum([
+  "pdf_text",
+  "pdf_image",
+  "html",
+  "markdown",
+  "plain_text",
+  "structured_field"
+]);
+var SourceKindSchema = z20.enum([
+  "policy_pdf",
+  "application_pdf",
+  "email",
+  "attachment",
+  "manual_note"
+]);
+var SourceSpanBBoxSchema = z20.object({
+  page: z20.number().int().positive(),
+  x: z20.number(),
+  y: z20.number(),
+  width: z20.number(),
+  height: z20.number()
+});
+var SourceSpanLocationSchema = z20.object({
+  page: z20.number().int().positive().optional(),
+  startPage: z20.number().int().positive().optional(),
+  endPage: z20.number().int().positive().optional(),
+  charStart: z20.number().int().nonnegative().optional(),
+  charEnd: z20.number().int().nonnegative().optional(),
+  lineStart: z20.number().int().positive().optional(),
+  lineEnd: z20.number().int().positive().optional(),
+  fieldPath: z20.string().optional()
+});
+var SourceSpanSchema = z20.object({
+  id: z20.string().min(1),
+  documentId: z20.string().min(1),
+  sourceKind: SourceKindSchema.optional(),
+  chunkId: z20.string().optional(),
+  kind: SourceSpanKindSchema,
+  text: z20.string(),
+  hash: z20.string().min(1),
+  textHash: z20.string().optional(),
+  pageStart: z20.number().int().positive().optional(),
+  pageEnd: z20.number().int().positive().optional(),
+  sectionId: z20.string().optional(),
+  formNumber: z20.string().optional(),
+  bbox: z20.array(SourceSpanBBoxSchema).optional(),
+  location: SourceSpanLocationSchema.optional(),
+  metadata: z20.record(z20.string()).optional()
+});
+var SourceSpanRefSchema = z20.object({
+  sourceSpanId: z20.string().min(1),
+  documentId: z20.string().min(1).optional(),
+  chunkId: z20.string().optional(),
+  quote: z20.string().optional(),
+  hash: z20.string().optional(),
+  location: SourceSpanLocationSchema.optional()
+});
+var SourceChunkSchema = z20.object({
+  id: z20.string().min(1),
+  documentId: z20.string().min(1),
+  sourceSpanIds: z20.array(z20.string().min(1)),
+  text: z20.string(),
+  textHash: z20.string().min(1),
+  pageStart: z20.number().int().positive().optional(),
+  pageEnd: z20.number().int().positive().optional(),
+  metadata: z20.record(z20.string()).default({})
+});
+
+// src/source/ids.ts
+function normalizeText(text) {
+  return text.replace(/\s+/g, " ").trim();
+}
+function stableStringify2(value) {
+  if (value === void 0) {
+    return "undefined";
+  }
+  if (value === null || typeof value !== "object") {
+    return JSON.stringify(value) ?? "undefined";
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map((item) => stableStringify2(item)).join(",")}]`;
+  }
+  const record = value;
+  return `{${Object.keys(record).sort().filter((key) => record[key] !== void 0).map((key) => `${JSON.stringify(key)}:${stableStringify2(record[key])}`).join(",")}}`;
+}
+function stableHash2(value) {
+  const input = stableStringify2(value);
+  let hashA = 2166136261;
+  let hashB = 73244475;
+  for (let index = 0; index < input.length; index++) {
+    const char = input.charCodeAt(index);
+    hashA ^= char;
+    hashA = Math.imul(hashA, 16777619);
+    hashB ^= char + index;
+    hashB = Math.imul(hashB, 668265261);
+  }
+  return `${(hashA >>> 0).toString(16).padStart(8, "0")}${(hashB >>> 0).toString(16).padStart(8, "0")}`;
+}
+function sourceSpanTextHash(text) {
+  return stableHash2(normalizeText(text));
+}
+function buildSourceSpanId(input) {
+  const hash = stableHash2({
+    documentId: input.documentId,
+    chunkId: input.chunkId,
+    fieldPath: input.fieldPath,
+    location: input.location,
+    text: input.text ? normalizeText(input.text) : void 0
+  }).slice(0, 16);
+  return [input.documentId, input.chunkId, input.fieldPath, hash].filter((part) => !!part).map((part) => part.replace(/[^a-zA-Z0-9_.:-]/g, "_")).join(":");
+}
+
+// src/source/retrieval.ts
+function evidenceTieBreakId(evidence) {
+  return [
+    evidence.source ?? "",
+    evidence.sourceSpanId ?? "",
+    evidence.chunkId ?? "",
+    evidence.documentId ?? "",
+    evidence.turnId ?? "",
+    evidence.attachmentId ?? "",
+    evidence.text
+  ].join("|");
+}
+function compareSourceEvidence(a, b) {
+  const relevanceDelta = b.relevance - a.relevance;
+  if (relevanceDelta !== 0) return relevanceDelta;
+  return evidenceTieBreakId(a).localeCompare(evidenceTieBreakId(b));
+}
+function orderSourceEvidence(evidence) {
+  return [...evidence].sort(compareSourceEvidence);
+}
+
+// src/source/extraction.ts
+function normalizeWhitespace(value) {
+  return value.replace(/\s+/g, " ").trim();
+}
+function sanitizeIdPart(value) {
+  return value.replace(/[^a-zA-Z0-9_.:-]/g, "_");
+}
+function buildSourceSpan(input, localIndex = 0) {
+  const text = normalizeWhitespace(input.text);
+  const textHash = sourceSpanTextHash(text);
+  const pagePart = input.pageStart ?? "na";
+  const id = [
+    sanitizeIdPart(input.documentId),
+    "span",
+    pagePart,
+    localIndex,
+    textHash.slice(0, 12)
+  ].join(":");
+  return SourceSpanSchema.parse({
+    id,
+    documentId: input.documentId,
+    sourceKind: input.sourceKind,
+    kind: input.sourceKind.endsWith("_pdf") ? "pdf_text" : "plain_text",
+    text,
+    hash: textHash,
+    textHash,
+    pageStart: input.pageStart,
+    pageEnd: input.pageEnd,
+    sectionId: input.sectionId,
+    formNumber: input.formNumber,
+    location: {
+      page: input.pageStart === input.pageEnd ? input.pageStart : void 0,
+      startPage: input.pageStart,
+      endPage: input.pageEnd,
+      fieldPath: input.sectionId
+    },
+    metadata: input.metadata
+  });
+}
+function buildPageSourceSpans(pages) {
+  return pages.filter((page) => normalizeWhitespace(page.text).length > 0).map(
+    (page, index) => buildSourceSpan(
+      {
+        documentId: page.documentId,
+        sourceKind: page.sourceKind ?? "policy_pdf",
+        text: page.text,
+        pageStart: page.pageNumber,
+        pageEnd: page.pageNumber,
+        sectionId: page.sectionId,
+        formNumber: page.formNumber,
+        metadata: page.metadata
+      },
+      index
+    )
+  );
+}
+function buildSectionSourceSpans(pages, options = {}) {
+  const headingPattern = options.headingPattern ?? /^(?:SECTION|COVERAGE|EXCLUSION|EXCLUSIONS|CONDITION|CONDITIONS|ENDORSEMENT|ENDORSEMENTS|DEFINITION|DEFINITIONS|DECLARATIONS?|SCHEDULE|FORM)\b[\s:.-]*(.*)$/i;
+  const minSectionChars = options.minSectionChars ?? 120;
+  const spans = [];
+  for (const page of pages) {
+    const sections = splitPageIntoSections(page.text, headingPattern, minSectionChars);
+    for (const section of sections) {
+      spans.push(buildSourceSpan(
+        {
+          documentId: page.documentId,
+          sourceKind: page.sourceKind ?? "policy_pdf",
+          text: section.text,
+          pageStart: page.pageNumber,
+          pageEnd: page.pageNumber,
+          sectionId: section.title,
+          formNumber: inferFormNumber(section.text),
+          metadata: {
+            ...page.metadata ?? {},
+            sourceUnit: "section_candidate"
+          }
+        },
+        spans.length
+      ));
+    }
+  }
+  return spans;
+}
+function buildTextSourceSpans(input, options = {}) {
+  const maxChars = options.maxChars ?? 4e3;
+  const overlapChars = Math.min(options.overlapChars ?? 0, Math.max(0, maxChars - 1));
+  const text = normalizeWhitespace(input.text);
+  if (!text) return [];
+  const spans = [];
+  let cursor = 0;
+  while (cursor < text.length) {
+    const end = Math.min(text.length, cursor + maxChars);
+    const unitText = text.slice(cursor, end);
+    spans.push(buildSourceSpan({ ...input, text: unitText }, spans.length));
+    if (end === text.length) break;
+    cursor = end - overlapChars;
+  }
+  return spans;
+}
+function chunkSourceSpans(spans, options = {}) {
+  const maxChars = options.maxChars ?? 6e3;
+  const chunks = [];
+  let current = [];
+  let currentLength = 0;
+  const flush = () => {
+    if (current.length === 0) return;
+    const text = current.map((span) => span.text).join("\n\n");
+    const textHash = sourceSpanTextHash(text);
+    const pageStart = firstNumber(current.map((span) => span.pageStart));
+    const pageEnd = lastNumber(current.map((span) => span.pageEnd ?? span.pageStart));
+    const chunk = {
+      id: `${sanitizeIdPart(current[0].documentId)}:source_chunk:${chunks.length}:${stableHash2({
+        sourceSpanIds: current.map((span) => span.id),
+        textHash
+      }).slice(0, 12)}`,
+      documentId: current[0].documentId,
+      sourceSpanIds: current.map((span) => span.id),
+      text,
+      textHash,
+      pageStart,
+      pageEnd,
+      metadata: mergeMetadata(current)
+    };
+    chunks.push(SourceChunkSchema.parse(chunk));
+    current = [];
+    currentLength = 0;
+  };
+  for (const span of spans) {
+    const nextLength = currentLength + span.text.length + (current.length > 0 ? 2 : 0);
+    if (current.length > 0 && nextLength > maxChars) {
+      flush();
+    }
+    current.push(span);
+    currentLength += span.text.length + (current.length > 1 ? 2 : 0);
+  }
+  flush();
+  return chunks;
+}
+function splitPageIntoSections(text, headingPattern, minSectionChars) {
+  const lines = text.split(/\r?\n/);
+  const sections = [];
+  let current;
+  for (const rawLine of lines) {
+    const line = rawLine.trim();
+    const match = line.match(headingPattern);
+    if (match) {
+      if (current) sections.push(current);
+      const suffix = match[1]?.trim();
+      current = {
+        title: normalizeWhitespace(suffix ? `${line}` : line).slice(0, 120),
+        lines: [line]
+      };
+      continue;
+    }
+    current?.lines.push(rawLine);
+  }
+  if (current) sections.push(current);
+  return sections.map((section) => ({
+    title: section.title,
+    text: normalizeWhitespace(section.lines.join("\n"))
+  })).filter((section) => section.text.length >= minSectionChars);
+}
+function inferFormNumber(text) {
+  return text.match(/\b[A-Z]{2,8}\s+\d{2,5}(?:\s+\d{2,4})?\b/)?.[0];
+}
+function firstNumber(values) {
+  return values.find((value) => typeof value === "number");
+}
+function lastNumber(values) {
+  return [...values].reverse().find((value) => typeof value === "number");
+}
+function mergeMetadata(spans) {
+  const metadata = {};
+  for (const span of spans) {
+    for (const [key, value] of Object.entries(span.metadata ?? {})) {
+      metadata[key] = metadata[key] ? `${metadata[key]},${value}` : value;
+    }
+    if (span.formNumber) metadata.formNumber = span.formNumber;
+    if (span.sectionId) metadata.sectionId = span.sectionId;
+    if (span.sourceKind) metadata.sourceKind = span.sourceKind;
+  }
+  return metadata;
+}
+
+// src/source/store.ts
+var MemorySourceStore = class {
+  constructor() {
+    this.spans = /* @__PURE__ */ new Map();
+    this.chunks = /* @__PURE__ */ new Map();
+  }
+  async addSourceSpans(spans) {
+    for (const span of spans) {
+      this.spans.set(span.id, span);
+    }
+  }
+  async addSourceChunks(chunks) {
+    for (const chunk of chunks) {
+      this.chunks.set(chunk.id, chunk);
+    }
+  }
+  async getSourceSpan(id) {
+    return this.spans.get(id) ?? null;
+  }
+  async getSourceSpansByDocument(documentId) {
+    return [...this.spans.values()].filter((span) => span.documentId === documentId).sort((left, right) => left.id.localeCompare(right.id));
+  }
+  async getSourceChunksByDocument(documentId) {
+    return [...this.chunks.values()].filter((chunk) => chunk.documentId === documentId).sort((left, right) => left.id.localeCompare(right.id));
+  }
+  async deleteDocumentSource(documentId) {
+    for (const [id, span] of this.spans.entries()) {
+      if (span.documentId === documentId) this.spans.delete(id);
+    }
+    for (const [id, chunk] of this.chunks.entries()) {
+      if (chunk.documentId === documentId) this.chunks.delete(id);
+    }
+  }
+  async searchSourceSpans(query) {
+    const terms = tokenize(query.question);
+    const documentFilter = new Set(query.documentIds ?? []);
+    const chunkFilter = new Set(query.chunkIds ?? []);
+    const limit = query.limit ?? 10;
+    const results = [...this.spans.values()].filter((span) => documentFilter.size === 0 || documentFilter.has(span.documentId)).filter((span) => chunkFilter.size === 0 || (span.chunkId ? chunkFilter.has(span.chunkId) : false)).filter((span) => matchesFilters(span, query.filters)).map((span) => ({
+      span,
+      relevance: lexicalRelevance(span.text, terms)
+    })).filter((result) => result.relevance > 0);
+    return orderSourceEvidence(results.map((result) => ({
+      ...result,
+      sourceSpanId: result.span.id,
+      documentId: result.span.documentId,
+      chunkId: result.span.chunkId,
+      text: result.span.text
+    }))).map(({ span, relevance }) => ({ span, relevance })).slice(0, limit);
+  }
+};
+function tokenize(value) {
+  return Array.from(new Set(
+    value.toLowerCase().split(/[^a-z0-9$.,%-]+/).map((term) => term.trim()).filter((term) => term.length >= 2)
+  ));
+}
+function lexicalRelevance(text, terms) {
+  if (terms.length === 0) return 0;
+  const normalized = text.toLowerCase();
+  const matches = terms.filter((term) => normalized.includes(term)).length;
+  if (matches === 0) return 0;
+  return Math.min(1, matches / terms.length);
+}
+function matchesFilters(span, filters) {
+  if (!filters) return true;
+  for (const [key, value] of Object.entries(filters)) {
+    if (span.metadata?.[key] === value) continue;
+    if (key === "sourceKind" && span.sourceKind === value) continue;
+    if (key === "formNumber" && span.formNumber === value) continue;
+    if (key === "sectionId" && span.sectionId === value) continue;
+    return false;
+  }
+  return true;
+}
+
 // src/extraction/pdf.ts
 import {
   PDFDocument,
@@ -1670,6 +2442,35 @@ async function overlayTextOnPdf(pdfBytes, overlays) {
 }
 
 // src/extraction/extractor.ts
+function sourceSpansForPageRange(providerOptions, startPage, endPage) {
+  const sourceSpans = providerOptions?.sourceSpans;
+  if (!Array.isArray(sourceSpans)) return [];
+  return sourceSpans.filter((span) => {
+    const spanStart = span.pageStart ?? span.location?.startPage ?? span.location?.page;
+    const spanEnd = span.pageEnd ?? span.location?.endPage ?? spanStart;
+    if (!spanStart || !spanEnd) return false;
+    return spanEnd >= startPage && spanStart <= endPage;
+  });
+}
+function buildSourceContext(spans, maxChars = 12e3) {
+  if (spans.length === 0) return "";
+  const lines = [];
+  let length = 0;
+  for (const span of spans) {
+    const header = `[sourceSpan:${span.id}${span.pageStart ? ` page:${span.pageStart}${span.pageEnd && span.pageEnd !== span.pageStart ? `-${span.pageEnd}` : ""}` : ""}${span.sectionId ? ` section:${span.sectionId}` : ""}${span.formNumber ? ` form:${span.formNumber}` : ""}]`;
+    const text = `${header}
+${span.text}`;
+    if (length + text.length > maxChars && lines.length > 0) break;
+    lines.push(text);
+    length += text.length;
+  }
+  return `
+
+SOURCE SPANS FOR THESE PAGES:
+${lines.join("\n\n")}
+
+Use sourceSpan IDs when grounding extracted contractual values.`;
+}
 async function runExtractor(params) {
   const {
     name,
@@ -1681,7 +2482,8 @@ async function runExtractor(params) {
     generateObject,
     convertPdfToImages,
     maxTokens = 4096,
-    providerOptions
+    providerOptions,
+    pageRangeCache
   } = params;
   const extractorProviderOptions = { ...providerOptions };
   let fullPrompt;
@@ -1693,12 +2495,21 @@ async function runExtractor(params) {
 
 [Document pages ${startPage}-${endPage} are provided as images.]`;
   } else {
-    const pagesPdf = await extractPageRange(pdfBase64, startPage, endPage);
+    const cacheKey = `${startPage}-${endPage}`;
+    let pagesPdf = pageRangeCache?.get(cacheKey);
+    if (!pagesPdf) {
+      pagesPdf = await extractPageRange(pdfBase64, startPage, endPage);
+      pageRangeCache?.set(cacheKey, pagesPdf);
+    }
     extractorProviderOptions.pdfBase64 = pagesPdf;
     fullPrompt = `${prompt}
 
 [Document pages ${startPage}-${endPage} are provided as a PDF file.]`;
   }
+  const sourceContext = buildSourceContext(sourceSpansForPageRange(providerOptions, startPage, endPage));
+  if (sourceContext) {
+    fullPrompt += sourceContext;
+  }
   const strictSchema = toStrictSchema(schema);
   const result = await withRetry(
     () => generateObject({
@@ -2297,6 +3108,45 @@ function promoteExtractedFields(doc) {
   promotePremium(doc);
 }
 
+// src/extraction/alignment.ts
+function normalizeKeyPart(value) {
+  if (value === void 0 || value === null) return "na";
+  const normalized = String(value).trim().toLowerCase().replace(/&/g, "and").replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+  return normalized || "na";
+}
+function hashText(value) {
+  let hash = 2166136261;
+  for (let index = 0; index < value.length; index++) {
+    hash ^= value.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0).toString(16).padStart(8, "0").slice(0, 8);
+}
+function evidencePart(record) {
+  const spans = Array.isArray(record.sourceSpanIds) ? record.sourceSpanIds.join(",") : "";
+  return [
+    spans,
+    record.sourceTextHash,
+    record.formNumber,
+    record.pageNumber ?? record.pageStart,
+    record.sectionRef,
+    record.originalContent ?? record.content
+  ].filter((part) => part !== void 0 && part !== null && String(part).trim().length > 0).map(normalizeKeyPart).join("|");
+}
+function buildExtractionRecordId(documentId, recordKind, record, labelParts) {
+  const label = labelParts.map(normalizeKeyPart).join(":");
+  const evidence = evidencePart(record);
+  const hash = hashText(`${documentId}|${recordKind}|${label}|${evidence}`);
+  return `${recordKind}:${normalizeKeyPart(documentId)}:${label}:${hash}`;
+}
+function alignExtractionRecords(documentId, recordKind, records, labelParts) {
+  if (!records?.length) return [];
+  return records.map((record) => {
+    const recordId = typeof record.recordId === "string" && record.recordId.trim().length > 0 ? record.recordId : buildExtractionRecordId(documentId, recordKind, record, labelParts(record));
+    return { ...record, recordId };
+  }).sort((left, right) => String(left.recordId).localeCompare(String(right.recordId)));
+}
+
 // src/extraction/assembler.ts
 function assembleDocument(documentId, documentType, memory) {
   const carrier = getCarrierInfo(memory);
@@ -2313,11 +3163,53 @@ function assembleDocument(documentId, documentType, memory) {
   const classify = readMemoryRecord(memory, "classify");
   const lossPayees = readRecordArray(insured, "lossPayees");
   const mortgageHolders = readRecordArray(insured, "mortgageHolders");
+  const coverageRecords = alignExtractionRecords(
+    documentId,
+    "coverage",
+    getCoverageLimitCoverages(memory),
+    (coverage) => [coverage.name, coverage.formNumber, coverage.pageNumber, coverage.limit, coverage.deductible]
+  );
+  const endorsementRecords = alignExtractionRecords(
+    documentId,
+    "endorsement",
+    readRecordValue(endorsements, "endorsements"),
+    (endorsement) => [endorsement.formNumber, endorsement.title, endorsement.pageStart]
+  );
+  const exclusionRecords = alignExtractionRecords(
+    documentId,
+    "exclusion",
+    readRecordValue(exclusions, "exclusions"),
+    (exclusion) => [exclusion.name, exclusion.formNumber, exclusion.pageNumber]
+  );
+  const conditionRecords = alignExtractionRecords(
+    documentId,
+    "condition",
+    readRecordValue(conditions, "conditions"),
+    (condition) => [condition.name, condition.conditionType, condition.pageNumber]
+  );
+  const sectionRecords = alignExtractionRecords(
+    documentId,
+    "section",
+    getSections(memory),
+    (section) => [section.title, section.type, section.pageStart, section.pageEnd]
+  );
+  const definitionRecords = alignExtractionRecords(
+    documentId,
+    "definition",
+    getDefinitions(memory),
+    (definition) => [definition.term, definition.formNumber, definition.pageNumber]
+  );
+  const coveredReasonRecords = alignExtractionRecords(
+    documentId,
+    "covered_reason",
+    getCoveredReasons(memory),
+    (reason2) => [reason2.coverageName, reason2.reasonNumber, reason2.title, reason2.pageNumber]
+  );
   const base = {
     id: documentId,
     carrier: readRecordValue(carrier, "carrierName") ?? "Unknown",
     insuredName: readRecordValue(insured, "insuredName") ?? "Unknown",
-    coverages: getCoverageLimitCoverages(memory),
+    coverages: coverageRecords,
     policyTypes: readRecordValue(classify, "policyTypes"),
     ...sanitizeNulls(carrier ?? {}),
     ...sanitizeNulls(insured ?? {}),
@@ -2333,13 +3225,13 @@ function assembleDocument(documentId, documentType, memory) {
     ...sanitizeNulls(premium ?? {}),
     ...sanitizeNulls(supplementary ?? {}),
     supplementaryFacts: readRecordValue(supplementary, "auxiliaryFacts"),
-    endorsements: readRecordValue(endorsements, "endorsements"),
-    exclusions: readRecordValue(exclusions, "exclusions"),
-    conditions: readRecordValue(conditions, "conditions"),
-    sections: getSections(memory),
+    endorsements: endorsementRecords.length > 0 ? endorsementRecords : void 0,
+    exclusions: exclusionRecords.length > 0 ? exclusionRecords : void 0,
+    conditions: conditionRecords.length > 0 ? conditionRecords : void 0,
+    sections: sectionRecords.length > 0 ? sectionRecords : void 0,
     formInventory: readRecordValue(formInventory, "forms"),
-    definitions: getDefinitions(memory),
-    coveredReasons: getCoveredReasons(memory),
+    definitions: definitionRecords.length > 0 ? definitionRecords : void 0,
+    coveredReasons: coveredReasonRecords.length > 0 ? coveredReasonRecords : void 0,
     declarations: declarations ? sanitizeNulls(declarations) : void 0,
     ...sanitizeNulls(lossHistory ?? {})
   };
@@ -2601,7 +3493,7 @@ async function formatDocumentContent(doc, generateText, options) {
       const result = await withRetry(
         () => generateText({
           prompt,
-          maxTokens: 16384,
+          maxTokens: options?.maxTokens ?? 16384,
           providerOptions: options?.providerOptions
         })
       );
@@ -3596,12 +4488,12 @@ function dedupeByKey(items, keyFn) {
   }
   return merged;
 }
-function normalizeKeyPart(value) {
+function normalizeKeyPart2(value) {
   if (value === void 0 || value === null) return "";
   return String(value).toLowerCase().replace(/&/g, "and").replace(/[^a-z0-9]+/g, "");
 }
 function keyFromParts(...parts) {
-  return parts.map(normalizeKeyPart).join("|");
+  return parts.map(normalizeKeyPart2).join("|");
 }
 function mergeUniqueObjects(existing, incoming, keyFn) {
   return dedupeByKey([...existing, ...incoming], keyFn);
@@ -4492,11 +5384,11 @@ function getTemplate(policyType) {
 }
 
 // src/prompts/coordinator/classify.ts
-import { z as z18 } from "zod";
-var ClassifyResultSchema = z18.object({
-  documentType: z18.enum(["policy", "quote"]).describe("Whether this is a bound policy or a proposed quote"),
-  policyTypes: z18.array(PolicyTypeSchema).min(1).describe("Lines of business covered \u2014 at least one required"),
-  confidence: z18.number().describe("Confidence score from 0.0 to 1.0")
+import { z as z21 } from "zod";
+var ClassifyResultSchema = z21.object({
+  documentType: z21.enum(["policy", "quote"]).describe("Whether this is a bound policy or a proposed quote"),
+  policyTypes: z21.array(PolicyTypeSchema).min(1).describe("Lines of business covered \u2014 at least one required"),
+  confidence: z21.number().describe("Confidence score from 0.0 to 1.0")
 });
 function buildClassifyPrompt() {
   return `You are classifying an insurance document. Examine the document and determine:
@@ -4586,14 +5478,14 @@ Return JSON only:
 }
 
 // src/prompts/coordinator/form-inventory.ts
-import { z as z19 } from "zod";
+import { z as z22 } from "zod";
 var FormInventoryEntrySchema = FormReferenceSchema.extend({
   formNumber: FormReferenceSchema.shape.formNumber.describe("Form number or identifier, e.g. PR5070CF"),
   pageStart: FormReferenceSchema.shape.pageStart.describe("Original document page where the form begins"),
   pageEnd: FormReferenceSchema.shape.pageEnd.describe("Original document page where the form ends")
 });
-var FormInventorySchema = z19.object({
-  forms: z19.array(FormInventoryEntrySchema)
+var FormInventorySchema = z22.object({
+  forms: z22.array(FormInventoryEntrySchema)
 });
 function buildFormInventoryPrompt(templateHints) {
   return `You are building a form inventory for an insurance document.
@@ -4622,8 +5514,8 @@ Respond with JSON only.`;
 }
 
 // src/prompts/coordinator/page-map.ts
-import { z as z20 } from "zod";
-var PageExtractorSchema = z20.enum([
+import { z as z23 } from "zod";
+var PageExtractorSchema = z23.enum([
   "carrier_info",
   "named_insured",
   "coverage_limits",
@@ -4638,10 +5530,10 @@ var PageExtractorSchema = z20.enum([
   "sections",
   "supplementary"
 ]);
-var PageAssignmentSchema = z20.object({
-  localPageNumber: z20.number().int().positive().describe("1-based page number within this supplied PDF chunk"),
-  extractorNames: z20.array(PageExtractorSchema).describe("Focused extractors that should inspect this page"),
-  pageRole: z20.enum([
+var PageAssignmentSchema = z23.object({
+  localPageNumber: z23.number().int().positive().describe("1-based page number within this supplied PDF chunk"),
+  extractorNames: z23.array(PageExtractorSchema).describe("Focused extractors that should inspect this page"),
+  pageRole: z23.enum([
     "declarations_schedule",
     "endorsement_schedule",
     "policy_form",
@@ -4650,12 +5542,12 @@ var PageAssignmentSchema = z20.object({
     "supplementary",
     "other"
   ]).optional().describe("Primary role of the page"),
-  hasScheduleValues: z20.boolean().optional().describe("True only when the page contains insured-specific declaration or schedule values, tables, or rows to extract"),
-  confidence: z20.number().min(0).max(1).optional().describe("Confidence in the page assignment"),
-  notes: z20.string().optional().describe("Short explanation of what appears on the page")
+  hasScheduleValues: z23.boolean().optional().describe("True only when the page contains insured-specific declaration or schedule values, tables, or rows to extract"),
+  confidence: z23.number().min(0).max(1).optional().describe("Confidence in the page assignment"),
+  notes: z23.string().optional().describe("Short explanation of what appears on the page")
 });
-var PageMapChunkSchema = z20.object({
-  pages: z20.array(PageAssignmentSchema)
+var PageMapChunkSchema = z23.object({
+  pages: z23.array(PageAssignmentSchema)
 });
 function buildPageMapPrompt(templateHints, startPage, endPage, formInventoryHint) {
   const inventoryBlock = formInventoryHint ? `
@@ -4731,16 +5623,16 @@ function formatFormInventoryForPageMap(forms) {
 }
 
 // src/prompts/coordinator/review.ts
-import { z as z21 } from "zod";
-var ReviewResultSchema = z21.object({
-  complete: z21.boolean(),
-  missingFields: z21.array(z21.string()),
-  qualityIssues: z21.array(z21.string()).optional(),
-  additionalTasks: z21.array(z21.object({
-    extractorName: z21.string(),
-    startPage: z21.number(),
-    endPage: z21.number(),
-    description: z21.string()
+import { z as z24 } from "zod";
+var ReviewResultSchema = z24.object({
+  complete: z24.boolean(),
+  missingFields: z24.array(z24.string()),
+  qualityIssues: z24.array(z24.string()).optional(),
+  additionalTasks: z24.array(z24.object({
+    extractorName: z24.string(),
+    startPage: z24.number(),
+    endPage: z24.number(),
+    description: z24.string()
   }))
 });
 function buildReviewPrompt(templateExpected, extractedKeys, extractionSummary, pageMapSummary, extractorCatalog) {
@@ -4796,9 +5688,9 @@ Respond with JSON only.`;
 }
 
 // src/prompts/coordinator/summarize.ts
-import { z as z22 } from "zod";
-var SummaryResultSchema = z22.object({
-  summary: z22.string().describe("A 1-3 sentence overview of this insurance document")
+import { z as z25 } from "zod";
+var SummaryResultSchema = z25.object({
+  summary: z25.string().describe("A 1-3 sentence overview of this insurance document")
 });
 function buildSummaryPrompt(doc) {
   const snapshot = {
@@ -4841,23 +5733,23 @@ Return JSON only with a "summary" field.`;
 }
 
 // src/prompts/extractors/carrier-info.ts
-import { z as z23 } from "zod";
-var CarrierInfoSchema = z23.object({
-  carrierName: z23.string().describe("Primary insurance company name for display"),
-  carrierLegalName: z23.string().optional().describe("Legal entity name of insurer"),
-  naicNumber: z23.string().optional().describe("NAIC company code"),
-  amBestRating: z23.string().optional().describe("AM Best rating, e.g. 'A+ XV'"),
-  admittedStatus: z23.enum(["admitted", "non_admitted", "surplus_lines"]).optional().describe("Admitted status of the carrier"),
-  mga: z23.string().optional().describe("Managing General Agent or Program Administrator name"),
-  underwriter: z23.string().optional().describe("Named individual underwriter"),
-  brokerAgency: z23.string().optional().describe("Broker or producer agency name"),
-  brokerContactName: z23.string().optional().describe("Broker or producer contact person name"),
-  brokerLicenseNumber: z23.string().optional().describe("Broker or producer license number"),
-  policyNumber: z23.string().optional().describe("Policy or quote reference number"),
-  effectiveDate: z23.string().optional().describe("Policy effective date (MM/DD/YYYY)"),
-  expirationDate: z23.string().optional().describe("Policy expiration date (MM/DD/YYYY)"),
-  quoteNumber: z23.string().optional().describe("Quote or proposal reference number"),
-  proposedEffectiveDate: z23.string().optional().describe("Proposed effective date for quotes (MM/DD/YYYY)")
+import { z as z26 } from "zod";
+var CarrierInfoSchema = z26.object({
+  carrierName: z26.string().describe("Primary insurance company name for display"),
+  carrierLegalName: z26.string().optional().describe("Legal entity name of insurer"),
+  naicNumber: z26.string().optional().describe("NAIC company code"),
+  amBestRating: z26.string().optional().describe("AM Best rating, e.g. 'A+ XV'"),
+  admittedStatus: z26.enum(["admitted", "non_admitted", "surplus_lines"]).optional().describe("Admitted status of the carrier"),
+  mga: z26.string().optional().describe("Managing General Agent or Program Administrator name"),
+  underwriter: z26.string().optional().describe("Named individual underwriter"),
+  brokerAgency: z26.string().optional().describe("Broker or producer agency name"),
+  brokerContactName: z26.string().optional().describe("Broker or producer contact person name"),
+  brokerLicenseNumber: z26.string().optional().describe("Broker or producer license number"),
+  policyNumber: z26.string().optional().describe("Policy or quote reference number"),
+  effectiveDate: z26.string().optional().describe("Policy effective date (MM/DD/YYYY)"),
+  expirationDate: z26.string().optional().describe("Policy expiration date (MM/DD/YYYY)"),
+  quoteNumber: z26.string().optional().describe("Quote or proposal reference number"),
+  proposedEffectiveDate: z26.string().optional().describe("Proposed effective date for quotes (MM/DD/YYYY)")
 });
 function buildCarrierInfoPrompt() {
   return `You are an expert insurance document analyst. Extract carrier and policy identification information from this document.
@@ -4880,18 +5772,18 @@ Return JSON only.`;
 }
 
 // src/prompts/extractors/named-insured.ts
-import { z as z24 } from "zod";
-var AddressSchema2 = z24.object({
-  street1: z24.string(),
-  city: z24.string(),
-  state: z24.string(),
-  zip: z24.string()
-});
-var NamedInsuredSchema2 = z24.object({
-  insuredName: z24.string().describe("Name of primary named insured"),
-  insuredDba: z24.string().optional().describe("Doing-business-as name"),
+import { z as z27 } from "zod";
+var AddressSchema2 = z27.object({
+  street1: z27.string(),
+  city: z27.string(),
+  state: z27.string(),
+  zip: z27.string()
+});
+var NamedInsuredSchema2 = z27.object({
+  insuredName: z27.string().describe("Name of primary named insured"),
+  insuredDba: z27.string().optional().describe("Doing-business-as name"),
   insuredAddress: AddressSchema2.optional().describe("Primary insured mailing address"),
-  insuredEntityType: z24.enum([
+  insuredEntityType: z27.enum([
     "corporation",
     "llc",
     "partnership",
@@ -4904,25 +5796,25 @@ var NamedInsuredSchema2 = z24.object({
     "married_couple",
     "other"
   ]).optional().describe("Legal entity type of the insured"),
-  insuredFein: z24.string().optional().describe("Federal Employer Identification Number"),
-  insuredSicCode: z24.string().optional().describe("SIC code"),
-  insuredNaicsCode: z24.string().optional().describe("NAICS code"),
-  additionalNamedInsureds: z24.array(
-    z24.object({
-      name: z24.string(),
-      relationship: z24.string().optional().describe("e.g. subsidiary, affiliate"),
+  insuredFein: z27.string().optional().describe("Federal Employer Identification Number"),
+  insuredSicCode: z27.string().optional().describe("SIC code"),
+  insuredNaicsCode: z27.string().optional().describe("NAICS code"),
+  additionalNamedInsureds: z27.array(
+    z27.object({
+      name: z27.string(),
+      relationship: z27.string().optional().describe("e.g. subsidiary, affiliate"),
       address: AddressSchema2.optional()
     })
   ).optional().describe("Additional named insureds listed on the policy"),
-  lossPayees: z24.array(
-    z24.object({
-      name: z24.string(),
+  lossPayees: z27.array(
+    z27.object({
+      name: z27.string(),
       address: AddressSchema2.optional()
     })
   ).optional().describe("Loss payees listed on the policy"),
-  mortgageHolders: z24.array(
-    z24.object({
-      name: z24.string(),
+  mortgageHolders: z27.array(
+    z27.object({
+      name: z27.string(),
       address: AddressSchema2.optional()
     })
   ).optional().describe("Mortgage holders / lienholders listed on the policy")
@@ -4945,14 +5837,14 @@ Return JSON only.`;
 }
 
 // src/prompts/extractors/coverage-limits.ts
-import { z as z25 } from "zod";
+import { z as z28 } from "zod";
 var ExtractorCoverageSchema = CoverageSchema.extend({
-  coverageCode: z25.string().optional().describe("Coverage code or class code")
+  coverageCode: z28.string().optional().describe("Coverage code or class code")
 });
-var CoverageLimitsSchema = z25.object({
-  coverages: z25.array(ExtractorCoverageSchema).describe("All coverages with their limits"),
-  coverageForm: z25.enum(["occurrence", "claims_made", "accident"]).optional().describe("Primary coverage trigger type"),
-  retroactiveDate: z25.string().optional().describe("Retroactive date for claims-made policies (MM/DD/YYYY)")
+var CoverageLimitsSchema = z28.object({
+  coverages: z28.array(ExtractorCoverageSchema).describe("All coverages with their limits"),
+  coverageForm: z28.enum(["occurrence", "claims_made", "accident"]).optional().describe("Primary coverage trigger type"),
+  retroactiveDate: z28.string().optional().describe("Retroactive date for claims-made policies (MM/DD/YYYY)")
 });
 function buildCoverageLimitsPrompt() {
   return `You are an expert insurance document analyst. Extract all coverage limits and deductibles from this document.
@@ -4991,14 +5883,14 @@ Return JSON only.`;
 }
 
 // src/prompts/extractors/endorsements.ts
-import { z as z26 } from "zod";
-var EndorsementsSchema = z26.object({
-  endorsements: z26.array(
-    z26.object({
-      formNumber: z26.string().describe("Form number, e.g. 'CG 21 47'"),
-      editionDate: z26.string().optional().describe("Edition date, e.g. '12 07'"),
-      title: z26.string().describe("Endorsement title"),
-      endorsementType: z26.enum([
+import { z as z29 } from "zod";
+var EndorsementsSchema = z29.object({
+  endorsements: z29.array(
+    z29.object({
+      formNumber: z29.string().describe("Form number, e.g. 'CG 21 47'"),
+      editionDate: z29.string().optional().describe("Edition date, e.g. '12 07'"),
+      title: z29.string().describe("Endorsement title"),
+      endorsementType: z29.enum([
         "additional_insured",
         "waiver_of_subrogation",
         "primary_noncontributory",
@@ -5018,12 +5910,12 @@ var EndorsementsSchema = z26.object({
         "territorial_extension",
         "other"
       ]).describe("Endorsement type classification"),
-      effectiveDate: z26.string().optional().describe("Endorsement effective date"),
-      affectedCoverageParts: z26.array(z26.string()).optional().describe("Coverage parts affected by this endorsement"),
-      namedParties: z26.array(
-        z26.object({
-          name: z26.string().describe("Party name"),
-          role: z26.enum([
+      effectiveDate: z29.string().optional().describe("Endorsement effective date"),
+      affectedCoverageParts: z29.array(z29.string()).optional().describe("Coverage parts affected by this endorsement"),
+      namedParties: z29.array(
+        z29.object({
+          name: z29.string().describe("Party name"),
+          role: z29.enum([
             "additional_insured",
             "loss_payee",
             "mortgage_holder",
@@ -5032,15 +5924,15 @@ var EndorsementsSchema = z26.object({
             "designated_person",
             "other"
           ]).describe("Party role"),
-          relationship: z26.string().optional().describe("Relationship to insured"),
-          scope: z26.string().optional().describe("Scope of coverage for this party")
+          relationship: z29.string().optional().describe("Relationship to insured"),
+          scope: z29.string().optional().describe("Scope of coverage for this party")
         })
       ).optional().describe("Named parties (additional insureds, loss payees, etc.)"),
-      keyTerms: z26.array(z26.string()).optional().describe("Key terms or notable provisions in the endorsement"),
-      premiumImpact: z26.string().optional().describe("Additional premium or credit"),
-      content: z26.string().describe("Full verbatim text of the endorsement"),
-      pageStart: z26.number().describe("Starting page number of this endorsement"),
-      pageEnd: z26.number().optional().describe("Ending page number of this endorsement")
+      keyTerms: z29.array(z29.string()).optional().describe("Key terms or notable provisions in the endorsement"),
+      premiumImpact: z29.string().optional().describe("Additional premium or credit"),
+      content: z29.string().describe("Full verbatim text of the endorsement"),
+      pageStart: z29.number().describe("Starting page number of this endorsement"),
+      pageEnd: z29.number().optional().describe("Ending page number of this endorsement")
     })
   ).describe("All endorsements found in the document")
 });
@@ -5071,20 +5963,20 @@ Return JSON only.`;
 }
 
 // src/prompts/extractors/exclusions.ts
-import { z as z27 } from "zod";
-var ExclusionsSchema = z27.object({
-  exclusions: z27.array(
-    z27.object({
-      name: z27.string().describe("Exclusion title or short description"),
-      formNumber: z27.string().optional().describe("Form number if part of a named endorsement"),
-      excludedPerils: z27.array(z27.string()).optional().describe("Specific perils excluded"),
-      isAbsolute: z27.boolean().optional().describe("Whether the exclusion is absolute (no exceptions)"),
-      exceptions: z27.array(z27.string()).optional().describe("Exceptions to the exclusion, if any"),
-      buybackAvailable: z27.boolean().optional().describe("Whether coverage can be bought back via endorsement"),
-      buybackEndorsement: z27.string().optional().describe("Form number of the buyback endorsement if available"),
-      appliesTo: z27.array(z27.string()).optional().describe("Coverage types this exclusion applies to"),
-      content: z27.string().describe("Full verbatim exclusion text"),
-      pageNumber: z27.number().optional().describe("Page number where exclusion appears")
+import { z as z30 } from "zod";
+var ExclusionsSchema = z30.object({
+  exclusions: z30.array(
+    z30.object({
+      name: z30.string().describe("Exclusion title or short description"),
+      formNumber: z30.string().optional().describe("Form number if part of a named endorsement"),
+      excludedPerils: z30.array(z30.string()).optional().describe("Specific perils excluded"),
+      isAbsolute: z30.boolean().optional().describe("Whether the exclusion is absolute (no exceptions)"),
+      exceptions: z30.array(z30.string()).optional().describe("Exceptions to the exclusion, if any"),
+      buybackAvailable: z30.boolean().optional().describe("Whether coverage can be bought back via endorsement"),
+      buybackEndorsement: z30.string().optional().describe("Form number of the buyback endorsement if available"),
+      appliesTo: z30.array(z30.string()).optional().describe("Coverage types this exclusion applies to"),
+      content: z30.string().describe("Full verbatim exclusion text"),
+      pageNumber: z30.number().optional().describe("Page number where exclusion appears")
     })
   ).describe("All exclusions found in the document")
 });
@@ -5120,12 +6012,12 @@ Return JSON only.`;
 }
 
 // src/prompts/extractors/conditions.ts
-import { z as z28 } from "zod";
-var ConditionsSchema = z28.object({
-  conditions: z28.array(
-    z28.object({
-      name: z28.string().describe("Condition title"),
-      conditionType: z28.enum([
+import { z as z31 } from "zod";
+var ConditionsSchema = z31.object({
+  conditions: z31.array(
+    z31.object({
+      name: z31.string().describe("Condition title"),
+      conditionType: z31.enum([
         "duties_after_loss",
         "notice_requirements",
         "other_insurance",
@@ -5144,14 +6036,14 @@ var ConditionsSchema = z28.object({
         "separation_of_insureds",
         "other"
       ]).describe("Condition category"),
-      content: z28.string().describe("Full verbatim condition text"),
-      keyValues: z28.array(
-        z28.object({
-          key: z28.string().describe("Key name (e.g. 'noticePeriod', 'suitDeadline')"),
-          value: z28.string().describe("Value (e.g. '30 days', '2 years')")
+      content: z31.string().describe("Full verbatim condition text"),
+      keyValues: z31.array(
+        z31.object({
+          key: z31.string().describe("Key name (e.g. 'noticePeriod', 'suitDeadline')"),
+          value: z31.string().describe("Value (e.g. '30 days', '2 years')")
         })
       ).optional().describe("Key values extracted from the condition (notice periods, deadlines, etc.)"),
-      pageNumber: z28.number().optional().describe("Page number where condition appears")
+      pageNumber: z31.number().optional().describe("Page number where condition appears")
     })
   ).describe("All policy conditions found in the document")
 });
@@ -5189,28 +6081,28 @@ Return JSON only.`;
 }
 
 // src/prompts/extractors/premium-breakdown.ts
-import { z as z29 } from "zod";
-var PremiumBreakdownSchema = z29.object({
-  premium: z29.string().optional().describe("Total premium amount, e.g. '$5,000'"),
-  totalCost: z29.string().optional().describe("Total cost including taxes and fees, e.g. '$5,250'"),
-  premiumBreakdown: z29.array(
-    z29.object({
-      line: z29.string().describe("Coverage line name"),
-      amount: z29.string().describe("Premium amount for this line")
+import { z as z32 } from "zod";
+var PremiumBreakdownSchema = z32.object({
+  premium: z32.string().optional().describe("Total premium amount, e.g. '$5,000'"),
+  totalCost: z32.string().optional().describe("Total cost including taxes and fees, e.g. '$5,250'"),
+  premiumBreakdown: z32.array(
+    z32.object({
+      line: z32.string().describe("Coverage line name"),
+      amount: z32.string().describe("Premium amount for this line")
     })
   ).optional().describe("Per-coverage-line premium breakdown"),
-  taxesAndFees: z29.array(
-    z29.object({
-      name: z29.string().describe("Fee or tax name"),
-      amount: z29.string().describe("Dollar amount"),
-      type: z29.enum(["tax", "fee", "surcharge", "assessment"]).optional().describe("Fee category")
+  taxesAndFees: z32.array(
+    z32.object({
+      name: z32.string().describe("Fee or tax name"),
+      amount: z32.string().describe("Dollar amount"),
+      type: z32.enum(["tax", "fee", "surcharge", "assessment"]).optional().describe("Fee category")
     })
   ).optional().describe("Taxes, fees, surcharges, and assessments"),
-  minimumPremium: z29.string().optional().describe("Minimum premium if stated"),
-  depositPremium: z29.string().optional().describe("Deposit premium if stated"),
-  paymentPlan: z29.string().optional().describe("Payment plan description"),
-  auditType: z29.enum(["annual", "semi_annual", "quarterly", "monthly", "final", "self"]).optional().describe("Premium audit type"),
-  ratingBasis: z29.string().optional().describe("Rating basis, e.g. payroll, revenue, area, units")
+  minimumPremium: z32.string().optional().describe("Minimum premium if stated"),
+  depositPremium: z32.string().optional().describe("Deposit premium if stated"),
+  paymentPlan: z32.string().optional().describe("Payment plan description"),
+  auditType: z32.enum(["annual", "semi_annual", "quarterly", "monthly", "final", "self"]).optional().describe("Premium audit type"),
+  ratingBasis: z32.string().optional().describe("Rating basis, e.g. payroll, revenue, area, units")
 });
 function buildPremiumBreakdownPrompt() {
   return `You are an expert insurance document analyst. Extract all premium and cost information from this document.
@@ -5230,14 +6122,14 @@ Return JSON only.`;
 }
 
 // src/prompts/extractors/declarations.ts
-import { z as z30 } from "zod";
-var DeclarationsFieldSchema = z30.object({
-  field: z30.string().describe("Descriptive field name (e.g. 'policyNumber', 'effectiveDate', 'coverageALimit')"),
-  value: z30.string().describe("Extracted value exactly as it appears in the document"),
-  section: z30.string().optional().describe("Section or grouping this field belongs to (e.g. 'Coverage Limits', 'Vehicle Schedule')")
+import { z as z33 } from "zod";
+var DeclarationsFieldSchema = z33.object({
+  field: z33.string().describe("Descriptive field name (e.g. 'policyNumber', 'effectiveDate', 'coverageALimit')"),
+  value: z33.string().describe("Extracted value exactly as it appears in the document"),
+  section: z33.string().optional().describe("Section or grouping this field belongs to (e.g. 'Coverage Limits', 'Vehicle Schedule')")
 });
-var DeclarationsExtractSchema = z30.object({
-  fields: z30.array(DeclarationsFieldSchema).describe("All declarations page fields extracted as key-value pairs. Structure varies by line of business.")
+var DeclarationsExtractSchema = z33.object({
+  fields: z33.array(DeclarationsFieldSchema).describe("All declarations page fields extracted as key-value pairs. Structure varies by line of business.")
 });
 function buildDeclarationsPrompt() {
   return `You are an expert insurance document analyst. Extract all declarations page data from this document into a flexible key-value structure.
@@ -5277,21 +6169,21 @@ Preserve original values exactly as they appear. Return JSON only.`;
 }
 
 // src/prompts/extractors/loss-history.ts
-import { z as z31 } from "zod";
-var LossHistorySchema = z31.object({
-  lossSummary: z31.string().optional().describe("Summary of loss history, e.g. '3 claims in past 5 years totaling $125,000'"),
-  individualClaims: z31.array(
-    z31.object({
-      date: z31.string().optional().describe("Date of loss or claim"),
-      type: z31.string().optional().describe("Type of claim, e.g. 'property damage', 'bodily injury'"),
-      description: z31.string().optional().describe("Brief description of the claim"),
-      amountPaid: z31.string().optional().describe("Amount paid"),
-      amountReserved: z31.string().optional().describe("Amount reserved"),
-      status: z31.enum(["open", "closed", "reopened"]).optional().describe("Claim status"),
-      claimNumber: z31.string().optional().describe("Claim reference number")
+import { z as z34 } from "zod";
+var LossHistorySchema = z34.object({
+  lossSummary: z34.string().optional().describe("Summary of loss history, e.g. '3 claims in past 5 years totaling $125,000'"),
+  individualClaims: z34.array(
+    z34.object({
+      date: z34.string().optional().describe("Date of loss or claim"),
+      type: z34.string().optional().describe("Type of claim, e.g. 'property damage', 'bodily injury'"),
+      description: z34.string().optional().describe("Brief description of the claim"),
+      amountPaid: z34.string().optional().describe("Amount paid"),
+      amountReserved: z34.string().optional().describe("Amount reserved"),
+      status: z34.enum(["open", "closed", "reopened"]).optional().describe("Claim status"),
+      claimNumber: z34.string().optional().describe("Claim reference number")
     })
   ).optional().describe("Individual claim records"),
-  experienceMod: z31.string().optional().describe("Experience modification factor for workers comp, e.g. '0.85'")
+  experienceMod: z34.string().optional().describe("Experience modification factor for workers comp, e.g. '0.85'")
 });
 function buildLossHistoryPrompt() {
   return `You are an expert insurance document analyst. Extract all loss history and claims information from this document.
@@ -5308,18 +6200,18 @@ Return JSON only.`;
 }
 
 // src/prompts/extractors/sections.ts
-import { z as z32 } from "zod";
-var SubsectionSchema2 = z32.object({
-  title: z32.string().describe("Subsection title"),
-  sectionNumber: z32.string().optional().describe("Subsection number"),
-  pageNumber: z32.number().optional().describe("Page number"),
-  content: z32.string().describe("Full verbatim text")
-});
-var SectionsSchema = z32.object({
-  sections: z32.array(
-    z32.object({
-      title: z32.string().describe("Section title"),
-      type: z32.enum([
+import { z as z35 } from "zod";
+var SubsectionSchema2 = z35.object({
+  title: z35.string().describe("Subsection title"),
+  sectionNumber: z35.string().optional().describe("Subsection number"),
+  pageNumber: z35.number().optional().describe("Page number"),
+  content: z35.string().describe("Full verbatim text")
+});
+var SectionsSchema = z35.object({
+  sections: z35.array(
+    z35.object({
+      title: z35.string().describe("Section title"),
+      type: z35.enum([
         "declarations",
         "insuring_agreement",
         "policy_form",
@@ -5334,10 +6226,10 @@ var SectionsSchema = z32.object({
         "regulatory",
         "other"
       ]).describe("Section type classification"),
-      content: z32.string().describe("Full verbatim text of the section"),
-      pageStart: z32.number().describe("Starting page number"),
-      pageEnd: z32.number().optional().describe("Ending page number"),
-      subsections: z32.array(SubsectionSchema2).optional().describe("Subsections within this section")
+      content: z35.string().describe("Full verbatim text of the section"),
+      pageStart: z35.number().describe("Starting page number"),
+      pageEnd: z35.number().optional().describe("Ending page number"),
+      subsections: z35.array(SubsectionSchema2).optional().describe("Subsections within this section")
     })
   ).describe("All document sections")
 });
@@ -5368,27 +6260,27 @@ Return JSON only.`;
 }
 
 // src/prompts/extractors/supplementary.ts
-import { z as z33 } from "zod";
-var ContactSchema2 = z33.object({
-  name: z33.string().optional().describe("Organization or person name"),
-  phone: z33.string().optional().describe("Phone number"),
-  email: z33.string().optional().describe("Email address"),
-  address: z33.string().optional().describe("Mailing address"),
-  type: z33.string().optional().describe("Contact type, e.g. 'State Department of Insurance'")
-});
-var AuxiliaryFactSchema2 = z33.object({
-  key: z33.string().describe("Normalized machine-readable fact key, e.g. 'policyholder_age' or 'insured_name'"),
-  value: z33.string().describe("Concrete extracted fact value"),
-  subject: z33.string().optional().describe("Person, entity, vehicle, property, or schedule item this fact belongs to"),
-  context: z33.string().optional().describe("Short disambiguating context, such as 'Driver Schedule' or 'Named Insured'")
-});
-var SupplementarySchema = z33.object({
-  regulatoryContacts: z33.array(ContactSchema2).optional().describe("Regulatory body contacts (state department of insurance, ombudsman)"),
-  claimsContacts: z33.array(ContactSchema2).optional().describe("Claims reporting contacts and instructions"),
-  thirdPartyAdministrators: z33.array(ContactSchema2).optional().describe("Third-party administrators for claims handling"),
-  cancellationNoticeDays: z33.number().optional().describe("Required notice period for cancellation in days"),
-  nonrenewalNoticeDays: z33.number().optional().describe("Required notice period for nonrenewal in days"),
-  auxiliaryFacts: z33.array(AuxiliaryFactSchema2).optional().describe("Additional retrieval-only facts that do not fit the strict primary schema")
+import { z as z36 } from "zod";
+var ContactSchema2 = z36.object({
+  name: z36.string().optional().describe("Organization or person name"),
+  phone: z36.string().optional().describe("Phone number"),
+  email: z36.string().optional().describe("Email address"),
+  address: z36.string().optional().describe("Mailing address"),
+  type: z36.string().optional().describe("Contact type, e.g. 'State Department of Insurance'")
+});
+var AuxiliaryFactSchema2 = z36.object({
+  key: z36.string().describe("Normalized machine-readable fact key, e.g. 'policyholder_age' or 'insured_name'"),
+  value: z36.string().describe("Concrete extracted fact value"),
+  subject: z36.string().optional().describe("Person, entity, vehicle, property, or schedule item this fact belongs to"),
+  context: z36.string().optional().describe("Short disambiguating context, such as 'Driver Schedule' or 'Named Insured'")
+});
+var SupplementarySchema = z36.object({
+  regulatoryContacts: z36.array(ContactSchema2).optional().describe("Regulatory body contacts (state department of insurance, ombudsman)"),
+  claimsContacts: z36.array(ContactSchema2).optional().describe("Claims reporting contacts and instructions"),
+  thirdPartyAdministrators: z36.array(ContactSchema2).optional().describe("Third-party administrators for claims handling"),
+  cancellationNoticeDays: z36.number().optional().describe("Required notice period for cancellation in days"),
+  nonrenewalNoticeDays: z36.number().optional().describe("Required notice period for nonrenewal in days"),
+  auxiliaryFacts: z36.array(AuxiliaryFactSchema2).optional().describe("Additional retrieval-only facts that do not fit the strict primary schema")
 });
 function buildSupplementaryPrompt(alreadyExtractedSummary) {
   const exclusionBlock = alreadyExtractedSummary ? `
@@ -5426,17 +6318,17 @@ Return JSON only.`;
 }
 
 // src/prompts/extractors/definitions.ts
-import { z as z34 } from "zod";
-var DefinitionsSchema = z34.object({
-  definitions: z34.array(
-    z34.object({
-      term: z34.string().describe("Defined term exactly as shown in the document"),
-      definition: z34.string().describe("Full verbatim definition text, preserving original wording"),
-      pageNumber: z34.number().optional().describe("Original document page number"),
-      formNumber: z34.string().optional().describe("Form number where this definition appears"),
-      formTitle: z34.string().optional().describe("Form title where this definition appears"),
-      sectionRef: z34.string().optional().describe("Definition section heading or subsection reference"),
-      originalContent: z34.string().optional().describe("Short verbatim source snippet containing the term and definition")
+import { z as z37 } from "zod";
+var DefinitionsSchema = z37.object({
+  definitions: z37.array(
+    z37.object({
+      term: z37.string().describe("Defined term exactly as shown in the document"),
+      definition: z37.string().describe("Full verbatim definition text, preserving original wording"),
+      pageNumber: z37.number().optional().describe("Original document page number"),
+      formNumber: z37.string().optional().describe("Form number where this definition appears"),
+      formTitle: z37.string().optional().describe("Form title where this definition appears"),
+      sectionRef: z37.string().optional().describe("Definition section heading or subsection reference"),
+      originalContent: z37.string().optional().describe("Short verbatim source snippet containing the term and definition")
     })
   ).describe("All substantive insurance definitions found in the document")
 });
@@ -5470,22 +6362,22 @@ Return JSON only.`;
 }
 
 // src/prompts/extractors/covered-reasons.ts
-import { z as z35 } from "zod";
-var CoveredReasonsSchema = z35.object({
-  coveredReasons: z35.array(
-    z35.object({
-      coverageName: z35.string().describe("Coverage, coverage part, or form this covered reason belongs to"),
-      reasonNumber: z35.string().optional().describe("Source number or letter for the covered reason, if shown"),
-      title: z35.string().optional().describe("Covered reason title, peril, cause of loss, trigger, or short name"),
-      content: z35.string().describe("Full verbatim covered-reason or insuring-agreement text"),
-      conditions: z35.array(z35.string()).optional().describe("Conditions, timing rules, documentation requirements, or prerequisites attached to this covered reason"),
-      exceptions: z35.array(z35.string()).optional().describe("Exceptions or limitations attached to this covered reason"),
-      appliesTo: z35.array(z35.string()).optional().describe("Covered property, persons, autos, locations, operations, or coverage parts this reason applies to"),
-      pageNumber: z35.number().optional().describe("Original document page number"),
-      formNumber: z35.string().optional().describe("Form number where this covered reason appears"),
-      formTitle: z35.string().optional().describe("Form title where this covered reason appears"),
-      sectionRef: z35.string().optional().describe("Section heading where this covered reason appears"),
-      originalContent: z35.string().optional().describe("Short verbatim source snippet used for this covered reason")
+import { z as z38 } from "zod";
+var CoveredReasonsSchema = z38.object({
+  coveredReasons: z38.array(
+    z38.object({
+      coverageName: z38.string().describe("Coverage, coverage part, or form this covered reason belongs to"),
+      reasonNumber: z38.string().optional().describe("Source number or letter for the covered reason, if shown"),
+      title: z38.string().optional().describe("Covered reason title, peril, cause of loss, trigger, or short name"),
+      content: z38.string().describe("Full verbatim covered-reason or insuring-agreement text"),
+      conditions: z38.array(z38.string()).optional().describe("Conditions, timing rules, documentation requirements, or prerequisites attached to this covered reason"),
+      exceptions: z38.array(z38.string()).optional().describe("Exceptions or limitations attached to this covered reason"),
+      appliesTo: z38.array(z38.string()).optional().describe("Covered property, persons, autos, locations, operations, or coverage parts this reason applies to"),
+      pageNumber: z38.number().optional().describe("Original document page number"),
+      formNumber: z38.string().optional().describe("Form number where this covered reason appears"),
+      formTitle: z38.string().optional().describe("Form title where this covered reason appears"),
+      sectionRef: z38.string().optional().describe("Section heading where this covered reason appears"),
+      originalContent: z38.string().optional().describe("Short verbatim source snippet used for this covered reason")
     })
   ).describe("Covered causes, perils, triggers, or reasons that affirmatively grant coverage")
 });
@@ -5618,21 +6510,21 @@ function formatExtractorCatalogForPrompt() {
 }
 
 // src/extraction/resolve-referential.ts
-import { z as z37 } from "zod";
+import { z as z40 } from "zod";
 
 // src/prompts/extractors/referential-lookup.ts
-import { z as z36 } from "zod";
-var ReferentialLookupSchema = z36.object({
-  resolvedCoverages: z36.array(
-    z36.object({
-      coverageName: z36.string().describe("The coverage name that was referenced"),
-      resolvedLimit: z36.string().optional().describe("The concrete limit value found, if any"),
+import { z as z39 } from "zod";
+var ReferentialLookupSchema = z39.object({
+  resolvedCoverages: z39.array(
+    z39.object({
+      coverageName: z39.string().describe("The coverage name that was referenced"),
+      resolvedLimit: z39.string().optional().describe("The concrete limit value found, if any"),
       resolvedLimitValueType: CoverageValueTypeSchema.optional(),
-      resolvedDeductible: z36.string().optional().describe("The concrete deductible value found, if any"),
+      resolvedDeductible: z39.string().optional().describe("The concrete deductible value found, if any"),
       resolvedDeductibleValueType: CoverageValueTypeSchema.optional(),
-      pageNumber: z36.number().optional().describe("Page where the resolved value was found"),
-      originalContent: z36.string().optional().describe("Verbatim source text for the resolved value"),
-      confidence: z36.enum(["high", "medium", "low"]).describe("Confidence in the resolution")
+      pageNumber: z39.number().optional().describe("Page where the resolved value was found"),
+      originalContent: z39.string().optional().describe("Verbatim source text for the resolved value"),
+      confidence: z39.enum(["high", "medium", "low"]).describe("Confidence in the resolution")
     })
   )
 });
@@ -5680,11 +6572,11 @@ function looksCoveredReasonSection(section) {
 }
 
 // src/extraction/referential-workflow.ts
-function normalizeText(value) {
+function normalizeText2(value) {
   return typeof value === "string" ? value.trim().toLowerCase() : "";
 }
 function containsTarget(value, target) {
-  const normalizedValue = normalizeText(value);
+  const normalizedValue = normalizeText2(value);
   return Boolean(normalizedValue && target && normalizedValue.includes(target));
 }
 function pageRangeFrom(startPage, endPage) {
@@ -5727,8 +6619,8 @@ function findLocalReferentialPages(params) {
 }
 function findDeclarationsSchedulePages(parsedTarget, formInventory) {
   for (const form of formInventory) {
-    const formType = normalizeText(form.formType);
-    const title = normalizeText(form.title);
+    const formType = normalizeText2(form.formType);
+    const title = normalizeText2(form.title);
     const matchesDeclarations = formType === "declarations" || /declarations?|dec\b|decs\b/.test(title);
     const matchesSchedule = /schedule|scheduled|coverage/.test(title) || formType === "coverage";
     const shouldUse = parsedTarget.kind === "declarations" ? matchesDeclarations : parsedTarget.kind === "schedule" || parsedTarget.kind === "item" || parsedTarget.kind === "premises" ? matchesSchedule || matchesDeclarations : parsedTarget.kind === "policy" ? matchesDeclarations || matchesSchedule : false;
@@ -5741,8 +6633,8 @@ function findDeclarationsSchedulePages(parsedTarget, formInventory) {
 }
 function findSectionPages(parsedTarget, sections) {
   for (const section of sections) {
-    const title = normalizeText(section.title);
-    const type = normalizeText(section.type);
+    const title = normalizeText2(section.title);
+    const type = normalizeText2(section.type);
     const matchesKind = parsedTarget.kind === "declarations" && (type === "declarations" || /declarations?/.test(title)) || parsedTarget.kind === "schedule" && (type === "schedule" || /schedule|scheduled/.test(title)) || parsedTarget.kind === "premises" && /premises?|location|building/.test(title) || parsedTarget.kind === "item" && /\bitem\b|schedule|scheduled/.test(title) || parsedTarget.kind === "section" && containsTarget(title, parsedTarget.normalized);
     if (matchesKind) {
       const range = pageRangeFrom(section.pageStart, section.pageEnd);
@@ -5797,9 +6689,9 @@ function parseReferenceTarget(text) {
   if (/if applicable/i.test(normalized)) return void 0;
   return void 0;
 }
-var PageLocationSchema = z37.object({
-  startPage: z37.number(),
-  endPage: z37.number()
+var PageLocationSchema = z40.object({
+  startPage: z40.number(),
+  endPage: z40.number()
 });
 async function findReferencedPages(params) {
   const {
@@ -5811,6 +6703,8 @@ async function findReferencedPages(params) {
     generateObject,
     providerOptions,
     trackUsage,
+    modelCapabilities,
+    modelBudgetConstraints,
     log
   } = params;
   const localPageRange = findLocalReferentialPages({
@@ -5837,6 +6731,12 @@ async function findReferencedPages(params) {
     return void 0;
   }
   try {
+    const budget = resolveModelBudget({
+      taskKind: "extraction_referential_lookup",
+      hintTokens: 256,
+      modelCapabilities,
+      constraint: modelBudgetConstraints?.extraction_referential_lookup
+    });
     const result = await safeGenerateObject(
       generateObject,
       {
@@ -5850,7 +6750,7 @@ If you cannot find the section, return startPage: 0 and endPage: 0.
 
 Return JSON only.`,
         schema: PageLocationSchema,
-        maxTokens: 256,
+        maxTokens: budget.maxTokens,
         providerOptions: await buildPdfProviderOptions(pdfInput, providerOptions)
       },
       {
@@ -5885,6 +6785,8 @@ async function resolveReferentialCoverages(params) {
     convertPdfToImages,
     concurrency = 2,
     providerOptions,
+    modelCapabilities,
+    modelBudgetConstraints,
     log,
     onProgress
   } = params;
@@ -5947,6 +6849,8 @@ async function resolveReferentialCoverages(params) {
           generateObject,
           providerOptions,
           trackUsage,
+          modelCapabilities,
+          modelBudgetConstraints,
           log
         });
         if (!pageRange) {
@@ -5973,6 +6877,12 @@ async function resolveReferentialCoverages(params) {
           sectionRef: coverage.sectionRef ? String(coverage.sectionRef) : void 0
         }));
         try {
+          const budget = resolveModelBudget({
+            taskKind: "extraction_referential_lookup",
+            hintTokens: 4096,
+            modelCapabilities,
+            constraint: modelBudgetConstraints?.extraction_referential_lookup
+          });
           const result = await runExtractor({
             name: "referential_lookup",
             prompt: buildReferentialLookupPrompt(promptCoverages),
@@ -5982,7 +6892,7 @@ async function resolveReferentialCoverages(params) {
             endPage: pageRange.endPage,
             generateObject,
             convertPdfToImages,
-            maxTokens: 4096,
+            maxTokens: budget.maxTokens,
             providerOptions
           });
           trackUsage(result.usage);
@@ -6072,7 +6982,9 @@ async function runFocusedExtractorWithFallback(params) {
     generateObject,
     convertPdfToImages,
     providerOptions,
+    pageRangeCache,
     trackUsage,
+    resolveBudget,
     log
   } = params;
   const ext = getExtractor(task.extractorName);
@@ -6081,6 +6993,9 @@ async function runFocusedExtractorWithFallback(params) {
     return null;
   }
   try {
+    const hintTokens = ext.maxTokens ?? 4096;
+    const taskKind = hintTokens >= 8192 ? "extraction_long_list" : "extraction_focused";
+    const budget = resolveBudget(taskKind, hintTokens);
     const result = await runExtractor({
       name: task.extractorName,
       prompt: ext.buildPrompt(),
@@ -6090,10 +7005,15 @@ async function runFocusedExtractorWithFallback(params) {
       endPage: task.endPage,
       generateObject,
       convertPdfToImages,
-      maxTokens: ext.maxTokens ?? 4096,
-      providerOptions
+      maxTokens: budget.maxTokens,
+      providerOptions,
+      pageRangeCache
+    });
+    trackUsage(result.usage, {
+      taskKind,
+      label: task.extractorName,
+      maxTokens: budget.maxTokens
     });
-    trackUsage(result.usage);
     if (!ext.fallback?.isEmpty(result.data)) {
       return result;
     }
@@ -6112,6 +7032,9 @@ async function runFocusedExtractorWithFallback(params) {
     `Extractor ${task.extractorName} produced no usable records; trying ${ext.fallback.extractorName} fallback for pages ${task.startPage}-${task.endPage}`
   );
   try {
+    const hintTokens = fallbackExt.maxTokens ?? 4096;
+    const taskKind = hintTokens >= 8192 ? "extraction_long_list" : "extraction_focused";
+    const budget = resolveBudget(taskKind, hintTokens);
     const fallbackResult = await runExtractor({
       name: ext.fallback.extractorName,
       prompt: fallbackExt.buildPrompt(),
@@ -6121,10 +7044,15 @@ async function runFocusedExtractorWithFallback(params) {
       endPage: task.endPage,
       generateObject,
       convertPdfToImages,
-      maxTokens: fallbackExt.maxTokens ?? 4096,
-      providerOptions
+      maxTokens: budget.maxTokens,
+      providerOptions,
+      pageRangeCache
+    });
+    trackUsage(fallbackResult.usage, {
+      taskKind,
+      label: ext.fallback.extractorName,
+      maxTokens: budget.maxTokens
     });
-    trackUsage(fallbackResult.usage);
     const focusedData = ext.fallback.deriveFocusedResult(fallbackResult.data);
     return focusedData ? [
       fallbackResult,
@@ -6201,6 +7129,15 @@ function buildExtractionReviewReport(params) {
   const coveredReasons = Array.isArray(coveredReasonsResult?.coveredReasons) ? coveredReasonsResult.coveredReasons : Array.isArray(coveredReasonsResult?.covered_reasons) ? coveredReasonsResult.covered_reasons : sections.filter(looksCoveredReasonSection);
   const mappedDefinitions = params.pageAssignments.some((assignment) => assignment.extractorNames.includes("definitions"));
   const mappedCoveredReasons = params.pageAssignments.some((assignment) => assignment.extractorNames.includes("covered_reasons"));
+  if (params.sourceSpansAvailable) {
+    addMissingSourceGroundingIssues(deterministicIssues, "coverage_limits", "coverages", coverages, "name");
+    addMissingSourceGroundingIssues(deterministicIssues, "endorsements", "endorsements", endorsements, "title");
+    addMissingSourceGroundingIssues(deterministicIssues, "exclusions", "exclusions", exclusions, "name");
+    addMissingSourceGroundingIssues(deterministicIssues, "conditions", "conditions", conditions, "name");
+    addMissingSourceGroundingIssues(deterministicIssues, "sections", "sections", sections, "title");
+    addMissingSourceGroundingIssues(deterministicIssues, "definitions", "definitions", definitions, "term");
+    addMissingSourceGroundingIssues(deterministicIssues, "covered_reasons", "coveredReasons", coveredReasons, "name");
+  }
   if (mappedDefinitions && definitions.length === 0) {
     deterministicIssues.push({
       code: "definitions_mapped_but_empty",
@@ -6514,6 +7451,24 @@ function buildExtractionReviewReport(params) {
     qualityGateStatus
   };
 }
+function addMissingSourceGroundingIssues(issues, extractorName, arrayName, records, labelKey) {
+  for (const record of records) {
+    if (!recordHasContent(record)) continue;
+    if (Array.isArray(record.sourceSpanIds) && record.sourceSpanIds.length > 0) continue;
+    issues.push({
+      code: "record_missing_source_span",
+      severity: "blocking",
+      message: `${extractorName}.${arrayName} record "${String(record[labelKey] ?? record.name ?? record.title ?? "unknown")}" is missing source span grounding.`,
+      extractorName,
+      pageNumber: typeof record.pageNumber === "number" ? record.pageNumber : typeof record.pageStart === "number" ? record.pageStart : void 0,
+      formNumber: typeof record.formNumber === "string" ? record.formNumber : void 0,
+      itemName: typeof record[labelKey] === "string" ? record[labelKey] : void 0
+    });
+  }
+}
+function recordHasContent(record) {
+  return ["name", "title", "term", "field", "coverageName", "content", "originalContent", "value", "limit", "deductible", "premium"].some((key) => typeof record[key] === "string" && record[key].trim().length > 0);
+}
 function toReviewRoundRecord(round, review) {
   return {
     round,
@@ -6652,6 +7607,104 @@ function buildPlanFromPageAssignments(pageAssignments, pageCount, formInventory)
   };
 }
 
+// src/extraction/source-grounding.ts
+var ARRAY_PATHS = [
+  { memoryKey: "coverage_limits", arrayKeys: ["coverages"] },
+  { memoryKey: "endorsements", arrayKeys: ["endorsements"] },
+  { memoryKey: "exclusions", arrayKeys: ["exclusions"] },
+  { memoryKey: "conditions", arrayKeys: ["conditions"] },
+  { memoryKey: "sections", arrayKeys: ["sections"] },
+  { memoryKey: "definitions", arrayKeys: ["definitions"] },
+  { memoryKey: "covered_reasons", arrayKeys: ["coveredReasons", "covered_reasons"] },
+  { memoryKey: "declarations", arrayKeys: ["fields"] }
+];
+function normalize(value) {
+  return value.replace(/\s+/g, " ").trim().toLowerCase();
+}
+function textValue(record, ...keys) {
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "string" && value.trim()) return value.trim();
+  }
+  return void 0;
+}
+function numberValue(record, ...keys) {
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "number" && Number.isFinite(value)) return value;
+  }
+  return void 0;
+}
+function pageOverlaps(recordStart, recordEnd, span) {
+  if (!recordStart && !recordEnd) return false;
+  const start = recordStart ?? recordEnd;
+  const end = recordEnd ?? recordStart;
+  const spanStart = span.pageStart ?? span.location?.page ?? span.location?.startPage;
+  const spanEnd = span.pageEnd ?? span.location?.page ?? span.location?.endPage ?? spanStart;
+  if (!spanStart) return false;
+  return start <= (spanEnd ?? spanStart) && end >= spanStart;
+}
+function formMatches(record, span) {
+  const formNumber = textValue(record, "formNumber");
+  if (!formNumber || !span.formNumber) return false;
+  return normalize(formNumber) === normalize(span.formNumber);
+}
+function textMatches(record, span) {
+  const spanText = normalize(span.text);
+  const candidates = [
+    textValue(record, "originalContent", "content", "definition", "value"),
+    textValue(record, "name", "title", "term", "field", "coverageName"),
+    textValue(record, "limit", "deductible", "premium")
+  ].filter((value) => !!value && value.length >= 3);
+  return candidates.some((candidate) => spanText.includes(normalize(candidate)));
+}
+function sourceHashFor(spans) {
+  return spans.map((span) => span.textHash ?? span.hash).filter(Boolean).join(":") || void 0;
+}
+function findSourceSpansForRecord(record, sourceSpans) {
+  if (sourceSpans.length === 0) return [];
+  const pageStart = numberValue(record, "pageNumber", "pageStart");
+  const pageEnd = numberValue(record, "pageNumber", "pageEnd");
+  const scored = sourceSpans.map((span) => {
+    let score = 0;
+    if (pageOverlaps(pageStart, pageEnd, span)) score += 4;
+    if (formMatches(record, span)) score += 3;
+    if (textMatches(record, span)) score += 2;
+    return { span, score };
+  }).filter((item) => item.score >= 2).sort((left, right) => {
+    if (right.score !== left.score) return right.score - left.score;
+    return left.span.id.localeCompare(right.span.id);
+  });
+  return scored.slice(0, 3).map((item) => item.span);
+}
+function groundRecord(record, sourceSpans) {
+  if (Array.isArray(record.sourceSpanIds) && record.sourceSpanIds.length > 0 && record.sourceTextHash) {
+    return record;
+  }
+  const matches = findSourceSpansForRecord(record, sourceSpans);
+  if (matches.length === 0) return record;
+  return {
+    ...record,
+    sourceSpanIds: Array.isArray(record.sourceSpanIds) && record.sourceSpanIds.length > 0 ? record.sourceSpanIds : matches.map((span) => span.id),
+    sourceTextHash: typeof record.sourceTextHash === "string" && record.sourceTextHash.trim() ? record.sourceTextHash : sourceHashFor(matches)
+  };
+}
+function groundExtractionMemoryWithSourceSpans(memory, sourceSpans) {
+  if (sourceSpans.length === 0) return;
+  for (const { memoryKey, arrayKeys } of ARRAY_PATHS) {
+    const payload = memory.get(memoryKey);
+    if (!payload || typeof payload !== "object" || Array.isArray(payload)) continue;
+    const record = payload;
+    for (const arrayKey of arrayKeys) {
+      const items = record[arrayKey];
+      if (!Array.isArray(items)) continue;
+      record[arrayKey] = items.map(
+        (item) => item && typeof item === "object" && !Array.isArray(item) ? groundRecord(item, sourceSpans) : item
+      );
+    }
+  }
+}
+
 // src/extraction/coordinator.ts
 function createExtractor(config) {
   const {
@@ -6664,7 +7717,10 @@ function createExtractor(config) {
     onProgress,
     log,
     providerOptions,
+    sourceStore,
     qualityGate = "warn",
+    modelCapabilities,
+    modelBudgetConstraints,
     onCheckpointSave
   } = config;
   const limit = pLimit(concurrency);
@@ -6673,7 +7729,20 @@ function createExtractor(config) {
   let modelCalls = 0;
   let callsWithUsage = 0;
   let callsMissingUsage = 0;
-  function trackUsage(usage) {
+  let performanceReport = {
+    modelCalls: [],
+    totalModelCallDurationMs: 0
+  };
+  let activeProviderOptions = providerOptions;
+  function resolveBudget(taskKind, hintTokens) {
+    return resolveModelBudget({
+      taskKind,
+      hintTokens,
+      modelCapabilities,
+      constraint: modelBudgetConstraints?.[taskKind]
+    });
+  }
+  function trackUsage(usage, report) {
     modelCalls += 1;
     if (usage) {
       callsWithUsage += 1;
@@ -6683,6 +7752,16 @@ function createExtractor(config) {
     } else {
       callsMissingUsage += 1;
     }
+    if (report) {
+      performanceReport.modelCalls.push({
+        ...report,
+        usage,
+        usageReported: !!usage
+      });
+      if (report.durationMs) {
+        performanceReport.totalModelCallDurationMs += report.durationMs;
+      }
+    }
   }
   function mergeMemoryResult(name, data, memory) {
     const existing = memory.get(name);
@@ -6765,9 +7844,10 @@ function createExtractor(config) {
     }
     return lines.length > 0 ? lines.join("\n") : "";
   }
-  async function runFocusedExtractorTask(task, pdfInput, memory) {
+  async function runFocusedExtractorTask(task, pdfInput, memory, pageRangeCache) {
     if (task.extractorName === "supplementary") {
       const alreadyExtractedSummary = buildAlreadyExtractedSummary(memory);
+      const budget = resolveBudget("extraction_focused", 4096);
       const result = await runExtractor({
         name: "supplementary",
         prompt: buildSupplementaryPrompt(alreadyExtractedSummary),
@@ -6777,10 +7857,15 @@ function createExtractor(config) {
         endPage: task.endPage,
         generateObject,
         convertPdfToImages,
-        maxTokens: 4096,
-        providerOptions
+        maxTokens: budget.maxTokens,
+        providerOptions: activeProviderOptions,
+        pageRangeCache
+      });
+      trackUsage(result.usage, {
+        taskKind: "extraction_focused",
+        label: "supplementary",
+        maxTokens: budget.maxTokens
       });
-      trackUsage(result.usage);
       return result;
     }
     return runFocusedExtractorWithFallback({
@@ -6788,8 +7873,10 @@ function createExtractor(config) {
       pdfInput,
       generateObject,
       convertPdfToImages,
-      providerOptions,
+      providerOptions: activeProviderOptions,
+      pageRangeCache,
       trackUsage,
+      resolveBudget,
       log
     });
   }
@@ -6810,6 +7897,19 @@ function createExtractor(config) {
     modelCalls = 0;
     callsWithUsage = 0;
     callsMissingUsage = 0;
+    performanceReport = {
+      modelCalls: [],
+      totalModelCallDurationMs: 0
+    };
+    const sourceSpans = options?.sourceSpans ?? [];
+    const sourceChunks = sourceSpans.length ? chunkSourceSpans(sourceSpans) : [];
+    activeProviderOptions = sourceSpans.length ? { ...providerOptions, sourceSpans, sourceChunks } : providerOptions;
+    if (sourceStore && sourceSpans.length > 0) {
+      await sourceStore.addSourceSpans(sourceSpans);
+      if (sourceChunks.length > 0) {
+        await sourceStore.addSourceChunks(sourceChunks);
+      }
+    }
     const pipelineCtx = createPipelineContext({
       id,
       onSave: onCheckpointSave,
@@ -6823,12 +7923,21 @@ function createExtractor(config) {
       }
     }
     let pdfBase64Cache;
+    const pageRangePdfCache = /* @__PURE__ */ new Map();
     async function getPdfBase64ForExtraction() {
       if (pdfBase64Cache === void 0) {
         pdfBase64Cache = await pdfInputToBase64(pdfInput);
       }
       return pdfBase64Cache;
     }
+    async function getPageRangePdf(startPage, endPage) {
+      const cacheKey = `${startPage}-${endPage}`;
+      const cached = pageRangePdfCache.get(cacheKey);
+      if (cached) return cached;
+      const pagesPdf = await extractPageRange(await getPdfBase64ForExtraction(), startPage, endPage);
+      pageRangePdfCache.set(cacheKey, pagesPdf);
+      return pagesPdf;
+    }
     let classifyResult;
     if (resumed?.classifyResult && pipelineCtx.isPhaseComplete("classify")) {
       classifyResult = resumed.classifyResult;
@@ -6836,13 +7945,14 @@ function createExtractor(config) {
     } else {
       onProgress?.("Classifying document...");
       const pageCount2 = await getPdfPageCount(pdfInput);
+      const budget = resolveBudget("extraction_classify", 512);
       const classifyResponse = await safeGenerateObject(
         generateObject,
         {
           prompt: buildClassifyPrompt(),
           schema: ClassifyResultSchema,
-          maxTokens: 512,
-          providerOptions: await buildPdfProviderOptions(pdfInput, providerOptions)
+          maxTokens: budget.maxTokens,
+          providerOptions: await buildPdfProviderOptions(pdfInput, activeProviderOptions)
         },
         {
           fallback: { documentType: "policy", policyTypes: ["other"], confidence: 0 },
@@ -6851,7 +7961,11 @@ function createExtractor(config) {
           onError: (err, attempt) => log?.(`Classify attempt ${attempt + 1} failed: ${err instanceof Error ? err.message : String(err)}`)
         }
       );
-      trackUsage(classifyResponse.usage);
+      trackUsage(classifyResponse.usage, {
+        taskKind: "extraction_classify",
+        label: "classify",
+        maxTokens: budget.maxTokens
+      });
       classifyResult = classifyResponse.object;
       if (classifyResult.confidence === 0) {
         await log?.(`WARNING: classify returned fallback (policyTypes: ["other"]). This usually means the generateObject callback failed \u2014 check that the document content is accessible to the model.`);
@@ -6864,7 +7978,8 @@ function createExtractor(config) {
         memory: Object.fromEntries(memory)
       });
     }
-    const { documentType, policyTypes } = classifyResult;
+    const documentType = classifyResult.documentType;
+    const policyTypes = classifyResult.policyTypes ?? [];
     const primaryType = policyTypes[0] ?? "other";
     const template = getTemplate(primaryType);
     const pageCount = resumed?.pageCount ?? await getPdfPageCount(pdfInput);
@@ -6876,13 +7991,14 @@ function createExtractor(config) {
       onProgress?.("Resuming from checkpoint (form inventory complete)...");
     } else {
       onProgress?.(`Building form inventory for ${primaryType} ${documentType}...`);
+      const budget = resolveBudget("extraction_form_inventory", 2048);
       const formInventoryResponse = await safeGenerateObject(
         generateObject,
         {
           prompt: buildFormInventoryPrompt(templateHints),
           schema: FormInventorySchema,
-          maxTokens: 2048,
-          providerOptions: await buildPdfProviderOptions(pdfInput, providerOptions)
+          maxTokens: budget.maxTokens,
+          providerOptions: await buildPdfProviderOptions(pdfInput, activeProviderOptions)
         },
         {
           fallback: { forms: [] },
@@ -6890,7 +8006,11 @@ function createExtractor(config) {
           onError: (err, attempt) => log?.(`Form inventory attempt ${attempt + 1} failed: ${err instanceof Error ? err.message : String(err)}`)
         }
       );
-      trackUsage(formInventoryResponse.usage);
+      trackUsage(formInventoryResponse.usage, {
+        taskKind: "extraction_form_inventory",
+        label: "form_inventory",
+        maxTokens: budget.maxTokens
+      });
       formInventory = formInventoryResponse.object;
       memory.set("form_inventory", formInventory);
       await pipelineCtx.save("form_inventory", {
@@ -6909,39 +8029,54 @@ function createExtractor(config) {
       onProgress?.(`Mapping document pages for ${primaryType} ${documentType}...`);
       const chunkSize = 8;
       const collectedAssignments = [];
-      const formInventoryHint = formInventory?.forms.length ? formatFormInventoryForPageMap(formInventory.forms) : void 0;
-      const extractionBase64 = await getPdfBase64ForExtraction();
-      for (let startPage = 1; startPage <= pageCount; startPage += chunkSize) {
-        const endPage = Math.min(pageCount, startPage + chunkSize - 1);
-        const pagesPdf = await extractPageRange(extractionBase64, startPage, endPage);
-        const mapResponse = await safeGenerateObject(
-          generateObject,
-          {
-            prompt: buildPageMapPrompt(templateHints, startPage, endPage, formInventoryHint),
-            schema: PageMapChunkSchema,
-            maxTokens: 2048,
-            providerOptions: { ...providerOptions, pdfBase64: pagesPdf }
-          },
-          {
-            fallback: {
-              pages: Array.from({ length: endPage - startPage + 1 }, (_, index) => ({
-                localPageNumber: index + 1,
-                extractorNames: index === 0 && startPage === 1 ? ["carrier_info", "named_insured", "declarations", "coverage_limits"] : ["sections"],
-                confidence: 0,
-                notes: "Fallback page assignment"
-              }))
-            },
-            log,
-            onError: (err, attempt) => log?.(`Page map attempt ${attempt + 1} failed for pages ${startPage}-${endPage}: ${err}`)
-          }
-        );
-        trackUsage(mapResponse.usage);
-        for (const assignment of mapResponse.object.pages) {
-          collectedAssignments.push({
-            ...assignment,
-            localPageNumber: startPage + assignment.localPageNumber - 1
-          });
+      const formInventoryHint = formInventory?.forms?.length ? formatFormInventoryForPageMap(formInventory.forms) : void 0;
+      const pageMapChunks = Array.from(
+        { length: Math.ceil(pageCount / chunkSize) },
+        (_, index) => {
+          const startPage = index * chunkSize + 1;
+          return { startPage, endPage: Math.min(pageCount, startPage + chunkSize - 1) };
         }
+      );
+      const pageMapResults = await Promise.all(
+        pageMapChunks.map(
+          ({ startPage, endPage }) => limit(async () => {
+            const pagesPdf = await getPageRangePdf(startPage, endPage);
+            const budget = resolveBudget("extraction_page_map", 2048);
+            const mapResponse = await safeGenerateObject(
+              generateObject,
+              {
+                prompt: buildPageMapPrompt(templateHints, startPage, endPage, formInventoryHint),
+                schema: PageMapChunkSchema,
+                maxTokens: budget.maxTokens,
+                providerOptions: { ...activeProviderOptions, pdfBase64: pagesPdf }
+              },
+              {
+                fallback: {
+                  pages: Array.from({ length: endPage - startPage + 1 }, (_, index) => ({
+                    localPageNumber: index + 1,
+                    extractorNames: index === 0 && startPage === 1 ? ["carrier_info", "named_insured", "declarations", "coverage_limits"] : ["sections"],
+                    confidence: 0,
+                    notes: "Fallback page assignment"
+                  }))
+                },
+                log,
+                onError: (err, attempt) => log?.(`Page map attempt ${attempt + 1} failed for pages ${startPage}-${endPage}: ${err}`)
+              }
+            );
+            trackUsage(mapResponse.usage, {
+              taskKind: "extraction_page_map",
+              label: `page_map:${startPage}-${endPage}`,
+              maxTokens: budget.maxTokens
+            });
+            return mapResponse.object.pages.map((assignment) => ({
+              ...assignment,
+              localPageNumber: startPage + assignment.localPageNumber - 1
+            }));
+          })
+        )
+      );
+      for (const assignments of pageMapResults) {
+        collectedAssignments.push(...assignments);
       }
       pageAssignments = collectedAssignments.length > 0 ? collectedAssignments : Array.from({ length: pageCount }, (_, index) => ({
         localPageNumber: index + 1,
@@ -6979,11 +8114,12 @@ function createExtractor(config) {
     if (!pipelineCtx.isPhaseComplete("extract")) {
       const tasks = plan.tasks;
       onProgress?.(`Dispatching ${tasks.length} extractors...`);
+      const extractionPdfInput = await getPdfBase64ForExtraction();
       const extractorResults = await Promise.all(
         tasks.map(
           (task) => limit(async () => {
             onProgress?.(`Extracting ${task.extractorName} (pages ${task.startPage}-${task.endPage})...`);
-            return runFocusedExtractorTask(task, pdfInput, memory);
+            return runFocusedExtractorTask(task, extractionPdfInput, memory, pageRangePdfCache);
           })
         )
       );
@@ -6997,6 +8133,7 @@ function createExtractor(config) {
         onProgress?.("Extracting supplementary retrieval facts...");
         try {
           const alreadyExtractedSummary = buildAlreadyExtractedSummary(memory);
+          const budget = resolveBudget("extraction_focused", 4096);
           const supplementaryResult = await runExtractor({
             name: "supplementary",
             prompt: buildSupplementaryPrompt(alreadyExtractedSummary),
@@ -7006,10 +8143,15 @@ function createExtractor(config) {
             endPage: pageCount,
             generateObject,
             convertPdfToImages,
-            maxTokens: 4096,
-            providerOptions
+            maxTokens: budget.maxTokens,
+            providerOptions: activeProviderOptions,
+            pageRangeCache: pageRangePdfCache
+          });
+          trackUsage(supplementaryResult.usage, {
+            taskKind: "extraction_focused",
+            label: "supplementary",
+            maxTokens: budget.maxTokens
           });
-          trackUsage(supplementaryResult.usage);
           mergeMemoryResult(supplementaryResult.name, supplementaryResult.data, memory);
         } catch (error) {
           await log?.(`Supplementary extractor failed: ${error}`);
@@ -7035,11 +8177,16 @@ function createExtractor(config) {
           generateObject,
           convertPdfToImages,
           concurrency,
-          providerOptions,
+          providerOptions: activeProviderOptions,
+          modelCapabilities,
+          modelBudgetConstraints,
           log,
           onProgress
         });
-        trackUsage(resolution.usage);
+        trackUsage(resolution.usage, {
+          taskKind: "extraction_referential_lookup",
+          label: "referential_resolution"
+        });
         if (resolution.attempts > 0) {
           await log?.(`Referential resolution: ${resolution.resolved}/${resolution.attempts} resolved, ${resolution.unresolved} unresolved`);
         }
@@ -7064,13 +8211,14 @@ function createExtractor(config) {
         const extractedKeys = [...memory.keys()].filter((k) => k !== "classify");
         const extractionSummary = summarizeExtraction(memory);
         const pageMapSummary = formatPageMapSummary(pageAssignments);
+        const budget = resolveBudget("extraction_review", 1536);
         const reviewResponse = await safeGenerateObject(
           generateObject,
           {
             prompt: buildReviewPrompt(template.required, extractedKeys, extractionSummary, pageMapSummary, extractorCatalog),
             schema: ReviewResultSchema,
-            maxTokens: 1536,
-            providerOptions: await buildPdfProviderOptions(pdfInput, providerOptions)
+            maxTokens: budget.maxTokens,
+            providerOptions: await buildPdfProviderOptions(pdfInput, activeProviderOptions)
           },
           {
             fallback: { complete: true, missingFields: [], qualityIssues: [], additionalTasks: [] },
@@ -7078,7 +8226,11 @@ function createExtractor(config) {
             onError: (err, attempt) => log?.(`Review round ${round + 1} attempt ${attempt + 1} failed: ${err}`)
           }
         );
-        trackUsage(reviewResponse.usage);
+        trackUsage(reviewResponse.usage, {
+          taskKind: "extraction_review",
+          label: `review:${round + 1}`,
+          maxTokens: budget.maxTokens
+        });
         reviewRounds.push(toReviewRoundRecord(round + 1, reviewResponse.object));
         if (reviewResponse.object.qualityIssues?.length) {
           await log?.(`Review round ${round + 1} quality issues: ${reviewResponse.object.qualityIssues.join("; ")}`);
@@ -7088,10 +8240,11 @@ function createExtractor(config) {
           break;
         }
         onProgress?.(`Review round ${round + 1}: dispatching ${reviewResponse.object.additionalTasks.length} follow-up extractors...`);
+        const extractionPdfInput = await getPdfBase64ForExtraction();
         const followUpResults = await Promise.all(
           reviewResponse.object.additionalTasks.map(
             (task) => limit(async () => {
-              return runFocusedExtractorTask(task, pdfInput, memory);
+              return runFocusedExtractorTask(task, extractionPdfInput, memory, pageRangePdfCache);
             })
           )
         );
@@ -7101,10 +8254,12 @@ function createExtractor(config) {
           }
         }
       }
+      groundExtractionMemoryWithSourceSpans(memory, sourceSpans);
       reviewReport = buildExtractionReviewReport({
         memory,
         pageAssignments,
-        reviewRounds
+        reviewRounds,
+        sourceSpansAvailable: sourceSpans.length > 0
       });
       if (reviewReport.issues.length > 0) {
         await log?.(
@@ -7125,10 +8280,12 @@ function createExtractor(config) {
         memory: Object.fromEntries(memory)
       });
     }
+    groundExtractionMemoryWithSourceSpans(memory, sourceSpans);
     reviewReport ?? (reviewReport = buildExtractionReviewReport({
       memory,
       pageAssignments,
-      reviewRounds
+      reviewRounds,
+      sourceSpansAvailable: sourceSpans.length > 0
     }));
     onProgress?.("Assembling document...");
     const document = assembleDocument(id, documentType, memory);
@@ -7146,13 +8303,14 @@ function createExtractor(config) {
     if (!document.summary) {
       onProgress?.("Generating document summary...");
       try {
+        const budget = resolveBudget("extraction_summary", 512);
         const summaryResponse = await safeGenerateObject(
           generateObject,
           {
             prompt: buildSummaryPrompt(document),
             schema: SummaryResultSchema,
-            maxTokens: 512,
-            providerOptions
+            maxTokens: budget.maxTokens,
+            providerOptions: activeProviderOptions
           },
           {
             fallback: { summary: "" },
@@ -7160,7 +8318,11 @@ function createExtractor(config) {
             onError: (err, attempt) => log?.(`Summary attempt ${attempt + 1} failed: ${err instanceof Error ? err.message : String(err)}`)
           }
         );
-        trackUsage(summaryResponse.usage);
+        trackUsage(summaryResponse.usage, {
+          taskKind: "extraction_summary",
+          label: "summary",
+          maxTokens: budget.maxTokens
+        });
         if (summaryResponse.object.summary) {
           document.summary = summaryResponse.object.summary;
         }
@@ -7169,12 +8331,18 @@ function createExtractor(config) {
       }
     }
     onProgress?.("Formatting extracted content...");
+    const formatBudget = resolveBudget("extraction_format", 16384);
     const formatResult = await formatDocumentContent(document, generateText, {
-      providerOptions,
+      providerOptions: activeProviderOptions,
+      maxTokens: formatBudget.maxTokens,
       onProgress,
       log
     });
-    trackUsage(formatResult.usage);
+    trackUsage(formatResult.usage, {
+      taskKind: "extraction_format",
+      label: "format",
+      maxTokens: formatBudget.maxTokens
+    });
     const chunks = chunkDocument(formatResult.document);
     const finalCheckpoint = pipelineCtx.getCheckpoint();
     if (callsMissingUsage > 0) {
@@ -7184,12 +8352,15 @@ function createExtractor(config) {
     return {
       document: formatResult.document,
       chunks,
+      sourceSpans,
+      sourceChunks,
       tokenUsage: totalUsage,
       usageReporting: {
         modelCalls,
         callsWithUsage,
         callsMissingUsage
       },
+      performanceReport,
       checkpoint: finalCheckpoint,
       reviewReport
     };
@@ -7411,8 +8582,8 @@ Respond with JSON only:
 }`;
 
 // src/schemas/application.ts
-import { z as z38 } from "zod";
-var FieldTypeSchema = z38.enum([
+import { z as z41 } from "zod";
+var FieldTypeSchema = z41.enum([
   "text",
   "numeric",
   "currency",
@@ -7421,144 +8592,153 @@ var FieldTypeSchema = z38.enum([
   "table",
   "declaration"
 ]);
-var ApplicationFieldSchema = z38.object({
-  id: z38.string(),
-  label: z38.string(),
-  section: z38.string(),
+var ApplicationFieldSchema = z41.object({
+  id: z41.string(),
+  label: z41.string(),
+  section: z41.string(),
   fieldType: FieldTypeSchema,
-  required: z38.boolean(),
-  options: z38.array(z38.string()).optional(),
-  columns: z38.array(z38.string()).optional(),
-  requiresExplanationIfYes: z38.boolean().optional(),
-  condition: z38.object({
-    dependsOn: z38.string(),
-    whenValue: z38.string()
+  required: z41.boolean(),
+  options: z41.array(z41.string()).optional(),
+  columns: z41.array(z41.string()).optional(),
+  requiresExplanationIfYes: z41.boolean().optional(),
+  condition: z41.object({
+    dependsOn: z41.string(),
+    whenValue: z41.string()
   }).optional(),
-  value: z38.string().optional(),
-  source: z38.string().optional().describe("Where the value came from: auto-fill, user, lookup"),
-  confidence: z38.enum(["confirmed", "high", "medium", "low"]).optional()
-});
-var ApplicationClassifyResultSchema = z38.object({
-  isApplication: z38.boolean(),
-  confidence: z38.number().min(0).max(1),
-  applicationType: z38.string().nullable()
-});
-var FieldExtractionResultSchema = z38.object({
-  fields: z38.array(ApplicationFieldSchema)
-});
-var AutoFillMatchSchema = z38.object({
-  fieldId: z38.string(),
-  value: z38.string(),
-  confidence: z38.enum(["confirmed"]),
-  contextKey: z38.string()
-});
-var AutoFillResultSchema = z38.object({
-  matches: z38.array(AutoFillMatchSchema)
-});
-var QuestionBatchResultSchema = z38.object({
-  batches: z38.array(z38.array(z38.string()).describe("Array of field IDs in this batch"))
-});
-var LookupRequestSchema = z38.object({
-  type: z38.string().describe("Type of lookup: 'records', 'website', 'policy'"),
-  description: z38.string(),
-  url: z38.string().optional(),
-  targetFieldIds: z38.array(z38.string())
-});
-var ReplyIntentSchema = z38.object({
-  primaryIntent: z38.enum(["answers_only", "question", "lookup_request", "mixed"]),
-  hasAnswers: z38.boolean(),
-  questionText: z38.string().optional(),
-  questionFieldIds: z38.array(z38.string()).optional(),
-  lookupRequests: z38.array(LookupRequestSchema).optional()
-});
-var ParsedAnswerSchema = z38.object({
-  fieldId: z38.string(),
-  value: z38.string(),
-  explanation: z38.string().optional()
-});
-var AnswerParsingResultSchema = z38.object({
-  answers: z38.array(ParsedAnswerSchema),
-  unanswered: z38.array(z38.string()).describe("Field IDs that were not answered")
-});
-var LookupFillSchema = z38.object({
-  fieldId: z38.string(),
-  value: z38.string(),
-  source: z38.string().describe("Specific citable reference, e.g. 'GL Policy #POL-12345 (Hartford)'")
-});
-var LookupFillResultSchema = z38.object({
-  fills: z38.array(LookupFillSchema),
-  unfillable: z38.array(z38.string()),
-  explanation: z38.string().optional()
-});
-var FlatPdfPlacementSchema = z38.object({
-  fieldId: z38.string(),
-  page: z38.number(),
-  x: z38.number().describe("Percentage from left edge (0-100)"),
-  y: z38.number().describe("Percentage from top edge (0-100)"),
-  text: z38.string(),
-  fontSize: z38.number().optional(),
-  isCheckmark: z38.boolean().optional()
-});
-var AcroFormMappingSchema = z38.object({
-  fieldId: z38.string(),
-  acroFormName: z38.string(),
-  value: z38.string()
-});
-var QualityGateStatusSchema = z38.enum(["passed", "warning", "failed"]);
-var QualitySeveritySchema = z38.enum(["info", "warning", "blocking"]);
-var ApplicationQualityIssueSchema = z38.object({
-  code: z38.string(),
+  value: z41.string().optional(),
+  source: z41.string().optional().describe("Where the value came from: auto-fill, user, lookup"),
+  confidence: z41.enum(["confirmed", "high", "medium", "low"]).optional(),
+  sourceSpanIds: z41.array(z41.string()).optional().describe("Stable source spans that support the field value or field anchor"),
+  userSourceSpanIds: z41.array(z41.string()).optional().describe("Message or attachment spans that support user-provided values"),
+  pageNumber: z41.number().int().positive().optional().describe("Application page where the field label or anchor appears"),
+  fieldAnchorId: z41.string().optional().describe("Stable field anchor ID derived from page, section, label, and form metadata"),
+  acroFormName: z41.string().optional().describe("Native PDF AcroForm field name when available"),
+  validationStatus: z41.enum(["valid", "needs_review", "unsupported", "missing"]).optional()
+});
+var ApplicationClassifyResultSchema = z41.object({
+  isApplication: z41.boolean(),
+  confidence: z41.number().min(0).max(1),
+  applicationType: z41.string().nullable()
+});
+var FieldExtractionResultSchema = z41.object({
+  fields: z41.array(ApplicationFieldSchema)
+});
+var AutoFillMatchSchema = z41.object({
+  fieldId: z41.string(),
+  value: z41.string(),
+  confidence: z41.enum(["confirmed"]),
+  contextKey: z41.string()
+});
+var AutoFillResultSchema = z41.object({
+  matches: z41.array(AutoFillMatchSchema)
+});
+var QuestionBatchResultSchema = z41.object({
+  batches: z41.array(z41.array(z41.string()).describe("Array of field IDs in this batch"))
+});
+var LookupRequestSchema = z41.object({
+  type: z41.string().describe("Type of lookup: 'records', 'website', 'policy'"),
+  description: z41.string(),
+  url: z41.string().optional(),
+  targetFieldIds: z41.array(z41.string())
+});
+var ReplyIntentSchema = z41.object({
+  primaryIntent: z41.enum(["answers_only", "question", "lookup_request", "mixed"]),
+  hasAnswers: z41.boolean(),
+  questionText: z41.string().optional(),
+  questionFieldIds: z41.array(z41.string()).optional(),
+  lookupRequests: z41.array(LookupRequestSchema).optional()
+});
+var ParsedAnswerSchema = z41.object({
+  fieldId: z41.string(),
+  value: z41.string(),
+  explanation: z41.string().optional()
+});
+var AnswerParsingResultSchema = z41.object({
+  answers: z41.array(ParsedAnswerSchema),
+  unanswered: z41.array(z41.string()).describe("Field IDs that were not answered")
+});
+var LookupFillSchema = z41.object({
+  fieldId: z41.string(),
+  value: z41.string(),
+  source: z41.string().describe("Specific citable reference, e.g. 'GL Policy #POL-12345 (Hartford)'"),
+  sourceSpanIds: z41.array(z41.string()).optional()
+});
+var LookupFillResultSchema = z41.object({
+  fills: z41.array(LookupFillSchema),
+  unfillable: z41.array(z41.string()),
+  explanation: z41.string().optional()
+});
+var FlatPdfPlacementSchema = z41.object({
+  fieldId: z41.string(),
+  page: z41.number(),
+  x: z41.number().describe("Percentage from left edge (0-100)"),
+  y: z41.number().describe("Percentage from top edge (0-100)"),
+  text: z41.string(),
+  fontSize: z41.number().optional(),
+  isCheckmark: z41.boolean().optional()
+});
+var AcroFormMappingSchema = z41.object({
+  fieldId: z41.string(),
+  acroFormName: z41.string(),
+  value: z41.string()
+});
+var QualityGateStatusSchema = z41.enum(["passed", "warning", "failed"]);
+var QualitySeveritySchema = z41.enum(["info", "warning", "blocking"]);
+var ApplicationQualityIssueSchema = z41.object({
+  code: z41.string(),
   severity: QualitySeveritySchema,
-  message: z38.string(),
-  fieldId: z38.string().optional()
+  message: z41.string(),
+  fieldId: z41.string().optional()
 });
-var ApplicationQualityRoundSchema = z38.object({
-  round: z38.number(),
-  kind: z38.string(),
+var ApplicationQualityRoundSchema = z41.object({
+  round: z41.number(),
+  kind: z41.string(),
   status: QualityGateStatusSchema,
-  summary: z38.string().optional()
+  summary: z41.string().optional()
 });
-var ApplicationQualityArtifactSchema = z38.object({
-  kind: z38.string(),
-  label: z38.string().optional(),
-  itemCount: z38.number().optional()
+var ApplicationQualityArtifactSchema = z41.object({
+  kind: z41.string(),
+  label: z41.string().optional(),
+  itemCount: z41.number().optional()
 });
-var ApplicationEmailReviewSchema = z38.object({
-  issues: z38.array(ApplicationQualityIssueSchema),
+var ApplicationEmailReviewSchema = z41.object({
+  issues: z41.array(ApplicationQualityIssueSchema),
   qualityGateStatus: QualityGateStatusSchema
 });
-var ApplicationQualityReportSchema = z38.object({
-  issues: z38.array(ApplicationQualityIssueSchema),
-  rounds: z38.array(ApplicationQualityRoundSchema).optional(),
-  artifacts: z38.array(ApplicationQualityArtifactSchema).optional(),
+var ApplicationQualityReportSchema = z41.object({
+  issues: z41.array(ApplicationQualityIssueSchema),
+  rounds: z41.array(ApplicationQualityRoundSchema).optional(),
+  artifacts: z41.array(ApplicationQualityArtifactSchema).optional(),
   emailReview: ApplicationEmailReviewSchema.optional(),
   qualityGateStatus: QualityGateStatusSchema
 });
-var ApplicationStateSchema = z38.object({
-  id: z38.string(),
-  pdfBase64: z38.string().optional().describe("Original PDF, omitted after extraction"),
-  title: z38.string().optional(),
-  applicationType: z38.string().nullable().optional(),
-  fields: z38.array(ApplicationFieldSchema),
-  batches: z38.array(z38.array(z38.string())).optional(),
-  currentBatchIndex: z38.number().default(0),
+var ApplicationStateSchema = z41.object({
+  id: z41.string(),
+  pdfBase64: z41.string().optional().describe("Original PDF, omitted after extraction"),
+  title: z41.string().optional(),
+  applicationType: z41.string().nullable().optional(),
+  fields: z41.array(ApplicationFieldSchema),
+  batches: z41.array(z41.array(z41.string())).optional(),
+  currentBatchIndex: z41.number().default(0),
   qualityReport: ApplicationQualityReportSchema.optional(),
-  status: z38.enum(["classifying", "extracting", "auto_filling", "batching", "collecting", "confirming", "mapping", "complete"]),
-  createdAt: z38.number(),
-  updatedAt: z38.number()
+  status: z41.enum(["classifying", "extracting", "auto_filling", "batching", "collecting", "confirming", "mapping", "complete"]),
+  createdAt: z41.number(),
+  updatedAt: z41.number()
 });
 
 // src/application/agents/classifier.ts
-async function classifyApplication(pdfContent, generateObject, providerOptions) {
+async function classifyApplication(pdfContent, generateObject, providerOptions, maxTokens = 512) {
   const { object, usage } = await withRetry(
     () => generateObject({
       prompt: `${APPLICATION_CLASSIFY_PROMPT}
 
-Analyze the following document content:
-${pdfContent}`,
+Analyze the attached insurance document. If text source units are provided in provider options, use them as supporting context. Do not infer from base64 text.`,
       schema: ApplicationClassifyResultSchema,
-      maxTokens: 512,
-      providerOptions
+      maxTokens,
+      providerOptions: {
+        ...providerOptions,
+        pdfBase64: providerOptions?.pdfBase64 ?? pdfContent
+      }
     })
   );
   return { result: object, usage };
@@ -7571,13 +8751,18 @@ function buildFieldExtractionPrompt() {
 Field types: "text", "numeric", "currency", "date", "yes_no", "table", "declaration"
 
 Required keys per field:
-- "id": short snake_case ID
+- "id": short provisional snake_case ID. The SDK will replace this with a stable deterministic ID.
 - "label": field label \u2014 a clear, natural question that a human would understand
 - "section": section heading
 - "fieldType": one of the types above
 - "required": boolean
 
 Optional keys (only include when applicable):
+- "sourceSpanIds": stable source span IDs if the caller provided source units for this application
+- "pageNumber": PDF page number where the field label/anchor appears
+- "fieldAnchorId": stable caller-provided field anchor ID, when available
+- "acroFormName": native PDF form field name, when visible or provided
+- "validationStatus": "missing" for extracted blank fields, "needs_review" for prefilled fields that need source validation
 - "options": array of strings \u2014 for fields with checkboxes/radio buttons/multiple choices (e.g. business type, state selections). Use "text" fieldType with options.
 - "columns": array of {"name","type"} \u2014 tables only
 - "requiresExplanationIfYes": boolean \u2014 declarations only
@@ -7593,25 +8778,73 @@ Example:
   {"id":"prior_claims","text":"Any claims in past 5 years?","section":"Declarations","fieldType":"declaration","required":true,"requiresExplanationIfYes":true}
 ]
 
-Extract ALL fields. Respond with ONLY the JSON array, no other text.`;
-}
+Extract ALL fields. Prefer page numbers and source span IDs over model-generated guesses whenever source units are supplied. Respond with ONLY the JSON array, no other text.`;
+}
+
+// src/application/field-ids.ts
+function normalizePart(value) {
+  const normalized = (value ?? "").trim().toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+  return normalized || "unknown";
+}
+function hashText2(value) {
+  let hash = 2166136261;
+  for (let index = 0; index < value.length; index++) {
+    hash ^= value.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0).toString(16).padStart(8, "0").slice(0, 8);
+}
+function buildApplicationFieldAnchorId(field) {
+  const page = field.pageNumber ? `p${field.pageNumber}` : "pna";
+  const section = normalizePart(field.section);
+  const label = normalizePart(field.label);
+  const acroFormName = normalizePart(field.acroFormName);
+  const hash = hashText2(`${page}|${section}|${label}|${acroFormName}`);
+  return `app_field_anchor:${page}:${section}:${label}:${hash}`;
+}
+function buildStableApplicationFieldId(field) {
+  const page = field.pageNumber ? `p${field.pageNumber}` : "pna";
+  const section = normalizePart(field.section);
+  const label = normalizePart(field.label);
+  const fieldType = normalizePart(field.fieldType);
+  const anchor = field.fieldAnchorId ?? buildApplicationFieldAnchorId(field);
+  const hash = hashText2(`${page}|${section}|${label}|${fieldType}|${field.acroFormName ?? ""}|${anchor}`);
+  return `app_field:${page}:${section}:${label}:${hash}`;
+}
+function normalizeApplicationFields(fields) {
+  const seen = /* @__PURE__ */ new Map();
+  return fields.map((field) => {
+    const fieldAnchorId = field.fieldAnchorId ?? buildApplicationFieldAnchorId(field);
+    const baseId = buildStableApplicationFieldId({ ...field, fieldAnchorId });
+    const count = seen.get(baseId) ?? 0;
+    seen.set(baseId, count + 1);
+    return {
+      ...field,
+      id: count === 0 ? baseId : `${baseId}:${count + 1}`,
+      fieldAnchorId,
+      validationStatus: field.validationStatus ?? (field.value ? "needs_review" : "missing")
+    };
+  });
+}
 
 // src/application/agents/field-extractor.ts
-async function extractFields(pdfContent, generateObject, providerOptions) {
+async function extractFields(pdfContent, generateObject, providerOptions, maxTokens = 8192) {
   const prompt = `${buildFieldExtractionPrompt()}
 
-Extract fields from this application:
-${pdfContent}`;
+Extract fields from the attached application PDF. Use provider-supplied source units/spans for page numbers and anchors when present. Do not treat raw base64 as readable document text.`;
   const { object, usage } = await withRetry(
     () => generateObject({
       prompt,
       schema: FieldExtractionResultSchema,
-      maxTokens: 8192,
-      providerOptions
+      maxTokens,
+      providerOptions: {
+        ...providerOptions,
+        pdfBase64: providerOptions?.pdfBase64 ?? pdfContent
+      }
     })
   );
   const result = object;
-  return { fields: result.fields, usage };
+  return { fields: normalizeApplicationFields(result.fields), usage };
 }
 
 // src/prompts/application/auto-fill.ts
@@ -7644,7 +8877,7 @@ 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) {
+async function autoFillFromContext(fields, orgContext, generateObject, providerOptions, maxTokens = 4096) {
   const fieldSummaries = fields.map((f) => ({
     id: f.id,
     label: f.label,
@@ -7656,7 +8889,7 @@ async function autoFillFromContext(fields, orgContext, generateObject, providerO
     () => generateObject({
       prompt,
       schema: AutoFillResultSchema,
-      maxTokens: 4096,
+      maxTokens,
       providerOptions
     })
   );
@@ -7711,7 +8944,7 @@ Respond with JSON only:
 }
 
 // src/application/agents/batcher.ts
-async function batchQuestions(unfilledFields, generateObject, providerOptions) {
+async function batchQuestions(unfilledFields, generateObject, providerOptions, maxTokens = 2048) {
   const fieldSummaries = unfilledFields.map((f) => ({
     id: f.id,
     label: f.label,
@@ -7726,7 +8959,7 @@ async function batchQuestions(unfilledFields, generateObject, providerOptions) {
     () => generateObject({
       prompt,
       schema: QuestionBatchResultSchema,
-      maxTokens: 2048,
+      maxTokens,
       providerOptions
     })
   );
@@ -7770,14 +9003,14 @@ Respond with JSON only:
 }
 
 // src/application/agents/reply-router.ts
-async function classifyReplyIntent(fields, replyText, generateObject, providerOptions) {
+async function classifyReplyIntent(fields, replyText, generateObject, providerOptions, maxTokens = 1024) {
   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,
+      maxTokens,
       providerOptions
     })
   );
@@ -7824,7 +9057,7 @@ Only include answers you are confident about. If a response is ambiguous, includ
 }
 
 // src/application/agents/answer-parser.ts
-async function parseAnswers(fields, replyText, generateObject, providerOptions) {
+async function parseAnswers(fields, replyText, generateObject, providerOptions, maxTokens = 4096) {
   const questions = fields.map((f) => ({
     id: f.id,
     label: f.label,
@@ -7836,7 +9069,7 @@ async function parseAnswers(fields, replyText, generateObject, providerOptions)
     () => generateObject({
       prompt,
       schema: AnswerParsingResultSchema,
-      maxTokens: 4096,
+      maxTokens,
       providerOptions
     })
   );
@@ -7936,11 +9169,12 @@ IMPORTANT: The "source" field must be a specific, citable reference that will be
 - "Business Context (company_info)"
 - "User Profile"
 Never use vague sources like "existing records" or "available data".
+If AVAILABLE DATA contains sourceSpanId values, include them in "sourceSpanIds" for every value filled from that source. Existing policy values such as policy numbers, dates, limits, deductibles, premiums, coverages, exclusions, conditions, endorsements, locations, vehicles, or named insureds must not be filled without sourceSpanIds unless the value is explicitly marked for review.
 
 Respond with JSON only:
 {
   "fills": [
-    { "fieldId": "field_id", "value": "the value from data", "source": "Specific source with identifier (e.g. GL Policy #ABC123, stripe.com)" }
+    { "fieldId": "field_id", "value": "the value from data", "source": "Specific source with identifier (e.g. GL Policy #ABC123, stripe.com)", "sourceSpanIds": ["doc-1:span:1:0:abcd1234"] }
   ],
   "unfillable": ["field_ids that couldn't be matched"],
   "explanation": "Brief note about what was filled and what couldn't be found, citing sources"
@@ -7948,7 +9182,7 @@ Respond with JSON only:
 }
 
 // src/application/agents/lookup-filler.ts
-async function fillFromLookup(requests, targetFields, availableData, generateObject, providerOptions) {
+async function fillFromLookup(requests, targetFields, availableData, generateObject, providerOptions, maxTokens = 4096) {
   const requestSummaries = requests.map((r) => ({
     type: r.type,
     description: r.description,
@@ -7964,7 +9198,7 @@ async function fillFromLookup(requests, targetFields, availableData, generateObj
     () => generateObject({
       prompt,
       schema: LookupFillResultSchema,
-      maxTokens: 4096,
+      maxTokens,
       providerOptions
     })
   );
@@ -8025,7 +9259,7 @@ Output the email body text ONLY. No subject line, no JSON. Use markdown for numb
 }
 
 // src/application/agents/email-generator.ts
-async function generateBatchEmail(batchFields, batchIndex, totalBatches, opts, generateText, providerOptions) {
+async function generateBatchEmail(batchFields, batchIndex, totalBatches, opts, generateText, providerOptions, maxTokens = 2048) {
   const fieldSummaries = batchFields.map((f) => ({
     id: f.id,
     label: f.label,
@@ -8046,7 +9280,7 @@ async function generateBatchEmail(batchFields, batchIndex, totalBatches, opts, g
   const { text, usage } = await withRetry(
     () => generateText({
       prompt,
-      maxTokens: 2048,
+      maxTokens,
       providerOptions
     })
   );
@@ -8059,6 +9293,17 @@ function isVagueSource(source) {
   const normalized = source.trim().toLowerCase();
   return normalized === "unknown" || normalized.includes("existing records") || normalized.includes("available data") || normalized === "context" || normalized === "user provided";
 }
+function isSourceGroundedPolicyValue(field) {
+  if (!field.value) return false;
+  const source = field.source?.toLowerCase() ?? "";
+  if (field.sourceSpanIds?.length) return false;
+  if (field.userSourceSpanIds?.length) return false;
+  const label = `${field.section} ${field.label}`.toLowerCase();
+  const highValueLabel = /\b(policy|effective|expiration|date|limit|deductible|premium|coverage|exclusion|condition|endorsement|location|vehicle|named insured|revenue|payroll|loss|claim|prior)\b/.test(label);
+  const highValueType = field.fieldType === "currency" || field.fieldType === "date" || field.fieldType === "numeric" || field.fieldType === "declaration";
+  const fromPolicyLikeSource = /\b(policy|quote|document|lookup|carrier|endorsement)\b/.test(source);
+  return fromPolicyLikeSource && (highValueLabel || highValueType);
+}
 function buildApplicationQualityReport(state) {
   const issues = [];
   const seenIds = /* @__PURE__ */ new Set();
@@ -8104,6 +9349,14 @@ function buildApplicationQualityReport(state) {
         fieldId: field.id
       });
     }
+    if (isSourceGroundedPolicyValue(field)) {
+      issues.push({
+        code: "policy_value_missing_source_span",
+        severity: "blocking",
+        message: `Filled policy-derived field "${field.label}" is missing source span evidence.`,
+        fieldId: field.id
+      });
+    }
   }
   return {
     issues,
@@ -8213,7 +9466,9 @@ function createApplicationPipeline(config) {
     onProgress,
     log,
     providerOptions,
-    qualityGate = "warn"
+    qualityGate = "warn",
+    modelCapabilities,
+    modelBudgetConstraints
   } = config;
   const limit = pLimit(concurrency);
   let totalUsage = { inputTokens: 0, outputTokens: 0 };
@@ -8224,9 +9479,18 @@ function createApplicationPipeline(config) {
       onTokenUsage?.(usage);
     }
   }
+  function resolveBudget(taskKind, hintTokens) {
+    return resolveModelBudget({
+      taskKind,
+      hintTokens,
+      modelCapabilities,
+      constraint: modelBudgetConstraints?.[taskKind]
+    });
+  }
   async function processApplication(input) {
     totalUsage = { inputTokens: 0, outputTokens: 0 };
     const { pdfBase64, context } = input;
+    const applicationProviderOptions = input.sourceSpans?.length ? { ...providerOptions, sourceSpans: input.sourceSpans } : providerOptions;
     const id = input.applicationId ?? `app-${Date.now()}`;
     const now = Date.now();
     let state = {
@@ -8247,9 +9511,10 @@ function createApplicationPipeline(config) {
     let classifyResult;
     try {
       const { result, usage: classifyUsage } = await classifyApplication(
-        pdfBase64.slice(0, 2e3),
+        pdfBase64,
         generateObject,
-        providerOptions
+        applicationProviderOptions,
+        resolveBudget("application_classify", 512).maxTokens
       );
       trackUsage(classifyUsage);
       classifyResult = result;
@@ -8274,7 +9539,8 @@ function createApplicationPipeline(config) {
       const { fields: extractedFields, usage: extractUsage } = await extractFields(
         pdfBase64,
         generateObject,
-        providerOptions
+        applicationProviderOptions,
+        resolveBudget("application_extract_fields", 8192).maxTokens
       );
       trackUsage(extractUsage);
       fields = extractedFields;
@@ -8312,6 +9578,7 @@ function createApplicationPipeline(config) {
             field.value = pa.value;
             field.source = `backfill: ${pa.source}`;
             field.confidence = "high";
+            field.validationStatus = "needs_review";
           }
         }
       } catch (e) {
@@ -8336,7 +9603,8 @@ function createApplicationPipeline(config) {
               unfilledFields2,
               orgContext,
               generateObject,
-              providerOptions
+              providerOptions,
+              resolveBudget("application_auto_fill", 4096).maxTokens
             );
             trackUsage(afUsage);
             for (const match of autoFillResult.matches) {
@@ -8345,6 +9613,7 @@ function createApplicationPipeline(config) {
                 field.value = match.value;
                 field.source = `auto-fill: ${match.contextKey}`;
                 field.confidence = match.confidence;
+                field.validationStatus = "valid";
               }
             }
           } catch (e) {
@@ -8387,7 +9656,8 @@ function createApplicationPipeline(config) {
         const { result: batchResult, usage: batchUsage } = await batchQuestions(
           unfilledFields,
           generateObject,
-          providerOptions
+          providerOptions,
+          resolveBudget("application_batch", 2048).maxTokens
         );
         trackUsage(batchUsage);
         state.batches = batchResult.batches;
@@ -8410,9 +9680,15 @@ function createApplicationPipeline(config) {
     onProgress?.(`Application processed: ${filledCount}/${state.fields.length} fields filled, ${state.batches?.length ?? 0} batches to collect.`);
     return { state, tokenUsage: totalUsage, reviewReport: state.qualityReport };
   }
-  async function processReply(input) {
+  async function processReply2(input) {
     totalUsage = { inputTokens: 0, outputTokens: 0 };
     const { applicationId, replyText, context } = input;
+    const replySourceSpanIds = input.replySourceSpanIds?.length ? input.replySourceSpanIds : buildTextSourceSpans({
+      documentId: `${applicationId}:reply:${sourceSpanTextHash(replyText).slice(0, 12)}`,
+      sourceKind: "email",
+      text: replyText,
+      metadata: { applicationId }
+    }).map((span) => span.id);
     let state = null;
     if (applicationStore) {
       state = await applicationStore.get(applicationId);
@@ -8431,7 +9707,8 @@ function createApplicationPipeline(config) {
         currentBatchFields,
         replyText,
         generateObject,
-        providerOptions
+        providerOptions,
+        resolveBudget("application_classify", 1024).maxTokens
       );
       trackUsage(intentUsage);
       intent = classifiedIntent;
@@ -8459,7 +9736,8 @@ function createApplicationPipeline(config) {
           currentBatchFields,
           replyText,
           generateObject,
-          providerOptions
+          providerOptions,
+          resolveBudget("application_parse_answers", 4096).maxTokens
         );
         trackUsage(parseUsage);
         for (const answer of parseResult.answers) {
@@ -8468,6 +9746,8 @@ function createApplicationPipeline(config) {
             field.value = answer.value;
             field.source = "user";
             field.confidence = "confirmed";
+            field.userSourceSpanIds = replySourceSpanIds;
+            field.validationStatus = "valid";
             fieldsFilled++;
           }
         }
@@ -8499,7 +9779,8 @@ function createApplicationPipeline(config) {
             targetFields,
             availableData,
             generateObject,
-            providerOptions
+            providerOptions,
+            resolveBudget("application_lookup", 4096).maxTokens
           );
           trackUsage(lookupUsage);
           for (const fill of lookupResult.fills) {
@@ -8508,6 +9789,10 @@ function createApplicationPipeline(config) {
               field.value = fill.value;
               field.source = `lookup: ${fill.source}`;
               field.confidence = "high";
+              field.validationStatus = fill.sourceSpanIds?.length ? "valid" : "needs_review";
+              if (fill.sourceSpanIds?.length) {
+                field.sourceSpanIds = fill.sourceSpanIds;
+              }
               fieldsFilled++;
             }
           }
@@ -8522,7 +9807,7 @@ function createApplicationPipeline(config) {
           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,
+          maxTokens: resolveBudget("application_email", 512).maxTokens,
           providerOptions
         });
         trackUsage(usage);
@@ -8570,7 +9855,8 @@ Provide a brief, helpful explanation (2-3 sentences). End with "Just reply with
                 companyName: context?.companyName
               },
               generateText,
-              providerOptions
+              providerOptions,
+              resolveBudget("application_email", 2048).maxTokens
             );
             trackUsage(emailUsage);
             const emailReview = reviewBatchEmail(emailText, nextBatchFields);
@@ -8628,7 +9914,8 @@ ${emailText}`;
         previousBatchSummary: opts?.previousBatchSummary
       },
       generateText,
-      providerOptions
+      providerOptions,
+      resolveBudget("application_email", 2048).maxTokens
     );
     trackUsage(usage);
     const emailReview = reviewBatchEmail(text, batchFields);
@@ -8652,7 +9939,7 @@ Application: ${state.title ?? "Insurance Application"}
 
 Fields:
 ${fieldSummary}`,
-      maxTokens: 4096,
+      maxTokens: resolveBudget("application_email", 4096).maxTokens,
       providerOptions
     });
     trackUsage(usage);
@@ -8660,7 +9947,7 @@ ${fieldSummary}`,
   }
   return {
     processApplication,
-    processReply,
+    processReply: processReply2,
     generateCurrentBatchEmail,
     getConfirmationSummary
   };
@@ -8777,91 +10064,104 @@ Respond with the final answer, deduplicated citations array, overall confidence
 }
 
 // src/schemas/query.ts
-import { z as z39 } from "zod";
-var QueryIntentSchema = z39.enum([
+import { z as z42 } from "zod";
+var QueryIntentSchema = z42.enum([
   "policy_question",
   "coverage_comparison",
   "document_search",
   "claims_inquiry",
   "general_knowledge"
 ]);
-var QueryAttachmentKindSchema = z39.enum(["image", "pdf", "text"]);
-var QueryAttachmentSchema = z39.object({
-  id: z39.string().optional().describe("Optional stable attachment ID from the caller"),
+var QueryAttachmentKindSchema = z42.enum(["image", "pdf", "text"]);
+var QueryAttachmentSchema = z42.object({
+  id: z42.string().optional().describe("Optional stable attachment ID from the caller"),
   kind: QueryAttachmentKindSchema,
-  name: z39.string().optional().describe("Original filename or user-facing label"),
-  mimeType: z39.string().optional().describe("MIME type such as image/jpeg or application/pdf"),
-  base64: z39.string().optional().describe("Base64-encoded file content for image/pdf attachments"),
-  text: z39.string().optional().describe("Plain-text attachment content when available"),
-  description: z39.string().optional().describe("Caller-provided description of the attachment")
-});
-var SubQuestionSchema = z39.object({
-  question: z39.string().describe("Atomic sub-question to retrieve and answer independently"),
+  name: z42.string().optional().describe("Original filename or user-facing label"),
+  mimeType: z42.string().optional().describe("MIME type such as image/jpeg or application/pdf"),
+  base64: z42.string().optional().describe("Base64-encoded file content for image/pdf attachments"),
+  text: z42.string().optional().describe("Plain-text attachment content when available"),
+  description: z42.string().optional().describe("Caller-provided description of the attachment")
+});
+var QueryRetrievalModeSchema = z42.enum([
+  "graph_only",
+  "source_rag",
+  "long_context",
+  "hybrid"
+]);
+var SubQuestionSchema = z42.object({
+  question: z42.string().describe("Atomic sub-question to retrieve and answer independently"),
   intent: QueryIntentSchema,
-  chunkTypes: z39.array(z39.string()).optional().describe("Chunk types to filter retrieval (e.g. coverage, endorsement, declaration)"),
-  documentFilters: z39.object({
-    type: z39.enum(["policy", "quote"]).optional(),
-    carrier: z39.string().optional(),
-    insuredName: z39.string().optional(),
-    policyNumber: z39.string().optional(),
-    quoteNumber: z39.string().optional(),
-    policyTypes: z39.array(PolicyTypeSchema).optional().describe("Filter by policy type (e.g. homeowners_ho3, renters_ho4, pet) to avoid mixing up similar policies")
+  chunkTypes: z42.array(z42.string()).optional().describe("Chunk types to filter retrieval (e.g. coverage, endorsement, declaration)"),
+  documentFilters: z42.object({
+    type: z42.enum(["policy", "quote"]).optional(),
+    carrier: z42.string().optional(),
+    insuredName: z42.string().optional(),
+    policyNumber: z42.string().optional(),
+    quoteNumber: z42.string().optional(),
+    policyTypes: z42.array(PolicyTypeSchema).optional().describe("Filter by policy type (e.g. homeowners_ho3, renters_ho4, pet) to avoid mixing up similar policies")
   }).optional().describe("Structured filters to narrow document lookup")
 });
-var QueryClassifyResultSchema = z39.object({
+var QueryClassifyResultSchema = z42.object({
   intent: QueryIntentSchema,
-  subQuestions: z39.array(SubQuestionSchema).min(1).describe("Decomposed atomic sub-questions"),
-  requiresDocumentLookup: z39.boolean().describe("Whether structured document lookup is needed"),
-  requiresChunkSearch: z39.boolean().describe("Whether semantic chunk search is needed"),
-  requiresConversationHistory: z39.boolean().describe("Whether conversation history is relevant")
-});
-var EvidenceItemSchema = z39.object({
-  source: z39.enum(["chunk", "document", "conversation", "attachment"]),
-  chunkId: z39.string().optional(),
-  documentId: z39.string().optional(),
-  turnId: z39.string().optional(),
-  attachmentId: z39.string().optional(),
-  text: z39.string().describe("Text excerpt from the source"),
-  relevance: z39.number().min(0).max(1),
-  metadata: z39.array(z39.object({ key: z39.string(), value: z39.string() })).optional()
-});
-var AttachmentInterpretationSchema = z39.object({
-  summary: z39.string().describe("Concise summary of what the attachment shows or contains"),
-  extractedFacts: z39.array(z39.string()).describe("Specific observable or document facts grounded in the attachment"),
-  recommendedFocus: z39.array(z39.string()).describe("Important details to incorporate when answering follow-up questions"),
-  confidence: z39.number().min(0).max(1)
-});
-var RetrievalResultSchema = z39.object({
-  subQuestion: z39.string(),
-  evidence: z39.array(EvidenceItemSchema)
-});
-var CitationSchema = z39.object({
-  index: z39.number().describe("Citation number [1], [2], etc."),
-  chunkId: z39.string().describe("Source chunk ID, e.g. doc-123:coverage:2"),
-  documentId: z39.string(),
-  documentType: z39.enum(["policy", "quote"]).optional(),
-  field: z39.string().optional().describe("Specific field path, e.g. coverages[0].deductible"),
-  quote: z39.string().describe("Exact text from source that supports the claim"),
-  relevance: z39.number().min(0).max(1)
-});
-var SubAnswerSchema = z39.object({
-  subQuestion: z39.string(),
-  answer: z39.string(),
-  citations: z39.array(CitationSchema),
-  confidence: z39.number().min(0).max(1),
-  needsMoreContext: z39.boolean().describe("True if evidence was insufficient to answer fully")
-});
-var VerifyResultSchema = z39.object({
-  approved: z39.boolean().describe("Whether all sub-answers are adequately grounded"),
-  issues: z39.array(z39.string()).describe("Specific grounding or consistency issues found"),
-  retrySubQuestions: z39.array(z39.string()).optional().describe("Sub-questions that need additional retrieval or re-reasoning")
-});
-var QueryResultSchema = z39.object({
-  answer: z39.string(),
-  citations: z39.array(CitationSchema),
+  subQuestions: z42.array(SubQuestionSchema).min(1).describe("Decomposed atomic sub-questions"),
+  requiresDocumentLookup: z42.boolean().describe("Whether structured document lookup is needed"),
+  requiresChunkSearch: z42.boolean().describe("Whether semantic chunk search is needed"),
+  requiresConversationHistory: z42.boolean().describe("Whether conversation history is relevant"),
+  retrievalMode: QueryRetrievalModeSchema.optional().describe("Preferred retrieval strategy for the query when source-span retrieval is available")
+});
+var EvidenceItemSchema = z42.object({
+  source: z42.enum(["chunk", "document", "conversation", "attachment", "source_span"]),
+  chunkId: z42.string().optional(),
+  sourceSpanId: z42.string().optional(),
+  documentId: z42.string().optional(),
+  turnId: z42.string().optional(),
+  attachmentId: z42.string().optional(),
+  text: z42.string().describe("Text excerpt from the source"),
+  relevance: z42.number().min(0).max(1),
+  retrievalMode: QueryRetrievalModeSchema.optional(),
+  sourceLocation: SourceSpanLocationSchema.optional(),
+  metadata: z42.array(z42.object({ key: z42.string(), value: z42.string() })).optional()
+});
+var AttachmentInterpretationSchema = z42.object({
+  summary: z42.string().describe("Concise summary of what the attachment shows or contains"),
+  extractedFacts: z42.array(z42.string()).describe("Specific observable or document facts grounded in the attachment"),
+  recommendedFocus: z42.array(z42.string()).describe("Important details to incorporate when answering follow-up questions"),
+  confidence: z42.number().min(0).max(1)
+});
+var RetrievalResultSchema = z42.object({
+  subQuestion: z42.string(),
+  evidence: z42.array(EvidenceItemSchema)
+});
+var CitationSchema = z42.object({
+  index: z42.number().describe("Citation number [1], [2], etc."),
+  chunkId: z42.string().optional().describe("Source chunk ID, e.g. doc-123:coverage:2"),
+  sourceSpanId: z42.string().optional().describe("Precise source span ID when available"),
+  documentId: z42.string(),
+  documentType: z42.enum(["policy", "quote"]).optional(),
+  field: z42.string().optional().describe("Specific field path, e.g. coverages[0].deductible"),
+  quote: z42.string().describe("Exact text from source that supports the claim"),
+  relevance: z42.number().min(0).max(1),
+  retrievalMode: QueryRetrievalModeSchema.optional(),
+  sourceLocation: SourceSpanLocationSchema.optional()
+});
+var SubAnswerSchema = z42.object({
+  subQuestion: z42.string(),
+  answer: z42.string(),
+  citations: z42.array(CitationSchema),
+  confidence: z42.number().min(0).max(1),
+  needsMoreContext: z42.boolean().describe("True if evidence was insufficient to answer fully")
+});
+var VerifyResultSchema = z42.object({
+  approved: z42.boolean().describe("Whether all sub-answers are adequately grounded"),
+  issues: z42.array(z42.string()).describe("Specific grounding or consistency issues found"),
+  retrySubQuestions: z42.array(z42.string()).optional().describe("Sub-questions that need additional retrieval or re-reasoning")
+});
+var QueryResultSchema = z42.object({
+  answer: z42.string(),
+  citations: z42.array(CitationSchema),
   intent: QueryIntentSchema,
-  confidence: z39.number().min(0).max(1),
-  followUp: z39.string().optional().describe("Suggested follow-up question if applicable")
+  confidence: z42.number().min(0).max(1),
+  followUp: z42.string().optional().describe("Suggested follow-up question if applicable")
 });
 
 // src/query/retriever.ts
@@ -8869,23 +10169,69 @@ function recordToKVArray(record) {
   return Object.entries(record).map(([key, value]) => ({ key, value }));
 }
 async function retrieve(subQuestion, conversationId, config) {
-  const { documentStore, memoryStore, retrievalLimit, log } = config;
+  const { documentStore, memoryStore, sourceRetriever, retrievalLimit, retrievalMode, 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) {
+  if (retrievalMode === "source_rag" || retrievalMode === "hybrid" || retrievalMode === "long_context") {
+    tasks.push(
+      (async () => {
+        try {
+          const sourceResults = await sourceRetriever?.searchSourceSpans({
+            question: subQuestion.question,
+            limit: retrievalLimit,
+            mode: retrievalMode
+          }) ?? [];
+          for (const result of sourceResults) {
+            evidence.push({
+              source: "source_span",
+              sourceSpanId: result.span.id,
+              chunkId: result.span.chunkId,
+              documentId: result.span.documentId,
+              text: result.span.text,
+              relevance: result.relevance,
+              retrievalMode,
+              sourceLocation: result.span.location,
+              metadata: result.span.metadata ? recordToKVArray(result.span.metadata) : void 0
+            });
+          }
+        } catch (e) {
+          await log?.(`Source span search failed for "${subQuestion.question}": ${e}`);
+        }
+      })()
+    );
+  }
+  if (retrievalMode === "graph_only" || retrievalMode === "hybrid" || !sourceRetriever) {
+    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
+                  retrievalMode,
+                  metadata: recordToKVArray(chunk.metadata)
+                });
+              }
+            }
+          } else {
+            const chunks = await memoryStore.search(subQuestion.question, {
+              limit: retrievalLimit
+            });
             for (const chunk of chunks) {
               evidence.push({
                 source: "chunk",
@@ -8893,32 +10239,18 @@ async function retrieve(subQuestion, conversationId, config) {
                 documentId: chunk.documentId,
                 text: chunk.text,
                 relevance: 0.8,
-                // Default — store doesn't expose scores directly
+                retrievalMode,
                 metadata: recordToKVArray(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: recordToKVArray(chunk.metadata)
-            });
-          }
+        } catch (e) {
+          await log?.(`Chunk search failed for "${subQuestion.question}": ${e}`);
         }
-      } catch (e) {
-        await log?.(`Chunk search failed for "${subQuestion.question}": ${e}`);
-      }
-    })()
-  );
-  if (subQuestion.documentFilters) {
+      })()
+    );
+  }
+  if (subQuestion.documentFilters && (retrievalMode === "graph_only" || retrievalMode === "hybrid" || retrievalMode === "long_context")) {
     tasks.push(
       (async () => {
         try {
@@ -8937,6 +10269,7 @@ async function retrieve(subQuestion, conversationId, config) {
               text: summary,
               relevance: 0.9,
               // Direct lookup is high relevance
+              retrievalMode,
               metadata: [
                 { key: "type", value: doc.type },
                 { key: "carrier", value: doc.carrier ?? "" },
@@ -8963,8 +10296,9 @@ async function retrieve(subQuestion, conversationId, config) {
               source: "conversation",
               turnId: turn.id,
               text: `[${turn.role}]: ${turn.content}`,
-              relevance: 0.6
+              relevance: 0.6,
               // Conversation context is lower relevance than documents
+              retrievalMode
             });
           }
         } catch (e) {
@@ -8974,10 +10308,10 @@ async function retrieve(subQuestion, conversationId, config) {
     );
   }
   await Promise.all(tasks);
-  evidence.sort((a, b) => b.relevance - a.relevance);
+  const orderedEvidence = orderSourceEvidence(evidence);
   return {
     subQuestion: subQuestion.question,
-    evidence: evidence.slice(0, retrievalLimit)
+    evidence: orderedEvidence.slice(0, retrievalLimit)
   };
 }
 function buildDocumentSummary(doc) {
@@ -9063,16 +10397,22 @@ Answer the sub-question based on the evidence above. For every factual claim, in
 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}]`;
+    const sourceLabel = e.source === "source_span" ? `[source-span:${e.sourceSpanId}]` : e.source === "chunk" ? `[chunk:${e.chunkId}]` : e.source === "document" ? `[doc:${e.documentId}]` : e.source === "attachment" ? `[attachment:${e.attachmentId}]` : `[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 budget = resolveModelBudget({
+    taskKind: "query_reason",
+    hintTokens: 4096,
+    modelCapabilities: config.modelCapabilities,
+    constraint: config.modelBudgetConstraints?.query_reason
+  });
   const { object, usage } = await withRetry(
     () => generateObject({
       prompt,
       schema: SubAnswerSchema,
-      maxTokens: 4096,
+      maxTokens: budget.maxTokens,
       providerOptions
     })
   );
@@ -9112,49 +10452,41 @@ RESPOND WITH:
 - 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/quality.ts
 function sourceIdForEvidence(evidence) {
-  return evidence.chunkId ?? evidence.documentId ?? evidence.turnId ?? evidence.attachmentId;
+  return evidence.sourceSpanId ?? evidence.chunkId ?? evidence.documentId ?? evidence.turnId ?? evidence.attachmentId;
 }
 function citationSourceId(citation) {
-  return citation.chunkId || citation.documentId;
+  return citation.sourceSpanId || citation.chunkId || citation.documentId;
+}
+function hasGroundingEvidence(evidence) {
+  return evidence.some((item) => item.source === "chunk" || item.source === "source_span");
+}
+function containsQuotedNumericDateOrContractualClaim(text) {
+  const normalized = text.toLowerCase();
+  return /[$€£]\s?\d|\b\d{1,3}(?:,\d{3})*(?:\.\d+)?\s?(?:%|percent|days?|months?|years?)\b/.test(text) || /\b\d{1,2}[/-]\d{1,2}[/-]\d{2,4}\b|\b\d{4}-\d{2}-\d{2}\b/.test(text) || /\b(?:january|february|march|april|may|june|july|august|september|october|november|december)\s+\d{1,2},?\s+\d{4}\b/i.test(text) || /\b(?:shall|must|required|subject to|excluded|exclusion|condition|endorsement|deductible|limit|premium|retention)\b/.test(normalized);
+}
+function deterministicQueryGroundingIssues(subAnswers, evidence) {
+  const issues = [];
+  const evidenceBySource = /* @__PURE__ */ new Map();
+  for (const item of evidence) {
+    const sourceId = sourceIdForEvidence(item);
+    if (!sourceId) continue;
+    evidenceBySource.set(sourceId, [...evidenceBySource.get(sourceId) ?? [], item]);
+  }
+  for (const subAnswer of subAnswers) {
+    if (!subAnswer.needsMoreContext && subAnswer.citations.length === 0 && containsQuotedNumericDateOrContractualClaim(subAnswer.answer)) {
+      issues.push(`Sub-answer "${subAnswer.subQuestion}" contains a numeric, date, or contractual claim without citations.`);
+    }
+    for (const citation of subAnswer.citations) {
+      const sourceId = citationSourceId(citation);
+      const supportedEvidence = sourceId ? evidenceBySource.get(sourceId) ?? [] : [];
+      if (containsQuotedNumericDateOrContractualClaim(citation.quote) && !hasGroundingEvidence(supportedEvidence)) {
+        issues.push(`Citation [${citation.index}] in "${subAnswer.subQuestion}" supports a numeric, date, or contractual claim without chunk or source-span evidence.`);
+      }
+    }
+  }
+  return issues;
 }
 function buildQueryReviewReport(params) {
   const { subAnswers, evidence, finalResult, verifyRounds } = params;
@@ -9207,6 +10539,16 @@ function buildQueryReviewReport(params) {
           sourceId
         });
       }
+      if (containsQuotedNumericDateOrContractualClaim(citation.quote) && !hasGroundingEvidence(supportedEvidence)) {
+        issues.push({
+          code: "citation_claim_lacks_chunk_or_source_span",
+          severity: "blocking",
+          message: `Citation [${citation.index}] in "${subAnswer.subQuestion}" supports a numeric, date, or contractual claim without chunk or source-span evidence.`,
+          subQuestion: subAnswer.subQuestion,
+          citationIndex: citation.index,
+          sourceId
+        });
+      }
     }
   }
   if (finalResult) {
@@ -9218,10 +10560,10 @@ function buildQueryReviewReport(params) {
       });
     }
     const knownCitationIds = new Set(
-      subAnswers.flatMap((sa) => sa.citations.map((citation) => `${citation.index}|${citation.chunkId}|${citation.documentId}`))
+      subAnswers.flatMap((sa) => sa.citations.map((citation) => `${citation.index}|${citation.sourceSpanId ?? ""}|${citation.chunkId ?? ""}|${citation.documentId}`))
     );
     for (const citation of finalResult.citations) {
-      const key = `${citation.index}|${citation.chunkId}|${citation.documentId}`;
+      const key = `${citation.index}|${citation.sourceSpanId ?? ""}|${citation.chunkId ?? ""}|${citation.documentId}`;
       if (!knownCitationIds.has(key)) {
         issues.push({
           code: "final_answer_unknown_citation",
@@ -9255,6 +10597,67 @@ function buildQueryReviewReport(params) {
   };
 }
 
+// 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.sourceSpanId ?? e.chunkId ?? e.documentId ?? e.turnId ?? e.attachmentId,
+      chunkId: e.chunkId,
+      sourceSpanId: e.sourceSpanId,
+      text: e.text.slice(0, 500),
+      // Truncate for context efficiency
+      relevance: e.relevance
+    })),
+    null,
+    2
+  );
+  const prompt = buildVerifyPrompt(originalQuestion, subAnswersJson, evidenceJson);
+  const budget = resolveModelBudget({
+    taskKind: "query_verify",
+    hintTokens: 2048,
+    modelCapabilities: config.modelCapabilities,
+    constraint: config.modelBudgetConstraints?.query_verify
+  });
+  const { object, usage } = await withRetry(
+    () => generateObject({
+      prompt,
+      schema: VerifyResultSchema,
+      maxTokens: budget.maxTokens,
+      providerOptions
+    })
+  );
+  const result = object;
+  const deterministicIssues = deterministicQueryGroundingIssues(subAnswers, allEvidence);
+  if (deterministicIssues.length > 0) {
+    return {
+      result: {
+        ...result,
+        approved: false,
+        issues: Array.from(/* @__PURE__ */ new Set([...result.issues, ...deterministicIssues])),
+        retrySubQuestions: Array.from(/* @__PURE__ */ new Set([
+          ...result.retrySubQuestions ?? [],
+          ...subAnswers.filter((answer) => deterministicIssues.some((issue) => issue.includes(`"${answer.subQuestion}"`))).map((answer) => answer.subQuestion)
+        ]))
+      },
+      usage
+    };
+  }
+  return { result, usage };
+}
+
 // src/prompts/query/interpret-attachment.ts
 function buildInterpretAttachmentPrompt(question, attachment) {
   const attachmentLabel = attachment.name ?? attachment.id ?? "attachment";
@@ -9334,7 +10737,7 @@ ${attachment.text}` : null
   return lines.filter(Boolean).join("\n");
 }
 async function interpretAttachments(params) {
-  const { attachments = [], question, generateObject, providerOptions, log, onUsage } = params;
+  const { attachments = [], question, generateObject, providerOptions, modelCapabilities, modelBudgetConstraints, log, onUsage } = params;
   if (attachments.length === 0) {
     return { evidence: [] };
   }
@@ -9363,12 +10766,18 @@ async function interpretAttachments(params) {
       continue;
     }
     const prompt = buildInterpretAttachmentPrompt(question, attachment);
+    const budget = resolveModelBudget({
+      taskKind: "query_attachment",
+      hintTokens: 2048,
+      modelCapabilities,
+      constraint: modelBudgetConstraints?.query_attachment
+    });
     const { object, usage } = await safeGenerateObject(
       generateObject,
       {
         prompt,
         schema: AttachmentInterpretationSchema,
-        maxTokens: 2048,
+        maxTokens: budget.maxTokens,
         providerOptions: buildAttachmentProviderOptions(attachment, providerOptions)
       },
       {
@@ -9405,10 +10814,19 @@ ${item.text}`).join("\n\n");
 function shouldRetrieveForClassification(classification) {
   return classification.requiresDocumentLookup || classification.requiresChunkSearch;
 }
+function resolveQueryRetrievalMode(params) {
+  const requestedMode = params.inputMode ?? params.configMode ?? params.classificationMode;
+  if (requestedMode) return requestedMode;
+  return params.supportsSourceRetrieval ? "hybrid" : "graph_only";
+}
 function buildInitialQueryWorkflowPlan(params) {
   const { classification, attachmentEvidence } = params;
   const actions = [];
   const shouldRetrieve = shouldRetrieveForClassification(classification);
+  const retrievalMode = params.retrievalMode ?? resolveQueryRetrievalMode({
+    classificationMode: classification.retrievalMode,
+    supportsSourceRetrieval: !!params.supportsSourceRetrieval
+  });
   if (shouldRetrieve) {
     actions.push({
       type: "retrieve",
@@ -9431,7 +10849,7 @@ function buildInitialQueryWorkflowPlan(params) {
       reason: "compose final response"
     }
   );
-  return { actions, shouldRetrieve };
+  return { actions, shouldRetrieve, retrievalMode };
 }
 function getWorkflowAction(plan, type) {
   return plan.actions.find((action) => action.type === type);
@@ -9444,14 +10862,18 @@ function createQueryAgent(config) {
     generateObject,
     documentStore,
     memoryStore,
+    sourceRetriever,
     concurrency = 3,
     maxVerifyRounds = 1,
     retrievalLimit = 10,
+    retrievalMode: configRetrievalMode,
     onTokenUsage,
     onProgress,
     log,
     providerOptions,
-    qualityGate = "warn"
+    qualityGate = "warn",
+    modelCapabilities,
+    modelBudgetConstraints
   } = config;
   const limit = pLimit(concurrency);
   let totalUsage = { inputTokens: 0, outputTokens: 0 };
@@ -9462,6 +10884,14 @@ function createQueryAgent(config) {
       onTokenUsage?.(usage);
     }
   }
+  function resolveBudget(taskKind, hintTokens) {
+    return resolveModelBudget({
+      taskKind,
+      hintTokens,
+      modelCapabilities,
+      constraint: modelBudgetConstraints?.[taskKind]
+    });
+  }
   async function query(input) {
     totalUsage = { inputTokens: 0, outputTokens: 0 };
     const { question, conversationId, context, attachments } = input;
@@ -9474,6 +10904,8 @@ function createQueryAgent(config) {
       question,
       generateObject,
       providerOptions,
+      modelCapabilities,
+      modelBudgetConstraints,
       log,
       onUsage: trackUsage
     });
@@ -9481,13 +10913,26 @@ function createQueryAgent(config) {
     onProgress?.("Classifying query...");
     const classification = await classify(question, conversationId, attachmentContext);
     await pipelineCtx.save("classify", { classification, attachmentEvidence });
+    const effectiveRetrievalMode = resolveQueryRetrievalMode({
+      inputMode: input.retrievalMode,
+      configMode: configRetrievalMode,
+      classificationMode: classification.retrievalMode,
+      supportsSourceRetrieval: !!sourceRetriever
+    });
     const retrieverConfig = {
       documentStore,
       memoryStore,
+      sourceRetriever,
       retrievalLimit,
+      retrievalMode: effectiveRetrievalMode,
       log
     };
-    const workflowPlan = buildInitialQueryWorkflowPlan({ classification, attachmentEvidence });
+    const workflowPlan = buildInitialQueryWorkflowPlan({
+      classification,
+      attachmentEvidence,
+      retrievalMode: effectiveRetrievalMode,
+      supportsSourceRetrieval: !!sourceRetriever
+    });
     const retrieveAction = getWorkflowAction(workflowPlan, "retrieve");
     const reasonAction = getWorkflowAction(workflowPlan, "reason");
     await pipelineCtx.save("workflow", { classification, attachmentEvidence, workflowPlan });
@@ -9502,7 +10947,7 @@ function createQueryAgent(config) {
     const allEvidence = [...attachmentEvidence, ...retrievalResults.flatMap((r) => r.evidence)];
     await pipelineCtx.save("retrieve", { classification, attachmentEvidence, evidence: allEvidence });
     onProgress?.("Reasoning over evidence...");
-    const reasonerConfig = { generateObject, providerOptions };
+    const reasonerConfig = { generateObject, providerOptions, modelCapabilities, modelBudgetConstraints };
     const subQuestionsToReason = reasonAction?.subQuestions ?? classification.subQuestions;
     const reasonResults = await Promise.allSettled(
       subQuestionsToReason.map(
@@ -9537,7 +10982,7 @@ function createQueryAgent(config) {
     }
     await pipelineCtx.save("reason", { classification, attachmentEvidence, evidence: allEvidence, subAnswers });
     onProgress?.("Verifying answer grounding...");
-    const verifierConfig = { generateObject, providerOptions };
+    const verifierConfig = { generateObject, providerOptions, modelCapabilities, modelBudgetConstraints };
     const verifyRounds = [];
     for (let round = 0; round < maxVerifyRounds; round++) {
       const { result: verifyResult, usage } = await safeVerify(
@@ -9663,12 +11108,13 @@ function createQueryAgent(config) {
       }
     }
     const prompt = buildQueryClassifyPrompt(question, conversationContext, attachmentContext);
+    const budget = resolveBudget("query_classify", 2048);
     const { object, usage } = await safeGenerateObject(
       generateObject,
       {
         prompt,
         schema: QueryClassifyResultSchema,
-        maxTokens: 2048,
+        maxTokens: budget.maxTokens,
         providerOptions
       },
       {
@@ -9682,7 +11128,8 @@ function createQueryAgent(config) {
           ],
           requiresDocumentLookup: true,
           requiresChunkSearch: true,
-          requiresConversationHistory: !!conversationId
+          requiresConversationHistory: !!conversationId,
+          retrievalMode: sourceRetriever ? "hybrid" : "graph_only"
         },
         log,
         onError: (err, attempt) => log?.(`Query classify attempt ${attempt + 1} failed: ${err}`)
@@ -9712,12 +11159,13 @@ function createQueryAgent(config) {
       2
     );
     const prompt = buildRespondPrompt(originalQuestion, subAnswersJson, platform);
+    const budget = resolveBudget("query_respond", 4096);
     const { object, usage } = await safeGenerateObject(
       generateObject,
       {
         prompt,
         schema: QueryResultSchema,
-        maxTokens: 4096,
+        maxTokens: budget.maxTokens,
         providerOptions
       },
       {
@@ -9740,6 +11188,673 @@ ${sa.answer}`).join("\n\n"),
   return { query };
 }
 
+// src/pce/index.ts
+import { z as z43 } from "zod";
+
+// src/prompts/pce/index.ts
+function buildPceNormalizePrompt(input) {
+  const evidence = input.evidenceSources.map(
+    (source) => `- ${source.id}${source.label ? ` (${source.label})` : ""}: ${source.text.slice(0, 1200)}`
+  ).join("\n");
+  return [
+    "Normalize this policy change endorsement request into atomic change items.",
+    "Use beforeValue only when the existing value is explicitly quoted in the provided evidence.",
+    "Every beforeValue must include a citation with sourceId and exact quote.",
+    "Ask missing-info questions for required details that are absent.",
+    "",
+    `Request:
+${input.requestText}`,
+    "",
+    `Evidence:
+${evidence || "(none provided)"}`
+  ].join("\n");
+}
+function buildPceReplyPrompt(input) {
+  return [
+    "Map this reply to the open missing-info questions.",
+    "Return concise answers only for questions that are directly answered.",
+    "",
+    `Reply:
+${input.replyText}`,
+    "",
+    `Open questions:
+${input.openQuestions.map((question) => `- ${question.id}${question.fieldPath ? ` (${question.fieldPath})` : ""}: ${question.question}`).join("\n")}`
+  ].join("\n");
+}
+
+// src/pce/index.ts
+var ReplyAnswersSchema = z43.object({
+  answers: z43.array(z43.object({
+    questionId: z43.string().optional(),
+    fieldPath: z43.string().optional(),
+    answer: z43.string()
+  }))
+});
+function createPceAgent(config = {}) {
+  const now = config.now ?? Date.now;
+  let tokenUsage = { inputTokens: 0, outputTokens: 0 };
+  const cases = /* @__PURE__ */ new Map();
+  function trackUsage(usage) {
+    if (!usage) return;
+    tokenUsage.inputTokens += usage.inputTokens;
+    tokenUsage.outputTokens += usage.outputTokens;
+    config.onTokenUsage?.(usage);
+  }
+  function resolveBudget(taskKind, hintTokens) {
+    return resolveModelBudget({
+      taskKind,
+      hintTokens,
+      modelCapabilities: config.modelCapabilities,
+      constraint: config.modelBudgetConstraints?.[taskKind]
+    });
+  }
+  async function processChangeRequest(input) {
+    tokenUsage = { inputTokens: 0, outputTokens: 0 };
+    const evidenceSources = await collectPceEvidenceSources(input, config);
+    const fallback = heuristicNormalize(input.requestText, evidenceSources);
+    let normalized = fallback;
+    if (config.generateObject) {
+      const budget = resolveBudget("pce_impact_analysis", 2500);
+      const result = await safeGenerateObject(
+        config.generateObject,
+        {
+          prompt: buildPceNormalizePrompt({ requestText: input.requestText, evidenceSources }),
+          schema: PceNormalizationResultSchema,
+          maxTokens: budget.maxTokens,
+          providerOptions: config.providerOptions
+        },
+        { fallback, maxRetries: 1, log: config.log }
+      );
+      normalized = PceNormalizationResultSchema.parse(result.object);
+      trackUsage(result.usage);
+    }
+    const createdAt = now();
+    const items = normalized.items.map((item) => finalizeItem(item, input.requestText));
+    const missingInfoQuestions = normalized.missingInfoQuestions.map((question) => {
+      const itemId = question.itemId ?? items.find((item) => item.fieldPath === question.fieldPath)?.id;
+      return {
+        ...question,
+        itemId,
+        id: question.id ?? stableCaseId("question", [itemId, question.fieldPath, question.question])
+      };
+    });
+    const validationIssues = validatePceItems(items, evidenceSources);
+    const impacts = buildPolicyChangeImpacts(items, evidenceSources);
+    const executionMode = selectPceExecutionMode({
+      requestedMode: input.executionMode ?? config.executionMode,
+      requestText: input.requestText,
+      items,
+      impacts,
+      evidenceSources,
+      validationIssues,
+      missingInfoQuestions
+    });
+    const state = {
+      id: input.caseId ?? stableCaseId("pce", [input.requestText, evidenceSources.map((source) => source.id)]),
+      requestText: input.requestText,
+      summary: normalized.summary || summarizeItems(items),
+      executionMode,
+      items,
+      impacts,
+      evidenceSources,
+      validationIssues,
+      missingInfoQuestions,
+      createdAt,
+      updatedAt: createdAt
+    };
+    cases.set(state.id, state);
+    return { state, tokenUsage };
+  }
+  async function processReply2(input) {
+    tokenUsage = { inputTokens: 0, outputTokens: 0 };
+    let answers = heuristicParseAnswers(
+      input.replyText,
+      input.state.missingInfoQuestions
+    );
+    if (config.generateObject && input.state.missingInfoQuestions.some((question) => !question.answer)) {
+      const budget = resolveBudget("pce_reply_parse", 1e3);
+      const result = await safeGenerateObject(
+        config.generateObject,
+        {
+          prompt: buildPceReplyPrompt({
+            replyText: input.replyText,
+            openQuestions: input.state.missingInfoQuestions.filter((question) => !question.answer).map(({ id, question, fieldPath }) => ({ id, question, fieldPath }))
+          }),
+          schema: ReplyAnswersSchema,
+          maxTokens: budget.maxTokens,
+          providerOptions: config.providerOptions
+        },
+        { fallback: { answers }, maxRetries: 1, log: config.log }
+      );
+      answers = ReplyAnswersSchema.parse(result.object).answers;
+      trackUsage(result.usage);
+    }
+    const merged = mergeQuestionAnswers(input.state.missingInfoQuestions, answers);
+    const items = applyMissingInfoAnswers(input.state.items, merged.questions);
+    const validationIssues = validatePceItems(items, input.state.evidenceSources);
+    const impacts = buildPolicyChangeImpacts(items, input.state.evidenceSources);
+    const executionMode = selectPceExecutionMode({
+      requestedMode: config.executionMode,
+      requestText: input.state.requestText,
+      items,
+      impacts,
+      evidenceSources: input.state.evidenceSources,
+      validationIssues,
+      missingInfoQuestions: merged.questions
+    });
+    const state = {
+      ...input.state,
+      executionMode,
+      items,
+      impacts,
+      validationIssues,
+      missingInfoQuestions: merged.questions,
+      updatedAt: now()
+    };
+    cases.set(state.id, state);
+    return { state, answersMerged: merged.answeredCount, tokenUsage };
+  }
+  function generateSubmissionPacket(input) {
+    const state = typeof input === "string" ? cases.get(input) : input.state;
+    if (!state) {
+      throw new Error(`Policy change case ${String(input)} not found`);
+    }
+    return buildPceSubmissionPacket(state, now());
+  }
+  return { processChangeRequest, processReply: processReply2, generateSubmissionPacket };
+}
+function applyMissingInfoAnswers(items, questions) {
+  return items.map((item) => {
+    const answers = questions.filter(
+      (question) => question.answer?.trim() && (question.itemId === item.id || !question.itemId && question.fieldPath === item.fieldPath)
+    );
+    if (answers.length === 0) return item;
+    const answer = answers[answers.length - 1].answer.trim();
+    return {
+      ...item,
+      afterValue: item.afterValue ?? answer,
+      requestedValue: item.requestedValue ?? answer,
+      status: item.status === "needs_info" ? "ready" : item.status,
+      userSourceSpanIds: item.userSourceSpanIds ?? []
+    };
+  });
+}
+async function collectPceEvidenceSources(input, config) {
+  const provided = input.evidenceSources ?? [];
+  if (!config?.sourceRetriever) return provided;
+  try {
+    const results = await config.sourceRetriever.searchSourceSpans({
+      question: input.requestText,
+      limit: config.retrievalLimit ?? 8,
+      mode: "hybrid"
+    });
+    const retrieved = results.map((result) => ({
+      id: result.span.id,
+      label: result.span.formNumber ?? result.span.sectionId ?? result.span.sourceKind,
+      documentId: result.span.documentId,
+      page: result.span.pageStart ?? result.span.location?.page,
+      fieldPath: result.span.sectionId ?? result.span.location?.fieldPath,
+      text: result.span.text,
+      metadata: {
+        ...result.span.metadata,
+        relevance: String(result.relevance),
+        sourceKind: result.span.sourceKind ?? result.span.kind
+      }
+    }));
+    return dedupeEvidenceSources([...provided, ...retrieved]);
+  } catch (error) {
+    await config.log?.(`PCE source evidence retrieval failed: ${error}`);
+    return provided;
+  }
+}
+function stablePolicyChangeItemId(item) {
+  return stableCaseId("pci", [
+    item.affectedPolicyId,
+    item.kind,
+    item.fieldPath,
+    item.afterValue ?? item.requestedValue ?? "",
+    item.sourceSpanIds?.join("|") ?? ""
+  ]);
+}
+function validatePceItems(items, sources) {
+  return items.flatMap((item) => {
+    const issues = [];
+    const citation = firstCitationForValue(item.citations, item.beforeValue);
+    issues.push(...validateQuotedEvidence({
+      itemId: item.id,
+      fieldPath: `${item.fieldPath}.beforeValue`,
+      quote: item.beforeValue,
+      citation,
+      sources
+    }));
+    if (item.beforeValue?.trim() && item.sourceSpanIds.length === 0 && item.sourceIds.length === 0) {
+      issues.push({
+        code: "existing_value_missing_source_span",
+        severity: "blocking",
+        message: `Existing value for ${item.fieldPath} is missing source span evidence.`,
+        itemId: item.id,
+        fieldPath: item.fieldPath
+      });
+    }
+    if (item.status === "needs_info" || !item.afterValue?.trim() && !item.requestedValue?.trim() && item.action !== "remove") {
+      issues.push({
+        code: "required_value_missing",
+        severity: "blocking",
+        message: `Requested value for ${item.fieldPath} is missing.`,
+        itemId: item.id,
+        fieldPath: item.fieldPath
+      });
+    }
+    if (item.kind === "coverage_change" && item.action !== "add" && item.sourceSpanIds.length === 0 && item.sourceIds.length === 0) {
+      issues.push({
+        code: "coverage_source_missing",
+        severity: "blocking",
+        message: `Coverage change for ${item.fieldPath} is not linked to existing coverage evidence.`,
+        itemId: item.id,
+        fieldPath: item.fieldPath
+      });
+    }
+    const effectiveDateIssue = validateEffectiveDate(item, sources);
+    if (effectiveDateIssue) issues.push(effectiveDateIssue);
+    const endorsementConflict = findEndorsementConflict(item, sources);
+    if (endorsementConflict) issues.push(endorsementConflict);
+    if ((item.kind === "cancellation" || item.kind === "nonrenewal") && (!item.effectiveDate || item.sourceSpanIds.length === 0)) {
+      issues.push({
+        code: "notice_rule_ambiguous",
+        severity: "blocking",
+        message: `${item.kind} request needs an effective date and source-backed notice/timing terms.`,
+        itemId: item.id,
+        fieldPath: item.fieldPath
+      });
+    }
+    if (item.kind === "certificate_endorsement_request" && !hasCertificateRequirementDetails(item)) {
+      issues.push({
+        code: "certificate_details_missing",
+        severity: "blocking",
+        message: "Certificate-driven endorsement request is missing holder or requirement details.",
+        itemId: item.id,
+        fieldPath: item.fieldPath
+      });
+    }
+    return dedupeValidationIssues(issues);
+  });
+}
+function buildPolicyChangeImpacts(items, sources) {
+  return items.map((item) => {
+    const citedSources = sources.filter((source) => item.sourceSpanIds.includes(source.id) || item.sourceIds.includes(source.id));
+    return {
+      itemId: item.id,
+      beforeValue: item.beforeValue,
+      requestedValue: item.requestedValue ?? item.afterValue,
+      likelyEndorsementRequired: item.kind !== "renewal_submission_update",
+      carrierApprovalLikelyRequired: item.kind !== "certificate_endorsement_request",
+      affectedCoverageForms: Array.from(new Set(
+        citedSources.map((source) => source.metadata?.formNumber ?? source.label).filter((value) => !!value)
+      )).sort(),
+      sourceSpanIds: Array.from(/* @__PURE__ */ new Set([...item.sourceSpanIds, ...item.sourceIds])).sort()
+    };
+  });
+}
+function selectPceExecutionMode(params) {
+  if (params.requestedMode && params.requestedMode !== "auto") {
+    return params.requestedMode;
+  }
+  if (params.validationIssues.some((issue) => issue.severity === "blocking")) {
+    return "hybrid";
+  }
+  if (hasConflictingEvidence(params.evidenceSources)) {
+    return "hybrid";
+  }
+  if (hasAmbiguousCancellationOrNonrenewal(params.requestText, params.items)) {
+    return "hybrid";
+  }
+  if (hasUnclearCertificateRequest(params.items, params.missingInfoQuestions ?? [])) {
+    return "hybrid";
+  }
+  if (hasMultiFormFinancialChange(params.items, params.impacts)) {
+    return "market_eval";
+  }
+  return "deterministic_tree";
+}
+function finalizeItem(item, requestText) {
+  const status = item.status ?? (!item.afterValue && item.action !== "remove" ? "needs_info" : "ready");
+  const citations = item.citations ?? [];
+  const sourceSpanIds = item.sourceSpanIds?.length ? item.sourceSpanIds : inferSourceIds(citations);
+  const afterValue = item.afterValue ?? item.requestedValue;
+  return {
+    ...item,
+    kind: item.kind ?? inferChangeKind(item.fieldPath, requestText),
+    affectedPolicyId: item.affectedPolicyId ?? "unknown",
+    afterValue,
+    requestedValue: item.requestedValue ?? afterValue,
+    sourceSpanIds,
+    userSourceSpanIds: item.userSourceSpanIds ?? [],
+    id: item.id ?? stablePolicyChangeItemId({
+      ...item,
+      kind: item.kind ?? inferChangeKind(item.fieldPath, requestText),
+      affectedPolicyId: item.affectedPolicyId ?? "unknown",
+      afterValue,
+      requestedValue: item.requestedValue ?? afterValue,
+      sourceSpanIds
+    }),
+    label: item.label || item.fieldPath,
+    sourceIds: item.sourceIds ?? sourceSpanIds,
+    citations,
+    confidence: item.confidence ?? (requestText.length > 0 ? "medium" : "low"),
+    confidenceScore: item.confidenceScore ?? (requestText.length > 0 ? 0.6 : 0.3),
+    status
+  };
+}
+function firstCitationForValue(citations, value) {
+  if (!value) return void 0;
+  return citations.find((citation) => citation.quote.trim() === value.trim()) ?? citations[0];
+}
+function inferSourceIds(citations) {
+  return Array.from(new Set(citations.map((citation) => citation.sourceId))).sort();
+}
+function dedupeEvidenceSources(sources) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const source of sources) {
+    byId.set(source.id, source);
+  }
+  return [...byId.values()].sort((left, right) => left.id.localeCompare(right.id));
+}
+function hasConflictingEvidence(sources) {
+  const signaturesByKey = /* @__PURE__ */ new Map();
+  for (const source of sources) {
+    const key = normalizeEvidenceConflictKey(source);
+    if (!key) continue;
+    const values = extractComparableEvidenceValues(source.text);
+    if (values.length === 0) continue;
+    const existing = signaturesByKey.get(key) ?? /* @__PURE__ */ new Set();
+    existing.add(values.sort().join("|"));
+    signaturesByKey.set(key, existing);
+    if (existing.size > 1) return true;
+  }
+  return false;
+}
+function normalizeEvidenceConflictKey(source) {
+  const fieldPath = source.fieldPath ?? source.metadata?.fieldPath;
+  const formNumber = source.metadata?.formNumber;
+  const key = fieldPath ? `${fieldPath}:${formNumber ?? "default"}` : source.label;
+  return key?.replace(/\s+/g, " ").trim().toLowerCase();
+}
+function extractComparableEvidenceValues(text) {
+  const values = /* @__PURE__ */ new Set();
+  for (const match of text.matchAll(/\$?\b\d{1,3}(?:,\d{3})*(?:\.\d+)?\b%?/g)) {
+    values.add(match[0].replace(/[$,%\s]/g, ""));
+  }
+  for (const match of text.matchAll(/\b\d{1,2}[/-]\d{1,2}[/-]\d{2,4}\b/g)) {
+    values.add(match[0]);
+  }
+  return [...values].filter((value) => value.length > 0);
+}
+function hasAmbiguousCancellationOrNonrenewal(requestText, items) {
+  const hasCancellationAction = items.some((item) => item.kind === "cancellation" || item.kind === "nonrenewal");
+  if (!hasCancellationAction) return false;
+  return /\b(if|unless|maybe|possibly|unsure|unclear|or|pending|conditional)\b/i.test(requestText);
+}
+function hasUnclearCertificateRequest(items, missingInfoQuestions) {
+  return items.some(
+    (item) => item.kind === "certificate_endorsement_request" && (item.status === "needs_info" || !item.afterValue?.trim() || item.confidence === "low" || item.sourceSpanIds.length === 0 || missingInfoQuestions.some((question) => question.itemId === item.id || question.fieldPath === item.fieldPath))
+  );
+}
+function hasMultiFormFinancialChange(items, impacts) {
+  const financialItemIds = new Set(items.filter((item) => item.kind === "limit_change" || item.kind === "deductible_change").map((item) => item.id));
+  return impacts.some(
+    (impact) => financialItemIds.has(impact.itemId) && (impact.affectedCoverageForms.length > 1 || impact.sourceSpanIds.length > 1)
+  );
+}
+function validateEffectiveDate(item, sources) {
+  if (!item.effectiveDate) return void 0;
+  const requestedDate = parseDateValue(item.effectiveDate);
+  if (!requestedDate) {
+    return {
+      code: "effective_date_unparseable",
+      severity: "warning",
+      message: `Requested effective date ${item.effectiveDate} could not be parsed.`,
+      itemId: item.id,
+      fieldPath: "effectiveDate"
+    };
+  }
+  const period = findPolicyPeriod(sources);
+  if (!period) return void 0;
+  if (requestedDate < period.start || requestedDate > period.end) {
+    return {
+      code: "effective_date_outside_policy_period",
+      severity: "blocking",
+      message: `Requested effective date ${item.effectiveDate} is outside the cited policy period.`,
+      itemId: item.id,
+      fieldPath: "effectiveDate",
+      sourceId: period.sourceId
+    };
+  }
+  return void 0;
+}
+function findPolicyPeriod(sources) {
+  for (const source of sources) {
+    const metadataStart = source.metadata?.policyEffectiveDate ?? source.metadata?.policyStartDate;
+    const metadataEnd = source.metadata?.policyExpirationDate ?? source.metadata?.policyEndDate;
+    const start = metadataStart ? parseDateValue(metadataStart) : void 0;
+    const end = metadataEnd ? parseDateValue(metadataEnd) : void 0;
+    if (start && end) return { start, end, sourceId: source.id };
+    const textPeriod = source.text.match(/\b(?:policy\s+period|effective)\b[^.\n]*?(\d{1,2}[/-]\d{1,2}[/-]\d{2,4})\s*(?:to|-|through)\s*(\d{1,2}[/-]\d{1,2}[/-]\d{2,4})/i);
+    const textStart = textPeriod?.[1] ? parseDateValue(textPeriod[1]) : void 0;
+    const textEnd = textPeriod?.[2] ? parseDateValue(textPeriod[2]) : void 0;
+    if (textStart && textEnd) return { start: textStart, end: textEnd, sourceId: source.id };
+  }
+  return void 0;
+}
+function parseDateValue(value) {
+  const numeric = value.match(/^(\d{1,2})[/-](\d{1,2})[/-](\d{2}|\d{4})$/);
+  if (!numeric) return void 0;
+  const month = Number(numeric[1]);
+  const day = Number(numeric[2]);
+  const rawYear = Number(numeric[3]);
+  const year = rawYear < 100 ? 2e3 + rawYear : rawYear;
+  if (month < 1 || month > 12 || day < 1 || day > 31) return void 0;
+  return Date.UTC(year, month - 1, day);
+}
+function findEndorsementConflict(item, sources) {
+  const linkedSources = sources.filter((source) => item.sourceSpanIds.includes(source.id) || item.sourceIds.includes(source.id));
+  const conflictSource = linkedSources.find(
+    (source) => /\bendorsement\b/i.test(`${source.label ?? ""} ${source.text}`) && /\b(excludes|exclusion|prohibits|not\s+covered|no\s+coverage|must\s+not)\b/i.test(source.text)
+  );
+  if (!conflictSource) return void 0;
+  return {
+    code: "endorsement_conflict",
+    severity: "blocking",
+    message: `Existing endorsement source ${conflictSource.id} may conflict with the requested change.`,
+    itemId: item.id,
+    fieldPath: item.fieldPath,
+    sourceId: conflictSource.id
+  };
+}
+function hasCertificateRequirementDetails(item) {
+  const text = `${item.label} ${item.afterValue ?? ""} ${item.requestedValue ?? ""} ${item.reason ?? ""}`.toLowerCase();
+  const hasHolder = /\b(holder|certificate holder|additional insured|loss payee|lender|landlord)\b/.test(text);
+  const hasRequirement = /\b(primary|non[- ]?contributory|waiver|subrogation|notice|endorsement|requirement|wording)\b/.test(text);
+  return hasHolder && hasRequirement;
+}
+function dedupeValidationIssues(issues) {
+  const seen = /* @__PURE__ */ new Set();
+  return issues.filter((issue) => {
+    const key = `${issue.code}:${issue.itemId ?? ""}:${issue.fieldPath ?? ""}:${issue.sourceId ?? ""}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+function heuristicNormalize(requestText, evidenceSources) {
+  const lower = requestText.toLowerCase();
+  const action = lower.includes("remove") || lower.includes("delete") ? "remove" : lower.includes("add") ? "add" : "update";
+  const effectiveDate = requestText.match(/\b\d{1,2}[/-]\d{1,2}[/-]\d{2,4}\b/)?.[0];
+  const label = requestText.split(/[.;\n]/)[0]?.trim() || "Policy change";
+  const quoted = Array.from(requestText.matchAll(/"([^"]+)"/g)).map((match) => match[1]);
+  const beforeValue = quoted.find(
+    (quote) => evidenceSources.some((source) => source.text.toLowerCase().includes(quote.toLowerCase()))
+  );
+  const citationSource = beforeValue ? evidenceSources.find((source) => source.text.toLowerCase().includes(beforeValue.toLowerCase())) : void 0;
+  const result = {
+    summary: label,
+    items: [{
+      action,
+      kind: inferChangeKind(inferFieldPath(requestText), requestText),
+      affectedPolicyId: evidenceSources.find((source) => source.documentId)?.documentId ?? "unknown",
+      fieldPath: inferFieldPath(requestText),
+      label,
+      beforeValue,
+      afterValue: inferAfterValue(requestText, beforeValue),
+      requestedValue: inferAfterValue(requestText, beforeValue),
+      effectiveDate,
+      reason: void 0,
+      sourceIds: citationSource ? [citationSource.id] : [],
+      sourceSpanIds: citationSource ? [citationSource.id] : [],
+      citations: beforeValue && citationSource ? [{
+        sourceId: citationSource.id,
+        quote: beforeValue,
+        page: citationSource.page,
+        fieldPath: citationSource.fieldPath
+      }] : [],
+      confidence: "low",
+      confidenceScore: 0.45
+    }],
+    missingInfoQuestions: inferAfterValue(requestText, beforeValue) ? [] : [{
+      fieldPath: inferFieldPath(requestText),
+      question: "What new value should the carrier endorse for this change?",
+      reason: "The request did not include a clear target value."
+    }]
+  };
+  return result;
+}
+function inferChangeKind(fieldPath, requestText) {
+  const lower = `${fieldPath} ${requestText}`.toLowerCase();
+  if (lower.includes("additional insured")) return "additional_insured_change";
+  if (lower.includes("named insured")) return "named_insured_change";
+  if (lower.includes("limit")) return "limit_change";
+  if (lower.includes("deductible")) return "deductible_change";
+  if (lower.includes("location") || lower.includes("address")) return "location_change";
+  if (lower.includes("vehicle") || lower.includes("auto")) return "vehicle_change";
+  if (lower.includes("certificate") || lower.includes("holder")) return "certificate_endorsement_request";
+  if (lower.includes("cancel")) return "cancellation";
+  if (lower.includes("nonrenew")) return "nonrenewal";
+  if (lower.includes("renewal") || lower.includes("submission")) return "renewal_submission_update";
+  if (lower.includes("coverage")) return "coverage_change";
+  return "general_endorsement";
+}
+function inferFieldPath(requestText) {
+  const lower = requestText.toLowerCase();
+  if (lower.includes("address")) return "insured.address";
+  if (lower.includes("vehicle")) return "auto.vehicles";
+  if (lower.includes("driver")) return "auto.drivers";
+  if (lower.includes("limit")) return "coverage.limit";
+  if (lower.includes("deductible")) return "coverage.deductible";
+  return "policy.change";
+}
+function inferAfterValue(requestText, beforeValue) {
+  const toMatch = requestText.match(/\bto\s+([^.;\n]+)/i)?.[1]?.trim();
+  if (toMatch && toMatch !== beforeValue) return toMatch.replace(/^"|"$/g, "");
+  const fromToMatch = requestText.match(/\bfrom\s+(.+?)\s+to\s+([^.;\n]+)/i)?.[2]?.trim();
+  return fromToMatch?.replace(/^"|"$/g, "");
+}
+function heuristicParseAnswers(replyText, questions) {
+  const unanswered = questions.filter((question) => !question.answer);
+  if (unanswered.length !== 1 || !replyText.trim()) return [];
+  return [{ questionId: unanswered[0].id, answer: replyText.trim() }];
+}
+function summarizeItems(items) {
+  return items.map((item) => `${item.action} ${item.label}`).join("; ");
+}
+function buildPceSubmissionPacket(state, createdAt) {
+  const citations = uniqueCitations(state.items.flatMap((item) => item.citations));
+  const readyItems = state.items.filter((item) => item.status === "ready");
+  const openQuestions = state.missingInfoQuestions.filter((question) => !question.answer);
+  const artifacts = [
+    {
+      id: stableCaseId("artifact", [state.id, "underwriter_summary"]),
+      kind: "underwriter_summary",
+      title: "Underwriter summary",
+      content: [
+        state.summary,
+        "",
+        ...state.items.map((item) => `- ${item.action.toUpperCase()} ${item.label}: ${item.beforeValue ?? "(not cited)"} -> ${item.afterValue ?? "(pending)"}`),
+        "",
+        "Impact analysis:",
+        ...state.impacts.map((impact) => `- ${impact.itemId}: endorsement=${impact.likelyEndorsementRequired ? "likely" : "not expected"}, carrierApproval=${impact.carrierApprovalLikelyRequired ? "likely" : "not expected"}`)
+      ].join("\n"),
+      citations
+    },
+    {
+      id: stableCaseId("artifact", [state.id, "carrier_email"]),
+      kind: "carrier_email",
+      title: "Carrier email",
+      content: [
+        "Please process the following policy change endorsement request:",
+        "",
+        ...readyItems.map((item) => `- ${item.label}: ${item.afterValue ?? item.action}`)
+      ].join("\n"),
+      citations
+    },
+    {
+      id: stableCaseId("artifact", [state.id, "missing_info_request"]),
+      kind: "missing_info_request",
+      title: "Missing information request",
+      content: openQuestions.length ? openQuestions.map((question) => `- ${question.question}`).join("\n") : "No missing information questions are open.",
+      citations: []
+    },
+    {
+      id: stableCaseId("artifact", [state.id, "json_packet"]),
+      kind: "json_packet",
+      title: "JSON packet",
+      content: JSON.stringify({ caseId: state.id, items: state.items, impacts: state.impacts, evidenceSourceIds: state.evidenceSources.map((source) => source.id) }, null, 2),
+      citations
+    },
+    {
+      id: stableCaseId("artifact", [state.id, "validation_report"]),
+      kind: "validation_report",
+      title: "Validation report",
+      content: state.validationIssues.length ? state.validationIssues.map((issue) => `- [${issue.severity}] ${issue.code}: ${issue.message}`).join("\n") : "No validation issues.",
+      citations: []
+    }
+  ];
+  return {
+    id: stableCaseId("packet", [state.id, state.updatedAt, state.items.map((item) => item.id)]),
+    caseId: state.id,
+    pceCase: state,
+    artifacts,
+    validationIssues: state.validationIssues,
+    missingInfoQuestions: state.missingInfoQuestions,
+    createdAt
+  };
+}
+function uniqueCitations(citations) {
+  const seen = /* @__PURE__ */ new Set();
+  return citations.filter((citation) => {
+    const key = `${citation.sourceId}:${citation.quote}:${citation.page ?? ""}:${citation.fieldPath ?? ""}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+
+// src/pce/quality.ts
+function buildPceQualityReport(state) {
+  const blockingIssues = state.validationIssues.filter((issue) => issue.severity === "blocking").length;
+  const warningIssues = state.validationIssues.filter((issue) => issue.severity === "warning").length;
+  const missingInfoCount = state.missingInfoQuestions.filter((question) => !question.answer?.trim()).length;
+  const ungroundedExistingValueCount = state.items.filter(
+    (item) => item.beforeValue?.trim() && item.sourceSpanIds.length === 0
+  ).length;
+  const qualityGateStatus = blockingIssues > 0 || ungroundedExistingValueCount > 0 ? "failed" : warningIssues > 0 || missingInfoCount > 0 ? "warning" : "passed";
+  return {
+    qualityGateStatus,
+    blockingIssues,
+    warningIssues,
+    missingInfoCount,
+    ungroundedExistingValueCount
+  };
+}
+
 // src/prompts/intent.ts
 function buildClassifyMessagePrompt(platform) {
   const platformFields = {
@@ -9868,6 +11983,7 @@ export {
   AcroFormMappingSchema,
   AddressSchema,
   AdmittedStatusSchema,
+  AgenticExecutionModeSchema,
   AnswerParsingResultSchema,
   ApplicationClassifyResultSchema,
   ApplicationEmailReviewSchema,
@@ -9894,6 +12010,15 @@ export {
   COVERAGE_COMPARISON_TOOL,
   COVERAGE_FORMS,
   COVERAGE_TRIGGERS,
+  CaseActionSchema,
+  CaseCitationSchema,
+  CaseEvidenceSourceSchema,
+  CasePacketArtifactKindSchema,
+  CasePacketArtifactSchema,
+  CaseProposalSchema,
+  CaseProposalScoreSchema,
+  CaseSubmissionPacketSchema,
+  CaseValidationIssueSchema,
   ChunkTypeSchema,
   CitationSchema,
   ClaimRecordSchema,
@@ -9975,6 +12100,8 @@ export {
   LookupRequestSchema,
   LossSettlementSchema,
   LossSummarySchema,
+  MemorySourceStore,
+  MissingInfoQuestionSchema,
   NamedInsuredSchema,
   PERSONAL_AUTO_USAGES,
   PET_SPECIES,
@@ -9985,6 +12112,9 @@ export {
   ParsedAnswerSchema,
   PaymentInstallmentSchema,
   PaymentPlanSchema,
+  PceCaseStateSchema,
+  PceNormalizationResultSchema,
+  PceSubmissionPacketSchema,
   PersonalArticlesDeclarationsSchema,
   PersonalAutoDeclarationsSchema,
   PersonalAutoUsageSchema,
@@ -9993,6 +12123,13 @@ export {
   PetDeclarationsSchema,
   PetSpeciesSchema,
   PlatformSchema,
+  PolicyChangeActionSchema,
+  PolicyChangeConfidenceSchema,
+  PolicyChangeImpactSchema,
+  PolicyChangeItemSchema,
+  PolicyChangeKindSchema,
+  PolicyChangeRequestSchema,
+  PolicyChangeStatusSchema,
   PolicyConditionSchema,
   PolicyDocumentSchema,
   PolicySectionTypeSchema,
@@ -10007,6 +12144,7 @@ export {
   QueryClassifyResultSchema,
   QueryIntentSchema,
   QueryResultSchema,
+  QueryRetrievalModeSchema,
   QuestionBatchResultSchema,
   QuoteDocumentSchema,
   QuoteSectionTypeSchema,
@@ -10025,6 +12163,13 @@ export {
   ScheduledItemCategorySchema,
   SectionSchema,
   SharedLimitSchema,
+  SourceChunkSchema,
+  SourceKindSchema,
+  SourceSpanBBoxSchema,
+  SourceSpanKindSchema,
+  SourceSpanLocationSchema,
+  SourceSpanRefSchema,
+  SourceSpanSchema,
   SubAnswerSchema,
   SubQuestionSchema,
   SubjectivityCategorySchema,
@@ -10040,6 +12185,7 @@ export {
   UnderwritingConditionSchema,
   VALUATION_METHODS,
   VEHICLE_COVERAGE_TYPES,
+  ValidationIssueSeveritySchema,
   ValuationMethodSchema,
   VehicleCoverageSchema,
   VehicleCoverageTypeSchema,
@@ -10064,6 +12210,11 @@ export {
   buildIntentPrompt,
   buildInterpretAttachmentPrompt,
   buildLookupFillPrompt,
+  buildPageSourceSpans,
+  buildPceNormalizePrompt,
+  buildPceQualityReport,
+  buildPceReplyPrompt,
+  buildPceSubmissionPacket,
   buildPdfProviderOptions,
   buildQueryClassifyPrompt,
   buildQuestionBatchPrompt,
@@ -10072,28 +12223,54 @@ export {
   buildReplyIntentClassificationPrompt,
   buildRespondPrompt,
   buildSafetyPrompt,
+  buildSectionSourceSpans,
+  buildSourceSpan,
+  buildSourceSpanId,
+  buildTextSourceSpans,
   buildVerifyPrompt,
   chunkDocument,
+  chunkSourceSpans,
+  collectPceEvidenceSources,
+  compareSourceEvidence,
   createApplicationPipeline,
   createExtractor,
+  createPceAgent,
   createPipelineContext,
   createQueryAgent,
+  evaluateCaseProposals,
+  evidenceContainsQuote,
   extractPageRange,
   fillAcroForm,
+  generateNextMessage,
   getAcroFormFields,
   getExtractor,
   getFileIdentifier,
   getPdfPageCount,
   getTemplate,
   isFileReference,
+  mergeQuestionAnswers,
+  normalizeForMatch,
+  orderSourceEvidence,
   overlayTextOnPdf,
   pLimit,
   pdfInputToBase64,
   pdfInputToBytes,
+  processReply,
+  resolveModelBudget,
   safeGenerateObject,
   sanitizeNulls,
+  scoreCaseProposal,
+  selectPceExecutionMode,
+  sourceSpanTextHash,
+  stableCaseId,
+  stableHash2 as stableHash,
+  stablePolicyChangeItemId,
+  stableStringify,
   stripFences,
   toStrictSchema,
+  validateEvidence,
+  validatePceItems,
+  validateQuotedEvidence,
   withRetry
 };
 //# sourceMappingURL=index.mjs.map