dsh-llm-verifier 0.1.2 → 0.1.4

package/lib/index.js

@@ -1,6 +1,7 @@
-import { a as TopLogprobCapabilityCache, i as emptyUsage, n as addUsage, r as callVerifier, t as RequestLimiter } from "./caller-CGlgZ-Su.js";
+import { a as TopLogprobCapabilityCache, i as emptyUsage, n as addUsage, r as callVerifier, t as RequestLimiter } from "./caller-BXrUTAoL.js";
 import { DEFAULT_CRITERIA, DEFAULT_GROUND_TRUTH_NOTE, GRANULARITY, LETTERS, SCALE_DESCRIPTION, accumulatePairs, bradleyTerry, buildPairwisePrompt, buildProgressPrompt, extractProgressScore, extractScore, normalizeScoreLetter, pivotRoundPairs, rankScores, ringCycle, seededRandom, topPivots } from "./core.js";
 import { defineTool } from "@deepseek-ai/dsh-tools";
+import { createUserMessage } from "@deepseek-ai/dsh-llm";
 import { installSettingsSection, settingsNamespace } from "@deepseek-ai/dsh-settings";
 import z from "schemastery";
 import { createHash, randomUUID } from "node:crypto";
@@ -10,6 +11,17 @@ import { dirname, isAbsolute, join, resolve } from "node:path";
 const VERIFIER_SETTINGS_NAMESPACE = settingsNamespace("llm-verifier");
 const Config = z.object({
 	enabled: z.boolean().default(true),
+	autoVerifyMode: z.union([
+		"manual",
+		"smart",
+		"strict"
+	]).default("smart"),
+	autoVerifyThreshold: z.number().min(0).max(1).default(.65),
+	autoVerifyRepeats: z.number().step(1).min(1).default(1),
+	autoVerifyMinToolCalls: z.number().step(1).min(1).default(3),
+	autoVerifyMaxChars: z.number().step(1).min(1e3).default(8e4),
+	autoVerifyMaxPerTask: z.number().step(1).min(1).default(2),
+	autoVerifyMaxPerSession: z.number().step(1).min(1).default(8),
 	provider: z.string().default("deepseek-official"),
 	model: z.string().default("deepseek-v4-flash"),
 	reasoningEffort: z.string(),
@@ -28,7 +40,20 @@ function resolveConfig(config = {}) {
 	const model = (config.model ?? "deepseek-v4-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";
+	if (![
+		"manual",
+		"smart",
+		"strict"
+	].includes(autoVerifyMode)) throw new Error("llm-verifier: autoVerifyMode must be manual, smart, or strict");
+	const autoVerifyThreshold = config.autoVerifyThreshold ?? .65;
+	if (!Number.isFinite(autoVerifyThreshold) || autoVerifyThreshold < 0 || autoVerifyThreshold > 1) throw new Error("llm-verifier: autoVerifyThreshold must be between 0 and 1");
 	const values = {
+		autoVerifyRepeats: config.autoVerifyRepeats ?? 1,
+		autoVerifyMinToolCalls: config.autoVerifyMinToolCalls ?? 3,
+		autoVerifyMaxChars: config.autoVerifyMaxChars ?? 8e4,
+		autoVerifyMaxPerTask: config.autoVerifyMaxPerTask ?? 2,
+		autoVerifyMaxPerSession: config.autoVerifyMaxPerSession ?? 8,
 		maxTokens: config.maxTokens ?? 32768,
 		timeoutMs: config.timeoutMs ?? 3e5,
 		maxConcurrency: config.maxConcurrency ?? 8,
@@ -36,6 +61,7 @@ function resolveConfig(config = {}) {
 		cacheMaxEntries: config.cacheMaxEntries ?? 1e4
 	};
 	for (const [name, value] of Object.entries(values)) if (!Number.isSafeInteger(value) || value <= 0) throw new Error("llm-verifier: " + name + " must be a positive safe integer");
+	if (values.autoVerifyMaxChars < 1e3) throw new Error("llm-verifier: autoVerifyMaxChars must be at least 1000");
 	const maxRetries = config.maxRetries ?? 3;
 	if (!Number.isSafeInteger(maxRetries) || maxRetries < 0) throw new Error("llm-verifier: maxRetries must be a non-negative safe integer");
 	const cacheDir = (config.cacheDir ?? ".dsh-verifier-cache").trim();
@@ -46,6 +72,8 @@ function resolveConfig(config = {}) {
 	const reasoningEffort = config.reasoningEffort?.trim();
 	return {
 		enabled: config.enabled ?? true,
+		autoVerifyMode,
+		autoVerifyThreshold,
 		provider,
 		model,
 		...reasoningEffort ? { reasoningEffort } : {},
@@ -514,6 +542,167 @@ async function extractSession(agent, loadImage, options = {}) {
 	};
 }
 //#endregion
+//#region src/auto.ts
+const PASSIVE_TOOLS = /* @__PURE__ */ new Set([
+	"read",
+	"read_image",
+	"glob",
+	"grep",
+	"web_search",
+	"ssh_list",
+	"job_list",
+	"job_output",
+	"list_agents",
+	"get_goal",
+	"skill",
+	"mcp__codegraph__codegraph_explore"
+]);
+const VERIFIER_TOOLS = /* @__PURE__ */ new Set([
+	"verifier_compare",
+	"verifier_select",
+	"verifier_track",
+	"verifier_current_session"
+]);
+const CONSEQUENTIAL_TOOLS = /* @__PURE__ */ new Set([
+	"edit",
+	"write",
+	"pwsh",
+	"bash",
+	"run_code",
+	"codex_image_generate",
+	"ssh_exec",
+	"ssh_upload",
+	"ssh_download",
+	"ssh_tunnel",
+	"ssh_cluster",
+	"job_kill",
+	"workbench_session_delete",
+	"create_goal",
+	"update_goal"
+]);
+function latestDirectUserSeq(events) {
+	for (let index = events.length - 1; index >= 0; index -= 1) {
+		const event = events[index];
+		if (event?.type === "user/message" && event.data.source.kind === "user") return event.seq;
+	}
+}
+function isConsequential(name) {
+	if (CONSEQUENTIAL_TOOLS.has(name)) return true;
+	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);
+}
+function analyzeAutoTask(events, policy) {
+	const taskStartSeq = latestDirectUserSeq(events);
+	if (taskStartSeq === void 0) return {
+		taskStartSeq: 0,
+		toolCalls: 0,
+		completedToolResults: 0,
+		consequentialToolCalls: 0,
+		hasManualSessionVerification: false,
+		eligible: false,
+		reason: "no-direct-user-task"
+	};
+	const relevant = events.filter((event) => event.seq >= taskStartSeq);
+	const calls = relevant.filter((event) => event.type === "tool/call");
+	const toolCalls = calls.filter((event) => !VERIFIER_TOOLS.has(event.data.name)).length;
+	const completedToolResults = relevant.filter((event) => event.type === "tool/result" && event.data.error === void 0 && event.data.message.content.every((block) => block.isError !== true)).length;
+	const consequentialToolCalls = calls.filter((event) => isConsequential(event.data.name)).length;
+	const hasManualSessionVerification = calls.some((event) => event.data.name === "verifier_current_session");
+	if (policy.mode === "manual") return {
+		taskStartSeq,
+		toolCalls,
+		completedToolResults,
+		consequentialToolCalls,
+		hasManualSessionVerification,
+		eligible: false,
+		reason: "manual-mode"
+	};
+	if (hasManualSessionVerification) return {
+		taskStartSeq,
+		toolCalls,
+		completedToolResults,
+		consequentialToolCalls,
+		hasManualSessionVerification,
+		eligible: false,
+		reason: "already-verified"
+	};
+	if (consequentialToolCalls === 0) return {
+		taskStartSeq,
+		toolCalls,
+		completedToolResults,
+		consequentialToolCalls,
+		hasManualSessionVerification,
+		eligible: false,
+		reason: "no-consequential-work"
+	};
+	if (completedToolResults === 0) return {
+		taskStartSeq,
+		toolCalls,
+		completedToolResults,
+		consequentialToolCalls,
+		hasManualSessionVerification,
+		eligible: false,
+		reason: "no-completed-evidence"
+	};
+	if (policy.mode === "smart" && toolCalls < policy.minToolCalls) return {
+		taskStartSeq,
+		toolCalls,
+		completedToolResults,
+		consequentialToolCalls,
+		hasManualSessionVerification,
+		eligible: false,
+		reason: "insufficient-tool-evidence"
+	};
+	return {
+		taskStartSeq,
+		toolCalls,
+		completedToolResults,
+		consequentialToolCalls,
+		hasManualSessionVerification,
+		eligible: true,
+		reason: policy.mode + "-eligible"
+	};
+}
+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 = agent.session.events.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) {
+	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)}.`,
+		"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");
+}
+//#endregion
 //#region src/statistics.ts
 const VERIFIER_TOOL_NAMES = [
 	"verifier_compare",
@@ -927,6 +1116,7 @@ function rpcFailure(message) {
 	};
 }
 function apply(ctx, config = {}) {
+	const services = ctx;
 	const entry = resolveConfig(config);
 	let limiter = new RequestLimiter(entry.maxConcurrency);
 	const current = installVerifierSettings(ctx, entry, () => {
@@ -936,6 +1126,7 @@ function apply(ctx, config = {}) {
 	const cache = new ScoreCache(cacheFile, entry.cacheMaxEntries);
 	const statistics = new StatisticsStore(resolveStatisticsFile(cacheFile));
 	const topLogprobCapabilities = new TopLogprobCapabilityCache();
+	const autoBudget = new AutoVerificationBudget();
 	const engine = async () => {
 		const selected = current();
 		await ctx.llm.resolveCallConfig({
@@ -949,7 +1140,7 @@ function apply(ctx, config = {}) {
 				...selected,
 				ctx,
 				llm: ctx.llm,
-				attachments: ctx.attachments,
+				attachments: services.attachments,
 				topLogprobCapabilities,
 				limiter
 			}, selected.maxConcurrency, cache, {
@@ -967,7 +1158,7 @@ function apply(ctx, config = {}) {
 	const requireEnabled = () => {
 		if (!current().enabled) throw new Error("llm-verifier: verifier tools are disabled — enable them in Settings → LLM Verifier");
 	};
-	const record = async (toolName, exec, operation) => {
+	const record = async (toolName, agent, operation) => {
 		const startedAt = Date.now();
 		let selected = current();
 		try {
@@ -979,7 +1170,7 @@ function apply(ctx, config = {}) {
 			};
 			await statistics.record({
 				toolName,
-				...exec.agent ? { sessionId: String(exec.agent.id) } : {},
+				...agent ? { sessionId: String(agent.id) } : {},
 				startedAt,
 				success: true,
 				provider: selected.provider,
@@ -991,7 +1182,7 @@ function apply(ctx, config = {}) {
 			const details = errorDetails(error);
 			await statistics.record({
 				toolName,
-				...exec.agent ? { sessionId: String(exec.agent.id) } : {},
+				...agent ? { sessionId: String(agent.id) } : {},
 				startedAt,
 				success: false,
 				...details,
@@ -1002,7 +1193,45 @@ function apply(ctx, config = {}) {
 			throw error;
 		}
 	};
-	ctx.effect(() => ctx.connection.rpc.handle("/llm-verifier", async (endpoint, payload) => {
+	const verifySession = async (agent, options, signal) => record("verifier_current_session", agent, async () => {
+		const extracted = await extractSession(agent, async (ref) => {
+			const stored = await services.attachments.readImage(ref, signal);
+			return {
+				data: stored.data,
+				mediaType: stored.ref.mediaType
+			};
+		}, {
+			fromSeq: options.fromSeq,
+			toSeq: options.toSeq,
+			includeAssistantText: options.includeAssistantText,
+			redactPatterns: options.redactPatterns,
+			maxChars: options.maxChars
+		});
+		const { verifier, selected } = await engine();
+		const compared = await verifier.compare({
+			problem: extracted.problem,
+			candidateA: extracted.trace,
+			candidateB: "(No useful work or verification was performed.)",
+			repeats: positive(options.repeats, 2, "repeats"),
+			images: extracted.images
+		}, signal);
+		return {
+			result: {
+				sessionId: extracted.sessionId,
+				problem: extracted.problem,
+				score: compared.scoreA,
+				baselineScore: compared.scoreB,
+				winner: compared.winner,
+				fromSeq: extracted.fromSeq,
+				toSeq: extracted.toSeq,
+				omittedCharacters: extracted.omittedCharacters,
+				calls: compared.calls,
+				stats: compared.stats
+			},
+			selected
+		};
+	});
+	ctx.effect(() => services.connection.rpc.handle("/llm-verifier", async (endpoint, payload) => {
 		if (endpoint !== "statistics") return rpcFailure("unknown llm-verifier endpoint");
 		if (typeof payload !== "object" || payload === null) return rpcFailure("statistics payload must be an object");
 		const row = payload;
@@ -1019,6 +1248,55 @@ function apply(ctx, config = {}) {
 			return rpcFailure(error instanceof Error ? error.message : String(error));
 		}
 	}, { authority: "loopback" }), "llm-verifier: statistics rpc");
+	ctx.on("agent/disposed", ({ agent }) => {
+		autoBudget.release(agent);
+	});
+	ctx.on("agent/turn-stopping", async ({ agent, signal }) => {
+		const selected = current();
+		if (!selected.enabled || selected.autoVerifyMode === "manual" || signal.aborted) return;
+		const evidence = analyzeAutoTask(agent.session.events, {
+			mode: selected.autoVerifyMode,
+			minToolCalls: selected.autoVerifyMinToolCalls,
+			maxPerTask: selected.autoVerifyMaxPerTask,
+			maxPerSession: selected.autoVerifyMaxPerSession
+		});
+		if (!autoBudget.claim(agent, evidence, {
+			mode: selected.autoVerifyMode,
+			minToolCalls: selected.autoVerifyMinToolCalls,
+			maxPerTask: selected.autoVerifyMaxPerTask,
+			maxPerSession: selected.autoVerifyMaxPerSession
+		})) return;
+		try {
+			const result = await verifySession(agent, {
+				fromSeq: evidence.taskStartSeq,
+				includeAssistantText: true,
+				maxChars: selected.autoVerifyMaxChars,
+				repeats: selected.autoVerifyRepeats
+			}, signal);
+			if (!(result.winner === "A" && result.score >= selected.autoVerifyThreshold)) agent.steer(createUserMessage({
+				content: [{
+					type: "text",
+					text: automaticFeedback(result.score, result.baselineScore, result.winner, selected.autoVerifyThreshold)
+				}],
+				source: {
+					kind: "plugin",
+					plugin: "dsh-llm-verifier"
+				}
+			}));
+		} catch (error) {
+			ctx.logger.warn("llm-verifier automatic session verification failed: " + (error instanceof Error ? error.message : String(error)));
+			if (selected.autoVerifyMode === "strict" && !signal.aborted) agent.steer(createUserMessage({
+				content: [{
+					type: "text",
+					text: "[Automatic verifier gate]\nThe required strict verification could not run: " + (error instanceof Error ? error.message : String(error)) + "\nInspect the task evidence and run a directly relevant verification command before concluding."
+				}],
+				source: {
+					kind: "plugin",
+					plugin: "dsh-llm-verifier"
+				}
+			}));
+		}
+	});
 	ctx.tools.register(defineTool({
 		name: "verifier_compare",
 		description: "Use autonomously when exactly two substantive answers, patches, plans, or execution trajectories need an independent evidence-based comparison and the choice is consequential or uncertain. Do not use for trivial deterministic questions or when there is only one candidate. Uses the verifier model selected in DSH Settings, with top-logprob A–T expectations when supported and explicit-tag fallback otherwise.",
@@ -1087,7 +1365,7 @@ function apply(ctx, config = {}) {
 		timeoutMs: entry.timeoutMs * 20,
 		async execute(args, exec) {
 			requireEnabled();
-			return record("verifier_compare", exec, async () => {
+			return record("verifier_compare", exec.agent, async () => {
 				const { verifier, selected } = await engine();
 				return {
 					result: await verifier.compare({
@@ -1105,7 +1383,7 @@ function apply(ctx, config = {}) {
 	}));
 	ctx.tools.register(defineTool({
 		name: "verifier_select",
-		description: "Use autonomously when three or more substantive candidate answers, patches, plans, or trajectories must be ranked and an independent choice is valuable. Use verifier_compare for exactly two candidates; do not generate extra candidates merely to invoke this tool. Uses the configured DSH verifier model and the O(Nk) Probabilistic Pivot Tournament.",
+		description: "Use autonomously when three or more substantive candidate answers, patches, plans, or trajectories must be ranked and an independent choice is valuable. Use verifier_compare for exactly two candidates; do not generate extra candidates merely to invoke this tool. Deterministic orchestrators should call this directly once they have three or more real candidates.",
 		parameters: {
 			problem: {
 				type: "string",
@@ -1175,7 +1453,7 @@ function apply(ctx, config = {}) {
 		timeoutMs: entry.timeoutMs * 100,
 		async execute(args, exec) {
 			requireEnabled();
-			return record("verifier_select", exec, async () => {
+			return record("verifier_select", exec.agent, async () => {
 				const { verifier, selected } = await engine();
 				return {
 					result: await verifier.select({
@@ -1194,7 +1472,7 @@ function apply(ctx, config = {}) {
 	}));
 	ctx.tools.register(defineTool({
 		name: "verifier_track",
-		description: "Use autonomously for a genuinely multi-step task when progress at explicit checkpoints is uncertain or needs evidence-based measurement. Do not use for a single completed answer or invent checkpoints that were not supplied by the task history. Trusts observed output rather than narration.",
+		description: "Use autonomously for a genuinely multi-step task when progress at explicit checkpoints is uncertain or needs evidence-based measurement. Deterministic goal/workflow orchestrators should call this directly when real checkpoints already exist. Do not use for a single completed answer or invent checkpoints.",
 		parameters: {
 			problem: {
 				type: "string",
@@ -1254,7 +1532,7 @@ function apply(ctx, config = {}) {
 		timeoutMs: entry.timeoutMs * 20,
 		async execute(args, exec) {
 			requireEnabled();
-			return record("verifier_track", exec, async () => {
+			return record("verifier_track", exec.agent, async () => {
 				const { verifier, selected } = await engine();
 				return {
 					result: await verifier.track(args.problem, args.steps, args.checkpoints, positive(args.repeats, 2, "repeats"), exec.signal, await images(args.images, exec.signal)),
@@ -1265,7 +1543,7 @@ function apply(ctx, config = {}) {
 	}));
 	ctx.tools.register(defineTool({
 		name: "verifier_current_session",
-		description: "Use autonomously near the end of a non-trivial coding, debugging, migration, deployment, or operations task when independent completion verification would materially reduce risk and the session contains real tool evidence. Do not use for routine conversation, simple factual answers, or every turn. Extracts the current DSH session, applies secret redaction, bounds and truncation, then sends the evidence to the verifier model selected in Settings.",
+		description: "Explicitly verify the current DSH session. Smart/strict policy can also invoke this gate automatically at the turn-stopping lifecycle boundary after consequential work with real tool evidence. Extracts the session, applies redaction and bounds, then sends the evidence to the configured verifier model.",
 		parameters: {
 			from_seq: { type: "integer" },
 			to_seq: { type: "integer" },
@@ -1342,50 +1620,20 @@ function apply(ctx, config = {}) {
 		timeoutMs: entry.timeoutMs * 20,
 		async execute(args, exec) {
 			requireEnabled();
-			return record("verifier_current_session", exec, async () => {
-				const agent = exec.agent ?? ctx.agents.currentInitiator();
-				if (agent === void 0) throw new Error("llm-verifier: verifier_current_session requires an agent-owned tool call");
-				const extracted = await extractSession(agent, async (ref) => {
-					const stored = await ctx.attachments.readImage(ref, exec.signal);
-					return {
-						data: stored.data,
-						mediaType: stored.ref.mediaType
-					};
-				}, {
-					fromSeq: args.from_seq,
-					toSeq: args.to_seq,
-					includeAssistantText: args.include_assistant_text,
-					redactPatterns: args.redact_patterns,
-					maxChars: args.max_chars
-				});
-				const { verifier, selected } = await engine();
-				const compared = await verifier.compare({
-					problem: extracted.problem,
-					candidateA: extracted.trace,
-					candidateB: "(No useful work or verification was performed.)",
-					repeats: positive(args.repeats, 2, "repeats"),
-					images: extracted.images
-				}, exec.signal);
-				return {
-					result: {
-						sessionId: extracted.sessionId,
-						problem: extracted.problem,
-						score: compared.scoreA,
-						baselineScore: compared.scoreB,
-						winner: compared.winner,
-						fromSeq: extracted.fromSeq,
-						toSeq: extracted.toSeq,
-						omittedCharacters: extracted.omittedCharacters,
-						calls: compared.calls,
-						stats: compared.stats
-					},
-					selected
-				};
-			});
+			const agent = exec.agent ?? ctx.agents.currentInitiator();
+			if (agent === void 0) throw new Error("llm-verifier: verifier_current_session requires an agent-owned tool call");
+			return verifySession(agent, {
+				fromSeq: args.from_seq,
+				toSeq: args.to_seq,
+				includeAssistantText: args.include_assistant_text,
+				redactPatterns: args.redact_patterns,
+				maxChars: args.max_chars,
+				repeats: args.repeats
+			}, exec.signal);
 		}
 	}));
 }
 //#endregion
-export { Config, DEFAULT_CRITERIA, DEFAULT_GROUND_TRUTH_NOTE, GRANULARITY, LETTERS, RequestLimiter, SCALE_DESCRIPTION, ScoreCache, StatisticsStore, VERIFIER_TOOL_NAMES, VerifierEngine, accumulatePairs, apply, bradleyTerry, buildPairwisePrompt, buildProgressPrompt, callVerifier, emptyRunStats, errorDetails, extractProgressScore, extractScore, inject, name, normalizeCriteria, normalizeScoreLetter, pivotRoundPairs, rankScores, resolveCacheFile, resolveStatisticsFile, ringCycle, seededRandom, stableHash, topPivots };
+export { AutoVerificationBudget, Config, DEFAULT_CRITERIA, DEFAULT_GROUND_TRUTH_NOTE, GRANULARITY, LETTERS, RequestLimiter, SCALE_DESCRIPTION, ScoreCache, StatisticsStore, VERIFIER_TOOL_NAMES, VerifierEngine, accumulatePairs, analyzeAutoTask, apply, automaticFeedback, bradleyTerry, buildPairwisePrompt, buildProgressPrompt, callVerifier, emptyRunStats, errorDetails, extractProgressScore, extractScore, inject, name, normalizeCriteria, normalizeScoreLetter, pivotRoundPairs, rankScores, resolveCacheFile, resolveStatisticsFile, ringCycle, seededRandom, stableHash, topPivots };
 
 //# sourceMappingURL=index.js.map

package/lib/types/auto.d.ts

@@ -0,0 +1,26 @@
+import type { Agent } from '@deepseek-ai/dsh-agent';
+import type { SessionEvent } from '@deepseek-ai/dsh-session';
+export type AutoVerifyMode = 'manual' | 'smart' | 'strict';
+export interface AutoVerifyPolicy {
+    mode: AutoVerifyMode;
+    minToolCalls: number;
+    maxPerTask: number;
+    maxPerSession: number;
+}
+export interface AutoTaskEvidence {
+    taskStartSeq: number;
+    toolCalls: number;
+    completedToolResults: number;
+    consequentialToolCalls: number;
+    hasManualSessionVerification: boolean;
+    eligible: boolean;
+    reason: string;
+}
+export declare function analyzeAutoTask(events: readonly SessionEvent[], policy: AutoVerifyPolicy): AutoTaskEvidence;
+export declare class AutoVerificationBudget {
+    private readonly states;
+    claim(agent: Agent, evidence: AutoTaskEvidence, policy: AutoVerifyPolicy): boolean;
+    release(agent: Agent): void;
+}
+export declare function automaticFeedback(score: number, baselineScore: number, winner: 'A' | 'B' | 'tie', threshold: number): string;
+//# sourceMappingURL=auto.d.ts.map

package/lib/types/auto.js

@@ -0,0 +1,86 @@
+const PASSIVE_TOOLS = new Set([
+    'read', 'read_image', 'glob', 'grep', 'web_search', 'ssh_list', 'job_list',
+    'job_output', 'list_agents', 'get_goal', 'skill', 'mcp__codegraph__codegraph_explore',
+]);
+const VERIFIER_TOOLS = new Set([
+    'verifier_compare', 'verifier_select', 'verifier_track', 'verifier_current_session',
+]);
+const CONSEQUENTIAL_TOOLS = new Set([
+    'edit', 'write', 'pwsh', 'bash', 'run_code', 'codex_image_generate',
+    'ssh_exec', 'ssh_upload', 'ssh_download', 'ssh_tunnel', 'ssh_cluster',
+    'job_kill', 'workbench_session_delete', 'create_goal', 'update_goal',
+]);
+function latestDirectUserSeq(events) {
+    for (let index = events.length - 1; index >= 0; index -= 1) {
+        const event = events[index];
+        if (event?.type === 'user/message' && event.data.source.kind === 'user')
+            return event.seq;
+    }
+    return undefined;
+}
+function isConsequential(name) {
+    if (CONSEQUENTIAL_TOOLS.has(name))
+        return true;
+    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);
+}
+export function analyzeAutoTask(events, policy) {
+    const taskStartSeq = latestDirectUserSeq(events);
+    if (taskStartSeq === undefined)
+        return { taskStartSeq: 0, toolCalls: 0, completedToolResults: 0, consequentialToolCalls: 0, hasManualSessionVerification: false, eligible: false, reason: 'no-direct-user-task' };
+    const relevant = events.filter(event => event.seq >= taskStartSeq);
+    const calls = relevant.filter((event) => event.type === 'tool/call');
+    const toolCalls = calls.filter(event => !VERIFIER_TOOLS.has(event.data.name)).length;
+    const completedToolResults = relevant.filter(event => event.type === 'tool/result' && event.data.error === undefined && event.data.message.content.every(block => block.isError !== true)).length;
+    const consequentialToolCalls = calls.filter(event => isConsequential(event.data.name)).length;
+    const hasManualSessionVerification = calls.some(event => event.data.name === 'verifier_current_session');
+    if (policy.mode === 'manual')
+        return { taskStartSeq, toolCalls, completedToolResults, consequentialToolCalls, hasManualSessionVerification, eligible: false, reason: 'manual-mode' };
+    if (hasManualSessionVerification)
+        return { taskStartSeq, toolCalls, completedToolResults, consequentialToolCalls, hasManualSessionVerification, eligible: false, reason: 'already-verified' };
+    if (consequentialToolCalls === 0)
+        return { taskStartSeq, toolCalls, completedToolResults, consequentialToolCalls, hasManualSessionVerification, eligible: false, reason: 'no-consequential-work' };
+    if (completedToolResults === 0)
+        return { taskStartSeq, toolCalls, completedToolResults, consequentialToolCalls, hasManualSessionVerification, eligible: false, reason: 'no-completed-evidence' };
+    if (policy.mode === 'smart' && toolCalls < policy.minToolCalls)
+        return { taskStartSeq, toolCalls, completedToolResults, consequentialToolCalls, hasManualSessionVerification, eligible: false, reason: 'insufficient-tool-evidence' };
+    return { taskStartSeq, toolCalls, completedToolResults, consequentialToolCalls, hasManualSessionVerification, eligible: true, reason: policy.mode + '-eligible' };
+}
+export class AutoVerificationBudget {
+    states = new Map();
+    claim(agent, evidence, policy) {
+        if (!evidence.eligible)
+            return false;
+        const id = String(agent.id);
+        const previous = this.states.get(id);
+        const state = previous ?? { 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 = agent.session.events.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));
+    }
+}
+export function automaticFeedback(score, baselineScore, winner, threshold) {
+    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)}.`,
+        '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');
+}
+//# sourceMappingURL=auto.js.map