@lousy-agents/mcp 5.22.0 → 5.22.1

package/dist/mcp-server.js

@@ -6559,7 +6559,7 @@ function escapeJsonPtr(str) {
 
 
 },
-2473(__unused_rspack_module, __unused_rspack___webpack_exports__, __webpack_require__) {
+4010(__unused_rspack_module, __unused_rspack___webpack_exports__, __webpack_require__) {
 // NAMESPACE OBJECT: ../../node_modules/micromark/lib/constructs.js
 var constructs_namespaceObject = {};
 __webpack_require__.r(constructs_namespaceObject);
@@ -37588,6 +37588,17 @@ function getFsSafeNativeConfig() {
             "auto",
     };
 }
+/** Internal provenance; keep the public configuration shape unchanged. */
+function getNativeModeSetting() {
+    if (overrideConfig.mode !== undefined)
+        return { mode: overrideConfig.mode, source: "programmatic configuration" };
+    for (const source of ["FS_SAFE_NATIVE_MODE", "OPENCLAW_FS_SAFE_NATIVE_MODE"]) {
+        const mode = parseMode(process.env[source]);
+        if (mode !== undefined)
+            return { mode, source };
+    }
+    return { mode: "auto", source: "default" };
+}
 function isFsSafeNativeRequired() {
     return (overrideConfig.mode ??
         parseMode(process.env.FS_SAFE_NATIVE_MODE) ??
@@ -37613,6 +37624,62 @@ let native_binding;
 let loadError;
 let attempted = false;
 let loadBinding = loadBundledBinding;
+let resolvePackage = (name) => native_require.resolve(name);
+let loadOutcome = { reason: "not-probed" };
+let selectedTarget;
+let targetDescription;
+function loadFailure(error, packageName) {
+    try {
+        return classifyLoadFailure(error, packageName);
+    }
+    catch {
+        // Diagnostic inspection must not replace an arbitrary thrown load value.
+        return { reason: "load-failed", code: "UNKNOWN" };
+    }
+}
+function classifyLoadFailure(error, packageName) {
+    const code = typeof error === "object" && error !== null && "code" in error ? error.code : undefined;
+    // Resolution must fail for the selected package itself. An exception inside
+    // an installed package (even one naming this package) is not package omission.
+    if (code === "MODULE_NOT_FOUND" && error instanceof Error &&
+        error.message.split("\n", 1)[0] === `Cannot find module '${packageName}'`) {
+        try {
+            resolvePackage(packageName);
+        }
+        catch (resolutionError) {
+            if (resolutionError instanceof Error && "code" in resolutionError &&
+                resolutionError.code === "MODULE_NOT_FOUND" &&
+                resolutionError.message.split("\n", 1)[0] === `Cannot find module '${packageName}'`) {
+                return { reason: "package-missing" };
+            }
+        }
+    }
+    // An allowlist excludes paths, secrets and arbitrary text in exception codes.
+    const knownCodes = ["ERR_DLOPEN_FAILED", "MODULE_NOT_FOUND", "ERR_MODULE_NOT_FOUND",
+        "ERR_PACKAGE_PATH_NOT_EXPORTED", "ERR_INVALID_PACKAGE_CONFIG", "EACCES", "EPERM", "ENOENT"];
+    return { reason: "load-failed", code: typeof code === "string" && knownCodes.includes(code) ? code : "UNKNOWN" };
+}
+/** Internal view of the cached load; never attempts to load an addon. */
+function getNativeFallbackDiagnostic(...capabilities) {
+    const setting = getNativeModeSetting();
+    const target = targetDescription === undefined ? bundledTarget() : selectedTarget;
+    const packageName = target === undefined ? undefined : nativePackageForTarget(target);
+    const manifest = native_require("../package.json");
+    const expected = {
+        target: targetDescription,
+        packageName,
+        packageVersion: packageName === undefined ? undefined : manifest.optionalDependencies[packageName],
+    };
+    if (setting.mode === "off")
+        return { ...expected, reason: "disabled", source: setting.source };
+    const loaded = native_binding;
+    if (loaded) {
+        const missing = capabilities.filter(name => typeof loaded[name] !== "function");
+        if (missing.length)
+            return { ...expected, reason: "capability-missing", capabilities: missing };
+    }
+    return { ...expected, ...loadOutcome };
+}
 function isMuslFilename(file) {
     return file.includes("libc.musl-") || file.includes("ld-musl-");
 }
@@ -37742,7 +37809,10 @@ function targetFor(platform, arch, musl) {
     return undefined;
 }
 function bundledTarget() {
-    return targetFor(process.platform, process.arch, isMusl());
+    const musl = isMusl();
+    selectedTarget = targetFor(process.platform, process.arch, musl);
+    targetDescription = selectedTarget ?? `${process.platform}-${process.arch}${process.platform === "linux" ? `-${musl ? "musl" : "gnu"}` : ""}`;
+    return selectedTarget;
 }
 function nativePackageForTarget(target) {
     return `@openclaw/fs-safe-${target}`;
@@ -37750,9 +37820,13 @@ function nativePackageForTarget(target) {
 function loadBundledBinding() {
     const target = bundledTarget();
     if (!target) {
+        loadOutcome = { reason: "unsupported-target" };
         throw new Error(`Unsupported OS or architecture: ${process.platform}-${process.arch}`);
     }
     const loaded = runNativeInitialization(() => native_require(nativePackageForTarget(target)));
+    if (typeof loaded.closeOwnedFd !== "function") {
+        loadOutcome = { reason: "capability-missing", capabilities: ["closeOwnedFd"] };
+    }
     captureNativeFdClose(loaded);
     return loaded;
 }
@@ -37794,11 +37868,19 @@ function native_getNativeBinding(...capabilities) {
         attempted = true;
         try {
             const loaded = loadBinding();
+            if (typeof loaded.closeOwnedFd !== "function") {
+                loadOutcome = { reason: "capability-missing", capabilities: ["closeOwnedFd"] };
+            }
             captureNativeFdClose(loaded);
             native_binding = loaded;
+            loadOutcome = { reason: "loaded" };
         }
         catch (error) {
             loadError = error;
+            if (loadOutcome.reason === "not-probed") {
+                selectedTarget ??= bundledTarget();
+                loadOutcome = loadFailure(error, nativePackageForTarget(selectedTarget ?? `${process.platform}-${process.arch}`));
+            }
         }
     }
     if (native_binding)
@@ -37819,17 +37901,25 @@ function native_requireNativeBinding(...capabilities) {
     }
     return native;
 }
-function __setNativeLoaderForTest(loader) {
+function __setNativeLoaderForTest(loader, resolver) {
     native_binding = undefined;
     loadError = undefined;
     attempted = false;
     loadBinding = loader;
+    loadOutcome = { reason: "not-probed" };
+    selectedTarget = undefined;
+    targetDescription = undefined;
+    resolvePackage = resolver ?? ((name) => native_require.resolve(name));
 }
 function __resetNativeLoaderForTest() {
     native_binding = undefined;
     loadError = undefined;
     attempted = false;
     loadBinding = loadBundledBinding;
+    loadOutcome = { reason: "not-probed" };
+    selectedTarget = undefined;
+    targetDescription = undefined;
+    resolvePackage = (name) => native_require.resolve(name);
 }
 
 ;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/file-observation.js
@@ -39314,6 +39404,15 @@ function assertDirectoryObservationGuardSync(guard) {
     }
 }
 
+;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/native-stat-identity.js
+/** Native stat identities are unsigned; Node BigIntStats preserves them as signed bits. */
+function statIdentityFromNative(value) {
+    return value <= 0x7fffffffffffffffn || process.versions.bun ? value : BigInt.asIntN(64, value);
+}
+function isNativeStatIdentity(value) {
+    return typeof value === "bigint" && value >= 0n && value <= 0xffffffffffffffffn;
+}
+
 ;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/directory-receipt.js
 
 
@@ -39818,6 +39917,7 @@ function createSuppressedError(error, suppressed, message) {
 
 
 
+
 /** Shared by tree byte copying and per-file copying; never resolves the target. */
 async function readCopyLinkTarget(source) {
     return await promises_.readlink(source, { encoding: "buffer" });
@@ -39887,7 +39987,7 @@ async function copyLinkAtParent(params, input, parent, native) {
             directory_guard_assertSyncDirectoryGuard(parent);
             if (native?.binding.createCopySymlink) {
                 const created = native.binding.createCopySymlink(native.fd, temporaryName, input.target, params.mode, input.preserveMetadata ? input.identity.atimeNs : undefined, input.preserveMetadata ? input.identity.mtimeNs : undefined);
-                identity = created;
+                identity = { dev: statIdentityFromNative(created.dev), ino: statIdentityFromNative(created.ino) };
                 if (created.errorCode)
                     throw Object.assign(new Error(created.errorMessage), { code: created.errorCode });
             }
@@ -40613,14 +40713,61 @@ function pinNodeDirectoryForModeSync(dirPath, options = {}) {
     }
 }
 
+;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/native-guidance.js
+/** Shared, path-free next steps for status reports and fallback warnings. */
+function nativeGuidance(reason, modeSource) {
+    switch (reason) {
+        case "disabled": {
+            const enable = modeSource === "programmatic configuration"
+                ? 'call configureFsSafeNative({ mode: "auto" }) or configureFsSafeNative({ mode: "require" })'
+                : `set ${modeSource}=auto or ${modeSource}=require`;
+            return `If native loading is intended, ${enable}; keep intentional off settings.`;
+        }
+        case "unsupported-target":
+            return "Portable mode is expected on this target.";
+        case "package-missing":
+            return "Reinstall with optional dependencies included: npm --include=optional, or pnpm without --no-optional / optional=false. Check the lockfile and registry mirror.";
+        case "load-failed":
+            return "Check Node architecture, Linux libc compatibility, package dependencies, and OS code-integrity policy. Reinstalling identical bytes may not help.";
+        case "capability-missing":
+            return "Use matching fs-safe and platform-package versions; some targets intentionally provide only a subset of capabilities.";
+        default:
+            return undefined;
+    }
+}
+
 ;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/native-fallback-warning.js
+
+
+
 const warnedFeatures = new Set();
+function fallbackReason(capabilities) {
+    const diagnostic = getNativeFallbackDiagnostic(...capabilities);
+    const expected = diagnostic.packageName === undefined
+        ? `No native package is published for ${diagnostic.target}.`
+        : `Expected ${diagnostic.packageName}@${diagnostic.packageVersion}.`;
+    const guidance = nativeGuidance(diagnostic.reason, getNativeModeSetting().source);
+    switch (diagnostic.reason) {
+        case "disabled":
+            return `native support is disabled by ${diagnostic.source} (disabled). ${expected} ${guidance}`;
+        case "unsupported-target":
+            return `the target ${diagnostic.target} is unsupported (unsupported-target). ${expected} ${guidance}`;
+        case "package-missing":
+            return `the selected native package could not be resolved (package-missing). ${expected} ${guidance}`;
+        case "load-failed":
+            return `the native package could not be loaded (load-failed: ${diagnostic.code}). ${expected} ${guidance}`;
+        case "capability-missing":
+            return `the native package lacks requested functions (capability-missing: ${diagnostic.capabilities.join(", ")}). ${expected} ${guidance}`;
+        default:
+            return `the requested native operation is unavailable (${diagnostic.reason}). ${expected}`;
+    }
+}
 /** Warn once per capability, without including caller paths or native error text. */
-function warnNativeFallback(feature, limitation) {
+function warnNativeFallback(feature, limitation, ...capabilities) {
     if (warnedFeatures.has(feature))
         return;
     warnedFeatures.add(feature);
-    process.emitWarning(`${feature} is using its portable fallback because native support is unavailable or disabled. ${limitation}`, { code: "FS_SAFE_NATIVE_FALLBACK", type: "FsSafeWarning" });
+    process.emitWarning(`${feature} is using its portable fallback because ${fallbackReason(capabilities)} ${limitation}`, { code: "FS_SAFE_NATIVE_FALLBACK", type: "FsSafeWarning" });
 }
 function __resetNativeFallbackWarningsForTest() {
     warnedFeatures.clear();
@@ -41459,17 +41606,17 @@ function creation_boundary_assertPrivateFileCreationAvailable() {
         typeof native.verifyPrivateWindowsFile !== "function")
         creation_boundary_unavailable();
 }
-function commandFallback() {
+function commandFallback(capability) {
     if (getFsSafeNativeConfig().mode === "require")
         creation_boundary_unavailable();
-    warnNativeFallback("windows-private-creation", "Private Windows creation uses a slower built-in system command.");
+    warnNativeFallback("windows-private-creation", "Private Windows creation launches the packaged .NET helper for each check or creation.", capability);
 }
 function creationOperation(name) {
     const native = native_getNativeBinding();
     const operation = native?.[name];
     if (typeof operation === "function")
         return operation.bind(native);
-    commandFallback();
+    commandFallback(name);
     return undefined;
 }
 /** Full Windows identity, with security validation when requested; no repairs. */
@@ -43798,6 +43945,7 @@ function mergeDenyMutationPolicies(defaultPolicy, callPolicy) {
 
 
 
+
 function getNativeDirectoryObservationBackend(enabled = true) {
     if (!enabled)
         return undefined;
@@ -43807,14 +43955,15 @@ function getNativeDirectoryObservationBackend(enabled = true) {
         : undefined;
 }
 function validateNativeDirectoryObservation(observation) {
-    if (!observation || typeof observation.dev !== "bigint" || observation.dev < 0n ||
-        typeof observation.ino !== "bigint" || observation.ino < 0n ||
+    if (!observation || !isNativeStatIdentity(observation.dev) ||
+        !isNativeStatIdentity(observation.ino) ||
         typeof observation.realPath !== "string" ||
         observation.realPath.includes("\0") ||
         (!external_node_path_.isAbsolute(observation.realPath) && !external_node_path_.win32.isAbsolute(observation.realPath))) {
         throw new errors_FsSafeError("path-mismatch", "native directory observation is invalid");
     }
-    return observation;
+    const dev = statIdentityFromNative(observation.dev), ino = statIdentityFromNative(observation.ino);
+    return dev === observation.dev && ino === observation.ino ? observation : { ...observation, dev, ino };
 }
 /** Exact identity, type, and canonical path captured from one retained handle. */
 function inspectNativeDirectoryObservation(backend, pathname, expected, platform = process.platform) {
@@ -43836,6 +43985,7 @@ function isNativeDirectoryObservationGuard(guard) {
 
 
 
+
 class NativePolicyDirectoryMismatch extends errors_FsSafeError {
     constructor(cause) {
         super("path-mismatch", "staging directory pathname changed", { cause });
@@ -43874,8 +44024,8 @@ function native_policy_directory_observation_nativePolicyDirectoryObserver(bindi
         }
         if (getFsSafeNativeConfig().mode !== mode)
             return undefined;
-        if (!observed || typeof observed.dev !== "bigint" || observed.dev < 0n || observed.dev > 0xffffffffffffffffn ||
-            typeof observed.ino !== "bigint" || observed.ino < 0n || observed.ino > 0xffffffffffffffffn ||
+        if (!observed || !isNativeStatIdentity(observed.dev) ||
+            !isNativeStatIdentity(observed.ino) ||
             typeof observed.mode !== "bigint" || observed.mode < 0n || observed.mode > 0xffffffffn ||
             typeof observed.nlink !== "bigint" || observed.nlink < 0n || observed.nlink > 0xffffffffffffffffn ||
             typeof observed.realPath !== "string" || observed.realPath.includes("\0") ||
@@ -43888,7 +44038,7 @@ function native_policy_directory_observation_nativePolicyDirectoryObserver(bindi
         return Object.freeze({
             canonicalPath: observed.realPath,
             identity: Object.freeze({
-                dev: observed.dev, ino: observed.ino, mode: observed.mode, nlink: observed.nlink,
+                dev: statIdentityFromNative(observed.dev), ino: statIdentityFromNative(observed.ino), mode: observed.mode, nlink: observed.nlink,
             }),
         });
     };
@@ -46678,6 +46828,64 @@ function __setFsSafeTestHooksForTest(hooks) {
     test_hooks_fsSafeTestHooks = hooks;
 }
 
+;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/root-native-creation-path.js
+
+
+
+
+
+
+
+
+
+function existingCreationParent(params) {
+    if (params.private || params.policy || params.assertBeforeMutation !== undefined ||
+        getFsSafeTestHooks()?.beforeRootFallbackMutation || !params.originalPath ||
+        params.directory !== external_node_path_.dirname(params.target))
+        return undefined;
+    const segments = params.originalPath.split(external_node_path_.sep === "\\" ? /[\\/]/ : "/");
+    if (segments.some(segment => !isSafePathSegment(segment, { allowDotPrefix: true }) || segment.endsWith(".")) ||
+        external_node_path_.join(params.root.rootReal, ...segments) !== params.target)
+        return undefined;
+    let rootStat;
+    root_context_assertRootIdentityCurrentSync(params.root, stat => { rootStat = stat; });
+    try {
+        const identity = directory_guard_inspectDirectoryIdentitySync(params.directory, undefined, params.directory === params.root.rootReal ? rootStat : undefined);
+        if (realpath_realpathSync.native(windows_path_alias_pathForWindowsFilesystem(params.directory)) !== params.directory)
+            return undefined;
+        return {
+            path: params.directory, identity,
+            relative: external_node_path_.relative(params.root.rootReal, params.directory).split(external_node_path_.sep).join("/"),
+            flags: (nodeDirectorySearchOnlyFlags()?.flags ?? external_node_fs_.constants.O_RDONLY) |
+                (external_node_fs_.constants.O_DIRECTORY ?? 0) | (external_node_fs_.constants.O_NOFOLLOW ?? 0),
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+function probeNativeCreationPath(root, relativePath) {
+    if (typeof relativePath !== "string")
+        return undefined;
+    const segments = relativePath.split(external_node_path_.sep === "\\" ? /[\\/]/ : "/");
+    if (segments.some(segment => !isSafePathSegment(segment, { allowDotPrefix: true }) || segment.endsWith(".")))
+        return undefined;
+    const target = external_node_path_.join(root.rootReal, ...segments);
+    root_context_assertRootIdentityCurrentSync(root);
+    try {
+        if (external_node_fs_.lstatSync(windows_path_alias_pathForWindowsFilesystem(target), { throwIfNoEntry: false }))
+            return undefined;
+    }
+    catch {
+        return undefined;
+    }
+    const parent = existingCreationParent({ root, target, directory: external_node_path_.dirname(target), mkdir: true,
+        originalPath: relativePath, resolveCurrent: async () => target });
+    if (!parent)
+        return undefined;
+    return { rootReal: root.rootReal, rootWithSep: root.rootWithSep, resolved: target, parent };
+}
+
 ;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/root-create-native.js
 var root_create_native_addDisposableResource = (undefined && undefined.__addDisposableResource) || function (env, value, async) {
     if (value !== null && value !== void 0) {
@@ -46755,6 +46963,8 @@ var root_create_native_disposeResources = (undefined && undefined.__disposeResou
 
 
 
+
+
 
 
 
@@ -46764,6 +46974,10 @@ function rootWriteQueueKey(root, relativePath) {
 function buildAtomicWriteTempPath(targetPath) {
     return external_node_path_.join(external_node_path_.dirname(targetPath), `.fs-safe-${(0,external_node_crypto_.randomUUID)()}.tmp`);
 }
+const nativeCreateCollisions = new WeakSet();
+function isNativeCreateCollision(error) {
+    return typeof error === "object" && error !== null && nativeCreateCollisions.has(error);
+}
 function root_create_native_unavailable() {
     throw new errors_FsSafeError("helper-unavailable", "native confined creation is unavailable");
 }
@@ -46771,6 +46985,60 @@ async function withNativeDirectory(params, operation, discard) {
     const binding = native_getNativeBinding("openBeneath", "mkdirChildBeneath");
     if (!binding?.openBeneath || !binding.mkdirChildBeneath || (params.private && process.platform === "win32"))
         return root_create_native_unavailable();
+    const existing = params.selectedParent ?? existingCreationParent(params);
+    if (existing) {
+        let pending;
+        try {
+            const env_1 = { stack: [], error: void 0, hasError: false };
+            try {
+                const rootOwner = root_create_native_addDisposableResource(env_1, openExactNativeRootSync(binding, {
+                    rootPath: params.root.rootReal, rootIdentity: params.root.rootIdentity,
+                }), false);
+                const close = captureNativeFdClose(binding);
+                const borrowed = existing.path === params.root.rootReal;
+                const fd = borrowed ? rootOwner.fd : binding.openBeneath(rootOwner.fd, existing.relative, existing.flags).fd;
+                const parentOwner = root_create_native_addDisposableResource(env_1, { [Symbol.dispose]() { if (!borrowed)
+                        close(fd); } }, false);
+                strict_file_identity_inspectFileIdentitySync(() => borrowed ? rootOwner.stat : external_node_fs_.fstatSync(fd, { bigint: true }), existing.identity);
+                verifyMkdirDirectory(binding, fd, existing.path);
+                const guard = { dir: existing.path, realPath: existing.path, stat: existing.identity };
+                const assertCurrent = () => {
+                    let currentRoot;
+                    root_context_assertRootIdentityCurrentSync(params.root, stat => { currentRoot = stat; });
+                    if (borrowed) {
+                        // Root and parent are the same name in this synchronous fence.
+                        directory_guard_inspectDirectoryIdentitySync(existing.path, existing.identity, currentRoot);
+                        if (realpath_realpathSync.native(windows_path_alias_pathForWindowsFilesystem(existing.path)) !== existing.path) {
+                            throw new errors_FsSafeError("path-mismatch", "directory changed during operation");
+                        }
+                    }
+                    else {
+                        directory_guard_assertSyncDirectoryGuard(guard);
+                    }
+                };
+                pending = { value: await operation(binding, fd, assertCurrent) };
+                return pending.value;
+            }
+            catch (e_1) {
+                env_1.error = e_1;
+                env_1.hasError = true;
+            }
+            finally {
+                root_create_native_disposeResources(env_1);
+            }
+        }
+        catch (error) {
+            if (pending && discard) {
+                try {
+                    await discard(pending.value);
+                }
+                catch (cleanupError) {
+                    throw createSuppressedError(cleanupError, error, "creation handoff and cleanup failed");
+                }
+            }
+            throw error;
+        }
+    }
     const directoryTarget = params.directory === params.target;
     const canonicalTarget = async (target) => directoryTarget
         ? await resolvePathViaExistingAncestor(target)
@@ -46787,14 +47055,14 @@ async function withNativeDirectory(params, operation, discard) {
     const close = captureNativeFdClose(binding);
     let pending;
     try {
-        const env_1 = { stack: [], error: void 0, hasError: false };
+        const env_2 = { stack: [], error: void 0, hasError: false };
         try {
             const admitted = await openNativeRootAdmission(binding, {
                 rootPath: params.root.rootReal, rootIdentity: params.root.rootIdentity, operation: "create", reportCloseErrors: true, searchOnly: true,
             });
-            const rootOwner = root_create_native_addDisposableResource(env_1, admitted.root, true);
+            const rootOwner = root_create_native_addDisposableResource(env_2, admitted.root, true);
             const descriptors = [];
-            const directoryOwner = root_create_native_addDisposableResource(env_1, { [Symbol.dispose]() {
+            const directoryOwner = root_create_native_addDisposableResource(env_2, { [Symbol.dispose]() {
                     const errors = [];
                     for (const fd of descriptors.reverse())
                         try {
@@ -46892,12 +47160,12 @@ async function withNativeDirectory(params, operation, discard) {
             pending = { value: await operation(binding, current, assertCurrent) };
             return pending.value;
         }
-        catch (e_1) {
-            env_1.error = e_1;
-            env_1.hasError = true;
+        catch (e_2) {
+            env_2.error = e_2;
+            env_2.hasError = true;
         }
         finally {
-            const result_1 = root_create_native_disposeResources(env_1);
+            const result_1 = root_create_native_disposeResources(env_2);
             if (result_1)
                 await result_1;
         }
@@ -46976,33 +47244,77 @@ function verifyMkdirDirectory(binding, fd, pathname) {
     describePolicyStagedDirectory(fd, pathname);
 }
 function ensureNativeRootCurrent(root) {
-    const env_2 = { stack: [], error: void 0, hasError: false };
+    root_context_assertRootIdentityCurrentSync(root);
+    const binding = native_getNativeBinding("openBeneath", "mkdirChildBeneath");
+    if (!binding?.openBeneath || !binding.mkdirChildBeneath)
+        return root_create_native_unavailable();
+    if (binding.verifyRootDirectory) {
+        const closeNative = captureNativeFdClose(binding);
+        const failure = binding.verifyRootDirectory(root.rootReal, root.rootIdentity.dev, root.rootIdentity.ino);
+        if (failure === null)
+            return;
+        if (failure?.fallbackFd !== undefined && failure.fallbackFd !== null) {
+            const env_3 = { stack: [], error: void 0, hasError: false };
+            try {
+                const fd = failure.fallbackFd;
+                if (!Number.isInteger(fd) || fd < 0)
+                    throw new errors_FsSafeError("helper-failed", "invalid root fallback descriptor");
+                const owner = root_create_native_addDisposableResource(env_3, { [Symbol.dispose]() { closeNative(fd); } }, false);
+                if (failure.errorCode || failure.closeErrorCode)
+                    throw new errors_FsSafeError("helper-failed", "invalid root verification result");
+                ensureNativeRootCurrentLegacy(root, binding);
+                return;
+            }
+            catch (e_3) {
+                env_3.error = e_3;
+                env_3.hasError = true;
+            }
+            finally {
+                root_create_native_disposeResources(env_3);
+            }
+        }
+        const error = failure?.errorCode ? rootVerificationError(failure.errorCode, failure.errorMessage, failure.errorErrno) : undefined;
+        const closeError = failure?.closeErrorCode ? Object.assign(new Error(failure.closeErrorMessage), {
+            code: failure.closeErrorCode,
+            ...(typeof failure.closeErrorErrno === "number" ? { errno: failure.closeErrorErrno } : {}),
+        }) : undefined;
+        if (error && closeError)
+            throw createSuppressedError(closeError, error, "root verification and close failed");
+        if (error || closeError)
+            throw error ?? closeError;
+        throw new errors_FsSafeError("helper-failed", "invalid root verification result");
+    }
+    ensureNativeRootCurrentLegacy(root, binding);
+}
+function rootVerificationError(code, message, errno) {
+    const error = Object.assign(new Error(message), { code, ...(typeof errno === "number" ? { errno } : {}) });
+    return code === "path-mismatch" || code === "OBSERVATION_REDIRECTED"
+        ? new errors_FsSafeError("path-mismatch", "root identity changed during verification", { cause: error }) : error;
+}
+function ensureNativeRootCurrentLegacy(root, binding) {
+    const env_4 = { stack: [], error: void 0, hasError: false };
     try {
-        root_context_assertRootIdentityCurrentSync(root);
-        const binding = native_getNativeBinding("openBeneath", "mkdirChildBeneath");
-        if (!binding?.openBeneath || !binding.mkdirChildBeneath)
-            return root_create_native_unavailable();
-        const rootOwner = root_create_native_addDisposableResource(env_2, openExactNativeRootSync(binding, {
+        const rootOwner = root_create_native_addDisposableResource(env_4, openExactNativeRootSync(binding, {
             rootPath: root.rootReal, rootIdentity: root.rootIdentity,
         }), false);
         verifyMkdirDirectory(binding, rootOwner.fd, root.rootReal);
         root_context_assertRootIdentityCurrentSync(root);
     }
-    catch (e_2) {
-        env_2.error = e_2;
-        env_2.hasError = true;
+    catch (e_4) {
+        env_4.error = e_4;
+        env_4.hasError = true;
     }
     finally {
-        root_create_native_disposeResources(env_2);
+        root_create_native_disposeResources(env_4);
     }
 }
 function mkdirNativeRootChild(params) {
-    const env_3 = { stack: [], error: void 0, hasError: false };
+    const env_5 = { stack: [], error: void 0, hasError: false };
     try {
         const binding = native_getNativeBinding("openBeneath", "mkdirChildBeneath");
         if (!binding?.openBeneath || !binding.mkdirChildBeneath)
             return root_create_native_unavailable();
-        const rootOwner = root_create_native_addDisposableResource(env_3, openExactNativeRootSync(binding, {
+        const rootOwner = root_create_native_addDisposableResource(env_5, openExactNativeRootSync(binding, {
             rootPath: params.root.rootReal, rootIdentity: params.root.rootIdentity,
         }), false);
         verifyMkdirDirectory(binding, rootOwner.fd, params.root.rootReal);
@@ -47015,17 +47327,17 @@ function mkdirNativeRootChild(params) {
             ? binding.mkdirOpenChildBeneath(rootOwner.fd, name, 0o777, flags).fd
             : (binding.mkdirChildBeneath(rootOwner.fd, name, 0o777), binding.openBeneath(rootOwner.fd, name, flags).fd);
         const close = captureNativeFdClose(binding);
-        const childOwner = root_create_native_addDisposableResource(env_3, { [Symbol.dispose]() { close(child); } }, false);
+        const childOwner = root_create_native_addDisposableResource(env_5, { [Symbol.dispose]() { close(child); } }, false);
         root_context_assertRootIdentityCurrentSync(params.root);
         verifyMkdirDirectory(binding, child, params.target);
         verifyMkdirDirectory(binding, rootOwner.fd, params.root.rootReal);
     }
-    catch (e_3) {
-        env_3.error = e_3;
-        env_3.hasError = true;
+    catch (e_5) {
+        env_5.error = e_5;
+        env_5.hasError = true;
     }
     finally {
-        root_create_native_disposeResources(env_3);
+        root_create_native_disposeResources(env_5);
     }
 }
 async function tryOpenCreateRootNative(params) {
@@ -47047,7 +47359,7 @@ async function tryOpenCreateRootNative(params) {
     if (creationMode() === undefined)
         return root_create_native_unavailable();
     return await withNativeDirectory(params, async (binding, parent, assertCurrent) => {
-        const env_4 = { stack: [], error: void 0, hasError: false };
+        const env_6 = { stack: [], error: void 0, hasError: false };
         try {
             params.assertBeforeMutation?.();
             assertCurrent();
@@ -47057,13 +47369,21 @@ async function tryOpenCreateRootNative(params) {
             // Native creation owns the only O_CREAT dispatch. The subsequent Node open
             // carries neither O_CREAT nor O_TRUNC and must match this retained inode.
             const close = captureNativeFdClose(binding);
-            const fd = binding.openCreateBeneath(parent, external_node_path_.basename(params.target), params.flags, params.mode & 0o7777);
+            let fd;
+            try {
+                fd = binding.openCreateBeneath(parent, external_node_path_.basename(params.target), params.flags, params.mode & 0o7777);
+            }
+            catch (error) {
+                if (hasNodeErrorCode(error, "EEXIST") && typeof error === "object" && error !== null)
+                    nativeCreateCollisions.add(error);
+                throw error;
+            }
             let rawOpen = true;
             const closeRaw = () => { if (rawOpen) {
                 rawOpen = false;
                 close(fd);
             } };
-            const owner = root_create_native_addDisposableResource(env_4, { [Symbol.dispose]: closeRaw }, false);
+            const owner = root_create_native_addDisposableResource(env_6, { [Symbol.dispose]: closeRaw }, false);
             try {
                 const identity = strict_file_identity_inspectFileIdentitySync(() => external_node_fs_.fstatSync(fd, { bigint: true }));
                 if (!identity.isFile() || identity.nlink !== 1n)
@@ -47117,26 +47437,26 @@ async function tryOpenCreateRootNative(params) {
                 throw error;
             }
         }
-        catch (e_4) {
-            env_4.error = e_4;
-            env_4.hasError = true;
+        catch (e_6) {
+            env_6.error = e_6;
+            env_6.hasError = true;
         }
         finally {
-            root_create_native_disposeResources(env_4);
+            root_create_native_disposeResources(env_6);
         }
     }, async (created) => {
-        const env_5 = { stack: [], error: void 0, hasError: false };
+        const env_7 = { stack: [], error: void 0, hasError: false };
         try {
-            const handle = root_create_native_addDisposableResource(env_5, created.handle, true);
-            const parent = root_create_native_addDisposableResource(env_5, { [Symbol.dispose]: created.releaseCreationParent }, false);
+            const handle = root_create_native_addDisposableResource(env_7, created.handle, true);
+            const parent = root_create_native_addDisposableResource(env_7, { [Symbol.dispose]: created.releaseCreationParent }, false);
             await created.cleanupCreated();
         }
-        catch (e_5) {
-            env_5.error = e_5;
-            env_5.hasError = true;
+        catch (e_7) {
+            env_7.error = e_7;
+            env_7.hasError = true;
         }
         finally {
-            const result_2 = root_create_native_disposeResources(env_5);
+            const result_2 = root_create_native_disposeResources(env_7);
             if (result_2)
                 await result_2;
         }
@@ -47872,7 +48192,7 @@ function privateDirectoryBackend() {
     if (getFsSafeNativeConfig().mode === "require") {
         throw new errors_FsSafeError("helper-unavailable", "private directory creation requires an up-to-date native parent identity capability");
     }
-    warnNativeFallback("windows-private-directory", "Private Windows directory creation uses a slower built-in system command.");
+    warnNativeFallback("windows-private-directory", "Private Windows directory creation launches the packaged .NET helper for each check or creation.", "createPrivateDirectoryWithParentIdentity");
     return undefined;
 }
 async function createDirectory(targetPath, options = {}) {
@@ -53682,6 +54002,247 @@ async function read_opened_file_readOpenedFileSafely(params) {
     };
 }
 
+;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/root-mkdir-native.js
+var root_mkdir_native_addDisposableResource = (undefined && undefined.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var root_mkdir_native_disposeResources = (undefined && undefined.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+function tryMkdirNativeParents(root, relativePath) {
+    try {
+        return mkdirOrdinaryNativeParents(root, relativePath);
+    }
+    catch (error) {
+        if (hasNodeErrorCode(error, "ENOTDIR"))
+            throw root_errors_directoryComponentNotDirectoryError(error);
+        throw error;
+    }
+}
+function mkdirOrdinaryNativeParents(root, relativePath) {
+    if (getFsSafeTestHooks()?.beforeRootFallbackMutation)
+        return false;
+    const segments = relativePath.split(external_node_path_.sep === "\\" ? /[\\/]/ : "/");
+    if (segments.length < 2 || segments.some(segment => !isSafePathSegment(segment, { allowDotPrefix: true }) || segment.endsWith(".")))
+        return false;
+    let rootStat;
+    root_context_assertRootIdentityCurrentSync(root, stat => { rootStat = stat; });
+    const target = external_node_path_.join(root.rootReal, ...segments);
+    const parentPath = external_node_path_.dirname(target);
+    try {
+        const child = external_node_fs_.lstatSync(windows_path_alias_pathForWindowsFilesystem(target), { throwIfNoEntry: false });
+        if (child && (!child.isDirectory() || realpath_realpathSync.native(windows_path_alias_pathForWindowsFilesystem(target)) !== target))
+            return false;
+    }
+    catch {
+        return false;
+    }
+    let parentIdentity;
+    try {
+        parentIdentity = directory_guard_inspectDirectoryIdentitySync(parentPath);
+    }
+    catch (error) {
+        // Reuse this exact Root snapshot and failed parent observation without an
+        // intervening await. All opened ancestors still receive fresh native fences.
+        return hasNodeErrorCode(error, "ENOENT") ? mkdirMissingParents(root, segments, rootStat) : false;
+    }
+    try {
+        if (realpath_realpathSync.native(windows_path_alias_pathForWindowsFilesystem(parentPath)) !== parentPath)
+            return false;
+    }
+    catch {
+        return false;
+    }
+    return mkdirExistingParent(root, segments, parentIdentity);
+}
+/** Ordinary missing suffixes need no policy callbacks or repeated path resolution. */
+function mkdirMissingParents(root, segments, rootStat) {
+    const binding = native_getNativeBinding("openBeneath", "mkdirChildBeneath");
+    if (!binding?.openBeneath || !binding.mkdirOpenChildBeneath)
+        return false;
+    let parentDepth = segments.length - 2;
+    let parentPath;
+    let parentIdentity;
+    for (;;) {
+        parentPath = external_node_path_.join(root.rootReal, ...segments.slice(0, parentDepth));
+        try {
+            parentIdentity = directory_guard_inspectDirectoryIdentitySync(parentPath, undefined, parentDepth === 0 ? rootStat : undefined);
+            if (realpath_realpathSync.native(windows_path_alias_pathForWindowsFilesystem(parentPath)) !== parentPath)
+                return false;
+            break;
+        }
+        catch (error) {
+            if (!hasNodeErrorCode(error, "ENOENT") || parentDepth === 0)
+                return false;
+            parentDepth--;
+        }
+    }
+    try {
+        const env_1 = { stack: [], error: void 0, hasError: false };
+        try {
+            const rootOwner = root_mkdir_native_addDisposableResource(env_1, openExactNativeRootSync(binding, {
+                rootPath: root.rootReal, rootIdentity: root.rootIdentity,
+            }), false);
+            const close = captureNativeFdClose(binding);
+            const directories = [];
+            const directoryOwner = root_mkdir_native_addDisposableResource(env_1, { [Symbol.dispose]() {
+                    const errors = [];
+                    for (const directory of directories.toReversed()) {
+                        try {
+                            close(directory.fd);
+                        }
+                        catch (error) {
+                            errors.push(error);
+                        }
+                    }
+                    if (errors.length)
+                        throw new AggregateError(errors, "mkdir directory close failed");
+                } }, false);
+            const flags = (nodeDirectorySearchOnlyFlags()?.flags ?? external_node_fs_.constants.O_RDONLY) |
+                (external_node_fs_.constants.O_DIRECTORY ?? 0) | (external_node_fs_.constants.O_NOFOLLOW ?? 0);
+            let current = rootOwner.fd;
+            if (parentDepth > 0) {
+                current = binding.openBeneath(rootOwner.fd, segments.slice(0, parentDepth).join("/"), flags).fd;
+                directories.push({ fd: current, pathname: parentPath });
+                strict_file_identity_inspectFileIdentitySync(() => external_node_fs_.fstatSync(current, { bigint: true }), parentIdentity);
+            }
+            const assertCurrent = () => {
+                root_context_assertRootIdentityCurrentSync(root);
+                for (const directory of directories)
+                    verifyMkdirDirectory(binding, directory.fd, directory.pathname);
+                verifyMkdirDirectory(binding, rootOwner.fd, root.rootReal);
+            };
+            assertCurrent();
+            for (const segment of segments.slice(parentDepth)) {
+                const child = binding.mkdirOpenChildBeneath(current, segment, 0o777, flags);
+                parentPath = external_node_path_.join(parentPath, segment);
+                directories.push({ fd: child.fd, pathname: parentPath });
+                // Retain every ancestor until the complete suffix is admitted. The
+                // post-create fence also precedes the next synchronous child mutation.
+                assertCurrent();
+                current = child.fd;
+            }
+            return true;
+        }
+        catch (e_1) {
+            env_1.error = e_1;
+            env_1.hasError = true;
+        }
+        finally {
+            root_mkdir_native_disposeResources(env_1);
+        }
+    }
+    catch (error) {
+        if (hasNodeErrorCode(error, "ENOTDIR"))
+            throw root_errors_directoryComponentNotDirectoryError(error);
+        throw error;
+    }
+}
+function mkdirExistingParent(root, segments, parentIdentity) {
+    const env_2 = { stack: [], error: void 0, hasError: false };
+    try {
+        const target = external_node_path_.join(root.rootReal, ...segments);
+        const parentPath = external_node_path_.dirname(target);
+        const binding = native_getNativeBinding("openBeneath", "mkdirChildBeneath");
+        if (!binding?.openBeneath || !binding.mkdirChildBeneath) {
+            throw new errors_FsSafeError("helper-unavailable", "native confined creation is unavailable");
+        }
+        const rootOwner = root_mkdir_native_addDisposableResource(env_2, openExactNativeRootSync(binding, {
+            rootPath: root.rootReal, rootIdentity: root.rootIdentity,
+        }), false);
+        verifyMkdirDirectory(binding, rootOwner.fd, root.rootReal);
+        const flags = (nodeDirectorySearchOnlyFlags()?.flags ?? external_node_fs_.constants.O_RDONLY) |
+            (external_node_fs_.constants.O_DIRECTORY ?? 0) | (external_node_fs_.constants.O_NOFOLLOW ?? 0);
+        const close = captureNativeFdClose(binding);
+        const parent = binding.openBeneath(rootOwner.fd, segments.slice(0, -1).join("/"), flags).fd;
+        const parentOwner = root_mkdir_native_addDisposableResource(env_2, { [Symbol.dispose]() { close(parent); } }, false);
+        strict_file_identity_inspectFileIdentitySync(() => external_node_fs_.fstatSync(parent, { bigint: true }), parentIdentity);
+        verifyMkdirDirectory(binding, parent, parentPath);
+        root_context_assertRootIdentityCurrentSync(root);
+        const name = segments.at(-1);
+        const child = binding.mkdirOpenChildBeneath
+            ? binding.mkdirOpenChildBeneath(parent, name, 0o777, flags).fd
+            : (binding.mkdirChildBeneath(parent, name, 0o777), binding.openBeneath(parent, name, flags).fd);
+        const childOwner = root_mkdir_native_addDisposableResource(env_2, { [Symbol.dispose]() { close(child); } }, false);
+        root_context_assertRootIdentityCurrentSync(root);
+        verifyMkdirDirectory(binding, child, target);
+        directory_guard_inspectDirectoryIdentitySync(parentPath, parentIdentity);
+        verifyMkdirDirectory(binding, parent, parentPath);
+        verifyMkdirDirectory(binding, rootOwner.fd, root.rootReal);
+        return true;
+    }
+    catch (e_2) {
+        env_2.error = e_2;
+        env_2.hasError = true;
+    }
+    finally {
+        root_mkdir_native_disposeResources(env_2);
+    }
+}
+
 ;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/write-open-flags.js
 
 
@@ -56754,6 +57315,7 @@ var root_impl_disposeResources = (undefined && undefined.__disposeResources) ||
 
 
 
+
 
 
 function logWarn(message) {
@@ -57154,7 +57716,9 @@ async function openWritableFileInRoot(root, params, options) {
             denyMutations: params.denyMutations,
             mutationSymlinks: params.mutationSymlinks,
         });
-    const { resolved } = guardedTarget?.resolvedPath ?? await resolveGuardedWritePathInRoot(root, {
+    const creationProbe = requireNative && !guardedTarget && params.assertBeforeMutation === undefined && options?.createIfMissing !== false
+        ? probeNativeCreationPath(root, params.relativePath) : undefined;
+    const { resolved } = creationProbe ?? guardedTarget?.resolvedPath ?? await resolveGuardedWritePathInRoot(root, {
         relativePath: params.relativePath,
     });
     const resolveCurrent = async () => (await resolveGuardedWritePathInRoot(root, {
@@ -57183,27 +57747,30 @@ async function openWritableFileInRoot(root, params, options) {
     let ioPath = nativeCreatesParents ? resolved : prepared?.targetPath ?? (params.mkdir === false ? resolved :
         await prepareRootWriteTarget(root, resolved, params.assertBeforeMutation));
     const operationTargetPath = ioPath;
-    try {
-        assertFinalSymlinkRejected(ioPath, params.mutationSymlinks !== undefined);
-        const resolvedRealPath = params.mutationSymlinks === undefined ? realpath_realpathSync.native(ioPath) : ioPath;
-        const admittedRealPath = root_boundary_admitPathInsideRoot({
-            rootPath: root.rootReal,
-            candidatePath: resolvedRealPath,
-            rootIdentity: root.rootIdentity,
-        });
-        if (!admittedRealPath) {
-            throw root_errors_outsideWorkspaceError();
-        }
-        ioPath = admittedRealPath.path;
-    }
-    catch (err) {
-        if (err instanceof errors_FsSafeError) {
-            throw err;
+    let observedMissing = Boolean(creationProbe);
+    if (!creationProbe)
+        try {
+            assertFinalSymlinkRejected(ioPath, params.mutationSymlinks !== undefined);
+            const resolvedRealPath = params.mutationSymlinks === undefined ? realpath_realpathSync.native(ioPath) : ioPath;
+            const admittedRealPath = root_boundary_admitPathInsideRoot({
+                rootPath: root.rootReal,
+                candidatePath: resolvedRealPath,
+                rootIdentity: root.rootIdentity,
+            });
+            if (!admittedRealPath) {
+                throw root_errors_outsideWorkspaceError();
+            }
+            ioPath = admittedRealPath.path;
         }
-        if (!path_isNotFoundPathError(err)) {
-            throw err;
+        catch (err) {
+            if (err instanceof errors_FsSafeError) {
+                throw err;
+            }
+            if (!path_isNotFoundPathError(err)) {
+                throw err;
+            }
+            observedMissing = true;
         }
-    }
     assertRootFallbackWritePath(params.expectedWritePath, ioPath);
     const mode = params.mode ?? 0o600;
     let handle;
@@ -57217,61 +57784,82 @@ async function openWritableFileInRoot(root, params, options) {
         writePathSelection = guardedTarget
             ? await prepareGuardedRootWritePathSelection(guardedTarget, ioPath, operationTargetPath, preparedParent)
             : undefined;
-        try {
-            if (writePathSelection)
-                assertRootWritePathSelectionSync(root, writePathSelection);
-            handle = await promises_.open(ioPath, existingFlags, mode);
-        }
-        catch (err) {
-            if (await isNonRegularWriteOpenError(err, ioPath, existingFlags)) {
-                throw new errors_FsSafeError("not-file", "path is not a regular file under root");
+        const createNative = () => tryOpenCreateRootNative({
+            originalPath: params.relativePath,
+            root, directory: external_node_path_.dirname(ioPath), target: ioPath, mkdir: params.mkdir !== false, policy,
+            selectedParent: creationProbe?.parent,
+            resolveCurrent,
+            assertBeforeMutation: params.assertBeforeMutation !== undefined || writePathSelection !== undefined ? () => {
+                params.assertBeforeMutation?.();
+                if (writePathSelection)
+                    assertRootWritePathSelectionSync(root, writePathSelection);
+            } : undefined,
+            flags: createFlags, existingFlags, mode,
+        });
+        let precreated;
+        if (requireNative && observedMissing && !guardedTarget && params.assertBeforeMutation === undefined && options?.createIfMissing !== false) {
+            try {
+                precreated = await createNative();
             }
-            if (!path_isNotFoundPathError(err)) {
-                throw err;
+            catch (error) {
+                if (!hasNodeErrorCode(error, "EEXIST") || !isNativeCreateCollision(error))
+                    throw error;
             }
-            if (options?.createIfMissing === false) {
-                if (nativeCreatesParents && !guardedTarget)
-                    await tryMkdirRootNative({
-                        originalPath: params.relativePath,
-                        root, directory: external_node_path_.dirname(ioPath), target: ioPath, mkdir: true, policy,
-                        resolveCurrent, assertBeforeMutation: params.assertBeforeMutation,
-                    });
-                const parentGuard = writePathSelection?.parentGuard ??
-                    await directory_guard_createAsyncDirectoryGuard(external_node_path_.dirname(ioPath), { bigint: true });
-                root_context_assertRootIdentityCurrentSync(root);
-                if (!root_boundary_admitPathInsideRoot({
-                    rootPath: root.rootReal, candidatePath: parentGuard.realPath, rootIdentity: root.rootIdentity,
-                }))
-                    throw root_errors_outsideWorkspaceError();
-                directory_guard_assertSyncDirectoryGuard(parentGuard);
-                return { missing: true, targetPath: ioPath, parentGuard, writeSelection: writePathSelection };
+        }
+        if (precreated) {
+            handle = precreated.handle;
+            cleanupCreated = precreated.cleanupCreated;
+            releaseCreationParent = precreated.releaseCreationParent;
+            createdForWrite = true;
+        }
+        else {
+            try {
+                if (writePathSelection)
+                    assertRootWritePathSelectionSync(root, writePathSelection);
+                handle = await promises_.open(ioPath, existingFlags, mode);
             }
-            if (writePathSelection)
-                await refreshRootWritePathSelection(writePathSelection);
-            const nativeCreated = requireNative ? await tryOpenCreateRootNative({
-                originalPath: params.relativePath,
-                root, directory: external_node_path_.dirname(ioPath), target: ioPath, mkdir: params.mkdir !== false, policy,
-                resolveCurrent, assertBeforeMutation() {
+            catch (err) {
+                if (await isNonRegularWriteOpenError(err, ioPath, existingFlags)) {
+                    throw new errors_FsSafeError("not-file", "path is not a regular file under root");
+                }
+                if (!path_isNotFoundPathError(err)) {
+                    throw err;
+                }
+                if (options?.createIfMissing === false) {
+                    if (nativeCreatesParents && !guardedTarget)
+                        await tryMkdirRootNative({
+                            originalPath: params.relativePath,
+                            root, directory: external_node_path_.dirname(ioPath), target: ioPath, mkdir: true, policy,
+                            resolveCurrent, assertBeforeMutation: params.assertBeforeMutation,
+                        });
+                    const parentGuard = writePathSelection?.parentGuard ??
+                        await directory_guard_createAsyncDirectoryGuard(external_node_path_.dirname(ioPath), { bigint: true });
+                    root_context_assertRootIdentityCurrentSync(root);
+                    if (!root_boundary_admitPathInsideRoot({
+                        rootPath: root.rootReal, candidatePath: parentGuard.realPath, rootIdentity: root.rootIdentity,
+                    }))
+                        throw root_errors_outsideWorkspaceError();
+                    directory_guard_assertSyncDirectoryGuard(parentGuard);
+                    return { missing: true, targetPath: ioPath, parentGuard, writeSelection: writePathSelection };
+                }
+                if (writePathSelection)
+                    await refreshRootWritePathSelection(writePathSelection);
+                const nativeCreated = requireNative ? await createNative() : undefined;
+                if (nativeCreated)
+                    handle = nativeCreated.handle;
+                else {
                     params.assertBeforeMutation?.();
                     if (writePathSelection)
                         assertRootWritePathSelectionSync(root, writePathSelection);
-                },
-                flags: createFlags, existingFlags, mode,
-            }) : undefined;
-            if (nativeCreated)
-                handle = nativeCreated.handle;
-            else {
-                params.assertBeforeMutation?.();
-                if (writePathSelection)
-                    assertRootWritePathSelectionSync(root, writePathSelection);
-                // Windows can follow a dangling symlink even with O_EXCL.
-                if (!SUPPORTS_NOFOLLOW)
-                    assertFinalSymlinkRejected(ioPath, true);
-                handle = await promises_.open(ioPath, createFlags, mode);
+                    // Windows can follow a dangling symlink even with O_EXCL.
+                    if (!SUPPORTS_NOFOLLOW)
+                        assertFinalSymlinkRejected(ioPath, true);
+                    handle = await promises_.open(ioPath, createFlags, mode);
+                }
+                cleanupCreated = nativeCreated?.cleanupCreated;
+                releaseCreationParent = nativeCreated?.releaseCreationParent;
+                createdForWrite = true;
             }
-            cleanupCreated = nativeCreated?.cleanupCreated;
-            releaseCreationParent = nativeCreated?.releaseCreationParent;
-            createdForWrite = true;
         }
     }
     catch (err) {
@@ -57518,6 +58106,8 @@ async function mkdirPathInRoot(root, params) {
         }
         if (tryMkdirNativeDirectChild(root, params.relativePath))
             return;
+        if (tryMkdirNativeParents(root, params.relativePath))
+            return;
     }
     const resolution = { relativePath: params.relativePath, allowRoot: params.allowRoot, ...policy };
     const resolveCurrent = policy
@@ -108008,4 +108598,4 @@ if (installedChunkData !== 0) { // 0 means "already installed".'
 // module factories are used so entry inlining is disabled
 // startup
 // Load entry module and return exports
-var __webpack_exports__ = __webpack_require__(2473);
+var __webpack_exports__ = __webpack_require__(4010);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@lousy-agents/mcp",
-    "version": "5.22.0",
+    "version": "5.22.1",
     "description": "MCP server for lousy-agents - provides AI coding assistant tools via the Model Context Protocol",
     "type": "module",
     "repository": {