dsh-llm-verifier 0.2.1 → 0.3.1

package/lib/index.js

@@ -384,6 +384,51 @@ function blankStats() {
 function unorderedPair(a, b) {
 	return a < b ? a + "," + b : b + "," + a;
 }
+/**
+* Deterministic A/B slot for one pivot-round pair, balanced by construction.
+*
+* The round used to emit `[candidate, pivot]` for every edge, so the ring leaders sat
+* in trajectory B in all of their extra matches: with a judge that merely prefers slot A
+* the pivots averaged 0.36 against 0.60 for everyone else and sank in the final ranking.
+* Alternating on the sum of the two RANKS — not the raw indices: the pivot set is
+* selected by score, so its indices can share a parity and a parity rule would then
+* handicap half the field — gives every pivot and every candidate both slots within one
+* edge of each other, without a second model call.
+*
+* Deliberately NOT in core.ts: `pivotRoundPairs` is compared against the upstream Python
+* reference in `parity.test.ts`, so the orientation stays an orchestration-side decision.
+* @param pair - one unordered pair from the pivot round.
+* @param pivotRanks - pivot index → its rank among the pivots.
+* @param nonPivotRanks - candidate index → its rank among the non-pivots.
+* @returns The pair in the order it should be presented.
+*/
+function orientRoundPairs(pairs) {
+	const balance = /* @__PURE__ */ new Map();
+	return pairs.map(([a, b]) => {
+		const first = balance.get(a) ?? 0;
+		const [x, y] = (balance.get(b) ?? 0) < first ? [b, a] : [a, b];
+		balance.set(x, (balance.get(x) ?? 0) + 1);
+		balance.set(y, (balance.get(y) ?? 0) - 1);
+		return [x, y];
+	});
+}
+/**
+* Arbitrary but fixed A/B slot for the single pair of a two-candidate select.
+*
+* There is only one match, so nothing can cancel a preference; the mix at least stops
+* candidate 0 from always sitting in slot A. Real comparisons go through `compare`,
+* where `routedRepeats` runs an even number of rounds instead.
+* @param a - first candidate index of the pair.
+* @param b - second candidate index of the pair.
+* @returns The pair in the order it should be presented.
+*/
+function orientPair(a, b) {
+	const lo = Math.min(a, b);
+	const hi = Math.max(a, b);
+	let mixed = Math.imul(lo + 1, 2654435761) ^ Math.imul(hi + 1, 2246822519);
+	mixed = Math.imul(mixed ^ mixed >>> 15, 625341585);
+	return ((mixed ^ mixed >>> 13) & 1) === 0 ? [a, b] : [b, a];
+}
 function judgeLabel(client) {
 	return client.label?.trim() || client.provider + "/" + client.model;
 }
@@ -739,10 +784,11 @@ var VerifierEngine = class {
 			};
 		}
 		if (options.candidates.length === 2) {
-			const { rewards, judgeRewards, judgeOk, judgeErrors, judgeCalls, stats } = await this.scorePairs(options, [[0, 1]], signal);
+			const single = orientPair(0, 1);
+			const { rewards, judgeRewards, judgeOk, judgeErrors, judgeCalls, stats } = await this.scorePairs(options, [single], signal);
 			const wins = [0, 0];
 			const counts = [0, 0];
-			accumulatePairs([[0, 1]], rewards, wins, counts);
+			accumulatePairs([single], rewards, wins, counts);
 			const ranked = rankScores(wins, counts);
 			const index = ranked[0].index;
 			const judges = this.clients.map((client, k) => {
@@ -787,7 +833,7 @@ var VerifierEngine = class {
 		accumulatePairs(ring, ringScores.rewards, firstWins, firstCounts);
 		const pivots = topPivots(firstWins, firstCounts, options.pivots ?? 2);
 		const ringPairs = new Set(ring.map((pair) => unorderedPair(pair[0], pair[1])));
-		const rounds = pivotRoundPairs(options.candidates.length, pivots).filter((pair) => !ringPairs.has(unorderedPair(pair[0], pair[1])));
+		const rounds = orientRoundPairs(pivotRoundPairs(options.candidates.length, pivots).filter((pair) => !ringPairs.has(unorderedPair(pair[0], pair[1]))));
 		const roundScores = await this.scorePairs(options, rounds, signal);
 		const allRewards = new Map([...ringScores.rewards, ...roundScores.rewards]);
 		const wins = new Array(options.candidates.length).fill(0);
@@ -1108,6 +1154,25 @@ function blockText$1(blocks) {
 	visit(blocks);
 	return parts.join("\n").trim();
 }
+/**
+* Text of one assistant turn, excluding reasoning blocks.
+*
+* Used only as the newest checkpoint's narration. Prose is not evidence, but for a
+* deliverable that lives in prose (a review, an analysis) it is the only thing that
+* describes the current state at all, so the judge receives it explicitly labelled
+* as a claim instead of being shown nothing about the deliverable.
+* @param blocks - content blocks of an `assistant/message` event.
+* @returns The joined text, trimmed.
+*/
+function narrativeText(blocks) {
+	const parts = [];
+	const visit = (items) => {
+		for (const block of items) if (block.type === "text") parts.push(block.text);
+		else if (block.type === "tool-result") visit(block.content);
+	};
+	visit(blocks);
+	return parts.join("\n").trim();
+}
 function successful(event) {
 	return event.data.error === void 0 && event.data.message.content.every((block) => block.isError !== true);
 }
@@ -1130,6 +1195,8 @@ function buildEvidenceIndex(events) {
 	const teamTasks = /* @__PURE__ */ new Map();
 	const paired = /* @__PURE__ */ new Map();
 	const currentTeamTasks = /* @__PURE__ */ new Map();
+	let narration;
+	const dispatchedTools = /* @__PURE__ */ new Map();
 	for (const rawEvent of relevant) {
 		const event = rawEvent;
 		if (event.type === "tool/call") calls.set(String(event.data.callId), rawEvent);
@@ -1141,8 +1208,21 @@ function buildEvidenceIndex(events) {
 				currentTeamTasks.set(data.task.id, { ...data.task });
 				teamTasks.set(event.seq, [...currentTeamTasks.values()]);
 			}
+		} else if (event.type === "assistant/message") {
+			const blocks = event.data?.message?.content ?? event.data?.content;
+			const text = narrativeText(Array.isArray(blocks) ? blocks : []);
+			if (text) narration = {
+				seq: event.seq,
+				text
+			};
 		} else if (event.type === "tool/ptc-dispatch" || event.type === "tool/code-dispatch") {
 			const data = event.data;
+			const rootCallId = typeof data.rootCallId === "string" && data.rootCallId ? data.rootCallId : void 0;
+			if (rootCallId) {
+				const names = dispatchedTools.get(rootCallId) ?? /* @__PURE__ */ new Set();
+				names.add(data.name);
+				dispatchedTools.set(rootCallId, names);
+			}
 			if (data.isError !== true && (!Array.isArray(data.content) || data.content.every((b) => b.isError !== true))) {
 				const subCallId = String(data.subCallId ?? "code:" + event.seq);
 				const content = Array.isArray(data.content) ? data.content : [];
@@ -1157,7 +1237,9 @@ function buildEvidenceIndex(events) {
 	}
 	for (const [callId, call] of calls) {
 		const result = results.get(callId);
-		if (result) paired.set(callId, {
+		if (!result) continue;
+		if (onlyBookkeepingDispatches(dispatchedTools.get(callId))) continue;
+		paired.set(callId, {
 			name: call.data.name,
 			callSeq: call.seq,
 			resultSeq: result.seq,
@@ -1168,7 +1250,8 @@ function buildEvidenceIndex(events) {
 		problemSeq: taskStartSeq,
 		calls: paired,
 		todos,
-		teamTasks
+		teamTasks,
+		narration
 	};
 }
 function parseTrustedWorkflow(value, callId, callSeq, resultSeq, maxCandidates, maxItemChars, maxInputChars) {
@@ -1225,23 +1308,68 @@ function canonicalTodoSnapshots(index) {
 	return values;
 }
 /**
+* Tools whose successful output only maintains the agent's own bookkeeping.
+*
+* A checkpoint already renders the todo/team snapshot these tools wrote, so their
+* own result repeats it while displacing the real work output that came just before
+* them.
+*
+* `present` belongs here for the same reason: declaring deliverables produces no
+* independent output, and it is always the LAST call of a turn. A live session ran
+* typecheck + the full suite, committed, then presented — and every stop boundary
+* showed the judge "Latest observed tool output at routing time (run_code):
+* presented: 8" instead of the verification run one call earlier. Following its own
+* rule ("a state without real verification should not exceed K"), the judge capped
+* the newest checkpoint at exactly K = 52.6% against a 0.8 threshold on four
+* consecutive routes, so each one steered "continue the unfinished work" for work
+* that was finished and verified. The `deliverables/presented` event still records
+* what was presented; the tool result adds nothing the judge can grade.
+*/
+const BOOKKEEPING_TOOLS = /* @__PURE__ */ new Set([
+	"todo_write",
+	"create_goal",
+	"get_goal",
+	"update_goal",
+	"interrupt_agent",
+	"list_agents",
+	"exit_plan_mode",
+	"skill",
+	"present"
+]);
+/** Whether a wrapper's dispatches were all bookkeeping; undefined/empty means it dispatched nothing. */
+function onlyBookkeepingDispatches(names) {
+	if (names === void 0 || names.size === 0) return false;
+	for (const name of names) if (!BOOKKEEPING_TOOLS.has(name)) return false;
+	return true;
+}
+/**
 * Observed tool evidence available at one checkpoint.
 *
 * A checkpoint rendered from todo/team text alone can never clear the progress
 * threshold: the judge prompt explicitly refuses to credit a state that carries
 * no observed output. The most recent successful tool result at or before the
 * checkpoint is therefore attached as evidence.
+*
+* Bookkeeping tools are skipped: the checkpoint already renders the todo/team
+* snapshot they wrote, so their own result repeats it while displacing the real
+* output produced just before them (a live session attached `create_goal`,
+* `update_goal` and `interrupt_agent` output to checkpoints that had already run
+* the task's test suite).
 * @param index - evidence index of the current task.
-* @param seq - checkpoint sequence number.
+* @param seq - checkpoint sequence number, or `Infinity` for the current state.
 * @param budget - maximum characters the evidence may occupy.
+* @param current - render the newest output in the task instead of the newest one before `seq`.
 * @returns Evidence block, or '' when the task produced none yet.
 */
-function checkpointEvidence(index, seq, budget) {
+function checkpointEvidence(index, seq, budget, current = false) {
 	if (budget < 64) return "";
 	let latest;
-	for (const pair of index.calls.values()) if (pair.resultSeq <= seq && (latest === void 0 || pair.resultSeq > latest.resultSeq)) latest = pair;
+	for (const pair of index.calls.values()) {
+		if (BOOKKEEPING_TOOLS.has(pair.name) || !pair.text.trim()) continue;
+		if (pair.resultSeq <= seq && (latest === void 0 || pair.resultSeq > latest.resultSeq)) latest = pair;
+	}
 	if (latest === void 0) return "";
-	const prefix = "\n\nLatest observed tool output before this checkpoint (" + latest.name + "):\n";
+	const prefix = current ? "\n\nLatest observed tool output at routing time (" + latest.name + "):\n" : "\n\nLatest observed tool output before this checkpoint (" + latest.name + "):\n";
 	if (prefix.length >= budget) return "";
 	return prefix + sanitizeVerifierText(latest.text, budget - prefix.length);
 }
@@ -1276,6 +1404,12 @@ const MAX_ROUTED_CHECKPOINTS = 6;
 * The result fits both caps by construction: each step is at most min(maxItemChars,
 * maxInputChars / kept.length) characters, so the combined length can never exceed
 * maxInputChars and boundDecision() no longer drops the whole route.
+*
+* The newest checkpoint is also the state the route is judging, so it is rendered as
+* the CURRENT state: its evidence is the newest observed output in the task rather
+* than the newest one before the last todo snapshot (which is often several tool calls
+* stale), and it carries the agent's latest prose as an explicitly labelled claim (see
+* {@link currentNarration}), because prose deliverables never reach a tool.
 * @param index - evidence index of the current task.
 * @param sources - checkpoints in chronological order.
 * @param maxItemChars - hard per-item cap enforced by boundDecision().
@@ -1295,13 +1429,35 @@ function renderCheckpointSteps(index, sources, maxItemChars, maxInputChars) {
 	return {
 		steps: kept.map((source, position) => {
 			const note = position === 0 && omitted > 0 ? "Earlier " + omitted + " checkpoint(s) omitted; showing the " + kept.length + " most recent.\n" : "";
-			const evidence = checkpointEvidence(index, source.seq, evidenceBudget);
-			return sanitizeVerifierText(note + source.label + source.body, Math.max(1, stepCap - evidence.length)) + evidence;
+			const isCurrent = position === kept.length - 1;
+			const observed = checkpointEvidence(index, isCurrent ? Number.POSITIVE_INFINITY : source.seq, isCurrent ? Math.floor(evidenceBudget / 2) : evidenceBudget, isCurrent);
+			const narration = isCurrent ? currentNarration(index, evidenceBudget - observed.length) : "";
+			return sanitizeVerifierText(note + source.label + source.body, Math.max(1, stepCap - observed.length - narration.length)) + observed + narration;
 		}),
 		evidenceSeqs: kept.map((source) => source.seq),
 		omitted
 	};
 }
+/**
+* The agent's newest unverified prose, attached to the current checkpoint.
+*
+* Progress checkpoints are graded against "would this state satisfy the task", and
+* for work whose deliverable is prose the todo snapshot plus one tool result say
+* nothing about it: every checkpoint then scores "certainly NO" even though the
+* deliverable exists (a live review task scored 0% on all four checkpoints while the
+* final session acceptance of the same work passed). The block is labelled as a claim
+* so the judge can weigh it without treating it as observed output.
+* @param index - evidence index of the current task.
+* @param budget - maximum characters the narration may occupy.
+* @returns Narration block, or '' when the task produced no prose or has no budget.
+*/
+function currentNarration(index, budget) {
+	const narration = index.narration;
+	if (narration === void 0 || budget < 64) return "";
+	const prefix = "\n\nNewest agent narration in this task (the agent's own claim — NOT observed evidence):\n";
+	if (87 >= budget) return "";
+	return prefix + sanitizeVerifierText(narration.text, budget - 87);
+}
 function canonicalTeamTaskSnapshots(index) {
 	const values = [];
 	let previous = "";
@@ -1368,7 +1524,8 @@ function analyzeStructuredRoute(events, maxCandidates = 8, maxItemChars = 2e4, m
 				reason: "changed durable todo snapshots",
 				fingerprint: stableHash({
 					kind: "track",
-					snapshots
+					snapshots,
+					steps: rendered.steps
 				}),
 				steps: rendered.steps,
 				checkpoints: rendered.steps.map((_, i) => i + 1),
@@ -1389,7 +1546,8 @@ function analyzeStructuredRoute(events, maxCandidates = 8, maxItemChars = 2e4, m
 				reason: "changed durable team tasks",
 				fingerprint: stableHash({
 					kind: "track",
-					teamSnapshots
+					teamSnapshots,
+					steps: rendered.steps
 				}),
 				steps: rendered.steps,
 				checkpoints: rendered.steps.map((_, i) => i + 1),
@@ -1398,12 +1556,35 @@ function analyzeStructuredRoute(events, maxCandidates = 8, maxItemChars = 2e4, m
 		}
 	}
 }
+/**
+* Artifacts that only the classifier can turn into candidates.
+*
+* Todo and team snapshots are deliberately absent. They are the structured track
+* route's own input, and that route runs first — so listing them here could only make
+* the hint true in shapes the structured pass already claimed (or in a task that
+* already ran an explicit `verifier_track`, where re-classifying the same snapshots is
+* not wanted). The one shape left out is a snapshot series whose lists are all shorter
+* than two items, which is not worth a classification call.
+*/
+const HINT_ARTIFACTS = /* @__PURE__ */ new Set([
+	"subagent",
+	"subagent_fork",
+	"workflow",
+	"exit_plan_mode"
+]);
+/**
+* Whether a smart-mode stop boundary is worth a semantic classification call.
+*
+* The semantic phase only runs when the structured pass produced nothing, so this
+* answers "is there material the structured pass never consumes?" — never "are there
+* todo/team snapshots?", which the structured pass would have used already.
+* @param events - Session event log.
+* @returns True when a subagent/workflow/plan artifact exists.
+*/
 function semanticRouteHint(events) {
 	const index = buildEvidenceIndex(events);
 	if (!index) return false;
-	if ([...index.calls.values()].some((pair) => pair.name === "subagent" || pair.name === "subagent_fork" || pair.name === "workflow" || pair.name === "exit_plan_mode")) return true;
-	if (canonicalTodoSnapshots(index).length >= 2) return true;
-	if (canonicalTeamTaskSnapshots(index).length >= 2) return true;
+	for (const pair of index.calls.values()) if (HINT_ARTIFACTS.has(pair.name)) return true;
 	return false;
 }
 function buildSemanticRoutePrompt(problem, events, maxCandidates, maxItemChars = 2e4, maxInputChars = 6e4) {
@@ -1413,6 +1594,7 @@ function buildSemanticRoutePrompt(problem, events, maxCandidates, maxItemChars =
 	let used = 0;
 	let omitted = 0;
 	for (const [callId, pair] of [...index.calls.entries()].reverse()) {
+		if (BOOKKEEPING_TOOLS.has(pair.name)) continue;
 		const text = sanitizeVerifierText(pair.text, maxItemChars);
 		if (artifacts.length > 0 && used + text.length > maxInputChars) {
 			omitted += 1;
@@ -1513,7 +1695,8 @@ function semanticDecision(output, events, maxItemChars = 2e4, maxInputChars = 6e
 	const perItem = itemBudget(output.candidateCallIds.length, maxItemChars, maxInputChars);
 	const candidates = output.candidateCallIds.map((callId, i) => {
 		const pair = index.calls.get(callId);
-		return pair ? {
+		if (!pair || BOOKKEEPING_TOOLS.has(pair.name)) return void 0;
+		return {
 			id: callId,
 			groupId: "semantic",
 			label: pair.name + " " + (i + 1),
@@ -1521,7 +1704,7 @@ function semanticDecision(output, events, maxItemChars = 2e4, maxInputChars = 6e
 			callId,
 			fromSeq: pair.callSeq,
 			toSeq: pair.resultSeq
-		} : void 0;
+		};
 	}).filter((candidate) => candidate !== void 0);
 	if (candidates.length !== output.candidateCallIds.length) return void 0;
 	const fingerprint = stableHash({
@@ -1556,6 +1739,26 @@ function semanticDecision(output, events, maxItemChars = 2e4, maxInputChars = 6e
 * @param criteriaCount - number of criteria evaluated per comparison.
 * @returns The planned model-call count, never below 1.
 */
+/**
+* Scoring repeats a routed decision actually runs.
+*
+* `compare` judges ONE unordered pair, and `VerifierEngine.compare` only swaps the
+* candidates on odd repeat indices — with the shipped default of a single round the
+* first candidate therefore always sat in slot A, so the winner was partly decided by
+* listing order. Rounding its count up to an even number averages a swapped round and
+* cancels that.
+*
+* `select` does not need it: its ring is symmetric by construction and the pivot round
+* is oriented per pair by the engine, so one round is already unbiased. `track` scores
+* a single checkpoint list and has no slots at all.
+* @param decision - the routed decision about to run.
+* @param configured - the configured auto-route repeat count.
+* @returns The repeat count to pass to the engine.
+*/
+function routedRepeats(decision, configured) {
+	if (decision.kind !== "compare") return configured;
+	return configured % 2 === 0 ? configured : configured + 1;
+}
 function estimateRoutedCalls(decision, repeats, criteriaCount) {
 	if (decision.kind === "compare") return Math.max(1, criteriaCount * repeats);
 	if (decision.kind === "track") return Math.max(1, repeats);
@@ -1754,7 +1957,23 @@ function parseSessionVerdict(value) {
 	if (start < 0 || end <= start) return void 0;
 	try {
 		const parsed = JSON.parse(text.slice(start, end + 1));
-		return typeof parsed === "object" && parsed !== null ? parsed : void 0;
+		if (typeof parsed !== "object" || parsed === null) return void 0;
+		const row = parsed;
+		const criteria = [];
+		for (const entry of Array.isArray(row.criteria) ? row.criteria : []) {
+			const item = typeof entry === "object" && entry !== null ? entry : {};
+			if (typeof item.id !== "string" || typeof item.scoreA !== "number" || !Number.isFinite(item.scoreA)) continue;
+			criteria.push({
+				id: item.id,
+				...typeof item.name === "string" ? { name: item.name } : {},
+				score: item.scoreA
+			});
+		}
+		return {
+			winner: row.winner,
+			score: row.score,
+			criteria
+		};
 	} catch {
 		return;
 	}
@@ -1810,7 +2029,8 @@ function analyzeAutoTask(events, policy) {
 		manualVerdicts.push({
 			seq: result.seq,
 			winner: verdict?.winner,
-			score: verdict?.score
+			score: verdict?.score,
+			criteria: verdict?.criteria
 		});
 	}
 	for (const entry of successfulDispatches) {
@@ -1819,11 +2039,16 @@ function analyzeAutoTask(events, policy) {
 		manualVerdicts.push({
 			seq: entry.seq,
 			winner: verdict?.winner,
-			score: verdict?.score
+			score: verdict?.score,
+			criteria: verdict?.criteria
 		});
 	}
 	const hasManualSessionVerification = manualVerdicts.length > 0;
-	const manualVerificationAccepted = manualVerdicts.some((verdict) => verdict.winner === "A" && typeof verdict.score === "number" && verdict.score >= policy.threshold && !stale(verdict.seq));
+	const manualVerificationAccepted = manualVerdicts.some((verdict) => verdict.winner === "A" && typeof verdict.score === "number" && sessionAccepted({
+		score: verdict.score,
+		winner: "A",
+		criteria: verdict.criteria
+	}, policy.threshold) && !stale(verdict.seq));
 	if (policy.mode === "manual") return {
 		taskStartSeq,
 		toolCalls,
@@ -1886,49 +2111,40 @@ function analyzeAutoTask(events, policy) {
 	};
 }
 /**
-* Session/task acceptance budget.
+* Criteria that do not clear the acceptance threshold.
 *
-* The automatic verifier enforces its per-task and per-session budget through
-* {@link AutoVerifierRouter} reservations, which also count the routing phases;
-* this standalone counter is kept as a public utility for orchestrators that
-* need the same accounting outside the router.
+* The acceptance score is the MEAN over criteria, so a session with one requirement at
+* zero and the others perfect averaged ~0.67 and cleared the 0.65 default: a single
+* failed requirement was arithmetically invisible. The gate therefore also requires
+* every criterion to clear the threshold on its own.
+* @param criteria - per-criterion A-side scores, when the judge reported them.
+* @param threshold - acceptance threshold.
+* @returns The failing criteria, in report order.
 */
-var AutoVerificationBudget = class {
-	states = /* @__PURE__ */ new Map();
-	claim(agent, evidence, policy) {
-		if (!evidence.eligible) return false;
-		const id = String(agent.id);
-		const state = this.states.get(id) ?? {
-			taskStartSeq: evidence.taskStartSeq,
-			taskAttempts: 0,
-			sessionAttempts: 0,
-			lastEvaluatedSeq: -1
-		};
-		if (state.taskStartSeq !== evidence.taskStartSeq) {
-			state.taskStartSeq = evidence.taskStartSeq;
-			state.taskAttempts = 0;
-			state.lastEvaluatedSeq = -1;
-		}
-		const lastSeq = sessionEvents(agent.session).at(-1)?.seq ?? -1;
-		if (lastSeq <= state.lastEvaluatedSeq || state.taskAttempts >= policy.maxPerTask || state.sessionAttempts >= policy.maxPerSession) {
-			this.states.set(id, state);
-			return false;
-		}
-		state.taskAttempts += 1;
-		state.sessionAttempts += 1;
-		state.lastEvaluatedSeq = lastSeq;
-		this.states.set(id, state);
-		return true;
-	}
-	release(agent) {
-		this.states.delete(String(agent.id));
-	}
-};
-function automaticFeedback(score, baselineScore, winner, threshold) {
+function failedAcceptanceCriteria(criteria, threshold) {
+	return (criteria ?? []).filter((criterion) => !(criterion.score >= threshold));
+}
+/**
+* Whether a session acceptance clears the gate.
+*
+* The empty-work baseline is a fixed sentence that always scores 0, so the comparison
+* itself is decorative; what actually decides is the session's own score, the winner
+* against that baseline, and (since the mean could hide a failed requirement) every
+* criterion clearing the threshold.
+* @param evidence - session acceptance result (score, winner and per-criterion scores).
+* @param threshold - acceptance threshold.
+* @returns True only when the session may conclude.
+*/
+function sessionAccepted(evidence, threshold) {
+	if (evidence.winner !== "A" || !(evidence.score >= threshold)) return false;
+	return failedAcceptanceCriteria(evidence.criteria, threshold).length === 0;
+}
+function automaticFeedback(score, baselineScore, winner, threshold, failedCriteria = []) {
 	const percent = (value) => (value * 100).toFixed(1) + "%";
 	return [
 		"[Automatic verifier gate]",
 		`The independent verifier did not clear this task for completion: evidence score ${percent(score)}, baseline ${percent(baselineScore)}, verdict ${winner}, required ${percent(threshold)}.`,
+		...failedCriteria.length > 0 ? ["Criteria below the threshold: " + failedCriteria.map((criterion) => (criterion.name ?? criterion.id) + " " + percent(criterion.score)).join("; ") + "."] : [],
 		"Re-open the task requirements, inspect the actual tool outputs for unresolved errors or missing proof, make any necessary corrections, and run a directly relevant verification command before concluding. Do not merely restate that the task is complete."
 	].join("\n");
 }
@@ -2069,12 +2285,100 @@ const VERIFIER_TOOL_NAMES = [
 	"verifier_track",
 	"verifier_current_session"
 ];
+/** Upper bound on the stored checkpoint progression; one explicit call can legitimately carry 32 steps. */
+const MAX_VERDICT_SCORES = 64;
+/** Upper bound on the stored per-criterion breakdown; the default rubric has three criteria. */
+const MAX_VERDICT_CRITERIA = 16;
+/**
+* Compact summary of what the judges decided, stored beside the call counters so
+* the dashboard can answer "why did this fail?" instead of only "how much did it cost".
+*
+* Pure on purpose: this mapping used to live inside the plugin closure, where the two
+* bugs it carried (a track verdict reported as the historical minimum, a comparison
+* reported as the loser's score under a threshold it never used) could not be tested.
+* @param toolName - the verifier tool that produced the value.
+* @param value - its rendered result.
+* @param phase - which stage produced it (explicit | compare | select | track | final | ...).
+* @param thresholds - resolved acceptance thresholds.
+* @returns A verdict summary; score fields are omitted when the tool has none.
+*/
+function summarizeVerdict(toolName, value, phase, thresholds) {
+	const row = typeof value === "object" && value !== null ? value : {};
+	const numberAt = (key) => typeof row[key] === "number" && Number.isFinite(row[key]) ? row[key] : void 0;
+	const scores = Array.isArray(row.scores) ? row.scores.filter((entry) => typeof entry === "number" && Number.isFinite(entry)) : [];
+	const winner = row.winner === "A" || row.winner === "B" || row.winner === "tie" ? row.winner : void 0;
+	if (toolName === "verifier_route_classify") return {
+		phase,
+		outcome: "classified"
+	};
+	if (toolName === "verifier_select") {
+		const index = numberAt("index");
+		const best = index === void 0 ? void 0 : scores[index];
+		return {
+			phase,
+			outcome: "ranked",
+			...best !== void 0 ? { score: best } : {}
+		};
+	}
+	if (toolName === "verifier_track") {
+		const latest = scores.length > 0 ? scores[scores.length - 1] : void 0;
+		const threshold = thresholds.autoTrackCompletionThreshold;
+		return {
+			phase,
+			outcome: latest !== void 0 && latest >= threshold ? "passed" : "below-threshold",
+			...latest !== void 0 ? { score: latest } : {},
+			...scores.length > 1 ? { scores: [...scores] } : {},
+			threshold
+		};
+	}
+	if (toolName === "verifier_compare") {
+		const scoreA = numberAt("score") ?? numberAt("scoreA");
+		const scoreB = numberAt("scoreB");
+		const score = winner === "B" ? scoreB : scoreA;
+		return {
+			phase,
+			outcome: winner === "tie" ? "tie" : "compared",
+			...score !== void 0 ? { score } : {},
+			...scoreB !== void 0 ? { scoreB } : {},
+			...winner !== void 0 ? { winner } : {}
+		};
+	}
+	const score = numberAt("score") ?? numberAt("scoreA");
+	const baselineScore = numberAt("baselineScore");
+	const threshold = thresholds.autoVerifyThreshold;
+	const criteria = Array.isArray(row.criteria) ? row.criteria.map((entry) => typeof entry === "object" && entry !== null ? entry : {}).filter((entry) => typeof entry.id === "string" && typeof entry.scoreA === "number" && Number.isFinite(entry.scoreA)).slice(0, MAX_VERDICT_CRITERIA).map((entry) => ({
+		id: entry.id,
+		score: entry.scoreA
+	})) : [];
+	const belowThreshold = criteria.filter((entry) => !(entry.score >= threshold));
+	return {
+		phase,
+		outcome: winner === "tie" ? "tie" : winner === "A" && score !== void 0 && score >= threshold && belowThreshold.length === 0 ? "passed" : "below-threshold",
+		...score !== void 0 ? { score } : {},
+		...baselineScore !== void 0 ? { baselineScore } : {},
+		...criteria.length > 0 ? { criteria } : {},
+		...winner !== void 0 ? { winner } : {},
+		threshold
+	};
+}
 function cleanVerdict(input) {
 	if (typeof input !== "object" || input === null || Array.isArray(input)) return void 0;
 	const verdict = {};
 	if (typeof input.phase === "string") verdict.phase = input.phase;
 	if (typeof input.outcome === "string") verdict.outcome = input.outcome;
 	if (typeof input.score === "number" && Number.isFinite(input.score)) verdict.score = input.score;
+	if (Array.isArray(input.scores)) {
+		const scores = input.scores.filter((entry) => typeof entry === "number" && Number.isFinite(entry)).slice(0, MAX_VERDICT_SCORES);
+		if (scores.length > 0) verdict.scores = scores;
+	}
+	if (typeof input.scoreB === "number" && Number.isFinite(input.scoreB)) verdict.scoreB = input.scoreB;
+	if (Array.isArray(input.criteria)) {
+		const criteria = input.criteria.filter((entry) => typeof entry === "object" && entry !== null && typeof entry.id === "string" && typeof entry.score === "number" && Number.isFinite(entry.score)).slice(0, MAX_VERDICT_CRITERIA).map((entry) => ({
+			id: entry.id,
+			score: entry.score
+		}));
+		if (criteria.length > 0) verdict.criteria = criteria;
+	}
 	if (typeof input.baselineScore === "number" && Number.isFinite(input.baselineScore)) verdict.baselineScore = input.baselineScore;
 	if (input.winner === "A" || input.winner === "B" || input.winner === "tie") verdict.winner = input.winner;
 	if (typeof input.threshold === "number" && Number.isFinite(input.threshold)) verdict.threshold = input.threshold;
@@ -2842,54 +3146,12 @@ function apply(ctx, config = {}) {
 	const requireEnabled = () => {
 		if (!current().enabled) throw new Error("llm-verifier: verifier tools are disabled — enable them in Settings → LLM Verifier");
 	};
-	/**
-	* Compact summary of what the judges decided, stored beside the call counters so
-	* the dashboard can answer "why did this fail?" instead of only "how much did it cost".
-	* @param toolName - the verifier tool that produced the value.
-	* @param value - its rendered result.
-	* @param phase - which stage produced it (explicit | compare | select | track | final | ...).
-	* @returns A verdict summary; score fields are omitted when the tool has none.
-	*/
 	const verdictFrom = (toolName, value, phase) => {
 		const selected = current();
-		const row = typeof value === "object" && value !== null ? value : {};
-		const numberAt = (key) => typeof row[key] === "number" && Number.isFinite(row[key]) ? row[key] : void 0;
-		const scores = Array.isArray(row.scores) ? row.scores.filter((entry) => typeof entry === "number" && Number.isFinite(entry)) : [];
-		const winner = row.winner === "A" || row.winner === "B" || row.winner === "tie" ? row.winner : void 0;
-		if (toolName === "verifier_route_classify") return {
-			phase,
-			outcome: "classified"
-		};
-		if (toolName === "verifier_select") {
-			const index = numberAt("index");
-			const best = index === void 0 ? void 0 : scores[index];
-			return {
-				phase,
-				outcome: "ranked",
-				...best !== void 0 ? { score: best } : {}
-			};
-		}
-		if (toolName === "verifier_track") {
-			const worst = scores.length > 0 ? Math.min(...scores) : void 0;
-			const threshold = selected.autoTrackCompletionThreshold;
-			return {
-				phase,
-				outcome: worst !== void 0 && worst >= threshold ? "passed" : "below-threshold",
-				...worst !== void 0 ? { score: worst } : {},
-				threshold
-			};
-		}
-		const score = numberAt("score") ?? numberAt("scoreA");
-		const baselineScore = numberAt("baselineScore");
-		const threshold = selected.autoVerifyThreshold;
-		return {
-			phase,
-			outcome: winner === "tie" ? "tie" : winner === "A" && score !== void 0 && score >= threshold ? "passed" : "below-threshold",
-			...score !== void 0 ? { score } : {},
-			...baselineScore !== void 0 ? { baselineScore } : {},
-			...winner !== void 0 ? { winner } : {},
-			threshold
-		};
+		return summarizeVerdict(toolName, value, phase, {
+			autoVerifyThreshold: selected.autoVerifyThreshold,
+			autoTrackCompletionThreshold: selected.autoTrackCompletionThreshold
+		});
 	};
 	const record = async (toolName, agent, operation, phase = "explicit") => {
 		const startedAt = Date.now();
@@ -2996,6 +3258,11 @@ function apply(ctx, config = {}) {
 				score: compared.scoreA,
 				baselineScore: compared.scoreB,
 				winner: compared.winner,
+				criteria: compared.criteria.map((row) => ({
+					id: row.id,
+					name: row.name,
+					score: row.scoreA
+				})),
 				fromSeq: extracted.fromSeq,
 				toSeq: extracted.toSeq,
 				omittedCharacters: extracted.omittedCharacters,
@@ -3235,8 +3502,9 @@ function apply(ctx, config = {}) {
 					}
 					const verdict = parseVerdictLetter(classified.text);
 					if (verdict === void 0) {
-						autoRouter.fail(agent, taskReservation, false);
-						ctx.logger.warn("llm-verifier team task verification produced no verdict line; task " + task.id + " was not gated");
+						const strict = selected.autoVerifyMode === "strict";
+						autoRouter.fail(agent, taskReservation, strict);
+						ctx.logger.warn("llm-verifier team task verification produced no verdict line; task " + task.id + (strict ? " stays blocked" : " was not gated"));
 						continue;
 					}
 					if (verdict.score >= selected.autoVerifyThreshold) {
@@ -3330,7 +3598,8 @@ function apply(ctx, config = {}) {
 		}
 		if (!stillCurrent()) return;
 		if (decision) {
-			const expectedCalls = estimateRoutedCalls(decision, selected.autoVerifyRepeats, DEFAULT_CRITERIA.length) * selected.judges.length;
+			const repeats = routedRepeats(decision, selected.autoVerifyRepeats);
+			const expectedCalls = estimateRoutedCalls(decision, repeats, DEFAULT_CRITERIA.length) * selected.judges.length;
 			const reservation = autoRouter.reserve(agent, decision.kind, decision.fingerprint, expectedCalls, policy);
 			if (reservation === void 0) {
 				const exhausted = autoRouter.budgetExhausted(agent, expectedCalls, policy);
@@ -3354,7 +3623,7 @@ function apply(ctx, config = {}) {
 			if (reservation) try {
 				const extracted = await extractTask(agent, evidence.taskStartSeq, admittedLastSeq, selected.autoVerifyMaxChars, signal);
 				if (decision.kind === "compare") {
-					const result = await compareCandidates(agent, extracted.problem, decision.candidates[0].content, decision.candidates[1].content, selected.autoVerifyRepeats, signal, extracted.images, "compare");
+					const result = await compareCandidates(agent, extracted.problem, decision.candidates[0].content, decision.candidates[1].content, repeats, signal, extracted.images, "compare");
 					if (!stillCurrent()) {
 						autoRouter.fail(agent, reservation, false);
 						return;
@@ -3365,7 +3634,7 @@ function apply(ctx, config = {}) {
 					return;
 				}
 				if (decision.kind === "select") {
-					const result = await selectCandidates(agent, extracted.problem, decision.candidates.map((candidate) => candidate.content), selected.autoVerifyRepeats, signal, extracted.images, "select");
+					const result = await selectCandidates(agent, extracted.problem, decision.candidates.map((candidate) => candidate.content), repeats, signal, extracted.images, "select");
 					if (!stillCurrent()) {
 						autoRouter.fail(agent, reservation, false);
 						return;
@@ -3375,14 +3644,14 @@ function apply(ctx, config = {}) {
 					agent.steer(routeFeedback(decision, "Ranking:\n" + ranking + "\nProceed with " + decision.candidates[result.index].label + "."));
 					return;
 				}
-				const result = await trackProgress(agent, extracted.problem, decision.steps, decision.checkpoints, selected.autoVerifyRepeats, signal, extracted.images, "track");
+				const result = await trackProgress(agent, extracted.problem, decision.steps, decision.checkpoints, repeats, signal, extracted.images, "track");
 				if (!stillCurrent()) {
 					autoRouter.fail(agent, reservation, false);
 					return;
 				}
 				if (!autoRouter.commit(agent, reservation, admittedLastSeq)) return;
 				const detail = result.scores.map((score, index) => "Checkpoint step " + decision.checkpoints[index] + ": " + (score * 100).toFixed(1) + "%").join("\n");
-				const continuation = result.scores.some((score) => score < selected.autoTrackCompletionThreshold) ? "\nContinue the unfinished work." : "\nPrepare final delivery evidence; final session verification is mandatory.";
+				const continuation = (result.scores.length > 0 ? result.scores[result.scores.length - 1] : 0) < selected.autoTrackCompletionThreshold ? "\nContinue the unfinished work." : "\nPrepare final delivery evidence; final session verification is mandatory.";
 				agent.steer(routeFeedback(decision, detail + continuation));
 				return;
 			} catch (error) {
@@ -3449,13 +3718,18 @@ function apply(ctx, config = {}) {
 				autoRouter.fail(agent, finalReservation, false);
 				return;
 			}
-			if (result.winner === "A" && result.score >= selected.autoVerifyThreshold) autoRouter.commit(agent, finalReservation);
+			const failed = failedAcceptanceCriteria(result.criteria, selected.autoVerifyThreshold);
+			if (sessionAccepted({
+				score: result.score,
+				winner: result.winner,
+				criteria: result.criteria
+			}, selected.autoVerifyThreshold)) autoRouter.commit(agent, finalReservation);
 			else {
 				autoRouter.fail(agent, finalReservation, selected.autoVerifyMode === "strict");
 				agent.steer(createUserMessage({
 					content: [{
 						type: "text",
-						text: automaticFeedback(result.score, result.baselineScore, result.winner, selected.autoVerifyThreshold)
+						text: automaticFeedback(result.score, result.baselineScore, result.winner, selected.autoVerifyThreshold, failed)
 					}],
 					source: {
 						kind: "plugin",
@@ -3843,6 +4117,6 @@ function apply(ctx, config = {}) {
 	}));
 }
 //#endregion
-export { AutoVerificationBudget, AutoVerifierRouter, Config, DEFAULT_CRITERIA, DEFAULT_GROUND_TRUTH_NOTE, GRANULARITY, LETTERS, MAX_ROUTED_CHECKPOINTS, MAX_TEAM_TASK_METADATA_CHARS, RequestLimiter, SCALE_DESCRIPTION, ScoreCache, SingleFlight, StatisticsStore, UNTRUSTED_EVIDENCE_NOTE, VERIFIER_TOOL_NAMES, VerifierEngine, accumulatePairs, analyzeAutoTask, analyzeStructuredRoute, apply, automaticFeedback, boundDecision, bradleyTerry, buildEvidenceIndex, buildPairwisePrompt, buildPlanPreReviewPrompt, buildProgressPrompt, buildSemanticRoutePrompt, buildTeamTaskVerificationPrompt, callVerifier, emptyRunStats, errorDetails, estimateRoutedCalls, evidenceNonce, extractProgressScore, extractScore, inject, inspectTeamTasks, isSubagentSession, latestDirectUserSeq, mergeStatisticsOverviews, name, normalizeCriteria, normalizeScoreLetter, parseSemanticRoute, parseStatisticsQuery, parseVerdictLetter, pivotRoundPairs, planFromArguments, rankScores, renderDelimitedBlock, resolveCacheFile, resolveStatisticsFile, resolveTopicDataDir, ringCycle, seededRandom, semanticDecision, semanticRouteHint, stableHash, topPivots };
+export { AutoVerifierRouter, Config, DEFAULT_CRITERIA, DEFAULT_GROUND_TRUTH_NOTE, GRANULARITY, LETTERS, MAX_ROUTED_CHECKPOINTS, MAX_TEAM_TASK_METADATA_CHARS, RequestLimiter, SCALE_DESCRIPTION, ScoreCache, SingleFlight, StatisticsStore, UNTRUSTED_EVIDENCE_NOTE, VERIFIER_TOOL_NAMES, VerifierEngine, accumulatePairs, analyzeAutoTask, analyzeStructuredRoute, apply, automaticFeedback, boundDecision, bradleyTerry, buildEvidenceIndex, buildPairwisePrompt, buildPlanPreReviewPrompt, buildProgressPrompt, buildSemanticRoutePrompt, buildTeamTaskVerificationPrompt, callVerifier, emptyRunStats, errorDetails, estimateRoutedCalls, evidenceNonce, extractProgressScore, extractScore, failedAcceptanceCriteria, inject, inspectTeamTasks, isSubagentSession, latestDirectUserSeq, mergeStatisticsOverviews, name, normalizeCriteria, normalizeScoreLetter, orientRoundPairs, parseSemanticRoute, parseStatisticsQuery, parseVerdictLetter, pivotRoundPairs, planFromArguments, rankScores, renderDelimitedBlock, resolveCacheFile, resolveStatisticsFile, resolveTopicDataDir, ringCycle, routedRepeats, seededRandom, semanticDecision, semanticRouteHint, sessionAccepted, stableHash, summarizeVerdict, topPivots };
 
 //# sourceMappingURL=index.js.map