@lousy-agents/mcp 5.23.1 → 5.23.3

package/dist/mcp-server.js

@@ -29226,18 +29226,16 @@ async function writeAllToFile(target, data, options = {}) {
         const length = Math.min(WRITE_CHUNK_BYTES, buffer.byteLength - offset);
         const position = options.position === undefined ? null : options.position + offset;
         options.assertBeforeMutation?.();
-        const written = typeof target === "number" && options.synchronous
-            ? external_node_fs_.writeSync(target, buffer, offset, length, position)
-            : typeof target === "number"
-                ? await new Promise((resolve, reject) => {
-                    external_node_fs_.write(target, buffer, offset, length, position, (error, bytesWritten) => {
-                        if (error)
-                            reject(error);
-                        else
-                            resolve(bytesWritten);
-                    });
-                })
-                : (await target.write(buffer, offset, length, position)).bytesWritten;
+        const written = typeof target === "number"
+            ? await new Promise((resolve, reject) => {
+                external_node_fs_.write(target, buffer, offset, length, position, (error, bytesWritten) => {
+                    if (error)
+                        reject(error);
+                    else
+                        resolve(bytesWritten);
+                });
+            })
+            : (await target.write(buffer, offset, length, position)).bytesWritten;
         if (written <= 0) {
             throw new errors_FsSafeError("helper-failed", "file write made no progress");
         }
@@ -30285,6 +30283,7 @@ function assertWindowsAclRemediationAllowed() {
 
 
 
+
 const runtimePlatform = process.versions.bun ? (0,external_node_os_.platform)() : undefined;
 const bunPosix = runtimePlatform === "darwin" || runtimePlatform === "linux" ? runtimePlatform : undefined;
 function realpath_resolve(input, native) {
@@ -30353,6 +30352,21 @@ function realpath_resolve(input, native) {
 const realpath_realpathSync = Object.assign((input) => realpath_resolve(input, false), {
     native: (input) => realpath_resolve(input, true),
 });
+/** Async on Node; retain runtime-specific native canonicalization guarantees. */
+async function realpath_realpathNative(input) {
+    if (bunPosix)
+        return realpath_realpathSync.native(input);
+    try {
+        return await promises_.realpath(input);
+    }
+    catch (error) {
+        if (process.platform !== "win32" || error.code !== "EPERM" ||
+            error.syscall !== "realpath")
+            throw error;
+        // AppContainer DOS-name translation still belongs to the native sync owner.
+        return realpath_realpathSync.native(input);
+    }
+}
 
 ;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/directory-entry-path.js
 
@@ -31563,7 +31577,7 @@ async function resolveAbsolutePathForRead(filePath, options = {}) {
     const normalized = assertAbsolutePathInput(filePath);
     let canonicalPath;
     try {
-        canonicalPath = realpathSync.native(pathForWindowsFilesystem(normalized));
+        canonicalPath = await realpathNative(pathForWindowsFilesystem(normalized));
         assertNoWindowsPathAlias(canonicalPath);
     }
     catch (err) {
@@ -33496,6 +33510,12 @@ function root_boundary_admitPathInsideRoot(params) {
 
 
 
+
+
+// Windows native realpath denies delete sharing. Preserve read/publication
+// scheduling until canonicalization can safely overlap replacement.
+const synchronousRootTraversal = process.platform === "win32";
+const root_path_existing_runRootTraversal = synchronousRootTraversal ? atomic_io_runSync : runAsync;
 function absolutePathWithRawSegments(candidate) {
     if (external_node_path_.sep !== "\\") {
         if (external_node_path_.isAbsolute(candidate))
@@ -33513,7 +33533,7 @@ function absolutePathWithRawSegments(candidate) {
     const base = drive ? external_node_path_.resolve(drive) : process.cwd();
     return `${base}${base.endsWith(external_node_path_.sep) ? "" : external_node_path_.sep}${raw.slice(drive.length)}`;
 }
-function rawPathRelativeToCanonicalRoot(candidate, rootCanonicalPath, options = {}) {
+function* rawPathRelativeToCanonicalRoot(candidate, rootCanonicalPath, options = {}, synchronous = true) {
     windows_path_alias_assertNoWindowsPathAlias(candidate);
     windows_path_alias_assertNoWindowsPathAlias(rootCanonicalPath);
     const absolute = absolutePathWithRawSegments(candidate);
@@ -33532,7 +33552,7 @@ function rawPathRelativeToCanonicalRoot(candidate, rootCanonicalPath, options =
         let isSymlink = false;
         try {
             const operationPath = windows_path_alias_pathForWindowsFilesystem(prefix);
-            const stat = external_node_fs_.lstatSync(operationPath);
+            const stat = synchronous ? external_node_fs_.lstatSync(operationPath) : yield* wait(promises_.lstat(operationPath));
             isSymlink = stat.isSymbolicLink();
             // Check the original leaf before canonicalization can erase an entry alias.
             if (isSymlink && options.rejectFinalSymlink && index === finalComponentIndex) {
@@ -33541,10 +33561,11 @@ function rawPathRelativeToCanonicalRoot(candidate, rootCanonicalPath, options =
             if (!isSymlink && !stat.isDirectory() && index < segments.length - 1)
                 return undefined;
             traversedSymlink ||= isSymlink;
-            canonical = realpath_realpathSync.native(operationPath);
+            canonical = synchronous ? realpath_realpathSync.native(operationPath) : yield* wait(realpath_realpathNative(operationPath));
             windows_path_alias_assertNoWindowsPathAlias(canonical);
             if (isSymlink && index < segments.length - 1 &&
-                !external_node_fs_.statSync(windows_path_alias_pathForWindowsFilesystem(canonical)).isDirectory())
+                !(synchronous ? external_node_fs_.statSync(windows_path_alias_pathForWindowsFilesystem(canonical))
+                    : yield* wait(promises_.stat(windows_path_alias_pathForWindowsFilesystem(canonical)))).isDirectory())
                 return undefined;
             if (isSymlink && !isPathInside(rootCanonicalPath, canonical) && !isPathInside(canonical, rootCanonicalPath)) {
                 throw new errors_FsSafeError("outside-workspace", `symlink prefix resolves outside the root ancestry: ${formatErrorDetail(candidate)}`);
@@ -33573,9 +33594,10 @@ function rawPathRelativeToCanonicalRoot(candidate, rootCanonicalPath, options =
     }
     return undefined;
 }
-function root_path_existing_pathExists(targetPath) {
+function* root_path_existing_pathExists(targetPath, synchronous) {
     try {
-        return external_node_fs_.lstatSync(windows_path_alias_pathForWindowsFilesystem(targetPath), { throwIfNoEntry: false }) !== undefined;
+        return (synchronous ? external_node_fs_.lstatSync(windows_path_alias_pathForWindowsFilesystem(targetPath), { throwIfNoEntry: false })
+            : yield* wait(promises_.lstat(windows_path_alias_pathForWindowsFilesystem(targetPath)))) !== undefined;
     }
     catch (error) {
         if (path_isNotFoundPathError(error)) {
@@ -33585,17 +33607,20 @@ function root_path_existing_pathExists(targetPath) {
     }
 }
 async function resolvePathViaExistingAncestor(targetPath) {
-    return resolveExistingAncestor(targetPath, "native");
+    return root_path_existing_runRootTraversal(resolveExistingAncestorProcedure(targetPath, "native", synchronousRootTraversal));
 }
-function pathExistsSync(targetPath) {
+function* ordinaryExists(targetPath) {
     return external_node_fs_.existsSync(windows_path_alias_pathForWindowsFilesystem(targetPath));
 }
 function resolvePathViaExistingAncestorSync(targetPath) {
     return resolveExistingAncestor(targetPath, "ordinary");
 }
 function resolveExistingAncestor(targetPath, mode, preserveRawSegments = false, remainingHops = 64) {
-    const exists = mode === "native" || preserveRawSegments ? root_path_existing_pathExists : pathExistsSync;
-    const canonicalize = realpath_realpathSync.native;
+    return atomic_io_runSync(resolveExistingAncestorProcedure(targetPath, mode, true, preserveRawSegments, remainingHops));
+}
+function* resolveExistingAncestorProcedure(targetPath, mode, synchronous, preserveRawSegments = false, remainingHops = 64) {
+    const exists = (pathname) => mode === "native" || preserveRawSegments
+        ? root_path_existing_pathExists(pathname, synchronous) : ordinaryExists(pathname);
     windows_path_alias_assertNoWindowsPathAlias(targetPath);
     const normalized = windows_path_alias_resolvePathPreservingWindowsRoot(targetPath);
     windows_path_alias_assertNoWindowsPathAlias(normalized);
@@ -33603,22 +33628,23 @@ function resolveExistingAncestor(targetPath, mode, preserveRawSegments = false,
     let cursor = candidate;
     const filesystemRoot = external_node_path_.parse(candidate).root;
     while (cursor !== filesystemRoot &&
-        !exists(cursor)) {
+        !(yield* exists(cursor))) {
         cursor = external_node_path_.dirname(cursor);
     }
-    if (!exists(cursor)) {
+    if (!(yield* exists(cursor))) {
         return normalized;
     }
     let rawResolvedAncestor;
     try {
-        rawResolvedAncestor = canonicalize(windows_path_alias_pathForWindowsFilesystem(cursor));
+        rawResolvedAncestor = synchronous ? realpath_realpathSync.native(windows_path_alias_pathForWindowsFilesystem(cursor))
+            : yield* wait(realpath_realpathNative(windows_path_alias_pathForWindowsFilesystem(cursor)));
     }
     catch (error) {
         if (!preserveRawSegments)
             return normalized;
         if (!path_isNotFoundPathError(error))
             throw error;
-        rawResolvedAncestor = resolveSymlinkHopPath(cursor, mode, false, remainingHops);
+        rawResolvedAncestor = yield* resolveSymlinkHopPath(cursor, mode, false, remainingHops, synchronous);
     }
     windows_path_alias_assertNoWindowsPathAlias(rawResolvedAncestor);
     const resolvedAncestor = windows_path_alias_resolvePathPreservingWindowsRoot(rawResolvedAncestor);
@@ -33634,10 +33660,10 @@ function resolveExistingAncestor(targetPath, mode, preserveRawSegments = false,
     windows_path_alias_assertNoWindowsPathAlias(resolved);
     return resolved;
 }
-function resolveSymlinkHopPath(symlinkPath, mode, rejectUnresolved, remainingHops = 64) {
+function* resolveSymlinkHopPath(symlinkPath, mode, rejectUnresolved, remainingHops = 64, synchronous = true) {
     try {
-        const canonicalize = realpath_realpathSync.native;
-        const rawRealPath = canonicalize(symlinkPath);
+        const rawRealPath = synchronous ? realpath_realpathSync.native(symlinkPath)
+            : yield* wait(realpath_realpathNative(symlinkPath));
         windows_path_alias_assertNoWindowsPathAlias(rawRealPath, "filesystem", "resolved symlink path uses a Windows filesystem namespace alias");
         const realPath = windows_path_alias_resolvePathPreservingWindowsRoot(rawRealPath);
         windows_path_alias_assertNoWindowsPathAlias(realPath, "filesystem", "resolved symlink path uses a Windows filesystem namespace alias");
@@ -33651,14 +33677,14 @@ function resolveSymlinkHopPath(symlinkPath, mode, rejectUnresolved, remainingHop
             throw error;
         if (remainingHops <= 0)
             throw new errors_FsSafeError("symlink", "too many unresolved symlink hops");
-        const linkTarget = external_node_fs_.readlinkSync(symlinkPath);
+        const linkTarget = synchronous ? external_node_fs_.readlinkSync(symlinkPath) : yield* wait(promises_.readlink(symlinkPath));
         windows_path_alias_assertNoWindowsPathAlias(linkTarget, "filesystem", "symlink target uses a Windows filesystem namespace alias");
         const linkDir = windows_path_alias_resolvePathPreservingWindowsRoot(external_node_path_.dirname(symlinkPath));
         // Keep parent segments until the kernel has resolved the existing prefix.
         const targetPath = external_node_path_.isAbsolute(linkTarget) ? linkTarget
             : external_node_path_.parse(linkTarget).root ? windows_path_alias_resolvePathFromBasePreservingWindowsRoot(linkDir, linkTarget)
                 : `${linkDir}${external_node_path_.sep}${linkTarget}`;
-        const resolved = resolveExistingAncestor(targetPath, mode, true, remainingHops - 1);
+        const resolved = yield* resolveExistingAncestorProcedure(targetPath, mode, synchronous, true, remainingHops - 1);
         windows_path_alias_assertNoWindowsPathAlias(resolved, "filesystem", "resolved symlink path uses a Windows filesystem namespace alias");
         return resolved;
     }
@@ -33786,7 +33812,7 @@ async function runAsync(procedure) {
     }
     return step.value;
 }
-function runSync(procedure) {
+function atomic_io_runSync(procedure) {
     let step = procedure.next();
     // Sync adapters retain their ordinary return values; this driver never reads then.
     while (!step.done)
@@ -34737,21 +34763,21 @@ function probeTemporaryEntry(directory) {
     const owner = new AtomicTempOwner(external_node_path_.join(directory, name), io);
     try {
         owner.start();
-        owner.adopt(runSync(writeTempFile(io, {
+        owner.adopt(atomic_io_runSync(writeTempFile(io, {
             tempPath: owner.pathname,
             content: "",
             mode: 0o600,
             sync: false,
             onIdentity: owner.onIdentity,
         })));
-        runSync(owner.assertCurrent());
+        atomic_io_runSync(owner.assertCurrent());
         const observed = probeEntry(directory, name, new Set(external_node_fs_.readdirSync(directory)));
-        runSync(owner.assertCurrent());
+        atomic_io_runSync(owner.assertCurrent());
         return observed;
     }
     finally {
         // Failed cleanup invalidates the observation; the existing owner retains its exit retry.
-        runSync(owner.finish({ throwOnCleanupError: true }));
+        atomic_io_runSync(owner.finish({ throwOnCleanupError: true }));
     }
 }
 function probeDirectory(directory, allowTemporaryProbe, preferredName) {
@@ -37412,6 +37438,8 @@ function captureRootPathObservedDirectory(observation, observed, publicPath, can
 
 
 
+
+
 const ROOT_PATH_ALIAS_POLICIES = {
     strict: Object.freeze({
         allowFinalSymlinkForUnlink: false,
@@ -37423,36 +37451,38 @@ const ROOT_PATH_ALIAS_POLICIES = {
     }),
 };
 async function root_path_resolveRootPath(params) {
-    return resolveRootPathInternal(params);
+    return root_path_existing_runRootTraversal(resolveRootPathInternal(params));
 }
 async function resolveRootPathWithCanonicalRootObservation(params, observeRoot) {
-    return resolveRootPathInternal(params, { observeRoot });
+    return runRootTraversal(resolveRootPathInternal(params, { observeRoot }));
 }
 async function resolveRootPathWithObservation(params, request) {
     const observation = { request };
-    const resolved = resolveRootPathInternal(params, { observation });
+    const resolved = synchronousRootTraversal
+        ? atomic_io_runSync(resolveRootPathInternal(params, { observation }))
+        : await root_path_existing_runRootTraversal(resolveRootPathInternal(params, { observation }));
     return observation.receipt ? { resolved, receipt: observation.receipt } : { resolved };
 }
 // Removal receipts are separate from metadata observations and canonical-root
-// callbacks; the public resolver's options and result remain unchanged.
+// callbacks; retain their synchronous admission and mutation-fence owner.
 async function resolveRootPathForRemoval(params, receipts) {
-    return resolveRootPathInternal(params, { removalReceipts: receipts });
+    return atomic_io_runSync(resolveRootPathInternal(params, { removalReceipts: receipts }, true));
 }
 function root_path_resolveRootPathSync(params) {
-    return resolveRootPathInternal(params, { mode: "ordinary" });
+    return atomic_io_runSync(resolveRootPathInternal(params, { mode: "ordinary" }, true));
 }
 function resolveRootPathSyncWithCanonicalRootObservation(params, observeRoot) {
-    return resolveRootPathInternal(params, { mode: "ordinary", observeRoot });
+    return runSync(resolveRootPathInternal(params, { mode: "ordinary", observeRoot }, true));
 }
-function resolveRootPathInternal(params, options = {}) {
+function* resolveRootPathInternal(params, options = {}, synchronous = synchronousRootTraversal) {
     try {
-        return traverseRootPath(params, options);
+        return yield* traverseRootPath(params, options, synchronous);
     }
     catch (error) {
         throw sanitizeRootPathError(error);
     }
 }
-function prepareRootTraversal(params, rootPath, rootCanonicalPath, absolutePath, rawAbsolutePath) {
+function* prepareRootTraversal(params, rootPath, rootCanonicalPath, absolutePath, rawAbsolutePath, synchronous) {
     let raw = rawAbsolutePath;
     let trustedAbsolutePath = false;
     // Even a metadata lookup on a foreign share contacts that host, including the
@@ -37468,7 +37498,7 @@ function prepareRootTraversal(params, rootPath, rootCanonicalPath, absolutePath,
     else {
         const canonical = admitRawPathInsideRoot(rootCanonicalPath, raw, params.rootIdentity);
         const relative = canonical?.relativePath
-            ?? rawPathRelativeToCanonicalRoot(raw, rootCanonicalPath, params);
+            ?? (yield* rawPathRelativeToCanonicalRoot(raw, rootCanonicalPath, params, synchronous));
         if (relative === undefined) {
             throw pathEscapeError({ rootPath, absolutePath: raw, boundaryLabel: params.boundaryLabel });
         }
@@ -37649,27 +37679,28 @@ function assertDirectoryBeforeMoreSegments(stat, pathname, isLast) {
         throw Object.assign(new Error(`Path component is not a directory: ${pathname}`), { code: "ENOTDIR" });
     }
 }
-function assertResolvedLinkDirectory(pathname, isLast) {
+function* assertResolvedLinkDirectory(pathname, isLast, synchronous) {
     if (isLast)
         return;
-    const stat = external_node_fs_.statSync(windows_path_alias_pathForWindowsFilesystem(pathname));
+    const stat = synchronous ? external_node_fs_.statSync(windows_path_alias_pathForWindowsFilesystem(pathname))
+        : yield* wait(promises_.stat(windows_path_alias_pathForWindowsFilesystem(pathname)));
     assertDirectoryBeforeMoreSegments(stat, pathname, isLast);
 }
-// Both public APIs use kernel canonicalization and synchronous metadata; only
-// ancestor existence differs. Promise wrappers preserve asynchronous rejection.
-function traverseRootPath(params, { mode = "native", observation: observationOutput, observeRoot, removalReceipts }) {
+// Both drivers share containment policy. Observation receipts and platform-specific
+// native guards retain their existing synchronous owners.
+function* traverseRootPath(params, { mode = "native", observation: observationOutput, observeRoot, removalReceipts }, synchronous) {
     const input = captureValidRootPathInputs(params);
     const rawAbsolutePath = absolutePathWithRawSegments(input.absolutePath);
     const rootPath = windows_path_alias_resolvePathPreservingWindowsRoot(input.rootPath);
     const absolutePath = windows_path_alias_resolvePathPreservingWindowsRoot(rawAbsolutePath);
     const rootCanonicalPath = input.rootCanonicalPath
         ? windows_path_alias_resolvePathPreservingWindowsRoot(input.rootCanonicalPath)
-        : resolveExistingAncestor(rootPath, mode);
+        : yield* resolveExistingAncestorProcedure(rootPath, mode, synchronous);
     windows_path_alias_assertNoWindowsPathAlias(rootPath);
     windows_path_alias_assertNoWindowsPathAlias(absolutePath);
     windows_path_alias_assertNoWindowsPathAlias(rootCanonicalPath);
     observeRoot?.(rootCanonicalPath);
-    const context = createLexicalTraversalContext(prepareRootTraversal(input, rootPath, rootCanonicalPath, absolutePath, rawAbsolutePath));
+    const context = createLexicalTraversalContext(yield* prepareRootTraversal(input, rootPath, rootCanonicalPath, absolutePath, rawAbsolutePath, synchronous));
     const { state } = context;
     const observation = createLexicalTraversalObservation(context, observationOutput?.request);
     for (let idx = 0; idx < state.segments.length; idx += 1) {
@@ -37706,7 +37737,8 @@ function traverseRootPath(params, { mode = "native", observation: observationOut
                 }
                 stat = isNativeDirectoryObservationGuard(observed)
                     ? undefined
-                    : observed?.stat ?? external_node_fs_.lstatSync(state.lexicalCursor);
+                    : observed?.stat ?? (synchronous ? external_node_fs_.lstatSync(state.lexicalCursor)
+                        : yield* wait(promises_.lstat(state.lexicalCursor)));
             }
         }
         catch (error) {
@@ -37769,12 +37801,12 @@ function traverseRootPath(params, { mode = "native", observation: observationOut
         }
         if (observation?.enabled)
             disableLexicalTraversalObservation(context, observation);
-        const linkCanonical = resolveSymlinkHopPath(state.lexicalCursor, mode, context.resolveParams.rejectUnresolvedSymlinks);
+        const linkCanonical = yield* resolveSymlinkHopPath(state.lexicalCursor, mode, context.resolveParams.rejectUnresolvedSymlinks, 64, synchronous);
         applyResolvedSymlinkHop(context, linkCanonical);
         if (context.resolveParams.rejectSymlinks === true) {
             throw new errors_FsSafeError("symlink", "symlink path component not allowed");
         }
-        assertResolvedLinkDirectory(linkCanonical, isLast);
+        yield* assertResolvedLinkDirectory(linkCanonical, isLast, synchronous);
     }
     const completeObservation = observation?.enabled === true && observation.directoryGuard !== undefined &&
         observation.targetPath === state.canonicalCursor && observation.target !== undefined;
@@ -37782,7 +37814,7 @@ function traverseRootPath(params, { mode = "native", observation: observationOut
         ? isNativeDirectoryObservationGuard(observation.target)
             ? "directory"
             : toResolvedKind(observation.target.stat)
-        : getPathKindSync(state.canonicalCursor, state.preserveFinalSymlink);
+        : yield* getPathKind(state.canonicalCursor, state.preserveFinalSymlink, synchronous);
     if (completeObservation && observationOutput) {
         observationOutput.receipt = {
             kind: observation.request.kind,
@@ -37795,12 +37827,12 @@ function traverseRootPath(params, { mode = "native", observation: observationOut
     }
     return finalizeLexicalResolution(context, kind);
 }
-function getPathKindSync(absolutePath, preserveFinalSymlink) {
+function* getPathKind(absolutePath, preserveFinalSymlink, synchronous) {
     try {
         const operationPath = windows_path_alias_pathForWindowsFilesystem(absolutePath);
         const stat = preserveFinalSymlink
-            ? external_node_fs_.lstatSync(operationPath)
-            : external_node_fs_.statSync(operationPath);
+            ? synchronous ? external_node_fs_.lstatSync(operationPath) : yield* wait(promises_.lstat(operationPath))
+            : synchronous ? external_node_fs_.statSync(operationPath) : yield* wait(promises_.stat(operationPath));
         return toResolvedKind(stat);
     }
     catch (error) {
@@ -40864,7 +40896,6 @@ function replayPinnedInput(fd, input) {
         })() };
 }
 const pinned_write_input_isUint8Array = external_node_util_.types.isUint8Array;
-const SMALL_BUFFER_BYTES = 64 * 1024;
 function streamChunkBytes(chunk) {
     if (Buffer.isBuffer(chunk))
         return chunk;
@@ -40879,16 +40910,6 @@ async function writePinnedInput(target, input, maxBytes, assertBeforeMutation) {
         await writeCopyFileToFd(typeof target === "number" ? target : target.fd, input, maxBytes, assertBeforeMutation);
         return;
     }
-    if (typeof target === "number" && input.kind === "buffer" &&
-        input.stageBeforePublish !== false && !assertBeforeMutation) {
-        const data = typeof input.data === "string" ? Buffer.from(input.data, input.encoding ?? "utf8") : input.data;
-        if (data.byteLength <= SMALL_BUFFER_BYTES) {
-            if (maxBytes !== undefined && data.byteLength > maxBytes) {
-                throw new errors_FsSafeError("too-large", `file exceeds limit of ${maxBytes} bytes (got at least ${data.byteLength})`);
-            }
-            return writeAllToFile(target, data, { synchronous: true });
-        }
-    }
     let bytes = 0;
     const write = async (data) => {
         bytes += data.byteLength;
@@ -41380,8 +41401,8 @@ function assertNativeStaging(binding) {
         binding.createStagedFile,
         binding.stagedFileMatches,
         binding.removeStagedFile,
-        binding.renameReplace,
-        binding.renameNoReplace,
+        binding.renameReplaceAsync,
+        binding.renameNoReplaceAsync,
     ].some((fn) => typeof fn !== "function")) {
         throw new errors_FsSafeError("helper-unavailable", "native retained-directory staging is unavailable");
     }
@@ -41401,7 +41422,7 @@ class NativeStagedFile {
     #verifyMode;
     #state = { status: "open", publication: NOT_PUBLISHED };
     #receipt;
-    #publicationFlush;
+    #publicationTask;
     #rejectFinalSymlink = false;
     #unsupportedNoReplace;
     #fallbackCleanup;
@@ -41592,7 +41613,7 @@ class NativeStagedFile {
                 if (this.#private)
                     assertDarwinCreationAcl(this.#owner.parentFd, "file");
                 try {
-                    state.fileFd = this.#owner.binding.createStagedFile(this.#owner.parentFd, this.#owner.name);
+                    state.fileFd = await this.#owner.binding.createStagedFile(this.#owner.parentFd, this.#owner.name);
                 }
                 catch (error) {
                     annotateReadOnlyOpenError(error, external_node_path_.join(this.#owner.directory.realPath, this.#owner.name));
@@ -41641,7 +41662,14 @@ class NativeStagedFile {
     async assertCurrent() {
         this.#assertCurrent();
     }
-    async publish(basename, options, onPublished) {
+    publish(basename, options, onPublished) {
+        if (this.#publicationTask)
+            return Promise.reject(stagedFailure("file", new errors_FsSafeError("helper-failed", "staged file publication is pending"), { phase: "publish", publication: this.#state.status === "closed" ? this.#state.receipt.publication : this.#state.publication }));
+        // Claim the operation before yielding so cleanup cannot recycle a worker's fds.
+        return this.#publicationTask = Promise.resolve().then(() => this.#publish(basename, options, onPublished))
+            .finally(() => { this.#publicationTask = undefined; });
+    }
+    async #publish(basename, options, onPublished) {
         const overwrite = options?.overwrite;
         try {
             const state = this.#open();
@@ -41658,10 +41686,10 @@ class NativeStagedFile {
             }
             try {
                 if (overwrite) {
-                    this.#owner.binding.renameReplace(this.#owner.parentFd, this.#owner.name, this.#owner.parentFd, basename);
+                    await this.#owner.binding.renameReplaceAsync(this.#owner.parentFd, this.#owner.name, this.#owner.parentFd, basename);
                 }
                 else {
-                    this.#owner.binding.renameNoReplace(this.#owner.parentFd, this.#owner.name, this.#owner.parentFd, basename);
+                    await this.#owner.binding.renameNoReplaceAsync(this.#owner.parentFd, this.#owner.name, this.#owner.parentFd, basename);
                 }
             }
             catch (error) {
@@ -41716,14 +41744,13 @@ class NativeStagedFile {
         };
         if (this.#owner.sync === false)
             return verify();
-        this.#publicationFlush = Promise.resolve().then(async () => {
+        return Promise.resolve().then(async () => {
             if ((this.#owner.mode & 0o600) !== 0o600 || (stagedMode & ~this.#owner.mode) !== 0) {
                 await (this.#owner.strictFileSync ? syncFile(fd) : syncFileBestEffort(fd));
             }
             await syncFileBestEffort(this.#owner.parentFd);
             return verify();
-        }).finally(() => { this.#publicationFlush = undefined; });
-        return this.#publicationFlush;
+        });
     }
     #finalize() {
         if (this.#state.status === "closed") {
@@ -41778,9 +41805,9 @@ class NativeStagedFile {
         return this.#state;
     }
     async cleanup() {
-        // Native descriptors cannot close or be recycled while libuv is synchronizing them.
-        if (this.#publicationFlush)
-            await this.#publicationFlush.catch(() => { });
+        // Native descriptors stay owned through the rename and all durability fences.
+        if (this.#publicationTask)
+            await this.#publicationTask.catch(() => { });
         const closed = this.#finalize();
         if (closed.error) {
             throw closed.error;
@@ -41878,7 +41905,7 @@ var native_pinned_write_disposeResources = (undefined && undefined.__disposeReso
 
 
 const writeCapabilities = ["openBeneath", "mkdirBeneath", "renameNoReplace", "renameReplace"];
-const posixWriteCapabilities = [...writeCapabilities, "createStagedFile", "stagedFileMatches", "removeStagedFile"];
+const posixWriteCapabilities = [...writeCapabilities, "createStagedFile", "stagedFileMatches", "removeStagedFile", "renameReplaceAsync", "renameNoReplaceAsync"];
 function pinnedWriteCapabilities(params) {
     const windows = process.platform === "win32";
     const capabilities = windows ? [...writeCapabilities, "fstatIdentity"] : posixWriteCapabilities;

package/package.json

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