dsh-llm-verifier 0.6.0 → 0.6.2

package/lib/index.js

@@ -1,6 +1,6 @@
 import { CRITERIA_PRESETS, CRITERIA_PRESET_IDS, DEFAULT_CRITERIA, DEFAULT_GROUND_TRUTH_NOTE, EMPTY_WORK_BASELINE, GRANULARITY, LETTERS, MAX_DIAGNOSTICS, MAX_DIAGNOSTIC_ACTION_CHARS, MAX_DIAGNOSTIC_CHARS, PROCESS_CRITERIA, PROPOSAL_CRITERIA, SCALE_DESCRIPTION, UNTRUSTED_EVIDENCE_NOTE, accumulatePairs, bradleyTerry, buildFindingContract, buildGenerationPrompt, buildPairwisePrompt, buildProgressPrompt, dedupeCriterionId, diagnosticKey, evidenceNonce, extractProgressScore, extractScore, normalizeScoreLetter, parseCriteriaMarkdown, parseDiagnostics, pivotRoundPairs, rankScores, renderDelimitedBlock, renderDiagnostics, renderReferenceContext, ringCycle, seededRandom, slugCriterionId, swapDiagnosticEvidence, topPivots } from "./core.js";
 import { a as attachUsage, c as emptyUsage, f as partialUsage, g as resolveCapabilityFile, h as TopLogprobCapabilityCache, i as addUsage, m as requestAttempts, o as callVerifier, p as predictScoringChannel, r as RequestLimiter, s as callVerifierText, u as generateCandidate } from "./caller-BUK7OgUs.js";
-import { A as verificationFailed, C as latestDirectUserSeq, D as semanticDecision, E as routedRepeats, F as ScoreCache, I as SingleFlight, L as resolveCacheFile, M as extractSession, N as sanitizeVerifierText, O as semanticReferencesVisible, P as sessionEvents, R as stableHash, S as itemBudget, T as parseSemanticRoute, _ as buildSemanticRoutePrompt, a as compareRouteFeedbackDetail, b as inspectDeliveryPhase, c as selectRouteFeedbackDetail, d as AutoVerifierRouter, f as MAX_ROUTED_CHECKPOINTS, g as buildEvidenceIndex, h as boundDecision, i as automaticFeedback, j as verificationVerdict, k as semanticRouteHint, l as sessionAccepted, m as analyzeStructuredRoute, n as PROPOSAL_FEEDBACK_NOTE, o as failedAcceptanceCriteria, p as RECOVERY_FAILURE_CONTEXT_CHARS, r as analyzeAutoTask, s as isSubagentSession, t as MAX_ROUTE_FEEDBACK_CHARS, u as topScoreIndices, v as buildSemanticRouteView, w as nextDiagnosticCycleId, x as inspectRecoverySignal, y as estimateRoutedCalls } from "./auto-DAMeKRkK.js";
+import { A as verificationFailed, C as latestDirectUserSeq, D as semanticDecision, E as routedRepeats, F as ScoreCache, I as SingleFlight, L as resolveCacheFile, M as extractSession, N as sanitizeVerifierText, O as semanticReferencesVisible, P as sessionEvents, R as stableHash, S as itemBudget, T as parseSemanticRoute, _ as buildSemanticRoutePrompt, a as compareRouteFeedbackDetail, b as inspectDeliveryPhase, c as selectRouteFeedbackDetail, d as AutoVerifierRouter, f as MAX_ROUTED_CHECKPOINTS, g as buildEvidenceIndex, h as boundDecision, i as automaticFeedback, j as verificationVerdict, k as semanticRouteHint, l as sessionAccepted, m as analyzeStructuredRoute, n as PROPOSAL_FEEDBACK_NOTE, o as failedAcceptanceCriteria, p as RECOVERY_FAILURE_CONTEXT_CHARS, r as analyzeAutoTask, s as isSubagentSession, t as MAX_ROUTE_FEEDBACK_CHARS, u as topScoreIndices, v as buildSemanticRouteView, w as nextDiagnosticCycleId, x as inspectRecoverySignal, y as estimateRoutedCalls } from "./auto-caXDU2pw.js";
 import { defineTool } from "@deepseek-ai/dsh-tools";
 import { createUserMessage, isAgentLoopRequest } from "@deepseek-ai/dsh-llm";
 import z from "schemastery";
@@ -1381,7 +1381,7 @@ var CriteriaResolver = class {
 	}
 };
 /**
-* Map one finished cycle onto the outcome the chip distinguishes.
+* Map one finished P06 cycle onto the outcome the chip distinguishes.
 *
 * `replayed` is the host-facing fact ("which stream did the host actually receive") and wins over
 * the outcome label: a cycle recorded as `candidate-selected` whose winner was withheld before the
@@ -1398,17 +1398,120 @@ function classifyProcessOutcome(outcome, replayed) {
 	return "failed";
 }
 /**
-* Per-session activity table. One active cycle per session, because the selector owns one phase
-* controller per session; a settled cycle replaces the previous settled one (the chip is a status
-* line, not a history — the statistics sidecar is the history).
+* Map one granted reservation onto the chip's active record.
+*
+* `process` is deliberately NOT mapped: P06 publishes its own richer record (candidate count,
+* generation vs comparison), and two writers for one cycle id would race. `plan_review` and
+* `team_task` are not announced either — the plan gate already shows a pending tool row in the
+* chat, so a chip line would only repeat it.
+* @param reservation - the reservation the router just granted.
+* @param startedAt - wall clock the cycle began at.
+* @returns The active record, or undefined for a phase the chip stays silent about.
+*/
+function reservationActivity(reservation, startedAt) {
+	switch (reservation.phase) {
+		case "semantic": return {
+			cycleId: reservation.id,
+			stage: "route",
+			phase: "classifying",
+			expectedCalls: reservation.expectedCalls,
+			startedAt
+		};
+		case "compare":
+		case "select":
+		case "track": return {
+			cycleId: reservation.id,
+			stage: "route",
+			phase: "reviewing",
+			destination: reservation.phase,
+			expectedCalls: reservation.expectedCalls,
+			startedAt
+		};
+		case "final": return {
+			cycleId: reservation.id,
+			stage: "final",
+			phase: "accepting",
+			expectedCalls: reservation.expectedCalls,
+			startedAt
+		};
+		default: return;
+	}
+}
+/**
+* Map a promotion onto the update the chip needs.
+*
+* A classification cycle that resolved to a decision stays the SAME reservation (that is what
+* promotion is for), so the chip must be moved from "classifying" to "reviewing" instead of leaving
+* a second cycle behind.
+* @param reservation - the promoted reservation, already carrying its execution phase.
+* @returns The patch, or undefined when the phase is not one the chip announces.
+*/
+function reservationPromotion(reservation) {
+	switch (reservation.phase) {
+		case "compare":
+		case "select":
+		case "track": return {
+			phase: "reviewing",
+			destination: reservation.phase,
+			expectedCalls: reservation.expectedCalls
+		};
+		default: return;
+	}
+}
+/**
+* Map a router settlement onto the chip's settled row.
+*
+* A routed verdict is steered into the chat by the caller right after the cycle settles, so a second
+* transient line would only repeat it; the final gate is the opposite (a PASSING acceptance steers
+* nothing), and that is exactly the case worth showing. `undefined` means "clear the active row and
+* leave nothing behind".
+* @param reservation - the reservation being settled.
+* @param outcome - whether the router committed or failed it.
+* @returns The stage and outcome to keep, or undefined to clear silently.
+*/
+function reservationSettled(reservation, outcome) {
+	return reservation.phase === "final" ? {
+		stage: "final",
+		outcome: outcome === "committed" ? "accepted" : "rejected"
+	} : void 0;
+}
+/**
+* Build the router's advisory observer over one activity table.
+*
+* The router supplies the reservation (it is the only component that knows a cycle was granted and
+* when it settled); this module owns what the chip says about it.
+* @param activities - the table the plugin's RPC reads.
+* @param now - wall clock used for the records and their TTLs.
+* @returns The observer to hand to `new AutoVerifierRouter(...)`.
 */
-var ProcessActivities = class {
+function createActivityObserver(activities, now = Date.now) {
+	const key = (agent) => String(agent.id);
+	return {
+		begin: (agent, reservation) => {
+			const activity = reservationActivity(reservation, now());
+			if (activity !== void 0) activities.begin(key(agent), activity);
+		},
+		promoted: (agent, reservation) => {
+			const patch = reservationPromotion(reservation);
+			if (patch !== void 0) activities.update(key(agent), reservation.id, patch);
+		},
+		settled: (agent, reservation, outcome) => {
+			const settled = reservationSettled(reservation, outcome);
+			activities.finish(key(agent), reservation.id, settled?.outcome, now());
+		}
+	};
+}
+/**
+* Per-session activity table.
+*
+* One active cycle per session, because the router owns one in-flight reservation per agent at a
+* time; a settled cycle replaces the previous settled one (the chip is a status line, not a history
+* — the statistics sidecar is the history).
+*/
+var VerifierActivities = class {
 	active = /* @__PURE__ */ new Map();
 	settled = /* @__PURE__ */ new Map();
-	/**
-	* Publish one cycle as in flight. Called once per bought cycle, after the reservation and the
-	* cycle log are in place and immediately before the alternative is dispatched.
-	*/
+	/** Publish one cycle as in flight. */
 	begin(sessionId, activity) {
 		this.active.set(sessionId, activity);
 	}
@@ -1419,50 +1522,62 @@ var ProcessActivities = class {
 	* moved back into "in flight" by a late async step.
 	* @returns whether the exact cycle was the active one.
 	*/
-	phase(sessionId, cycleId, phase) {
+	update(sessionId, cycleId, patch) {
 		const current = this.active.get(sessionId);
 		if (current === void 0 || current.cycleId !== cycleId) return false;
 		this.active.set(sessionId, {
 			...current,
-			phase
+			...patch
 		});
 		return true;
 	}
 	/**
-	* Retire one cycle and report how it resolved.
+	* Retire one cycle.
 	*
 	* A cycle nobody observed (the purchase itself failed, so `begin` never ran) leaves nothing
 	* behind: the chip must not claim a cycle that never started. A cycle that WAS observed stays
-	* correctable while its own settled record is the current one, which is what the selector's
-	* late "the winner was not delivered" correction needs.
-	* @returns whether the cycle was known and the outcome recorded.
+	* correctable while its own settled record is the current one, which is what P06's late
+	* "the winner was not delivered" correction needs.
+	* @param sessionId - the session the cycle belongs to.
+	* @param cycleId - the cycle to retire.
+	* @param outcome - the settled row to keep, or undefined to clear without leaving one.
+	* @param now - wall clock used for the settled record.
+	* @returns whether the cycle was known and retired.
 	*/
-	finish(sessionId, cycleId, outcome, replayed, now) {
-		const current = this.active.get(sessionId);
-		const known = current?.cycleId === cycleId ? current : this.settled.get(sessionId)?.cycleId === cycleId ? this.settled.get(sessionId) : void 0;
+	finish(sessionId, cycleId, outcome, now) {
+		const active = this.active.get(sessionId);
+		const settled = this.settled.get(sessionId);
+		const known = active?.cycleId === cycleId ? active : settled?.cycleId === cycleId ? settled : void 0;
 		if (known === void 0) return false;
-		if (current?.cycleId === cycleId) this.active.delete(sessionId);
+		if (active?.cycleId === cycleId) this.active.delete(sessionId);
+		if (outcome === void 0) {
+			if (settled?.cycleId === cycleId) this.settled.delete(sessionId);
+			return true;
+		}
 		this.settled.set(sessionId, {
 			cycleId,
-			outcome: classifyProcessOutcome(outcome, replayed),
-			candidates: known.candidates,
+			stage: known.stage,
+			outcome,
+			...known.candidates === void 0 ? {} : { candidates: known.candidates },
 			at: now
 		});
 		return true;
 	}
 	/**
-	* What one session has to show right now, with expired settled records pruned in place.
+	* What one session has to show right now, with expired records pruned in place.
 	* @param sessionId - the session to read.
-	* @param now - wall clock used for the settled TTL.
+	* @param now - wall clock used for both TTLs.
 	*/
 	read(sessionId, now) {
+		const active = this.active.get(sessionId);
+		if (active !== void 0 && now - active.startedAt >= 6e5) this.active.delete(sessionId);
 		const settled = this.settled.get(sessionId);
 		if (settled !== void 0 && now - settled.at >= 2e4) this.settled.delete(sessionId);
-		const active = this.active.get(sessionId);
-		const current = this.settled.get(sessionId);
+		const currentActive = this.active.get(sessionId);
+		const currentSettled = this.settled.get(sessionId);
 		return {
-			...active === void 0 ? {} : { active },
-			...current === void 0 ? {} : { settled: current }
+			...currentActive === void 0 ? {} : { active: currentActive },
+			...currentSettled === void 0 ? {} : { settled: currentSettled }
 		};
 	}
 	/** Forget one session entirely (settings changed, task replaced, agent disposed). */
@@ -1996,14 +2111,18 @@ var ProcessSelector = class {
 	*
 	* Host-only and in memory: a session event would carry the same information, but the persistence
 	* read path refuses unknown event types for an out-of-repo plugin, and `Session.append` cannot
-	* set the `ignorable` marker that would make one loadable (see `process-activity.ts`).
+	* set the `ignorable` marker that would make one loadable (see `verifier-activity.ts`).
 	*/
-	activities = new ProcessActivities();
+	activities;
 	constructor(deps) {
 		this.deps = deps;
+		this.activities = deps.activities ?? new VerifierActivities();
 	}
 	/**
 	* The cycle one session has to show right now, for the UI chip (in flight, or just settled).
+	*
+	* Reads the SAME table the router publishes into, so a routed review and a process cycle are never
+	* two different answers to "what is this session doing".
 	* @param sessionId - the session to read.
 	*/
 	activity(sessionId) {
@@ -2169,6 +2288,7 @@ var ProcessSelector = class {
 		this.cycles.set(intent.sessionId, phase);
 		this.activities.begin(intent.sessionId, {
 			cycleId: reservation.id,
+			stage: "process",
 			phase: "generating",
 			candidates: count,
 			...observation.alternativeModel === void 0 ? {} : { alternativeModel: observation.alternativeModel },
@@ -2511,7 +2631,7 @@ var ProcessSelector = class {
 				});
 				return;
 			}
-			this.activities.phase(intent.sessionId, reservation.id, "comparing");
+			this.activities.update(intent.sessionId, reservation.id, { phase: "comparing" });
 			let judged;
 			try {
 				if ("candidateA" in view) {
@@ -2530,7 +2650,8 @@ var ProcessSelector = class {
 						winner: compared.winner === "B" ? alternatives[0] : void 0,
 						tie: compared.winner === "tie",
 						stats: compared.stats,
-						compare: compared
+						compare: compared,
+						...compared.decisionId === void 0 ? {} : { decisionId: compared.decisionId }
 					};
 				} else {
 					const selected = await this.deps.select({
@@ -2547,7 +2668,8 @@ var ProcessSelector = class {
 						winner: selected.index > 0 ? alternatives[selected.index - 1] : void 0,
 						tie: false,
 						stats: selected.stats,
-						select: selected
+						select: selected,
+						...selected.decisionId === void 0 ? {} : { decisionId: selected.decisionId }
 					};
 				}
 			} catch (error) {
@@ -2622,7 +2744,7 @@ var ProcessSelector = class {
 					const outcome = "candidate-not-delivered (" + staleBeforeReplay + ")";
 					observation.replayed = "original";
 					await this.deps.store(intent.agent).finish(reservation.id, outcome, "original");
-					this.activities.finish(intent.sessionId, reservation.id, outcome, "original", this.deps.now());
+					this.activities.finish(intent.sessionId, reservation.id, classifyProcessOutcome(outcome, "original"), this.deps.now());
 					try {
 						await this.deps.correctDelivery({
 							agent: intent.agent,
@@ -2690,13 +2812,15 @@ var ProcessSelector = class {
 	}
 	/** Record a purchased cycle and stamp its durable outcome. */
 	async report(input) {
-		this.activities.finish(input.intent.sessionId, input.reservation.id, input.outcome, input.replayed, this.deps.now());
+		this.activities.finish(input.intent.sessionId, input.reservation.id, classifyProcessOutcome(input.outcome, input.replayed), this.deps.now());
 		await this.deps.store(input.intent.agent).finish(input.reservation.id, input.outcome, input.replayed);
+		const decisionId = input.compare?.decisionId ?? input.select?.decisionId;
 		await this.deps.record({
 			agent: input.intent.agent,
 			cycleId: input.reservation.id,
 			purchased: true,
 			startedAt: input.startedAt,
+			...decisionId === void 0 ? {} : { decisionId },
 			outcome: input.outcome,
 			replayed: input.replayed,
 			generatedCalls: input.generatedCalls,
@@ -3302,7 +3426,7 @@ var StatisticsStore = class {
 		const verdict = cleanVerdict(input.verdict);
 		const route = cleanRoute(input.route);
 		const record = {
-			id: randomUUID(),
+			id: typeof input.id === "string" && input.id.length > 0 ? input.id : randomUUID(),
 			toolName: input.toolName,
 			...input.sessionId ? { sessionId: input.sessionId } : {},
 			startedAt: input.startedAt,
@@ -3638,7 +3762,7 @@ var DecisionStore = class {
 		const calls = boundDecisionCalls(input.calls);
 		if (calls.length === 0) return void 0;
 		const record = {
-			id: randomUUID(),
+			id: idOf(input.id),
 			toolName: input.toolName,
 			phase: input.phase,
 			startedAt: input.startedAt,
@@ -3698,6 +3822,18 @@ var DecisionStore = class {
 	}
 };
 /**
+* The id a snapshot is filed under.
+*
+* A caller-supplied id is the statistics row's own id ({@link DecisionInput.id}), which is what
+* makes the dashboard's "one snapshot per row" lookup resolve; anything unusable falls back to a
+* fresh uuid so a malformed argument can never merge two invocations into one record.
+* @param candidate - id supplied by the caller, if any.
+* @returns The id to store the record under.
+*/
+function idOf(candidate) {
+	return typeof candidate === "string" && candidate.length > 0 ? candidate : randomUUID();
+}
+/**
 * Loose validation, so a record written by a newer/older plugin still loads.
 * @param value - parsed JSON entry.
 * @returns True when the entry carries the fields the dashboard needs.
@@ -4095,7 +4231,8 @@ function apply(ctx, config = {}) {
 		limiter = new RequestLimiter(current().maxConcurrency);
 		clearProcessIntents();
 	});
-	const autoRouter = new AutoVerifierRouter();
+	const activities = new VerifierActivities();
+	const autoRouter = new AutoVerifierRouter(createActivityObserver(activities));
 	const topics = /* @__PURE__ */ new Map();
 	const topic = (header) => {
 		const selected = current();
@@ -4258,7 +4395,7 @@ function apply(ctx, config = {}) {
 				...completed.result,
 				...route(selected)
 			};
-			await statistics.record({
+			const invocation = await statistics.record({
 				toolName,
 				sessionId: String(agent.id),
 				startedAt,
@@ -4268,8 +4405,9 @@ function apply(ctx, config = {}) {
 				stats: statsFrom(value),
 				verdict: verdictFrom(toolName, value, phase),
 				...observation ? { route: observation } : {}
-			}).catch(() => {});
+			}).catch(() => void 0);
 			if (calls.length > 0) await topicEntry.decisions.record({
+				...invocation === void 0 ? {} : { id: invocation.id },
 				toolName,
 				phase,
 				startedAt,
@@ -4877,6 +5015,7 @@ function apply(ctx, config = {}) {
 		sanitize: (text, maxChars) => sanitizeVerifierText(text, maxChars),
 		policy: processPolicy,
 		router: () => autoRouter,
+		activities,
 		store: (agent) => topic(agent.session.header).process,
 		taskStatement: async (agent, fromSeq, signal) => {
 			const target = agent;
@@ -4908,15 +5047,18 @@ function apply(ctx, config = {}) {
 				reviewStage: "proposal",
 				...trace ? { trace } : {}
 			}, request.signal);
-			if (calls.length > 0) await topic(agent.session.header).decisions.record({
+			const snapshot = calls.length === 0 ? void 0 : await topic(agent.session.header).decisions.record({
 				toolName: "verifier_compare",
 				phase: "process",
 				startedAt,
 				provider: selected.provider,
 				model: selected.model,
 				calls: boundDecisionCalls([...calls].sort((a, b) => a.label < b.label ? -1 : a.label > b.label ? 1 : 0))
-			}).catch(() => {});
-			return result;
+			}).catch(() => void 0);
+			return snapshot === void 0 ? result : {
+				...result,
+				decisionId: snapshot.id
+			};
 		},
 		select: async (request) => {
 			const agent = request.agent;
@@ -4935,15 +5077,18 @@ function apply(ctx, config = {}) {
 				reviewStage: "proposal",
 				...trace ? { trace } : {}
 			}, request.signal);
-			if (calls.length > 0) await topic(agent.session.header).decisions.record({
+			const snapshot = calls.length === 0 ? void 0 : await topic(agent.session.header).decisions.record({
 				toolName: "verifier_select",
 				phase: "process",
 				startedAt,
 				provider: selected.provider,
 				model: selected.model,
 				calls: boundDecisionCalls([...calls].sort((a, b) => a.label < b.label ? -1 : a.label > b.label ? 1 : 0))
-			}).catch(() => {});
-			return result;
+			}).catch(() => void 0);
+			return snapshot === void 0 ? result : {
+				...result,
+				decisionId: snapshot.id
+			};
 		},
 		record: async (report) => {
 			const agent = report.agent;
@@ -4970,6 +5115,7 @@ function apply(ctx, config = {}) {
 			};
 			const failedCall = report.outcome === "generation-failed" || report.outcome === "comparison-failed";
 			await topic(agent.session.header).statistics.record({
+				...report.decisionId === void 0 ? {} : { id: report.decisionId },
 				toolName: report.select === void 0 ? "verifier_compare" : "verifier_select",
 				sessionId: String(agent.id),
 				startedAt: report.startedAt,
@@ -5080,15 +5226,18 @@ function apply(ctx, config = {}) {
 	/** Whether a payload asks for a decision snapshot instead of a statistics overview. */
 	const isDecisionQuery = (payload) => typeof payload === "object" && payload !== null && payload.kind === "decision";
 	/**
-	* Whether a payload asks what the process-selection (P06) cycle of one session is doing.
+	* Whether a payload asks what this plugin is doing for one session.
 	*
-	* This is what the chat chip polls while a turn runs. The answer is in-memory state only: no
-	* sidecar read, no model call, and nothing durable, so polling it cannot cost anything or change
-	* a verdict. A session that never bought a cycle answers with an empty object.
+	* This is what the chat chip polls while a turn runs: a P06 cycle (which buffers the reply), a
+	* routed review, or the final acceptance. The wire name is historical — it covers every stage now,
+	* and keeping it means a page holding the older client bundle keeps working.
 	*/
 	const isProcessQuery = (payload) => typeof payload === "object" && payload !== null && payload.kind === "process";
 	/**
-	* Read the in-flight / just-settled process cycle of one session.
+	* Read the in-flight / just-settled cycle of one session.
+	*
+	* In-memory state only: no sidecar read, no model call, nothing durable, so polling it cannot cost
+	* anything or change a verdict. A session with nothing to show answers with an empty object.
 	* @param payload - the RPC payload; `sessionId` is required.
 	* @returns The activity view, or a bad-request failure.
 	*/
@@ -5097,7 +5246,7 @@ function apply(ctx, config = {}) {
 		if (typeof sessionId !== "string" || sessionId === "") return rpcFailure("a sessionId is required");
 		return rpcSuccess({
 			sessionId,
-			...processSelector.activity(sessionId)
+			...activities.read(sessionId, Date.now())
 		});
 	};
 	/**