@openclaw/signal 2026.9.6 → 2026.9.7

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

@@ -70,11 +70,6 @@ function snapshotDirectoryMetadata(stat, identity) {
 export function directoryReceiptAuthority(receipt) {
     return authorities.get(receipt) ?? snapshotDirectoryReceipt(receipt);
 }
-function rememberReceipt(receipt, authority) {
-    authorities.set(receipt, authority);
-    identities.set(receipt.identity, authority);
-    return receipt;
-}
 export function ownDirectoryReceipt(receipt) {
     return receiptFromAuthority(snapshotDirectoryReceipt(receipt));
 }
@@ -83,11 +78,14 @@ export function copyRetainedDirectoryReceipt(receipt) {
     return receiptFromAuthority(authority);
 }
 function receiptFromAuthority(authority) {
-    return rememberReceipt({
+    const receipt = {
         path: authority.path,
         realPath: authority.realPath,
         identity: Object.assign(Object.create(fs.Stats.prototype), authority.metadata),
-    }, authority);
+    };
+    authorities.set(receipt, authority);
+    identities.set(receipt.identity, authority);
+    return receipt;
 }
 // The caller already admitted the exact observation and its paths.
 export function createDirectoryReceiptFromIdentity(pathname, realPath, exactStat) {

package/node_modules/@openclaw/fs-safe/dist/effective-uid.js

@@ -1,6 +1,3 @@
-function isValidUid(value) {
-    return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
-}
 function unavailable(cause) {
     return new Error("Effective user identity is unavailable.", {
         ...(cause === undefined ? {} : { cause }),
@@ -18,7 +15,7 @@ export function resolveEffectiveUid() {
     catch (cause) {
         throw unavailable(cause);
     }
-    if (!isValidUid(uid)) {
+    if (!(typeof uid === "number" && Number.isSafeInteger(uid) && uid >= 0)) {
         throw unavailable();
     }
     return uid;

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

@@ -1,6 +1,7 @@
-export type FsSafeErrorCode = "already-exists" | "denied-path" | "device-path" | "hardlink" | "helper-failed" | "helper-unavailable" | "invalid-path" | "insecure-permissions" | "not-empty" | "not-file" | "not-found" | "not-owned" | "not-removable" | "outside-workspace" | "path-alias" | "path-mismatch" | "permission-unverified" | "read-failed" | "secret-exists" | "store-reentrant-update" | "symlink" | "timeout" | "too-large" | "unsupported-platform";
+export type FsSafeErrorCode = (typeof OPERATIONAL_CODE_VALUES)[number] | "already-exists" | "denied-path" | "device-path" | "hardlink" | "invalid-path" | "insecure-permissions" | "not-file" | "not-owned" | "outside-workspace" | "path-alias" | "path-mismatch" | "secret-exists" | "store-reentrant-update" | "symlink" | "too-large";
 export type FsSafeErrorCategory = "policy" | "operational";
 export type FsSafeErrorDetails = Readonly<Record<string, unknown>>;
+declare const OPERATIONAL_CODE_VALUES: readonly ["helper-failed", "helper-unavailable", "not-empty", "not-found", "not-removable", "permission-unverified", "read-failed", "timeout", "unsupported-platform"];
 export declare function categorizeFsSafeError(code: FsSafeErrorCode): FsSafeErrorCategory;
 export declare class FsSafeError extends Error {
     readonly code: FsSafeErrorCode;
@@ -11,3 +12,4 @@ export declare class FsSafeError extends Error {
         details?: FsSafeErrorDetails;
     });
 }
+export {};

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

@@ -1,4 +1,4 @@
-const OPERATIONAL_CODES = new Set([
+const OPERATIONAL_CODE_VALUES = [
     "helper-failed",
     "helper-unavailable",
     "not-empty",
@@ -8,7 +8,8 @@ const OPERATIONAL_CODES = new Set([
     "read-failed",
     "timeout",
     "unsupported-platform",
-]);
+];
+const OPERATIONAL_CODES = new Set(OPERATIONAL_CODE_VALUES);
 export function categorizeFsSafeError(code) {
     return OPERATIONAL_CODES.has(code) ? "operational" : "policy";
 }

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

@@ -22,9 +22,17 @@ export function sameFileIdentity(left, right, platform = process.platform) {
     return (!isStatValueProvablyDifferent(left.dev, right.dev, platform) &&
         !isStatValueProvablyDifferent(left.ino, right.ino, platform));
 }
+function sameCleanupStatValue(left, right) {
+    // Converting an unsafe number to bigint cannot recover an already rounded ID.
+    if (typeof left === "number" && !Number.isSafeInteger(left))
+        return false;
+    if (typeof right === "number" && !Number.isSafeInteger(right))
+        return false;
+    return sameStatValue(left, right);
+}
 export function sameFileIdentityForCleanup(left, right, platform = process.platform) {
     if (platform !== "win32") {
-        return sameStatValue(left.dev, right.dev) && sameStatValue(left.ino, right.ino);
+        return sameCleanupStatValue(left.dev, right.dev) && sameCleanupStatValue(left.ino, right.ino);
     }
     // A zero Windows device or inode is unknown, not proof that a pathname still
     // names the object we created. Cleanup must fail closed rather than delete a
@@ -44,5 +52,5 @@ export function sameFileIdentityForCleanup(left, right, platform = process.platf
     const rightIno = right.ino;
     if (isZero(rightIno))
         return false;
-    return sameStatValue(leftDev, rightDev) && sameStatValue(leftIno, rightIno);
+    return sameCleanupStatValue(leftDev, rightDev) && sameCleanupStatValue(leftIno, rightIno);
 }

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

@@ -66,7 +66,7 @@ export class SyncLockAcquisition {
         }
         catch (waitError) {
             // Exhausted backoff must preserve the filesystem denial diagnosis.
-            if (waitError.code === "file_lock_timeout")
+            if (waitError?.code === "file_lock_timeout")
                 throw error;
             throw waitError;
         }

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

@@ -30,7 +30,11 @@ export function defaultSyncShouldReclaim(snapshot, staleMs, nowMs) {
     const createdAtMs = sidecarLockPayloadCreatedAtMs(snapshot.payload);
     if (createdAtMs !== null)
         return nowMs - createdAtMs > staleMs;
-    return !snapshot.stat || nowMs - snapshot.stat.mtimeMs > staleMs;
+    if (!snapshot.stat)
+        return true;
+    const mtimeMs = "mtimeNs" in snapshot.stat
+        ? Number(snapshot.stat.mtimeNs) / 1e6 : snapshot.stat.mtimeMs;
+    return nowMs - mtimeMs > staleMs;
 }
 export function syncReclaimGuardExists(reclaimGuardPath) {
     try {

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

@@ -1,5 +1,6 @@
+import { type SyncHeldLock } from "./file-lock-sync-admission.js";
+import type { SidecarLockOptionFields } from "./sidecar-lock-types.js";
 import type { FileLockSyncHandle } from "./file-lock-sync.js";
-import { type SidecarLockSnapshot } from "./sidecar-lock-reclaim.js";
 import { type FileLockSyncRootAuthority, type FileLockSyncRootPath } from "./file-lock-sync-root.js";
 import { type FileLockSyncRootFileReceipt, type FileLockSyncRootSnapshot } from "./file-lock-sync-root-io.js";
 type RootSyncHeldLockReleaseState = "active" | "releasing" | "exit-cleaning" | "released";
@@ -7,22 +8,14 @@ type RootSyncHeldLockHandleDisposition = {
     held: RootSyncHeldLock;
     released: boolean;
 };
-export type RootSyncHeldLock = {
+export type RootSyncHeldLock = SidecarLockOptionFields<SyncHeldLock & {
     deferredExitReleases?: Set<RootSyncHeldLockHandleDisposition>;
-    fd: number | undefined;
-    lockPath: string;
-    normalizedTargetPath: string;
-    parsePayload?: (raw: string) => unknown;
-    refCount: number;
-    reentrantOwner?: string;
     releaseState: RootSyncHeldLockReleaseState;
     revision: number;
     rootAuthority: FileLockSyncRootAuthority;
     rootPath: FileLockSyncRootPath;
     rootReceipt: FileLockSyncRootFileReceipt;
-    snapshot: SidecarLockSnapshot;
-    timer?: NodeJS.Timeout;
-};
+}>;
 export declare function readRootSidecarSnapshotSync(rootPath: FileLockSyncRootPath, parsePayload?: (raw: string) => unknown, onOpenFailure?: (error: unknown) => void, expectedReceipt?: FileLockSyncRootFileReceipt): FileLockSyncRootSnapshot | null;
 export declare function getRootSyncHeldLocks(): Map<string, RootSyncHeldLock>;
 export declare function ensureRootSyncExitCleanupRegistered(): void;

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

@@ -53,9 +53,6 @@ export function getRootSyncHeldLocks() {
     }
     return globalWithState[ROOT_SYNC_HELD_LOCKS_KEY];
 }
-function existingRootSyncHeldLocks() {
-    return globalThis[ROOT_SYNC_HELD_LOCKS_KEY];
-}
 function reactivateExactHeldLock(heldLocks, held, restoreConsumedReference) {
     if (heldLocks.get(held.normalizedTargetPath) !== held || held.releaseState === "released") {
         return false;
@@ -123,7 +120,7 @@ function releaseAllRootSyncHeldLocks() {
     try {
         // A newListener callback can invoke the candidate handler before
         // registration succeeds. Do not create acquisition state in that window.
-        const heldLocks = existingRootSyncHeldLocks();
+        const heldLocks = globalThis[ROOT_SYNC_HELD_LOCKS_KEY];
         if (!heldLocks)
             return;
         getSyncLockAdmissions().clear();

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

@@ -1,4 +1,4 @@
-import { type BigIntStats, type Stats } from "node:fs";
+import { type BigIntStats } from "node:fs";
 import type { RootDefaults } from "./root-options.js";
 import { type FileLockSyncRootPath } from "./file-lock-sync-root.js";
 export type ExactIdentity = Readonly<{
@@ -14,15 +14,12 @@ export type FileLockSyncRootFileReceipt = Readonly<{
     identity: ExactIdentity;
     parent: DirectoryReceipt;
 }>;
-export type FileLockSyncRootDirectoryReceipt = Readonly<{
-    identity: ExactIdentity;
-    parent: DirectoryReceipt;
-}>;
+export type FileLockSyncRootDirectoryReceipt = FileLockSyncRootFileReceipt;
 export type FileLockSyncRootDiskSnapshot = {
     ownershipToken?: never;
     payload: unknown;
     raw: string;
-    stat: Stats;
+    stat: BigIntStats;
 };
 export type FileLockSyncRootSnapshot = Readonly<{
     receipt: FileLockSyncRootFileReceipt;

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

@@ -143,7 +143,7 @@ export function readFileLockSyncRootSnapshot(pathAuthority, options = {}) {
             throw error;
         }
         assertRegularFile(after, pathAuthority.authority.hardlinks);
-        const stat = fs.fstatSync(fd);
+        const stat = fs.fstatSync(fd, { bigint: true });
         if (expectedReceipt) {
             assertRetainedParentCurrent(pathAuthority, parent);
         }

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

@@ -1,19 +1,11 @@
 import type { FileLockSyncAcquireOptions } from "./file-lock-sync.js";
-import type { SidecarLockCompromisedInfo, SidecarLockRetryOptions, SidecarLockStaleRecovery } from "./sidecar-lock-types.js";
-type CapturedRootSyncAcquireOptions<TPayload extends Record<string, unknown>> = Readonly<{
-    compromiseCheckIntervalMs?: number;
-    lockPath?: string;
-    onCompromised?: (info: SidecarLockCompromisedInfo) => void;
+import type { SidecarLockRetryOptions } from "./sidecar-lock-types.js";
+type CapturedRootSyncAcquireOptions<TPayload extends Record<string, unknown>> = Readonly<Pick<FileLockSyncAcquireOptions<TPayload>, "compromiseCheckIntervalMs" | "lockPath" | "onCompromised" | "parsePayload" | "payload" | "reentrantOwner" | "staleRecovery" | "timeoutMs"> & {
     optionsReceiver: FileLockSyncAcquireOptions<TPayload>;
-    parsePayload?: (raw: string) => unknown;
-    payload: () => TPayload;
-    reentrantOwner?: string;
     retry: Readonly<SidecarLockRetryOptions>;
     shouldReclaim?: FileLockSyncAcquireOptions<TPayload>["shouldReclaim"];
     shouldRemoveStaleLock?: FileLockSyncAcquireOptions<TPayload>["shouldRemoveStaleLock"];
     staleMs: number;
-    staleRecovery?: SidecarLockStaleRecovery;
-    timeoutMs?: number;
 }>;
 export declare function captureRootSyncAcquireOptions<TPayload extends Record<string, unknown>>(options: FileLockSyncAcquireOptions<TPayload>): CapturedRootSyncAcquireOptions<TPayload>;
 export {};

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

@@ -1,3 +1,4 @@
+import { type DenyMutationPolicy } from "./deny-mutations.js";
 import { type RootContext } from "./root-context.js";
 import type { Root } from "./root-impl.js";
 import type { RootDefaults } from "./root-options.js";
@@ -7,10 +8,7 @@ export type FileLockSyncRootAuthority = Readonly<{
     adapter: object;
     context: RootContext;
     assertBeforeMutation?: () => void;
-    denyMutations?: Readonly<{
-        paths?: readonly string[];
-        prefixes?: readonly string[];
-    }>;
+    denyMutations?: Readonly<DenyMutationPolicy>;
     hardlinks?: RootDefaults["hardlinks"];
     mutationPolicy: RootPathResolutionPolicy;
     readPolicy: RootPathResolutionPolicy;

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

@@ -240,7 +240,7 @@ export function acquireFileLockSync(targetPath, options) {
                 createdSnapshot = {
                     raw,
                     payload,
-                    stat: fs.fstatSync(fd),
+                    stat: fs.fstatSync(fd, { bigint: true }),
                     ownershipToken,
                 };
                 createdHeld = {
@@ -280,7 +280,7 @@ export function acquireFileLockSync(targetPath, options) {
                     const failed = createdSnapshot ?? { payload: null };
                     if (!failed.stat) {
                         try {
-                            failed.stat = fs.fstatSync(fd);
+                            failed.stat = fs.fstatSync(fd, { bigint: true });
                         }
                         catch {
                             // Missing identity leaves the sidecar in place, but must not skip close.

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

@@ -1,5 +1,5 @@
 import type { Readable } from "node:stream";
-import { type SyncStoreDirectoryReceipt } from "./file-store-sync-directory.js";
+import { ensureSyncStoreDirectory, type SyncStoreDirectoryReceipt } from "./file-store-sync-directory.js";
 import { type Root } from "./root.js";
 import { prepareSecretFileWrite } from "./secret-file.js";
 export type SyncParentGuard = SyncStoreDirectoryReceipt;
@@ -23,12 +23,8 @@ export declare function ensureParentSync(params: {
     filePath: string;
     mode: number;
 }): SyncParentGuard;
-export declare function ensureStoreDirectorySync(params: {
-    rootDir: string;
-    targetDir: string;
-    mode: number;
-    messagePrefix: "private store" | "store";
-}): SyncParentGuard;
+export declare function ensureStoreDirectorySync(params: Parameters<typeof ensureSyncStoreDirectory>[0]): SyncParentGuard;
+export declare function literalStoreRootPath(relativePath: string): string;
 export declare function assertRelativePath(relativePath: string): string;
 export declare function resolveStorePath(rootDir: string, relativePath: string): string;
 export declare function assertFileStoreMaxBytes(size: number, limit: number | undefined): void;

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

@@ -7,8 +7,7 @@ import { FsSafeError } from "./errors.js";
 import { assertSyncStoreDirectoryReceipt, ensureSyncStoreDirectory, } from "./file-store-sync-directory.js";
 import { isPathInside, splitSafeRelativePath } from "./path.js";
 import { resolveOpenedFileRealPathForHandle, root } from "./root.js";
-import { ensureTrailingSep } from "./root-context.js";
-import { RootHandle } from "./root-impl.js";
+import { rootFromDirectoryGuard } from "./root-impl.js";
 import { prepareSecretFileWrite } from "./secret-file.js";
 import { resolveSecureTempRoot } from "./secure-temp-dir.js";
 import { recursiveMkdirPath } from "./recursive-mkdir-path.js";
@@ -16,7 +15,7 @@ import { readRegularFile } from "./regular-file.js";
 import { errorCauseOptions } from "./root-errors.js";
 import { assertNoWindowsPathAlias } from "./windows-path-alias.js";
 export async function ensureParentInRoot(scopedRoot, relativePath, mode) {
-    const parent = path.posix.dirname(relativePath);
+    const parent = literalStoreRootPath(path.posix.dirname(relativePath));
     if (parent === ".") {
         return;
     }
@@ -32,13 +31,7 @@ export async function openWritableStoreRoot(params) {
 export async function openPrivateStoreLockRoot(params) {
     const { parentGuard } = await prepareSecretFileWrite(params);
     // Bind to the admitted parent, never resolve a replacement into a fresh capability.
-    return new RootHandle({
-        rootDir: parentGuard.dir,
-        rootGuard: { dir: parentGuard.realPath, realPath: parentGuard.realPath, stat: parentGuard.stat },
-        rootReal: parentGuard.realPath,
-        rootWithSep: ensureTrailingSep(parentGuard.realPath),
-        rootIdentity: { dev: parentGuard.stat.dev, ino: parentGuard.stat.ino },
-    }, { hardlinks: "reject" });
+    return rootFromDirectoryGuard(parentGuard, { hardlinks: "reject" });
 }
 async function chmodDirectoryInRootBestEffort(scopedRoot, relativePath, mode) {
     const dirPath = await scopedRoot.resolve(relativePath);
@@ -120,6 +113,10 @@ export function ensureStoreDirectorySync(params) {
     assertSyncStoreDirectoryReceipt(guard);
     return guard;
 }
+// Store keys and directory-entry names are literal, unlike Root's home syntax.
+export function literalStoreRootPath(relativePath) {
+    return relativePath === "~" || relativePath.startsWith("~/") ? `./${relativePath}` : relativePath;
+}
 export function assertRelativePath(relativePath) {
     const raw = relativePath.trim();
     if (!raw || raw !== relativePath) {

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

@@ -2,6 +2,7 @@ import fsSync, {} from "node:fs";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { FsSafeError } from "./errors.js";
+import { literalStoreRootPath } from "./file-store-boundary.js";
 import { isPathInside } from "./path.js";
 import { realpathSync } from "./realpath.js";
 import { recursiveMkdirPath } from "./recursive-mkdir-path.js";
@@ -22,10 +23,10 @@ export async function pruneExpiredStoreEntries(params) {
     const rootGuard = {
         dir: rootReal,
         realPath: rootReal,
-        stat: fsSync.lstatSync(rootReal),
+        stat: fsSync.lstatSync(rootReal, { bigint: true }),
     };
     async function assertRootGuard() {
-        const stat = fsSync.lstatSync(rootGuard.dir);
+        const stat = fsSync.lstatSync(rootGuard.dir, { bigint: true });
         if (stat.isSymbolicLink() ||
             !stat.isDirectory() ||
             stat.dev !== rootGuard.stat.dev ||
@@ -35,7 +36,7 @@ export async function pruneExpiredStoreEntries(params) {
         }
     }
     async function readStableDirectory(dir) {
-        const before = observeOrNull(() => fsSync.lstatSync(dir));
+        const before = observeOrNull(() => fsSync.lstatSync(dir, { bigint: true }));
         if (!before || before.isSymbolicLink() || !before.isDirectory()) {
             return null;
         }
@@ -47,7 +48,7 @@ export async function pruneExpiredStoreEntries(params) {
         if (!entries) {
             return null;
         }
-        const after = observeOrNull(() => fsSync.lstatSync(dir));
+        const after = observeOrNull(() => fsSync.lstatSync(dir, { bigint: true }));
         if (!after || before.dev !== after.dev || before.ino !== after.ino) {
             return null;
         }
@@ -74,13 +75,13 @@ export async function pruneExpiredStoreEntries(params) {
                     await assertRootGuard();
                     // Keep empty-dir pruning on the same root-bounded remove path as files;
                     // the Root fallback handles empty directories without recursive delete.
-                    await scopedRoot.remove(relativePath, REMOVE_EMPTY_DIRECTORY_OPTIONS).catch(() => undefined);
+                    await scopedRoot.remove(literalStoreRootPath(relativePath), REMOVE_EMPTY_DIRECTORY_OPTIONS).catch(() => undefined);
                 }
                 continue;
             }
             if (stat.isFile() && now - stat.mtimeMs > params.options.ttlMs) {
                 await assertRootGuard();
-                await scopedRoot.remove(relativePath, {
+                await scopedRoot.remove(literalStoreRootPath(relativePath), {
                     assertBeforeMutation: () => {
                         // Removal preparation can outlive the expiry observation above.
                         const current = fsSync.lstatSync(fullPath);

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

@@ -12,14 +12,11 @@ export type FileStoreOptions = {
     mode?: number;
     maxBytes?: number;
 };
-export type FileStoreWriteOptions = {
+export type FileStoreWriteOptions = Partial<Pick<FileStoreOptions, "dirMode" | "mode" | "maxBytes"> & {
     /** Override store durability; defaults to the store option, then true. */
-    durable?: boolean;
-    dirMode?: number;
-    mode?: number;
-    maxBytes?: number;
-    tempPrefix?: string;
-};
+    durable: boolean;
+    tempPrefix: string;
+}>;
 export type FileStoreReadOptions = RootReadOptions & {
     encoding?: BufferEncoding;
 };

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

@@ -3,7 +3,7 @@ import { normalizeMaxBytes } from "./byte-budget.js";
 import { readFileDescriptorBoundedSync } from "./bounded-read.js";
 import { FsSafeError } from "./errors.js";
 import { pruneExpiredStoreEntries } from "./file-store-prune.js";
-import { assertFileStoreMaxBytes, assertRelativePath, ensureParentInRoot, openPrivateStoreLockRoot, openWritableStoreRoot, readFileStoreCopySource, resolveStorePath, writeStreamToTempSource, } from "./file-store-boundary.js";
+import { assertFileStoreMaxBytes, assertRelativePath, ensureParentInRoot, literalStoreRootPath, 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";
@@ -61,7 +61,7 @@ function handleSyncStoreReadOpenFailure(opened) {
     });
 }
 async function copyIntoRoot(params) {
-    const relativePath = assertRelativePath(params.relativePath);
+    const relativePath = params.relativePath;
     const destination = resolveStorePath(params.rootDir, relativePath);
     assertNoWindowsPathAlias(params.sourcePath, "filesystem", "source path uses a Windows filesystem namespace alias");
     const sourceStat = syncFs.lstatSync(params.sourcePath);
@@ -75,7 +75,7 @@ async function copyIntoRoot(params) {
         maxBytes: params.maxBytes,
     });
     await ensureParentInRoot(scopedRoot, relativePath, params.dirMode);
-    await scopedRoot.copyIn(relativePath, params.sourcePath, {
+    await scopedRoot.copyIn(literalStoreRootPath(relativePath), params.sourcePath, {
         durable: params.durable,
         maxBytes: params.maxBytes,
         mkdir: false,
@@ -97,8 +97,7 @@ export function fileStore(options) {
         return await root(rootDir, { hardlinks: "reject", maxBytes });
     }
     async function write(relativePath, data, writeOptions) {
-        const safeRelativePath = assertRelativePath(relativePath);
-        const destination = resolveStorePath(rootDir, safeRelativePath);
+        const destination = resolveStorePath(rootDir, relativePath);
         const content = Buffer.isBuffer(data) ? data : Buffer.from(data);
         const writeMaxBytes = normalizeMaxBytes(writeOptions?.maxBytes, { defaultValue: maxBytes });
         assertFileStoreMaxBytes(content.byteLength, writeMaxBytes);
@@ -121,8 +120,8 @@ export function fileStore(options) {
             dirMode: writeDirMode,
             maxBytes: writeMaxBytes,
         });
-        await ensureParentInRoot(scopedRoot, safeRelativePath, writeDirMode);
-        await scopedRoot.write(safeRelativePath, content, {
+        await ensureParentInRoot(scopedRoot, relativePath, writeDirMode);
+        await scopedRoot.write(literalStoreRootPath(relativePath), content, {
             mkdir: false,
             mode: writeMode,
             durable: writeDurable,
@@ -135,8 +134,7 @@ export function fileStore(options) {
         root: openRoot,
         write,
         writeStream: async (relativePath, stream, writeOptions) => {
-            const safeRelativePath = assertRelativePath(relativePath);
-            const destination = resolveStorePath(rootDir, safeRelativePath);
+            const destination = resolveStorePath(rootDir, relativePath);
             const configuredLimit = normalizeMaxBytes(writeOptions?.maxBytes, { defaultValue: maxBytes });
             const limit = configuredLimit ?? (privateMode ? DEFAULT_ROOT_MAX_BYTES : undefined);
             if (privateMode) {
@@ -172,7 +170,7 @@ export function fileStore(options) {
             try {
                 await copyIntoRoot({
                     rootDir,
-                    relativePath: safeRelativePath,
+                    relativePath,
                     sourcePath: staged.path,
                     durable: writeDurable,
                     maxBytes: limit,
@@ -214,17 +212,17 @@ export function fileStore(options) {
                 tempPrefix: writeOptions?.tempPrefix,
             });
         },
-        open: async (relativePath, readOptions) => await (await openRoot()).open(assertRelativePath(relativePath), readOptions),
-        read: async (relativePath, readOptions) => await (await openRoot()).read(assertRelativePath(relativePath), readOptions),
-        readBytes: async (relativePath, readOptions) => await (await openRoot()).readBytes(assertRelativePath(relativePath), readOptions),
+        open: async (relativePath, readOptions) => await (await openRoot()).open(literalStoreRootPath(assertRelativePath(relativePath)), readOptions),
+        read: async (relativePath, readOptions) => await (await openRoot()).read(literalStoreRootPath(assertRelativePath(relativePath)), readOptions),
+        readBytes: async (relativePath, readOptions) => await (await openRoot()).readBytes(literalStoreRootPath(assertRelativePath(relativePath)), readOptions),
         readText: async (relativePath, readOptions) => {
             const { encoding = "utf8", ...options } = readOptions ?? {};
-            return (await (await openRoot()).read(assertRelativePath(relativePath), options)).buffer
+            return (await (await openRoot()).read(literalStoreRootPath(assertRelativePath(relativePath)), options)).buffer
                 .toString(encoding);
         },
         readTextIfExists: async (relativePath, readOptions) => {
             try {
-                return await (await openRoot()).readText(assertRelativePath(relativePath), readOptions);
+                return await (await openRoot()).readText(literalStoreRootPath(assertRelativePath(relativePath)), readOptions);
             }
             catch (error) {
                 if (isNotFound(error)) {
@@ -235,12 +233,12 @@ export function fileStore(options) {
         },
         readJson: async (relativePath, readOptions) => {
             const { encoding = "utf8", ...options } = readOptions ?? {};
-            return JSON.parse((await (await openRoot()).read(assertRelativePath(relativePath), options)).buffer
+            return JSON.parse((await (await openRoot()).read(literalStoreRootPath(assertRelativePath(relativePath)), options)).buffer
                 .toString(encoding));
         },
         readJsonIfExists: async (relativePath, readOptions) => {
             try {
-                return await (await openRoot()).readJson(assertRelativePath(relativePath), readOptions);
+                return await (await openRoot()).readJson(literalStoreRootPath(assertRelativePath(relativePath)), readOptions);
             }
             catch (error) {
                 if (isNotFound(error)) {
@@ -250,9 +248,9 @@ export function fileStore(options) {
             }
         },
         remove: async (relativePath) => {
-            await (await openRoot()).remove(assertRelativePath(relativePath));
+            await (await openRoot()).remove(literalStoreRootPath(assertRelativePath(relativePath)));
         },
-        exists: async (relativePath) => await (await openRoot()).exists(assertRelativePath(relativePath)),
+        exists: async (relativePath) => await (await openRoot()).exists(literalStoreRootPath(assertRelativePath(relativePath))),
         writeText: async (relativePath, data, writeOptions) => await write(relativePath, data, writeOptions),
         writeJson: async (relativePath, data, writeOptions) => {
             const trailingNewline = writeOptions?.trailingNewline;
@@ -269,7 +267,7 @@ export function fileStore(options) {
                 } : {}),
                 readIfExists: async () => {
                     try {
-                        return await (await openRoot()).readJson(assertRelativePath(relativePath));
+                        return await (await openRoot()).readJson(literalStoreRootPath(relativePath));
                     }
                     catch (error) {
                         if (isNotFound(error)) {
@@ -278,7 +276,7 @@ export function fileStore(options) {
                         throw error;
                     }
                 },
-                readRequired: async () => await (await openRoot()).readJson(assertRelativePath(relativePath)),
+                readRequired: async () => await (await openRoot()).readJson(literalStoreRootPath(relativePath)),
                 write: async (value, options) => {
                     const json = stringifyJsonDocument(value, null, 2);
                     await write(relativePath, options?.trailingNewline === false ? json : `${json}\n`, { durable: options?.durable });

package/node_modules/@openclaw/fs-safe/dist/guest-native-python.js

@@ -36,15 +36,6 @@ export const GUEST_FILESYSTEM_RENAME_NO_REPLACE_PYTHON = [
     "    is_linux = sys.platform.startswith('linux')",
     "    if is_linux:",
     "        rename_fn = getattr(libc, 'renameat2', None)",
-    "        if rename_fn is None:",
-    "            os.link(",
-    "                src_basename,",
-    "                dst_basename,",
-    "                src_dir_fd=src_parent_fd,",
-    "                dst_dir_fd=dst_parent_fd,",
-    "                follow_symlinks=False,",
-    "            )",
-    "            return",
     "        flags = 1  # RENAME_NOREPLACE",
     "    elif sys.platform == 'darwin':",
     "        rename_fn = getattr(libc, 'renameatx_np', None)",
@@ -52,32 +43,33 @@ export const GUEST_FILESYSTEM_RENAME_NO_REPLACE_PYTHON = [
     "    else:",
     "        rename_fn = None",
     "        flags = 0",
-    "    if rename_fn is None:",
-    "        raise OSError(errno.ENOSYS, 'atomic no-replace rename is unavailable')",
-    "    rename_fn.argtypes = [ctypes.c_int, ctypes.c_char_p, ctypes.c_int, ctypes.c_char_p, ctypes.c_uint]",
-    "    rename_fn.restype = ctypes.c_int",
-    "    result = rename_fn(",
-    "        src_parent_fd,",
-    "        os.fsencode(src_basename),",
-    "        dst_parent_fd,",
-    "        os.fsencode(dst_basename),",
-    "        flags,",
-    "    )",
-    "    if result != 0:",
+    "    if rename_fn is not None:",
+    "        rename_fn.argtypes = [ctypes.c_int, ctypes.c_char_p, ctypes.c_int, ctypes.c_char_p, ctypes.c_uint]",
+    "        rename_fn.restype = ctypes.c_int",
+    "        result = rename_fn(",
+    "            src_parent_fd,",
+    "            os.fsencode(src_basename),",
+    "            dst_parent_fd,",
+    "            os.fsencode(dst_basename),",
+    "            flags,",
+    "        )",
+    "        if result == 0:",
+    "            return",
     "        error_code = ctypes.get_errno()",
     "        unsupported_codes = {errno.ENOSYS, errno.EINVAL, errno.ENOTSUP}",
     "        if hasattr(errno, 'EOPNOTSUPP'):",
     "            unsupported_codes.add(errno.EOPNOTSUPP)",
-    "        if is_linux and error_code in unsupported_codes:",
-    "            os.link(",
-    "                src_basename,",
-    "                dst_basename,",
-    "                src_dir_fd=src_parent_fd,",
-    "                dst_dir_fd=dst_parent_fd,",
-    "                follow_symlinks=False,",
-    "            )",
-    "            return",
-    "        raise OSError(error_code, os.strerror(error_code), dst_basename)",
+    "        if not is_linux or error_code not in unsupported_codes:",
+    "            raise OSError(error_code, os.strerror(error_code), dst_basename)",
+    "    elif not is_linux:",
+    "        raise OSError(errno.ENOSYS, 'atomic no-replace rename is unavailable')",
+    "    os.link(",
+    "        src_basename,",
+    "        dst_basename,",
+    "        src_dir_fd=src_parent_fd,",
+    "        dst_dir_fd=dst_parent_fd,",
+    "        follow_symlinks=False,",
+    "    )",
 ].join("\n");
 export const GUEST_FILESYSTEM_CREATE_EXCLUSIVE_PYTHON = [
     "def create_exclusive(parent_fd, basename, stdin_buffer):",