@openclaw/openshell-sandbox 2026.9.4 → 2026.9.5

package/node_modules/@openclaw/fs-safe/dist/sidecar-lock-acquire.js

@@ -1,16 +1,28 @@
+import fsSync from "node:fs";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { canonicalPathFromExistingAncestor } from "./absolute-path.js";
 import { FsSafeError } from "./errors.js";
 import { fileObservation } from "./file-observation.js";
 import { readFileHandleBounded } from "./bounded-read.js";
+import { realpathSync } from "./realpath.js";
+import { recursiveMkdirPath } from "./recursive-mkdir-path.js";
 import { openSidecarRoot } from "./sidecar-lock-root.js";
 import { createNativeExclusiveFile } from "./native-operations.js";
-import { computeSidecarLockDelayMs, defaultSidecarLockShouldReclaim, isTransientLockFileDenial, maxTransientLockDenials, validateSidecarLockRetryOptions, validateSidecarLockTimeoutMs, } from "./sidecar-lock-policy.js";
+import { computeSidecarLockDelayMs, defaultSidecarLockShouldReclaim, isTransientLockFileDenial, maxTransientLockDenials, validateSidecarLockStaleMs, validateSidecarLockRetryOptions, validateSidecarLockCompromiseCheckIntervalMs, validateSidecarLockTimeoutMs, } from "./sidecar-lock-policy.js";
 import { readSidecarLockRawSnapshot, parseSidecarLockSnapshot, relativeSidecarLockPath, releaseSidecarReclaimGuard, removeSidecarLockIfUnchanged, removeStaleSidecarLockIfAllowed, serializeSidecarLockPayload, sidecarLockSnapshotStillPresent, sidecarReclaimGuardExists, tryAcquireSidecarReclaimGuard, } from "./sidecar-lock-reclaim.js";
 import { createSuppressedError } from "./suppressed-error.js";
-async function resolveNormalizedTargetPath(targetPath, lockRoot) {
-    const resolved = path.resolve(targetPath);
+import { sleep } from "./timing.js";
+import { anchorWindowsDriveRelativePath, assertNoWindowsPathAlias } from "./windows-path-alias.js";
+function isCwdIndependentAbsolutePath(filePath) {
+    if (!path.isAbsolute(filePath))
+        return false;
+    // A leading separator on Windows is rooted on the process's current drive.
+    // Drive-qualified, UNC, and namespace roots are longer and need no cwd state.
+    return process.platform !== "win32" || path.parse(filePath).root.length > 1;
+}
+async function resolveNormalizedTargetPath(resolved, lockRoot) {
+    assertNoWindowsPathAlias(resolved);
     const dir = path.dirname(resolved);
     if (lockRoot) {
         // The target is an arbitration key, not necessarily inside the lock Root.
@@ -18,23 +30,48 @@ async function resolveNormalizedTargetPath(targetPath, lockRoot) {
         await lockRoot.resolve(".");
         const parent = await canonicalPathFromExistingAncestor(dir);
         await lockRoot.resolve(".");
-        return path.join(parent, path.basename(resolved));
+        assertNoWindowsPathAlias(parent);
+        const normalized = path.join(parent, path.basename(resolved));
+        assertNoWindowsPathAlias(normalized);
+        return normalized;
     }
-    await fs.mkdir(dir, { recursive: true });
+    await fs.mkdir(recursiveMkdirPath(dir), { recursive: true });
+    let parent;
     try {
-        return path.join(await fs.realpath(dir), path.basename(resolved));
+        parent = realpathSync.native(dir);
     }
     catch {
         return resolved;
     }
+    assertNoWindowsPathAlias(parent);
+    const normalized = path.join(parent, path.basename(resolved));
+    assertNoWindowsPathAlias(normalized);
+    return normalized;
 }
 export async function acquireSidecarLock(options, context) {
     const retry = options.retry ?? {};
     validateSidecarLockRetryOptions(retry);
     validateSidecarLockTimeoutMs(options.timeoutMs);
+    validateSidecarLockStaleMs(options.staleMs);
+    validateSidecarLockCompromiseCheckIntervalMs(options.compromiseCheckIntervalMs);
+    const targetPath = options.targetPath;
+    const explicitLockPath = options.lockPath;
+    const anchoredTargetPath = anchorWindowsDriveRelativePath(targetPath);
+    assertNoWindowsPathAlias(anchoredTargetPath);
+    const resolvedTargetPath = path.resolve(anchoredTargetPath);
+    let resolvedLockPath;
+    if (explicitLockPath !== undefined) {
+        const anchoredLockPath = anchorWindowsDriveRelativePath(explicitLockPath);
+        assertNoWindowsPathAlias(anchoredLockPath);
+        resolvedLockPath = isCwdIndependentAbsolutePath(explicitLockPath)
+            ? explicitLockPath
+            : path.resolve(anchoredLockPath);
+    }
     context.ensureExitCleanupRegistered();
-    const normalizedTargetPath = await resolveNormalizedTargetPath(options.targetPath, options.lockRoot);
-    const lockPath = options.lockPath ?? `${normalizedTargetPath}.lock`;
+    const lockRoot = options.lockRoot;
+    const normalizedTargetPath = await resolveNormalizedTargetPath(resolvedTargetPath, lockRoot);
+    const lockPath = resolvedLockPath ?? `${normalizedTargetPath}.lock`;
+    assertNoWindowsPathAlias(lockPath);
     let held = context.held.get(normalizedTargetPath);
     if (held &&
         options.reentrantOwner !== undefined &&
@@ -52,7 +89,7 @@ export async function acquireSidecarLock(options, context) {
             options.reentrantOwner !== undefined &&
             held.reentrantOwner !== undefined &&
             options.reentrantOwner === held.reentrantOwner) {
-            held.refCount += 1;
+            held.refCount = (held.refCount ?? 1) + 1;
             // Retention is monotonic: any same-owner request to keep the sidecar on
             // exit upgrades the held lock; a later default acquisition never revokes it.
             if (options.retainOnExit === true) {
@@ -85,7 +122,7 @@ export async function acquireSidecarLock(options, context) {
             : Math.max(0, options.timeoutMs - elapsed);
         const delay = Math.min(computeSidecarLockDelayMs(retry, attempt), remaining);
         attempt += 1;
-        await new Promise((resolve) => setTimeout(resolve, delay));
+        await sleep(delay);
     };
     // Waiting can fail on the caller's own retry or deadline limits. Classifying
     // a denial as contention must not cost them the original diagnosis, so hand
@@ -112,8 +149,7 @@ export async function acquireSidecarLock(options, context) {
             const payload = await options.payload();
             const { raw, ownershipToken } = serializeSidecarLockPayload(payload);
             try {
-                if (options.lockRoot) {
-                    const lockRoot = options.lockRoot;
+                if (lockRoot) {
                     const relativeLockPath = relativeSidecarLockPath(lockRoot, lockPath);
                     const observation = fileObservation();
                     try {
@@ -151,7 +187,7 @@ export async function acquireSidecarLock(options, context) {
                     try {
                         handle =
                             (await createNativeExclusiveFile(lockPath, 0o600)) ??
-                                (await fs.open(lockPath, "wx"));
+                                (await fs.open(lockPath, "wx", 0o600));
                     }
                     catch (createError) {
                         lockFileCreateDenied = isTransientLockFileDenial(createError, lockPath);
@@ -159,7 +195,7 @@ export async function acquireSidecarLock(options, context) {
                     }
                     await handle.writeFile(raw, "utf8");
                 }
-                const snapshot = { raw, payload, stat: await handle.stat(), ownershipToken };
+                const snapshot = { raw, payload, stat: fsSync.fstatSync(handle.fd), ownershipToken };
                 if (snapshot.stat.nlink === 0) {
                     await handle.close();
                     handle = null;
@@ -174,7 +210,7 @@ export async function acquireSidecarLock(options, context) {
                     snapshot,
                     acquiredAt: Date.now(),
                     metadata: options.metadata ?? {},
-                    lockRoot: options.lockRoot,
+                    lockRoot,
                     retainOnExit: options.retainOnExit,
                     parsePayload: options.parsePayload,
                 };
@@ -192,7 +228,11 @@ export async function acquireSidecarLock(options, context) {
                 const returnedHandle = context.handleForHeldLock(normalizedTargetPath, createdHeld);
                 const interval = options.compromiseCheckIntervalMs;
                 if (options.onCompromised && interval !== undefined && interval > 0) {
+                    let compromiseCheckInFlight = false;
                     createdHeld.compromiseTimer = setInterval(() => {
+                        if (compromiseCheckInFlight)
+                            return;
+                        compromiseCheckInFlight = true;
                         void returnedHandle
                             .verifyStillHeld()
                             .catch(() => false)
@@ -202,6 +242,9 @@ export async function acquireSidecarLock(options, context) {
                                 createdHeld.compromiseTimer = undefined;
                                 options.onCompromised?.({ lockPath, normalizedTargetPath });
                             }
+                        })
+                            .finally(() => {
+                            compromiseCheckInFlight = false;
                         });
                     }, interval);
                     createdHeld.compromiseTimer.unref();
@@ -213,7 +256,7 @@ export async function acquireSidecarLock(options, context) {
                     if (handle) {
                         const failedSnapshot = createdSnapshot ?? { payload: null };
                         try {
-                            failedSnapshot.stat = await handle.stat();
+                            failedSnapshot.stat = fsSync.fstatSync(handle.fd);
                         }
                         catch {
                             // Best-effort cleanup of a failed exclusive create.
@@ -226,13 +269,13 @@ export async function acquireSidecarLock(options, context) {
                         // Root-created records retain the creator's byte/token receipt;
                         // partial direct writes use the exclusive descriptor's identity.
                         await removeSidecarLockIfUnchanged(lockPath, failedSnapshot, {
-                            lockRoot: options.lockRoot,
+                            lockRoot,
                             parsePayload: options.parsePayload,
                         });
                     }
                     else if (createdSnapshot) {
                         await removeSidecarLockIfUnchanged(lockPath, createdSnapshot, {
-                            lockRoot: options.lockRoot,
+                            lockRoot,
                             parsePayload: options.parsePayload,
                         });
                     }
@@ -258,7 +301,7 @@ export async function acquireSidecarLock(options, context) {
                 let lockFileOpenDenied = false;
                 try {
                     rawSnapshot = await readSidecarLockRawSnapshot(lockPath, {
-                        lockRoot: options.lockRoot,
+                        lockRoot,
                         rejectNonFile: true,
                         discardObservation: "changed",
                         onOpenFailure: (error) => { lockFileOpenDenied = isTransientLockFileDenial(error, lockPath); },
@@ -289,7 +332,7 @@ export async function acquireSidecarLock(options, context) {
                     heldByThisProcess: context.held.has(normalizedTargetPath),
                 })) {
                     if (!(await sidecarLockSnapshotStillPresent(lockPath, snapshot, {
-                        lockRoot: options.lockRoot,
+                        lockRoot,
                         parsePayload: options.parsePayload,
                     }))) {
                         await waitForRetry();
@@ -307,7 +350,7 @@ export async function acquireSidecarLock(options, context) {
                             normalizedTargetPath,
                             snapshot,
                             shouldRemoveStaleLock: options.shouldRemoveStaleLock,
-                            lockRoot: options.lockRoot,
+                            lockRoot,
                             parsePayload: options.parsePayload,
                         });
                         if (removal === "removed" || removal === "changed") {

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

@@ -1,6 +1,8 @@
 import type { SidecarLockRetryOptions } from "./sidecar-lock-types.js";
 export declare function validateSidecarLockRetryOptions(retry: SidecarLockRetryOptions): void;
 export declare function validateSidecarLockTimeoutMs(timeoutMs: number | undefined): void;
+export declare function validateSidecarLockStaleMs(staleMs: number | undefined): void;
+export declare function validateSidecarLockCompromiseCheckIntervalMs(intervalMs: number | undefined): void;
 export declare function computeSidecarLockDelayMs(retry: SidecarLockRetryOptions, attempt: number): number;
 export declare const maxTransientLockDenials = 8;
 export declare function isTransientLockFileDenial(error: unknown, lockPath: string): boolean;

package/node_modules/@openclaw/fs-safe/dist/sidecar-lock-policy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sidecar-lock-policy.d.ts","sourceRoot":"","sources":["../src/sidecar-lock-policy.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,yBAAyB,CAAC;AAQvE,wBAAgB,+BAA+B,CAAC,KAAK,EAAE,uBAAuB,GAAG,IAAI,CAkBpF;AAED,wBAAgB,4BAA4B,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CAGhF;AAED,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,uBAAuB,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAQjG;AASD,eAAO,MAAM,uBAAuB,IAAI,CAAC;AAEzC,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAGnF;AAED,wBAAgB,6BAA6B,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAU7E;AAED,wBAAsB,+BAA+B,CAAC,MAAM,EAAE;IAC5D,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;CACf,GAAG,OAAO,CAAC,OAAO,CAAC,CAQnB"}
+{"version":3,"file":"sidecar-lock-policy.d.ts","sourceRoot":"","sources":["../src/sidecar-lock-policy.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,yBAAyB,CAAC;AAUvE,wBAAgB,+BAA+B,CAAC,KAAK,EAAE,uBAAuB,GAAG,IAAI,CAkBpF;AAED,wBAAgB,4BAA4B,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CAGhF;AAED,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CAO5E;AAED,wBAAgB,4CAA4C,CAAC,UAAU,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CAOjG;AAED,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,uBAAuB,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAUjG;AASD,eAAO,MAAM,uBAAuB,IAAI,CAAC;AAEzC,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAGnF;AAED,wBAAgB,6BAA6B,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAU7E;AAED,wBAAsB,+BAA+B,CAAC,MAAM,EAAE;IAC5D,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;CACf,GAAG,OAAO,CAAC,OAAO,CAAC,CAQnB"}

package/node_modules/@openclaw/fs-safe/dist/sidecar-lock-policy.js

@@ -1,4 +1,5 @@
-import fs from "node:fs/promises";
+import fsSync from "node:fs";
+const MAX_TIMER_DELAY_MS = 2 ** 31 - 1;
 function assertFiniteNonNegative(value, label) {
     if (!Number.isFinite(value) || value < 0) {
         throw new RangeError(`${label} must be a finite non-negative number`);
@@ -27,12 +28,30 @@ export function validateSidecarLockTimeoutMs(timeoutMs) {
         return;
     assertFiniteNonNegative(timeoutMs, "lock timeoutMs");
 }
+export function validateSidecarLockStaleMs(staleMs) {
+    // The lower-level sidecar manager historically treats an omitted threshold
+    // as disabling age-based reclamation. Its public type requires a number, but
+    // retain that fail-closed runtime behavior for JavaScript callers and older
+    // consumers.
+    if (staleMs === undefined || staleMs === Number.POSITIVE_INFINITY)
+        return;
+    assertFiniteNonNegative(staleMs, "lock staleMs");
+}
+export function validateSidecarLockCompromiseCheckIntervalMs(intervalMs) {
+    if (intervalMs === undefined || intervalMs === 0)
+        return;
+    if (!Number.isFinite(intervalMs) || intervalMs < 1 || intervalMs > MAX_TIMER_DELAY_MS) {
+        throw new RangeError(`lock compromiseCheckIntervalMs must be 0 or a finite number between 1 and ${MAX_TIMER_DELAY_MS}`);
+    }
+}
 export function computeSidecarLockDelayMs(retry, attempt) {
     validateSidecarLockRetryOptions(retry);
     const minTimeout = retry.minTimeout ?? 50;
     const maxTimeout = retry.maxTimeout ?? 1000;
     const factor = retry.factor ?? 1;
-    const base = Math.min(maxTimeout, Math.max(minTimeout, minTimeout * factor ** attempt));
+    // Zero times an overflowing power is NaN, which makes Atomics.wait unbounded.
+    const scaled = minTimeout === 0 ? 0 : minTimeout * factor ** attempt;
+    const base = Math.min(maxTimeout, Math.max(minTimeout, scaled));
     const jitter = retry.randomize ? 1 + Math.random() : 1;
     return Math.min(maxTimeout, Math.round(base * jitter));
 }
@@ -63,7 +82,7 @@ export async function defaultSidecarLockShouldReclaim(params) {
     if (createdAtMs !== null)
         return params.nowMs - createdAtMs > params.staleMs;
     try {
-        return params.nowMs - (await fs.stat(params.lockPath)).mtimeMs > params.staleMs;
+        return params.nowMs - fsSync.statSync(params.lockPath).mtimeMs > params.staleMs;
     }
     catch {
         return true;

package/node_modules/@openclaw/fs-safe/dist/sidecar-lock-reclaim.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sidecar-lock-reclaim.d.ts","sourceRoot":"","sources":["../src/sidecar-lock-reclaim.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"sidecar-lock-reclaim.d.ts","sourceRoot":"","sources":["../src/sidecar-lock-reclaim.ts"],"names":[],"mappings":"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"}

package/node_modules/@openclaw/fs-safe/dist/sidecar-lock-reclaim.js

@@ -90,7 +90,13 @@ export async function readSidecarLockRawSnapshot(lockPath, options = {}) {
                 await opened.handle.close().catch(() => undefined);
             }
         }
-        const before = await fs.lstat(lockPath).catch(missingSnapshotPath);
+        let before;
+        try {
+            before = fsSync.lstatSync(lockPath);
+        }
+        catch (error) {
+            before = missingSnapshotPath(error);
+        }
         if (!before)
             return null;
         if (!before.isFile() || before.isSymbolicLink()) {
@@ -119,7 +125,7 @@ export async function readSidecarLockRawSnapshot(lockPath, options = {}) {
             options.onOpenFailure?.(error);
             throw error;
         }
-        const opened = await handle.stat();
+        const opened = fsSync.fstatSync(handle.fd);
         if (!opened.isFile()) {
             if (options.rejectNonFile) {
                 throw new FsSafeError("not-file", `sidecar lock is not a regular file: ${lockPath}`);
@@ -129,7 +135,13 @@ export async function readSidecarLockRawSnapshot(lockPath, options = {}) {
         if (!options.allowDescriptorIdentityDrift && !sameFileIdentity(before, opened))
             return null;
         const raw = (await readFileHandleBounded(handle, MAX_LOCK_PAYLOAD_BYTES)).toString("utf8");
-        const after = await fs.lstat(lockPath).catch(missingSnapshotPath);
+        let after;
+        try {
+            after = fsSync.lstatSync(lockPath);
+        }
+        catch (error) {
+            after = missingSnapshotPath(error);
+        }
         if (!after || !after.isFile() || !sameFileIdentity(before, after))
             return null;
         return { raw, stat: after };
@@ -241,7 +253,7 @@ export async function sidecarLockSnapshotStillPresent(lockPath, observed, option
 }
 export async function sidecarReclaimGuardExists(pathname) {
     try {
-        await fs.lstat(pathname);
+        fsSync.lstatSync(pathname);
         return true;
     }
     catch (err) {

package/node_modules/@openclaw/fs-safe/dist/sidecar-lock-root.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sidecar-lock-root.d.ts","sourceRoot":"","sources":["../src/sidecar-lock-root.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAC;AAGvD,wBAAsB,eAAe,CACnC,QAAQ,EAAE,IAAI,EACd,QAAQ,EAAE,MAAM,EAChB,kBAAkB,CAAC,EAAE,UAAU,GAAG,SAAS,EAC3C,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,GACvC,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC,CAuD5B"}
+{"version":3,"file":"sidecar-lock-root.d.ts","sourceRoot":"","sources":["../src/sidecar-lock-root.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAC;AAGvD,wBAAsB,eAAe,CACnC,QAAQ,EAAE,IAAI,EACd,QAAQ,EAAE,MAAM,EAChB,kBAAkB,CAAC,EAAE,UAAU,GAAG,SAAS,EAC3C,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,GACvC,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC,CAyD5B"}

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

@@ -53,13 +53,15 @@ export async function openSidecarRoot(lockRoot, relative, discardObservation, on
         if (!discardObservation || (!missing && (!completeParents || !discardable)))
             throw error;
         try {
+            const probe = fileObservation();
             try {
-                const current = await lockRoot.stat(relative);
+                const current = await probe.run(() => lockRoot.stat(relative));
                 if (!current.isFile || current.isSymbolicLink || current.nlink !== 1)
                     throw error;
             }
             catch (probeError) {
-                if (!(probeError instanceof FsSafeError && probeError.code === "not-found"))
+                if (!(probeError instanceof FsSafeError && probeError.code === "not-found") &&
+                    !probe.has(probeError, `stat-leaf-missing:${expectedRealPath}`))
                     throw probeError;
             }
             for (const { dir, stat } of parents)

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

@@ -1 +1 @@
-{"version":3,"file":"sidecar-lock.d.ts","sourceRoot":"","sources":["../src/sidecar-lock.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EACV,yBAAyB,EACzB,iBAAiB,EACjB,oBAAoB,EACpB,sBAAsB,EACvB,MAAM,yBAAyB,CAAC;AACjC,YAAY,EAAE,wBAAwB,EAAE,MAAM,2BAA2B,CAAC;AAC1E,YAAY,EACV,yBAAyB,EACzB,0BAA0B,EAC1B,iBAAiB,EACjB,oBAAoB,EACpB,uBAAuB,EACvB,wBAAwB,EACxB,sBAAsB,GACvB,MAAM,yBAAyB,CAAC;AAqIjC,0FAA0F;AAC1F,wBAAgB,uBAAuB,IAAI,OAAO,CAMjD;AAuFD,wBAAgB,wBAAwB,CAAC,GAAG,EAAE,MAAM;cAU3B,QAAQ,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,WACpD,yBAAyB,CAAC,QAAQ,CAAC,KAC3C,OAAO,CAAC,iBAAiB,CAAC;eAkBL,CAAC,EAAE,QAAQ,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,WACxD,yBAAyB,CAAC,QAAQ,CAAC,MACxC,MAAM,OAAO,CAAC,CAAC,CAAC,KACnB,OAAO,CAAC,CAAC,CAAC;iBAqBW,OAAO,CAAC,IAAI,CAAC;iBAQnB,IAAI;uBAIE,oBAAoB,EAAE;EAW/C;AAED,wBAAsB,eAAe,CAAC,CAAC,EAAE,QAAQ,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/E,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,sBAAsB,CAAC,QAAQ,CAAC,EACzC,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GACnB,OAAO,CAAC,CAAC,CAAC,CAMZ"}
+{"version":3,"file":"sidecar-lock.d.ts","sourceRoot":"","sources":["../src/sidecar-lock.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EACV,yBAAyB,EACzB,iBAAiB,EACjB,oBAAoB,EACpB,sBAAsB,EACvB,MAAM,yBAAyB,CAAC;AACjC,YAAY,EAAE,wBAAwB,EAAE,MAAM,2BAA2B,CAAC;AAC1E,YAAY,EACV,yBAAyB,EACzB,0BAA0B,EAC1B,iBAAiB,EACjB,oBAAoB,EACpB,uBAAuB,EACvB,wBAAwB,EACxB,sBAAsB,GACvB,MAAM,yBAAyB,CAAC;AAmIjC,0FAA0F;AAC1F,wBAAgB,uBAAuB,IAAI,OAAO,CAMjD;AAyFD,wBAAgB,wBAAwB,CAAC,GAAG,EAAE,MAAM;cAU3B,QAAQ,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,WACpD,yBAAyB,CAAC,QAAQ,CAAC,KAC3C,OAAO,CAAC,iBAAiB,CAAC;eAkBL,CAAC,EAAE,QAAQ,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,WACxD,yBAAyB,CAAC,QAAQ,CAAC,MACxC,MAAM,OAAO,CAAC,CAAC,CAAC,KACnB,OAAO,CAAC,CAAC,CAAC;iBAqBW,OAAO,CAAC,IAAI,CAAC;iBAQnB,IAAI;uBAIE,oBAAoB,EAAE;EAW/C;AAED,wBAAsB,eAAe,CAAC,CAAC,EAAE,QAAQ,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/E,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,sBAAsB,CAAC,QAAQ,CAAC,EACzC,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GACnB,OAAO,CAAC,CAAC,CAAC,CAMZ"}

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

@@ -37,9 +37,6 @@ function resolveManagerState(key) {
         // Backfill state created by fs-safe versions that predate reclaim guards.
         state.reclaimCleanupRegistered ??= false;
         state.reclaimGuards ??= new Set();
-        for (const held of state.held.values()) {
-            held.refCount ??= 1;
-        }
     }
     return state;
 }
@@ -85,7 +82,8 @@ function snapshotMatchesSync(lockPath, observed) {
     }
 }
 function releaseAllReclaimGuardsSync(state) {
-    for (const reclaimGuardPath of state.reclaimGuards) {
+    // Exit cleanup also visits managers created by older copies and never reopened here.
+    for (const reclaimGuardPath of state.reclaimGuards ?? []) {
         try {
             fsSync.rmdirSync(reclaimGuardPath);
             state.reclaimGuards.delete(reclaimGuardPath);
@@ -162,6 +160,8 @@ async function releaseHeldLock(state, normalizedTargetPath, held, options = {})
         await held.releasePromise;
         return true;
     }
+    // Older package copies can add holders after this manager was constructed.
+    held.refCount ??= 1;
     if (options.force) {
         held.refCount = 0;
     }

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

@@ -1,16 +1,25 @@
+import { type BigIntStats } from "node:fs";
 import type { DirectoryReceipt } from "./directory-durability.js";
 import type { FileIdentityStat } from "./file-identity.js";
+import { type MutationDirectoryObservation } from "./pinned-mutation-observation.js";
 import type { StagedFileReceipt } from "./staged-file-types.js";
-type DirectorySnapshot = StagedFileReceipt["directory"];
+export type StagedDirectorySnapshot = StagedFileReceipt["directory"];
+export type PolicyStagedDirectory = Readonly<{
+    directory: StagedDirectorySnapshot;
+    observation: MutationDirectoryObservation;
+    stat: BigIntStats;
+}>;
 export declare function exactIdentityMatches(expected: FileIdentityStat, actual: Readonly<{
     dev: bigint;
     ino: bigint;
 }>): boolean;
-export declare function describeStagedDirectory(fd: number, pathname: string): DirectorySnapshot;
-export declare function assertStagedDirectoryCurrent(receipt: DirectorySnapshot): void;
+export declare function describeStagedDirectory(fd: number, pathname: string): StagedDirectorySnapshot;
+export declare function assertStagedDirectoryCurrent(receipt: StagedDirectorySnapshot): BigIntStats;
+export declare function describePolicyStagedDirectory(fd: number, pathname: string): PolicyStagedDirectory;
+export declare function assertPolicyStagedDirectoryCurrent(captured: PolicyStagedDirectory): BigIntStats;
+export declare function refreshPolicyStagedDirectoryObservation(captured: PolicyStagedDirectory): MutationDirectoryObservation;
 export declare function openStagedDirectory(directory: string | DirectoryReceipt): {
     fd: number;
-    receipt: DirectorySnapshot;
+    receipt: StagedDirectorySnapshot;
 };
-export {};
 //# sourceMappingURL=staged-directory.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"staged-directory.d.ts","sourceRoot":"","sources":["../src/staged-directory.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAElE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAC3D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAEhE,KAAK,iBAAiB,GAAG,iBAAiB,CAAC,WAAW,CAAC,CAAC;AAExD,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,gBAAgB,EAC1B,MAAM,EAAE,QAAQ,CAAC;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC,GAC7C,OAAO,CAKT;AAED,wBAAgB,uBAAuB,CAAC,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,iBAAiB,CAYvF;AAED,wBAAgB,4BAA4B,CAAC,OAAO,EAAE,iBAAiB,GAAG,IAAI,CAQ7E;AAED,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,MAAM,GAAG,gBAAgB,GAAG;IACzE,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,iBAAiB,CAAC;CAC5B,CA+BA"}
+{"version":3,"file":"staged-directory.d.ts","sourceRoot":"","sources":["../src/staged-directory.ts"],"names":[],"mappings":"AAAA,OAAW,EAAE,KAAK,WAAW,EAAE,MAAM,SAAS,CAAC;AAE/C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAElE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAE3D,OAAO,EAEL,KAAK,4BAA4B,EAClC,MAAM,kCAAkC,CAAC;AAE1C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAGhE,MAAM,MAAM,uBAAuB,GAAG,iBAAiB,CAAC,WAAW,CAAC,CAAC;AAErE,MAAM,MAAM,qBAAqB,GAAG,QAAQ,CAAC;IAC3C,SAAS,EAAE,uBAAuB,CAAC;IACnC,WAAW,EAAE,4BAA4B,CAAC;IAC1C,IAAI,EAAE,WAAW,CAAC;CACnB,CAAC,CAAC;AAEH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,gBAAgB,EAC1B,MAAM,EAAE,QAAQ,CAAC;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC,GAC7C,OAAO,CAKT;AAED,wBAAgB,uBAAuB,CAAC,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,uBAAuB,CAY7F;AAED,wBAAgB,4BAA4B,CAAC,OAAO,EAAE,uBAAuB,GAAG,WAAW,CAS1F;AASD,wBAAgB,6BAA6B,CAC3C,EAAE,EAAE,MAAM,EACV,QAAQ,EAAE,MAAM,GACf,qBAAqB,CAwBvB;AAED,wBAAgB,kCAAkC,CAChD,QAAQ,EAAE,qBAAqB,GAC9B,WAAW,CAOb;AAED,wBAAgB,uCAAuC,CACrD,QAAQ,EAAE,qBAAqB,GAC9B,4BAA4B,CAU9B;AAED,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,MAAM,GAAG,gBAAgB,GAAG;IACzE,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,uBAAuB,CAAC;CAClC,CAiCA"}

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

@@ -1,6 +1,10 @@
-import fs from "node:fs";
+import fs, {} from "node:fs";
 import path from "node:path";
 import { FsSafeError } from "./errors.js";
+import { inspectDirectoryIdentitySync } from "./directory-guard.js";
+import { checkedMutationDirectory, } from "./pinned-mutation-observation.js";
+import { realpathSync } from "./realpath.js";
+import { resolvePathPreservingWindowsRoot } from "./windows-path-alias.js";
 export function exactIdentityMatches(expected, actual) {
     return ["dev", "ino"].every((key) => {
         const value = expected[key];
@@ -13,8 +17,8 @@ export function describeStagedDirectory(fd, pathname) {
         throw new FsSafeError("not-file", "staging parent must be a directory");
     }
     const receipt = Object.freeze({
-        path: path.resolve(pathname),
-        realPath: fs.realpathSync(pathname),
+        path: resolvePathPreservingWindowsRoot(pathname),
+        realPath: realpathSync(pathname),
         identity: Object.freeze({ dev: identity.dev, ino: identity.ino }),
     });
     assertStagedDirectoryCurrent(receipt);
@@ -23,13 +27,61 @@ export function describeStagedDirectory(fd, pathname) {
 export function assertStagedDirectoryCurrent(receipt) {
     const current = fs.lstatSync(receipt.path, { bigint: true });
     if (!current.isDirectory() || !exactIdentityMatches(receipt.identity, current) ||
-        fs.realpathSync(receipt.path) !== receipt.realPath) {
+        realpathSync(receipt.path) !== receipt.realPath) {
         throw new FsSafeError("path-mismatch", "staging directory pathname changed");
     }
+    return current;
+}
+function sameDirectoryMetadata(left, right) {
+    return left.dev === right.dev && left.ino === right.ino && left.mode === right.mode &&
+        left.nlink === right.nlink;
+}
+// The policy hot path is Node/POSIX-only. It deliberately uses native
+// canonicalization so a successful capture contains no JS realpath work.
+export function describePolicyStagedDirectory(fd, pathname) {
+    const resolved = path.resolve(pathname);
+    const descriptor = fs.fstatSync(fd, { bigint: true });
+    if (!descriptor.isDirectory()) {
+        throw new FsSafeError("not-file", "staging parent must be a directory");
+    }
+    const before = inspectDirectoryIdentitySync(resolved);
+    const canonicalPath = path.resolve(realpathSync.native(resolved));
+    const after = inspectDirectoryIdentitySync(resolved, descriptor);
+    if (canonicalPath !== resolved || !sameDirectoryMetadata(descriptor, before) ||
+        !sameDirectoryMetadata(descriptor, after) ||
+        path.resolve(realpathSync.native(resolved)) !== canonicalPath) {
+        throw new FsSafeError("path-mismatch", "staging directory pathname changed");
+    }
+    const directory = Object.freeze({
+        path: resolved,
+        realPath: canonicalPath,
+        identity: Object.freeze({ dev: descriptor.dev, ino: descriptor.ino }),
+    });
+    return Object.freeze({
+        directory,
+        observation: checkedMutationDirectory(resolved, canonicalPath, after),
+        stat: after,
+    });
+}
+export function assertPolicyStagedDirectoryCurrent(captured) {
+    const current = inspectDirectoryIdentitySync(captured.directory.path, captured.directory.identity);
+    if (!sameDirectoryMetadata(captured.stat, current) ||
+        path.resolve(realpathSync.native(captured.directory.path)) !== captured.directory.realPath) {
+        throw new FsSafeError("path-mismatch", "staging directory pathname changed");
+    }
+    return current;
+}
+export function refreshPolicyStagedDirectoryObservation(captured) {
+    const current = inspectDirectoryIdentitySync(captured.directory.path, captured.directory.identity);
+    const canonicalPath = path.resolve(realpathSync.native(captured.directory.path));
+    if (canonicalPath !== captured.directory.realPath) {
+        throw new FsSafeError("path-mismatch", "staging directory pathname changed");
+    }
+    return checkedMutationDirectory(captured.directory.path, canonicalPath, current);
 }
 export function openStagedDirectory(directory) {
     // Copy supplied facts before any asynchronous work; receipts are not authority.
-    const pathname = path.resolve(typeof directory === "string" ? directory : directory.path);
+    const pathname = resolvePathPreservingWindowsRoot(typeof directory === "string" ? directory : directory.path);
     const expected = typeof directory === "string" ? undefined : {
         realPath: directory.realPath, dev: directory.identity.dev, ino: directory.identity.ino,
     };
@@ -37,7 +89,7 @@ export function openStagedDirectory(directory) {
     if (!before.isDirectory()) {
         throw new FsSafeError("not-file", "staging parent must be a real directory");
     }
-    if (expected && (!exactIdentityMatches(expected, before) || fs.realpathSync(pathname) !== expected.realPath)) {
+    if (expected && (!exactIdentityMatches(expected, before) || realpathSync(pathname) !== expected.realPath)) {
         throw new FsSafeError("path-mismatch", "stale staging directory receipt");
     }
     const fd = fs.openSync(pathname, fs.constants.O_RDONLY | fs.constants.O_DIRECTORY | fs.constants.O_NOFOLLOW | fs.constants.O_NONBLOCK);

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

@@ -0,0 +1,2 @@
+export declare function admitStandalonePublicationPath(value: string, message?: string): string;
+//# sourceMappingURL=standalone-publication-path.d.ts.map

package/node_modules/@openclaw/fs-safe/dist/standalone-publication-path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"standalone-publication-path.d.ts","sourceRoot":"","sources":["../src/standalone-publication-path.ts"],"names":[],"mappings":"AAKA,wBAAgB,8BAA8B,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,CAItF"}

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

@@ -0,0 +1,6 @@
+import { anchorWindowsDriveRelativePath, assertNoWindowsPathAlias, } from "./windows-path-alias.js";
+export function admitStandalonePublicationPath(value, message) {
+    const admittedPath = anchorWindowsDriveRelativePath(value);
+    assertNoWindowsPathAlias(admittedPath, "filesystem", message);
+    return admittedPath;
+}

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

@@ -0,0 +1,11 @@
+import type { BigIntStats, Stats } from "node:fs";
+export type ExactStatIdentity = Pick<BigIntStats, "dev" | "ino">;
+export type StatObservationReceipt = {
+    stat: Stats | BigIntStats;
+    identity: ExactStatIdentity;
+};
+/** Operation-local metadata plus exact identity; never use projected PathStat IDs. */
+export declare function inspectStatObservationSync(inspect: (bigint: boolean) => Stats | BigIntStats, expected?: ExactStatIdentity, initial?: Stats | BigIntStats, platform?: NodeJS.Platform): StatObservationReceipt;
+/** Revalidate an exact identity without allocating a receipt that the caller will discard. */
+export declare function assertStatObservationSync(inspect: (bigint: boolean) => Stats | BigIntStats, expected: ExactStatIdentity, initial?: Stats | BigIntStats, platform?: NodeJS.Platform): Stats | BigIntStats;
+//# sourceMappingURL=stat-observation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"stat-observation.d.ts","sourceRoot":"","sources":["../src/stat-observation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAKlD,MAAM,MAAM,iBAAiB,GAAG,IAAI,CAAC,WAAW,EAAE,KAAK,GAAG,KAAK,CAAC,CAAC;AACjE,MAAM,MAAM,sBAAsB,GAAG;IACnC,IAAI,EAAE,KAAK,GAAG,WAAW,CAAC;IAC1B,QAAQ,EAAE,iBAAiB,CAAC;CAC7B,CAAC;AAqEF,sFAAsF;AACtF,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,CAAC,MAAM,EAAE,OAAO,KAAK,KAAK,GAAG,WAAW,EACjD,QAAQ,CAAC,EAAE,iBAAiB,EAC5B,OAAO,CAAC,EAAE,KAAK,GAAG,WAAW,EAC7B,QAAQ,GAAE,MAAM,CAAC,QAA2B,GAC3C,sBAAsB,CAExB;AAED,8FAA8F;AAC9F,wBAAgB,yBAAyB,CACvC,OAAO,EAAE,CAAC,MAAM,EAAE,OAAO,KAAK,KAAK,GAAG,WAAW,EACjD,QAAQ,EAAE,iBAAiB,EAC3B,OAAO,CAAC,EAAE,KAAK,GAAG,WAAW,EAC7B,QAAQ,GAAE,MAAM,CAAC,QAA2B,GAC3C,KAAK,GAAG,WAAW,CAErB"}

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

@@ -0,0 +1,64 @@
+import { FsSafeError } from "./errors.js";
+import { recordFileObservationFailure } from "./file-observation.js";
+import { inspectFileIdentitySync } from "./strict-file-identity.js";
+function identityMismatch() {
+    const error = new FsSafeError("path-mismatch", "file identity changed or could not be verified");
+    recordFileObservationFailure(error, "identity");
+    throw error;
+}
+function safeNumber(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+function safeExpected(identity) {
+    return typeof identity.dev === "bigint" && typeof identity.ino === "bigint" &&
+        identity.dev >= 0n && identity.ino >= 0n &&
+        identity.dev <= 9007199254740991n && identity.ino <= 9007199254740991n;
+}
+function observeStatSync(inspect, expected, initial, platform = process.platform, captureIdentity) {
+    if (platform === "win32" || (!initial && expected && !safeExpected(expected))) {
+        // Preserve the strict Windows unknown-ID retry, including known components
+        // and validation of the expected identity before the first observation.
+        const stat = inspectFileIdentitySync(() => {
+            const current = initial;
+            initial = undefined;
+            return (current ?? inspect(true));
+        }, expected, platform);
+        return (captureIdentity
+            ? { stat, identity: expected ?? { dev: stat.dev, ino: stat.ino } }
+            : stat);
+    }
+    const stat = initial ?? inspect(false);
+    const { dev: rawDev, ino: rawIno } = stat;
+    const numericDev = safeNumber(rawDev);
+    const numericIno = safeNumber(rawIno);
+    const dev = numericDev ? BigInt(rawDev) : typeof rawDev === "bigint" ? rawDev : undefined;
+    const ino = numericIno ? BigInt(rawIno) : typeof rawIno === "bigint" ? rawIno : undefined;
+    if (expected && ((dev !== undefined && dev !== expected.dev) ||
+        (ino !== undefined && ino !== expected.ino)))
+        identityMismatch();
+    if (numericDev && numericIno) {
+        return (captureIdentity
+            ? { stat, identity: expected ?? { dev: dev, ino: ino } }
+            : stat);
+    }
+    // An unsafe numeric component is unknown, not a rounded identity. Retain
+    // every exact component from this observation while obtaining the full ID.
+    const exact = inspectFileIdentitySync(() => {
+        const current = inspect(true);
+        if ((dev !== undefined && current.dev !== dev) ||
+            (ino !== undefined && current.ino !== ino))
+            identityMismatch();
+        return current;
+    }, expected, platform);
+    return (captureIdentity
+        ? { stat: exact, identity: expected ?? { dev: exact.dev, ino: exact.ino } }
+        : exact);
+}
+/** Operation-local metadata plus exact identity; never use projected PathStat IDs. */
+export function inspectStatObservationSync(inspect, expected, initial, platform = process.platform) {
+    return observeStatSync(inspect, expected, initial, platform, true);
+}
+/** Revalidate an exact identity without allocating a receipt that the caller will discard. */
+export function assertStatObservationSync(inspect, expected, initial, platform = process.platform) {
+    return observeStatSync(inspect, expected, initial, platform, false);
+}