@lousy-agents/mcp 5.21.6 → 5.21.8

package/dist/mcp-server.js

@@ -6559,7 +6559,7 @@ function escapeJsonPtr(str) {
 
 
 },
-3829(__unused_rspack_module, __unused_rspack___webpack_exports__, __webpack_require__) {
+6732(__unused_rspack_module, __unused_rspack___webpack_exports__, __webpack_require__) {
 // NAMESPACE OBJECT: ../../node_modules/micromark/lib/constructs.js
 var constructs_namespaceObject = {};
 __webpack_require__.r(constructs_namespaceObject);
@@ -37057,7 +37057,7 @@ function byte_budget_normalizeMaxBytes(value, options = {}) {
     if (selected === undefined || selected === Number.POSITIVE_INFINITY)
         return selected;
     if (!Number.isSafeInteger(selected) || selected < 0) {
-        throw new RangeError(`${options.label ?? "maxBytes"} must be a non-negative safe integer or Infinity`);
+        throw new RangeError("maxBytes must be a non-negative safe integer or Infinity");
     }
     return selected;
 }
@@ -37076,7 +37076,7 @@ function isStatValueProvablyDifferent(left, right, platform) {
     }
     return platform !== "win32" || (!isZero(left) && !isZero(right));
 }
-function sha256Hex(data, encoding) {
+function file_identity_sha256Hex(data, encoding) {
     const buffer = typeof data === "string" ? Buffer.from(data, encoding ?? "utf8") : data;
     return (0,external_node_crypto_.createHash)("sha256").update(buffer).digest("hex");
 }
@@ -37087,7 +37087,7 @@ function file_identity_sameFileIdentity(left, right, platform = process.platform
     return (!isStatValueProvablyDifferent(left.dev, right.dev, platform) &&
         !isStatValueProvablyDifferent(left.ino, right.ino, platform));
 }
-function sameFileIdentityForCleanup(left, right, platform = process.platform) {
+function file_identity_sameFileIdentityForCleanup(left, right, platform = process.platform) {
     // A zero Windows device or inode is unknown, not proof that a pathname still
     // names the object we created. Cleanup must fail closed rather than delete a
     // replacement that happens to share the known half of the identity.
@@ -37158,7 +37158,7 @@ function identityCheck(expected, platform) {
 }
 // Retry only unknown Windows identities, retaining every known component so a
 // later observation cannot erase a definite mismatch. Never reopen the file.
-async function inspectFileIdentity(inspect, expected, platform = process.platform) {
+async function strict_file_identity_inspectFileIdentity(inspect, expected, platform = process.platform) {
     const check = identityCheck(expected, platform);
     for (let attempt = 0; attempt < 2; attempt++) {
         const stat = await inspect();
@@ -37167,7 +37167,7 @@ async function inspectFileIdentity(inspect, expected, platform = process.platfor
     }
     throw identityMismatch();
 }
-function inspectFileIdentitySync(inspect, expected, platform = process.platform) {
+function strict_file_identity_inspectFileIdentitySync(inspect, expected, platform = process.platform) {
     const check = identityCheck(expected, platform);
     for (let attempt = 0; attempt < 2; attempt++) {
         const stat = inspect();
@@ -37198,11 +37198,11 @@ function normalizeWindowsPathForComparison(input) {
     // whitespace is part of the path and must not be trimmed away.
     return normalized.replaceAll("/", "\\").toLowerCase();
 }
-function isNodeError(value) {
+function path_isNodeError(value) {
     return Boolean(value && typeof value === "object" && "code" in value);
 }
 function hasNodeErrorCode(value, code) {
-    return isNodeError(value) && value.code === code;
+    return path_isNodeError(value) && value.code === code;
 }
 function path_assertNoNulPathInput(filePath, message = "path contains a NUL byte") {
     if (filePath.includes("\0")) {
@@ -37210,10 +37210,10 @@ function path_assertNoNulPathInput(filePath, message = "path contains a NUL byte
     }
 }
 function path_isNotFoundPathError(value) {
-    return isNodeError(value) && typeof value.code === "string" && NOT_FOUND_CODES.has(value.code);
+    return path_isNodeError(value) && typeof value.code === "string" && NOT_FOUND_CODES.has(value.code);
 }
 function isSymlinkOpenError(value) {
-    return isNodeError(value) && typeof value.code === "string" && SYMLINK_OPEN_CODES.has(value.code);
+    return path_isNodeError(value) && typeof value.code === "string" && SYMLINK_OPEN_CODES.has(value.code);
 }
 function path_isPathInside(root, target) {
     if (process.platform === "win32") {
@@ -37370,7 +37370,7 @@ function normalizeRemovePathError(error) {
     if (error instanceof errors_FsSafeError) {
         return error;
     }
-    if (!isNodeError(error) || typeof error.code !== "string") {
+    if (!path_isNodeError(error) || typeof error.code !== "string") {
         return normalizePinnedPathError(error);
     }
     const cause = error instanceof Error ? error : undefined;
@@ -37382,6 +37382,15 @@ function normalizeRemovePathError(error) {
     }
     return new errors_FsSafeError("not-removable", "path could not be removed", { cause });
 }
+function throwFsSafeReadError(error, label) {
+    if (error instanceof FsSafeError) {
+        throw error;
+    }
+    if (isNodeError(error)) {
+        throw new FsSafeError("read-failed", `${label} target could not be read`, { cause: error });
+    }
+    throw error;
+}
 
 ;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/directory-guard.js
 
@@ -37391,20 +37400,21 @@ function normalizeRemovePathError(error) {
 
 
 
-
-async function directory_guard_createAsyncDirectoryGuard(dir) {
-    const stat = await promises_.lstat(dir);
+async function directory_guard_createAsyncDirectoryGuard(dir, options) {
+    const stat = options?.bigint ? await inspectDirectoryIdentity(dir) : external_node_fs_.lstatSync(dir);
     if (stat.isSymbolicLink() || !stat.isDirectory()) {
         throw root_errors_directoryComponentNotDirectoryError();
     }
-    return { dir, realPath: await promises_.realpath(dir), stat };
+    return { dir, realPath: external_node_fs_.realpathSync.native(dir), stat };
 }
-async function assertAsyncDirectoryGuard(guard) {
-    const stat = await promises_.lstat(guard.dir);
+async function directory_guard_assertAsyncDirectoryGuard(guard) {
+    const stat = typeof guard.stat.dev === "bigint" && typeof guard.stat.ino === "bigint"
+        ? await inspectDirectoryIdentity(guard.dir, { dev: guard.stat.dev, ino: guard.stat.ino })
+        : external_node_fs_.lstatSync(guard.dir);
     if (stat.isSymbolicLink() || !stat.isDirectory()) {
         throw root_errors_directoryComponentNotDirectoryError();
     }
-    if (!file_identity_sameFileIdentity(stat, guard.stat) || (await promises_.realpath(guard.dir)) !== guard.realPath) {
+    if (!file_identity_sameFileIdentity(stat, guard.stat) || external_node_fs_.realpathSync.native(guard.dir) !== guard.realPath) {
         throw new errors_FsSafeError("path-mismatch", "directory changed during operation");
     }
 }
@@ -37424,12 +37434,12 @@ function directory_guard_assertSyncDirectoryGuard(guard) {
         throw new FsSafeError("path-mismatch", "directory changed during operation");
     }
 }
-async function directory_guard_createNearestExistingDirectoryGuard(rootReal, targetPath) {
+async function directory_guard_createNearestExistingDirectoryGuard(rootReal, targetPath, options = { bigint: false }) {
     let current = external_node_path_.resolve(targetPath);
     const root = external_node_path_.resolve(rootReal);
     while (current !== root) {
         try {
-            return await directory_guard_createAsyncDirectoryGuard(current);
+            return await directory_guard_createAsyncDirectoryGuard(current, options);
         }
         catch (error) {
             if (!path_isNotFoundPathError(error)) {
@@ -37438,7 +37448,7 @@ async function directory_guard_createNearestExistingDirectoryGuard(rootReal, tar
             current = external_node_path_.dirname(current);
         }
     }
-    return await directory_guard_createAsyncDirectoryGuard(root);
+    return await directory_guard_createAsyncDirectoryGuard(root, options);
 }
 function directory_guard_createNearestExistingSyncDirectoryGuard(rootReal, targetPath) {
     let current = path.resolve(targetPath);
@@ -37458,8 +37468,8 @@ function directory_guard_createNearestExistingSyncDirectoryGuard(rootReal, targe
 }
 // Recovery receipts must retain every identity bit, including on Windows.
 async function inspectDirectoryIdentity(dir, expected) {
-    return await inspectFileIdentity(async () => {
-        const stat = await promises_.lstat(dir, { bigint: true });
+    return await strict_file_identity_inspectFileIdentity(async () => {
+        const stat = external_node_fs_.lstatSync(dir, { bigint: true });
         if (stat.isSymbolicLink() || !stat.isDirectory())
             throw root_errors_directoryComponentNotDirectoryError();
         return stat;
@@ -37512,11 +37522,11 @@ function assertDirectory(identity, pathname, label) {
 }
 async function createDirectoryReceipt(directoryPath, label) {
     const resolvedPath = external_node_path_.resolve(directoryPath);
-    const identity = await promises_.lstat(resolvedPath);
+    const identity = external_node_fs_.lstatSync(resolvedPath);
     assertDirectory(identity, resolvedPath, label);
     return {
         path: resolvedPath,
-        realPath: await promises_.realpath(resolvedPath),
+        realPath: external_node_fs_.realpathSync.native(resolvedPath),
         identity,
     };
 }
@@ -37531,10 +37541,10 @@ function createDirectoryReceiptSync(directoryPath, label) {
     };
 }
 async function assertDirectoryReceiptCurrent(receipt, label) {
-    const currentIdentity = await promises_.lstat(receipt.path);
+    const currentIdentity = external_node_fs_.lstatSync(receipt.path);
     assertDirectory(currentIdentity, receipt.path, label);
     if (!file_identity_sameFileIdentity(receipt.identity, currentIdentity) ||
-        (await promises_.realpath(receipt.path)) !== receipt.realPath) {
+        (external_node_fs_.realpathSync.native(receipt.path)) !== receipt.realPath) {
         throw new errors_FsSafeError("path-mismatch", `${label} changed during durable directory operation: ${receipt.path}`);
     }
 }
@@ -37547,7 +37557,7 @@ function assertDirectoryReceiptCurrentSync(receipt, label) {
     }
 }
 async function assertOpenDirectoryCurrent(handle, receipt, label) {
-    const openedIdentity = await handle.stat();
+    const openedIdentity = external_node_fs_.fstatSync(handle.fd);
     assertDirectory(openedIdentity, receipt.path, label);
     if (!file_identity_sameFileIdentity(receipt.identity, openedIdentity)) {
         throw new errors_FsSafeError("path-mismatch", `${label} handle changed during directory sync: ${receipt.path}`);
@@ -37774,13 +37784,14 @@ async function ensureDurableDirectory(options) {
 
 
 
+
 function isSameOrChildPath(candidate, parent) {
     const parentPrefix = parent.endsWith(external_node_path_.sep) ? parent : `${parent}${external_node_path_.sep}`;
     return candidate === parent || candidate.startsWith(parentPrefix);
 }
 async function realpathOrThrowNotFile(target) {
     try {
-        return external_node_path_.resolve(await promises_.realpath(target));
+        return external_node_path_.resolve(external_node_fs_.realpathSync.native(target));
     }
     catch (error) {
         if (path_isNotFoundPathError(error)) {
@@ -37799,7 +37810,7 @@ async function realpathOrThrowNotFile(target) {
  */
 async function mkdirPathComponentsWithGuards(params) {
     const root = external_node_path_.resolve(params.rootReal);
-    const rootCanonical = external_node_path_.resolve(await promises_.realpath(root));
+    const rootCanonical = external_node_path_.resolve(external_node_fs_.realpathSync.native(root));
     const target = external_node_path_.resolve(params.targetPath);
     const relative = external_node_path_.relative(root, target);
     if (isPathRelativeEscape(relative)) {
@@ -37809,18 +37820,18 @@ async function mkdirPathComponentsWithGuards(params) {
     for (const part of relative.split(external_node_path_.sep).filter(Boolean)) {
         const next = external_node_path_.join(current, part);
         const parentGuard = await directory_guard_createAsyncDirectoryGuard(current);
-        await assertAsyncDirectoryGuard(parentGuard);
+        await directory_guard_assertAsyncDirectoryGuard(parentGuard);
         await params.beforeComponent?.(next);
         try {
-            await promises_.mkdir(next);
+            await promises_.mkdir(next, { mode: params.mode });
         }
         catch (error) {
             if (!error || typeof error !== "object" || !("code" in error) || error.code !== "EEXIST") {
                 throw error;
             }
         }
-        const stat = await promises_.lstat(next);
-        if (!stat.isSymbolicLink() && !stat.isDirectory()) {
+        const stat = external_node_fs_.lstatSync(next);
+        if ((params.rejectSymlinks && stat.isSymbolicLink()) || (!stat.isSymbolicLink() && !stat.isDirectory())) {
             throw root_errors_directoryComponentNotDirectoryError();
         }
         // Node's recursive mkdir follows symlinks in missing components. Build one
@@ -37839,17 +37850,17 @@ async function mkdirPathComponentsWithGuards(params) {
             // every subsequent segment. Callers that need the final directory
             // (e.g. to guard it themselves after this function returns) must use
             // the returned resolved path, not their own lexical parent path.
-            const targetStat = await promises_.stat(nextReal);
+            const targetStat = external_node_fs_.statSync(nextReal);
             if (!targetStat.isDirectory()) {
                 throw root_errors_directoryComponentNotDirectoryError();
             }
             await directory_guard_createAsyncDirectoryGuard(nextReal);
-            await assertAsyncDirectoryGuard(parentGuard);
+            await directory_guard_assertAsyncDirectoryGuard(parentGuard);
             current = nextReal;
             continue;
         }
         await directory_guard_createAsyncDirectoryGuard(next);
-        await assertAsyncDirectoryGuard(parentGuard);
+        await directory_guard_assertAsyncDirectoryGuard(parentGuard);
         current = next;
     }
     return current;
@@ -37862,13 +37873,13 @@ async function mkdirPathComponentsWithGuards(params) {
 
 async function withAsyncDirectoryGuards(guards, mutate, options = {}) {
     for (const guard of guards) {
-        await assertAsyncDirectoryGuard(guard);
+        await directory_guard_assertAsyncDirectoryGuard(guard);
     }
     const result = await mutate();
     if (options.verifyAfter !== false) {
         try {
             for (const guard of guards) {
-                await assertAsyncDirectoryGuard(guard);
+                await directory_guard_assertAsyncDirectoryGuard(guard);
             }
         }
         catch (error) {
@@ -37906,9 +37917,13 @@ async function guardedRename(params) {
         ? await createNearestExistingDirectoryGuard(params.targetRoot, path.dirname(params.to))
         : await createAsyncDirectoryGuard(path.dirname(params.to));
     await withAsyncDirectoryGuards([sourceGuard, targetGuard], async () => {
+        if (params.onSourceInspected) {
+            params.onSourceInspected(fsSync.lstatSync(params.from, { bigint: true }));
+        }
         // Authority must survive all awaited guards; do not yield before rename dispatch.
         params.assertBeforeRename?.();
         await fs.rename(params.from, params.to);
+        params.onRenamed?.();
     }, { verifyAfter: params.verifyAfter });
 }
 function guardedRenameSync(params) {
@@ -37939,13 +37954,12 @@ function guardedRmSync(params) {
 
 
 
-
 function isFilesystemRoot(candidate) {
     return external_node_path_.parse(candidate).root === candidate;
 }
-async function pathExists(targetPath) {
+async function root_path_existing_pathExists(targetPath) {
     try {
-        await promises_.lstat(targetPath);
+        external_node_fs_.lstatSync(targetPath);
         return true;
     }
     catch (error) {
@@ -37959,7 +37973,7 @@ async function resolvePathViaExistingAncestor(targetPath) {
     const normalized = external_node_path_.resolve(targetPath);
     let cursor = normalized;
     const missingSuffix = [];
-    while (!isFilesystemRoot(cursor) && !(await pathExists(cursor))) {
+    while (!isFilesystemRoot(cursor) && !(await root_path_existing_pathExists(cursor))) {
         missingSuffix.unshift(external_node_path_.basename(cursor));
         const parent = external_node_path_.dirname(cursor);
         if (parent === cursor) {
@@ -37967,11 +37981,11 @@ async function resolvePathViaExistingAncestor(targetPath) {
         }
         cursor = parent;
     }
-    if (!(await pathExists(cursor))) {
+    if (!(await root_path_existing_pathExists(cursor))) {
         return normalized;
     }
     try {
-        const resolvedAncestor = external_node_path_.resolve(await promises_.realpath(cursor));
+        const resolvedAncestor = external_node_path_.resolve(external_node_fs_.realpathSync.native(cursor));
         return missingSuffix.length === 0
             ? resolvedAncestor
             : external_node_path_.resolve(resolvedAncestor, ...missingSuffix);
@@ -38081,10 +38095,15 @@ function mergeDenyMutationPolicies(defaultPolicy, callPolicy) {
 
 
 
+
 function recordFileOpenFailure(error, filePath) {
     recordFileObservationFailure(error, `open:${filePath}`);
     throw error;
 }
+function recordExclusiveCreateFailure(error, filePath) {
+    recordFileObservationFailure(error, `exclusive-create:${filePath}`);
+    throw error;
+}
 function openedPathResolutionError(error = new errors_FsSafeError("path-mismatch", "unable to resolve opened file path")) {
     recordFileObservationFailure(error, "resolution");
     return error;
@@ -38094,8 +38113,8 @@ async function recordPreOpenFileChange(error, handle, filePath, before, opened)
         ![0n, 1n].includes(before.nlink) || ![0n, 1n].includes(opened.nlink))
         return;
     try {
-        await inspectFileIdentity(async () => before);
-        const current = await inspectFileIdentity(() => handle.stat({ bigint: true }), opened);
+        await strict_file_identity_inspectFileIdentity(async () => before);
+        const current = await strict_file_identity_inspectFileIdentity(() => external_node_fs_.fstatSync(handle.fd, { bigint: true }), opened);
         if (current.isFile() && [0n, 1n].includes(current.nlink) &&
             (before.dev !== current.dev || before.ino !== current.ino)) {
             // A stale pathname sample is not proof that its former inode was unlinked.
@@ -38111,7 +38130,7 @@ async function recordOpenedFileFailure(error, handle, filePath, identity) {
         !identity.isFile() || identity.nlink > 1n)
         return;
     try {
-        const current = await inspectFileIdentity(() => handle.stat({ bigint: true }), identity);
+        const current = await strict_file_identity_inspectFileIdentity(() => external_node_fs_.fstatSync(handle.fd, { bigint: true }), identity);
         if (current.isFile() && current.nlink === 0n)
             recordFileObservationFailure(error, `unlinked:${filePath}`);
     }
@@ -38126,24 +38145,23 @@ async function recordOpenedFileFailure(error, handle, filePath, identity) {
 
 
 
+
 async function resolveOpenedFileRealPathForHandle(handle, ioPath) {
-    const handleStat = await handle.stat();
-    return await resolveOpenedFileRealPathForFd(handle.fd, handleStat, ioPath);
+    const handleStat = external_node_fs_.fstatSync(handle.fd);
+    return (await resolveOpenedFileRealPathForFd(handle.fd, handleStat, ioPath)).realPath;
 }
 async function resolveOpenedFileRealPathForFd(fd, handleStat, ioPath) {
     const statOptions = typeof handleStat.dev === "bigint" || typeof handleStat.ino === "bigint"
         ? { bigint: true } : undefined;
     const fdCandidates = process.platform === "linux"
         ? [`/proc/self/fd/${fd}`, `/dev/fd/${fd}`]
-        : process.platform === "win32"
-            ? []
-            : [`/dev/fd/${fd}`];
+        : [];
     for (const fdPath of fdCandidates) {
         try {
-            const fdRealPath = await promises_.realpath(fdPath);
-            const fdRealStat = statOptions ? await promises_.stat(fdRealPath, statOptions) : await promises_.stat(fdRealPath);
+            const fdRealPath = external_node_fs_.realpathSync.native(fdPath);
+            const fdRealStat = statOptions ? external_node_fs_.statSync(fdRealPath, statOptions) : external_node_fs_.statSync(fdRealPath);
             if (file_identity_sameFileIdentity(handleStat, fdRealStat)) {
-                return fdRealPath;
+                return { realPath: fdRealPath, stat: fdRealStat };
             }
         }
         catch {
@@ -38151,10 +38169,10 @@ async function resolveOpenedFileRealPathForFd(fd, handleStat, ioPath) {
         }
     }
     try {
-        const ioRealPath = await promises_.realpath(ioPath);
-        const ioRealStat = statOptions ? await promises_.stat(ioRealPath, statOptions) : await promises_.stat(ioRealPath);
+        const ioRealPath = external_node_fs_.realpathSync.native(ioPath);
+        const ioRealStat = statOptions ? external_node_fs_.statSync(ioRealPath, statOptions) : external_node_fs_.statSync(ioRealPath);
         if (file_identity_sameFileIdentity(handleStat, ioRealStat)) {
-            return ioRealPath;
+            return { realPath: ioRealPath, stat: ioRealStat };
         }
     }
     catch (err) {
@@ -38177,7 +38195,7 @@ async function resolveOpenedFileRealPathForFd(fd, handleStat, ioPath) {
 async function resolveOpenedFileRealPathFromParent(handleStat, ioPath, statOptions) {
     let parentReal;
     try {
-        parentReal = await promises_.realpath(external_node_path_.dirname(ioPath));
+        parentReal = external_node_fs_.realpathSync.native(external_node_path_.dirname(ioPath));
     }
     catch (err) {
         if (path_isNotFoundPathError(err)) {
@@ -38198,9 +38216,12 @@ async function resolveOpenedFileRealPathFromParent(handleStat, ioPath, statOptio
     for (const entry of entries.toSorted()) {
         const candidatePath = external_node_path_.join(parentReal, entry);
         try {
-            const candidateStat = statOptions ? await promises_.lstat(candidatePath, statOptions) : await promises_.lstat(candidatePath);
+            const candidateStat = statOptions ? external_node_fs_.lstatSync(candidatePath, statOptions) : external_node_fs_.lstatSync(candidatePath);
             if (candidateStat.isFile() && file_identity_sameFileIdentity(handleStat, candidateStat)) {
-                return await promises_.realpath(candidatePath);
+                const realPath = external_node_fs_.realpathSync.native(candidatePath);
+                const stat = statOptions ? external_node_fs_.statSync(realPath, statOptions) : external_node_fs_.statSync(realPath);
+                if (file_identity_sameFileIdentity(handleStat, stat))
+                    return { realPath, stat };
             }
         }
         catch (err) {
@@ -38212,6 +38233,27 @@ async function resolveOpenedFileRealPathFromParent(handleStat, ioPath, statOptio
     return null;
 }
 
+;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/file-sync.js
+
+async function syncFileBestEffort(handle) {
+    try {
+        await handle.sync();
+    }
+    catch (error) {
+        if (error?.code !== "EPERM")
+            throw error;
+    }
+}
+function syncFileBestEffortSync(fd, fsModule = external_node_fs_) {
+    try {
+        fsModule.fsyncSync(fd);
+    }
+    catch (error) {
+        if (error?.code !== "EPERM")
+            throw error;
+    }
+}
+
 // EXTERNAL MODULE: external "node:module"
 var external_node_module_ = __webpack_require__(8995);
 ;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/native-config.js
@@ -38471,7 +38513,7 @@ function getNativeBinding() {
     }
     return undefined;
 }
-function requireNativeBinding() {
+function native_requireNativeBinding() {
     const native = getNativeBinding();
     if (!native) {
         throw new FsSafeError("helper-unavailable", "native fs-safe helper is unavailable", {
@@ -38558,15 +38600,14 @@ function removeNativeCreatedFileIfStillPinned(params) {
         return;
     }
     try {
-        const parentPathStat = external_node_fs_.lstatSync(params.parentPath);
-        const parentFdStat = params.binding.fstatIdentity(params.parentFd);
+        const parentPathStat = external_node_fs_.lstatSync(params.parentPath, { bigint: true });
+        const parentFdStat = external_node_fs_.fstatSync(params.parentFd, { bigint: true });
         const targetPath = external_node_path_.join(params.parentPath, params.basename);
-        const target = external_node_fs_.lstatSync(targetPath);
-        if (!parentPathStat.isSymbolicLink() &&
-            parentPathStat.dev === parentFdStat.dev &&
-            parentPathStat.ino === parentFdStat.ino &&
-            !target.isSymbolicLink() &&
-            sameFileIdentityForCleanup(target, params.created)) {
+        const target = external_node_fs_.lstatSync(targetPath, { bigint: true });
+        if (!parentPathStat.isSymbolicLink() && parentPathStat.isDirectory() &&
+            file_identity_sameFileIdentityForCleanup(parentPathStat, parentFdStat) &&
+            !target.isSymbolicLink() && target.isFile() &&
+            file_identity_sameFileIdentityForCleanup(target, params.created)) {
             external_node_fs_.rmSync(targetPath);
         }
     }
@@ -38603,7 +38644,7 @@ async function createNativeExclusiveFile(targetPath, mode) {
         }
         fd = opened.fd;
         external_node_fs_.fchmodSync(fd, mode);
-        created = external_node_fs_.fstatSync(fd);
+        created = external_node_fs_.fstatSync(fd, { bigint: true });
         return wrapNativeFd(fd, opened.containment);
     }
     catch (error) {
@@ -38615,7 +38656,6 @@ async function createNativeExclusiveFile(targetPath, mode) {
                 // Preserve the original error.
             }
             removeNativeCreatedFileIfStillPinned({
-                binding,
                 parentPath,
                 parentFd: parent.fd,
                 basename,
@@ -38628,22 +38668,14 @@ async function createNativeExclusiveFile(targetPath, mode) {
         await parent.close().catch(() => undefined);
     }
 }
-function syncNativeFileBestEffort(fd) {
-    try {
-        external_node_fs_.fsyncSync(fd);
-    }
-    catch (error) {
-        if (error.code !== "EPERM") {
-            throw error;
-        }
-    }
-}
 
 ;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/native-pinned-write-windows.js
 
 
 
 
+
+
 function sameNativeIdentity(left, right) {
     return left.dev === right.dev && left.ino === right.ino;
 }
@@ -38668,14 +38700,15 @@ async function runPinnedWriteWindows(binding, params, root, parentFd, parentGuar
     try {
         tempName = `.fs-safe-${(0,external_node_crypto_.randomUUID)()}.tmp`;
         tempFd = binding.openBeneath(parentFd, tempName, nativeOpenFlags(external_node_fs_.constants.O_WRONLY | external_node_fs_.constants.O_CREAT | external_node_fs_.constants.O_EXCL)).fd;
-        tempIdentity = external_node_fs_.fstatSync(tempFd);
-        const verificationIdentity = external_node_fs_.fstatSync(tempFd, { bigint: true });
+        const verificationIdentity = strict_file_identity_inspectFileIdentitySync(() => external_node_fs_.fstatSync(tempFd, { bigint: true }));
+        tempIdentity = verificationIdentity;
         // Creation is requested at 0600 in the binding, but a restrictive umask
         // can remove owner access. Keep the unpublished inode private and
         // reopenable until the published name has been identity-fenced.
         external_node_fs_.fchmodSync(tempFd, 0o600);
         await writeNativeInput(tempFd, params.input, params.maxBytes);
-        syncNativeFileBestEffort(tempFd);
+        if (params.sync !== false)
+            syncFileBestEffortSync(tempFd);
         if (params.overwrite === false) {
             binding.renameNoReplace(parentFd, tempName, parentFd, params.basename);
         }
@@ -38684,8 +38717,9 @@ async function runPinnedWriteWindows(binding, params, root, parentFd, parentGuar
         }
         renamed = true;
         targetFd = binding.openBeneath(parentFd, params.basename, nativeOpenFlags(external_node_fs_.constants.O_RDONLY)).fd;
+        const targetStat = strict_file_identity_inspectFileIdentitySync(() => external_node_fs_.fstatSync(targetFd, { bigint: true }), verificationIdentity);
         const targetIdentity = binding.fstatIdentity(targetFd);
-        if (!targetIdentity.isFile || !sameNativeIdentity(tempIdentity, targetIdentity)) {
+        if (!targetStat.isFile()) {
             throw new errors_FsSafeError("path-mismatch", "native write target changed after rename");
         }
         // Native exclusive creation starts at 0600. Apply the requested mode only
@@ -38693,13 +38727,13 @@ async function runPinnedWriteWindows(binding, params, root, parentFd, parentGuar
         // verifiable and so broader modes are never exposed before that fence.
         try {
             external_node_fs_.fchmodSync(targetFd, params.mode);
-            syncNativeFileBestEffort(targetFd);
+            if (params.sync !== false)
+                syncFileBestEffortSync(targetFd);
         }
         catch (error) {
             closeWriteFd(targetFd);
             targetFd = undefined;
             removeNativeCreatedFileIfStillPinned({
-                binding,
                 parentPath,
                 parentFd,
                 basename: params.basename,
@@ -38707,7 +38741,8 @@ async function runPinnedWriteWindows(binding, params, root, parentFd, parentGuar
             });
             throw error;
         }
-        syncNativeFileBestEffort(parentFd);
+        if (params.sync !== false)
+            syncFileBestEffortSync(parentFd);
         // Verification follows publication and final chmod, outside rollback handling.
         await params.verifyPublished?.(targetFd, verificationIdentity, parentGuard);
         completed = true;
@@ -38718,7 +38753,6 @@ async function runPinnedWriteWindows(binding, params, root, parentFd, parentGuar
         const tempCloseError = closeWriteFd(tempFd);
         if (!renamed) {
             removeNativeCreatedFileIfStillPinned({
-                binding,
                 parentPath,
                 parentFd,
                 basename: tempName,
@@ -38763,7 +38797,7 @@ function assertStagedDirectoryCurrent(receipt) {
         throw new errors_FsSafeError("path-mismatch", "staging directory pathname changed");
     }
 }
-function openStagedDirectory(directory) {
+function staged_directory_openStagedDirectory(directory) {
     // Copy supplied facts before any asynchronous work; receipts are not authority.
     const pathname = path.resolve(typeof directory === "string" ? directory : directory.path);
     const expected = typeof directory === "string" ? undefined : {
@@ -38853,6 +38887,8 @@ var __disposeResources = (undefined && undefined.__disposeResources) || (functio
 
 
 
+
+
 function assertNativeStaging(binding) {
     if ([
         binding.createStagedFile,
@@ -38888,23 +38924,25 @@ class NativeStagedFile {
     #directory;
     #portableNames;
     #publishedMode;
+    #sync;
     #name = `.fs-safe-${(0,external_node_crypto_.randomUUID)()}.tmp`;
     #state = { status: "open", publication: NOT_PUBLISHED };
     #receipt;
-    constructor(binding, parentFd, directory, portableNames, publishedMode) {
+    constructor(binding, parentFd, directory, portableNames, publishedMode, sync) {
         this.#binding = binding;
         this.#parentFd = parentFd;
         this.#directory = directory;
         this.#portableNames = portableNames;
         this.#publishedMode = publishedMode;
+        this.#sync = sync;
     }
     // Takes ownership of parentFd, including all construction and preparation failures.
     static async create(binding, parentFd, directory, input, mode, maxBytes, 
     // Public staging uses portable names; existing POSIX writes accept literal names.
-    portableNames = true) {
+    portableNames = true, sync = true) {
         let staged;
         try {
-            staged = new NativeStagedFile(binding, parentFd, directory, portableNames, mode);
+            staged = new NativeStagedFile(binding, parentFd, directory, portableNames, mode, sync);
         }
         catch (error) {
             try {
@@ -38923,7 +38961,7 @@ class NativeStagedFile {
         try {
             // This owner never escapes. Only the internal verifier borrows its fd;
             // public descriptor methods remain await-free and cannot race disposal.
-            const staged = __addDisposableResource(env_1, await NativeStagedFile.create(binding, parentFd, directory, params.input, params.mode, params.maxBytes, false), true);
+            const staged = __addDisposableResource(env_1, await NativeStagedFile.create(binding, parentFd, directory, params.input, params.mode, params.maxBytes, false, params.sync), true);
             const published = await staged.publish(params.basename, { overwrite: params.overwrite !== false });
             const identity = published.staged.identity;
             await params.verifyPublished?.(staged.#file(), identity, parentGuard);
@@ -38960,10 +38998,12 @@ class NativeStagedFile {
     }
     #assertNamed(name) {
         const fd = this.#file();
-        if (!this.#binding.stagedFileMatches(this.#parentFd, name, fd) ||
-            external_node_fs_.fstatSync(fd, { bigint: true }).nlink !== 1n) {
+        const stat = this.#binding.stagedFileMatches(this.#parentFd, name, fd)
+            ? external_node_fs_.fstatSync(fd, { bigint: true }) : undefined;
+        if (!stat || stat.nlink !== 1n) {
             throw new errors_FsSafeError("path-mismatch", "staged entry no longer names the exclusive created file");
         }
+        return Number(stat.mode & 4095n);
     }
     #assertCurrent() {
         if (this.#open().publication.status !== "not-published") {
@@ -38986,7 +39026,8 @@ class NativeStagedFile {
             const fd = state.fileFd;
             external_node_fs_.fchmodSync(fd, 0o600);
             await writeNativeInput(fd, input, maxBytes);
-            syncNativeFileBestEffort(fd);
+            if (this.#sync)
+                syncFileBestEffortSync(fd);
             const stat = external_node_fs_.fstatSync(fd, { bigint: true });
             this.#receipt = Object.freeze({
                 directory: this.#directory,
@@ -39053,14 +39094,21 @@ class NativeStagedFile {
                 overwrite,
             });
             state.publication = receipt;
-            this.#assertNamed(basename);
+            const stagedMode = this.#assertNamed(basename);
             assertStagedDirectoryCurrent(this.#directory);
             // Keep contents private until the published name passes its identity
             // fence. Mode changes use the owned fd, including for final mode 000.
             const fd = this.#file();
-            external_node_fs_.fchmodSync(fd, this.#publishedMode);
-            syncNativeFileBestEffort(fd);
-            syncNativeFileBestEffort(this.#parentFd);
+            if (this.#publishedMode !== 0o600 || stagedMode !== 0o600)
+                external_node_fs_.fchmodSync(fd, this.#publishedMode);
+            // With sync enabled, content was synced before rename. A lost chmod leaves staged 0600,
+            // no wider than modes retaining owner rw. Restrictive modes and observed
+            // widening of the stage still need the permission correction made durable.
+            if (this.#sync && ((this.#publishedMode & 0o600) !== 0o600 || (stagedMode & ~this.#publishedMode) !== 0)) {
+                syncFileBestEffortSync(fd);
+            }
+            if (this.#sync)
+                syncFileBestEffortSync(this.#parentFd);
             this.#assertNamed(basename);
             assertStagedDirectoryCurrent(this.#directory);
             return receipt;
@@ -39133,6 +39181,17 @@ class NativeStagedFile {
 }
 const createNativeStage = NativeStagedFile.create;
 const writeNativeStage = NativeStagedFile.write;
+async function stageFileInDirectory(options) {
+    if (process.platform !== "linux" && process.platform !== "darwin") {
+        throw new FsSafeError("unsupported-platform", "retained-directory staging requires Linux or macOS");
+    }
+    const binding = requireNativeBinding();
+    assertNativeStaging(binding);
+    const input = { kind: "buffer", data: Buffer.from(options.content) };
+    const mode = options.mode ?? 0o600;
+    const parent = openStagedDirectory(options.directory);
+    return await createNativeStage(binding, parent.fd, parent.receipt, input, mode);
+}
 
 ;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/native-pinned-write.js
 var native_pinned_write_addDisposableResource = (undefined && undefined.__addDisposableResource) || function (env, value, async) {
@@ -39194,6 +39253,8 @@ var native_pinned_write_disposeResources = (undefined && undefined.__disposeReso
 
 
 
+
+
 async function runPinnedWriteNative(binding, params) {
     const env_1 = { stack: [], error: void 0, hasError: false };
     try {
@@ -39216,8 +39277,14 @@ async function runPinnedWriteNative(binding, params) {
             },
         }, false);
         try {
+            const exactRoot = typeof params.rootIdentity?.dev === "bigint" && typeof params.rootIdentity.ino === "bigint"
+                ? { dev: params.rootIdentity.dev, ino: params.rootIdentity.ino } : undefined;
             let rootMatches;
-            if (windows) {
+            if (exactRoot) {
+                strict_file_identity_inspectFileIdentitySync(() => external_node_fs_.fstatSync(root.fd, { bigint: true }), exactRoot);
+                rootMatches = true;
+            }
+            else if (windows) {
                 const identity = binding.fstatIdentity(root.fd);
                 rootMatches = !params.rootIdentity || sameNativeIdentity(params.rootIdentity, identity);
             }
@@ -39232,24 +39299,26 @@ async function runPinnedWriteNative(binding, params) {
                 binding.mkdirBeneath(root.fd, params.relativeParentPath, 0o777);
             }
             parentFd = binding.openBeneath(root.fd, params.relativeParentPath, directoryFlags).fd;
-            const parentPath = await promises_.realpath(params.relativeParentPath
+            const parentPath = external_node_fs_.realpathSync.native(params.relativeParentPath
                 ? external_node_path_.join(params.rootPath, ...params.relativeParentPath.split("/"))
                 : params.rootPath);
             const directory = windows ? undefined : describeStagedDirectory(parentFd, parentPath);
-            const parentPathStat = await promises_.lstat(parentPath);
-            if (windows) {
+            const parentPathStat = exactRoot
+                ? await inspectDirectoryIdentity(parentPath, strict_file_identity_inspectFileIdentitySync(() => external_node_fs_.fstatSync(parentFd, { bigint: true })))
+                : external_node_fs_.lstatSync(parentPath);
+            if (windows && !exactRoot) {
                 const parentIdentity = binding.fstatIdentity(parentFd);
                 if (parentPathStat.isSymbolicLink() || !sameNativeIdentity(parentPathStat, parentIdentity)) {
                     throw new errors_FsSafeError("path-mismatch", "native write parent changed during resolution");
                 }
             }
-            else if (parentPathStat.isSymbolicLink() || !exactIdentityMatches(parentPathStat, directory.identity)) {
+            else if (!windows && (parentPathStat.isSymbolicLink() || !exactIdentityMatches(parentPathStat, directory.identity))) {
                 throw new errors_FsSafeError("path-mismatch", "native write parent changed during resolution");
             }
             const verificationGuard = { dir: parentPath, realPath: parentPath, stat: parentPathStat };
             if (params.overwrite === false) {
                 try {
-                    await promises_.lstat(external_node_path_.join(parentPath, params.basename));
+                    external_node_fs_.lstatSync(external_node_path_.join(parentPath, params.basename));
                     throw Object.assign(new Error("destination already exists"), { code: "EEXIST" });
                 }
                 catch (error) {
@@ -39339,6 +39408,384 @@ function read_open_flags_resolveReadOpenFlags(options) {
     return constants.O_RDONLY | noFollow | nonBlocking;
 }
 
+;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/replace-file-temp-owner.js
+
+
+
+
+
+
+
+
+const PUBLISHED_READ_FLAGS = read_open_flags_resolveReadOpenFlags();
+function assertOwnedFile(stat, pathname, pathnameEntry) {
+    if (stat.isSymbolicLink()) {
+        throw new FsSafeError("symlink", `Atomic replace owned file became a symlink: ${pathname}`);
+    }
+    if (!stat.isFile()) {
+        throw new FsSafeError("not-file", `Atomic replace owned file must remain regular: ${pathname}`);
+    }
+    if (stat.nlink > 1n || (pathnameEntry && stat.nlink !== 1n)) {
+        throw new FsSafeError("hardlink", `Atomic replace owned file must retain one link: ${pathname}`);
+    }
+}
+function missingOwnedFile(pathname, cause) {
+    return new FsSafeError("path-mismatch", `Atomic replace owned file disappeared: ${pathname}`, {
+        cause,
+    });
+}
+function cleanupFailure(originalError, cleanupError) {
+    if (originalError !== undefined) {
+        return new Error(`Atomic file replace failed (${String(originalError)}); cleanup also failed (${String(cleanupError)})`, { cause: originalError });
+    }
+    return cleanupError instanceof Error ? cleanupError : new Error(String(cleanupError));
+}
+async function cleanupOwnedPath(params) {
+    if (!params.identity)
+        return true;
+    try {
+        const current = params.fsModule === promises_
+            ? external_node_fs_.lstatSync(params.pathname, { bigint: true })
+            : await params.fsModule.lstat(params.pathname, { bigint: true });
+        if (current.isSymbolicLink() ||
+            !current.isFile() ||
+            current.nlink !== 1n ||
+            !file_identity_sameFileIdentityForCleanup(current, params.identity)) {
+            return true;
+        }
+        await params.fsModule.unlink(params.pathname);
+        return true;
+    }
+    catch (cleanupError) {
+        if (cleanupError.code === "ENOENT")
+            return true;
+        if (params.throwOnCleanupError) {
+            throw cleanupFailure(params.originalError, cleanupError);
+        }
+        return false;
+    }
+}
+// Borrowed handle: the caller retains it until this best-effort cleanup finishes.
+async function cleanupPinnedFilePath(params) {
+    if (!params.identity)
+        return;
+    try {
+        const guard = params.parentGuard;
+        if ([guard.stat.dev, guard.stat.ino].some((value) => typeof value === "number" && !Number.isSafeInteger(value)))
+            return;
+        await directory_guard_assertAsyncDirectoryGuard(guard);
+        const parent = external_node_fs_.lstatSync(guard.dir, { bigint: true });
+        if (parent.isSymbolicLink() || !parent.isDirectory() ||
+            !file_identity_sameFileIdentityForCleanup(parent, guard.stat))
+            return;
+        const opened = external_node_fs_.fstatSync(params.handle.fd, { bigint: true });
+        if (!opened.isFile() || opened.nlink !== 1n ||
+            !file_identity_sameFileIdentityForCleanup(opened, params.identity))
+            return;
+        await cleanupOwnedPath({
+            fsModule: promises_,
+            pathname: params.pathname,
+            identity: params.identity,
+            throwOnCleanupError: false,
+        });
+    }
+    catch {
+        // Unverifiable authority must preserve the path and the original write failure.
+    }
+}
+function cleanupOwnedPathSync(params) {
+    if (!params.identity)
+        return true;
+    try {
+        const current = params.fsModule.lstatSync(params.pathname, { bigint: true });
+        if (current.isSymbolicLink() ||
+            !current.isFile() ||
+            current.nlink !== 1n ||
+            !sameFileIdentityForCleanup(current, params.identity)) {
+            return true;
+        }
+        params.fsModule.unlinkSync(params.pathname);
+        return true;
+    }
+    catch (cleanupError) {
+        if (cleanupError.code === "ENOENT")
+            return true;
+        if (params.throwOnCleanupError) {
+            throw cleanupFailure(params.originalError, cleanupError);
+        }
+        return false;
+    }
+}
+class AsyncAtomicTempOwner {
+    pathname;
+    #handle;
+    #identity;
+    #exists = false;
+    #unregister;
+    constructor(pathname) {
+        this.pathname = pathname;
+        this.#unregister = registerTempPathForExit(pathname, { singleLinkFile: true });
+    }
+    start() {
+        this.#exists = true;
+    }
+    onIdentity = (identity) => {
+        this.#identity = identity;
+        this.#unregister.setIdentity(identity);
+    };
+    adopt(temp) {
+        this.#handle = temp.handle;
+        this.onIdentity(temp.identity);
+    }
+    get identity() {
+        if (!this.#identity)
+            throw new Error("Atomic temp owner has no identity");
+        return this.#identity;
+    }
+    async assertCurrent(fsModule, pathname = this.pathname) {
+        const opened = await inspectFileIdentity(async () => {
+            const stat = fsModule === fs ? syncFs.fstatSync(this.#handle.fd, { bigint: true })
+                : await this.#handle.stat({ bigint: true });
+            assertOwnedFile(stat, pathname, false);
+            return stat;
+        }, this.identity);
+        try {
+            await inspectFileIdentity(async () => {
+                const stat = fsModule === fs ? syncFs.lstatSync(pathname, { bigint: true })
+                    : await fsModule.lstat(pathname, { bigint: true });
+                assertOwnedFile(stat, pathname, true);
+                return stat;
+            }, opened);
+        }
+        catch (error) {
+            if (error.code === "ENOENT") {
+                throw missingOwnedFile(pathname, error);
+            }
+            throw error;
+        }
+    }
+    async assertPublished(fsModule, pathname, expectedHash) {
+        try {
+            await this.assertCurrent(fsModule, pathname);
+            return;
+        }
+        catch (error) {
+            if (!(error instanceof FsSafeError) || error.code !== "path-mismatch" || !expectedHash) {
+                throw error;
+            }
+        }
+        let published;
+        try {
+            try {
+                published = await fsModule.open(pathname, PUBLISHED_READ_FLAGS);
+            }
+            catch (error) {
+                if (error.code === "ELOOP") {
+                    throw new FsSafeError("symlink", `Atomic replace published file became a symlink: ${pathname}`, {
+                        cause: error,
+                    });
+                }
+                throw error;
+            }
+            const identity = await inspectFileIdentity(async () => {
+                const stat = fsModule === fs ? syncFs.fstatSync(published.fd, { bigint: true })
+                    : await published.stat({ bigint: true });
+                assertOwnedFile(stat, pathname, false);
+                return stat;
+            });
+            await inspectFileIdentity(async () => {
+                const stat = fsModule === fs ? syncFs.lstatSync(pathname, { bigint: true })
+                    : await fsModule.lstat(pathname, { bigint: true });
+                assertOwnedFile(stat, pathname, true);
+                return stat;
+            }, identity);
+            if (sha256Hex(await published.readFile()) !== expectedHash) {
+                throw new FsSafeError("path-mismatch", `Atomic replace published content changed: ${pathname}`);
+            }
+            await this.#handle?.close();
+            this.#handle = published;
+            this.#identity = identity;
+            published = undefined;
+        }
+        finally {
+            await published?.close().catch(() => undefined);
+        }
+    }
+    markRenamed() {
+        this.#exists = false;
+        this.#unregister();
+    }
+    async finish(params) {
+        let deferredError;
+        let cleanupComplete = !this.#exists;
+        if (this.#exists) {
+            try {
+                cleanupComplete = await cleanupOwnedPath({
+                    fsModule: params.fsModule,
+                    pathname: this.pathname,
+                    identity: this.#identity,
+                    originalError: params.originalError,
+                    throwOnCleanupError: params.throwOnCleanupError,
+                });
+            }
+            catch (error) {
+                deferredError = error;
+            }
+        }
+        if (cleanupComplete)
+            this.#unregister();
+        try {
+            await this.#handle?.close();
+        }
+        catch (closeError) {
+            deferredError = deferredError
+                ? new AggregateError([deferredError, closeError], "Atomic temp cleanup and close failed")
+                : params.originalError !== undefined
+                    ? new AggregateError([params.originalError, closeError], "Atomic file replace and close failed")
+                    : closeError;
+        }
+        if (deferredError)
+            throw deferredError;
+    }
+}
+class SyncAtomicTempOwner {
+    pathname;
+    #fd;
+    #identity;
+    #exists = false;
+    #unregister;
+    constructor(pathname) {
+        this.pathname = pathname;
+        this.#unregister = registerTempPathForExit(pathname, { singleLinkFile: true });
+    }
+    start() {
+        this.#exists = true;
+    }
+    onIdentity = (identity) => {
+        this.#identity = identity;
+        this.#unregister.setIdentity(identity);
+    };
+    adopt(temp) {
+        this.#fd = temp.fd;
+        this.onIdentity(temp.identity);
+    }
+    get identity() {
+        if (!this.#identity)
+            throw new Error("Atomic temp owner has no identity");
+        return this.#identity;
+    }
+    assertCurrent(fsModule, pathname = this.pathname) {
+        const opened = inspectFileIdentitySync(() => {
+            const stat = fsModule.fstatSync(this.#fd, { bigint: true });
+            assertOwnedFile(stat, pathname, false);
+            return stat;
+        }, this.identity);
+        try {
+            inspectFileIdentitySync(() => {
+                const stat = fsModule.lstatSync(pathname, { bigint: true });
+                assertOwnedFile(stat, pathname, true);
+                return stat;
+            }, opened);
+        }
+        catch (error) {
+            if (error.code === "ENOENT") {
+                throw missingOwnedFile(pathname, error);
+            }
+            throw error;
+        }
+    }
+    assertPublished(fsModule, pathname, expectedHash) {
+        try {
+            this.assertCurrent(fsModule, pathname);
+            return;
+        }
+        catch (error) {
+            if (!(error instanceof FsSafeError) || error.code !== "path-mismatch" || !expectedHash) {
+                throw error;
+            }
+        }
+        let publishedFd;
+        try {
+            try {
+                publishedFd = fsModule.openSync(pathname, PUBLISHED_READ_FLAGS);
+            }
+            catch (error) {
+                if (error.code === "ELOOP") {
+                    throw new FsSafeError("symlink", `Atomic replace published file became a symlink: ${pathname}`, {
+                        cause: error,
+                    });
+                }
+                throw error;
+            }
+            const identity = inspectFileIdentitySync(() => {
+                const stat = fsModule.fstatSync(publishedFd, { bigint: true });
+                assertOwnedFile(stat, pathname, false);
+                return stat;
+            });
+            inspectFileIdentitySync(() => {
+                const stat = fsModule.lstatSync(pathname, { bigint: true });
+                assertOwnedFile(stat, pathname, true);
+                return stat;
+            }, identity);
+            if (sha256Hex(fsModule.readFileSync(publishedFd)) !== expectedHash) {
+                throw new FsSafeError("path-mismatch", `Atomic replace published content changed: ${pathname}`);
+            }
+            fsModule.closeSync(this.#fd);
+            this.#fd = publishedFd;
+            this.#identity = identity;
+            publishedFd = undefined;
+        }
+        finally {
+            if (publishedFd !== undefined) {
+                try {
+                    fsModule.closeSync(publishedFd);
+                }
+                catch {
+                    // Best-effort close after a rejected content verification.
+                }
+            }
+        }
+    }
+    markRenamed() {
+        this.#exists = false;
+        this.#unregister();
+    }
+    finish(params) {
+        let deferredError;
+        let cleanupComplete = !this.#exists;
+        if (this.#exists) {
+            try {
+                cleanupComplete = cleanupOwnedPathSync({
+                    fsModule: params.fsModule,
+                    pathname: this.pathname,
+                    identity: this.#identity,
+                    originalError: params.originalError,
+                    throwOnCleanupError: params.throwOnCleanupError,
+                });
+            }
+            catch (error) {
+                deferredError = error;
+            }
+        }
+        if (cleanupComplete)
+            this.#unregister();
+        if (this.#fd !== undefined) {
+            try {
+                params.fsModule.closeSync(this.#fd);
+            }
+            catch (closeError) {
+                deferredError = deferredError
+                    ? new AggregateError([deferredError, closeError], "Atomic temp cleanup and close failed")
+                    : params.originalError !== undefined
+                        ? new AggregateError([params.originalError, closeError], "Atomic file replace and close failed")
+                        : closeError;
+            }
+        }
+        if (deferredError)
+            throw deferredError;
+    }
+}
+
 ;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/bounded-read.js
 
 
@@ -39363,11 +39810,24 @@ function appendChunk(params) {
     params.chunks.push(Buffer.from(params.scratch.subarray(0, params.bytesRead)));
     return total;
 }
-async function readBoundedAsync(maxBytes, readChunk) {
+async function readBoundedAsync(maxBytes, readChunk, observeRegularFileSize) {
     byte_budget_normalizeMaxBytes(maxBytes);
     const chunks = [];
-    const scratch = createScratchBuffer(maxBytes);
     let total = 0;
+    const size = observeRegularFileSize?.();
+    if (size !== undefined) {
+        const first = Buffer.allocUnsafe(Math.min(maxBytes, size) + 1);
+        const bytesRead = await readChunk(first, first.length);
+        if (bytesRead === 0)
+            return first.subarray(0, 0);
+        // Short reads can occur before EOF. Only accept one when a fresh fd size
+        // observation proves we consumed at least the entire current file size.
+        const currentSize = bytesRead < first.length ? observeRegularFileSize?.() : undefined;
+        if (currentSize !== undefined && bytesRead >= currentSize)
+            return first.subarray(0, bytesRead);
+        total = appendChunk({ chunks, scratch: first, bytesRead, total, maxBytes });
+    }
+    const scratch = createScratchBuffer(maxBytes);
     while (true) {
         const length = nextReadLength(total, maxBytes, scratch.length);
         const bytesRead = await readChunk(scratch, length);
@@ -39383,9 +39843,22 @@ async function readBoundedAsync(maxBytes, readChunk) {
  * force an unbounded allocation.
  */
 async function readFileHandleBounded(handle, maxBytes) {
+    byte_budget_normalizeMaxBytes(maxBytes);
+    const fd = "fd" in handle && typeof handle.fd === "number" ? handle.fd : undefined;
     return await readBoundedAsync(maxBytes, async (scratch, length) => {
         return (await handle.read(scratch, 0, length, null)).bytesRead;
-    });
+    }, fd === undefined ? undefined : () => regularFileSize(fd));
+}
+function regularFileSize(fd) {
+    try {
+        const stat = external_node_fs_.fstatSync(fd);
+        return stat.isFile() && Number.isSafeInteger(stat.size) && stat.size >= 0
+            ? stat.size : undefined;
+    }
+    catch {
+        // Size is only an optimization hint; retain the reader's original errors.
+        return undefined;
+    }
 }
 function readDescriptorChunk(fd, scratch, length) {
     return new Promise((resolve, reject) => {
@@ -39400,9 +39873,10 @@ function readDescriptorChunk(fd, scratch, length) {
 }
 /** Async bounded read from a numeric descriptor. The caller owns the descriptor. */
 async function readFileDescriptorBounded(fd, maxBytes) {
+    normalizeMaxBytes(maxBytes);
     return await readBoundedAsync(maxBytes, async (scratch, length) => {
         return await readDescriptorChunk(fd, scratch, length);
-    });
+    }, () => regularFileSize(fd));
 }
 /** Sync bounded read from a numeric descriptor. The caller owns the descriptor. */
 function bounded_read_readFileDescriptorBoundedSync(fd, maxBytes) {
@@ -39420,11 +39894,19 @@ function bounded_read_readFileDescriptorBoundedSync(fd, maxBytes) {
     }
 }
 
+// EXTERNAL MODULE: external "node:os"
+var external_node_os_ = __webpack_require__(8161);
 ;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/error-detail.js
+
 const UNSAFE_ERROR_DETAIL_CHARACTERS = /[\u0000-\u001f\u007f-\u009f\u2028\u2029]/gu;
 function formatErrorDetail(value) {
     return value.replace(UNSAFE_ERROR_DETAIL_CHARACTERS, (character) => `\\u${character.charCodeAt(0).toString(16).padStart(4, "0")}`);
 }
+function shortPath(value) {
+    const home = external_node_os_.homedir();
+    const shortened = value.startsWith(home) ? `~${value.slice(home.length)}` : value;
+    return formatErrorDetail(shortened);
+}
 
 ;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/root-path-symlink.js
 
@@ -39432,9 +39914,9 @@ function formatErrorDetail(value) {
 
 
 
-
-function normalizeSymlinkResolutionError(error) {
-    if (isSymlinkOpenError(error)) {
+function normalizeSymlinkResolutionError(error, options) {
+    if (isSymlinkOpenError(error) ||
+        (options.rejectUnresolved && path_isNotFoundPathError(error))) {
         throw new errors_FsSafeError("symlink", "symlink path could not be resolved", {
             cause: error instanceof Error ? error : undefined,
         });
@@ -39442,22 +39924,22 @@ function normalizeSymlinkResolutionError(error) {
     if (!path_isNotFoundPathError(error))
         throw error;
 }
-async function resolveSymlinkHopPath(symlinkPath) {
+async function resolveSymlinkHopPath(symlinkPath, options = {}) {
     try {
-        return external_node_path_.resolve(await promises_.realpath(symlinkPath));
+        return external_node_path_.resolve(external_node_fs_.realpathSync.native(symlinkPath));
     }
     catch (error) {
-        normalizeSymlinkResolutionError(error);
-        const linkTarget = await promises_.readlink(symlinkPath);
+        normalizeSymlinkResolutionError(error, options);
+        const linkTarget = external_node_fs_.readlinkSync(symlinkPath);
         return resolvePathViaExistingAncestor(external_node_path_.resolve(external_node_path_.dirname(symlinkPath), linkTarget));
     }
 }
-function root_path_symlink_resolveSymlinkHopPathSync(symlinkPath) {
+function root_path_symlink_resolveSymlinkHopPathSync(symlinkPath, options = {}) {
     try {
         return path.resolve(fs.realpathSync(symlinkPath));
     }
     catch (error) {
-        normalizeSymlinkResolutionError(error);
+        normalizeSymlinkResolutionError(error, options);
         const linkTarget = fs.readlinkSync(symlinkPath);
         return resolvePathViaExistingAncestorSync(path.resolve(path.dirname(symlinkPath), linkTarget));
     }
@@ -39540,17 +40022,6 @@ function assertSafePathPrefix(prefix, options = {}) {
     });
 }
 
-// EXTERNAL MODULE: external "node:os"
-var external_node_os_ = __webpack_require__(8161);
-;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/short-path.js
-
-
-function shortPath(value) {
-    const home = external_node_os_.homedir();
-    const shortened = value.startsWith(home) ? `~${value.slice(home.length)}` : value;
-    return formatErrorDetail(shortened);
-}
-
 ;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/root-path.js
 
 
@@ -39561,8 +40032,6 @@ function shortPath(value) {
 
 
 
-
-
 const ROOT_PATH_ALIAS_POLICIES = {
     strict: Object.freeze({
         allowFinalSymlinkForUnlink: false,
@@ -39573,7 +40042,7 @@ const ROOT_PATH_ALIAS_POLICIES = {
         allowFinalHardlinkForUnlink: true,
     }),
 };
-async function resolveRootPath(params) {
+async function root_path_resolveRootPath(params) {
     try {
         return await resolveRootPathInternal(params);
     }
@@ -39674,12 +40143,6 @@ function assertNoEmbeddedDriveRelativeSegment(filePath, label) {
     const root = external_node_path_.parse(filePath).root;
     assertNoDriveRelativePathSegments(filePath.slice(root.length).replaceAll("\\", "/"), label);
 }
-function isPromiseLike(value) {
-    return Boolean(value &&
-        (typeof value === "object" || typeof value === "function") &&
-        "then" in value &&
-        typeof value.then === "function");
-}
 function createLexicalTraversalState(params) {
     const rawAbsolutePath = params.params.absolutePath;
     const rawRelativePath = rawPathRelativeToRoot(params.rootPath, rawAbsolutePath);
@@ -39759,26 +40222,13 @@ function handleLexicalLstatFailure(context, error, missingFromIndex) {
     applyMissingSuffixToCanonicalCursor(context, missingFromIndex);
     return true;
 }
-function handleLexicalStatReadFailure(context, error, missingFromIndex) {
-    if (handleLexicalLstatFailure(context, error, missingFromIndex)) {
-        return null;
-    }
-    throw error;
-}
-function handleLexicalStatDisposition(context, params) {
-    if (!params.isSymbolicLink) {
-        advanceCanonicalCursorForSegment(context, params.segment);
+function lexicalStatDisposition(params) {
+    if (!params.isSymbolicLink)
         return "continue";
-    }
-    if (context.resolveParams.rejectSymlinks === true && params.isLast) {
+    if (params.rejectSymlinks === true && params.isLast) {
         throw new errors_FsSafeError("symlink", "symlink path component not allowed");
     }
-    if (context.state.allowFinalSymlink && params.isLast) {
-        context.state.preserveFinalSymlink = true;
-        advanceCanonicalCursorForSegment(context, params.segment);
-        return "break";
-    }
-    return "resolve-link";
+    return params.allowFinalSymlink && params.isLast ? "break" : "resolve-link";
 }
 function applyResolvedSymlinkHop(context, linkCanonical) {
     if (!path_isPathInside(context.rootCanonicalPath, linkCanonical)) {
@@ -39791,68 +40241,48 @@ function applyResolvedSymlinkHop(context, linkCanonical) {
     context.state.canonicalCursor = linkCanonical;
     context.state.lexicalCursor = linkCanonical;
 }
-function readLexicalStat(context, params) {
-    try {
-        const stat = params.read(context.state.lexicalCursor);
-        if (isPromiseLike(stat)) {
-            return Promise.resolve(stat).catch((error) => handleLexicalStatReadFailure(context, error, params.missingFromIndex));
-        }
-        return stat;
-    }
-    catch (error) {
-        return handleLexicalStatReadFailure(context, error, params.missingFromIndex);
-    }
-}
-function resolveAndApplySymlinkHop(context, params) {
-    const linkCanonical = params.resolveLinkCanonical(context.state.lexicalCursor);
-    if (isPromiseLike(linkCanonical)) {
-        return Promise.resolve(linkCanonical).then((value) => {
-            applyResolvedSymlinkHop(context, value);
-        });
-    }
-    applyResolvedSymlinkHop(context, linkCanonical);
-}
 function applyParentTraversalStep(context) {
     context.state.lexicalCursor = external_node_path_.resolve(context.state.lexicalCursor, "..");
     advanceCanonicalCursorForSegment(context, "..");
 }
-function* iterateLexicalTraversal(state) {
-    for (let idx = 0; idx < state.segments.length; idx += 1) {
-        const segment = state.segments[idx] ?? "";
-        const isLast = idx === state.segments.length - 1;
-        yield { idx, segment, isLast };
-    }
-}
 async function resolveRootPathLexicalAsync(params) {
     const context = createLexicalTraversalContext(params);
     const { state } = context;
-    for (const { idx, segment, isLast } of iterateLexicalTraversal(state)) {
+    for (let idx = 0; idx < state.segments.length; idx += 1) {
+        const segment = state.segments[idx] ?? "";
+        const isLast = idx === state.segments.length - 1;
         if (segment === "..") {
             applyParentTraversalStep(context);
             continue;
         }
         state.lexicalCursor = external_node_path_.join(state.lexicalCursor, segment);
-        const stat = await readLexicalStat(context, {
-            missingFromIndex: idx,
-            read: (cursor) => promises_.lstat(cursor),
-        });
-        if (!stat) {
-            break;
+        let stat;
+        try {
+            stat = external_node_fs_.lstatSync(state.lexicalCursor);
         }
-        const disposition = handleLexicalStatDisposition(context, {
-            isSymbolicLink: stat.isSymbolicLink(),
-            segment,
+        catch (error) {
+            if (handleLexicalLstatFailure(context, error, idx))
+                break;
+            throw error;
+        }
+        const isSymbolicLink = stat.isSymbolicLink();
+        const disposition = lexicalStatDisposition({
+            isSymbolicLink,
             isLast,
+            rejectSymlinks: isSymbolicLink ? context.resolveParams.rejectSymlinks : undefined,
+            allowFinalSymlink: state.allowFinalSymlink,
         });
-        if (disposition === "continue") {
+        if (disposition !== "resolve-link") {
+            state.preserveFinalSymlink = disposition === "break";
+            advanceCanonicalCursorForSegment(context, segment);
+            if (state.preserveFinalSymlink)
+                break;
             continue;
         }
-        if (disposition === "break") {
-            break;
-        }
-        await resolveAndApplySymlinkHop(context, {
-            resolveLinkCanonical: (cursor) => resolveSymlinkHopPath(cursor),
+        const linkCanonical = await resolveSymlinkHopPath(state.lexicalCursor, {
+            rejectUnresolved: context.resolveParams.rejectUnresolvedSymlinks,
         });
+        applyResolvedSymlinkHop(context, linkCanonical);
         if (context.resolveParams.rejectSymlinks === true) {
             throw new errors_FsSafeError("symlink", "symlink path component not allowed");
         }
@@ -39871,34 +40301,33 @@ function resolveRootPathLexicalSync(params) {
             continue;
         }
         state.lexicalCursor = path.join(state.lexicalCursor, segment);
-        const maybeStat = readLexicalStat(context, {
-            missingFromIndex: idx,
-            read: (cursor) => fs.lstatSync(cursor),
-        });
-        if (isPromiseLike(maybeStat)) {
-            throw new Error("Unexpected async lexical stat");
+        let stat;
+        try {
+            stat = fs.lstatSync(state.lexicalCursor);
         }
-        const stat = maybeStat;
-        if (!stat) {
-            break;
+        catch (error) {
+            if (handleLexicalLstatFailure(context, error, idx))
+                break;
+            throw error;
         }
-        const disposition = handleLexicalStatDisposition(context, {
-            isSymbolicLink: stat.isSymbolicLink(),
-            segment,
+        const isSymbolicLink = stat.isSymbolicLink();
+        const disposition = lexicalStatDisposition({
+            isSymbolicLink,
             isLast,
+            rejectSymlinks: isSymbolicLink ? context.resolveParams.rejectSymlinks : undefined,
+            allowFinalSymlink: state.allowFinalSymlink,
         });
-        if (disposition === "continue") {
+        if (disposition !== "resolve-link") {
+            state.preserveFinalSymlink = disposition === "break";
+            advanceCanonicalCursorForSegment(context, segment);
+            if (state.preserveFinalSymlink)
+                break;
             continue;
         }
-        if (disposition === "break") {
-            break;
-        }
-        const maybeApplied = resolveAndApplySymlinkHop(context, {
-            resolveLinkCanonical: (cursor) => resolveSymlinkHopPathSync(cursor),
+        const linkCanonical = resolveSymlinkHopPathSync(state.lexicalCursor, {
+            rejectUnresolved: context.resolveParams.rejectUnresolvedSymlinks,
         });
-        if (isPromiseLike(maybeApplied)) {
-            throw new Error("Unexpected async symlink resolution");
-        }
+        applyResolvedSymlinkHop(context, linkCanonical);
         if (context.resolveParams.rejectSymlinks === true) {
             throw new FsSafeError("symlink", "symlink path component not allowed");
         }
@@ -40018,8 +40447,8 @@ function buildResolvedRootPath(params) {
 async function getPathKind(absolutePath, preserveFinalSymlink) {
     try {
         const stat = preserveFinalSymlink
-            ? await promises_.lstat(absolutePath)
-            : await promises_.stat(absolutePath);
+            ? external_node_fs_.lstatSync(absolutePath)
+            : external_node_fs_.statSync(absolutePath);
         return { exists: true, kind: toResolvedKind(stat) };
     }
     catch (error) {
@@ -40085,7 +40514,7 @@ function symlinkEscapeError(params) {
 
 async function openSidecarRoot(lockRoot, relative, discardObservation, onOpenFailure) {
     const resolved = await lockRoot.resolve(relative);
-    const canonicalPath = async () => (await resolveRootPath({
+    const canonicalPath = async () => (await root_path_resolveRootPath({
         absolutePath: resolved,
         rootPath: lockRoot.rootReal,
         rootCanonicalPath: lockRoot.rootReal,
@@ -40202,10 +40631,12 @@ function readSidecarLockOwnershipToken(raw) {
 }
 function serializeSidecarLockPayload(payload) {
     const ownershipToken = createSidecarLockOwnershipToken();
-    return {
-        raw: `${JSON.stringify(payload, null, 2)}\n${ownershipToken}\n`,
-        ownershipToken,
-    };
+    const raw = `${JSON.stringify(payload, null, 2)}\n${ownershipToken}\n`;
+    const bytes = Buffer.byteLength(raw, "utf8");
+    if (bytes > MAX_LOCK_PAYLOAD_BYTES) {
+        throw new errors_FsSafeError("too-large", `sidecar lock payload exceeds limit of ${MAX_LOCK_PAYLOAD_BYTES} bytes (got ${bytes})`);
+    }
+    return { raw, ownershipToken };
 }
 function relativeSidecarLockPath(lockRoot, lockPath) {
     const resolved = external_node_path_.resolve(lockPath);
@@ -40260,7 +40691,13 @@ async function readSidecarLockRawSnapshot(lockPath, options = {}) {
                 await opened.handle.close().catch(() => undefined);
             }
         }
-        const before = await promises_.lstat(lockPath).catch(missingSnapshotPath);
+        let before;
+        try {
+            before = external_node_fs_.lstatSync(lockPath);
+        }
+        catch (error) {
+            before = missingSnapshotPath(error);
+        }
         if (!before)
             return null;
         if (!before.isFile() || before.isSymbolicLink()) {
@@ -40289,7 +40726,7 @@ async function readSidecarLockRawSnapshot(lockPath, options = {}) {
             options.onOpenFailure?.(error);
             throw error;
         }
-        const opened = await handle.stat();
+        const opened = external_node_fs_.fstatSync(handle.fd);
         if (!opened.isFile()) {
             if (options.rejectNonFile) {
                 throw new errors_FsSafeError("not-file", `sidecar lock is not a regular file: ${lockPath}`);
@@ -40299,7 +40736,13 @@ async function readSidecarLockRawSnapshot(lockPath, options = {}) {
         if (!options.allowDescriptorIdentityDrift && !file_identity_sameFileIdentity(before, opened))
             return null;
         const raw = (await readFileHandleBounded(handle, MAX_LOCK_PAYLOAD_BYTES)).toString("utf8");
-        const after = await promises_.lstat(lockPath).catch(missingSnapshotPath);
+        let after;
+        try {
+            after = external_node_fs_.lstatSync(lockPath);
+        }
+        catch (error) {
+            after = missingSnapshotPath(error);
+        }
         if (!after || !after.isFile() || !file_identity_sameFileIdentity(before, after))
             return null;
         return { raw, stat: after };
@@ -40411,7 +40854,7 @@ async function sidecarLockSnapshotStillPresent(lockPath, observed, options = {})
 }
 async function sidecarReclaimGuardExists(pathname) {
     try {
-        await promises_.lstat(pathname);
+        external_node_fs_.lstatSync(pathname);
         return true;
     }
     catch (err) {
@@ -40474,6 +40917,315 @@ async function removeStaleSidecarLockIfAllowed(params) {
     }
 }
 
+;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/absolute-path.js
+
+
+
+
+
+
+
+function resolveSymlinkPolicy(policy) {
+    if (policy === undefined)
+        return "reject";
+    if (policy !== "reject" && policy !== "follow") {
+        throw new TypeError(`invalid absolute path symlink policy: ${String(policy)}`);
+    }
+    return policy;
+}
+function ensureDirectoryFailure(code, message, cause) {
+    return {
+        ok: false,
+        code,
+        error: new FsSafeError(code, message, { cause }),
+    };
+}
+async function assertGuardResult(guard, scopeLabel) {
+    try {
+        await assertAsyncDirectoryGuard(guard);
+        return { ok: true };
+    }
+    catch (err) {
+        if (err instanceof FsSafeError) {
+            return await directoryGuardFailure(err, guard.dir, scopeLabel);
+        }
+        throw err;
+    }
+}
+async function createDirectoryGuardResult(dir, scopeLabel) {
+    try {
+        return { ok: true, guard: await createAsyncDirectoryGuard(dir) };
+    }
+    catch (err) {
+        if (err instanceof FsSafeError) {
+            return await directoryGuardFailure(err, dir, scopeLabel);
+        }
+        throw err;
+    }
+}
+function classifyDirectoryLookupError(err, scopeLabel) {
+    const code = err.code;
+    if (code === "ENOENT") {
+        return ensureDirectoryFailure("not-found", `directory path must have a real existing ancestor within ${scopeLabel}`, err);
+    }
+    if (code === "ENOTDIR") {
+        return ensureDirectoryFailure("not-file", `path must be a real directory within ${scopeLabel}`, err);
+    }
+    return null;
+}
+function classifyExistingDirectorySegment(stat, scopeLabel) {
+    if (stat.isSymbolicLink()) {
+        return ensureDirectoryFailure("symlink", `directory path traverses a symlink within ${scopeLabel}`);
+    }
+    if (!stat.isDirectory()) {
+        return ensureDirectoryFailure("not-file", `path must be a real directory within ${scopeLabel}`);
+    }
+    return null;
+}
+async function directoryGuardFailure(err, dir, scopeLabel) {
+    if (err.code !== "not-file") {
+        return { ok: false, code: err.code, error: err };
+    }
+    try {
+        const stat = fsSync.lstatSync(dir);
+        const failure = classifyExistingDirectorySegment(stat, scopeLabel);
+        if (failure) {
+            return failure;
+        }
+    }
+    catch (lookupErr) {
+        const failure = classifyDirectoryLookupError(lookupErr, scopeLabel);
+        if (failure) {
+            return failure;
+        }
+        throw lookupErr;
+    }
+    return { ok: false, code: err.code, error: err };
+}
+async function resolveTrustedDirectoryPrefix(targetPath, scopeLabel) {
+    const root = path.parse(targetPath).root;
+    let current = root;
+    let currentStat;
+    try {
+        currentStat = fsSync.lstatSync(current);
+    }
+    catch (err) {
+        const failure = classifyDirectoryLookupError(err, scopeLabel);
+        if (failure) {
+            return failure;
+        }
+        throw err;
+    }
+    const rootFailure = classifyExistingDirectorySegment(currentStat, scopeLabel);
+    if (rootFailure) {
+        return rootFailure;
+    }
+    // Walk forward with lstat. Looking backward for the "nearest existing
+    // ancestor" can cross an existing suffix through a symlinked parent before
+    // this helper gets a chance to reject that parent.
+    const segments = path.relative(root, targetPath).split(path.sep).filter(Boolean);
+    for (let index = 0; index < segments.length; index += 1) {
+        const segment = segments[index];
+        if (!segment) {
+            continue;
+        }
+        const next = path.join(current, segment);
+        try {
+            const nextStat = fsSync.lstatSync(next);
+            const segmentFailure = classifyExistingDirectorySegment(nextStat, scopeLabel);
+            if (segmentFailure) {
+                return segmentFailure;
+            }
+            current = next;
+            currentStat = nextStat;
+        }
+        catch (err) {
+            const code = err.code;
+            if (code === "ENOENT") {
+                return {
+                    ok: true,
+                    ancestorPath: current,
+                    missingSegments: segments.slice(index),
+                };
+            }
+            const failure = classifyDirectoryLookupError(err, scopeLabel);
+            if (failure) {
+                return failure;
+            }
+            throw err;
+        }
+    }
+    return { ok: true, ancestorPath: current, missingSegments: [] };
+}
+function assertAbsolutePathInput(filePath) {
+    if (!filePath) {
+        throw new FsSafeError("invalid-path", "path is required");
+    }
+    if (filePath.includes("\0")) {
+        throw new FsSafeError("invalid-path", "path must not contain NUL bytes");
+    }
+    if (!path.isAbsolute(filePath)) {
+        throw new FsSafeError("invalid-path", "path must be absolute");
+    }
+    return path.normalize(filePath);
+}
+async function findExistingAncestor(filePath) {
+    return (await findExistingAncestorWithStat(filePath))?.path ?? null;
+}
+async function findExistingAncestorWithStat(filePath) {
+    let current = external_node_path_.resolve(filePath);
+    while (true) {
+        try {
+            return { path: current, stat: external_node_fs_.lstatSync(current) };
+        }
+        catch (err) {
+            if (err.code !== "ENOENT") {
+                throw err;
+            }
+        }
+        const parent = external_node_path_.dirname(current);
+        if (parent === current) {
+            return null;
+        }
+        current = parent;
+    }
+}
+async function absolute_path_ensureAbsoluteDirectory(dirPath, options = {}) {
+    const scopeLabel = options.scopeLabel ?? "directory";
+    let targetPath;
+    try {
+        targetPath = assertAbsolutePathInput(dirPath);
+    }
+    catch (err) {
+        if (err instanceof FsSafeError) {
+            return { ok: false, code: err.code, error: err };
+        }
+        throw err;
+    }
+    const prefix = await resolveTrustedDirectoryPrefix(targetPath, scopeLabel);
+    if (!prefix.ok) {
+        return prefix;
+    }
+    let current = prefix.ancestorPath;
+    const initialGuard = await createDirectoryGuardResult(prefix.ancestorPath, scopeLabel);
+    if (!initialGuard.ok) {
+        return initialGuard;
+    }
+    let currentGuard = initialGuard.guard;
+    for (const segment of prefix.missingSegments) {
+        current = path.join(current, segment);
+        while (true) {
+            const guardResult = await assertGuardResult(currentGuard, scopeLabel);
+            if (!guardResult.ok) {
+                return guardResult;
+            }
+            try {
+                const stat = fsSync.lstatSync(current);
+                if (stat.isSymbolicLink()) {
+                    return ensureDirectoryFailure("symlink", `directory path traverses a symlink within ${scopeLabel}`);
+                }
+                if (!stat.isDirectory()) {
+                    return ensureDirectoryFailure("not-file", `path must be a real directory within ${scopeLabel}`);
+                }
+                break;
+            }
+            catch (err) {
+                if (err.code !== "ENOENT") {
+                    throw err;
+                }
+                const parentStillValid = await assertGuardResult(currentGuard, scopeLabel);
+                if (!parentStillValid.ok) {
+                    return parentStillValid;
+                }
+                try {
+                    await fs.mkdir(current, { mode: options.mode });
+                }
+                catch (mkdirErr) {
+                    if (mkdirErr.code === "EEXIST") {
+                        continue;
+                    }
+                    throw mkdirErr;
+                }
+            }
+        }
+        const nextGuard = await createDirectoryGuardResult(current, scopeLabel);
+        if (!nextGuard.ok) {
+            return nextGuard;
+        }
+        const previousGuardStillValid = await assertGuardResult(currentGuard, scopeLabel);
+        if (!previousGuardStillValid.ok) {
+            return previousGuardStillValid;
+        }
+        currentGuard = nextGuard.guard;
+    }
+    const finalGuardResult = await assertGuardResult(currentGuard, scopeLabel);
+    if (!finalGuardResult.ok) {
+        return finalGuardResult;
+    }
+    return { ok: true, path: targetPath };
+}
+async function canonicalPathFromExistingAncestor(filePath) {
+    const ancestor = await findExistingAncestor(filePath);
+    if (!ancestor) {
+        return external_node_path_.resolve(filePath);
+    }
+    let canonicalAncestor = ancestor;
+    try {
+        canonicalAncestor = external_node_fs_.realpathSync.native(ancestor);
+    }
+    catch {
+        // Keep lexical path when the existing ancestor cannot be canonicalized.
+    }
+    const relative = external_node_path_.relative(ancestor, filePath);
+    return relative ? external_node_path_.join(canonicalAncestor, relative) : canonicalAncestor;
+}
+async function resolveAbsolutePathForRead(filePath, options = {}) {
+    const symlinks = resolveSymlinkPolicy(options.symlinks);
+    const normalized = assertAbsolutePathInput(filePath);
+    let canonicalPath;
+    try {
+        canonicalPath = fsSync.realpathSync.native(normalized);
+    }
+    catch (err) {
+        if (err.code === "ENOENT") {
+            throw new FsSafeError("not-found", "path not found", { cause: err });
+        }
+        throw err;
+    }
+    if (symlinks === "reject" && canonicalPath !== normalized) {
+        throw new FsSafeError("symlink", "path traverses a symlink", { cause: { canonicalPath } });
+    }
+    return { path: normalized, canonicalPath };
+}
+async function resolveAbsolutePathForWrite(filePath, options = {}) {
+    const symlinks = resolveSymlinkPolicy(options.symlinks);
+    const normalized = assertAbsolutePathInput(filePath);
+    const parentDir = path.dirname(normalized);
+    const parentExists = await pathExists(parentDir);
+    if (symlinks === "reject") {
+        const filesystemRoot = path.parse(normalized).root;
+        await resolveRootPath({
+            absolutePath: normalized,
+            rootPath: filesystemRoot,
+            rootCanonicalPath: filesystemRoot,
+            boundaryLabel: "absolute path",
+            rejectSymlinks: true,
+        });
+    }
+    const canonicalPath = await canonicalPathFromExistingAncestor(normalized);
+    if (symlinks === "reject" && canonicalPath !== normalized) {
+        throw new FsSafeError("symlink", "path traverses a symlink", {
+            cause: { canonicalPath },
+        });
+    }
+    return {
+        path: normalized,
+        canonicalPath,
+        parentDir,
+        parentExists,
+    };
+}
+
 ;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/sidecar-lock-policy.js
 
 function assertFiniteNonNegative(value, label) {
@@ -40525,10 +41277,6 @@ function isTransientLockFileDenial(error, lockPath) {
     const denial = error;
     return process.platform === "win32" && denial?.code === "EPERM" && denial.path === lockPath;
 }
-function sidecarLockPayloadIsStale(payload, staleMs, nowMs) {
-    const createdAtMs = sidecarLockPayloadCreatedAtMs(payload);
-    return createdAtMs !== null && nowMs - createdAtMs > staleMs;
-}
 function sidecarLockPayloadCreatedAtMs(payload) {
     const createdAt = payload &&
         typeof payload === "object" &&
@@ -40544,7 +41292,7 @@ async function defaultSidecarLockShouldReclaim(params) {
     if (createdAtMs !== null)
         return params.nowMs - createdAtMs > params.staleMs;
     try {
-        return params.nowMs - (await promises_.stat(params.lockPath)).mtimeMs > params.staleMs;
+        return params.nowMs - external_node_fs_.statSync(params.lockPath).mtimeMs > params.staleMs;
     }
     catch {
         return true;
@@ -40578,12 +41326,23 @@ function createSuppressedError(error, suppressed, message) {
 
 
 
-async function resolveNormalizedTargetPath(targetPath) {
+
+
+
+async function resolveNormalizedTargetPath(targetPath, lockRoot) {
     const resolved = external_node_path_.resolve(targetPath);
     const dir = external_node_path_.dirname(resolved);
+    if (lockRoot) {
+        // The target is an arbitration key, not necessarily inside the lock Root.
+        // Leave parent creation to the Root-backed sidecar write.
+        await lockRoot.resolve(".");
+        const parent = await canonicalPathFromExistingAncestor(dir);
+        await lockRoot.resolve(".");
+        return external_node_path_.join(parent, external_node_path_.basename(resolved));
+    }
     await promises_.mkdir(dir, { recursive: true });
     try {
-        return external_node_path_.join(await promises_.realpath(dir), external_node_path_.basename(resolved));
+        return external_node_path_.join(external_node_fs_.realpathSync.native(dir), external_node_path_.basename(resolved));
     }
     catch {
         return resolved;
@@ -40594,7 +41353,7 @@ async function acquireSidecarLock(options, context) {
     validateSidecarLockRetryOptions(retry);
     validateSidecarLockTimeoutMs(options.timeoutMs);
     context.ensureExitCleanupRegistered();
-    const normalizedTargetPath = await resolveNormalizedTargetPath(options.targetPath);
+    const normalizedTargetPath = await resolveNormalizedTargetPath(options.targetPath, options.lockRoot);
     const lockPath = options.lockPath ?? `${normalizedTargetPath}.lock`;
     let held = context.held.get(normalizedTargetPath);
     if (held &&
@@ -40614,11 +41373,15 @@ async function acquireSidecarLock(options, context) {
             held.reentrantOwner !== undefined &&
             options.reentrantOwner === held.reentrantOwner) {
             held.refCount += 1;
+            // Retention is monotonic: any same-owner request to keep the sidecar on
+            // exit upgrades the held lock; a later default acquisition never revokes it.
+            if (options.retainOnExit === true) {
+                held.retainOnExit = true;
+            }
             return context.handleForHeldLock(normalizedTargetPath, held);
         }
     }
     const startedAt = Date.now();
-    const maxRetries = options.timeoutMs === Number.POSITIVE_INFINITY ? undefined : retry.retries;
     const reclaimGuardPath = `${lockPath}.reclaim`;
     let ownsReclaimGuard = false;
     let attempt = 0;
@@ -40630,7 +41393,7 @@ async function acquireSidecarLock(options, context) {
         if ((options.timeoutMs !== undefined &&
             options.timeoutMs !== Number.POSITIVE_INFINITY &&
             elapsed >= options.timeoutMs) ||
-            (maxRetries !== undefined && attempt >= maxRetries)) {
+            (retry.retries !== undefined && attempt >= retry.retries)) {
             throw Object.assign(new Error(`file lock timeout for ${normalizedTargetPath}`), {
                 code: "file_lock_timeout",
                 lockPath,
@@ -40672,10 +41435,14 @@ async function acquireSidecarLock(options, context) {
                 if (options.lockRoot) {
                     const lockRoot = options.lockRoot;
                     const relativeLockPath = relativeSidecarLockPath(lockRoot, lockPath);
+                    const observation = fileObservation();
                     try {
-                        await lockRoot.create(relativeLockPath, raw, { mkdir: true, mode: 0o600 });
+                        await observation.run(() => lockRoot.create(relativeLockPath, raw, { mkdir: true, mode: 0o600 }));
                     }
                     catch (error) {
+                        // Only this invocation's failed exclusive open grants denial retry authority.
+                        lockFileCreateDenied = observation.has(error, `exclusive-create:${lockPath}`) &&
+                            isTransientLockFileDenial(error, lockPath);
                         if (error instanceof errors_FsSafeError && error.code === "already-exists") {
                             throw Object.assign(new Error("sidecar lock exists"), { code: "EEXIST" });
                         }
@@ -40712,7 +41479,7 @@ async function acquireSidecarLock(options, context) {
                     }
                     await handle.writeFile(raw, "utf8");
                 }
-                const snapshot = { raw, payload, stat: await handle.stat(), ownershipToken };
+                const snapshot = { raw, payload, stat: external_node_fs_.fstatSync(handle.fd), ownershipToken };
                 if (snapshot.stat.nlink === 0) {
                     await handle.close();
                     handle = null;
@@ -40728,6 +41495,7 @@ async function acquireSidecarLock(options, context) {
                     acquiredAt: Date.now(),
                     metadata: options.metadata ?? {},
                     lockRoot: options.lockRoot,
+                    retainOnExit: options.retainOnExit,
                     parsePayload: options.parsePayload,
                 };
                 context.held.set(normalizedTargetPath, createdHeld);
@@ -40765,7 +41533,7 @@ async function acquireSidecarLock(options, context) {
                     if (handle) {
                         const failedSnapshot = createdSnapshot ?? { payload: null };
                         try {
-                            failedSnapshot.stat = await handle.stat();
+                            failedSnapshot.stat = external_node_fs_.fstatSync(handle.fd);
                         }
                         catch {
                             // Best-effort cleanup of a failed exclusive create.
@@ -40938,9 +41706,15 @@ function createHeldSidecarLockHandle(params) {
 
 
 
+
 const GLOBAL_STATE_KEY = Symbol.for("fsSafe.sidecarLockManagers");
 const GLOBAL_CLEANUP_KEY = Symbol.for("fsSafe.sidecarLockCleanupRegistered");
 const GLOBAL_CLEANUP_HANDLER_KEY = Symbol.for("fsSafe.sidecarLockCleanupHandler");
+const GLOBAL_BEFORE_EXIT_KEY = Symbol.for("fsSafe.sidecarLockBeforeExitCleanup");
+// Set by copies whose exit handlers honor retainOnExit. When an older package
+// copy registered the handlers first, this marker stays absent and retained
+// acquisitions must fail closed rather than silently lose the guarantee.
+const GLOBAL_RETAIN_AWARE_KEY = Symbol.for("fsSafe.sidecarLockRetainAwareCleanup");
 function getGlobalManagers() {
     const globalWithState = globalThis;
     if (!globalWithState[GLOBAL_STATE_KEY]) {
@@ -41013,7 +41787,8 @@ function snapshotMatchesSync(lockPath, observed) {
     }
 }
 function releaseAllReclaimGuardsSync(state) {
-    for (const reclaimGuardPath of state.reclaimGuards) {
+    // Exit cleanup also visits managers created by older copies and never reopened here.
+    for (const reclaimGuardPath of state.reclaimGuards ?? []) {
         try {
             external_node_fs_.rmdirSync(reclaimGuardPath);
             state.reclaimGuards.delete(reclaimGuardPath);
@@ -41023,11 +41798,12 @@ function releaseAllReclaimGuardsSync(state) {
         }
     }
 }
-function releaseAllLocksSync(state) {
+function releaseAllLocksSync(state, options) {
     for (const [normalizedTargetPath, held] of state.held) {
         void held.handle.close().catch(() => undefined);
         try {
-            if (!held.lockRoot && snapshotMatchesSync(held.lockPath, held.snapshot)) {
+            const retained = options?.preserveRetained === true && held.retainOnExit;
+            if (!retained && !held.lockRoot && snapshotMatchesSync(held.lockPath, held.snapshot)) {
                 external_node_fs_.rmSync(held.lockPath, { force: true });
             }
         }
@@ -41043,14 +41819,43 @@ function ensureGlobalExitCleanupRegistered() {
     if (globalWithCleanup[GLOBAL_CLEANUP_KEY])
         return;
     globalWithCleanup[GLOBAL_CLEANUP_KEY] = true;
+    globalWithCleanup[GLOBAL_RETAIN_AWARE_KEY] = true;
     const cleanup = () => {
         for (const state of getGlobalManagers().values()) {
-            releaseAllLocksSync(state);
+            releaseAllLocksSync(state, { preserveRetained: true });
         }
     };
     globalWithCleanup[GLOBAL_CLEANUP_HANDLER_KEY] = cleanup;
     process.on("exit", cleanup);
 }
+/** True when a retain-unaware package copy registered the process-exit handlers first. */
+function exitCleanupCannotRetain() {
+    const globalWithCleanup = globalThis;
+    return globalWithCleanup[GLOBAL_CLEANUP_KEY] === true && globalWithCleanup[GLOBAL_RETAIN_AWARE_KEY] !== true;
+}
+function ensureGlobalBeforeExitCleanupRegistered() {
+    const globalWithCleanup = globalThis;
+    if (globalWithCleanup[GLOBAL_BEFORE_EXIT_KEY]) {
+        return globalWithCleanup[GLOBAL_BEFORE_EXIT_KEY];
+    }
+    // Independent of the exit registration, which an older package copy may own.
+    const lifecycle = { armed: false };
+    globalWithCleanup[GLOBAL_BEFORE_EXIT_KEY] = lifecycle;
+    process.on("beforeExit", () => {
+        if (!lifecycle.armed)
+            return;
+        // Cleanup itself schedules I/O; retry only after another acquisition.
+        lifecycle.armed = false;
+        for (const state of getGlobalManagers().values()) {
+            for (const [normalizedTargetPath, held] of Array.from(state.held.entries())) {
+                if (held.lockRoot && !held.retainOnExit) {
+                    void releaseHeldLock(state, normalizedTargetPath, held, { force: true }).catch(() => undefined);
+                }
+            }
+        }
+    });
+    return lifecycle;
+}
 async function releaseHeldLock(state, normalizedTargetPath, held, options = {}) {
     const current = state.held.get(normalizedTargetPath);
     if (current !== held) {
@@ -41092,6 +41897,7 @@ async function releaseHeldLock(state, normalizedTargetPath, held, options = {})
     }
 }
 function handleForHeldLock(state, normalizedTargetPath, held) {
+    ensureGlobalBeforeExitCleanupRegistered().armed = true;
     return createHeldSidecarLockHandle({
         normalizedTargetPath,
         held,
@@ -41104,8 +41910,12 @@ function createSidecarLockManager(key) {
         state.cleanupRegistered = true;
         state.reclaimCleanupRegistered = true;
         ensureGlobalExitCleanupRegistered();
+        ensureGlobalBeforeExitCleanupRegistered().armed = true;
     }
     async function acquire(options) {
+        if (options.retainOnExit === true && exitCleanupCannotRetain()) {
+            throw new errors_FsSafeError("helper-unavailable", "retainOnExit requires this process's exit handlers to be retain-aware; an older package copy registered them first");
+        }
         return await acquireSidecarLock(options, {
             held: state.held,
             reclaimGuards: state.reclaimGuards,
@@ -41175,6 +41985,8 @@ async function withSidecarLock(targetPath, options, fn) {
 
 
 
+
+
 function pinned_write_byteLength(input, encoding) {
     return typeof input === "string"
         ? Buffer.byteLength(input, encoding ?? "utf8")
@@ -41194,16 +42006,6 @@ function assertWithinMaxBytes(bytes, maxBytes) {
         throw new errors_FsSafeError("too-large", `file exceeds limit of ${maxBytes} bytes (got at least ${bytes})`);
     }
 }
-async function syncFileBestEffort(handle) {
-    try {
-        await handle.sync();
-    }
-    catch (error) {
-        if (error?.code !== "EPERM") {
-            throw error;
-        }
-    }
-}
 async function writeStreamToHandle(stream, handle, maxBytes) {
     let bytes = 0;
     for await (const chunk of stream) {
@@ -41245,7 +42047,7 @@ async function runPinnedWriteWithRenamePolicy(params) {
     const relativeTargetPath = writeParams.relativeParentPath
         ? `${writeParams.relativeParentPath}/${writeParams.basename}`
         : writeParams.basename;
-    const lockPath = external_node_path_.join(writeParams.rootPath, `.fs-safe-write-${sha256Hex(relativeTargetPath)}.lock`);
+    const lockPath = external_node_path_.join(writeParams.rootPath, `.fs-safe-write-${file_identity_sha256Hex(relativeTargetPath)}.lock`);
     return await withSidecarLock(writeParams.rootPath, {
         managerKey: `fs-safe.write:${targetPath}`,
         lockPath,
@@ -41259,6 +42061,11 @@ async function runPinnedWriteWithRenamePolicy(params) {
     }));
 }
 async function runPinnedWriteFallback(params) {
+    const exactRoot = typeof params.rootIdentity?.dev === "bigint" && typeof params.rootIdentity.ino === "bigint"
+        ? { dev: params.rootIdentity.dev, ino: params.rootIdentity.ino } : undefined;
+    if (exactRoot)
+        await inspectDirectoryIdentity(params.rootPath, exactRoot);
+    const guardOptions = { bigint: exactRoot !== undefined };
     let parentPath = params.relativeParentPath
         ? external_node_path_.join(params.rootPath, ...params.relativeParentPath.split("/"))
         : params.rootPath;
@@ -41274,8 +42081,8 @@ async function runPinnedWriteFallback(params) {
         });
     }
     const parentGuard = params.mkdir
-        ? await directory_guard_createAsyncDirectoryGuard(parentPath)
-        : await directory_guard_createNearestExistingDirectoryGuard(params.rootPath, parentPath);
+        ? await directory_guard_createAsyncDirectoryGuard(parentPath, guardOptions)
+        : await directory_guard_createNearestExistingDirectoryGuard(params.rootPath, parentPath, guardOptions);
     const targetPath = external_node_path_.join(parentPath, params.basename);
     if (params.overwrite === false) {
         const handle = await withAsyncDirectoryGuards([parentGuard], async () => await promises_.open(targetPath, external_node_fs_.constants.O_WRONLY | external_node_fs_.constants.O_CREAT | external_node_fs_.constants.O_EXCL, params.mode), {
@@ -41286,9 +42093,10 @@ async function runPinnedWriteFallback(params) {
             },
         });
         let created = true;
+        let createdIdentity;
         try {
-            const verificationIdentity = await handle.stat({ bigint: true });
-            await handle.chmod(params.mode);
+            const verificationIdentity = external_node_fs_.fstatSync(handle.fd, { bigint: true });
+            createdIdentity = verificationIdentity;
             if (params.input.kind === "buffer") {
                 assertWithinMaxBytes(pinned_write_byteLength(params.input.data, params.input.encoding), params.maxBytes);
                 if (typeof params.input.data === "string") {
@@ -41301,18 +42109,26 @@ async function runPinnedWriteFallback(params) {
             else {
                 await writeStreamToHandle(params.input.stream, handle, params.maxBytes);
             }
-            await syncFileBestEffort(handle);
-            const stat = await handle.stat();
-            await syncDirectoryBestEffort(parentPath);
+            // Content writes may clear set-ID bits; finalize them through the owned fd.
+            await handle.chmod(params.mode);
+            if (params.sync !== false)
+                await syncFileBestEffort(handle);
+            const stat = external_node_fs_.fstatSync(handle.fd);
+            if (params.sync !== false)
+                await syncDirectoryBestEffort(parentPath);
             // Publication is complete. A failed outer check must not remove its target.
             created = false;
             await params.verifyPublished?.(handle.fd, verificationIdentity, parentGuard);
             return { dev: stat.dev, ino: stat.ino };
         }
         finally {
-            await handle.close().catch(() => undefined);
-            if (created) {
-                await promises_.rm(targetPath, { force: true }).catch(() => undefined);
+            try {
+                if (created) {
+                    await cleanupPinnedFilePath({ pathname: targetPath, handle, identity: createdIdentity, parentGuard });
+                }
+            }
+            finally {
+                await handle.close().catch(() => undefined);
             }
         }
     }
@@ -41326,12 +42142,13 @@ async function runPinnedWriteFallback(params) {
             : 0);
     let handle;
     let tempStat;
+    let tempIdentity;
     let readHandle;
     let renamed = false;
     try {
         handle = await promises_.open(tempPath, tempFlags, params.mode);
-        let verificationIdentity = await handle.stat({ bigint: true });
-        await handle.chmod(params.mode);
+        let verificationIdentity = external_node_fs_.fstatSync(handle.fd, { bigint: true });
+        tempIdentity = verificationIdentity;
         if (params.input.kind === "buffer") {
             assertWithinMaxBytes(pinned_write_byteLength(params.input.data, params.input.encoding), params.maxBytes);
             if (typeof params.input.data === "string") {
@@ -41344,20 +42161,23 @@ async function runPinnedWriteFallback(params) {
         else {
             await writeStreamToHandle(params.input.stream, handle, params.maxBytes);
         }
-        tempStat = await handle.stat();
-        const tempPathStat = await promises_.lstat(tempPath);
+        tempStat = external_node_fs_.fstatSync(handle.fd);
+        const tempPathStat = external_node_fs_.lstatSync(tempPath);
         if (tempPathStat.isSymbolicLink() || !file_identity_sameFileIdentity(tempPathStat, tempStat)) {
             throw new errors_FsSafeError("path-mismatch", "fallback temp path changed during write");
         }
         const expectedTempStat = tempStat;
-        await syncFileBestEffort(handle);
+        await handle.chmod(params.mode);
+        if (params.sync !== false)
+            await syncFileBestEffort(handle);
         let verifiedIdentity = expectedTempStat;
         await withAsyncDirectoryGuards([parentGuard], async () => {
             await promises_.rename(tempPath, targetPath);
             renamed = true;
             await getFsSafeTestHooks()?.afterPinnedWriteFallbackRename?.(targetPath);
-            await syncDirectoryBestEffort(parentPath);
-            const targetStat = await promises_.lstat(targetPath);
+            if (params.sync !== false)
+                await syncDirectoryBestEffort(parentPath);
+            const targetStat = external_node_fs_.lstatSync(targetPath);
             if (targetStat.isSymbolicLink()) {
                 throw new errors_FsSafeError("path-mismatch", "fallback target changed during write");
             }
@@ -41372,10 +42192,10 @@ async function runPinnedWriteFallback(params) {
                 if (params.input.kind !== "buffer") {
                     throw new errors_FsSafeError("path-mismatch", "fallback target changed during write");
                 }
-                const expectedHash = sha256Hex(params.input.data, params.input.encoding);
+                const expectedHash = file_identity_sha256Hex(params.input.data, params.input.encoding);
                 readHandle = await promises_.open(targetPath, read_open_flags_resolveReadOpenFlags());
-                const readHandleStat = await readHandle.stat({ bigint: true });
-                const actualHash = sha256Hex(await readHandle.readFile());
+                const readHandleStat = external_node_fs_.fstatSync(readHandle.fd, { bigint: true });
+                const actualHash = file_identity_sha256Hex(await readHandle.readFile());
                 if (actualHash !== expectedHash) {
                     throw new errors_FsSafeError("path-mismatch", "fallback target changed during write");
                 }
@@ -41389,10 +42209,14 @@ async function runPinnedWriteFallback(params) {
         return { dev: verifiedIdentity.dev, ino: verifiedIdentity.ino };
     }
     finally {
-        await readHandle?.close().catch(() => undefined);
-        await handle?.close().catch(() => undefined);
-        if (!renamed) {
-            await promises_.rm(tempPath, { force: true }).catch(() => undefined);
+        try {
+            if (!renamed && handle) {
+                await cleanupPinnedFilePath({ pathname: tempPath, handle, identity: tempIdentity, parentGuard });
+            }
+        }
+        finally {
+            await readHandle?.close().catch(() => undefined);
+            await handle?.close().catch(() => undefined);
         }
     }
 }
@@ -41404,7 +42228,7 @@ async function runPinnedWriteFallback(params) {
 
 const PATH_ALIAS_POLICIES = ROOT_PATH_ALIAS_POLICIES;
 async function assertNoPathAliasEscape(params) {
-    const resolved = await resolveRootPath({
+    const resolved = await root_path_resolveRootPath({
         absolutePath: params.absolutePath,
         rootPath: params.rootPath,
         boundaryLabel: params.boundaryLabel,
@@ -41427,7 +42251,7 @@ async function assertNoHardlinkedFinalPath(params) {
     }
     let stat;
     try {
-        stat = await promises_.stat(params.filePath);
+        stat = external_node_fs_.statSync(params.filePath);
     }
     catch (err) {
         if (path_isNotFoundPathError(err)) {
@@ -41446,9 +42270,6 @@ async function assertNoHardlinkedFinalPath(params) {
 // EXTERNAL MODULE: external "node:url"
 var external_node_url_ = __webpack_require__(3136);
 ;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/string-coerce.js
-function readStringValue(value) {
-    return typeof value === "string" ? value : undefined;
-}
 function normalizeNullableString(value) {
     if (typeof value !== "string") {
         return null;
@@ -41459,65 +42280,12 @@ function normalizeNullableString(value) {
 function normalizeOptionalString(value) {
     return normalizeNullableString(value) ?? undefined;
 }
-function normalizeStringifiedOptionalString(value) {
-    if (typeof value === "string") {
-        return normalizeOptionalString(value);
-    }
-    if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
-        return normalizeOptionalString(String(value));
-    }
-    return undefined;
-}
 function normalizeOptionalLowercaseString(value) {
     return normalizeOptionalString(value)?.toLowerCase();
 }
 function normalizeLowercaseStringOrEmpty(value) {
     return normalizeOptionalLowercaseString(value) ?? "";
 }
-function normalizeFastMode(raw) {
-    if (typeof raw === "boolean") {
-        return raw;
-    }
-    if (!raw) {
-        return undefined;
-    }
-    const key = normalizeLowercaseStringOrEmpty(raw);
-    if (["off", "false", "no", "0", "disable", "disabled", "normal"].includes(key)) {
-        return false;
-    }
-    if (["on", "true", "yes", "1", "enable", "enabled", "fast"].includes(key)) {
-        return true;
-    }
-    return undefined;
-}
-function lowercasePreservingWhitespace(value) {
-    return value.toLowerCase();
-}
-function localeLowercasePreservingWhitespace(value) {
-    return value.toLocaleLowerCase();
-}
-function resolvePrimaryStringValue(value) {
-    if (typeof value === "string") {
-        return normalizeOptionalString(value);
-    }
-    if (!value || typeof value !== "object") {
-        return undefined;
-    }
-    return normalizeOptionalString(value.primary);
-}
-function normalizeOptionalThreadValue(value) {
-    if (typeof value === "number") {
-        return Number.isFinite(value) ? Math.trunc(value) : undefined;
-    }
-    return normalizeOptionalString(value);
-}
-function normalizeOptionalStringifiedId(value) {
-    const normalized = normalizeOptionalThreadValue(value);
-    return normalized == null ? undefined : String(normalized);
-}
-function hasNonEmptyString(value) {
-    return normalizeOptionalString(value) !== undefined;
-}
 
 ;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/local-file-access.js
 
@@ -41709,8 +42477,11 @@ function normalizeWindowsDeviceBaseName(filePath) {
     const normalized = trimTrailingWindowsSeparators(filePath.replace(/\//g, "\\"));
     const lastSegment = normalized.split("\\").filter(Boolean).at(-1) ?? normalized;
     const withoutStream = lastSegment.split(":")[0] ?? lastSegment;
-    const withoutTrailingIgnoredChars = trimTrailingWindowsIgnoredChars(withoutStream);
-    return (withoutTrailingIgnoredChars.split(".")[0] ?? withoutTrailingIgnoredChars).toUpperCase();
+    const stem = withoutStream.split(".")[0] ?? withoutStream;
+    return trimTrailingWindowsIgnoredChars(stem).toUpperCase();
+}
+function isWindowsReservedDeviceName(name) {
+    return name.length > 0 && WINDOWS_RESERVED_DEVICE_NAMES.has(normalizeWindowsDeviceBaseName(name));
 }
 function matchWindowsDeviceReadPath(filePath) {
     const normalized = filePath.replace(/\//g, "\\");
@@ -41764,6 +42535,42 @@ async function read_opened_file_readOpenedFileSafely(params) {
     };
 }
 
+;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/write-open-flags.js
+
+
+function resolveNonblockingWriteFlag(constants = external_node_fs_.constants) {
+    return process.platform !== "win32" && typeof constants.O_NONBLOCK === "number"
+        ? constants.O_NONBLOCK
+        : 0;
+}
+function isNonblockingWriteEnxio(error, flags) {
+    return hasNodeErrorCode(error, "ENXIO") &&
+        (flags & (external_node_fs_.constants.O_WRONLY | external_node_fs_.constants.O_RDWR)) === external_node_fs_.constants.O_WRONLY &&
+        (flags & resolveNonblockingWriteFlag()) !== 0;
+}
+// A no-reader FIFO rejects a nonblocking write-only open before fstat is possible.
+// Reclassify only a confirmed non-regular path; inconclusive races keep the errno.
+async function isNonRegularWriteOpenError(error, filePath, flags) {
+    if (!isNonblockingWriteEnxio(error, flags))
+        return false;
+    try {
+        return !external_node_fs_.lstatSync(filePath).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function isNonRegularWriteOpenErrorSync(error, filePath, flags) {
+    if (!isNonblockingWriteEnxio(error, flags))
+        return false;
+    try {
+        return !fsSync.lstatSync(filePath).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+
 ;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/home-dir.js
 
 
@@ -41782,10 +42589,6 @@ function resolveEffectiveHomeDir(env = process.env, homedir = external_node_os_.
     const raw = resolveRawHomeDir(env, homedir);
     return raw ? external_node_path_.resolve(raw) : undefined;
 }
-function resolveOsHomeDir(env = process.env, homedir = os.homedir) {
-    const raw = resolveRawOsHomeDir(env, homedir);
-    return raw ? path.resolve(raw) : undefined;
-}
 function resolveRawHomeDir(env, homedir) {
     const explicitHome = normalize(env.OPENCLAW_HOME);
     if (!explicitHome) {
@@ -41826,9 +42629,6 @@ function normalizeSafe(homedir) {
 function resolveRequiredHomeDir(env = process.env, homedir = os.homedir) {
     return resolveEffectiveHomeDir(env, homedir) ?? path.resolve(process.cwd());
 }
-function resolveRequiredOsHomeDir(env = process.env, homedir = os.homedir) {
-    return resolveOsHomeDir(env, homedir) ?? path.resolve(process.cwd());
-}
 function expandHomePrefix(input, opts) {
     const segments = external_node_path_.normalize(input).split(external_node_path_.sep);
     if (segments[0] !== "~") {
@@ -41856,27 +42656,6 @@ function resolveHomeRelativePath(input, opts) {
     });
     return path.resolve(expanded);
 }
-function resolveUserPath(input, optsOrEnv, homedir) {
-    const opts = optsOrEnv && ("env" in optsOrEnv || "homedir" in optsOrEnv)
-        ? optsOrEnv
-        : { env: optsOrEnv, homedir };
-    return resolveHomeRelativePath(input, opts);
-}
-function resolveOsHomeRelativePath(input, opts) {
-    if (!input) {
-        return input;
-    }
-    const segments = path.normalize(input).split(path.sep);
-    if (segments[0] !== "~") {
-        return path.resolve(input);
-    }
-    const expanded = expandHomePrefix(input, {
-        home: resolveRequiredOsHomeDir(opts?.env ?? process.env, opts?.homedir ?? os.homedir),
-        env: opts?.env,
-        homedir: opts?.homedir,
-    });
-    return path.resolve(expanded);
-}
 
 ;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/root-context.js
 
@@ -41889,6 +42668,7 @@ function resolveOsHomeRelativePath(input, opts) {
 
 
 
+
 const ensureTrailingSep = (value) => value.endsWith(external_node_path_.sep) ? value : value + external_node_path_.sep;
 function assertValidRootRelativePath(relativePath) {
     path_assertNoNulPathInput(relativePath, "relative path contains a NUL byte");
@@ -41905,7 +42685,7 @@ async function expandRelativePathWithHome(relativePath) {
     if (cachedHomePath?.raw !== rawHome) {
         let realHome = rawHome;
         try {
-            realHome = await promises_.realpath(rawHome);
+            realHome = external_node_fs_.realpathSync.native(rawHome);
         }
         catch {
             // If the home dir cannot be canonicalized, keep lexical expansion behavior.
@@ -41919,8 +42699,8 @@ async function resolveRootContext(rootDir) {
     let rootReal;
     let rootIdentity;
     try {
-        rootReal = await promises_.realpath(rootDir);
-        const rootStat = await promises_.stat(rootReal);
+        rootReal = external_node_fs_.realpathSync.native(rootDir);
+        const rootStat = external_node_fs_.statSync(rootReal);
         if (!rootStat.isDirectory()) {
             throw new errors_FsSafeError("invalid-path", "root dir is not a directory");
         }
@@ -41942,10 +42722,28 @@ async function resolveRootContext(rootDir) {
         rootWithSep: ensureTrailingSep(rootReal),
     };
 }
+function rootRelativeReadPath(root, filePath) {
+    const absoluteInput = external_node_path_.isAbsolute(filePath);
+    const candidatePath = absoluteInput
+        ? external_node_path_.resolve(filePath)
+        : external_node_path_.resolve(root.rootDir, filePath);
+    let relativeBase = root.rootDir;
+    if (absoluteInput &&
+        !path_isPathInside(root.rootDir, candidatePath) &&
+        path_isPathInside(root.rootReal, candidatePath)) {
+        // A Root created through an alias has two valid in-root absolute spellings.
+        relativeBase = root.rootReal;
+    }
+    return external_node_path_.relative(relativeBase, candidatePath);
+}
 async function assertRootIdentityCurrent(root) {
     let current;
     try {
-        current = await promises_.lstat(root.rootReal);
+        if (typeof root.rootIdentity.dev === "bigint" && typeof root.rootIdentity.ino === "bigint") {
+            await inspectDirectoryIdentity(root.rootReal, { dev: root.rootIdentity.dev, ino: root.rootIdentity.ino });
+            return;
+        }
+        current = external_node_fs_.lstatSync(root.rootReal);
     }
     catch (error) {
         throw new errors_FsSafeError("path-mismatch", "root path changed during operation", {
@@ -41973,7 +42771,7 @@ async function resolvePathInRoot(root, relativePath, options) {
         ? expanded
         : `${root.rootWithSep}${expanded}`;
     try {
-        await resolveRootPath({
+        await root_path_resolveRootPath({
             absolutePath: rawAbsolutePath,
             rootPath: root.rootReal,
             rootCanonicalPath: root.rootReal,
@@ -42051,17 +42849,19 @@ async function* walkRoot(root, relativePath, options) {
     const maxEntries = validateBudget("maxEntries", options.maxEntries);
     const visitedDirectories = new Set();
     let examined = 0;
+    let truncated = false;
     const onLimit = (atPath) => {
         if ((options.limitBehavior ?? "truncate") === "throw") {
             throw new errors_FsSafeError("too-large", `root walk budget exceeded at ${atPath || "."}`);
         }
+        truncated = true;
         return limitEntry(atPath);
     };
     async function* visit(directory, depth) {
         options.signal?.throwIfAborted();
         let entries;
         try {
-            const resolvedDirectory = await resolveRootPath({
+            const resolvedDirectory = await root_path_resolveRootPath({
                 absolutePath: external_node_path_.resolve(root.rootReal, directory),
                 rootPath: root.rootReal,
                 rootCanonicalPath: root.rootReal,
@@ -42105,7 +42905,7 @@ async function* walkRoot(root, relativePath, options) {
                 if (options.symlinkPolicy === "skip") {
                     continue;
                 }
-                const resolved = await resolveRootPath({
+                const resolved = await root_path_resolveRootPath({
                     absolutePath: external_node_path_.resolve(root.rootReal, child),
                     rootPath: root.rootReal,
                     rootCanonicalPath: root.rootReal,
@@ -42136,6 +42936,8 @@ async function* walkRoot(root, relativePath, options) {
                 return;
             }
             yield* visit(child, depth + 1);
+            if (truncated)
+                return;
         }
     }
     yield* visit(relativePath, 0);
@@ -42153,7 +42955,7 @@ function pathStillMatchesReceipt(entry) {
     try {
         const current = external_node_fs_.lstatSync(entry.path, { bigint: true });
         return (!entry.singleLinkFile || (current.isFile() && current.nlink === 1n)) &&
-            sameFileIdentityForCleanup(current, entry.identity);
+            file_identity_sameFileIdentityForCleanup(current, entry.identity);
     }
     catch (error) {
         return !entry.singleLinkFile && error.code === "ENOENT";
@@ -42184,7 +42986,7 @@ function cleanupRegisteredTempPathsSync() {
     }
     tempCleanupEntries.clear();
 }
-function registerTempPathForExit(tempPath, options) {
+function temp_cleanup_registerTempPathForExit(tempPath, options) {
     if (!cleanupRegistered) {
         cleanupRegistered = true;
         process.once("exit", cleanupRegisteredTempPathsSync);
@@ -42288,21 +43090,27 @@ async function verifyAtomicWriteResult(params) {
             throw new errors_FsSafeError("path-mismatch", "descriptor changed during write");
         }
         assertFile(stat);
+        if (process.platform !== "win32" && params.expectedMode !== undefined) {
+            const actualMode = Number(stat.mode & 4095n);
+            if (actualMode !== params.expectedMode) {
+                throw new Error(`Private secret file ${params.targetPath} has insecure permissions ${actualMode.toString(8)}.`);
+            }
+        }
         return stat;
     };
     try {
         // This descriptor remains owned by the writer, even when final mode forbids opens.
         const stat = assertDescriptor();
-        assertPath(await promises_.lstat(params.targetPath, { bigint: true }));
-        const realPath = await resolveOpenedFileRealPathForFd(params.fd, stat, params.targetPath);
-        assertPath(await promises_.stat(realPath, { bigint: true }));
+        assertPath(external_node_fs_.lstatSync(params.targetPath, { bigint: true }));
+        const { realPath } = await resolveOpenedFileRealPathForFd(params.fd, stat, params.targetPath);
+        assertPath(external_node_fs_.statSync(realPath, { bigint: true }));
         if (!path_isPathInside(params.root.rootWithSep, realPath)) {
             throw outsideWorkspaceError();
         }
-        await assertAsyncDirectoryGuard(params.parentGuard);
+        await directory_guard_assertAsyncDirectoryGuard(params.parentGuard);
         await assertRootIdentityCurrent(params.root);
         // Recheck after canonical resolution and directory checks, including late links.
-        assertPath(await promises_.lstat(params.targetPath, { bigint: true }));
+        assertPath(external_node_fs_.lstatSync(params.targetPath, { bigint: true }));
         assertDescriptor();
         if (needsPathOpen) {
             // A retained fd cannot prove that an opaque Windows pathname still names it.
@@ -42320,15 +43128,15 @@ async function verifyAtomicWriteResult(params) {
             });
             try {
                 const reopenedStat = assertDescriptor(opened.fd);
-                assertPath(await promises_.lstat(params.targetPath, { bigint: true }));
-                const reopenedPath = await resolveOpenedFileRealPathForFd(opened.fd, reopenedStat, params.targetPath);
-                assertPath(await promises_.stat(reopenedPath, { bigint: true }));
+                assertPath(external_node_fs_.lstatSync(params.targetPath, { bigint: true }));
+                const { realPath: reopenedPath } = await resolveOpenedFileRealPathForFd(opened.fd, reopenedStat, params.targetPath);
+                assertPath(external_node_fs_.statSync(reopenedPath, { bigint: true }));
                 if (!path_isPathInside(params.root.rootWithSep, reopenedPath)) {
                     throw outsideWorkspaceError();
                 }
-                await assertAsyncDirectoryGuard(params.parentGuard);
+                await directory_guard_assertAsyncDirectoryGuard(params.parentGuard);
                 await assertRootIdentityCurrent(params.root);
-                assertPath(await promises_.lstat(params.targetPath, { bigint: true }));
+                assertPath(external_node_fs_.lstatSync(params.targetPath, { bigint: true }));
                 assertDescriptor(opened.fd);
             }
             finally {
@@ -42343,6 +43151,74 @@ async function verifyAtomicWriteResult(params) {
     }
 }
 
+;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/root-write-mode.js
+
+
+
+
+
+
+
+
+// The caller has already resolved and guarded this write target.
+async function inheritWriteTargetMode(params) {
+    try {
+        const existing = await strict_file_identity_inspectFileIdentity(() => external_node_fs_.lstatSync(params.targetPath, { bigint: true }));
+        if (existing.isSymbolicLink())
+            throw new errors_FsSafeError("path-alias", "path alias escape blocked");
+        if (!existing.isFile())
+            throw new errors_FsSafeError("not-file", "not a file");
+        if (existing.nlink > 1n)
+            throw hardlinkedPathNotAllowedError();
+        if (!path_isPathInside(params.rootWithSep, params.targetPath))
+            throw outsideWorkspaceError();
+        // Preserve read-open admission of the pre-existing destination. access(2)
+        // is not equivalent: it ignores ACLs on Windows and capabilities on Linux.
+        const handle = await promises_.open(params.targetPath, read_open_flags_resolveReadOpenFlags());
+        try {
+            // Bind admission to the inode whose metadata is inherited.
+            if (!file_identity_sameFileIdentity(external_node_fs_.fstatSync(handle.fd, { bigint: true }), existing)) {
+                throw new errors_FsSafeError("path-mismatch", "write target changed during mode inheritance");
+            }
+        }
+        finally {
+            await handle.close().catch(() => undefined);
+        }
+        try {
+            // A parent can change after guarded resolution. Do not inherit metadata
+            // from an outside inode, even if the parent is restored before publication.
+            const realPath = external_node_fs_.realpathSync.native(params.targetPath);
+            if (!path_isPathInside(params.rootWithSep, realPath))
+                throw outsideWorkspaceError();
+            await strict_file_identity_inspectFileIdentity(async () => {
+                const current = external_node_fs_.statSync(realPath, { bigint: true });
+                if (!current.isFile())
+                    throw new errors_FsSafeError("not-file", "not a file");
+                if (current.nlink > 1n)
+                    throw hardlinkedPathNotAllowedError();
+                return current;
+            }, existing);
+        }
+        catch (error) {
+            if (path_isNotFoundPathError(error)) {
+                throw new errors_FsSafeError("path-mismatch", "write target changed during mode inheritance", { cause: error });
+            }
+            throw error;
+        }
+        return params.requestedMode ?? Number(existing.mode & 511n);
+    }
+    catch (error) {
+        if (!path_isNotFoundPathError(error))
+            throw error;
+        return params.requestedMode ?? 0o600;
+    }
+}
+
+;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/copy-publication.js
+// Internal composition hook; the descriptor is borrowed until the callback returns.
+// Kept off RootCopyOptions and all public package exports.
+const onCopyPublication = Symbol("onCopyPublication");
+
 ;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/root-impl.js
 
 
@@ -42372,6 +43248,9 @@ async function verifyAtomicWriteResult(params) {
 
 
 
+
+
+
 
 
 
@@ -42384,12 +43263,14 @@ function logWarn(message) {
 const SUPPORTS_NOFOLLOW = process.platform !== "win32" && "O_NOFOLLOW" in external_node_fs_.constants;
 const OPEN_READ_FLAGS = read_open_flags_resolveReadOpenFlags();
 const OPEN_READ_FOLLOW_FLAGS = read_open_flags_resolveReadOpenFlags({ followSymlinks: true });
-const OPEN_WRITE_EXISTING_FLAGS = external_node_fs_.constants.O_WRONLY | (SUPPORTS_NOFOLLOW ? external_node_fs_.constants.O_NOFOLLOW : 0);
+const OPEN_WRITE_EXISTING_FLAGS = external_node_fs_.constants.O_WRONLY | (SUPPORTS_NOFOLLOW ? external_node_fs_.constants.O_NOFOLLOW : 0) |
+    resolveNonblockingWriteFlag();
 const OPEN_WRITE_CREATE_FLAGS = external_node_fs_.constants.O_WRONLY |
     external_node_fs_.constants.O_CREAT |
     external_node_fs_.constants.O_EXCL |
     (SUPPORTS_NOFOLLOW ? external_node_fs_.constants.O_NOFOLLOW : 0);
-const OPEN_APPEND_EXISTING_FLAGS = external_node_fs_.constants.O_RDWR | external_node_fs_.constants.O_APPEND | (SUPPORTS_NOFOLLOW ? external_node_fs_.constants.O_NOFOLLOW : 0);
+const OPEN_APPEND_EXISTING_FLAGS = external_node_fs_.constants.O_RDWR | external_node_fs_.constants.O_APPEND | (SUPPORTS_NOFOLLOW ? external_node_fs_.constants.O_NOFOLLOW : 0) |
+    resolveNonblockingWriteFlag();
 const OPEN_APPEND_CREATE_FLAGS = external_node_fs_.constants.O_RDWR |
     external_node_fs_.constants.O_APPEND |
     external_node_fs_.constants.O_CREAT |
@@ -42428,8 +43309,8 @@ async function openVerifiedLocalFile(filePath, options) {
     // Reject directories before opening so we never surface EISDIR to callers (e.g. tool
     // results that get sent to messaging channels). See openclaw/openclaw#31186.
     try {
-        preOpenStat = await inspectFileIdentity(async () => {
-            const stat = await promises_.lstat(filePath, { bigint: true });
+        preOpenStat = await strict_file_identity_inspectFileIdentity(async () => {
+            const stat = external_node_fs_.lstatSync(filePath, { bigint: true });
             observedBeforeOpen = true;
             if (stat.isSymbolicLink() && options?.symlinks !== "follow-within-root") {
                 throw new errors_FsSafeError("symlink", "symlink not allowed");
@@ -42469,13 +43350,13 @@ async function openVerifiedLocalFile(filePath, options) {
     }
     try {
         await fsSafeTestHooks?.afterOpen?.(filePath, handle);
-        const stat = await handle.stat();
+        const stat = external_node_fs_.fstatSync(handle.fd);
         if (!stat.isFile()) {
             throw new errors_FsSafeError("not-file", "not a file");
         }
         // Keep numeric Stats for the public receipt, never for identity verification.
         let openedIdentity;
-        const identity = await inspectFileIdentity(async () => (openedIdentity = await handle.stat({ bigint: true })), preOpenStat && !preOpenStat.isSymbolicLink() ? preOpenStat : undefined).catch(async (error) => {
+        const identity = await strict_file_identity_inspectFileIdentity(async () => (openedIdentity = external_node_fs_.fstatSync(handle.fd, { bigint: true })), preOpenStat && !preOpenStat.isSymbolicLink() ? preOpenStat : undefined).catch(async (error) => {
             if ([0, 1].includes(stat.nlink)) {
                 await recordPreOpenFileChange(error, handle, filePath, preOpenStat, openedIdentity);
             }
@@ -42486,7 +43367,7 @@ async function openVerifiedLocalFile(filePath, options) {
         }
         const inspectPathIdentity = async (inspect) => {
             try {
-                return await inspectFileIdentity(inspect, identity);
+                return await strict_file_identity_inspectFileIdentity(inspect, identity);
             }
             catch (error) {
                 const failure = path_isNotFoundPathError(error) ? openedPathResolutionError(fileNotFoundError()) : error;
@@ -42498,23 +43379,28 @@ async function openVerifiedLocalFile(filePath, options) {
         };
         await inspectPathIdentity(async () => {
             const pathStat = options?.symlinks === "follow-within-root"
-                ? await promises_.stat(filePath, { bigint: true })
-                : await promises_.lstat(filePath, { bigint: true });
+                ? external_node_fs_.statSync(filePath, { bigint: true })
+                : external_node_fs_.lstatSync(filePath, { bigint: true });
             if (pathStat.isSymbolicLink() && options?.symlinks !== "follow-within-root") {
                 throw new errors_FsSafeError("symlink", "symlink not allowed");
             }
             return pathStat;
         });
         await fsSafeTestHooks?.afterOpenedPathIdentityCheck?.(filePath, handle);
-        const realPath = await resolveOpenedFileRealPathForFd(handle.fd, identity, filePath)
+        const resolved = await resolveOpenedFileRealPathForFd(handle.fd, identity, filePath)
             .catch(async (error) => {
             if (stat.nlink <= 1 && (!preOpenStat || preOpenStat.nlink <= 1n)) {
                 await recordOpenedFileFailure(error, handle, filePath, identity);
             }
             throw error;
         });
+        const { realPath } = resolved;
+        let resolvedStat = resolved.stat;
         await inspectPathIdentity(async () => {
-            const realStat = await promises_.stat(realPath, { bigint: true });
+            // Reuse the post-realpath observation; unknown Windows identities still
+            // get a fresh observation on inspectFileIdentity's retry.
+            const realStat = resolvedStat ?? external_node_fs_.statSync(realPath, { bigint: true });
+            resolvedStat = undefined;
             if (options?.hardlinks === "reject" && realStat.nlink > 1n) {
                 throw hardlinkedPathNotAllowedError();
             }
@@ -42612,6 +43498,7 @@ class RootHandle {
             mkdir: this.defaults.mkdir,
             mode: this.defaults.mode,
             ...this.mutationOptions(options),
+            durable: options.durable ?? this.defaults.durable ?? true,
         });
     }
     async remove(relativePath, options = {}) {
@@ -42644,6 +43531,7 @@ class RootHandle {
             mode: this.defaults.mode,
             renameIdentity: this.defaults.renameIdentity,
             ...this.mutationOptions(options),
+            durable: options.durable ?? this.defaults.durable ?? true,
         });
     }
     async create(relativePath, data, options = {}) {
@@ -42654,6 +43542,7 @@ class RootHandle {
             mkdir: this.defaults.mkdir,
             mode: this.defaults.mode,
             ...this.mutationOptions(options),
+            durable: options.durable ?? this.defaults.durable ?? true,
             overwrite: false,
         });
     }
@@ -42677,6 +43566,8 @@ class RootHandle {
             mkdir: this.defaults.mkdir,
             mode: this.defaults.mode,
             ...copyOptions,
+            durable: options.durable ?? this.defaults.durable ?? true,
+            verifyPublished: options[onCopyPublication],
         });
     }
     async exists(relativePath) {
@@ -42727,7 +43618,6 @@ function readDefaults(defaults) {
     return {
         hardlinks: defaults.hardlinks,
         maxBytes: byte_budget_normalizeMaxBytes(defaults.maxBytes, { defaultValue: DEFAULT_ROOT_MAX_BYTES }),
-        nonBlockingRead: defaults.nonBlockingRead,
         symlinks: defaults.symlinks,
     };
 }
@@ -42736,8 +43626,6 @@ function mergeReadOptions(defaults, options) {
     if (options.hardlinks !== undefined)
         merged.hardlinks = options.hardlinks;
     merged.maxBytes = byte_budget_normalizeMaxBytes(options.maxBytes, { defaultValue: merged.maxBytes });
-    if (options.nonBlockingRead !== undefined)
-        merged.nonBlockingRead = options.nonBlockingRead;
     if (options.symlinks !== undefined)
         merged.symlinks = options.symlinks;
     return merged;
@@ -42753,7 +43641,6 @@ async function openFileInRoot(root, params) {
         rejectSymlinks: params.symlinks !== "follow-within-root",
     });
     const { opened } = await openVerifiedLocalFile(resolved, {
-        nonBlockingRead: params.nonBlockingRead,
         symlinks: params.symlinks,
     });
     if (params.hardlinks !== "allow" && opened.stat.nlink > 1) {
@@ -42776,16 +43663,11 @@ async function readFileInRoot(root, params) {
     }
 }
 async function readPathInRoot(root, params) {
-    const rootDir = root.rootDir;
-    const candidatePath = external_node_path_.isAbsolute(params.filePath)
-        ? external_node_path_.resolve(params.filePath)
-        : external_node_path_.resolve(rootDir, params.filePath);
-    const relativePath = external_node_path_.relative(rootDir, candidatePath);
+    const relativePath = rootRelativeReadPath(root, params.filePath);
     return await readFileInRoot(root, {
         relativePath,
         hardlinks: params.hardlinks,
         maxBytes: params.maxBytes,
-        nonBlockingRead: params.nonBlockingRead,
         symlinks: params.symlinks,
     });
 }
@@ -42832,7 +43714,7 @@ async function writeTempFileForAtomicReplace(params) {
         }
         return {
             handle: tempHandle,
-            identity: await tempHandle.stat({ bigint: true }),
+            identity: external_node_fs_.fstatSync(tempHandle.fd, { bigint: true }),
         };
     }
     catch (error) {
@@ -42871,7 +43753,7 @@ async function openWritableFileInRoot(root, params) {
         ? resolved
         : await prepareRootWriteTarget(rootReal, resolved);
     try {
-        const resolvedRealPath = await promises_.realpath(ioPath);
+        const resolvedRealPath = external_node_fs_.realpathSync.native(ioPath);
         if (!path_isPathInside(rootWithSep, resolvedRealPath)) {
             throw outsideWorkspaceError();
         }
@@ -42895,6 +43777,9 @@ async function openWritableFileInRoot(root, params) {
             handle = await promises_.open(ioPath, existingFlags, mode);
         }
         catch (err) {
+            if (await isNonRegularWriteOpenError(err, ioPath, existingFlags)) {
+                throw new errors_FsSafeError("not-file", "path is not a regular file under root");
+            }
             if (!path_isNotFoundPathError(err)) {
                 throw err;
             }
@@ -42917,7 +43802,7 @@ async function openWritableFileInRoot(root, params) {
     let realPathForCleanup = null;
     let createdIdentity = null;
     try {
-        const stat = await handle.stat();
+        const stat = external_node_fs_.fstatSync(handle.fd);
         if (createdForWrite) {
             createdIdentity = stat;
         }
@@ -42928,7 +43813,7 @@ async function openWritableFileInRoot(root, params) {
             throw hardlinkedPathNotAllowedError();
         }
         try {
-            const lstat = await promises_.lstat(ioPath);
+            const lstat = external_node_fs_.lstatSync(ioPath);
             if (lstat.isSymbolicLink() || !lstat.isFile()) {
                 throw new errors_FsSafeError(lstat.isSymbolicLink() ? "symlink" : "not-file", "path is not a regular file under root");
             }
@@ -42943,7 +43828,7 @@ async function openWritableFileInRoot(root, params) {
         }
         const realPath = await resolveOpenedFileRealPathForHandle(handle, ioPath);
         realPathForCleanup = realPath;
-        const realStat = await promises_.stat(realPath);
+        const realStat = external_node_fs_.statSync(realPath);
         if (!file_identity_sameFileIdentity(stat, realStat)) {
             throw new errors_FsSafeError("path-mismatch", "path mismatch");
         }
@@ -43006,8 +43891,9 @@ async function appendFileInRoot(root, params) {
             const payload = prefix.length > 0 ? Buffer.concat([Buffer.from(prefix, "utf8"), params.data]) : params.data;
             await target.handle.appendFile(payload);
         }
-        await target.handle.sync();
-        if (target.createdForWrite) {
+        if (params.durable !== false)
+            await target.handle.sync();
+        if (params.durable !== false && target.createdForWrite) {
             await syncDirectoryBestEffort(external_node_path_.dirname(target.realPath));
         }
     }
@@ -43063,6 +43949,7 @@ async function commitPinnedWriteInRoot(root, pinned, params) {
             renameIdentity: params.renameIdentity,
             mkdir: params.mkdir !== false,
             mode: params.mode ?? pinned.mode,
+            sync: params.durable !== false,
             overwrite: params.overwrite,
             input: { kind: "buffer", data: params.data, encoding: params.encoding },
             rootIdentity: root.rootIdentity,
@@ -43124,6 +44011,8 @@ async function copyFileInRoot(root, params) {
                         mode: pinned.mode,
                         overwrite: true,
                         maxBytes: params.maxBytes,
+                        sync: params.durable !== false,
+                        verifyPublished: params.verifyPublished,
                         input: { kind: "stream", stream: source.handle.createReadStream() },
                         rootIdentity: root.rootIdentity,
                     });
@@ -43146,12 +44035,12 @@ async function copyFileInRoot(root, params) {
     }
 }
 async function assertCopySourceCurrent(source, identity) {
-    await inspectFileIdentity(() => source.handle.stat({ bigint: true }), identity);
+    await strict_file_identity_inspectFileIdentity(() => external_node_fs_.fstatSync(source.handle.fd, { bigint: true }), identity);
     await assertCopySourcePathCurrent(source, identity);
 }
 async function assertCopySourcePathCurrent(source, identity) {
-    await inspectFileIdentity(async () => {
-        const current = await promises_.lstat(source.realPath, { bigint: true });
+    await strict_file_identity_inspectFileIdentity(async () => {
+        const current = external_node_fs_.lstatSync(source.realPath, { bigint: true });
         if (current.isSymbolicLink() || !current.isFile()) {
             throw new errors_FsSafeError("path-mismatch", "copy source path changed");
         }
@@ -43160,8 +44049,8 @@ async function assertCopySourcePathCurrent(source, identity) {
 }
 async function removePathIfIdentityUnchanged(targetPath, identity) {
     const parentGuard = await directory_guard_createAsyncDirectoryGuard(external_node_path_.dirname(targetPath));
-    const current = await promises_.lstat(targetPath);
-    if (current.isSymbolicLink() || !sameFileIdentityForCleanup(current, identity)) {
+    const current = external_node_fs_.lstatSync(targetPath);
+    if (current.isSymbolicLink() || !file_identity_sameFileIdentityForCleanup(current, identity)) {
         return;
     }
     await withAsyncDirectoryGuards([parentGuard], async () => {
@@ -43190,7 +44079,7 @@ async function resolvePinnedWriteTargetInRoot(root, relativePath, requestedMode,
     // and alias checks, but never open a competing owner's record just to reject it.
     if (!overwrite) {
         try {
-            const existing = await promises_.stat(resolved);
+            const existing = external_node_fs_.statSync(resolved);
             if (!existing.isFile())
                 throw new errors_FsSafeError("not-file", "not a file");
             if (existing.nlink > 1)
@@ -43202,31 +44091,9 @@ async function resolvePinnedWriteTargetInRoot(root, relativePath, requestedMode,
                 throw error;
         }
     }
-    let mode = requestedMode ?? 0o600;
-    try {
-        if (overwrite) {
-            const opened = await openFileInRoot(root, {
-                relativePath,
-                hardlinks: "reject",
-                nonBlockingRead: true,
-                symlinks: "follow-within-root",
-            });
-            try {
-                mode = requestedMode ?? (opened.stat.mode & 0o777);
-                if (!path_isPathInside(rootWithSep, opened.realPath)) {
-                    throw outsideWorkspaceError();
-                }
-            }
-            finally {
-                await opened.handle.close().catch(() => { });
-            }
-        }
-    }
-    catch (err) {
-        if (!(err instanceof errors_FsSafeError) || err.code !== "not-found") {
-            throw err;
-        }
-    }
+    const mode = overwrite
+        ? await inheritWriteTargetMode({ targetPath: resolved, rootWithSep, requestedMode })
+        : requestedMode ?? 0o600;
     return {
         rootReal,
         targetPath: resolved,
@@ -43276,7 +44143,7 @@ async function resolvePinnedRootPathInRoot(root, params) {
     let resolved;
     try {
         const expandedPath = await expandRelativePathWithHome(params.relativePath);
-        resolved = await resolveRootPath({
+        resolved = await root_path_resolveRootPath({
             absolutePath: external_node_path_.isAbsolute(expandedPath)
                 ? expandedPath
                 : `${ensureTrailingSep(rootReal)}${expandedPath}`,
@@ -43300,7 +44167,7 @@ async function prepareRemoveGuard(targetPath) {
     try {
         const guard = await directory_guard_createAsyncDirectoryGuard(external_node_path_.dirname(targetPath));
         await getFsSafeTestHooks()?.beforeRootFallbackMutation?.("remove", targetPath);
-        await assertAsyncDirectoryGuard(guard);
+        await directory_guard_assertAsyncDirectoryGuard(guard);
         return guard;
     }
     catch (error) {
@@ -43310,12 +44177,12 @@ async function prepareRemoveGuard(targetPath) {
 async function removePathFallback(resolved) {
     const guard = await prepareRemoveGuard(resolved.resolved);
     try {
-        await ((await promises_.lstat(resolved.resolved)).isDirectory() ? promises_.rmdir(resolved.resolved) : promises_.rm(resolved.resolved));
+        await (external_node_fs_.lstatSync(resolved.resolved).isDirectory() ? promises_.rmdir(resolved.resolved) : promises_.rm(resolved.resolved));
     }
     catch (error) {
         throw normalizeRemovePathError(error);
     }
-    await assertAsyncDirectoryGuard(guard).catch(() => undefined);
+    await directory_guard_assertAsyncDirectoryGuard(guard).catch(() => undefined);
 }
 async function mkdirPathFallback(resolved) {
     await mkdirPathComponentsWithGuards({
@@ -43326,7 +44193,7 @@ async function mkdirPathFallback(resolved) {
 async function statPathFallback(root, relativePath) {
     const resolved = await resolvePinnedPathInRoot(root, { relativePath, allowRoot: true });
     try {
-        const stat = pathStatFromStats(await promises_.lstat(resolved.resolved));
+        const stat = pathStatFromStats(external_node_fs_.lstatSync(resolved.resolved));
         await assertRootIdentityCurrent(root);
         return stat;
     }
@@ -43350,7 +44217,7 @@ async function listPathFallback(root, relativePath, withFileTypes) {
         for (const name of sortedNames) {
             entries.push({
                 name,
-                ...pathStatFromStats(await promises_.lstat(external_node_path_.join(resolved.resolved, name))),
+                ...pathStatFromStats(external_node_fs_.lstatSync(external_node_path_.join(resolved.resolved, name))),
             });
         }
         await assertRootIdentityCurrent(root);
@@ -43399,7 +44266,11 @@ async function movePathFallback(root, params) {
                 relativePath: params.toRelative,
                 policy: PATH_ALIAS_POLICIES.unlinkTarget,
             });
-            const targetStat = await promises_.lstat(resolvedTarget.resolved).catch(() => undefined);
+            let targetStat;
+            try {
+                targetStat = external_node_fs_.lstatSync(resolvedTarget.resolved);
+            }
+            catch { /* Advisory lookup. */ }
             return !(process.platform !== "win32" &&
                 params.overwrite &&
                 targetStat?.isSymbolicLink() === true);
@@ -43407,7 +44278,7 @@ async function movePathFallback(root, params) {
     });
     let sourceStat;
     try {
-        sourceStat = await promises_.lstat(source.resolved);
+        sourceStat = external_node_fs_.lstatSync(source.resolved);
     }
     catch (error) {
         if (path_isNotFoundPathError(error)) {
@@ -43426,7 +44297,7 @@ async function movePathFallback(root, params) {
     }
     if (!params.overwrite) {
         try {
-            await promises_.lstat(target.resolved);
+            external_node_fs_.lstatSync(target.resolved);
             throw new errors_FsSafeError("already-exists", "destination exists");
         }
         catch (error) {
@@ -43441,8 +44312,8 @@ async function movePathFallback(root, params) {
     const sourceParentGuard = await directory_guard_createAsyncDirectoryGuard(external_node_path_.dirname(source.resolved));
     const targetParentGuard = await directory_guard_createNearestExistingDirectoryGuard(target.rootReal, external_node_path_.dirname(target.resolved));
     await getFsSafeTestHooks()?.beforeRootFallbackMutation?.("move", target.resolved);
-    await assertAsyncDirectoryGuard(sourceParentGuard);
-    await assertAsyncDirectoryGuard(targetParentGuard);
+    await directory_guard_assertAsyncDirectoryGuard(sourceParentGuard);
+    await directory_guard_assertAsyncDirectoryGuard(targetParentGuard);
     try {
         await promises_.rename(source.resolved, target.resolved);
     }
@@ -43457,7 +44328,7 @@ async function movePathFallback(root, params) {
         }
         throw error;
     }
-    await assertAsyncDirectoryGuard(targetParentGuard).catch(() => undefined);
+    await directory_guard_assertAsyncDirectoryGuard(targetParentGuard).catch(() => undefined);
 }
 async function writeFileFallback(root, params) {
     if (params.overwrite === false) {
@@ -43467,7 +44338,8 @@ async function writeFileFallback(root, params) {
     const target = await openWritableFileInRoot(root, {
         relativePath: params.relativePath,
         mkdir: params.mkdir,
-        mode: params.mode,
+        // Private, writable placeholder: Windows cannot rename over a read-only file.
+        mode: 0o600,
         denyMutations: params.denyMutations,
         truncateExisting: false,
     });
@@ -43480,12 +44352,12 @@ async function writeFileFallback(root, params) {
     let writtenHandle;
     try {
         tempPath = buildAtomicWriteTempPath(destinationPath);
-        unregisterTempPath = registerTempPathForExit(tempPath);
+        unregisterTempPath = temp_cleanup_registerTempPathForExit(tempPath);
         const written = await writeTempFileForAtomicReplace({
             tempPath,
             data: params.data,
             encoding: params.encoding,
-            mode,
+            mode: 0o600,
         });
         writtenHandle = written.handle;
         unregisterTempPath.setIdentity(written.identity);
@@ -43496,6 +44368,14 @@ async function writeFileFallback(root, params) {
         });
         unregisterTempPath();
         unregisterTempPath = null;
+        // Final mode via the retained handle after publication, as the native writer does.
+        try {
+            await written.handle.chmod(mode);
+        }
+        catch (error) {
+            await removePathIfIdentityUnchanged(destinationPath, written.identity).catch(() => { });
+            throw error;
+        }
         try {
             await verifyAtomicWriteResult({
                 root,
@@ -43533,11 +44413,11 @@ async function writeMissingFileFallback(root, params) {
     let verifyingPublication = false;
     try {
         const { handle, writtenStat } = await withAsyncDirectoryGuards([parentGuard], async () => {
-            const handle = await promises_.open(targetPath, OPEN_WRITE_CREATE_FLAGS, params.mode ?? 0o600);
+            const handle = await promises_.open(targetPath, OPEN_WRITE_CREATE_FLAGS, params.mode ?? 0o600).catch((error) => recordExclusiveCreateFailure(error, targetPath));
             created = true;
             try {
-                createdIdentity = await handle.stat();
-                const writtenStat = await handle.stat({ bigint: true });
+                createdIdentity = external_node_fs_.fstatSync(handle.fd);
+                const writtenStat = external_node_fs_.fstatSync(handle.fd, { bigint: true });
                 if (typeof params.data === "string") {
                     await handle.writeFile(params.data, params.encoding ?? "utf8");
                 }
@@ -92069,4 +92949,4 @@ if (installedChunkData !== 0) { // 0 means "already installed".'
 // module factories are used so entry inlining is disabled
 // startup
 // Load entry module and return exports
-var __webpack_exports__ = __webpack_require__(3829);
+var __webpack_exports__ = __webpack_require__(6732);