dsh-llm-verifier 0.1.13 → 0.1.16

package/lib/index.js

@@ -31,8 +31,10 @@ const Config = z.object({
 	autoRouteMaxInputChars: z.number().step(1).min(1e3).default(6e4),
 	autoMaxModelCallsPerTask: z.number().step(1).min(1).default(48),
 	autoMaxModelCallsPerSession: z.number().step(1).min(1).default(160),
+	autoVerifyTeamTasks: z.boolean().default(true),
+	autoVerifyPlanMode: z.boolean().default(true),
 	provider: z.string().default("deepseek-official"),
-	model: z.string().default("deepseek-v4-flash"),
+	model: z.string().default("deepseek-flash"),
 	reasoningEffort: z.string(),
 	maxTokens: z.number().step(1).min(1).default(32768),
 	timeoutMs: z.number().step(1).min(1).default(3e5),
@@ -46,7 +48,7 @@ const Config = z.object({
 });
 function resolveConfig(config = {}) {
 	const provider = (config.provider ?? "deepseek-official").trim();
-	const model = (config.model ?? "deepseek-v4-flash").trim();
+	const model = (config.model ?? "deepseek-flash").trim();
 	if (!provider) throw new Error("llm-verifier: provider must be non-empty");
 	if (!model) throw new Error("llm-verifier: model must be non-empty");
 	const autoVerifyMode = config.autoVerifyMode ?? "smart";
@@ -100,6 +102,8 @@ function resolveConfig(config = {}) {
 		autoRouteSemantic: config.autoRouteSemantic ?? true,
 		autoRouteMinConfidence,
 		autoTrackCompletionThreshold,
+		autoVerifyTeamTasks: config.autoVerifyTeamTasks ?? true,
+		autoVerifyPlanMode: config.autoVerifyPlanMode ?? true,
 		provider,
 		model,
 		...reasoningEffort ? { reasoningEffort } : {},
@@ -602,12 +606,33 @@ async function loadVerifierImages(inputs, signal) {
 }
 //#endregion
 //#region src/session.ts
+/**
+* Read one session's event log.
+*
+* DSH 0.1.5 replaced the `events` array with `snapshotEvents()`; older hosts
+* expose the array directly. Both shapes are accepted so the plugin keeps
+* working across the versions it declares support for.
+* @param session - Agent session, or any object exposing one of the two shapes.
+* @returns The session's events in log order, or an empty array.
+*/
+function sessionEvents(session) {
+	const candidate = session;
+	if (typeof candidate?.snapshotEvents === "function") return candidate.snapshotEvents();
+	return candidate?.events ?? [];
+}
 function textOf(blocks) {
 	const parts = [];
-	for (const block of blocks) if (block.type === "text") parts.push(block.text);
-	else if (block.type === "reasoning") parts.push("[Reasoning] " + block.text);
-	else if (block.type === "tool-call") parts.push("[Tool Call] " + block.name + " " + block.arguments);
-	else if (block.type === "tool-result") parts.push("[Tool Result] " + textOf(block.content));
+	for (const block of blocks) {
+		const blockType = block.type;
+		if (blockType === "text") parts.push(block.text);
+		else if (blockType === "reasoning") parts.push("[Reasoning] " + block.text);
+		else if (blockType === "tool-call") parts.push("[Tool Call] " + block.name + " " + block.arguments);
+		else if (blockType === "tool-result") parts.push("[Tool Result] " + textOf(block.content));
+		else if (blockType === "file") {
+			const fileData = block;
+			parts.push("[File] " + (fileData.path ?? fileData.filename ?? fileData.title ?? "attachment"));
+		}
+	}
 	return parts.join("\n");
 }
 const DEFAULT_REDACT_PATTERNS = ["Bearer\\s+[A-Za-z0-9._~+\\/=-]+", "(?:api[_-]?key|token|password|secret)\\s*[=:]\\s*[\"']?[^\\s,\"';}]+"];
@@ -635,7 +660,7 @@ function sanitizeVerifierText(text, maxChars, patterns = DEFAULT_REDACT_PATTERNS
 	return redacted.length <= maxChars ? redacted : redacted.slice(0, maxChars) + "\n[Truncated " + (redacted.length - maxChars) + " characters]";
 }
 async function extractSession(agent, loadImage, options = {}) {
-	const all = agent.session.events;
+	const all = sessionEvents(agent.session);
 	const from = options.fromSeq ?? 0;
 	const to = options.toSeq ?? Number.MAX_SAFE_INTEGER;
 	const events = all.filter((event) => event.seq >= from && event.seq <= to);
@@ -643,24 +668,35 @@ async function extractSession(agent, loadImage, options = {}) {
 	let problem = "";
 	const trace = [];
 	const images = [];
-	for (const event of events) if (event.type === "user/message") {
-		if (event.data.source.kind !== "user") continue;
-		const text = textOf(event.data.content);
-		if (!problem && text.trim()) problem = text.trim();
-		for (const block of event.data.content) if (block.type === "image") images.push(await loadImage(block.attachment));
-		trace.push("--- User seq " + event.seq + " ---\n" + text);
-	} else if (event.type === "assistant/message" && options.includeAssistantText !== false) trace.push("--- Assistant turn " + event.data.turn + " step " + event.data.step + " ---\n" + textOf(event.data.message.content));
-	else if (event.type === "tool/call") trace.push("--- Tool Call turn " + event.data.turn + " step " + event.data.step + " ---\n[Command] " + event.data.name + " " + event.data.arguments);
-	else if (event.type === "tool/result") trace.push("--- Tool Result turn " + event.data.turn + " step " + event.data.step + " ---\n[Output] " + textOf(event.data.message.content));
-	else if (event.type === "tool/code-dispatch") {
-		const data = event.data;
-		const status = data.isError ? " [Error]" : "";
-		const args = data.arguments !== void 0 ? " " + (typeof data.arguments === "string" ? data.arguments : JSON.stringify(data.arguments)) : "";
-		const content = Array.isArray(data.content) ? textOf(data.content) : "";
-		if (Array.isArray(data.content)) {
-			for (const block of data.content) if (block.type === "image") images.push(await loadImage(block.attachment));
+	for (const rawEvent of events) {
+		const event = rawEvent;
+		if (event.type === "user/message") {
+			const sourceKind = event.data?.source?.kind;
+			if (sourceKind !== "user" && sourceKind !== "team-message") continue;
+			const text = textOf(event.data.content);
+			if (!problem && sourceKind === "user" && text.trim()) problem = text.trim();
+			for (const block of event.data.content) if (block.type === "image") images.push(await loadImage(block.attachment));
+			const tag = sourceKind === "team-message" ? "Team Message" : "User";
+			trace.push("--- " + tag + " seq " + event.seq + " ---\n" + text);
+		} else if (event.type === "assistant/message" && options.includeAssistantText !== false) trace.push("--- Assistant turn " + event.data.turn + " step " + event.data.step + " ---\n" + textOf(event.data.message.content));
+		else if (event.type === "tool/call") trace.push("--- Tool Call turn " + event.data.turn + " step " + event.data.step + " ---\n[Command] " + event.data.name + " " + event.data.arguments);
+		else if (event.type === "tool/result") trace.push("--- Tool Result turn " + event.data.turn + " step " + event.data.step + " ---\n[Output] " + textOf(event.data.message.content));
+		else if (event.type === "tool/ptc-dispatch" || event.type === "tool/code-dispatch") {
+			const data = event.data;
+			const status = data.isError ? " [Error]" : "";
+			const args = data.arguments !== void 0 ? " " + (typeof data.arguments === "string" ? data.arguments : JSON.stringify(data.arguments)) : "";
+			const content = Array.isArray(data.content) ? textOf(data.content) : "";
+			if (Array.isArray(data.content)) {
+				for (const block of data.content) if (block.type === "image") images.push(await loadImage(block.attachment));
+			}
+			const label = event.type === "tool/ptc-dispatch" ? "PTC Dispatch " : "Code Dispatch ";
+			trace.push("--- " + label + data.name + status + " seq " + event.seq + " ---\n[Command] " + data.name + args + "\n[Output] " + content);
+		} else if (event.type === "team/message/queued") {
+			const data = event.data;
+			const sender = data?.message?.senderName ?? "Teammate";
+			const content = Array.isArray(data?.message?.content) ? textOf(data.message.content) : "";
+			trace.push("--- Team Message Queued from " + sender + " seq " + event.seq + " ---\n" + content);
 		}
-		trace.push("--- Code Dispatch " + data.name + status + " seq " + event.seq + " ---\n[Command] " + data.name + args + "\n[Output] " + content);
 	}
 	const raw = redactText(trace.join("\n\n"), patterns);
 	const maxChars = options.maxChars ?? 2e5;
@@ -726,6 +762,8 @@ function isConsequential(name) {
 	if (PASSIVE_TOOLS.has(name) || VERIFIER_TOOLS.has(name)) return false;
 	return /(?:edit|write|patch|apply|deploy|upload|delete|remove|kill|exec|shell|command|migration|database|tunnel|cluster)/iu.test(name);
 }
+/** Event names that carry one settled PTC/code dispatch, across the hosts the plugin supports. */
+const CODE_DISPATCH_TYPES = /* @__PURE__ */ new Set(["tool/code-dispatch", "tool/ptc-dispatch"]);
 function isSuccessfulCodeDispatch(data) {
 	if (data.isError === true) return false;
 	if (Array.isArray(data.content) && data.content.some((b) => b.isError === true)) return false;
@@ -746,7 +784,7 @@ function analyzeAutoTask(events, policy) {
 	const calls = relevant.filter((event) => event.type === "tool/call");
 	const successfulResults = new Set(relevant.filter((event) => event.type === "tool/result" && event.data.error === void 0 && event.data.message.content.every((block) => block.isError !== true)).map((event) => String(event.data.message.source.callId)));
 	const pairedCalls = calls.filter((event) => successfulResults.has(String(event.data.callId)));
-	const codeDispatches = relevant.filter((event) => event.type === "tool/code-dispatch").map((event) => event.data);
+	const codeDispatches = relevant.filter((event) => CODE_DISPATCH_TYPES.has(event.type)).map((event) => event.data);
 	const successfulDispatches = codeDispatches.filter(isSuccessfulCodeDispatch);
 	const toolCalls = calls.filter((event) => !VERIFIER_TOOLS.has(event.data.name)).length + codeDispatches.filter((d) => !VERIFIER_TOOLS.has(d.name)).length;
 	const completedToolResults = pairedCalls.length + successfulDispatches.length;
@@ -823,7 +861,7 @@ var AutoVerificationBudget = class {
 			state.taskAttempts = 0;
 			state.lastEvaluatedSeq = -1;
 		}
-		const lastSeq = agent.session.events.at(-1)?.seq ?? -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;
@@ -895,21 +933,32 @@ function buildEvidenceIndex(events) {
 	const calls = /* @__PURE__ */ new Map();
 	const results = /* @__PURE__ */ new Map();
 	const todos = /* @__PURE__ */ new Map();
+	const teamTasks = /* @__PURE__ */ new Map();
 	const paired = /* @__PURE__ */ new Map();
-	for (const event of relevant) if (event.type === "tool/call") calls.set(String(event.data.callId), event);
-	else if (event.type === "tool/result" && successful(event)) results.set(String(event.data.message.source.callId), event);
-	else if (event.type === "todo/write") todos.set(event.seq, event.data.todos);
-	else if (event.type === "tool/code-dispatch") {
-		const data = event.data;
-		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 : [];
-			paired.set(subCallId, {
-				name: data.name,
-				callSeq: event.seq,
-				resultSeq: event.seq,
-				text: blockText(content)
-			});
+	const currentTeamTasks = /* @__PURE__ */ new Map();
+	for (const rawEvent of relevant) {
+		const event = rawEvent;
+		if (event.type === "tool/call") calls.set(String(event.data.callId), rawEvent);
+		else if (event.type === "tool/result" && successful(rawEvent)) results.set(String(event.data.message.source.callId), rawEvent);
+		else if (event.type === "todo/write") todos.set(event.seq, event.data.todos);
+		else if (event.type === "team/task") {
+			const data = event.data;
+			if (data?.task) {
+				currentTeamTasks.set(data.task.id, { ...data.task });
+				teamTasks.set(event.seq, [...currentTeamTasks.values()]);
+			}
+		} else if (event.type === "tool/ptc-dispatch" || event.type === "tool/code-dispatch") {
+			const data = event.data;
+			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 : [];
+				paired.set(subCallId, {
+					name: data.name,
+					callSeq: event.seq,
+					resultSeq: event.seq,
+					text: blockText(content)
+				});
+			}
 		}
 	}
 	for (const [callId, call] of calls) {
@@ -924,7 +973,8 @@ function buildEvidenceIndex(events) {
 	return {
 		problemSeq: taskStartSeq,
 		calls: paired,
-		todos
+		todos,
+		teamTasks
 	};
 }
 function parseTrustedWorkflow(value, callId, callSeq, resultSeq, maxCandidates, maxItemChars) {
@@ -978,6 +1028,23 @@ function canonicalTodoSnapshots(index) {
 	}
 	return values;
 }
+function canonicalTeamTaskSnapshots(index) {
+	const values = [];
+	let previous = "";
+	for (const [seq, tasks] of index.teamTasks) {
+		const canonical = JSON.stringify(tasks.map((t) => ({
+			id: t.id,
+			status: t.status,
+			revision: t.revision
+		})));
+		if (canonical !== previous) values.push({
+			seq,
+			tasks
+		});
+		previous = canonical;
+	}
+	return values;
+}
 function analyzeStructuredRoute(events, maxCandidates = 8, maxItemChars = 2e4) {
 	const index = buildEvidenceIndex(events);
 	if (!index) return void 0;
@@ -1031,13 +1098,32 @@ function analyzeStructuredRoute(events, maxCandidates = 8, maxItemChars = 2e4) {
 				evidenceSeqs: snapshots.map((snapshot) => snapshot.seq)
 			};
 		}
+		const teamSnapshots = canonicalTeamTaskSnapshots(index);
+		if (teamSnapshots.length >= 2) {
+			const steps = teamSnapshots.map((snapshot) => sanitizeVerifierText("Team task checkpoint seq " + snapshot.seq + ":\n" + snapshot.tasks.map((task) => "- [" + task.status + "] " + task.subject + (task.description ? " (" + task.description + ")" : "")).join("\n"), maxItemChars));
+			const checkpoints = steps.map((_, i) => i + 1);
+			return {
+				kind: "track",
+				source: "structured",
+				confidence: 1,
+				reason: "changed durable team tasks",
+				fingerprint: stableHash({
+					kind: "track",
+					teamSnapshots
+				}),
+				steps,
+				checkpoints,
+				evidenceSeqs: teamSnapshots.map((snapshot) => snapshot.seq)
+			};
+		}
 	}
 }
 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")) return true;
+	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;
 	return false;
 }
 function buildSemanticRoutePrompt(problem, events, maxCandidates, maxItemChars = 2e4) {
@@ -1161,7 +1247,7 @@ var AutoVerifierRouter = class {
 	states = /* @__PURE__ */ new Map();
 	serial = 0;
 	state(agent) {
-		const taskStartSeq = latestDirectUserSeq(agent.session.events);
+		const taskStartSeq = latestDirectUserSeq(sessionEvents(agent.session));
 		if (taskStartSeq === void 0) return void 0;
 		const id = String(agent.id);
 		const state = this.states.get(id) ?? {
@@ -1221,6 +1307,10 @@ var AutoVerifierRouter = class {
 		state.failed.add(reservation.fingerprint);
 		if (strict) state.strictBlocked = true;
 	}
+	/** Whether this exact fingerprint already passed within the current task. */
+	completedFingerprint(agent, fingerprint) {
+		return this.state(agent)?.completed.has(fingerprint) ?? false;
+	}
 	finalRequired(agent) {
 		return this.state(agent)?.finalRequiredFromSeq;
 	}
@@ -1232,6 +1322,120 @@ var AutoVerifierRouter = class {
 	}
 };
 //#endregion
+//#region src/plan-gate.ts
+/**
+* Read the plan markdown out of one `exit_plan_mode` argument object.
+* @param args - Parsed tool arguments; anything but `{ plan: string }` yields ''.
+* @returns Trimmed plan markdown, or '' when the call carries no plan.
+*/
+function planFromArguments(args) {
+	if (typeof args !== "object" || args === null) return "";
+	const plan = args.plan;
+	return typeof plan === "string" ? plan.trim() : "";
+}
+function buildPlanPreReviewPrompt(problem, planText, maxChars = 2e4) {
+	return [
+		"You are an expert independent technical plan verifier. A candidate implementation plan is about to be submitted to the human for approval.",
+		"Evaluate whether the plan is sound, executable, and comprehensive.",
+		"Scoring criteria:",
+		"A: Flawless, thorough, with clear steps, rigorous verification, edge cases handled.",
+		"B-J: Mostly sound, minor gaps or nuances missing.",
+		"K-S: Noticeable architectural gaps, missing regression checks, or ambiguities.",
+		"T: Fundamentally flawed, dangerous, or missing core requirements.",
+		"",
+		"Task requirement:",
+		sanitizeVerifierText(problem, 4e3),
+		"",
+		"Proposed Plan:",
+		sanitizeVerifierText(planText, maxChars),
+		"",
+		"Output format:",
+		"The first line must be exactly \"Verdict: <single uppercase letter A-T>\" — one letter, nothing else on the line.",
+		"Line 2: Summary: <One sentence assessment>",
+		"Line 3+: Key strengths, blind spots, and verification guidance."
+	].join("\n\n");
+}
+/**
+* Parse the `Verdict: <A-T>` line the judge prompts require.
+*
+* Markdown decoration around the required line is stripped first, so "**Verdict:
+* A**", "- Verdict: B." or a numbered list marker still produce a grade — a
+* formatting habit must never silently switch the gate off. Prose that is not a
+* grade is still rejected: "Verdict: Failed" and "Verdict: Approved" carry no
+* verdict letter, and an answer without a verdict line has no score at all —
+* callers must skip such a review, never treat it as a pass. A is 1.0 and T is
+* 0.0, matching the top-logprob A-T scale used by the judge prompts.
+* @param text - Raw judge model output.
+* @returns The parsed verdict, or undefined when no verdict line is present.
+*/
+function parseVerdictLetter(text) {
+	for (const rawLine of text.split(/\r?\n/)) {
+		const line = rawLine.replace(/[*_`~#>]/g, " ").replace(/^\s*(?:[-+]|\d+[.)])\s+/, " ").trim();
+		const match = /^verdict\s*:\s*([A-Ta-t])\s*[.)]?$/i.exec(line);
+		if (match === null) continue;
+		const verdict = match[1].toUpperCase();
+		return {
+			verdict,
+			score: Math.max(0, Math.min(1, 1 - (verdict.charCodeAt(0) - 65) / 19)),
+			feedback: text.trim()
+		};
+	}
+}
+//#endregion
+//#region src/team-gate.ts
+function inspectTeamTasks(events, fromSeq = 0) {
+	const taskMap = /* @__PURE__ */ new Map();
+	const completionSeq = /* @__PURE__ */ new Map();
+	for (const rawEvent of events) {
+		const event = rawEvent;
+		if (event.type === "team/task") {
+			const data = event.data;
+			if (data?.task) {
+				taskMap.set(data.task.id, { ...data.task });
+				if (data.task.status === "completed") completionSeq.set(data.task.id, event.seq);
+				else completionSeq.delete(data.task.id);
+			}
+		}
+	}
+	const completedTasks = [...completionSeq.entries()].filter(([id, seq]) => seq >= fromSeq && taskMap.get(id)?.status === "completed").map(([id, seq]) => ({
+		task: { ...taskMap.get(id) },
+		seq
+	})).sort((left, right) => left.seq - right.seq);
+	const latest = completedTasks.at(-1);
+	return {
+		latestCompletedTask: latest?.task,
+		completedSeq: latest?.seq,
+		completedTasks,
+		activeTasks: [...taskMap.values()].filter((t) => t.status !== "deleted"),
+		hasRecentCompletedTask: latest !== void 0
+	};
+}
+function buildTeamTaskVerificationPrompt(task, executionTrace, maxChars = 2e4) {
+	return [
+		"You are an expert independent technical verifier reviewing a completed Agent Teams task.",
+		"Verify if the task goal has been satisfied by concrete evidence (code edits, test runs, successful commands).",
+		"Task Details:",
+		"ID: " + task.id,
+		"Subject: " + task.subject,
+		task.description ? "Description: " + task.description : "",
+		"",
+		"Execution Evidence & Trace:",
+		sanitizeVerifierText(executionTrace, maxChars),
+		"",
+		"Evaluate whether the task is genuinely completed with verified proof.",
+		"Scoring criteria:",
+		"A: Completely fulfilled with solid execution/test evidence.",
+		"B-J: Mostly complete, minor gaps or edge cases not fully asserted.",
+		"K-S: Incomplete, missing key requirements or untested.",
+		"T: Unfulfilled, failed, or contradictory evidence.",
+		"",
+		"Output format:",
+		"The first line must be exactly \"Verdict: <single uppercase letter A-T>\" — one letter, nothing else on the line.",
+		"Line 2: Summary: <One sentence evaluation of task fulfillment>",
+		"Line 3+: Remaining gaps or next steps for the team."
+	].filter(Boolean).join("\n\n");
+}
+//#endregion
 //#region src/statistics.ts
 const VERIFIER_TOOL_NAMES = [
 	"verifier_route_classify",
@@ -2010,8 +2214,7 @@ function apply(ctx, config = {}) {
 			summary: "Automatic verifier routed " + decision.kind
 		}
 	});
-	services.connection.rpc.handle("/llm-verifier", async (endpoint, payload) => {
-		if (endpoint !== "statistics") return rpcFailure("unknown llm-verifier endpoint");
+	const handleStatisticsQuery = async (payload) => {
 		if (typeof payload !== "object" || payload === null) return rpcFailure("statistics payload must be an object");
 		const row = payload;
 		const sessionId = typeof row.sessionId === "string" && row.sessionId.length > 0 ? row.sessionId : void 0;
@@ -2028,25 +2231,171 @@ function apply(ctx, config = {}) {
 		} catch (error) {
 			return rpcFailure(error instanceof Error ? error.message : String(error));
 		}
-	}, { authority: "loopback" });
+	};
+	const anyConn = services.connection;
+	if (anyConn && anyConn.fetch && typeof anyConn.fetch.register === "function") try {
+		anyConn.fetch.register({
+			path: "/api/llm-verifier/statistics",
+			methods: ["POST"],
+			requestBody: "buffered",
+			fetch: async (request) => {
+				let body;
+				try {
+					body = await request.json();
+				} catch {
+					return new Response("body is not JSON", { status: 400 });
+				}
+				const isRpcEnvelope = typeof body === "object" && body !== null && body.type === "client-request" && typeof body.rpcId === "string";
+				const rpcId = isRpcEnvelope ? body.rpcId : "direct";
+				const payload = isRpcEnvelope ? body.payload : body;
+				const outcome = await handleStatisticsQuery(payload);
+				if (isRpcEnvelope) return Response.json({
+					type: "server-response",
+					rpcId,
+					result: outcome
+				});
+				return Response.json(outcome);
+			}
+		});
+	} catch (e) {
+		ctx.logger.warn("failed to register /api/llm-verifier/statistics fetch route: " + String(e));
+	}
+	const legacyRpc = services.connection;
+	if (typeof legacyRpc.rpc?.handle === "function") try {
+		legacyRpc.rpc.handle("/llm-verifier", async (endpoint, payload) => {
+			if (endpoint !== "statistics") return rpcFailure("unknown llm-verifier endpoint");
+			return handleStatisticsQuery(payload);
+		});
+	} catch (e) {
+		ctx.logger.warn("failed to register /llm-verifier rpc fallback: " + String(e));
+	}
 	ctx.on("agent/disposed", ({ agent }) => {
 		autoBudget.release(agent);
 		autoRouter.release(agent);
 		topics.delete(String(agent.id));
 	});
+	ctx.on("tools/pre-execute", async (exec, next) => {
+		const selected = current();
+		if (!selected.enabled || selected.autoVerifyMode === "manual" || !selected.autoVerifyPlanMode) return next();
+		if (exec.name !== "exit_plan_mode" || exec.agent === void 0 || exec.signal.aborted) return next();
+		const plan = planFromArguments(exec.arguments);
+		if (!plan) return next();
+		const agent = exec.agent;
+		const policy = routePolicy(selected);
+		const evidence = analyzeAutoTask(sessionEvents(agent.session), {
+			mode: selected.autoVerifyMode,
+			minToolCalls: selected.autoVerifyMinToolCalls,
+			maxPerTask: selected.autoVerifyMaxPerTask,
+			maxPerSession: selected.autoVerifyMaxPerSession
+		});
+		const planFingerprint = stableHash({
+			phase: "plan_review",
+			plan
+		});
+		const reservation = autoRouter.reserve(agent, "plan_review", planFingerprint, 1, policy);
+		if (reservation === void 0) {
+			if (!autoRouter.completedFingerprint(agent, planFingerprint)) ctx.logger.warn("llm-verifier plan pre-review skipped (verification in flight or auto-verification budget exhausted)");
+			return next();
+		}
+		try {
+			const toSeq = sessionEvents(agent.session).at(-1)?.seq ?? -1;
+			const extracted = await extractTask(agent, evidence.taskStartSeq, toSeq, selected.autoVerifyMaxChars, exec.signal);
+			const verdict = parseVerdictLetter((await classifyRoute(agent, buildPlanPreReviewPrompt(extracted.problem, plan, selected.autoRouteMaxInputChars), exec.signal)).text);
+			if (verdict === void 0) {
+				autoRouter.fail(agent, reservation, false);
+				ctx.logger.warn("llm-verifier plan pre-review produced no verdict line; the plan was allowed through");
+				return next();
+			}
+			if (verdict.score >= selected.autoVerifyThreshold) {
+				autoRouter.commit(agent, reservation);
+				return next();
+			}
+			autoRouter.fail(agent, reservation, selected.autoVerifyMode === "strict");
+			return {
+				kind: "deny",
+				reason: "[Automatic Verifier Plan Pre-review] scored " + (verdict.score * 100).toFixed(1) + "% against a " + (selected.autoVerifyThreshold * 100).toFixed(0) + "% threshold.\n" + verdict.feedback.slice(0, 4e3) + "\nRevise the plan to address these findings, then call exit_plan_mode again."
+			};
+		} catch (error) {
+			autoRouter.fail(agent, reservation, false);
+			ctx.logger.warn("llm-verifier plan pre-review failed: " + (error instanceof Error ? error.message : String(error)));
+			return next();
+		}
+	});
 	ctx.on("agent/turn-stopping", async ({ agent, signal }) => {
 		const selected = current();
 		if (!selected.enabled || selected.autoVerifyMode === "manual" || signal.aborted) return;
 		const policy = routePolicy(selected);
-		const evidence = analyzeAutoTask(agent.session.events, {
+		const evidence = analyzeAutoTask(sessionEvents(agent.session), {
 			mode: selected.autoVerifyMode,
 			minToolCalls: selected.autoVerifyMinToolCalls,
 			maxPerTask: selected.autoVerifyMaxPerTask,
 			maxPerSession: selected.autoVerifyMaxPerSession
 		});
-		const admittedLastSeq = agent.session.events.at(-1)?.seq ?? -1;
-		const snapshot = agent.session.events.filter((event) => event.seq <= admittedLastSeq);
-		const stillCurrent = () => !signal.aborted && (agent.session.events.at(-1)?.seq ?? -1) === admittedLastSeq;
+		const admittedLastSeq = sessionEvents(agent.session).at(-1)?.seq ?? -1;
+		const snapshot = sessionEvents(agent.session).filter((event) => event.seq <= admittedLastSeq);
+		const stillCurrent = () => !signal.aborted && (sessionEvents(agent.session).at(-1)?.seq ?? -1) === admittedLastSeq;
+		if (selected.autoVerifyTeamTasks) {
+			const teamInspection = inspectTeamTasks(snapshot, evidence.taskStartSeq);
+			for (const completed of teamInspection.completedTasks) {
+				const task = completed.task;
+				const taskReservation = autoRouter.reserve(agent, "team_task", stableHash({
+					phase: "team_task",
+					taskId: task.id,
+					status: task.status,
+					seq: completed.seq
+				}), 1, policy);
+				if (taskReservation === void 0) continue;
+				try {
+					const prompt = buildTeamTaskVerificationPrompt(task, (await extractTask(agent, evidence.taskStartSeq, admittedLastSeq, selected.autoVerifyMaxChars, signal)).trace, selected.autoRouteMaxInputChars);
+					const classified = await classifyRoute(agent, prompt, signal);
+					if (!stillCurrent()) {
+						autoRouter.fail(agent, taskReservation, false);
+						return;
+					}
+					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");
+						continue;
+					}
+					if (verdict.score >= selected.autoVerifyThreshold) {
+						autoRouter.commit(agent, taskReservation, admittedLastSeq);
+						continue;
+					}
+					autoRouter.fail(agent, taskReservation, selected.autoVerifyMode === "strict");
+					agent.steer(createUserMessage({
+						content: [{
+							type: "text",
+							text: "[Automatic Verifier Team Task Gate]\nTask \"" + task.subject + "\" (#" + task.id + ") verification scored " + (verdict.score * 100).toFixed(1) + "% (Threshold: " + (selected.autoVerifyThreshold * 100).toFixed(0) + "%).\n" + verdict.feedback + "\nProvide verified execution evidence or resolve remaining issues before completing the task."
+						}],
+						source: {
+							kind: "plugin",
+							plugin: "dsh-llm-verifier",
+							form: "notice",
+							summary: "Team Task Gate Feedback"
+						}
+					}));
+					return;
+				} catch (error) {
+					autoRouter.fail(agent, taskReservation, selected.autoVerifyMode === "strict");
+					ctx.logger.warn("llm-verifier team task verification failed: " + (error instanceof Error ? error.message : String(error)));
+					if (selected.autoVerifyMode === "strict" && !signal.aborted) {
+						agent.steer(createUserMessage({
+							content: [{
+								type: "text",
+								text: "[Automatic Verifier Team Task Gate]\nTask verification failed: " + (error instanceof Error ? error.message : String(error))
+							}],
+							source: {
+								kind: "plugin",
+								plugin: "dsh-llm-verifier"
+							}
+						}));
+						return;
+					}
+					continue;
+				}
+			}
+		}
 		let decision = boundDecision(analyzeStructuredRoute(snapshot, selected.autoRouteMaxCandidates, selected.autoRouteMaxItemChars), policy);
 		if (decision === void 0 && selected.autoRouteSemantic && (selected.autoVerifyMode === "strict" || semanticRouteHint(snapshot))) {
 			const fingerprint = stableHash({
@@ -2551,6 +2900,6 @@ function apply(ctx, config = {}) {
 	}));
 }
 //#endregion
-export { AutoVerificationBudget, AutoVerifierRouter, Config, DEFAULT_CRITERIA, DEFAULT_GROUND_TRUTH_NOTE, GRANULARITY, LETTERS, RequestLimiter, SCALE_DESCRIPTION, ScoreCache, SingleFlight, StatisticsStore, VERIFIER_TOOL_NAMES, VerifierEngine, accumulatePairs, analyzeAutoTask, analyzeStructuredRoute, apply, automaticFeedback, boundDecision, bradleyTerry, buildEvidenceIndex, buildPairwisePrompt, buildProgressPrompt, buildSemanticRoutePrompt, callVerifier, emptyRunStats, errorDetails, extractProgressScore, extractScore, inject, latestDirectUserSeq, mergeStatisticsOverviews, name, normalizeCriteria, normalizeScoreLetter, parseSemanticRoute, pivotRoundPairs, rankScores, resolveCacheFile, resolveStatisticsFile, resolveTopicDataDir, ringCycle, seededRandom, semanticDecision, semanticRouteHint, stableHash, topPivots };
+export { AutoVerificationBudget, AutoVerifierRouter, Config, DEFAULT_CRITERIA, DEFAULT_GROUND_TRUTH_NOTE, GRANULARITY, LETTERS, RequestLimiter, SCALE_DESCRIPTION, ScoreCache, SingleFlight, StatisticsStore, VERIFIER_TOOL_NAMES, VerifierEngine, accumulatePairs, analyzeAutoTask, analyzeStructuredRoute, apply, automaticFeedback, boundDecision, bradleyTerry, buildEvidenceIndex, buildPairwisePrompt, buildPlanPreReviewPrompt, buildProgressPrompt, buildSemanticRoutePrompt, buildTeamTaskVerificationPrompt, callVerifier, emptyRunStats, errorDetails, extractProgressScore, extractScore, inject, inspectTeamTasks, latestDirectUserSeq, mergeStatisticsOverviews, name, normalizeCriteria, normalizeScoreLetter, parseSemanticRoute, parseVerdictLetter, pivotRoundPairs, planFromArguments, rankScores, resolveCacheFile, resolveStatisticsFile, resolveTopicDataDir, ringCycle, seededRandom, semanticDecision, semanticRouteHint, stableHash, topPivots };
 
 //# sourceMappingURL=index.js.map