@agwab/pi-workflow 0.1.2 → 0.2.1

package/workflows/deep-research/helpers/claim-evidence-gate.mjs

@@ -50,8 +50,11 @@ function collectUrls(value, urls = new Set()) {
 }
 
 function looksLikeLocalSourceRef(value) {
-	const text = String(value ?? "").trim();
-	return /^(?:\.?[\w.-]+\/)?[\w./-]+\.(?:md|json|ya?ml|ts|tsx|js|mjs|cjs|py|go|rs|zig|txt)$/i.test(
+	const text = String(value ?? "")
+		.trim()
+		.replace(/^(?:file|repo):/i, "")
+		.replace(/#L\d+(?:-L?\d+)?$/i, "");
+	return /^(?:\.?[\w.-]+\/)?[\w./-]+\.(?:md|json|ya?ml|ts|tsx|js|mjs|cjs|py|go|rs|zig|txt|sol|java|kt|swift|rb|php|c|cc|cpp|h|hpp)$/i.test(
 		text,
 	);
 }
@@ -60,9 +63,19 @@ function collectEvidenceRefs(claim) {
 	const refs = new Set([...collectUrls(claim)]);
 	for (const row of Array.isArray(claim?.evidence) ? claim.evidence : []) {
 		if (!row || typeof row !== "object") continue;
-		for (const value of [row.url, row.source, row.file, row.path, row.sourceRef]) {
+		for (const value of [
+			row.url,
+			row.source,
+			row.file,
+			row.path,
+			row.sourceRef,
+		]) {
 			if (typeof value !== "string") continue;
-			if (/^https?:\/\//i.test(value) || isWorkflowSourceRef(value) || looksLikeLocalSourceRef(value))
+			if (
+				/^https?:\/\//i.test(value) ||
+				isWorkflowSourceRef(value) ||
+				looksLikeLocalSourceRef(value)
+			)
 				refs.add(value.trim());
 		}
 	}
@@ -71,7 +84,8 @@ function collectEvidenceRefs(claim) {
 
 function collectWorkflowSourceRefs(value, refs = new Set()) {
 	if (typeof value === "string") {
-		for (const match of value.matchAll(/\bwsrc_[a-f0-9]{32}\b/g)) refs.add(match[0]);
+		for (const match of value.matchAll(/\bwsrc_[a-f0-9]{32}\b/g))
+			refs.add(match[0]);
 		return refs;
 	}
 	if (Array.isArray(value)) {
@@ -79,7 +93,8 @@ function collectWorkflowSourceRefs(value, refs = new Set()) {
 		return refs;
 	}
 	if (value && typeof value === "object") {
-		for (const item of Object.values(value)) collectWorkflowSourceRefs(item, refs);
+		for (const item of Object.values(value))
+			collectWorkflowSourceRefs(item, refs);
 	}
 	return refs;
 }
@@ -90,7 +105,9 @@ function isWorkflowSourceRef(value) {
 
 function sourceUrlArray(value) {
 	if (!Array.isArray(value)) return [];
-	return value.filter((item) => typeof item === "string" && item.trim()).map((item) => item.trim());
+	return value
+		.filter((item) => typeof item === "string" && item.trim())
+		.map((item) => item.trim());
 }
 
 function stripCitationUrlPunctuation(value) {
@@ -135,7 +152,9 @@ function buildUrlSourceRefLookup(normalizeInputPacket) {
 		if (!source || typeof source !== "object") continue;
 		addUrlSourceRef(urlToSourceRef, source.url, source.sourceRef);
 	}
-	const sourceRefIndex = asArray(normalizeInputPacket?.packet?.research?.sourceRefIndex);
+	const sourceRefIndex = asArray(
+		normalizeInputPacket?.packet?.research?.sourceRefIndex,
+	);
 	for (const source of sourceRefIndex) {
 		if (!source || typeof source !== "object") continue;
 		addUrlSourceRef(urlToSourceRef, source.url, source.sourceRef);
@@ -162,7 +181,9 @@ function sourceRefsForUrls(urls, urlToSourceRef) {
 // a keyword scan over the serialized claim, this cannot be satisfied by merely
 // mentioning a URL/path in prose.
 function hasFetchedEvidence(claim) {
-	return Array.isArray(claim?.evidence) && claim.evidence.some(hasStrongEvidenceRow);
+	return (
+		Array.isArray(claim?.evidence) && claim.evidence.some(hasStrongEvidenceRow)
+	);
 }
 
 function hasStrongEvidenceRow(row) {
@@ -170,26 +191,51 @@ function hasStrongEvidenceRow(row) {
 	const refs = [row.url, row.source, row.file, row.path, row.sourceRef].filter(
 		(value) => typeof value === "string",
 	);
-	const sourceRef = refs.some(
-		(value) =>
-			/^https?:\/\//i.test(value) ||
-			isWorkflowSourceRef(value) ||
-			looksLikeLocalSourceRef(value),
+	const hasExternalRef = refs.some(
+		(value) => /^https?:\/\//i.test(value) || isWorkflowSourceRef(value),
 	);
+	const hasLocalRef = refs.some((value) => looksLikeLocalSourceRef(value));
+	const hasLocatedLocalRef =
+		hasLocalRef &&
+		(refs.some(hasLineFragment) || hasLocalEvidenceLocation(row));
+	const sourceRef = hasExternalRef || hasLocatedLocalRef;
 	const quote = typeof row.quote === "string" && row.quote.trim().length > 0;
 	if (!sourceRef || !quote) return false;
 	if (isCandidateEvidenceRow(row)) return false;
 	return true;
 }
 
+function hasLineFragment(value) {
+	return /#L\d+(?:-L?\d+)?$/i.test(String(value ?? "").trim());
+}
+
+function hasLocalEvidenceLocation(row) {
+	return [
+		row.line,
+		row.lineStart,
+		row.lineEnd,
+		row.lines,
+		row.excerptLocation,
+	].some(
+		(value) =>
+			typeof value === "number" ||
+			(typeof value === "string" && value.trim().length > 0),
+	);
+}
+
 function isCandidateEvidenceRow(row) {
-	return row?.candidateOnly === true || row?.matchType === "terms" || row?.sourceRead?.matchType === "terms";
+	return (
+		row?.candidateOnly === true ||
+		row?.matchType === "terms" ||
+		row?.sourceRead?.matchType === "terms"
+	);
 }
 
 function strongEvidenceIssue(claim) {
 	const rows = Array.isArray(claim?.evidence) ? claim.evidence : [];
 	if (rows.length === 0) return "missing_structured_evidence_rows";
-	if (rows.some(isCandidateEvidenceRow)) return "candidate_only_evidence_not_strong";
+	if (rows.some(isCandidateEvidenceRow))
+		return "candidate_only_evidence_not_strong";
 	return "evidence_rows_missing_source_or_quote";
 }
 
@@ -275,7 +321,10 @@ function conservativeVerifierStatus(statuses) {
 		if (normalized.includes(status)) return status;
 	}
 	if (normalized.every((status) => status === "verified")) return "verified";
-	return normalized.find((status) => typeof status === "string" && status) ?? "unverified";
+	return (
+		normalized.find((status) => typeof status === "string" && status) ??
+		"unverified"
+	);
 }
 
 function issueForVerifierRow({ sourceId, claim, reason, claimId, index }) {
@@ -303,20 +352,24 @@ function gapForVerifierIssue(issue) {
 
 function mergeVerifierRows(rows) {
 	const first = rows[0];
-	if (rows.length === 1) return { sourceId: first.sourceId, claim: first.claim, duplicate: null };
+	if (rows.length === 1)
+		return { sourceId: first.sourceId, claim: first.claim, duplicate: null };
 	const sourceIds = rows.map((row) => row.sourceId);
 	const statusInputs = rows.map((row) => verdictOf(row.claim));
 	const selectedStatus = conservativeVerifierStatus(statusInputs);
 	const selectedRow =
-		rows.find((row) => canonicalVerifierStatus(verdictOf(row.claim)) === selectedStatus) ??
-		first;
+		rows.find(
+			(row) => canonicalVerifierStatus(verdictOf(row.claim)) === selectedStatus,
+		) ?? first;
 	const merged = { ...selectedRow.claim };
 	const evidence = rows.flatMap((row) =>
 		Array.isArray(row.claim?.evidence) ? row.claim.evidence : [],
 	);
 	if (evidence.length > 0) merged.evidence = evidence;
 	for (const field of ["sourceRefs", "sourceUrls", "factSlotIds"]) {
-		const values = compactStrings(rows.flatMap((row) => row.claim?.[field] ?? []));
+		const values = compactStrings(
+			rows.flatMap((row) => row.claim?.[field] ?? []),
+		);
 		if (values.length > 0) merged[field] = values;
 	}
 	merged.status = selectedStatus;
@@ -362,7 +415,11 @@ function findSource(sources, stageId) {
 
 export default async function claimEvidenceGate({ sources, options = {} }) {
 	const plan = findSource(sources, "plan");
-	const normalized = findSource(sources, "normalize-claims");
+	const normalizeClaims = findSource(sources, "normalize-claims");
+	const sanitizedCandidates =
+		findSource(sources, "sanitize-claims") ??
+		findSource(sources, "sanitize-verification-candidates");
+	const normalized = sanitizedCandidates ?? normalizeClaims;
 	const normalizeInputPacket = findSource(sources, "normalize-input-packet");
 	const urlToSourceRef = buildUrlSourceRefLookup(normalizeInputPacket);
 	const candidateRecords = [];
@@ -406,7 +463,8 @@ export default async function claimEvidenceGate({ sources, options = {} }) {
 		);
 	// Legacy layout: when no verify-claims.* source ids exist (for example a
 	// single from: string dependency), fall back to every non-plan/non-normalize
-	// source.
+	// source. Exclude sanitizer sources because they are canonicalizer inputs, not
+	// verifier verdict rows.
 	const verifierClaims =
 		claims.length > 0
 			? claims
@@ -415,7 +473,9 @@ export default async function claimEvidenceGate({ sources, options = {} }) {
 						([specId]) =>
 							!specId.startsWith("plan") &&
 							!specId.startsWith("normalize-claims") &&
-							!specId.startsWith("normalize-input-packet"),
+							!specId.startsWith("normalize-input-packet") &&
+							!specId.startsWith("sanitize-claims") &&
+							!specId.startsWith("sanitize-verification-candidates"),
 					)
 					.flatMap(([sourceId, source]) =>
 						asArray(source).map((claim, index) => ({ sourceId, claim, index })),
@@ -488,7 +548,13 @@ export default async function claimEvidenceGate({ sources, options = {} }) {
 		}
 	}
 
-	function auditClaim({ sourceId, claim, candidate, claimId, missingVerifierResult = false }) {
+	function auditClaim({
+		sourceId,
+		claim,
+		candidate,
+		claimId,
+		missingVerifierResult = false,
+	}) {
 		if (!claim || typeof claim !== "object") return;
 		gateSummary.total += 1;
 		const evidenceRefs = [...collectEvidenceRefs(claim)];
@@ -549,22 +615,24 @@ export default async function claimEvidenceGate({ sources, options = {} }) {
 				workflowSourceRefs.size - beforeUrlBackfillSourceRefCount;
 		}
 		if (workflowSourceRefs.size > 0) next.sourceRefs = [...workflowSourceRefs];
+		const httpSourceUrls = [
+			...new Set([
+				...sourceUrlArray(candidate?.sourceUrls).filter((ref) =>
+					/^https?:\/\//i.test(ref),
+				),
+				...evidenceRefs.filter((ref) => /^https?:\/\//i.test(ref)),
+			]),
+		];
 		if (
 			claimId &&
 			candidate &&
 			workflowSourceRefs.size === 0 &&
-			(sourceUrlArray(candidate.sourceUrls).length > 0 ||
-				evidenceRefs.some((ref) => /^https?:\/\//i.test(ref)))
+			httpSourceUrls.length > 0
 		) {
 			const failure = {
 				claimId,
 				evidenceState: "source_ref_not_available",
-				sourceUrls: [
-					...new Set([
-						...sourceUrlArray(candidate?.sourceUrls),
-						...evidenceRefs.filter((ref) => /^https?:\/\//i.test(ref)),
-					]),
-				],
+				sourceUrls: httpSourceUrls,
 				nextStep:
 					"Preserve sourceRefs from workflow_web_fetch_source through research and normalization when available.",
 			};
@@ -573,7 +641,8 @@ export default async function claimEvidenceGate({ sources, options = {} }) {
 		}
 
 		const verdict = verdictOf(next);
-		const exactQuantitativeForGate = exactQuantitative || hasExactQuantitativeClaim(next);
+		const exactQuantitativeForGate =
+			exactQuantitative || hasExactQuantitativeClaim(next);
 		if (
 			verdict === "verified" &&
 			options.requireFetchedEvidenceForVerified !== false &&
@@ -610,7 +679,8 @@ export default async function claimEvidenceGate({ sources, options = {} }) {
 			gateSummary.downgraded += 1;
 			remainingGaps.push({
 				claimId: next.id ?? next.claimId,
-				evidenceState: next.evidenceGate?.reasonCode ?? "insufficient_for_verified",
+				evidenceState:
+					next.evidenceGate?.reasonCode ?? "insufficient_for_verified",
 				reason: next.evidenceGate?.reason,
 				sourceUrls: evidenceRefs,
 				nextStep:
@@ -653,7 +723,10 @@ export default async function claimEvidenceGate({ sources, options = {} }) {
 					status === "partiallySupported" ? "partially_supported" : status,
 				);
 				const hasStatusConflict = new Set(statuses).size > 1;
-				const duplicate = { ...merged.duplicate, statusConflict: hasStatusConflict };
+				const duplicate = {
+					...merged.duplicate,
+					statusConflict: hasStatusConflict,
+				};
 				duplicateVerifierRows.push(duplicate);
 				gateSummary.duplicateVerifierClaims += 1;
 				gateSummary.duplicateVerifierRows += rows.length - 1;
@@ -764,6 +837,7 @@ export default async function claimEvidenceGate({ sources, options = {} }) {
 			droppedSlotIds,
 		},
 		identityJoinNotes,
-		precisionGuardDiagnostics: normalizeInputPacket?.packet?.precisionGuard?.summary,
+		precisionGuardDiagnostics:
+			normalizeInputPacket?.packet?.precisionGuard?.summary,
 	};
 }

package/workflows/deep-research/helpers/final-audit-packet.mjs

@@ -20,7 +20,9 @@ function asArray(value) {
 }
 
 function asObject(value) {
-	return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+	return value && typeof value === "object" && !Array.isArray(value)
+		? value
+		: {};
 }
 
 function stringOf(value) {
@@ -46,6 +48,14 @@ function compactStrings(values, limit = 5) {
 	return out;
 }
 
+function truncateText(value, limit = 240) {
+	const text = stringOf(value);
+	if (!text) return undefined;
+	const normalized = text.replace(/\s+/g, " ").trim();
+	if (normalized.length <= limit) return normalized;
+	return `${normalized.slice(0, Math.max(0, limit - 1)).trimEnd()}…`;
+}
+
 function compactClaimDigest(claim) {
 	const digest = asObject(claim);
 	return {
@@ -56,7 +66,11 @@ function compactClaimDigest(claim) {
 		factSlotIds: compactStrings(digest.factSlotIds, 12),
 		sourceRefs: compactStrings(digest.sourceRefs, 8),
 		sourceUrls: compactStrings(digest.sourceUrls, 8),
-		support: stringOf(digest.verdictDigest?.support ?? digest.verdictDigest?.summary ?? digest.verdictDigest),
+		support: stringOf(
+			digest.verdictDigest?.support ??
+				digest.verdictDigest?.summary ??
+				digest.verdictDigest,
+		),
 		caveat: stringOf(digest.verdictDigest?.caveat ?? digest.caveat),
 		correctionOrCounterclaim: stringOf(digest.correctionOrCounterclaim),
 		...(digest.evidenceGate ? { evidenceGate: digest.evidenceGate } : {}),
@@ -81,6 +95,7 @@ function compactSlot(slot) {
 function compactGap(gap) {
 	const item = asObject(gap);
 	return {
+		id: stringOf(item.id ?? item.gapId),
 		claimId: stringOf(item.claimId),
 		slotId: stringOf(item.slotId),
 		evidenceState: stringOf(item.evidenceState),
@@ -108,7 +123,9 @@ function compactDuplicateVerifierRow(row) {
 	const item = asObject(row);
 	return {
 		claimId: stringOf(item.claimId),
-		rowCount: Number.isFinite(Number(item.rowCount)) ? Number(item.rowCount) : undefined,
+		rowCount: Number.isFinite(Number(item.rowCount))
+			? Number(item.rowCount)
+			: undefined,
 		sourceIds: compactStrings(item.sourceIds, 8),
 		statusInputs: compactStrings(item.statusInputs, 8),
 		selectedStatus: stringOf(item.selectedStatus),
@@ -126,9 +143,124 @@ function countByStatus(slots) {
 	return counts;
 }
 
+function withGeneratedIds(items, prefix) {
+	return items.map((item, index) => ({
+		...item,
+		id: stringOf(item.id) ?? `${prefix}-${String(index + 1).padStart(3, "0")}`,
+	}));
+}
+
+function synthesisClaimDigest(claim) {
+	const item = compactClaimDigest(claim);
+	return {
+		id: item.id,
+		claim: truncateText(item.claim, 260),
+		status: item.status,
+		confidence: item.confidence,
+		factSlotIds: compactStrings(item.factSlotIds, 8),
+		support: truncateText(item.support, 240),
+		caveat: truncateText(item.caveat, 180),
+		correctionOrCounterclaim: truncateText(item.correctionOrCounterclaim, 180),
+		hasSourceUrls: compactStrings(item.sourceUrls, 1).length > 0,
+		hasSourceRefs: compactStrings(item.sourceRefs, 1).length > 0,
+	};
+}
+
+function synthesisFactSlot(slot) {
+	const item = asObject(slot);
+	return {
+		slotId: stringOf(item.slotId),
+		label: truncateText(item.label, 120),
+		status: stringOf(item.status),
+		gapReason: truncateText(item.gapReason, 120),
+		parentImpact: truncateText(item.parentImpact, 120),
+	};
+}
+
+function synthesisGap(gap) {
+	const item = asObject(gap);
+	return {
+		id: stringOf(item.id),
+		kind: stringOf(item.kind),
+		claimId: stringOf(item.claimId),
+		slotId: stringOf(item.slotId),
+		evidenceState: stringOf(item.evidenceState),
+		reason: truncateText(item.reason, 220),
+		nextStep: truncateText(item.nextStep, 180),
+		scopeItem: truncateText(item.scopeItem, 160),
+		whyItMatters: truncateText(item.whyItMatters, 180),
+	};
+}
+
+function synthesisScopeCoverage(row) {
+	const item = asObject(row);
+	return {
+		scopeItem: truncateText(item.scopeItem ?? item.item ?? item.topic, 160),
+		status: stringOf(item.status ?? item.coverageStatus),
+		evidenceState: stringOf(item.evidenceState),
+		summary: truncateText(item.summary ?? item.reason, 220),
+		whyItMatters: truncateText(item.whyItMatters, 180),
+	};
+}
+
+function buildSynthesisInput({
+	plan,
+	factSlotCoverage,
+	claimDigests,
+	preservedClaims,
+	coverageGaps,
+	remainingGaps,
+	sourceRefJoinFailures,
+	researchScopeCoverage,
+	integritySummary,
+	audit,
+}) {
+	return {
+		researchMetadata: {
+			depth: stringOf(plan.depth),
+			taskType: stringOf(plan.taskType),
+			expectedFinalShape: stringOf(plan.expectedFinalShape),
+			researchQuestions: asArray(plan.researchQuestions).length,
+			plannedFactSlots: asArray(plan.factSlots).length,
+		},
+		verdictCounts: asObject(audit.verdictCounts),
+		factSlotStatusCounts: countByStatus(factSlotCoverage),
+		integritySummary,
+		researchScopeCoverage: asArray(researchScopeCoverage)
+			.slice(0, 24)
+			.map(synthesisScopeCoverage),
+		factSlots: factSlotCoverage.map(synthesisFactSlot),
+		claims: claimDigests.map(synthesisClaimDigest),
+		preservedClaims: preservedClaims.slice(0, 12).map((claim) => ({
+			id: idOf(claim),
+			claim: truncateText(claim.claim, 240),
+			factSlotIds: compactStrings(claim.factSlotIds, 8),
+			whyItMatters: truncateText(claim.whyItMatters ?? claim.reason, 180),
+		})),
+		gaps: [
+			...remainingGaps.map((gap) =>
+				synthesisGap({ ...gap, kind: "remaining" }),
+			),
+			...coverageGaps.map((gap) => synthesisGap({ ...gap, kind: "coverage" })),
+			...sourceRefJoinFailures.map((gap) =>
+				synthesisGap({ ...gap, kind: "sourceRefJoinFailure" }),
+			),
+		],
+	};
+}
+
 export default async function finalAuditPacket({ sources }) {
 	const plan = asObject(findSource(sources, "plan"));
-	const normalized = asObject(findSource(sources, "normalize-claims"));
+	const normalizeClaims = asObject(findSource(sources, "normalize-claims"));
+	const sanitizedCandidates = asObject(
+		findSource(sources, "sanitize-claims") ??
+			findSource(sources, "sanitize-verification-candidates"),
+	);
+	const normalized =
+		Object.keys(sanitizedCandidates).length > 0
+			? sanitizedCandidates
+			: normalizeClaims;
+	const sanitizerDiagnostics = asObject(normalized.sanitizerDiagnostics);
 	const audit = asObject(findSource(sources, "audit-claims"));
 	const claimInventory = asObject(normalized.claimInventory);
 	const verificationCandidates = asArray(claimInventory.verificationCandidates);
@@ -137,12 +269,27 @@ export default async function finalAuditPacket({ sources }) {
 	const auditedIds = new Set(claimDigests.map(idOf).filter(Boolean));
 	const candidateIds = verificationCandidates.map(idOf).filter(Boolean);
 	const omittedCandidateIds = candidateIds.filter((id) => !auditedIds.has(id));
-	const factSlotCoverage = asArray(normalized.factSlotCoverage).map(compactSlot);
-	const coverageGaps = asArray(normalized.coverageGaps).map(compactGap);
-	const remainingGaps = asArray(audit.remainingGaps).map(compactGap);
-	const sourceRefJoinFailures = asArray(audit.sourceRefJoinFailures).map(compactGap);
-	const invalidVerifierRows = asArray(audit.invalidVerifierRows).map(compactVerifierIssue);
-	const duplicateVerifierRows = asArray(audit.duplicateVerifierRows).map(compactDuplicateVerifierRow);
+	const factSlotCoverage = asArray(normalized.factSlotCoverage).map(
+		compactSlot,
+	);
+	const coverageGaps = withGeneratedIds(
+		asArray(normalized.coverageGaps).map(compactGap),
+		"gap-coverage",
+	);
+	const remainingGaps = withGeneratedIds(
+		asArray(audit.remainingGaps).map(compactGap),
+		"gap-remaining",
+	);
+	const sourceRefJoinFailures = withGeneratedIds(
+		asArray(audit.sourceRefJoinFailures).map(compactGap),
+		"gap-source-ref",
+	);
+	const invalidVerifierRows = asArray(audit.invalidVerifierRows).map(
+		compactVerifierIssue,
+	);
+	const duplicateVerifierRows = asArray(audit.duplicateVerifierRows).map(
+		compactDuplicateVerifierRow,
+	);
 	const gateSummary = asObject(audit.gateSummary);
 	const precisionGuardDiagnostics = asObject(audit.precisionGuardDiagnostics);
 	const sourceRefCoverage = {
@@ -154,10 +301,31 @@ export default async function finalAuditPacket({ sources }) {
 		).length,
 		sourceRefJoinFailures: sourceRefJoinFailures.length,
 	};
+	const integritySummary = {
+		omittedVerificationCandidateCount: omittedCandidateIds.length,
+		sourceRefJoinFailures: sourceRefJoinFailures.length,
+		invalidVerifierRows: invalidVerifierRows.length,
+		duplicateVerifierRows: duplicateVerifierRows.length,
+		missingVerifierResults: Number(gateSummary.missingVerifierResults ?? 0),
+		sourceRefCoverage,
+	};
+	const synthesisInput = buildSynthesisInput({
+		plan,
+		factSlotCoverage,
+		claimDigests,
+		preservedClaims,
+		coverageGaps,
+		remainingGaps,
+		sourceRefJoinFailures,
+		researchScopeCoverage: normalized.researchScopeCoverage,
+		integritySummary,
+		audit,
+	});
 
 	return {
 		schema: SCHEMA,
 		packet: {
+			synthesisInput,
 			researchMetadataSeed: {
 				depth: stringOf(plan.depth),
 				taskType: stringOf(plan.taskType),
@@ -165,9 +333,15 @@ export default async function finalAuditPacket({ sources }) {
 				researchQuestions: asArray(plan.researchQuestions).length,
 				sourcePolicy: asObject(plan.sourcePolicy),
 				plannedFactSlots: asArray(plan.factSlots).length,
-				filledFactSlots: factSlotCoverage.filter((slot) => slot.status === "filled").length,
-				partialFactSlots: factSlotCoverage.filter((slot) => slot.status === "partial").length,
-				missingFactSlots: factSlotCoverage.filter((slot) => slot.status === "missing").length,
+				filledFactSlots: factSlotCoverage.filter(
+					(slot) => slot.status === "filled",
+				).length,
+				partialFactSlots: factSlotCoverage.filter(
+					(slot) => slot.status === "partial",
+				).length,
+				missingFactSlots: factSlotCoverage.filter(
+					(slot) => slot.status === "missing",
+				).length,
 			},
 			verdictCounts: asObject(audit.verdictCounts),
 			statusPartitions: asObject(audit.statusPartitions),
@@ -184,6 +358,7 @@ export default async function finalAuditPacket({ sources }) {
 			},
 			normalizerDiagnostics: {
 				precisionGuard: precisionGuardDiagnostics,
+				sanitizer: sanitizerDiagnostics,
 			},
 			preservedClaims: preservedClaims.map((claim) => ({
 				id: idOf(claim),
@@ -203,7 +378,9 @@ export default async function finalAuditPacket({ sources }) {
 				verifierIntegrity: {
 					invalidVerifierRows: invalidVerifierRows.length,
 					duplicateVerifierRows: duplicateVerifierRows.length,
-					missingVerifierResults: Number(gateSummary.missingVerifierResults ?? 0),
+					missingVerifierResults: Number(
+						gateSummary.missingVerifierResults ?? 0,
+					),
 				},
 			},
 			overflowLedger: {