page-agent-sdk 1.4.2 → 2.1.0

package/dist/page-agent-sdk.js

@@ -13082,7 +13082,7 @@ app.mount('#app');
 						key: e.name,
 						class: "info-item"
 					}, [Y("div", Gp, V(e.name), 1), Y("div", Kp, V(e.description), 1)]))), 128))])) : X("", !0),
-					b.value.windowProps.length ? (q(), J("div", qp, [Y("div", Jp, "🪟 可操作属性 (" + V(b.value.windowProps.length) + ")", 1), (q(!0), J(K, null, Xi(b.value.windowProps, (e) => (q(), J("div", {
+					b.value.dataSlots.length ? (q(), J("div", qp, [Y("div", Jp, "🪟 可操作属性 (" + V(b.value.dataSlots.length) + ")", 1), (q(!0), J(K, null, Xi(b.value.dataSlots, (e) => (q(), J("div", {
 						key: e.path,
 						class: "info-item"
 					}, [Y("div", Yp, V(e.path), 1), Y("div", Xp, V(e.description), 1)]))), 128))])) : X("", !0),
@@ -13125,7 +13125,7 @@ app.mount('#app');
 			_: 1
 		})]));
 	}
-}), [["__scopeId", "data-v-ac94546c"]]), zm = { class: "chat-header" }, Bm = { class: "header-left" }, Vm = { class: "header-title" }, Hm = {
+}), [["__scopeId", "data-v-2a895152"]]), zm = { class: "chat-header" }, Bm = { class: "header-left" }, Vm = { class: "header-title" }, Hm = {
 	key: 0,
 	class: "status-dot pulse"
 }, Um = { class: "header-actions" }, Wm = {
@@ -13591,7 +13591,7 @@ app.mount('#app');
 			])
 		], 2));
 	}
-}), [["__scopeId", "data-v-063f5f71"]]);
+}), [["__scopeId", "data-v-5bd12eb9"]]);
 function Zh(e) {
 	return e.replace(/^\/+/, "").replace(/\/+/g, "/");
 }
@@ -14357,14 +14357,14 @@ function Ag(e = "") {
 //#endregion
 //#region src/core/harness/permissions.ts
 var jg = /* @__PURE__ */ new Set([
-	"set_window_prop",
-	"delete_window_prop",
+	"set_data_slot",
+	"delete_data_slot",
 	"vfs_write",
 	"vfs_edit"
 ]), Mg = /* @__PURE__ */ new Set([
-	"get_window_prop",
-	"describe_window_prop",
-	"list_window_props",
+	"get_data_slot",
+	"describe_data_slot",
+	"list_data_slots",
 	"vfs_read",
 	"vfs_ls",
 	"vfs_glob",
@@ -14530,7 +14530,7 @@ function qg(e) {
 	return {
 		save(i) {
 			let a = Kg(e.messages), o = {};
-			for (let t of e.windowPaths) o[t] = Vg(Hg(window, t));
+			for (let t of e.slotPaths) o[t] = Vg(Hg(window, t));
 			let s = {
 				id: r++,
 				label: i,
@@ -14584,10 +14584,10 @@ function Yg(e) {
 	return !!e && typeof e == "object" && typeof e.invoke == "function" && typeof e.stream == "function";
 }
 var Xg = [
-	"get_window_prop",
-	"get_window_paths",
-	"list_window_props",
-	"describe_window_prop",
+	"get_data_slot",
+	"get_slot_paths",
+	"list_data_slots",
+	"describe_data_slot",
 	"fetch_document"
 ], Zg = 1, Qg = 4, $g = 6, e_ = ["spawn_agent", "spawn_agents"];
 async function t_(e, t, n, r, i) {
@@ -14753,9 +14753,9 @@ function o_(e) {
 	};
 }
 var s_ = /* @__PURE__ */ new Set([
-	"set_window_prop",
-	"edit_window_prop",
-	"delete_window_prop"
+	"set_data_slot",
+	"edit_data_slot",
+	"delete_data_slot"
 ]), c_ = /校验失败|未在注册表中声明|未注册|不存在|仅支持|必须是/;
 function l_(e) {
 	let t = /* @__PURE__ */ new Map();
@@ -14796,7 +14796,7 @@ function f_(e = {}) {
 			let r = s ? i.get(s) : void 0;
 			if (r && c_.test(r)) continue;
 			let c = d_(t, e);
-			if (n === "delete_window_prop") c !== void 0 && o.push(`${e} 删除后读回仍有值,疑似未生效`);
+			if (n === "delete_data_slot") c !== void 0 && o.push(`${e} 删除后读回仍有值,疑似未生效`);
 			else if (c == null) o.push(`写入 ${e} 后读回为空,疑似未生效`);
 			else if (a[e]) {
 				let t = a[e].safeParse(c);
@@ -14834,7 +14834,7 @@ async function v_(e, t, n, r) {
 		"你是严格的对抗式审查者,目标是找出以下 AI 助手回复的错误并证明它有问题(事实错误 / 遗漏 / 逻辑矛盾 / 与需求不符)。",
 		`用户需求:${i || "(未明确)"}`,
 		`助手回复:${a}`,
-		o ? "重点检查 window 修改:① 属性路径是否正确(是否误写未注册路径);② 值类型是否符合该属性 schema;③ 语义是否符合属性 description。可用只读工具(get_window_prop / list_window_props 等)读回实际值实证。" : "只报告具体、可验证的问题。",
+		o ? "重点检查 window 修改:① 属性路径是否正确(是否误写未注册路径);② 值类型是否符合该属性 schema;③ 语义是否符合属性 description。可用只读工具(get_data_slot / list_data_slots 等)读回实际值实证。" : "只报告具体、可验证的问题。",
 		"若确实无问题,只回复\"无问题\"。"
 	].join("\n"), c = "你是严格的对抗式审查者,只找问题不赞美。目标是反驳,不是改进。", l = n ? (e) => n(e.type, {
 		...e.data,
@@ -15042,11 +15042,11 @@ function P_(e = {}) {
 		}
 		else u = M_(o, l), d = s + "index_summary";
 		let f = t.enableRecall ? N_(o, c, t.recallTopK) : [], p = f.length ? f.map((e) => `- 第${e.round}轮：${w_(e.userMsg.content, 60)} → ${e.assistantMsgs[0] ? w_(e.assistantMsgs[0].content, 80) : ""}`).join("\n") : "", m = [`【对话历史摘要】以下是之前 ${o.length} 轮对话的要点（最新 ${a.length} 轮已完整保留）：`, u];
-		if (p && m.push("\n【与当前问题可能相关的早期对话】", p), t.getRegisteredProps) try {
-			let e = t.getRegisteredProps();
+		if (p && m.push("\n【与当前问题可能相关的早期对话】", p), t.getRegisteredSlots) try {
+			let e = t.getRegisteredSlots();
 			if (e.length) {
 				let t = e.map((e) => `- ${e.path}: ${e.description}`).join("\n");
-				m.push("\n【当前可操作 window 属性(动态增删后的最新状态,操作前以 list_window_props 为准)】", t);
+				m.push("\n【当前可操作数据槽 属性(动态增删后的最新状态,操作前以 list_data_slots 为准)】", t);
 			}
 		} catch {}
 		let h = {
@@ -15110,7 +15110,7 @@ function I_(e = {}) {
 //#endregion
 //#region src/core/presets.ts
 var L_ = {
-	pageBuilder: { systemPrompt: "你是页面构建助手。流程:get_window_prop 读取当前页面结构 → set_window_prop / edit_window_prop 修改属性 → 页面实时更新。多步任务先用 write_todos 拆解,逐步推进。" },
+	pageBuilder: { systemPrompt: "你是页面构建助手。流程:get_data_slot 读取当前页面结构 → set_data_slot / edit_data_slot 修改属性 → 页面实时更新。多步任务先用 write_todos 拆解,逐步推进。" },
 	researcher: {
 		systemPrompt: "你是调研助手。多路调研用 spawn_agents 并行委派子 agent(各负责一个方向);单份资料用 fetch_document 抓取;最后结构化汇总,给出结论与依据。",
 		subagent: { maxParallel: 4 }
@@ -15125,11 +15125,11 @@ var L_ = {
 	} }
 }, R_ = { reliableWriteRules: [
 	"【可靠写入规则】",
-	"1. 改任何属性前,先用 get_window_prop 读其当前真实值,基于真实值改,不要凭记忆;",
-	"2. 若不确定可操作哪些属性,先 list_window_props 查看当前注册项(动态组件场景下注册表会增删,以工具返回为准,勿凭旧记忆);",
-	"3. 不确定某属性字段结构时,先 describe_window_prop 看其说明,字段以 describe 返回为准;",
+	"1. 改任何属性前,先用 get_data_slot 读其当前真实值,基于真实值改,不要凭记忆;",
+	"2. 若不确定可操作哪些属性,先 list_data_slots 查看当前注册项(动态组件场景下注册表会增删,以工具返回为准,勿凭旧记忆);",
+	"3. 不确定某属性字段结构时,先 describe_data_slot 看其说明,字段以 describe 返回为准;",
 	"4. 写入若被 schema 校验拒绝(返回结构化错误含字段名与期望类型),按错误修正后重试,不要放弃;",
-	"5. 优先用 edit_window_prop 增量 patch(只发改动),避免 set 整体重传大 JSON 被截断。"
+	"5. 优先用 edit_data_slot 增量 patch(只发改动),避免 set 整体重传大 JSON 被截断。"
 ].join("\n") }, z_ = {
 	auto: {
 		summaryThresholdRatio: .5,
@@ -15184,7 +15184,7 @@ function H_(e, t) {
 		code: "SCHEMA_INVALID",
 		path: e,
 		message: `值不符合 "${e}" 的 schema(${t.length} 处问题)`,
-		hint: `按 describe_window_prop("${e}") 查看格式,修正后重试;改大对象优先用 edit_window_prop 增量 patch(只发改动部分)`,
+		hint: `按 describe_data_slot("${e}") 查看格式,修正后重试;改大对象优先用 edit_data_slot 增量 patch(只发改动部分)`,
 		details: V_(t)
 	});
 }
@@ -15403,7 +15403,7 @@ function Q_(e) {
 	};
 }
 //#endregion
-//#region src/core/tools/windowQuery.ts
+//#region src/core/tools/dataSlotQuery.ts
 var $_ = /[\w$-]/;
 function ev(e) {
 	let t = [], n = e.trim(), r = +(n[0] === "$");
@@ -15804,7 +15804,7 @@ function pv(e, t, n = 3e3) {
 	});
 }
 //#endregion
-//#region src/core/tools/windowOps.ts
+//#region src/core/tools/dataSlotOps.ts
 var mv = /* @__PURE__ */ new Set([
 	"__proto__",
 	"constructor",
@@ -15872,7 +15872,7 @@ function Sv(e) {
 	return n.toString(36);
 }
 function Cv(e, t, n, r) {
-	if (t === "set") return n ? (vv(e, n, r), null) : "set 操作需要 jsonPath(整体替换请用 set_window_prop)";
+	if (t === "set") return n ? (vv(e, n, r), null) : "set 操作需要 jsonPath(整体替换请用 set_data_slot)";
 	if (t === "remove") return n ? (yv(e, n), null) : "remove 操作需要 jsonPath";
 	if (t === "merge") {
 		let t = n ? _v(e, n) : e;
@@ -15906,7 +15906,7 @@ function Ev(e, t) {
 function Dv(e, r = {}) {
 	let i = /* @__PURE__ */ new Map();
 	for (let t of e) i.set(t.path, t);
-	let a = /* @__PURE__ */ new Map(), o = r.maxSnapshots ?? 20, s = {
+	let a = /* @__PURE__ */ new Map(), o = r.maxSnapshots ?? 20, s = /* @__PURE__ */ new Map(), c = r.autoLock !== !1, l = {
 		add: (e) => {
 			i.set(e.path, e);
 		},
@@ -15916,20 +15916,20 @@ function Dv(e, r = {}) {
 		},
 		list: () => [...i.values()],
 		has: (e) => i.has(e)
-	}, c = (e) => {
+	}, u = (e) => {
 		r.onAudit?.(e);
 	};
-	function l() {
+	function d() {
 		let e = [...i.keys()];
 		if (!e.length) return "";
 		let t = e.join(", ");
-		return e.length > 8 || t.length > 240 ? `\n(当前可操作属性共 ${e.length} 项,用 list_window_props 查看)` : `\n(当前可操作 path: ${t})`;
+		return e.length > 8 || t.length > 240 ? `\n(当前可操作属性共 ${e.length} 项,用 list_data_slots 查看)` : `\n(当前可操作 path: ${t})`;
 	}
-	let u = (r.whitelist ?? !0) === !1;
-	function d(e) {
-		return r.allowRawRead ? !0 : [...i.keys()].some((t) => e === t || e.startsWith(t + ".") || u && t.startsWith(e + "."));
+	let f = (r.whitelist ?? !0) === !1;
+	function p(e) {
+		return r.allowRawRead ? !0 : [...i.keys()].some((t) => e === t || e.startsWith(t + ".") || f && t.startsWith(e + "."));
 	}
-	function f(e, t, n) {
+	function m(e, t, n) {
 		let r = bv(_v(window, e)), i = a.get(e) || [], s = i.length ? i[i.length - 1].id + 1 : 1;
 		for (i.push({
 			id: s,
@@ -15940,7 +15940,7 @@ function Dv(e, r = {}) {
 		}); i.length > o;) i.shift();
 		return a.set(e, i), s;
 	}
-	async function p(e, t, n, i) {
+	async function h(e, t, n, i) {
 		if (!n || n === "") return null;
 		let o = _v(window, e), s = Sv(o);
 		if (s === n) return null;
@@ -15948,7 +15948,7 @@ function Dv(e, r = {}) {
 			code: "VERSION_CONFLICT",
 			path: e,
 			message: `乐观锁冲突:expectedHash=${n} 但当前 hash=${s}。属性 "${e}" 在你 get 之后已被修改(外部代码/其他 agent/用户手动改)。`,
-			hint: `重新 get_window_prop("${e}") 拿最新值与 hash,基于最新值修改后再写入(传新的 expectedHash)。当前值:${xv(o, 400)}`
+			hint: `重新 get_data_slot("${e}") 拿最新值与 hash,基于最新值修改后再写入(传新的 expectedHash)。当前值:${xv(o, 400)}`
 		});
 		let c = await r.onConflict({
 			path: e,
@@ -15959,7 +15959,7 @@ function Dv(e, r = {}) {
 			expectedHash: n,
 			snapshotId: 0
 		});
-		if (c.action === "keep_external") return `已保留外部修改(未写入)。当前值:${xv(o, 400)} (hash=${s})。请重新 get_window_prop("${e}") 拿最新值与 hash 再改。`;
+		if (c.action === "keep_external") return `已保留外部修改(未写入)。当前值:${xv(o, 400)} (hash=${s})。请重新 get_data_slot("${e}") 拿最新值与 hash 再改。`;
 		if (c.action === "restore") {
 			let t = a.get(e) || [];
 			if (!t.length) return `无历史快照可回退(本次为首次操作)。当前值:${xv(o, 400)} (hash=${s})。请重新 get 再改或选「强制覆盖」。`;
@@ -15970,132 +15970,136 @@ function Dv(e, r = {}) {
 		}
 		return null;
 	}
-	let m = n(async () => {
-		if (!i.size) return "当前没有已注册的可操作 window 属性。";
+	let g = n(async () => {
+		if (!i.size) return "当前没有已注册的可操作 数据槽。";
 		let e = [...i.values()].map((e) => `- ${e.path}: ${e.description}`);
-		return `可操作的 window 属性(共 ${i.size} 项):\n${e.join("\n")}`;
+		return `可操作的 数据槽(共 ${i.size} 项):\n${e.join("\n")}`;
 	}, {
-		name: "list_window_props",
-		description: "列出所有已注册、可操作的 window 属性(path + 说明)。操作 window 前先调用此工具了解可用范围。",
+		name: "list_data_slots",
+		description: "列出所有已注册、可操作的 数据槽(path + 说明)。操作数据槽前先调用此工具了解可用范围。",
 		schema: t.object({})
-	}), h = n(async ({ path: e }) => {
+	}), _ = n(async ({ path: e }) => {
 		let t = i.get(e);
 		return t ? [
 			`路径: ${t.path}`,
 			`说明: ${t.description}`,
-			"格式: 写入值需为 JSON,且通过注册时声明的 schema 校验(校验失败时 set_window_prop/edit_window_prop 会返回结构化错误,含具体字段与期望类型)。"
+			"格式: 写入值需为 JSON,且通过注册时声明的 schema 校验(校验失败时 set_data_slot/edit_data_slot 会返回结构化错误,含具体字段与期望类型)。"
 		].join("\n") : $({
 			code: "NOT_REGISTERED",
 			path: e,
 			message: `属性 "${e}" 未注册`,
-			hint: "用 list_window_props 查看可用属性"
+			hint: "用 list_data_slots 查看可用属性"
 		});
 	}, {
-		name: "describe_window_prop",
-		description: "获取单个已注册 window 属性的说明与格式要求。",
+		name: "describe_data_slot",
+		description: "获取单个已注册 数据槽的说明与格式要求。",
 		schema: t.object({ path: t.string().describe("属性路径,如 app.theme") })
-	}), g = n(async ({ path: e }) => {
-		if (!d(e)) return $({
+	}), v = n(async ({ path: e }) => {
+		if (!p(e)) return $({
 			code: "NOT_REGISTERED",
 			path: e,
 			message: `属性 "${e}" 不可读取(未注册,且非已注册路径的后代)`,
-			hint: "用 list_window_props 查看可操作字段;字段白名单读模式下未注册的祖先(整体大 JSON)不暴露,需读其声明子路径"
+			hint: "用 list_data_slots 查看可操作字段;字段白名单读模式下未注册的祖先(整体大 JSON)不暴露,需读其声明子路径"
 		});
 		let t = _v(window, e);
-		return t === void 0 ? `${e} = (undefined)` : `${e} = ${xv(t)} (hash=${Sv(t)})`;
+		if (t === void 0) return `${e} = (undefined)`;
+		let n = Sv(t);
+		return s.set(e, n), `${e} = ${xv(t)} (hash=${n})`;
 	}, {
-		name: "get_window_prop",
-		description: "读取一个已注册 window 属性的当前值(安全序列化:函数/DOM/循环引用做摘要;大结果由系统自动外存,提示用 vfs_read 回读)。返回含 hash(乐观锁):改属性前先 get 拿 hash,写入时(set/edit/delete)传 expectedHash 回传,系统对比当前 hash 防\"基于过期值覆盖\"(外部代码/其他 agent/用户手动改过会 CONFLICT,需重新 get 再改)。字段白名单读模式(默认)下仅可读注册 path 自身/后代;未注册祖先(整体大 JSON)不可读,避免大 JSON 拉进上下文。",
+		name: "get_data_slot",
+		description: "读取一个已注册 数据槽的当前值(安全序列化:函数/DOM/循环引用做摘要;大结果由系统自动外存,提示用 vfs_read 回读)。返回含 hash(乐观锁):改属性前先 get 拿 hash,写入时(set/edit/delete)传 expectedHash 回传,系统对比当前 hash 防\"基于过期值覆盖\"(外部代码/其他 agent/用户手动改过会 CONFLICT,需重新 get 再改)。字段白名单读模式(默认)下仅可读注册 path 自身/后代;未注册祖先(整体大 JSON)不可读,避免大 JSON 拉进上下文。",
 		schema: t.object({ path: t.string().describe("已注册的属性路径或其后代") })
-	}), _ = n(async ({ path: e, value: t, expectedHash: n }) => {
+	}), y = n(async ({ path: e, value: t, expectedHash: n }) => {
 		let r = i.get(e);
 		if (!r) return $({
 			code: "NOT_REGISTERED",
 			path: e,
 			message: `属性 "${e}" 未在注册表中声明,不可写`,
-			hint: "用 list_window_props 查看可用属性;集成方需先在 windowProps 声明该 path"
+			hint: "用 list_data_slots 查看可用属性;集成方需先在 dataSlots 声明该 path"
 		});
-		let a = await p(e, "set", n);
+		let a = await h(e, "set", n || (c ? s.get(e) : void 0));
 		if (a !== null) return a;
 		let o;
-		try {
+		if (typeof t == "string") try {
 			o = JSON.parse(t);
 		} catch (n) {
 			return U_(e, t, n);
 		}
-		let s = r.schema.safeParse(o);
-		if (!s.success) return H_(e, s.error.issues);
-		f(e, "set");
-		let u = _v(window, e);
-		return typeof u == "object" && u && s.data !== null && typeof s.data == "object" ? Ev(u, s.data) : vv(window, e, s.data), c({
+		else o = t;
+		let l = r.schema.safeParse(o);
+		if (!l.success) return H_(e, l.error.issues);
+		m(e, "set");
+		let f = _v(window, e);
+		return typeof f == "object" && f && l.data !== null && typeof l.data == "object" ? Ev(f, l.data) : vv(window, e, l.data), u({
 			op: "set",
 			path: e,
-			value: s.data,
+			value: l.data,
 			timestamp: Date.now()
-		}), `已设置 ${e} = ${xv(s.data, 600)} (新 hash=${Sv(_v(window, e))})${l()}`;
+		}), `已设置 ${e} = ${xv(l.data, 600)} (新 hash=${Sv(_v(window, e))})${d()}`;
 	}, {
-		name: "set_window_prop",
-		description: "设置一个已注册 window 属性的值(整体替换)。仅能操作注册表内声明的属性;value 为 JSON 字符串,需通过该属性声明的 schema 校验。校验失败会返回错误而非写入。expectedHash(可选):改前 get_window_prop 返回的 hash,传入则启用乐观锁——若属性已被改过(外部代码/其他 agent/用户手动)则返回 VERSION_CONFLICT 不写入,需重新 get 再改,防\"基于过期值覆盖\"。大对象/数组强烈建议改用 edit_window_prop 增量 patch。",
+		name: "set_data_slot",
+		description: "设置一个已注册 数据槽的值(整体替换)。仅能操作注册表内声明的属性;value 为 JSON 对象(或 JSON 字符串),需通过该属性声明的 schema 校验。校验失败会返回错误而非写入。expectedHash(可选):改前 get_data_slot 返回的 hash,传入则启用乐观锁;不传时系统自动用你最后一次 get 读到的 hash 比对(autoLock,默认开)——若属性已被改过(外部代码/其他 agent/用户手动)则返回 VERSION_CONFLICT 不写入,需重新 get 再改,防\"基于过期值覆盖\"。大对象/数组强烈建议改用 edit_data_slot 增量 patch。",
 		schema: t.object({
 			path: t.string().describe("已注册的属性路径"),
-			value: t.string().describe("JSON 字符串形式的值,需符合该属性 schema"),
-			expectedHash: t.string().optional().describe("乐观锁:改前 get_window_prop 返回的 hash;传入则校验,不一致拒绝写入防覆盖")
+			value: t.unknown().describe("JSON 对象(推荐直传,如 {title:\"x\"}),或 JSON 字符串;需符合该属性 schema"),
+			expectedHash: t.string().optional().describe("乐观锁:改前 get_data_slot 返回的 hash;传入则校验,不一致拒绝写入防覆盖。不传则自动用你最后 get 到的 hash(autoLock)")
 		})
-	}), v = n(async ({ path: e, op: t, jsonPath: n, value: r, expectedHash: a }) => {
+	}), b = n(async ({ path: e, op: t, jsonPath: n, value: r, expectedHash: a }) => {
 		let o = i.get(e);
 		if (!o) return $({
 			code: "NOT_REGISTERED",
 			path: e,
 			message: `属性 "${e}" 未在注册表中声明,不可写`,
-			hint: "用 list_window_props 查看可用属性"
+			hint: "用 list_data_slots 查看可用属性"
 		});
-		let s = n || "";
-		if (hv(s)) return $({
+		let l = n || "";
+		if (hv(l)) return $({
 			code: "PATH_UNSAFE",
 			path: e,
-			message: `jsonPath "${s}" 含非法段(__proto__/constructor/prototype)`,
+			message: `jsonPath "${l}" 含非法段(__proto__/constructor/prototype)`,
 			hint: "使用正常的属性路径,如 components.0.text(数组索引用数字)"
 		});
-		let u = _v(window, e), d = await p(e, "edit", a);
-		if (d !== null) return d;
-		if (typeof u != "object" || !u) return $({
+		let f = _v(window, e), p = await h(e, "edit", a || (c ? s.get(e) : void 0));
+		if (p !== null) return p;
+		if (typeof f != "object" || !f) return $({
 			code: "NOT_OBJECT",
 			path: e,
-			message: `edit 仅适用于对象/数组属性,"${e}" 当前是 ${u === void 0 ? "undefined" : typeof u}`,
-			hint: "叶子属性(原始类型)请用 set_window_prop 整体设置"
+			message: `edit 仅适用于对象/数组属性,"${e}" 当前是 ${f === void 0 ? "undefined" : typeof f}`,
+			hint: "叶子属性(原始类型)请用 set_data_slot 整体设置"
 		});
-		let m;
+		let g;
 		if (t !== "remove") {
 			if (r === void 0 || r === "") return $({
 				code: "MISSING_VALUE",
 				path: e,
-				message: `${t} 操作需要 value(JSON 字符串)`,
+				message: `${t} 操作需要 value(JSON 对象或字符串)`,
 				hint: `op 为 ${t} 时 value 必填;若想删除请用 op:'remove'`
 			});
-			try {
-				m = JSON.parse(r);
+			if (typeof r == "string") try {
+				g = JSON.parse(r);
 			} catch (t) {
 				return U_(e, r, t);
 			}
+			else g = r;
 		}
-		let h = bv(u), g = Cv(h, t, s, m);
-		if (g) return $({
+		let _ = bv(f), v = Cv(_, t, l, g);
+		if (v) return $({
 			code: "PATCH_FAILED",
 			path: e,
-			message: g,
+			message: v,
 			hint: "检查 op 与目标类型:merge 需目标为对象,append 需目标为数组;jsonPath 指向需存在"
 		});
-		let _ = o.schema.safeParse(h);
-		return _.success ? (f(e, "edit"), wv(e, t, s, m), c({
+		let y = o.schema.safeParse(_);
+		return y.success ? (m(e, "edit"), wv(e, t, l, g), u({
 			op: "edit",
 			path: e,
-			detail: `${t}${s ? "@" + s : ""}`,
-			value: m,
+			detail: `${t}${l ? "@" + l : ""}`,
+			value: g,
 			timestamp: Date.now()
-		}), `已 edit ${e}(${t}${s ? " @ " + s : ""})。当前值:${xv(_v(window, e), 600)} (新 hash=${Sv(_v(window, e))})${l()}`) : H_(e, _.error.issues);
+		}), `已 edit ${e}(${t}${l ? " @ " + l : ""})。当前值:${xv(_v(window, e), 600)} (新 hash=${Sv(_v(window, e))})${d()}`) : H_(e, y.error.issues);
 	}, {
-		name: "edit_window_prop",
-		description: "增量编辑一个已注册的「对象/数组」window 属性,只发改动的 patch,无需重传整个大对象。op:set(在 jsonPath 设值)、remove(删 jsonPath)、merge(把 value 合并到 jsonPath 指向的对象,默认根)、append(把 value 追加到 jsonPath 指向的数组,默认根)。jsonPath 为相对属性根的点号路径(数组索引用数字,如 components.0.text);value 为 JSON 字符串。整体仍经 schema 校验,失败不写入。expectedHash(可选):改前 get_window_prop 返回的 hash,传入启用乐观锁防\"基于过期值覆盖\"。",
+		name: "edit_data_slot",
+		description: "增量编辑一个已注册的「对象/数组」数据槽,只发改动的 patch,无需重传整个大对象。op:set(在 jsonPath 设值)、remove(删 jsonPath)、merge(把 value 合并到 jsonPath 指向的对象,默认根)、append(把 value 追加到 jsonPath 指向的数组,默认根)。jsonPath 为相对属性根的点号路径(数组索引用数字,如 components.0.text);value 为 JSON 对象(推荐直传)或 JSON 字符串。整体仍经 schema 校验,失败不写入。expectedHash(可选):改前 get_data_slot 返回的 hash;不传时自动用你最后 get 到的 hash(autoLock,默认开)防\"基于过期值覆盖\"。",
 		schema: t.object({
 			path: t.string().describe("已注册的对象/数组属性路径"),
 			op: t.enum([
@@ -16105,51 +16109,51 @@ function Dv(e, r = {}) {
 				"append"
 			]),
 			jsonPath: t.string().optional().describe("相对属性根的点号路径(数组索引用数字,如 components.0.text)。set/remove 必填;merge/append 不填则作用于根"),
-			value: t.string().optional().describe("JSON 字符串(set/merge/append 必填)"),
-			expectedHash: t.string().optional().describe("乐观锁:改前 get_window_prop 返回的 hash;传入则校验,不一致拒绝写入防覆盖")
+			value: t.unknown().optional().describe("JSON 对象(推荐直传,如 {text:\"x\"})或 JSON 字符串(set/merge/append 必填)"),
+			expectedHash: t.string().optional().describe("乐观锁:改前 get_data_slot 返回的 hash;传入则校验,不一致拒绝写入防覆盖。不传则自动用你最后 get 到的 hash(autoLock)")
 		})
-	}), y = n(async ({ path: e, expectedHash: t }) => {
+	}), x = n(async ({ path: e, expectedHash: t }) => {
 		if (!i.has(e)) return $({
 			code: "NOT_REGISTERED",
 			path: e,
 			message: `属性 "${e}" 未在注册表中声明,不可删除`,
-			hint: "用 list_window_props 查看可用属性"
+			hint: "用 list_data_slots 查看可用属性"
 		});
-		let n = await p(e, "delete", t);
+		let n = await h(e, "delete", t || (c ? s.get(e) : void 0));
 		if (n !== null) return n;
-		f(e, "delete");
+		m(e, "delete");
 		let r = yv(window, e);
-		return c({
+		return u({
 			op: "delete",
 			path: e,
 			timestamp: Date.now()
-		}), r ? `已删除 ${e}${l()}` : `${e} 不存在(无需删除)${l()}`;
+		}), r ? `已删除 ${e}${d()}` : `${e} 不存在(无需删除)${d()}`;
 	}, {
-		name: "delete_window_prop",
-		description: "删除一个已注册 window 属性。expectedHash(可选):改前 get_window_prop 返回的 hash,传入启用乐观锁防\"基于过期值删除\"。",
+		name: "delete_data_slot",
+		description: "删除一个已注册 数据槽。expectedHash(可选):改前 get_data_slot 返回的 hash;不传时自动用你最后 get 到的 hash(autoLock,默认开)防\"基于过期值删除\"。",
 		schema: t.object({
 			path: t.string().describe("已注册的属性路径"),
-			expectedHash: t.string().optional().describe("乐观锁:改前 get_window_prop 返回的 hash;传入则校验,不一致拒绝删除防覆盖")
+			expectedHash: t.string().optional().describe("乐观锁:改前 get_data_slot 返回的 hash;传入则校验,不一致拒绝删除防覆盖。不传则自动用你最后 get 到的 hash(autoLock)")
 		})
-	}), b = n(async ({ path: e, label: t }) => i.has(e) ? `已为 ${e} 创建快照 #${f(e, "manual", t)}${t ? `(${t})` : ""}。可用 list_window_snapshots 查看、restore_window_snapshot 回退。` : $({
+	}), S = n(async ({ path: e, label: t }) => i.has(e) ? `已为 ${e} 创建快照 #${m(e, "manual", t)}${t ? `(${t})` : ""}。可用 list_data_snapshots 查看、restore_data_snapshot 回退。` : $({
 		code: "NOT_REGISTERED",
 		path: e,
 		message: `属性 "${e}" 未注册,无法打快照`,
-		hint: "用 list_window_props 查看可用属性"
+		hint: "用 list_data_slots 查看可用属性"
 	}), {
-		name: "snapshot_window_prop",
-		description: "为已注册 window 属性手动创建一个命名快照(检查点)。set/edit/delete 也会自动存快照。",
+		name: "snapshot_data_slot",
+		description: "为已注册 数据槽手动创建一个命名快照(检查点)。set/edit/delete 也会自动存快照。",
 		schema: t.object({
 			path: t.string().describe("已注册的属性路径"),
 			label: t.string().optional().describe("可选的快照标签,便于识别")
 		})
-	}), x = n(async ({ path: e }) => {
+	}), C = n(async ({ path: e }) => {
 		let t = e ? [e] : [...i.keys()];
 		if (e && !i.has(e)) return $({
 			code: "NOT_REGISTERED",
 			path: e,
 			message: `属性 "${e}" 未注册`,
-			hint: "用 list_window_props 查看可用属性"
+			hint: "用 list_data_slots 查看可用属性"
 		});
 		let n = [];
 		for (let r of t) {
@@ -16164,35 +16168,35 @@ function Dv(e, r = {}) {
 				n.push(`  #${e.id} [${e.op}]${e.label ? ` "${e.label}"` : ""} ${r} 修改前≈${t}字符`);
 			}
 		}
-		return n.join("\n") || "无快照。set/edit/delete 会自动存快照,也可用 snapshot_window_prop 手动创建检查点。";
+		return n.join("\n") || "无快照。set/edit/delete 会自动存快照,也可用 snapshot_data_slot 手动创建检查点。";
 	}, {
-		name: "list_window_snapshots",
-		description: "列出 window 属性的快照时间线(序号、操作类型、标签、大小)。不传 path 列出所有属性。",
+		name: "list_data_snapshots",
+		description: "列出 数据槽的快照时间线(序号、操作类型、标签、大小)。不传 path 列出所有属性。",
 		schema: t.object({ path: t.string().optional().describe("限定单个属性,不传则列出全部") })
-	}), S = n(async ({ path: e, id: t }) => {
+	}), w = n(async ({ path: e, id: t }) => {
 		let n = i.get(e);
 		if (!n) return $({
 			code: "NOT_REGISTERED",
 			path: e,
 			message: `属性 "${e}" 未注册`,
-			hint: "用 list_window_props 查看可用属性"
+			hint: "用 list_data_slots 查看可用属性"
 		});
 		let r = a.get(e) || [];
 		if (!r.length) return $({
 			code: "NO_SNAPSHOT",
 			path: e,
 			message: `"${e}" 无快照可回退`,
-			hint: "set/edit/delete 会自动存快照;也可先 snapshot_window_prop 手动创建检查点"
+			hint: "set/edit/delete 会自动存快照;也可先 snapshot_data_slot 手动创建检查点"
 		});
 		let o = t === void 0 ? r[r.length - 1] : r.find((e) => e.id === t);
 		if (!o) return $({
 			code: "SNAPSHOT_NOT_FOUND",
 			path: e,
 			message: `未找到快照 #${t}`,
-			hint: "用 list_window_snapshots 查看可用快照序号"
+			hint: "用 list_data_snapshots 查看可用快照序号"
 		});
 		let s = n.schema.safeParse(o.value);
-		return s.success ? (Tv(e, bv(o.value)), c({
+		return s.success ? (Tv(e, bv(o.value)), u({
 			op: "restore",
 			path: e,
 			detail: `#${o.id}`,
@@ -16205,25 +16209,25 @@ function Dv(e, r = {}) {
 			details: V_(s.error.issues)
 		});
 	}, {
-		name: "restore_window_snapshot",
-		description: "把已注册 window 属性回退到某个快照(就地还原,保留响应式)。不传 id 则回退最近一次(快速回退)。可用 list_window_snapshots 查看快照列表。",
+		name: "restore_data_snapshot",
+		description: "把已注册 数据槽回退到某个快照(就地还原,保留响应式)。不传 id 则回退最近一次(快速回退)。可用 list_data_snapshots 查看快照列表。",
 		schema: t.object({
 			path: t.string().describe("已注册的属性路径"),
 			id: t.number().int().optional().describe("指定快照序号;不传则回退最近一次")
 		})
-	}), C = [
-		m,
-		h,
+	}), T = [
 		g,
+		_,
+		v,
 		n(async ({ paths: e }) => {
 			let t = [];
 			for (let n of e) {
-				if (!d(n)) {
+				if (!p(n)) {
 					t.push(`- ${n} = ERROR: ${$({
 						code: "NOT_REGISTERED",
 						path: n,
 						message: "不可读取(未注册,且非已注册路径的后代)",
-						hint: "用 list_window_props 查看可操作字段"
+						hint: "用 list_data_slots 查看可操作字段"
 					})}`);
 					continue;
 				}
@@ -16232,29 +16236,29 @@ function Dv(e, r = {}) {
 			}
 			return t.join("\n");
 		}, {
-			name: "get_window_paths",
-			description: "批量按路径读取 window 属性的局部或多个字段(避免对大 JSON 整体读取)。paths 支持注册属性的任意后代路径(如 page.components.0.text)、自身。字段白名单读模式(默认)下未注册祖先不可读。逐行返回 path = value;单个值过大仍由系统自动外存 vfs。",
+			name: "get_slot_paths",
+			description: "批量按路径读取 数据槽的局部或多个字段(避免对大 JSON 整体读取)。paths 支持注册属性的任意后代路径(如 page.components.0.text)、自身。字段白名单读模式(默认)下未注册祖先不可读。逐行返回 path = value;单个值过大仍由系统自动外存 vfs。",
 			schema: t.object({ paths: t.array(t.string().describe("路径,如 page.components.0.text")).min(1).max(20) })
 		}),
-		_,
-		v,
 		y,
 		b,
 		x,
 		S,
+		C,
+		w,
 		n(async ({ path: e, expr: t, limit: n }) => {
 			if (!i.get(e)) return $({
 				code: "NOT_REGISTERED",
 				path: e,
 				message: `属性 "${e}" 未注册`,
-				hint: "用 list_window_props 查看可用属性"
+				hint: "用 list_data_slots 查看可用属性"
 			});
 			let r = _v(window, e);
 			if (typeof r != "object" || !r) return $({
 				code: "NOT_OBJECT",
 				path: e,
 				message: `"${e}" 不是对象/数组,无法查询(当前为 ${r === void 0 ? "undefined" : typeof r})`,
-				hint: "query 仅适用于对象/数组;叶子属性用 get_window_prop 读"
+				hint: "query 仅适用于对象/数组;叶子属性用 get_data_slot 读"
 			});
 			let a;
 			try {
@@ -16271,8 +16275,8 @@ function Dv(e, r = {}) {
 			let o = n ?? 50, s = a.slice(0, o), c = s.map((e) => `{"path":${JSON.stringify(e.path)},"index":${e.index === void 0 ? "null" : e.index},"value":${xv(e.value)}}`);
 			return `{"matched":${a.length},"returned":${s.length},"truncated":${a.length > o},"results":[${c.join(",")}]}`;
 		}, {
-			name: "query_window_prop",
-			description: "用 JSONPath 表达式对一个已注册的对象/数组属性做结构化查询(只读,无副作用)。语法子集:$ 根、.key、[n]、[\"key\"]、[*] 通配、[?(filter)] 过滤、..key 递归找后代、..* 全后代。过滤表达式:@.field op literal(op:==/!=/</<=/>/>=),&&/||/() 连接;@ 指当前元素。注意过滤作用于\"当前节点的子元素数组\",若注册属性是对象需先点出数组字段再过滤,如 $.components[?(@.type==\"card\" && @.price<100)]。返回匹配元素的 path(相对属性根,数组索引可作后续 edit_window_prop 的 jsonPath)+ index(若父为数组)+ value。适合在大数组里按条件筛选元素,定位后再用 edit_window_prop 增量改。",
+			name: "query_data_slot",
+			description: "用 JSONPath 表达式对一个已注册的对象/数组属性做结构化查询(只读,无副作用)。语法子集:$ 根、.key、[n]、[\"key\"]、[*] 通配、[?(filter)] 过滤、..key 递归找后代、..* 全后代。过滤表达式:@.field op literal(op:==/!=/</<=/>/>=),&&/||/() 连接;@ 指当前元素。注意过滤作用于\"当前节点的子元素数组\",若注册属性是对象需先点出数组字段再过滤,如 $.components[?(@.type==\"card\" && @.price<100)]。返回匹配元素的 path(相对属性根,数组索引可作后续 edit_data_slot 的 jsonPath)+ index(若父为数组)+ value。适合在大数组里按条件筛选元素,定位后再用 edit_data_slot 增量改。",
 			schema: t.object({
 				path: t.string().describe("已注册的对象/数组属性路径"),
 				expr: t.string().describe("JSONPath 表达式,如 $[?(@.type==\"card\" && @.price<100)] 或 $..title(递归找所有 title)"),
@@ -16284,7 +16288,7 @@ function Dv(e, r = {}) {
 				code: "NOT_REGISTERED",
 				path: e,
 				message: `属性 "${e}" 未注册`,
-				hint: "用 list_window_props 查看可用属性"
+				hint: "用 list_data_slots 查看可用属性"
 			});
 			let s = _v(window, e);
 			if (s == null) return $({
@@ -16313,8 +16317,8 @@ function Dv(e, r = {}) {
 				});
 			}
 		}, {
-			name: "search_window_prop",
-			description: "在一个已注册 window 属性内做文本搜索(只读,无副作用)。mode:substring(子串,默认,大小写不敏感)、regex(正则,i 标志)、fuzzy(模糊:子串命中或 Levenshtein 距离 ≤ fuzzyThreshold)。递归遍历所有叶子值(及可选 key),返回命中元素的 path + value(超 200 字符截断)。适合在大 JSON 里找名字近似、记不清的元素,定位 path 后用 edit_window_prop 改。",
+			name: "search_data_slot",
+			description: "在一个已注册 数据槽内做文本搜索(只读,无副作用)。mode:substring(子串,默认,大小写不敏感)、regex(正则,i 标志)、fuzzy(模糊:子串命中或 Levenshtein 距离 ≤ fuzzyThreshold)。递归遍历所有叶子值(及可选 key),返回命中元素的 path + value(超 200 字符截断)。适合在大 JSON 里找名字近似、记不清的元素,定位 path 后用 edit_data_slot 改。",
 			schema: t.object({
 				path: t.string().describe("已注册的属性路径(在它的子树内搜索)"),
 				query: t.string().describe("搜索词(substring/regex/fuzzy 共用)"),
@@ -16334,7 +16338,7 @@ function Dv(e, r = {}) {
 				code: "NOT_REGISTERED",
 				path: e,
 				message: `属性 "${e}" 未注册`,
-				hint: "用 list_window_props 查看可用属性"
+				hint: "用 list_data_slots 查看可用属性"
 			});
 			if (t.length > 8e3) return $({
 				code: "SCRIPT_TOO_LARGE",
@@ -16362,12 +16366,12 @@ function Dv(e, r = {}) {
 					code: "SCHEMA_INVALID",
 					path: e,
 					message: "脚本返回值校验失败,未写入(transform 模式要求返回该属性的完整新值且符合 schema)",
-					hint: `确认脚本 return 了完整新值(非部分);按 describe_window_prop("${e}") 查看格式`,
+					hint: `确认脚本 return 了完整新值(非部分);按 describe_data_slot("${e}") 查看格式`,
 					details: V_(t.error.issues)
 				});
-				f(e, "edit", "eval_transform");
+				m(e, "edit", "eval_transform");
 				let n = _v(window, e);
-				return typeof n == "object" && n && t.data !== null && typeof t.data == "object" ? Ev(n, t.data) : vv(window, e, t.data), c({
+				return typeof n == "object" && n && t.data !== null && typeof t.data == "object" ? Ev(n, t.data) : vv(window, e, t.data), u({
 					op: "edit",
 					path: e,
 					detail: "eval_transform",
@@ -16380,8 +16384,8 @@ function Dv(e, r = {}) {
 				elapsedMs: a.elapsedMs
 			});
 		}, {
-			name: "eval_window_script",
-			description: "在隔离的 Web Worker 沙箱里对一个已注册 window 属性跑自定义 JS 脚本(无 window/document 访问,fetch/XHR/WebSocket/importScripts 已禁用,超时 3s 可终止)。脚本以 `data` 为入参(该属性的深拷贝),返回值即结果。mode:query(默认,只读,把返回值回给 LLM,适合过滤/映射/聚合/统计大数组)、transform(把返回值作为该属性的新整体值,经 schema 校验后就地落地,适合批量重写)。注意:transform 需返回完整新值;query 不改 window。脚本内可用标准 JS(Array/Object/JSON/Math 等)与 async/await。",
+			name: "eval_script",
+			description: "在隔离的 Web Worker 沙箱里对一个已注册 数据槽跑自定义 JS 脚本(无 window/document 访问,fetch/XHR/WebSocket/importScripts 已禁用,超时 3s 可终止)。脚本以 `data` 为入参(该属性的深拷贝),返回值即结果。mode:query(默认,只读,把返回值回给 LLM,适合过滤/映射/聚合/统计大数组)、transform(把返回值作为该属性的新整体值,经 schema 校验后就地落地,适合批量重写)。注意:transform 需返回完整新值;query 不改 window。脚本内可用标准 JS(Array/Object/JSON/Math 等)与 async/await。",
 			schema: t.object({
 				path: t.string().describe("已注册的属性路径,其深拷贝作为脚本的 data 入参"),
 				script: t.string().describe("JS 脚本体,如 data.filter(c=>c.stock>0).map(c=>c.id);入参名 data;末尾表达式或 return 即返回值"),
@@ -16389,12 +16393,12 @@ function Dv(e, r = {}) {
 			})
 		})
 	];
-	return Object.defineProperty(C, "controller", {
-		value: s,
+	return Object.defineProperty(T, "controller", {
+		value: l,
 		enumerable: !1,
 		configurable: !1,
 		writable: !1
-	}), C;
+	}), T;
 }
 //#endregion
 //#region src/core/tools/fetchDoc.ts
@@ -16432,7 +16436,7 @@ function jv(e, t) {
 	return Dv(e, t);
 }
 function Mv(e, t, n) {
-	let r = e?.windowOps !== !1, i = e?.fetch !== !1;
+	let r = e?.dataSlotOps !== !1, i = e?.fetch !== !1;
 	return [...r ? t : [], ...i ? n : []];
 }
 //#endregion
@@ -16443,9 +16447,9 @@ function Pv(e, t) {
 		name: "usageHints",
 		augmentPrompt: () => {
 			let n = [];
-			if (e?.planning !== !1 && n.push("多步任务建议先 write_todos 拆解为步骤并逐步推进。"), t && (n.push("改属性前先 get_window_prop(path) 读其当前真实值与 hash(返回末尾 hash=xxx),基于真实值改,不要凭记忆。写入(set/edit/delete)时回传 expectedHash=该 hash 启用乐观锁——若属性在你 get 之后被外部代码/其他 agent/用户手动改过,会触发冲突:集成方若开启人工介入,工具会挂起等用户决定(保留外部/强制覆盖/回退),你应等待工具返回后按结果继续(保留外部→重新 get 再改;强制覆盖→已写入,继续;回退→已回退到历史快照,基于回退值重写);未开启人工介入时返回 VERSION_CONFLICT 不写入,重新 get 拿最新值与 hash 再改。"), n.push("不确定可操作哪些属性时用 list_window_props 查看(动态组件场景下注册表会增删,以工具返回为准,勿凭旧记忆);不确定某属性字段结构时用 describe_window_prop。"), n.push("修改大对象/数组属性优先用 edit_window_prop 增量 patch(只发改动部分),避免 set 整体重传被 max_tokens 截断导致 JSON 不完整、校验失败。"), n.push("修改属性出错时可用 restore_window_snapshot(path) 回退最近一次。"), n.push("在大数组里按条件筛选元素用 query_window_prop(JSONPath,如 $[?(@.type==\"card\" && @.price<100)]),返回匹配元素的 path/index;定位后再 edit_window_prop 改。"), n.push("找名字记不清的元素用 search_window_prop(支持 substring/regex/fuzzy 模糊搜索)。"), n.push("需要过滤/映射/聚合/批量重写大数组时用 eval_window_script(沙箱脚本,入参 data);只读探查用 mode=query,批量重写用 mode=transform(返回值经校验后落地)。")), e?.subagent !== !1 && n.push("独立子任务可 spawn_agent 委派(只读工具,过程不占主上下文)。"), e?.subagents?.length) {
+			if (e?.planning !== !1 && n.push("多步任务建议先 write_todos 拆解为步骤并逐步推进。"), t && (n.push("改属性前先 get_data_slot(path) 读其当前真实值与 hash(返回末尾 hash=xxx),基于真实值改,不要凭记忆。写入(set/edit/delete)时回传 expectedHash=该 hash 启用乐观锁——若属性在你 get 之后被外部代码/其他 agent/用户手动改过,会触发冲突:集成方若开启人工介入,工具会挂起等用户决定(保留外部/强制覆盖/回退),你应等待工具返回后按结果继续(保留外部→重新 get 再改;强制覆盖→已写入,继续;回退→已回退到历史快照,基于回退值重写);未开启人工介入时返回 VERSION_CONFLICT 不写入,重新 get 拿最新值与 hash 再改。"), n.push("不确定可操作哪些属性时用 list_data_slots 查看(动态组件场景下注册表会增删,以工具返回为准,勿凭旧记忆);不确定某属性字段结构时用 describe_data_slot。"), n.push("修改大对象/数组属性优先用 edit_data_slot 增量 patch(只发改动部分),避免 set 整体重传被 max_tokens 截断导致 JSON 不完整、校验失败。"), n.push("修改属性出错时可用 restore_data_snapshot(path) 回退最近一次。"), n.push("在大数组里按条件筛选元素用 query_data_slot(JSONPath,如 $[?(@.type==\"card\" && @.price<100)]),返回匹配元素的 path/index;定位后再 edit_data_slot 改。"), n.push("找名字记不清的元素用 search_data_slot(支持 substring/regex/fuzzy 模糊搜索)。"), n.push("需要过滤/映射/聚合/批量重写大数组时用 eval_script(沙箱脚本,入参 data);只读探查用 mode=query,批量重写用 mode=transform(返回值经校验后落地)。")), e?.subagent !== !1 && n.push("独立子任务可 spawn_agent 委派(只读工具,过程不占主上下文)。"), e?.subagents?.length) {
 				let t = e.subagents.filter((e) => (e.temperature ?? 0) >= Nv || /规划|创意|设计|方案|brainstorm|plan/i.test(e.description)), r = e.subagents.filter((e) => (e.temperature ?? 0) < Nv && /反思|审查|挑刺|校验|review|critique|reflect/i.test(e.description));
-				n.push("【规划-反思-执行·路由】按任务性质选模式,不要对简单任务过度编排:"), t.length && (n.push(`  · 创作/设计/开放性需求(如"设计主题风格""换个感觉")→ 先调 ${t.map((e) => "use_" + e.id).join("/")} 出 2-3 套方案(高温创意),`), n.push("    不要自己拍板;拿到方案后,若需用户拍板用 request_human_confirmation 弹选项。")), r.length && n.push(`  · 严谨/易错/校验类 → 可先调 ${r.map((e) => "use_" + e.id).join("/")} 反思挑刺(低温审查),据反馈修订。`), n.push("  · 方案定稿后,由你(主 agent)用 edit_window_prop 落地成 JSON(低温度执行 + schema 校验 + 写前确认)。"), n.push("  · 简单/明确任务(如\"标题改红色\")直接执行,不必走规划-反思。");
+				n.push("【规划-反思-执行·路由】按任务性质选模式,不要对简单任务过度编排:"), t.length && (n.push(`  · 创作/设计/开放性需求(如"设计主题风格""换个感觉")→ 先调 ${t.map((e) => "use_" + e.id).join("/")} 出 2-3 套方案(高温创意),`), n.push("    不要自己拍板;拿到方案后,若需用户拍板用 request_human_confirmation 弹选项。")), r.length && n.push(`  · 严谨/易错/校验类 → 可先调 ${r.map((e) => "use_" + e.id).join("/")} 反思挑刺(低温审查),据反馈修订。`), n.push("  · 方案定稿后,由你(主 agent)用 edit_data_slot 落地成 JSON(低温度执行 + schema 校验 + 写前确认)。"), n.push("  · 简单/明确任务(如\"标题改红色\")直接执行,不必走规划-反思。");
 			}
 			return e?.humanConfirm && (n.push("【人工确认·必读】以下情形必须先调 request_human_confirmation 征询用户、拿到答复后再继续,不要自行拍板:"), n.push("  1) 用户让你「给方案/列选项/我来选/挑一个」时:把每个方案作为一个 option,调 request_human_confirmation(question=简述, options=[方案A,方案B,...], recommendation=你推荐的)。不要只回文字罗列方案让用户自己回复——要用工具把选项做成可点选按钮。"), n.push("  2) 需求有歧义/不确定时:调工具问清楚(options 不传则用户答同意或拒绝)。"), n.push("  3) 即将执行高风险不可逆操作(删除/覆盖/批量改动)前:调工具确认。"), n.push("用户在选项里选了哪个,就按那个方案继续;选「拒绝」则停止并询问如何调整。")), n.length && n.unshift("调用工具务必用标准 function calling(工具调用)格式发起,不要在回复正文里输出伪 XML/标签(如 deepseek 的 tool_calls 标签、invoke、function_call、tool_call 等)或 JSON 文本——那不会被识别为工具调用,会被当普通文字,工具不执行。"), n.length ? "## 能力使用提示\n" + n.join("\n") : void 0;
 		}
@@ -16871,7 +16875,7 @@ function fy(e) {
 	};
 }
 function py(e) {
-	return e === "set_window_prop" ? "set" : e === "edit_window_prop" ? "edit" : e === "delete_window_prop" ? "delete" : e === "restore_window_snapshot" ? "restore" : null;
+	return e === "set_data_slot" ? "set" : e === "edit_data_slot" ? "edit" : e === "delete_data_slot" ? "delete" : e === "restore_data_snapshot" ? "restore" : null;
 }
 function my(e) {
 	let t = e.split("."), n = globalThis.window;
@@ -16889,7 +16893,7 @@ function hy(e, t) {
 			if (i) {
 				let n = String(t.args?.path ?? "");
 				e({
-					type: "window_prop_change",
+					type: "data_slot_change",
 					path: n,
 					operation: i,
 					value: n ? my(n) : void 0
@@ -16942,17 +16946,18 @@ function gy(e, r) {
 		} } : void 0,
 		maxBytes: e.vfs?.maxBytes
 	}), m = Sg(), h = Ag(e.memory || ""), g = { current: null }, _ = e.checkpoint, v = _ !== void 0 && _ !== !1, y = v ? qg({
-		windowPaths: (e.windowProps ?? []).map((e) => e.path),
+		slotPaths: (e.dataSlots ?? []).map((e) => e.path),
 		vfsStore: p,
 		todosMw: m,
 		getTodos: () => g.current?.getState?.()?.todos ?? [],
 		messages: f,
 		maxCheckpoints: _ && typeof _ == "object" ? _.maxCheckpoints : void 0
-	}) : null, b = !_ || typeof _ != "object" || _.auto !== !1, x = e.capabilities, S = x?.windowOps !== !1, C = S ? Dv(e.windowProps || [], {
+	}) : null, b = !_ || typeof _ != "object" || _.auto !== !1, x = e.capabilities, S = x?.dataSlotOps !== !1, C = S ? Dv(e.dataSlots || [], {
 		onAudit: e.debug ? (e) => console.log("[page-agent-sdk][window audit]", e) : void 0,
 		maxSnapshots: e.maxSnapshots,
-		onConflict: o
-	}) : [], w = S ? C.controller ?? null : null, T = () => w?.list() ?? e.windowProps ?? [], E = /* @__PURE__ */ new Map(), D = Mv(x, C, kv);
+		onConflict: o,
+		autoLock: e.autoLock
+	}) : [], w = S ? C.controller ?? null : null, T = () => w?.list() ?? e.dataSlots ?? [], E = /* @__PURE__ */ new Map(), D = Mv(x, C, kv);
 	D.forEach((e) => E.set(e.name, "builtin"));
 	let O = [...e.tools || []];
 	O.forEach((e) => E.set(e.name, "user"));
@@ -16960,10 +16965,10 @@ function gy(e, r) {
 	A && E.set(Lg, "builtin");
 	let j = v && y ? [n(async () => {
 		let e = y.list();
-		return e.length ? y.restore() ? `已回退到最近一次正常状态(checkpoint #${e[e.length - 1].id})。对话历史、window 注册属性、vfs、todos 已整体还原。请基于回退后的状态重新判断并继续。` : "回退失败:无可用 checkpoint。" : "无可用 checkpoint,无法回退。";
+		return e.length ? y.restore() ? `已回退到最近一次正常状态(checkpoint #${e[e.length - 1].id})。对话历史、数据槽注册项、vfs、todos 已整体还原。请基于回退后的状态重新判断并继续。` : "回退失败:无可用 checkpoint。" : "无可用 checkpoint,无法回退。";
 	}, {
 		name: "restore_last_checkpoint",
-		description: "回退到最近一次正常状态(整体还原对话历史 + window 注册属性 + vfs + todos)。当本轮操作出错、页面被改坏、或走偏时调用,回到本轮起点重新来过。不传参数即回退最近一次。",
+		description: "回退到最近一次正常状态(整体还原对话历史 + 数据槽注册项 + vfs + todos)。当本轮操作出错、页面被改坏、或走偏时调用,回到本轮起点重新来过。不传参数即回退最近一次。",
 		schema: t.object({}).optional()
 	}), n(async () => {
 		let e = y.list();
@@ -16997,10 +17002,10 @@ function gy(e, r) {
 		allTools: M,
 		debug: e.debug
 	}) : void 0, ae = [
-		"get_window_prop",
-		"get_window_paths",
-		"list_window_props",
-		"describe_window_prop",
+		"get_data_slot",
+		"get_slot_paths",
+		"list_data_slots",
+		"describe_data_slot",
 		"fetch_document"
 	], oe = M.filter((e) => ae.includes(e.name)), se = z ? o_({
 		check: e.verify.check ?? f_({ schemas: () => Object.fromEntries(T().map((e) => [e.path, e.schema])) }),
@@ -17016,7 +17021,7 @@ function gy(e, r) {
 			description: e.description,
 			temperature: e.temperature
 		}))
-	}, S && !!e.windowProps?.length), le = e.onEvent, ue = /* @__PURE__ */ new Set(), de = (e) => {
+	}, S && !!e.dataSlots?.length), le = e.onEvent, ue = /* @__PURE__ */ new Set(), de = (e) => {
 		if (e.type !== "approval_request") {
 			if (le) try {
 				le(e);
@@ -17033,11 +17038,11 @@ function gy(e, r) {
 		...I ? [I_({
 			...B_(e, u.contextWindow),
 			llmInvoke: d,
-			getRegisteredProps: () => T().map((e) => ({
+			getRegisteredSlots: () => T().map((e) => ({
 				path: e.path,
 				description: e.description
 			})),
-			preserveLastToolResults: (e.contextOptions && e.contextOptions.preserveLastToolResults) ?? ["describe_window_prop", "list_window_props"]
+			preserveLastToolResults: (e.contextOptions && e.contextOptions.preserveLastToolResults) ?? ["describe_data_slot", "list_data_slots"]
 		})] : [],
 		...L ? [h] : [],
 		...e.permissions?.length ? [Fg(e.permissions)] : [],
@@ -17064,9 +17069,9 @@ function gy(e, r) {
 		mcpClosers: [],
 		mcpServers: [],
 		checkpoint: y,
-		windowOpsController: w,
+		dataSlotOpsController: w,
 		pendingConflict: i,
-		liveWindowProps: T,
+		liveDataSlots: T,
 		applySnapshot(t) {
 			t.messages?.length && f.push(...t.messages), t.vfs && p.hydrate && p.hydrate(t.vfs), t.todos?.length && m.reset(t.todos), t.memory && !e.memory && h.reset(t.memory);
 		},
@@ -17133,7 +17138,7 @@ function gy(e, r) {
 					name: e.name,
 					description: e.description
 				})),
-				windowProps: T().map((e) => ({
+				dataSlots: T().map((e) => ({
 					path: e.path,
 					description: e.description,
 					schema: e.schema
@@ -17293,15 +17298,15 @@ function _y(e) {
 		restoreLastCheckpoint: () => i.checkpoint?.restore() ?? !1,
 		listCheckpoints: () => i.checkpoint?.list() ?? [],
 		hook: (e) => (i.listeners.add(e), () => i.listeners.delete(e)),
-		addWindowProp: (e) => {
-			if (!i.windowOpsController) {
-				console.warn("[page-agent-sdk] addWindowProp 忽略:windowOps 已关闭(capabilities.windowOps:false)");
+		addDataSlot: (e) => {
+			if (!i.dataSlotOpsController) {
+				console.warn("[page-agent-sdk] addDataSlot 忽略:dataSlotOps 已关闭(capabilities.dataSlotOps:false)");
 				return;
 			}
-			i.windowOpsController.add(e);
+			i.dataSlotOpsController.add(e);
 		},
-		removeWindowProp: (e) => i.windowOpsController ? i.windowOpsController.remove(e) : !1,
-		listWindowProps: () => i.liveWindowProps(),
+		removeDataSlot: (e) => i.dataSlotOpsController ? i.dataSlotOpsController.remove(e) : !1,
+		listDataSlots: () => i.liveDataSlots(),
 		pendingConflict: i.pendingConflict,
 		resolveConflict: (e) => i.resolveConflict(e)
 	};
@@ -17319,4 +17324,4 @@ function vy(e) {
 	});
 }
 //#endregion
-export { z_ as CONTEXT_PRESETS, Xh as ChatDialog, ef as CodePreview, Lg as HUMAN_CONFIRM_TOOL_NAME, nf as MessageContent, S_ as connectMcp, Sl as copyText, bg as createAgent, Ig as createApprovalMiddleware, _y as createChatSdk, qg as createCheckpointManager, Jg as createCheckpointMiddleware, Bg as createHumanConfirmMiddleware, zg as createHumanConfirmTool, ty as createMemoryBackend, ay as createSessionStore, n_ as createSubagentMiddleware, a_ as createSubagentsMiddleware, Pv as createUsageHintsMiddleware, o_ as createVerifyMiddleware, G_ as createVfs, ry as createWebStorageBackend, Dv as createWindowOps, f_ as createWriteBackCheck, Cg as defineSkill, vy as defineTool, jv as defineWindowToolset, hg as detectGarbledToolCall, rg as estimateTokens, y_ as extractText, kv as fetchDocTools, Av as fetchTools, V_ as formatZodIssues, qv as isQuotaError, cv as jpEval, U_ as jsonParseError, ag as offloadPassThroughChars, ig as offloadThresholdChars, L_ as presets, B_ as resolveContextOptions, ng as resolveModelCaps, pv as runSandboxedScript, uv as searchJson, Mv as selectBuiltinTools, R_ as systemPromptHelpers, $ as toolError, xl as useChat, e as z, H_ as zodError };
+export { z_ as CONTEXT_PRESETS, Xh as ChatDialog, ef as CodePreview, Lg as HUMAN_CONFIRM_TOOL_NAME, nf as MessageContent, S_ as connectMcp, Sl as copyText, bg as createAgent, Ig as createApprovalMiddleware, _y as createChatSdk, qg as createCheckpointManager, Jg as createCheckpointMiddleware, Dv as createDataSlotOps, Bg as createHumanConfirmMiddleware, zg as createHumanConfirmTool, ty as createMemoryBackend, ay as createSessionStore, n_ as createSubagentMiddleware, a_ as createSubagentsMiddleware, Pv as createUsageHintsMiddleware, o_ as createVerifyMiddleware, G_ as createVfs, ry as createWebStorageBackend, f_ as createWriteBackCheck, jv as defineDataSlotToolset, Cg as defineSkill, vy as defineTool, hg as detectGarbledToolCall, rg as estimateTokens, y_ as extractText, kv as fetchDocTools, Av as fetchTools, V_ as formatZodIssues, qv as isQuotaError, cv as jpEval, U_ as jsonParseError, ag as offloadPassThroughChars, ig as offloadThresholdChars, L_ as presets, B_ as resolveContextOptions, ng as resolveModelCaps, pv as runSandboxedScript, uv as searchJson, Mv as selectBuiltinTools, R_ as systemPromptHelpers, $ as toolError, xl as useChat, e as z, H_ as zodError };