@eddyskywalker/dsh-chatgpt-subscription 0.48.0 → 0.48.2

package/lib/index.js

@@ -145,7 +145,7 @@ const ROUTE_PREFIX$5 = "/api/dsh-chatgpt-subscription";
 * `test/responses-client.test.ts` asserts the two agree, so a release that
 * forgets this constant fails the suite instead of shipping quietly.
 */
-const PLUGIN_VERSION = "0.48.0";
+const PLUGIN_VERSION = "0.48.2";
 const CODEX_CHATGPT_PROVIDER_ID = "codex-chatgpt";
 const CODEX_API_BASE = "https://chatgpt.com/backend-api/codex";
 const CODEX_RESPONSES_URL = `${CODEX_API_BASE}/responses`;
@@ -80832,10 +80832,11 @@ function installCompactionPrompt(ctx) {
 * realm 的 `ctx.reflect.store` 里，宿主平面根本看不到它，也就没有地方把
 * "这场会话的 provider 该不该修剪" 插进去。
 *
-* 这一层守卫因此待在**宿主平面**：它不替换任何行，只在下述两个时机把已经挂载
+* 这一层守卫因此待在**宿主平面**：它不替换任何行，只在下述时机把已经挂载
 * 的 `toolResultPruner` 实例的 `pruneSession` 包一层 provider 短路 ——
-* 安装时先扫一遍，此后每个 agent 开始一步（`agent/pre-step`）或撞上上下文溢出
-* （`agent/request-error`）时再扫一遍。两个位置都要看：
+* 安装时先扫一遍，此后每个 agent 开始一步（`agent/pre-step`）、每次发起请求
+* （`agent/request`）或撞上上下文溢出（`agent/request-error`）时再扫一遍。
+* 三个事件都是 Cordis **瀑布**事件，监听器必须转交 `next()`（见下）。两个位置都要看：
 *
 * - `ctx.reflect.store`（宿主平面自己的服务记录，含安装后才挂上的实例）；
 * - `agent.ctx.get('toolResultPruner')` 与 `agent.ctx.reflect.store`
@@ -80844,6 +80845,17 @@ function installCompactionPrompt(ctx) {
 * 包装按 `WeakSet` 幂等，重复事件不会叠第二层；`dispose()` 逐条还原原方法并
 * 摘掉监听器。
 *
+* ## 瀑布事件必须转交 `next()`
+*
+* `agent/pre-step` / `agent/request` / `agent/request-error` 是 Cordis **瀑布**事件
+* （`ctx.waterfall`），最后一个参数就是 `next`。瀑布的返回值是**最外层监听器的返回值**：不调用 `next()`
+* 等于替整条链做了决定——后续监听器（连同内置的默认行为）一个都不跑，瀑布的返回值
+* 也变成监听器自己的返回值。于是 `agent-loop` 读 `decision.kind` 时拿到
+* `undefined`，每一轮都炸成
+* `TypeError: Cannot read properties of undefined (reading 'kind')`。
+* 本守卫是旁路，扫描失败只吞掉扫描本身，但 `next()` 在所有分支上都要被调用并原样
+* 交回去。
+*
 * ## 只做短路，不改语义
 *
 * 包装后的 `pruneSession` 只有一条分支：`shouldSkipPruningForSession` 命中就
@@ -80852,8 +80864,12 @@ function installCompactionPrompt(ctx) {
 *
 * @module @eddyskywalker/dsh-chatgpt-subscription/host/tool-result-pruner-guard
 */
-/** 会先跑一遍扫描的宿主事件。 */
-const GUARDED_EVENTS$1 = ["agent/pre-step", "agent/request-error"];
+/** 会先跑一遍扫描的宿主事件（全部是 Cordis 瀑布事件，监听器必须转交 `next()`）。 */
+const GUARDED_EVENTS$1 = [
+	"agent/pre-step",
+	"agent/request",
+	"agent/request-error"
+];
 /**
 * 安装跨 preset 守卫。
 *
@@ -80869,6 +80885,8 @@ function installToolResultPrunerGuard(ctx, options = {}) {
 	const skipSet = resolveSkipProviders(options.skipProviders ?? DEFAULT_SKIP_PROVIDERS);
 	/** 已包装过的实例（幂等标记）。 */
 	const alreadyWrapped = /* @__PURE__ */ new WeakSet();
+	/** 已包装过的「方法宿主 + 方法名」：同一个原型不叠第二层包装。 */
+	const patchedMethods = /* @__PURE__ */ new WeakMap();
 	/** 已包装的方法，销毁时逐条还原。 */
 	const restores = [];
 	/** 事件监听的 disposer。 */
@@ -80883,22 +80901,25 @@ function installToolResultPrunerGuard(ctx, options = {}) {
 	const wrapPruner = (pruner) => {
 		if (disposed || !isRecord$8(pruner)) return false;
 		if (alreadyWrapped.has(pruner)) return false;
-		const target = pruner;
-		const current = target["pruneSession"];
-		if (typeof current !== "function") return false;
-		const original = current;
+		const target = resolveMethodTarget$3(pruner, "pruneSession");
+		if (target === void 0) return false;
+		if (alreadyPatched$3(patchedMethods, target.holder, target.name)) {
+			alreadyWrapped.add(pruner);
+			return false;
+		}
+		const original = target.original;
 		const replacement = function(session) {
 			if (shouldSkipPruningForSession(session, skipSet)) return {
 				pruned: [],
 				charsRemoved: 0
 			};
-			return original.call(this, session);
+			return original.call(this ?? pruner, session);
 		};
-		target["pruneSession"] = replacement;
+		if (!installMethod$3(target, replacement)) return false;
+		markPatched$3(patchedMethods, target.holder, target.name);
 		alreadyWrapped.add(pruner);
-		restores.push({
-			target,
-			original
+		restores.push(() => {
+			restoreMethod$3(target);
 		});
 		return true;
 	};
@@ -80965,16 +80986,32 @@ function installToolResultPrunerGuard(ctx, options = {}) {
 	/**
 	* 事件回调：先扫宿主平面，再扫事件里那个 agent 自己的 realm。
 	*
-	* @param args - 事件参数（通常第一个是 agent 本身）。
+	* ## 瀑布必须转交
+	*
+	* `agent/pre-step` / `agent/request` / `agent/request-error` 在 DSH 里是 Cordis
+	* **瀑布**事件（`ctx.waterfall`），最后一个参数就是 `next`。瀑布的返回值是**最外层监听器
+	* 的返回值**：不调用 `next()` 等于替整条链做了决定——后续监听器（连同内置的
+	* 默认行为）一个都不会跑，瀑布的返回值也变成监听器自己的返回值（这里是
+	* `undefined`）。`agent-loop` 随后读 `decision.kind`，于是每一轮都炸成
+	* `TypeError: Cannot read properties of undefined (reading 'kind')`。
+	*
+	* 所以扫描照旧做（扫描失败也只吞掉扫描本身），但 `next()` **必须**在所有分支上
+	* 被调用，并把它的结果原样交回去。
+	*
+	* @param args - 事件参数（最后一个参数可能是 `next`）。
+	* @returns `next()` 的结果；没有 `next` 时为 `undefined`。
 	*/
 	const handleAgentEvent = (...args) => {
+		const next = args.length > 0 && typeof args[args.length - 1] === "function" ? args[args.length - 1] : void 0;
 		try {
 			scanAndWrap();
 			const agentCtx = findAgentContext$1(args);
-			if (agentCtx === void 0) return;
-			scanStore(agentCtx);
-			wrapServiceFrom(agentCtx, PRUNER_SERVICE_NAME);
+			if (agentCtx !== void 0) {
+				scanStore(agentCtx);
+				wrapServiceFrom(agentCtx, PRUNER_SERVICE_NAME);
+			}
 		} catch {}
+		return next === void 0 ? void 0 : next();
 	};
 	for (const event of GUARDED_EVENTS$1) {
 		const disposer = subscribe$3(host, event, handleAgentEvent);
@@ -80989,7 +81026,9 @@ function installToolResultPrunerGuard(ctx, options = {}) {
 			for (const disposer of disposers.splice(0)) try {
 				disposer();
 			} catch {}
-			for (const record of restores.splice(0)) record.target["pruneSession"] = record.original;
+			for (const restore of restores.splice(0)) try {
+				restore();
+			} catch {}
 		}
 	};
 }
@@ -81082,6 +81121,103 @@ function readContext$1(value) {
 function isRecord$8(value) {
 	return typeof value === "object" && value !== null;
 }
+/**
+* 定位一个待包装的方法。
+*
+* Cordis 的 `Service` 代理在读属性时会把方法**绑定到读取它的那一层作用域**
+* （`Reflect.get(target, prop, receiver).bind(receiver)`）。于是
+* `const original = tools.register` 拿到的是一份**已经绑到根作用域**的函数；再
+* `original.call(tools, …)` 就把根作用域硬塞回每一个 preset 的注册里，全局层
+* 于是撞上 "already registered"。
+*
+* 真正要的是**原型上那份未绑定的方法**：包装器用 `original.call(this, …)` 把
+* 调用方自己的 receiver 传下去，服务里的 `this.ctx` 才留在调用方那一层作用域
+* （child ctx）里。方法挂在原型上时（真实 Cordis `Service`），包装也写在原型上；
+* 只有普通假对象（单测）才把方法作为自有属性挂在实例上。
+*
+* @param service - 服务实例（可以是 Cordis 的跟踪代理）。
+* @param name - 方法名。
+* @returns 目标；方法不存在时为 `undefined`。
+*/
+function resolveMethodTarget$3(service, name) {
+	if (typeof service !== "object" || service === null) return void 0;
+	const own = service;
+	if (Object.prototype.hasOwnProperty.call(own, name)) {
+		const original = own[name];
+		if (typeof original !== "function") return void 0;
+		return {
+			holder: own,
+			name,
+			original,
+			descriptor: Object.getOwnPropertyDescriptor(own, name)
+		};
+	}
+	const proto = Object.getPrototypeOf(service);
+	if (proto === null) return void 0;
+	if (proto === Object.prototype || proto === Function.prototype) return void 0;
+	const original = proto[name];
+	if (typeof original !== "function") return void 0;
+	return {
+		holder: proto,
+		name,
+		original,
+		descriptor: Object.getOwnPropertyDescriptor(proto, name)
+	};
+}
+/**
+* 把一个包装写到方法所在的位置上。
+*
+* @param target - 目标。
+* @param replacement - 包装实现。
+* @returns 是否装上了。
+*/
+function installMethod$3(target, replacement) {
+	try {
+		Object.defineProperty(target.holder, target.name, {
+			value: replacement,
+			configurable: true,
+			writable: true,
+			enumerable: target.descriptor?.enumerable ?? false
+		});
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* 还原方法所在位置上原来的实现。
+*
+* @param target - 目标。
+*/
+function restoreMethod$3(target) {
+	try {
+		if (target.descriptor === void 0) Reflect.deleteProperty(target.holder, target.name);
+		else Object.defineProperty(target.holder, target.name, target.descriptor);
+	} catch {}
+}
+/**
+* 判断某个「方法宿主 + 方法名」是不是已经被本守卫包过。
+*
+* @param patched - 已包装记录。
+* @param holder - 方法宿主。
+* @param name - 方法名。
+* @returns 是否已经包过。
+*/
+function alreadyPatched$3(patched, holder, name) {
+	return patched.get(holder)?.has(name) === true;
+}
+/**
+* 记下某个「方法宿主 + 方法名」已经被本守卫包过。
+*
+* @param patched - 已包装记录。
+* @param holder - 方法宿主。
+* @param name - 方法名。
+*/
+function markPatched$3(patched, holder, name) {
+	const names = patched.get(holder);
+	if (names === void 0) patched.set(holder, /* @__PURE__ */ new Set([name]));
+	else names.add(name);
+}
 //#endregion
 //#region src/host/plan-mode-cache-guard.ts
 /** 没有 scope 的装配（会话标题之类）用的桶键。 */
@@ -81136,6 +81272,8 @@ function subscribe$2(ctx, event, listener) {
 function installPlanModeCacheGuard(ctx) {
 	const states = /* @__PURE__ */ new WeakMap();
 	const restores = [];
+	/** 已包装过的「方法宿主 + 方法名」：同一个原型不叠第二层包装。 */
+	const patchedMethods = /* @__PURE__ */ new WeakMap();
 	let closed = false;
 	/**
 	* 取（或建）一个桶的状态。
@@ -81210,22 +81348,25 @@ function installPlanModeCacheGuard(ctx) {
 		offPreStep();
 	});
 	const wrap = (tools) => {
-		if (tools === void 0 || typeof tools.register !== "function") return;
-		const original = tools.register;
-		const wrapped = function(definition, options) {
+		if (tools === void 0) return;
+		const target = resolveMethodTarget$2(tools, "register");
+		if (target === void 0) return;
+		if (alreadyPatched$2(patchedMethods, target.holder, target.name)) return;
+		const original = target.original;
+		const wrapped = function(...args) {
+			const receiver = this ?? tools;
+			const definition = args[0];
+			const options = args[1];
 			if (definition?.name === "exit_plan_mode" && options !== void 0 && options !== null && "when" in options) {
 				const { when: _dropped, ...rest } = options;
-				return original.call(tools, definition, rest);
+				return original.call(receiver, definition, rest);
 			}
-			return original.call(tools, definition, options);
+			return original.call(receiver, definition, options);
 		};
-		try {
-			tools.register = wrapped;
-		} catch {
-			return;
-		}
+		if (!installMethod$2(target, wrapped)) return;
+		markPatched$2(patchedMethods, target.holder, target.name);
 		restores.push(() => {
-			if (tools.register === wrapped) tools.register = original;
+			restoreMethod$2(target);
 		});
 		if (typeof tools.get === "function") try {
 			if (tools.get("exit_plan_mode") !== void 0) logWarn(ctx, "[dsh-chatgpt-subscription] plan-mode cache guard was installed after exit_plan_mode was already registered; this session keeps the conditional admission");
@@ -81281,6 +81422,103 @@ function logWarn(ctx, message) {
 		logger?.warn(message);
 	} catch {}
 }
+/**
+* 定位一个待包装的方法。
+*
+* Cordis 的 `Service` 代理在读属性时会把方法**绑定到读取它的那一层作用域**
+* （`Reflect.get(target, prop, receiver).bind(receiver)`）。于是
+* `const original = tools.register` 拿到的是一份**已经绑到根作用域**的函数；再
+* `original.call(tools, …)` 就把根作用域硬塞回每一个 preset 的注册里，全局层
+* 于是撞上 "already registered"。
+*
+* 真正要的是**原型上那份未绑定的方法**：包装器用 `original.call(this, …)` 把
+* 调用方自己的 receiver 传下去，服务里的 `this.ctx` 才留在调用方那一层作用域
+* （child ctx）里。方法挂在原型上时（真实 Cordis `Service`），包装也写在原型上；
+* 只有普通假对象（单测）才把方法作为自有属性挂在实例上。
+*
+* @param service - 服务实例（可以是 Cordis 的跟踪代理）。
+* @param name - 方法名。
+* @returns 目标；方法不存在时为 `undefined`。
+*/
+function resolveMethodTarget$2(service, name) {
+	if (typeof service !== "object" || service === null) return void 0;
+	const own = service;
+	if (Object.prototype.hasOwnProperty.call(own, name)) {
+		const original = own[name];
+		if (typeof original !== "function") return void 0;
+		return {
+			holder: own,
+			name,
+			original,
+			descriptor: Object.getOwnPropertyDescriptor(own, name)
+		};
+	}
+	const proto = Object.getPrototypeOf(service);
+	if (proto === null) return void 0;
+	if (proto === Object.prototype || proto === Function.prototype) return void 0;
+	const original = proto[name];
+	if (typeof original !== "function") return void 0;
+	return {
+		holder: proto,
+		name,
+		original,
+		descriptor: Object.getOwnPropertyDescriptor(proto, name)
+	};
+}
+/**
+* 把一个包装写到方法所在的位置上。
+*
+* @param target - 目标。
+* @param replacement - 包装实现。
+* @returns 是否装上了。
+*/
+function installMethod$2(target, replacement) {
+	try {
+		Object.defineProperty(target.holder, target.name, {
+			value: replacement,
+			configurable: true,
+			writable: true,
+			enumerable: target.descriptor?.enumerable ?? false
+		});
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* 还原方法所在位置上原来的实现。
+*
+* @param target - 目标。
+*/
+function restoreMethod$2(target) {
+	try {
+		if (target.descriptor === void 0) Reflect.deleteProperty(target.holder, target.name);
+		else Object.defineProperty(target.holder, target.name, target.descriptor);
+	} catch {}
+}
+/**
+* 判断某个「方法宿主 + 方法名」是不是已经被本守卫包过。
+*
+* @param patched - 已包装记录。
+* @param holder - 方法宿主。
+* @param name - 方法名。
+* @returns 是否已经包过。
+*/
+function alreadyPatched$2(patched, holder, name) {
+	return patched.get(holder)?.has(name) === true;
+}
+/**
+* 记下某个「方法宿主 + 方法名」已经被本守卫包过。
+*
+* @param patched - 已包装记录。
+* @param holder - 方法宿主。
+* @param name - 方法名。
+*/
+function markPatched$2(patched, holder, name) {
+	const names = patched.get(holder);
+	if (names === void 0) patched.set(holder, /* @__PURE__ */ new Set([name]));
+	else names.add(name);
+}
 /** PTC 生成的 SDK 段名。 */
 const PTC_SDK_SECTION_NAME = "tools:sdk";
 /** 没有 scope 的装配（会话标题之类）用的桶键。 */
@@ -81337,6 +81575,8 @@ function installPtcSdkCacheGuard(ctx, options = {}) {
 	const providers = new Set(options.providers ?? ["kimi-code"]);
 	/** 已包装过的实例（幂等标记）。 */
 	const alreadyWrapped = /* @__PURE__ */ new WeakSet();
+	/** 已包装过的「方法宿主 + 方法名」：同一个原型不叠第二层包装。 */
+	const patchedMethods = /* @__PURE__ */ new WeakMap();
 	/** 每个 scope 的 SDK 段缓存。 */
 	const cache = /* @__PURE__ */ new WeakMap();
 	/** 事件监听的 disposer。 */
@@ -81363,11 +81603,11 @@ function installPtcSdkCacheGuard(ctx, options = {}) {
 	*/
 	const toolFingerprint = (tools, scope) => {
 		if (!isRecord$7(tools)) return "";
-		const definitions = tools["definitions"];
-		if (typeof definitions !== "function") return "";
+		const target = resolveMethodTarget$1(tools, "definitions");
+		if (target === void 0) return "";
 		let list;
 		try {
-			list = definitions.call(tools, scope, void 0);
+			list = target.original.call(tools, scope, void 0);
 		} catch {
 			return "";
 		}
@@ -81383,33 +81623,26 @@ function installPtcSdkCacheGuard(ctx, options = {}) {
 	const wrapToolsService = (tools) => {
 		if (disposed || !isRecord$7(tools)) return false;
 		if (alreadyWrapped.has(tools)) return false;
-		const current = tools["definitions"];
-		if (typeof current !== "function") return false;
-		const original = current;
+		const target = resolveMethodTarget$1(tools, "definitions");
+		if (target === void 0) return false;
+		if (alreadyPatched$1(patchedMethods, target.holder, target.name)) {
+			alreadyWrapped.add(tools);
+			return false;
+		}
+		const original = target.original;
 		const replacement = function(scope, toolSet) {
+			const receiver = this ?? tools;
 			if (toolSet !== void 0) {
 				const provider = readScopeProvider(scope);
-				if (provider !== void 0 && providers.has(provider)) return original.call(tools, scope, void 0);
+				if (provider !== void 0 && providers.has(provider)) return original.call(receiver, scope, void 0);
 			}
-			return original.call(tools, scope, toolSet);
+			return original.call(receiver, scope, toolSet);
 		};
-		const descriptor = Object.getOwnPropertyDescriptor(tools, "definitions");
-		try {
-			Object.defineProperty(tools, "definitions", {
-				value: replacement,
-				configurable: true,
-				writable: true,
-				enumerable: descriptor?.enumerable ?? false
-			});
-		} catch {
-			return false;
-		}
+		if (!installMethod$1(target, replacement)) return false;
+		markPatched$1(patchedMethods, target.holder, target.name);
 		alreadyWrapped.add(tools);
 		restores.push(() => {
-			try {
-				if (descriptor === void 0) delete tools["definitions"];
-				else Object.defineProperty(tools, "definitions", descriptor);
-			} catch {}
+			restoreMethod$1(target);
 		});
 		return true;
 	};
@@ -81537,6 +81770,103 @@ function subscribe$1(host, event, listener) {
 function isRecord$7(value) {
 	return typeof value === "object" && value !== null;
 }
+/**
+* 定位一个待包装的方法。
+*
+* Cordis 的 `Service` 代理在读属性时会把方法**绑定到读取它的那一层作用域**
+* （`Reflect.get(target, prop, receiver).bind(receiver)`）。于是
+* `const original = tools.register` 拿到的是一份**已经绑到根作用域**的函数；再
+* `original.call(tools, …)` 就把根作用域硬塞回每一个 preset 的注册里，全局层
+* 于是撞上 "already registered"。
+*
+* 真正要的是**原型上那份未绑定的方法**：包装器用 `original.call(this, …)` 把
+* 调用方自己的 receiver 传下去，服务里的 `this.ctx` 才留在调用方那一层作用域
+* （child ctx）里。方法挂在原型上时（真实 Cordis `Service`），包装也写在原型上；
+* 只有普通假对象（单测）才把方法作为自有属性挂在实例上。
+*
+* @param service - 服务实例（可以是 Cordis 的跟踪代理）。
+* @param name - 方法名。
+* @returns 目标；方法不存在时为 `undefined`。
+*/
+function resolveMethodTarget$1(service, name) {
+	if (typeof service !== "object" || service === null) return void 0;
+	const own = service;
+	if (Object.prototype.hasOwnProperty.call(own, name)) {
+		const original = own[name];
+		if (typeof original !== "function") return void 0;
+		return {
+			holder: own,
+			name,
+			original,
+			descriptor: Object.getOwnPropertyDescriptor(own, name)
+		};
+	}
+	const proto = Object.getPrototypeOf(service);
+	if (proto === null) return void 0;
+	if (proto === Object.prototype || proto === Function.prototype) return void 0;
+	const original = proto[name];
+	if (typeof original !== "function") return void 0;
+	return {
+		holder: proto,
+		name,
+		original,
+		descriptor: Object.getOwnPropertyDescriptor(proto, name)
+	};
+}
+/**
+* 把一个包装写到方法所在的位置上。
+*
+* @param target - 目标。
+* @param replacement - 包装实现。
+* @returns 是否装上了。
+*/
+function installMethod$1(target, replacement) {
+	try {
+		Object.defineProperty(target.holder, target.name, {
+			value: replacement,
+			configurable: true,
+			writable: true,
+			enumerable: target.descriptor?.enumerable ?? false
+		});
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* 还原方法所在位置上原来的实现。
+*
+* @param target - 目标。
+*/
+function restoreMethod$1(target) {
+	try {
+		if (target.descriptor === void 0) Reflect.deleteProperty(target.holder, target.name);
+		else Object.defineProperty(target.holder, target.name, target.descriptor);
+	} catch {}
+}
+/**
+* 判断某个「方法宿主 + 方法名」是不是已经被本守卫包过。
+*
+* @param patched - 已包装记录。
+* @param holder - 方法宿主。
+* @param name - 方法名。
+* @returns 是否已经包过。
+*/
+function alreadyPatched$1(patched, holder, name) {
+	return patched.get(holder)?.has(name) === true;
+}
+/**
+* 记下某个「方法宿主 + 方法名」已经被本守卫包过。
+*
+* @param patched - 已包装记录。
+* @param holder - 方法宿主。
+* @param name - 方法名。
+*/
+function markPatched$1(patched, holder, name) {
+	const names = patched.get(holder);
+	if (names === void 0) patched.set(holder, /* @__PURE__ */ new Set([name]));
+	else names.add(name);
+}
 //#endregion
 //#region src/host/compaction-policy-guard.ts
 /**
@@ -81595,6 +81925,17 @@ function isRecord$7(value) {
 * `agent.options`），把确切的 provider/model 登记进来——于是匹配用的是 100%
 * 标准的普通对象，没有一行依赖 Proxy 的巧合。
 *
+* ## 瀑布事件必须转交 `next()`
+*
+* `agent/pre-step` / `agent/request` / `agent/request-error` 是 Cordis **瀑布**事件
+* （`ctx.waterfall`），最后一个参数就是 `next`。瀑布的返回值是**最外层监听器的
+* 返回值**：不调用 `next()` 等于替整条链做了决定——后续监听器（连同内置的默认行为）
+* 一个都不跑，瀑布的返回值也变成监听器自己的返回值。于是 `agent-loop` 读
+* `decision.kind` / `proposedConfig.provider` 时拿到 `undefined`，每一轮都炸成
+* `TypeError: Cannot read properties of undefined (reading 'kind')`。
+* 本守卫是旁路，观测与扫描失败只吞掉它们自己，但 `next()` 在所有分支上都要被调用
+* 并原样交回去。
+*
 * @module @eddyskywalker/dsh-chatgpt-subscription/host/compaction-policy-guard
 */
 /** 压缩服务的名字（`ctx.reflect.store` 与 `ctx.get` 都用它）。 */
@@ -81655,6 +81996,8 @@ function installCompactionPolicyGuard(ctx, options = {}) {
 	const observed = /* @__PURE__ */ new Map();
 	/** 已改写的引擎（幂等标记）与还原动作。 */
 	const patched = /* @__PURE__ */ new WeakMap();
+	/** 已包装过的「方法宿主 + 方法名」：同一个原型不叠第二层包装。 */
+	const patchedMethods = /* @__PURE__ */ new WeakMap();
 	const restores = [];
 	/** 事件监听的 disposer。 */
 	const disposers = [];
@@ -81825,10 +82168,10 @@ function installCompactionPolicyGuard(ctx, options = {}) {
 			"compact",
 			"summarize"
 		]) {
-			const current = engine[name];
-			if (typeof current !== "function") continue;
-			const original = current;
-			const methodDescriptor = Object.getOwnPropertyDescriptor(engine, name);
+			const target = resolveMethodTarget(engine, name);
+			if (target === void 0) continue;
+			if (alreadyPatched(patchedMethods, target.holder, target.name)) continue;
+			const original = target.original;
 			const replacement = function(...args) {
 				observeFrom(args[0]);
 				observeFrom(args[1]);
@@ -81846,23 +82189,12 @@ function installCompactionPolicyGuard(ctx, options = {}) {
 						}
 					}
 				}
-				return original.apply(this, nextArgs);
+				return original.apply(this ?? engine, nextArgs);
 			};
-			try {
-				Object.defineProperty(engine, name, {
-					value: replacement,
-					configurable: true,
-					writable: true,
-					enumerable: Object.getOwnPropertyDescriptor(engine, name)?.enumerable ?? false
-				});
-			} catch {
-				continue;
-			}
+			if (!installMethod(target, replacement)) continue;
+			markPatched(patchedMethods, target.holder, target.name);
 			restoresForEngine.push(() => {
-				try {
-					if (methodDescriptor === void 0) delete engine[name];
-					else Object.defineProperty(engine, name, methodDescriptor);
-				} catch {}
+				restoreMethod(target);
 			});
 		}
 		const restore = () => {
@@ -81946,9 +82278,24 @@ function installCompactionPolicyGuard(ctx, options = {}) {
 	/**
 	* 事件回调：先观测模型，再扫宿主平面与 agent 自己的 realm。
 	*
-	* @param args - 事件参数。
+	* ## 瀑布必须转交
+	*
+	* `agent/pre-step` / `agent/request` / `agent/request-error` 在 DSH 里是
+	* Cordis **瀑布**事件（`ctx.waterfall`），最后一个参数就是 `next`。瀑布的返回值
+	* 是**最外层监听器的返回值**：不调用 `next()` 等于替整条链做了决定——后续监听器
+	* （连同内置的默认行为）一个都不会跑，瀑布的返回值也变成监听器自己的返回值
+	* （这里是 `undefined`）。`agent-loop` 随后读 `decision.kind` 与
+	* `proposedConfig.provider`，于是每一轮都炸成
+	* `TypeError: Cannot read properties of undefined (reading 'kind')`。
+	*
+	* 所以观测与扫描照旧做（失败也只吞掉扫描本身），但 `next()` **必须**在所有分支上
+	* 被调用，并把它的结果原样交回去。
+	*
+	* @param args - 事件参数（最后一个参数可能是 `next`）。
+	* @returns `next()` 的结果；没有 `next` 时为 `undefined`。
 	*/
 	const handleAgentEvent = (...args) => {
+		const next = args.length > 0 && typeof args[args.length - 1] === "function" ? args[args.length - 1] : void 0;
 		try {
 			for (const arg of args) {
 				observeFrom(arg);
@@ -81956,10 +82303,12 @@ function installCompactionPolicyGuard(ctx, options = {}) {
 			}
 			scanAndPatch();
 			const agentCtx = findAgentContext(args);
-			if (agentCtx === void 0) return;
-			scanStore(agentCtx);
-			patchServiceFrom(agentCtx, COMPACTION_SERVICE_NAME);
+			if (agentCtx !== void 0) {
+				scanStore(agentCtx);
+				patchServiceFrom(agentCtx, COMPACTION_SERVICE_NAME);
+			}
 		} catch {}
+		return next === void 0 ? void 0 : next();
 	};
 	for (const event of GUARDED_EVENTS) {
 		const disposer = subscribe(host, event, handleAgentEvent);
@@ -82062,6 +82411,103 @@ function subscribe(host, event, listener) {
 function isRecord$6(value) {
 	return typeof value === "object" && value !== null;
 }
+/**
+* 定位一个待包装的方法。
+*
+* Cordis 的 `Service` 代理在读属性时会把方法**绑定到读取它的那一层作用域**
+* （`Reflect.get(target, prop, receiver).bind(receiver)`）。于是
+* `const original = tools.register` 拿到的是一份**已经绑到根作用域**的函数；再
+* `original.call(tools, …)` 就把根作用域硬塞回每一个 preset 的注册里，全局层
+* 于是撞上 "already registered"。
+*
+* 真正要的是**原型上那份未绑定的方法**：包装器用 `original.call(this, …)` 把
+* 调用方自己的 receiver 传下去，服务里的 `this.ctx` 才留在调用方那一层作用域
+* （child ctx）里。方法挂在原型上时（真实 Cordis `Service`），包装也写在原型上；
+* 只有普通假对象（单测）才把方法作为自有属性挂在实例上。
+*
+* @param service - 服务实例（可以是 Cordis 的跟踪代理）。
+* @param name - 方法名。
+* @returns 目标；方法不存在时为 `undefined`。
+*/
+function resolveMethodTarget(service, name) {
+	if (typeof service !== "object" || service === null) return void 0;
+	const own = service;
+	if (Object.prototype.hasOwnProperty.call(own, name)) {
+		const original = own[name];
+		if (typeof original !== "function") return void 0;
+		return {
+			holder: own,
+			name,
+			original,
+			descriptor: Object.getOwnPropertyDescriptor(own, name)
+		};
+	}
+	const proto = Object.getPrototypeOf(service);
+	if (proto === null) return void 0;
+	if (proto === Object.prototype || proto === Function.prototype) return void 0;
+	const original = proto[name];
+	if (typeof original !== "function") return void 0;
+	return {
+		holder: proto,
+		name,
+		original,
+		descriptor: Object.getOwnPropertyDescriptor(proto, name)
+	};
+}
+/**
+* 把一个包装写到方法所在的位置上。
+*
+* @param target - 目标。
+* @param replacement - 包装实现。
+* @returns 是否装上了。
+*/
+function installMethod(target, replacement) {
+	try {
+		Object.defineProperty(target.holder, target.name, {
+			value: replacement,
+			configurable: true,
+			writable: true,
+			enumerable: target.descriptor?.enumerable ?? false
+		});
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* 还原方法所在位置上原来的实现。
+*
+* @param target - 目标。
+*/
+function restoreMethod(target) {
+	try {
+		if (target.descriptor === void 0) Reflect.deleteProperty(target.holder, target.name);
+		else Object.defineProperty(target.holder, target.name, target.descriptor);
+	} catch {}
+}
+/**
+* 判断某个「方法宿主 + 方法名」是不是已经被本守卫包过。
+*
+* @param patched - 已包装记录。
+* @param holder - 方法宿主。
+* @param name - 方法名。
+* @returns 是否已经包过。
+*/
+function alreadyPatched(patched, holder, name) {
+	return patched.get(holder)?.has(name) === true;
+}
+/**
+* 记下某个「方法宿主 + 方法名」已经被本守卫包过。
+*
+* @param patched - 已包装记录。
+* @param holder - 方法宿主。
+* @param name - 方法名。
+*/
+function markPatched(patched, holder, name) {
+	const names = patched.get(holder);
+	if (names === void 0) patched.set(holder, /* @__PURE__ */ new Set([name]));
+	else names.add(name);
+}
 //#endregion
 //#region src/host/preset-sync.ts
 /**