dsh-llm-verifier 0.6.6 → 0.6.8

package/README.md

@@ -263,6 +263,7 @@ flowchart LR
 | **最多候选数** | 自动 `select` 一次最多纳入的候选数，默认 `8` |
 | **每任务/每会话最多路由** | 限制自动路由**周期**的次数：`compare/select/track`、语义分类、团队任务闸、计划预审与 P06 的过程选优周期（过程周期同样消耗本项额度，因此它受既有路由额度约束；另有独立的过程周期每任务上限——恢复触发档 1 次，每步选优档 `maxProcessCyclesPerTask` 次）。**一次周期只消耗一次**——语义分类成立时会在同一个预约上直接提升为它解析出的 `compare/select/track`（分类＋执行＝1 次），因此默认 2 次足以完成「计划预审 → 分类＋compare」；解析为 `none`、低置信、非法引用，或分类成功但执行预算不足时同样消费该周期（后者记录为 `classification-only-budget`，不会伪装成"未路由"或"已评审"）。它与最终验收**各自独立计数**（路由用本项，最终验收用「每任务/每会话最多验收」，互不占用），因此被路由要求过的最终验收一定有额度可用；旧版共享一个计数器时，路由可以把最终验收的额度花光，导致 turn 在从未验收的情况下静默关闭。预算按真实对局数估算（8 候选约需 108 次调用）；被拒绝时写入宿主日志并区分「预算不足 / 已有 verifier 在跑 / 同一证据已路由」，strict 下额外注入一次提示。每个周期还会在统计里留下一条 `route` 观测：周期 id、触发点、去向、预约调用数、证据保留/省略数与取消标记——它是诊断口径，**不是**模型调用数。分类去重按**渲染后的证据（提示词）**而非最后事件序号，追加纯叙述不会再次付费分类；周期 id 取 epoch＋实例＋序号，跨插件重载唯一，重载前后两个不同周期不会在看板与离线汇总里合并；没有预约的诊断行（预算丢弃、交付阶段跳过、证据读取失败 evidence-unreadable）共用同一套 epoch 命名空间 |
 | **同时验收子 Agent** | 默认关闭；开启后 `subagent` / fork 子会话也会执行自动路由与最终验收 |
+| **接入真实文件改动证据** | 默认**开启**。会话验收（显式 `verifier_current_session` 与自动最终验收）把**宿主自己记录的**本轮文件改动作为证据交给裁判：改动文件清单（路径 + 增删行数）与逐文件前后对比（`@@` 块 + 带 `+`/`-`/空格前缀的行），经参考上下文分隔块进入提示词（因此改动不同必然重新评分，评分缓存键包含该文本）。它修的是「裁判只能从 `tool/call` 的参数反推 Agent 声称改了什么」——改完没落盘、或事后又被改写，过去与真实改动无从区分。限长沿用同一套预算：整块不超过「单项字符上限」（截断提示计入），最多渲染 8 个文件（超出在表头注明），其余字符按文件数用 `itemBudget` 分摊、逐文件按行截断并注明省略行数；`binary` / `oversized` 文件只列一行说明、不读取对比。宿主未提供该服务（0.1.1/0.1.5）、会话已销毁、`summary` 或 `diff` 报错时一律**静默降级为不带该证据**并在宿主日志告警，绝不阻断验收。需要 DSH 0.1.6+ 宿主 |
 | **过程选优** | 三档（旧布尔值兼容：`true`→`recovery`，`false`/缺省→`off`）：`off`（默认）完全不进入该路径（不生成候选、不调用裁判、不缓冲响应）；`recovery`（恢复触发）仅当同一任务最近两次已完成的验证运行**都失败**（「失败」从运行自己的判决读：`[exit code: N≠0]`、`N failed`、`error TS…`、`test result: FAILED`、`FAIL` 都算，工具级报错也算；`0 failed` 不算失败）时，为**下一次主模型请求**额外生成备选回复，每任务最多 1 个周期；`every-step`（每步选优）为**每个主循环请求**登记选优意图，无需失败信号，每任务最多 `maxProcessCyclesPerTask` 个周期。三档均**仅 smart 模式**生效（manual/strict 不进入该路径），触发后机制相同：额外生成备选（默认 N=2：原回复＝候选 0，新增一份＝候选 1；`autoProcessCandidates` 可提到 3 或 4，那时按锦标赛判定；采样温度不低于生成档位，避免低温会话买到原回复的副本），按 **process 判据**（失败靶向 / 与已失败尝试不同 / 可验证的一步）比较后**只回放胜者**。过程周期有自己的每任务上限（独立于路由与最终验收的第三本账），同时也消耗「每任务/每会话最多路由」额度，并受任务/会话模型调用预算与最终验收保留额度共同限制；生成与比较共用一个 `timeoutMs` 阶段截止时间。裁判视图里的任务、约束、最近失败证据与两份候选（含工具名与参数）**先脱敏再限长**，并按实际渲染文本计量总量，工具动作无法完整容纳时回退原回复。选优**不是**验收：胜者交给宿主后，最终验收照常覆盖随后产生的实际工作 |
 | **备选带上失败证据** | 默认**开启**，仅在过程选优非 `off` 时生效。`recovery` 档把触发本周期的那两次失败验证运行（先 `sanitizeVerifierText` 脱敏，再按单项/总量双层限长，总量 4000 字符）作为一条插件 user 消息附在备选请求之后，让额外生成的候选是针对真实失败的一次不同尝试，而不是同一提示词的再抽样；`every-step` 档只在任务恰好出现两连败信号时附带，无信号则不带；关闭即对照组（两份候选掌握的信息完全相同，周期照买）。裁判**不被告知**哪份候选带了证据，避免按来源而不是按内容打分；统计行的 `route.alternativeAugmented` 记录该差异，供真实任务对照读取。 |
 | **备选用另一个模型** | 默认留空：备选由当前会话模型再采样。可填**逗号分隔**的 `provider/model` 列表（例如 `deepseek-official/deepseek-v4-flash, openai/gpt-5`）：第 i 份备选使用第 i 项，列表短于备选数时循环取用，候选之间因此是真正的不同假设；跨 provider 时**不继承**原请求的推理强度（适配器可能不认识该 id），`maxTokens` 与生成温度下限照旧，归一化后的整个列表记进 `route.alternativeModel`。代价是比较同时也在比「哪个模型更好」，与任务本身的质量不可分——所以它是实验臂，不是推荐配置。 |

package/lib/{auto-DzlnuWAr.js → auto-DmyrNZXK.js}

@@ -122,10 +122,10 @@ var ScoreCache = class {
 		};
 		this.writing = this.writing.catch(() => {}).then(async () => {
 			await mkdir(dirname(this.file), { recursive: true });
-			const temporary = this.file + ".tmp-" + process.pid;
+			const temporary = this.file + ".tmp-" + process.pid + "-" + (replaceOrdinal += 1);
 			await writeFile(temporary, JSON.stringify(snapshot), "utf8");
 			try {
-				await rename(temporary, this.file);
+				await replaceFile(temporary, this.file);
 			} catch (error) {
 				await unlink(temporary).catch(() => {});
 				throw error;
@@ -134,14 +134,48 @@ var ScoreCache = class {
 		await this.writing;
 	}
 };
+/** Replace failures that are a transient lock rather than a verdict about the cache directory. */
+const TRANSIENT_REPLACE_CODES = /* @__PURE__ */ new Set([
+	"EPERM",
+	"EACCES",
+	"EBUSY"
+]);
+/** Distinguishes the temporary file of every write in this process, across all cache instances. */
+let replaceOrdinal = 0;
+/**
+* Windows refuses the replace with a transient sharing violation while a scanner or indexer still
+* holds the freshly written file. The score this snapshot carries was already paid for, so those
+* codes are retried; anything else, or a persistent failure, still fails the write.
+* @param temporary - the written snapshot, or the named source of the replace.
+* @param target - the cache file every reader opens.
+*/
+async function replaceFile(temporary, target) {
+	for (let attempt = 1;; attempt += 1) try {
+		await rename(temporary, target);
+		return;
+	} catch (error) {
+		const code = error.code;
+		if (attempt >= 5 || code === void 0 || !TRANSIENT_REPLACE_CODES.has(code)) throw error;
+		await new Promise((resolve) => setTimeout(resolve, attempt * 10));
+	}
+}
 //#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.
+* 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.
+*
+* DSH 0.1.6 deprecated `snapshotEvents()`: existing logic may stay unmigrated, but new calls are
+* prohibited, and so are wrappers that expose the same synchronous history — this function is such
+* a wrapper and is kept deliberately. The replacement the host offers, `SessionController.page()`,
+* is filtered to `user/message` and `assistant/message`, so `tool/call`, `tool/result` and the PTC
+* dispatches this plugin scores on do not come back through it; the host's own `auto-review`
+* carries the same waiver for the same reason. The migration is to maintain the evidence these
+* readers need through a registered Session projection instead of looking back through the log;
+* `AGENTS.md` records the decision and what would force it.
 * @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.
 */
@@ -614,7 +648,7 @@ const VERIFIER_EVIDENCE_TOOLS = /* @__PURE__ */ new Set([
 	"verifier_current_session"
 ]);
 /** Tools that return either a child's report (evidence) or a bare start acknowledgement (not evidence). */
-const SUBAGENT_TOOLS = /* @__PURE__ */ new Set(["subagent", "subagent_fork"]);
+const SUBAGENT_TOOLS$1 = /* @__PURE__ */ new Set(["subagent", "subagent_fork"]);
 /**
 * Start acknowledgement of a background child.
 *
@@ -638,7 +672,7 @@ function isEvidenceOutput(name, text) {
 	if (BOOKKEEPING_TOOLS.has(name) || VERIFIER_EVIDENCE_TOOLS.has(name)) return false;
 	const body = text.trim();
 	if (!body) return false;
-	return !(SUBAGENT_TOOLS.has(name) && CHILD_START_ACKNOWLEDGEMENT.test(body));
+	return !(SUBAGENT_TOOLS$1.has(name) && CHILD_START_ACKNOWLEDGEMENT.test(body));
 }
 /** Signatures of an output that reports a PASSED verification result. */
 const VERIFICATION_PASS_SIGNATURES = [
@@ -1849,6 +1883,116 @@ function isSuccessfulCodeDispatch(data) {
 	if (Array.isArray(data.content) && data.content.some((b) => b.isError === true)) return false;
 	return true;
 }
+const SUBAGENT_TOOLS = /* @__PURE__ */ new Set(["subagent", "subagent_fork"]);
+const CONTINUABLE_SUBAGENT_START = /^\s*started subagent\s+([^\s`]+)/imu;
+const BACKGROUND_SUBAGENT_JOB_START = /^\s*started background subagent job\s+([^\s`]+)/imu;
+const GENERAL_SUBAGENT_START = /^\s*started (?:background )?subagent\b/imu;
+/**
+* Whether background subagents started during the current task remain in flight.
+*
+* A background subagent returns immediately with a start receipt (`started subagent <id>`
+* or `started background subagent job <id>`) and settles later via a runtime-injected notice
+* (`source.kind === 'subagent-settled'` or a job settlement notice). Performing session
+* acceptance while subagents are in flight will always fail and steer prematurely because the
+* delegated work has not reported back yet.
+* @param events - session events.
+* @param taskStartSeq - sequence number of the current direct user task statement.
+* @returns True when at least one background subagent remains unsettled.
+*/
+function hasPendingSubagents(events, taskStartSeq) {
+	const relevant = events.filter((event) => event.seq >= taskStartSeq);
+	const pendingContinuable = /* @__PURE__ */ new Map();
+	const pendingJobs = /* @__PURE__ */ new Map();
+	let anonymousPendingCount = 0;
+	const calls = /* @__PURE__ */ new Map();
+	for (const event of relevant) if (event.type === "tool/call") calls.set(String(event.data.callId), event);
+	for (const event of relevant) {
+		if (event.type === "tool/result") {
+			const call = calls.get(String(event.data.message.source.callId));
+			if (call && SUBAGENT_TOOLS.has(call.data.name) && event.data.error === void 0) {
+				if (event.data.message.content.every((b) => b.isError !== true)) {
+					const text = blockText(event.data.message.content);
+					const contMatch = text.match(CONTINUABLE_SUBAGENT_START);
+					const jobMatch = text.match(BACKGROUND_SUBAGENT_JOB_START);
+					if (contMatch) pendingContinuable.set(contMatch[1], event.seq);
+					else if (jobMatch) pendingJobs.set(jobMatch[1], event.seq);
+					else if (GENERAL_SUBAGENT_START.test(text)) anonymousPendingCount += 1;
+				}
+			}
+		} else if (CODE_DISPATCH_TYPES.has(event.type)) {
+			const data = event.data;
+			if (data && SUBAGENT_TOOLS.has(data.name) && isSuccessfulCodeDispatch(data)) {
+				const text = blockText(data.content);
+				const contMatch = text.match(CONTINUABLE_SUBAGENT_START);
+				const jobMatch = text.match(BACKGROUND_SUBAGENT_JOB_START);
+				if (contMatch) pendingContinuable.set(contMatch[1], event.seq);
+				else if (jobMatch) pendingJobs.set(jobMatch[1], event.seq);
+				else if (GENERAL_SUBAGENT_START.test(text)) anonymousPendingCount += 1;
+			}
+		}
+		if (event.type === "user/message") {
+			const source = event.data?.source;
+			const text = blockText(event.data?.content);
+			if (source?.kind === "subagent-settled") {
+				const senderId = typeof source.senderSessionId === "string" ? source.senderSessionId : void 0;
+				if (senderId && pendingContinuable.has(senderId)) pendingContinuable.delete(senderId);
+				else {
+					let found = false;
+					for (const [id] of pendingContinuable) if (text.includes(id)) {
+						pendingContinuable.delete(id);
+						found = true;
+						break;
+					}
+					if (!found) {
+						if (pendingContinuable.size > 0) {
+							const oldest = pendingContinuable.keys().next().value;
+							if (oldest !== void 0) pendingContinuable.delete(oldest);
+						} else if (anonymousPendingCount > 0) anonymousPendingCount -= 1;
+					}
+				}
+			} else if (source?.plugin === "tool-jobs" || /background job\b.*finished/iu.test(text)) {
+				for (const [jobId] of pendingJobs) if (text.includes(jobId)) {
+					pendingJobs.delete(jobId);
+					break;
+				}
+			}
+		}
+		if (event.type === "tool/call") {
+			const name = event.data.name;
+			const argsText = event.data.arguments;
+			let parsedArgs = {};
+			if (typeof argsText === "string") try {
+				parsedArgs = JSON.parse(argsText);
+			} catch {}
+			else if (typeof argsText === "object" && argsText !== null) parsedArgs = argsText;
+			if (name === "interrupt_agent") {
+				const target = String(parsedArgs.target ?? parsedArgs.agent_id ?? "");
+				if (target && pendingContinuable.has(target)) pendingContinuable.delete(target);
+			} else if (name === "job_kill") {
+				const jobId = String(parsedArgs.job_id ?? "");
+				if (jobId && pendingJobs.has(jobId)) pendingJobs.delete(jobId);
+			}
+		} else if (CODE_DISPATCH_TYPES.has(event.type)) {
+			const data = event.data;
+			if (data) {
+				const name = data.name;
+				let parsedArgs = {};
+				if (typeof data.arguments === "string") try {
+					parsedArgs = JSON.parse(data.arguments);
+				} catch {}
+				else if (typeof data.arguments === "object" && data.arguments !== null) parsedArgs = data.arguments;
+				if (name === "interrupt_agent") {
+					const target = String(parsedArgs.target ?? parsedArgs.agent_id ?? "");
+					if (target && pendingContinuable.has(target)) pendingContinuable.delete(target);
+				} else if (name === "job_kill") {
+					const jobId = String(parsedArgs.job_id ?? "");
+					if (jobId && pendingJobs.has(jobId)) pendingJobs.delete(jobId);
+				}
+			}
+		}
+	}
+	return pendingContinuable.size > 0 || pendingJobs.size > 0 || anonymousPendingCount > 0;
+}
 function analyzeAutoTask(events, policy, sessionId) {
 	const taskStartSeq = latestDirectUserSeq(events);
 	if (taskStartSeq === void 0) return {
@@ -1858,6 +2002,7 @@ function analyzeAutoTask(events, policy, sessionId) {
 		consequentialToolCalls: 0,
 		hasManualSessionVerification: false,
 		manualVerificationAccepted: false,
+		pendingSubagents: false,
 		eligible: false,
 		reason: "no-direct-user-task"
 	};
@@ -1915,6 +2060,7 @@ function analyzeAutoTask(events, policy, sessionId) {
 			criteria: verdict.criteria
 		}, policy.threshold) && !stale(verdict.toSeq);
 	});
+	const pendingSubagents = hasPendingSubagents(events, taskStartSeq);
 	if (policy.mode === "manual") return {
 		taskStartSeq,
 		toolCalls,
@@ -1922,6 +2068,7 @@ function analyzeAutoTask(events, policy, sessionId) {
 		consequentialToolCalls,
 		hasManualSessionVerification,
 		manualVerificationAccepted,
+		pendingSubagents,
 		eligible: false,
 		reason: "manual-mode"
 	};
@@ -1932,9 +2079,21 @@ function analyzeAutoTask(events, policy, sessionId) {
 		consequentialToolCalls,
 		hasManualSessionVerification,
 		manualVerificationAccepted,
+		pendingSubagents,
 		eligible: false,
 		reason: "already-verified"
 	};
+	if (pendingSubagents) return {
+		taskStartSeq,
+		toolCalls,
+		completedToolResults,
+		consequentialToolCalls,
+		hasManualSessionVerification,
+		manualVerificationAccepted,
+		pendingSubagents: true,
+		eligible: false,
+		reason: "pending-subagents"
+	};
 	if (consequentialToolCalls === 0) return {
 		taskStartSeq,
 		toolCalls,
@@ -1942,6 +2101,7 @@ function analyzeAutoTask(events, policy, sessionId) {
 		consequentialToolCalls,
 		hasManualSessionVerification,
 		manualVerificationAccepted,
+		pendingSubagents,
 		eligible: false,
 		reason: "no-consequential-work"
 	};
@@ -1952,6 +2112,7 @@ function analyzeAutoTask(events, policy, sessionId) {
 		consequentialToolCalls,
 		hasManualSessionVerification,
 		manualVerificationAccepted,
+		pendingSubagents,
 		eligible: false,
 		reason: "no-completed-evidence"
 	};
@@ -1962,6 +2123,7 @@ function analyzeAutoTask(events, policy, sessionId) {
 		consequentialToolCalls,
 		hasManualSessionVerification,
 		manualVerificationAccepted,
+		pendingSubagents,
 		eligible: false,
 		reason: "insufficient-tool-evidence"
 	};
@@ -1972,6 +2134,7 @@ function analyzeAutoTask(events, policy, sessionId) {
 		consequentialToolCalls,
 		hasManualSessionVerification,
 		manualVerificationAccepted,
+		pendingSubagents,
 		eligible: true,
 		reason: policy.mode + "-eligible"
 	};
@@ -2139,6 +2302,6 @@ function selectRouteFeedbackDetail(candidates, result, maxChars = MAX_ROUTE_FEED
 	].join("\n"));
 }
 //#endregion
-export { verificationFailed as A, latestDirectUserSeq as C, semanticDecision as D, routedRepeats as E, ScoreCache as F, SingleFlight as I, resolveCacheFile as L, extractSession as M, sanitizeVerifierText as N, semanticReferencesVisible as O, sessionEvents as P, stableHash as R, itemBudget as S, parseSemanticRoute as T, buildSemanticRoutePrompt as _, compareRouteFeedbackDetail as a, inspectDeliveryPhase as b, selectRouteFeedbackDetail as c, AutoVerifierRouter as d, MAX_ROUTED_CHECKPOINTS as f, buildEvidenceIndex as g, boundDecision as h, automaticFeedback as i, verificationVerdict as j, semanticRouteHint as k, sessionAccepted as l, analyzeStructuredRoute as m, PROPOSAL_FEEDBACK_NOTE as n, failedAcceptanceCriteria as o, RECOVERY_FAILURE_CONTEXT_CHARS as p, analyzeAutoTask as r, isSubagentSession as s, MAX_ROUTE_FEEDBACK_CHARS as t, topScoreIndices as u, buildSemanticRouteView as v, nextDiagnosticCycleId as w, inspectRecoverySignal as x, estimateRoutedCalls as y };
+export { semanticRouteHint as A, itemBudget as C, routedRepeats as D, parseSemanticRoute as E, sessionEvents as F, ScoreCache as I, SingleFlight as L, verificationVerdict as M, extractSession as N, semanticDecision as O, sanitizeVerifierText as P, resolveCacheFile as R, inspectRecoverySignal as S, nextDiagnosticCycleId as T, buildEvidenceIndex as _, compareRouteFeedbackDetail as a, estimateRoutedCalls as b, isSubagentSession as c, topScoreIndices as d, AutoVerifierRouter as f, boundDecision as g, analyzeStructuredRoute as h, automaticFeedback as i, verificationFailed as j, semanticReferencesVisible as k, selectRouteFeedbackDetail as l, RECOVERY_FAILURE_CONTEXT_CHARS as m, PROPOSAL_FEEDBACK_NOTE as n, failedAcceptanceCriteria as o, MAX_ROUTED_CHECKPOINTS as p, analyzeAutoTask as r, hasPendingSubagents as s, MAX_ROUTE_FEEDBACK_CHARS as t, sessionAccepted as u, buildSemanticRoutePrompt as v, latestDirectUserSeq as w, inspectDeliveryPhase as x, buildSemanticRouteView as y, stableHash as z };
 
-//# sourceMappingURL=auto-DzlnuWAr.js.map
+//# sourceMappingURL=auto-DmyrNZXK.js.map