@openclaw/feishu 2026.9.8 → 2026.10.1-beta.2

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

@@ -4,7 +4,7 @@ import { FsSafeError } from "./errors.js";
 import { formatErrorDetail } from "./error-detail.js";
 import { isNotFoundPathError, isPathInside, isSymlinkOpenError } from "./path.js";
 import { realpathSync } from "./realpath.js";
-import { assertNoWindowsPathAlias, pathForWindowsFilesystem, resolvePathFromBasePreservingWindowsRoot, resolvePathPreservingWindowsRoot, } from "./windows-path-alias.js";
+import { assertNoWindowsPathAlias, isForeignWindowsShareOrDevicePath, pathForWindowsFilesystem, resolvePathFromBasePreservingWindowsRoot, resolvePathPreservingWindowsRoot, } from "./windows-path-alias.js";
 import { admitPathInsideRoot } from "./root-boundary.js";
 import { errorCauseOptions } from "./root-errors.js";
 export function absolutePathWithRawSegments(candidate) {
@@ -29,6 +29,8 @@ export function rawPathRelativeToCanonicalRoot(candidate, rootCanonicalPath, opt
     assertNoWindowsPathAlias(rootCanonicalPath);
     const absolute = absolutePathWithRawSegments(candidate);
     const raw = process.platform === "win32" ? absolute.replaceAll("/", path.sep) : absolute;
+    if (isForeignWindowsShareOrDevicePath(raw, [rootCanonicalPath]))
+        return undefined;
     const filesystemRoot = path.parse(raw).root;
     const segments = raw.slice(filesystemRoot.length).split(path.sep);
     const finalComponentIndex = segments.findLastIndex(segment => segment !== "" && segment !== ".");

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

@@ -50,102 +50,85 @@ export async function statResolvedPathInRoot(root, resolvedPath, receipt) {
     const proof = {};
     try {
         // Nested observations in a hook cannot grant this invocation discard authority.
-        return await fileObservation().run(() => statObservedPathInRoot(root, resolvedPath, proof, receipt));
-    }
-    catch (error) {
-        const failure = proof.failure;
-        if (failure && failure.error === error)
-            recordFileObservationFailure(error, failure.kind);
-        throw error;
-    }
-}
-async function statObservedPathInRoot(root, resolvedPath, proof, receipt) {
-    let admittedTarget = false;
-    try {
-        if (receipt) {
-            if (receipt.kind !== "stat" || receipt.targetPath !== resolvedPath) {
-                throw new FsSafeError("path-mismatch", "file observation receipt does not match target");
-            }
-            admittedTarget = true;
-            const beforeObservation = getFsSafeTestHooks()?.beforeRootStatObservation;
-            if (beforeObservation)
-                await beforeObservation(resolvedPath);
-            let observed;
-            let sample, samples = 0;
-            const comparison = fileObservation();
+        return await fileObservation().run(async () => {
+            let admittedTarget = false;
             try {
-                observed = comparison.run(() => assertStatObservationSync(bigint => {
+                let parentGuard;
+                let expected;
+                if (receipt) {
+                    if (receipt.kind !== "stat" || receipt.targetPath !== resolvedPath) {
+                        throw new FsSafeError("path-mismatch", "file observation receipt does not match target");
+                    }
+                }
+                else {
+                    const guardPath = resolvedPath === root.rootReal ? root.rootReal : path.dirname(resolvedPath);
+                    parentGuard = guardPath === root.rootReal && root.rootGuard
+                        ? root.rootGuard
+                        : await createRootDirectoryObservationGuard(root, guardPath);
+                    try {
+                        const beforeInitialObservation = getFsSafeTestHooks()?.beforeRootStatInitialObservation;
+                        if (beforeInitialObservation)
+                            await beforeInitialObservation(resolvedPath);
+                        expected = inspectFileIdentitySync(() => fsSync.lstatSync(resolvedPath, { bigint: true }));
+                        if (expected.isSymbolicLink()) {
+                            throw new FsSafeError("path-mismatch", "file changed during operation");
+                        }
+                    }
+                    catch (error) {
+                        // No initial target error is safe to expose until the admitted parent is
+                        // proven current; a redirect must win over an ordinary lookup failure.
+                        await assertRootDirectoryObservationGuard(root, parentGuard);
+                        throw error;
+                    }
+                }
+                admittedTarget = true;
+                const beforeObservation = getFsSafeTestHooks()?.beforeRootStatObservation;
+                if (beforeObservation)
+                    await beforeObservation(resolvedPath);
+                let observed;
+                let sample, samples = 0;
+                const comparison = fileObservation();
+                const inspect = (bigint = true) => {
                     sample = bigint ? fsSync.lstatSync(resolvedPath, { bigint: true }) : fsSync.lstatSync(resolvedPath);
                     samples += 1;
                     return sample;
-                }, receipt.target.identity));
+                };
+                try {
+                    observed = comparison.run(() => receipt
+                        ? assertStatObservationSync(inspect, receipt.target.identity)
+                        : inspectFileIdentitySync(inspect, expected));
+                }
+                catch (error) {
+                    if (isNotFoundPathError(error)) {
+                        throw await missingObservedFileError(error, resolvedPath, receipt ? ("stat" in receipt.target ? receipt.target.stat : undefined) : expected, () => receipt ? assertRootPathObservationReceiptCurrent(root, receipt)
+                            : assertRootDirectoryObservationGuard(root, parentGuard), proof);
+                    }
+                    if (comparison.has(error, "identity"))
+                        await captureChangedObservedFile(error, resolvedPath, receipt ? ("stat" in receipt.target ? receipt.target.stat : undefined) : expected, samples === 1 ? sample : undefined, () => receipt ? assertRootPathObservationReceiptCurrent(root, receipt)
+                            : assertRootDirectoryObservationGuard(root, parentGuard), proof);
+                    throw error;
+                }
+                if (observed.isSymbolicLink()) {
+                    throw new FsSafeError("path-mismatch", "file changed during operation");
+                }
+                if (receipt)
+                    assertRootPathObservationReceiptCurrent(root, receipt, observed);
+                else
+                    await assertRootDirectoryObservationGuard(root, parentGuard);
+                return pathStatFromStats(observed);
             }
             catch (error) {
-                if (isNotFoundPathError(error)) {
-                    throw await missingObservedFileError(error, resolvedPath, "stat" in receipt.target ? receipt.target.stat : undefined, () => assertRootPathObservationReceiptCurrent(root, receipt), proof);
+                if (!admittedTarget && isNotFoundPathError(error)) {
+                    throw fileNotFoundError(error instanceof Error ? error : undefined);
                 }
-                if (comparison.has(error, "identity"))
-                    await captureChangedObservedFile(error, resolvedPath, "stat" in receipt.target ? receipt.target.stat : undefined, samples === 1 ? sample : undefined, () => assertRootPathObservationReceiptCurrent(root, receipt), proof);
                 throw error;
             }
-            if (observed.isSymbolicLink()) {
-                throw new FsSafeError("path-mismatch", "file changed during operation");
-            }
-            assertRootPathObservationReceiptCurrent(root, receipt, observed);
-            return pathStatFromStats(observed);
-        }
-        const guardPath = resolvedPath === root.rootReal ? root.rootReal : path.dirname(resolvedPath);
-        const parentGuard = guardPath === root.rootReal && root.rootGuard
-            ? root.rootGuard
-            : await createRootDirectoryObservationGuard(root, guardPath);
-        let expected;
-        try {
-            const beforeInitialObservation = getFsSafeTestHooks()?.beforeRootStatInitialObservation;
-            if (beforeInitialObservation)
-                await beforeInitialObservation(resolvedPath);
-            expected = inspectFileIdentitySync(() => fsSync.lstatSync(resolvedPath, { bigint: true }));
-            if (expected.isSymbolicLink()) {
-                throw new FsSafeError("path-mismatch", "file changed during operation");
-            }
-        }
-        catch (error) {
-            // No initial target error is safe to expose until the admitted parent is
-            // proven current; a redirect must win over an ordinary lookup failure.
-            await assertRootDirectoryObservationGuard(root, parentGuard);
-            throw error;
-        }
-        admittedTarget = true;
-        const beforeObservation = getFsSafeTestHooks()?.beforeRootStatObservation;
-        if (beforeObservation)
-            await beforeObservation(resolvedPath);
-        let observed;
-        let sample, samples = 0;
-        const comparison = fileObservation();
-        try {
-            observed = comparison.run(() => inspectFileIdentitySync(() => {
-                sample = fsSync.lstatSync(resolvedPath, { bigint: true });
-                samples += 1;
-                return sample;
-            }, expected));
-        }
-        catch (error) {
-            if (isNotFoundPathError(error)) {
-                throw await missingObservedFileError(error, resolvedPath, expected, () => assertRootDirectoryObservationGuard(root, parentGuard), proof);
-            }
-            if (comparison.has(error, "identity"))
-                await captureChangedObservedFile(error, resolvedPath, expected, samples === 1 ? sample : undefined, () => assertRootDirectoryObservationGuard(root, parentGuard), proof);
-            throw error;
-        }
-        if (observed.isSymbolicLink()) {
-            throw new FsSafeError("path-mismatch", "file changed during operation");
-        }
-        await assertRootDirectoryObservationGuard(root, parentGuard);
-        return pathStatFromStats(observed);
+        });
     }
     catch (error) {
-        if (!admittedTarget && isNotFoundPathError(error)) {
-            throw fileNotFoundError(error instanceof Error ? error : undefined);
-        }
+        const failure = proof.failure;
+        if (failure && failure.error === error)
+            recordFileObservationFailure(error, failure.kind);
         throw error;
     }
 }

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

@@ -9,7 +9,7 @@ import { absolutePathWithRawSegments, rawPathRelativeToCanonicalRoot, resolveExi
 import { admitPathInsideRoot, } from "./root-boundary.js";
 import { RootPathObservationError, captureRootPathObservedDirectory, createRootPathTraversalObservation, inspectRootPathTraversalEntry, } from "./root-path-observation.js";
 import { assertNoDriveRelativePathSegments } from "./safe-path-segment.js";
-import { assertNoWindowsPathAlias, pathForWindowsFilesystem, resolvePathFromBasePreservingWindowsRoot, resolvePathPreservingWindowsRoot, } from "./windows-path-alias.js";
+import { assertNoWindowsPathAlias, isForeignWindowsShareOrDevicePath, pathForWindowsFilesystem, resolvePathFromBasePreservingWindowsRoot, resolvePathPreservingWindowsRoot, } from "./windows-path-alias.js";
 export { resolvePathViaExistingAncestorSync } from "./root-path-existing.js";
 export { RootPathObservationError, } from "./root-path-observation.js";
 export const ROOT_PATH_ALIAS_POLICIES = {
@@ -55,6 +55,11 @@ function resolveRootPathInternal(params, options = {}) {
 function prepareRootTraversal(params, rootPath, rootCanonicalPath, absolutePath, rawAbsolutePath) {
     let raw = rawAbsolutePath;
     let trustedAbsolutePath = false;
+    // Even a metadata lookup on a foreign share contacts that host, including the
+    // identity check behind a case-folded root prefix.
+    if (isForeignWindowsShareOrDevicePath(raw, [rootPath, rootCanonicalPath])) {
+        throw pathEscapeError({ rootPath, absolutePath: raw, boundaryLabel: params.boundaryLabel });
+    }
     const direct = admitRawPathInsideRoot(rootPath, raw, params.rootIdentity);
     if (direct) {
         raw = direct.path;

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

@@ -1,4 +1,8 @@
 import { type ResolvePathWithinRootParams } from "./path-scope-lexical.js";
+export declare function invalidPath(scopeLabel: string): {
+    ok: false;
+    error: string;
+};
 export declare function resolvePathWithinRoot(params: ResolvePathWithinRootParams): {
     ok: true;
     path: string;

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

@@ -1,7 +1,7 @@
 import path from "node:path";
 import { resolvePathWithinNormalizedRoot } from "./path-scope-lexical.js";
 import { hasWindowsPathAlias, resolvePathPreservingWindowsRoot, } from "./windows-path-alias.js";
-function invalidPath(scopeLabel) {
+export function invalidPath(scopeLabel) {
     return { ok: false, error: `Invalid path: must stay within ${scopeLabel}` };
 }
 export function resolvePathWithinRoot(params) {

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

@@ -4,18 +4,12 @@ import { FsSafeError } from "./errors.js";
 import { isNotFoundPathError, isPathInside, } from "./path.js";
 import { realpathSync } from "./realpath.js";
 import { root as openRoot } from "./root.js";
-import { hasWindowsPathAlias, pathForWindowsFilesystem, resolvePathPreservingWindowsRoot, } from "./windows-path-alias.js";
-import { resolvePathWithinRoot } from "./root-paths-lexical.js";
+import { hasWindowsPathAlias, isForeignWindowsShareOrDevicePath, pathForWindowsFilesystem, resolvePathPreservingWindowsRoot, } from "./windows-path-alias.js";
+import { invalidPath, resolvePathWithinRoot } from "./root-paths-lexical.js";
 import { resolvePathWithinNormalizedRoot } from "./path-scope-lexical.js";
 import { assertNoSymlinkSegments, ensureDirectoryWithinRoot, resolveNearestExistingPath, } from "./root-directory.js";
 export { resolvePathWithinRoot } from "./root-paths-lexical.js";
 export { ensureDirectoryWithinRoot } from "./root-directory.js";
-function invalidPath(scopeLabel) {
-    return {
-        ok: false,
-        error: `Invalid path: must stay within ${scopeLabel}`,
-    };
-}
 const INVALID_REAL_PATH = Symbol("invalid-real-path");
 async function resolveRealPathIfExists(targetPath) {
     if (hasWindowsPathAlias(targetPath, "filesystem"))
@@ -216,7 +210,8 @@ async function resolveCheckedPathsWithinRoot(params, allowMissingFallback) {
         if (!rootRealPath ||
             !raw ||
             !path.isAbsolute(raw) ||
-            hasWindowsPathAlias(raw, "filesystem")) {
+            hasWindowsPathAlias(raw, "filesystem") ||
+            isForeignWindowsShareOrDevicePath(raw, [rootDir, rootRealPath])) {
             return lexicalPathResult;
         }
         try {

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

@@ -0,0 +1,4 @@
+import { type RootContext } from "./root-context.js";
+import { type InternalRemoveOptions } from "./root-remove.js";
+import type { RemovalPathReceipts } from "./root-remove-receipt.js";
+export declare function removePathInRootNative(root: RootContext, target: string, options: InternalRemoveOptions, receipts?: RemovalPathReceipts): Promise<void>;

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

@@ -0,0 +1,311 @@
+import fs from "node:fs";
+import path from "node:path";
+import { scheduler } from "node:timers/promises";
+import { assertSyncDirectoryGuard } from "./directory-guard.js";
+import { assertMutationNotDenied } from "./deny-mutations.js";
+import { FsSafeError } from "./errors.js";
+import { MutationAuthorityError } from "./mutation-authority.js";
+import { getNativeBinding } from "./native.js";
+import { openNativeParentAdmission, openNativeRootAdmission } from "./native-parent-admission.js";
+import { isNotFoundPathError, isPathInside } from "./path.js";
+import { assertRootIdentityCurrentSync } from "./root-context.js";
+import { normalizeRemoveGuardError, normalizeRemovePathError } from "./root-errors.js";
+import { captureNonrecursiveRemovalAdmission, nonrecursiveRemovalKind } from "./root-remove.js";
+import { createSuppressedError } from "./suppressed-error.js";
+import { getFsSafeTestHooks } from "./test-hooks.js";
+function unavailable() {
+    throw new FsSafeError("helper-unavailable", "native confined removal is unavailable on this platform");
+}
+function normalize(error, details) {
+    if (error instanceof FsSafeError || error instanceof MutationAuthorityError ||
+        (error instanceof Error && error.name === "SuppressedError"))
+        return error;
+    const code = error?.code;
+    if (code === "path-mismatch")
+        return new FsSafeError("path-mismatch", "removal identity changed", { cause: error, details });
+    if (["ENOTSUP", "ENOSYS", "EOPNOTSUPP"].includes(code ?? "")) {
+        return new FsSafeError("helper-unavailable", "native confined removal is unavailable", { cause: error, details });
+    }
+    return normalizeRemovePathError(error, details);
+}
+export async function removePathInRootNative(root, target, options, receipts) {
+    const binding = getNativeBinding();
+    if (!binding?.rootRemovalStat || !binding.rootRemovalUnlink) {
+        unavailable();
+    }
+    const inspect = binding.rootRemovalStat.bind(binding);
+    const unlink = binding.rootRemovalUnlink.bind(binding);
+    const openDirectory = binding.openRootRemovalDirectory?.bind(binding);
+    const boundary = await captureNonrecursiveRemovalAdmission(root, target, options, receipts);
+    if (!boundary)
+        return;
+    const rootAdmission = await openNativeRootAdmission(binding, {
+        rootPath: root.rootReal, rootIdentity: root.rootIdentity, operation: "remove", reportCloseErrors: true, searchOnly: true,
+    }).catch(error => { throw normalizeRemoveGuardError(error); });
+    let parent;
+    let initialEntry;
+    let initialDirectory;
+    let initialDirectoryAttempted = false;
+    let operationError;
+    let failed = false;
+    try {
+        const parentPath = path.dirname(target);
+        if (!isPathInside(root.rootReal, parentPath))
+            throw new FsSafeError("outside-workspace", "removal parent is outside root");
+        try {
+            parent = await openNativeParentAdmission(binding, rootAdmission, path.relative(root.rootReal, parentPath).split(path.sep).join("/"));
+        }
+        catch (error) {
+            assertRootIdentityCurrentSync(root);
+            boundary.assertCurrent();
+            if (!(options.force && isNotFoundPathError(error)))
+                throw error;
+        }
+        if (parent) {
+            // Bind the native descriptor to the parent admitted before opening it;
+            // an in-root redirect must not inherit another directory's approval.
+            if (parent.guard.stat.dev !== boundary.parentIdentity.dev || parent.guard.stat.ino !== boundary.parentIdentity.ino) {
+                throw new FsSafeError("path-mismatch", "removal parent identity changed");
+            }
+            if (options.recursive) {
+                boundary.assertCurrent();
+                try {
+                    initialEntry = inspect(parent.fd, path.basename(target));
+                }
+                catch (error) {
+                    boundary.assertCurrent();
+                    if (!(options.force && isNotFoundPathError(error)))
+                        throw error;
+                }
+                if (initialEntry?.directory) {
+                    if (!openDirectory)
+                        unavailable();
+                    initialDirectoryAttempted = true;
+                    try {
+                        initialDirectory = openDirectory(parent.fd, path.basename(target), initialEntry.dev, initialEntry.ino);
+                    }
+                    catch (error) {
+                        boundary.assertCurrent();
+                        const code = error?.code;
+                        if (["ENOTSUP", "ENOSYS", "EOPNOTSUPP"].includes(code ?? ""))
+                            unavailable();
+                        else if (!(options.force && isNotFoundPathError(error))) {
+                            throw normalize(error, { operation: "remove", phase: "enumerate", relativePath: "" });
+                        }
+                    }
+                }
+            }
+            if (!options.recursive || initialEntry)
+                await removeEntries(parent);
+        }
+    }
+    catch (error) {
+        failed = true;
+        operationError = error instanceof MutationAuthorityError ? error : normalize(error);
+    }
+    const closeErrors = [];
+    try {
+        initialDirectory?.close();
+    }
+    catch (error) {
+        closeErrors.push(error);
+    }
+    try {
+        parent?.close();
+    }
+    catch (error) {
+        closeErrors.push(error);
+    }
+    try {
+        await rootAdmission.root.close();
+    }
+    catch (error) {
+        closeErrors.push(error);
+    }
+    if (closeErrors.length) {
+        const error = closeErrors.length === 1 ? closeErrors[0] : new AggregateError(closeErrors, "removal descriptors could not close");
+        if (failed)
+            throw createSuppressedError(error, operationError instanceof MutationAuthorityError ? operationError.rejection : operationError, "removal and descriptor close failed");
+        throw error;
+    }
+    if (failed)
+        throw operationError;
+    async function removeEntries(admitted) {
+        // The admission already checks Root through the retained parent. This list
+        // adds only traversal descendants, avoiding duplicate ancestry fences.
+        const guards = [];
+        const maxEntries = options.maxEntries ?? 100_000;
+        const maxDepth = options.maxDepth ?? 64;
+        let examined = 0;
+        const details = (entryPath, phase) => ({
+            operation: "remove", relativePath: path.relative(target, entryPath), phase,
+        });
+        async function beforeMutation(entryPath) {
+            try {
+                await getFsSafeTestHooks()?.beforeRootFallbackMutation?.("remove", entryPath);
+            }
+            catch (error) {
+                throw normalizeRemoveGuardError(error);
+            }
+        }
+        function assertNotAborted() {
+            try {
+                options.signal?.throwIfAborted();
+            }
+            catch (error) {
+                throw new MutationAuthorityError(error);
+            }
+        }
+        function assertTraversalCurrent() {
+            for (const guard of guards) {
+                try {
+                    assertSyncDirectoryGuard(guard);
+                }
+                catch (cause) {
+                    throw new FsSafeError("path-mismatch", "removal ancestor changed", { cause });
+                }
+            }
+        }
+        function assertCurrent() {
+            assertNotAborted();
+            boundary.assertCurrent();
+            assertTraversalCurrent();
+        }
+        function observe(fd, name, entryPath, expected) {
+            assertCurrent();
+            try {
+                const entry = inspect(fd, name);
+                if (expected && (entry.dev !== expected.dev || entry.ino !== expected.ino || entry.directory !== expected.directory)) {
+                    throw new FsSafeError("path-mismatch", "removal entry changed");
+                }
+                if (entry.symlink && options.mutationSymlinks !== undefined) {
+                    throw new FsSafeError("symlink", "symlink not allowed", { details: details(entryPath, expected ? "remove" : "inspect") });
+                }
+                return entry;
+            }
+            catch (error) {
+                if (options.force && isNotFoundPathError(error))
+                    return undefined;
+                throw normalize(error, details(entryPath, expected ? "remove" : "inspect"));
+            }
+        }
+        async function visit(fd, name, entryPath, depth, counted = false) {
+            assertNotAborted();
+            if (options.recursive && ((!counted && examined >= maxEntries) || depth > maxDepth)) {
+                throw new FsSafeError("too-large", "recursive removal budget exceeded", { details: details(entryPath, "inspect") });
+            }
+            if (!counted)
+                examined++;
+            if (!options.recursive)
+                await beforeMutation(entryPath);
+            await assertMutationNotDenied(entryPath, options.denyMutations, { protectAncestors: true });
+            const initial = observe(fd, name, entryPath, depth === 0 ? initialEntry : undefined);
+            if (!initial)
+                return;
+            if (!initial.directory && options[nonrecursiveRemovalKind] === "directory") {
+                throw new FsSafeError("path-mismatch", "store entry is no longer a directory");
+            }
+            if (initial.directory && options.recursive) {
+                let directory;
+                try {
+                    if (depth === 0 && initialDirectoryAttempted) {
+                        directory = initialDirectory;
+                        initialDirectory = undefined;
+                    }
+                    else
+                        directory = openDirectory(fd, name, initial.dev, initial.ino);
+                }
+                catch (error) {
+                    assertCurrent();
+                    if (!(options.force && isNotFoundPathError(error)))
+                        throw normalize(error, details(entryPath, "enumerate"));
+                    if (!observe(fd, name, entryPath, initial))
+                        return;
+                }
+                if (directory) {
+                    let failure;
+                    try {
+                        const stat = fs.fstatSync(directory.fd, { bigint: true });
+                        const read = () => {
+                            try {
+                                return directory.read();
+                            }
+                            catch (error) {
+                                throw normalize(error, details(entryPath, "enumerate"));
+                            }
+                        };
+                        guards.push({ dir: entryPath, realPath: entryPath, stat });
+                        try {
+                            assertCurrent();
+                            if (options.order === "sorted") {
+                                const names = [];
+                                for (let child = read(); child !== null; child = read()) {
+                                    await scheduler.yield();
+                                    assertCurrent();
+                                    if (examined >= maxEntries)
+                                        throw new FsSafeError("too-large", "recursive removal budget exceeded", {
+                                            details: details(path.join(entryPath, child), "enumerate"),
+                                        });
+                                    examined++;
+                                    names.push(child);
+                                }
+                                for (const child of names.sort())
+                                    await visit(directory.fd, child, path.join(entryPath, child), depth + 1, true);
+                            }
+                            else {
+                                for (let child = read(); child !== null; child = read()) {
+                                    await scheduler.yield();
+                                    await visit(directory.fd, child, path.join(entryPath, child), depth + 1);
+                                }
+                            }
+                        }
+                        finally {
+                            guards.pop();
+                        }
+                    }
+                    catch (error) {
+                        failure = { error: error instanceof MutationAuthorityError ? error.rejection : error };
+                        throw error;
+                    }
+                    finally {
+                        try {
+                            directory.close();
+                        }
+                        catch (error) {
+                            const closeError = normalize(error, details(entryPath, "enumerate"));
+                            if (failure)
+                                throw createSuppressedError(closeError, failure.error, "removal and directory close failed");
+                            throw closeError;
+                        }
+                    }
+                }
+            }
+            if (options.recursive) {
+                await beforeMutation(entryPath);
+                await assertMutationNotDenied(entryPath, options.denyMutations, { protectAncestors: true });
+                if (!observe(fd, name, entryPath, initial))
+                    return;
+            }
+            if (options.assertBeforeMutation) {
+                options.assertBeforeMutation();
+                if (!observe(fd, name, entryPath, initial))
+                    return;
+            }
+            // No await separates the final admission from native identity-checked unlink.
+            try {
+                unlink(fd, name, initial.dev, initial.ino, initial.directory);
+            }
+            catch (error) {
+                if (!(options.force && isNotFoundPathError(error)))
+                    throw normalize(error, details(entryPath, "remove"));
+            }
+            if (options.recursive)
+                boundary.assertCurrent();
+            else
+                boundary.assertAfterMutation();
+            assertTraversalCurrent();
+            assertNotAborted();
+        }
+        await visit(admitted.fd, path.basename(target), target, 0);
+    }
+}

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

@@ -1,6 +1,17 @@
+import type { BigIntStats } from "node:fs";
 import { type RootContext } from "./root-context.js";
 import type { RootRemoveOptions } from "./root-options.js";
 import type { RemovalPathReceipts } from "./root-remove-receipt.js";
 export declare const nonrecursiveRemovalKind: unique symbol;
+export type InternalRemoveOptions = RootRemoveOptions & {
+    [nonrecursiveRemovalKind]?: "directory";
+};
 export declare function validateRemoveOptions(options: RootRemoveOptions): void;
+type NonrecursiveRemovalAdmission = Readonly<{
+    parentIdentity: Readonly<Pick<BigIntStats, "dev" | "ino">>;
+    assertAfterMutation(): void;
+    assertCurrent(): void;
+}>;
+export declare function captureNonrecursiveRemovalAdmission(root: RootContext, targetPath: string, options: RootRemoveOptions, receipts?: RemovalPathReceipts): Promise<NonrecursiveRemovalAdmission | undefined>;
 export declare function removePathInRootFallback(root: RootContext, targetPath: string, options: RootRemoveOptions, receipts?: RemovalPathReceipts): Promise<void>;
+export {};

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

@@ -80,7 +80,7 @@ async function assertMissingRemovalPrefixCurrent(rootGuard, intermediates) {
         throw removalAncestorChanged();
     }
 }
-async function captureNonrecursiveRemovalAdmission(root, targetPath, options, receipts) {
+export async function captureNonrecursiveRemovalAdmission(root, targetPath, options, receipts) {
     const parentPath = path.dirname(targetPath);
     if (!isPathInside(root.rootReal, parentPath)) {
         throw new FsSafeError("path-mismatch", "removal parent is outside the retained root");
@@ -105,6 +105,7 @@ async function captureNonrecursiveRemovalAdmission(root, targetPath, options, re
     if (parentPath === root.rootReal) {
         const rootAssertion = createRemovalDirectoryAssertion(rootGuard.dir, rootGuard.stat, rootGuard.realPath);
         return Object.freeze({
+            parentIdentity: rootAssertion,
             assertAfterMutation() {
                 // Here Root is also the immediate parent, so retain its established
                 // post-dispatch error classification while checking it only once.
@@ -187,6 +188,7 @@ async function captureNonrecursiveRemovalAdmission(root, targetPath, options, re
         }
     };
     return Object.freeze({
+        parentIdentity: parentAssertion,
         assertAfterMutation() {
             assertPrefixCurrent();
             // Preserve the established nonrecursive post-dispatch mapping for the

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

@@ -1,6 +1,6 @@
 import type { DirectoryObservationGuard } from "./directory-guard.js";
 import { type RootPathObservationReceipt } from "./root-path.js";
-import type { RootDirectoryListing, RootDirectoryListingOptions } from "./root-directory-list.js";
+import type { RootDirectoryListing, RootDirectoryListingOptions } from "./root-directory-list-types.js";
 import type { PathStat } from "./types.js";
 export type RootWalkSymlinkPolicy = "skip" | "follow-within-root" | "include";
 type LegacyRootWalkSymlinkPolicy = Exclude<RootWalkSymlinkPolicy, "include">;
@@ -40,7 +40,7 @@ type AnyRootWalkOptions = RootWalkOptions | RootWalkOptions<"include"> | RootWal
 type AnyRootWalkEntry = RootWalkEntry<RootWalkSymlinkPolicy>;
 type RootWalkCapability = {
     rootReal: string;
-    observeRoot(): Promise<DirectoryObservationGuard | undefined>;
+    observeRoot(): Promise<DirectoryObservationGuard>;
     stat(relativePath: string): Promise<PathStat>;
     list(relativePath: string, options: RootDirectoryListingOptions, receipt?: RootPathObservationReceipt): Promise<RootDirectoryListing>;
 };

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

@@ -87,9 +87,6 @@ export async function* walkRoot(root, relativePath, options) {
             let resolvedDirectory;
             if (includeChild) {
                 const rootGuard = await root.observeRoot();
-                if (!rootGuard) {
-                    throw new FsSafeError("helper-unavailable", "root walk requires an exact directory observation");
-                }
                 const observed = await resolveRootPathWithObservation({
                     ...resolution,
                     rootIdentity: rootGuard.identity,
@@ -192,6 +189,7 @@ export async function* walkRoot(root, relativePath, options) {
                         return;
                     }
                 }
+                options.signal?.throwIfAborted();
                 if (!["include", "skip", "skip-subtree"].includes(filterResult)) {
                     throw new TypeError(`invalid root walk entryFilter result: ${String(filterResult)}`);
                 }