@honor-claw/yoyo 2026.7.1-beta.21 → 2026.7.1-beta.22

package/dist/capabilities/remote-file/paths.mjs

@@ -1,38 +1,46 @@
-import { existsSync as e, readdirSync as t } from "node:fs";
-import n from "node:path";
-import r from "node:os";
-import { assertAbsolutePathInput as i, canonicalPathFromExistingAncestor as a, ensureAbsoluteDirectory as o, resolveAbsolutePathForRead as s, resolveAbsolutePathForWrite as c, sanitizeUntrustedFileName as l } from "openclaw/plugin-sdk/security-runtime";
+import { toErrorMessage as e } from "../../utils/error.mjs";
+import { clawLogger as t } from "../../utils/claw-logger.mjs";
+import { existsSync as n, readdirSync as r } from "node:fs";
+import i from "node:path";
+import a from "node:os";
+import { canonicalPathFromExistingAncestor as o, ensureAbsoluteDirectory as s, resolveAbsolutePathForRead as c, resolveAbsolutePathForWrite as l, sanitizeUntrustedFileName as u } from "openclaw/plugin-sdk/security-runtime";
 //#region src/capabilities/remote-file/paths.ts
-var u = n.join(r.homedir(), ".openclaw", "downloads");
-async function d(e) {
+var d = t("capabilities");
+function f(e) {
+	if (!e) throw Error("path is required");
+	if (e.includes("\0")) throw Error("path must not contain NUL bytes");
+	if (!i.isAbsolute(e)) throw Error("path must be absolute");
+}
+var p = i.join(a.homedir(), ".openclaw", "downloads");
+async function m(t) {
 	try {
-		return i(e), { absolutePath: await a((await s(e)).path) };
-	} catch {
-		return {
+		return f(t), { absolutePath: await o((await c(t)).path) };
+	} catch (n) {
+		return d.error("resolve read path failed", n, { localPath: t }), {
 			error: !0,
-			message: "文件不存在或不可读"
+			message: `文件不存在或不可读: ${e(n)}`
 		};
 	}
 }
-async function f(t, n) {
-	let r = t && t.trim().length > 0 ? t : u, a;
+async function h(e, t) {
+	let r = e && e.trim().length > 0 ? e : p, i;
 	try {
-		i(r), a = (await c(r)).path;
+		f(r), i = (await l(r)).path;
 	} catch {
 		return {
 			ok: !1,
 			message: "目标目录路径格式不正确"
 		};
 	}
-	if (n === !1) return e(a) ? {
+	if (t === !1) return n(i) ? {
 		ok: !0,
-		dir: a
+		dir: i
 	} : {
 		ok: !1,
 		message: "目标目录不存在"
 	};
 	try {
-		let e = await o(a);
+		let e = await s(i);
 		return e.ok ? {
 			ok: !0,
 			dir: e.path
@@ -47,19 +55,19 @@ async function f(t, n) {
 		};
 	}
 }
-function p(e, t) {
-	let r = l(e, "download"), i = n.extname(r), a = i ? r.slice(0, -i.length) : r;
-	if (!t.has(r)) return r;
+function g(e, t) {
+	let n = u(e, "download"), r = i.extname(n), a = r ? n.slice(0, -r.length) : n;
+	if (!t.has(n)) return n;
 	let o = 1;
-	for (; t.has(`${a} (${o})${i}`);) o++;
-	return `${a} (${o})${i}`;
+	for (; t.has(`${a} (${o})${r}`);) o++;
+	return `${a} (${o})${r}`;
 }
-function m(e) {
+function _(e) {
 	try {
-		return new Set(t(e));
+		return new Set(r(e));
 	} catch {
 		return /* @__PURE__ */ new Set();
 	}
 }
 //#endregion
-export { u as DEFAULT_DOWNLOAD_DIR, p as nextAvailableName, f as prepareSaveDir, m as readExistingNames, d as resolveReadPath };
+export { p as DEFAULT_DOWNLOAD_DIR, g as nextAvailableName, h as prepareSaveDir, _ as readExistingNames, m as resolveReadPath };

package/dist/messaging/dispatchers/stream/controller.mjs

@@ -7,14 +7,14 @@ import { normalizeAnswerPartial as a, normalizeFinalVisibleText as o } from "../
 import "../../guard/index.mjs";
 import { finishThinking as s, pushStreamDelta as c, pushThinkingDelta as l, pushToolEvent as u, pushToolStatus as d } from "./session.mjs";
 import { captureErrorPayload as f } from "./error.mjs";
-import { resolveAnswerPartialDelta as p, resolveThinkingDelta as m } from "./resolvers.mjs";
-import { buildToolResultEvent as h, buildToolStartEvent as g } from "./tool/event-builder.mjs";
+import { resolveAnswerPartialDelta as p, resolveThinkingDelta as m, rotateAnswerSegment as h } from "./resolvers.mjs";
+import { buildToolResultEvent as g, buildToolStartEvent as _ } from "./tool/event-builder.mjs";
 //#region src/messaging/dispatchers/stream/controller.ts
-var _ = t("dispatcher"), v = "💬";
-function y(e, t) {
+var v = t("dispatcher"), y = "💬";
+function b(e, t) {
 	return e ?? `no-id:${t}`;
 }
-var b = class {
+var x = class {
 	session;
 	includeThinking;
 	includeToolCalls;
@@ -52,8 +52,8 @@ var b = class {
 	}
 	emitToolStart(e) {
 		if (!this.includeToolCalls || !e.name) return;
-		let t = y(e.toolCallId, e.name);
-		this.emittedToolStartKeys.has(t) || (this.emittedToolStartKeys.add(t), u(this.session, g(e)), this.pendingToolKeys.add(t), e.toolCallId && this.flushPendingToolStatus(e.toolCallId), _.debug("tool start emitted", {
+		let t = b(e.toolCallId, e.name);
+		this.emittedToolStartKeys.has(t) || (this.emittedToolStartKeys.add(t), u(this.session, _(e)), this.pendingToolKeys.add(t), e.toolCallId && this.flushPendingToolStatus(e.toolCallId), v.debug("tool start emitted", {
 			sessionKey: this.session.sessionKey,
 			toolName: e.name,
 			hasToolCallId: !!e.toolCallId,
@@ -61,7 +61,7 @@ var b = class {
 		}));
 	}
 	emitToolResult(e) {
-		this.includeToolCalls && (u(this.session, h(e)), this.pendingToolKeys.delete(y(e.toolCallId, e.toolName)), e.toolCallId && this.pendingToolStatus.delete(e.toolCallId), this.pendingToolKeys.size === 0 && this.flushPendingReplyPayloads());
+		this.includeToolCalls && (u(this.session, g(e)), this.pendingToolKeys.delete(b(e.toolCallId, e.toolName)), e.toolCallId && this.pendingToolStatus.delete(e.toolCallId), this.pendingToolKeys.size === 0 && this.flushPendingReplyPayloads());
 	}
 	onToolStart = (e) => {
 		e.phase && e.phase !== "start" || e.name && this.emitToolStart({
@@ -76,7 +76,7 @@ var b = class {
 			this.emitToolResult(t);
 			return;
 		}
-		_.warn("tool result frame skipped, no finished step", {
+		v.warn("tool result frame skipped, no finished step", {
 			sessionKey: this.session.sessionKey,
 			chatId: this.session.chatId,
 			hasToolCallId: !!e,
@@ -132,25 +132,32 @@ var b = class {
 		this.includeThinking && s(this.session);
 	};
 	rescueCommentaryProgress(e) {
-		if (typeof e != "string" || !e.startsWith(v)) return;
+		if (typeof e != "string" || !e.startsWith(y)) return;
 		let t = e.slice(2).trimStart(), n = this.session.answerSnapshot;
 		if (!t || n.startsWith(t)) return;
 		if (this.pendingReplyPayloads.length > 0) {
-			_.warn("commentary rescue skipped: pending reply payloads", {
+			v.warn("commentary rescue skipped: pending reply payloads", {
 				sessionKey: this.session.sessionKey,
 				pending: this.pendingReplyPayloads.length
 			});
 			return;
 		}
 		let r = t.startsWith(n) ? t.slice(n.length) : t;
-		this.session.answerSnapshot = t, c(this.session, r);
+		h(this.session, t), c(this.session, r);
 	}
 	async pushFinalAnswerDiff(e) {
 		if (!e) return;
-		let t = this.session.answerSnapshot;
-		if (t.startsWith(e)) return;
-		let n = e.startsWith(t) ? e.slice(t.length) : e;
-		n && (this.session.answerSnapshot = e, await c(this.session, n));
+		let t = 0;
+		for (let n of [this.session.answerSnapshot, this.session.prevAnswerSnapshot]) if (n) {
+			if (n.startsWith(e)) return;
+			for (let r of [n, n.trim()]) r && e.startsWith(r) && r.length > t && (t = r.length);
+		}
+		t >= e.length || (t === 0 && v.debug("final diff full push, no covered segment", {
+			sessionKey: this.session.sessionKey,
+			textLen: e.length,
+			snapshotLen: this.session.answerSnapshot.length,
+			prevLen: this.session.prevAnswerSnapshot.length
+		}), h(this.session, e), await c(this.session, e.slice(t)));
 	}
 	deliver = async (e, t) => {
 		if (t.kind === "tool") {
@@ -167,7 +174,7 @@ var b = class {
 		}
 	};
 	onError = (t) => {
-		n(this.session.chatId, "reply_error", { error: e(t) }), _.warn("reply dispatcher error", {
+		n(this.session.chatId, "reply_error", { error: e(t) }), v.warn("reply dispatcher error", {
 			sender: this.session.target.deviceId,
 			turnId: this.session.traceInfo.turnId,
 			error: t
@@ -201,4 +208,4 @@ var b = class {
 	}
 };
 //#endregion
-export { b as StreamingController };
+export { x as StreamingController };

package/dist/messaging/dispatchers/stream/resolvers.mjs

@@ -4,21 +4,24 @@ var t = e("dispatcher");
 function n(e, t) {
 	return t.length < e.length || !t.startsWith(e);
 }
-function r(e, r) {
-	if (r.delta) return typeof r.text == "string" ? e.answerSnapshot = r.text : e.answerSnapshot += r.delta, r.delta;
-	if (typeof r.text != "string" || r.text.length === 0) return "";
-	if (r.replace) return t.debug("answer partial dropped: replace frame", {
+function r(e, t) {
+	e.prevAnswerSnapshot = e.answerSnapshot, e.answerSnapshot = t;
+}
+function i(e, i) {
+	if (i.delta) return typeof i.text == "string" ? e.answerSnapshot = i.text : e.answerSnapshot += i.delta, i.delta;
+	if (typeof i.text != "string" || i.text.length === 0) return "";
+	if (i.replace) return t.debug("answer partial dropped: replace frame", {
 		sessionKey: e.sessionKey,
 		chatId: e.chatId,
 		snapshotLen: e.answerSnapshot.length,
-		textLen: r.text.length,
-		textHead: r.text.slice(0, 16)
-	}), e.answerSnapshot = r.text, "";
-	if (n(e.answerSnapshot, r.text)) return e.answerSnapshot = r.text, r.text;
-	let i = r.text.slice(e.answerSnapshot.length);
-	return e.answerSnapshot = r.text, i;
+		textLen: i.text.length,
+		textHead: i.text.slice(0, 16)
+	}), r(e, i.text), "";
+	if (n(e.answerSnapshot, i.text)) return r(e, i.text), i.text;
+	let a = i.text.slice(e.answerSnapshot.length);
+	return e.answerSnapshot = i.text, a;
 }
-function i(e, t) {
+function a(e, t) {
 	let r = t.text ?? "";
 	if (!r) return "";
 	if (t.isReasoningSnapshot) {
@@ -29,4 +32,4 @@ function i(e, t) {
 	return e.thinkingSnapshot += r, r;
 }
 //#endregion
-export { r as resolveAnswerPartialDelta, i as resolveThinkingDelta };
+export { i as resolveAnswerPartialDelta, a as resolveThinkingDelta, r as rotateAnswerSegment };

package/dist/messaging/dispatchers/stream/session.mjs

@@ -26,6 +26,7 @@ function c(e) {
 		silent: e.silent ?? !1,
 		contentGuard: r(),
 		answerSnapshot: "",
+		prevAnswerSnapshot: "",
 		thinkingSnapshot: "",
 		hasPushedAnswerText: !1,
 		hasPushedThinkingText: !1

package/dist/tools/remote-file-upload/helpers.mjs

@@ -1,9 +1,12 @@
-import { resolveReadPath as e } from "../../capabilities/remote-file/paths.mjs";
+import { toErrorMessage as e } from "../../utils/error.mjs";
+import { clawLogger as t } from "../../utils/claw-logger.mjs";
+import { resolveReadPath as n } from "../../capabilities/remote-file/paths.mjs";
 import "../../capabilities/remote-file/index.mjs";
-import t from "node:path";
-import { stat as n } from "node:fs/promises";
+import r from "node:path";
+import { stat as i } from "node:fs/promises";
 //#region src/tools/remote-file-upload/helpers.ts
-function r(e, t) {
+var a = t("tools");
+function o(e, t) {
 	return new Promise((n, r) => {
 		if (t?.aborted) {
 			r(/* @__PURE__ */ Error("aborted"));
@@ -17,48 +20,48 @@ function r(e, t) {
 		t?.addEventListener("abort", a, { once: !0 });
 	});
 }
-function i(e) {
+function s(e) {
 	return !!e.errorInfo;
 }
-async function a(r) {
-	let i = [], a = [];
-	return await Promise.all(r.map(async (r, o) => {
-		let s = await e(r);
-		if ("error" in s) {
-			a.push({
-				index: o,
-				fileName: t.basename(r) || r,
-				reason: s.message
+async function c(t) {
+	let o = [], s = [];
+	return await Promise.all(t.map(async (t, c) => {
+		let l = await n(t);
+		if ("error" in l) {
+			s.push({
+				index: c,
+				fileName: r.basename(t) || t,
+				reason: l.message
 			});
 			return;
 		}
 		try {
-			let e = await n(s.absolutePath);
+			let e = await i(l.absolutePath);
 			if (!e.isFile()) {
-				a.push({
-					index: o,
-					fileName: t.basename(s.absolutePath),
+				s.push({
+					index: c,
+					fileName: r.basename(l.absolutePath),
 					reason: "文件不存在或不可读"
 				});
 				return;
 			}
-			i.push({
-				index: o,
-				fileName: t.basename(s.absolutePath),
+			o.push({
+				index: c,
+				fileName: r.basename(l.absolutePath),
 				fileSize: e.size,
-				absolutePath: s.absolutePath
+				absolutePath: l.absolutePath
 			});
-		} catch {
-			a.push({
-				index: o,
-				fileName: t.basename(s.absolutePath),
-				reason: "文件不存在或不可读"
+		} catch (t) {
+			a.error("preflight stat failed", t, { localPath: l.absolutePath }), s.push({
+				index: c,
+				fileName: r.basename(l.absolutePath),
+				reason: `文件不存在或不可读: ${e(t)}`
 			});
 		}
-	})), i.sort((e, t) => e.index - t.index), {
-		ok: i,
-		failed: a
+	})), o.sort((e, t) => e.index - t.index), {
+		ok: o,
+		failed: s
 	};
 }
 //#endregion
-export { i as isErrorItem, a as preflight, r as sleep };
+export { s as isErrorItem, c as preflight, o as sleep };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@honor-claw/yoyo",
-  "version": "2026.7.1-beta.21",
+  "version": "2026.7.1-beta.22",
   "description": "OpenClaw Honor Yoyo connection plugin",
   "keywords": [
     "ai",

package/skills/yoyo-file-transfer/SKILL.md

@@ -38,7 +38,7 @@ metadata: { "openclaw": { "emoji": "📤", "always": false } }
 
 **已知传哪个文件（路径齐全）+ 目标设备唯一（单台或用户已指定）→ 直接传，不确认、不寒暄。**仅以下信息不全 / 有歧义才追问：
 
-> 设备数量不是 1：多台 connected 且用户未指定 → 按下表「多设备候选」追问；无 connected 设备 → 告知"当前无设备连接"，止步，不得调上传/下载。
+> 设备数量不是 1：多台 connected 且用户未指定 → 按下表「多设备候选」追问；无 connected 设备 → 告知"当前无设备连接"，止步，不得调上传/下载。该校验仅针对需 node_invoke 的远端设备（手机）；PC 为本机直调，不作节点校验。
 
 | 场景 | 话术 |
 |---|---|
@@ -52,11 +52,7 @@ metadata: { "openclaw": { "emoji": "📤", "always": false } }
 
 - 收尾（用户取消时用一句话，其余场景一律走「Summary 模板」表格）：用户取消 → 已取消本次传输。
 
-**发提醒的时机**（上传、下载各提醒一次，不刷屏）：
-
-- **上传提醒**：设备已定向（`nodes_status` 返回后）+ 路径齐全，**调上传工具的同一条消息里先输出提醒、再调工具**——用户在传输开始时看到；轮询/执行过程中不再重复。
-- **下载提醒**：上传成功后，**调下载工具的同一条消息里先输出提醒、再调工具**。上传全失败 → 不调下载、不发下载提醒；跳过上传（已在云侧中转）→ 只发下载提醒。
-- 提醒是「执行过程不展示给用户」的**唯一例外**；仍受「`nodes_status` 返回前不得承诺」约束——设备未定向前不发任何提醒。
+**发提醒的时机**（上传、下载各提醒一次，不刷屏）：具体时机和话术在各方向 reference 的对应步骤里，以 reference 为准。
 
 ## 轮询契约（task-result-query）
 

package/skills/yoyo-file-transfer/references/pc-to-phone.md

@@ -37,6 +37,8 @@ PC 源端用户在 PC。三种情况：
 - 多个 connected 且无法区分 → 按 SKILL「追问话术·多设备候选」询问用户
 - 无 connected 设备 → 告知"当前无设备连接"，止步，不得调上传
 
+此校验仅针对目标手机；源端 PC 即当前会话所在的本机 openclaw，上传走本地直调，**不要求 nodes_status 中存在 connected 的 PC 节点**。
+
 ### 步骤 3：源端上传（PC 直调，同步）
 
 **源端 PC：本地直调 `remote_file_upload`，`execute` 同步返回即完成，不轮询。**
@@ -56,7 +58,9 @@ PC 源端用户在 PC。三种情况：
 | `totalCount` / `successCount` / `failCount` | 总数 / 成功数 / 失败数 |
 | `errorMessage?` | 整批级异常时 |
 
-上传出参中成功项的 `fileId`、`accessUrl`、`fileName`、`accessExpireTime` 留作步骤 4 下载入参。**调 `remote_file_upload` 前按 SKILL「提醒话术·时机」输出上传提醒**（同条消息先提醒再调工具；PC 直调同步返回快，提醒仍要在调用前发出）。本方向发送端是 PC（本机 openclaw），上传提醒固定为"发送端（PC）文件上传中，请勿发送新指令，否则会中断传输。"。上传全失败 → 不下载直接报；部分成功 → 只下载成功项。
+上传出参中成功项的 `fileId`、`accessUrl`、`fileName`、`accessExpireTime` 留作步骤 4 下载入参。上传全失败 → 不下载直接报；部分成功 → 只下载成功项。
+
+**上传提醒**：调 `remote_file_upload` 前按 SKILL「提醒话术·时机」输出上传提醒（同条消息先提醒再调工具；PC 直调同步返回快，提醒仍要在调用前发出）。本方向发送端是 PC（本机 openclaw），上传提醒固定为"发送端（PC）文件上传中，请勿发送新指令，否则会中断传输。"。
 
 ### 步骤 4：目标端下载（手机 node_invoke + 轮询）
 
@@ -98,7 +102,9 @@ PC 源端用户在 PC。三种情况：
    ❌ 错:  files: { fileId, accessUrl, fileName, ... }                             // 裸对象
    ```
 
-   **字段来源（调 `node_invoke` 前）**：`fileId`/`accessUrl`/`fileName`/`accessExpireTime` 原样取步骤 3 upload 出参对应成功项，不得编造/丢失。按 SKILL「提醒话术·时机」先输出下载提醒（同条消息先提醒再调工具），轮询过程中不再重复。本方向目标端是手机，下载提醒为"目标端（{目标手机 nodeName}）文件下载中，请勿发送新指令，否则会中断传输。"，`nodeName` 取步骤 2 中选中目标手机的 `nodeName`。
+   **字段来源（调 `node_invoke` 前）**：`fileId`/`accessUrl`/`fileName`/`accessExpireTime` 原样取步骤 3 upload 出参对应成功项，不得编造/丢失。
+
+   **下载提醒**：按 SKILL「提醒话术·时机」先输出下载提醒（同条消息先提醒再调工具），轮询过程中不再重复。本方向目标端是手机，下载提醒为"目标端（{目标手机 nodeName}）文件下载中，请勿发送新指令，否则会中断传输。"，`nodeName` 取步骤 2 中选中目标手机的 `nodeName`。
 2. **查进度**：反复 `node_invoke({ nodeId, name:"task-result-query", params:{ task_id } })`，看顶层 `isFinal`——`false` → 继续轮询；`true` → 停，取 `files[]`。**轮询契约（isFinal 判定 / 1-3 秒节奏 / 300 次超限 / 严禁自行推测结论）见 SKILL「轮询契约」，此处不重复**。
 3. **拿结果**：`isFinal:true` 停止 → `files[]` 每文件终态，顶层带 `successCount`/`failCount`，整批级异常在 `errorMessage`
 

package/skills/yoyo-file-transfer/references/phone-to-pc.md

@@ -29,6 +29,8 @@ description: 手机 → PC 方向的完整执行流程。源端手机 node_invok
 - 多个 connected 且无法区分 → 询问用户
 - 无 connected 设备 → 告知"当前无设备连接"，止步，不得先调上传
 
+此校验仅针对源手机；目标端 PC 即当前会话所在的本机 openclaw，下载走本地直调，**不要求 nodes_status 中存在 connected 的 PC 节点**，不得因 nodes_status 无 PC 节点而中止。
+
 ### 步骤 2：拿源端路径
 
 按用户是否给出源手机完整路径，分两支拿 `filePaths`（手机路径形如 `/storage/emulated/0/...`）：
@@ -109,7 +111,9 @@ description: 手机 → PC 方向的完整执行流程。源端手机 node_invok
 | `fileSize` | 文件大小 |
 | `failReason` | `FAILED` / `CANCELLED` 必带 |
 
-上传出参中成功项的 `fileId`、`accessUrl`、`fileName` 留作步骤 4 下载入参。**派活 `remote_file_upload` 前按 SKILL「提醒话术·时机」输出上传提醒**（同条消息先提醒再调工具），轮询过程中不再重复。本方向发送端是手机，上传提醒为"发送端（{源手机 nodeName}）文件上传中，请勿发送新指令，否则会中断传输。"，`nodeName` 取步骤 1 中选中源手机的 `nodeName`。上传全失败 → 不下载直接报；部分成功 → 只下载成功项。
+上传出参中成功项的 `fileId`、`accessUrl`、`fileName` 留作步骤 4 下载入参。上传全失败 → 不下载直接报；部分成功 → 只下载成功项。
+
+**上传提醒**：派活 `remote_file_upload` 前按 SKILL「提醒话术·时机」输出上传提醒（同条消息先提醒再调工具），轮询过程中不再重复。本方向发送端是手机，上传提醒为"发送端（{源手机 nodeName}）文件上传中，请勿发送新指令，否则会中断传输。"，`nodeName` 取步骤 1 中选中源手机的 `nodeName`。
 
 ### 步骤 4：目标端下载（PC 直调，同步）
 
@@ -131,7 +135,9 @@ description: 手机 → PC 方向的完整执行流程。源端手机 node_invok
 | `totalCount` / `successCount` / `failCount` | 总数 / 成功数 / 失败数 |
 | `errorMessage?` | 整批级异常时 |
 
-**字段来源（调 `remote_file_download` 前）**：`files[]` 每项的 `fileId`/`accessUrl`/`fileName` 均原样取源端 upload 出参对应成功项，不得编造/丢失。按 SKILL「提醒话术·时机」先输出下载提醒（同条消息先提醒再调工具；PC 直调同步返回快，提醒仍要在调用前发出）。本方向目标端是 PC（本机 openclaw），下载提醒固定为"目标端（PC）文件下载中，请勿发送新指令，否则会中断传输。"。
+**字段来源（调 `remote_file_download` 前）**：`files[]` 每项的 `fileId`/`accessUrl`/`fileName` 均原样取源端 upload 出参对应成功项，不得编造/丢失。
+
+**下载提醒**：按 SKILL「提醒话术·时机」先输出下载提醒（同条消息先提醒再调工具；PC 直调同步返回快，提醒仍要在调用前发出）。本方向目标端是 PC（本机 openclaw），下载提醒固定为"目标端（PC）文件下载中，请勿发送新指令，否则会中断传输。"。
 
 **saveDir**：用户指定 → 传 `saveDir`（PC 插件可创建任意目录）；未指定 → 不传，默认 `~/.openclaw/downloads`，不追问保存位置。