@eddyskywalker/dsh-chatgpt-subscription 0.60.0 → 0.61.0

package/lib/codemode.js

@@ -112,13 +112,19 @@ function searchDefinition(name, rules, catalog) {
 							additionalProperties: false,
 							required: [
 								"name",
+								"namespace",
 								"description",
 								"parameters"
 							],
 							properties: {
 								name: { type: "string" },
+								namespace: {
+									type: "string",
+									description: "Namespace of the tool: an MCP server name, or \"plugin\"."
+								},
 								description: { type: "string" },
-								parameters: {}
+								parameters: {},
+								output: { description: "The tool's declared output schema, when it has one." }
 							}
 						}
 					}
@@ -126,7 +132,7 @@ function searchDefinition(name, rules, catalog) {
 			},
 			render: (_args, value) => [{
 				type: "text",
-				text: value.tools.length === 0 ? "No tool matched that query, and this session has no tools to browse." : (value.fallback === true ? "No exact match. These are the callable tools, grouped by namespace — call one by exact name, or refine the query:" : "") + value.tools.map((hit) => hit.name + "\n  " + hit.description + "\n  parameters: " + safeJson(hit.parameters)).join("\n\n")
+				text: value.tools.length === 0 ? "No tool matched that query, and this session has no tools to browse." : (value.fallback === true ? "No exact match. These are the callable tools, grouped by namespace — call one by exact name, or refine the query:" : "") + value.tools.map((hit) => hit.name + "  [" + hit.namespace + "]\n  " + hit.description + "\n  parameters: " + safeJson(hit.parameters) + (hit.output === void 0 ? "" : "\n  output: " + safeJson(hit.output))).join("\n\n")
 			}]
 		},
 		async execute(args) {
@@ -151,8 +157,10 @@ function searchDefinition(name, rules, catalog) {
 			const hits = scored.slice(0, limit);
 			if (hits.length > 0) return { tools: hits.map((row) => ({
 				name: row.indexed.entry.name,
+				namespace: namespaceOfName(row.indexed.entry.name),
 				description: clip(row.indexed.entry.description),
-				parameters: row.indexed.entry.parameters
+				parameters: row.indexed.entry.parameters,
+				...row.indexed.entry.output === void 0 ? {} : { output: row.indexed.entry.output }
 			})) };
 			return {
 				tools: browseByNamespace(candidates, limit),
@@ -183,13 +191,15 @@ function describeDefinition(name, catalog) {
 				properties: {
 					found: { type: "boolean" },
 					name: { type: "string" },
+					namespace: { type: "string" },
 					description: { type: "string" },
-					parameters: {}
+					parameters: {},
+					output: { description: "The tool's declared output schema, when it has one." }
 				}
 			},
 			render: (_args, value) => [{
 				type: "text",
-				text: value.found !== true ? "No tool named that is callable from this session." : String(value.name) + "\n" + String(value.description) + "\nparameters: " + safeJson(value.parameters)
+				text: value.found !== true ? "No tool named that is callable from this session." : String(value.name) + "  [" + String(value.namespace) + "]\n" + String(value.description) + "\nparameters: " + safeJson(value.parameters) + (value.output === void 0 ? "" : "\noutput: " + safeJson(value.output))
 			}]
 		},
 		async execute(args) {
@@ -200,8 +210,10 @@ function describeDefinition(name, catalog) {
 			return {
 				found: true,
 				name: entry.name,
+				namespace: namespaceOfName(entry.name),
 				description: clip(entry.description),
-				parameters: entry.parameters
+				parameters: entry.parameters,
+				...entry.output === void 0 ? {} : { output: entry.output }
 			};
 		}
 	};
@@ -272,8 +284,10 @@ function browseByNamespace(entries, limit) {
 		if (rows.length >= limit) return rows;
 		rows.push({
 			name: entry.name,
+			namespace,
 			description: clip(namespace + ": " + entry.description),
-			parameters: entry.parameters
+			parameters: entry.parameters,
+			...entry.output === void 0 ? {} : { output: entry.output }
 		});
 	}
 	return rows;
@@ -587,16 +601,16 @@ function buildCodemodeSectionText(input) {
 		"```py",
 		"# standard tools and hidden tools alike",
 		"import asyncio",
-		"files = await tools.glob({\"pattern\": \"src/**/*.ts\"})",
-		"rows = await asyncio.gather(*(tools.read({\"file_path\": f}) for f in files))",
-		"[r.splitlines()[0] for r in rows if \"TODO\" in r]",
+		"found = await tools.glob({\"pattern\": \"src/**/*.ts\"})",
+		"pages = await asyncio.gather(*(tools.read({\"file_path\": p}) for p in found[\"paths\"]))",
+		"[l[\"text\"] for page in pages for l in page[\"lines\"] if \"TODO\" in l[\"text\"]]",
 		"```"
 	] : [
 		"```js",
 		"// standard tools and hidden tools alike",
-		"const files = await tools.glob({ pattern: \"src/**/*.ts\" })",
-		"const rows = await Promise.all(files.map((f) => tools.read({ file_path: f })))",
-		retained ? "rows.filter((r) => r.includes(\"TODO\")).map((r) => r.split(\"\\n\")[0])" : "return rows.filter((r) => r.includes(\"TODO\")).map((r) => r.split(\"\\n\")[0])",
+		"const { paths } = await tools.glob({ pattern: \"src/**/*.ts\" })",
+		"const pages = await Promise.all(paths.map((p) => tools.read({ file_path: p })))",
+		retained ? "pages.flatMap((r) => r.lines.filter((l) => l.text.includes(\"TODO\")).map((l) => l.text))" : "return pages.flatMap((r) => r.lines.filter((l) => l.text.includes(\"TODO\")).map((l) => l.text))",
 		"```"
 	];
 	return [
@@ -610,6 +624,9 @@ function buildCodemodeSectionText(input) {
 		"",
 		python ? retained ? "- A retained Python REPL: top-level await and a final expression. Its variables and imported modules survive into your later programs in this session." : "- Async Python program: top-level await works; print or evaluate a final expression to produce output." : retained ? "- A retained TypeScript REPL: top-level declarations, await, and a final expression. Its variables and imported modules survive into your later programs in this session." : "- Erasable TypeScript, run as the body of an async function: top-level await and return work.",
 		"- Only what you return or console.log reaches the conversation; every intermediate result stays in the program, so filter and aggregate there instead of returning raw payloads.",
+		"- File, search, and shell tool results are named-field objects, never bare strings (whereas `job_list` returns a bare array): `glob` answers `{ root, paths }`, `grep` answers `{ matches }` with matches shaped `{ path, lineNumber, line }`, `read` answers `{ path, offset, lines, totalLines }` with `lines` items shaped `{ number, text }`, and `win_bash` answers `{ stdout, stderr, exitCode }`. A named-field object carries its list or text inside those fields — `r.lines.map((l) => l.text)` — so never call `.map`, `.filter`, `.split`, `.splitlines` or `in` on the envelope itself.",
+		"- Discovery returns whole objects too: `" + listTool + "` answers `{ tools: [{ name, description, namespace }] }`, `" + searchTool + "` answers `{ tools: [{ name, namespace, description, parameters, output? }], fallback? }`, and `" + describeTool + "` answers `{ found, name?, namespace?, description?, parameters?, output? }`.",
+		"- Tool argument objects and `return` values must be lossless JSON: **never leave `undefined` in an object property value** — `{ a: x.opt }` fails the call when `x.opt === undefined`. Omit the key, write `x.opt ?? null`, or print it with `console.log`.",
 		"- Prefer batching multi-step read/search chains inside one " + run + " program instead of issuing many sequential single-tool turns.",
 		"- Independent read-only calls may overlap under Promise.all; mutating calls run alone, in submission order.",
 		"- A failed sub-call rejects; try/catch or Promise.allSettled it to keep the calls that succeeded. Completed calls are real side effects and are not rolled back.",
@@ -617,8 +634,8 @@ function buildCodemodeSectionText(input) {
 		"### Discovery API (callable from inside a program)",
 		"",
 		"- tools." + listTool + "({ namespace? }) - every callable tool as { name, description, namespace }, hidden ones included.",
-		"- tools." + searchTool + "({ query, limit?, namespace? }) - ranked matches with their full parameter schemas; the intended first step. Query with the English keywords the tool is likely named and described with (tool names and descriptions are English); a phrase in another language is only matched literally.",
-		"- tools." + describeTool + "({ name }) - one tool description and complete parameter schema.",
+		"- tools." + searchTool + "({ query, limit?, namespace? }) - ranked matches with their full parameter schemas and output schema when the tool declares one; the intended first step. Query with the English keywords the tool is likely named and described with (tool names and descriptions are English); a phrase in another language is only matched literally.",
+		"- tools." + describeTool + "({ name }) - one tool description, its complete parameter schema, and its output schema when declared.",
 		"",
 		"If a hidden tool name is called directly instead of from a program, the call is refused and the refusal names the discovery call to make."
 	].join("\n");
@@ -1188,7 +1205,7 @@ function createTransportDefinition(host, rules) {
 			const owner = host.stateOwner(exec.agent);
 			let maxSubCalls = rules.options.maxSubCalls;
 			let attempts = 0;
-			const scheduler = createSubCallScheduler(rules.options.maxParallelSubCalls, () => runController.signal.aborted);
+			const lane = createCommitLane(rules.options.maxParallelSubCalls, () => runController.signal.aborted);
 			const definitions = /* @__PURE__ */ new Map();
 			for (const entry of catalog) definitions.set(entry.name, entry);
 			const functions = Object.create(null);
@@ -1212,36 +1229,58 @@ function createTransportDefinition(host, rules) {
 						name: entry.name,
 						arguments: loggedArgs
 					});
-					const run = async () => {
-						dispatchLog.start();
-						let outcome;
-						try {
-							outcome = await host.callTool({
-								name: entry.name,
-								args: parsed,
-								callId,
-								signal: nestedSignal,
+					const mode = isConcurrencySafe(definitions.get(entry.name), parsed) ? "parallel" : "exclusive";
+					return lane.schedule(mode, {
+						start() {
+							dispatchLog.start();
+						},
+						body: async () => await host.callTool({
+							name: entry.name,
+							args: parsed,
+							callId,
+							signal: nestedSignal,
+							agent: exec.agent,
+							toolSet: exec.toolSet
+						}),
+						/**
+						* 提交阶段：按**提交顺序**逐条执行，落在会话里的副作用因此与提交顺序一致。
+						*
+						* 内核把这几步全部放在同一条有序 lane 里（`ptc.ts` 的 commit 游标）：回放内容
+						* 投影、settle 事件、图片与附加上下文、`concludeTurn`、放行互斥屏障。并发的
+						* body 谁先跑完都不影响这一串的顺序——否则界面里的子调用记录会错位，延迟上下文
+						* 也会插到错误的位置。
+						*/
+						async commit(parked) {
+							if (!parked.ok) {
+								dispatchLog.settle({ error: messageOf$1(parked.error) });
+								throw parked.error;
+							}
+							const outcome = parked.value;
+							const isError = outcome.error !== void 0;
+							const content = await shapeDispatchContent(host, {
 								agent: exec.agent,
-								toolSet: exec.toolSet
+								name: entry.name,
+								arguments: loggedArgs,
+								isError,
+								content: clipContent(outcome.content)
 							});
-						} catch (error) {
-							dispatchLog.settle({ error: error instanceof Error ? error.message : String(error) });
-							throw error;
-						}
-						dispatchLog.settle(outcome);
-						if (outcome.error === void 0 && Array.isArray(outcome.content) && hasImageBlock(outcome.content)) {
-							const imageMsg = host.createImageContext?.(outcome.content);
-							if (imageMsg !== void 0) exec.deferContext?.(imageMsg);
+							dispatchLog.settle({
+								...outcome,
+								content
+							});
+							if (!isError && Array.isArray(outcome.content) && hasImageBlock(outcome.content)) {
+								const imageMsg = host.createImageContext?.(outcome.content);
+								if (imageMsg !== void 0) exec.deferContext?.(imageMsg);
+							}
+							if (Array.isArray(outcome.additionalContexts)) for (const contextMsg of outcome.additionalContexts) exec.deferContext?.(contextMsg);
+							if (!isError && outcome.concluded === true) exec.concludeTurn?.();
+							if (runController.signal.aborted) throw new Error(runToolName + " run is over; " + entry.name + " result discarded");
+							if (outcome.error !== void 0) throw new Error(outcome.error);
+							return outcome.value !== void 0 ? outcome.value : outcome.text ?? null;
+						},
+						abandon() {
+							throw new Error(runToolName + " run is over; " + entry.name + " tool call abandoned");
 						}
-						if (Array.isArray(outcome.additionalContexts)) for (const contextMsg of outcome.additionalContexts) exec.deferContext?.(contextMsg);
-						if (outcome.error === void 0 && outcome.concluded === true) exec.concludeTurn?.();
-						if (runController.signal.aborted) throw new Error(runToolName + " run is over; " + entry.name + " result discarded");
-						if (outcome.error !== void 0) throw new Error(outcome.error);
-						return outcome.value !== void 0 ? outcome.value : outcome.text ?? null;
-					};
-					const mode = isConcurrencySafe(definitions.get(entry.name), parsed) ? "parallel" : "exclusive";
-					return scheduler.schedule(mode, run, () => {
-						throw new Error(runToolName + " run is over; " + entry.name + " tool call abandoned");
 					});
 				};
 				Object.defineProperty(functions, entry.name, {
@@ -1259,6 +1298,8 @@ function createTransportDefinition(host, rules) {
 				* `stateOwner`，避免把单次授权固化到常驻环境中（对齐内核 `ptc.ts`）。
 				*/
 				let approvedEscalatedMode;
+				/** 这次运行在入口那边的登记；结算时释放（重跑会重新登记一次）。 */
+				let untrackRun = () => {};
 				const attempt = async () => {
 					const authority = await host.runAuthority?.(exec.agent, nestedSignal);
 					const standingPolicy = authority?.sandboxPolicy;
@@ -1284,6 +1325,13 @@ function createTransportDefinition(host, rules) {
 						};
 						escalated = modeOfPolicy(effectivePolicy) !== modeOfPolicy(standingPolicy);
 					}
+					untrackRun();
+					const runMode = modeOfPolicy(effectivePolicy);
+					untrackRun = host.trackRun?.({
+						agent: exec.agent,
+						controller: runController,
+						...runMode === void 0 ? {} : { mode: runMode }
+					}) ?? (() => {});
 					const request = {
 						program: input.code,
 						bindings: [{
@@ -1316,7 +1364,8 @@ function createTransportDefinition(host, rules) {
 					}
 				} finally {
 					runController.abort(runToolName + " settled");
-					await scheduler.drain();
+					await lane.drain();
+					untrackRun();
 				}
 				if (result.error !== void 0) {
 					const logsText = Array.isArray(result.logs) && result.logs.length > 0 ? "\nCaptured output:\n" + result.logs.join("\n") : "";
@@ -1409,7 +1458,7 @@ function createDispatchLog(agent, entry) {
 			write("tool/ptc-dispatch", {
 				...base,
 				isError: outcome.error !== void 0,
-				content: clipContent(outcome.content),
+				content: Array.isArray(outcome.content) ? outcome.content : [],
 				...outcome.meta === void 0 ? {} : { meta: outcome.meta },
 				...outcome.errorInfo === void 0 ? {} : { error: outcome.errorInfo }
 			});
@@ -1461,7 +1510,10 @@ function readArguments(args) {
 	const record = args;
 	const code = record["code"];
 	const description = record["description"];
-	if (typeof code !== "string" || code.trim().length === 0) throw new Error("codemode: invalid code: expected a non-empty string");
+	if (typeof code !== "string" || code.trim().length === 0) {
+		const received = Object.keys(record);
+		throw new Error("codemode: invalid code: expected a non-empty string" + (received.length === 0 ? "" : " (received keys: " + received.join(", ") + "; pass program source in \"code\")"));
+	}
 	if (typeof description !== "string" || description.trim().length === 0) throw new Error("codemode: invalid description: expected a non-empty string");
 	const escalation = validateEscalationArgs(record["sandbox_permissions"], record["justification"]);
 	const timeoutMs = record["timeoutMs"];
@@ -1497,72 +1549,157 @@ function isConcurrencySafe(entry, args) {
 	}
 }
 /**
-* 子调用并发与互斥调度器（对齐内核 `ptc.ts` 的读写屏障）：
+* 子调用的并发、提交顺序与互斥屏障（对齐内核 `ptc.ts` 的 ordered commit lane）。
+*
+* - `start()`（记 start 事件 + 启动 body）在 lane 里按提交顺序执行：`parallel` body 之间
+*   可以并发重叠，最多 `maxParallel` 个同时在飞；
+* - `commit()`（记 settle 事件 + 转发图片/附加上下文 + `concludeTurn` + 放行互斥屏障）
+*   按**提交顺序**逐条执行：前一条没提交完，后一条的结果不会先落到会话里；
+* - `exclusive` 调用等所有在飞 body 结算后独占运行，并独占到自己 commit 完成才放行后续；
+* - 排队期间若外层运行已中止，直接放弃且不启动任务（未启动调用零 `start` 事件）；
+* - `drain()` 等到 lane 彻底静止（所有 body 结算、所有 commit 完成）才返回。
+*
+* 程序拿到的值在 commit 里结算（与内核同）：body 结束不保证顺序，提交才是顺序。
 *
-* - `parallel` 调用可并发重叠，最多 `maxParallel` 个同时在飞；
-* - `exclusive` 调用必须等待所有已在飞调用结算后独占运行，并在自身结算后才放行后续调用；
-* - 排队期间若外层运行已中止，直接放弃且不启动任务（保证未启动调用零 `start` 事件）；
-* - `drain()` 等待全部已启动任务结算。
+* @param maxParallel - 同时在飞的上限。
+* @param isAborted - 外层运行是否已中止。
+* @returns 调度入口与排空。
 */
-function createSubCallScheduler(maxParallel, isAborted) {
+function createCommitLane(maxParallel, isAborted) {
 	const cap = Math.max(1, maxParallel);
 	const queue = [];
+	const commitQueue = [];
 	const inFlight = /* @__PURE__ */ new Set();
 	let exclusiveActive = false;
-	const pump = () => {
-		while (queue.length > 0) {
-			const head = queue[0];
-			if (isAborted()) {
-				queue.shift();
-				head.abandon();
-				continue;
-			}
-			if (exclusiveActive) return;
-			if (head.mode === "exclusive") {
-				if (inFlight.size > 0) return;
-				exclusiveActive = true;
-				queue.shift();
-				head.start();
-				return;
+	let driving = false;
+	let driverRun = Promise.resolve();
+	let wake;
+	const wakeup = () => {
+		const release = wake;
+		wake = void 0;
+		release?.();
+	};
+	/**
+	* 唯一的有序车道：每一轮先提交队首已结算的调用，再在有空位时启动下一个排队调用，
+	* 否则睡到「有 body 结算或有新提交」为止。三条队列全空即静止。
+	*/
+	const drive = () => {
+		if (driving) return driverRun;
+		driving = true;
+		driverRun = (async () => {
+			try {
+				for (;;) {
+					const signal = new Promise((resolve) => {
+						wake = resolve;
+					});
+					const commitHead = commitQueue[0];
+					if (commitHead !== void 0 && commitHead.settled) {
+						commitQueue.shift();
+						await commitHead.commit();
+						if (commitHead.mode === "exclusive") exclusiveActive = false;
+						continue;
+					}
+					const head = queue[0];
+					if (head !== void 0) {
+						if (isAborted()) {
+							queue.shift();
+							head.abandon();
+							continue;
+						}
+						if (!exclusiveActive && (head.mode === "exclusive" ? inFlight.size === 0 : inFlight.size < cap)) {
+							if (head.mode === "exclusive") exclusiveActive = true;
+							queue.shift();
+							commitQueue.push(head);
+							head.start();
+							const flight = head.flight.finally(() => {
+								inFlight.delete(flight);
+								wakeup();
+							});
+							inFlight.add(flight);
+							continue;
+						}
+					}
+					if (queue.length === 0 && commitQueue.length === 0 && inFlight.size === 0) return;
+					await signal;
+				}
+			} finally {
+				driving = false;
+				wake = void 0;
 			}
-			if (inFlight.size >= cap) return;
-			queue.shift();
-			head.start();
-		}
+		})();
+		return driverRun;
 	};
 	return {
-		schedule(mode, task, onAbandon) {
+		schedule(mode, task) {
 			return new Promise((resolve, reject) => {
-				queue.push({
+				let parked;
+				const entry = {
 					mode,
-					abandon() {
+					settled: false,
+					flight: Promise.resolve(),
+					start() {
+						task.start();
+						entry.flight = (async () => {
+							try {
+								parked = {
+									ok: true,
+									value: await task.body()
+								};
+							} catch (error) {
+								parked = {
+									ok: false,
+									error
+								};
+							}
+							entry.settled = true;
+							wakeup();
+						})();
+					},
+					async commit() {
+						const result = parked;
+						if (result === void 0) return;
 						try {
-							onAbandon();
+							resolve(await task.commit(result));
 						} catch (error) {
 							reject(error);
 						}
 					},
-					start() {
-						const tracked = task().then(resolve, reject).finally(() => {
-							inFlight.delete(tracked);
-							if (mode === "exclusive") exclusiveActive = false;
-							pump();
-						}).then(() => void 0, () => void 0);
-						inFlight.add(tracked);
+					abandon() {
+						try {
+							task.abandon();
+						} catch (error) {
+							reject(error);
+						}
 					}
-				});
-				pump();
+				};
+				queue.push(entry);
+				wakeup();
+				drive();
 			});
 		},
 		async drain() {
-			pump();
-			while (inFlight.size > 0) {
-				await Promise.allSettled([...inFlight]);
-				pump();
-			}
+			await drive();
 		}
 	};
 }
+/**
+* 回放内容的投影：先按日志上限裁剪，再交给入口的 `tools/ptc-dispatch-log` 瀑布。
+*
+* 瀑布失败**不**影响这条记录：回落裁剪后的原始内容（内核 `ptc.ts` 同此）。
+*/
+async function shapeDispatchContent(host, dispatch) {
+	if (typeof host.shapeDispatchLog !== "function") return dispatch.content;
+	try {
+		const shaped = await host.shapeDispatchLog(dispatch);
+		return Array.isArray(shaped) ? shaped : dispatch.content;
+	} catch {
+		return dispatch.content;
+	}
+}
+/** 一个抛出值的消息。 */
+function messageOf$1(error) {
+	return error instanceof Error ? error.message : String(error);
+}
 const JSON_INDENT = "  ";
 const MAX_JSON_INDENT_CHARS = 10;
 /** 迭代式 JSON 渲染：与内核 `ptc.ts` 一致，深于 5 层后自动紧凑化，防止深层缩进膨胀。 */
@@ -1744,6 +1881,76 @@ function apply(ctx, config = {}) {
 	if (typeof context.effect === "function") context.effect(() => () => {
 		retention.dispose();
 	}, "codemode retained environments");
+	/** 在飞运行：会话键 → 该会话里正在跑的程序。 */
+	const activeRuns = /* @__PURE__ */ new Map();
+	/**
+	* 登记一只在飞运行，返回运行结算时的 disposer。
+	*
+	* 传输层每轮运行（含常驻环境换策略后的重跑）都登记一次，入口因此知道「这一轮跑在哪个
+	* 会话、当时的沙箱模式是什么」。会话切模式时，模式不匹配的运行必须停：常驻环境换策略
+	* 会抛错，而已经跑起来的那一轮不能继续用旧权限往下写。
+	*/
+	const trackRun = (run) => {
+		const key = sessionKeyOf(run.agent);
+		if (key === void 0) return () => void 0;
+		const record = {
+			controller: run.controller,
+			...run.mode === void 0 ? {} : { mode: run.mode }
+		};
+		let bucket = activeRuns.get(key);
+		if (bucket === void 0) {
+			bucket = /* @__PURE__ */ new Set();
+			activeRuns.set(key, bucket);
+		}
+		bucket.add(record);
+		return () => {
+			const current = activeRuns.get(key);
+			if (current === void 0) return;
+			current.delete(record);
+			if (current.size === 0) activeRuns.delete(key);
+		};
+	};
+	/**
+	* 会话的 `sandbox/mode` 事件：生效模式已经变了的在飞运行直接取消（内核 `PtcCalls` 同此）。
+	*
+	* 只取消「能确认模式变了」的那些：拿不到模式（运行时不管沙箱）或模式相同的运行一律不动。
+	*/
+	const cancelOnModeChange = (session, event) => {
+		if (typeof event !== "object" || event === null) return;
+		const record = event;
+		if (record.type !== "sandbox/mode") return;
+		const mode = (typeof record.data === "object" && record.data !== null ? record.data : void 0)?.mode;
+		if (typeof mode !== "string") return;
+		const key = sessionKeyOf(session);
+		if (key === void 0) return;
+		for (const run of activeRuns.get(key) ?? []) if (run.mode !== void 0 && run.mode !== mode) run.controller.abort(/* @__PURE__ */ new Error("sandbox mode changed"));
+	};
+	if (typeof context.on === "function") try {
+		const off = context.on("session/event", cancelOnModeChange, { global: true });
+		if (typeof context.effect === "function") context.effect(() => () => {
+			if (typeof off === "function") off();
+		}, "codemode sandbox mode cancellation");
+	} catch (error) {
+		log("warn", "[codemode] could not subscribe to session/event; an in-flight code_run keeps running after the session sandbox mode changes: " + messageOf(error));
+	}
+	/**
+	* 把一条子调用回放记录交给 `tools/ptc-dispatch-log` 瀑布（内核 `ptc.ts` 的同名钩子）。
+	*
+	* 监听器的失败必须在这里吞掉：它决定的只是日志副本长什么样，不是程序拿到的结果。内核
+	* 用 `scopeTarget(tools, agent)` 当接收方；本包不依赖 `@deepseek-ai/dsh-scope`，直接以
+	* `tools` 为接收方——作用域过滤由宿主自己的监听器完成。
+	*/
+	const shapeDispatchLog = async (dispatch) => {
+		const waterfall = context.waterfall;
+		if (typeof waterfall !== "function") return dispatch.content;
+		try {
+			const shaped = await waterfall.call(context, tools, "tools/ptc-dispatch-log", dispatch, () => Promise.resolve(dispatch.content));
+			return Array.isArray(shaped) ? shaped : dispatch.content;
+		} catch (error) {
+			log("warn", "tools: ptc-dispatch-log listener failed for " + dispatch.name + ": " + messageOf(error) + "; logging the original settled content");
+			return dispatch.content;
+		}
+	};
 	const scopeKey = findScopeKey(ctx);
 	if (rules.options.nativeScope && scopeKey === void 0) log("warn", "[codemode] no registry scope tag on this context: masking falls back to name rules only (" + rules.options.hiddenPrefixes.join(", ") + "). Mount this row inside an agent preset to hide every tool the preset does not own.");
 	/** 最近一次 describe 收到的完整定义集（含被遮蔽的）。 */
@@ -1794,6 +2001,8 @@ function apply(ctx, config = {}) {
 				source: { kind: PLUGIN_MESSAGE_SOURCE_KIND }
 			});
 		},
+		trackRun,
+		shapeDispatchLog,
 		async callTool(request) {
 			const call = {
 				type: "tool-call",
@@ -1884,10 +2093,13 @@ function toCatalogEntry(definition) {
 	if (typeof toolName !== "string" || toolName.length === 0) return void 0;
 	const description = typeof record["description"] === "string" ? record["description"] : "";
 	const safe = record["isConcurrencySafe"];
+	const declaredOutput = record["output"];
+	const output = typeof declaredOutput === "object" && declaredOutput !== null ? declaredOutput.schema : void 0;
 	return {
 		name: toolName,
 		description,
 		parameters: record["parameters"],
+		...output === void 0 ? {} : { output },
 		...typeof safe === "function" ? { isConcurrencySafe: safe } : {}
 	};
 }
@@ -1933,6 +2145,24 @@ function errorInfoOf(result) {
 function nonEmptyString(value) {
 	return typeof value === "string" && value.length > 0 ? value : void 0;
 }
+/**
+* 一个会话的身份键。
+*
+* 优先用会话 id（与内核 `session/event` 监听器里的 `session.id` 对齐）；取不到 id 时退回
+* 会话对象本身——调用方 agent 上的 `session` 与事件里的会话是同一个对象，靠身份比对同样
+* 成立。连会话都没有时返回 `undefined`，这类运行不参与取消。
+*
+* @param value - 一个 agent，或一个会话对象。
+* @returns 会话 id / 会话对象，或 `undefined`。
+*/
+function sessionKeyOf(value) {
+	if (typeof value !== "object" || value === null) return void 0;
+	const nested = value.session;
+	const session = typeof nested === "object" && nested !== null ? nested : value;
+	const id = session.id;
+	if (typeof id === "string" && id.length > 0) return id;
+	return session;
+}
 /** 把内容块里的文本拼起来。 */
 function textOf(content) {
 	if (!Array.isArray(content)) return "";