@openclaw/openshell-sandbox 2026.9.4 → 2026.9.6

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

@@ -1,16 +1,27 @@
+import { type BigIntStats, type Stats } from "node:fs";
 import type { DirectoryReceipt } from "./directory-durability.js";
 import type { FileIdentityStat } from "./file-identity.js";
+import type { NativeBinding } from "./native-binding.js";
+import { type MutationDirectoryObservation, type MutationDirectoryObserver } 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;
+    observeCurrent?: MutationDirectoryObserver;
+    disposeObservation?(): void;
+}>;
 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 openStagedDirectory(directory: string | DirectoryReceipt): {
+export declare function describeStagedDirectory(fd: number, pathname: string): StagedDirectorySnapshot;
+export declare function assertStagedDirectoryCurrent(receipt: StagedDirectorySnapshot): BigIntStats;
+export declare function describePolicyStagedDirectory(fd: number, pathname: string, binding?: NativeBinding): PolicyStagedDirectory;
+export declare function assertPolicyStagedDirectoryCurrent(captured: PolicyStagedDirectory): BigIntStats;
+export declare function refreshPolicyStagedDirectoryObservation(captured: PolicyStagedDirectory): MutationDirectoryObservation;
+export declare function openStagedDirectory(directory: string | DirectoryReceipt<Stats | BigIntStats>): {
     fd: number;
-    receipt: DirectorySnapshot;
+    receipt: StagedDirectorySnapshot;
 };
-export {};
-//# sourceMappingURL=staged-directory.d.ts.map

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

@@ -1,6 +1,12 @@
-import fs from "node:fs";
+import fs, {} from "node:fs";
 import path from "node:path";
+import { directoryReceiptAuthority, ownDirectoryReceipt } from "./directory-receipt.js";
 import { FsSafeError } from "./errors.js";
+import { inspectDirectoryIdentitySync } from "./directory-guard.js";
+import { nativePolicyDirectoryObserver, NativePolicyDirectoryMismatch } from "./native-policy-directory-observation.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 +19,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,21 +29,103 @@ 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, binding) {
+    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 observeCurrent = nativePolicyDirectoryObserver(binding, fd, resolved);
+    const observed = observeCurrent?.();
+    if (observed) {
+        if (!sameDirectoryMetadata(descriptor, observed.identity)) {
+            throw new NativePolicyDirectoryMismatch();
+        }
+        const directory = Object.freeze({
+            path: resolved,
+            realPath: observed.canonicalPath,
+            identity: Object.freeze({ dev: descriptor.dev, ino: descriptor.ino }),
+        });
+        return Object.freeze({
+            directory,
+            observation: checkedMutationDirectory(resolved, observed.canonicalPath, observed.identity, observeCurrent),
+            stat: descriptor,
+            observeCurrent,
+            disposeObservation: observeCurrent.dispose,
+        });
+    }
+    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 observed = captured.observeCurrent?.();
+    if (observed) {
+        if (!sameDirectoryMetadata(captured.stat, observed.identity) ||
+            observed.canonicalPath !== captured.directory.realPath) {
+            throw new FsSafeError("path-mismatch", "staging directory pathname changed");
+        }
+        return captured.stat;
+    }
+    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 observed = captured.observeCurrent?.();
+    if (observed) {
+        if (!exactIdentityMatches(captured.directory.identity, observed.identity) ||
+            observed.canonicalPath !== captured.directory.realPath) {
+            throw new FsSafeError("path-mismatch", "staging directory pathname changed");
+        }
+        return checkedMutationDirectory(captured.directory.path, observed.canonicalPath, observed.identity, captured.observeCurrent);
+    }
+    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 expected = typeof directory === "string" ? undefined : {
-        realPath: directory.realPath, dev: directory.identity.dev, ino: directory.identity.ino,
-    };
+    const expected = typeof directory === "string"
+        ? undefined
+        : directoryReceiptAuthority(ownDirectoryReceipt(directory));
+    const pathname = resolvePathPreservingWindowsRoot(typeof directory === "string" ? directory : expected.path);
     const before = fs.lstatSync(pathname, { bigint: true });
     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.identity, 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/staged-file-settlement.d.ts

@@ -0,0 +1,16 @@
+import type { BigIntStats } from "node:fs";
+import { FsSafeError } from "./errors.js";
+import type { StagedFileCleanupReceipt, StagedFileFailureDetails, StagedFilePublication, StagedFileReceipt } from "./staged-file-types.js";
+export declare function createStagedFileReceipt(directory: StagedFileReceipt["directory"], temporaryBasename: string, stat: BigIntStats): StagedFileReceipt;
+export declare function stagedFileFailure(error: unknown, details: StagedFileFailureDetails): FsSafeError;
+/** Finish owned cleanup and every close before surfacing publication evidence. */
+export declare function settleStagedFile(params: {
+    temporaryBasename: string;
+    publication: StagedFilePublication;
+    phase: StagedFileFailureDetails["phase"];
+    failure?: {
+        error: unknown;
+    };
+    cleanup: () => Promise<StagedFileCleanupReceipt["status"]>;
+    close: readonly (() => Promise<void> | void)[];
+}): Promise<void>;

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

@@ -0,0 +1,57 @@
+import { FsSafeError } from "./errors.js";
+export function createStagedFileReceipt(directory, temporaryBasename, stat) {
+    return Object.freeze({
+        directory,
+        temporaryBasename,
+        identity: Object.freeze({
+            dev: stat.dev, ino: stat.ino, mode: Number(stat.mode & 4095n),
+            nlink: stat.nlink, size: stat.size, uid: Number(stat.uid), gid: Number(stat.gid),
+            mtimeNs: stat.mtimeNs, ctimeNs: stat.ctimeNs,
+        }),
+    });
+}
+export function stagedFileFailure(error, details) {
+    const code = error instanceof FsSafeError
+        ? error.code
+        : error?.code === "EEXIST" ? "already-exists" : "helper-failed";
+    return new FsSafeError(code, `staged file ${details.phase} failed`, { cause: error, details });
+}
+/** Finish owned cleanup and every close before surfacing publication evidence. */
+export async function settleStagedFile(params) {
+    const errors = params.failure ? [params.failure.error] : [];
+    let status;
+    try {
+        status = await params.cleanup();
+    }
+    catch (error) {
+        status = "failed";
+        errors.push(error);
+    }
+    let resources = "closed";
+    for (const close of params.close) {
+        try {
+            await close();
+        }
+        catch (error) {
+            resources = "close-failed";
+            errors.push(error);
+        }
+    }
+    const incomplete = status === "failed" || status === "preserved" || resources === "close-failed";
+    // A settled pre-publication failure retains the producer/authority rejection exactly.
+    if (!incomplete && (!params.failure || params.publication.status === "not-published"))
+        return;
+    const error = errors.length > 1 ? new AggregateError(errors, "staged operation and settlement failed")
+        : errors.length === 1 ? errors[0] : new FsSafeError("not-removable", "staged cleanup preserved an unverified entry");
+    const cleanup = Object.freeze({
+        temporaryBasename: params.temporaryBasename,
+        publication: params.publication,
+        status,
+        resources,
+    });
+    throw stagedFileFailure(error, {
+        phase: params.failure ? params.phase : "cleanup",
+        publication: params.publication,
+        cleanup,
+    });
+}

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

@@ -53,4 +53,3 @@ export interface StagedFile extends AsyncDisposable {
     }): Promise<PublishedFileReceipt>;
     cleanup(): Promise<StagedFileCleanupReceipt>;
 }
-//# sourceMappingURL=staged-file-types.d.ts.map

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

@@ -0,0 +1,10 @@
+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;

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);
+}

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

@@ -1,4 +1,3 @@
 export { fileStore, fileStoreSync, type FileStore, type FileStoreOptions, type FileStorePruneOptions, type FileStoreReadOptions, type FileStoreSync, type FileStoreWriteOptions, } from "./file-store.js";
 export { jsonStore, type JsonStore, type JsonFileStoreOptions, type JsonStoreLockOptions, type JsonStoreOptions, } from "./json-store.js";
 export { ackJsonDurableQueueEntry, ensureJsonDurableQueueDirs, jsonDurableQueueEntryExists, loadJsonDurableQueueEntry, loadPendingJsonDurableQueueEntries, moveJsonDurableQueueEntryToFailed, readJsonDurableQueueEntry, resolveJsonDurableQueueEntryPaths, unlinkBestEffort, writeJsonDurableQueueEntry, type JsonDurableQueueEntryPaths, type JsonDurableQueueLoadOptions, type JsonDurableQueueReadResult, } from "./json-durable-queue.js";
-//# sourceMappingURL=store.d.ts.map

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

@@ -1,6 +1,5 @@
 import type { BigIntStats } from "node:fs";
 type ExactFileIdentity = Pick<BigIntStats, "dev" | "ino">;
 export declare function inspectFileIdentity<T extends ExactFileIdentity>(inspect: () => T | Promise<T>, expected?: ExactFileIdentity, platform?: NodeJS.Platform): Promise<T>;
-export declare function inspectFileIdentitySync<T extends ExactFileIdentity>(inspect: () => T, expected?: ExactFileIdentity, platform?: NodeJS.Platform): T;
+export declare function inspectFileIdentitySync<T extends ExactFileIdentity>(inspect: () => T, expected?: ExactFileIdentity, platform?: NodeJS.Platform, mismatch?: () => Error): T;
 export {};
-//# sourceMappingURL=strict-file-identity.d.ts.map

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

@@ -40,12 +40,49 @@ export async function inspectFileIdentity(inspect, expected, platform = process.
     }
     throw identityMismatch();
 }
-export function inspectFileIdentitySync(inspect, expected, platform = process.platform) {
-    const check = identityCheck(expected, platform);
+export function inspectFileIdentitySync(inspect, expected, platform = process.platform, mismatch = identityMismatch) {
+    let knownDev;
+    let knownIno;
+    if (expected) {
+        knownDev = expected.dev;
+        if (typeof knownDev !== "bigint")
+            throw mismatch();
+        knownIno = expected.ino;
+        if (typeof knownIno !== "bigint")
+            throw mismatch();
+        // An unknown expected device must not bypass observation of its inode.
+        if (platform === "win32" && (knownDev === 0n || knownIno === 0n))
+            throw mismatch();
+    }
     for (let attempt = 0; attempt < 2; attempt++) {
         const stat = inspect();
-        if (check(stat))
+        let complete = true;
+        // Keep dev-before-ino access and early mismatch errors without allocating
+        // a checker closure, known-component object, or field array per inspection.
+        const dev = stat.dev;
+        if (typeof dev !== "bigint")
+            throw mismatch();
+        if (platform === "win32" && dev === 0n) {
+            complete = false;
+        }
+        else {
+            if (knownDev !== undefined && knownDev !== dev)
+                throw mismatch();
+            knownDev = dev;
+        }
+        const ino = stat.ino;
+        if (typeof ino !== "bigint")
+            throw mismatch();
+        if (platform === "win32" && ino === 0n) {
+            complete = false;
+        }
+        else {
+            if (knownIno !== undefined && knownIno !== ino)
+                throw mismatch();
+            knownIno = ino;
+        }
+        if (complete)
             return stat;
     }
-    throw identityMismatch();
+    throw mismatch();
 }

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

@@ -2,4 +2,3 @@ export declare function normalizeNullableString(value: unknown): string | null;
 export declare function normalizeOptionalString(value: unknown): string | undefined;
 export declare function normalizeOptionalLowercaseString(value: unknown): string | undefined;
 export declare function normalizeLowercaseStringOrEmpty(value: unknown): string;
-//# sourceMappingURL=string-coerce.d.ts.map

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

@@ -3,4 +3,3 @@ export type SuppressedErrorLike = Error & {
     suppressed: unknown;
 };
 export declare function createSuppressedError(error: unknown, suppressed: unknown, message: string): SuppressedErrorLike;
-//# sourceMappingURL=suppressed-error.d.ts.map

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

@@ -9,4 +9,3 @@ export type AssertNoSymlinkParentsOptions = {
 };
 export declare function assertNoSymlinkParents(params: AssertNoSymlinkParentsOptions): Promise<void>;
 export declare function assertNoSymlinkParentsSync(params: AssertNoSymlinkParentsOptions): void;
-//# sourceMappingURL=symlink-parents.d.ts.map

package/node_modules/@openclaw/fs-safe/dist/symlink-parents.js

@@ -2,9 +2,14 @@ import fsSync from "node:fs";
 import path from "node:path";
 import { FsSafeError } from "./errors.js";
 import { hasNodeErrorCode, isPathRelativeEscape } from "./path.js";
+import { assertNoWindowsPathAlias, resolvePathPreservingWindowsRoot, } from "./windows-path-alias.js";
 function resolvePathWalk(params) {
-    const root = path.resolve(params.rootDir);
-    const target = path.resolve(params.targetPath);
+    const rawRootDir = params.rootDir;
+    assertNoWindowsPathAlias(rawRootDir, "filesystem", "root dir uses a Windows filesystem namespace alias");
+    const rawTargetPath = params.targetPath;
+    assertNoWindowsPathAlias(rawTargetPath, "filesystem", "target path uses a Windows filesystem namespace alias");
+    const root = resolvePathPreservingWindowsRoot(rawRootDir);
+    const target = resolvePathPreservingWindowsRoot(rawTargetPath);
     const relative = path.relative(root, target);
     if (isPathRelativeEscape(relative)) {
         if (params.allowOutsideRoot) {
@@ -21,32 +26,7 @@ function formatUnsafePath(params, current) {
     return `${params.messagePrefix ?? "Path"} must not traverse symlinked directory: ${current}`;
 }
 export async function assertNoSymlinkParents(params) {
-    const walk = resolvePathWalk(params);
-    if (!walk) {
-        return;
-    }
-    let current = walk.root;
-    for (const [index, segment] of walk.segments.entries()) {
-        current = path.join(current, segment);
-        try {
-            const stat = fsSync.lstatSync(current);
-            if (stat.isSymbolicLink()) {
-                if (params.allowRootChildSymlink && path.dirname(current) === walk.root) {
-                    continue;
-                }
-                throw new Error(formatUnsafePath(params, current));
-            }
-            if ((params.requireDirectories || index < walk.segments.length - 1) && !stat.isDirectory()) {
-                throw new FsSafeError("not-file", `${params.messagePrefix ?? "Path"} must traverse directories: ${current}`);
-            }
-        }
-        catch (err) {
-            if (hasNodeErrorCode(err, "ENOENT") && params.allowMissing !== false) {
-                return;
-            }
-            throw err;
-        }
-    }
+    assertNoSymlinkParentsSync(params);
 }
 export function assertNoSymlinkParentsSync(params) {
     const walk = resolvePathWalk(params);
@@ -69,7 +49,7 @@ export function assertNoSymlinkParentsSync(params) {
             }
         }
         catch (err) {
-            if (err.code === "ENOENT" && params.allowMissing !== false) {
+            if (hasNodeErrorCode(err, "ENOENT") && params.allowMissing !== false) {
                 return;
             }
             throw err;

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

@@ -11,4 +11,3 @@ export declare function registerTempPathForExit(tempPath: string, options?: {
 }): TempPathRegistration;
 export declare function __cleanupRegisteredTempPathsForTest(): void;
 export declare function __cleanupRegisteredTempPathForTest(tempPath: string): void;
-//# sourceMappingURL=temp-cleanup.d.ts.map

package/node_modules/@openclaw/fs-safe/dist/temp-cleanup.js

@@ -11,8 +11,9 @@ function pathStillMatchesReceipt(entry) {
         return (!entry.singleLinkFile || (current.isFile() && current.nlink === 1n)) &&
             sameFileIdentityForCleanup(current, entry.identity);
     }
-    catch (error) {
-        return !entry.singleLinkFile && error.code === "ENOENT";
+    catch {
+        // A missing pathname grants no authority over an entry created after this lookup.
+        return false;
     }
 }
 function removeRegisteredPathSync(entry) {

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

@@ -1,3 +1,5 @@
+import fsSync from "node:fs";
+import type { TempWorkspaceCleanupSafety } from "./temp-workspace-owner.js";
 export type TempFile = {
     dir: string;
     path: string;
@@ -5,6 +7,13 @@ export type TempFile = {
     cleanup: () => Promise<void>;
     [Symbol.asyncDispose](): Promise<void>;
 };
+type TempFileOptions = {
+    rootDir?: string;
+    prefix: string;
+    fileName?: string;
+    onCleanupError?: (error: unknown) => void;
+    cleanupSafety?: TempWorkspaceCleanupSafety;
+};
 export declare function sanitizeTempFileName(fileName: string): string;
 export declare function buildRandomTempFilePath(params: {
     rootDir?: string;
@@ -13,16 +22,10 @@ export declare function buildRandomTempFilePath(params: {
     now?: number;
     uuid?: string;
 }): string;
-export declare function tempFile(params: {
-    rootDir?: string;
-    prefix: string;
-    fileName?: string;
-    onCleanupError?: (error: unknown) => void;
-}): Promise<TempFile>;
-export declare function withTempFile<T>(params: {
-    rootDir?: string;
-    prefix: string;
-    fileName?: string;
-    onCleanupError?: (error: unknown) => void;
-}, fn: (tmpPath: string) => Promise<T>): Promise<T>;
-//# sourceMappingURL=temp-target.d.ts.map
+export declare function createOwnedTempFile(params: TempFileOptions): Promise<{
+    target: TempFile;
+    identity: Readonly<Pick<fsSync.BigIntStats, "dev" | "ino">>;
+}>;
+export declare function tempFile(params: TempFileOptions): Promise<TempFile>;
+export declare function withTempFile<T>(params: TempFileOptions, fn: (tmpPath: string) => Promise<T>): Promise<T>;
+export {};