@agwab/pi-workflow 0.2.1 → 0.3.0

package/src/workflow-web-source.ts

@@ -98,7 +98,7 @@ export interface WorkflowWebSourceReadRequest {
 }
 
 export interface WorkflowWebSourceReadResult {
-	status: "matched" | "not_found";
+	status: "matched" | "truncated" | "not_found";
 	matchType?: "exact" | "normalized" | "terms";
 	quote?: string;
 	startOffset?: number;
@@ -108,6 +108,7 @@ export interface WorkflowWebSourceReadResult {
 	missingTerms?: string[];
 	coverageRatio?: number;
 	candidateOnly?: boolean;
+	truncated?: boolean;
 }
 
 export interface WorkflowWebSourceCard {
@@ -791,6 +792,8 @@ function snippetForTerms(options: {
 	const candidates: Array<{
 		start: number;
 		end: number;
+		anchorStart: number;
+		anchorEnd: number;
 		matchedTerms: string[];
 		missingTerms: string[];
 		score: number;
@@ -822,23 +825,34 @@ function snippetForTerms(options: {
 		if (right.score !== left.score) return right.score - left.score;
 		return right.matchedTerms.length - left.matchedTerms.length;
 	})[0]!;
-	const raw = redactInlineSecrets(options.text.slice(best.start, best.end));
-	const consumed = consumeWorkflowWebVisibleBudget(
-		options.budget,
-		raw,
-		options.maxChars,
-	);
+	const consumed = consumeAnchoredSnippet({
+		text: options.text,
+		anchorStart: best.anchorStart,
+		anchorEnd: best.anchorEnd,
+		maxChars: options.maxChars,
+		budget: options.budget,
+	});
+	const returnedWindowNorm = normalizeForSearch(
+		options.text.slice(consumed.sourceStart, consumed.sourceEnd),
+	).normalized;
+	const matchedTerms = needles
+		.filter((term) => returnedWindowNorm.includes(term.normalized))
+		.map((term) => term.raw);
+	const missingTerms = needles
+		.filter((term) => !returnedWindowNorm.includes(term.normalized))
+		.map((term) => term.raw);
 	return {
-		status: "matched",
+		status: consumed.status,
 		matchType: "terms",
-		quote: consumed.text,
-		startOffset: best.start,
-		endOffset: best.end,
-		visibleChars: consumed.text.length,
-		matchedTerms: best.matchedTerms,
-		missingTerms: best.missingTerms,
-		coverageRatio: best.matchedTerms.length / Math.max(1, needles.length),
+		quote: consumed.quote || undefined,
+		startOffset: consumed.sourceStart,
+		endOffset: consumed.sourceEnd,
+		visibleChars: consumed.visibleChars,
+		matchedTerms,
+		missingTerms,
+		coverageRatio: matchedTerms.length / Math.max(1, needles.length),
 		candidateOnly: true,
+		truncated: consumed.truncated || undefined,
 	};
 }
 
@@ -854,6 +868,8 @@ function scoreTermWindow(
 	matchedTerms: string[];
 	missingTerms: string[];
 	score: number;
+	anchorStart: number;
+	anchorEnd: number;
 } {
 	const center = Math.floor((matchStart + matchEnd) / 2);
 	const start = Math.max(0, center - Math.floor(maxChars / 2));
@@ -874,6 +890,8 @@ function scoreTermWindow(
 	return {
 		start,
 		end,
+		anchorStart: matchStart,
+		anchorEnd: matchEnd,
 		matchedTerms,
 		missingTerms,
 		score: matchedTerms.length * 1_000 + occurrenceScore,
@@ -963,27 +981,99 @@ function snippetForMatch(options: {
 	maxChars: number;
 	budget: WorkflowWebVisibleBudget;
 }): WorkflowWebSourceReadResult {
-	const matchLength = Math.max(0, options.end - options.start);
-	const slack = Math.max(0, options.maxChars - matchLength);
-	const before = Math.floor(slack / 2);
-	const snippetStart = Math.max(0, options.start - before);
-	const snippetEnd = Math.min(
-		options.text.length,
-		snippetStart + options.maxChars,
+	const consumed = consumeAnchoredSnippet({
+		text: options.text,
+		anchorStart: options.start,
+		anchorEnd: options.end,
+		maxChars: options.maxChars,
+		budget: options.budget,
+	});
+	return {
+		status: consumed.status,
+		matchType: options.matchType,
+		quote: consumed.quote || undefined,
+		startOffset: options.start,
+		endOffset: options.end,
+		visibleChars: consumed.visibleChars,
+		truncated: consumed.truncated || undefined,
+	};
+}
+
+type AnchoredSnippetResult = {
+	status: "matched" | "truncated";
+	quote: string;
+	visibleChars: number;
+	sourceStart: number;
+	sourceEnd: number;
+	truncated: boolean;
+};
+
+function consumeAnchoredSnippet(options: {
+	text: string;
+	anchorStart: number;
+	anchorEnd: number;
+	maxChars: number;
+	budget: WorkflowWebVisibleBudget;
+}): AnchoredSnippetResult {
+	const maxChars = Math.max(0, Math.floor(options.maxChars));
+	const remainingBefore = Math.max(
+		0,
+		options.budget.limit - options.budget.used,
+	);
+	const visibleLimit = Math.max(0, Math.min(maxChars, remainingBefore));
+	const anchorStart = Math.max(
+		0,
+		Math.min(options.text.length, Math.floor(options.anchorStart)),
+	);
+	const anchorEnd = Math.max(
+		anchorStart,
+		Math.min(options.text.length, Math.floor(options.anchorEnd)),
 	);
-	const raw = redactInlineSecrets(options.text.slice(snippetStart, snippetEnd));
+	const anchorLength = Math.max(0, anchorEnd - anchorStart);
+	if (visibleLimit <= 0) {
+		return {
+			status: "truncated",
+			quote: "",
+			visibleChars: 0,
+			sourceStart: anchorStart,
+			sourceEnd: anchorStart,
+			truncated: true,
+		};
+	}
+
+	let sourceStart: number;
+	let sourceEnd: number;
+	let status: "matched" | "truncated" = "matched";
+	if (anchorLength > visibleLimit) {
+		sourceStart = anchorStart;
+		sourceEnd = Math.min(options.text.length, sourceStart + visibleLimit);
+		status = "truncated";
+	} else {
+		const slack = Math.max(0, visibleLimit - anchorLength);
+		sourceStart = Math.max(0, anchorStart - Math.floor(slack / 2));
+		sourceEnd = Math.min(options.text.length, sourceStart + visibleLimit);
+		if (sourceEnd < anchorEnd) {
+			sourceEnd = anchorEnd;
+			sourceStart = Math.max(0, sourceEnd - visibleLimit);
+		} else if (sourceEnd === options.text.length) {
+			sourceStart = Math.max(0, sourceEnd - visibleLimit);
+		}
+	}
+
+	const raw = redactInlineSecrets(options.text.slice(sourceStart, sourceEnd));
 	const consumed = consumeWorkflowWebVisibleBudget(
 		options.budget,
 		raw,
-		options.maxChars,
+		visibleLimit,
 	);
+	const truncated = status === "truncated" || consumed.truncated;
 	return {
-		status: "matched",
-		matchType: options.matchType,
+		status,
 		quote: consumed.text,
-		startOffset: options.start,
-		endOffset: options.end,
 		visibleChars: consumed.text.length,
+		sourceStart,
+		sourceEnd,
+		truncated,
 	};
 }
 

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

@@ -82,6 +82,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 +159,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 +172,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 +197,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 +279,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 = {}) {
@@ -416,9 +454,7 @@ function findSource(sources, stageId) {
 export default async function claimEvidenceGate({ sources, options = {} }) {
 	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 normalizeInputPacket = findSource(sources, "normalize-input-packet");
 	const urlToSourceRef = buildUrlSourceRefLookup(normalizeInputPacket);
@@ -474,8 +510,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 })),
@@ -558,6 +593,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 +666,7 @@ export default async function claimEvidenceGate({ sources, options = {} }) {
 			claimId &&
 			candidate &&
 			workflowSourceRefs.size === 0 &&
+			localEvidenceRefs.size === 0 &&
 			httpSourceUrls.length > 0
 		) {
 			const failure = {

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

@@ -221,7 +221,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 ?? ""),
 	);
 }

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

@@ -468,7 +468,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) {
@@ -987,11 +994,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
@@ -1261,15 +1264,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 +1290,6 @@ export default async function renderExecutive({
 		!serializationArtifact;
 
 	let executiveSidecarPath;
-	let reportSidecarPath;
 	let auditSidecarPath;
 	try {
 		if (context.cwd && context.runId && context.taskId) {
@@ -1310,10 +1303,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 +1335,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 +1342,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/schemas/deep-research-executive-render-control.schema.json

@@ -56,7 +56,6 @@
     },
     "auditArtifact": { "type": "string" },
     "sidecarPath": { "type": "string" },
-    "reportSidecarPath": { "type": "string" },
     "auditSidecarPath": { "type": "string" },
     "reportMarkdown": { "type": "string" },
     "auditMarkdown": { "type": "string" },

package/workflows/deep-research/schemas/deep-research-verify-claims-control.schema.json

@@ -20,7 +20,10 @@
     "id": {},
     "claim": {},
     "factSlotIds": {},
-    "status": {},
+    "status": {
+      "type": "string",
+      "enum": ["verified", "partially_supported", "unsupported", "conflicting"]
+    },
     "verdictDigest": {},
     "evidence": {
       "type": "array",

package/workflows/impact-review/spec.json

@@ -92,7 +92,7 @@
             ],
             "sourcePolicy": "require-success",
             "output": {
-              "controlSchema": "./schemas/state-data-impact-control.schema.json",
+              "controlSchema": "./schemas/api-contract-impact-control.schema.json",
               "analysis": {
                 "required": true
               },
@@ -131,7 +131,7 @@
             ],
             "sourcePolicy": "require-success",
             "output": {
-              "controlSchema": "./schemas/docs-release-impact-control.schema.json",
+              "controlSchema": "./schemas/api-contract-impact-control.schema.json",
               "analysis": {
                 "required": true
               },
@@ -150,7 +150,7 @@
             ],
             "sourcePolicy": "require-success",
             "output": {
-              "controlSchema": "./schemas/security-performance-impact-control.schema.json",
+              "controlSchema": "./schemas/api-contract-impact-control.schema.json",
               "analysis": {
                 "required": true
               },

package/workflows/spec-review/helpers/spec-review-pipeline.mjs

@@ -169,14 +169,7 @@ export default async function specReviewPipeline({ sources, options }) {
 
 function findAnalysisOutput(sources) {
 	return (
-		sources["analysis.candidate-findings"] ??
-		sources["analysis.candidate-findings.main"] ??
-		sources["candidate-findings"] ??
-		sources["candidate-findings.main"] ??
-		Object.entries(sources).find(([key]) =>
-			key.includes("candidate-findings"),
-		)?.[1] ??
-		{}
+		sources["candidate-findings"] ?? sources["candidate-findings.main"] ?? {}
 	);
 }