@agwab/pi-workflow 0.2.1 → 0.4.0

package/workflows/deep-research/helpers/batch-verification-candidates.mjs

@@ -0,0 +1,136 @@
+// Deterministic verification candidate batch planner for deep-research.
+//
+// This helper is intentionally planning-only: it groups sanitized verification
+// candidates into stable batch records but does not change verifier semantics or
+// skip single-claim verification. A later workflow can consume these batches only
+// after per-claim result identity and fallback gates pass.
+
+function asArray(value) {
+	if (Array.isArray(value)) return value;
+	if (value && typeof value === "object") {
+		if (Array.isArray(value.claimInventory?.verificationCandidates))
+			return value.claimInventory.verificationCandidates;
+		if (Array.isArray(value.verificationCandidates))
+			return value.verificationCandidates;
+		if (Array.isArray(value.claims)) return value.claims;
+		if (Array.isArray(value.items)) return value.items;
+	}
+	return [];
+}
+
+function findCandidates(sources) {
+	for (const [specId, source] of Object.entries(sources ?? {})) {
+		if (specId === "sanitize-claims" || specId.startsWith("sanitize-claims.")) {
+			const candidates = asArray(source);
+			if (candidates.length > 0) return candidates;
+		}
+	}
+	for (const [specId, source] of Object.entries(sources ?? {})) {
+		if (
+			specId === "normalize-claims" ||
+			specId.startsWith("normalize-claims.")
+		) {
+			const candidates = asArray(source);
+			if (candidates.length > 0) return candidates;
+		}
+	}
+	return [];
+}
+
+function stableId(value, fallback) {
+	const id = typeof value?.id === "string" ? value.id.trim() : "";
+	return id || fallback;
+}
+
+function sourceKey(candidate) {
+	const refs = Array.isArray(candidate?.sourceRefs)
+		? candidate.sourceRefs.filter(
+				(ref) => typeof ref === "string" && ref.trim(),
+			)
+		: [];
+	if (refs.length > 0) return `refs:${refs.slice().sort().join("|")}`;
+	const urls = Array.isArray(candidate?.sourceUrls)
+		? candidate.sourceUrls.filter(
+				(url) => typeof url === "string" && url.trim(),
+			)
+		: [];
+	if (urls.length > 0) return `urls:${urls.slice().sort().join("|")}`;
+	return "refs:none";
+}
+
+function normalizeMaxBatchSize(value) {
+	const parsed = Number(value ?? 2);
+	if (!Number.isInteger(parsed) || parsed < 1) return 2;
+	return Math.min(parsed, 4);
+}
+
+function cloneCandidate(candidate, id) {
+	return {
+		...candidate,
+		id,
+		...(Array.isArray(candidate.sourceRefs)
+			? { sourceRefs: [...candidate.sourceRefs] }
+			: {}),
+		...(Array.isArray(candidate.sourceUrls)
+			? { sourceUrls: [...candidate.sourceUrls] }
+			: {}),
+		...(Array.isArray(candidate.sourceEvidenceHints)
+			? {
+					sourceEvidenceHints: candidate.sourceEvidenceHints.map((hint) => ({
+						...hint,
+					})),
+				}
+			: {}),
+	};
+}
+
+export default async function batchVerificationCandidates({
+	sources,
+	options = {},
+}) {
+	const maxBatchSize = normalizeMaxBatchSize(options.maxBatchSize);
+	const rawCandidates = findCandidates(sources);
+	const candidates = rawCandidates
+		.map((candidate, index) => ({
+			candidate,
+			id: stableId(
+				candidate,
+				`candidate-${String(index + 1).padStart(3, "0")}`,
+			),
+			index,
+		}))
+		.sort((left, right) => left.id.localeCompare(right.id));
+
+	const groups = new Map();
+	for (const item of candidates) {
+		const key = sourceKey(item.candidate);
+		const group = groups.get(key) ?? [];
+		group.push(item);
+		groups.set(key, group);
+	}
+
+	const batches = [];
+	for (const [key, items] of [...groups.entries()].sort(([a], [b]) =>
+		a.localeCompare(b),
+	)) {
+		for (let offset = 0; offset < items.length; offset += maxBatchSize) {
+			const slice = items.slice(offset, offset + maxBatchSize);
+			const claimIds = slice.map((item) => item.id);
+			batches.push({
+				id: `vbatch-${String(batches.length + 1).padStart(3, "0")}`,
+				sourceKey: key,
+				claimIds,
+				claims: slice.map((item) => cloneCandidate(item.candidate, item.id)),
+			});
+		}
+	}
+
+	return {
+		schema: "deep-research-verification-batches-v1",
+		digest: `${batches.length} verification batch(es), ${candidates.length} candidate(s), maxBatchSize=${maxBatchSize}`,
+		maxBatchSize,
+		candidateCount: candidates.length,
+		batchCount: batches.length,
+		batches,
+	};
+}

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

@@ -1,3 +1,9 @@
+import {
+	VERIFICATION_STATUS,
+	VERIFICATION_STATUS_BUCKETS,
+	canonicalVerificationStatus,
+} from "./verification-ontology.mjs";
+
 // Deterministic claim audit for deep-research.
 //
 // Sources: plan (optional), normalize-claims (optional), verify-claims foreach
@@ -16,10 +22,6 @@ function asArray(value) {
 	if (Array.isArray(value)) return value;
 	if (value && typeof value === "object") {
 		if (Array.isArray(value.auditedClaims)) return value.auditedClaims;
-		if (Array.isArray(value.claims)) return value.claims;
-		if (Array.isArray(value.claimVerdicts)) return value.claimVerdicts;
-		if (Array.isArray(value.verdicts)) return value.verdicts;
-		if (Array.isArray(value.items)) return value.items;
 		if (
 			"status" in value ||
 			"verdict" in value ||
@@ -28,6 +30,11 @@ function asArray(value) {
 			"id" in value
 		)
 			return [value];
+		if (Array.isArray(value.results)) return value.results;
+		if (Array.isArray(value.claims)) return value.claims;
+		if (Array.isArray(value.claimVerdicts)) return value.claimVerdicts;
+		if (Array.isArray(value.verdicts)) return value.verdicts;
+		if (Array.isArray(value.items)) return value.items;
 		return Object.values(value).flatMap(asArray);
 	}
 	return [];
@@ -82,6 +89,38 @@ function collectEvidenceRefs(claim) {
 	return refs;
 }
 
+function addLocalEvidenceRef(refs, value) {
+	if (typeof value !== "string") return;
+	const text = value.trim();
+	if (!text || /^https?:\/\//i.test(text) || isWorkflowSourceRef(text)) return;
+	if (looksLikeLocalSourceRef(text)) refs.add(text);
+}
+
+function collectLocalEvidenceRefs(claim) {
+	const refs = new Set();
+	if (!claim || typeof claim !== "object") return refs;
+	for (const key of ["file", "path", "repoPath", "localPath", "sourceRef"]) {
+		addLocalEvidenceRef(refs, claim[key]);
+	}
+	for (const value of Array.isArray(claim.sourceRefs) ? claim.sourceRefs : []) {
+		addLocalEvidenceRef(refs, value);
+	}
+	for (const row of Array.isArray(claim.evidence) ? claim.evidence : []) {
+		if (!row || typeof row !== "object") continue;
+		for (const key of [
+			"file",
+			"path",
+			"repoPath",
+			"localPath",
+			"source",
+			"sourceRef",
+		]) {
+			addLocalEvidenceRef(refs, row[key]);
+		}
+	}
+	return refs;
+}
+
 function collectWorkflowSourceRefs(value, refs = new Set()) {
 	if (typeof value === "string") {
 		for (const match of value.matchAll(/\bwsrc_[a-f0-9]{32}\b/g))
@@ -127,9 +166,11 @@ function canonicalUrlKeys(value) {
 		url.hash = "";
 		const serialized = stripCitationUrlPunctuation(url.toString());
 		keys.add(serialized);
+		addNpmDocsVersionAgnosticKey(keys, url);
 		if (url.pathname !== "/" && url.pathname.endsWith("/")) {
 			url.pathname = url.pathname.replace(/\/+$/u, "");
 			keys.add(stripCitationUrlPunctuation(url.toString()));
+			addNpmDocsVersionAgnosticKey(keys, url);
 		}
 	} catch {
 		// Keep the trimmed raw URL key only; malformed strings should not throw from
@@ -138,6 +179,17 @@ function canonicalUrlKeys(value) {
 	return [...keys].filter(Boolean);
 }
 
+function addNpmDocsVersionAgnosticKey(keys, url) {
+	if (url.hostname !== "docs.npmjs.com") return;
+	if (!/^\/cli\/(?:v\d+\/)?using-npm\//u.test(url.pathname)) return;
+	const versionless = new URL(url.toString());
+	versionless.pathname = versionless.pathname.replace(
+		/^\/cli\/v\d+\//u,
+		"/cli/",
+	);
+	keys.add(stripCitationUrlPunctuation(versionless.toString()));
+}
+
 function addUrlSourceRef(urlToSourceRef, url, sourceRef) {
 	if (!isWorkflowSourceRef(sourceRef)) return;
 	for (const key of canonicalUrlKeys(url)) {
@@ -152,13 +204,6 @@ function buildUrlSourceRefLookup(normalizeInputPacket) {
 		if (!source || typeof source !== "object") continue;
 		addUrlSourceRef(urlToSourceRef, source.url, source.sourceRef);
 	}
-	const sourceRefIndex = asArray(
-		normalizeInputPacket?.packet?.research?.sourceRefIndex,
-	);
-	for (const source of sourceRefIndex) {
-		if (!source || typeof source !== "object") continue;
-		addUrlSourceRef(urlToSourceRef, source.url, source.sourceRef);
-	}
 	return urlToSourceRef;
 }
 
@@ -241,19 +286,19 @@ function strongEvidenceIssue(claim) {
 
 function hasExactQuantitativeClaim(value) {
 	const text = JSON.stringify(value ?? "");
-	return /\b\d+(?:\.\d+)?\s*(?:%|percent|ms|s|sec|seconds|minutes|hours|x|×|usd|\$|k|m|b|tokens?|users?|samples?|n\s*=)\b/i.test(
+	return /\b\d+(?:\.\d+)?\s*(?:(?:%|×|\$|n\s*=)|(?:percent|ms|s|sec|seconds|minutes|hours|x|usd|k|m|b|tokens?|users?|samples?)\b)/i.test(
 		text,
 	);
 }
 
 function verdictOf(claim) {
-	return (
+	const status =
 		claim?.status ??
 		claim?.verdict ??
 		claim?.verdictDigest?.status ??
 		claim?.verdictDigest?.verdict ??
-		"unverified"
-	);
+		"unverified";
+	return canonicalVerifierStatus(status);
 }
 
 function withVerdict(claim, verdict, reason, details = {}) {
@@ -307,40 +352,133 @@ function compactStrings(values) {
 }
 
 function canonicalVerifierStatus(status) {
-	return status === "partiallySupported" ? "partially_supported" : status;
+	return canonicalVerificationStatus(status);
 }
 
 function conservativeVerifierStatus(statuses) {
 	const normalized = statuses.map(canonicalVerifierStatus);
 	for (const status of [
-		"conflicting",
-		"unsupported",
-		"partially_supported",
-		"unverified",
+		VERIFICATION_STATUS.CONFLICTING,
+		VERIFICATION_STATUS.UNSUPPORTED,
+		VERIFICATION_STATUS.VERIFICATION_BLOCKED,
+		VERIFICATION_STATUS.PARTIALLY_SUPPORTED,
+		VERIFICATION_STATUS.UNVERIFIED,
 	]) {
 		if (normalized.includes(status)) return status;
 	}
-	if (normalized.every((status) => status === "verified")) return "verified";
+	if (normalized.every((status) => status === VERIFICATION_STATUS.VERIFIED))
+		return VERIFICATION_STATUS.VERIFIED;
 	return (
 		normalized.find((status) => typeof status === "string" && status) ??
-		"unverified"
+		VERIFICATION_STATUS.UNVERIFIED
 	);
 }
 
-function issueForVerifierRow({ sourceId, claim, reason, claimId, index }) {
+function issueForVerifierRow({
+	sourceId,
+	claim,
+	reason,
+	claimId,
+	index,
+	...details
+}) {
 	return {
 		sourceId,
 		...(Number.isInteger(index) ? { index } : {}),
 		...(claimId ? { claimId } : {}),
+		...details,
 		reason,
 		status: verdictOf(claim),
 		nextStep:
 			reason === "unknown_claim_id"
 				? "Verify-claims output did not match any normalized verification candidate; quarantine it from claim counts."
-				: "Verifier output is missing a usable string id/claimId; rerun or repair the verifier row before counting it.",
+				: reason === "batch_result_id_not_in_source_batch"
+					? "Verifier batch output included a claim id outside the source batch; rerun or repair the batch before counting any row."
+					: reason === "unknown_verification_batch_id"
+						? "Verifier batch output came from an unknown batch id; rerun or repair the batch before counting any row."
+						: "Verifier output is missing a usable string id/claimId; rerun or repair the verifier row before counting it.",
 	};
 }
 
+function asBatchArray(value) {
+	if (Array.isArray(value?.batches)) return value.batches;
+	if (Array.isArray(value)) return value;
+	return [];
+}
+
+function buildBatchMembershipById(verificationBatches) {
+	const batches = new Map();
+	for (const batch of asBatchArray(verificationBatches)) {
+		const id = typeof batch?.id === "string" ? batch.id.trim() : "";
+		if (!id) continue;
+		const claimIds = Array.isArray(batch.claimIds)
+			? batch.claimIds
+			: Array.isArray(batch.claims)
+				? batch.claims.map(
+						(claim, index) =>
+							claimIdOf(claim).id ??
+							`candidate-${String(index + 1).padStart(3, "0")}`,
+					)
+				: [];
+		batches.set(
+			id,
+			new Set(
+				claimIds
+					.filter((claimId) => typeof claimId === "string")
+					.map((claimId) => claimId.trim())
+					.filter(Boolean),
+			),
+		);
+	}
+	return batches;
+}
+
+function verifierBatchId(sourceId) {
+	const prefix = "verify-claims.";
+	if (typeof sourceId !== "string" || !sourceId.startsWith(prefix)) return null;
+	const id = sourceId.slice(prefix.length).trim();
+	return id || null;
+}
+
+function buildBatchIdBySourceName(sourceStatuses) {
+	const bySource = new Map();
+	for (const status of Array.isArray(sourceStatuses) ? sourceStatuses : []) {
+		const source = typeof status?.source === "string" ? status.source : "";
+		const batchId = verifierBatchId(status?.specId);
+		if (source && batchId) bySource.set(source, batchId);
+	}
+	return bySource;
+}
+
+function batchMembershipIssue({
+	sourceId,
+	claimId,
+	batchMembershipById,
+	batchIdBySourceName,
+}) {
+	if (!(batchMembershipById instanceof Map) || batchMembershipById.size === 0)
+		return null;
+	const batchId =
+		verifierBatchId(sourceId) ?? batchIdBySourceName?.get(sourceId);
+	if (!batchId) return null;
+	const expectedClaimIds = batchMembershipById.get(batchId);
+	if (!expectedClaimIds) {
+		return {
+			reason: "unknown_verification_batch_id",
+			batchId,
+			expectedBatchIds: [...batchMembershipById.keys()],
+		};
+	}
+	if (!expectedClaimIds.has(claimId)) {
+		return {
+			reason: "batch_result_id_not_in_source_batch",
+			batchId,
+			expectedClaimIds: [...expectedClaimIds],
+		};
+	}
+	return null;
+}
+
 function gapForVerifierIssue(issue) {
 	return {
 		...(issue.claimId ? { claimId: issue.claimId } : {}),
@@ -399,12 +537,33 @@ function mergeVerifierRows(rows) {
 	};
 }
 
-const STATUS_BUCKETS = {
-	verified: "verified",
-	partially_supported: "partiallySupported",
-	unsupported: "unsupported",
-	conflicting: "conflicting",
-};
+function buildBatchAdoptionReadiness({ gateSummary, candidateCount }) {
+	const checks = [
+		["invalid_verifier_rows", gateSummary.invalidVerifierRows],
+		["missing_verifier_results", gateSummary.missingVerifierResults],
+		["duplicate_verifier_rows", gateSummary.duplicateVerifierRows],
+		["duplicate_status_conflicts", gateSummary.duplicateStatusConflicts],
+		["invalid_normalized_candidates", gateSummary.invalidNormalizedCandidates],
+		["source_ref_join_failures", gateSummary.sourceRefJoinFailures],
+	];
+	const blockers = checks
+		.filter(([, count]) => Number(count ?? 0) > 0)
+		.map(([reason, count]) => ({ reason, count }));
+	if (candidateCount === 0)
+		blockers.push({ reason: "no_verification_candidates", count: 0 });
+	return {
+		status: blockers.length === 0 ? "eligible_for_canary" : "blocked",
+		adopted: false,
+		canaryRequired: true,
+		reason:
+			blockers.length === 0
+				? "Verifier identity/sourceRef integrity is clean; batch adoption still requires a non-holdout canary before use."
+				: "Batch adoption is blocked until verifier identity/sourceRef integrity issues are resolved.",
+		blockers,
+	};
+}
+
+const STATUS_BUCKETS = VERIFICATION_STATUS_BUCKETS;
 
 function findSource(sources, stageId) {
 	for (const [specId, source] of Object.entries(sources ?? {})) {
@@ -413,13 +572,18 @@ function findSource(sources, stageId) {
 	return null;
 }
 
-export default async function claimEvidenceGate({ sources, options = {} }) {
+export default async function claimEvidenceGate({
+	sources,
+	options = {},
+	context = {},
+}) {
 	const plan = findSource(sources, "plan");
 	const normalizeClaims = findSource(sources, "normalize-claims");
-	const sanitizedCandidates =
-		findSource(sources, "sanitize-claims") ??
-		findSource(sources, "sanitize-verification-candidates");
+	const sanitizedCandidates = findSource(sources, "sanitize-claims");
 	const normalized = sanitizedCandidates ?? normalizeClaims;
+	const verificationBatches = findSource(sources, "verification-batches");
+	const batchMembershipById = buildBatchMembershipById(verificationBatches);
+	const batchIdBySourceName = buildBatchIdBySourceName(context.sourceStatuses);
 	const normalizeInputPacket = findSource(sources, "normalize-input-packet");
 	const urlToSourceRef = buildUrlSourceRefLookup(normalizeInputPacket);
 	const candidateRecords = [];
@@ -474,8 +638,7 @@ export default async function claimEvidenceGate({ sources, options = {} }) {
 							!specId.startsWith("plan") &&
 							!specId.startsWith("normalize-claims") &&
 							!specId.startsWith("normalize-input-packet") &&
-							!specId.startsWith("sanitize-claims") &&
-							!specId.startsWith("sanitize-verification-candidates"),
+							!specId.startsWith("sanitize-claims"),
 					)
 					.flatMap(([sourceId, source]) =>
 						asArray(source).map((claim, index) => ({ sourceId, claim, index })),
@@ -533,6 +696,25 @@ export default async function claimEvidenceGate({ sources, options = {} }) {
 			gateSummary.invalidVerifierRows += 1;
 			continue;
 		}
+		const batchIssue = batchMembershipIssue({
+			sourceId,
+			claimId: idCheck.id,
+			batchMembershipById,
+			batchIdBySourceName,
+		});
+		if (batchIssue) {
+			const issue = issueForVerifierRow({
+				sourceId,
+				claim,
+				index,
+				claimId: idCheck.id,
+				...batchIssue,
+			});
+			invalidVerifierRows.push(issue);
+			remainingGaps.push(gapForVerifierIssue(issue));
+			gateSummary.invalidVerifierRows += 1;
+			continue;
+		}
 		const row = {
 			sourceId,
 			claimId: idCheck.id,
@@ -558,6 +740,10 @@ export default async function claimEvidenceGate({ sources, options = {} }) {
 		if (!claim || typeof claim !== "object") return;
 		gateSummary.total += 1;
 		const evidenceRefs = [...collectEvidenceRefs(claim)];
+		const localEvidenceRefs = new Set([
+			...collectLocalEvidenceRefs(claim),
+			...collectLocalEvidenceRefs(candidate),
+		]);
 		const workflowSourceRefs = new Set([...collectWorkflowSourceRefs(claim)]);
 		const exactQuantitative = hasExactQuantitativeClaim(claim);
 		const fetched = hasFetchedEvidence(claim);
@@ -627,6 +813,7 @@ export default async function claimEvidenceGate({ sources, options = {} }) {
 			claimId &&
 			candidate &&
 			workflowSourceRefs.size === 0 &&
+			localEvidenceRefs.size === 0 &&
 			httpSourceUrls.length > 0
 		) {
 			const failure = {
@@ -766,6 +953,7 @@ export default async function claimEvidenceGate({ sources, options = {} }) {
 		partiallySupported: [],
 		unsupported: [],
 		conflicting: [],
+		verificationBlocked: [],
 		other: [],
 	};
 	for (const claim of auditedClaims) {
@@ -819,11 +1007,16 @@ export default async function claimEvidenceGate({ sources, options = {} }) {
 		verdictDigest: claim.verdictDigest,
 		correctionOrCounterclaim: claim.correctionOrCounterclaim,
 	}));
+	const batchAdoptionReadiness = buildBatchAdoptionReadiness({
+		gateSummary,
+		candidateCount: candidateRecords.length,
+	});
 
 	return {
 		auditedClaims,
 		claimDigests,
 		gateSummary,
+		batchAdoptionReadiness,
 		remainingGaps,
 		sourceRefJoinFailures,
 		invalidVerifierRows,

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

@@ -252,10 +252,7 @@ function buildSynthesisInput({
 export default async function finalAuditPacket({ sources }) {
 	const plan = asObject(findSource(sources, "plan"));
 	const normalizeClaims = asObject(findSource(sources, "normalize-claims"));
-	const sanitizedCandidates = asObject(
-		findSource(sources, "sanitize-claims") ??
-			findSource(sources, "sanitize-verification-candidates"),
-	);
+	const sanitizedCandidates = asObject(findSource(sources, "sanitize-claims"));
 	const normalized =
 		Object.keys(sanitizedCandidates).length > 0
 			? sanitizedCandidates

package/workflows/deep-research/helpers/normalize-input-packet.mjs

@@ -157,6 +157,60 @@ function compactGap(gap, sourceId, index) {
 	};
 }
 
+function compactBudgetLedger(source, sourceId) {
+	const ledger = asObject(source.budgetLedger);
+	if (Object.keys(ledger).length === 0) return undefined;
+	const searchBudget = Number(ledger.searchBudget);
+	const searchCallsUsed = Number(ledger.searchCallsUsed);
+	return {
+		sourceId,
+		question: stringOf(source.question)?.slice(0, 300),
+		...(Number.isFinite(searchBudget) ? { searchBudget } : {}),
+		...(Number.isFinite(searchCallsUsed) ? { searchCallsUsed } : {}),
+		searchQueriesAttempted: compactStrings(ledger.searchQueriesAttempted, 12),
+		omittedSearchQueries: compactStrings(ledger.omittedSearchQueries, 12),
+		budgetExhausted: ledger.budgetExhausted === true,
+		gapRecorded: ledger.gapRecorded === true,
+	};
+}
+
+function sourceStatusesOf(context) {
+	return asArray(context?.sourceStatuses).map(asObject);
+}
+
+function isResearchQuestionStatus(status) {
+	return [status.source, status.specId, status.displayName, status.stageId]
+		.map((value) => String(value ?? ""))
+		.some(
+			(value) =>
+				value === "research-questions" ||
+				value.startsWith("research-questions."),
+		);
+}
+
+function compactSourceStatusGap(status, index) {
+	const sourceId =
+		stringOf(status.specId) ??
+		stringOf(status.source) ??
+		stringOf(status.displayName) ??
+		`research-questions.status-${String(index + 1).padStart(3, "0")}`;
+	const detail = compactStrings(
+		[status.statusDetail, status.errorType, status.lastMessage],
+		3,
+	).join("; ");
+	return {
+		originLocator: `${sourceId}.status-gap`,
+		sourceId,
+		lead: `Research question source ${sourceId} ended with status ${String(status.status ?? "unknown")}${detail ? ` (${detail.slice(0, 300)})` : ""}.`,
+		sourceUrls: [],
+		sourceRefs: [],
+		factSlotIds: [],
+		reason: "research_question_non_completed",
+		status: String(status.status ?? "unknown"),
+		...(stringOf(status.taskId) ? { taskId: stringOf(status.taskId) } : {}),
+	};
+}
+
 function pushBounded(target, overflow, items, limit, overflowKind) {
 	for (const item of items) {
 		if (target.length < limit) target.push(item);
@@ -221,7 +275,7 @@ function isRequiredOrCriticalSlot(slot) {
 }
 
 function looksQuantitative(text) {
-	return /\b\d+(?:\.\d+)?\s*(?:%|percent|ms|s|sec|seconds|minutes|hours|x|×|usd|\$|k|m|b|tokens?|users?|samples?|n\s*=|gb|mb|tb|requests?|qps|rps|per\s+month|\/month)\b/i.test(
+	return /\b\d+(?:\.\d+)?\s*(?:(?:%|×|\$|n\s*=)|(?:percent|ms|s|sec|seconds|minutes|hours|x|usd|k|m|b|tokens?|users?|samples?|gb|mb|tb|requests?|qps|rps|per\s+month|\/month)\b)/i.test(
 		String(text ?? ""),
 	);
 }
@@ -428,19 +482,21 @@ function buildPrecisionGuard({ claims, planSlots }) {
 	};
 }
 
-export default async function normalizeInputPacket({ sources }) {
+export default async function normalizeInputPacket({ sources, context } = {}) {
 	const plan = asObject(findSource(sources, "plan"));
 	const research = researchSources(sources);
 	const extractedFacts = [];
 	const claims = [];
 	const sourceCards = [];
 	const evidenceGaps = [];
+	const questionBudgetLedger = [];
 	const overflow = {};
 	const limits = {
 		extractedFacts: 240,
 		claims: 240,
 		sources: 160,
 		evidenceGaps: 120,
+		questionBudgetLedger: 80,
 	};
 
 	for (const { sourceId, source } of research) {
@@ -480,7 +536,29 @@ export default async function normalizeInputPacket({ sources }) {
 			limits.evidenceGaps,
 			"omittedEvidenceGaps",
 		);
+		const budgetLedger = compactBudgetLedger(source, sourceId);
+		if (budgetLedger) {
+			pushBounded(
+				questionBudgetLedger,
+				overflow,
+				[budgetLedger],
+				limits.questionBudgetLedger,
+				"omittedQuestionBudgetLedgers",
+			);
+		}
 	}
+	pushBounded(
+		evidenceGaps,
+		overflow,
+		sourceStatusesOf(context)
+			.filter(
+				(status) =>
+					isResearchQuestionStatus(status) && status.status !== "completed",
+			)
+			.map(compactSourceStatusGap),
+		limits.evidenceGaps,
+		"omittedEvidenceGaps",
+	);
 
 	const planSlots = asArray(plan.factSlots).map(compactPlanSlot);
 	const precisionGuard = buildPrecisionGuard({ claims, planSlots });
@@ -506,6 +584,7 @@ export default async function normalizeInputPacket({ sources }) {
 				claims,
 				sources: sourceCards,
 				evidenceGaps,
+				questionBudgetLedger,
 			},
 			slotPreservation,
 			precisionGuard,