@lousy-agents/mcp 5.21.4 → 5.21.5

package/dist/mcp-server.js

@@ -6559,7 +6559,7 @@ function escapeJsonPtr(str) {
 
 
 },
-836(__unused_rspack_module, __unused_rspack___webpack_exports__, __webpack_require__) {
+3829(__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);
@@ -37098,6 +37098,85 @@ function sameFileIdentityForCleanup(left, right, platform = process.platform) {
     return sameStatValue(left.dev, right.dev) && sameStatValue(left.ino, right.ino);
 }
 
+;// CONCATENATED MODULE: external "node:async_hooks"
+const external_node_async_hooks_namespaceObject = __rspack_createRequire_require("node:async_hooks");
+;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/file-observation.js
+
+const active = new external_node_async_hooks_namespaceObject.AsyncLocalStorage();
+function recordFileObservationFailure(error, kind) {
+    const failures = active.getStore();
+    if (!failures)
+        return;
+    let kinds = failures.get(error);
+    if (!kinds)
+        failures.set(error, kinds = new Set());
+    kinds.add(kind);
+}
+function isFileObservationFailure(error, kind) {
+    return active.getStore()?.get(error)?.has(kind) === true;
+}
+// Each Root observation owns its receipts, including nested and concurrent reads.
+function fileObservation() {
+    const failures = new Map();
+    return {
+        run(operation) { return active.run(failures, operation); },
+        has(error, kind) { return failures.get(error)?.has(kind) === true; },
+    };
+}
+
+;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/strict-file-identity.js
+
+
+function identityMismatch() {
+    const error = new errors_FsSafeError("path-mismatch", "file identity changed or could not be verified");
+    recordFileObservationFailure(error, "identity");
+    return error;
+}
+function identityCheck(expected, platform) {
+    const known = {};
+    const check = (stat) => {
+        let complete = true;
+        for (const field of ["dev", "ino"]) {
+            const value = stat[field];
+            // Numeric receipts cannot recover identity bits already lost to rounding.
+            if (typeof value !== "bigint")
+                throw identityMismatch();
+            if (platform === "win32" && value === 0n) {
+                complete = false;
+            }
+            else {
+                if (known[field] !== undefined && known[field] !== value)
+                    throw identityMismatch();
+                known[field] = value;
+            }
+        }
+        return complete;
+    };
+    if (expected && !check(expected))
+        throw identityMismatch();
+    return check;
+}
+// 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) {
+    const check = identityCheck(expected, platform);
+    for (let attempt = 0; attempt < 2; attempt++) {
+        const stat = await inspect();
+        if (check(stat))
+            return stat;
+    }
+    throw identityMismatch();
+}
+function inspectFileIdentitySync(inspect, expected, platform = process.platform) {
+    const check = identityCheck(expected, platform);
+    for (let attempt = 0; attempt < 2; attempt++) {
+        const stat = inspect();
+        if (check(stat))
+            return stat;
+    }
+    throw identityMismatch();
+}
+
 ;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/path.js
 
 
@@ -37312,6 +37391,7 @@ function normalizeRemovePathError(error) {
 
 
 
+
 async function directory_guard_createAsyncDirectoryGuard(dir) {
     const stat = await promises_.lstat(dir);
     if (stat.isSymbolicLink() || !stat.isDirectory()) {
@@ -37376,6 +37456,15 @@ function directory_guard_createNearestExistingSyncDirectoryGuard(rootReal, targe
     }
     return directory_guard_createSyncDirectoryGuard(root);
 }
+// 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 });
+        if (stat.isSymbolicLink() || !stat.isDirectory())
+            throw root_errors_directoryComponentNotDirectoryError();
+        return stat;
+    }, expected);
+}
 
 ;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/directory-durability.js
 
@@ -37817,6 +37906,8 @@ async function guardedRename(params) {
         ? await createNearestExistingDirectoryGuard(params.targetRoot, path.dirname(params.to))
         : await createAsyncDirectoryGuard(path.dirname(params.to));
     await withAsyncDirectoryGuards([sourceGuard, targetGuard], async () => {
+        // Authority must survive all awaited guards; do not yield before rename dispatch.
+        params.assertBeforeRename?.();
         await fs.rename(params.from, params.to);
     }, { verifyAfter: params.verifyAfter });
 }
@@ -37986,6 +38077,49 @@ function mergeDenyMutationPolicies(defaultPolicy, callPolicy) {
     };
 }
 
+;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/opened-file-failure.js
+
+
+
+function recordFileOpenFailure(error, filePath) {
+    recordFileObservationFailure(error, `open:${filePath}`);
+    throw error;
+}
+function openedPathResolutionError(error = new errors_FsSafeError("path-mismatch", "unable to resolve opened file path")) {
+    recordFileObservationFailure(error, "resolution");
+    return error;
+}
+async function recordPreOpenFileChange(error, handle, filePath, before, opened) {
+    if (!isFileObservationFailure(error, "identity") || !before?.isFile() || !opened?.isFile() ||
+        ![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);
+        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.
+            recordFileObservationFailure(error, `changed:${filePath}`);
+        }
+    }
+    catch {
+        // Unknown, changed, or closed descriptor evidence never permits a discard.
+    }
+}
+async function recordOpenedFileFailure(error, handle, filePath, identity) {
+    if ((!isFileObservationFailure(error, "resolution") && !isFileObservationFailure(error, "identity")) ||
+        !identity.isFile() || identity.nlink > 1n)
+        return;
+    try {
+        const current = await inspectFileIdentity(() => handle.stat({ bigint: true }), identity);
+        if (current.isFile() && current.nlink === 0n)
+            recordFileObservationFailure(error, `unlinked:${filePath}`);
+    }
+    catch {
+        // A closed, changed, or unknown descriptor provides no retry evidence.
+    }
+}
+
 ;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/opened-realpath.js
 
 
@@ -38025,6 +38159,12 @@ async function resolveOpenedFileRealPathForFd(fd, handleStat, ioPath) {
     }
     catch (err) {
         if (!path_isNotFoundPathError(err)) {
+            // Windows can fail here on a deleted-but-open file. Brand only this
+            // resolver operation; the caller must still prove unlink on the same fd.
+            if (process.platform === "win32" && err instanceof Error &&
+                ["EPERM", "EBADF"].includes(err.code ?? "")) {
+                throw openedPathResolutionError(err);
+            }
             throw err;
         }
     }
@@ -38032,7 +38172,7 @@ async function resolveOpenedFileRealPathForFd(fd, handleStat, ioPath) {
     if (parentResolved) {
         return parentResolved;
     }
-    throw new errors_FsSafeError("path-mismatch", "unable to resolve opened file path");
+    throw openedPathResolutionError();
 }
 async function resolveOpenedFileRealPathFromParent(handleStat, ioPath, statOptions) {
     let parentReal;
@@ -38526,7 +38666,7 @@ async function runPinnedWriteWindows(binding, params, root, parentFd, parentGuar
     let renamed = false;
     let completed = false;
     try {
-        tempName = `.${params.basename}.${(0,external_node_crypto_.randomUUID)()}.native.tmp`;
+        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 });
@@ -38736,7 +38876,7 @@ const UNCOMMITTED_RENAME_ERRORS = new Set([
     "ENAMETOOLONG", "ENOENT", "ENOSPC", "ENOSYS", "ENOTDIR", "ENOTEMPTY", "ENOTSUP",
     "EPERM", "EROFS", "ETXTBSY", "EXDEV",
 ]);
-function failure(error, details) {
+function native_staged_file_failure(error, details) {
     const code = error instanceof errors_FsSafeError
         ? error.code
         : error?.code === "EEXIST" ? "already-exists" : "helper-failed";
@@ -38868,10 +39008,10 @@ class NativeStagedFile {
         catch (error) {
             const { receipt: cleanup, error: cleanupError } = this.#finalize();
             if (cleanupError) {
-                throw failure(new AggregateError([error, cleanupError], "preparation and cleanup failed"), { phase: "prepare", publication: cleanup.publication, cleanup });
+                throw native_staged_file_failure(new AggregateError([error, cleanupError], "preparation and cleanup failed"), { phase: "prepare", publication: cleanup.publication, cleanup });
             }
             if (cleanup.status === "preserved") {
-                throw failure(error, { phase: "prepare", publication: cleanup.publication, cleanup });
+                throw native_staged_file_failure(error, { phase: "prepare", publication: cleanup.publication, cleanup });
             }
             throw error;
         }
@@ -38930,7 +39070,7 @@ class NativeStagedFile {
             const publication = this.#state.status === "closed"
                 ? this.#state.receipt.publication
                 : this.#state.publication;
-            throw failure(error, { phase: "publish", publication });
+            throw native_staged_file_failure(error, { phase: "publish", publication });
         }
     }
     #finalize() {
@@ -38971,7 +39111,7 @@ class NativeStagedFile {
             status: outcome,
             resources,
         });
-        const error = errors.length ? failure(errors.length === 1 ? errors[0] : new AggregateError(errors, "staged cleanup failed"), { phase: "cleanup", publication: state.publication, cleanup: receipt }) : undefined;
+        const error = errors.length ? native_staged_file_failure(errors.length === 1 ? errors[0] : new AggregateError(errors, "staged cleanup failed"), { phase: "cleanup", publication: state.publication, cleanup: receipt }) : undefined;
         this.#state = { status: "closed", receipt, error };
         return this.#state;
     }
@@ -39280,438 +39420,1184 @@ function bounded_read_readFileDescriptorBoundedSync(fd, maxBytes) {
     }
 }
 
-;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/test-hooks.js
-let test_hooks_fsSafeTestHooks;
-function allowFsSafeTestHooks() {
-    return  false || process.env.VITEST === "true";
-}
-function getFsSafeTestHooks() {
-    return test_hooks_fsSafeTestHooks;
-}
-function __setFsSafeTestHooksForTest(hooks) {
-    if (hooks && !allowFsSafeTestHooks()) {
-        throw new Error("__setFsSafeTestHooksForTest is only available in tests");
-    }
-    test_hooks_fsSafeTestHooks = hooks;
+;// 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")}`);
 }
 
-;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/sidecar-lock-reclaim.js
-
-
-
+;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/root-path-symlink.js
 
 
 
 
 
 
-const MAX_LOCK_PAYLOAD_BYTES = 1024 * 1024;
-const SIDECAR_LOCK_OWNERSHIP_TOKEN_BYTES = 16;
-const SIDECAR_LOCK_OWNERSHIP_TOKEN_BITS = SIDECAR_LOCK_OWNERSHIP_TOKEN_BYTES * 8;
-const SIDECAR_LOCK_OWNERSHIP_TOKEN_PREFIX = "\t".repeat(8);
-const SIDECAR_LOCK_OWNERSHIP_TOKEN_PATTERN = new RegExp(`\\n(${SIDECAR_LOCK_OWNERSHIP_TOKEN_PREFIX}[ \\t]{${SIDECAR_LOCK_OWNERSHIP_TOKEN_BITS}})\\n$`);
-function createSidecarLockOwnershipToken() {
-    let token = SIDECAR_LOCK_OWNERSHIP_TOKEN_PREFIX;
-    for (const byte of (0,external_node_crypto_.randomBytes)(SIDECAR_LOCK_OWNERSHIP_TOKEN_BYTES)) {
-        for (let bit = 7; bit >= 0; bit -= 1) {
-            token += byte & (1 << bit) ? "\t" : " ";
-        }
-    }
-    return token;
-}
-function readSidecarLockOwnershipToken(raw) {
-    return SIDECAR_LOCK_OWNERSHIP_TOKEN_PATTERN.exec(raw)?.[1];
-}
-function serializeSidecarLockPayload(payload) {
-    const ownershipToken = createSidecarLockOwnershipToken();
-    return {
-        raw: `${JSON.stringify(payload, null, 2)}\n${ownershipToken}\n`,
-        ownershipToken,
-    };
-}
-function relativeSidecarLockPath(lockRoot, lockPath) {
-    const resolved = external_node_path_.resolve(lockPath);
-    const lexicalRelative = external_node_path_.relative(lockRoot.rootDir, resolved);
-    const relative = lexicalRelative !== ".." &&
-        !lexicalRelative.startsWith(`..${external_node_path_.sep}`) &&
-        !external_node_path_.isAbsolute(lexicalRelative)
-        ? lexicalRelative
-        : external_node_path_.relative(lockRoot.rootReal, resolved);
-    if (!relative || relative === ".." || relative.startsWith(`..${external_node_path_.sep}`) || external_node_path_.isAbsolute(relative)) {
-        throw new errors_FsSafeError("outside-workspace", "sidecar lock path is outside lockRoot");
+function normalizeSymlinkResolutionError(error) {
+    if (isSymlinkOpenError(error)) {
+        throw new errors_FsSafeError("symlink", "symlink path could not be resolved", {
+            cause: error instanceof Error ? error : undefined,
+        });
     }
-    return relative.split(external_node_path_.sep).join(external_node_path_.posix.sep);
+    if (!path_isNotFoundPathError(error))
+        throw error;
 }
-function parseSidecarLockPayload(raw, parser) {
-    if (parser) {
-        return parser(raw);
-    }
+async function resolveSymlinkHopPath(symlinkPath) {
     try {
-        const parsed = JSON.parse(raw);
-        return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+        return external_node_path_.resolve(await promises_.realpath(symlinkPath));
     }
-    catch {
-        return null;
+    catch (error) {
+        normalizeSymlinkResolutionError(error);
+        const linkTarget = await promises_.readlink(symlinkPath);
+        return resolvePathViaExistingAncestor(external_node_path_.resolve(external_node_path_.dirname(symlinkPath), linkTarget));
     }
 }
-async function readSidecarLockSnapshot(lockPath, options = {}) {
-    let handle;
+function root_path_symlink_resolveSymlinkHopPathSync(symlinkPath) {
     try {
-        if (options.lockRoot) {
-            const lockRoot = options.lockRoot;
-            const relative = relativeSidecarLockPath(lockRoot, lockPath);
-            const opened = await lockRoot.open(relative).catch(async (error) => {
-                if (error instanceof errors_FsSafeError && error.code === "path-mismatch") {
-                    // An owner can unlink after open. Prove absence through the same root;
-                    // acquisition retries create-only, so a later replacement stays guarded.
-                    try {
-                        await lockRoot.stat(relative);
-                    }
-                    catch (probeError) {
-                        if (probeError instanceof errors_FsSafeError && probeError.code === "not-found") {
-                            return null;
-                        }
-                    }
-                }
-                throw error;
-            });
-            if (!opened)
-                return null;
-            try {
-                const raw = (await readFileHandleBounded(opened.handle, MAX_LOCK_PAYLOAD_BYTES)).toString("utf8");
-                return {
-                    raw,
-                    payload: parseSidecarLockPayload(raw, options.parsePayload),
-                    stat: opened.stat,
-                };
-            }
-            finally {
-                await opened.handle.close().catch(() => undefined);
-            }
-        }
-        const before = await promises_.lstat(lockPath);
-        if (!before.isFile() || before.isSymbolicLink()) {
-            if (options.rejectNonFile) {
-                throw new errors_FsSafeError("not-file", `sidecar lock is not a regular file: ${lockPath}`);
-            }
-            return null;
-        }
-        await getFsSafeTestHooks()?.beforeSidecarLockSnapshotOpen?.(lockPath);
-        const noFollow = process.platform !== "win32" && typeof external_node_fs_.constants.O_NOFOLLOW === "number"
-            ? external_node_fs_.constants.O_NOFOLLOW
-            : 0;
-        try {
-            handle = await promises_.open(lockPath, external_node_fs_.constants.O_RDONLY |
-                noFollow |
-                (typeof external_node_fs_.constants.O_NONBLOCK === "number" ? external_node_fs_.constants.O_NONBLOCK : 0));
-        }
-        catch (error) {
-            if (options.rejectNonFile && error.code === "ELOOP") {
-                throw new errors_FsSafeError("not-file", `sidecar lock is not a regular file: ${lockPath}`, {
-                    cause: error,
-                });
-            }
-            throw error;
-        }
-        const opened = await handle.stat();
-        if (!opened.isFile()) {
-            if (options.rejectNonFile) {
-                throw new errors_FsSafeError("not-file", `sidecar lock is not a regular file: ${lockPath}`);
-            }
-            return null;
-        }
-        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);
-        if (!after.isFile() || !file_identity_sameFileIdentity(before, after))
-            return null;
-        return { raw, payload: parseSidecarLockPayload(raw, options.parsePayload), stat: after };
-    }
-    catch (err) {
-        if (err.code === "ENOENT" ||
-            (err instanceof errors_FsSafeError && err.code === "not-found")) {
-            return null;
-        }
-        throw err;
+        return path.resolve(fs.realpathSync(symlinkPath));
     }
-    finally {
-        await handle?.close().catch(() => undefined);
+    catch (error) {
+        normalizeSymlinkResolutionError(error);
+        const linkTarget = fs.readlinkSync(symlinkPath);
+        return resolvePathViaExistingAncestorSync(path.resolve(path.dirname(symlinkPath), linkTarget));
     }
 }
-function readSidecarLockSnapshotSync(lockPath, parsePayload, options = {}) {
-    let fd;
-    try {
-        const before = fsSync.lstatSync(lockPath);
-        if (!before.isFile() || before.isSymbolicLink()) {
-            if (options.rejectNonFile) {
-                throw new FsSafeError("not-file", `sidecar lock is not a regular file: ${lockPath}`);
-            }
-            return null;
-        }
-        fd = fsSync.openSync(lockPath, resolveReadOpenFlags());
-        const opened = fsSync.fstatSync(fd);
-        if (!opened.isFile()) {
-            if (options.rejectNonFile) {
-                throw new FsSafeError("not-file", `sidecar lock is not a regular file: ${lockPath}`);
-            }
-            return null;
-        }
-        const raw = readFileDescriptorBoundedSync(fd, MAX_LOCK_PAYLOAD_BYTES).toString("utf8");
-        const after = fsSync.lstatSync(lockPath);
-        if (!sameFileIdentity(before, opened) || !sameFileIdentity(opened, after))
-            return null;
-        return {
-            raw,
-            payload: parseSidecarLockPayload(raw, parsePayload),
-            stat: after,
-            ownershipToken: readSidecarLockOwnershipToken(raw),
-        };
+
+;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/safe-path-segment.js
+
+const SAFE_PATH_SEGMENT_PATTERN = /^[A-Za-z0-9_-][A-Za-z0-9._-]*$/;
+const SAFE_DOT_PREFIX_PATH_SEGMENT_PATTERN = /^[A-Za-z0-9._-]+$/;
+// Windows treats "C:name" as relative to the drive's current directory even
+// though path.win32.isAbsolute() reports false.
+const DRIVE_RELATIVE_PREFIX = /^[A-Za-z]:(?![\\/])/;
+const HYPHEN_CHAR_CODE = 0x2d;
+function safe_path_segment_isDriveRelativePath(value) {
+    return DRIVE_RELATIVE_PREFIX.test(value);
+}
+function assertNoDriveRelativePathSegments(value, label) {
+    if (value.split("/").some(safe_path_segment_isDriveRelativePath)) {
+        throw new errors_FsSafeError("invalid-path", `${label} must not contain a drive letter`);
     }
-    catch (error) {
-        if (error.code === "ENOENT")
-            return null;
-        throw error;
+    return value;
+}
+function trimHyphenEdges(value) {
+    let start = 0;
+    let end = value.length;
+    while (start < end && value.charCodeAt(start) === HYPHEN_CHAR_CODE) {
+        start += 1;
     }
-    finally {
-        if (fd !== undefined)
-            fsSync.closeSync(fd);
+    while (end > start && value.charCodeAt(end - 1) === HYPHEN_CHAR_CODE) {
+        end -= 1;
     }
+    return start === 0 && end === value.length ? value : value.slice(start, end);
 }
-function removeSidecarLockIfUnchangedSync(lockPath, observed) {
-    const current = readSidecarLockSnapshotSync(lockPath);
-    if (!current || !sidecarLockSnapshotMatches(current, observed))
-        return false;
-    fsSync.rmSync(lockPath);
-    return true;
+function isSafePathSegment(segment, options = {}) {
+    return (segment !== "" &&
+        segment !== "." &&
+        segment !== ".." &&
+        !segment.includes("/") &&
+        !segment.includes("\\") &&
+        !segment.includes("\0") &&
+        (options.allowDotPrefix === true || !segment.startsWith(".")) &&
+        (options.allowDotPrefix === true
+            ? SAFE_DOT_PREFIX_PATH_SEGMENT_PATTERN.test(segment)
+            : SAFE_PATH_SEGMENT_PATTERN.test(segment)));
 }
-function sidecarLockSnapshotMatches(current, observed) {
-    if (observed.ownershipToken !== undefined) {
-        return (current.stat?.isFile() === true &&
-            current.raw !== undefined &&
-            observed.raw !== undefined &&
-            readSidecarLockOwnershipToken(current.raw) === observed.ownershipToken &&
-            readSidecarLockOwnershipToken(observed.raw) === observed.ownershipToken &&
-            current.raw === observed.raw);
-    }
-    if (observed.stat && current.stat && !file_identity_sameFileIdentity(observed.stat, current.stat)) {
-        return false;
+function assertSafePathSegment(segment, options = {}) {
+    // Validate the exact value callers will later join into paths; trimming here
+    // would let whitespace-padded ids pass and then be used verbatim.
+    if (!isSafePathSegment(segment, options)) {
+        throw new FsSafeError("invalid-path", `${options.label ?? "path segment"} must be a safe path segment`);
     }
-    if (observed.raw !== undefined) {
-        return current.raw === observed.raw;
+    return segment;
+}
+function sanitizeSafePathSegment(value, fallback, options = {}) {
+    const sanitized = value
+        .trim()
+        .replace(/[\\/]+/g, "-")
+        .replace(/\0/g, "")
+        .replace(/[^A-Za-z0-9._-]+/g, "-");
+    const trimmed = trimHyphenEdges(sanitized);
+    if (isSafePathSegment(trimmed, options)) {
+        return trimmed;
     }
-    return observed.stat !== undefined && current.stat !== undefined;
+    return assertSafePathSegment(fallback, { ...options, label: "fallback path segment" });
 }
-async function removeSidecarLockIfUnchanged(lockPath, observed, options = {}) {
-    const current = await readSidecarLockSnapshot(lockPath, {
+function assertSafePathPrefix(prefix, options = {}) {
+    // Prefixes are often derived from safe filenames. Normalize harmless
+    // filename characters first, but still reject real path-control bytes.
+    if (prefix.includes("/") || prefix.includes("\\") || prefix.includes("\0")) {
+        return assertSafePathSegment(prefix, {
+            allowDotPrefix: true,
+            ...options,
+            label: options.label ?? "path prefix",
+        });
+    }
+    return assertSafePathSegment(prefix.replace(/[^A-Za-z0-9._-]+/g, "-"), {
+        allowDotPrefix: true,
         ...options,
-        allowDescriptorIdentityDrift: observed?.ownershipToken !== undefined,
+        label: options.label ?? "path prefix",
     });
-    if (!current || !observed || !sidecarLockSnapshotMatches(current, observed)) {
-        return false;
-    }
-    if (options.lockRoot) {
-        await options.lockRoot.remove(relativeSidecarLockPath(options.lockRoot, lockPath));
+}
+
+// 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
+
+
+
+
+
+
+
+
+
+
+
+const ROOT_PATH_ALIAS_POLICIES = {
+    strict: Object.freeze({
+        allowFinalSymlinkForUnlink: false,
+        allowFinalHardlinkForUnlink: false,
+    }),
+    unlinkTarget: Object.freeze({
+        allowFinalSymlinkForUnlink: true,
+        allowFinalHardlinkForUnlink: true,
+    }),
+};
+async function resolveRootPath(params) {
+    try {
+        return await resolveRootPathInternal(params);
     }
-    else {
-        await promises_.rm(lockPath, { force: true });
+    catch (error) {
+        throw sanitizeRootPathError(error);
     }
-    return true;
 }
-async function sidecarLockSnapshotStillPresent(lockPath, observed, options = {}) {
-    const current = await readSidecarLockSnapshot(lockPath, {
-        ...options,
-        allowDescriptorIdentityDrift: observed?.ownershipToken !== undefined,
+async function resolveRootPathInternal(params) {
+    assertValidRootPathInputs(params);
+    const rootPath = external_node_path_.resolve(params.rootPath);
+    const absolutePath = external_node_path_.resolve(params.absolutePath);
+    const rootCanonicalPath = params.rootCanonicalPath
+        ? external_node_path_.resolve(params.rootCanonicalPath)
+        : await resolvePathViaExistingAncestor(rootPath);
+    const context = createBoundaryResolutionContext({
+        resolveParams: params,
+        rootPath,
+        absolutePath,
+        rootCanonicalPath,
+        outsideLexicalCanonicalPath: await resolveOutsideLexicalCanonicalPathAsync({
+            rootPath,
+            absolutePath,
+        }),
+    });
+    const outsideResult = await resolveOutsideRootPathAsync({
+        boundaryLabel: params.boundaryLabel,
+        context,
+    });
+    if (outsideResult) {
+        return outsideResult;
+    }
+    return resolveRootPathLexicalAsync({
+        params,
+        absolutePath: context.absolutePath,
+        rootPath: context.rootPath,
+        rootCanonicalPath: context.rootCanonicalPath,
     });
-    return !!current && !!observed && sidecarLockSnapshotMatches(current, observed);
 }
-async function sidecarReclaimGuardExists(pathname) {
+function resolveRootPathSync(params) {
     try {
-        await promises_.lstat(pathname);
-        return true;
+        return resolveRootPathSyncInternal(params);
     }
-    catch (err) {
-        if (err.code === "ENOENT") {
-            return false;
-        }
-        throw err;
+    catch (error) {
+        throw sanitizeRootPathError(error);
     }
 }
-async function tryAcquireSidecarReclaimGuard(reclaimGuards, reclaimGuardPath) {
-    try {
-        await promises_.mkdir(reclaimGuardPath);
-        reclaimGuards.add(reclaimGuardPath);
-        return true;
+function resolveRootPathSyncInternal(params) {
+    assertValidRootPathInputs(params);
+    const rootPath = path.resolve(params.rootPath);
+    const absolutePath = path.resolve(params.absolutePath);
+    const rootCanonicalPath = params.rootCanonicalPath
+        ? path.resolve(params.rootCanonicalPath)
+        : resolvePathViaExistingAncestorSync(rootPath);
+    const context = createBoundaryResolutionContext({
+        resolveParams: params,
+        rootPath,
+        absolutePath,
+        rootCanonicalPath,
+        outsideLexicalCanonicalPath: resolveOutsideLexicalCanonicalPathSync({
+            rootPath,
+            absolutePath,
+        }),
+    });
+    const outsideResult = resolveOutsideRootPathSync({
+        boundaryLabel: params.boundaryLabel,
+        context,
+    });
+    if (outsideResult) {
+        return outsideResult;
     }
-    catch (err) {
-        if (err.code === "EEXIST") {
-            return false;
-        }
-        throw err;
+    return resolveRootPathLexicalSync({
+        params,
+        absolutePath: context.absolutePath,
+        rootPath: context.rootPath,
+        rootCanonicalPath: context.rootCanonicalPath,
+    });
+}
+function sanitizeRootPathError(error) {
+    if (error instanceof Error) {
+        error.message = formatErrorDetail(error.message);
     }
+    return error;
 }
-async function releaseSidecarReclaimGuard(reclaimGuards, reclaimGuardPath) {
-    await promises_.rmdir(reclaimGuardPath);
-    reclaimGuards.delete(reclaimGuardPath);
+function assertValidRootPathInputs(params) {
+    path_assertNoNulPathInput(params.rootPath, "root path contains a NUL byte");
+    path_assertNoNulPathInput(params.absolutePath, "absolute path contains a NUL byte");
+    assertNoEmbeddedDriveRelativeSegment(params.rootPath, "root path");
+    assertNoEmbeddedDriveRelativeSegment(params.absolutePath, "absolute path");
+    if (params.rootCanonicalPath !== undefined) {
+        path_assertNoNulPathInput(params.rootCanonicalPath, "canonical root path contains a NUL byte");
+        assertNoEmbeddedDriveRelativeSegment(params.rootCanonicalPath, "canonical root path");
+    }
 }
-async function removeStaleSidecarLockIfAllowed(params) {
-    if (!params.shouldRemoveStaleLock || params.snapshot.raw === undefined) {
-        return "not-approved";
+function assertNoEmbeddedDriveRelativeSegment(filePath, label) {
+    if (process.platform !== "win32") {
+        return;
     }
-    const ioOptions = { lockRoot: params.lockRoot, parsePayload: params.parsePayload };
-    if (!(await sidecarLockSnapshotStillPresent(params.lockPath, params.snapshot, ioOptions))) {
-        return "changed";
+    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);
+    const relative = rawRelativePath ?? external_node_path_.relative(params.rootPath, params.absolutePath);
+    return {
+        segments: splitTraversalSegments(relative),
+        allowFinalSymlink: params.params.policy?.allowFinalSymlinkForUnlink === true,
+        canonicalCursor: params.rootCanonicalPath,
+        lexicalCursor: params.rootPath,
+        preserveFinalSymlink: false,
+    };
+}
+function createLexicalTraversalContext(params) {
+    return {
+        state: createLexicalTraversalState(params),
+        resolveParams: params.params,
+        rootPath: params.rootPath,
+        rootCanonicalPath: params.rootCanonicalPath,
+        absolutePath: params.absolutePath,
+    };
+}
+function splitTraversalSegments(value) {
+    return value
+        .split(process.platform === "win32" ? /[\\/]+/ : /\/+/)
+        .filter((segment) => Boolean(segment) && segment !== ".");
+}
+function rawPathRelativeToRoot(rootPath, candidatePath) {
+    if (!external_node_path_.isAbsolute(candidatePath)) {
+        return undefined;
     }
-    if (!(await params.shouldRemoveStaleLock({
-        lockPath: params.lockPath,
-        normalizedTargetPath: params.normalizedTargetPath,
-        raw: params.snapshot.raw,
-        payload: params.snapshot.payload,
-    }))) {
-        return "not-approved";
+    const root = external_node_path_.resolve(rootPath);
+    const candidate = process.platform === "win32"
+        ? candidatePath.replaceAll("/", external_node_path_.sep)
+        : candidatePath;
+    if (candidate === root) {
+        return "";
     }
-    if (!(await sidecarLockSnapshotStillPresent(params.lockPath, params.snapshot, ioOptions))) {
-        return "changed";
+    const rootWithSep = root.endsWith(external_node_path_.sep) ? root : `${root}${external_node_path_.sep}`;
+    const candidatePrefix = candidate.slice(0, rootWithSep.length);
+    const prefixMatches = process.platform === "win32"
+        ? candidatePrefix.toLowerCase() === rootWithSep.toLowerCase()
+        : candidatePrefix === rootWithSep;
+    return prefixMatches ? candidate.slice(rootWithSep.length) : undefined;
+}
+function assertLexicalCursorInsideBoundary(context, candidatePath) {
+    assertInsideBoundary({
+        boundaryLabel: context.resolveParams.boundaryLabel,
+        rootCanonicalPath: context.rootCanonicalPath,
+        candidatePath,
+        absolutePath: context.absolutePath,
+    });
+}
+function applyMissingSuffixToCanonicalCursor(context, missingFromIndex) {
+    const missingSuffix = context.state.segments.slice(missingFromIndex);
+    for (const segment of missingSuffix) {
+        advanceCanonicalCursorForSegment(context, segment);
+    }
+}
+function advanceCanonicalCursorForSegment(context, segment) {
+    context.state.canonicalCursor = external_node_path_.resolve(context.state.canonicalCursor, segment);
+    assertLexicalCursorInsideBoundary(context, context.state.canonicalCursor);
+}
+function finalizeLexicalResolution(context, kind) {
+    assertLexicalCursorInsideBoundary(context, context.state.canonicalCursor);
+    return buildResolvedRootPath({
+        absolutePath: context.absolutePath,
+        canonicalPath: context.state.canonicalCursor,
+        rootPath: context.rootPath,
+        rootCanonicalPath: context.rootCanonicalPath,
+        kind,
+    });
+}
+function handleLexicalLstatFailure(context, error, missingFromIndex) {
+    if (!path_isNotFoundPathError(error)) {
+        return false;
+    }
+    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);
+        return "continue";
+    }
+    if (context.resolveParams.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";
+}
+function applyResolvedSymlinkHop(context, linkCanonical) {
+    if (!path_isPathInside(context.rootCanonicalPath, linkCanonical)) {
+        throw symlinkEscapeError({
+            boundaryLabel: context.resolveParams.boundaryLabel,
+            rootCanonicalPath: context.rootCanonicalPath,
+            symlinkPath: context.state.lexicalCursor,
+        });
     }
+    context.state.canonicalCursor = linkCanonical;
+    context.state.lexicalCursor = linkCanonical;
+}
+function readLexicalStat(context, params) {
     try {
-        if (params.lockRoot) {
-            await params.lockRoot.remove(relativeSidecarLockPath(params.lockRoot, params.lockPath));
-        }
-        else {
-            await promises_.rm(params.lockPath);
+        const stat = params.read(context.state.lexicalCursor);
+        if (isPromiseLike(stat)) {
+            return Promise.resolve(stat).catch((error) => handleLexicalStatReadFailure(context, error, params.missingFromIndex));
         }
-        return "removed";
+        return stat;
     }
-    catch (err) {
-        if (err.code === "ENOENT") {
-            return "changed";
+    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)) {
+        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;
+        }
+        const disposition = handleLexicalStatDisposition(context, {
+            isSymbolicLink: stat.isSymbolicLink(),
+            segment,
+            isLast,
+        });
+        if (disposition === "continue") {
+            continue;
+        }
+        if (disposition === "break") {
+            break;
+        }
+        await resolveAndApplySymlinkHop(context, {
+            resolveLinkCanonical: (cursor) => resolveSymlinkHopPath(cursor),
+        });
+        if (context.resolveParams.rejectSymlinks === true) {
+            throw new errors_FsSafeError("symlink", "symlink path component not allowed");
         }
-        throw err;
     }
+    const kind = await getPathKind(state.canonicalCursor, state.preserveFinalSymlink);
+    return finalizeLexicalResolution(context, kind);
 }
-
-;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/sidecar-lock-policy.js
-
-function assertFiniteNonNegative(value, label) {
-    if (!Number.isFinite(value) || value < 0) {
-        throw new RangeError(`${label} must be a finite non-negative number`);
+function resolveRootPathLexicalSync(params) {
+    const context = createLexicalTraversalContext(params);
+    const { state } = context;
+    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 = 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");
+        }
+        const stat = maybeStat;
+        if (!stat) {
+            break;
+        }
+        const disposition = handleLexicalStatDisposition(context, {
+            isSymbolicLink: stat.isSymbolicLink(),
+            segment,
+            isLast,
+        });
+        if (disposition === "continue") {
+            continue;
+        }
+        if (disposition === "break") {
+            break;
+        }
+        const maybeApplied = resolveAndApplySymlinkHop(context, {
+            resolveLinkCanonical: (cursor) => resolveSymlinkHopPathSync(cursor),
+        });
+        if (isPromiseLike(maybeApplied)) {
+            throw new Error("Unexpected async symlink resolution");
+        }
+        if (context.resolveParams.rejectSymlinks === true) {
+            throw new FsSafeError("symlink", "symlink path component not allowed");
+        }
     }
+    const kind = getPathKindSync(state.canonicalCursor, state.preserveFinalSymlink);
+    return finalizeLexicalResolution(context, kind);
 }
-function validateSidecarLockRetryOptions(retry) {
-    if (retry.retries !== undefined && (!Number.isSafeInteger(retry.retries) || retry.retries < 0)) {
-        throw new RangeError("lock retry.retries must be a non-negative safe integer");
+function resolveCanonicalOutsideLexicalPath(params) {
+    return params.outsideLexicalCanonicalPath ?? params.absolutePath;
+}
+function createBoundaryResolutionContext(params) {
+    const lexicalInside = path_isPathInside(params.rootPath, params.absolutePath);
+    const canonicalOutsideLexicalPath = resolveCanonicalOutsideLexicalPath({
+        absolutePath: params.absolutePath,
+        outsideLexicalCanonicalPath: params.outsideLexicalCanonicalPath,
+    });
+    assertLexicalBoundaryOrCanonicalAlias({
+        skipLexicalRootCheck: params.resolveParams.skipLexicalRootCheck,
+        lexicalInside,
+        canonicalOutsideLexicalPath,
+        rootCanonicalPath: params.rootCanonicalPath,
+        boundaryLabel: params.resolveParams.boundaryLabel,
+        rootPath: params.rootPath,
+        absolutePath: params.absolutePath,
+    });
+    return {
+        rootPath: params.rootPath,
+        absolutePath: params.absolutePath,
+        rootCanonicalPath: params.rootCanonicalPath,
+        lexicalInside,
+        canonicalOutsideLexicalPath,
+    };
+}
+async function resolveOutsideRootPathAsync(params) {
+    if (params.context.lexicalInside) {
+        return null;
     }
-    if (retry.factor !== undefined)
-        assertFiniteNonNegative(retry.factor, "lock retry.factor");
-    if (retry.minTimeout !== undefined) {
-        assertFiniteNonNegative(retry.minTimeout, "lock retry.minTimeout");
+    const kind = await getPathKind(params.context.absolutePath, false);
+    return buildOutsideRootPathFromContext({
+        boundaryLabel: params.boundaryLabel,
+        context: params.context,
+        kind,
+    });
+}
+function resolveOutsideRootPathSync(params) {
+    if (params.context.lexicalInside) {
+        return null;
     }
-    if (retry.maxTimeout !== undefined) {
-        assertFiniteNonNegative(retry.maxTimeout, "lock retry.maxTimeout");
+    const kind = getPathKindSync(params.context.absolutePath, false);
+    return buildOutsideRootPathFromContext({
+        boundaryLabel: params.boundaryLabel,
+        context: params.context,
+        kind,
+    });
+}
+function buildOutsideRootPathFromContext(params) {
+    return buildOutsideLexicalRootPath({
+        boundaryLabel: params.boundaryLabel,
+        rootCanonicalPath: params.context.rootCanonicalPath,
+        absolutePath: params.context.absolutePath,
+        canonicalOutsideLexicalPath: params.context.canonicalOutsideLexicalPath,
+        rootPath: params.context.rootPath,
+        kind: params.kind,
+    });
+}
+async function resolveOutsideLexicalCanonicalPathAsync(params) {
+    if (path_isPathInside(params.rootPath, params.absolutePath)) {
+        return undefined;
     }
-    if (retry.minTimeout !== undefined &&
-        retry.maxTimeout !== undefined &&
-        retry.minTimeout > retry.maxTimeout) {
-        throw new RangeError("lock retry.minTimeout must not exceed retry.maxTimeout");
+    return await resolvePathViaExistingAncestor(params.absolutePath);
+}
+function resolveOutsideLexicalCanonicalPathSync(params) {
+    if (isPathInside(params.rootPath, params.absolutePath)) {
+        return undefined;
     }
+    return resolvePathViaExistingAncestorSync(params.absolutePath);
 }
-function validateSidecarLockTimeoutMs(timeoutMs) {
-    if (timeoutMs === undefined || timeoutMs === Number.POSITIVE_INFINITY)
+function buildOutsideLexicalRootPath(params) {
+    assertInsideBoundary({
+        boundaryLabel: params.boundaryLabel,
+        rootCanonicalPath: params.rootCanonicalPath,
+        candidatePath: params.canonicalOutsideLexicalPath,
+        absolutePath: params.absolutePath,
+    });
+    return buildResolvedRootPath({
+        absolutePath: params.absolutePath,
+        canonicalPath: params.canonicalOutsideLexicalPath,
+        rootPath: params.rootPath,
+        rootCanonicalPath: params.rootCanonicalPath,
+        kind: params.kind,
+    });
+}
+function assertLexicalBoundaryOrCanonicalAlias(params) {
+    if (params.skipLexicalRootCheck || params.lexicalInside) {
         return;
-    assertFiniteNonNegative(timeoutMs, "lock timeoutMs");
+    }
+    if (path_isPathInside(params.rootCanonicalPath, params.canonicalOutsideLexicalPath)) {
+        return;
+    }
+    throw pathEscapeError({
+        boundaryLabel: params.boundaryLabel,
+        rootPath: params.rootPath,
+        absolutePath: params.absolutePath,
+    });
 }
-function computeSidecarLockDelayMs(retry, attempt) {
-    validateSidecarLockRetryOptions(retry);
-    const minTimeout = retry.minTimeout ?? 50;
-    const maxTimeout = retry.maxTimeout ?? 1000;
-    const factor = retry.factor ?? 1;
-    const base = Math.min(maxTimeout, Math.max(minTimeout, minTimeout * factor ** attempt));
-    const jitter = retry.randomize ? 1 + Math.random() : 1;
-    return Math.min(maxTimeout, Math.round(base * jitter));
+function buildResolvedRootPath(params) {
+    return {
+        absolutePath: params.absolutePath,
+        canonicalPath: params.canonicalPath,
+        rootPath: params.rootPath,
+        rootCanonicalPath: params.rootCanonicalPath,
+        relativePath: relativeInsideRoot(params.rootCanonicalPath, params.canonicalPath),
+        exists: params.kind.exists,
+        kind: params.kind.kind,
+    };
 }
-// Windows denies access to a lock file while a just-unlinked directory entry
-// is still being torn down, so a contended acquire sees EPERM on a name that is
-// already gone -- both when creating it exclusively and when reading the
-// holder's snapshot. The next attempt succeeds, so this is contention rather
-// than a permission failure. The error must name the lock file itself: the
-// exclusive-create helper opens the parent directory first, and a denial from
-// that setup step carries no teardown evidence and has to reach the caller.
-const maxTransientLockDenials = 8;
-function isTransientLockFileDenial(error, lockPath) {
-    const denial = error;
-    return process.platform === "win32" && denial?.code === "EPERM" && denial.path === lockPath;
+async function getPathKind(absolutePath, preserveFinalSymlink) {
+    try {
+        const stat = preserveFinalSymlink
+            ? await promises_.lstat(absolutePath)
+            : await promises_.stat(absolutePath);
+        return { exists: true, kind: toResolvedKind(stat) };
+    }
+    catch (error) {
+        if (path_isNotFoundPathError(error)) {
+            return { exists: false, kind: "missing" };
+        }
+        throw error;
+    }
 }
-function sidecarLockPayloadIsStale(payload, staleMs, nowMs) {
-    const createdAtMs = sidecarLockPayloadCreatedAtMs(payload);
-    return createdAtMs !== null && nowMs - createdAtMs > staleMs;
+function getPathKindSync(absolutePath, preserveFinalSymlink) {
+    try {
+        const stat = preserveFinalSymlink ? fs.lstatSync(absolutePath) : fs.statSync(absolutePath);
+        return { exists: true, kind: toResolvedKind(stat) };
+    }
+    catch (error) {
+        if (isNotFoundPathError(error)) {
+            return { exists: false, kind: "missing" };
+        }
+        throw error;
+    }
 }
-function sidecarLockPayloadCreatedAtMs(payload) {
-    const createdAt = payload &&
-        typeof payload === "object" &&
-        "createdAt" in payload &&
-        typeof payload.createdAt === "string"
-        ? payload.createdAt
-        : "";
-    const createdAtMs = Date.parse(createdAt);
-    return Number.isFinite(createdAtMs) ? createdAtMs : null;
+function toResolvedKind(stat) {
+    if (stat.isFile()) {
+        return "file";
+    }
+    if (stat.isDirectory()) {
+        return "directory";
+    }
+    if (stat.isSymbolicLink()) {
+        return "symlink";
+    }
+    return "other";
 }
-async function defaultSidecarLockShouldReclaim(params) {
-    const createdAtMs = sidecarLockPayloadCreatedAtMs(params.payload);
-    if (createdAtMs !== null)
-        return params.nowMs - createdAtMs > params.staleMs;
-    try {
-        return params.nowMs - (await promises_.stat(params.lockPath)).mtimeMs > params.staleMs;
+function relativeInsideRoot(rootPath, targetPath) {
+    const relative = external_node_path_.relative(external_node_path_.resolve(rootPath), external_node_path_.resolve(targetPath));
+    if (!relative || relative === ".") {
+        return "";
     }
-    catch {
-        return true;
+    if (isPathRelativeEscape(relative)) {
+        return "";
     }
+    return relative;
 }
-
-;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/suppressed-error.js
-function createSuppressedError(error, suppressed, message) {
-    const constructor = globalThis.SuppressedError;
-    if (constructor) {
-        return new constructor(error, suppressed, message);
+function assertInsideBoundary(params) {
+    if (path_isPathInside(params.rootCanonicalPath, params.candidatePath)) {
+        return;
     }
-    const combined = new Error(message, {
-        cause: error instanceof Error ? error : undefined,
-    });
-    combined.name = "SuppressedError";
-    Object.defineProperties(combined, {
-        error: { configurable: true, value: error },
-        suppressed: { configurable: true, value: suppressed },
-    });
-    return combined;
+    throw new Error(`Path resolves outside ${params.boundaryLabel} (${shortPath(params.rootCanonicalPath)}): ${shortPath(params.absolutePath)}`);
+}
+function pathEscapeError(params) {
+    return new Error(`Path escapes ${params.boundaryLabel} (${shortPath(params.rootPath)}): ${shortPath(params.absolutePath)}`);
+}
+function symlinkEscapeError(params) {
+    return new Error(`Symlink escapes ${params.boundaryLabel} (${shortPath(params.rootCanonicalPath)}): ${shortPath(params.symlinkPath)}`);
 }
 
-;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/sidecar-lock-acquire.js
-
+;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/sidecar-lock-root.js
 
 
 
 
 
 
-async function resolveNormalizedTargetPath(targetPath) {
-    const resolved = external_node_path_.resolve(targetPath);
-    const dir = external_node_path_.dirname(resolved);
-    await promises_.mkdir(dir, { recursive: true });
+async function openSidecarRoot(lockRoot, relative, discardObservation, onOpenFailure) {
+    const resolved = await lockRoot.resolve(relative);
+    const canonicalPath = async () => (await resolveRootPath({
+        absolutePath: resolved,
+        rootPath: lockRoot.rootReal,
+        rootCanonicalPath: lockRoot.rootReal,
+        boundaryLabel: "sidecar lock root",
+    })).canonicalPath;
+    const expectedRealPath = await canonicalPath();
+    if (expectedRealPath === lockRoot.rootReal)
+        throw new errors_FsSafeError("not-file", "sidecar lock is a directory");
+    const parents = [];
+    let completeParents = true;
+    if (discardObservation) {
+        // Follow permitted in-root aliases first; receipts cover canonical ancestry.
+        for (let dir = external_node_path_.dirname(expectedRealPath);; dir = external_node_path_.dirname(dir)) {
+            try {
+                parents.push({ dir, stat: await inspectDirectoryIdentity(dir) });
+            }
+            catch (error) {
+                if (!path_isNotFoundPathError(error))
+                    throw error;
+                completeParents = false;
+            }
+            if (dir === lockRoot.rootReal)
+                break;
+        }
+    }
+    const observation = fileObservation();
     try {
-        return external_node_path_.join(await promises_.realpath(dir), external_node_path_.basename(resolved));
+        const opened = await observation.run(() => lockRoot.open(relative));
+        if (opened.realPath !== expectedRealPath) {
+            await opened.handle.close().catch(() => undefined);
+            throw new errors_FsSafeError("path-mismatch", "sidecar lock path changed during open");
+        }
+        return opened;
     }
-    catch {
-        return resolved;
+    catch (error) {
+        const openFailed = observation.has(error, `open:${resolved}`);
+        if (openFailed)
+            onOpenFailure?.(error);
+        const missing = openFailed && error instanceof errors_FsSafeError && error.code === "not-found";
+        if (missing && !discardObservation)
+            return null;
+        const discardable = observation.has(error, `unlinked:${resolved}`) ||
+            (discardObservation === "changed" && observation.has(error, `changed:${resolved}`));
+        if (!discardObservation || (!missing && (!completeParents || !discardable)))
+            throw error;
+        try {
+            try {
+                const current = await lockRoot.stat(relative);
+                if (!current.isFile || current.isSymbolicLink || current.nlink !== 1)
+                    throw error;
+            }
+            catch (probeError) {
+                if (!(probeError instanceof errors_FsSafeError && probeError.code === "not-found"))
+                    throw probeError;
+            }
+            for (const { dir, stat } of parents)
+                await inspectDirectoryIdentity(dir, stat);
+            await lockRoot.resolve(relative);
+            if (await canonicalPath() === expectedRealPath)
+                return null;
+        }
+        catch {
+            // Keep the original failure when directory or confinement proof fails.
+        }
+        throw error;
     }
 }
-async function acquireSidecarLock(options, context) {
-    const retry = options.retry ?? {};
-    validateSidecarLockRetryOptions(retry);
-    validateSidecarLockTimeoutMs(options.timeoutMs);
-    context.ensureExitCleanupRegistered();
-    const normalizedTargetPath = await resolveNormalizedTargetPath(options.targetPath);
-    const lockPath = options.lockPath ?? `${normalizedTargetPath}.lock`;
-    let held = context.held.get(normalizedTargetPath);
-    if (held &&
+
+;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/test-hooks.js
+let test_hooks_fsSafeTestHooks;
+function allowFsSafeTestHooks() {
+    return  false || process.env.VITEST === "true";
+}
+function getFsSafeTestHooks() {
+    return test_hooks_fsSafeTestHooks;
+}
+function __setFsSafeTestHooksForTest(hooks) {
+    if (hooks && !allowFsSafeTestHooks()) {
+        throw new Error("__setFsSafeTestHooksForTest is only available in tests");
+    }
+    test_hooks_fsSafeTestHooks = hooks;
+}
+
+;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/sidecar-lock-reclaim.js
+
+
+
+
+
+
+
+
+
+
+const MAX_LOCK_PAYLOAD_BYTES = 1024 * 1024;
+const SIDECAR_LOCK_OWNERSHIP_TOKEN_BYTES = 16;
+const SIDECAR_LOCK_OWNERSHIP_TOKEN_BITS = SIDECAR_LOCK_OWNERSHIP_TOKEN_BYTES * 8;
+const SIDECAR_LOCK_OWNERSHIP_TOKEN_PREFIX = "\t".repeat(8);
+const SIDECAR_LOCK_OWNERSHIP_TOKEN_PATTERN = new RegExp(`\\n(${SIDECAR_LOCK_OWNERSHIP_TOKEN_PREFIX}[ \\t]{${SIDECAR_LOCK_OWNERSHIP_TOKEN_BITS}})\\n$`);
+function parseSidecarLockSnapshot(snapshot, parser) {
+    return snapshot && { ...snapshot, payload: parseSidecarLockPayload(snapshot.raw, parser) };
+}
+function createSidecarLockOwnershipToken() {
+    let token = SIDECAR_LOCK_OWNERSHIP_TOKEN_PREFIX;
+    for (const byte of (0,external_node_crypto_.randomBytes)(SIDECAR_LOCK_OWNERSHIP_TOKEN_BYTES)) {
+        for (let bit = 7; bit >= 0; bit -= 1) {
+            token += byte & (1 << bit) ? "\t" : " ";
+        }
+    }
+    return token;
+}
+function readSidecarLockOwnershipToken(raw) {
+    return SIDECAR_LOCK_OWNERSHIP_TOKEN_PATTERN.exec(raw)?.[1];
+}
+function serializeSidecarLockPayload(payload) {
+    const ownershipToken = createSidecarLockOwnershipToken();
+    return {
+        raw: `${JSON.stringify(payload, null, 2)}\n${ownershipToken}\n`,
+        ownershipToken,
+    };
+}
+function relativeSidecarLockPath(lockRoot, lockPath) {
+    const resolved = external_node_path_.resolve(lockPath);
+    const lexicalRelative = external_node_path_.relative(lockRoot.rootDir, resolved);
+    const relative = lexicalRelative !== ".." &&
+        !lexicalRelative.startsWith(`..${external_node_path_.sep}`) &&
+        !external_node_path_.isAbsolute(lexicalRelative)
+        ? lexicalRelative
+        : external_node_path_.relative(lockRoot.rootReal, resolved);
+    if (!relative || relative === ".." || relative.startsWith(`..${external_node_path_.sep}`) || external_node_path_.isAbsolute(relative)) {
+        throw new errors_FsSafeError("outside-workspace", "sidecar lock path is outside lockRoot");
+    }
+    return relative.split(external_node_path_.sep).join(external_node_path_.posix.sep);
+}
+function parseSidecarLockPayload(raw, parser) {
+    if (parser) {
+        return parser(raw);
+    }
+    try {
+        const parsed = JSON.parse(raw);
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function missingSnapshotPath(error) {
+    if (error.code === "ENOENT")
+        return null;
+    throw error;
+}
+async function readSidecarLockSnapshot(lockPath, options = {}) {
+    return parseSidecarLockSnapshot(await readSidecarLockRawSnapshot(lockPath, options), options.parsePayload);
+}
+async function readSidecarLockRawSnapshot(lockPath, options = {}) {
+    let handle;
+    try {
+        if (options.lockRoot) {
+            const lockRoot = options.lockRoot;
+            const relative = relativeSidecarLockPath(lockRoot, lockPath);
+            const opened = await openSidecarRoot(lockRoot, relative, options.discardObservation, options.onOpenFailure);
+            if (!opened)
+                return null;
+            try {
+                const raw = (await readFileHandleBounded(opened.handle, MAX_LOCK_PAYLOAD_BYTES)).toString("utf8");
+                return {
+                    raw,
+                    stat: opened.stat,
+                };
+            }
+            finally {
+                await opened.handle.close().catch(() => undefined);
+            }
+        }
+        const before = await promises_.lstat(lockPath).catch(missingSnapshotPath);
+        if (!before)
+            return null;
+        if (!before.isFile() || before.isSymbolicLink()) {
+            if (options.rejectNonFile) {
+                throw new errors_FsSafeError("not-file", `sidecar lock is not a regular file: ${lockPath}`);
+            }
+            return null;
+        }
+        await getFsSafeTestHooks()?.beforeSidecarLockSnapshotOpen?.(lockPath);
+        const noFollow = process.platform !== "win32" && typeof external_node_fs_.constants.O_NOFOLLOW === "number"
+            ? external_node_fs_.constants.O_NOFOLLOW
+            : 0;
+        try {
+            handle = await promises_.open(lockPath, external_node_fs_.constants.O_RDONLY |
+                noFollow |
+                (typeof external_node_fs_.constants.O_NONBLOCK === "number" ? external_node_fs_.constants.O_NONBLOCK : 0));
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return null;
+            if (options.rejectNonFile && error.code === "ELOOP") {
+                throw new errors_FsSafeError("not-file", `sidecar lock is not a regular file: ${lockPath}`, {
+                    cause: error,
+                });
+            }
+            options.onOpenFailure?.(error);
+            throw error;
+        }
+        const opened = await handle.stat();
+        if (!opened.isFile()) {
+            if (options.rejectNonFile) {
+                throw new errors_FsSafeError("not-file", `sidecar lock is not a regular file: ${lockPath}`);
+            }
+            return null;
+        }
+        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);
+        if (!after || !after.isFile() || !file_identity_sameFileIdentity(before, after))
+            return null;
+        return { raw, stat: after };
+    }
+    finally {
+        await handle?.close().catch(() => undefined);
+    }
+}
+function lstatSidecarLockSync(lockPath) {
+    try {
+        return fsSync.lstatSync(lockPath);
+    }
+    catch (error) {
+        return missingSnapshotPath(error);
+    }
+}
+function readSidecarLockSnapshotSync(lockPath, parsePayload, options = {}) {
+    return parseSidecarLockSnapshot(readSidecarLockRawSnapshotSync(lockPath, options), parsePayload);
+}
+function readSidecarLockRawSnapshotSync(lockPath, options = {}) {
+    let fd;
+    try {
+        const before = lstatSidecarLockSync(lockPath);
+        if (!before)
+            return null;
+        if (!before.isFile() || before.isSymbolicLink()) {
+            if (options.rejectNonFile) {
+                throw new FsSafeError("not-file", `sidecar lock is not a regular file: ${lockPath}`);
+            }
+            return null;
+        }
+        try {
+            fd = fsSync.openSync(lockPath, resolveReadOpenFlags());
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return null;
+            options.onOpenFailure?.(error);
+            throw error;
+        }
+        const opened = fsSync.fstatSync(fd);
+        if (!opened.isFile()) {
+            if (options.rejectNonFile) {
+                throw new FsSafeError("not-file", `sidecar lock is not a regular file: ${lockPath}`);
+            }
+            return null;
+        }
+        const raw = readFileDescriptorBoundedSync(fd, MAX_LOCK_PAYLOAD_BYTES).toString("utf8");
+        const after = lstatSidecarLockSync(lockPath);
+        if (!after || !sameFileIdentity(before, opened) || !sameFileIdentity(opened, after))
+            return null;
+        return {
+            raw,
+            stat: after,
+            ownershipToken: readSidecarLockOwnershipToken(raw),
+        };
+    }
+    finally {
+        if (fd !== undefined)
+            fsSync.closeSync(fd);
+    }
+}
+function removeSidecarLockIfUnchangedSync(lockPath, observed) {
+    const current = readSidecarLockSnapshotSync(lockPath);
+    if (!current || !sidecarLockSnapshotMatches(current, observed))
+        return false;
+    fsSync.rmSync(lockPath);
+    return true;
+}
+function sidecarLockSnapshotMatches(current, observed) {
+    if (observed.ownershipToken !== undefined) {
+        return (current.stat?.isFile() === true &&
+            current.raw !== undefined &&
+            observed.raw !== undefined &&
+            readSidecarLockOwnershipToken(current.raw) === observed.ownershipToken &&
+            readSidecarLockOwnershipToken(observed.raw) === observed.ownershipToken &&
+            current.raw === observed.raw);
+    }
+    if (observed.stat && current.stat && !file_identity_sameFileIdentity(observed.stat, current.stat)) {
+        return false;
+    }
+    if (observed.raw !== undefined) {
+        return current.raw === observed.raw;
+    }
+    return observed.stat !== undefined && current.stat !== undefined;
+}
+async function removeSidecarLockIfUnchanged(lockPath, observed, options = {}) {
+    const current = await readSidecarLockSnapshot(lockPath, {
+        ...options,
+        allowDescriptorIdentityDrift: observed?.ownershipToken !== undefined,
+    });
+    if (!current || !observed || !sidecarLockSnapshotMatches(current, observed)) {
+        return false;
+    }
+    if (options.lockRoot) {
+        await options.lockRoot.remove(relativeSidecarLockPath(options.lockRoot, lockPath));
+    }
+    else {
+        await promises_.rm(lockPath, { force: true });
+    }
+    return true;
+}
+async function sidecarLockSnapshotStillPresent(lockPath, observed, options = {}) {
+    const current = await readSidecarLockSnapshot(lockPath, {
+        ...options,
+        allowDescriptorIdentityDrift: observed?.ownershipToken !== undefined,
+    });
+    return !!current && !!observed && sidecarLockSnapshotMatches(current, observed);
+}
+async function sidecarReclaimGuardExists(pathname) {
+    try {
+        await promises_.lstat(pathname);
+        return true;
+    }
+    catch (err) {
+        if (err.code === "ENOENT") {
+            return false;
+        }
+        throw err;
+    }
+}
+async function tryAcquireSidecarReclaimGuard(reclaimGuards, reclaimGuardPath) {
+    try {
+        await promises_.mkdir(reclaimGuardPath);
+        reclaimGuards.add(reclaimGuardPath);
+        return true;
+    }
+    catch (err) {
+        if (err.code === "EEXIST") {
+            return false;
+        }
+        throw err;
+    }
+}
+async function releaseSidecarReclaimGuard(reclaimGuards, reclaimGuardPath) {
+    await promises_.rmdir(reclaimGuardPath);
+    reclaimGuards.delete(reclaimGuardPath);
+}
+async function removeStaleSidecarLockIfAllowed(params) {
+    if (!params.shouldRemoveStaleLock || params.snapshot.raw === undefined) {
+        return "not-approved";
+    }
+    const ioOptions = { lockRoot: params.lockRoot, parsePayload: params.parsePayload };
+    if (!(await sidecarLockSnapshotStillPresent(params.lockPath, params.snapshot, ioOptions))) {
+        return "changed";
+    }
+    if (!(await params.shouldRemoveStaleLock({
+        lockPath: params.lockPath,
+        normalizedTargetPath: params.normalizedTargetPath,
+        raw: params.snapshot.raw,
+        payload: params.snapshot.payload,
+    }))) {
+        return "not-approved";
+    }
+    if (!(await sidecarLockSnapshotStillPresent(params.lockPath, params.snapshot, ioOptions))) {
+        return "changed";
+    }
+    try {
+        if (params.lockRoot) {
+            await params.lockRoot.remove(relativeSidecarLockPath(params.lockRoot, params.lockPath));
+        }
+        else {
+            await promises_.rm(params.lockPath);
+        }
+        return "removed";
+    }
+    catch (err) {
+        if (err.code === "ENOENT") {
+            return "changed";
+        }
+        throw err;
+    }
+}
+
+;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/sidecar-lock-policy.js
+
+function assertFiniteNonNegative(value, label) {
+    if (!Number.isFinite(value) || value < 0) {
+        throw new RangeError(`${label} must be a finite non-negative number`);
+    }
+}
+function validateSidecarLockRetryOptions(retry) {
+    if (retry.retries !== undefined && (!Number.isSafeInteger(retry.retries) || retry.retries < 0)) {
+        throw new RangeError("lock retry.retries must be a non-negative safe integer");
+    }
+    if (retry.factor !== undefined)
+        assertFiniteNonNegative(retry.factor, "lock retry.factor");
+    if (retry.minTimeout !== undefined) {
+        assertFiniteNonNegative(retry.minTimeout, "lock retry.minTimeout");
+    }
+    if (retry.maxTimeout !== undefined) {
+        assertFiniteNonNegative(retry.maxTimeout, "lock retry.maxTimeout");
+    }
+    if (retry.minTimeout !== undefined &&
+        retry.maxTimeout !== undefined &&
+        retry.minTimeout > retry.maxTimeout) {
+        throw new RangeError("lock retry.minTimeout must not exceed retry.maxTimeout");
+    }
+}
+function validateSidecarLockTimeoutMs(timeoutMs) {
+    if (timeoutMs === undefined || timeoutMs === Number.POSITIVE_INFINITY)
+        return;
+    assertFiniteNonNegative(timeoutMs, "lock timeoutMs");
+}
+function computeSidecarLockDelayMs(retry, attempt) {
+    validateSidecarLockRetryOptions(retry);
+    const minTimeout = retry.minTimeout ?? 50;
+    const maxTimeout = retry.maxTimeout ?? 1000;
+    const factor = retry.factor ?? 1;
+    const base = Math.min(maxTimeout, Math.max(minTimeout, minTimeout * factor ** attempt));
+    const jitter = retry.randomize ? 1 + Math.random() : 1;
+    return Math.min(maxTimeout, Math.round(base * jitter));
+}
+// Windows denies access to a lock file while a just-unlinked directory entry
+// is still being torn down, so a contended acquire sees EPERM on a name that is
+// already gone -- both when creating it exclusively and when reading the
+// holder's snapshot. The next attempt succeeds, so this is contention rather
+// than a permission failure. The error must name the lock file itself: the
+// exclusive-create helper opens the parent directory first, and a denial from
+// that setup step carries no teardown evidence and has to reach the caller.
+const maxTransientLockDenials = 8;
+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" &&
+        "createdAt" in payload &&
+        typeof payload.createdAt === "string"
+        ? payload.createdAt
+        : "";
+    const createdAtMs = Date.parse(createdAt);
+    return Number.isFinite(createdAtMs) ? createdAtMs : null;
+}
+async function defaultSidecarLockShouldReclaim(params) {
+    const createdAtMs = sidecarLockPayloadCreatedAtMs(params.payload);
+    if (createdAtMs !== null)
+        return params.nowMs - createdAtMs > params.staleMs;
+    try {
+        return params.nowMs - (await promises_.stat(params.lockPath)).mtimeMs > params.staleMs;
+    }
+    catch {
+        return true;
+    }
+}
+
+;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/suppressed-error.js
+function createSuppressedError(error, suppressed, message) {
+    const constructor = globalThis.SuppressedError;
+    if (constructor) {
+        return new constructor(error, suppressed, message);
+    }
+    const combined = new Error(message, {
+        cause: error instanceof Error ? error : undefined,
+    });
+    combined.name = "SuppressedError";
+    Object.defineProperties(combined, {
+        error: { configurable: true, value: error },
+        suppressed: { configurable: true, value: suppressed },
+    });
+    return combined;
+}
+
+;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/sidecar-lock-acquire.js
+
+
+
+
+
+
+
+
+
+async function resolveNormalizedTargetPath(targetPath) {
+    const resolved = external_node_path_.resolve(targetPath);
+    const dir = external_node_path_.dirname(resolved);
+    await promises_.mkdir(dir, { recursive: true });
+    try {
+        return external_node_path_.join(await promises_.realpath(dir), external_node_path_.basename(resolved));
+    }
+    catch {
+        return resolved;
+    }
+}
+async function acquireSidecarLock(options, context) {
+    const retry = options.retry ?? {};
+    validateSidecarLockRetryOptions(retry);
+    validateSidecarLockTimeoutMs(options.timeoutMs);
+    context.ensureExitCleanupRegistered();
+    const normalizedTargetPath = await resolveNormalizedTargetPath(options.targetPath);
+    const lockPath = options.lockPath ?? `${normalizedTargetPath}.lock`;
+    let held = context.held.get(normalizedTargetPath);
+    if (held &&
         options.reentrantOwner !== undefined &&
         held.reentrantOwner !== undefined &&
         options.reentrantOwner === held.reentrantOwner) {
@@ -39780,13 +40666,14 @@ async function acquireSidecarLock(options, context) {
             let handle = null;
             let createdSnapshot = null;
             let lockFileCreateDenied = false;
+            const payload = await options.payload();
+            const { raw, ownershipToken } = serializeSidecarLockPayload(payload);
             try {
-                const payload = await options.payload();
-                const { raw, ownershipToken } = serializeSidecarLockPayload(payload);
                 if (options.lockRoot) {
-                    const relativeLockPath = relativeSidecarLockPath(options.lockRoot, lockPath);
+                    const lockRoot = options.lockRoot;
+                    const relativeLockPath = relativeSidecarLockPath(lockRoot, lockPath);
                     try {
-                        await options.lockRoot.create(relativeLockPath, raw, { mkdir: true, mode: 0o600 });
+                        await lockRoot.create(relativeLockPath, raw, { mkdir: true, mode: 0o600 });
                     }
                     catch (error) {
                         if (error instanceof errors_FsSafeError && error.code === "already-exists") {
@@ -39795,7 +40682,23 @@ async function acquireSidecarLock(options, context) {
                         throw error;
                     }
                     createdSnapshot = { raw, payload, ownershipToken };
-                    handle = (await options.lockRoot.open(relativeLockPath)).handle;
+                    const opened = await openSidecarRoot(lockRoot, relativeLockPath, "unlinked");
+                    if (!opened) {
+                        await waitForRetry();
+                        continue;
+                    }
+                    try {
+                        // Root.open admits the current file, not necessarily the one we created.
+                        const currentRaw = await readFileHandleBounded(opened.handle, Buffer.byteLength(raw));
+                        if (!currentRaw.equals(Buffer.from(raw))) {
+                            throw new errors_FsSafeError("path-mismatch", "created sidecar lock changed before admission");
+                        }
+                    }
+                    catch (error) {
+                        await opened.handle.close().catch(() => undefined);
+                        throw error;
+                    }
+                    handle = opened.handle;
                 }
                 else {
                     try {
@@ -39810,6 +40713,12 @@ async function acquireSidecarLock(options, context) {
                     await handle.writeFile(raw, "utf8");
                 }
                 const snapshot = { raw, payload, stat: await handle.stat(), ownershipToken };
+                if (snapshot.stat.nlink === 0) {
+                    await handle.close();
+                    handle = null;
+                    await waitForRetry();
+                    continue;
+                }
                 const createdHeld = {
                     refCount: 1,
                     reentrantOwner: options.reentrantOwner,
@@ -39854,7 +40763,7 @@ async function acquireSidecarLock(options, context) {
             catch (err) {
                 try {
                     if (handle) {
-                        const failedSnapshot = { payload: null };
+                        const failedSnapshot = createdSnapshot ?? { payload: null };
                         try {
                             failedSnapshot.stat = await handle.stat();
                         }
@@ -39866,8 +40775,8 @@ async function acquireSidecarLock(options, context) {
                             context.held.delete(normalizedTargetPath);
                         }
                         await handle.close().catch(() => undefined);
-                        // The file may be empty or partial JSON, so remove by the identity
-                        // captured from our exclusive handle rather than by pathname alone.
+                        // Root-created records retain the creator's byte/token receipt;
+                        // partial direct writes use the exclusive descriptor's identity.
                         await removeSidecarLockIfUnchanged(lockPath, failedSnapshot, {
                             lockRoot: options.lockRoot,
                             parsePayload: options.parsePayload,
@@ -39893,24 +40802,29 @@ async function acquireSidecarLock(options, context) {
                 if (ownsReclaimGuard) {
                     await releaseSidecarReclaimGuard(context.reclaimGuards, reclaimGuardPath);
                     ownsReclaimGuard = false;
+                    await waitForRetry();
                     continue;
                 }
                 const nowMs = Date.now();
-                let snapshot;
+                let rawSnapshot;
+                let lockFileOpenDenied = false;
                 try {
-                    snapshot = await readSidecarLockSnapshot(lockPath, {
+                    rawSnapshot = await readSidecarLockRawSnapshot(lockPath, {
                         lockRoot: options.lockRoot,
-                        parsePayload: options.parsePayload,
                         rejectNonFile: true,
+                        discardObservation: "changed",
+                        onOpenFailure: (error) => { lockFileOpenDenied = isTransientLockFileDenial(error, lockPath); },
                     });
                 }
                 catch (readErr) {
-                    if (!isTransientLockFileDenial(readErr, lockPath) || !withinDenialBudget())
+                    if (!lockFileOpenDenied || !withinDenialBudget())
                         throw readErr;
                     await retryOrRethrowDenial(readErr);
                     continue;
                 }
+                const snapshot = parseSidecarLockSnapshot(rawSnapshot, options.parsePayload);
                 if (!snapshot) {
+                    await waitForRetry();
                     continue;
                 }
                 if (context.held.has(normalizedTargetPath)) {
@@ -39930,6 +40844,7 @@ async function acquireSidecarLock(options, context) {
                         lockRoot: options.lockRoot,
                         parsePayload: options.parsePayload,
                     }))) {
+                        await waitForRetry();
                         continue;
                     }
                     const staleRecovery = options.staleRecovery ?? "fail-closed";
@@ -39948,6 +40863,8 @@ async function acquireSidecarLock(options, context) {
                             parsePayload: options.parsePayload,
                         });
                         if (removal === "removed" || removal === "changed") {
+                            if (removal === "changed")
+                                await waitForRetry();
                             continue;
                         }
                         await releaseSidecarReclaimGuard(context.reclaimGuards, reclaimGuardPath);
@@ -39963,1176 +40880,521 @@ async function acquireSidecarLock(options, context) {
             }
         }
     }
-    finally {
-        if (ownsReclaimGuard) {
-            await releaseSidecarReclaimGuard(context.reclaimGuards, reclaimGuardPath).catch(() => undefined);
-        }
-    }
-}
-
-;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/sidecar-lock-handle.js
-
-function createSidecarLockHandle(params) {
-    let released = false;
-    let releasePromise;
-    let releaseStarted = false;
-    const release = async () => {
-        if (released)
-            return;
-        if (!releasePromise) {
-            const retry = releaseStarted;
-            releaseStarted = true;
-            releasePromise = (async () => {
-                await params.release({ retry });
-                released = true;
-            })();
-        }
-        try {
-            await releasePromise;
-        }
-        finally {
-            releasePromise = undefined;
-        }
-    };
-    return {
-        lockPath: params.lockPath,
-        normalizedTargetPath: params.normalizedTargetPath,
-        verifyStillHeld: params.verifyStillHeld,
-        release,
-        [Symbol.asyncDispose]: release,
-    };
-}
-function createHeldSidecarLockHandle(params) {
-    return createSidecarLockHandle({
-        lockPath: params.held.lockPath,
-        normalizedTargetPath: params.normalizedTargetPath,
-        verifyStillHeld: async () => await sidecarLockSnapshotStillPresent(params.held.lockPath, params.held.snapshot, {
-            lockRoot: params.held.lockRoot,
-            parsePayload: params.held.parsePayload,
-        }),
-        release: (options) => params.release(options),
-    });
-}
-
-;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/sidecar-lock.js
-
-
-
-
-
-
-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");
-function getGlobalManagers() {
-    const globalWithState = globalThis;
-    if (!globalWithState[GLOBAL_STATE_KEY]) {
-        globalWithState[GLOBAL_STATE_KEY] = new Map();
-    }
-    return globalWithState[GLOBAL_STATE_KEY];
-}
-function resolveManagerState(key) {
-    const managers = getGlobalManagers();
-    let state = managers.get(key);
-    if (!state) {
-        state = {
-            cleanupRegistered: false,
-            held: new Map(),
-            reclaimCleanupRegistered: false,
-            reclaimGuards: new Set(),
-        };
-        managers.set(key, state);
-    }
-    else {
-        // The global manager symbol is shared across package copies and hot reloads.
-        // Backfill state created by fs-safe versions that predate reclaim guards.
-        state.reclaimCleanupRegistered ??= false;
-        state.reclaimGuards ??= new Set();
-        for (const held of state.held.values()) {
-            held.refCount ??= 1;
-        }
-    }
-    return state;
-}
-function snapshotMatchesSync(lockPath, observed) {
-    let fd;
-    try {
-        const beforeStat = external_node_fs_.lstatSync(lockPath);
-        if (!beforeStat.isFile()) {
-            return false;
-        }
-        const openFlags = external_node_fs_.constants.O_RDONLY |
-            (process.platform !== "win32" && typeof external_node_fs_.constants.O_NOFOLLOW === "number"
-                ? external_node_fs_.constants.O_NOFOLLOW
-                : 0) |
-            (typeof external_node_fs_.constants.O_NONBLOCK === "number" ? external_node_fs_.constants.O_NONBLOCK : 0);
-        fd = external_node_fs_.openSync(lockPath, openFlags);
-        const openedStat = external_node_fs_.fstatSync(fd);
-        if (!openedStat.isFile()) {
-            return false;
-        }
-        if (observed.raw !== undefined && openedStat.size !== Buffer.byteLength(observed.raw)) {
-            return false;
-        }
-        const raw = external_node_fs_.readFileSync(fd, "utf8");
-        const afterStat = external_node_fs_.lstatSync(lockPath);
-        if (!afterStat.isFile() || !file_identity_sameFileIdentity(beforeStat, afterStat)) {
-            return false;
-        }
-        return sidecarLockSnapshotMatches({ raw, payload: null, stat: afterStat }, observed);
-    }
-    catch {
-        return false;
-    }
-    finally {
-        if (fd !== undefined) {
-            try {
-                external_node_fs_.closeSync(fd);
-            }
-            catch {
-                // Best-effort process-exit cleanup.
-            }
-        }
-    }
-}
-function releaseAllReclaimGuardsSync(state) {
-    for (const reclaimGuardPath of state.reclaimGuards) {
-        try {
-            external_node_fs_.rmdirSync(reclaimGuardPath);
-            state.reclaimGuards.delete(reclaimGuardPath);
-        }
-        catch {
-            // Best-effort process-exit cleanup. A surviving guard fails closed.
-        }
-    }
-}
-function releaseAllLocksSync(state) {
-    for (const [normalizedTargetPath, held] of state.held) {
-        void held.handle.close().catch(() => undefined);
-        try {
-            if (!held.lockRoot && snapshotMatchesSync(held.lockPath, held.snapshot)) {
-                external_node_fs_.rmSync(held.lockPath, { force: true });
-            }
-        }
-        catch {
-            // Best-effort process-exit cleanup.
-        }
-        state.held.delete(normalizedTargetPath);
-    }
-    releaseAllReclaimGuardsSync(state);
-}
-function ensureGlobalExitCleanupRegistered() {
-    const globalWithCleanup = globalThis;
-    if (globalWithCleanup[GLOBAL_CLEANUP_KEY])
-        return;
-    globalWithCleanup[GLOBAL_CLEANUP_KEY] = true;
-    const cleanup = () => {
-        for (const state of getGlobalManagers().values()) {
-            releaseAllLocksSync(state);
-        }
-    };
-    globalWithCleanup[GLOBAL_CLEANUP_HANDLER_KEY] = cleanup;
-    process.on("exit", cleanup);
-}
-async function releaseHeldLock(state, normalizedTargetPath, held, options = {}) {
-    const current = state.held.get(normalizedTargetPath);
-    if (current !== held) {
-        return false;
-    }
-    if (held.releasePromise) {
-        await held.releasePromise;
-        return true;
-    }
-    if (options.force) {
-        held.refCount = 0;
-    }
-    else if (!options.retry && held.refCount > 0) {
-        held.refCount -= 1;
-    }
-    if (held.refCount > 0) {
-        return false;
-    }
-    held.releasePromise = (async () => {
-        await held.handle.close().catch(() => undefined);
-        await removeSidecarLockIfUnchanged(held.lockPath, held.snapshot, {
-            lockRoot: held.lockRoot,
-            parsePayload: held.parsePayload,
-        });
-        if (state.held.get(normalizedTargetPath) === held) {
-            state.held.delete(normalizedTargetPath);
-        }
-        if (held.compromiseTimer) {
-            clearInterval(held.compromiseTimer);
-            held.compromiseTimer = undefined;
-        }
-    })();
-    try {
-        await held.releasePromise;
-        return true;
-    }
-    finally {
-        held.releasePromise = undefined;
-    }
-}
-function handleForHeldLock(state, normalizedTargetPath, held) {
-    return createHeldSidecarLockHandle({
-        normalizedTargetPath,
-        held,
-        release: async (options) => await releaseHeldLock(state, normalizedTargetPath, held, { retry: options?.retry }),
-    });
-}
-function createSidecarLockManager(key) {
-    const state = resolveManagerState(key);
-    function ensureExitCleanupRegistered() {
-        state.cleanupRegistered = true;
-        state.reclaimCleanupRegistered = true;
-        ensureGlobalExitCleanupRegistered();
-    }
-    async function acquire(options) {
-        return await acquireSidecarLock(options, {
-            held: state.held,
-            reclaimGuards: state.reclaimGuards,
-            ensureExitCleanupRegistered,
-            handleForHeldLock: (normalizedTargetPath, held) => handleForHeldLock(state, normalizedTargetPath, held),
-            releaseHeldLock: async (normalizedTargetPath, held, releaseOptions) => await releaseHeldLock(state, normalizedTargetPath, held, releaseOptions),
-        });
-    }
-    async function withLock(options, fn) {
-        const lock = await acquire(options);
-        let result;
-        try {
-            result = await fn();
-        }
-        catch (bodyError) {
-            try {
-                await lock.release();
-            }
-            catch (releaseError) {
-                throw createSuppressedError(releaseError, bodyError, "file lock callback and release both failed");
-            }
-            throw bodyError;
-        }
-        await lock.release();
-        return result;
-    }
-    async function drain() {
-        for (const [normalizedTargetPath, held] of Array.from(state.held.entries())) {
-            await releaseHeldLock(state, normalizedTargetPath, held, { force: true }).catch(() => undefined);
-        }
-    }
-    function reset() {
-        releaseAllLocksSync(state);
-    }
-    function heldEntries() {
-        return Array.from(state.held.entries()).map(([normalizedTargetPath, held]) => ({
-            normalizedTargetPath,
-            lockPath: held.lockPath,
-            acquiredAt: held.acquiredAt,
-            metadata: held.metadata,
-            forceRelease: () => releaseHeldLock(state, normalizedTargetPath, held, { force: true }),
-        }));
-    }
-    return { acquire, withLock, drain, reset, heldEntries };
-}
-async function withSidecarLock(targetPath, options, fn) {
-    const manager = createSidecarLockManager(options.managerKey ?? `fs-safe.sidecar-lock:${targetPath}`);
-    const { managerKey: _managerKey, ...acquireOptions } = options;
-    return await manager.withLock({ ...acquireOptions, targetPath }, fn);
-}
-
-;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/pinned-write.js
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-function pinned_write_byteLength(input, encoding) {
-    return typeof input === "string"
-        ? Buffer.byteLength(input, encoding ?? "utf8")
-        : input.byteLength;
-}
-function assertSafeBasename(basename) {
-    if (!basename ||
-        basename === "." ||
-        basename === ".." ||
-        basename.includes("/") ||
-        basename.includes("\0")) {
-        throw new errors_FsSafeError("invalid-path", "invalid target path");
-    }
-}
-function assertWithinMaxBytes(bytes, maxBytes) {
-    if (maxBytes !== undefined && 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) {
-        const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
-        bytes += buffer.byteLength;
-        assertWithinMaxBytes(bytes, maxBytes);
-        let offset = 0;
-        while (offset < buffer.byteLength) {
-            const { bytesWritten } = await handle.write(buffer, offset, buffer.byteLength - offset);
-            if (bytesWritten <= 0) {
-                throw new errors_FsSafeError("helper-failed", "fallback stream write made no progress");
-            }
-            offset += bytesWritten;
-        }
-    }
-}
-async function runPinnedWriteHelper(params) {
-    const normalizedParams = { ...params, maxBytes: byte_budget_normalizeMaxBytes(params.maxBytes) };
-    assertSafeBasename(params.basename);
-    validatePinnedOperationPayload({
-        relativeParentPath: params.relativeParentPath,
-    });
-    // The explicit compatibility policy uses the guarded Node fallback, where
-    // content verification can replace the strict post-rename inode check.
-    if (normalizedParams.onRenameIdentityMismatch === "verify-content") {
-        return await runPinnedWriteFallback(normalizedParams);
-    }
-    const native = getNativeBinding();
-    if (native) {
-        return await runPinnedWriteNative(native, normalizedParams);
-    }
-    return await runPinnedWriteFallback(normalizedParams);
-}
-async function runPinnedWriteWithRenamePolicy(params) {
-    const { targetPath, renameIdentity, ...writeParams } = params;
-    if (renameIdentity !== "verify-content-with-lock") {
-        return await runPinnedWriteHelper(writeParams);
-    }
-    const relativeTargetPath = writeParams.relativeParentPath
-        ? `${writeParams.relativeParentPath}/${writeParams.basename}`
-        : writeParams.basename;
-    const lockPath = external_node_path_.join(writeParams.rootPath, `.fs-safe-write-${sha256Hex(relativeTargetPath)}.lock`);
-    return await withSidecarLock(writeParams.rootPath, {
-        managerKey: `fs-safe.write:${targetPath}`,
-        lockPath,
-        staleMs: 30_000,
-        timeoutMs: 5_000,
-        payload: () => ({ pid: process.pid, createdAt: new Date().toISOString() }),
-        retry: { retries: 5, minTimeout: 100, maxTimeout: 2_000, factor: 2 },
-    }, async () => await runPinnedWriteHelper({
-        ...writeParams,
-        onRenameIdentityMismatch: "verify-content",
-    }));
-}
-async function runPinnedWriteFallback(params) {
-    let parentPath = params.relativeParentPath
-        ? external_node_path_.join(params.rootPath, ...params.relativeParentPath.split("/"))
-        : params.rootPath;
-    if (params.mkdir) {
-        // mkdirPathComponentsWithGuards may resolve the final component through
-        // an in-root symlink (e.g. a skill-bank layout). Use its returned real
-        // path for the subsequent guard and target path so we don't re-check the
-        // original, possibly-symlinked, lexical path and reject it outright.
-        parentPath = await mkdirPathComponentsWithGuards({
-            rootReal: params.rootPath,
-            targetPath: parentPath,
-            beforeComponent: async (componentPath) => await getFsSafeTestHooks()?.beforeRootFallbackMutation?.("mkdir", componentPath),
-        });
-    }
-    const parentGuard = params.mkdir
-        ? await directory_guard_createAsyncDirectoryGuard(parentPath)
-        : await directory_guard_createNearestExistingDirectoryGuard(params.rootPath, parentPath);
-    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), {
-            onPostGuardFailure: async (openedHandle) => {
-                // The parent failed verification, so targetPath may now resolve
-                // somewhere else. Close the fd, but do not clean up by path.
-                await openedHandle.close().catch(() => undefined);
-            },
-        });
-        let created = true;
-        try {
-            const verificationIdentity = await handle.stat({ bigint: true });
-            await handle.chmod(params.mode);
-            if (params.input.kind === "buffer") {
-                assertWithinMaxBytes(pinned_write_byteLength(params.input.data, params.input.encoding), params.maxBytes);
-                if (typeof params.input.data === "string") {
-                    await handle.writeFile(params.input.data, params.input.encoding ?? "utf8");
-                }
-                else {
-                    await handle.writeFile(params.input.data);
-                }
-            }
-            else {
-                await writeStreamToHandle(params.input.stream, handle, params.maxBytes);
-            }
-            await syncFileBestEffort(handle);
-            const stat = await handle.stat();
-            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);
-            }
-        }
-    }
-    const tempPath = external_node_path_.join(parentPath, `.${params.basename}.${(0,external_node_crypto_.randomUUID)()}.fallback.tmp`);
-    const tempFlags = external_node_fs_.constants.O_WRONLY |
-        external_node_fs_.constants.O_CREAT |
-        external_node_fs_.constants.O_EXCL |
-        (process.platform !== "win32" && "O_NOFOLLOW" in external_node_fs_.constants
-            ? external_node_fs_.constants.O_NOFOLLOW
-            : 0);
-    let handle;
-    let tempStat;
-    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);
-        if (params.input.kind === "buffer") {
-            assertWithinMaxBytes(pinned_write_byteLength(params.input.data, params.input.encoding), params.maxBytes);
-            if (typeof params.input.data === "string") {
-                await handle.writeFile(params.input.data, params.input.encoding ?? "utf8");
-            }
-            else {
-                await handle.writeFile(params.input.data);
-            }
-        }
-        else {
-            await writeStreamToHandle(params.input.stream, handle, params.maxBytes);
-        }
-        tempStat = await handle.stat();
-        const tempPathStat = await promises_.lstat(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);
-        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 (targetStat.isSymbolicLink()) {
-                throw new errors_FsSafeError("path-mismatch", "fallback target changed during write");
-            }
-            if (!file_identity_sameFileIdentity(targetStat, expectedTempStat)) {
-                // On filesystems like rclone FUSE, rename(2) can give the destination a
-                // different inode from the source temp fd even with zero concurrency. The
-                // caller must ensure mutual exclusion before passing "verify-content";
-                // fall back to a content hash for this rename-boundary check only.
-                if (params.onRenameIdentityMismatch !== "verify-content") {
-                    throw new errors_FsSafeError("path-mismatch", "fallback target changed during write");
-                }
-                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);
-                readHandle = await promises_.open(targetPath, read_open_flags_resolveReadOpenFlags());
-                const readHandleStat = await readHandle.stat({ bigint: true });
-                const actualHash = sha256Hex(await readHandle.readFile());
-                if (actualHash !== expectedHash) {
-                    throw new errors_FsSafeError("path-mismatch", "fallback target changed during write");
-                }
-                // The content-verified destination, not the old temp inode, is now pinned.
-                verificationIdentity = readHandleStat;
-                // Preserve the helper's legacy numeric return facts, not the private proof.
-                verifiedIdentity = { dev: Number(readHandleStat.dev), ino: Number(readHandleStat.ino) };
-            }
-        });
-        await params.verifyPublished?.((readHandle ?? handle).fd, verificationIdentity, parentGuard);
-        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);
-        }
-    }
-}
-
-;// 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")}`);
-}
-
-;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/root-path-symlink.js
-
-
-
-
-
-
-function normalizeSymlinkResolutionError(error) {
-    if (isSymlinkOpenError(error)) {
-        throw new errors_FsSafeError("symlink", "symlink path could not be resolved", {
-            cause: error instanceof Error ? error : undefined,
-        });
-    }
-    if (!path_isNotFoundPathError(error))
-        throw error;
-}
-async function resolveSymlinkHopPath(symlinkPath) {
-    try {
-        return external_node_path_.resolve(await promises_.realpath(symlinkPath));
-    }
-    catch (error) {
-        normalizeSymlinkResolutionError(error);
-        const linkTarget = await promises_.readlink(symlinkPath);
-        return resolvePathViaExistingAncestor(external_node_path_.resolve(external_node_path_.dirname(symlinkPath), linkTarget));
-    }
-}
-function root_path_symlink_resolveSymlinkHopPathSync(symlinkPath) {
-    try {
-        return path.resolve(fs.realpathSync(symlinkPath));
-    }
-    catch (error) {
-        normalizeSymlinkResolutionError(error);
-        const linkTarget = fs.readlinkSync(symlinkPath);
-        return resolvePathViaExistingAncestorSync(path.resolve(path.dirname(symlinkPath), linkTarget));
-    }
-}
-
-;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/safe-path-segment.js
-
-const SAFE_PATH_SEGMENT_PATTERN = /^[A-Za-z0-9_-][A-Za-z0-9._-]*$/;
-const SAFE_DOT_PREFIX_PATH_SEGMENT_PATTERN = /^[A-Za-z0-9._-]+$/;
-// Windows treats "C:name" as relative to the drive's current directory even
-// though path.win32.isAbsolute() reports false.
-const DRIVE_RELATIVE_PREFIX = /^[A-Za-z]:(?![\\/])/;
-const HYPHEN_CHAR_CODE = 0x2d;
-function safe_path_segment_isDriveRelativePath(value) {
-    return DRIVE_RELATIVE_PREFIX.test(value);
-}
-function assertNoDriveRelativePathSegments(value, label) {
-    if (value.split("/").some(safe_path_segment_isDriveRelativePath)) {
-        throw new errors_FsSafeError("invalid-path", `${label} must not contain a drive letter`);
-    }
-    return value;
-}
-function trimHyphenEdges(value) {
-    let start = 0;
-    let end = value.length;
-    while (start < end && value.charCodeAt(start) === HYPHEN_CHAR_CODE) {
-        start += 1;
-    }
-    while (end > start && value.charCodeAt(end - 1) === HYPHEN_CHAR_CODE) {
-        end -= 1;
-    }
-    return start === 0 && end === value.length ? value : value.slice(start, end);
-}
-function isSafePathSegment(segment, options = {}) {
-    return (segment !== "" &&
-        segment !== "." &&
-        segment !== ".." &&
-        !segment.includes("/") &&
-        !segment.includes("\\") &&
-        !segment.includes("\0") &&
-        (options.allowDotPrefix === true || !segment.startsWith(".")) &&
-        (options.allowDotPrefix === true
-            ? SAFE_DOT_PREFIX_PATH_SEGMENT_PATTERN.test(segment)
-            : SAFE_PATH_SEGMENT_PATTERN.test(segment)));
-}
-function assertSafePathSegment(segment, options = {}) {
-    // Validate the exact value callers will later join into paths; trimming here
-    // would let whitespace-padded ids pass and then be used verbatim.
-    if (!isSafePathSegment(segment, options)) {
-        throw new FsSafeError("invalid-path", `${options.label ?? "path segment"} must be a safe path segment`);
-    }
-    return segment;
-}
-function sanitizeSafePathSegment(value, fallback, options = {}) {
-    const sanitized = value
-        .trim()
-        .replace(/[\\/]+/g, "-")
-        .replace(/\0/g, "")
-        .replace(/[^A-Za-z0-9._-]+/g, "-");
-    const trimmed = trimHyphenEdges(sanitized);
-    if (isSafePathSegment(trimmed, options)) {
-        return trimmed;
-    }
-    return assertSafePathSegment(fallback, { ...options, label: "fallback path segment" });
-}
-function assertSafePathPrefix(prefix, options = {}) {
-    // Prefixes are often derived from safe filenames. Normalize harmless
-    // filename characters first, but still reject real path-control bytes.
-    if (prefix.includes("/") || prefix.includes("\\") || prefix.includes("\0")) {
-        return assertSafePathSegment(prefix, {
-            allowDotPrefix: true,
-            ...options,
-            label: options.label ?? "path prefix",
-        });
+    finally {
+        if (ownsReclaimGuard) {
+            await releaseSidecarReclaimGuard(context.reclaimGuards, reclaimGuardPath).catch(() => undefined);
+        }
     }
-    return assertSafePathSegment(prefix.replace(/[^A-Za-z0-9._-]+/g, "-"), {
-        allowDotPrefix: true,
-        ...options,
-        label: options.label ?? "path prefix",
-    });
 }
 
-// EXTERNAL MODULE: external "node:os"
-var external_node_os_ = __webpack_require__(8161);
-;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/short-path.js
-
+;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/sidecar-lock-handle.js
 
-function shortPath(value) {
-    const home = external_node_os_.homedir();
-    const shortened = value.startsWith(home) ? `~${value.slice(home.length)}` : value;
-    return formatErrorDetail(shortened);
+function createSidecarLockHandle(params) {
+    let released = false;
+    let releasePromise;
+    let releaseStarted = false;
+    const release = async () => {
+        if (released)
+            return;
+        if (!releasePromise) {
+            const retry = releaseStarted;
+            releaseStarted = true;
+            releasePromise = (async () => {
+                await params.release({ retry });
+                released = true;
+            })();
+        }
+        try {
+            await releasePromise;
+        }
+        finally {
+            releasePromise = undefined;
+        }
+    };
+    return {
+        lockPath: params.lockPath,
+        normalizedTargetPath: params.normalizedTargetPath,
+        verifyStillHeld: params.verifyStillHeld,
+        release,
+        [Symbol.asyncDispose]: release,
+    };
+}
+function createHeldSidecarLockHandle(params) {
+    return createSidecarLockHandle({
+        lockPath: params.held.lockPath,
+        normalizedTargetPath: params.normalizedTargetPath,
+        verifyStillHeld: async () => await sidecarLockSnapshotStillPresent(params.held.lockPath, params.held.snapshot, {
+            lockRoot: params.held.lockRoot,
+            parsePayload: params.held.parsePayload,
+        }),
+        release: (options) => params.release(options),
+    });
 }
 
-;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/root-path.js
-
-
-
-
-
+;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/sidecar-lock.js
 
 
 
 
 
 
-const ROOT_PATH_ALIAS_POLICIES = {
-    strict: Object.freeze({
-        allowFinalSymlinkForUnlink: false,
-        allowFinalHardlinkForUnlink: false,
-    }),
-    unlinkTarget: Object.freeze({
-        allowFinalSymlinkForUnlink: true,
-        allowFinalHardlinkForUnlink: true,
-    }),
-};
-async function resolveRootPath(params) {
-    try {
-        return await resolveRootPathInternal(params);
-    }
-    catch (error) {
-        throw sanitizeRootPathError(error);
+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");
+function getGlobalManagers() {
+    const globalWithState = globalThis;
+    if (!globalWithState[GLOBAL_STATE_KEY]) {
+        globalWithState[GLOBAL_STATE_KEY] = new Map();
     }
+    return globalWithState[GLOBAL_STATE_KEY];
 }
-async function resolveRootPathInternal(params) {
-    assertValidRootPathInputs(params);
-    const rootPath = external_node_path_.resolve(params.rootPath);
-    const absolutePath = external_node_path_.resolve(params.absolutePath);
-    const rootCanonicalPath = params.rootCanonicalPath
-        ? external_node_path_.resolve(params.rootCanonicalPath)
-        : await resolvePathViaExistingAncestor(rootPath);
-    const context = createBoundaryResolutionContext({
-        resolveParams: params,
-        rootPath,
-        absolutePath,
-        rootCanonicalPath,
-        outsideLexicalCanonicalPath: await resolveOutsideLexicalCanonicalPathAsync({
-            rootPath,
-            absolutePath,
-        }),
-    });
-    const outsideResult = await resolveOutsideRootPathAsync({
-        boundaryLabel: params.boundaryLabel,
-        context,
-    });
-    if (outsideResult) {
-        return outsideResult;
+function resolveManagerState(key) {
+    const managers = getGlobalManagers();
+    let state = managers.get(key);
+    if (!state) {
+        state = {
+            cleanupRegistered: false,
+            held: new Map(),
+            reclaimCleanupRegistered: false,
+            reclaimGuards: new Set(),
+        };
+        managers.set(key, state);
     }
-    return resolveRootPathLexicalAsync({
-        params,
-        absolutePath: context.absolutePath,
-        rootPath: context.rootPath,
-        rootCanonicalPath: context.rootCanonicalPath,
-    });
+    else {
+        // The global manager symbol is shared across package copies and hot reloads.
+        // Backfill state created by fs-safe versions that predate reclaim guards.
+        state.reclaimCleanupRegistered ??= false;
+        state.reclaimGuards ??= new Set();
+        for (const held of state.held.values()) {
+            held.refCount ??= 1;
+        }
+    }
+    return state;
 }
-function resolveRootPathSync(params) {
+function snapshotMatchesSync(lockPath, observed) {
+    let fd;
     try {
-        return resolveRootPathSyncInternal(params);
+        const beforeStat = external_node_fs_.lstatSync(lockPath);
+        if (!beforeStat.isFile()) {
+            return false;
+        }
+        const openFlags = external_node_fs_.constants.O_RDONLY |
+            (process.platform !== "win32" && typeof external_node_fs_.constants.O_NOFOLLOW === "number"
+                ? external_node_fs_.constants.O_NOFOLLOW
+                : 0) |
+            (typeof external_node_fs_.constants.O_NONBLOCK === "number" ? external_node_fs_.constants.O_NONBLOCK : 0);
+        fd = external_node_fs_.openSync(lockPath, openFlags);
+        const openedStat = external_node_fs_.fstatSync(fd);
+        if (!openedStat.isFile()) {
+            return false;
+        }
+        if (observed.raw !== undefined && openedStat.size !== Buffer.byteLength(observed.raw)) {
+            return false;
+        }
+        const raw = external_node_fs_.readFileSync(fd, "utf8");
+        const afterStat = external_node_fs_.lstatSync(lockPath);
+        if (!afterStat.isFile() || !file_identity_sameFileIdentity(beforeStat, afterStat)) {
+            return false;
+        }
+        return sidecarLockSnapshotMatches({ raw, payload: null, stat: afterStat }, observed);
     }
-    catch (error) {
-        throw sanitizeRootPathError(error);
+    catch {
+        return false;
     }
-}
-function resolveRootPathSyncInternal(params) {
-    assertValidRootPathInputs(params);
-    const rootPath = path.resolve(params.rootPath);
-    const absolutePath = path.resolve(params.absolutePath);
-    const rootCanonicalPath = params.rootCanonicalPath
-        ? path.resolve(params.rootCanonicalPath)
-        : resolvePathViaExistingAncestorSync(rootPath);
-    const context = createBoundaryResolutionContext({
-        resolveParams: params,
-        rootPath,
-        absolutePath,
-        rootCanonicalPath,
-        outsideLexicalCanonicalPath: resolveOutsideLexicalCanonicalPathSync({
-            rootPath,
-            absolutePath,
-        }),
-    });
-    const outsideResult = resolveOutsideRootPathSync({
-        boundaryLabel: params.boundaryLabel,
-        context,
-    });
-    if (outsideResult) {
-        return outsideResult;
+    finally {
+        if (fd !== undefined) {
+            try {
+                external_node_fs_.closeSync(fd);
+            }
+            catch {
+                // Best-effort process-exit cleanup.
+            }
+        }
     }
-    return resolveRootPathLexicalSync({
-        params,
-        absolutePath: context.absolutePath,
-        rootPath: context.rootPath,
-        rootCanonicalPath: context.rootCanonicalPath,
-    });
 }
-function sanitizeRootPathError(error) {
-    if (error instanceof Error) {
-        error.message = formatErrorDetail(error.message);
+function releaseAllReclaimGuardsSync(state) {
+    for (const reclaimGuardPath of state.reclaimGuards) {
+        try {
+            external_node_fs_.rmdirSync(reclaimGuardPath);
+            state.reclaimGuards.delete(reclaimGuardPath);
+        }
+        catch {
+            // Best-effort process-exit cleanup. A surviving guard fails closed.
+        }
     }
-    return error;
 }
-function assertValidRootPathInputs(params) {
-    path_assertNoNulPathInput(params.rootPath, "root path contains a NUL byte");
-    path_assertNoNulPathInput(params.absolutePath, "absolute path contains a NUL byte");
-    assertNoEmbeddedDriveRelativeSegment(params.rootPath, "root path");
-    assertNoEmbeddedDriveRelativeSegment(params.absolutePath, "absolute path");
-    if (params.rootCanonicalPath !== undefined) {
-        path_assertNoNulPathInput(params.rootCanonicalPath, "canonical root path contains a NUL byte");
-        assertNoEmbeddedDriveRelativeSegment(params.rootCanonicalPath, "canonical root path");
+function releaseAllLocksSync(state) {
+    for (const [normalizedTargetPath, held] of state.held) {
+        void held.handle.close().catch(() => undefined);
+        try {
+            if (!held.lockRoot && snapshotMatchesSync(held.lockPath, held.snapshot)) {
+                external_node_fs_.rmSync(held.lockPath, { force: true });
+            }
+        }
+        catch {
+            // Best-effort process-exit cleanup.
+        }
+        state.held.delete(normalizedTargetPath);
     }
+    releaseAllReclaimGuardsSync(state);
 }
-function assertNoEmbeddedDriveRelativeSegment(filePath, label) {
-    if (process.platform !== "win32") {
+function ensureGlobalExitCleanupRegistered() {
+    const globalWithCleanup = globalThis;
+    if (globalWithCleanup[GLOBAL_CLEANUP_KEY])
         return;
-    }
-    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);
-    const relative = rawRelativePath ?? external_node_path_.relative(params.rootPath, params.absolutePath);
-    return {
-        segments: splitTraversalSegments(relative),
-        allowFinalSymlink: params.params.policy?.allowFinalSymlinkForUnlink === true,
-        canonicalCursor: params.rootCanonicalPath,
-        lexicalCursor: params.rootPath,
-        preserveFinalSymlink: false,
-    };
-}
-function createLexicalTraversalContext(params) {
-    return {
-        state: createLexicalTraversalState(params),
-        resolveParams: params.params,
-        rootPath: params.rootPath,
-        rootCanonicalPath: params.rootCanonicalPath,
-        absolutePath: params.absolutePath,
+    globalWithCleanup[GLOBAL_CLEANUP_KEY] = true;
+    const cleanup = () => {
+        for (const state of getGlobalManagers().values()) {
+            releaseAllLocksSync(state);
+        }
     };
+    globalWithCleanup[GLOBAL_CLEANUP_HANDLER_KEY] = cleanup;
+    process.on("exit", cleanup);
 }
-function splitTraversalSegments(value) {
-    return value
-        .split(process.platform === "win32" ? /[\\/]+/ : /\/+/)
-        .filter((segment) => Boolean(segment) && segment !== ".");
-}
-function rawPathRelativeToRoot(rootPath, candidatePath) {
-    if (!external_node_path_.isAbsolute(candidatePath)) {
-        return undefined;
-    }
-    const root = external_node_path_.resolve(rootPath);
-    const candidate = process.platform === "win32"
-        ? candidatePath.replaceAll("/", external_node_path_.sep)
-        : candidatePath;
-    if (candidate === root) {
-        return "";
-    }
-    const rootWithSep = root.endsWith(external_node_path_.sep) ? root : `${root}${external_node_path_.sep}`;
-    const candidatePrefix = candidate.slice(0, rootWithSep.length);
-    const prefixMatches = process.platform === "win32"
-        ? candidatePrefix.toLowerCase() === rootWithSep.toLowerCase()
-        : candidatePrefix === rootWithSep;
-    return prefixMatches ? candidate.slice(rootWithSep.length) : undefined;
-}
-function assertLexicalCursorInsideBoundary(context, candidatePath) {
-    assertInsideBoundary({
-        boundaryLabel: context.resolveParams.boundaryLabel,
-        rootCanonicalPath: context.rootCanonicalPath,
-        candidatePath,
-        absolutePath: context.absolutePath,
-    });
-}
-function applyMissingSuffixToCanonicalCursor(context, missingFromIndex) {
-    const missingSuffix = context.state.segments.slice(missingFromIndex);
-    for (const segment of missingSuffix) {
-        advanceCanonicalCursorForSegment(context, segment);
-    }
-}
-function advanceCanonicalCursorForSegment(context, segment) {
-    context.state.canonicalCursor = external_node_path_.resolve(context.state.canonicalCursor, segment);
-    assertLexicalCursorInsideBoundary(context, context.state.canonicalCursor);
-}
-function finalizeLexicalResolution(context, kind) {
-    assertLexicalCursorInsideBoundary(context, context.state.canonicalCursor);
-    return buildResolvedRootPath({
-        absolutePath: context.absolutePath,
-        canonicalPath: context.state.canonicalCursor,
-        rootPath: context.rootPath,
-        rootCanonicalPath: context.rootCanonicalPath,
-        kind,
-    });
-}
-function handleLexicalLstatFailure(context, error, missingFromIndex) {
-    if (!path_isNotFoundPathError(error)) {
+async function releaseHeldLock(state, normalizedTargetPath, held, options = {}) {
+    const current = state.held.get(normalizedTargetPath);
+    if (current !== held) {
         return false;
     }
-    applyMissingSuffixToCanonicalCursor(context, missingFromIndex);
-    return true;
-}
-function handleLexicalStatReadFailure(context, error, missingFromIndex) {
-    if (handleLexicalLstatFailure(context, error, missingFromIndex)) {
-        return null;
+    if (held.releasePromise) {
+        await held.releasePromise;
+        return true;
     }
-    throw error;
-}
-function handleLexicalStatDisposition(context, params) {
-    if (!params.isSymbolicLink) {
-        advanceCanonicalCursorForSegment(context, params.segment);
-        return "continue";
+    if (options.force) {
+        held.refCount = 0;
     }
-    if (context.resolveParams.rejectSymlinks === true && params.isLast) {
-        throw new errors_FsSafeError("symlink", "symlink path component not allowed");
+    else if (!options.retry && held.refCount > 0) {
+        held.refCount -= 1;
     }
-    if (context.state.allowFinalSymlink && params.isLast) {
-        context.state.preserveFinalSymlink = true;
-        advanceCanonicalCursorForSegment(context, params.segment);
-        return "break";
+    if (held.refCount > 0) {
+        return false;
     }
-    return "resolve-link";
-}
-function applyResolvedSymlinkHop(context, linkCanonical) {
-    if (!path_isPathInside(context.rootCanonicalPath, linkCanonical)) {
-        throw symlinkEscapeError({
-            boundaryLabel: context.resolveParams.boundaryLabel,
-            rootCanonicalPath: context.rootCanonicalPath,
-            symlinkPath: context.state.lexicalCursor,
+    held.releasePromise = (async () => {
+        await held.handle.close().catch(() => undefined);
+        await removeSidecarLockIfUnchanged(held.lockPath, held.snapshot, {
+            lockRoot: held.lockRoot,
+            parsePayload: held.parsePayload,
         });
-    }
-    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));
+        if (state.held.get(normalizedTargetPath) === held) {
+            state.held.delete(normalizedTargetPath);
         }
-        return stat;
-    }
-    catch (error) {
-        return handleLexicalStatReadFailure(context, error, params.missingFromIndex);
+        if (held.compromiseTimer) {
+            clearInterval(held.compromiseTimer);
+            held.compromiseTimer = undefined;
+        }
+    })();
+    try {
+        await held.releasePromise;
+        return true;
     }
-}
-function resolveAndApplySymlinkHop(context, params) {
-    const linkCanonical = params.resolveLinkCanonical(context.state.lexicalCursor);
-    if (isPromiseLike(linkCanonical)) {
-        return Promise.resolve(linkCanonical).then((value) => {
-            applyResolvedSymlinkHop(context, value);
-        });
+    finally {
+        held.releasePromise = undefined;
     }
-    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 };
-    }
+function handleForHeldLock(state, normalizedTargetPath, held) {
+    return createHeldSidecarLockHandle({
+        normalizedTargetPath,
+        held,
+        release: async (options) => await releaseHeldLock(state, normalizedTargetPath, held, { retry: options?.retry }),
+    });
 }
-async function resolveRootPathLexicalAsync(params) {
-    const context = createLexicalTraversalContext(params);
-    const { state } = context;
-    for (const { idx, segment, isLast } of iterateLexicalTraversal(state)) {
-        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;
-        }
-        const disposition = handleLexicalStatDisposition(context, {
-            isSymbolicLink: stat.isSymbolicLink(),
-            segment,
-            isLast,
-        });
-        if (disposition === "continue") {
-            continue;
-        }
-        if (disposition === "break") {
-            break;
-        }
-        await resolveAndApplySymlinkHop(context, {
-            resolveLinkCanonical: (cursor) => resolveSymlinkHopPath(cursor),
-        });
-        if (context.resolveParams.rejectSymlinks === true) {
-            throw new errors_FsSafeError("symlink", "symlink path component not allowed");
-        }
+function createSidecarLockManager(key) {
+    const state = resolveManagerState(key);
+    function ensureExitCleanupRegistered() {
+        state.cleanupRegistered = true;
+        state.reclaimCleanupRegistered = true;
+        ensureGlobalExitCleanupRegistered();
     }
-    const kind = await getPathKind(state.canonicalCursor, state.preserveFinalSymlink);
-    return finalizeLexicalResolution(context, kind);
-}
-function resolveRootPathLexicalSync(params) {
-    const context = createLexicalTraversalContext(params);
-    const { state } = context;
-    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 = 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");
-        }
-        const stat = maybeStat;
-        if (!stat) {
-            break;
-        }
-        const disposition = handleLexicalStatDisposition(context, {
-            isSymbolicLink: stat.isSymbolicLink(),
-            segment,
-            isLast,
-        });
-        if (disposition === "continue") {
-            continue;
-        }
-        if (disposition === "break") {
-            break;
-        }
-        const maybeApplied = resolveAndApplySymlinkHop(context, {
-            resolveLinkCanonical: (cursor) => resolveSymlinkHopPathSync(cursor),
+    async function acquire(options) {
+        return await acquireSidecarLock(options, {
+            held: state.held,
+            reclaimGuards: state.reclaimGuards,
+            ensureExitCleanupRegistered,
+            handleForHeldLock: (normalizedTargetPath, held) => handleForHeldLock(state, normalizedTargetPath, held),
+            releaseHeldLock: async (normalizedTargetPath, held, releaseOptions) => await releaseHeldLock(state, normalizedTargetPath, held, releaseOptions),
         });
-        if (isPromiseLike(maybeApplied)) {
-            throw new Error("Unexpected async symlink resolution");
+    }
+    async function withLock(options, fn) {
+        const lock = await acquire(options);
+        let result;
+        try {
+            result = await fn();
         }
-        if (context.resolveParams.rejectSymlinks === true) {
-            throw new FsSafeError("symlink", "symlink path component not allowed");
+        catch (bodyError) {
+            try {
+                await lock.release();
+            }
+            catch (releaseError) {
+                throw createSuppressedError(releaseError, bodyError, "file lock callback and release both failed");
+            }
+            throw bodyError;
         }
+        await lock.release();
+        return result;
     }
-    const kind = getPathKindSync(state.canonicalCursor, state.preserveFinalSymlink);
-    return finalizeLexicalResolution(context, kind);
-}
-function resolveCanonicalOutsideLexicalPath(params) {
-    return params.outsideLexicalCanonicalPath ?? params.absolutePath;
-}
-function createBoundaryResolutionContext(params) {
-    const lexicalInside = path_isPathInside(params.rootPath, params.absolutePath);
-    const canonicalOutsideLexicalPath = resolveCanonicalOutsideLexicalPath({
-        absolutePath: params.absolutePath,
-        outsideLexicalCanonicalPath: params.outsideLexicalCanonicalPath,
-    });
-    assertLexicalBoundaryOrCanonicalAlias({
-        skipLexicalRootCheck: params.resolveParams.skipLexicalRootCheck,
-        lexicalInside,
-        canonicalOutsideLexicalPath,
-        rootCanonicalPath: params.rootCanonicalPath,
-        boundaryLabel: params.resolveParams.boundaryLabel,
-        rootPath: params.rootPath,
-        absolutePath: params.absolutePath,
-    });
-    return {
-        rootPath: params.rootPath,
-        absolutePath: params.absolutePath,
-        rootCanonicalPath: params.rootCanonicalPath,
-        lexicalInside,
-        canonicalOutsideLexicalPath,
-    };
-}
-async function resolveOutsideRootPathAsync(params) {
-    if (params.context.lexicalInside) {
-        return null;
+    async function drain() {
+        for (const [normalizedTargetPath, held] of Array.from(state.held.entries())) {
+            await releaseHeldLock(state, normalizedTargetPath, held, { force: true }).catch(() => undefined);
+        }
     }
-    const kind = await getPathKind(params.context.absolutePath, false);
-    return buildOutsideRootPathFromContext({
-        boundaryLabel: params.boundaryLabel,
-        context: params.context,
-        kind,
-    });
-}
-function resolveOutsideRootPathSync(params) {
-    if (params.context.lexicalInside) {
-        return null;
+    function reset() {
+        releaseAllLocksSync(state);
     }
-    const kind = getPathKindSync(params.context.absolutePath, false);
-    return buildOutsideRootPathFromContext({
-        boundaryLabel: params.boundaryLabel,
-        context: params.context,
-        kind,
-    });
-}
-function buildOutsideRootPathFromContext(params) {
-    return buildOutsideLexicalRootPath({
-        boundaryLabel: params.boundaryLabel,
-        rootCanonicalPath: params.context.rootCanonicalPath,
-        absolutePath: params.context.absolutePath,
-        canonicalOutsideLexicalPath: params.context.canonicalOutsideLexicalPath,
-        rootPath: params.context.rootPath,
-        kind: params.kind,
-    });
-}
-async function resolveOutsideLexicalCanonicalPathAsync(params) {
-    if (path_isPathInside(params.rootPath, params.absolutePath)) {
-        return undefined;
+    function heldEntries() {
+        return Array.from(state.held.entries()).map(([normalizedTargetPath, held]) => ({
+            normalizedTargetPath,
+            lockPath: held.lockPath,
+            acquiredAt: held.acquiredAt,
+            metadata: held.metadata,
+            forceRelease: () => releaseHeldLock(state, normalizedTargetPath, held, { force: true }),
+        }));
     }
-    return await resolvePathViaExistingAncestor(params.absolutePath);
+    return { acquire, withLock, drain, reset, heldEntries };
 }
-function resolveOutsideLexicalCanonicalPathSync(params) {
-    if (isPathInside(params.rootPath, params.absolutePath)) {
-        return undefined;
-    }
-    return resolvePathViaExistingAncestorSync(params.absolutePath);
+async function withSidecarLock(targetPath, options, fn) {
+    const manager = createSidecarLockManager(options.managerKey ?? `fs-safe.sidecar-lock:${targetPath}`);
+    const { managerKey: _managerKey, ...acquireOptions } = options;
+    return await manager.withLock({ ...acquireOptions, targetPath }, fn);
 }
-function buildOutsideLexicalRootPath(params) {
-    assertInsideBoundary({
-        boundaryLabel: params.boundaryLabel,
-        rootCanonicalPath: params.rootCanonicalPath,
-        candidatePath: params.canonicalOutsideLexicalPath,
-        absolutePath: params.absolutePath,
-    });
-    return buildResolvedRootPath({
-        absolutePath: params.absolutePath,
-        canonicalPath: params.canonicalOutsideLexicalPath,
-        rootPath: params.rootPath,
-        rootCanonicalPath: params.rootCanonicalPath,
-        kind: params.kind,
-    });
+
+;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/pinned-write.js
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+function pinned_write_byteLength(input, encoding) {
+    return typeof input === "string"
+        ? Buffer.byteLength(input, encoding ?? "utf8")
+        : input.byteLength;
 }
-function assertLexicalBoundaryOrCanonicalAlias(params) {
-    if (params.skipLexicalRootCheck || params.lexicalInside) {
-        return;
-    }
-    if (path_isPathInside(params.rootCanonicalPath, params.canonicalOutsideLexicalPath)) {
-        return;
+function assertSafeBasename(basename) {
+    if (!basename ||
+        basename === "." ||
+        basename === ".." ||
+        basename.includes("/") ||
+        basename.includes("\0")) {
+        throw new errors_FsSafeError("invalid-path", "invalid target path");
     }
-    throw pathEscapeError({
-        boundaryLabel: params.boundaryLabel,
-        rootPath: params.rootPath,
-        absolutePath: params.absolutePath,
-    });
 }
-function buildResolvedRootPath(params) {
-    return {
-        absolutePath: params.absolutePath,
-        canonicalPath: params.canonicalPath,
-        rootPath: params.rootPath,
-        rootCanonicalPath: params.rootCanonicalPath,
-        relativePath: relativeInsideRoot(params.rootCanonicalPath, params.canonicalPath),
-        exists: params.kind.exists,
-        kind: params.kind.kind,
-    };
+function assertWithinMaxBytes(bytes, maxBytes) {
+    if (maxBytes !== undefined && bytes > maxBytes) {
+        throw new errors_FsSafeError("too-large", `file exceeds limit of ${maxBytes} bytes (got at least ${bytes})`);
+    }
 }
-async function getPathKind(absolutePath, preserveFinalSymlink) {
+async function syncFileBestEffort(handle) {
     try {
-        const stat = preserveFinalSymlink
-            ? await promises_.lstat(absolutePath)
-            : await promises_.stat(absolutePath);
-        return { exists: true, kind: toResolvedKind(stat) };
+        await handle.sync();
     }
     catch (error) {
-        if (path_isNotFoundPathError(error)) {
-            return { exists: false, kind: "missing" };
+        if (error?.code !== "EPERM") {
+            throw error;
         }
-        throw error;
     }
 }
-function getPathKindSync(absolutePath, preserveFinalSymlink) {
-    try {
-        const stat = preserveFinalSymlink ? fs.lstatSync(absolutePath) : fs.statSync(absolutePath);
-        return { exists: true, kind: toResolvedKind(stat) };
-    }
-    catch (error) {
-        if (isNotFoundPathError(error)) {
-            return { exists: false, kind: "missing" };
+async function writeStreamToHandle(stream, handle, maxBytes) {
+    let bytes = 0;
+    for await (const chunk of stream) {
+        const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        bytes += buffer.byteLength;
+        assertWithinMaxBytes(bytes, maxBytes);
+        let offset = 0;
+        while (offset < buffer.byteLength) {
+            const { bytesWritten } = await handle.write(buffer, offset, buffer.byteLength - offset);
+            if (bytesWritten <= 0) {
+                throw new errors_FsSafeError("helper-failed", "fallback stream write made no progress");
+            }
+            offset += bytesWritten;
         }
-        throw error;
     }
 }
-function toResolvedKind(stat) {
-    if (stat.isFile()) {
-        return "file";
+async function runPinnedWriteHelper(params) {
+    const normalizedParams = { ...params, maxBytes: byte_budget_normalizeMaxBytes(params.maxBytes) };
+    assertSafeBasename(params.basename);
+    validatePinnedOperationPayload({
+        relativeParentPath: params.relativeParentPath,
+    });
+    // The explicit compatibility policy uses the guarded Node fallback, where
+    // content verification can replace the strict post-rename inode check.
+    if (normalizedParams.onRenameIdentityMismatch === "verify-content") {
+        return await runPinnedWriteFallback(normalizedParams);
     }
-    if (stat.isDirectory()) {
-        return "directory";
+    const native = getNativeBinding();
+    if (native) {
+        return await runPinnedWriteNative(native, normalizedParams);
     }
-    if (stat.isSymbolicLink()) {
-        return "symlink";
+    return await runPinnedWriteFallback(normalizedParams);
+}
+async function runPinnedWriteWithRenamePolicy(params) {
+    const { targetPath, renameIdentity, ...writeParams } = params;
+    if (renameIdentity !== "verify-content-with-lock") {
+        return await runPinnedWriteHelper(writeParams);
     }
-    return "other";
+    const relativeTargetPath = writeParams.relativeParentPath
+        ? `${writeParams.relativeParentPath}/${writeParams.basename}`
+        : writeParams.basename;
+    const lockPath = external_node_path_.join(writeParams.rootPath, `.fs-safe-write-${sha256Hex(relativeTargetPath)}.lock`);
+    return await withSidecarLock(writeParams.rootPath, {
+        managerKey: `fs-safe.write:${targetPath}`,
+        lockPath,
+        staleMs: 30_000,
+        timeoutMs: 5_000,
+        payload: () => ({ pid: process.pid, createdAt: new Date().toISOString() }),
+        retry: { retries: 5, minTimeout: 100, maxTimeout: 2_000, factor: 2 },
+    }, async () => await runPinnedWriteHelper({
+        ...writeParams,
+        onRenameIdentityMismatch: "verify-content",
+    }));
 }
-function relativeInsideRoot(rootPath, targetPath) {
-    const relative = external_node_path_.relative(external_node_path_.resolve(rootPath), external_node_path_.resolve(targetPath));
-    if (!relative || relative === ".") {
-        return "";
+async function runPinnedWriteFallback(params) {
+    let parentPath = params.relativeParentPath
+        ? external_node_path_.join(params.rootPath, ...params.relativeParentPath.split("/"))
+        : params.rootPath;
+    if (params.mkdir) {
+        // mkdirPathComponentsWithGuards may resolve the final component through
+        // an in-root symlink (e.g. a skill-bank layout). Use its returned real
+        // path for the subsequent guard and target path so we don't re-check the
+        // original, possibly-symlinked, lexical path and reject it outright.
+        parentPath = await mkdirPathComponentsWithGuards({
+            rootReal: params.rootPath,
+            targetPath: parentPath,
+            beforeComponent: async (componentPath) => await getFsSafeTestHooks()?.beforeRootFallbackMutation?.("mkdir", componentPath),
+        });
     }
-    if (isPathRelativeEscape(relative)) {
-        return "";
+    const parentGuard = params.mkdir
+        ? await directory_guard_createAsyncDirectoryGuard(parentPath)
+        : await directory_guard_createNearestExistingDirectoryGuard(params.rootPath, parentPath);
+    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), {
+            onPostGuardFailure: async (openedHandle) => {
+                // The parent failed verification, so targetPath may now resolve
+                // somewhere else. Close the fd, but do not clean up by path.
+                await openedHandle.close().catch(() => undefined);
+            },
+        });
+        let created = true;
+        try {
+            const verificationIdentity = await handle.stat({ bigint: true });
+            await handle.chmod(params.mode);
+            if (params.input.kind === "buffer") {
+                assertWithinMaxBytes(pinned_write_byteLength(params.input.data, params.input.encoding), params.maxBytes);
+                if (typeof params.input.data === "string") {
+                    await handle.writeFile(params.input.data, params.input.encoding ?? "utf8");
+                }
+                else {
+                    await handle.writeFile(params.input.data);
+                }
+            }
+            else {
+                await writeStreamToHandle(params.input.stream, handle, params.maxBytes);
+            }
+            await syncFileBestEffort(handle);
+            const stat = await handle.stat();
+            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);
+            }
+        }
     }
-    return relative;
-}
-function assertInsideBoundary(params) {
-    if (path_isPathInside(params.rootCanonicalPath, params.candidatePath)) {
-        return;
+    // Private staging must not consume the destination basename's filename budget.
+    const tempPath = external_node_path_.join(parentPath, `.fs-safe-${(0,external_node_crypto_.randomUUID)()}.tmp`);
+    const tempFlags = external_node_fs_.constants.O_WRONLY |
+        external_node_fs_.constants.O_CREAT |
+        external_node_fs_.constants.O_EXCL |
+        (process.platform !== "win32" && "O_NOFOLLOW" in external_node_fs_.constants
+            ? external_node_fs_.constants.O_NOFOLLOW
+            : 0);
+    let handle;
+    let tempStat;
+    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);
+        if (params.input.kind === "buffer") {
+            assertWithinMaxBytes(pinned_write_byteLength(params.input.data, params.input.encoding), params.maxBytes);
+            if (typeof params.input.data === "string") {
+                await handle.writeFile(params.input.data, params.input.encoding ?? "utf8");
+            }
+            else {
+                await handle.writeFile(params.input.data);
+            }
+        }
+        else {
+            await writeStreamToHandle(params.input.stream, handle, params.maxBytes);
+        }
+        tempStat = await handle.stat();
+        const tempPathStat = await promises_.lstat(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);
+        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 (targetStat.isSymbolicLink()) {
+                throw new errors_FsSafeError("path-mismatch", "fallback target changed during write");
+            }
+            if (!file_identity_sameFileIdentity(targetStat, expectedTempStat)) {
+                // On filesystems like rclone FUSE, rename(2) can give the destination a
+                // different inode from the source temp fd even with zero concurrency. The
+                // caller must ensure mutual exclusion before passing "verify-content";
+                // fall back to a content hash for this rename-boundary check only.
+                if (params.onRenameIdentityMismatch !== "verify-content") {
+                    throw new errors_FsSafeError("path-mismatch", "fallback target changed during write");
+                }
+                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);
+                readHandle = await promises_.open(targetPath, read_open_flags_resolveReadOpenFlags());
+                const readHandleStat = await readHandle.stat({ bigint: true });
+                const actualHash = sha256Hex(await readHandle.readFile());
+                if (actualHash !== expectedHash) {
+                    throw new errors_FsSafeError("path-mismatch", "fallback target changed during write");
+                }
+                // The content-verified destination, not the old temp inode, is now pinned.
+                verificationIdentity = readHandleStat;
+                // Preserve the helper's legacy numeric return facts, not the private proof.
+                verifiedIdentity = { dev: Number(readHandleStat.dev), ino: Number(readHandleStat.ino) };
+            }
+        });
+        await params.verifyPublished?.((readHandle ?? handle).fd, verificationIdentity, parentGuard);
+        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);
+        }
     }
-    throw new Error(`Path resolves outside ${params.boundaryLabel} (${shortPath(params.rootCanonicalPath)}): ${shortPath(params.absolutePath)}`);
-}
-function pathEscapeError(params) {
-    return new Error(`Path escapes ${params.boundaryLabel} (${shortPath(params.rootPath)}): ${shortPath(params.absolutePath)}`);
-}
-function symlinkEscapeError(params) {
-    return new Error(`Symlink escapes ${params.boundaryLabel} (${shortPath(params.rootCanonicalPath)}): ${shortPath(params.symlinkPath)}`);
 }
 
 ;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/path-policy.js
@@ -42081,56 +42343,6 @@ async function verifyAtomicWriteResult(params) {
     }
 }
 
-;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/strict-file-identity.js
-
-function identityMismatch() {
-    return new errors_FsSafeError("path-mismatch", "file identity changed or could not be verified");
-}
-function identityCheck(expected, platform) {
-    const known = {};
-    const check = (stat) => {
-        let complete = true;
-        for (const field of ["dev", "ino"]) {
-            const value = stat[field];
-            // Numeric receipts cannot recover identity bits already lost to rounding.
-            if (typeof value !== "bigint")
-                throw identityMismatch();
-            if (platform === "win32" && value === 0n) {
-                complete = false;
-            }
-            else {
-                if (known[field] !== undefined && known[field] !== value)
-                    throw identityMismatch();
-                known[field] = value;
-            }
-        }
-        return complete;
-    };
-    if (expected && !check(expected))
-        throw identityMismatch();
-    return check;
-}
-// 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) {
-    const check = identityCheck(expected, platform);
-    for (let attempt = 0; attempt < 2; attempt++) {
-        const stat = await inspect();
-        if (check(stat))
-            return stat;
-    }
-    throw identityMismatch();
-}
-function inspectFileIdentitySync(inspect, expected, platform = process.platform) {
-    const check = identityCheck(expected, platform);
-    for (let attempt = 0; attempt < 2; attempt++) {
-        const stat = inspect();
-        if (check(stat))
-            return stat;
-    }
-    throw identityMismatch();
-}
-
 ;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/root-impl.js
 
 
@@ -42161,6 +42373,7 @@ function inspectFileIdentitySync(inspect, expected, platform = process.platform)
 
 
 
+
 
 
 function logWarn(message) {
@@ -42236,25 +42449,15 @@ async function openVerifiedLocalFile(filePath, options) {
     if (preOpenStat) {
         await fsSafeTestHooks?.afterPreOpenLstat?.(filePath);
     }
+    const openFlags = options?.symlinks === "follow-within-root"
+        ? OPEN_READ_FOLLOW_FLAGS
+        : OPEN_READ_FLAGS;
+    await fsSafeTestHooks?.beforeOpen?.(filePath, openFlags);
     let handle;
     try {
-        const openFlags = options?.symlinks === "follow-within-root"
-            ? OPEN_READ_FOLLOW_FLAGS
-            : OPEN_READ_FLAGS;
-        await fsSafeTestHooks?.beforeOpen?.(filePath, openFlags);
-        handle = await promises_.open(filePath, openFlags);
-        try {
-            await fsSafeTestHooks?.afterOpen?.(filePath, handle);
-        }
-        catch (err) {
-            await handle.close().catch(() => { });
-            throw err;
-        }
+        handle = await promises_.open(filePath, openFlags).catch((error) => recordFileOpenFailure(path_isNotFoundPathError(error) ? fileNotFoundError() : error, filePath));
     }
     catch (err) {
-        if (path_isNotFoundPathError(err)) {
-            throw fileNotFoundError();
-        }
         if (isSymlinkOpenError(err)) {
             throw new errors_FsSafeError("symlink", "symlink open blocked", { cause: err });
         }
@@ -42265,16 +42468,35 @@ async function openVerifiedLocalFile(filePath, options) {
         throw err;
     }
     try {
+        await fsSafeTestHooks?.afterOpen?.(filePath, handle);
         const stat = await handle.stat();
         if (!stat.isFile()) {
             throw new errors_FsSafeError("not-file", "not a file");
         }
         // Keep numeric Stats for the public receipt, never for identity verification.
-        const identity = await inspectFileIdentity(() => handle.stat({ bigint: true }), preOpenStat && !preOpenStat.isSymbolicLink() ? preOpenStat : undefined);
+        let openedIdentity;
+        const identity = await inspectFileIdentity(async () => (openedIdentity = await handle.stat({ bigint: true })), preOpenStat && !preOpenStat.isSymbolicLink() ? preOpenStat : undefined).catch(async (error) => {
+            if ([0, 1].includes(stat.nlink)) {
+                await recordPreOpenFileChange(error, handle, filePath, preOpenStat, openedIdentity);
+            }
+            throw error;
+        });
         if (options?.hardlinks === "reject" && stat.nlink > 1) {
             throw hardlinkedPathNotAllowedError();
         }
-        await inspectFileIdentity(async () => {
+        const inspectPathIdentity = async (inspect) => {
+            try {
+                return await inspectFileIdentity(inspect, identity);
+            }
+            catch (error) {
+                const failure = path_isNotFoundPathError(error) ? openedPathResolutionError(fileNotFoundError()) : error;
+                if (stat.nlink <= 1 && (!preOpenStat || preOpenStat.nlink <= 1n)) {
+                    await recordOpenedFileFailure(failure, handle, filePath, identity);
+                }
+                throw failure;
+            }
+        };
+        await inspectPathIdentity(async () => {
             const pathStat = options?.symlinks === "follow-within-root"
                 ? await promises_.stat(filePath, { bigint: true })
                 : await promises_.lstat(filePath, { bigint: true });
@@ -42282,26 +42504,26 @@ async function openVerifiedLocalFile(filePath, options) {
                 throw new errors_FsSafeError("symlink", "symlink not allowed");
             }
             return pathStat;
-        }, identity);
+        });
         await fsSafeTestHooks?.afterOpenedPathIdentityCheck?.(filePath, handle);
-        const realPath = await resolveOpenedFileRealPathForFd(handle.fd, identity, filePath);
-        await inspectFileIdentity(async () => {
+        const realPath = 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;
+        });
+        await inspectPathIdentity(async () => {
             const realStat = await promises_.stat(realPath, { bigint: true });
             if (options?.hardlinks === "reject" && realStat.nlink > 1n) {
                 throw hardlinkedPathNotAllowedError();
             }
             return realStat;
-        }, identity);
+        });
         return { opened: openResult({ handle, realPath, stat }), identity };
     }
     catch (err) {
         await handle.close().catch(() => { });
-        if (err instanceof errors_FsSafeError) {
-            throw err;
-        }
-        if (path_isNotFoundPathError(err)) {
-            throw fileNotFoundError();
-        }
         throw err;
     }
 }
@@ -42530,19 +42752,10 @@ async function openFileInRoot(root, params) {
         rejectUnsafeDeviceReads: true,
         rejectSymlinks: params.symlinks !== "follow-within-root",
     });
-    let opened;
-    try {
-        ({ opened } = await openVerifiedLocalFile(resolved, {
-            nonBlockingRead: params.nonBlockingRead,
-            symlinks: params.symlinks,
-        }));
-    }
-    catch (err) {
-        if (err instanceof errors_FsSafeError) {
-            throw err;
-        }
-        throw err;
-    }
+    const { opened } = await openVerifiedLocalFile(resolved, {
+        nonBlockingRead: params.nonBlockingRead,
+        symlinks: params.symlinks,
+    });
     if (params.hardlinks !== "allow" && opened.stat.nlink > 1) {
         await opened.handle.close().catch(() => { });
         throw hardlinkedPathNotAllowedError();
@@ -42594,9 +42807,7 @@ function emitWriteBoundaryWarning(reason) {
     logWarn(`security: fs-safe write boundary warning (${reason})`);
 }
 function buildAtomicWriteTempPath(targetPath) {
-    const dir = external_node_path_.dirname(targetPath);
-    const base = external_node_path_.basename(targetPath);
-    return external_node_path_.join(dir, `.${base}.${process.pid}.${(0,external_node_crypto_.randomUUID)()}.tmp`);
+    return external_node_path_.join(external_node_path_.dirname(targetPath), `.fs-safe-${(0,external_node_crypto_.randomUUID)()}.tmp`);
 }
 function rootWriteQueueKey(root, relativePath) {
     return `${root.rootReal}\0${relativePath}`;
@@ -42835,7 +43046,7 @@ async function writeFileInRoot(root, params) {
             await writeFileFallback(root, params);
             return;
         }
-        const pinned = await resolvePinnedWriteTargetInRoot(root, params.relativePath, params.mode, params.denyMutations);
+        const pinned = await resolvePinnedWriteTargetInRoot(root, params.relativePath, params.mode, params.denyMutations, params.overwrite);
         await serializePathWrite(pinned.targetPath, async () => {
             await commitPinnedWriteInRoot(root, pinned, params);
         });
@@ -42957,7 +43168,7 @@ async function removePathIfIdentityUnchanged(targetPath, identity) {
         await promises_.rm(targetPath);
     });
 }
-async function resolvePinnedWriteTargetInRoot(root, relativePath, requestedMode, denyMutations) {
+async function resolvePinnedWriteTargetInRoot(root, relativePath, requestedMode, denyMutations, overwrite = true) {
     const { rootReal, rootWithSep, resolved } = await resolveGuardedWritePathInRoot(root, {
         relativePath,
         denyMutations,
@@ -42975,22 +43186,40 @@ async function resolvePinnedWriteTargetInRoot(root, relativePath, requestedMode,
     if (!basename || basename === "." || basename === "/") {
         throw new errors_FsSafeError("invalid-path", "invalid target path");
     }
+    // Exclusive publication cannot inherit an existing file's mode. Keep type
+    // and alias checks, but never open a competing owner's record just to reject it.
+    if (!overwrite) {
+        try {
+            const existing = await promises_.stat(resolved);
+            if (!existing.isFile())
+                throw new errors_FsSafeError("not-file", "not a file");
+            if (existing.nlink > 1)
+                throw hardlinkedPathNotAllowedError();
+            throw new errors_FsSafeError("already-exists", "file already exists");
+        }
+        catch (error) {
+            if (!path_isNotFoundPathError(error))
+                throw error;
+        }
+    }
     let mode = requestedMode ?? 0o600;
     try {
-        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();
+        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(() => { });
             }
-        }
-        finally {
-            await opened.handle.close().catch(() => { });
         }
     }
     catch (err) {
@@ -91840,4 +92069,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__(836);
+var __webpack_exports__ = __webpack_require__(3829);