@lousy-agents/lint 5.14.9 → 5.15.0

package/dist/116.js

@@ -2,9 +2,6 @@ export const __rspack_esm_id = 116;
 export const __rspack_esm_ids = [116];
 export const __webpack_modules__ = {
 8711(__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
-__webpack_require__.d(__webpack_exports__, {
-  prompt: () => (prompt)
-});
 /* import */ var node_util__rspack_import_0 = __webpack_require__(7975);
 /* import */ var node_process__rspack_import_1 = __webpack_require__(1708);
 /* import */ var node_readline__rspack_import_2 = __webpack_require__(481);
@@ -290,6 +287,10 @@ async function prompt(message, opts = {}) {
 
 
 
+__webpack_require__.d(__webpack_exports__, {
+  prompt: () => (prompt)
+});
+
 
 },
 

package/dist/316.js

@@ -4,9 +4,6 @@ export const __webpack_modules__ = {
 5375(__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
 var zlib__rspack_import_11_namespace_cache;
 __webpack_require__.r(__webpack_exports__);
-__webpack_require__.d(__webpack_exports__, {
-  t: () => (ce)
-});
 /* import */ var _rolldown_runtime_mjs__rspack_import_14 = __webpack_require__(421);
 /* import */ var node_fs__rspack_import_0 = __webpack_require__(3024);
 /* import */ var node_fs_promises__rspack_import_1 = __webpack_require__(1455);
@@ -2954,6 +2951,10 @@ var Da = (e) => {
 };
 
 
+__webpack_require__.d(__webpack_exports__, {
+  t: () => (ce)
+});
+
 
 },
 

package/dist/475.js

@@ -1729,10 +1729,10 @@ class FSWatcher extends external_node_events_.EventEmitter {
         const options = { type: EVENTS.ALL, alwaysStat: true, lstat: true, ...opts, depth: 0 };
         let stream = readdirp(root, options);
         this._streams.add(stream);
-        stream.once(STR_CLOSE, () => {
+        stream.once((/* inlined export .STR_CLOSE */"close"), () => {
             stream = undefined;
         });
-        stream.once(STR_END, () => {
+        stream.once((/* inlined export .STR_END */"end"), () => {
             if (stream) {
                 this._streams.delete(stream);
                 stream = undefined;

package/dist/653.js

@@ -3,13 +3,6 @@ export const __rspack_esm_ids = [653];
 export const __webpack_modules__ = {
 292(__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
 __webpack_require__.r(__webpack_exports__);
-__webpack_require__.d(__webpack_exports__, {
-  a: () => (y),
-  i: () => (S),
-  n: () => (ne),
-  r: () => (C),
-  t: () => (oe)
-});
 /* import */ var _rolldown_runtime_mjs__rspack_import_8 = __webpack_require__(421);
 /* import */ var node_module__rspack_import_0 = __webpack_require__(8995);
 /* import */ var node_fs__rspack_import_1 = __webpack_require__(3024);
@@ -689,12 +682,18 @@ async function fe(e = {}) {
 }
 
 
+__webpack_require__.d(__webpack_exports__, {
+  t: () => (oe)
+}, {
+  a: y,
+  i: S,
+  n: ne,
+  r: C
+});
+
 
 },
 421(__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
-__webpack_require__.d(__webpack_exports__, {
-  t: () => (__exportAll)
-});
 /* import */ var node_module__rspack_import_0 = __webpack_require__(8995);
 
 //#region \0rolldown/runtime.js
@@ -711,6 +710,10 @@ var __exportAll = (all, no_symbols) => {
 //#endregion
 
 
+__webpack_require__.d(__webpack_exports__, {
+  t: () => (__exportAll)
+});
+
 
 },
 8900(__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {

package/dist/index.js

@@ -566,7 +566,7 @@ module.exports = webpackEmptyAsyncContext;
 
 
 },
-4403(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+9884(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
 
 // EXPORTS
 __webpack_require__.d(__webpack_exports__, {
@@ -1031,6 +1031,9 @@ function path_isPathInside(root, target) {
     const firstSegment = relative.split(external_node_path_.posix.sep)[0];
     return relative === "" || (firstSegment !== ".." && !external_node_path_.isAbsolute(relative));
 }
+function isPathRelativeEscape(relativePath) {
+    return relativePath === ".." || relativePath.startsWith(`..${external_node_path_.sep}`) || external_node_path_.isAbsolute(relativePath);
+}
 function resolveSafeBaseDir(rootDir) {
     const resolved = path.resolve(rootDir);
     return resolved.endsWith(path.sep) ? resolved : `${resolved}${path.sep}`;
@@ -1179,17 +1182,17 @@ function directory_guard_createNearestExistingSyncDirectoryGuard(rootReal, targe
 
 
 
+
 function isSameOrChildPath(candidate, parent) {
-    return candidate === parent || candidate.startsWith(`${parent}${external_node_path_.sep}`);
-}
-function isPathEscape(relativePath) {
-    return relativePath === ".." || relativePath.startsWith(`..${external_node_path_.sep}`) || external_node_path_.isAbsolute(relativePath);
+    const parentPrefix = parent.endsWith(external_node_path_.sep) ? parent : `${parent}${external_node_path_.sep}`;
+    return candidate === parent || candidate.startsWith(parentPrefix);
 }
 async function mkdirPathComponentsWithGuards(params) {
     const root = external_node_path_.resolve(params.rootReal);
+    const rootCanonical = external_node_path_.resolve(await promises_.realpath(root));
     const target = external_node_path_.resolve(params.targetPath);
     const relative = external_node_path_.relative(root, target);
-    if (isPathEscape(relative)) {
+    if (isPathRelativeEscape(relative)) {
         throw new errors_FsSafeError("outside-workspace", "directory is outside workspace root");
     }
     let current = root;
@@ -1212,7 +1215,7 @@ async function mkdirPathComponentsWithGuards(params) {
         }
         // Node's recursive mkdir follows symlinks in missing components. Build one
         // segment at a time and realpath-check each segment before descending.
-        if (!isSameOrChildPath(external_node_path_.resolve(await promises_.realpath(next)), root)) {
+        if (!isSameOrChildPath(external_node_path_.resolve(await promises_.realpath(next)), rootCanonical)) {
             throw new errors_FsSafeError("outside-workspace", "directory escaped workspace root");
         }
         await directory_guard_createAsyncDirectoryGuard(next);
@@ -1299,6 +1302,191 @@ function guardedRmSync(params) {
     }), { verifyAfter: params.verifyAfter });
 }
 
+;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/deny-mutations.js
+
+
+
+
+async function pathExists(filePath) {
+    try {
+        await promises_.lstat(filePath);
+        return true;
+    }
+    catch (err) {
+        if (!path_isNotFoundPathError(err)) {
+            throw err;
+        }
+        return false;
+    }
+}
+async function resolvePathViaExistingAncestor(targetPath) {
+    const normalized = external_node_path_.resolve(targetPath);
+    let cursor = normalized;
+    const missingSuffix = [];
+    while (external_node_path_.dirname(cursor) !== cursor && !(await pathExists(cursor))) {
+        missingSuffix.unshift(external_node_path_.basename(cursor));
+        cursor = external_node_path_.dirname(cursor);
+    }
+    if (!(await pathExists(cursor))) {
+        return normalized;
+    }
+    try {
+        const resolvedAncestor = external_node_path_.resolve(await promises_.realpath(cursor));
+        return missingSuffix.length === 0
+            ? resolvedAncestor
+            : external_node_path_.resolve(resolvedAncestor, ...missingSuffix);
+    }
+    catch {
+        return normalized;
+    }
+}
+async function comparablePaths(rawPath) {
+    path_assertNoNulPathInput(rawPath, "path contains a NUL byte");
+    const resolved = external_node_path_.resolve(rawPath);
+    return new Set([resolved, await resolvePathViaExistingAncestor(resolved)]);
+}
+function isSamePath(left, right) {
+    return path_isPathInside(left, right) && path_isPathInside(right, left);
+}
+function hasPolicyEntries(policy) {
+    return Boolean(policy?.paths?.length || policy?.prefixes?.length);
+}
+function policyPathEntries(entries) {
+    const paths = [];
+    for (const entry of entries ?? []) {
+        if (entry.length === 0) {
+            throw new errors_FsSafeError("invalid-path", "deny mutation paths must be non-empty");
+        }
+        path_assertNoNulPathInput(entry, "deny mutation path contains a NUL byte");
+        if (!external_node_path_.isAbsolute(entry)) {
+            throw new errors_FsSafeError("invalid-path", "deny mutation paths must be absolute");
+        }
+        paths.push(entry);
+    }
+    return paths;
+}
+async function assertMutationNotDenied(filePath, policy, options = {}) {
+    if (!hasPolicyEntries(policy)) {
+        return;
+    }
+    const targetPaths = await comparablePaths(filePath);
+    for (const deniedPath of policyPathEntries(policy.paths)) {
+        const deniedPaths = await comparablePaths(deniedPath);
+        for (const target of targetPaths) {
+            for (const denied of deniedPaths) {
+                if (isSamePath(denied, target) ||
+                    (options.protectAncestors === true && path_isPathInside(target, denied))) {
+                    throw new errors_FsSafeError("denied-path", "path is denied by denyMutations policy");
+                }
+            }
+        }
+    }
+    for (const deniedPrefix of policyPathEntries(policy.prefixes)) {
+        const deniedPaths = await comparablePaths(deniedPrefix);
+        for (const target of targetPaths) {
+            for (const denied of deniedPaths) {
+                if (path_isPathInside(denied, target) ||
+                    (options.protectAncestors === true && path_isPathInside(target, denied))) {
+                    throw new errors_FsSafeError("denied-path", "path is denied by denyMutations policy");
+                }
+            }
+        }
+    }
+}
+function mergeDenyMutationPolicies(defaultPolicy, callPolicy) {
+    if (!defaultPolicy) {
+        return callPolicy;
+    }
+    if (!callPolicy) {
+        return defaultPolicy;
+    }
+    return {
+        paths: [...(defaultPolicy.paths ?? []), ...(callPolicy.paths ?? [])],
+        prefixes: [...(defaultPolicy.prefixes ?? []), ...(callPolicy.prefixes ?? [])],
+    };
+}
+
+;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/opened-realpath.js
+
+
+
+
+
+async function resolveOpenedFileRealPathForHandle(handle, ioPath) {
+    const handleStat = await handle.stat();
+    const fdCandidates = process.platform === "linux"
+        ? [`/proc/self/fd/${handle.fd}`, `/dev/fd/${handle.fd}`]
+        : process.platform === "win32"
+            ? []
+            : [`/dev/fd/${handle.fd}`];
+    for (const fdPath of fdCandidates) {
+        try {
+            const fdRealPath = await promises_.realpath(fdPath);
+            const fdRealStat = await promises_.stat(fdRealPath);
+            if (file_identity_sameFileIdentity(handleStat, fdRealStat)) {
+                return fdRealPath;
+            }
+        }
+        catch {
+            // try next fd path
+        }
+    }
+    try {
+        const ioRealPath = await promises_.realpath(ioPath);
+        const ioRealStat = await promises_.stat(ioRealPath);
+        if (file_identity_sameFileIdentity(handleStat, ioRealStat)) {
+            return ioRealPath;
+        }
+    }
+    catch (err) {
+        if (!path_isNotFoundPathError(err)) {
+            throw err;
+        }
+    }
+    const parentResolved = await resolveOpenedFileRealPathFromParent(handleStat, ioPath);
+    if (parentResolved) {
+        return parentResolved;
+    }
+    throw new errors_FsSafeError("path-mismatch", "unable to resolve opened file path");
+}
+async function resolveOpenedFileRealPathFromParent(handleStat, ioPath) {
+    let parentReal;
+    try {
+        parentReal = await promises_.realpath(external_node_path_.dirname(ioPath));
+    }
+    catch (err) {
+        if (path_isNotFoundPathError(err)) {
+            return null;
+        }
+        throw err;
+    }
+    let entries;
+    try {
+        entries = await promises_.readdir(parentReal);
+    }
+    catch (err) {
+        if (path_isNotFoundPathError(err)) {
+            return null;
+        }
+        throw err;
+    }
+    for (const entry of entries.toSorted()) {
+        const candidatePath = external_node_path_.join(parentReal, entry);
+        try {
+            const candidateStat = await promises_.lstat(candidatePath);
+            if (candidateStat.isFile() && file_identity_sameFileIdentity(handleStat, candidateStat)) {
+                return await promises_.realpath(candidatePath);
+            }
+        }
+        catch (err) {
+            if (!path_isNotFoundPathError(err)) {
+                throw err;
+            }
+        }
+    }
+    return null;
+}
+
 ;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/pinned-python-config.js
 let overrideConfig = {};
 function parseMode(value) {
@@ -1347,26 +1535,20 @@ var external_node_child_process_ = __webpack_require__(1421);
 
 
 const PINNED_PYTHON_WORKER_SOURCE = String.raw `
-import base64
-import errno
-import json
-import os
-import secrets
-import stat
-import sys
-
+import base64, errno, json, os, secrets, stat, sys
 DIR_FLAGS = os.O_RDONLY
 if hasattr(os, "O_DIRECTORY"):
     DIR_FLAGS |= os.O_DIRECTORY
 if hasattr(os, "O_NOFOLLOW"):
     DIR_FLAGS |= os.O_NOFOLLOW
 READ_FLAGS = os.O_RDONLY
+if hasattr(os, "O_NONBLOCK"):
+    READ_FLAGS |= os.O_NONBLOCK
 if hasattr(os, "O_NOFOLLOW"):
     READ_FLAGS |= os.O_NOFOLLOW
 WRITE_FLAGS = os.O_WRONLY | os.O_CREAT | os.O_EXCL
 if hasattr(os, "O_NOFOLLOW"):
     WRITE_FLAGS |= os.O_NOFOLLOW
-
 def split_relative(value):
     if value in ("", "."):
         return []
@@ -1379,10 +1561,8 @@ def split_relative(value):
         if part == "..":
             raise OSError(errno.EPERM, "path traversal is not allowed")
     return parts
-
 def open_dir(path_value, dir_fd=None):
     return os.open(path_value, DIR_FLAGS, dir_fd=dir_fd)
-
 def walk_dir(root_fd, segments, mkdir_enabled=False):
     current_fd = os.dup(root_fd)
     try:
@@ -1400,14 +1580,12 @@ def walk_dir(root_fd, segments, mkdir_enabled=False):
     except Exception:
         os.close(current_fd)
         raise
-
 def parent_and_basename(root_fd, relative):
     segments = split_relative(relative)
     if not segments:
         raise OSError(errno.EPERM, "operation requires a non-root path")
     parent_fd = walk_dir(root_fd, segments[:-1])
     return parent_fd, segments[-1]
-
 def encode_stat(st):
     mode = st.st_mode
     return {
@@ -1423,14 +1601,12 @@ def encode_stat(st):
         "size": st.st_size,
         "uid": st.st_uid,
     }
-
 def reject_unsafe_endpoint(st):
     mode = st.st_mode
     if stat.S_ISLNK(mode):
         raise OSError(errno.ELOOP, "symlink endpoint is not allowed")
     if stat.S_ISREG(mode) and st.st_nlink > 1:
         raise OSError(errno.EPERM, "hardlinked file endpoint is not allowed")
-
 def copy_bytes(source_fd, dest_fd):
     while True:
         chunk = os.read(source_fd, 65536)
@@ -1442,7 +1618,6 @@ def copy_bytes(source_fd, dest_fd):
             if written <= 0:
                 raise OSError(errno.EIO, "short write")
             view = view[written:]
-
 def write_all(fd, data):
     view = memoryview(data)
     while view:
@@ -1450,11 +1625,9 @@ def write_all(fd, data):
         if written <= 0:
             raise OSError(errno.EIO, "short write")
         view = view[written:]
-
 def link_unsupported(exc):
     unsupported = (errno.EPERM, errno.EOPNOTSUPP, getattr(errno, "ENOTSUP", errno.EOPNOTSUPP))
     return getattr(exc, "errno", None) in unsupported
-
 def link_no_replace(name, new_name, source_fd, target_fd):
     linked = False
     try:
@@ -1469,11 +1642,9 @@ def link_no_replace(name, new_name, source_fd, target_fd):
     os.fsync(source_fd)
     if source_fd != target_fd:
         os.fsync(target_fd)
-
 def copy_file_no_replace(source_parent_fd, source_name, target_parent_fd, basename, mode, expected=None, unlink_source=False):
     source_fd = os.open(source_name, READ_FLAGS, dir_fd=source_parent_fd)
-    dest_fd = None
-    success = False
+    dest_fd = None; success = False; dest_stat = None
     try:
         if expected is not None:
             source_stat = os.fstat(source_fd)
@@ -1482,6 +1653,7 @@ def copy_file_no_replace(source_parent_fd, source_name, target_parent_fd, basena
         dest_fd = os.open(basename, WRITE_FLAGS, mode, dir_fd=target_parent_fd)
         copy_bytes(source_fd, dest_fd)
         os.fsync(dest_fd)
+        dest_stat = os.fstat(dest_fd)
         success = True
     finally:
         os.close(source_fd)
@@ -1497,19 +1669,40 @@ def copy_file_no_replace(source_parent_fd, source_name, target_parent_fd, basena
             try: os.unlink(basename, dir_fd=target_parent_fd)
             except FileNotFoundError: pass
             raise
-
-def commit_temp_file(parent_fd, temp_name, basename, overwrite, mode):
+    return dest_stat
+def same_identity(left, right):
+    return left.st_dev == right.st_dev and left.st_ino == right.st_ino
+def verify_temp_name(parent_fd, temp_name, expected_stat):
+    current_stat = os.lstat(temp_name, dir_fd=parent_fd)
+    if stat.S_ISLNK(current_stat.st_mode) or not same_identity(current_stat, expected_stat):
+        raise RuntimeError("fs-safe-temp-mismatch")
+def verify_committed_temp(parent_fd, basename, expected_stat):
+    final_stat = os.lstat(basename, dir_fd=parent_fd)
+    if not stat.S_ISLNK(final_stat.st_mode) and same_identity(final_stat, expected_stat):
+        return final_stat
+    try: os.unlink(basename, dir_fd=parent_fd)
+    except FileNotFoundError: pass
+    raise RuntimeError("fs-safe-temp-mismatch")
+def commit_temp_file(parent_fd, temp_name, basename, overwrite, mode, expected_stat):
+    verify_temp_name(parent_fd, temp_name, expected_stat)
     if overwrite:
         os.replace(temp_name, basename, src_dir_fd=parent_fd, dst_dir_fd=parent_fd)
+        return verify_committed_temp(parent_fd, basename, expected_stat)
     else:
         try:
             os.link(temp_name, basename, src_dir_fd=parent_fd, dst_dir_fd=parent_fd, follow_symlinks=False)
+            final_stat = verify_committed_temp(parent_fd, basename, expected_stat)
             os.unlink(temp_name, dir_fd=parent_fd)
+            return final_stat
         except OSError as exc:
             if not link_unsupported(exc):
                 raise
-            copy_file_no_replace(parent_fd, temp_name, parent_fd, basename, mode, unlink_source=True)
-
+            return copy_file_no_replace(parent_fd, temp_name, parent_fd, basename, mode, expected_stat, True)
+def assert_expected_root(root_fd, payload):
+    if "rootDev" in payload or "rootIno" in payload:
+        root_stat = os.fstat(root_fd)
+        if root_stat.st_dev != int(payload["rootDev"]) or root_stat.st_ino != int(payload["rootIno"]):
+            raise RuntimeError("fs-safe-root-mismatch")
 def stat_path(root_fd, payload):
     relative = payload.get("relativePath", "")
     segments = split_relative(relative)
@@ -1523,7 +1716,6 @@ def stat_path(root_fd, payload):
         return encode_stat(st)
     finally:
         os.close(parent_fd)
-
 def readdir_path(root_fd, payload):
     dir_fd = walk_dir(root_fd, split_relative(payload.get("relativePath", "")))
     try:
@@ -1539,12 +1731,9 @@ def readdir_path(root_fd, payload):
         return entries
     finally:
         os.close(dir_fd)
-
 def mkdirp_path(root_fd, payload):
     dir_fd = walk_dir(root_fd, split_relative(payload.get("relativePath", "")), mkdir_enabled=True)
-    os.close(dir_fd)
-    return None
-
+    os.close(dir_fd); return None
 def remove_tree(parent_fd, basename):
     st = os.lstat(basename, dir_fd=parent_fd)
     if stat.S_ISDIR(st.st_mode) and not stat.S_ISLNK(st.st_mode):
@@ -1557,7 +1746,6 @@ def remove_tree(parent_fd, basename):
         os.rmdir(basename, dir_fd=parent_fd)
     else:
         os.unlink(basename, dir_fd=parent_fd)
-
 def remove_path(root_fd, payload):
     parent_fd, basename = parent_and_basename(root_fd, payload.get("relativePath", ""))
     try:
@@ -1640,14 +1828,15 @@ def write_path(root_fd, payload):
             except FileNotFoundError:
                 pass
         temp_name, temp_fd = create_temp_file(parent_fd, basename, mode)
+        os.fchmod(temp_fd, mode)
         write_all(temp_fd, data)
         os.fsync(temp_fd)
+        temp_stat = os.fstat(temp_fd)
         os.close(temp_fd)
         temp_fd = None
-        commit_temp_file(parent_fd, temp_name, basename, overwrite, mode)
+        result_stat = commit_temp_file(parent_fd, temp_name, basename, overwrite, mode, temp_stat)
         temp_name = None
         os.fsync(parent_fd)
-        result_stat = os.stat(basename, dir_fd=parent_fd, follow_symlinks=False)
         return {"dev": result_stat.st_dev, "ino": result_stat.st_ino}
     finally:
         if temp_fd is not None:
@@ -1678,6 +1867,7 @@ def copy_path(root_fd, payload):
             raise RuntimeError("fs-safe-too-large:%d:%d" % (max_bytes, source_stat.st_size))
         parent_fd = walk_dir(root_fd, split_relative(payload.get("relativeParentPath", "")), bool(payload.get("mkdir", True)))
         temp_name, temp_fd = create_temp_file(parent_fd, basename, mode)
+        os.fchmod(temp_fd, mode)
         written_bytes = 0
         while True:
             chunk = os.read(source_fd, 65536)
@@ -1693,12 +1883,12 @@ def copy_path(root_fd, payload):
                     raise OSError(errno.EIO, "short write")
                 view = view[written:]
         os.fsync(temp_fd)
+        temp_stat = os.fstat(temp_fd)
         os.close(temp_fd)
         temp_fd = None
-        commit_temp_file(parent_fd, temp_name, basename, overwrite, mode)
+        result_stat = commit_temp_file(parent_fd, temp_name, basename, overwrite, mode, temp_stat)
         temp_name = None
         os.fsync(parent_fd)
-        result_stat = os.stat(basename, dir_fd=parent_fd, follow_symlinks=False)
         return {"dev": result_stat.st_dev, "ino": result_stat.st_ino}
     finally:
         os.close(source_fd)
@@ -1715,6 +1905,7 @@ def copy_path(root_fd, payload):
 def run_operation(operation, root_path, payload):
     root_fd = open_dir(root_path)
     try:
+        assert_expected_root(root_fd, payload)
         if operation == "stat":
             return stat_path(root_fd, payload)
         if operation == "readdir":
@@ -1819,6 +2010,12 @@ function mapWorkerError(response) {
     if (message.includes("fs-safe-source-mismatch")) {
         return new errors_FsSafeError("path-mismatch", "source path changed during copy");
     }
+    if (message.includes("fs-safe-temp-mismatch")) {
+        return new errors_FsSafeError("path-mismatch", "temp path changed during write");
+    }
+    if (message.includes("fs-safe-root-mismatch")) {
+        return new errors_FsSafeError("path-mismatch", "root path changed during operation");
+    }
     if (message.includes("fs-safe-directory-noreplace-unsupported")) {
         return new errors_FsSafeError("invalid-path", "directory moves require overwrite: true");
     }
@@ -1999,9 +2196,7 @@ function validatePinnedOperationPayload(payload) {
     }
 }
 function isPinnedHelperUnavailable(error) {
-    return error instanceof Error &&
-        "code" in error &&
-        error.code === "helper-unavailable";
+    return error instanceof Error && "code" in error && error.code === "helper-unavailable";
 }
 function validatePinnedRelativePath(relativePath) {
     if (relativePath.length === 0 || relativePath === ".") {
@@ -2099,29 +2294,21 @@ function assertWithinMaxBytes(bytes, maxBytes) {
         throw new errors_FsSafeError("too-large", `file exceeds limit of ${maxBytes} bytes (got at least ${bytes})`);
     }
 }
-function pinned_write_createMaxBytesTransform(maxBytes) {
-    if (maxBytes === undefined) {
-        return undefined;
-    }
+async function writeStreamToHandle(stream, handle, maxBytes) {
     let bytes = 0;
-    return new external_node_stream_.Transform({
-        transform(chunk, _encoding, callback) {
-            bytes += chunk.byteLength;
-            if (bytes > maxBytes) {
-                callback(new errors_FsSafeError("too-large", `file exceeds limit of ${maxBytes} bytes (got at least ${bytes})`));
-                return;
+    for await (const chunk of stream) {
+        const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        bytes += buffer.byteLength;
+        assertWithinMaxBytes(bytes, maxBytes);
+        let offset = 0;
+        while (offset < buffer.byteLength) {
+            const { bytesWritten } = await handle.write(buffer, offset, buffer.byteLength - offset);
+            if (bytesWritten <= 0) {
+                throw new errors_FsSafeError("helper-failed", "fallback stream write made no progress");
             }
-            callback(null, chunk);
-        },
-    });
-}
-async function pipelineWithMaxBytes(stream, destination, maxBytes) {
-    const limiter = pinned_write_createMaxBytesTransform(maxBytes);
-    if (limiter) {
-        await (0,external_node_stream_promises_.pipeline)(stream, limiter, destination);
-        return;
+            offset += bytesWritten;
+        }
     }
-    await (0,external_node_stream_promises_.pipeline)(stream, destination);
 }
 async function inputToBase64(input, maxBytes) {
     if (input.kind === "buffer") {
@@ -2167,6 +2354,7 @@ async function runPinnedWriteHelper(params) {
         mode: params.mode || 0o600,
         overwrite: params.overwrite !== false,
         relativeParentPath: params.relativeParentPath,
+        ...(params.rootIdentity ? { rootDev: params.rootIdentity.dev, rootIno: params.rootIdentity.ino } : {}),
     };
     try {
         return await runPinnedPythonOperation({
@@ -2197,6 +2385,7 @@ async function runPinnedCopyHelper(params) {
             mode: params.mode || 0o600,
             overwrite: params.overwrite !== false,
             relativeParentPath: params.relativeParentPath,
+            ...(params.rootIdentity ? { rootDev: params.rootIdentity.dev, rootIno: params.rootIdentity.ino } : {}),
             sourceDev: params.sourceIdentity.dev,
             sourceIno: params.sourceIdentity.ino,
             sourcePath: params.sourcePath,
@@ -2207,12 +2396,12 @@ async function runPinnedWriteFallback(params) {
     const parentPath = params.relativeParentPath
         ? external_node_path_.join(params.rootPath, ...params.relativeParentPath.split("/"))
         : params.rootPath;
-    const parentGuard = await directory_guard_createNearestExistingDirectoryGuard(params.rootPath, parentPath);
     if (params.mkdir) {
-        await withAsyncDirectoryGuards([parentGuard], async () => {
-            await promises_.mkdir(parentPath, { recursive: true });
-        });
+        await mkdirPathComponentsWithGuards({ rootReal: params.rootPath, targetPath: parentPath });
     }
+    const parentGuard = params.mkdir
+        ? await directory_guard_createAsyncDirectoryGuard(parentPath)
+        : await directory_guard_createNearestExistingDirectoryGuard(params.rootPath, parentPath);
     const targetPath = external_node_path_.join(parentPath, params.basename);
     if (params.overwrite === false) {
         let handle = await withAsyncDirectoryGuards([parentGuard], async () => await promises_.open(targetPath, external_node_fs_.constants.O_WRONLY | external_node_fs_.constants.O_CREAT | external_node_fs_.constants.O_EXCL, params.mode), {
@@ -2234,7 +2423,7 @@ async function runPinnedWriteFallback(params) {
                 }
             }
             else {
-                await pipelineWithMaxBytes(params.input.stream, handle.createWriteStream(), params.maxBytes);
+                await writeStreamToHandle(params.input.stream, handle, params.maxBytes);
             }
             const stat = await handle.stat();
             created = false;
@@ -2255,7 +2444,9 @@ async function runPinnedWriteFallback(params) {
             ? external_node_fs_.constants.O_NOFOLLOW
             : 0);
     let handle;
-    let handleClosedByStream = false;
+    let tempStat;
+    let targetStat;
+    let renamed = false;
     try {
         handle = await promises_.open(tempPath, tempFlags, params.mode);
         if (params.input.kind === "buffer") {
@@ -2268,29 +2459,36 @@ async function runPinnedWriteFallback(params) {
             }
         }
         else {
-            const writable = handle.createWriteStream();
-            writable.once("close", () => {
-                handleClosedByStream = true;
-            });
-            await pipelineWithMaxBytes(params.input.stream, writable, params.maxBytes);
+            await writeStreamToHandle(params.input.stream, handle, params.maxBytes);
         }
-        if (!handleClosedByStream) {
-            await handle.close().catch(() => undefined);
-            handle = undefined;
+        tempStat = await handle.stat();
+        const tempPathStat = await promises_.lstat(tempPath);
+        if (tempPathStat.isSymbolicLink() || !file_identity_sameFileIdentity(tempPathStat, tempStat)) {
+            throw new errors_FsSafeError("path-mismatch", "fallback temp path changed during write");
         }
+        const expectedTempStat = tempStat;
+        await handle.close().catch(() => undefined);
+        handle = undefined;
         await withAsyncDirectoryGuards([parentGuard], async () => {
             await promises_.rename(tempPath, targetPath);
+            renamed = true;
+            targetStat = await promises_.lstat(targetPath);
+            if (targetStat.isSymbolicLink() || !file_identity_sameFileIdentity(targetStat, expectedTempStat)) {
+                throw new errors_FsSafeError("path-mismatch", "fallback target changed during write");
+            }
         });
     }
     catch (error) {
-        if (handle && !handleClosedByStream) {
-            await handle.close().catch(() => undefined);
+        await handle?.close().catch(() => undefined);
+        if (!renamed) {
+            await promises_.rm(tempPath, { force: true }).catch(() => undefined);
         }
-        await promises_.rm(tempPath, { force: true }).catch(() => undefined);
         throw error;
     }
-    const stat = await promises_.stat(targetPath);
-    return { dev: stat.dev, ino: stat.ino };
+    if (!targetStat) {
+        throw new errors_FsSafeError("path-mismatch", "fallback target was not verified");
+    }
+    return { dev: targetStat.dev, ino: targetStat.ino };
 }
 
 // EXTERNAL MODULE: external "node:os"
@@ -2316,7 +2514,7 @@ async function resolveRootPath(params) {
     const absolutePath = external_node_path_.resolve(params.absolutePath);
     const rootCanonicalPath = params.rootCanonicalPath
         ? external_node_path_.resolve(params.rootCanonicalPath)
-        : await resolvePathViaExistingAncestor(rootPath);
+        : await root_path_resolvePathViaExistingAncestor(rootPath);
     const context = createBoundaryResolutionContext({
         resolveParams: params,
         rootPath,
@@ -2685,7 +2883,7 @@ async function resolveOutsideLexicalCanonicalPathAsync(params) {
     if (path_isPathInside(params.rootPath, params.absolutePath)) {
         return undefined;
     }
-    return await resolvePathViaExistingAncestor(params.absolutePath);
+    return await root_path_resolvePathViaExistingAncestor(params.absolutePath);
 }
 function resolveOutsideLexicalCanonicalPathSync(params) {
     if (isPathInside(params.rootPath, params.absolutePath)) {
@@ -2732,11 +2930,11 @@ function buildResolvedRootPath(params) {
         kind: params.kind.kind,
     };
 }
-async function resolvePathViaExistingAncestor(targetPath) {
+async function root_path_resolvePathViaExistingAncestor(targetPath) {
     const normalized = external_node_path_.resolve(targetPath);
     let cursor = normalized;
     const missingSuffix = [];
-    while (!isFilesystemRoot(cursor) && !(await pathExists(cursor))) {
+    while (!isFilesystemRoot(cursor) && !(await root_path_pathExists(cursor))) {
         missingSuffix.unshift(external_node_path_.basename(cursor));
         const parent = external_node_path_.dirname(cursor);
         if (parent === cursor) {
@@ -2744,7 +2942,7 @@ async function resolvePathViaExistingAncestor(targetPath) {
         }
         cursor = parent;
     }
-    if (!(await pathExists(cursor))) {
+    if (!(await root_path_pathExists(cursor))) {
         return normalized;
     }
     try {
@@ -2829,7 +3027,7 @@ function relativeInsideRoot(rootPath, targetPath) {
     if (!relative || relative === ".") {
         return "";
     }
-    if (relative.startsWith("..") || external_node_path_.isAbsolute(relative)) {
+    if (isPathRelativeEscape(relative)) {
         return "";
     }
     return relative;
@@ -2856,7 +3054,7 @@ function shortPath(value) {
 function isFilesystemRoot(candidate) {
     return external_node_path_.parse(candidate).root === candidate;
 }
-async function pathExists(targetPath) {
+async function root_path_pathExists(targetPath) {
     try {
         await promises_.lstat(targetPath);
         return true;
@@ -2878,7 +3076,7 @@ async function resolveSymlinkHopPath(symlinkPath) {
         }
         const linkTarget = await promises_.readlink(symlinkPath);
         const linkAbsolute = external_node_path_.resolve(external_node_path_.dirname(symlinkPath), linkTarget);
-        return resolvePathViaExistingAncestor(linkAbsolute);
+        return root_path_resolvePathViaExistingAncestor(linkAbsolute);
     }
 }
 function resolveSymlinkHopPathSync(symlinkPath) {
@@ -2947,6 +3145,23 @@ function path_policy_shortPath(value) {
     return value;
 }
 
+;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/read-opened-file.js
+
+async function read_opened_file_readOpenedFileSafely(params) {
+    if (params.maxBytes !== undefined && params.opened.stat.size > params.maxBytes) {
+        throw new errors_FsSafeError("too-large", `file exceeds limit of ${params.maxBytes} bytes (got ${params.opened.stat.size})`);
+    }
+    const buffer = await params.opened.handle.readFile();
+    if (params.maxBytes !== undefined && buffer.byteLength > params.maxBytes) {
+        throw new errors_FsSafeError("too-large", `file exceeds limit of ${params.maxBytes} bytes (got ${buffer.byteLength})`);
+    }
+    return {
+        buffer,
+        realPath: params.opened.realPath,
+        stat: params.opened.stat,
+    };
+}
+
 ;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/path-stat.js
 function pathStatFromStats(stat) {
     return {
@@ -3274,6 +3489,10 @@ async function serializePathWrite(key, run) {
 
 
 
+
+
+
+
 
 
 
@@ -3472,6 +3691,7 @@ class RootHandle {
             mkdir: this.defaults.mkdir,
             mode: this.defaults.mode,
             ...options,
+            denyMutations: mergeDenyMutationPolicies(this.defaults.denyMutations, options.denyMutations),
             append: writeMode === "append",
             truncateExisting: writeMode === "replace",
         });
@@ -3483,18 +3703,29 @@ class RootHandle {
             mkdir: this.defaults.mkdir,
             mode: this.defaults.mode,
             ...options,
+            denyMutations: mergeDenyMutationPolicies(this.defaults.denyMutations, options.denyMutations),
         });
     }
-    async remove(relativePath) {
+    async remove(relativePath, options = {}) {
         assertValidRootRelativePath(relativePath);
-        await removePathInRoot(this.context, relativePath);
+        await removePathInRoot(this.context, {
+            relativePath,
+            denyMutations: mergeDenyMutationPolicies(this.defaults.denyMutations, options.denyMutations),
+        });
     }
-    async mkdir(relativePath) {
+    async mkdir(relativePath, options = {}) {
         assertValidRootRelativePath(relativePath);
-        await mkdirPathInRoot(this.context, { relativePath });
+        await mkdirPathInRoot(this.context, {
+            relativePath,
+            denyMutations: mergeDenyMutationPolicies(this.defaults.denyMutations, options.denyMutations),
+        });
     }
-    async ensureRoot() {
-        await mkdirPathInRoot(this.context, { relativePath: "", allowRoot: true });
+    async ensureRoot(options = {}) {
+        await mkdirPathInRoot(this.context, {
+            relativePath: "",
+            allowRoot: true,
+            denyMutations: mergeDenyMutationPolicies(this.defaults.denyMutations, options.denyMutations),
+        });
     }
     async write(relativePath, data, options = {}) {
         await writeFileInRoot(this.context, {
@@ -3503,6 +3734,7 @@ class RootHandle {
             mkdir: this.defaults.mkdir,
             mode: this.defaults.mode,
             ...options,
+            denyMutations: mergeDenyMutationPolicies(this.defaults.denyMutations, options.denyMutations),
         });
     }
     async create(relativePath, data, options = {}) {
@@ -3512,6 +3744,7 @@ class RootHandle {
             mkdir: this.defaults.mkdir,
             mode: this.defaults.mode,
             ...options,
+            denyMutations: mergeDenyMutationPolicies(this.defaults.denyMutations, options.denyMutations),
             overwrite: false,
         });
     }
@@ -3534,6 +3767,7 @@ class RootHandle {
             mkdir: this.defaults.mkdir,
             mode: this.defaults.mode,
             ...options,
+            denyMutations: mergeDenyMutationPolicies(this.defaults.denyMutations, options.denyMutations),
         });
     }
     async exists(relativePath) {
@@ -3577,6 +3811,12 @@ class RootHandle {
     async move(fromRelative, toRelative, options = {}) {
         assertValidRootRelativePath(fromRelative);
         assertValidRootRelativePath(toRelative);
+        const denyMutations = mergeDenyMutationPolicies(this.defaults.denyMutations, options.denyMutations);
+        await assertMoveMutationAllowed(this.context, {
+            fromRelative,
+            toRelative,
+            denyMutations,
+        });
         try {
             await runPinnedHelper("rename", this.rootReal, {
                 from: fromRelative,
@@ -3588,6 +3828,7 @@ class RootHandle {
             if (canFallbackFromPythonError(error)) {
                 await movePathFallback(this.context, {
                     fromRelative,
+                    denyMutations,
                     overwrite: options.overwrite ?? false,
                     toRelative,
                 });
@@ -3636,7 +3877,7 @@ async function openFileInRoot(root, params) {
 async function readFileInRoot(root, params) {
     const opened = await openFileInRoot(root, params);
     try {
-        return await readOpenedFileSafely({ opened, maxBytes: params.maxBytes });
+        return await read_opened_file_readOpenedFileSafely({ opened, maxBytes: params.maxBytes });
     }
     finally {
         await opened.handle.close().catch(() => { });
@@ -3669,20 +3910,6 @@ async function openLocalFileSafely(params) {
     assertNoNulPathInput(params.filePath, "file path contains a NUL byte");
     return await openVerifiedLocalFile(params.filePath);
 }
-async function readOpenedFileSafely(params) {
-    if (params.maxBytes !== undefined && params.opened.stat.size > params.maxBytes) {
-        throw new errors_FsSafeError("too-large", `file exceeds limit of ${params.maxBytes} bytes (got ${params.opened.stat.size})`);
-    }
-    const buffer = await params.opened.handle.readFile();
-    if (params.maxBytes !== undefined && buffer.byteLength > params.maxBytes) {
-        throw new errors_FsSafeError("too-large", `file exceeds limit of ${params.maxBytes} bytes (got ${buffer.byteLength})`);
-    }
-    return {
-        buffer,
-        realPath: params.opened.realPath,
-        stat: params.opened.stat,
-    };
-}
 function emitWriteBoundaryWarning(reason) {
     logWarn(`security: fs-safe write boundary warning (${reason})`);
 }
@@ -3723,82 +3950,9 @@ async function verifyAtomicWriteResult(params) {
         await opened.handle.close().catch(() => { });
     }
 }
-async function resolveOpenedFileRealPathForHandle(handle, ioPath) {
-    const handleStat = await handle.stat();
-    const fdCandidates = process.platform === "linux"
-        ? [`/proc/self/fd/${handle.fd}`, `/dev/fd/${handle.fd}`]
-        : process.platform === "win32"
-            ? []
-            : [`/dev/fd/${handle.fd}`];
-    for (const fdPath of fdCandidates) {
-        try {
-            const fdRealPath = await promises_.realpath(fdPath);
-            const fdRealStat = await promises_.stat(fdRealPath);
-            if (file_identity_sameFileIdentity(handleStat, fdRealStat)) {
-                return fdRealPath;
-            }
-        }
-        catch {
-            // try next fd path
-        }
-    }
-    try {
-        const ioRealPath = await promises_.realpath(ioPath);
-        const ioRealStat = await promises_.stat(ioRealPath);
-        if (file_identity_sameFileIdentity(handleStat, ioRealStat)) {
-            return ioRealPath;
-        }
-    }
-    catch (err) {
-        if (!path_isNotFoundPathError(err)) {
-            throw err;
-        }
-    }
-    const parentResolved = await resolveOpenedFileRealPathFromParent(handleStat, ioPath);
-    if (parentResolved) {
-        return parentResolved;
-    }
-    throw new errors_FsSafeError("path-mismatch", "unable to resolve opened file path");
-}
-async function resolveOpenedFileRealPathFromParent(handleStat, ioPath) {
-    let parentReal;
-    try {
-        parentReal = await promises_.realpath(external_node_path_.dirname(ioPath));
-    }
-    catch (err) {
-        if (path_isNotFoundPathError(err)) {
-            return null;
-        }
-        throw err;
-    }
-    let entries;
-    try {
-        entries = await promises_.readdir(parentReal);
-    }
-    catch (err) {
-        if (path_isNotFoundPathError(err)) {
-            return null;
-        }
-        throw err;
-    }
-    for (const entry of entries.toSorted()) {
-        const candidatePath = external_node_path_.join(parentReal, entry);
-        try {
-            const candidateStat = await promises_.lstat(candidatePath);
-            if (candidateStat.isFile() && file_identity_sameFileIdentity(handleStat, candidateStat)) {
-                return await promises_.realpath(candidatePath);
-            }
-        }
-        catch (err) {
-            if (!path_isNotFoundPathError(err)) {
-                throw err;
-            }
-        }
-    }
-    return null;
-}
 async function openWritableFileInRoot(root, params) {
     const { rootReal, rootWithSep, resolved } = await resolvePathInRoot(root, params.relativePath);
+    await assertMutationNotDenied(resolved, params.denyMutations);
     try {
         await assertNoPathAliasEscape({
             absolutePath: resolved,
@@ -3925,6 +4079,7 @@ async function appendFileInRoot(root, params) {
         relativePath: params.relativePath,
         mkdir: params.mkdir,
         mode: params.mode,
+        denyMutations: params.denyMutations,
         truncateExisting: false,
         append: true,
     });
@@ -3952,8 +4107,8 @@ async function appendFileInRoot(root, params) {
         await target.handle.close().catch(() => { });
     }
 }
-async function removePathInRoot(root, relativePath) {
-    const resolved = await resolvePinnedRemovePathInRoot(root, relativePath);
+async function removePathInRoot(root, params) {
+    const resolved = await resolvePinnedRemovePathInRoot(root, params.relativePath, params.denyMutations);
     if (process.platform === "win32") {
         await removePathFallback(resolved);
         return;
@@ -4001,7 +4156,7 @@ async function writeFileInRoot(root, params) {
         });
         return;
     }
-    const pinned = await resolvePinnedWriteTargetInRoot(root, params.relativePath, params.mode);
+    const pinned = await resolvePinnedWriteTargetInRoot(root, params.relativePath, params.mode, params.denyMutations);
     await serializePathWrite(pinned.targetPath, async () => {
         let identity;
         try {
@@ -4057,7 +4212,7 @@ async function copyFileInRoot(root, params) {
             });
             return;
         }
-        const pinned = await resolvePinnedWriteTargetInRoot(root, params.relativePath, params.mode);
+        const pinned = await resolvePinnedWriteTargetInRoot(root, params.relativePath, params.mode, params.denyMutations);
         await serializePathWrite(pinned.targetPath, async () => {
             let identity;
             try {
@@ -4101,8 +4256,9 @@ async function copyFileInRoot(root, params) {
         await source.handle.close().catch(() => { });
     }
 }
-async function resolvePinnedWriteTargetInRoot(root, relativePath, requestedMode) {
+async function resolvePinnedWriteTargetInRoot(root, relativePath, requestedMode, denyMutations) {
     const { rootReal, rootWithSep, resolved } = await resolvePathInRoot(root, relativePath);
+    await assertMutationNotDenied(resolved, denyMutations);
     try {
         await assertNoPathAliasEscape({
             absolutePath: resolved,
@@ -4159,12 +4315,16 @@ async function resolvePinnedWriteTargetInRoot(root, relativePath, requestedMode)
 async function resolvePinnedPathInRoot(root, params) {
     return await resolvePinnedOperationPathInRoot(root, {
         allowRoot: params.allowRoot,
+        denyMutations: params.denyMutations,
+        protectDenyMutationAncestors: false,
         relativePath: params.relativePath,
         policy: PATH_ALIAS_POLICIES.strict,
     });
 }
-async function resolvePinnedRemovePathInRoot(root, relativePath) {
+async function resolvePinnedRemovePathInRoot(root, relativePath, denyMutations) {
     return await resolvePinnedOperationPathInRoot(root, {
+        denyMutations,
+        protectDenyMutationAncestors: true,
         relativePath,
         policy: PATH_ALIAS_POLICIES.unlinkTarget,
     });
@@ -4176,6 +4336,7 @@ async function resolvePinnedOperationPathInRoot(root, params) {
     });
     const relativeResolved = external_node_path_.relative(resolved.rootReal, resolved.canonicalPath);
     if ((relativeResolved === "" || relativeResolved === ".") && params.allowRoot === true) {
+        await assertMutationNotDenied(resolved.canonicalPath, params.denyMutations);
         return { rootReal: resolved.rootReal, resolved: resolved.canonicalPath, relativePosix: "" };
     }
     const firstSegment = relativeResolved.split(external_node_path_.sep)[0];
@@ -4189,6 +4350,9 @@ async function resolvePinnedOperationPathInRoot(root, params) {
     if (!path_isPathInside(resolved.rootWithSep, resolved.canonicalPath)) {
         throw new errors_FsSafeError("outside-workspace", "file is outside workspace root");
     }
+    await assertMutationNotDenied(resolved.canonicalPath, params.denyMutations, {
+        protectAncestors: params.protectDenyMutationAncestors,
+    });
     return { rootReal: resolved.rootReal, resolved: resolved.canonicalPath, relativePosix };
 }
 async function resolvePinnedRootPathInRoot(root, params) {
@@ -4266,13 +4430,21 @@ async function listPathFallback(root, relativePath, withFileTypes) {
         throw error;
     }
 }
+async function assertMoveMutationAllowed(root, params) {
+    const source = await resolvePathInRoot(root, params.fromRelative);
+    await assertMutationNotDenied(source.resolved, params.denyMutations, { protectAncestors: true });
+    const target = await resolvePathInRoot(root, params.toRelative);
+    await assertMutationNotDenied(target.resolved, params.denyMutations, { protectAncestors: true });
+}
 async function movePathFallback(root, params) {
     const source = await resolvePathInRoot(root, params.fromRelative);
+    await assertMutationNotDenied(source.resolved, params.denyMutations, { protectAncestors: true });
     await resolvePinnedRootPathInRoot(root, {
         relativePath: params.fromRelative,
         policy: PATH_ALIAS_POLICIES.strict,
     });
     const target = await resolvePathInRoot(root, params.toRelative);
+    await assertMutationNotDenied(target.resolved, params.denyMutations, { protectAncestors: true });
     await resolvePinnedRootPathInRoot(root, {
         relativePath: params.toRelative,
         policy: PATH_ALIAS_POLICIES.unlinkTarget,
@@ -4356,6 +4528,7 @@ async function writeFileFallback(root, params) {
         relativePath: params.relativePath,
         mkdir: params.mkdir,
         mode: params.mode,
+        denyMutations: params.denyMutations,
         truncateExisting: false,
     });
     const destinationPath = target.realPath;
@@ -4401,6 +4574,7 @@ async function writeFileFallback(root, params) {
 }
 async function writeMissingFileFallback(root, params) {
     const { rootReal, resolved } = await resolvePathInRoot(root, params.relativePath);
+    await assertMutationNotDenied(resolved, params.denyMutations);
     try {
         await assertNoPathAliasEscape({
             absolutePath: resolved,
@@ -4474,6 +4648,7 @@ async function copyFileFallback(root, params, source) {
             relativePath: params.relativePath,
             mkdir: params.mkdir,
             mode: params.mode,
+            denyMutations: params.denyMutations,
             truncateExisting: false,
         });
         const destinationPath = target.realPath;
@@ -4634,7 +4809,7 @@ async function pathExistsWithinRoot(targetDir, relativePath) {
  * FsSafeError as their `cause` and should be re-thrown rather than
  * silently swallowed by per-file error handlers.
  */ function isFsSafeViolation(error) {
-    return error instanceof Error && error.cause instanceof FsSafeError;
+    return error instanceof Error && error.cause instanceof errors_FsSafeError;
 }
 async function statWithinRoot(targetDir, relativePath) {
     try {
@@ -19078,7 +19253,7 @@ function formatHeadingAsSetext(node, state) {
       node.type === 'break'
     ) {
       literalWithBreak = true
-      return EXIT
+      return (/* inlined export .EXIT */false)
     }
   })
 
@@ -33401,6 +33576,7 @@ const PackageJsonSchema = schemas_object({
  */ 
 
 
+
 /** Maximum skill file size: 1 MB */ const MAX_SKILL_FILE_BYTES = 1_048_576;
 /**
  * Skill directory locations to search for SKILL.md files.
@@ -33409,6 +33585,33 @@ const PackageJsonSchema = schemas_object({
     (0,external_node_path_.join)(".claude", "skills"),
     (0,external_node_path_.join)(".agents", "skills")
 ];
+/** Maximum lock file size: 256 KB */ const MAX_LOCK_FILE_BYTES = 262_144;
+/** Relative path to the skills lock file. */ const SKILLS_LOCK_PATH = "skills-lock.json";
+/** Zod schema for skills-lock.json structure */ const SkillsLockSchema = schemas_object({
+    skills: record(schemas_string(), schemas_unknown()).optional()
+});
+/**
+ * Reads the skills-lock.json file and returns the set of locked skill names.
+ * Returns an empty set if the file does not exist or cannot be parsed.
+ */ async function readLockedSkillNames(targetDir) {
+    try {
+        const exists = await pathExistsWithinRoot(targetDir, SKILLS_LOCK_PATH);
+        if (!exists) {
+            return new Set();
+        }
+        const content = await readTextWithinRoot(targetDir, SKILLS_LOCK_PATH, MAX_LOCK_FILE_BYTES);
+        const result = SkillsLockSchema.safeParse(JSON.parse(content));
+        if (result.success && Object.hasOwn(result.data, "skills") && result.data.skills != null) {
+            return new Set(Object.keys(result.data.skills));
+        }
+        return new Set();
+    } catch (error) {
+        if (isFsSafeViolation(error)) {
+            throw error;
+        }
+        return new Set();
+    }
+}
 /**
  * File system implementation of the skill lint gateway.
  */ class FileSystemSkillLintGateway {
@@ -33418,7 +33621,11 @@ const PackageJsonSchema = schemas_object({
             const discovered = await this.discoverSkillsInDir(targetDir, relativeDir);
             skills.push(...discovered);
         }
-        return skills;
+        const lockedNames = await readLockedSkillNames(targetDir);
+        if (lockedNames.size === 0) {
+            return skills;
+        }
+        return skills.filter((skill)=>!lockedNames.has(skill.skillName));
     }
     async discoverSkillsInDir(targetDir, skillsDir) {
         try {
@@ -45923,10 +46130,11 @@ exports.visitAsync = visitAsync;
 
 },
 5492(__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
+const t=Symbol.for(`__confbox_fmt__`),n=/^(\s+)/,r=/(\s+)$/;function i(e,t={}){return{sample:t.indent===void 0&&t.preserveIndentation!==!1&&e.slice(0,t?.sampleSize||1024),whiteSpace:t.preserveWhitespace===!1?void 0:{start:n.exec(e)?.[0]||``,end:r.exec(e)?.[0]||``}}}function a(e,n,r){!n||typeof n!=`object`||Object.defineProperty(n,t,{enumerable:!1,configurable:!0,writable:!0,value:i(e,r)})}function o(n,r){if(!n||typeof n!=`object`||!(t in n))return{indent:r?.indent??2,whitespace:{start:``,end:``}};let i=n[t];return{indent:r?.indent||e(i.sample||``).indent,whitespace:i.whiteSpace||{start:``,end:``}}}
 __webpack_require__.d(__webpack_exports__, {
   n: () => (a)
 });
-const t=Symbol.for(`__confbox_fmt__`),n=/^(\s+)/,r=/(\s+)$/;function i(e,t={}){return{sample:t.indent===void 0&&t.preserveIndentation!==!1&&e.slice(0,t?.sampleSize||1024),whiteSpace:t.preserveWhitespace===!1?void 0:{start:n.exec(e)?.[0]||``,end:r.exec(e)?.[0]||``}}}function a(e,n,r){!n||typeof n!=`object`||Object.defineProperty(n,t,{enumerable:!1,configurable:!0,writable:!0,value:i(e,r)})}function o(n,r){if(!n||typeof n!=`object`||!(t in n))return{indent:r?.indent??2,whitespace:{start:``,end:``}};let i=n[t];return{indent:r?.indent||e(i.sample||``).indent,whitespace:i.whiteSpace||{start:``,end:``}}}
+
 
 },
 5975(__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
@@ -46011,12 +46219,16 @@ __webpack_require__.t = function(value, mode) {
 })();
 // webpack/runtime/define_property_getters
 (() => {
-__webpack_require__.d = (exports, definition) => {
-	for(var key in definition) {
-        if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
-            Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
-        }
-    }
+__webpack_require__.d = (exports, getters, values) => {
+	var define = (defs, kind) => {
+		for(var key in defs) {
+			if(__webpack_require__.o(defs, key) && !__webpack_require__.o(exports, key)) {
+				Object.defineProperty(exports, key, { enumerable: true, [kind]: defs[key] });
+			}
+		}
+	};
+	define(getters, "get");
+	define(values, "value");
 };
 })();
 // webpack/runtime/ensure_chunk
@@ -46118,7 +46330,7 @@ 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__(4403);
+var __webpack_exports__ = __webpack_require__(9884);
 var __webpack_exports__DEFAULT_LINT_RULES = __webpack_exports__.Kd;
 var __webpack_exports__LintValidationError = __webpack_exports__.F5;
 var __webpack_exports__createFormatter = __webpack_exports__.xi;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@lousy-agents/lint",
-    "version": "5.14.9",
+    "version": "5.15.0",
     "description": "Programmatic lint API for validating AI coding assistant configurations — skills, agents, hooks, and instructions",
     "type": "module",
     "repository": {