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

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

@@ -13,6 +13,9 @@ export type PublishFileExclusiveFailureDetails = {
     targetIdentity?: FileIdentityStat;
     cleanup: PublishFileExclusiveCleanup;
     directorySync?: PublishFileExclusiveDirectorySyncFailure;
+    fallback?: "link-unlink";
+    publication?: "published";
+    sourceRemoval?: "not-attempted" | "still-linked" | "unverified" | "removed";
 };
 export type PublishFailureState = {
     phase: PublishFileExclusiveFailurePhase;
@@ -21,6 +24,8 @@ export type PublishFailureState = {
     targetCleanupIdentity?: FileIdentityStat;
     preserveTarget: boolean;
     directorySync?: PublishFileExclusiveDirectorySyncFailure;
+    fallback?: PublishFileExclusiveFailureDetails["fallback"];
+    sourceRemoval?: PublishFileExclusiveFailureDetails["sourceRemoval"];
 };
 export declare function rememberCreatedTarget(state: PublishFailureState, identity: FileIdentityStat, phase: PublishFileExclusiveFailurePhase): void;
 export declare function publicationFailure(error: unknown, state: PublishFailureState, cleanup: PublishFileExclusiveCleanup): FsSafeError;

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

@@ -12,6 +12,7 @@ export function publicationFailure(error, state, cleanup) {
         targetCreated: state.targetCreated,
         ...(state.targetIdentity ? { targetIdentity: state.targetIdentity } : {}),
         ...(state.directorySync ? { directorySync: state.directorySync } : {}),
+        ...(state.fallback ? { fallback: state.fallback, publication: "published", sourceRemoval: state.sourceRemoval } : {}),
         cleanup,
     };
     return new FsSafeError(error instanceof FsSafeError ? error.code : "helper-failed", `exclusive file publication failed during ${state.phase}: ${cause.message}`, { cause, details });

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

@@ -5,6 +5,8 @@ import { type PublishFileExclusiveSyncFailurePolicy } from "./publish-file-failu
 export type PublishFileExclusiveStrategy = "link-or-copy" | "link-required" | "rename-noreplace";
 export type PublishFileExclusiveResult = {
     method: "hardlink" | "exclusive-copy" | "rename-noreplace";
+    /** Linux auto fallback; exclusive and identity-checked, but not crash-atomic. */
+    fallback?: "link-unlink";
     identity: Stats;
     directorySync: DirectorySyncOutcome;
 };

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

@@ -1,3 +1,5 @@
+import { nativeMoveNoReplace } from "./native-move-fallback.js";
+import { getFsSafeNativeConfig } from "./native-config.js";
 import { createHash } from "node:crypto";
 import fsSync, {} from "node:fs";
 import fs, {} from "node:fs/promises";
@@ -256,7 +258,7 @@ export async function publishFileExclusive(params) {
             else
                 assertSourceCurrent();
             assertPublishedTargetCurrent(targetPath, identity, "publication target changed during directory sync");
-            return { method, identity: fsSync.fstatSync(handle.fd), directorySync };
+            return { method, ...(failure.fallback ? { fallback: failure.fallback } : {}), identity: fsSync.fstatSync(handle.fd), directorySync };
         };
         await parent.assertCurrent();
         assertSourceCurrent();
@@ -269,7 +271,38 @@ export async function publishFileExclusive(params) {
         }
         if (strategy === "rename-noreplace") {
             const binding = requireNativeBinding();
-            binding.renameNoReplace(sourceNativeParent.handle.fd, sourceNativeParent.basename, targetNativeParent.handle.fd, targetNativeParent.basename);
+            try {
+                const fallback = nativeMoveNoReplace(binding, [
+                    sourceNativeParent.handle.fd, sourceNativeParent.basename,
+                    targetNativeParent.handle.fd, targetNativeParent.basename,
+                ], sourceExactIdentity, getFsSafeNativeConfig().mode === "auto", "file publication");
+                if (fallback) {
+                    failure.fallback = fallback;
+                    failure.sourceRemoval = "removed";
+                }
+            }
+            catch (error) {
+                if (error instanceof FsSafeError) {
+                    if (error.details?.publication === "published") {
+                        failure.targetCreated = true;
+                        failure.preserveTarget = true;
+                        failure.phase = "rename-verify";
+                        failure.fallback = "link-unlink";
+                        failure.sourceRemoval = error.details.sourceRemoval;
+                        // Changed/unverified pairs cannot establish which inode was published.
+                        if (failure.sourceRemoval === "still-linked")
+                            rememberCreatedTarget(failure, sourceExactIdentity, "rename-verify");
+                    }
+                    throw error;
+                }
+                const code = error?.code;
+                if (code === "path-mismatch" || code === "hardlink") {
+                    throw new FsSafeError(code, "publication source changed before fallback", { cause: error });
+                }
+                if (code === "ELOOP")
+                    throw new FsSafeError("symlink", "publication source became a symlink", { cause: error });
+                throw error;
+            }
             rememberCreatedTarget(failure, sourceExactIdentity, "rename-verify");
             // A failed post-rename fence must not delete the only remaining name.
             failure.preserveTarget = true;

package/node_modules/@openclaw/fs-safe/dist/replace-directory.js

@@ -1,3 +1,4 @@
+import { noReplaceUnavailable } from "./native-noreplace.js";
 import { randomUUID } from "node:crypto";
 import fsSync from "node:fs";
 import fs from "node:fs/promises";
@@ -19,7 +20,8 @@ function assertGuardsCurrent(guards) {
 }
 function replacementFailure(error, message, details, cause = error) {
     if (error instanceof FsSafeError) {
-        return new FsSafeError(error.code, message, { cause, details });
+        const code = error.code;
+        return new FsSafeError(code, code === "helper-unavailable" ? `${message}: ${error.message}` : message, { cause, details });
     }
     const failure = new Error(message, { cause });
     copyOperationalCode(failure, error);
@@ -46,14 +48,13 @@ function observeOptionalDirectory(pathname) {
     return inspectDirectoryIdentitySync(pathname, undefined, initial);
 }
 function normalizeNativeRenameFailure(error) {
+    const unavailable = noReplaceUnavailable(error, "directory rename", true);
+    if (unavailable)
+        return unavailable;
     const code = error?.code;
     if (code === NATIVE_RENAME_SOURCE_IDENTITY_MISMATCH) {
         return new FsSafeError("path-mismatch", "directory replacement source identity changed before native rename", { cause: error });
     }
-    if (code === "EINVAL" || code === "ENOSYS" || code === "ENOTSUP" ||
-        code === "EOPNOTSUPP") {
-        return new FsSafeError("helper-unavailable", "native no-replace directory rename is unavailable on this filesystem", { cause: error });
-    }
     return error;
 }
 function renameRetainedDirectory(params) {

package/node_modules/@openclaw/fs-safe/dist/replace-file-copy-fallback.js

@@ -139,15 +139,12 @@ function* replacePinnedWithRestore(io, file, replacement, maxRestoreBytes, repla
             if (io.asynchronous)
                 yield chmod;
             yield* file.sync();
-            throw restoreFailure(writeError, "restored");
         }
         catch (restoreError) {
             mutation.rethrowRefusal();
-            if (restoreError instanceof FsSafeError && restoreError.details?.cleanup === "restored") {
-                throw restoreError;
-            }
             throw restoreFailure(writeError, "restore-failed", restoreError);
         }
+        throw restoreFailure(writeError, "restored");
     }
 }
 export function* copyFallbackReplace(io, params) {

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

@@ -139,6 +139,12 @@ export function* writeTempFile(io, params) {
         const writing = file.writeFile(params.content, true);
         if (io.asynchronous)
             yield writing;
+        if (io.asyncFs === fs && process.platform !== "win32" && !params.sync) {
+            // Matching non-durable writes have no I/O left after this identity fence.
+            const current = inspectAtomicIdentity(io, () => file.statExact(), identity, true);
+            if (Number(current.mode & 4095n) === (params.mode & 0o7777))
+                return { file, identity };
+        }
         const chmod = file.chmod(params.mode);
         if (io.asynchronous)
             yield chmod;

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

@@ -1,14 +1,28 @@
-import type { PinnedWriteInput } from "./pinned-write-types.js";
+import type { NativeWriteParent, PinnedWriteInput, PublishedWriteIdentity } from "./pinned-write-types.js";
 import type { RootCreateOptions, RootCreateStreamOptions, RootWriteOptions } from "./root-options.js";
+import type { AnyAsyncDirectoryGuard } from "./directory-guard.js";
 declare const exclusiveSidecarCreate: unique symbol;
 export declare const sidecarExclusiveCreate: Readonly<{
     [exclusiveSidecarCreate]: true;
 }>;
+export declare const retainSidecarCreated: unique symbol;
+export type SidecarCreationRetention = Readonly<{
+    retain(fd: number, parent: AnyAsyncDirectoryGuard, nativeParent?: NativeWriteParent): void;
+    cleanup(fd: number, parent: NativeWriteParent, identity: PublishedWriteIdentity): void;
+}>;
 export type RootWriteParams = RootWriteOptions & RootCreateOptions & RootCreateStreamOptions & {
     relativePath: string;
     data: string | Buffer | AsyncIterable<Uint8Array>;
     strictFileSync?: boolean;
     [exclusiveSidecarCreate]?: true;
+    [retainSidecarCreated]?: SidecarCreationRetention;
+};
+export declare function sidecarRetainedCreate(retain: NonNullable<RootWriteParams[typeof retainSidecarCreated]>): {
+    [exclusiveSidecarCreate]: true;
+    [retainSidecarCreated]: Readonly<{
+        retain(fd: number, parent: AnyAsyncDirectoryGuard, nativeParent?: NativeWriteParent): void;
+        cleanup(fd: number, parent: NativeWriteParent, identity: PublishedWriteIdentity): void;
+    }>;
 };
 export declare function rethrowCreateInputError(error: unknown): never;
 export declare function createInputOptions(data: RootWriteParams["data"], options: RootCreateOptions & RootCreateStreamOptions, defaultMaxBytes?: number): RootCreateOptions & RootCreateStreamOptions;

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

@@ -5,6 +5,10 @@ import { MutationAuthorityError } from "./mutation-authority.js";
 // Keep this composition hook off the public Root options and package exports.
 const exclusiveSidecarCreate = Symbol("exclusiveSidecarCreate");
 export const sidecarExclusiveCreate = Object.freeze({ [exclusiveSidecarCreate]: true });
+export const retainSidecarCreated = Symbol("retainSidecarCreated");
+export function sidecarRetainedCreate(retain) {
+    return { ...sidecarExclusiveCreate, [retainSidecarCreated]: retain };
+}
 class CreateInputError extends FsSafeError {
     rejection;
     constructor(rejection) {

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

@@ -17,7 +17,7 @@ export async function lookupRootDirectoryEntry(root, guard, name) {
         const observed = inspectStatObservationSync(bigint => bigint
             ? fs.lstatSync(pathname, { bigint: true }) : fs.lstatSync(pathname));
         await assertRootDirectoryObservationGuard(root, guard);
-        return { entry: { name, ...pathStatFromStats(observed.stat) }, identity: observed.identity };
+        return { entry: pathStatFromStats(observed.stat, name), identity: observed.identity };
     }
     catch (error) {
         await assertRootDirectoryObservationGuard(root, guard);

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

@@ -16,6 +16,5 @@ export declare function assertRootDirectoryObservationGuard(root: RootContext, g
  * both its identity and canonical check here.
  */
 export declare function assertRootPathObservationReceiptCurrent(root: RootContext, receipt: RootPathObservationReceipt | RootPathParentObservationReceipt, finalTarget?: Stats | BigIntStats): void;
-export declare function listDirectoryPath(root: RootContext, directory: string, withFileTypes: true, receipt?: RootPathObservationReceipt): Promise<DirEntry[]>;
 export declare function listDirectoryPath(root: RootContext, directory: string, withFileTypes: boolean, receipt?: RootPathObservationReceipt): Promise<string[] | DirEntry[]>;
 export declare function openRootDirectoryListing(root: RootContext, directory: string, options: RootDirectoryListingOptions, receipt?: RootPathObservationReceipt): Promise<RootDirectoryListing>;

package/node_modules/@openclaw/fs-safe/dist/root-directory-list.js

@@ -105,10 +105,6 @@ export async function assertRootDirectoryObservationGuard(root, guard) {
         throw directoryChangedError(error);
     }
 }
-function sameObservationDirectory(left, right) {
-    return left.dir === right.dir && left.realPath === right.realPath &&
-        left.identity.dev === right.identity.dev && left.identity.ino === right.identity.ino;
-}
 function assertReceiptDirectoryGuardSync(root, guard, backend) {
     if (backend) {
         const observed = inspectNativeDirectoryObservation(backend, guard.dir, guard.identity);
@@ -139,7 +135,8 @@ export function assertRootPathObservationReceiptCurrent(root, receipt, finalTarg
         rootGuard.identity.dev !== root.rootIdentity.dev || rootGuard.identity.ino !== root.rootIdentity.ino) {
         throw rootPathChangedError();
     }
-    if (sameObservationDirectory(rootGuard, directoryGuard)) {
+    if (rootGuard.dir === directoryGuard.dir && rootGuard.realPath === directoryGuard.realPath &&
+        rootGuard.identity.dev === directoryGuard.identity.dev && rootGuard.identity.ino === directoryGuard.identity.ino) {
         try {
             if (receipt.kind === "stat" && receipt.target === rootGuard && finalTarget &&
                 !receipt.directoryObserver) {
@@ -176,12 +173,6 @@ function normalizeDirectoryError(error) {
     }
     return error;
 }
-function normalizeInitialDirectoryError(error) {
-    if (error instanceof FsSafeError && error.code === "not-file") {
-        return new FsSafeError("not-found", "directory not found", { cause: error });
-    }
-    return normalizeDirectoryError(error);
-}
 export async function listDirectoryPath(root, directory, withFileTypes, receipt) {
     let guard;
     if (receipt) {
@@ -192,7 +183,10 @@ export async function listDirectoryPath(root, directory, withFileTypes, receipt)
             guard = await createRootDirectoryObservationGuard(root, directory);
         }
         catch (error) {
-            throw normalizeInitialDirectoryError(error);
+            if (error instanceof FsSafeError && error.code === "not-file") {
+                throw new FsSafeError("not-found", "directory not found", { cause: error });
+            }
+            throw normalizeDirectoryError(error);
         }
     }
     return await listGuardedDirectoryPath(root, guard, withFileTypes, receipt);

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

@@ -29,7 +29,7 @@ export function hardlinkedPathNotAllowedError() {
 export function isAlreadyExistsError(error) {
     return hasNodeErrorCode(error, "EEXIST") || /File exists|EEXIST/i.test(String(error));
 }
-function descriptorExhaustion(error) {
+function resourceExhaustion(error) {
     const pending = [error];
     let details;
     let code;
@@ -45,7 +45,11 @@ function descriptorExhaustion(error) {
         const diagnostic = current;
         if (current instanceof FsSafeError && (!details || current.details?.cleanup))
             details = current.details ?? details;
-        if (diagnostic.code === "EMFILE" || diagnostic.code === "ENFILE")
+        if (diagnostic.code === "EMFILE" || diagnostic.code === "ENFILE") {
+            if (!code || code === "ENOSPC")
+                code = diagnostic.code;
+        }
+        else if (diagnostic.code === "ENOSPC")
             code ??= diagnostic.code;
         if (diagnostic.name === "SuppressedError")
             pending.push(diagnostic.suppressed, diagnostic.error);
@@ -55,15 +59,32 @@ function descriptorExhaustion(error) {
     }
     if (!code)
         return;
+    // Disk-space diagnostics retain the published direct-write code and already-classified errors.
+    if (code === "ENOSPC" && error instanceof FsSafeError)
+        return;
     const cleanup = details?.cleanup;
     const publication = details?.publication;
     const preserved = cleanup?.status === "preserved" && publication?.status === "indeterminate";
-    return new FsSafeError("helper-failed", `filesystem write failed: too many open files (${code})${preserved ? "; publication outcome is indeterminate; staged file preserved" : ""}`, { cause: error, details });
+    const message = code === "ENOSPC" ? PINNED_WRITE_ERRNO_MESSAGES.get(code) : "filesystem write failed: too many open files";
+    return new FsSafeError(code === "ENOSPC" ? "invalid-path" : "helper-failed", `${message} (${code})${preserved ? "; publication outcome is indeterminate; staged file preserved" : ""}`, { cause: error, details });
 }
 export function normalizePinnedWriteError(error) {
-    const exhausted = descriptorExhaustion(error);
+    const exhausted = resourceExhaustion(error);
     if (exhausted)
         return exhausted;
+    // Disposal retains cleanup evidence, but the failed publication remains primary.
+    let primary = error;
+    const seen = new Set();
+    try {
+        while (primary instanceof Error && primary.name === "SuppressedError" && !seen.has(primary)) {
+            seen.add(primary);
+            primary = primary.suppressed;
+        }
+        if (primary !== error && primary instanceof FsSafeError && primary.details?.phase === "publish") {
+            return new FsSafeError(primary.code, primary.message, { cause: error, details: primary.details });
+        }
+    }
+    catch { /* Unreadable diagnostics retain the original failure. */ }
     if (error instanceof FsSafeError) {
         return error;
     }

package/node_modules/@openclaw/fs-safe/dist/root-impl.js

@@ -86,7 +86,6 @@ import { admitPathInsideRoot } from "./root-boundary.js";
 import { listDirectoryPath, openRootDirectoryListing } from "./root-directory-list.js";
 import { statResolvedPathInRoot } from "./root-path-stat.js";
 import { entriesInRoot } from "./root-entries.js";
-import { assertMoveMutationAllowed } from "./root-move-preflight.js";
 import { assertRootIdentityCurrent, assertRootIdentityCurrentSync, assertValidRootDestinationPath, assertValidRootRelativePath, createRootObservationGuard, ensureTrailingSep, expandRelativePathWithHome, resolvePathInRoot, resolveRootContext, rootRelativeReadPath, } from "./root-context.js";
 import { errorCauseOptions, fileNotFoundError, hardlinkedPathNotAllowedError, isAlreadyExistsError, normalizePinnedPathError, normalizePinnedWriteError, outsideWorkspaceError, } from "./root-errors.js";
 import { getFsSafeTestHooks } from "./test-hooks.js";
@@ -96,7 +95,7 @@ import { registerTempPathForExit } from "./temp-cleanup.js";
 import { removePathInRootFallback, validateRemoveOptions } from "./root-remove.js";
 import { removePathInRootNative } from "./root-remove-native.js";
 import { serializePathWrite } from "./write-queue.js";
-import { verifyAtomicWriteResult } from "./root-write-verification.js";
+import { verifyAtomicWriteResult, verifyRootWritePublication } from "./root-write-verification.js";
 import { assertRootWritePathSelectionSync, assertRootWriteSelectionSync, createRootWriteSelectionForFd, prepareGuardedRootWritePathSelection, resolveGuardedWritePathInRoot, resolveGuardedWriteTargetInRoot, resolvePinnedWriteTargetInRoot, refreshRetainedRootWriteAdmission, refreshRootWritePathSelection, } from "./root-write-admission.js";
 import { prepareSharedRootWriteTarget } from "./root-write-complete-parent.js";
 import { finishRootFallbackWrite } from "./root-write-publication.js";
@@ -107,7 +106,7 @@ import { admitMoveSourceStat, movePathNative } from "./root-move-noreplace.js";
 import { admitRootReadHandle, inspectOpenedPathIdentitySync } from "./root-read-admission.js";
 import { createCopyPublicationObserver, onCopyPublication, onCopySourceAdmission } from "./copy-publication.js";
 import { writeAllToFile } from "./write-file-handle.js";
-import { createInputOptions, rethrowCreateInputError, rootWriteInput } from "./root-create-input.js";
+import { createInputOptions, rethrowCreateInputError, rootWriteInput, retainSidecarCreated } from "./root-create-input.js";
 import { assertFinalSymlinkRejected, mutationSymlinkResolution, readSymlinkResolution } from "./root-symlink-policy.js";
 import { assertExclusiveCreateLeaf } from "./exclusive-create.js";
 import { assertNoWindowsPathAlias, resolvePathPreservingWindowsRoot } from "./windows-path-alias.js";
@@ -390,11 +389,14 @@ export class RootHandle {
         const { denyMutations, mutationSymlinks } = snapshotPinnedMutationPolicy(mutationOptions.denyMutations, mutationOptions.mutationSymlinks) ?? {};
         const overwrite = options.overwrite ?? false;
         const requireNative = isFsSafeNativeRequired();
-        await assertMoveMutationAllowed(this.context, {
-            fromRelative,
-            toRelative,
-            denyMutations,
-        });
+        // Deny both routes before source alias or identity admission.
+        for (const relativePath of [fromRelative, toRelative]) {
+            const { resolved } = await resolvePathInRoot(this.context, relativePath, {
+                aliasErrorCode: "path-alias",
+                allowFinalSymlink: true,
+            });
+            await assertMutationNotDenied(resolved, denyMutations, { protectAncestors: true });
+        }
         await movePathFallback(this.context, {
             requireNative,
             fromRelative,
@@ -934,15 +936,13 @@ async function commitPinnedWriteInRoot(root, pinned, params, input) {
             rootIdentity: root.rootIdentity,
             mutationAdmission: pinned.mutationAdmission,
             assertBeforeMutation: params.assertBeforeMutation,
-            verifyPublished: async (fd, expectedIdentity, parentGuard) => {
+            verifyPublished: async (fd, expectedIdentity, parentGuard, nativeParent) => {
                 verifyingPublication = true;
                 try {
-                    await verifyAtomicWriteResult({
-                        root,
-                        targetPath: pinned.targetPath,
-                        fd,
-                        expectedIdentity,
-                        parentGuard,
+                    await verifyRootWritePublication({
+                        fd, expectedIdentity, parentGuard,
+                        nativeParent, retention: params[retainSidecarCreated],
+                        verify: () => verifyAtomicWriteResult({ root, targetPath: pinned.targetPath, fd, expectedIdentity, parentGuard }),
                     });
                 }
                 catch (error) {
@@ -1167,10 +1167,10 @@ async function movePathFallback(root, params) {
     let sourceIdentity;
     try {
         if (params.overwrite && params.assertBeforeMutation) {
-            sourceIdentity = inspectFileIdentitySync(() => admitMoveSourceStat(fsSync.lstatSync(source.resolved, { bigint: true }), true));
+            sourceIdentity = inspectFileIdentitySync(() => admitMoveSourceStat(fsSync.lstatSync(source.resolved, { bigint: true })));
         }
         else {
-            admitMoveSourceStat(fsSync.lstatSync(source.resolved), params.overwrite);
+            admitMoveSourceStat(fsSync.lstatSync(source.resolved));
         }
     }
     catch (error) {
@@ -1234,7 +1234,7 @@ async function movePathFallback(root, params) {
                     }
                 }
             }
-            inspectFileIdentitySync(() => admitMoveSourceStat(fsSync.lstatSync(source.resolved, { bigint: true }), true), sourceIdentity);
+            inspectFileIdentitySync(() => admitMoveSourceStat(fsSync.lstatSync(source.resolved, { bigint: true })), sourceIdentity);
         }
         await fs.rename(source.resolved, target.resolved);
     }

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

@@ -1,8 +1,10 @@
 import { type BigIntStats, type Stats } from "node:fs";
 import type { RootMoveOptions } from "./root-options.js";
 import { type RootContext } from "./root-context.js";
-export declare function admitMoveSourceStat<T extends Stats | BigIntStats>(stat: T, overwrite?: boolean): T;
-export declare function movePathNative(root: RootContext, params: Pick<RootMoveOptions, "assertBeforeMutation" | "denyMutations" | "mutationSymlinks">, paths: {
+export declare function admitMoveSourceStat<T extends Stats | BigIntStats>(stat: T): T;
+export declare function movePathNative(root: RootContext, params: Pick<RootMoveOptions, "assertBeforeMutation" | "denyMutations" | "mutationSymlinks"> & {
+    requireNative: boolean;
+}, paths: {
     sourcePath: string;
     sourceParentPath: string;
     targetPath: string;

package/node_modules/@openclaw/fs-safe/dist/root-move-noreplace.js

@@ -15,6 +15,7 @@ import { PATH_ALIAS_POLICIES } from "./path-policy.js";
 import { createSuppressedError } from "./suppressed-error.js";
 import { inspectFileIdentitySync } from "./strict-file-identity.js";
 import { getFsSafeTestHooks } from "./test-hooks.js";
+import { nativeMoveNoReplace } from "./native-move-fallback.js";
 function nativeParentRelativePath(rootReal, parentPath) {
     const relative = path.relative(rootReal, parentPath);
     if (relative === "" || relative === ".")
@@ -57,22 +58,13 @@ function normalizeMoveError(error) {
     }
     return error;
 }
-function normalizeRenameNoReplaceError(error) {
-    if (error?.code === "EINVAL") {
-        return new FsSafeError("helper-unavailable", "native no-replace move is unavailable on this filesystem", errorCauseOptions(error));
-    }
-    return normalizeMoveError(error);
-}
-export function admitMoveSourceStat(stat, overwrite = false) {
+export function admitMoveSourceStat(stat) {
     if (stat.isSymbolicLink()) {
         throw new FsSafeError("symlink", "symlink not allowed");
     }
     if (stat.isFile() && stat.nlink > 1) {
         throw hardlinkedPathNotAllowedError();
     }
-    if (!overwrite && stat.isDirectory()) {
-        throw new FsSafeError("invalid-path", "directory moves require overwrite: true");
-    }
     return stat;
 }
 export async function movePathNative(root, params, paths, overwrite = false) {
@@ -124,10 +116,9 @@ export async function movePathNative(root, params, paths, overwrite = false) {
         await assertRootIdentityCurrent(root);
         for (const admission of parentAdmissions)
             assertSyncDirectoryGuard(admission.guard);
-        // Overwrite publication always binds an exact source; no-clobber retains
-        // its existing callback-dependent identity contract.
-        const sourceStat = overwrite || params.assertBeforeMutation
-            ? inspectFileIdentitySync(() => admitMoveSourceStat(fsSync.lstatSync(admittedSourcePath, { bigint: true }), overwrite), paths.expectedSourceIdentity)
+        // Linux auto fallback needs an exact source even without an authority callback.
+        const sourceStat = overwrite || params.assertBeforeMutation || (process.platform === "linux" && !params.requireNative)
+            ? inspectFileIdentitySync(() => admitMoveSourceStat(fsSync.lstatSync(admittedSourcePath, { bigint: true })), paths.expectedSourceIdentity)
             : undefined;
         if (!sourceStat)
             admitMoveSourceStat(fsSync.lstatSync(admittedSourcePath));
@@ -172,20 +163,25 @@ export async function movePathNative(root, params, paths, overwrite = false) {
             }
         }
         if (sourceStat !== undefined) {
-            inspectFileIdentitySync(() => admitMoveSourceStat(fsSync.lstatSync(admittedSourcePath, { bigint: true }), overwrite), sourceStat);
+            inspectFileIdentitySync(() => admitMoveSourceStat(fsSync.lstatSync(admittedSourcePath, { bigint: true })), sourceStat);
         }
         try {
             assertFinalSymlinkRejected(admittedTargetPath, params.mutationSymlinks !== undefined);
             if (overwrite)
                 binding.renameReplaceWithIdentity(sourceParent.fd, path.basename(paths.sourcePath), targetParent.fd, path.basename(paths.targetPath), sourceStat.dev, sourceStat.ino);
             else
-                binding.renameNoReplace(sourceParent.fd, path.basename(paths.sourcePath), targetParent.fd, path.basename(paths.targetPath));
+                nativeMoveNoReplace(binding, [
+                    sourceParent.fd,
+                    path.basename(paths.sourcePath),
+                    targetParent.fd,
+                    path.basename(paths.targetPath),
+                ], sourceStat, !params.requireNative);
         }
         catch (error) {
             if (isAlreadyExistsError(error) || (!overwrite && error?.code === "ENOTEMPTY")) {
                 throw new FsSafeError("already-exists", "destination exists", errorCauseOptions(error));
             }
-            throw overwrite ? normalizeMoveError(error) : normalizeRenameNoReplaceError(error);
+            throw normalizeMoveError(error);
         }
         try {
             for (const admission of parentAdmissions)

package/node_modules/@openclaw/fs-safe/dist/root-paths.js

@@ -244,7 +244,7 @@ async function resolveCheckedPathsWithinRoot(params, allowMissingFallback) {
             if (!root) {
                 throw new FsSafeError("not-found", "root dir not found");
             }
-            opened = await root.open(pathResult.relativePath);
+            opened = await root.open(`./${pathResult.relativePath}`);
             resolvedPaths.push(opened.realPath);
         }
         catch (err) {

package/node_modules/@openclaw/fs-safe/dist/root-walk.js

@@ -136,7 +136,9 @@ export async function* walkRoot(root, relativePath, options) {
         let failed = false;
         let operationError;
         try {
-            const relativeDirectory = directory.split(path.sep).join(path.posix.sep);
+            const relativeDirectory = path.posix.normalize(directory.split(path.sep).join(path.posix.sep));
+            const childPrefix = relativeDirectory === "." || relativeDirectory === "./" ? ""
+                : relativeDirectory.endsWith("/") ? relativeDirectory : `${relativeDirectory}/`;
             while (true) {
                 let next;
                 try {
@@ -150,9 +152,7 @@ export async function* walkRoot(root, relativePath, options) {
                 if (next === undefined)
                     return;
                 const name = next.kind === "entry" ? next.entry.name : next.name;
-                const child = directory
-                    ? path.posix.join(relativeDirectory, name)
-                    : name;
+                const child = childPrefix + name;
                 if (next.kind === "limit") {
                     yield onLimit(child);
                     return;

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

@@ -1,6 +1,15 @@
 import { type AnyAsyncDirectoryGuard } from "./directory-guard.js";
-import type { PublishedWriteIdentity } from "./pinned-write-types.js";
+import type { NativeWriteParent, PublishedWriteIdentity } from "./pinned-write-types.js";
+import type { SidecarCreationRetention } from "./root-create-input.js";
 import { type RootContext } from "./root-context.js";
+export declare function verifyRootWritePublication(params: {
+    fd: number;
+    expectedIdentity: PublishedWriteIdentity;
+    parentGuard: AnyAsyncDirectoryGuard;
+    nativeParent?: NativeWriteParent;
+    retention?: SidecarCreationRetention;
+    verify(): Promise<void>;
+}): Promise<void>;
 export declare function verifyAtomicWriteResult(params: {
     root: RootContext;
     targetPath: string;

package/node_modules/@openclaw/fs-safe/dist/root-write-verification.js

@@ -5,10 +5,30 @@ import { FsSafeError } from "./errors.js";
 import { sameFileIdentity } from "./file-identity.js";
 import { resolveOpenedFileRealPathForFd } from "./opened-realpath.js";
 import { assertNoUnsafeDeviceReadPath, hasNodeErrorCode, isNotFoundPathError, isSymlinkOpenError } from "./path.js";
+import { createSuppressedError } from "./suppressed-error.js";
 import { resolveReadOpenFlags } from "./read-open-flags.js";
 import { assertRootIdentityCurrent } from "./root-context.js";
 import { fileNotFoundError, hardlinkedPathNotAllowedError, outsideWorkspaceError } from "./root-errors.js";
 import { admitPathInsideRoot } from "./root-boundary.js";
+export async function verifyRootWritePublication(params) {
+    try {
+        await params.verify();
+        params.retention?.retain(params.fd, params.parentGuard, params.nativeParent);
+    }
+    catch (error) {
+        if (params.retention && params.nativeParent) {
+            // Publication already happened. The creator still owns these descriptors
+            // even if opening an additional retained handle failed.
+            try {
+                params.retention.cleanup(params.fd, params.nativeParent, params.expectedIdentity);
+            }
+            catch (cleanupError) {
+                throw createSuppressedError(cleanupError, error, "sidecar retention and creator cleanup both failed");
+            }
+        }
+        throw error;
+    }
+}
 export async function verifyAtomicWriteResult(params) {
     let needsPathOpen = false;
     const assertFile = (stat) => {