@lmzhen/dsh-evolution-approval 0.22.0 → 0.24.0

package/lib/index.js

@@ -1,6 +1,6 @@
 import { Service } from "@deepseek-ai/cordis";
 import { randomUUID } from "node:crypto";
-import { clampOnce, elapsedSince, isLoopbackRequest, isProcessAlive, parseLockBody, readJsonObject, textDiffFacts, writeJson } from "@lmzhen/dsh-evolution-core";
+import { clampOnce, elapsedSince, isLoopbackRequest, readJsonObject, textDiffFacts, writeJson } from "@lmzhen/dsh-evolution-core";
 import z from "@deepseek-ai/schemastery";
 import { PENDING_STATUSES } from "@lmzhen/dsh-evolution-state-storage";
 //#region lib/types/routes.js
@@ -32,11 +32,11 @@ function makeApprovalRoutes(approval) {
 	/** Guard: trust fence, then method. Every refusal is a JSON body, never an empty response. */
 	const guard = (req, res, method) => {
 		if (!isLoopbackRequest(req)) {
-			writeJson(res, 403, { error: "forbidden: loopback-only" });
+			writeJson(res, 403, { error: "禁止访问：仅限回环地址" });
 			return false;
 		}
 		if (req.method !== method) {
-			writeJson(res, 405, { error: "method not allowed: " + method });
+			writeJson(res, 405, { error: "方法不允许：" + method });
 			return false;
 		}
 		return true;
@@ -82,7 +82,7 @@ function makeApprovalRoutes(approval) {
 					writeJson(res, 400, {
 						ok: false,
 						code: "bad-request",
-						message: "status must be one of " + PENDING_STATUSES.join(", ")
+						message: "status 必须是以下之一：" + PENDING_STATUSES.join(", ")
 					});
 					return;
 				}
@@ -118,7 +118,7 @@ function makeApprovalRoutes(approval) {
 					writeJson(res, 400, {
 						ok: false,
 						code: "bad-request",
-						message: "id is required"
+						message: "缺少 id"
 					});
 					return;
 				}
@@ -128,7 +128,7 @@ function makeApprovalRoutes(approval) {
 						writeJson(res, 200, {
 							ok: false,
 							code: "not-found",
-							message: "no staged write with id \"" + id + "\""
+							message: "没有 id 为「" + id + "」的待批准写入"
 						});
 						return;
 					}
@@ -138,7 +138,7 @@ function makeApprovalRoutes(approval) {
 							ok: true,
 							data: {
 								available: false,
-								reason: "a \"" + record.kind + "\" write has no preview"
+								reason: "类型 \"" + record.kind + "\" 的写入没有可预览内容"
 							}
 						});
 						return;
@@ -182,7 +182,7 @@ function makeApprovalRoutes(approval) {
 					writeJson(res, 400, {
 						ok: false,
 						code: "bad-request",
-						message: "id is required"
+						message: "缺少 id"
 					});
 					return;
 				}
@@ -199,7 +199,7 @@ function makeApprovalRoutes(approval) {
 					writeJson(res, 400, {
 						ok: false,
 						code: "bad-request",
-						message: "id is required"
+						message: "缺少 id"
 					});
 					return;
 				}
@@ -228,6 +228,30 @@ function makeApprovalRoutes(approval) {
 *
 * @module @lmzhen/dsh-evolution-approval
 */
+/** A claim id carries its holder pid as `<pid>:<hex token>` (minted by `newClaimId()`). */
+const CLAIM_ID_RE = /^(\d+):[0-9a-f]*$/;
+/**
+* @param claimId - an id from a record's `claimedBy` field.
+* @returns the holder pid, or null when the id does not have the claim shape (pre-v43 bare UUID).
+*/
+function claimHolderPid(claimId) {
+	const match = CLAIM_ID_RE.exec(claimId.trim());
+	return match === null ? null : Number(match[1]);
+}
+/**
+* Whether a pid can still be running. `kill(pid, 0)` is the POSIX/Windows probe: it sends no
+* signal and answers through the error — EPERM means the process EXISTS but is not ours.
+* @param pid - the holder pid from a claim id (callers guard `> 0`; there is no pid 0).
+* @returns true when the process exists.
+*/
+function isProcessAlive(pid) {
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch (error) {
+		return error.code === "EPERM";
+	}
+}
 /** The requesting session's effective policy (override ?? configured default);
 * undefined when the approval service is not mounted or no session is
 * available — callers keep their previous behavior. Single source (G4.8,
@@ -242,7 +266,12 @@ var EvolutionApproval = class extends Service {
 	static Config = z.object({
 		enabled: z.boolean().default(false),
 		stageForeground: z.boolean().default(true),
-		pendingTtlMs: z.number().min(0).default(0).volatile()
+		pendingTtlMs: z.number().min(0).default(0).volatile(),
+		approvalConfirm: z.union([
+			z.const("auto"),
+			z.const("ask"),
+			z.const("timeout")
+		]).default("auto").volatile()
 	});
 	enabled;
 	stageForegroundConfig;
@@ -320,12 +349,12 @@ var EvolutionApproval = class extends Service {
 	async run(kind, args, intent) {
 		if (intent?.interface !== "background_review") return {
 			ok: false,
-			message: "approval.run is the background-review replay channel; direct execution must use the tool path (staging is the only gate bypass for foreground)."
+			message: "approval.run 是后台复核的回放通道；直接执行必须走工具路径（对前台而言，暂存是唯一的门禁旁路）。"
 		};
 		const runner = this.runners.get(kind);
 		if (!runner) return {
 			ok: false,
-			message: `No replay runner registered for kind "${kind}".`
+			message: `没有为类型「${kind}」注册回放运行器。`
 		};
 		return await runner(args);
 	}
@@ -334,11 +363,11 @@ var EvolutionApproval = class extends Service {
 		const summary = normalizeSummary(input);
 		if (!this.enabled) return {
 			action: "allow",
-			message: "Approval disabled."
+			message: "批准已禁用。"
 		};
 		if ((this.deriveSessionPolicy(input.sessionId, input.session) ?? (this.ctx.get("approval") ? void 0 : input.sessionPolicy)) === "never") return {
 			action: "allow",
-			message: "Session approval policy is \"never\"; write allowed without staging."
+			message: "会话批准策略是「never」：写入无需暂存，直接放行。"
 		};
 		if (input.origin === "background_review" || this.stageForeground) {
 			if (input.kind !== "capability" && !this.runners.has(input.kind)) this.ctx.logger.warn(`evolution-approval: staging "${input.kind}" write with no replay runner registered - it will not be approvable`);
@@ -356,12 +385,12 @@ var EvolutionApproval = class extends Service {
 			return {
 				action: "staged",
 				pendingId: record.id,
-				message: `Write staged for approval. Review with /evolution pending and approve ${record.id}.`
+				message: `写入已暂存待批准。用 /evolution pending 查看，并批准 ${record.id}。`
 			};
 		}
 		return {
 			action: "allow",
-			message: "Foreground write allowed."
+			message: "前台写入已放行。"
 		};
 	}
 	/** T4-09/A51: the effective expiry of the staged window, 0 = never. Read by the command surface
@@ -427,9 +456,9 @@ var EvolutionApproval = class extends Service {
 	* core/instance-scope.ts, i.e. PER PROCESS, so a second process over one home
 	* is not excluded at all. Two checks stand in its place:
 	* 1. `inFlight` — an approve/reject running in THIS service instance;
-	* 2. the claim's holder pid. Claim ids are minted as `<pid>:<hex token>`, the
-	*    same body shape the io write lock uses, so `parseLockBody` + the core
-	*    `isProcessAlive` probe answer whether that holder can still be running: a
+	* 2. the claim's holder pid. Claim ids are minted as `<pid>:<hex token>` (this
+	*    service's own grammar, see `claimHolderPid`), so that id plus a liveness
+	*    probe answer whether the holder can still be running: a
 	*    LIVE FOREIGN pid REFUSES the release; our own pid is this process's
 	*    leftover (a live in-process approve is what `inFlight` covers); a dead pid
 	*    is a crash. The last two are releasable, which is the S2-P2-22 case.
@@ -445,26 +474,26 @@ var EvolutionApproval = class extends Service {
 		if (!executing) {
 			if ((await this.state().listPending("pending")).find((item) => item.id === id)) return {
 				ok: false,
-				message: `Pending write "${id}" is already in the pending window — approve or reject it.`
+				message: `待批准写入「${id}」已经在待批准窗口里：直接批准或拒绝它。`
 			};
 			return {
 				ok: false,
-				message: `Pending write "${id}" is not in the executing window — nothing to release.`
+				message: `待批准写入「${id}」不在执行窗口中：没有可释放的。`
 			};
 		}
 		if (this.inFlight.has(`approve:${id}`) || this.inFlight.has(`reject:${id}`)) return {
 			ok: false,
-			message: `Pending write "${id}" has an approve/reject RUNNING in this process — do not release it. Verify the effect instead; a completed approve resolves its own record.`
+			message: `待批准写入「${id}」在本进程里有正在运行的批准或拒绝：不要释放它。改为核验效果；已完成的批准会自行了结该记录。`
 		};
 		const claimId = typeof executing.claimedBy === "string" ? executing.claimedBy : "";
 		if (claimId === "") return {
 			ok: false,
-			message: `Pending write "${id}" carries no claim to release (unexpected record shape) — reject it instead.`
+			message: `待批准写入「${id}」没有可释放的占用声明（记录形状异常）：请改为拒绝它。`
 		};
-		const holderPid = parseLockBody(claimId);
+		const holderPid = claimHolderPid(claimId);
 		if (holderPid !== null && holderPid > 0 && holderPid !== process.pid && isProcessAlive(holderPid)) return {
 			ok: false,
-			message: `Pending write "${id}" is claimed by pid ${holderPid}, which is ALIVE — another process may be running this approve. Do not release it: verify the write effect instead and let that run finish (a completed approve resolves its own record).`
+			message: `待批准写入「${id}」被 pid ${holderPid} 占用且该进程仍存活：可能有另一个进程正在执行这次批准。不要释放它：改为核验写入效果，并让那次运行跑完（已完成的批准会自行了结该记录）。`
 		};
 		let released = false;
 		let failure = "";
@@ -477,11 +506,11 @@ var EvolutionApproval = class extends Service {
 		}
 		if (!released) return {
 			ok: false,
-			message: `Release of "${id}" did not take effect (${failure === "" ? "the claim no longer matches the record — a concurrent writer moved it" : failure}) — it stays EXECUTING with its claim unless it resolved, and the write effect is still unverified. Retry, or reject it to close the record without replaying.`
+			message: `释放「${id}」没有生效（${failure === "" ? "the claim no longer matches the record — a concurrent writer moved it" : failure}）：除非它已了结，否则仍处于 EXECUTING 且保留占用声明，写入效果也仍未核验。请重试，或拒绝它以在不重放的情况下关闭记录。`
 		};
 		return {
 			ok: true,
-			message: `Released "${id}" back to the pending window.${holderPid === null ? " Its claim carries no pid, so liveness could NOT be verified: another process may still be running this approve." : ""} VERIFY the effect before approving: approve re-runs the write, and a non-idempotent replay duplicates an effect that already landed; reject closes the record instead.`
+			message: `已把「${id}」放回待批准窗口。${holderPid === null ? " Its claim carries no pid, so liveness could NOT be verified: another process may still be running this approve." : ""} 批准前请先核验效果：批准会重跑该写入，非幂等的重放会造成效果重复；改为拒绝则可关闭该记录。`
 		};
 	}
 	async reject(id) {
@@ -490,14 +519,14 @@ var EvolutionApproval = class extends Service {
 			if (!await this.state().claimPending(id, claimId)) {
 				if ((await this.state().listPending("executing")).find((item) => item.id === id)) return (await this.state().tryResolvePending(id, "rejected")).applied ? {
 					ok: true,
-					message: `Rejected executing write "${id}" (no claim held — this may race an in-flight approve runner; if the write already landed its effect stands as-is. Verify the write state manually).`
+					message: `已拒绝执行中的写入「${id}」（未持有占用声明：这可能与在途的批准运行器抢跑；如果写入已落地，其效果按现状保留。请手动核验写入状态）。`
 				} : {
 					ok: false,
-					message: `Pending write "${id}" could not be rejected: it resolved concurrently.`
+					message: `待批准写入「${id}」无法拒绝：它并发地了结了。`
 				};
 				return {
 					ok: false,
-					message: `Pending write "${id}" is not in the pending window (rotated or resolved).`
+					message: `待批准写入「${id}」不在待批准窗口里（已轮转或已了结）。`
 				};
 			}
 			const resolution = await this.state().tryResolvePending(id, "rejected", claimId);
@@ -505,12 +534,12 @@ var EvolutionApproval = class extends Service {
 				await this.state().releasePendingClaim(id, claimId);
 				return {
 					ok: false,
-					message: `Pending write "${id}" is not pending (already resolved or missing).`
+					message: `待批准写入「${id}」已不在待批准状态（已了结或不存在）。`
 				};
 			}
 			return {
 				ok: true,
-				message: `Rejected ${resolution.record.kind} write "${id}".`
+				message: `已拒绝 ${resolution.record.kind} 写入「${id}」。`
 			};
 		});
 	}
@@ -531,12 +560,11 @@ var EvolutionApproval = class extends Service {
 		if (override === "never" || override === "ask") return override;
 		return platformApproval.config?.policy ?? "ask";
 	}
-	/** v43 FLOW2-1: a claim id that CARRIES its holder pid — `parseLockBody`
-	* reads it back and `isProcessAlive` turns it into `release()`'s verifiable
-	* orphan criterion. The `<pid>:<hex token>` body is the io write lock's own
-	* shape, so one set of core helpers reads both; the token stays unique per
-	* call, so two approves of one record can never share a claim (the token is a
-	* dashed UUID stripped to hex because `LOCK_BODY_RE` accepts only hex). */
+	/** v43 FLOW2-1: a claim id that CARRIES its holder pid — `claimHolderPid` reads
+	* it back and the liveness probe turns it into `release()`'s verifiable orphan
+	* criterion. The token stays unique per call, so two approves of one record can
+	* never share a claim (a dashed UUID stripped to hex, which is what the
+	* claim-id grammar accepts). */
 	newClaimId() {
 		return `${process.pid}:${randomUUID().split("-").join("")}`;
 	}
@@ -555,11 +583,11 @@ var EvolutionApproval = class extends Service {
 		if (!record) {
 			if ((await this.state().listPending("executing")).find((item) => item.id === id)) return {
 				ok: false,
-				message: `Pending write "${id}" is executing — either another writer is resolving it right now, or a previous approve ran then crashed. If you did not start this approve, do not reject it (the in-flight run completes on its own); verify the effect instead. A genuinely stuck record (no runner activity) can still be rejected — /evolution pending shows it as EXECUTING.`
+				message: `待批准写入「${id}」正在执行：可能有另一个写入方正在了结它，或此前一次批准跑过之后崩了。如果不是你发起的这次批准，就不要拒绝它（在途的运行会自行完成）；改为核验效果。确实卡住的记录（运行器没有任何动静）仍然可以拒绝 —— /evolution pending 会把它显示为 EXECUTING。`
 			};
 			return {
 				ok: false,
-				message: `Pending write "${id}" is not in the pending window (rotated or resolved).`
+				message: `待批准写入「${id}」不在待批准窗口里（已轮转或已了结）。`
 			};
 		}
 		const runner = this.runners.get(record.kind);
@@ -568,22 +596,22 @@ var EvolutionApproval = class extends Service {
 				if (!(await this.state().tryResolvePending(id, "approved", claimId)).applied) {
 					if ((await this.state().listPending("rejected")).find((item) => item.id === id)) return {
 						ok: false,
-						message: `Capability "${id}" was approved, but the record was resolved to "rejected" concurrently — no code ran and nothing needs replaying; verify before re-submitting.`
+						message: `能力「${id}」已获批准，但记录被并发地了结为「rejected」：没有代码运行，也无需重放；重新提交前请先核验。`
 					};
 					return {
 						ok: false,
-						message: `Pending write "${id}" was already resolved by another writer.`
+						message: `待批准写入「${id}」已被另一个写入方了结。`
 					};
 				}
 				return {
 					ok: true,
-					message: "Capability approved for manual activation in Creator mode (no code was executed)."
+					message: "能力已批准，可在 Creator 模式下手动激活（未执行任何代码）。"
 				};
 			}
 			await this.state().releasePendingClaim(id, claimId);
 			return {
 				ok: false,
-				message: `No replay runner registered for kind "${record.kind}".`
+				message: `没有为类型「${record.kind}」注册回放运行器。`
 			};
 		}
 		try {
@@ -592,7 +620,7 @@ var EvolutionApproval = class extends Service {
 				await this.state().releasePendingClaim(id, claimId);
 				return {
 					ok: false,
-					message: /changed since this plan|no entry matching|not found|no longer exists|path traversal/i.test(result.message) ? `${result.message} — a sibling write from the same plan may have already changed this target, so repeated approves will keep failing. Reject this record unless the target changed again.` : result.message
+					message: (/* @__PURE__ */ new RegExp("changed since this plan|no entry matching|not found|no longer exists|path traversal|在图渲染之后被改动过|匹配到多条不同条目|已不存在|不存在|路径穿越|不在技能|找不到|被改动过|已改动|不匹配|已过期|changed since it was read", "i")).test(result.message) ? `${result.message} 同一计划里的兄弟写入可能已改动该目标，反复批准会一直失败；除非目标再次变更，请驳回该记录。` : result.message
 				};
 			}
 		} catch (error) {
@@ -600,7 +628,7 @@ var EvolutionApproval = class extends Service {
 			this.ctx.logger.warn(error);
 			return {
 				ok: false,
-				message: "Replay runner failed; the pending write remains pending."
+				message: "回放运行器失败：该待批准写入仍处于待批准状态。"
 			};
 		}
 		const resolution = await this.state().tryResolvePending(id, "approved", claimId).catch((error) => {
@@ -609,21 +637,21 @@ var EvolutionApproval = class extends Service {
 		});
 		if (typeof resolution === "string") return {
 			ok: false,
-			message: `Approved write "${id}" was replayed, but resolving the record failed (${resolution.slice(8)}) — the effect has LANDED while the audit row stays "executing". Verify the write manually; approve will not re-run it.`
+			message: `已批准写入「${id}」已重放，但了结记录失败（${resolution.slice(8)}）：效果已经落地，而审计行仍停在「executing」。请手动核验该写入；批准不会再次重跑它。`
 		};
 		if (!resolution.applied) {
 			if ((await this.state().listPending("rejected")).find((item) => item.id === id)) return {
 				ok: false,
-				message: `Approved write "${id}" was replayed, but the record was resolved to "rejected" concurrently — the effect has landed while the audit reads rejected. Verify the write and do NOT replay it.`
+				message: `已批准写入「${id}」已重放，但记录被并发地了结为「rejected」：效果已落地，而审计显示为 rejected。请核验该写入，且不要重放它。`
 			};
 			return {
 				ok: false,
-				message: `Pending write "${id}" was already resolved by another writer.`
+				message: `待批准写入「${id}」已被另一个写入方了结。`
 			};
 		}
 		return {
 			ok: true,
-			message: `Approved ${record.kind} write "${id}" (${record.summary}).`
+			message: `已批准 ${record.kind} 写入「${id}」（${record.summary}）。`
 		};
 	}
 };

package/lib/types/index.d.ts

@@ -164,6 +164,12 @@ export interface Config {
      * reference and is read at USE time — a settings write changes the window without a reload.
      */
     pendingTtlMs?: Volatile<number>;
+    /**
+     * U-6: what the confirmation before an APPROVE does. The same three words `skillWriteConfirm` uses
+     * for a skill write (`tool-skill-manage/src/write-gates.ts:50`) — mirrored, not imported: the two
+     * packages do not depend on each other and this is a vocabulary, not behaviour.
+     */
+    approvalConfirm?: Volatile<'auto' | 'ask' | 'timeout'>;
 }
 export declare class EvolutionApproval extends Service {
     static inject: string[];
@@ -171,10 +177,12 @@ export declare class EvolutionApproval extends Service {
         enabled: z<boolean, boolean, "defined">;
         stageForeground: z<boolean, boolean, "defined">;
         pendingTtlMs: z<number, number, "volatile-defined">;
+        approvalConfirm: z<"ask" | "auto" | "timeout", "ask" | "auto" | "timeout", "volatile-defined">;
     }>>, Schemastery.ObjectT<NoInfer<{
         enabled: z<boolean, boolean, "defined">;
         stageForeground: z<boolean, boolean, "defined">;
         pendingTtlMs: z<number, number, "volatile-defined">;
+        approvalConfirm: z<"ask" | "auto" | "timeout", "ask" | "auto" | "timeout", "volatile-defined">;
     }>>, "plain">;
     private readonly enabled;
     private readonly stageForegroundConfig;
@@ -263,9 +271,9 @@ export declare class EvolutionApproval extends Service {
      * core/instance-scope.ts, i.e. PER PROCESS, so a second process over one home
      * is not excluded at all. Two checks stand in its place:
      * 1. `inFlight` — an approve/reject running in THIS service instance;
-     * 2. the claim's holder pid. Claim ids are minted as `<pid>:<hex token>`, the
-     *    same body shape the io write lock uses, so `parseLockBody` + the core
-     *    `isProcessAlive` probe answer whether that holder can still be running: a
+     * 2. the claim's holder pid. Claim ids are minted as `<pid>:<hex token>` (this
+     *    service's own grammar, see `claimHolderPid`), so that id plus a liveness
+     *    probe answer whether the holder can still be running: a
      *    LIVE FOREIGN pid REFUSES the release; our own pid is this process's
      *    leftover (a live in-process approve is what `inFlight` covers); a dead pid
      *    is a crash. The last two are releasable, which is the S2-P2-22 case.
@@ -294,12 +302,11 @@ export declare class EvolutionApproval extends Service {
      * check is lazy: the platform service can start before or after this plugin.
      */
     private deriveSessionPolicy;
-    /** v43 FLOW2-1: a claim id that CARRIES its holder pid — `parseLockBody`
-     * reads it back and `isProcessAlive` turns it into `release()`'s verifiable
-     * orphan criterion. The `<pid>:<hex token>` body is the io write lock's own
-     * shape, so one set of core helpers reads both; the token stays unique per
-     * call, so two approves of one record can never share a claim (the token is a
-     * dashed UUID stripped to hex because `LOCK_BODY_RE` accepts only hex). */
+    /** v43 FLOW2-1: a claim id that CARRIES its holder pid — `claimHolderPid` reads
+     * it back and the liveness probe turns it into `release()`'s verifiable orphan
+     * criterion. The token stays unique per call, so two approves of one record can
+     * never share a claim (a dashed UUID stripped to hex, which is what the
+     * claim-id grammar accepts). */
     private newClaimId;
     private dedupe;
     private doApprove;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@lmzhen/dsh-evolution-approval",
   "description": "Stage/pending approval service for Hermes-style self-evolution writes (community build)",
-  "version": "0.22.0",
+  "version": "0.24.0",
   "publishConfig": {
     "access": "public"
   },
@@ -27,18 +27,18 @@
   "license": "MIT",
   "dependencies": {
     "@deepseek-ai/schemastery": "^3.18.4",
-    "@lmzhen/dsh-evolution-core": "^0.22.0"
+    "@lmzhen/dsh-evolution-core": "^0.24.0"
   },
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.1",
     "@deepseek-ai/dsh-host-webserver": "^0.2.0-rc.1",
-    "@lmzhen/dsh-evolution-state-storage": "^0.22.0",
-    "@lmzhen/dsh-evolution-state": "^0.22.0"
+    "@lmzhen/dsh-evolution-state-storage": "^0.24.0",
+    "@lmzhen/dsh-evolution-state": "^0.24.0"
   },
   "devDependencies": {
     "@deepseek-ai/dsh-host-webserver": "^0.2.0-rc.1",
-    "@lmzhen/dsh-evolution-core": "^0.22.0",
-    "@lmzhen/dsh-evolution-state-storage": "^0.22.0",
-    "@lmzhen/dsh-evolution-state": "^0.22.0"
+    "@lmzhen/dsh-evolution-core": "^0.24.0",
+    "@lmzhen/dsh-evolution-state-storage": "^0.24.0",
+    "@lmzhen/dsh-evolution-state": "^0.24.0"
   }
 }