@openclaw/openshell-sandbox 2026.10.1-beta.2 → 2026.10.5-beta.1

package/node_modules/@openclaw/fs-safe/dist/copy-path-admission.js

@@ -0,0 +1,117 @@
+import fs from "node:fs";
+import path from "node:path";
+import { assertSyncDirectoryGuard, captureDirectoryGuard, inspectDirectoryIdentitySync } from "./directory-guard.js";
+import { FsSafeError } from "./errors.js";
+import { sameFileIdentity } from "./file-identity.js";
+import { realpathSync } from "./realpath.js";
+import { resolveRootPathSync, ROOT_PATH_ALIAS_POLICIES } from "./root-path.js";
+function admitUncachedCopyPath(input, create = false, admittedRoot) {
+    if (!path.isAbsolute(input.rootPath) || !path.isAbsolute(input.absolutePath)) {
+        throw new FsSafeError("invalid-path", "copy roots and paths must be absolute");
+    }
+    const root = admittedRoot ?? captureDirectoryGuard(realpathSync(input.rootPath), "native", { bigint: true });
+    // Canonical POSIX callers already own a freshly checked root. Keep the
+    // resolver's lexical/symlink walk, but do not rediscover that root each time.
+    const rootCanonicalPath = admittedRoot?.realPath;
+    const resolve = () => {
+        const parent = create ? resolveRootPathSync({
+            ...input, rootCanonicalPath, absolutePath: path.dirname(input.absolutePath), boundaryLabel: "copy parent",
+            rejectSymlinks: true, rejectFinalSymlink: true,
+        }) : undefined;
+        const selected = resolveRootPathSync({
+            ...input, rootCanonicalPath, boundaryLabel: "copy", rejectSymlinks: !create, rejectFinalSymlink: !create,
+            policy: create ? ROOT_PATH_ALIAS_POLICIES.unlinkTarget : undefined,
+        });
+        if (parent && path.dirname(selected.canonicalPath) !== parent.canonicalPath) {
+            throw new FsSafeError("path-mismatch", "copy destination parent changed");
+        }
+        return selected;
+    };
+    const selected = resolve();
+    const parent = captureDirectoryGuard(path.dirname(selected.canonicalPath), "native", { bigint: true });
+    const assertCurrent = () => {
+        assertSyncDirectoryGuard(root);
+        assertSyncDirectoryGuard(parent);
+        const current = resolve();
+        if (current.rootCanonicalPath !== root.realPath || current.canonicalPath !== selected.canonicalPath) {
+            throw new FsSafeError("path-mismatch", "copy path changed during operation");
+        }
+        assertSyncDirectoryGuard(root);
+        assertSyncDirectoryGuard(parent);
+    };
+    assertCurrent();
+    return { path: selected.canonicalPath, parent, assertCurrent, rootCanonicalPath: undefined };
+}
+/** Metadata custody lasts only for the owning copy or explicit batch. */
+export function createCopyPathAdmissionCache() {
+    const roots = new Map();
+    const parents = new Map();
+    const directories = new Map();
+    const assertParent = ({ root, parent, chain }) => {
+        assertSyncDirectoryGuard(root);
+        for (const guard of chain) {
+            inspectDirectoryIdentitySync(guard.dir, { dev: BigInt(guard.stat.dev), ino: BigInt(guard.stat.ino) });
+        }
+        assertSyncDirectoryGuard(parent);
+        assertSyncDirectoryGuard(root);
+    };
+    const admit = (input, create = false) => {
+        // Keep the public resolver for Windows aliases and noncanonical spellings,
+        // including raw dot segments whose traversal must not be normalized away.
+        if (process.platform === "win32" || !path.isAbsolute(input.rootPath) ||
+            !path.isAbsolute(input.absolutePath) || input.rootPath.includes("\0") || input.absolutePath.includes("\0") ||
+            path.resolve(input.rootPath) !== input.rootPath || path.resolve(input.absolutePath) !== input.absolutePath ||
+            !input.absolutePath.startsWith(input.rootPath.endsWith(path.sep) ? input.rootPath : `${input.rootPath}${path.sep}`)) {
+            return admitUncachedCopyPath(input, create);
+        }
+        let root = roots.get(input.rootPath);
+        if (!root) {
+            const canonical = realpathSync(input.rootPath);
+            if (canonical !== input.rootPath)
+                return admitUncachedCopyPath(input, create);
+            root = captureDirectoryGuard(canonical, "native", { bigint: true });
+            roots.set(input.rootPath, root);
+        }
+        assertSyncDirectoryGuard(root);
+        const parentPath = path.dirname(input.absolutePath);
+        let byParent = parents.get(input.rootPath);
+        let admitted = byParent?.get(parentPath);
+        if (!admitted) {
+            // The first file in each parent retains the existing lexical admission.
+            const selected = admitUncachedCopyPath(input, create, root);
+            const chain = [];
+            let cursor = input.rootPath;
+            const relative = path.relative(input.rootPath, parentPath);
+            for (const segment of relative ? relative.split(path.sep) : []) {
+                cursor = path.join(cursor, segment);
+                let guard = directories.get(cursor);
+                if (!guard) {
+                    guard = captureDirectoryGuard(cursor, "native", { bigint: true });
+                    directories.set(cursor, guard);
+                }
+                chain.push(guard);
+            }
+            admitted = { root, parent: chain.at(-1) ?? root, chain };
+            assertParent(admitted);
+            if (selected.path !== input.absolutePath || selected.parent.realPath !== parentPath ||
+                !sameFileIdentity(selected.parent.stat, admitted.parent.stat)) {
+                throw new FsSafeError("path-mismatch", "copy path changed during admission");
+            }
+            byParent ??= new Map();
+            byParent.set(parentPath, admitted);
+            parents.set(input.rootPath, byParent);
+        }
+        const selected = admitted;
+        const assertCurrent = () => {
+            assertParent(selected);
+            // No file observation is cached. Preserve the resolver's symlink errors.
+            if (!create && fs.lstatSync(input.absolutePath, { throwIfNoEntry: false })?.isSymbolicLink()) {
+                admitUncachedCopyPath(input, create);
+                throw new FsSafeError("symlink", "symlink not allowed");
+            }
+        };
+        assertCurrent();
+        return { path: input.absolutePath, parent: selected.parent, assertCurrent, rootCanonicalPath: selected.root.realPath };
+    };
+    return { admit, clear() { roots.clear(); parents.clear(); directories.clear(); } };
+}

package/node_modules/@openclaw/fs-safe/dist/copy-root-file-sync.d.ts

@@ -0,0 +1,38 @@
+import { type CopyPath } from "./copy-path-admission.js";
+import { type CopyCloneMode } from "./copy-policy.js";
+import { type OwnedFileDescriptorSync } from "./create-owned-file.js";
+export type CopyRootFileSyncOptions = {
+    source: CopyPath;
+    destination: CopyPath;
+    expectedSourceIdentity?: {
+        dev: bigint;
+        ino: bigint;
+    };
+    clone?: CopyCloneMode;
+    maxBytes?: number;
+    mode?: number;
+    preserveSourceMode?: boolean;
+    sourceHardlinks?: "reject" | "allow";
+};
+export type CopiedRootFileSync = OwnedFileDescriptorSync & Readonly<{
+    path: string;
+    bytes: number;
+    method: "clone" | "copy-file-range" | "copy";
+    identity: Readonly<{
+        dev: bigint;
+        ino: bigint;
+    }>;
+    sourceIdentity: Readonly<{
+        dev: bigint;
+        ino: bigint;
+    }>;
+}>;
+/** Exclusively copies an admitted source and transfers the owned destination fd. */
+export declare function copyRootFileSync(options: CopyRootFileSyncOptions): CopiedRootFileSync;
+export type RootFileCopyBatchSync = {
+    copyFile(options: CopyRootFileSyncOptions): CopiedRootFileSync;
+    close(): void;
+    [Symbol.dispose](): void;
+};
+/** Reuses directory admissions while retaining fresh checks for every copy. */
+export declare function createRootFileCopyBatchSync(): RootFileCopyBatchSync;

package/node_modules/@openclaw/fs-safe/dist/copy-root-file-sync.js

@@ -0,0 +1,195 @@
+import fs, {} from "node:fs";
+import path from "node:path";
+import { normalizeMaxBytes } from "./byte-budget.js";
+import { createCopyPathAdmissionCache } from "./copy-path-admission.js";
+import { resolveCopyCloneMode } from "./copy-policy.js";
+import { createFileWithAdmissionSync } from "./create.js";
+import { ownFileDescriptorSync } from "./create-owned-file.js";
+import { creationAdmissionFromParent, removeRecordedCreationFileSync } from "./creation-boundary.js";
+import { FsSafeError } from "./errors.js";
+import { assertExclusiveCreateLeaf } from "./exclusive-create.js";
+import { copyFileDescriptorSync } from "./file-handle-transfer.js";
+import { captureNativeFdClose } from "./native-binding.js";
+import { getNativeBinding } from "./native.js";
+import { openRootFileSync } from "./root-file.js";
+import { inspectOpenedPathIdentitySync } from "./root-read-admission.js";
+import { openStagedDirectory } from "./staged-directory.js";
+import { inspectFileIdentitySync } from "./strict-file-identity.js";
+function copyError(error) {
+    if (error instanceof FsSafeError)
+        return error;
+    const code = error?.code;
+    return new FsSafeError(code === "EEXIST" ? "already-exists" : code === "ENOENT" ? "not-found" :
+        code === "too-large" ? "too-large" :
+            ["ENOTSUP", "EOPNOTSUPP", "ENOSYS", "EXDEV", "EINVAL"].includes(code ?? "")
+                ? "unsupported-platform" : "helper-failed", "guarded synchronous file copy failed", { cause: error });
+}
+/** Exclusively copies an admitted source and transfers the owned destination fd. */
+export function copyRootFileSync(options) {
+    return copyRootFileWithAdmissionSync(options, createCopyPathAdmissionCache());
+}
+/** Reuses directory admissions while retaining fresh checks for every copy. */
+export function createRootFileCopyBatchSync() {
+    const cache = createCopyPathAdmissionCache();
+    let closed = false;
+    const close = () => { closed = true; cache.clear(); };
+    return Object.freeze({
+        copyFile(options) {
+            if (closed)
+                throw new FsSafeError("invalid-path", "copy batch is closed");
+            return copyRootFileWithAdmissionSync(options, cache);
+        },
+        close,
+        [Symbol.dispose]: close,
+    });
+}
+function copyRootFileWithAdmissionSync(options, cache) {
+    // Snapshot caller options before the first filesystem observation.
+    const sourceInput = options.source;
+    const sourcePath = { rootPath: sourceInput.rootPath, absolutePath: sourceInput.absolutePath };
+    const targetInput = options.destination;
+    const targetPath = { rootPath: targetInput.rootPath, absolutePath: targetInput.absolutePath };
+    const expectedInput = options.expectedSourceIdentity;
+    const expectedSourceIdentity = expectedInput === undefined ? undefined : { dev: expectedInput.dev, ino: expectedInput.ino };
+    const clone = resolveCopyCloneMode(options.clone, "never");
+    const maxBytes = normalizeMaxBytes(options.maxBytes);
+    const mode = options.mode;
+    const preserveSourceMode = options.preserveSourceMode;
+    const sourceHardlinks = options.sourceHardlinks ?? "reject";
+    if (mode !== undefined && (!Number.isInteger(mode) || mode < 0 || mode > 0o777)) {
+        throw new FsSafeError("invalid-path", "copy mode must be an integer from 0 to 0o777");
+    }
+    if (sourceHardlinks !== "allow" && sourceHardlinks !== "reject") {
+        throw new FsSafeError("invalid-path", "invalid copy source hardlink policy");
+    }
+    let sourceOwner;
+    let targetOwner;
+    let parentOwner;
+    let parentOpen = false;
+    let target;
+    let identity;
+    const native = getNativeBinding();
+    const nativeCopy = process.platform !== "win32" && native?.copyFileExclusiveSync && native.removeStagedFile
+        ? native.copyFileExclusiveSync.bind(native) : undefined;
+    try {
+        const source = cache.admit(sourcePath);
+        target = cache.admit(targetPath, true);
+        // Preserve exclusive-create collision semantics for dangling Windows leaves.
+        assertExclusiveCreateLeaf(targetPath.absolutePath);
+        if (fs.lstatSync(target.path, { throwIfNoEntry: false })) {
+            throw new FsSafeError("already-exists", "copy destination already exists");
+        }
+        const opened = openRootFileSync({
+            ...sourcePath, rootRealPath: source.rootCanonicalPath, boundaryLabel: "copy source", maxBytes,
+            rejectHardlinks: sourceHardlinks !== "allow",
+        });
+        if (!opened.ok)
+            throw opened.error ?? new FsSafeError("helper-failed", "copy source admission failed");
+        sourceOwner = ownFileDescriptorSync(opened.fd);
+        const sourceIdentity = inspectFileIdentitySync(() => fs.fstatSync(opened.fd, { bigint: true }), expectedSourceIdentity);
+        const verifySource = () => {
+            source.assertCurrent();
+            for (const inspect of [
+                () => fs.fstatSync(opened.fd, { bigint: true }),
+                () => inspectOpenedPathIdentitySync(source.path, undefined),
+            ]) {
+                const current = inspectFileIdentitySync(inspect, sourceIdentity);
+                if (!current.isFile())
+                    throw new FsSafeError("not-file", "copy source must be a regular file");
+                if (sourceHardlinks !== "allow" && current.nlink > 1n) {
+                    throw new FsSafeError("hardlink", "copy source must not be hardlinked");
+                }
+            }
+        };
+        const selectedMode = mode ?? (preserveSourceMode ? Number(sourceIdentity.mode & 511n) : 0o600 & ~process.umask());
+        let copied;
+        verifySource();
+        target.assertCurrent();
+        if (nativeCopy) {
+            const closeNative = captureNativeFdClose(native);
+            const parent = openStagedDirectory(target.parent.realPath);
+            parentOwner = ownFileDescriptorSync(parent.fd);
+            parentOpen = true;
+            inspectFileIdentitySync(() => fs.fstatSync(parent.fd, { bigint: true }), { dev: BigInt(target.parent.stat.dev), ino: BigInt(target.parent.stat.ino) });
+            target.assertCurrent();
+            copied = nativeCopy(opened.fd, parent.fd, path.basename(target.path), clone, maxBytes !== undefined && Number.isFinite(maxBytes) ? maxBytes : undefined);
+            targetOwner = ownFileDescriptorSync(copied.fd, closeNative);
+        }
+        else {
+            if (clone === "always")
+                throw new FsSafeError("unsupported-platform", "synchronous native file cloning is unavailable");
+            targetOwner = createFileWithAdmissionSync(target.path, { mode: 0o600, assertBeforeMutation: target.assertCurrent }, creationAdmissionFromParent(target.parent));
+        }
+        identity = inspectFileIdentitySync(() => fs.fstatSync(targetOwner.fd, { bigint: true }));
+        const verifyTarget = () => {
+            target.assertCurrent();
+            const current = inspectFileIdentitySync(() => fs.fstatSync(targetOwner.fd, { bigint: true }), identity);
+            const named = inspectFileIdentitySync(() => inspectOpenedPathIdentitySync(target.path, undefined), identity);
+            if (!current.isFile() || current.nlink !== 1n || !named.isFile() || named.nlink !== 1n) {
+                throw new FsSafeError("path-mismatch", "copy destination changed");
+            }
+            return current;
+        };
+        verifyTarget();
+        if (copied?.errorCode) {
+            throw copyError(Object.assign(new Error(copied.errorMessage), { code: copied.errorCode }));
+        }
+        const method = copied ? copied.method : "copy";
+        if (method !== "clone" && method !== "copy-file-range" && method !== "copy") {
+            throw new FsSafeError("helper-failed", "native copy returned an unknown method");
+        }
+        if (!copied) {
+            copyFileDescriptorSync(opened.fd, targetOwner.fd, { maxBytes });
+        }
+        verifySource();
+        const completed = verifyTarget();
+        if (maxBytes !== undefined && Number.isFinite(maxBytes) && completed.size > BigInt(maxBytes)) {
+            throw new FsSafeError("too-large", "copy exceeds maxBytes");
+        }
+        fs.fchmodSync(targetOwner.fd, selectedMode);
+        verifySource();
+        verifyTarget();
+        sourceOwner.close();
+        parentOpen = false;
+        parentOwner?.close();
+        return Object.freeze({
+            ...targetOwner, path: target.path, bytes: Number(completed.size), method,
+            identity: Object.freeze({ dev: identity.dev, ino: identity.ino }),
+            sourceIdentity: Object.freeze({ dev: sourceIdentity.dev, ino: sourceIdentity.ino }),
+        });
+    }
+    catch (error) {
+        const primary = copyError(error);
+        const cleanup = [];
+        if (targetOwner && target) {
+            try {
+                if (parentOpen) {
+                    const removed = native.removeStagedFile(parentOwner.fd, path.basename(target.path), targetOwner.fd);
+                    if (removed === "preserved")
+                        throw new FsSafeError("path-mismatch", "copy cleanup preserved a replacement");
+                }
+                else if (identity) {
+                    removeRecordedCreationFileSync(target.path, identity, target.assertCurrent);
+                }
+            }
+            catch (failure) {
+                cleanup.push(failure);
+            }
+        }
+        for (const owner of [targetOwner, sourceOwner, parentOwner]) {
+            try {
+                owner?.close();
+            }
+            catch (failure) {
+                cleanup.push(failure);
+            }
+        }
+        if (cleanup.length) {
+            throw new FsSafeError(primary.code, primary.message, {
+                cause: new AggregateError([primary, ...cleanup], "copy and cleanup failed"),
+                details: { path: target?.path, cleanup: "failed" },
+            });
+        }
+        throw primary;
+    }
+}

package/node_modules/@openclaw/fs-safe/dist/create.d.ts

@@ -4,6 +4,7 @@ import { type CreationPermissions, type CreationParentIdentity } from "./creatio
 export type { OwnedFileDescriptorSync } from "./create-owned-file.js";
 export type CreateFileOptions = CreateDirectoryOptions;
 export declare function createFileSync(targetPath: string, options?: CreateFileOptions): OwnedFileDescriptorSync;
+export declare function createFileWithAdmissionSync(targetPath: string, options?: CreateFileOptions, admission?: CreationAdmission): OwnedFileDescriptorSync;
 /** Internal async writer; Windows preparation uses the nonblocking stage owner. */
 export declare function createFileHandle(targetPath: string, options?: CreateFileOptions, admission?: CreationAdmission): Promise<FileHandle>;
 export type CreateDirectoryOptions = CreationPermissions & {

package/node_modules/@openclaw/fs-safe/dist/create.js

@@ -108,9 +108,12 @@ function createPrivateWindowsFile(selected, options, mode) {
     }
 }
 export function createFileSync(targetPath, options = {}) {
+    return createFileWithAdmissionSync(targetPath, options);
+}
+export function createFileWithAdmissionSync(targetPath, options = {}, admission = {}) {
     const permissions = resolveCreationPermissions(options, false);
     const assertion = options.assertBeforeMutation;
-    const selected = prepareCreationPath(targetPath);
+    const selected = prepareCreationPath(targetPath, admission.expectedParentIdentity);
     if (permissions.private && process.platform === "win32") {
         assertPrivateFileCreationAvailable();
         return createPrivateWindowsFile(selected, { ...permissions, assertBeforeMutation: assertion }, permissions.mode);

package/node_modules/@openclaw/fs-safe/dist/entry-publication.js

@@ -2,6 +2,7 @@ import fs, {} from "node:fs";
 import path from "node:path";
 import { assertDirectoryIdentitySync } from "./directory-guard.js";
 import { FsSafeError } from "./errors.js";
+import { noReplaceUnavailable } from "./native-noreplace.js";
 import { assertSynchronousCallbackResult } from "./mutation-authority.js";
 import { captureNativeFdClose } from "./native-binding.js";
 import { requireNativeBinding } from "./native.js";
@@ -120,7 +121,8 @@ class Publication {
             }
             transition = native.outcome; // Capture BEFORE diagnostics, observations or close.
             if (native.errorCode || transition !== "committed") {
-                throw Object.assign(new Error(native.errorMessage ?? "entry publication did not commit"), { code: native.errorCode ?? "helper-failed" });
+                const error = Object.assign(new Error(native.errorMessage ?? "entry publication did not commit"), { code: native.errorCode ?? "helper-failed" });
+                throw noReplaceUnavailable(error, "retained entry publication") ?? error;
             }
             phase = "postcheck";
             verification = "failed";

package/node_modules/@openclaw/fs-safe/dist/errors.d.ts

@@ -12,4 +12,6 @@ export declare class FsSafeError extends Error {
         details?: FsSafeErrorDetails;
     });
 }
+/** A rejected no-replace rename capability, not a generic missing native helper. */
+export declare function isNoReplaceUnsupported(error: unknown): error is FsSafeError;
 export {};

package/node_modules/@openclaw/fs-safe/dist/errors.js

@@ -25,3 +25,8 @@ export class FsSafeError extends Error {
         this.details = options.details;
     }
 }
+/** A rejected no-replace rename capability, not a generic missing native helper. */
+export function isNoReplaceUnsupported(error) {
+    return error instanceof FsSafeError && error.code === "helper-unavailable" &&
+        error.details?.capability === "rename-noreplace";
+}

package/node_modules/@openclaw/fs-safe/dist/file-lock-sync-root-acquire.d.ts

@@ -1,3 +1,6 @@
 import type { FileLockSyncAcquireOptions, FileLockSyncHandle } from "./file-lock-sync.js";
 import type { Root } from "./root-impl.js";
+import { type FileLockSyncRootPath } from "./file-lock-sync-root.js";
+import { type FileLockSyncRootFileReceipt } from "./file-lock-sync-root-io.js";
+export declare function cleanupCreatedRootSyncLock(lockRootPath: FileLockSyncRootPath, fd: number, receipt: FileLockSyncRootFileReceipt, timer?: NodeJS.Timeout): void;
 export declare function acquireFileLockSyncWithRoot<TPayload extends Record<string, unknown>>(targetPath: string, inputOptions: FileLockSyncAcquireOptions<TPayload>, lockRoot: Root): FileLockSyncHandle;

package/node_modules/@openclaw/fs-safe/dist/file-lock-sync-root-acquire.js

@@ -10,10 +10,40 @@ import { SyncLockAcquisition } from "./file-lock-sync-acquisition.js";
 import { assertSynchronousCallbackResult } from "./mutation-authority.js";
 import { assertNoWindowsPathAlias } from "./windows-path-alias.js";
 import { admitFileLockSyncRootPath, assertFileLockSyncRootPathsCurrent, captureFileLockSyncRootAuthority, normalizeFileLockSyncTargetWithRoot, } from "./file-lock-sync-root.js";
-import { cleanupCreatedRootSyncLock, FileLockSyncRootArbitrationCollision, tryReuseCurrentRootSyncHeldLock, } from "./file-lock-sync-root-arbitration.js";
 import { fileLockSyncRootSnapshotStillCurrent, } from "./file-lock-sync-root-io.js";
 import { createFileLockSyncRootDirectory, createFileLockSyncRootFile, fileLockSyncRootGuardExists, fileLockSyncRootDirectoryReceiptStillCurrent, refreshFileLockSyncRootFileReceipt, removeFileLockSyncRootDirectory, removeFileLockSyncRootFile, } from "./file-lock-sync-root-mutation.js";
-import { createRootSyncHeldLockHandle, ensureRootSyncExitCleanupRegistered, getRootSyncHeldLocks, readRootSidecarSnapshotSync, } from "./file-lock-sync-root-held.js";
+import { createRootSyncHeldLockHandle, ensureRootSyncExitCleanupRegistered, getRootSyncHeldLocks, readRootSidecarSnapshotSync, verifyRootSyncHeldLock, } from "./file-lock-sync-root-held.js";
+class FileLockSyncRootArbitrationCollision extends FsSafeError {
+    constructor() {
+        super("path-mismatch", "file lock arbitration changed during local creation");
+    }
+}
+export function cleanupCreatedRootSyncLock(lockRootPath, fd, receipt, timer) {
+    let timerCleanupFailed = false;
+    let timerCleanupError;
+    try {
+        if (timer)
+            clearInterval(timer);
+    }
+    catch (error) {
+        timerCleanupFailed = true;
+        timerCleanupError = error;
+    }
+    try {
+        fs.closeSync(fd);
+        if (!removeFileLockSyncRootFile(lockRootPath, receipt)) {
+            throw new FsSafeError("path-mismatch", "created sidecar lock changed before cleanup");
+        }
+    }
+    catch (fileCleanupError) {
+        if (timerCleanupFailed) {
+            throw createSuppressedError(timerCleanupError, fileCleanupError, "unpublished lock timer and file cleanup both failed");
+        }
+        throw fileCleanupError;
+    }
+    if (timerCleanupFailed)
+        throw timerCleanupError;
+}
 export function acquireFileLockSyncWithRoot(targetPath, inputOptions, lockRoot) {
     // The public dispatcher already read lockRoot exactly once. Validate and
     // snapshot that genuine Root before any remaining option or retry getter can
@@ -37,23 +67,39 @@ export function acquireFileLockSyncWithRoot(targetPath, inputOptions, lockRoot)
     const heldLocks = getRootSyncHeldLocks();
     const currentTargetHolder = () => heldLocks.get(normalizedTargetPath) ??
         foreignSyncHeldLock("root", normalizedTargetPath);
-    const arbitration = Object.freeze({
-        authority,
-        heldLocks,
-        lockRootPath,
-        normalizedTargetPath,
-        reentrantOwner: options.reentrantOwner,
-    });
+    const tryReuseCurrentHeld = () => {
+        const held = heldLocks.get(normalizedTargetPath);
+        const reusable = held && !foreignSyncHeldLock("root", normalizedTargetPath) &&
+            options.reentrantOwner !== undefined && held.reentrantOwner !== undefined &&
+            options.reentrantOwner === held.reentrantOwner &&
+            authority.adapter === held.rootAuthority.adapter &&
+            lockRootPath.relativePath === held.rootPath.relativePath &&
+            path.relative(lockRootPath.path, held.rootPath.path) === "" &&
+            held.releaseState !== "released";
+        if (!reusable)
+            return undefined;
+        if (!verifyRootSyncHeldLock(held)) {
+            throw new FsSafeError("path-mismatch", "held sidecar lock changed before reentrant reuse");
+        }
+        // The parser can reenter acquisition; recheck the exact held entry before reuse.
+        if (heldLocks.get(normalizedTargetPath) !== held || held.releaseState === "released" ||
+            foreignSyncHeldLock("root", normalizedTargetPath)) {
+            throw new FsSafeError("path-mismatch", "held sidecar lock changed during reentrant reuse");
+        }
+        held.refCount += 1;
+        held.revision += 1;
+        return createRootSyncHeldLockHandle(held);
+    };
     if (heldLocks.has(normalizedTargetPath) && !foreignSyncHeldLock("root", normalizedTargetPath)) {
         assertFileLockSyncRootPathsCurrent(guardedPaths);
-        const initiallyReusable = tryReuseCurrentRootSyncHeldLock(arbitration);
+        const initiallyReusable = tryReuseCurrentHeld();
         if (initiallyReusable)
             return initiallyReusable;
     }
     const acquisition = new SyncLockAcquisition(lockPath, normalizedTargetPath, options.retry, options.timeoutMs);
     let ownedReclaimGuard;
     let reclaimCleanupAttempted = false;
-    const reuseCurrentHeld = () => ownedReclaimGuard ? undefined : tryReuseCurrentRootSyncHeldLock(arbitration);
+    const reuseCurrentHeld = () => ownedReclaimGuard ? undefined : tryReuseCurrentHeld();
     const releaseReclaimGuard = () => {
         const receipt = ownedReclaimGuard;
         if (!receipt)

package/node_modules/@openclaw/fs-safe/dist/guarded-mutation.js

@@ -1,16 +1,16 @@
 import fsSync, {} from "node:fs";
 import fs from "node:fs/promises";
 import path from "node:path";
-import { assertAsyncDirectoryGuard, assertSyncDirectoryGuard, createAsyncDirectoryGuard, createSyncDirectoryGuard, } from "./directory-guard.js";
+import { assertDirectoryGuard, assertSyncDirectoryGuard, createAsyncDirectoryGuard, createSyncDirectoryGuard, } from "./directory-guard.js";
 export async function withAsyncDirectoryGuards(guards, mutate, options = {}) {
     for (const guard of guards) {
-        await assertAsyncDirectoryGuard(guard);
+        assertDirectoryGuard(guard, "native");
     }
     const result = await mutate();
     if (options.verifyAfter !== false) {
         try {
             for (const guard of guards) {
-                await assertAsyncDirectoryGuard(guard);
+                assertDirectoryGuard(guard, "native");
             }
         }
         catch (error) {
@@ -46,11 +46,11 @@ export async function guardedRename(params) {
     const sourceGuard = await createAsyncDirectoryGuard(path.dirname(params.from));
     const targetGuard = 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?.();
         if (params.onSourceInspected) {
             params.onSourceInspected(fsSync.lstatSync(params.from, { bigint: true }));
         }
-        // Authority must survive all awaited guards; do not yield before rename dispatch.
-        params.assertBeforeRename?.();
         await fs.rename(params.from, params.to);
         params.onRenamed?.();
     });