@openclaw/openshell-sandbox 2026.9.5 → 2026.9.6

package/node_modules/@openclaw/fs-safe/dist/file-store-sync-write.js

@@ -2,22 +2,17 @@ import { randomUUID } from "node:crypto";
 import fs, {} from "node:fs";
 import path from "node:path";
 import { syncDirectorySync } from "./directory-durability.js";
+import { createDirectoryReceiptFromIdentity } from "./directory-receipt.js";
 import { FsSafeError } from "./errors.js";
-import { assertSyncDirectoryGuard, ensureParentSync, ensureStoreDirectorySync, } from "./file-store-boundary.js";
+import { ensureParentSync, ensureStoreDirectorySync, } from "./file-store-boundary.js";
+import { assertSyncStoreDirectoryReceipt } from "./file-store-sync-directory.js";
 import { isPathInside } from "./path.js";
 import { resolveReadOpenFlags } from "./read-open-flags.js";
 import { writeTempFileSync } from "./replace-file-descriptor.js";
 import { SyncAtomicTempOwner } from "./replace-file-temp-owner.js";
+import { errorCauseOptions } from "./root-errors.js";
 import { inspectFileIdentitySync } from "./strict-file-identity.js";
 import { getFsSafeTestHooks } from "./test-hooks.js";
-function ensurePrivateDirectorySync(rootDir, targetDir, mode) {
-    return ensureStoreDirectorySync({
-        rootDir,
-        targetDir,
-        mode,
-        messagePrefix: "private store",
-    });
-}
 function verifyStoreFile(fd, expected, filePath) {
     const assertFile = (stat, allowUnknown = false) => {
         const unknown = allowUnknown && process.platform === "win32" && (stat.dev === 0n || stat.ino === 0n);
@@ -54,7 +49,12 @@ export function writeFileSyncAtomic(params) {
     }
     let parentGuard;
     if (params.privateMode) {
-        parentGuard = ensurePrivateDirectorySync(params.rootDir, path.dirname(filePath), params.dirMode);
+        parentGuard = ensureStoreDirectorySync({
+            rootDir: params.rootDir,
+            targetDir: path.dirname(filePath),
+            mode: params.dirMode,
+            messagePrefix: "private store",
+        });
         try {
             const stat = fs.lstatSync(filePath);
             if (stat.isSymbolicLink() || !stat.isFile()) {
@@ -74,14 +74,12 @@ export function writeFileSyncAtomic(params) {
             mode: params.dirMode,
         });
     }
-    const tempPath = path.join(parentGuard?.dir ?? path.dirname(filePath), `.fs-safe-${process.pid}-${randomUUID()}.tmp`);
+    const tempPath = path.join(parentGuard.dir, `.fs-safe-${process.pid}-${randomUUID()}.tmp`);
     const owner = new SyncAtomicTempOwner(tempPath);
-    let originalError;
+    let originalFailure;
     try {
         getFsSafeTestHooks()?.beforeFileStoreSyncPrivateWrite?.(filePath);
-        if (parentGuard) {
-            assertSyncDirectoryGuard(parentGuard);
-        }
+        assertSyncStoreDirectoryReceipt(parentGuard);
         owner.start();
         const temp = writeTempFileSync({
             fsModule: fs, tempPath, content: params.content, mode: params.mode, sync: false,
@@ -100,14 +98,10 @@ export function writeFileSyncAtomic(params) {
         if (params.durable)
             fs.fsyncSync(temp.fd);
         verifyStoreFile(temp.fd, owner.identity, tempPath);
-        if (parentGuard) {
-            assertSyncDirectoryGuard(parentGuard);
-        }
+        assertSyncStoreDirectoryReceipt(parentGuard);
         fs.renameSync(tempPath, filePath);
         owner.markRenamed();
-        if (parentGuard) {
-            assertSyncDirectoryGuard(parentGuard);
-        }
+        assertSyncStoreDirectoryReceipt(parentGuard);
         try {
             verifyStoreFile(temp.fd, owner.identity, filePath);
         }
@@ -115,28 +109,20 @@ export function writeFileSyncAtomic(params) {
             if (error instanceof FsSafeError) {
                 throw error;
             }
-            throw new FsSafeError("path-mismatch", "store target changed after write", {
-                cause: error instanceof Error ? error : undefined,
-            });
+            throw new FsSafeError("path-mismatch", "store target changed after write", errorCauseOptions(error));
         }
-        if (parentGuard) {
-            assertSyncDirectoryGuard(parentGuard);
-            if (params.durable) {
-                syncDirectorySync({
-                    path: parentGuard.dir,
-                    realPath: parentGuard.realPath,
-                    identity: parentGuard.stat,
-                }, { label: "store parent" });
-            }
-            assertSyncDirectoryGuard(parentGuard);
+        assertSyncStoreDirectoryReceipt(parentGuard);
+        if (params.durable) {
+            syncDirectorySync(createDirectoryReceiptFromIdentity(parentGuard.dir, parentGuard.realPath, parentGuard.exactStat), { label: "store parent" });
         }
+        assertSyncStoreDirectoryReceipt(parentGuard);
         return filePath;
     }
     catch (error) {
-        originalError = error;
+        originalFailure = { error };
         throw error;
     }
     finally {
-        owner.finish({ fsModule: fs, originalError, throwOnCleanupError: false });
+        owner.finish({ fsModule: fs, originalFailure, throwOnCleanupError: false });
     }
 }

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

@@ -63,4 +63,3 @@ export type FileStoreSync = {
 };
 export declare function fileStore(options: FileStoreOptions): FileStore;
 export declare function fileStoreSync(options: FileStoreOptions): FileStoreSync;
-//# sourceMappingURL=file-store.d.ts.map

package/node_modules/@openclaw/fs-safe/dist/file-store.js

@@ -1,13 +1,9 @@
 import syncFs from "node:fs";
-import fs from "node:fs/promises";
-import path from "node:path";
 import { normalizeMaxBytes } from "./byte-budget.js";
 import { readFileDescriptorBoundedSync } from "./bounded-read.js";
 import { FsSafeError } from "./errors.js";
-import { assertFileStoreMaxBytes } from "./file-store-limit.js";
-import { assertRelativePath, resolveStorePath } from "./file-store-path.js";
 import { pruneExpiredStoreEntries } from "./file-store-prune.js";
-import { ensureParentInRoot, openPrivateStoreLockRoot, openWritableStoreRoot, writeStreamToTempSource, } from "./file-store-boundary.js";
+import { assertFileStoreMaxBytes, assertRelativePath, ensureParentInRoot, openPrivateStoreLockRoot, openWritableStoreRoot, readFileStoreCopySource, resolveStorePath, writeStreamToTempSource, } from "./file-store-boundary.js";
 import { writeFileSyncAtomic } from "./file-store-sync-write.js";
 import { createJsonStore } from "./json-document-store.js";
 import { stringifyJsonDocument } from "./json-stringify.js";
@@ -18,7 +14,21 @@ import { DEFAULT_ROOT_MAX_BYTES } from "./root-impl.js";
 import { matchRootFileOpenFailure, openRootFileSync } from "./root-file.js";
 import { writeSecretFileAtomic } from "./secret-file.js";
 import { assertNoWindowsPathAlias, resolvePathPreservingWindowsRoot, } from "./windows-path-alias.js";
-import { readFileStoreCopySource } from "./file-store-copy-source.js";
+function snapshotWriteOptions(options, durabilityFirst = true) {
+    if (options == null)
+        return undefined;
+    return durabilityFirst ? {
+        maxBytes: options.maxBytes,
+        durable: options.durable,
+        dirMode: options.dirMode,
+        mode: options.mode,
+    } : {
+        maxBytes: options.maxBytes,
+        dirMode: options.dirMode,
+        mode: options.mode,
+        durable: options.durable,
+    };
+}
 function isNotFound(error) {
     return error instanceof FsSafeError ? error.code === "not-found" : isNotFoundPathError(error);
 }
@@ -59,18 +69,17 @@ async function copyIntoRoot(params) {
         throw new FsSafeError("not-file", "source path is not a file");
     }
     assertFileStoreMaxBytes(sourceStat.size, params.maxBytes);
-    const dirMode = params.dirMode ?? 0o700;
     const scopedRoot = await openWritableStoreRoot({
         rootDir: params.rootDir,
-        dirMode,
+        dirMode: params.dirMode,
         maxBytes: params.maxBytes,
     });
-    await ensureParentInRoot(scopedRoot, relativePath, dirMode);
+    await ensureParentInRoot(scopedRoot, relativePath, params.dirMode);
     await scopedRoot.copyIn(relativePath, params.sourcePath, {
         durable: params.durable,
         maxBytes: params.maxBytes,
         mkdir: false,
-        mode: params.mode ?? 0o600,
+        mode: params.mode,
     });
     return destination;
 }
@@ -105,6 +114,8 @@ export function fileStore(options) {
             return destination;
         }
         const writeDirMode = writeOptions?.dirMode ?? dirMode;
+        const writeMode = writeOptions?.mode ?? mode;
+        const writeDurable = writeOptions?.durable ?? durable;
         const scopedRoot = await openWritableStoreRoot({
             rootDir,
             dirMode: writeDirMode,
@@ -113,8 +124,8 @@ export function fileStore(options) {
         await ensureParentInRoot(scopedRoot, safeRelativePath, writeDirMode);
         await scopedRoot.write(safeRelativePath, content, {
             mkdir: false,
-            mode: writeOptions?.mode ?? mode,
-            durable: writeOptions?.durable ?? durable,
+            mode: writeMode,
+            durable: writeDurable,
         });
         return destination;
     }
@@ -129,6 +140,9 @@ export function fileStore(options) {
             const configuredLimit = normalizeMaxBytes(writeOptions?.maxBytes, { defaultValue: maxBytes });
             const limit = configuredLimit ?? (privateMode ? DEFAULT_ROOT_MAX_BYTES : undefined);
             if (privateMode) {
+                const writeDurable = writeOptions?.durable ?? durable;
+                const writeDirMode = writeOptions?.dirMode ?? dirMode;
+                const writeMode = writeOptions?.mode ?? mode;
                 const chunks = [];
                 let total = 0;
                 for await (const chunk of stream) {
@@ -141,27 +155,30 @@ export function fileStore(options) {
                     rootDir,
                     filePath: destination,
                     content: Buffer.concat(chunks),
-                    durable: writeOptions?.durable ?? durable,
-                    dirMode: writeOptions?.dirMode ?? dirMode,
-                    mode: writeOptions?.mode ?? mode,
+                    durable: writeDurable,
+                    dirMode: writeDirMode,
+                    mode: writeMode,
                 });
                 return destination;
             }
+            const writeMode = writeOptions?.mode ?? mode;
+            const writeDurable = writeOptions?.durable ?? durable;
+            const writeDirMode = writeOptions?.dirMode ?? dirMode;
             const staged = await writeStreamToTempSource({
                 stream,
                 maxBytes: limit,
-                mode: writeOptions?.mode ?? mode,
+                mode: writeMode,
             });
             try {
                 await copyIntoRoot({
                     rootDir,
                     relativePath: safeRelativePath,
                     sourcePath: staged.path,
-                    durable: writeOptions?.durable ?? durable,
+                    durable: writeDurable,
                     maxBytes: limit,
-                    mode: writeOptions?.mode ?? mode,
+                    mode: writeMode,
                     tempPrefix: writeOptions?.tempPrefix,
-                    dirMode: writeOptions?.dirMode ?? dirMode,
+                    dirMode: writeDirMode,
                 });
             }
             finally {
@@ -172,11 +189,19 @@ export function fileStore(options) {
         copyIn: async (relativePath, sourcePath, writeOptions) => {
             const configuredLimit = normalizeMaxBytes(writeOptions?.maxBytes, { defaultValue: maxBytes });
             if (privateMode) {
+                const policy = writeOptions == null
+                    ? undefined
+                    : {
+                        maxBytes: configuredLimit,
+                        durable: writeOptions?.durable,
+                        dirMode: writeOptions?.dirMode,
+                        mode: writeOptions?.mode,
+                    };
                 const buffer = await readFileStoreCopySource({
                     sourcePath,
                     maxBytes: configuredLimit ?? DEFAULT_ROOT_MAX_BYTES,
                 });
-                return await write(relativePath, buffer, writeOptions);
+                return await write(relativePath, buffer, policy);
             }
             return await copyIntoRoot({
                 rootDir,
@@ -230,8 +255,10 @@ export function fileStore(options) {
         exists: async (relativePath) => await (await openRoot()).exists(assertRelativePath(relativePath)),
         writeText: async (relativePath, data, writeOptions) => await write(relativePath, data, writeOptions),
         writeJson: async (relativePath, data, writeOptions) => {
+            const trailingNewline = writeOptions?.trailingNewline;
+            const policy = snapshotWriteOptions(writeOptions, privateMode);
             const json = stringifyJsonDocument(data, null, 2);
-            return await write(relativePath, writeOptions?.trailingNewline === false ? json : `${json}\n`, writeOptions);
+            return await write(relativePath, trailingNewline === false ? json : `${json}\n`, policy);
         },
         json: (relativePath, jsonOptions) => {
             const filePath = resolveStorePath(rootDir, relativePath);
@@ -288,10 +315,11 @@ export function fileStoreSync(options) {
             mode: writeOptions?.mode ?? mode,
         });
     }
+    let readTextIfExists;
     return {
         rootDir,
         path: (relativePath) => resolveStorePath(rootDir, relativePath),
-        readTextIfExists: (relativePath, readOptions) => {
+        readTextIfExists: readTextIfExists = (relativePath, readOptions) => {
             const limit = normalizeMaxBytes(readOptions?.maxBytes, { defaultValue: maxBytes });
             const targetPath = resolveStorePath(rootDir, relativePath);
             const opened = openRootFileSync({
@@ -319,15 +347,16 @@ export function fileStoreSync(options) {
             }
         },
         readJsonIfExists: (relativePath, readOptions) => {
-            const raw = fileStoreSync({ rootDir, private: privateMode, dirMode, mode, maxBytes })
-                .readTextIfExists(relativePath, readOptions);
+            const raw = readTextIfExists(relativePath, readOptions);
             return raw === null ? null : JSON.parse(raw);
         },
         write,
         writeText: (relativePath, data, writeOptions) => write(relativePath, data, writeOptions),
         writeJson: (relativePath, data, writeOptions) => {
+            const trailingNewline = writeOptions?.trailingNewline;
+            const policy = snapshotWriteOptions(writeOptions);
             const json = stringifyJsonDocument(data, null, 2);
-            return write(relativePath, writeOptions?.trailingNewline === false ? json : `${json}\n`, writeOptions);
+            return write(relativePath, trailingNewline === false ? json : `${json}\n`, policy);
         },
     };
 }

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

@@ -2,4 +2,3 @@ import fs from "node:fs";
 import type { FileHandle } from "node:fs/promises";
 export declare function syncFileBestEffort(handle: Pick<FileHandle, "sync">): Promise<void>;
 export declare function syncFileBestEffortSync(fd: number, fsModule?: Pick<typeof fs, "fsyncSync">): void;
-//# sourceMappingURL=file-sync.d.ts.map

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

@@ -6,4 +6,3 @@ export declare function fitFileNameToPortableComponent(params: {
     suffix: string;
 }): string;
 export declare function sanitizeUntrustedFileName(fileName: string, fallbackName: string): string;
-//# sourceMappingURL=filename.d.ts.map

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

@@ -1,6 +1,7 @@
 import path from "node:path";
 import { WINDOWS_RESERVED_DEVICE_NAMES } from "./device-path.js";
 import { maxNormalizedUtf8Bytes } from "./unicode-path.js";
+import { hasWindowsDrivePrefix } from "./windows-path-syntax.js";
 const INVALID_FILE_NAME_CHARACTERS = /[\u0000-\u001f\u007f-\u009f<>:"/\\|?*]/g;
 const HAS_INVALID_FILE_NAME_CHARACTER = /[\u0000-\u001f\u007f-\u009f<>:"/\\|?*]/;
 const HAS_RETAINED_FILE_NAME_CHARACTER = /[^\u0000-\u001f\u007f-\u009f<>:"/\\|?*\s]/;
@@ -53,13 +54,6 @@ function isBoundedSanitizedFileName(fileName, trimmedFileName) {
         !HAS_INVALID_FILE_NAME_CHARACTER.test(fileName) &&
         suffixWindowsReservedDeviceName(fileName) === fileName;
 }
-function hasWindowsDrivePrefix(value) {
-    if (value.length < 2 || value.charCodeAt(1) !== 0x3a)
-        return false;
-    const firstCodeUnit = value.charCodeAt(0);
-    return (firstCodeUnit >= 0x41 && firstCodeUnit <= 0x5a) ||
-        (firstCodeUnit >= 0x61 && firstCodeUnit <= 0x7a);
-}
 function normalizedFileNameBytes(value) {
     return maxNormalizedUtf8Bytes(value, true);
 }

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

@@ -10,4 +10,3 @@ export declare function pathExists(filePath: string): Promise<boolean>;
  * semantics.
  */
 export declare function pathExistsSync(filePath: string): boolean;
-//# sourceMappingURL=fs.d.ts.map

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

@@ -1,6 +1,6 @@
 import { type RootBoundaryIdentity } from "./root-boundary.js";
 import { type MutationDirectoryObservation } from "./pinned-mutation-observation.js";
-import type { PinnedCreatedDirectoryReceipt, PinnedMutationAdmissionReceipt, PinnedMutationAuthorizationToken } from "./pinned-write.js";
+import type { PinnedCreatedDirectoryReceipt, PinnedMutationAdmissionReceipt, PinnedMutationAuthorizationToken } from "./pinned-write-types.js";
 /**
  * Creates each missing path component from `rootReal` down to `targetPath`,
  * guarding every step. Returns the real (symlink-resolved) path of the final
@@ -16,10 +16,10 @@ export declare function mkdirPathComponentsWithGuards(params: {
     afterCreateComponent?: (receipt: PinnedCreatedDirectoryReceipt) => PinnedMutationAuthorizationToken | undefined;
     assertBeforeMutation?: () => void;
     mode?: number;
+    private?: boolean;
     rejectSymlinks?: boolean;
     revalidateParentAfterBeforeComponent?: boolean;
     synchronousAuthorizationIncludesFence?: boolean;
     retainedTargetPath?: string;
     rootIdentity?: RootBoundaryIdentity;
 }): Promise<string>;
-//# sourceMappingURL=guarded-mkdir.d.ts.map

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

@@ -1,9 +1,10 @@
 import fsSync, {} from "node:fs";
 import fs from "node:fs/promises";
 import path from "node:path";
+import { createDirectoryWithAdmission } from "./create.js";
 import { assertAsyncDirectoryGuard, createAsyncDirectoryGuard, inspectDirectoryIdentitySync, } from "./directory-guard.js";
 import { FsSafeError } from "./errors.js";
-import { isNotFoundPathError, isPathRelativeEscape } from "./path.js";
+import { hasNodeErrorCode, isNotFoundPathError, isPathRelativeEscape } from "./path.js";
 import { directoryComponentNotDirectoryError, rootPathChangedError } from "./root-errors.js";
 import { assertNoWindowsPathAlias, pathForWindowsFilesystem, resolvePathPreservingWindowsRoot, } from "./windows-path-alias.js";
 import { realpathSync } from "./realpath.js";
@@ -14,6 +15,10 @@ function sameDirectoryFacts(left, right) {
     return left.dev === right.dev && left.ino === right.ino && left.mode === right.mode &&
         left.nlink === right.nlink;
 }
+function isDirectoryCollision(error) {
+    return hasNodeErrorCode(error, "EEXIST") ||
+        (error instanceof FsSafeError && error.code === "already-exists");
+}
 function inspectGuardCurrent(parent) {
     const stat = inspectDirectoryIdentitySync(parent.dir, parent.stat);
     if (realpathSync.native(parent.dir) !== parent.realPath) {
@@ -144,6 +149,7 @@ export async function mkdirPathComponentsWithGuards(params) {
         if (params.revalidateParentAfterBeforeComponent) {
             await assertAsyncDirectoryGuard(parentGuard);
         }
+        let shouldCreate = true;
         if (params.beforeCreateComponent) {
             let missing = false;
             try {
@@ -154,6 +160,7 @@ export async function mkdirPathComponentsWithGuards(params) {
                     throw error;
                 missing = true;
             }
+            shouldCreate = missing;
             if (missing) {
                 let prospectiveParent = retainedParentPath;
                 if (!prospectiveParent) {
@@ -172,31 +179,32 @@ export async function mkdirPathComponentsWithGuards(params) {
                     if (!params.synchronousAuthorizationIncludesFence)
                         inspectGuardCurrent(parentGuard);
                 }
-                params.assertBeforeMutation?.();
-                // Authority callbacks are an explicit freshness boundary. Recheck the
-                // exact parent synchronously so no callback-observed authority is
-                // carried into a pathname mkdir after the parent was swapped.
-                inspectGuardCurrent(parentGuard);
-                try {
-                    await fs.mkdir(next, { mode: params.mode });
-                    created = true;
-                }
-                catch (error) {
-                    if (!error || typeof error !== "object" || !("code" in error) || error.code !== "EEXIST") {
-                        throw error;
-                    }
-                }
             }
         }
-        else {
+        if (shouldCreate) {
             params.assertBeforeMutation?.();
+            // Both policy and ordinary mkdir must renew the parent after callbacks.
+            inspectGuardCurrent(parentGuard);
             try {
-                await fs.mkdir(next, { mode: params.mode });
+                if (params.private) {
+                    await createDirectoryWithAdmission(next, {
+                        private: true,
+                        mode: params.mode,
+                        assertBeforeMutation: params.assertBeforeMutation,
+                    }, {
+                        expectedParentIdentity: {
+                            dev: parentGuard.stat.dev, ino: parentGuard.stat.ino, realPath: parentGuard.realPath,
+                        },
+                    });
+                }
+                else {
+                    await fs.mkdir(next, { mode: params.mode });
+                }
+                created = true;
             }
             catch (error) {
-                if (!error || typeof error !== "object" || !("code" in error) || error.code !== "EEXIST") {
+                if (!isDirectoryCollision(error))
                     throw error;
-                }
             }
         }
         let createdAuthorization;

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

@@ -13,21 +13,15 @@ export declare function guardedRename(params: {
     onRenamed?: () => void;
     from: string;
     to: string;
-    targetRoot?: string;
-    verifyAfter?: boolean;
 }): Promise<void>;
 export declare function guardedRenameSync(params: {
     from: string;
     to: string;
-    targetRoot?: string;
-    verifyAfter?: boolean;
 }): void;
 export declare function guardedRm(params: {
     target: string;
     assertBeforeMutation?: () => void;
     recursive?: boolean;
-    force?: boolean;
-    verifyAfter?: boolean;
 }): Promise<void>;
 export declare function guardedRmSync(params: {
     target: string;
@@ -36,4 +30,3 @@ export declare function guardedRmSync(params: {
     force?: boolean;
     verifyAfter?: boolean;
 }): void;
-//# sourceMappingURL=guarded-mutation.d.ts.map

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

@@ -1,7 +1,7 @@
 import fsSync, {} from "node:fs";
 import fs from "node:fs/promises";
 import path from "node:path";
-import { assertAsyncDirectoryGuard, assertSyncDirectoryGuard, createAsyncDirectoryGuard, createNearestExistingDirectoryGuard, createNearestExistingSyncDirectoryGuard, createSyncDirectoryGuard, } from "./directory-guard.js";
+import { assertAsyncDirectoryGuard, assertSyncDirectoryGuard, createAsyncDirectoryGuard, createSyncDirectoryGuard, } from "./directory-guard.js";
 export async function withAsyncDirectoryGuards(guards, mutate, options = {}) {
     for (const guard of guards) {
         await assertAsyncDirectoryGuard(guard);
@@ -44,9 +44,7 @@ export function withSyncDirectoryGuards(guards, mutate, options = {}) {
 }
 export async function guardedRename(params) {
     const sourceGuard = await createAsyncDirectoryGuard(path.dirname(params.from));
-    const targetGuard = params.targetRoot
-        ? await createNearestExistingDirectoryGuard(params.targetRoot, path.dirname(params.to))
-        : await createAsyncDirectoryGuard(path.dirname(params.to));
+    const targetGuard = await createAsyncDirectoryGuard(path.dirname(params.to));
     await withAsyncDirectoryGuards([sourceGuard, targetGuard], async () => {
         if (params.onSourceInspected) {
             params.onSourceInspected(fsSync.lstatSync(params.from, { bigint: true }));
@@ -55,14 +53,12 @@ export async function guardedRename(params) {
         params.assertBeforeRename?.();
         await fs.rename(params.from, params.to);
         params.onRenamed?.();
-    }, { verifyAfter: params.verifyAfter });
+    });
 }
 export function guardedRenameSync(params) {
     const sourceGuard = createSyncDirectoryGuard(path.dirname(params.from));
-    const targetGuard = params.targetRoot
-        ? createNearestExistingSyncDirectoryGuard(params.targetRoot, path.dirname(params.to))
-        : createSyncDirectoryGuard(path.dirname(params.to));
-    withSyncDirectoryGuards([sourceGuard, targetGuard], () => fsSync.renameSync(params.from, params.to), { verifyAfter: params.verifyAfter });
+    const targetGuard = createSyncDirectoryGuard(path.dirname(params.to));
+    withSyncDirectoryGuards([sourceGuard, targetGuard], () => fsSync.renameSync(params.from, params.to));
 }
 export async function guardedRm(params) {
     const guard = await createAsyncDirectoryGuard(path.dirname(params.target));
@@ -70,9 +66,8 @@ export async function guardedRm(params) {
         params.assertBeforeMutation?.();
         await fs.rm(params.target, {
             ...(params.recursive !== undefined ? { recursive: params.recursive } : {}),
-            ...(params.force !== undefined ? { force: params.force } : {}),
         });
-    }, { verifyAfter: params.verifyAfter });
+    });
 }
 export function guardedRmSync(params) {
     const guard = createSyncDirectoryGuard(path.dirname(params.target));

package/node_modules/@openclaw/fs-safe/dist/guest-dispatch-python.d.ts

@@ -1,2 +1 @@
 export declare const GUEST_FILESYSTEM_DISPATCH_PYTHON: string;
-//# sourceMappingURL=guest-dispatch-python.d.ts.map