dsh-crwu-workbench 0.0.13 → 0.0.14

package/lib/index.js

@@ -229,7 +229,7 @@ const PLUGIN_INJECT = [
 * 还会让打包器的 JSON 插件成为隐式依赖。代价是升版本时要同时改这里 ——
 * `tests/unit/host-package.test.mjs` 有一条断言盯着它必须等于 `package.json` 的 version。
 */
-const PLUGIN_VERSION = "0.0.13";
+const PLUGIN_VERSION = "0.0.14";
 /**
 * `ping` / `boot` 应答里的版本指纹，形如 `pkg-0.0.5`。
 *
@@ -538,20 +538,15 @@ function workspaceView(state) {
 //#endregion
 //#region src/host/environment/manifest.ts
 /**
-* 环境域的取值收窄与 shell 引用。
+* 环境域的取值收窄。
 *
 * 2026-09-25 之前这里还住着「远程清单拉取与归一」：一份放在只读 OSS 上的 JSON 可以远程改写
 * 员工机器上认哪些二进制、装到哪儿。整条只读依赖下掉后它已删除 —— 现在清单只有内置一份
 * （`manifest-default.ts`），外部输入只剩 YAML（由 `config/yaml.ts` 校验）。
 *
-* 留着这个文件是因为两个纯函数还被别处用着，且都属于「环境值怎么进 shell / 怎么收窄」这一件事。
+* 原来的 `quoteArg`（POSIX-only 引用）已经删除：平台引用只有一个出口，
+* 就是 `platform/shell.ts` 的 `shellQuote` —— 留着第二个引用函数就等于留着第二条绕过 Windows 的路。
 */
-/** 单引号安全引用；需要时包一层 shell 引用，避免清单地址里的特殊字符被解释。 */
-function quoteArg(value) {
-	const raw = String(value);
-	if (raw.length > 0 && /^[A-Za-z0-9_@%+=:,./-]+$/.test(raw)) return raw;
-	return `'${raw.split("'").join("'\\''")}'`;
-}
 function asRecord$1(value) {
 	return value !== null && typeof value === "object" ? value : {};
 }
@@ -927,10 +922,165 @@ const AUDIT_BINARIES = [
 const TOOL_TEXT_MAX = 8e3;
 /** 知识库材料的落地目录名（在案例目录内）。 */
 const CASE_KNOWLEDGE_DIR = "knowledge";
+/** 知识库下载清单的文件名（落在 `knowledge/` 下，与下载正文同级）。 */
+const KB_MANIFEST_FILE = ".crwu-manifest.json";
+//#endregion
+//#region src/shared/utils/local-path.ts
+/**
+* **本地展示路径**的纯函数适配器（不引用 `node:path`）。
+*
+* ## 为什么需要它
+*
+* Host 与 Client 都要算「案例目录」「文件名」这类**展示路径**，而共享层不能引入 Node 模块
+* （Client 产物是要进浏览器的）。于是历史实现各处都用 `/` 硬拼，在 Windows 上产生三类错误：
+*
+* 1. **拼接**：`C:\Work` + `/` + `S1` 得到 `C:\Work/S1`，进 shell（PowerShell 的 `-Path`）
+*    与进提示词（模型照着写命令）都是混用分隔符；
+* 2. **取末段**：`'C:\\Work\\S1'.split('/')` 得到整串，界面上的案例名变成一整条路径；
+* 3. **裁剪**：`replace(/\/+$/, '')` 对 `C:\Work\` 无效；对 `\\server\share\` 稍有不慎就裁成
+*    无法解析的 `\\server`。
+*
+* ## 边界（改这个文件前先读）
+*
+* - 这里处理的是**本地路径**：盘符、UNC、POSIX 根。**OSS object key 永远用 `/`**，
+*   不属于这里（见 `host/oss/ops.ts` 里 `objectKey` 的命名）。
+* - **安全性判断不要用这里的函数**：`..`、符号链接、Windows 盘符大小写都会让字符串比较失效，
+*   父目录/子目录判定一律走 `ctx.fs.contains`（后端 realpath 之后比较）。
+*   这里只负责「拼一条给人看、给命令用的路径」。
+* - `joinLocalPath` 对**不受信任的片段**是拒绝而不是清洗：绝对路径、`..` 片段都抛错。
+*   静默清洗会让调用方以为拿到了一条安全路径（最危险的形态）。
+*/
+/**
+* 盘符**风格**：`C:\` / `C:/`，也接受裸 `C:`。
+*
+* `C:` 是「盘符相对路径」（这个盘上的当前目录），它**不是**绝对路径 —— 风格与绝对必须分开判，
+* 见 `isAbsoluteLocalPath`。
+*/
+const DRIVE_STYLE = /^[A-Za-z]:([\\/]|$)/;
+/** 盘符**绝对**：盘符后必须有分隔符（`C:\` / `C:/`）。裸 `C:` 不算。 */
+const DRIVE_ROOTED = /^[A-Za-z]:[\\/]/;
+/** UNC / 双分隔符开头：`\\server\share` 或 `//server/share`。 */
+const UNC = /^[\\/]{2}[^\\/]/;
+/** 这个字符串看起来是 Windows 风格路径（盘符或 UNC）。**不表示它是绝对路径。** */
+function isWindowsStylePath(value) {
+	const raw = text(value);
+	return DRIVE_STYLE.test(raw) || UNC.test(raw);
+}
+/**
+* 是否是绝对本地路径（POSIX `/…`、Windows 盘符根、UNC）。
+*
+* **裸 `C:` 不是绝对路径**（2026-09-28 复查修）：早先这里复用了「Windows 风格」的判断，
+* 于是 `requireCaseDir('C:')` 会把盘符相对路径当绝对路径放行 —— 案例目录随后随进程 cwd 漂移，
+* 产物落点不可预测。`C:` 与 `C:\` 是完全不同的位置，两条正则不能共用。
+*/
+function isAbsoluteLocalPath(value) {
+	const raw = text(value);
+	return raw.startsWith("/") || DRIVE_ROOTED.test(raw) || UNC.test(raw);
+}
+/**
+* 去掉尾部路径分隔符，但**保留根**：
+*
+* - `'/work/'` → `'/work'`；`'/'` → `'/'`；
+* - `'C:\\Work\\'` → `'C:\\Work'`；`'C:\\'` → `'C:\\'`（裁成 `'C:'` 会变成「盘符相对路径」）；
+* - `'\\\\server\\share\\'` → `'\\\\server\\share'`；
+*   `'\\\\server\\'` → `'\\\\server\\'`（裁掉尾部分隔符就只剩服务器名，不是一个可解析的路径）。
+*/
+function trimTrailingSeparators(value) {
+	const raw = text(value);
+	if (raw === "") return "";
+	if (/^\/+$/.test(raw)) return "/";
+	if (/^[A-Za-z]:[\\/]$/.test(raw)) return raw;
+	if (/^[\\/]{2}[^\\/]+[\\/]$/.test(raw)) return raw;
+	let end = raw.length;
+	while (end > 0 && (raw[end - 1] === "/" || raw[end - 1] === "\\")) end -= 1;
+	return end === 0 ? raw : raw.slice(0, end);
+}
+/** 该路径风格用哪个分隔符；非 Windows 风格一律 `/`。 */
+function localSeparator(value) {
+	return isWindowsStylePath(value) ? "\\" : "/";
+}
+/**
+* `child` 是不是 `parent` 本身或它的后代（**仅供展示层的匹配**）。
+*
+* 为什么需要：`WorkspaceEntry` 之间可能互相嵌套（一个工作空间是另一个的子目录），
+* 界面要选**最长**的那个；历史实现写的是 `child.startsWith(parent + '/')`，
+* 在 Windows 上既漏（分隔符是 `\`）又不区分大小写（Windows 路径不区分）。
+*
+* **这不是安全边界**：`..`、符号链接、8.3 短名都会让它判断错 ——
+* 任何「能不能读写这个目录」的判断都必须走 `ctx.fs.contains`（后端 realpath 之后比较）。
+*/
+function isLocalPathUnder(child, parent) {
+	const base = trimTrailingSeparators(parent);
+	if (base === "") return false;
+	const target = trimTrailingSeparators(child);
+	if (target === "") return false;
+	const fold = isWindowsStylePath(base) ? (value) => value.toLowerCase() : (value) => value;
+	const left = fold(target);
+	const right = fold(base);
+	if (left === right) return true;
+	if (/[\\/]$/.test(base)) return left.startsWith(right);
+	return left.startsWith(`${right}/`) || left.startsWith(`${right}\\`);
+}
+/** 一个片段是不是 `..`（只看整段，不看 `a..b` 这种文件名）。 */
+function isParentSegment(segment) {
+	return segment.split(/[\\/]+/).some((part) => part === "..");
+}
+/**
+* 拼接一条本地路径：分隔符随 `root` 的风格。
+*
+* - `joinLocalPath('C:\\Work', 'a', 'b')` → `'C:\\Work\\a\\b'`
+* - `joinLocalPath('/work', 'a', 'b')` → `'/work/a/b'`
+* - `joinLocalPath('/work/', 'a')` → `'/work/a'`（根上的尾分隔符不产生双斜杠）
+*
+* **拒绝**（抛 `RangeError`）而不是清洗：
+* - 片段是绝对路径（`/x`、`C:\x`、`\\server\x`）—— 那会静默替换掉整条路径；
+* - 片段含 `..` 整段 —— 那会静默越出调用方以为的目录。
+*
+* 空片段（`''`）跳过；片段内部的另一种分隔符会被规范成目标分隔符。
+*
+* 裸盘符根（`'C:'`）会被规范成 `'C:\\'` —— 「往 `C:` 后面接一段」在 Windows 上的实际含义
+* 就是该盘的根，而不是「这个盘上的当前目录」；要判「是不是绝对路径」用 `isAbsoluteLocalPath`，
+* 那一条对裸 `C:` 明确返回 `false`。
+*/
+function joinLocalPath(root, ...segments) {
+	const base = trimTrailingSeparators(root);
+	const sep = localSeparator(base);
+	const parts = [];
+	if (base !== "") parts.push(base);
+	for (const segment of segments) {
+		const raw = text(segment);
+		if (raw === "") continue;
+		if (isAbsoluteLocalPath(raw)) throw new RangeError(`joinLocalPath 拒绝绝对路径片段：${raw}`);
+		if (isParentSegment(raw)) throw new RangeError(`joinLocalPath 拒绝含 .. 的片段：${raw}`);
+		const cleaned = raw.replace(/^[\\/]+/, "").replace(/[\\/]+$/, "");
+		if (cleaned === "") continue;
+		parts.push(sep === "\\" ? cleaned.replace(/\//g, "\\") : cleaned.replace(/\\/g, "/"));
+	}
+	if (parts.length === 0) return "";
+	if (parts.length === 1) return parts[0];
+	const [head, ...tail] = parts;
+	const joint = head !== void 0 && /[\\/]$/.test(head) ? "" : sep;
+	return `${head ?? ""}${joint}${tail.join(sep)}`;
+}
+/**
+* 取路径最后一段（目录名 / 文件名）。
+*
+* 两种分隔符、盘符根、UNC 根都能正确处理：`'C:\\Work\\S1\\'` → `'S1'`，
+* `'\\\\server\\share'` → `'share'`，`'/'` → `'/'`，`'C:\\'` → `'C:\\'`。
+*/
+function basenameLocalPath(value) {
+	const trimmed = trimTrailingSeparators(value);
+	if (trimmed === "") return "";
+	if (/^[\\/]+$/.test(trimmed)) return trimmed;
+	if (/^[A-Za-z]:$/.test(trimmed)) return trimmed;
+	if (/^[A-Za-z]:[\\/]$/.test(trimmed)) return trimmed;
+	const parts = trimmed.split(/[\\/]+/).filter(Boolean);
+	return parts.length > 0 ? parts[parts.length - 1] ?? trimmed : trimmed;
+}
 //#endregion
 //#region src/shared/utils/case-dir.ts
 /**
-* 一条报告的**案例目录**：`<工作空间>/<流水号>`。
+* 一条报告的**案例目录**：`<工作空间>/<流水号>`（Windows 上是 `<工作空间>\<流水号>`）。
 *
 * 这是 Host 与 Client 都依赖的唯一约定，所以只在这里定义一次：
 * - Host 的审核提示词拿它告诉审核子代理「本案例目录必须是 …」（`host/audit/prompt.ts`）；
@@ -941,15 +1091,22 @@ const CASE_KNOWLEDGE_DIR = "knowledge";
 * 猜成了 `<工作空间>/cases/<流水号>`：既扫了用户的磁盘，又把材料下到了错的地方。
 * 两处各写一份拼接逻辑就是这种漂移的温床，所以宁可多一个共享模块。
 *
-* 拼接方式与 Host 原实现逐字一致（用 `/` 连接、去掉工作空间末尾的斜杠），
-* 因为提示词里给出的是**跨平台都一样的字符串**，不引入 `node:path` 的平台差异。
-* 任一侧为空时返回空串，调用方据此**不写这一段**（宁可不给，也不给一个半截路径）。
+* **拼接交给 `joinLocalPath`**（2026-09-28 Windows 适配）：分隔符随工作空间的风格走 ——
+* 在 Windows 上硬拼 `/` 会得到 `C:\Work/S1` 这种混用形式，而这条路径既进提示词
+* （模型照着写 PowerShell 命令）又进 `ctx.shell` 的 `workdir`。
+*
+* 任一侧为空、或流水号不是安全的一段（绝对路径 / 含 `..`）时返回空串，
+* 调用方据此**不写这一段**（宁可不给，也不给一个半截或越界的路径）。
 */
 function caseDirOf(workspacePath, seqNo) {
-	const workspace = text(workspacePath).replace(/\/+$/, "");
+	const workspace = text(workspacePath);
 	const seq = text(seqNo).trim();
 	if (workspace === "" || seq === "") return "";
-	return `${workspace}/${seq}`;
+	try {
+		return joinLocalPath(workspace, seq);
+	} catch (error) {
+		return "";
+	}
 }
 //#endregion
 //#region src/host/audit/prompt.ts
@@ -1537,421 +1694,120 @@ function isWindowsPlatform(platform) {
 	return platform.startsWith("win32");
 }
 //#endregion
-//#region src/host/oss/sanitize.ts
+//#region src/host/platform/shell.ts
+/** 一段文本是否可以不加引号直接放进 POSIX 命令（保守白名单，含 `$` 就不行）。 */
+const POSIX_SAFE = /^[A-Za-z0-9_@%+=:,./-]+$/;
 /**
-* OSS 输出脱敏：**唯一**一处把 ossutil 的 stdout / stderr 变成可以给人看（或进日志）的文本。
-*
-* 为什么必须集中一处：`ossutil` 的报错里会带请求 URL（含 `Signature` / `OSSAccessKeyId`）、
-* 甚至完整的临时凭据与 `x-oss-security-token`。这类文本一旦进会话记录或界面，
-* 就等于把凭据写进了可回放的日志。上传路径（`tools/oss.ts`）与环境探测
-* （`environment/probe.ts`）都要用同一份判据 —— 两套正则必然有一天只改了一处。
-*
-* 顺序有讲究：**先按字段名抹值、再抹整条查询串、最后兜底抹 AK 形态**。
-* 反过来会把 URL 整条打成 `?<redacted>`，连"是哪个 bucket"都看不出来。
+* NUL 无法在命令串里表达（两个平台都一样）：原样带进去会截断命令、把后面的内容变成新命令。
+* 所以这里是**明确拒绝**，而不是「尽量拼一个」。
 */
-function sanitizeOssError(value) {
-	return text(value).replace(/(Signature|OSSAccessKeyId|security-token|AccessKeyId|AccessKeySecret|STS\w*Token)=[^&\s"']+/gi, "$1=<redacted>").replace(/(https?:\/\/[^\s"']*?)\?[^\s"']*/gi, "$1?<redacted>").replace(/\bLTAI[A-Za-z0-9]{8,}\b/g, "<redacted-access-key>").slice(0, 600);
+function assertNoNul(value, what) {
+	if (value.includes("\0")) throw new Error(`${what} 含 NUL 字符，无法安全放进 shell 命令`);
+	return value;
+}
+/** 该平台键走哪条方言。`win32-x64` / `win32-arm64` 都是 PowerShell。 */
+function shellDialect(platform) {
+	return isWindowsPlatform(text(platform)) ? "powershell" : "posix";
 }
-//#endregion
-//#region src/host/environment/probe.ts
 /**
-* 把一个参数安全地放进**该平台真实使用的 shell** 的命令串里。
-*
-* POSIX 上就是 `bash -c`：能不加引号就不加（`quoteArg`），需要时用单引号 + `'\''`。
+* 把一个**参数**安全地引用成字面量。
 *
-* **Windows 上是 PowerShell，不是 `cmd.exe`**（DSH 在 Windows 挂 `@deepseek-ai/dsh-pwsh-local`，
-* 整串命令交给 `pwsh -Command`）。所以这里用 PowerShell 的单引号字面量、内部单引号翻倍：
-* 双引号在 PowerShell 里会做 `$` / 反引号插值（路径或 URL 里出现 `$` 就会被当变量展开），
-* 而单引号是纯字面量。cmd 那套 `"…"` + `""` 转义在这里既没必要也不安全。
+* - PowerShell：一律单引号 + 内部单引号翻倍。**不用双引号** —— 双引号会插值 `$` / 反引号，
+*   路径或 URL 里的 `$` 会被当变量展开。
+* - POSIX：能不加引号就不加（可读性），否则单引号 + `'\''`。
 *
-* 以引号开头的命令还需要 PowerShell 的调用运算符 `&` —— 那是**命令位置**的事，由下面的
-* `shellInvoke()` 负责；`shellQuote` 只管「一个参数」。
+* 换行、制表、回车都**安全表示**（单引号内部是字面量，不会变成语句分隔符）；只有 NUL 抛错。
 */
-function shellQuote$1(value, platform) {
-	if (!isWindowsPlatform(text(platform))) return quoteArg(value);
-	return `'${String(value).replace(/'/g, "''")}'`;
+function shellQuote(value, platform) {
+	const raw = assertNoNul(text(value), "参数");
+	if (shellDialect(platform) === "powershell") return `'${raw.replace(/'/g, "''")}'`;
+	if (raw !== "" && POSIX_SAFE.test(raw)) return raw;
+	return `'${raw.replace(/'/g, "'\\''")}'`;
 }
 /**
-* 拼一条**可执行文件 + 参数**的命令串（命令位置）。
-*
-* 为什么不能直接 `${shellQuote(exe, platform)} 参数…`（2026-09-28 修，员工在 Windows 上实测报错）：
-* DSH 在 Windows 挂的执行器是 `@deepseek-ai/dsh-pwsh-local`，它把整条命令作为**一个 argv 元素**
-* 交给 `pwsh -NoLogo -NoProfile -NonInteractive -Command <整串>`（该包自己的 README：*the command
-* string is passed as ONE argv element to `-Command`; PowerShell itself parses the text*）。
-* 也就是说插件拼的是 **PowerShell 脚本**，不是 `cmd.exe` 的批处理行。
-*
-* 后果很硬：**以引号开头的 token 在 PowerShell 里是字符串表达式，不是命令调用**。
-*
-* ```text
-* PS> "C:\…\crwu.exe" "h3yun" "session" "status"
-* 表达式或语句中包含意外的标记"h3yun"。
-* ```
+* 拼一条「可执行文件 + 参数」的命令（**命令位置**）。
 *
-* 员工看到的正是这个：环境页「氚云员工会话」「钉钉认证」两行一起红，因为它们的命令都以包内绝对
-* 路径开头。PowerShell 的调用运算符 `&` 才是「把这段字符串当命令执行」，所以 Windows 上必须写
-* `& 'C:\…\crwu.exe' 'h3yun' 'session' 'status'`。
-*
-* POSIX 上**绝不能**加 `&`：`bash -c` 里它是后台作业，会把前台命令变成异步执行。
-*
-* 所有「第一条 token 是可执行文件」的调用点都必须走这里，而不是自己 join ——
-* `tests/unit/host-shell-fs.test.mjs` 里有静态守卫钉着这一点。
+* Windows 上第一个 token 必须是 `& <引用后的路径>`：`&` 才是「把这段字符串当命令执行」。
+* POSIX 上**绝不能**加 `&` —— 在 `bash -c` 里它是后台作业，会把前台命令变成异步执行。
 */
 function shellInvoke(executable, args, platform) {
-	const parts = [executable, ...args].map((item) => shellQuote$1(item, platform));
-	return isWindowsPlatform(text(platform)) ? `& ${parts.join(" ")}` : parts.join(" ");
+	const parts = [executable, ...args].map((item) => shellQuote(item, platform));
+	return shellDialect(platform) === "powershell" ? `& ${parts.join(" ")}` : parts.join(" ");
+}
+/** 幂等建目录（`mkdir -p` 的等价物）。 */
+function mkdirCommand(path, platform) {
+	return shellDialect(platform) === "powershell" ? `New-Item -ItemType Directory -Force -Path ${shellQuote(path, platform)} | Out-Null` : `mkdir -p ${shellQuote(path, platform)}`;
 }
 /**
-* 包内路径：`<包根>` 与 `<包根>/bin/manifest.json`。
+* 幂等删除一个普通文件。
 *
-* 为什么不用相对层数硬拼：这份代码在源码形态（`src/host/environment/`，距包根 3 层）与构建产物
-* （`lib/`，距包根 1 层）里都跑，由 `packageRootFrom` 按 `package.json` 定位才是唯一可靠的做法。
-* 导出它是为了让测试与实现比对**同一条**路径，而不是各写一份。
+* 「目标本来不存在」是幂等成功，其余失败（权限、占用、父目录错误）必须让退出码非 0：
+* PowerShell 分支用 `-ErrorAction Stop` 让错误终止，并用 `if (Test-Path …)` 把「没有这个文件」
+* 挡在删除之前 —— **不用** `-ErrorAction SilentlyContinue`，那会把真实失败也吞成成功。
 */
-function packageIntegrityPaths() {
-	const packageRoot = packageRootFrom(dirname(fileURLToPath(import.meta.url)));
-	return {
-		packageRoot,
-		manifestPath: packageRoot === "" ? "" : join(packageRoot, "bin", "manifest.json")
-	};
-}
-/** 读包内 `bin/manifest.json` 里某个平台的声明；读不到就返回空表（**不**当成「没有组件」）。 */
-function readBinManifest(raw, platform) {
-	const tools = /* @__PURE__ */ new Map();
-	let parsed;
-	try {
-		parsed = JSON.parse(text(raw));
-	} catch (error) {
-		return {
-			found: false,
-			tools
-		};
-	}
-	const doc = parsed !== null && typeof parsed === "object" ? parsed : {};
-	const platforms = Array.isArray(doc.platforms) ? doc.platforms : [];
-	for (const entry of platforms) {
-		const row = entry !== null && typeof entry === "object" ? entry : {};
-		if (text(row.platform) !== platform) continue;
-		for (const item of Array.isArray(row.tools) ? row.tools : []) {
-			const tool = item !== null && typeof item === "object" ? item : {};
-			const file = text(tool.file);
-			if (file === "") continue;
-			tools.set(text(tool.tool) || file, {
-				file,
-				size: typeof tool.size === "number" && Number.isFinite(tool.size) ? tool.size : 0,
-				sha256: text(tool.sha256),
-				sourceVersion: text(tool.sourceVersion)
-			});
-		}
-		return {
-			found: true,
-			tools
-		};
-	}
-	return {
-		found: false,
-		tools
-	};
+function removeFileCommand(path, platform) {
+	if (shellDialect(platform) !== "powershell") return `rm -f -- ${shellQuote(path, platform)}`;
+	const quoted = shellQuote(path, platform);
+	return `if (Test-Path -LiteralPath ${quoted}) { Remove-Item -LiteralPath ${quoted} -Force -ErrorAction Stop }`;
 }
-/** 「插件包不完整 / 平台不受支持」那一句：三件组件共用，措辞里不许出现「安装命令」。 */
-function packageGapMessage(platform, detail) {
-	return `插件包不完整 / 平台不受支持：${detail}。请重新安装中瑞世联工作台插件，或联系管理员确认插件包是否完整；这些组件由插件按包内绝对路径使用（当前平台 ${platform || "未知"}），不从 PATH 上查找，也不由员工单独配置。`;
+/** 用系统默认程序打开一个文件或 URL。 */
+function openExternalCommand(target, platform) {
+	if (shellDialect(platform) === "powershell") return `Start-Process -FilePath ${shellQuote(target, platform)}`;
+	if (text(platform).startsWith("darwin")) return `open ${shellQuote(target, platform)}`;
+	return `xdg-open ${shellQuote(target, platform)}`;
 }
 /**
-* 检查随包组件：只读文件事实，**一次 shell 都不跑**。
+* 把 stdin 写进系统剪贴板的命令。
 *
-* 判据（三条都来自包内，互相独立）：
-* 1. 当前平台有随包目录（否则「平台不受支持」）；
-* 2. 文件真的在 `bin/<平台>/` 里；
-* 3. 字节数与包内 `bin/manifest.json` 一致（运行残留 / 安装不完整都会在这里露出来）。
+* 内容**只走 stdin**、永远不作为参数（提示词里的引号、反引号、`$` 拼进命令行会被解释）。
 */
-async function probePackageIntegrity(ctx, manifest, platform, options = {}) {
-	const { packageRoot, manifestPath } = packageIntegrityPaths();
-	const supported = binPlatformDir(platform) !== "";
-	const fs = fileSystem(ctx);
-	let manifestFound = false;
-	const declared = /* @__PURE__ */ new Map();
-	if (fs !== void 0 && manifestPath !== "") try {
-		const parsed = readBinManifest(await fs.readText(await resolveTarget(ctx, manifestPath)), platform);
-		manifestFound = parsed.found;
-		for (const [name, tool] of parsed.tools) declared.set(name, tool);
-	} catch (error) {
-		manifestFound = false;
-	}
-	const tools = [];
-	for (const spec of manifest.packaged) tools.push(await checkPackagedTool(ctx, spec, platform, {
-		supported,
-		manifestFound,
-		manifestPath,
-		declared
-	}));
-	const failed = tools.filter((tool) => !tool.ok);
-	const ok = failed.length === 0;
-	return {
-		ok,
-		supported,
-		platform,
-		packageRoot,
-		manifestPath,
-		manifestFound,
-		tools,
-		note: ok ? `插件内置组件 ${String(tools.length)}/${String(tools.length)} 完整：字节数与包内 bin/manifest.json 一致（sha256 见明细，不在自检里重算）。` : failed[0]?.reason ?? packageGapMessage(platform, "插件内置组件不可用")
-	};
-}
-/** 单个组件：存在性 + 字节数；理由必须能分辨「平台不受支持」「缺文件」「清单读不到」「字节数不一致」。 */
-async function checkPackagedTool(ctx, spec, platform, facts) {
-	const file = binaryFileName(spec.name, platform);
-	const entry = facts.declared.get(spec.name);
-	const base = {
-		name: spec.name,
-		label: spec.label,
-		file,
-		present: false,
-		sizeBytes: 0,
-		manifestSizeBytes: entry?.size ?? 0,
-		sha256: entry?.sha256 ?? "",
-		expectedVersion: spec.expectedVersion,
-		note: spec.note,
-		ok: false,
-		reason: ""
-	};
-	if (!facts.supported) return {
-		...base,
-		reason: packageGapMessage(platform, "当前平台没有随包发布的组件目录")
-	};
-	const bundled = bundledBinaryPath(platform, spec.name);
-	if (bundled === "") return {
-		...base,
-		reason: packageGapMessage(platform, "当前平台没有随包发布的组件目录")
-	};
-	const fs = fileSystem(ctx);
-	if (fs === void 0) return {
-		...base,
-		reason: `无法核对插件包完整性：Host 文件服务不可用（包内路径 ${bundled}）`
-	};
-	let info;
-	try {
-		info = await fs.stat(await resolveTarget(ctx, bundled));
-	} catch (error) {
-		info = void 0;
-	}
-	if (info?.type !== "file") return {
-		...base,
-		reason: `插件包不完整：包内缺少 ${bundled}`
-	};
-	const sizeBytes = typeof info.size === "number" && Number.isFinite(info.size) ? info.size : 0;
-	const present = {
-		...base,
-		present: true,
-		sizeBytes
-	};
-	if (!facts.manifestFound) return {
-		...present,
-		reason: `插件包不完整：读不到包内清单 ${facts.manifestPath}，无法核对 ${file} 的字节数`
-	};
-	if (present.manifestSizeBytes === 0) return {
-		...present,
-		reason: `插件包不完整：包内清单里没有 ${spec.name} 的字节数，无法核对`
-	};
-	if (sizeBytes !== present.manifestSizeBytes) return {
-		...present,
-		reason: `插件包不完整：包内 ${file} 的字节数与随包清单不一致（磁盘 ${String(sizeBytes)} / 清单 ${String(present.manifestSizeBytes)}，可能是安装不完整或运行残留）`
-	};
-	return {
-		...present,
-		ok: true,
-		reason: ""
-	};
-}
-/** 定位失败时给用户的那句话。文案里不许出现安装指引：这个二进制随插件发布。 */
-function ossutilMissingMessage(lookup) {
-	return lookup.error === "" ? packageGapMessage("", "没有找到随包发布的 ossutil") : lookup.error;
+function clipboardCommand(platform) {
+	if (text(platform).startsWith("darwin")) return "pbcopy";
+	if (shellDialect(platform) === "powershell") return "clip";
+	return "xclip -selection clipboard 2>/dev/null || xsel -b";
 }
 /**
-* 解析包内 ossutil 的绝对路径。
+* 探测执行世界主目录的命令。
 *
-* **没有 PATH 回退**（2026-09-25 口径）：回退会让模型在某台机器上看到 `command not found`，
-* 下一步自然就是 `which` / `command -v` / 去搜可执行文件 —— 正是本次改造要消灭的行为。
-* `oss` 参数保留是为了不改调用方签名：清单里的 `ossutil` 命令名已经不再参与解析。
+* Windows 只用 PowerShell 自己的环境变量：`python3` / `printf` 在 Windows 上都不保证存在，
+* 拿它们当探针会把「插件包装配」变成「系统装没装 Python」。POSIX 侧同理不依赖 `python3`。
 */
-async function resolveOssutil(ctx, oss, platform, options = {}) {
-	const bundled = bundledBinaryPath(platform, "ossutil");
-	if (bundled === "") return {
-		path: "",
-		error: packageGapMessage(platform, "当前平台没有随包发布的 ossutil")
-	};
-	const fs = fileSystem(ctx);
-	if (fs === void 0) return {
-		path: "",
-		error: `无法核对插件包完整性：Host 文件服务不可用（包内路径 ${bundled}）`
-	};
-	try {
-		if ((await fs.stat(await resolveTarget(ctx, bundled)))?.type === "file") return {
-			path: bundled,
-			error: ""
-		};
-	} catch (error) {}
-	return {
-		path: "",
-		error: packageGapMessage(platform, `包内缺少 ${bundled}`)
-	};
+function homeProbeCommand(platform) {
+	return shellDialect(platform) === "powershell" ? "Write-Output $env:USERPROFILE" : "printf %s \"$HOME\"";
 }
 /**
-* 一次真实 OSS 只读验证的请求形状（**完全由受信配置推出，模型与员工都不能提交**）。
+* 把普通文件权限收紧到「仅属主可读写」。
 *
-* 导出它有两个目的：① 单测可以对命令字符串逐字断言；② 开发者诊断里能显示"验的是哪个目标"，
-* 而目标里**不含任何凭据**。
+* Windows 没有 POSIX 权限位、也没有 `chmod` 命令，返回空串表示**这一项不适用**（凭据文件在
+* 用户配置目录内，由用户 ACL 保护）。调用方据此上报「继承当前账户 ACL」而不是伪造一次成功。
 */
-function ossProbeTarget(oss) {
-	const prefix = oss.prefix.replace(/^\/+|\/+$/g, "");
-	const path = prefix === "" ? "" : `${prefix}/`;
-	return {
-		bucket: oss.bucket,
-		prefix: path,
-		target: `oss://${oss.bucket}/${path}`
-	};
+function privateFileCommand(path, platform) {
+	if (shellDialect(platform) === "powershell") return "";
+	return `chmod 600 ${shellQuote(path, platform)}`;
 }
 /**
-* 端到端唯一的 OSS 真实验证：**用包内 ossutil 对配置好的 bucket + 业务前缀做一次只读列举**。
+* 读取一个文件的 POSIX 权限模式（八进制，例如 `600`）。
 *
-* 判据（2026-09-26 收紧）：
-* - 必须打**业务前缀**（`oss://<bucket>/<prefix>/`）而不是桶根：只验桶根证明不了"能写交付件"；
-* - `--limited-num 1`：只要一次请求，空目录也算成功（判据是"请求成功且凭据有权访问该目标"，
-*   不是"一定列到对象"）；
-* - 只用只读 `ls`：**不**为了验证去上传、删除或创建对象；
-* - 只认包内绝对路径（`resolveOssutil`），不回退 PATH、不要员工装 ossutil；
-* - 所有 stdout / stderr 在返回或写日志之前过 `sanitizeOssError`（AK / STS / Signature / 签名 URL）。
+* **为什么需要它**：`chmod` 在个别文件系统（网络盘、被容器/虚拟化层挡住的挂载点）上会
+* **静默无效** —— 退出码 0 但模式没变。只信退出码就把「命令跑过了」说成「权限已验证」，
+* 而 0600 正是凭据文件的安全边界。所以收紧之后要回读一次。
 *
-* 归因顺序是刻意的：**先看命令有没有跑起来**（沙箱 / 审批 / 包内缺文件），
-* 再看 HTTP / 服务端错误码。把"命令根本没跑起来"说成"AK 无效"会把员工指去换一份好密钥。
-*/
-async function probeOss(ctx, oss, platform, options = {}) {
-	const { target, prefix } = ossProbeTarget(oss);
-	const base = {
-		id: "oss",
-		label: "阿里云 OSS（AK 权限）",
-		required: true,
-		ok: false,
-		state: "",
-		detail: "",
-		errorKind: "",
-		target
-	};
-	if (!oss.enabled) return {
-		...base,
-		ok: false,
-		state: "未启用",
-		errorKind: "config",
-		detail: "清单 oss.enabled 为 false"
-	};
-	if (oss.bucket === "") return {
-		...base,
-		ok: false,
-		state: "缺 bucket",
-		errorKind: "config",
-		detail: "清单 oss.bucket 为空（由管理员在部署配置里设置）"
-	};
-	const lookup = await resolveOssutil(ctx, oss, platform, options);
-	if (lookup.path === "") return {
-		...base,
-		ok: false,
-		state: "插件包不完整 / 平台不受支持",
-		errorKind: "infrastructure",
-		detail: lookup.error
-	};
-	const ossutil = lookup.path;
-	const run = await runShell(ctx, buildOssProbeCommand(oss, ossutil, platform), {
-		timeoutMs: 6e4,
-		...options.workdir === void 0 ? {} : { workdir: options.workdir }
-	});
-	if (shellUnavailable(run)) return {
-		...base,
-		ok: false,
-		state: "无法探测",
-		errorKind: "infrastructure",
-		detail: sanitizeOssError(text(run.error) || text(run.stderr) || "探测命令没有执行")
-	};
-	const verdict = classifyOssFailure(run.ok, sanitizeOssError(text(run.stderr) || text(run.stdout) || text(run.error)));
-	if (run.ok) return {
-		...base,
-		ok: true,
-		state: "AK 正常",
-		errorKind: "",
-		detail: `已验证可访问 ${target}${oss.endpoint === "" ? "" : ` @ ${oss.endpoint}`}（只读列举，空目录也算通过）`
-	};
-	return {
-		...base,
-		ok: false,
-		state: verdict.state,
-		errorKind: verdict.kind,
-		detail: verdict.detail
-	};
-}
-/**
-* 探测命令：**只读 `ls` + 业务前缀 + `--limited-num 1`**。
-*
-* `oss.probeCommand` 仍被尊重（部署方可以换成等价的只读命令），但 `{prefix}` 占位符与默认分支
-* 都指向业务前缀 —— 旧默认（列桶根）证明不了"能写交付件"。跑之前不检查、跑之后才看错误码，
-* 所以它必须自身只读。
+* GNU 与 BSD 的 `stat` 参数不同，这个分歧只在这里出现一次：
+* `stat -c %a`（GNU/Linux）与 `stat -f %Lp`（BSD/macOS）。Windows 没有 POSIX 模式位，返回空串。
 */
-function buildOssProbeCommand(oss, ossutil, platform) {
-	const { bucket, prefix, target } = ossProbeTarget(oss);
-	const executable = shellInvoke(ossutil, [], platform);
-	if (oss.probeCommand !== "") return oss.probeCommand.split("{ossutil}").join(executable).split("{bucket}").join(bucket).split("{prefix}").join(prefix).split("{target}").join(target).split("{endpoint}").join(oss.endpoint);
-	return shellInvoke(ossutil, [
-		"ls",
-		target,
-		...oss.endpoint === "" ? [] : ["--endpoint", oss.endpoint],
-		"--limited-num",
-		"1",
-		...oss.extraArgs
-	], platform);
+function readFileModeCommand(path, platform) {
+	if (shellDialect(platform) === "powershell") return "";
+	const quoted = shellQuote(path, platform);
+	return text(platform).startsWith("darwin") ? `stat -f %Lp ${quoted}` : `stat -c %a ${quoted}`;
 }
 /**
-* OSS 失败 → 人话归因。
+* 该平台用哪种机制保护凭据文件 —— 与 `privateFileCommand` **同一判据**。
 *
-* 四类分开（用户口径：错误要"按凭据、权限、配置、网络分别给人话提示"）：
-* - `credential`：`InvalidAccessKeyId` / `SignatureDoesNotMatch` / `InvalidSecurityToken` / `AccessKeyId is disabled`
-*   → 员工重填 AK；
-* - `permission`：`AccessDenied` / `Forbidden` / `no permission`
-*   → 凭据有效但没有这个 Bucket/Prefix 的权限，找管理员开权限；
-* - `config`：`NoSuchBucket` / `InvalidBucketName` / `Endpoint` 解析失败 / `unknown endpoint`
-*   → 部署配置错了，找管理员；
-* - `infrastructure`：上面都不匹配（网络、DNS、超时、TLS、上游 5xx）
-*   → 稍后重试 / 找管理员排查连通性，**不是** AK 的问题。
+* 拆出来是因为调用方要把「谁在负责」写进结构化的权限结论（`CredentialPermission.mechanism`），
+* 而不是只看命令字符串空不空。
 */
-function classifyOssFailure(ok, raw) {
-	const detail = clampOssText(raw);
-	if (ok) return {
-		state: "AK 正常",
-		kind: "",
-		detail
-	};
-	const lower = raw.toLowerCase();
-	if (/invalidaccesskeyid|signaturedoesnotmatch|invalidsaccesskeyid|invalidsecuritytoken|accesskeyid is disabled|accesskeyidisdisabled|invalidaccesskeyid\.notfound/i.test(raw)) return {
-		state: "AccessKey 无效",
-		kind: "credential",
-		detail: detail || "OSS 认为这份 AccessKey 无效或已禁用"
-	};
-	if (/accessdenied|forbidden|no permission|denied/i.test(raw)) return {
-		state: "AccessKey 没有目标权限",
-		kind: "permission",
-		detail: detail || "凭据有效，但没有该 Bucket / 前缀的访问权限"
-	};
-	if (/nosuchbucket|invalidbucketname|unknown endpoint|invalidendpoint|no such host.*oss|endpoint/i.test(lower)) return {
-		state: "Bucket 或 Endpoint 配置有误",
-		kind: "config",
-		detail: detail || "Bucket 或 Endpoint 配置有误（由管理员在部署配置里设置）"
-	};
-	return {
-		state: "连接 OSS 失败",
-		kind: "infrastructure",
-		detail: detail || "无法连接 OSS（网络 / 超时 / 服务不可达）"
-	};
-}
-/** 探测输出的截断 + 脱敏（**唯一**出口，见 `oss/sanitize.ts`）。 */
-function clampOssText(raw) {
-	const clean = sanitizeOssError(raw).trim();
-	return clean.length <= 400 ? clean : `${clean.slice(0, 400)}…`;
+function privateFileMechanism(platform) {
+	return shellDialect(platform) === "powershell" ? "windows-acl" : "posix-0600";
 }
 //#endregion
 //#region src/host/platform/command.ts
@@ -2142,63 +1998,102 @@ function maskKey(value) {
 * 为什么不是 `node:fs`：插件跑在 Host 进程里，直接用 Node 文件 API 会绕过 DSH 的
 * 文件服务与沙箱策略。「删掉上一轮同名产物」这种动作必须走与其它命令同一条路径。
 *
-* 命令串由这里按固定模板 + `shellQuote` 构造：路径全部来自已经过案例目录包含检查的
-* 绝对路径，模型输入不参与拼接。
+* 三条口径（2026-09-28 收紧，含一次复查修正）：
+* 1. 命令串由 `platform/shell.ts` 按平台生成 —— 这里不再出现 `cmd /c`、`mkdir`、`rm` 之类字面量；
+* 2. **失败必须传播**：只把「目标已经是我们要的状态」视为成功。旧形态在 Windows 上把任意
+*    mkdir 失败都当成功，故障会推迟到「下一步写文件才炸」，归因到完全无关的地方；
+* 3. **后置条件要回读**，而且回读本身有**三种结果**（2026-09-28 复查修）：
+*    存在 / 不存在 / **查不出来**。DSH `fs.stat` 的契约是「不存在返回 `undefined`，
+*    真故障（权限、解析、基础设施）抛异常」——把异常也折叠成「不存在」，
+*    就会在 `Access denied` 时回报「删除成功」，或把一次读不到的目录当成已建好。
+*    所以「查不出来」一律按基础设施失败如实上报，不猜。
 */
 async function removeFileIfExists(ctx, path, options) {
-	const fs = fileSystem(ctx);
-	if (fs === void 0) return {
+	const probe = await probePath(ctx, path);
+	if (probe.kind === "error") return {
 		ok: false,
-		error: "Host 文件服务不可用"
+		error: `无法确认目标状态：${probe.error}（${path}）`.slice(0, 300)
 	};
-	try {
-		const info = await fs.stat(await resolveTarget(ctx, path));
-		if (info === void 0) return {
-			ok: true,
-			error: ""
-		};
-		if (info.type !== "file") return {
-			ok: false,
-			error: `目标不是普通文件，拒绝删除：${path}`
-		};
-	} catch (error) {
-		return {
-			ok: true,
-			error: ""
-		};
-	}
-	const quote = (value) => shellQuote$1(value, options.platform);
-	const run = await runShell(ctx, isWindowsPlatform(options.platform) ? `cmd /c del /f /q ${quote(path)}` : `rm -f -- ${quote(path)}`, {
+	if (probe.kind === "absent") return {
+		ok: true,
+		error: ""
+	};
+	if (probe.type !== "file") return {
+		ok: false,
+		error: `目标不是普通文件，拒绝删除：${path}`
+	};
+	const run = await runShell(ctx, removeFileCommand(path, options.platform), {
 		workdir: options.workdir,
 		timeoutMs: 2e4,
 		...options.signal === void 0 ? {} : { signal: options.signal }
 	});
+	if (!run.ok) return {
+		ok: false,
+		error: (text(run.stderr) || text(run.error) || "删除旧产物失败").slice(0, 300)
+	};
+	const after = await probePath(ctx, path);
+	if (after.kind === "error") return {
+		ok: false,
+		error: `删除命令返回成功，但无法确认目标是否已删除：${after.error}`.slice(0, 300)
+	};
+	if (after.kind === "present") return {
+		ok: false,
+		error: `删除命令返回成功，但文件仍然存在：${path}`
+	};
 	return {
-		ok: run.ok,
-		error: run.ok ? "" : (run.stderr || run.error || "删除旧产物失败").slice(0, 300)
+		ok: true,
+		error: ""
 	};
 }
-/** 确保目录存在（`mkdir -p`）。 */
+/** 确保目录存在（`mkdir -p` / `New-Item -ItemType Directory -Force`）。 */
 async function ensureDirectory$1(ctx, path, options) {
-	const quote = (value) => shellQuote$1(value, options.platform);
-	const run = await runShell(ctx, isWindowsPlatform(options.platform) ? `cmd /c mkdir ${quote(path)}` : `mkdir -p ${quote(path)}`, {
+	const run = await runShell(ctx, mkdirCommand(path, options.platform), {
 		workdir: options.workdir,
 		timeoutMs: 2e4,
 		...options.signal === void 0 ? {} : { signal: options.signal }
 	});
-	if (run.ok) return {
-		ok: true,
-		error: ""
+	const after = await probePath(ctx, path);
+	if (after.kind === "error") return {
+		ok: false,
+		error: `无法确认目录是否已创建：${after.error}（${path}）`.slice(0, 300)
 	};
-	if (isWindowsPlatform(options.platform)) return {
+	if (after.kind === "present" && after.type === "directory") return {
 		ok: true,
 		error: ""
 	};
+	if (!run.ok) return {
+		ok: false,
+		error: (text(run.stderr) || text(run.error) || "创建目录失败").slice(0, 300)
+	};
+	if (after.kind === "present") return {
+		ok: false,
+		error: `创建目录命令返回成功，但目标不是目录：${path}`
+	};
 	return {
 		ok: false,
-		error: (run.stderr || run.error || "创建目录失败").slice(0, 300)
+		error: `创建目录命令返回成功，但目录不存在：${path}`
 	};
 }
+async function probePath(ctx, path) {
+	const fs = fileSystem(ctx);
+	if (fs === void 0) return {
+		kind: "error",
+		error: "Host 文件服务不可用"
+	};
+	try {
+		const info = await fs.stat(await resolveTarget(ctx, path));
+		if (info === void 0) return { kind: "absent" };
+		return {
+			kind: "present",
+			type: text(info.type)
+		};
+	} catch (error) {
+		return {
+			kind: "error",
+			error: error instanceof Error ? error.message : String(error)
+		};
+	}
+}
 //#endregion
 //#region src/shared/utils/json.ts
 /**
@@ -2314,7 +2209,7 @@ function renderJson(value) {
 async function requireCaseDir(ctx, raw) {
 	const value = text(raw).trim();
 	if (value === "") return { ...failure$1("input", "缺少案例目录（caseDir 必须是绝对路径）") };
-	if (!value.startsWith("/") && !/^[A-Za-z]:[\\/]/.test(value)) return { ...failure$1("input", `案例目录必须是绝对路径：${value}`) };
+	if (!isAbsoluteLocalPath(value)) return { ...failure$1("input", `案例目录必须是绝对路径：${value}`) };
 	if (value.split(/[\\/]/).includes("..")) return { ...failure$1("input", `案例目录不能包含 .. 片段：${value}`) };
 	const fs = fileSystem(ctx);
 	if (fs === void 0) return { ...failure$1("infrastructure", "Host 文件服务不可用") };
@@ -2341,7 +2236,7 @@ async function requireInsideCase(ctx, casePath, relative) {
 	if (name.split("/").includes("..")) return { ...failure$1("input", `相对路径不能包含 ..：${name}`) };
 	const fs = fileSystem(ctx);
 	if (fs === void 0) return { ...failure$1("infrastructure", "Host 文件服务不可用") };
-	const full = `${casePath.replace(/[\\/]+$/, "")}/${name}`;
+	const full = joinLocalPath(casePath, name);
 	try {
 		const root = await resolveTarget(ctx, casePath);
 		const target = await fs.resolve(name, { cwd: text(root.displayPath) });
@@ -2792,7 +2687,7 @@ function bootstrapTools(deps) {
 				...failure$1("cli", `files list 没有返回附件数组：${clampText(filesRun.stdout, 400)}`),
 				...empty
 			};
-			const snapshotDir = `${caseCheck.path}/${SNAPSHOT_DIR}`;
+			const snapshotDir = joinLocalPath(caseCheck.path, SNAPSHOT_DIR);
 			const made = await ensureDirectory$1(ctx, snapshotDir, {
 				workdir: caseCheck.path,
 				platform,
@@ -2819,9 +2714,9 @@ function bootstrapTools(deps) {
 				fieldCount: Object.keys(record).length,
 				attachmentCount: attachments.length,
 				snapshotDir,
-				snapshotPath: `${snapshotDir}/${SNAPSHOT_RECORD_FILE}`,
-				attachmentsPath: `${snapshotDir}/${SNAPSHOT_ATTACHMENTS_FILE}`,
-				metadataPath: `${snapshotDir}/${SNAPSHOT_METADATA_FILE}`,
+				snapshotPath: joinLocalPath(snapshotDir, SNAPSHOT_RECORD_FILE),
+				attachmentsPath: joinLocalPath(snapshotDir, SNAPSHOT_ATTACHMENTS_FILE),
+				metadataPath: joinLocalPath(snapshotDir, SNAPSHOT_METADATA_FILE),
 				routingFacts: routingFactsOf(record, seqNo, form.name),
 				reused: false
 			};
@@ -3884,7 +3779,7 @@ function dingtalkTools(deps) {
 				"drive",
 				"+upload",
 				"--file",
-				requested.split("/").pop() ?? requested,
+				basenameLocalPath(requested),
 				"--file-name",
 				plan.plan.remoteName,
 				"--folder",
@@ -4050,7 +3945,7 @@ function dingtalkTools(deps) {
 			};
 			const caseDir = caseCheck.path;
 			const send = async () => {
-				const statePath = `${caseDir.replace(/[\\/]+$/, "")}/${NOTIFY_STATE_FILE}`;
+				const statePath = joinLocalPath(caseDir, NOTIFY_STATE_FILE);
 				const existing = await readTextIfExists(ctx, statePath);
 				if (existing !== "") {
 					const parsed = jsonObject(existing);
@@ -4787,6 +4682,112 @@ function h3yunTools(deps) {
 	];
 }
 //#endregion
+//#region src/host/platform/credential-permission.ts
+/**
+* 凭据文件的**权限收紧与如实报告**（协议 17）。
+*
+* ## 为什么单独成一个模块
+*
+* iFinD API-Key 与 OSS AccessKey 落在同一个形态的文件里（用户配置目录下的私有文件），
+* 收紧方式与「失败怎么说话」必须**只有一份判据**。旧形态两处各写一遍
+* `if (!isWindowsPlatform(...)) { chmod } else { chmodOk = true }` —— 于是 Windows 上
+* 两处都报「成功」，而实际什么都没做。
+*
+* ## 三种结局（见 `shared/types.ts` 的 `CredentialPermission`）
+*
+* - `verified`：POSIX 上跑了收紧命令**并回读了模式位**，两者都确认是 `0600`（`posix-0600`）；
+* - `inherited`：该平台没有 POSIX 权限位这件事（Windows），不执行任何命令，
+*   如实说明权限由**当前账户 ACL** 负责 —— 不伪装成成功，也不谎报失败；
+* - `failed`：试图收紧但失败，或**回读对不上**（chmod 报错 / 沙箱拒绝 / 命令没跑起来 /
+*   文件系统静默忽略 chmod），带原因。
+*
+* `verified` 的含义是「回读确认」，所以**必须有第二步**（2026-09-28 复查修）：
+* 只信 `chmod` 的退出码就把「命令跑过了」说成「权限已验证」，而有些文件系统会静默忽略 chmod。
+* 回读命令由 `platform/shell.ts` 的 `readFileModeCommand()` 生成（GNU / BSD 的参数差异只在那里出现一次）。
+*
+* 本轮**不**调用 `icacls` 重写 ACL：企业域策略下的权限继承不是插件该擅自改的东西，
+* 真要「收紧 ACL」得另做设计与域环境测试（见设计说明 §3.5）。
+*/
+/** 期望的模式位（八进制字符串）。 */
+const EXPECTED_MODE = "600";
+async function enforceCredentialPermission(ctx, path, platform, options) {
+	const mechanism = privateFileMechanism(platform);
+	if (mechanism === "windows-acl") return {
+		status: "inherited",
+		mechanism,
+		message: "使用当前 Windows 账户 ACL；POSIX 0600 不适用"
+	};
+	const command = privateFileCommand(path, platform);
+	if (command === "") return {
+		status: "failed",
+		mechanism,
+		message: `无法为该平台生成权限收紧命令（platform=${platform || "未知"}）`
+	};
+	const shellOptions = {
+		workdir: options.workdir,
+		timeoutMs: 15e3,
+		...options.escalate === true ? { escalate: true } : {}
+	};
+	const run = await runShell(ctx, command, shellOptions);
+	if (!run.ok) return {
+		status: "failed",
+		mechanism,
+		message: permissionFailureMessage(run)
+	};
+	const readCommand = readFileModeCommand(path, platform);
+	if (readCommand === "") return {
+		status: "failed",
+		mechanism,
+		message: "无法为该平台生成权限回读命令（平台事实自相矛盾）"
+	};
+	const read = await runShell(ctx, readCommand, shellOptions);
+	if (!read.ok) return {
+		status: "failed",
+		mechanism,
+		message: `权限回读失败：${permissionFailureMessage(read)}`
+	};
+	const mode = parseFileMode(read.stdout);
+	if (mode === "") return {
+		status: "failed",
+		mechanism,
+		message: `权限回读没有给出可解析的模式位：${text(read.stdout).trim().slice(0, 80)}`
+	};
+	if (mode !== EXPECTED_MODE) return {
+		status: "failed",
+		mechanism,
+		message: `权限收紧命令返回成功，但回读到的模式是 ${mode}（期望 ${EXPECTED_MODE}）—— 该文件系统可能忽略了 chmod`
+	};
+	return {
+		status: "verified",
+		mechanism,
+		message: ""
+	};
+}
+/**
+* 从 `stat` 的输出里取出八进制模式位。
+*
+* GNU `stat -c %a` 给 `600`（也可能带前导 `0`）；BSD `stat -f %Lp` 给 `600`；
+* 都按「最后一个连续八进制串」取，避免把别的输出混进来。取不到返回空串。
+*/
+function parseFileMode(raw) {
+	const match = /(?:^|\s)([0-7]{3,4})\s*$/.exec(text(raw).trim());
+	if (match === null) return "";
+	const digits = match[1] ?? "";
+	return digits.length === 4 && digits.startsWith("0") ? digits.slice(1) : digits;
+}
+/** 失败原因：命令没跑起来（沙箱/审批）与跑完报错要能分辨。 */
+function permissionFailureMessage(run) {
+	return ((text(run.stderr) || text(run.error) || text(run.stdout)).trim() || "权限收紧命令没有成功").slice(0, 200);
+}
+/** Host 凭据服务（`credentials`）托管时的权限结论：不由我们管，也不宣称已验证。 */
+function hostStorePermission() {
+	return {
+		status: "inherited",
+		mechanism: "host-store",
+		message: "凭据由 DSH 凭据服务保管，文件权限不适用"
+	};
+}
+//#endregion
 //#region src/host/ifind/store.ts
 /**
 * iFinD **API-Key** 的**插件自有凭据存储**。
@@ -4821,16 +4822,20 @@ const IFIND_CREDENTIAL_FILE = "ifind-credential.json";
 const IFIND_CREDENTIAL_FIELD = "auth_token";
 /** 视为占位符的取值（上游文档里就是这么写的）。 */
 const IFIND_PLACEHOLDER = "your ifind-mcp key";
-/** 凭据文件的绝对路径。 */
+/**
+* 凭据文件的绝对路径。
+*
+* 分隔符随主目录风格走（`joinLocalPath`）：这条路径交给 fs 与 shell 两条链路，
+* 混用分隔符在 Windows 上既进不了 `New-Item -Path`，也会被别的程序当转义。
+*/
 function ifindCredentialPath(home) {
-	const base = home.replace(/[\\/]+$/, "");
-	if (base === "") return `~/${PLUGIN_STATE_DIR}/${IFIND_CREDENTIAL_FILE}`;
-	const sep = base.includes("\\") ? "\\" : "/";
-	return `${base}${sep}${PLUGIN_STATE_DIR.replace(/\//g, sep)}${sep}${IFIND_CREDENTIAL_FILE}`;
+	if (text(home) === "") return `~/${PLUGIN_STATE_DIR}/${IFIND_CREDENTIAL_FILE}`;
+	return joinLocalPath(home, PLUGIN_STATE_DIR, IFIND_CREDENTIAL_FILE);
 }
-/** 状态目录的绝对路径（`chmod` / `mkdir` 用）。 */
+/** 状态目录的绝对路径（`mkdir` / 权限收紧用）。 */
 function ifindStateDir(home) {
-	return ifindCredentialPath(home).replace(/[\\/][^\\/]+$/, "");
+	if (text(home) === "") return `~/${PLUGIN_STATE_DIR}`;
+	return joinLocalPath(home, PLUGIN_STATE_DIR);
 }
 /**
 * 校验一份 API-Key。**五种坏值都必须能分辨**，因为界面要给的处置不同：
@@ -5018,15 +5023,23 @@ async function readIfindSecret(ctx, home) {
 async function ifindCredentialView(ctx, home) {
 	return (await readIfindSecret(ctx, home)).view;
 }
-/** 写盘结果里的失败形状（集中一处，避免每个分支各写一遍）。 */
-function writeFailure(kind, error, path) {
+/**
+* 写盘结果里的失败形状（集中一处，避免每个分支各写一遍）。
+*
+* `mechanism` 由**注入的平台事实**推出（`privateFileMechanism` 是唯一判据，不看 `process.platform`）；
+* 写盘都没成功时它只影响文案口径，`status` 恒为 `failed`。
+*/
+function writeFailure(kind, error, path, platform) {
 	return {
 		ok: false,
 		errorKind: kind,
 		error,
 		dirReady: false,
-		chmodOk: false,
-		chmodError: "",
+		permission: {
+			status: "failed",
+			mechanism: privateFileMechanism(platform),
+			message: error
+		},
 		mode: "file",
 		view: {
 			path,
@@ -5048,8 +5061,9 @@ function writeFailure(kind, error, path) {
 */
 async function writeIfindSecret(ctx, home, rawSecret, options = {}) {
 	const path = ifindCredentialPath(home);
+	const platform = text(options.platform);
 	const verdict = checkIfindSecret(rawSecret, options.placeholder ?? "your ifind-mcp key");
-	if (!verdict.ok) return writeFailure("input", verdict.reason, path);
+	if (!verdict.ok) return writeFailure("input", verdict.reason, path, platform);
 	const resolved = resolveIfindStore(ctx);
 	if (resolved.kind === "host" && resolved.store !== void 0) try {
 		await resolved.store.set(IFIND_CREDENTIAL_KEY, verdict.value);
@@ -5058,8 +5072,7 @@ async function writeIfindSecret(ctx, home, rawSecret, options = {}) {
 			errorKind: "",
 			error: "",
 			dirReady: true,
-			chmodOk: true,
-			chmodError: "",
+			permission: hostStorePermission(),
 			mode: "host",
 			view: {
 				path: `credentials:${IFIND_CREDENTIAL_KEY}`,
@@ -5070,20 +5083,20 @@ async function writeIfindSecret(ctx, home, rawSecret, options = {}) {
 			}
 		};
 	} catch (error) {
-		return writeFailure("infrastructure", `写入 DSH 凭据存储失败：${error instanceof Error ? error.message : String(error)}`, path);
+		return writeFailure("infrastructure", `写入 DSH 凭据存储失败：${error instanceof Error ? error.message : String(error)}`, path, platform);
 	}
-	if (home === "") return writeFailure("infrastructure", "主目录未知，无法保存同花顺 iFinD 凭据", path);
+	if (home === "") return writeFailure("infrastructure", "主目录未知，无法保存同花顺 iFinD 凭据", path, platform);
 	const fs = fileSystem(ctx);
-	if (fs === void 0) return writeFailure("infrastructure", "Host 文件服务不可用，无法保存同花顺 iFinD 凭据", path);
-	const platform = text(options.platform) || process.platform;
+	if (fs === void 0) return writeFailure("infrastructure", "Host 文件服务不可用，无法保存同花顺 iFinD 凭据", path, platform);
+	if (platform === "") return writeFailure("infrastructure", "未知平台，拒绝在没有平台事实的情况下写凭据", path, platform);
 	const dir = ifindStateDir(home);
-	const mkdir = await runShell(ctx, isWindowsPlatform(platform) ? `New-Item -ItemType Directory -Force -Path ${shellQuote(dir, platform)} | Out-Null` : `mkdir -p ${shellQuote(dir, platform)}`, {
+	const mkdirRun = await runShell(ctx, mkdirCommand(dir, platform), {
 		workdir: home,
 		timeoutMs: 15e3,
 		escalate: true
 	});
-	const dirReady = mkdir.ok;
-	if (!dirReady) return writeFailure("infrastructure", `创建插件状态目录失败：${text(mkdir.stderr) || text(mkdir.error) || dir}`.slice(0, 300), path);
+	const dirReady = mkdirRun.ok;
+	if (!dirReady) return writeFailure("infrastructure", `创建插件状态目录失败：${text(mkdirRun.stderr) || text(mkdirRun.error) || dir}`.slice(0, 300), path, platform);
 	const body = `${JSON.stringify({ [IFIND_CREDENTIAL_FIELD]: verdict.value }, null, 2)}\n`;
 	try {
 		await fs.writeText(await resolveTarget(ctx, path), body, void 0, void 0, {
@@ -5091,26 +5104,17 @@ async function writeIfindSecret(ctx, home, rawSecret, options = {}) {
 			workspaceRoot: home
 		});
 	} catch (error) {
-		return writeFailure("infrastructure", `写入 ${path} 失败：${error instanceof Error ? error.message : String(error)}`, path);
-	}
-	let chmodOk = true;
-	let chmodError = "";
-	if (!isWindowsPlatform(platform)) {
-		const chmod = await runShell(ctx, `chmod 600 ${shellQuote(path, platform)}`, {
-			workdir: home,
-			timeoutMs: 15e3,
-			escalate: true
-		});
-		chmodOk = chmod.ok;
-		chmodError = chmod.ok ? "" : (text(chmod.stderr) || text(chmod.error) || "权限设置命令没有跑起来").slice(0, 200);
+		return writeFailure("infrastructure", `写入 ${path} 失败：${error instanceof Error ? error.message : String(error)}`, path, platform);
 	}
 	return {
 		ok: true,
 		errorKind: "",
 		error: "",
 		dirReady,
-		chmodOk,
-		chmodError,
+		permission: await enforceCredentialPermission(ctx, path, platform, {
+			workdir: home,
+			escalate: true
+		}),
 		mode: "file",
 		view: {
 			path,
@@ -5146,8 +5150,14 @@ async function clearIfindSecret(ctx, home, options = {}) {
 		error: "主目录未知，无法清除同花顺 iFinD 凭据",
 		mode: "file"
 	};
-	const platform = text(options.platform) || process.platform;
-	const result = await runShell(ctx, isWindowsPlatform(platform) ? `Remove-Item -LiteralPath ${shellQuote(ifindCredentialPath(home), platform)} -Force -ErrorAction SilentlyContinue` : `rm -f ${shellQuote(ifindCredentialPath(home), platform)}`, {
+	const platform = text(options.platform);
+	if (platform === "") return {
+		ok: false,
+		errorKind: "infrastructure",
+		error: "未知平台，拒绝在没有平台事实的情况下清除凭据",
+		mode: "file"
+	};
+	const result = await runShell(ctx, removeFileCommand(ifindCredentialPath(home), platform), {
 		workdir: home,
 		timeoutMs: 15e3,
 		escalate: true
@@ -5165,19 +5175,6 @@ async function clearIfindSecret(ctx, home, options = {}) {
 		mode: "file"
 	};
 }
-/**
-* 平台引用方式。
-*
-* 与 `environment/probe.ts` 的 `shellQuote` 同一判据（POSIX 单引号 / Windows 也是单引号 ——
-* Windows 上 DSH 跑的是 PowerShell，单引号才是纯字面量，双引号会插值），
-* 这里各写一份是因为 `probe.ts` 已经反向依赖本模块（`checkIfindSecret` 由它复用），
-* 再互相 import 会成环。两处都只有两行，且都有单测钉着 Windows 分支。
-*/
-function shellQuote(value, platform) {
-	const raw = text(value);
-	if (!isWindowsPlatform(text(platform))) return `'${raw.replace(/'/g, "'\\''")}'`;
-	return `'${raw.replace(/'/g, "''")}'`;
-}
 //#endregion
 //#region src/host/ifind/mcp.ts
 /**
@@ -6734,7 +6731,7 @@ function knowledgeTools(deps) {
 			const platform = await deps.world.platform();
 			const trusted = credentialsTrusted(deps);
 			const caseDir = caseCheck.path;
-			const knowledgeDir = `${caseDir.replace(/[\\/]+$/, "")}/${CASE_KNOWLEDGE_DIR}`;
+			const knowledgeDir = joinLocalPath(caseDir, CASE_KNOWLEDGE_DIR);
 			const base = {
 				...empty,
 				caseDir,
@@ -6838,7 +6835,7 @@ function knowledgeTools(deps) {
 						});
 						continue;
 					}
-					const local = `${knowledgeDir}/${relative}`;
+					const local = joinLocalPath(knowledgeDir, relative);
 					const cleared = await removeFileIfExists(ctx, local, {
 						workdir: caseDir,
 						platform,
@@ -6918,7 +6915,7 @@ function knowledgeTools(deps) {
 					});
 				}
 			}
-			const manifestPath = `${knowledgeDir}/.crwu-manifest.json`;
+			const manifestPath = joinLocalPath(knowledgeDir, KB_MANIFEST_FILE);
 			const written = await writeManifest(ctx, manifestPath, {
 				schema: "crwu.kb-materialize.manifest.v1",
 				spaceName,
@@ -6990,6 +6987,22 @@ async function writeManifest(ctx, path, payload) {
 	}
 }
 //#endregion
+//#region src/host/oss/sanitize.ts
+/**
+* OSS 输出脱敏：**唯一**一处把 ossutil 的 stdout / stderr 变成可以给人看（或进日志）的文本。
+*
+* 为什么必须集中一处：`ossutil` 的报错里会带请求 URL（含 `Signature` / `OSSAccessKeyId`）、
+* 甚至完整的临时凭据与 `x-oss-security-token`。这类文本一旦进会话记录或界面，
+* 就等于把凭据写进了可回放的日志。上传路径（`tools/oss.ts`）与环境探测
+* （`environment/probe.ts`）都要用同一份判据 —— 两套正则必然有一天只改了一处。
+*
+* 顺序有讲究：**先按字段名抹值、再抹整条查询串、最后兜底抹 AK 形态**。
+* 反过来会把 URL 整条打成 `?<redacted>`，连"是哪个 bucket"都看不出来。
+*/
+function sanitizeOssError(value) {
+	return text(value).replace(/(Signature|OSSAccessKeyId|security-token|AccessKeyId|AccessKeySecret|STS\w*Token)=[^&\s"']+/gi, "$1=<redacted>").replace(/(https?:\/\/[^\s"']*?)\?[^\s"']*/gi, "$1?<redacted>").replace(/\bLTAI[A-Za-z0-9]{8,}\b/g, "<redacted-access-key>").slice(0, 600);
+}
+//#endregion
 //#region src/host/oss/parse.ts
 /**
 * OSS 对象路径与命令输出的解析。
@@ -7321,13 +7334,13 @@ function ossTools(deps) {
 					});
 					continue;
 				}
-				const key = `${prefix}/${relative.split("/").pop() ?? relative}`;
+				const objectKey = `${prefix}/${basenameLocalPath(relative)}`;
 				const argv = [
 					ossutil,
 					"cp",
 					"-f",
 					local,
-					`oss://${oss.bucket}/${key}`
+					`oss://${oss.bucket}/${objectKey}`
 				];
 				if (oss.endpoint !== "") argv.push("--endpoint", oss.endpoint);
 				for (const extra of oss.extraArgs) argv.push(extra);
@@ -7340,7 +7353,7 @@ function ossTools(deps) {
 					results.push({
 						kind,
 						name: relative,
-						key,
+						key: objectKey,
 						ok: false,
 						sizeBytes: 0,
 						exitCode: run.exitCode,
@@ -7348,11 +7361,11 @@ function ossTools(deps) {
 					});
 					continue;
 				}
-				const verify = await verifyObject(ctx, platform, oss.bucket, prefix, key, size, caseDir, ossutil, exec.signal);
+				const verify = await verifyObject(ctx, platform, oss.bucket, prefix, objectKey, size, caseDir, ossutil, exec.signal);
 				results.push({
 					kind,
 					name: relative,
-					key,
+					key: objectKey,
 					ok: verify.ok,
 					sizeBytes: verify.sizeBytes,
 					exitCode: run.exitCode,
@@ -7624,8 +7637,19 @@ async function bootstrapInputSnapshot(ctx, agent, args) {
 */
 /** 根会话的标题前缀；后面会补时间戳，便于区分分叉出来的多棵树。 */
 const AUDIT_ROOT_TITLE = "审核子代理根节点";
-/** 预检指令：一次调用同时证明「模型能回」「bash 能用、cwd 正确」「CRWU Tool 链路与 policy pipeline 通」。 */
-const AUDIT_ROOT_PROBE = "hello，请依次做两件事：① 用 bash 执行 `pwd`；② 调用 `crwu_audit_capabilities`（无参数）。然后回复当前目录，以及该工具返回的 `ok`、`platform` 与 `binPlatform`。";
+/**
+* 预检指令：一次调用同时证明「模型能回」「shell 能用、cwd 正确」「CRWU Tool 链路与 policy pipeline 通」。
+*
+* **必须按平台生成**（2026-09-28）：旧文案写死了「用 bash 执行 `pwd`」，而 DSH 在 Windows 上挂的是
+* PowerShell（`@deepseek-ai/dsh-pwsh-local`，整串命令交给 `pwsh -Command`）。后果是宿主侧环境自检
+* 全绿、Agent 预检却直接失败，错误里还出现一个这台机器上根本不存在的 `bash` —— 让人往
+* 「装 Git Bash」的方向排查。这里给出的命令一律是**当前平台 shell 的真实写法**。
+*/
+function auditRootProbe(platform) {
+	const cwd = shellDialect(platform) === "powershell" ? "`Get-Location`" : "`pwd`";
+	const shellName = shellDialect(platform) === "powershell" ? "PowerShell" : "POSIX shell";
+	return "hello，请依次做两件事：① 用**当前平台的 shell 工具**执行 " + cwd + ` 输出当前目录（这个会话的 shell 是 ${shellName}，不要再去找别的 shell）；② 调用 \`crwu_audit_capabilities\`（无参数）。然后回复当前目录，以及该工具返回的 \`ok\`、\`platform\` 与 \`binPlatform\`。`;
+}
 /** 根标题：`审核子代理根节点 · 09-20 21:30`。 */
 function auditRootTitle(now) {
 	const pad = (value) => String(value).padStart(2, "0");
@@ -7642,13 +7666,13 @@ function mintSessionId() {
 * 不走 `@deepseek-ai/dsh-llm` 的 `createUserMessage`：那会把 dsh-llm 变成我们的一条运行时依赖，
 * 而这里只需要「一条带 id 与 role 的用户消息」这个形状（字段与它产出的完全一致）。
 */
-function probeMessage(sessionSeed) {
+function probeMessage(sessionSeed, platform) {
 	return {
 		id: `msg-${sessionSeed}`,
 		role: "user",
 		content: [{
 			type: "text",
-			text: AUDIT_ROOT_PROBE
+			text: auditRootProbe(platform)
 		}],
 		source: { kind: "user" }
 	};
@@ -7698,10 +7722,11 @@ function auditRootUsability(ctx, state, workspacePath) {
 /**
 * 目录不存在就建（`workspaceRegistry.create` 要求目录已存在）。
 *
-* Windows 的 `mkdir`（cmd 内建）本身就会建中间目录，加 `-p` 反而不认，所以按平台分两种写法。
+* 命令由 `platform/shell.ts` 按平台生成：POSIX 是 `mkdir -p`，Windows 是 PowerShell 的
+* `New-Item -ItemType Directory -Force`（`cmd` 的 `mkdir` 既不认 `-p`，引号解析也是第二套规则）。
 */
 async function ensureDirectory(ctx, path, workspace, platform) {
-	const result = await runShell(ctx, `mkdir ${isWindowsPlatform(platform) ? "" : "-p "}${quoteArg(path)}`, {
+	const result = await runShell(ctx, mkdirCommand(path, platform), {
 		timeoutMs: 2e4,
 		workdir: workspace
 	});
@@ -7722,6 +7747,7 @@ async function ensureAuditRoot(deps, options = {}) {
 		notes: []
 	});
 	if (workspacePath === "") return fail("尚未选定工作空间：审核根会话需要一个明确的工作空间。");
+	const platform = await deps.world.platform();
 	const usable = auditRootUsability(ctx, state, workspacePath);
 	if (usable.ok) return {
 		ok: true,
@@ -7736,7 +7762,7 @@ async function ensureAuditRoot(deps, options = {}) {
 	if (agents === void 0 || typeof agents.create !== "function") return fail("Host agents 服务不可用，无法创建审核根会话");
 	let workspace = await resolveWorkspaceEntity(ctx, workspacePath);
 	if (workspace === void 0) {
-		const mkdirError = await ensureDirectory(ctx, workspacePath, await deps.world.workdir(), await deps.world.platform());
+		const mkdirError = await ensureDirectory(ctx, workspacePath, await deps.world.workdir(), platform);
 		if (mkdirError !== "") return fail(mkdirError);
 		workspace = await createWorkspace(ctx, workspacePath, state.workspaceTitle || workspacePath);
 		if (workspace === void 0) return fail(`工作空间登记失败：${workspacePath}`);
@@ -7769,7 +7795,7 @@ async function ensureAuditRoot(deps, options = {}) {
 	}
 	const title = auditRootTitle(/* @__PURE__ */ new Date());
 	if (!renameSession(ctx, sessionId, title)) notes.push("根会话改名失败（不影响审核，只是标题不好认）");
-	const probeError = await preflight(ctx, created.agent, sessionId);
+	const probeError = await preflight(ctx, created.agent, sessionId, platform);
 	if (probeError !== "") return fail(`审核根会话预检未通过：${probeError}`);
 	const missing = auditToolsVisible(ctx, created.agent);
 	if (missing.length > 0) return fail(`审核所需的 CRWU Tool 对该 Agent 不可见：${missing.join("、")}。请确认部署已装配 @deepseek-ai/dsh-tools（base bundle 的 tools 行）。`);
@@ -7789,10 +7815,10 @@ async function ensureAuditRoot(deps, options = {}) {
 	};
 }
 /** 一次 hello 预检；返回空串表示通过。 */
-async function preflight(ctx, agent, sessionSeed, timeoutMs = 9e4) {
+async function preflight(ctx, agent, sessionSeed, platform, timeoutMs = 9e4) {
 	if (typeof agent.followup !== "function" || typeof agent.whenIdle !== "function") return "这个部署的 Agent 不支持 followup/whenIdle，无法确认会话可驱动";
 	try {
-		agent.followup(probeMessage(sessionSeed));
+		agent.followup(probeMessage(sessionSeed, platform));
 	} catch (error) {
 		return `发送预检消息失败：${error instanceof Error ? error.message : String(error)}`;
 	}
@@ -7883,11 +7909,10 @@ function auditRootView(ctx, state) {
 }
 //#endregion
 //#region src/host/audit/case.ts
-/** 目录名取路径最后一段；结尾斜杠不影响。 */
+/** 目录名取路径最后一段；Windows 的 `\` 与 POSIX 的 `/`、结尾斜杠都不影响。 */
 function caseNameOf(displayPath) {
-	const trimmed = displayPath.replace(/\/+$/, "");
-	const parts = trimmed.split("/");
-	return parts.length > 0 ? parts[parts.length - 1] ?? trimmed : trimmed;
+	const name = basenameLocalPath(displayPath);
+	return name === "" ? text(displayPath) : name;
 }
 async function inspectCase(ctx, dirTarget) {
 	const fs = fileSystem(ctx);
@@ -7956,7 +7981,7 @@ async function inspectCase(ctx, dirTarget) {
 		error: ""
 	};
 	if (resultFile !== "") try {
-		const target = await resolveTarget(ctx, `${item.path.replace(/\/+$/, "")}/${resultFile}`);
+		const target = await resolveTarget(ctx, joinLocalPath(item.path, resultFile));
 		item.audit = JSON.parse(await fs.readText(target));
 	} catch (error) {
 		item.error = error instanceof Error ? error.message : String(error);
@@ -7969,8 +7994,8 @@ function rootCandidates(context, record) {
 	const paths = [];
 	if (record.casePath !== "") paths.push(record.casePath);
 	if (context.caseRoot !== "") {
-		if (record.seqNo !== "") paths.push(`${context.caseRoot}/${record.seqNo}`);
-		if (record.key !== "") paths.push(`${context.caseRoot}/${record.key}`);
+		if (record.seqNo !== "") paths.push(joinLocalPath(context.caseRoot, record.seqNo));
+		if (record.key !== "") paths.push(joinLocalPath(context.caseRoot, record.key));
 	}
 	return paths;
 }
@@ -8479,9 +8504,14 @@ async function auditStatus(deps, args) {
 }
 //#endregion
 //#region src/host/workspace/resolve.ts
-/** 去掉结尾斜杠；空值保持空。 */
+/**
+* 去掉结尾分隔符；空值保持空。
+*
+* 用共享的 `trimTrailingSeparators` 而不是 `replace(/[\\/]+$/, '')`：
+* 后者会把 Windows 的 `C:\` 裁成 `C:`（盘符相对路径）—— 那是另一个目录。
+*/
 function trimSlash(value) {
-	return text(value).replace(/[\\/]+$/, "");
+	return trimTrailingSeparators(value);
 }
 /**
 * 落盘里记的来源，**原样恢复**。
@@ -8630,7 +8660,7 @@ function sessionWorkspaceInfo(ctx, state) {
 	let best = null;
 	for (const entry of registryList(ctx)) {
 		if (entry.path === "") continue;
-		if (out.sessionCwd === entry.path || out.sessionCwd.startsWith(`${entry.path}/`)) {
+		if (isLocalPathUnder(out.sessionCwd, entry.path)) {
 			if (best === null || entry.path.length > best.path.length) best = entry;
 		}
 	}
@@ -8657,7 +8687,7 @@ async function adoptWorkspace(deps) {
 }
 /** 选定案例根目录（手动）。 */
 async function pickWorkspace(deps, args) {
-	const path = String(args.path ?? "").trim().replace(/\/+$/, "");
+	const path = trimTrailingSeparators(String(args.path ?? "").trim());
 	let persistError = "";
 	if (path !== "") {
 		const title = String(args.title ?? "") || path;
@@ -8711,33 +8741,462 @@ async function autoWorkspace(deps) {
 	};
 }
 //#endregion
-//#region src/host/platform/home.ts
+//#region src/host/environment/probe.ts
 /**
-* 用户主目录。
+* 包内路径：`<包根>` 与 `<包根>/bin/manifest.json`。
 *
-* 包形态优先用 Host 的 `os.homedir()`：插件就跑在 DSH 进程里，不必再探一次。只有当它与执行
-* 世界不一致（例如 shell 走 SSH/容器，本地主目录不是目标机器的主目录）时，才退回 shell 探测。
+* 为什么不用相对层数硬拼：这份代码在源码形态（`src/host/environment/`，距包根 3 层）与构建产物
+* （`lib/`，距包根 1 层）里都跑，由 `packageRootFrom` 按 `package.json` 定位才是唯一可靠的做法。
+* 导出它是为了让测试与实现比对**同一条**路径，而不是各写一份。
 */
-async function detectHome(ctx, workdir) {
-	let local = "";
+function packageIntegrityPaths() {
+	const packageRoot = packageRootFrom(dirname(fileURLToPath(import.meta.url)));
+	return {
+		packageRoot,
+		manifestPath: packageRoot === "" ? "" : join(packageRoot, "bin", "manifest.json")
+	};
+}
+/** 读包内 `bin/manifest.json` 里某个平台的声明；读不到就返回空表（**不**当成「没有组件」）。 */
+function readBinManifest(raw, platform) {
+	const tools = /* @__PURE__ */ new Map();
+	let parsed;
+	try {
+		parsed = JSON.parse(text(raw));
+	} catch (error) {
+		return {
+			found: false,
+			tools
+		};
+	}
+	const doc = parsed !== null && typeof parsed === "object" ? parsed : {};
+	const platforms = Array.isArray(doc.platforms) ? doc.platforms : [];
+	for (const entry of platforms) {
+		const row = entry !== null && typeof entry === "object" ? entry : {};
+		if (text(row.platform) !== platform) continue;
+		for (const item of Array.isArray(row.tools) ? row.tools : []) {
+			const tool = item !== null && typeof item === "object" ? item : {};
+			const file = text(tool.file);
+			if (file === "") continue;
+			tools.set(text(tool.tool) || file, {
+				file,
+				size: typeof tool.size === "number" && Number.isFinite(tool.size) ? tool.size : 0,
+				sha256: text(tool.sha256),
+				sourceVersion: text(tool.sourceVersion)
+			});
+		}
+		return {
+			found: true,
+			tools
+		};
+	}
+	return {
+		found: false,
+		tools
+	};
+}
+/** 「插件包不完整 / 平台不受支持」那一句：三件组件共用，措辞里不许出现「安装命令」。 */
+function packageGapMessage(platform, detail) {
+	return `插件包不完整 / 平台不受支持：${detail}。请重新安装中瑞世联工作台插件，或联系管理员确认插件包是否完整；这些组件由插件按包内绝对路径使用（当前平台 ${platform || "未知"}），不从 PATH 上查找，也不由员工单独配置。`;
+}
+/**
+* 检查随包组件：只读文件事实，**一次 shell 都不跑**。
+*
+* 判据（三条都来自包内，互相独立）：
+* 1. 当前平台有随包目录（否则「平台不受支持」）；
+* 2. 文件真的在 `bin/<平台>/` 里；
+* 3. 字节数与包内 `bin/manifest.json` 一致（运行残留 / 安装不完整都会在这里露出来）。
+*/
+async function probePackageIntegrity(ctx, manifest, platform, options = {}) {
+	const { packageRoot, manifestPath } = packageIntegrityPaths();
+	const supported = binPlatformDir(platform) !== "";
+	const fs = fileSystem(ctx);
+	let manifestFound = false;
+	const declared = /* @__PURE__ */ new Map();
+	if (fs !== void 0 && manifestPath !== "") try {
+		const parsed = readBinManifest(await fs.readText(await resolveTarget(ctx, manifestPath)), platform);
+		manifestFound = parsed.found;
+		for (const [name, tool] of parsed.tools) declared.set(name, tool);
+	} catch (error) {
+		manifestFound = false;
+	}
+	const tools = [];
+	for (const spec of manifest.packaged) tools.push(await checkPackagedTool(ctx, spec, platform, {
+		supported,
+		manifestFound,
+		manifestPath,
+		declared
+	}));
+	const failed = tools.filter((tool) => !tool.ok);
+	const ok = failed.length === 0;
+	return {
+		ok,
+		supported,
+		platform,
+		packageRoot,
+		manifestPath,
+		manifestFound,
+		tools,
+		note: ok ? `插件内置组件 ${String(tools.length)}/${String(tools.length)} 完整：字节数与包内 bin/manifest.json 一致（sha256 见明细，不在自检里重算）。` : failed[0]?.reason ?? packageGapMessage(platform, "插件内置组件不可用")
+	};
+}
+/** 单个组件：存在性 + 字节数；理由必须能分辨「平台不受支持」「缺文件」「清单读不到」「字节数不一致」。 */
+async function checkPackagedTool(ctx, spec, platform, facts) {
+	const file = binaryFileName(spec.name, platform);
+	const entry = facts.declared.get(spec.name);
+	const base = {
+		name: spec.name,
+		label: spec.label,
+		file,
+		present: false,
+		sizeBytes: 0,
+		manifestSizeBytes: entry?.size ?? 0,
+		sha256: entry?.sha256 ?? "",
+		expectedVersion: spec.expectedVersion,
+		note: spec.note,
+		ok: false,
+		reason: ""
+	};
+	if (!facts.supported) return {
+		...base,
+		reason: packageGapMessage(platform, "当前平台没有随包发布的组件目录")
+	};
+	const bundled = bundledBinaryPath(platform, spec.name);
+	if (bundled === "") return {
+		...base,
+		reason: packageGapMessage(platform, "当前平台没有随包发布的组件目录")
+	};
+	const fs = fileSystem(ctx);
+	if (fs === void 0) return {
+		...base,
+		reason: `无法核对插件包完整性：Host 文件服务不可用（包内路径 ${bundled}）`
+	};
+	let info;
+	try {
+		info = await fs.stat(await resolveTarget(ctx, bundled));
+	} catch (error) {
+		info = void 0;
+	}
+	if (info?.type !== "file") return {
+		...base,
+		reason: `插件包不完整：包内缺少 ${bundled}`
+	};
+	const sizeBytes = typeof info.size === "number" && Number.isFinite(info.size) ? info.size : 0;
+	const present = {
+		...base,
+		present: true,
+		sizeBytes
+	};
+	if (!facts.manifestFound) return {
+		...present,
+		reason: `插件包不完整：读不到包内清单 ${facts.manifestPath}，无法核对 ${file} 的字节数`
+	};
+	if (present.manifestSizeBytes === 0) return {
+		...present,
+		reason: `插件包不完整：包内清单里没有 ${spec.name} 的字节数，无法核对`
+	};
+	if (sizeBytes !== present.manifestSizeBytes) return {
+		...present,
+		reason: `插件包不完整：包内 ${file} 的字节数与随包清单不一致（磁盘 ${String(sizeBytes)} / 清单 ${String(present.manifestSizeBytes)}，可能是安装不完整或运行残留）`
+	};
+	return {
+		...present,
+		ok: true,
+		reason: ""
+	};
+}
+/** 定位失败时给用户的那句话。文案里不许出现安装指引：这个二进制随插件发布。 */
+function ossutilMissingMessage(lookup) {
+	return lookup.error === "" ? packageGapMessage("", "没有找到随包发布的 ossutil") : lookup.error;
+}
+/**
+* 解析包内 ossutil 的绝对路径。
+*
+* **没有 PATH 回退**（2026-09-25 口径）：回退会让模型在某台机器上看到 `command not found`，
+* 下一步自然就是 `which` / `command -v` / 去搜可执行文件 —— 正是本次改造要消灭的行为。
+* `oss` 参数保留是为了不改调用方签名：清单里的 `ossutil` 命令名已经不再参与解析。
+*/
+async function resolveOssutil(ctx, oss, platform, options = {}) {
+	const bundled = bundledBinaryPath(platform, "ossutil");
+	if (bundled === "") return {
+		path: "",
+		error: packageGapMessage(platform, "当前平台没有随包发布的 ossutil")
+	};
+	const fs = fileSystem(ctx);
+	if (fs === void 0) return {
+		path: "",
+		error: `无法核对插件包完整性：Host 文件服务不可用（包内路径 ${bundled}）`
+	};
+	try {
+		if ((await fs.stat(await resolveTarget(ctx, bundled)))?.type === "file") return {
+			path: bundled,
+			error: ""
+		};
+	} catch (error) {}
+	return {
+		path: "",
+		error: packageGapMessage(platform, `包内缺少 ${bundled}`)
+	};
+}
+/**
+* 一次真实 OSS 只读验证的请求形状（**完全由受信配置推出，模型与员工都不能提交**）。
+*
+* 导出它有两个目的：① 单测可以对命令字符串逐字断言；② 开发者诊断里能显示"验的是哪个目标"，
+* 而目标里**不含任何凭据**。
+*/
+function ossProbeTarget(oss) {
+	const prefix = oss.prefix.replace(/^\/+|\/+$/g, "");
+	const path = prefix === "" ? "" : `${prefix}/`;
+	return {
+		bucket: oss.bucket,
+		prefix: path,
+		target: `oss://${oss.bucket}/${path}`
+	};
+}
+/**
+* 端到端唯一的 OSS 真实验证：**用包内 ossutil 对配置好的 bucket + 业务前缀做一次只读列举**。
+*
+* 判据（2026-09-26 收紧）：
+* - 必须打**业务前缀**（`oss://<bucket>/<prefix>/`）而不是桶根：只验桶根证明不了"能写交付件"；
+* - `--limited-num 1`：只要一次请求，空目录也算成功（判据是"请求成功且凭据有权访问该目标"，
+*   不是"一定列到对象"）；
+* - 只用只读 `ls`：**不**为了验证去上传、删除或创建对象；
+* - 只认包内绝对路径（`resolveOssutil`），不回退 PATH、不要员工装 ossutil；
+* - 所有 stdout / stderr 在返回或写日志之前过 `sanitizeOssError`（AK / STS / Signature / 签名 URL）。
+*
+* 归因顺序是刻意的：**先看命令有没有跑起来**（沙箱 / 审批 / 包内缺文件），
+* 再看 HTTP / 服务端错误码。把"命令根本没跑起来"说成"AK 无效"会把员工指去换一份好密钥。
+*/
+async function probeOss(ctx, oss, platform, options = {}) {
+	const { target } = ossProbeTarget(oss);
+	const base = {
+		id: "oss",
+		label: "阿里云 OSS（AK 权限）",
+		required: true,
+		ok: false,
+		state: "",
+		detail: "",
+		errorKind: "",
+		target
+	};
+	if (!oss.enabled) return {
+		...base,
+		ok: false,
+		state: "未启用",
+		errorKind: "config",
+		detail: "清单 oss.enabled 为 false"
+	};
+	if (oss.bucket === "") return {
+		...base,
+		ok: false,
+		state: "缺 bucket",
+		errorKind: "config",
+		detail: "清单 oss.bucket 为空（由管理员在部署配置里设置）"
+	};
+	const lookup = await resolveOssutil(ctx, oss, platform, options);
+	if (lookup.path === "") return {
+		...base,
+		ok: false,
+		state: "插件包不完整 / 平台不受支持",
+		errorKind: "infrastructure",
+		detail: lookup.error
+	};
+	const ossutil = lookup.path;
+	const built = buildOssProbeCommand(oss, ossutil, platform);
+	if (!built.ok) return {
+		...base,
+		ok: false,
+		state: "探测配置有误",
+		errorKind: "config",
+		detail: built.error
+	};
+	const run = await runShell(ctx, built.command, {
+		timeoutMs: 6e4,
+		...options.workdir === void 0 ? {} : { workdir: options.workdir }
+	});
+	if (shellUnavailable(run)) return {
+		...base,
+		ok: false,
+		state: "无法探测",
+		errorKind: "infrastructure",
+		detail: sanitizeOssError(text(run.error) || text(run.stderr) || "探测命令没有执行")
+	};
+	const verdict = classifyOssFailure(run.ok, sanitizeOssError(text(run.stderr) || text(run.stdout) || text(run.error)));
+	if (run.ok) return {
+		...base,
+		ok: true,
+		state: "AK 正常",
+		errorKind: "",
+		detail: `已验证可访问 ${target}${oss.endpoint === "" ? "" : ` @ ${oss.endpoint}`}（只读列举，空目录也算通过）`
+	};
+	return {
+		...base,
+		ok: false,
+		state: verdict.state,
+		errorKind: verdict.kind,
+		detail: verdict.detail
+	};
+}
+/** 默认探测：**只读 `ls` + 业务前缀 + `--limited-num 1`**，结构化形状。 */
+function ossProbeSpec(oss, ossutil) {
+	const { target } = ossProbeTarget(oss);
+	return {
+		executable: ossutil,
+		args: [
+			"ls",
+			target,
+			...oss.endpoint === "" ? [] : ["--endpoint", oss.endpoint],
+			"--limited-num",
+			"1",
+			...oss.extraArgs
+		]
+	};
+}
+/** 旧字符串模板允许的占位符；出现别的 `{…}` 一律拒绝。 */
+const OSS_PROBE_PLACEHOLDERS = [
+	"ossutil",
+	"bucket",
+	"prefix",
+	"target",
+	"endpoint"
+];
+/**
+* 生成探测命令。
+*
+* **默认路径是结构化的**（`ossProbeSpec` + `shellInvoke`）：部署配置里不需要、也不应该出现
+* 「一段宿主 shell 脚本」。`oss.probeCommand` 作为 **deprecated 兼容路径**保留，但不再是裸替换：
+*
+* - 只认 `{ossutil}` / `{bucket}` / `{prefix}` / `{target}` / `{endpoint}` 五个占位符，别的一律拒绝；
+* - 每个占位符的值**逐个按平台引用**（`shellQuote`）—— 旧实现是把动态值裸拼进去，
+*   于是 endpoint 里一个空格或 `$` 就能改变命令结构；
+* - `{ossutil}` 是**命令位置**，替换成 `shellInvoke(ossutil, [], platform)`（Windows 上带 `&`）；
+* - 拒绝换行、拒绝替换后仍残留的 `{` / `}`、拒绝空可执行文件。
+*
+* 部署配置是管理员写的，但这仍然是外部输入：它进 shell 前必须过同一套边界。
+*/
+function buildOssProbeCommand(oss, ossutil, platform) {
+	if (ossutil === "") return {
+		ok: false,
+		error: "探测命令缺少可执行文件（ossutil 解析失败）"
+	};
+	if (oss.probeCommand === "") {
+		const spec = ossProbeSpec(oss, ossutil);
+		return {
+			ok: true,
+			command: shellInvoke(spec.executable, spec.args, platform),
+			deprecated: false
+		};
+	}
+	const template = oss.probeCommand;
+	if (template.trim() === "") return {
+		ok: false,
+		error: "oss.probeCommand 是空白字符串，请留空使用内置只读探测"
+	};
+	if (/[\r\n]/.test(template)) return {
+		ok: false,
+		error: "oss.probeCommand 不能包含换行"
+	};
+	const { bucket, prefix, target } = ossProbeTarget(oss);
+	const values = {
+		ossutil,
+		bucket,
+		prefix,
+		target,
+		endpoint: oss.endpoint
+	};
+	const unknown = [];
+	const command = template.replace(/\{([A-Za-z0-9_]+)\}/g, (whole, name) => {
+		if (!Object.hasOwn(values, name)) {
+			unknown.push(whole);
+			return whole;
+		}
+		return name === "ossutil" ? shellInvoke(values[name], [], platform) : shellQuote(values[name], platform);
+	});
+	if (unknown.length > 0) return {
+		ok: false,
+		error: `oss.probeCommand 含未知占位符：${[...new Set(unknown)].join(" ")}（只认 ${OSS_PROBE_PLACEHOLDERS.join(" / ")}）`
+	};
+	if (command.includes("{") || command.includes("}")) return {
+		ok: false,
+		error: "oss.probeCommand 含无法识别的花括号，请只使用 {ossutil} {bucket} {prefix} {target} {endpoint}"
+	};
+	return {
+		ok: true,
+		command,
+		deprecated: true
+	};
+}
+/**
+* OSS 失败 → 人话归因。
+*
+* 四类分开（用户口径：错误要"按凭据、权限、配置、网络分别给人话提示"）：
+* - `credential`：`InvalidAccessKeyId` / `SignatureDoesNotMatch` / `InvalidSecurityToken` / `AccessKeyId is disabled`
+*   → 员工重填 AK；
+* - `permission`：`AccessDenied` / `Forbidden` / `no permission`
+*   → 凭据有效但没有这个 Bucket/Prefix 的权限，找管理员开权限；
+* - `config`：`NoSuchBucket` / `InvalidBucketName` / `Endpoint` 解析失败 / `unknown endpoint`
+*   → 部署配置错了，找管理员；
+* - `infrastructure`：上面都不匹配（网络、DNS、超时、TLS、上游 5xx）
+*   → 稍后重试 / 找管理员排查连通性，**不是** AK 的问题。
+*/
+function classifyOssFailure(ok, raw) {
+	const detail = clampOssText(raw);
+	if (ok) return {
+		state: "AK 正常",
+		kind: "",
+		detail
+	};
+	const lower = raw.toLowerCase();
+	if (/invalidaccesskeyid|signaturedoesnotmatch|invalidsaccesskeyid|invalidsecuritytoken|accesskeyid is disabled|accesskeyidisdisabled|invalidaccesskeyid\.notfound/i.test(raw)) return {
+		state: "AccessKey 无效",
+		kind: "credential",
+		detail: detail || "OSS 认为这份 AccessKey 无效或已禁用"
+	};
+	if (/accessdenied|forbidden|no permission|denied/i.test(raw)) return {
+		state: "AccessKey 没有目标权限",
+		kind: "permission",
+		detail: detail || "凭据有效，但没有该 Bucket / 前缀的访问权限"
+	};
+	if (/nosuchbucket|invalidbucketname|unknown endpoint|invalidendpoint|no such host.*oss|endpoint/i.test(lower)) return {
+		state: "Bucket 或 Endpoint 配置有误",
+		kind: "config",
+		detail: detail || "Bucket 或 Endpoint 配置有误（由管理员在部署配置里设置）"
+	};
+	return {
+		state: "连接 OSS 失败",
+		kind: "infrastructure",
+		detail: detail || "无法连接 OSS（网络 / 超时 / 服务不可达）"
+	};
+}
+/** 探测输出的截断 + 脱敏（**唯一**出口，见 `oss/sanitize.ts`）。 */
+function clampOssText(raw) {
+	const clean = sanitizeOssError(raw).trim();
+	return clean.length <= 400 ? clean : `${clean.slice(0, 400)}…`;
+}
+//#endregion
+//#region src/host/platform/home.ts
+/**
+* 用户主目录。
+*
+* 包形态优先用 Host 的 `os.homedir()`：插件就跑在 DSH 进程里，不必再探一次。只有当它与执行
+* 世界不一致（例如 shell 走 SSH/容器，本地主目录不是目标机器的主目录）时，才退回 shell 探测。
+*
+* **探测命令按平台只选一条**（2026-09-28 收紧）：旧实现把三条探测串成一条链
+* （`python3` → `printf` → `$env:USERPROFILE`）在 Windows 上先跑 `python3` —— 系统没装 Python 时
+* 每个探测都会先在 PowerShell 里报一次 command-not-found，日志噪音大、还让人误以为缺依赖。
+* 现在 Windows 只问 PowerShell 自己的环境变量，POSIX 只问 `$HOME`。
+*/
+async function detectHome(ctx, options = {}) {
+	let local = "";
 	try {
 		local = text(homedir()).trim();
 	} catch (error) {
 		local = "";
 	}
 	if (local !== "") return local;
-	for (const probe of [
-		"python3 -c 'import os;print(os.path.expanduser(\"~\"))'",
-		"printf %s \"$HOME\"",
-		"Write-Output $env:USERPROFILE"
-	]) {
-		const line = await commandLine(ctx, probe, {
-			timeoutMs: 15e3,
-			...workdir === void 0 ? {} : { workdir }
-		});
-		if (line !== "") return line;
-	}
-	return "";
+	return await commandLine(ctx, homeProbeCommand(text(options.platform)), {
+		timeoutMs: 15e3,
+		...options.workdir === void 0 ? {} : { workdir: options.workdir }
+	});
 }
 //#endregion
 //#region src/host/oss/cred.ts
@@ -8747,10 +9206,14 @@ async function detectHome(ctx, workdir) {
 * 两条硬约束（`AGENTS.md` §4.3）：AccessKey/STS **绝不回显** —— 读只回脱敏与「有没有」；
 * 写完之后也不回读内容，只回路径与是否成功。文件按 600 权限落盘。
 */
-/** ossutil 配置文件的路径：跟着主目录走，不写死。 */
+/**
+* ossutil 配置文件的路径：跟着主目录走，不写死。
+*
+* 分隔符随主目录风格（Windows 上是 `\`）：这条路径既进提示词与界面，也进 `chmod` / 读取命令。
+*/
 function ossConfigPath(home) {
 	if (home === "") return "~/.ossutilconfig";
-	return `${home.replace(/[\\/]+$/, "")}/.ossutilconfig`;
+	return joinLocalPath(home, ".ossutilconfig");
 }
 /** 解析 ossutil 的 INI 风格配置：`key=value`，忽略注释与段名，键小写。 */
 function parseOssConfig(content) {
@@ -9121,8 +9584,7 @@ async function ossLink(deps, args) {
 		if (url === "") return failed(`签名命令没有输出 URL：${text(run.stdout).slice(0, 200)}`);
 	}
 	if (url.startsWith("http://")) url = `https://${url.slice(7)}`;
-	const command = deps.platform.startsWith("darwin") ? `open ${shellQuote$1(url, deps.platform)}` : deps.platform.startsWith("win32") ? `cmd /c start "" ${shellQuote$1(url, deps.platform)}` : `xdg-open ${shellQuote$1(url, deps.platform)}`;
-	const opened = await runShell(deps.ctx, command, {
+	const opened = await runShell(deps.ctx, openExternalCommand(url, deps.platform), {
 		workdir: await shellWorkdir(deps),
 		timeoutMs: 3e4,
 		escalate: true
@@ -9158,14 +9620,14 @@ async function uploadArtifacts(deps, item, projectId, ossutil, oss) {
 	const prefix = `${oss.prefix}/${projectId === "" ? item.name : projectId}`;
 	const results = [];
 	for (const file of files) {
-		const local = `${item.path.replace(/\/+$/, "")}/${file.name}`;
-		const key = `${prefix}/${file.name}`;
+		const localPath = joinLocalPath(item.path, file.name);
+		const objectKey = `${prefix}/${file.name}`;
 		const argv = [
 			ossutil,
 			"cp",
 			"-f",
-			local,
-			`oss://${oss.bucket}/${key}`
+			localPath,
+			`oss://${oss.bucket}/${objectKey}`
 		];
 		if (oss.endpoint !== "") argv.push("--endpoint", oss.endpoint);
 		for (const extra of oss.extraArgs) argv.push(extra);
@@ -9176,9 +9638,9 @@ async function uploadArtifacts(deps, item, projectId, ossutil, oss) {
 		results.push({
 			kind: file.kind,
 			name: file.name,
-			key,
+			key: objectKey,
 			ok: run.ok,
-			publicUrl: joinUrl(oss.publicBaseUrl, key),
+			publicUrl: joinUrl(oss.publicBaseUrl, objectKey),
 			error: run.ok ? "" : (text(run.stderr) || text(run.error) || "上传失败").slice(0, 400)
 		});
 	}
@@ -9261,8 +9723,7 @@ async function ossCredSave(deps, args) {
 		error,
 		path: "",
 		operation: "",
-		chmodOk: false,
-		chmodError: "",
+		permission: failedPermission(error, deps.platform),
 		probe: null,
 		cred: null
 	});
@@ -9285,13 +9746,12 @@ async function ossCredSave(deps, args) {
 		error: probe.ok ? "" : probe.detail || probe.state || "OSS 验证未通过",
 		path: written.path,
 		operation: written.operation,
-		chmodOk: written.chmodOk,
-		chmodError: written.chmodError,
+		permission: written.permission,
 		probe,
 		cred: await readOssCred(deps.ctx, deps.home)
 	};
 }
-/** 写 `~/.ossutilconfig`，并把权限收紧到 600。 */
+/** 写 `~/.ossutilconfig`，并把权限收紧到 600（Windows 上如实报「继承账户 ACL」）。 */
 async function writeOssCred(deps, input) {
 	const fs = fileSystem(deps.ctx);
 	if (fs === void 0) return {
@@ -9299,49 +9759,45 @@ async function writeOssCred(deps, input) {
 		error: "Host 文件服务不可用",
 		path: "",
 		operation: "",
-		chmodOk: false,
-		chmodError: ""
+		permission: failedPermission("Host 文件服务不可用", deps.platform)
 	};
-	const path = `${deps.home.replace(/[\\/]+$/, "")}/.ossutilconfig`;
+	const path = ossConfigPath(deps.home);
 	const built = buildConfigContent(input);
 	if (!built.ok) return {
 		ok: false,
 		error: built.error,
 		path: "",
 		operation: "",
-		chmodOk: false,
-		chmodError: ""
+		permission: failedPermission(built.error, deps.platform)
 	};
 	let operation = "";
 	try {
 		operation = text((await fs.writeText(await resolveTarget(deps.ctx, path), built.content))?.operation);
 	} catch (error) {
+		const message = `写入 ${path} 失败：${error instanceof Error ? error.message : String(error)}`;
 		return {
 			ok: false,
-			error: `写入 ${path} 失败：${error instanceof Error ? error.message : String(error)}`,
+			error: message,
 			path: "",
 			operation: "",
-			chmodOk: false,
-			chmodError: ""
+			permission: failedPermission(message, deps.platform)
 		};
 	}
-	let chmodOk = true;
-	let chmodError = "";
-	if (!isWindowsPlatform(deps.platform)) {
-		const chmod = await runShell(deps.ctx, `chmod 600 ${shellQuote$1(path, deps.platform)}`, {
-			workdir: await shellWorkdir(deps),
-			timeoutMs: 15e3
-		});
-		chmodOk = chmod.ok;
-		chmodError = chmod.ok ? "" : (text(chmod.stderr) || text(chmod.error) || "权限设置失败").slice(0, 200);
-	}
+	const permission = await enforceCredentialPermission(deps.ctx, path, deps.platform, { workdir: await shellWorkdir(deps) });
 	return {
 		ok: true,
 		error: "",
 		path,
 		operation,
-		chmodOk,
-		chmodError
+		permission
+	};
+}
+/** 写盘都没走到权限那一步时的失败信封（mechanism 与平台一致，status 恒为 failed）。 */
+function failedPermission(message, platform) {
+	return {
+		status: "failed",
+		mechanism: privateFileMechanism(platform),
+		message
 	};
 }
 /** 生成 ossutil 配置内容（`[Credentials]` 段）。 */
@@ -9481,7 +9937,7 @@ function parseH3yunFiles(payload) {
 	return out;
 }
 function joinPath(base, name) {
-	return base.endsWith("/") ? `${base}${name}` : `${base}/${name}`;
+	return joinLocalPath(base, name);
 }
 /** 递归列目录（只名字与大小，深度与数量都设上限）。 */
 async function collectLocal(fs, target, base, relative, depth, out) {
@@ -9568,15 +10024,20 @@ async function reportFiles(deps, args = {}) {
 	const localDir = workspacePath === "" ? "" : joinPath(workspacePath, seqNo);
 	let local = [];
 	let localExists = false;
-	if (localDir !== "" && (localDir === workspacePath || localDir.startsWith(`${workspacePath.replace(/\/+$/, "")}/`))) {
+	if (localDir !== "") {
 		const fs = fileSystem(deps.ctx);
 		if (fs !== void 0) {
 			const target = await resolveTarget(deps.ctx, localDir);
-			if (await fs.listDir(target).catch((error) => {
+			const root = await resolveTarget(deps.ctx, workspacePath).catch((error) => {
 				return null;
-			}) !== null) {
-				localExists = true;
-				await collectLocal(fs, target, localDir, "", 1, local);
+			});
+			if (root !== null && fs.contains(root, target) === true) {
+				if (await fs.listDir(target).catch((error) => {
+					return null;
+				}) !== null) {
+					localExists = true;
+					await collectLocal(fs, target, localDir, "", 1, local);
+				}
 			}
 		}
 	}
@@ -9673,8 +10134,7 @@ async function clipboard(deps, args) {
 		ok: false,
 		error: "没有内容"
 	};
-	const command = deps.platform.startsWith("darwin") ? "pbcopy" : deps.platform.startsWith("win32") ? "clip" : "xclip -selection clipboard 2>/dev/null || xsel -b";
-	const run = await runShell(deps.ctx, command, {
+	const run = await runShell(deps.ctx, clipboardCommand(deps.platform), {
 		workdir: await deps.workdir(),
 		timeoutMs: 2e4,
 		escalate: true,
@@ -9708,8 +10168,7 @@ async function openPath(deps, args) {
 	} catch (error) {
 		return failed(`路径解析失败：${error instanceof Error ? error.message : String(error)}`);
 	}
-	const command = deps.platform.startsWith("darwin") ? `open ${shellQuote$1(path, deps.platform)}` : deps.platform.startsWith("win32") ? `cmd /c start "" ${shellQuote$1(path, deps.platform)}` : `xdg-open ${shellQuote$1(path, deps.platform)}`;
-	const run = await runShell(deps.ctx, command, {
+	const run = await runShell(deps.ctx, openExternalCommand(path, deps.platform), {
 		workdir: await deps.workdir(),
 		timeoutMs: 3e4,
 		escalate: true
@@ -10676,8 +11135,7 @@ async function ifindCredentialSave(deps, args) {
 		error,
 		errorKind,
 		view: written.view,
-		chmodOk: written.chmodOk,
-		chmodError: written.chmodError,
+		permission: written.permission,
 		mode: written.mode,
 		probe: {
 			ok: false,
@@ -10697,14 +11155,13 @@ async function ifindCredentialSave(deps, args) {
 	const probe = await probeIfind(deps.transport ?? defaultIfindTransport(), await readSecretFor(deps), { ...deps.timeoutMs === void 0 ? {} : { timeoutMs: deps.timeoutMs } });
 	return {
 		ok: true,
-		error: written.chmodOk ? "" : `凭据已保存，但权限没有收紧到 0600：${written.chmodError}`,
+		error: written.permission.status === "failed" ? `凭据已保存，但权限没有收紧到 0600：${written.permission.message}` : "",
 		errorKind: "",
 		view: {
 			...written.view,
 			state: probe.state
 		},
-		chmodOk: written.chmodOk,
-		chmodError: written.chmodError,
+		permission: written.permission,
 		mode: written.mode,
 		probe: probeViewOf(probe)
 	};
@@ -11077,7 +11534,7 @@ function createCoreOperations(ctx, config, state, world, resolvers, extra = {})
 			buildKind: HOST_BUILD_KIND,
 			at: (/* @__PURE__ */ new Date()).toISOString(),
 			builtAt: HOST_BUILD_STAMP,
-			protocol: 16
+			protocol: 17
 		}),
 		boot: async () => {
 			await ensureRegistry(ctx, await world.home(), state);
@@ -11089,7 +11546,7 @@ function createCoreOperations(ctx, config, state, world, resolvers, extra = {})
 			});
 			return {
 				ok: true,
-				protocol: 16,
+				protocol: 17,
 				rev: PLUGIN_REV,
 				version: PLUGIN_VERSION,
 				buildKind: HOST_BUILD_KIND,
@@ -12637,7 +13094,7 @@ function createWorldFacts(ctx) {
 			return platform;
 		},
 		async home() {
-			if (home === null) home = await detectHome(ctx);
+			if (home === null) home = await detectHome(ctx, { platform: await this.platform() });
 			return home;
 		},
 		async workdir() {