@agwab/pi-workflow 0.2.1 → 0.4.0

package/workflows/deep-research/helpers/render-executive.mjs

@@ -8,6 +8,7 @@
 
 import { mkdir, writeFile } from "node:fs/promises";
 import { join } from "node:path";
+import { canonicalVerificationStatus } from "./verification-ontology.mjs";
 
 function findSource(sources, stageId) {
 	const entries = Object.entries(sources ?? {});
@@ -298,11 +299,24 @@ function finiteNumber(value) {
 function normalizeClaimStatus(status) {
 	const text = cleanText(status).toLowerCase();
 	if (!text) return "";
+	const canonical = canonicalVerificationStatus(text);
+	if (canonical !== "unverified") return canonical;
+	if (
+		text === "unverified" ||
+		text.includes("not verified") ||
+		text.includes("not_verified")
+	)
+		return "unverified";
+	if (
+		text.includes("verification_blocked") ||
+		text.includes("verification blocked")
+	)
+		return "verification_blocked";
 	if (text.includes("conflict")) return "conflicting";
 	if (text.includes("unsupported")) return "unsupported";
 	if (text.includes("partial")) return "partially_supported";
-	if (text.includes("verified")) return "verified";
-	return text;
+	if (/\bverified\b/.test(text)) return "verified";
+	return canonical;
 }
 
 function coverageCounts(coverage, fallback) {
@@ -316,13 +330,18 @@ function coverageCounts(coverage, fallback) {
 			fallback.partially_supported,
 		unsupported: finiteNumber(coverage.unsupported) ?? fallback.unsupported,
 		conflicting: finiteNumber(coverage.conflicting) ?? fallback.conflicting,
+		verification_blocked:
+			finiteNumber(coverage.verificationBlocked) ??
+			finiteNumber(coverage.verification_blocked) ??
+			fallback.verification_blocked,
 	};
 	if (counts.total == null) {
 		counts.total =
 			counts.verified +
 			counts.partially_supported +
 			counts.unsupported +
-			counts.conflicting;
+			counts.conflicting +
+			counts.verification_blocked;
 	}
 	return counts;
 }
@@ -338,7 +357,8 @@ function packetVerdictCounts(packet, fallback) {
 		counts.verified +
 			counts.partially_supported +
 			counts.unsupported +
-			counts.conflicting;
+			counts.conflicting +
+			counts.verification_blocked;
 	return counts;
 }
 
@@ -350,6 +370,7 @@ function claimCounts(control, packet) {
 		partially_supported: 0,
 		unsupported: 0,
 		conflicting: 0,
+		verification_blocked: 0,
 	};
 	for (const claim of claims) {
 		const status = normalizeClaimStatus(claim?.status);
@@ -372,6 +393,7 @@ function claimCounts(control, packet) {
 		"partially_supported",
 		"unsupported",
 		"conflicting",
+		"verification_blocked",
 	]) {
 		if (coverage[key] !== counts[key]) {
 			mismatches.push({
@@ -468,7 +490,14 @@ function packetGapRows(packet) {
 		kind: "Coverage gap",
 		...gap,
 	}));
-	return [...remaining, ...coverage];
+	const sourceRefJoinFailures = asArray(packet?.sourceRefJoinFailures).map(
+		(gap, index) => ({
+			id: gapIdOf(gap) || numberedId("gap-source-ref", index),
+			kind: "Source reference gap",
+			...gap,
+		}),
+	);
+	return [...remaining, ...coverage, ...sourceRefJoinFailures];
 }
 
 function rowsForIds(ids, rowById, warnings, label) {
@@ -513,6 +542,8 @@ function evidenceStrength(status) {
 		case "unsupported":
 			return 1;
 		case "conflicting":
+		case "verification_blocked":
+		case "unverified":
 			return 0;
 		default:
 			return -1;
@@ -580,6 +611,7 @@ function coverageSummaryFromPacket(packet, fallback = {}) {
 		partially_supported: 0,
 		unsupported: 0,
 		conflicting: 0,
+		verification_blocked: 0,
 	});
 	if (!counts) return fallback;
 	return {
@@ -588,6 +620,7 @@ function coverageSummaryFromPacket(packet, fallback = {}) {
 		partiallySupported: counts.partially_supported,
 		unsupported: counts.unsupported,
 		conflicting: counts.conflicting,
+		verificationBlocked: counts.verification_blocked,
 		verificationCandidates: counts.total,
 		depth: packet?.researchMetadataSeed?.depth ?? fallback.depth,
 		researchQuestions:
@@ -968,7 +1001,7 @@ function renderAuditSummary(report, claimSummary, slots) {
 	return [
 		"## Audit summary",
 		"",
-		`- Claims: ${claimSummary.verified} verified, ${claimSummary.partially_supported} partially supported, ${claimSummary.unsupported} unsupported, ${claimSummary.conflicting} conflicting.`,
+		`- Claims: ${claimSummary.verified} verified, ${claimSummary.partially_supported} partially supported, ${claimSummary.unsupported} unsupported, ${claimSummary.conflicting} conflicting, ${claimSummary.verification_blocked} verification blocked.`,
 		`- Fact slots: ${slots.filled} filled, ${slots.partial} partial, ${slots.missingOrConflicting} missing/conflicting, ${slots.total} total.`,
 		...(mismatches.length > 0
 			? [
@@ -987,11 +1020,7 @@ function renderAuditSummary(report, claimSummary, slots) {
 
 function renderWarnings(sectionCounts) {
 	const checks = [
-		["findings", "renderedFindings", "findings"],
-		["recommendations", "renderedRecommendations", "recommendations"],
-		["actionItems", "renderedActionItems", "action items"],
 		["caveatsAndGaps", "renderedCaveatsAndGaps", "caveats/gaps"],
-		["factSlots", "renderedFactSlots", "fact slots"],
 		["sourceUrls", "renderedSourceUrls", "source URLs"],
 	];
 	return checks
@@ -1237,6 +1266,7 @@ export default async function renderExecutive({
 				partially_supported: 0,
 				unsupported: 0,
 				conflicting: 0,
+				verification_blocked: 0,
 			},
 			factSlotSummary: {
 				total: 0,
@@ -1261,15 +1291,6 @@ export default async function renderExecutive({
 		maxUrls: Number.isFinite(Number(options.maxUrls))
 			? Math.max(0, Number(options.maxUrls))
 			: Infinity,
-		maxFindings: Number.isFinite(Number(options.maxFindings))
-			? Math.max(0, Number(options.maxFindings))
-			: undefined,
-		maxRecommendations: Number.isFinite(Number(options.maxRecommendations))
-			? Math.max(0, Number(options.maxRecommendations))
-			: undefined,
-		maxGaps: Number.isFinite(Number(options.maxGaps))
-			? Math.max(0, Number(options.maxGaps))
-			: undefined,
 	};
 	const rendered = renderResearchMarkdown(control, auditPacket, opts);
 	let markdown = rendered.markdown;
@@ -1296,7 +1317,6 @@ export default async function renderExecutive({
 		!serializationArtifact;
 
 	let executiveSidecarPath;
-	let reportSidecarPath;
 	let auditSidecarPath;
 	try {
 		if (context.cwd && context.runId && context.taskId) {
@@ -1310,10 +1330,8 @@ export default async function renderExecutive({
 			);
 			await mkdir(taskDir, { recursive: true });
 			executiveSidecarPath = join(taskDir, "executive.md");
-			reportSidecarPath = join(taskDir, "report.md");
 			auditSidecarPath = join(taskDir, "audit.md");
 			await writeFile(executiveSidecarPath, `${markdown}\n`, "utf8");
-			await writeFile(reportSidecarPath, `${markdown}\n`, "utf8");
 			await writeFile(auditSidecarPath, `${auditMarkdown}\n`, "utf8");
 		}
 	} catch {
@@ -1344,9 +1362,6 @@ export default async function renderExecutive({
 			renderedAllStructuredItems,
 			maxWords: Number.isFinite(opts.maxWords) ? opts.maxWords : null,
 			maxUrls: Number.isFinite(opts.maxUrls) ? opts.maxUrls : null,
-			maxFindings: opts.maxFindings,
-			maxRecommendations: opts.maxRecommendations,
-			maxGaps: opts.maxGaps,
 			truncated,
 			truncatedWithOpenGaps,
 			serializationArtifact,
@@ -1354,7 +1369,6 @@ export default async function renderExecutive({
 		},
 		auditArtifact: auditSidecarPath ? "audit.md" : "final-audit.control.json",
 		...(executiveSidecarPath ? { sidecarPath: "executive.md" } : {}),
-		...(reportSidecarPath ? { reportSidecarPath: "report.md" } : {}),
 		...(auditSidecarPath ? { auditSidecarPath: "audit.md" } : {}),
 	};
 }

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

@@ -89,12 +89,55 @@ function matchesAny(text, patterns) {
 	return patterns.some((pattern) => pattern.test(text));
 }
 
+const WORD_TOKEN_RE =
+	/[\p{Letter}\p{Number}][\p{Letter}\p{Number}\p{Mark}_-]*/gu;
+const ASCII_TOKEN_RE = /^[a-z0-9][a-z0-9_-]{2,}$/iu;
+const ASCII_RUN_RE = /[a-z0-9][a-z0-9_-]{2,}/giu;
+const CJK_RUN_RE =
+	/[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}]+/gu;
+const ASCII_CHAR_RE = /[a-z0-9]/iu;
+
+function addCjkRunTokens(tokens, run) {
+	const chars = [...run];
+	if (chars.length === 0) return;
+	if (chars.length === 1) {
+		tokens.add(chars[0]);
+		return;
+	}
+	tokens.add(run);
+	for (const size of [2, 3]) {
+		if (chars.length < size) continue;
+		for (let index = 0; index <= chars.length - size; index += 1) {
+			tokens.add(chars.slice(index, index + size).join(""));
+		}
+	}
+}
+
 function tokenSet(value) {
-	return new Set(
-		String(value ?? "")
-			.toLowerCase()
-			.match(/[a-z0-9][a-z0-9_-]{2,}/g) ?? [],
-	);
+	const tokens = new Set();
+	const normalized = String(value ?? "")
+		.normalize("NFKC")
+		.toLocaleLowerCase();
+	for (const match of normalized.matchAll(WORD_TOKEN_RE)) {
+		const token = match[0].replace(/^[_-]+|[_-]+$/gu, "");
+		if (!token) continue;
+		for (const asciiMatch of token.matchAll(ASCII_RUN_RE)) {
+			tokens.add(asciiMatch[0]);
+		}
+		if (ASCII_TOKEN_RE.test(token)) continue;
+		let cjkMatched = false;
+		for (const cjkMatch of token.matchAll(CJK_RUN_RE)) {
+			cjkMatched = true;
+			addCjkRunTokens(tokens, cjkMatch[0]);
+		}
+		if (!cjkMatched && [...token].length >= 3) tokens.add(token);
+	}
+	return tokens;
+}
+
+function hasAsciiToken(tokens) {
+	for (const token of tokens) if (ASCII_CHAR_RE.test(token)) return true;
+	return false;
 }
 
 function setIntersectionCount(left, right) {
@@ -235,10 +278,15 @@ function evidenceHintsForCandidate(candidate, hintRows) {
 			candidateSlots,
 		);
 		const tokenHits = setIntersectionCount(row._tokens, candidateTokens);
+		const unicodeSlotOnlyFallback =
+			slotHits > 0 &&
+			tokenHits < 2 &&
+			!hasAsciiToken(candidateTokens) &&
+			!hasAsciiToken(row._tokens);
 		if (slotHits === 0 && tokenHits < 2) continue;
 		const score =
 			refHits * 6 + urlHits * 5 + slotHits * 2 + Math.min(tokenHits, 5);
-		if (score < 7) continue;
+		if (score < 7 && !unicodeSlotOnlyFallback) continue;
 		scored.push({ score, row });
 	}
 	scored.sort((left, right) => right.score - left.score);
@@ -376,11 +424,14 @@ function rewrittenCandidate(candidate, reasons, hints, urlToSourceRef) {
 	if (!hint) return null;
 	const replacement = stringOf(hint.value) || stringOf(hint.quote);
 	if (!replacement || replacement === claimText(candidate)) return null;
+	const refs = backfillSourceRefs(candidate, [hint], urlToSourceRef);
+	if (refs.length === 0 && localEvidenceRefs(candidate).length === 0)
+		return null;
 	return {
 		...candidate,
 		originalClaim: claimText(candidate),
 		claim: replacement,
-		sourceRefs: backfillSourceRefs(candidate, [hint], urlToSourceRef),
+		sourceRefs: refs,
 		sourceUrls: hint.url ? [hint.url] : sourceUrls(candidate),
 		sanitizerRewriteReasons: rewriteReasons,
 		reasonToVerify: `Deterministically rewritten to a source-backed atom from ${hint.sourceTitleOrPublisher ?? hint.url ?? hint.sourceRef ?? "source evidence"}.`,
@@ -399,6 +450,16 @@ function sanitizedCandidate(candidate, hints, urlToSourceRef) {
 	};
 }
 
+function withoutSanitizerGapReason(value) {
+	return stringOf(value)
+		.split(";")
+		.map((part) => part.trim())
+		.filter(
+			(part) => part && !part.startsWith("sanitized verifier candidates:"),
+		)
+		.join("; ");
+}
+
 function adjustFactSlotCoverage(rows, demotedBySlot, keptIds) {
 	return asArray(rows).map((row) => {
 		const slot = { ...asObject(row) };
@@ -484,6 +545,7 @@ export default async function sanitizeVerificationCandidates({ sources }) {
 	const webUrlOnlyDemotedIds = [];
 	const promotedCandidateIds = [];
 	const promotedBySlot = new Map();
+	const promotedPreservedClaims = new Set();
 	const retainedCandidates = [];
 	for (const [index, candidate] of keptCandidates.entries()) {
 		const hasRefs = sourceRefs(candidate).length > 0;
@@ -550,6 +612,7 @@ export default async function sanitizeVerificationCandidates({ sources }) {
 		for (const entry of promotable.slice(0, webUrlOnlyDemotedIds.length)) {
 			takenIds.add(entry.id);
 			promotedCandidateIds.push(entry.id);
+			promotedPreservedClaims.add(entry.preserved);
 			for (const slotId of entry.slots) {
 				const list = promotedBySlot.get(slotId) ?? [];
 				list.push(entry.id);
@@ -584,19 +647,30 @@ export default async function sanitizeVerificationCandidates({ sources }) {
 		const slotId = stringOf(row.slotId ?? row.id);
 		const promoted = promotedBySlot.get(slotId) ?? [];
 		if (promoted.length === 0) return row;
-		return {
-			...row,
-			verificationCandidateIds: compactStrings(
-				[...asArray(row.verificationCandidateIds), ...promoted],
-				24,
-			),
-		};
+		const verificationCandidateIds = compactStrings(
+			[...asArray(row.verificationCandidateIds), ...promoted],
+			24,
+		);
+		const next = { ...row, verificationCandidateIds };
+		if (verificationCandidateIds.length > 0) {
+			if (next.status === "partial" || next.status === "missing") {
+				next.status = "filled";
+			}
+			const gapReason = withoutSanitizerGapReason(next.gapReason);
+			if (gapReason) next.gapReason = gapReason;
+			else delete next.gapReason;
+		}
+		return next;
 	});
+	const outputPreservedClaims =
+		promotedPreservedClaims.size === 0
+			? preservedClaims
+			: preservedClaims.filter((claim) => !promotedPreservedClaims.has(claim));
 	return {
 		schema: SCHEMA,
 		claimInventory: {
 			verificationCandidates: keptCandidates,
-			preservedClaims,
+			preservedClaims: outputPreservedClaims,
 			duplicates: asArray(claimInventory.duplicates),
 		},
 		factSlotCoverage: factSlotCoverageRows,

package/workflows/deep-research/helpers/shadow-select-verification.mjs

@@ -0,0 +1,229 @@
+// Shadow-only selective verification reporter for deep-research.
+//
+// This helper never skips verification. It records which candidates a future
+// selector might skip, then joins those shadow decisions to actual audit output
+// so adoption can be judged with evidence before any verifier is removed.
+
+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.auditedClaims)) return value.auditedClaims;
+		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 findAuditedClaims(sources) {
+	for (const [specId, source] of Object.entries(sources ?? {})) {
+		if (specId === "audit-claims" || specId.startsWith("audit-claims.")) {
+			const claims = asArray(source);
+			if (claims.length > 0) return claims;
+		}
+	}
+	return [];
+}
+
+function findAuditSource(sources) {
+	for (const [specId, source] of Object.entries(sources ?? {})) {
+		if (specId === "audit-claims" || specId.startsWith("audit-claims."))
+			return source && typeof source === "object" ? source : {};
+	}
+	return {};
+}
+
+function issueCount(audit, field) {
+	const fromSummary = Number(audit?.gateSummary?.[field] ?? 0);
+	const fromArray = Array.isArray(audit?.[field]) ? audit[field].length : 0;
+	return Math.max(Number.isFinite(fromSummary) ? fromSummary : 0, fromArray);
+}
+
+function auditIntegrityBlockers(audit) {
+	return [
+		["audit_invalid_verifier_rows", issueCount(audit, "invalidVerifierRows")],
+		[
+			"audit_missing_verifier_results",
+			issueCount(audit, "missingVerifierResults"),
+		],
+		[
+			"audit_duplicate_verifier_rows",
+			issueCount(audit, "duplicateVerifierRows"),
+		],
+		[
+			"audit_duplicate_status_conflicts",
+			issueCount(audit, "duplicateStatusConflicts"),
+		],
+		[
+			"audit_invalid_normalized_candidates",
+			issueCount(audit, "invalidNormalizedCandidates"),
+		],
+		[
+			"audit_source_ref_join_failures",
+			issueCount(audit, "sourceRefJoinFailures"),
+		],
+	]
+		.filter(([, count]) => count > 0)
+		.map(([reason, count]) => ({ reason, count }));
+}
+
+function candidateId(candidate, index) {
+	const id = typeof candidate?.id === "string" ? candidate.id.trim() : "";
+	return id || `candidate-${String(index + 1).padStart(3, "0")}`;
+}
+
+function hasExactQuantitativeText(candidate) {
+	return /\b\d+(?:\.\d+)?\b|\b(v\d+(?:\.\d+)*)\b|\b\d+\s*(?:ms|s|min|hour|day|%|percent|usd|dollars?|tokens?|kb|mb|gb)\b/iu.test(
+		String(candidate?.claim ?? ""),
+	);
+}
+
+function hasCriticalSlots(candidate) {
+	const ids = Array.isArray(candidate?.factSlotIds)
+		? candidate.factSlotIds
+		: [];
+	return ids.some((id) =>
+		/(price|pricing|cost|ttl|limit|version|date|policy|security|numeric|slot-critical)/iu.test(
+			String(id),
+		),
+	);
+}
+
+function hasExactSourceHint(candidate) {
+	return (
+		Array.isArray(candidate?.sourceEvidenceHints) &&
+		candidate.sourceEvidenceHints.some(
+			(hint) =>
+				typeof hint?.quote === "string" &&
+				hint.quote.trim() &&
+				(typeof hint.sourceRef === "string" ||
+					typeof hint.sourceUrl === "string"),
+		)
+	);
+}
+
+function decide(candidate) {
+	const reasonCodes = [];
+	if (hasExactQuantitativeText(candidate))
+		reasonCodes.push("exact_quantitative");
+	if (hasCriticalSlots(candidate)) reasonCodes.push("critical_fact_slot");
+	if (!hasExactSourceHint(candidate)) reasonCodes.push("no_exact_source_hint");
+	if (reasonCodes.length > 0) {
+		return { decision: "would_verify", reasonCodes };
+	}
+	return {
+		decision: "would_skip_shadow_only",
+		reasonCodes: ["exact_source_hint_noncritical"],
+	};
+}
+
+export default async function shadowSelectVerification({ sources }) {
+	const audit = findAuditSource(sources);
+	const candidates = findCandidates(sources).map((candidate, index) => ({
+		candidate,
+		id: candidateId(candidate, index),
+	}));
+	const auditedById = new Map(
+		findAuditedClaims(sources).map((claim, index) => [
+			candidateId(claim, index),
+			claim,
+		]),
+	);
+	const decisions = candidates.map(({ candidate, id }) => {
+		const decision = decide(candidate);
+		const audited = auditedById.get(id);
+		return {
+			id,
+			decision: decision.decision,
+			reasonCodes: decision.reasonCodes,
+			actualStatus:
+				typeof audited?.status === "string" ? audited.status : undefined,
+			actualVerified: audited?.status === "verified",
+			factSlotIds: Array.isArray(candidate.factSlotIds)
+				? [...candidate.factSlotIds]
+				: [],
+		};
+	});
+	const wouldSkip = decisions.filter(
+		(decision) => decision.decision === "would_skip_shadow_only",
+	);
+	const wouldVerify = decisions.filter(
+		(decision) => decision.decision === "would_verify",
+	);
+	const skippedButVerified = wouldSkip.filter(
+		(decision) => decision.actualVerified,
+	);
+	const wouldSkipWithoutAudit = wouldSkip.filter(
+		(decision) => typeof decision.actualStatus !== "string",
+	);
+	const blockers = [];
+	if (skippedButVerified.length > 0)
+		blockers.push({
+			reason: "would_skip_verified_claims",
+			count: skippedButVerified.length,
+		});
+	if (wouldSkipWithoutAudit.length > 0)
+		blockers.push({
+			reason: "would_skip_without_audit_result",
+			count: wouldSkipWithoutAudit.length,
+		});
+	blockers.push(...auditIntegrityBlockers(audit));
+	if (wouldSkip.length === 0)
+		blockers.push({ reason: "no_shadow_skip_candidates", count: 0 });
+	const realSkipReadiness = {
+		status: blockers.length === 0 ? "eligible_for_canary" : "blocked",
+		realSkippingEnabled: false,
+		adopted: false,
+		canaryRequired: true,
+		reason:
+			blockers.length === 0
+				? "Shadow selector found skip candidates with no verified or missing-audit rows; real skipping still requires a non-holdout canary."
+				: "Real selective verification is blocked until shadow decisions prove no verified or unaudited claims would be skipped.",
+		blockers,
+	};
+	return {
+		schema: "deep-research-verification-shadow-selector-v1",
+		digest: `${wouldSkip.length} would-skip shadow candidate(s), ${wouldVerify.length} would-verify candidate(s); real skipping disabled`,
+		realSkippingEnabled: false,
+		candidateCount: decisions.length,
+		summary: {
+			wouldSkip: wouldSkip.length,
+			wouldVerify: wouldVerify.length,
+			skippedButVerified: skippedButVerified.length,
+			wouldSkipWithoutAudit: wouldSkipWithoutAudit.length,
+			skippedCritical: wouldSkip.filter((decision) =>
+				decision.reasonCodes.includes("critical_fact_slot"),
+			).length,
+			shadowOnly: true,
+		},
+		realSkipReadiness,
+		decisions,
+		w8FastProfilePrerequisite: {
+			status: "not_met",
+			reason:
+				"selective verification is shadow-only; no verified cost/speed reduction is available to package as an opt-in fast profile",
+		},
+	};
+}

package/workflows/deep-research/helpers/verification-ontology.mjs

@@ -0,0 +1,77 @@
+// Bundle-local compatibility surface for the package verification ontology.
+//
+// Workflow support helpers are bundled from the workflow spec directory, so this
+// dependency-free helper intentionally lives inside the deep-research bundle.
+// Keep it in semantic parity with src/verification-ontology.ts.
+
+export const VERIFICATION_STATUS = Object.freeze({
+	VERIFIED: "verified",
+	PARTIALLY_SUPPORTED: "partially_supported",
+	UNSUPPORTED: "unsupported",
+	CONFLICTING: "conflicting",
+	VERIFICATION_BLOCKED: "verification_blocked",
+	UNVERIFIED: "unverified",
+});
+
+export const VERIFICATION_STATUS_VALUES = Object.freeze([
+	VERIFICATION_STATUS.VERIFIED,
+	VERIFICATION_STATUS.PARTIALLY_SUPPORTED,
+	VERIFICATION_STATUS.UNSUPPORTED,
+	VERIFICATION_STATUS.CONFLICTING,
+	VERIFICATION_STATUS.VERIFICATION_BLOCKED,
+]);
+
+export const VERIFICATION_STATUS_BUCKETS = Object.freeze({
+	[VERIFICATION_STATUS.VERIFIED]: "verified",
+	[VERIFICATION_STATUS.PARTIALLY_SUPPORTED]: "partiallySupported",
+	[VERIFICATION_STATUS.UNSUPPORTED]: "unsupported",
+	[VERIFICATION_STATUS.CONFLICTING]: "conflicting",
+	[VERIFICATION_STATUS.VERIFICATION_BLOCKED]: "verificationBlocked",
+});
+
+export const VERIFICATION_STATUS_LABELS = Object.freeze({
+	[VERIFICATION_STATUS.VERIFIED]: "verified",
+	[VERIFICATION_STATUS.PARTIALLY_SUPPORTED]: "partially supported",
+	[VERIFICATION_STATUS.UNSUPPORTED]: "unsupported",
+	[VERIFICATION_STATUS.CONFLICTING]: "conflicting",
+	[VERIFICATION_STATUS.VERIFICATION_BLOCKED]: "verification blocked",
+	[VERIFICATION_STATUS.UNVERIFIED]: "unverified",
+});
+
+export function canonicalVerificationStatus(status) {
+	const text = String(status ?? "").trim();
+	if (!text) return VERIFICATION_STATUS.UNVERIFIED;
+	if (text === "partiallySupported")
+		return VERIFICATION_STATUS.PARTIALLY_SUPPORTED;
+	if (text === "verificationBlocked" || text === "blocked")
+		return VERIFICATION_STATUS.VERIFICATION_BLOCKED;
+	return Object.values(VERIFICATION_STATUS).includes(text)
+		? text
+		: VERIFICATION_STATUS.UNVERIFIED;
+}
+
+export function verificationStatusBucket(status) {
+	return (
+		VERIFICATION_STATUS_BUCKETS[canonicalVerificationStatus(status)] ?? "other"
+	);
+}
+
+export function isVerifiedStatus(status) {
+	return canonicalVerificationStatus(status) === VERIFICATION_STATUS.VERIFIED;
+}
+
+export function isVerificationBlockedStatus(status) {
+	return (
+		canonicalVerificationStatus(status) ===
+		VERIFICATION_STATUS.VERIFICATION_BLOCKED
+	);
+}
+
+export function isNonVerifiedTerminalStatus(status) {
+	return [
+		VERIFICATION_STATUS.PARTIALLY_SUPPORTED,
+		VERIFICATION_STATUS.UNSUPPORTED,
+		VERIFICATION_STATUS.CONFLICTING,
+		VERIFICATION_STATUS.VERIFICATION_BLOCKED,
+	].includes(canonicalVerificationStatus(status));
+}

package/workflows/deep-research/schemas/deep-research-executive-render-control.schema.json

@@ -24,13 +24,14 @@
     "sourceUrls": { "type": "array", "items": { "type": "string" } },
     "claimSummary": {
       "type": "object",
-      "required": ["total", "verified", "partially_supported", "unsupported", "conflicting"],
+      "required": ["total", "verified", "partially_supported", "unsupported", "conflicting", "verification_blocked"],
       "properties": {
         "total": { "type": "number" },
         "verified": { "type": "number" },
         "partially_supported": { "type": "number" },
         "unsupported": { "type": "number" },
-        "conflicting": { "type": "number" }
+        "conflicting": { "type": "number" },
+        "verification_blocked": { "type": "number" }
       },
       "additionalProperties": true
     },
@@ -56,7 +57,6 @@
     },
     "auditArtifact": { "type": "string" },
     "sidecarPath": { "type": "string" },
-    "reportSidecarPath": { "type": "string" },
     "auditSidecarPath": { "type": "string" },
     "reportMarkdown": { "type": "string" },
     "auditMarkdown": { "type": "string" },