@lousy-agents/mcp 5.14.1 → 5.14.2

package/dist/mcp-server.js

@@ -6559,7 +6559,7 @@ function escapeJsonPtr(str) {
 
 
 },
-8050(__unused_rspack_module, __unused_rspack___webpack_exports__, __webpack_require__) {
+2415(__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);
@@ -26479,8 +26479,6 @@ const EMPTY_COMPLETION_RESULT = {
     }
 };
 //# sourceMappingURL=mcp.js.map
-// EXTERNAL MODULE: external "node:fs/promises"
-var promises_ = __webpack_require__(1455);
 // EXTERNAL MODULE: external "node:path"
 var external_node_path_ = __webpack_require__(6760);
 ;// CONCATENATED MODULE: ../core/src/gateways/action-version-gateway.ts
@@ -26506,34 +26504,3651 @@ var external_node_path_ = __webpack_require__(6760);
         // Simulate async lookup (for future remote API compatibility)
         return DEFAULT_ACTION_VERSIONS[actionName];
     }
-    async getVersions(actionNames) {
-        const result = {};
-        for (const actionName of actionNames){
-            const version = await this.getVersion(actionName);
-            if (version) {
-                result[actionName] = version;
+    async getVersions(actionNames) {
+        const result = {};
+        for (const actionName of actionNames){
+            const version = await this.getVersion(actionName);
+            if (version) {
+                result[actionName] = version;
+            }
+        }
+        return result;
+    }
+}
+/**
+ * Creates and returns the default action version gateway
+ */ function createActionVersionGateway() {
+    return new LocalActionVersionGateway();
+}
+/**
+ * List of known action names for convenience
+ */ const KNOWN_ACTIONS = Object.keys(DEFAULT_ACTION_VERSIONS);
+
+// EXTERNAL MODULE: external "node:fs/promises"
+var promises_ = __webpack_require__(1455);
+// EXTERNAL MODULE: external "node:fs"
+var external_node_fs_ = __webpack_require__(3024);
+;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/errors.js
+const OPERATIONAL_CODES = new Set([
+    "helper-failed",
+    "helper-unavailable",
+    "permission-unverified",
+    "timeout",
+    "unsupported-platform",
+]);
+function categorizeFsSafeError(code) {
+    return OPERATIONAL_CODES.has(code) ? "operational" : "policy";
+}
+class errors_FsSafeError extends Error {
+    code;
+    category;
+    constructor(code, message, options = {}) {
+        super(message, options);
+        this.name = "FsSafeError";
+        this.code = code;
+        this.category = categorizeFsSafeError(code);
+    }
+}
+
+// EXTERNAL MODULE: external "node:crypto"
+var external_node_crypto_ = __webpack_require__(7598);
+// EXTERNAL MODULE: external "node:stream/promises"
+var external_node_stream_promises_ = __webpack_require__(6466);
+// EXTERNAL MODULE: external "node:stream"
+var external_node_stream_ = __webpack_require__(7075);
+;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/bounded-read-stream.js
+
+
+function createMaxBytesTransform(maxBytes) {
+    let bytes = 0;
+    return new external_node_stream_.Transform({
+        transform(chunk, _encoding, callback) {
+            const buffer = chunk instanceof Buffer ? chunk : Buffer.from(chunk);
+            bytes += buffer.byteLength;
+            if (bytes > maxBytes) {
+                callback(new errors_FsSafeError("too-large", `file exceeds limit of ${maxBytes} bytes (got at least ${bytes})`));
+                return;
+            }
+            callback(null, buffer);
+        },
+    });
+}
+function createBoundedReadStream(opened, maxBytes) {
+    const stream = opened.handle.createReadStream();
+    return maxBytes === undefined ? stream : stream.pipe(createMaxBytesTransform(maxBytes));
+}
+
+;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/file-identity.js
+function isZero(value) {
+    return value === 0 || value === 0n;
+}
+function file_identity_sameFileIdentity(left, right, platform = process.platform) {
+    if (left.ino !== right.ino) {
+        return false;
+    }
+    // On Windows, path-based stat calls can report dev=0 while fd-based stat
+    // reports a real volume serial; treat either-side dev=0 as "unknown device".
+    if (left.dev === right.dev) {
+        return true;
+    }
+    return platform === "win32" && (isZero(left.dev) || isZero(right.dev));
+}
+
+;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/string-coerce.js
+function readStringValue(value) {
+    return typeof value === "string" ? value : undefined;
+}
+function normalizeNullableString(value) {
+    if (typeof value !== "string") {
+        return null;
+    }
+    const trimmed = value.trim();
+    return trimmed ? trimmed : null;
+}
+function normalizeOptionalString(value) {
+    return normalizeNullableString(value) ?? undefined;
+}
+function normalizeStringifiedOptionalString(value) {
+    if (typeof value === "string") {
+        return normalizeOptionalString(value);
+    }
+    if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
+        return normalizeOptionalString(String(value));
+    }
+    return undefined;
+}
+function normalizeOptionalLowercaseString(value) {
+    return normalizeOptionalString(value)?.toLowerCase();
+}
+function normalizeLowercaseStringOrEmpty(value) {
+    return normalizeOptionalLowercaseString(value) ?? "";
+}
+function normalizeFastMode(raw) {
+    if (typeof raw === "boolean") {
+        return raw;
+    }
+    if (!raw) {
+        return undefined;
+    }
+    const key = normalizeLowercaseStringOrEmpty(raw);
+    if (["off", "false", "no", "0", "disable", "disabled", "normal"].includes(key)) {
+        return false;
+    }
+    if (["on", "true", "yes", "1", "enable", "enabled", "fast"].includes(key)) {
+        return true;
+    }
+    return undefined;
+}
+function lowercasePreservingWhitespace(value) {
+    return value.toLowerCase();
+}
+function localeLowercasePreservingWhitespace(value) {
+    return value.toLocaleLowerCase();
+}
+function resolvePrimaryStringValue(value) {
+    if (typeof value === "string") {
+        return normalizeOptionalString(value);
+    }
+    if (!value || typeof value !== "object") {
+        return undefined;
+    }
+    return normalizeOptionalString(value.primary);
+}
+function normalizeOptionalThreadValue(value) {
+    if (typeof value === "number") {
+        return Number.isFinite(value) ? Math.trunc(value) : undefined;
+    }
+    return normalizeOptionalString(value);
+}
+function normalizeOptionalStringifiedId(value) {
+    const normalized = normalizeOptionalThreadValue(value);
+    return normalized == null ? undefined : String(normalized);
+}
+function hasNonEmptyString(value) {
+    return normalizeOptionalString(value) !== undefined;
+}
+
+;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/path.js
+
+
+
+
+const NOT_FOUND_CODES = new Set(["ENOENT", "ENOTDIR"]);
+const SYMLINK_OPEN_CODES = new Set(["ELOOP", "EINVAL", "ENOTSUP"]);
+const POSIX_SEPARATOR_CHAR_CODE = 0x2f;
+function normalizeWindowsPathForComparison(input) {
+    let normalized = external_node_path_.win32.normalize(input);
+    if (normalized.startsWith("\\\\?\\")) {
+        normalized = normalized.slice(4);
+        if (normalized.toUpperCase().startsWith("UNC\\")) {
+            normalized = `\\\\${normalized.slice(4)}`;
+        }
+    }
+    return normalizeLowercaseStringOrEmpty(normalized.replaceAll("/", "\\"));
+}
+function isNodeError(value) {
+    return Boolean(value && typeof value === "object" && "code" in value);
+}
+function hasNodeErrorCode(value, code) {
+    return isNodeError(value) && value.code === code;
+}
+function path_assertNoNulPathInput(filePath, message = "path contains a NUL byte") {
+    if (filePath.includes("\0")) {
+        throw new errors_FsSafeError("invalid-path", message);
+    }
+}
+function path_isNotFoundPathError(value) {
+    return isNodeError(value) && typeof value.code === "string" && NOT_FOUND_CODES.has(value.code);
+}
+function isSymlinkOpenError(value) {
+    return isNodeError(value) && typeof value.code === "string" && SYMLINK_OPEN_CODES.has(value.code);
+}
+function path_isPathInside(root, target) {
+    if (process.platform === "win32") {
+        const rootForCompare = normalizeWindowsPathForComparison(external_node_path_.win32.resolve(root));
+        const targetForCompare = normalizeWindowsPathForComparison(external_node_path_.win32.resolve(target));
+        const relative = external_node_path_.win32.relative(rootForCompare, targetForCompare);
+        const firstSegment = relative.split(external_node_path_.win32.sep)[0];
+        return (relative === "" || (firstSegment !== ".." && !external_node_path_.win32.isAbsolute(relative)));
+    }
+    if (root.length > 0 &&
+        root.charCodeAt(0) === POSIX_SEPARATOR_CHAR_CODE &&
+        target.length >= root.length &&
+        target.charCodeAt(0) === POSIX_SEPARATOR_CHAR_CODE &&
+        !target.includes("/..") &&
+        (target === root ||
+            (target.startsWith(root) && target.charCodeAt(root.length) === POSIX_SEPARATOR_CHAR_CODE))) {
+        return true;
+    }
+    const resolvedRoot = external_node_path_.resolve(root);
+    const resolvedTarget = external_node_path_.resolve(target);
+    const relative = external_node_path_.relative(resolvedRoot, resolvedTarget);
+    const firstSegment = relative.split(external_node_path_.posix.sep)[0];
+    return relative === "" || (firstSegment !== ".." && !external_node_path_.isAbsolute(relative));
+}
+function resolveSafeBaseDir(rootDir) {
+    const resolved = path.resolve(rootDir);
+    return resolved.endsWith(path.sep) ? resolved : `${resolved}${path.sep}`;
+}
+function isWithinDir(rootDir, targetPath) {
+    return path_isPathInside(rootDir, targetPath);
+}
+function safeRealpathSync(targetPath, cache) {
+    const cached = cache?.get(targetPath);
+    if (cached) {
+        return cached;
+    }
+    try {
+        const resolved = fs.realpathSync(targetPath);
+        cache?.set(targetPath, resolved);
+        cache?.set(resolved, resolved);
+        return resolved;
+    }
+    catch {
+        return null;
+    }
+}
+function isPathInsideWithRealpath(basePath, candidatePath, opts) {
+    if (!path_isPathInside(basePath, candidatePath)) {
+        return false;
+    }
+    const baseReal = safeRealpathSync(basePath, opts?.cache);
+    const candidateReal = safeRealpathSync(candidatePath, opts?.cache);
+    if (!baseReal || !candidateReal) {
+        return opts?.requireRealpath === false;
+    }
+    return path_isPathInside(baseReal, candidateReal);
+}
+function safeStatSync(targetPath) {
+    try {
+        return fs.statSync(targetPath);
+    }
+    catch {
+        return null;
+    }
+}
+function splitSafeRelativePath(relativePath) {
+    if (relativePath.length === 0 || relativePath === ".") {
+        return [];
+    }
+    path_assertNoNulPathInput(relativePath, "relative path contains a NUL byte");
+    if (relativePath.includes("\\")) {
+        throw new FsSafeError("invalid-path", "relative path must use forward slashes");
+    }
+    if (path.posix.isAbsolute(relativePath) ||
+        path.win32.isAbsolute(relativePath) ||
+        relativePath.startsWith("//")) {
+        throw new FsSafeError("invalid-path", "relative path must not be absolute");
+    }
+    const segments = relativePath.split("/").filter((segment) => segment.length > 0 && segment !== ".");
+    for (const segment of segments) {
+        if (segment === "..") {
+            throw new FsSafeError("invalid-path", "relative path must not contain '..'");
+        }
+    }
+    return segments;
+}
+function resolveSafeRelativePath(rootDir, relativePath) {
+    const root = path.resolve(rootDir);
+    const target = path.resolve(root, ...splitSafeRelativePath(relativePath));
+    if (target !== root && !target.startsWith(root + path.sep)) {
+        throw new FsSafeError("outside-workspace", "relative path escapes root");
+    }
+    return target;
+}
+
+;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/directory-guard.js
+
+
+
+
+
+
+async function directory_guard_createAsyncDirectoryGuard(dir) {
+    const stat = await promises_.lstat(dir);
+    if (stat.isSymbolicLink() || !stat.isDirectory()) {
+        throw new errors_FsSafeError("not-file", "directory component must be a directory");
+    }
+    return { dir, realPath: await promises_.realpath(dir), stat };
+}
+async function assertAsyncDirectoryGuard(guard) {
+    const stat = await promises_.lstat(guard.dir);
+    if (stat.isSymbolicLink() || !stat.isDirectory()) {
+        throw new errors_FsSafeError("not-file", "directory component must be a directory");
+    }
+    if (!file_identity_sameFileIdentity(stat, guard.stat) || (await promises_.realpath(guard.dir)) !== guard.realPath) {
+        throw new errors_FsSafeError("path-mismatch", "directory changed during operation");
+    }
+}
+function directory_guard_createSyncDirectoryGuard(dir) {
+    const stat = fsSync.lstatSync(dir);
+    if (stat.isSymbolicLink() || !stat.isDirectory()) {
+        throw new FsSafeError("not-file", "directory component must be a directory");
+    }
+    return { dir, realPath: fsSync.realpathSync(dir), stat };
+}
+function directory_guard_assertSyncDirectoryGuard(guard) {
+    const stat = fsSync.lstatSync(guard.dir);
+    if (stat.isSymbolicLink() || !stat.isDirectory()) {
+        throw new FsSafeError("not-file", "directory component must be a directory");
+    }
+    if (!sameFileIdentity(stat, guard.stat) || fsSync.realpathSync(guard.dir) !== guard.realPath) {
+        throw new FsSafeError("path-mismatch", "directory changed during operation");
+    }
+}
+async function directory_guard_createNearestExistingDirectoryGuard(rootReal, targetPath) {
+    let current = external_node_path_.resolve(targetPath);
+    const root = external_node_path_.resolve(rootReal);
+    while (current !== root) {
+        try {
+            return await directory_guard_createAsyncDirectoryGuard(current);
+        }
+        catch (error) {
+            if (!path_isNotFoundPathError(error)) {
+                throw error;
+            }
+            current = external_node_path_.dirname(current);
+        }
+    }
+    return await directory_guard_createAsyncDirectoryGuard(root);
+}
+function directory_guard_createNearestExistingSyncDirectoryGuard(rootReal, targetPath) {
+    let current = path.resolve(targetPath);
+    const root = path.resolve(rootReal);
+    while (current !== root) {
+        try {
+            return directory_guard_createSyncDirectoryGuard(current);
+        }
+        catch (error) {
+            if (!isNotFoundPathError(error)) {
+                throw error;
+            }
+            current = path.dirname(current);
+        }
+    }
+    return directory_guard_createSyncDirectoryGuard(root);
+}
+
+;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/guarded-mkdir.js
+
+
+
+
+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);
+}
+async function mkdirPathComponentsWithGuards(params) {
+    const root = external_node_path_.resolve(params.rootReal);
+    const target = external_node_path_.resolve(params.targetPath);
+    const relative = external_node_path_.relative(root, target);
+    if (isPathEscape(relative)) {
+        throw new errors_FsSafeError("outside-workspace", "directory is outside workspace root");
+    }
+    let current = root;
+    for (const part of relative.split(external_node_path_.sep).filter(Boolean)) {
+        const next = external_node_path_.join(current, part);
+        const parentGuard = await directory_guard_createAsyncDirectoryGuard(current);
+        await params.beforeComponent?.(next);
+        await assertAsyncDirectoryGuard(parentGuard);
+        try {
+            await promises_.mkdir(next);
+        }
+        catch (error) {
+            if (!error || typeof error !== "object" || !("code" in error) || error.code !== "EEXIST") {
+                throw error;
+            }
+        }
+        const stat = await promises_.lstat(next);
+        if (stat.isSymbolicLink() || !stat.isDirectory()) {
+            throw new errors_FsSafeError("not-file", "directory component must be a directory");
+        }
+        // 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)) {
+            throw new errors_FsSafeError("outside-workspace", "directory escaped workspace root");
+        }
+        await directory_guard_createAsyncDirectoryGuard(next);
+        await assertAsyncDirectoryGuard(parentGuard);
+        current = next;
+    }
+}
+
+;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/guarded-mutation.js
+
+
+
+
+async function withAsyncDirectoryGuards(guards, mutate, options = {}) {
+    for (const guard of guards) {
+        await assertAsyncDirectoryGuard(guard);
+    }
+    const result = await mutate();
+    if (options.verifyAfter !== false) {
+        try {
+            for (const guard of guards) {
+                await assertAsyncDirectoryGuard(guard);
+            }
+        }
+        catch (error) {
+            if (options.onPostGuardFailure) {
+                try {
+                    // The mutation may have returned an owned resource before the post-guard
+                    // check detected a swapped directory. Give callers one chance to close
+                    // handles without letting cleanup hide the boundary failure.
+                    await options.onPostGuardFailure(result, error);
+                }
+                catch {
+                    // Preserve the boundary failure. Cleanup is best-effort.
+                }
+            }
+            throw error;
+        }
+    }
+    return result;
+}
+function withSyncDirectoryGuards(guards, mutate, options = {}) {
+    for (const guard of guards) {
+        assertSyncDirectoryGuard(guard);
+    }
+    const result = mutate();
+    if (options.verifyAfter !== false) {
+        for (const guard of guards) {
+            assertSyncDirectoryGuard(guard);
+        }
+    }
+    return result;
+}
+async function guardedRename(params) {
+    const sourceGuard = await createAsyncDirectoryGuard(path.dirname(params.from));
+    const targetGuard = params.targetRoot
+        ? await createNearestExistingDirectoryGuard(params.targetRoot, path.dirname(params.to))
+        : await createAsyncDirectoryGuard(path.dirname(params.to));
+    await withAsyncDirectoryGuards([sourceGuard, targetGuard], async () => {
+        await fs.rename(params.from, params.to);
+    }, { verifyAfter: params.verifyAfter });
+}
+function guardedRenameSync(params) {
+    const sourceGuard = createSyncDirectoryGuard(path.dirname(params.from));
+    const targetGuard = params.targetRoot
+        ? createNearestExistingSyncDirectoryGuard(params.targetRoot, path.dirname(params.to))
+        : createSyncDirectoryGuard(path.dirname(params.to));
+    withSyncDirectoryGuards([sourceGuard, targetGuard], () => fsSync.renameSync(params.from, params.to), { verifyAfter: params.verifyAfter });
+}
+async function guardedRm(params) {
+    const guard = await createAsyncDirectoryGuard(path.dirname(params.target));
+    await withAsyncDirectoryGuards([guard], async () => {
+        await fs.rm(params.target, {
+            ...(params.recursive !== undefined ? { recursive: params.recursive } : {}),
+            ...(params.force !== undefined ? { force: params.force } : {}),
+        });
+    }, { verifyAfter: params.verifyAfter });
+}
+function guardedRmSync(params) {
+    const guard = createSyncDirectoryGuard(path.dirname(params.target));
+    withSyncDirectoryGuards([guard], () => fsSync.rmSync(params.target, {
+        ...(params.recursive !== undefined ? { recursive: params.recursive } : {}),
+        ...(params.force !== undefined ? { force: params.force } : {}),
+    }), { verifyAfter: params.verifyAfter });
+}
+
+;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/pinned-python-config.js
+let overrideConfig = {};
+function parseMode(value) {
+    if (!value) {
+        return undefined;
+    }
+    const normalized = value.trim().toLowerCase();
+    if (normalized === "0" || normalized === "false" || normalized === "off" || normalized === "never") {
+        return "off";
+    }
+    if (normalized === "1" || normalized === "true" || normalized === "on" || normalized === "auto") {
+        return "auto";
+    }
+    if (normalized === "required" || normalized === "require") {
+        return "require";
+    }
+    return undefined;
+}
+function configureFsSafePython(config) {
+    overrideConfig = { ...overrideConfig, ...config };
+}
+function getFsSafePythonConfig() {
+    return {
+        mode: overrideConfig.mode ??
+            parseMode(process.env.FS_SAFE_PYTHON_MODE) ??
+            parseMode(process.env.OPENCLAW_FS_SAFE_PYTHON_MODE) ??
+            "auto",
+        pythonPath: overrideConfig.pythonPath ??
+            process.env.FS_SAFE_PYTHON ??
+            process.env.OPENCLAW_FS_SAFE_PYTHON ??
+            process.env.OPENCLAW_PINNED_PYTHON ??
+            process.env.OPENCLAW_PINNED_WRITE_PYTHON,
+    };
+}
+function canFallbackFromPythonError(error) {
+    return (getFsSafePythonConfig().mode !== "require" &&
+        error instanceof Error &&
+        "code" in error &&
+        error.code === "helper-unavailable");
+}
+
+// EXTERNAL MODULE: external "node:child_process"
+var external_node_child_process_ = __webpack_require__(1421);
+;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/pinned-python.js
+
+
+
+
+const PINNED_PYTHON_WORKER_SOURCE = String.raw `
+import base64
+import errno
+import json
+import os
+import secrets
+import stat
+import 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_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 []
+    if "\x00" in value or value.startswith("/") or value.startswith("//"):
+        raise OSError(errno.EPERM, "invalid relative path")
+    if value.startswith("..\\"):
+        raise OSError(errno.EPERM, "path traversal is not allowed")
+    parts = [part for part in value.split("/") if part and part != "."]
+    for part in parts:
+        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:
+        for segment in segments:
+            try:
+                next_fd = open_dir(segment, dir_fd=current_fd)
+            except FileNotFoundError:
+                if not mkdir_enabled:
+                    raise
+                os.mkdir(segment, 0o777, dir_fd=current_fd)
+                next_fd = open_dir(segment, dir_fd=current_fd)
+            os.close(current_fd)
+            current_fd = next_fd
+        return current_fd
+    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 {
+        "dev": st.st_dev,
+        "gid": st.st_gid,
+        "ino": st.st_ino,
+        "isDirectory": stat.S_ISDIR(mode),
+        "isFile": stat.S_ISREG(mode),
+        "isSymbolicLink": stat.S_ISLNK(mode),
+        "mode": mode,
+        "mtimeMs": st.st_mtime * 1000,
+        "nlink": st.st_nlink,
+        "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 stat_path(root_fd, payload):
+    relative = payload.get("relativePath", "")
+    segments = split_relative(relative)
+    if not segments:
+        return encode_stat(os.fstat(root_fd))
+    parent_fd, basename = parent_and_basename(root_fd, relative)
+    try:
+        st = os.lstat(basename, dir_fd=parent_fd)
+        if payload.get("rejectSymlink", True) and stat.S_ISLNK(st.st_mode):
+            raise OSError(errno.ELOOP, "symlink endpoint is not allowed")
+        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:
+        names = sorted(os.listdir(dir_fd))
+        if not payload.get("withFileTypes", False):
+            return names
+        entries = []
+        for name in names:
+            st = os.lstat(name, dir_fd=dir_fd)
+            entry = encode_stat(st)
+            entry["name"] = name
+            entries.append(entry)
+        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
+
+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):
+        dir_fd = open_dir(basename, dir_fd=parent_fd)
+        try:
+            for child in os.listdir(dir_fd):
+                remove_tree(dir_fd, child)
+        finally:
+            os.close(dir_fd)
+        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:
+        try:
+            st = os.lstat(basename, dir_fd=parent_fd)
+        except FileNotFoundError:
+            if payload.get("force", True):
+                return None
+            raise
+        if stat.S_ISDIR(st.st_mode) and not stat.S_ISLNK(st.st_mode):
+            if payload.get("recursive", False):
+                remove_tree(parent_fd, basename)
+            else:
+                os.rmdir(basename, dir_fd=parent_fd)
+        else:
+            os.unlink(basename, dir_fd=parent_fd)
+        return None
+    finally:
+        os.close(parent_fd)
+
+def rename_path(root_fd, payload):
+    from_parent_fd, from_base = parent_and_basename(root_fd, payload["from"])
+    to_parent_fd, to_base = parent_and_basename(root_fd, payload["to"])
+    try:
+        from_stat = os.lstat(from_base, dir_fd=from_parent_fd)
+        reject_unsafe_endpoint(from_stat)
+        if not payload.get("overwrite", True):
+            try:
+                os.lstat(to_base, dir_fd=to_parent_fd)
+                raise FileExistsError(errno.EEXIST, "destination exists", to_base)
+            except FileNotFoundError:
+                pass
+        os.rename(from_base, to_base, src_dir_fd=from_parent_fd, dst_dir_fd=to_parent_fd)
+        os.fsync(from_parent_fd)
+        if from_parent_fd != to_parent_fd:
+            os.fsync(to_parent_fd)
+        return None
+    finally:
+        os.close(from_parent_fd)
+        os.close(to_parent_fd)
+
+def create_temp_file(parent_fd, basename, mode):
+    prefix = "." + basename + "."
+    for _ in range(128):
+        candidate = prefix + secrets.token_hex(6) + ".tmp"
+        try:
+            fd = os.open(candidate, WRITE_FLAGS, mode, dir_fd=parent_fd)
+            return candidate, fd
+        except FileExistsError:
+            continue
+    raise RuntimeError("failed to allocate pinned temp file")
+
+def write_path(root_fd, payload):
+    parent_fd = walk_dir(root_fd, split_relative(payload.get("relativeParentPath", "")), bool(payload.get("mkdir", True)))
+    temp_fd = None
+    temp_name = None
+    basename = payload["basename"]
+    mode = int(payload.get("mode", 0o600))
+    overwrite = bool(payload.get("overwrite", True))
+    max_bytes = int(payload.get("maxBytes", -1))
+    data = base64.b64decode(payload.get("base64", ""))
+    try:
+        if max_bytes >= 0 and len(data) > max_bytes:
+            raise RuntimeError("fs-safe-too-large:%d:%d" % (max_bytes, len(data)))
+        if not overwrite:
+            try:
+                os.lstat(basename, dir_fd=parent_fd)
+                raise FileExistsError(errno.EEXIST, "destination exists", basename)
+            except FileNotFoundError:
+                pass
+        temp_name, temp_fd = create_temp_file(parent_fd, basename, mode)
+        view = memoryview(data)
+        while view:
+            written = os.write(temp_fd, view)
+            if written <= 0:
+                raise OSError(errno.EIO, "short write")
+            view = view[written:]
+        os.fsync(temp_fd)
+        os.close(temp_fd)
+        temp_fd = None
+        os.replace(temp_name, basename, src_dir_fd=parent_fd, dst_dir_fd=parent_fd)
+        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:
+            os.close(temp_fd)
+        if temp_name is not None:
+            try:
+                os.unlink(temp_name, dir_fd=parent_fd)
+            except FileNotFoundError:
+                pass
+        os.close(parent_fd)
+
+def copy_path(root_fd, payload):
+    source_fd = os.open(payload["sourcePath"], READ_FLAGS)
+    parent_fd = None
+    temp_fd = None
+    temp_name = None
+    try:
+        source_stat = os.fstat(source_fd)
+        if not stat.S_ISREG(source_stat.st_mode):
+            raise RuntimeError("fs-safe-not-file")
+        if source_stat.st_dev != int(payload["sourceDev"]) or source_stat.st_ino != int(payload["sourceIno"]):
+            raise RuntimeError("fs-safe-source-mismatch")
+        basename = payload["basename"]
+        mode = int(payload.get("mode", 0o600))
+        overwrite = bool(payload.get("overwrite", True))
+        max_bytes = int(payload.get("maxBytes", -1))
+        if max_bytes >= 0 and source_stat.st_size > max_bytes:
+            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)))
+        if not overwrite:
+            try:
+                os.lstat(basename, dir_fd=parent_fd)
+                raise FileExistsError(errno.EEXIST, "destination exists", basename)
+            except FileNotFoundError:
+                pass
+        temp_name, temp_fd = create_temp_file(parent_fd, basename, mode)
+        written_bytes = 0
+        while True:
+            chunk = os.read(source_fd, 65536)
+            if not chunk:
+                break
+            written_bytes += len(chunk)
+            if max_bytes >= 0 and written_bytes > max_bytes:
+                raise RuntimeError("fs-safe-too-large:%d:%d" % (max_bytes, written_bytes))
+            view = memoryview(chunk)
+            while view:
+                written = os.write(temp_fd, view)
+                if written <= 0:
+                    raise OSError(errno.EIO, "short write")
+                view = view[written:]
+        os.fsync(temp_fd)
+        os.close(temp_fd)
+        temp_fd = None
+        os.replace(temp_name, basename, src_dir_fd=parent_fd, dst_dir_fd=parent_fd)
+        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)
+        if temp_fd is not None:
+            os.close(temp_fd)
+        if temp_name is not None and parent_fd is not None:
+            try:
+                os.unlink(temp_name, dir_fd=parent_fd)
+            except FileNotFoundError:
+                pass
+        if parent_fd is not None:
+            os.close(parent_fd)
+
+def run_operation(operation, root_path, payload):
+    root_fd = open_dir(root_path)
+    try:
+        if operation == "stat":
+            return stat_path(root_fd, payload)
+        if operation == "readdir":
+            return readdir_path(root_fd, payload)
+        if operation == "mkdirp":
+            return mkdirp_path(root_fd, payload)
+        if operation == "remove":
+            return remove_path(root_fd, payload)
+        if operation == "rename":
+            return rename_path(root_fd, payload)
+        if operation == "write":
+            return write_path(root_fd, payload)
+        if operation == "copy":
+            return copy_path(root_fd, payload)
+        raise RuntimeError("unknown operation: " + operation)
+    finally:
+        os.close(root_fd)
+
+for line in sys.stdin:
+    try:
+        request = json.loads(line)
+        result = run_operation(request["operation"], request["rootPath"], request.get("payload") or {})
+        response = {"id": request["id"], "ok": True, "result": result}
+    except Exception as exc:
+        response = {
+            "id": request.get("id") if isinstance(locals().get("request"), dict) else None,
+            "ok": False,
+            "code": exc.__class__.__name__,
+            "errno": getattr(exc, "errno", None),
+            "message": str(exc),
+        }
+    print(json.dumps(response, separators=(",", ":")), flush=True)
+`;
+let nextRequestId = 1;
+let worker = null;
+function __resetPinnedPythonWorkerForTest() {
+    const currentWorker = worker;
+    worker = null;
+    if (!currentWorker) {
+        return;
+    }
+    currentWorker.pending.clear();
+    currentWorker.child.kill("SIGTERM");
+}
+const PYTHON_CANDIDATE_DEFAULTS = [
+    "/usr/bin/python3",
+    "/opt/homebrew/bin/python3",
+    "/usr/local/bin/python3",
+];
+function canExecute(binPath) {
+    try {
+        external_node_fs_.accessSync(binPath, external_node_fs_.constants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function resolvePython() {
+    const configured = getFsSafePythonConfig().pythonPath;
+    if (configured) {
+        return configured;
+    }
+    for (const candidate of PYTHON_CANDIDATE_DEFAULTS) {
+        if (canExecute(candidate)) {
+            return candidate;
+        }
+    }
+    return "python3";
+}
+function assertPinnedHelperSupported() {
+    if (process.platform === "win32") {
+        throw new errors_FsSafeError("unsupported-platform", "fd-relative pinned filesystem operations are not available on Windows");
+    }
+    if (getFsSafePythonConfig().mode === "off") {
+        throw new errors_FsSafeError("helper-unavailable", "Python helper is disabled");
+    }
+}
+function isSpawnUnavailable(error) {
+    if (!(error instanceof Error)) {
+        return false;
+    }
+    const maybeErrno = error;
+    return (typeof maybeErrno.syscall === "string" &&
+        maybeErrno.syscall.startsWith("spawn") &&
+        ["EACCES", "ENOENT", "ENOEXEC"].includes(maybeErrno.code ?? ""));
+}
+function mapWorkerError(response) {
+    const code = typeof response.code === "string" ? response.code : "";
+    const errno = typeof response.errno === "number" ? response.errno : undefined;
+    const message = typeof response.message === "string" && response.message
+        ? response.message
+        : "pinned helper failed";
+    const tooLarge = message.match(/fs-safe-too-large:(\d+):(\d+)/);
+    if (tooLarge) {
+        const [, limit, got] = tooLarge;
+        return new errors_FsSafeError("too-large", `file exceeds limit of ${limit} bytes (got at least ${got})`);
+    }
+    if (message.includes("fs-safe-not-file")) {
+        return new errors_FsSafeError("not-file", "not a file");
+    }
+    if (message.includes("fs-safe-source-mismatch")) {
+        return new errors_FsSafeError("path-mismatch", "source path changed during copy");
+    }
+    if (code === "FileNotFoundError" || errno === 2) {
+        return new errors_FsSafeError("not-found", "file not found");
+    }
+    if (code === "FileExistsError" || errno === 17) {
+        return new errors_FsSafeError("already-exists", message);
+    }
+    if (errno === 39) {
+        return new errors_FsSafeError("not-empty", "directory is not empty");
+    }
+    if (errno === 1 || errno === 13 || errno === 21) {
+        return new errors_FsSafeError("not-removable", "path is not removable under root");
+    }
+    if (code === "NotADirectoryError" || code === "OSError" || errno === 20 || errno === 40) {
+        return new errors_FsSafeError("path-alias", message);
+    }
+    return new errors_FsSafeError("helper-failed", message);
+}
+function rejectPending(error) {
+    if (!worker) {
+        return;
+    }
+    setWorkerRef(worker, false);
+    for (const pending of worker.pending.values()) {
+        pending.reject(error);
+    }
+    worker.pending.clear();
+    worker = null;
+}
+function handleWorkerLine(line) {
+    if (!worker || !line.trim()) {
+        return;
+    }
+    let decoded;
+    try {
+        decoded = JSON.parse(line);
+    }
+    catch {
+        rejectPending(new errors_FsSafeError("helper-failed", `pinned helper returned invalid JSON: ${line}`));
+        return;
+    }
+    if (typeof decoded !== "object" || decoded === null || !("id" in decoded)) {
+        rejectPending(new errors_FsSafeError("helper-failed", "pinned helper returned invalid response"));
+        return;
+    }
+    const response = decoded;
+    const id = typeof response.id === "number" ? response.id : undefined;
+    if (id === undefined) {
+        return;
+    }
+    const pending = worker.pending.get(id);
+    if (!pending) {
+        return;
+    }
+    worker.pending.delete(id);
+    if (worker.pending.size === 0) {
+        setWorkerRef(worker, false);
+    }
+    if (response.ok === true) {
+        pending.resolve(response.result);
+        return;
+    }
+    pending.reject(mapWorkerError(decoded));
+}
+function getWorker() {
+    assertPinnedHelperSupported();
+    if (worker) {
+        return worker;
+    }
+    const child = (0,external_node_child_process_.spawn)(resolvePython(), ["-u", "-c", PINNED_PYTHON_WORKER_SOURCE], {
+        stdio: ["pipe", "pipe", "pipe"],
+    });
+    worker = { child, pending: new Map(), stderr: "", stdoutBuffer: "" };
+    child.stdout.setEncoding("utf8");
+    child.stderr.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => {
+        const current = worker;
+        if (!current) {
+            return;
+        }
+        current.stdoutBuffer += chunk;
+        for (;;) {
+            const newline = current.stdoutBuffer.indexOf("\n");
+            if (newline < 0) {
+                break;
+            }
+            const line = current.stdoutBuffer.slice(0, newline);
+            current.stdoutBuffer = current.stdoutBuffer.slice(newline + 1);
+            handleWorkerLine(line);
+        }
+    });
+    child.stderr.on("data", (chunk) => {
+        if (worker) {
+            worker.stderr = `${worker.stderr}${chunk}`.slice(-4096);
+        }
+    });
+    child.once("error", (error) => {
+        const mapped = isSpawnUnavailable(error)
+            ? new errors_FsSafeError("helper-unavailable", "Python helper is unavailable", { cause: error })
+            : error instanceof Error
+                ? error
+                : new Error(String(error));
+        rejectPending(mapped);
+    });
+    child.once("close", (code, signal) => {
+        const stderr = worker?.stderr.trim();
+        rejectPending(new errors_FsSafeError("helper-failed", stderr || `pinned helper exited with code ${code ?? "null"} (${signal ?? "?"})`));
+    });
+    process.once("exit", () => {
+        child.kill("SIGTERM");
+    });
+    setWorkerRef(worker, false);
+    return worker;
+}
+function setRefable(value, ref) {
+    if (!value) {
+        return;
+    }
+    const method = ref ? "ref" : "unref";
+    const refable = value;
+    refable[method]?.();
+}
+function setWorkerRef(currentWorker, ref) {
+    setRefable(currentWorker.child, ref);
+    setRefable(currentWorker.child.stdin, ref);
+    setRefable(currentWorker.child.stdout, ref);
+    setRefable(currentWorker.child.stderr, ref);
+}
+async function runPinnedPythonOperation(params) {
+    const requestId = nextRequestId++;
+    const currentWorker = getWorker();
+    if (typeof currentWorker.child.stdin?.write !== "function") {
+        throw new errors_FsSafeError("helper-unavailable", "Python helper stdin is unavailable");
+    }
+    setWorkerRef(currentWorker, true);
+    return await new Promise((resolve, reject) => {
+        currentWorker.pending.set(requestId, {
+            reject,
+            resolve: (value) => resolve(value),
+        });
+        const request = JSON.stringify({
+            id: requestId,
+            operation: params.operation,
+            rootPath: params.rootPath,
+            payload: params.payload,
+        });
+        currentWorker.child.stdin.write(`${request}\n`, (error) => {
+            if (error) {
+                currentWorker.pending.delete(requestId);
+                if (currentWorker.pending.size === 0) {
+                    setWorkerRef(currentWorker, false);
+                }
+                reject(error);
+            }
+        });
+    });
+}
+function assertPinnedPythonOperationAvailable() {
+    const currentWorker = getWorker();
+    if (typeof currentWorker.child.stdin?.write !== "function") {
+        throw new errors_FsSafeError("helper-unavailable", "Python helper stdin is unavailable");
+    }
+}
+function validatePinnedOperationPayload(payload) {
+    if (typeof payload.relativePath === "string") {
+        validatePinnedRelativePath(payload.relativePath);
+    }
+    if (typeof payload.relativeParentPath === "string") {
+        validatePinnedRelativePath(payload.relativeParentPath);
+    }
+    if (typeof payload.from === "string") {
+        validatePinnedRelativePath(payload.from);
+    }
+    if (typeof payload.to === "string") {
+        validatePinnedRelativePath(payload.to);
+    }
+}
+function isPinnedHelperUnavailable(error) {
+    return error instanceof Error &&
+        "code" in error &&
+        error.code === "helper-unavailable";
+}
+function validatePinnedRelativePath(relativePath) {
+    if (relativePath.length === 0 || relativePath === ".") {
+        return;
+    }
+    if (relativePath.includes("\0")) {
+        throw new errors_FsSafeError("invalid-path", "relative path contains a NUL byte");
+    }
+    if (relativePath.startsWith("/") ||
+        relativePath.startsWith("//") ||
+        relativePath === ".." ||
+        relativePath.startsWith("../") ||
+        relativePath.startsWith("..\\")) {
+        throw new errors_FsSafeError("invalid-path", "relative path must not escape root");
+    }
+    for (const segment of relativePath.split("/")) {
+        if (segment === "..") {
+            throw new errors_FsSafeError("invalid-path", "relative path must not contain '..'");
+        }
+    }
+}
+
+;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/pinned-helper.js
+
+
+async function runPinnedHelper(operation, rootDir, payload) {
+    validatePinnedOperationPayload(payload);
+    return await runPinnedPythonOperation({
+        operation,
+        rootPath: rootDir,
+        payload,
+    });
+}
+async function helperStat(rootDir, relativePath) {
+    return await runPinnedHelper("stat", rootDir, { relativePath });
+}
+async function helperReaddir(rootDir, relativePath, withFileTypes) {
+    return await runPinnedHelper("readdir", rootDir, {
+        relativePath,
+        withFileTypes,
+    });
+}
+
+;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/pinned-path.js
+
+
+
+function isPinnedPathHelperSpawnError(error) {
+    return canFallbackFromPythonError(error);
+}
+async function runPinnedPathHelper(params) {
+    try {
+        await runPinnedHelper(params.operation, params.rootPath, {
+            relativePath: params.relativePath,
+        });
+    }
+    catch (error) {
+        if (error instanceof errors_FsSafeError) {
+            throw error;
+        }
+        throw new errors_FsSafeError("helper-failed", "pinned path helper failed", {
+            cause: error instanceof Error ? error : undefined,
+        });
+    }
+}
+
+;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/pinned-write.js
+
+
+
+
+
+
+
+
+
+
+
+function pinned_write_byteLength(input, encoding) {
+    return typeof input === "string"
+        ? Buffer.byteLength(input, encoding ?? "utf8")
+        : input.byteLength;
+}
+function assertSafeBasename(basename) {
+    if (!basename ||
+        basename === "." ||
+        basename === ".." ||
+        basename.includes("/") ||
+        basename.includes("\0")) {
+        throw new errors_FsSafeError("invalid-path", "invalid target path");
+    }
+}
+function assertWithinMaxBytes(bytes, maxBytes) {
+    if (maxBytes !== undefined && 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;
+    }
+    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;
+            }
+            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;
+    }
+    await (0,external_node_stream_promises_.pipeline)(stream, destination);
+}
+async function inputToBase64(input, maxBytes) {
+    if (input.kind === "buffer") {
+        assertWithinMaxBytes(pinned_write_byteLength(input.data, input.encoding), maxBytes);
+        return (typeof input.data === "string"
+            ? Buffer.from(input.data, input.encoding ?? "utf8")
+            : input.data).toString("base64");
+    }
+    const chunks = [];
+    let bytes = 0;
+    for await (const chunk of input.stream) {
+        const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        bytes += buffer.byteLength;
+        assertWithinMaxBytes(bytes, maxBytes);
+        chunks.push(buffer);
+    }
+    return Buffer.concat(chunks, bytes).toString("base64");
+}
+async function runPinnedWriteHelper(params) {
+    assertSafeBasename(params.basename);
+    validatePinnedOperationPayload({
+        relativeParentPath: params.relativeParentPath,
+    });
+    if (getFsSafePythonConfig().mode === "off") {
+        return await runPinnedWriteFallback(params);
+    }
+    if (params.input.kind === "stream") {
+        try {
+            assertPinnedPythonOperationAvailable();
+        }
+        catch (error) {
+            if (canFallbackFromPythonError(error)) {
+                return await runPinnedWriteFallback(params);
+            }
+            throw error;
+        }
+    }
+    const payload = {
+        base64: await inputToBase64(params.input, params.maxBytes),
+        basename: params.basename,
+        maxBytes: params.maxBytes ?? -1,
+        mkdir: params.mkdir,
+        mode: params.mode || 0o600,
+        overwrite: params.overwrite !== false,
+        relativeParentPath: params.relativeParentPath,
+    };
+    try {
+        return await runPinnedPythonOperation({
+            operation: "write",
+            rootPath: params.rootPath,
+            payload,
+        });
+    }
+    catch (error) {
+        if (canFallbackFromPythonError(error)) {
+            return await runPinnedWriteFallback(params);
+        }
+        throw error;
+    }
+}
+async function runPinnedCopyHelper(params) {
+    assertSafeBasename(params.basename);
+    validatePinnedOperationPayload({
+        relativeParentPath: params.relativeParentPath,
+    });
+    return await runPinnedPythonOperation({
+        operation: "copy",
+        rootPath: params.rootPath,
+        payload: {
+            basename: params.basename,
+            maxBytes: params.maxBytes ?? -1,
+            mkdir: params.mkdir,
+            mode: params.mode || 0o600,
+            overwrite: params.overwrite !== false,
+            relativeParentPath: params.relativeParentPath,
+            sourceDev: params.sourceIdentity.dev,
+            sourceIno: params.sourceIdentity.ino,
+            sourcePath: params.sourcePath,
+        },
+    });
+}
+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 });
+        });
+    }
+    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), {
+            onPostGuardFailure: async (openedHandle) => {
+                // The parent failed verification, so targetPath may now resolve
+                // somewhere else. Close the fd, but do not clean up by path.
+                await openedHandle.close().catch(() => undefined);
+            },
+        });
+        let created = true;
+        try {
+            if (params.input.kind === "buffer") {
+                assertWithinMaxBytes(pinned_write_byteLength(params.input.data, params.input.encoding), params.maxBytes);
+                if (typeof params.input.data === "string") {
+                    await handle.writeFile(params.input.data, params.input.encoding ?? "utf8");
+                }
+                else {
+                    await handle.writeFile(params.input.data);
+                }
+            }
+            else {
+                await pipelineWithMaxBytes(params.input.stream, handle.createWriteStream(), params.maxBytes);
+            }
+            const stat = await handle.stat();
+            created = false;
+            return { dev: stat.dev, ino: stat.ino };
+        }
+        finally {
+            await handle.close().catch(() => undefined);
+            if (created) {
+                await promises_.rm(targetPath, { force: true }).catch(() => undefined);
+            }
+        }
+    }
+    const tempPath = external_node_path_.join(parentPath, `.${params.basename}.${(0,external_node_crypto_.randomUUID)()}.fallback.tmp`);
+    const tempFlags = external_node_fs_.constants.O_WRONLY |
+        external_node_fs_.constants.O_CREAT |
+        external_node_fs_.constants.O_EXCL |
+        (process.platform !== "win32" && "O_NOFOLLOW" in external_node_fs_.constants
+            ? external_node_fs_.constants.O_NOFOLLOW
+            : 0);
+    let handle;
+    let handleClosedByStream = false;
+    try {
+        handle = await promises_.open(tempPath, tempFlags, params.mode);
+        if (params.input.kind === "buffer") {
+            assertWithinMaxBytes(pinned_write_byteLength(params.input.data, params.input.encoding), params.maxBytes);
+            if (typeof params.input.data === "string") {
+                await handle.writeFile(params.input.data, params.input.encoding ?? "utf8");
+            }
+            else {
+                await handle.writeFile(params.input.data);
+            }
+        }
+        else {
+            const writable = handle.createWriteStream();
+            writable.once("close", () => {
+                handleClosedByStream = true;
+            });
+            await pipelineWithMaxBytes(params.input.stream, writable, params.maxBytes);
+        }
+        if (!handleClosedByStream) {
+            await handle.close().catch(() => undefined);
+            handle = undefined;
+        }
+        await withAsyncDirectoryGuards([parentGuard], async () => {
+            await promises_.rename(tempPath, targetPath);
+        });
+    }
+    catch (error) {
+        if (handle && !handleClosedByStream) {
+            await handle.close().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 };
+}
+
+// EXTERNAL MODULE: external "node:os"
+var external_node_os_ = __webpack_require__(8161);
+;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/root-path.js
+
+
+
+
+
+const ROOT_PATH_ALIAS_POLICIES = {
+    strict: Object.freeze({
+        allowFinalSymlinkForUnlink: false,
+        allowFinalHardlinkForUnlink: false,
+    }),
+    unlinkTarget: Object.freeze({
+        allowFinalSymlinkForUnlink: true,
+        allowFinalHardlinkForUnlink: true,
+    }),
+};
+async function resolveRootPath(params) {
+    const rootPath = external_node_path_.resolve(params.rootPath);
+    const absolutePath = external_node_path_.resolve(params.absolutePath);
+    const rootCanonicalPath = params.rootCanonicalPath
+        ? external_node_path_.resolve(params.rootCanonicalPath)
+        : await resolvePathViaExistingAncestor(rootPath);
+    const context = createBoundaryResolutionContext({
+        resolveParams: params,
+        rootPath,
+        absolutePath,
+        rootCanonicalPath,
+        outsideLexicalCanonicalPath: await resolveOutsideLexicalCanonicalPathAsync({
+            rootPath,
+            absolutePath,
+        }),
+    });
+    const outsideResult = await resolveOutsideRootPathAsync({
+        boundaryLabel: params.boundaryLabel,
+        context,
+    });
+    if (outsideResult) {
+        return outsideResult;
+    }
+    return resolveRootPathLexicalAsync({
+        params,
+        absolutePath: context.absolutePath,
+        rootPath: context.rootPath,
+        rootCanonicalPath: context.rootCanonicalPath,
+    });
+}
+function resolveRootPathSync(params) {
+    const rootPath = path.resolve(params.rootPath);
+    const absolutePath = path.resolve(params.absolutePath);
+    const rootCanonicalPath = params.rootCanonicalPath
+        ? path.resolve(params.rootCanonicalPath)
+        : resolvePathViaExistingAncestorSync(rootPath);
+    const context = createBoundaryResolutionContext({
+        resolveParams: params,
+        rootPath,
+        absolutePath,
+        rootCanonicalPath,
+        outsideLexicalCanonicalPath: resolveOutsideLexicalCanonicalPathSync({
+            rootPath,
+            absolutePath,
+        }),
+    });
+    const outsideResult = resolveOutsideRootPathSync({
+        boundaryLabel: params.boundaryLabel,
+        context,
+    });
+    if (outsideResult) {
+        return outsideResult;
+    }
+    return resolveRootPathLexicalSync({
+        params,
+        absolutePath: context.absolutePath,
+        rootPath: context.rootPath,
+        rootCanonicalPath: context.rootCanonicalPath,
+    });
+}
+function isPromiseLike(value) {
+    return Boolean(value &&
+        (typeof value === "object" || typeof value === "function") &&
+        "then" in value &&
+        typeof value.then === "function");
+}
+function createLexicalTraversalState(params) {
+    const relative = external_node_path_.relative(params.rootPath, params.absolutePath);
+    return {
+        segments: relative.split(external_node_path_.sep).filter(Boolean),
+        allowFinalSymlink: params.params.policy?.allowFinalSymlinkForUnlink === true,
+        canonicalCursor: params.rootCanonicalPath,
+        lexicalCursor: params.rootPath,
+        preserveFinalSymlink: false,
+    };
+}
+function assertLexicalCursorInsideBoundary(params) {
+    assertInsideBoundary({
+        boundaryLabel: params.params.boundaryLabel,
+        rootCanonicalPath: params.rootCanonicalPath,
+        candidatePath: params.candidatePath,
+        absolutePath: params.absolutePath,
+    });
+}
+function applyMissingSuffixToCanonicalCursor(params) {
+    const missingSuffix = params.state.segments.slice(params.missingFromIndex);
+    params.state.canonicalCursor = external_node_path_.resolve(params.state.canonicalCursor, ...missingSuffix);
+    assertLexicalCursorInsideBoundary({
+        params: params.params,
+        rootCanonicalPath: params.rootCanonicalPath,
+        candidatePath: params.state.canonicalCursor,
+        absolutePath: params.absolutePath,
+    });
+}
+function advanceCanonicalCursorForSegment(params) {
+    params.state.canonicalCursor = external_node_path_.resolve(params.state.canonicalCursor, params.segment);
+    assertLexicalCursorInsideBoundary({
+        params: params.params,
+        rootCanonicalPath: params.rootCanonicalPath,
+        candidatePath: params.state.canonicalCursor,
+        absolutePath: params.absolutePath,
+    });
+}
+function finalizeLexicalResolution(params) {
+    assertLexicalCursorInsideBoundary({
+        params: params.params,
+        rootCanonicalPath: params.rootCanonicalPath,
+        candidatePath: params.state.canonicalCursor,
+        absolutePath: params.absolutePath,
+    });
+    return buildResolvedRootPath({
+        absolutePath: params.absolutePath,
+        canonicalPath: params.state.canonicalCursor,
+        rootPath: params.rootPath,
+        rootCanonicalPath: params.rootCanonicalPath,
+        kind: params.kind,
+    });
+}
+function handleLexicalLstatFailure(params) {
+    if (!path_isNotFoundPathError(params.error)) {
+        return false;
+    }
+    applyMissingSuffixToCanonicalCursor({
+        state: params.state,
+        missingFromIndex: params.missingFromIndex,
+        rootCanonicalPath: params.rootCanonicalPath,
+        params: params.resolveParams,
+        absolutePath: params.absolutePath,
+    });
+    return true;
+}
+function handleLexicalStatReadFailure(params) {
+    if (handleLexicalLstatFailure({
+        error: params.error,
+        state: params.state,
+        missingFromIndex: params.missingFromIndex,
+        rootCanonicalPath: params.rootCanonicalPath,
+        resolveParams: params.resolveParams,
+        absolutePath: params.absolutePath,
+    })) {
+        return null;
+    }
+    throw params.error;
+}
+function handleLexicalStatDisposition(params) {
+    if (!params.isSymbolicLink) {
+        advanceCanonicalCursorForSegment({
+            state: params.state,
+            segment: params.segment,
+            rootCanonicalPath: params.rootCanonicalPath,
+            params: params.resolveParams,
+            absolutePath: params.absolutePath,
+        });
+        return "continue";
+    }
+    if (params.state.allowFinalSymlink && params.isLast) {
+        params.state.preserveFinalSymlink = true;
+        advanceCanonicalCursorForSegment({
+            state: params.state,
+            segment: params.segment,
+            rootCanonicalPath: params.rootCanonicalPath,
+            params: params.resolveParams,
+            absolutePath: params.absolutePath,
+        });
+        return "break";
+    }
+    return "resolve-link";
+}
+function applyResolvedSymlinkHop(params) {
+    if (!path_isPathInside(params.rootCanonicalPath, params.linkCanonical)) {
+        throw symlinkEscapeError({
+            boundaryLabel: params.boundaryLabel,
+            rootCanonicalPath: params.rootCanonicalPath,
+            symlinkPath: params.state.lexicalCursor,
+        });
+    }
+    params.state.canonicalCursor = params.linkCanonical;
+    params.state.lexicalCursor = params.linkCanonical;
+}
+function readLexicalStat(params) {
+    try {
+        const stat = params.read(params.state.lexicalCursor);
+        if (isPromiseLike(stat)) {
+            return Promise.resolve(stat).catch((error) => handleLexicalStatReadFailure({ ...params, error }));
+        }
+        return stat;
+    }
+    catch (error) {
+        return handleLexicalStatReadFailure({ ...params, error });
+    }
+}
+function resolveAndApplySymlinkHop(params) {
+    const linkCanonical = params.resolveLinkCanonical(params.state.lexicalCursor);
+    if (isPromiseLike(linkCanonical)) {
+        return Promise.resolve(linkCanonical).then((value) => applyResolvedSymlinkHop({
+            state: params.state,
+            linkCanonical: value,
+            rootCanonicalPath: params.rootCanonicalPath,
+            boundaryLabel: params.boundaryLabel,
+        }));
+    }
+    applyResolvedSymlinkHop({
+        state: params.state,
+        linkCanonical,
+        rootCanonicalPath: params.rootCanonicalPath,
+        boundaryLabel: params.boundaryLabel,
+    });
+}
+function* iterateLexicalTraversal(state) {
+    for (let idx = 0; idx < state.segments.length; idx += 1) {
+        const segment = state.segments[idx] ?? "";
+        const isLast = idx === state.segments.length - 1;
+        state.lexicalCursor = external_node_path_.join(state.lexicalCursor, segment);
+        yield { idx, segment, isLast };
+    }
+}
+async function resolveRootPathLexicalAsync(params) {
+    const state = createLexicalTraversalState(params);
+    const sharedStepParams = {
+        state,
+        rootCanonicalPath: params.rootCanonicalPath,
+        resolveParams: params.params,
+        absolutePath: params.absolutePath,
+    };
+    for (const { idx, segment, isLast } of iterateLexicalTraversal(state)) {
+        const stat = await readLexicalStat({
+            ...sharedStepParams,
+            missingFromIndex: idx,
+            read: (cursor) => promises_.lstat(cursor),
+        });
+        if (!stat) {
+            break;
+        }
+        const disposition = handleLexicalStatDisposition({
+            ...sharedStepParams,
+            isSymbolicLink: stat.isSymbolicLink(),
+            segment,
+            isLast,
+        });
+        if (disposition === "continue") {
+            continue;
+        }
+        if (disposition === "break") {
+            break;
+        }
+        await resolveAndApplySymlinkHop({
+            state,
+            rootCanonicalPath: params.rootCanonicalPath,
+            boundaryLabel: params.params.boundaryLabel,
+            resolveLinkCanonical: (cursor) => resolveSymlinkHopPath(cursor),
+        });
+    }
+    const kind = await getPathKind(params.absolutePath, state.preserveFinalSymlink);
+    return finalizeLexicalResolution({
+        ...params,
+        state,
+        kind,
+    });
+}
+function resolveRootPathLexicalSync(params) {
+    const state = createLexicalTraversalState(params);
+    for (let idx = 0; idx < state.segments.length; idx += 1) {
+        const segment = state.segments[idx] ?? "";
+        const isLast = idx === state.segments.length - 1;
+        state.lexicalCursor = path.join(state.lexicalCursor, segment);
+        const maybeStat = readLexicalStat({
+            state,
+            missingFromIndex: idx,
+            rootCanonicalPath: params.rootCanonicalPath,
+            resolveParams: params.params,
+            absolutePath: params.absolutePath,
+            read: (cursor) => fs.lstatSync(cursor),
+        });
+        if (isPromiseLike(maybeStat)) {
+            throw new Error("Unexpected async lexical stat");
+        }
+        const stat = maybeStat;
+        if (!stat) {
+            break;
+        }
+        const disposition = handleLexicalStatDisposition({
+            state,
+            isSymbolicLink: stat.isSymbolicLink(),
+            segment,
+            isLast,
+            rootCanonicalPath: params.rootCanonicalPath,
+            resolveParams: params.params,
+            absolutePath: params.absolutePath,
+        });
+        if (disposition === "continue") {
+            continue;
+        }
+        if (disposition === "break") {
+            break;
+        }
+        const maybeApplied = resolveAndApplySymlinkHop({
+            state,
+            rootCanonicalPath: params.rootCanonicalPath,
+            boundaryLabel: params.params.boundaryLabel,
+            resolveLinkCanonical: (cursor) => resolveSymlinkHopPathSync(cursor),
+        });
+        if (isPromiseLike(maybeApplied)) {
+            throw new Error("Unexpected async symlink resolution");
+        }
+    }
+    const kind = getPathKindSync(params.absolutePath, state.preserveFinalSymlink);
+    return finalizeLexicalResolution({
+        ...params,
+        state,
+        kind,
+    });
+}
+function resolveCanonicalOutsideLexicalPath(params) {
+    return params.outsideLexicalCanonicalPath ?? params.absolutePath;
+}
+function createBoundaryResolutionContext(params) {
+    const lexicalInside = path_isPathInside(params.rootPath, params.absolutePath);
+    const canonicalOutsideLexicalPath = resolveCanonicalOutsideLexicalPath({
+        absolutePath: params.absolutePath,
+        outsideLexicalCanonicalPath: params.outsideLexicalCanonicalPath,
+    });
+    assertLexicalBoundaryOrCanonicalAlias({
+        skipLexicalRootCheck: params.resolveParams.skipLexicalRootCheck,
+        lexicalInside,
+        canonicalOutsideLexicalPath,
+        rootCanonicalPath: params.rootCanonicalPath,
+        boundaryLabel: params.resolveParams.boundaryLabel,
+        rootPath: params.rootPath,
+        absolutePath: params.absolutePath,
+    });
+    return {
+        rootPath: params.rootPath,
+        absolutePath: params.absolutePath,
+        rootCanonicalPath: params.rootCanonicalPath,
+        lexicalInside,
+        canonicalOutsideLexicalPath,
+    };
+}
+async function resolveOutsideRootPathAsync(params) {
+    if (params.context.lexicalInside) {
+        return null;
+    }
+    const kind = await getPathKind(params.context.absolutePath, false);
+    return buildOutsideRootPathFromContext({
+        boundaryLabel: params.boundaryLabel,
+        context: params.context,
+        kind,
+    });
+}
+function resolveOutsideRootPathSync(params) {
+    if (params.context.lexicalInside) {
+        return null;
+    }
+    const kind = getPathKindSync(params.context.absolutePath, false);
+    return buildOutsideRootPathFromContext({
+        boundaryLabel: params.boundaryLabel,
+        context: params.context,
+        kind,
+    });
+}
+function buildOutsideRootPathFromContext(params) {
+    return buildOutsideLexicalRootPath({
+        boundaryLabel: params.boundaryLabel,
+        rootCanonicalPath: params.context.rootCanonicalPath,
+        absolutePath: params.context.absolutePath,
+        canonicalOutsideLexicalPath: params.context.canonicalOutsideLexicalPath,
+        rootPath: params.context.rootPath,
+        kind: params.kind,
+    });
+}
+async function resolveOutsideLexicalCanonicalPathAsync(params) {
+    if (path_isPathInside(params.rootPath, params.absolutePath)) {
+        return undefined;
+    }
+    return await resolvePathViaExistingAncestor(params.absolutePath);
+}
+function resolveOutsideLexicalCanonicalPathSync(params) {
+    if (isPathInside(params.rootPath, params.absolutePath)) {
+        return undefined;
+    }
+    return resolvePathViaExistingAncestorSync(params.absolutePath);
+}
+function buildOutsideLexicalRootPath(params) {
+    assertInsideBoundary({
+        boundaryLabel: params.boundaryLabel,
+        rootCanonicalPath: params.rootCanonicalPath,
+        candidatePath: params.canonicalOutsideLexicalPath,
+        absolutePath: params.absolutePath,
+    });
+    return buildResolvedRootPath({
+        absolutePath: params.absolutePath,
+        canonicalPath: params.canonicalOutsideLexicalPath,
+        rootPath: params.rootPath,
+        rootCanonicalPath: params.rootCanonicalPath,
+        kind: params.kind,
+    });
+}
+function assertLexicalBoundaryOrCanonicalAlias(params) {
+    if (params.skipLexicalRootCheck || params.lexicalInside) {
+        return;
+    }
+    if (path_isPathInside(params.rootCanonicalPath, params.canonicalOutsideLexicalPath)) {
+        return;
+    }
+    throw pathEscapeError({
+        boundaryLabel: params.boundaryLabel,
+        rootPath: params.rootPath,
+        absolutePath: params.absolutePath,
+    });
+}
+function buildResolvedRootPath(params) {
+    return {
+        absolutePath: params.absolutePath,
+        canonicalPath: params.canonicalPath,
+        rootPath: params.rootPath,
+        rootCanonicalPath: params.rootCanonicalPath,
+        relativePath: relativeInsideRoot(params.rootCanonicalPath, params.canonicalPath),
+        exists: params.kind.exists,
+        kind: params.kind.kind,
+    };
+}
+async function resolvePathViaExistingAncestor(targetPath) {
+    const normalized = external_node_path_.resolve(targetPath);
+    let cursor = normalized;
+    const missingSuffix = [];
+    while (!isFilesystemRoot(cursor) && !(await pathExists(cursor))) {
+        missingSuffix.unshift(external_node_path_.basename(cursor));
+        const parent = external_node_path_.dirname(cursor);
+        if (parent === cursor) {
+            break;
+        }
+        cursor = parent;
+    }
+    if (!(await pathExists(cursor))) {
+        return normalized;
+    }
+    try {
+        const resolvedAncestor = external_node_path_.resolve(await promises_.realpath(cursor));
+        if (missingSuffix.length === 0) {
+            return resolvedAncestor;
+        }
+        return external_node_path_.resolve(resolvedAncestor, ...missingSuffix);
+    }
+    catch {
+        return normalized;
+    }
+}
+function resolvePathViaExistingAncestorSync(targetPath) {
+    const normalized = path.resolve(targetPath);
+    let cursor = normalized;
+    const missingSuffix = [];
+    while (!isFilesystemRoot(cursor) && !fs.existsSync(cursor)) {
+        missingSuffix.unshift(path.basename(cursor));
+        const parent = path.dirname(cursor);
+        if (parent === cursor) {
+            break;
+        }
+        cursor = parent;
+    }
+    if (!fs.existsSync(cursor)) {
+        return normalized;
+    }
+    try {
+        // Keep sync behavior aligned with async (`fsp.realpath`) to avoid
+        // platform-specific canonical alias drift (notably on Windows).
+        const resolvedAncestor = path.resolve(fs.realpathSync(cursor));
+        if (missingSuffix.length === 0) {
+            return resolvedAncestor;
+        }
+        return path.resolve(resolvedAncestor, ...missingSuffix);
+    }
+    catch {
+        return normalized;
+    }
+}
+async function getPathKind(absolutePath, preserveFinalSymlink) {
+    try {
+        const stat = preserveFinalSymlink
+            ? await promises_.lstat(absolutePath)
+            : await promises_.stat(absolutePath);
+        return { exists: true, kind: toResolvedKind(stat) };
+    }
+    catch (error) {
+        if (path_isNotFoundPathError(error)) {
+            return { exists: false, kind: "missing" };
+        }
+        throw error;
+    }
+}
+function getPathKindSync(absolutePath, preserveFinalSymlink) {
+    try {
+        const stat = preserveFinalSymlink ? fs.lstatSync(absolutePath) : fs.statSync(absolutePath);
+        return { exists: true, kind: toResolvedKind(stat) };
+    }
+    catch (error) {
+        if (isNotFoundPathError(error)) {
+            return { exists: false, kind: "missing" };
+        }
+        throw error;
+    }
+}
+function toResolvedKind(stat) {
+    if (stat.isFile()) {
+        return "file";
+    }
+    if (stat.isDirectory()) {
+        return "directory";
+    }
+    if (stat.isSymbolicLink()) {
+        return "symlink";
+    }
+    return "other";
+}
+function relativeInsideRoot(rootPath, targetPath) {
+    const relative = external_node_path_.relative(external_node_path_.resolve(rootPath), external_node_path_.resolve(targetPath));
+    if (!relative || relative === ".") {
+        return "";
+    }
+    if (relative.startsWith("..") || external_node_path_.isAbsolute(relative)) {
+        return "";
+    }
+    return relative;
+}
+function assertInsideBoundary(params) {
+    if (path_isPathInside(params.rootCanonicalPath, params.candidatePath)) {
+        return;
+    }
+    throw new Error(`Path resolves outside ${params.boundaryLabel} (${shortPath(params.rootCanonicalPath)}): ${shortPath(params.absolutePath)}`);
+}
+function pathEscapeError(params) {
+    return new Error(`Path escapes ${params.boundaryLabel} (${shortPath(params.rootPath)}): ${shortPath(params.absolutePath)}`);
+}
+function symlinkEscapeError(params) {
+    return new Error(`Symlink escapes ${params.boundaryLabel} (${shortPath(params.rootCanonicalPath)}): ${shortPath(params.symlinkPath)}`);
+}
+function shortPath(value) {
+    const home = external_node_os_.homedir();
+    if (value.startsWith(home)) {
+        return `~${value.slice(home.length)}`;
+    }
+    return value;
+}
+function isFilesystemRoot(candidate) {
+    return external_node_path_.parse(candidate).root === candidate;
+}
+async function pathExists(targetPath) {
+    try {
+        await promises_.lstat(targetPath);
+        return true;
+    }
+    catch (error) {
+        if (path_isNotFoundPathError(error)) {
+            return false;
+        }
+        throw error;
+    }
+}
+async function resolveSymlinkHopPath(symlinkPath) {
+    try {
+        return external_node_path_.resolve(await promises_.realpath(symlinkPath));
+    }
+    catch (error) {
+        if (!path_isNotFoundPathError(error)) {
+            throw error;
+        }
+        const linkTarget = await promises_.readlink(symlinkPath);
+        const linkAbsolute = external_node_path_.resolve(external_node_path_.dirname(symlinkPath), linkTarget);
+        return resolvePathViaExistingAncestor(linkAbsolute);
+    }
+}
+function resolveSymlinkHopPathSync(symlinkPath) {
+    try {
+        return path.resolve(fs.realpathSync(symlinkPath));
+    }
+    catch (error) {
+        if (!isNotFoundPathError(error)) {
+            throw error;
+        }
+        const linkTarget = fs.readlinkSync(symlinkPath);
+        const linkAbsolute = path.resolve(path.dirname(symlinkPath), linkTarget);
+        return resolvePathViaExistingAncestorSync(linkAbsolute);
+    }
+}
+
+;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/path-policy.js
+
+
+
+
+const PATH_ALIAS_POLICIES = ROOT_PATH_ALIAS_POLICIES;
+async function assertNoPathAliasEscape(params) {
+    const resolved = await resolveRootPath({
+        absolutePath: params.absolutePath,
+        rootPath: params.rootPath,
+        boundaryLabel: params.boundaryLabel,
+        policy: params.policy,
+    });
+    const allowFinalSymlink = params.policy?.allowFinalSymlinkForUnlink === true;
+    if (allowFinalSymlink && resolved.kind === "symlink") {
+        return;
+    }
+    await assertNoHardlinkedFinalPath({
+        filePath: resolved.absolutePath,
+        root: resolved.rootPath,
+        boundaryLabel: params.boundaryLabel,
+        allowFinalHardlinkForUnlink: params.policy?.allowFinalHardlinkForUnlink,
+    });
+}
+async function assertNoHardlinkedFinalPath(params) {
+    if (params.allowFinalHardlinkForUnlink) {
+        return;
+    }
+    let stat;
+    try {
+        stat = await promises_.stat(params.filePath);
+    }
+    catch (err) {
+        if (path_isNotFoundPathError(err)) {
+            return;
+        }
+        throw err;
+    }
+    if (!stat.isFile()) {
+        return;
+    }
+    if (stat.nlink > 1) {
+        throw new Error(`Hardlinked path is not allowed under ${params.boundaryLabel} (${path_policy_shortPath(params.root)}): ${path_policy_shortPath(params.filePath)}`);
+    }
+}
+function path_policy_shortPath(value) {
+    if (value.startsWith(external_node_os_.homedir())) {
+        return `~${value.slice(external_node_os_.homedir().length)}`;
+    }
+    return value;
+}
+
+;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/path-stat.js
+function pathStatFromStats(stat) {
+    return {
+        dev: Number(stat.dev),
+        gid: Number(stat.gid),
+        ino: Number(stat.ino),
+        isDirectory: stat.isDirectory(),
+        isFile: stat.isFile(),
+        isSymbolicLink: stat.isSymbolicLink(),
+        mode: stat.mode,
+        mtimeMs: stat.mtimeMs,
+        nlink: stat.nlink,
+        size: stat.size,
+        uid: stat.uid,
+    };
+}
+
+;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/home-dir.js
+
+
+
+function normalize(value) {
+    const trimmed = normalizeOptionalString(value);
+    if (!trimmed) {
+        return undefined;
+    }
+    if (trimmed === "undefined" || trimmed === "null") {
+        return undefined;
+    }
+    return trimmed;
+}
+function resolveEffectiveHomeDir(env = process.env, homedir = external_node_os_.homedir) {
+    const raw = resolveRawHomeDir(env, homedir);
+    return raw ? external_node_path_.resolve(raw) : undefined;
+}
+function resolveOsHomeDir(env = process.env, homedir = os.homedir) {
+    const raw = resolveRawOsHomeDir(env, homedir);
+    return raw ? path.resolve(raw) : undefined;
+}
+function resolveRawHomeDir(env, homedir) {
+    const explicitHome = normalize(env.OPENCLAW_HOME);
+    if (!explicitHome) {
+        return resolveRawOsHomeDir(env, homedir);
+    }
+    const segments = external_node_path_.normalize(explicitHome).split(external_node_path_.sep);
+    if (segments[0] !== "~") {
+        return explicitHome;
+    }
+    // OPENCLAW_HOME starts with "~"; expand against the os home dir. Fall
+    // back to undefined when there is no os home to expand against rather
+    // than returning a raw "~"-prefixed path the caller cannot use.
+    const fallbackHome = resolveRawOsHomeDir(env, homedir);
+    if (!fallbackHome) {
+        return undefined;
+    }
+    return expandHomePrefix(explicitHome, { home: fallbackHome });
+}
+function resolveRawOsHomeDir(env, homedir) {
+    const envHome = normalize(env.HOME);
+    if (envHome) {
+        return envHome;
+    }
+    const userProfile = normalize(env.USERPROFILE);
+    if (userProfile) {
+        return userProfile;
+    }
+    return normalizeSafe(homedir);
+}
+function normalizeSafe(homedir) {
+    try {
+        return normalize(homedir());
+    }
+    catch {
+        return undefined;
+    }
+}
+function resolveRequiredHomeDir(env = process.env, homedir = os.homedir) {
+    return resolveEffectiveHomeDir(env, homedir) ?? path.resolve(process.cwd());
+}
+function resolveRequiredOsHomeDir(env = process.env, homedir = os.homedir) {
+    return resolveOsHomeDir(env, homedir) ?? path.resolve(process.cwd());
+}
+function expandHomePrefix(input, opts) {
+    const segments = external_node_path_.normalize(input).split(external_node_path_.sep);
+    if (segments[0] !== "~") {
+        return input;
+    }
+    const home = normalize(opts?.home) ??
+        resolveEffectiveHomeDir(opts?.env ?? process.env, opts?.homedir ?? external_node_os_.homedir);
+    if (!home) {
+        return input;
+    }
+    return external_node_path_.join(home, ...segments.slice(1));
+}
+function resolveHomeRelativePath(input, opts) {
+    if (!input) {
+        return input;
+    }
+    const segments = path.normalize(input).split(path.sep);
+    if (segments[0] !== "~") {
+        return path.resolve(input);
+    }
+    const expanded = expandHomePrefix(input, {
+        home: resolveRequiredHomeDir(opts?.env ?? process.env, opts?.homedir ?? os.homedir),
+        env: opts?.env,
+        homedir: opts?.homedir,
+    });
+    return path.resolve(expanded);
+}
+function resolveUserPath(input, optsOrEnv, homedir) {
+    const opts = optsOrEnv && ("env" in optsOrEnv || "homedir" in optsOrEnv)
+        ? optsOrEnv
+        : { env: optsOrEnv, homedir };
+    return resolveHomeRelativePath(input, opts);
+}
+function resolveOsHomeRelativePath(input, opts) {
+    if (!input) {
+        return input;
+    }
+    const segments = path.normalize(input).split(path.sep);
+    if (segments[0] !== "~") {
+        return path.resolve(input);
+    }
+    const expanded = expandHomePrefix(input, {
+        home: resolveRequiredOsHomeDir(opts?.env ?? process.env, opts?.homedir ?? os.homedir),
+        env: opts?.env,
+        homedir: opts?.homedir,
+    });
+    return path.resolve(expanded);
+}
+
+;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/root-context.js
+
+
+
+
+
+
+const ensureTrailingSep = (value) => value.endsWith(external_node_path_.sep) ? value : value + external_node_path_.sep;
+function assertValidRootRelativePath(relativePath) {
+    path_assertNoNulPathInput(relativePath, "relative path contains a NUL byte");
+}
+let cachedHomePath;
+async function expandRelativePathWithHome(relativePath) {
+    const rawHome = process.env.HOME || process.env.USERPROFILE || external_node_os_.homedir();
+    if (cachedHomePath?.raw !== rawHome) {
+        let realHome = rawHome;
+        try {
+            realHome = await promises_.realpath(rawHome);
+        }
+        catch {
+            // If the home dir cannot be canonicalized, keep lexical expansion behavior.
+        }
+        cachedHomePath = { raw: rawHome, real: realHome };
+    }
+    return expandHomePrefix(relativePath, { home: cachedHomePath.real });
+}
+async function resolveRootContext(rootDir) {
+    path_assertNoNulPathInput(rootDir, "root dir contains a NUL byte");
+    let rootReal;
+    try {
+        rootReal = await promises_.realpath(rootDir);
+        const rootStat = await promises_.stat(rootReal);
+        if (!rootStat.isDirectory()) {
+            throw new errors_FsSafeError("invalid-path", "root dir is not a directory");
+        }
+    }
+    catch (err) {
+        if (err instanceof errors_FsSafeError) {
+            throw err;
+        }
+        if (path_isNotFoundPathError(err)) {
+            throw new errors_FsSafeError("not-found", "root dir not found");
+        }
+        throw err;
+    }
+    return {
+        rootDir: external_node_path_.resolve(rootDir),
+        rootReal,
+        rootWithSep: ensureTrailingSep(rootReal),
+    };
+}
+async function resolvePathInRoot(root, relativePath) {
+    assertValidRootRelativePath(relativePath);
+    const expanded = await expandRelativePathWithHome(relativePath);
+    const resolved = external_node_path_.resolve(root.rootWithSep, expanded);
+    if (!path_isPathInside(root.rootWithSep, resolved)) {
+        throw new errors_FsSafeError("outside-workspace", "file is outside workspace root");
+    }
+    return { rootReal: root.rootReal, rootWithSep: root.rootWithSep, resolved };
+}
+async function resolvePathWithinRoot(params) {
+    return await resolvePathInRoot(await resolveRootContext(params.rootDir), params.relativePath);
+}
+
+;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/root-errors.js
+
+
+function isAlreadyExistsError(error) {
+    return hasNodeErrorCode(error, "EEXIST") || /File exists|EEXIST/i.test(String(error));
+}
+function normalizePinnedWriteError(error) {
+    if (error instanceof errors_FsSafeError) {
+        return error;
+    }
+    return new errors_FsSafeError("invalid-path", "path is not a regular file under root", {
+        cause: error instanceof Error ? error : undefined,
+    });
+}
+function normalizePinnedPathError(error) {
+    if (error instanceof errors_FsSafeError) {
+        return error;
+    }
+    return new errors_FsSafeError("path-alias", "path is not under root", {
+        cause: error instanceof Error ? error : undefined,
+    });
+}
+
+;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/test-hooks.js
+let test_hooks_fsSafeTestHooks;
+function allowFsSafeTestHooks() {
+    return  false || process.env.VITEST === "true";
+}
+function getFsSafeTestHooks() {
+    return test_hooks_fsSafeTestHooks;
+}
+function __setFsSafeTestHooksForTest(hooks) {
+    if (hooks && !allowFsSafeTestHooks()) {
+        throw new Error("__setFsSafeTestHooksForTest is only available in tests");
+    }
+    test_hooks_fsSafeTestHooks = hooks;
+}
+
+;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/temp-cleanup.js
+
+const tempCleanupEntries = new Map();
+let cleanupRegistered = false;
+function cleanupRegisteredTempPathsSync() {
+    for (const entry of tempCleanupEntries.values()) {
+        try {
+            external_node_fs_.rmSync(entry.path, { force: true, recursive: entry.recursive });
+        }
+        catch {
+            // Process-exit cleanup is best-effort.
+        }
+    }
+    tempCleanupEntries.clear();
+}
+function registerTempPathForExit(tempPath, options) {
+    if (!cleanupRegistered) {
+        cleanupRegistered = true;
+        process.once("exit", cleanupRegisteredTempPathsSync);
+    }
+    tempCleanupEntries.set(tempPath, {
+        path: tempPath,
+        recursive: options?.recursive === true,
+    });
+    return () => {
+        tempCleanupEntries.delete(tempPath);
+    };
+}
+function __cleanupRegisteredTempPathsForTest() {
+    cleanupRegisteredTempPathsSync();
+}
+function __cleanupRegisteredTempPathForTest(tempPath) {
+    const entry = tempCleanupEntries.get(tempPath);
+    if (!entry) {
+        return;
+    }
+    try {
+        fsSync.rmSync(entry.path, { force: true, recursive: entry.recursive });
+    }
+    finally {
+        tempCleanupEntries.delete(tempPath);
+    }
+}
+
+;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/write-queue.js
+const writeQueues = new Map();
+async function serializePathWrite(key, run) {
+    const previous = writeQueues.get(key) ?? Promise.resolve();
+    const task = (async () => {
+        await previous.catch(() => undefined);
+        return await run();
+    })();
+    const done = task.then(() => undefined, () => undefined);
+    writeQueues.set(key, done);
+    try {
+        return await task;
+    }
+    finally {
+        if (writeQueues.get(key) === done) {
+            writeQueues.delete(key);
+        }
+    }
+}
+
+;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/root-impl.js
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+function logWarn(message) {
+    if (process.env.FS_SAFE_DEBUG_WARNINGS === "1") {
+        console.warn(message);
+    }
+}
+const SUPPORTS_NOFOLLOW = process.platform !== "win32" && "O_NOFOLLOW" in external_node_fs_.constants;
+const NONBLOCK_OPEN_FLAG = "O_NONBLOCK" in external_node_fs_.constants ? external_node_fs_.constants.O_NONBLOCK : 0;
+const OPEN_READ_FLAGS = external_node_fs_.constants.O_RDONLY | (SUPPORTS_NOFOLLOW ? external_node_fs_.constants.O_NOFOLLOW : 0);
+const OPEN_READ_NONBLOCK_FLAGS = OPEN_READ_FLAGS | NONBLOCK_OPEN_FLAG;
+const OPEN_READ_FOLLOW_FLAGS = external_node_fs_.constants.O_RDONLY;
+const OPEN_READ_FOLLOW_NONBLOCK_FLAGS = OPEN_READ_FOLLOW_FLAGS | NONBLOCK_OPEN_FLAG;
+const OPEN_WRITE_EXISTING_FLAGS = external_node_fs_.constants.O_WRONLY | (SUPPORTS_NOFOLLOW ? external_node_fs_.constants.O_NOFOLLOW : 0);
+const OPEN_WRITE_CREATE_FLAGS = external_node_fs_.constants.O_WRONLY |
+    external_node_fs_.constants.O_CREAT |
+    external_node_fs_.constants.O_EXCL |
+    (SUPPORTS_NOFOLLOW ? external_node_fs_.constants.O_NOFOLLOW : 0);
+const OPEN_APPEND_EXISTING_FLAGS = external_node_fs_.constants.O_RDWR | external_node_fs_.constants.O_APPEND | (SUPPORTS_NOFOLLOW ? external_node_fs_.constants.O_NOFOLLOW : 0);
+const OPEN_APPEND_CREATE_FLAGS = external_node_fs_.constants.O_RDWR |
+    external_node_fs_.constants.O_APPEND |
+    external_node_fs_.constants.O_CREAT |
+    external_node_fs_.constants.O_EXCL |
+    (SUPPORTS_NOFOLLOW ? external_node_fs_.constants.O_NOFOLLOW : 0);
+const DEFAULT_ROOT_MAX_BYTES = 16 * 1024 * 1024;
+function closeHandleForDispose(handle) {
+    return handle.close().catch(() => undefined);
+}
+function openResult(params) {
+    return {
+        handle: params.handle,
+        realPath: params.realPath,
+        stat: params.stat,
+        [Symbol.asyncDispose]: async () => {
+            await closeHandleForDispose(params.handle);
+        },
+    };
+}
+async function openVerifiedLocalFile(filePath, options) {
+    const fsSafeTestHooks = getFsSafeTestHooks();
+    // Reject directories before opening so we never surface EISDIR to callers (e.g. tool
+    // results that get sent to messaging channels). See openclaw/openclaw#31186.
+    try {
+        const preStat = await promises_.lstat(filePath);
+        if (preStat.isDirectory()) {
+            throw new errors_FsSafeError("not-file", "not a file");
+        }
+        await fsSafeTestHooks?.afterPreOpenLstat?.(filePath);
+    }
+    catch (err) {
+        if (err instanceof errors_FsSafeError) {
+            throw err;
+        }
+        // ENOENT and other lstat errors: fall through and let fs.open handle.
+    }
+    let handle;
+    try {
+        const openFlags = options?.symlinks === "follow-within-root"
+            ? options?.nonBlockingRead
+                ? OPEN_READ_FOLLOW_NONBLOCK_FLAGS
+                : OPEN_READ_FOLLOW_FLAGS
+            : options?.nonBlockingRead
+                ? OPEN_READ_NONBLOCK_FLAGS
+                : OPEN_READ_FLAGS;
+        await fsSafeTestHooks?.beforeOpen?.(filePath, openFlags);
+        handle = await promises_.open(filePath, openFlags);
+        try {
+            await fsSafeTestHooks?.afterOpen?.(filePath, handle);
+        }
+        catch (err) {
+            await handle.close().catch(() => { });
+            throw err;
+        }
+    }
+    catch (err) {
+        if (path_isNotFoundPathError(err)) {
+            throw new errors_FsSafeError("not-found", "file not found");
+        }
+        if (isSymlinkOpenError(err)) {
+            throw new errors_FsSafeError("symlink", "symlink open blocked", { cause: err });
+        }
+        // Defensive: if open still throws EISDIR (e.g. race), sanitize so it never leaks.
+        if (hasNodeErrorCode(err, "EISDIR")) {
+            throw new errors_FsSafeError("not-file", "not a file");
+        }
+        throw err;
+    }
+    try {
+        const stat = await handle.stat();
+        if (!stat.isFile()) {
+            throw new errors_FsSafeError("not-file", "not a file");
+        }
+        if (options?.hardlinks === "reject" && stat.nlink > 1) {
+            throw new errors_FsSafeError("hardlink", "hardlinked path not allowed");
+        }
+        if (options?.symlinks === "follow-within-root") {
+            const pathStat = await promises_.stat(filePath);
+            if (!file_identity_sameFileIdentity(stat, pathStat)) {
+                throw new errors_FsSafeError("path-mismatch", "path changed during read");
+            }
+        }
+        else {
+            const pathStat = await promises_.lstat(filePath);
+            if (pathStat.isSymbolicLink()) {
+                throw new errors_FsSafeError("symlink", "symlink not allowed");
+            }
+            if (!file_identity_sameFileIdentity(stat, pathStat)) {
+                throw new errors_FsSafeError("path-mismatch", "path changed during read");
+            }
+        }
+        const realPath = await resolveOpenedFileRealPathForHandle(handle, filePath);
+        const realStat = await promises_.stat(realPath);
+        if (options?.hardlinks === "reject" && realStat.nlink > 1) {
+            throw new errors_FsSafeError("hardlink", "hardlinked path not allowed");
+        }
+        if (!file_identity_sameFileIdentity(stat, realStat)) {
+            throw new errors_FsSafeError("path-mismatch", "path mismatch");
+        }
+        return openResult({ handle, realPath, stat });
+    }
+    catch (err) {
+        await handle.close().catch(() => { });
+        if (err instanceof errors_FsSafeError) {
+            throw err;
+        }
+        if (path_isNotFoundPathError(err)) {
+            throw new errors_FsSafeError("not-found", "file not found");
+        }
+        throw err;
+    }
+}
+class RootHandle {
+    rootDir;
+    rootReal;
+    rootWithSep;
+    defaults;
+    constructor(context, defaults = {}) {
+        this.rootDir = context.rootDir;
+        this.rootReal = context.rootReal;
+        this.rootWithSep = context.rootWithSep;
+        this.defaults = defaults;
+    }
+    get context() {
+        return {
+            rootDir: this.rootDir,
+            rootReal: this.rootReal,
+            rootWithSep: this.rootWithSep,
+        };
+    }
+    async resolve(relativePath) {
+        return (await resolvePathInRoot(this.context, relativePath)).resolved;
+    }
+    async open(relativePath, options = {}) {
+        return await openFileInRoot(this.context, {
+            relativePath,
+            ...readDefaults(this.defaults),
+            ...options,
+        });
+    }
+    async read(relativePath, options = {}) {
+        return await readFileInRoot(this.context, {
+            relativePath,
+            ...readDefaults(this.defaults),
+            ...options,
+        });
+    }
+    async readBytes(relativePath, options = {}) {
+        return (await this.read(relativePath, options)).buffer;
+    }
+    async readText(relativePath, options = {}) {
+        const { encoding = "utf8", ...readOptions } = options;
+        return (await this.read(relativePath, readOptions)).buffer.toString(encoding);
+    }
+    async readJson(relativePath, options = {}) {
+        return JSON.parse(await this.readText(relativePath, options));
+    }
+    async readAbsolute(filePath, options = {}) {
+        return await readPathInRoot(this.context, {
+            filePath,
+            ...readDefaults(this.defaults),
+            ...options,
+        });
+    }
+    reader(options = {}) {
+        return async (filePath) => {
+            return (await this.readAbsolute(filePath, options)).buffer;
+        };
+    }
+    async openWritable(relativePath, options = {}) {
+        const writeMode = options.writeMode ?? "replace";
+        return await openWritableFileInRoot(this.context, {
+            relativePath,
+            mkdir: this.defaults.mkdir,
+            mode: this.defaults.mode,
+            ...options,
+            append: writeMode === "append",
+            truncateExisting: writeMode === "replace",
+        });
+    }
+    async append(relativePath, data, options = {}) {
+        await appendFileInRoot(this.context, {
+            relativePath,
+            data,
+            mkdir: this.defaults.mkdir,
+            mode: this.defaults.mode,
+            ...options,
+        });
+    }
+    async remove(relativePath) {
+        assertValidRootRelativePath(relativePath);
+        await removePathInRoot(this.context, relativePath);
+    }
+    async mkdir(relativePath) {
+        assertValidRootRelativePath(relativePath);
+        await mkdirPathInRoot(this.context, { relativePath });
+    }
+    async ensureRoot() {
+        await mkdirPathInRoot(this.context, { relativePath: "", allowRoot: true });
+    }
+    async write(relativePath, data, options = {}) {
+        await writeFileInRoot(this.context, {
+            relativePath,
+            data,
+            mkdir: this.defaults.mkdir,
+            mode: this.defaults.mode,
+            ...options,
+        });
+    }
+    async create(relativePath, data, options = {}) {
+        await writeFileInRoot(this.context, {
+            relativePath,
+            data,
+            mkdir: this.defaults.mkdir,
+            mode: this.defaults.mode,
+            ...options,
+            overwrite: false,
+        });
+    }
+    async writeJson(relativePath, data, options = {}) {
+        const { replacer, space, trailingNewline = true, ...writeOptions } = options;
+        const json = JSON.stringify(data, replacer, space);
+        await this.write(relativePath, trailingNewline ? `${json}\n` : json, writeOptions);
+    }
+    async createJson(relativePath, data, options = {}) {
+        const { replacer, space, trailingNewline = true, ...writeOptions } = options;
+        const json = JSON.stringify(data, replacer, space);
+        await this.create(relativePath, trailingNewline ? `${json}\n` : json, writeOptions);
+    }
+    async copyIn(relativePath, sourcePath, options = {}) {
+        assertValidRootRelativePath(relativePath);
+        await copyFileInRoot(this.context, {
+            sourcePath,
+            relativePath,
+            maxBytes: this.defaults.maxBytes,
+            mkdir: this.defaults.mkdir,
+            mode: this.defaults.mode,
+            ...options,
+        });
+    }
+    async exists(relativePath) {
+        try {
+            await this.stat(relativePath);
+            return true;
+        }
+        catch (err) {
+            if (err instanceof errors_FsSafeError && err.code === "not-found") {
+                return false;
             }
+            throw err;
+        }
+    }
+    async stat(relativePath) {
+        assertValidRootRelativePath(relativePath);
+        try {
+            return await helperStat(this.rootReal, relativePath);
+        }
+        catch (error) {
+            if (canFallbackFromPythonError(error)) {
+                return await statPathFallback(this.context, relativePath);
+            }
+            throw error;
+        }
+    }
+    async list(relativePath, options = {}) {
+        assertValidRootRelativePath(relativePath);
+        try {
+            return options.withFileTypes === true
+                ? await helperReaddir(this.rootReal, relativePath, true)
+                : await helperReaddir(this.rootReal, relativePath, false);
+        }
+        catch (error) {
+            if (canFallbackFromPythonError(error)) {
+                return await listPathFallback(this.context, relativePath, options.withFileTypes === true);
+            }
+            throw error;
+        }
+    }
+    async move(fromRelative, toRelative, options = {}) {
+        assertValidRootRelativePath(fromRelative);
+        assertValidRootRelativePath(toRelative);
+        try {
+            await runPinnedHelper("rename", this.rootReal, {
+                from: fromRelative,
+                overwrite: options.overwrite ?? false,
+                to: toRelative,
+            });
+        }
+        catch (error) {
+            if (canFallbackFromPythonError(error)) {
+                await movePathFallback(this.context, {
+                    fromRelative,
+                    overwrite: options.overwrite ?? false,
+                    toRelative,
+                });
+                return;
+            }
+            throw error;
         }
-        return result;
     }
 }
-/**
- * Creates and returns the default action version gateway
- */ function createActionVersionGateway() {
-    return new LocalActionVersionGateway();
+function readDefaults(defaults) {
+    return {
+        hardlinks: defaults.hardlinks,
+        maxBytes: defaults.maxBytes ?? DEFAULT_ROOT_MAX_BYTES,
+        nonBlockingRead: defaults.nonBlockingRead,
+        symlinks: defaults.symlinks,
+    };
+}
+async function root_impl_root(rootDir, defaults = {}) {
+    return new RootHandle(await resolveRootContext(rootDir), defaults);
+}
+async function openFileInRoot(root, params) {
+    const { rootWithSep, resolved } = await resolvePathInRoot(root, params.relativePath);
+    let opened;
+    try {
+        opened = await openVerifiedLocalFile(resolved, {
+            nonBlockingRead: params.nonBlockingRead,
+            symlinks: params.symlinks,
+        });
+    }
+    catch (err) {
+        if (err instanceof errors_FsSafeError) {
+            throw err;
+        }
+        throw err;
+    }
+    if (params.hardlinks !== "allow" && opened.stat.nlink > 1) {
+        await opened.handle.close().catch(() => { });
+        throw new errors_FsSafeError("hardlink", "hardlinked path not allowed");
+    }
+    if (!path_isPathInside(rootWithSep, opened.realPath)) {
+        await opened.handle.close().catch(() => { });
+        throw new errors_FsSafeError("outside-workspace", "file is outside workspace root");
+    }
+    return opened;
+}
+async function readFileInRoot(root, params) {
+    const opened = await openFileInRoot(root, params);
+    try {
+        return await readOpenedFileSafely({ opened, maxBytes: params.maxBytes });
+    }
+    finally {
+        await opened.handle.close().catch(() => { });
+    }
+}
+async function readPathInRoot(root, params) {
+    const rootDir = root.rootDir;
+    const candidatePath = external_node_path_.isAbsolute(params.filePath)
+        ? external_node_path_.resolve(params.filePath)
+        : external_node_path_.resolve(rootDir, params.filePath);
+    const relativePath = external_node_path_.relative(rootDir, candidatePath);
+    return await readFileInRoot(root, {
+        relativePath,
+        hardlinks: params.hardlinks,
+        maxBytes: params.maxBytes,
+        nonBlockingRead: params.nonBlockingRead,
+        symlinks: params.symlinks,
+    });
+}
+async function readLocalFileSafely(params) {
+    const opened = await openLocalFileSafely({ filePath: params.filePath });
+    try {
+        return await readOpenedFileSafely({ opened, maxBytes: params.maxBytes });
+    }
+    finally {
+        await opened.handle.close().catch(() => { });
+    }
+}
+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})`);
+}
+function buildAtomicWriteTempPath(targetPath) {
+    const dir = external_node_path_.dirname(targetPath);
+    const base = external_node_path_.basename(targetPath);
+    return external_node_path_.join(dir, `.${base}.${process.pid}.${(0,external_node_crypto_.randomUUID)()}.tmp`);
+}
+function rootWriteQueueKey(root, relativePath) {
+    return `${root.rootReal}\0${relativePath}`;
+}
+async function writeTempFileForAtomicReplace(params) {
+    const tempHandle = await promises_.open(params.tempPath, OPEN_WRITE_CREATE_FLAGS, params.mode);
+    try {
+        if (typeof params.data === "string") {
+            await tempHandle.writeFile(params.data, params.encoding ?? "utf8");
+        }
+        else {
+            await tempHandle.writeFile(params.data);
+        }
+        return await tempHandle.stat();
+    }
+    finally {
+        await tempHandle.close().catch(() => { });
+    }
+}
+async function verifyAtomicWriteResult(params) {
+    const opened = await openVerifiedLocalFile(params.targetPath, { hardlinks: "reject" });
+    try {
+        if (!file_identity_sameFileIdentity(opened.stat, params.expectedIdentity)) {
+            throw new errors_FsSafeError("path-mismatch", "path changed during write");
+        }
+        if (!path_isPathInside(params.root.rootWithSep, opened.realPath)) {
+            throw new errors_FsSafeError("outside-workspace", "file is outside workspace root");
+        }
+    }
+    finally {
+        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);
+    try {
+        await assertNoPathAliasEscape({
+            absolutePath: resolved,
+            rootPath: rootReal,
+            boundaryLabel: "root",
+        });
+    }
+    catch (err) {
+        throw new errors_FsSafeError("path-alias", "path alias escape blocked", { cause: err });
+    }
+    if (params.mkdir !== false) {
+        const parentGuard = await directory_guard_createNearestExistingDirectoryGuard(rootReal, external_node_path_.dirname(resolved));
+        await withAsyncDirectoryGuards([parentGuard], async () => {
+            await promises_.mkdir(external_node_path_.dirname(resolved), { recursive: true });
+        });
+    }
+    let ioPath = resolved;
+    try {
+        const resolvedRealPath = await promises_.realpath(resolved);
+        if (!path_isPathInside(rootWithSep, resolvedRealPath)) {
+            throw new errors_FsSafeError("outside-workspace", "file is outside workspace root");
+        }
+        ioPath = resolvedRealPath;
+    }
+    catch (err) {
+        if (err instanceof errors_FsSafeError) {
+            throw err;
+        }
+        if (!path_isNotFoundPathError(err)) {
+            throw err;
+        }
+    }
+    const mode = params.mode ?? 0o600;
+    let handle;
+    let createdForWrite = false;
+    const existingFlags = params.append ? OPEN_APPEND_EXISTING_FLAGS : OPEN_WRITE_EXISTING_FLAGS;
+    const createFlags = params.append ? OPEN_APPEND_CREATE_FLAGS : OPEN_WRITE_CREATE_FLAGS;
+    try {
+        try {
+            handle = await promises_.open(ioPath, existingFlags, mode);
+        }
+        catch (err) {
+            if (!path_isNotFoundPathError(err)) {
+                throw err;
+            }
+            handle = await promises_.open(ioPath, createFlags, mode);
+            createdForWrite = true;
+        }
+    }
+    catch (err) {
+        if (path_isNotFoundPathError(err)) {
+            throw new errors_FsSafeError("not-found", "file not found");
+        }
+        if (isSymlinkOpenError(err)) {
+            throw new errors_FsSafeError("symlink", "symlink open blocked", { cause: err });
+        }
+        if (hasNodeErrorCode(err, "EISDIR")) {
+            throw new errors_FsSafeError("not-file", "not a file", { cause: err });
+        }
+        throw err;
+    }
+    let realPathForCleanup = null;
+    try {
+        const stat = await handle.stat();
+        if (!stat.isFile()) {
+            throw new errors_FsSafeError("invalid-path", "path is not a regular file under root");
+        }
+        if (stat.nlink > 1) {
+            throw new errors_FsSafeError("hardlink", "hardlinked path not allowed");
+        }
+        try {
+            const lstat = await promises_.lstat(ioPath);
+            if (lstat.isSymbolicLink() || !lstat.isFile()) {
+                throw new errors_FsSafeError(lstat.isSymbolicLink() ? "symlink" : "not-file", "path is not a regular file under root");
+            }
+            if (!file_identity_sameFileIdentity(stat, lstat)) {
+                throw new errors_FsSafeError("path-mismatch", "path changed during write");
+            }
+        }
+        catch (err) {
+            if (!path_isNotFoundPathError(err)) {
+                throw err;
+            }
+        }
+        const realPath = await resolveOpenedFileRealPathForHandle(handle, ioPath);
+        realPathForCleanup = realPath;
+        const realStat = await promises_.stat(realPath);
+        if (!file_identity_sameFileIdentity(stat, realStat)) {
+            throw new errors_FsSafeError("path-mismatch", "path mismatch");
+        }
+        if (realStat.nlink > 1) {
+            throw new errors_FsSafeError("hardlink", "hardlinked path not allowed");
+        }
+        if (!path_isPathInside(rootWithSep, realPath)) {
+            throw new errors_FsSafeError("outside-workspace", "file is outside workspace root");
+        }
+        // Truncate only after boundary and identity checks complete. This avoids
+        // irreversible side effects if a symlink target changes before validation.
+        if (params.append !== true && params.truncateExisting !== false && !createdForWrite) {
+            await handle.truncate(0);
+        }
+        return {
+            handle,
+            createdForWrite,
+            realPath,
+            stat,
+            [Symbol.asyncDispose]: async () => {
+                await closeHandleForDispose(handle);
+            },
+        };
+    }
+    catch (err) {
+        const cleanupCreatedPath = createdForWrite && err instanceof errors_FsSafeError;
+        const cleanupPath = realPathForCleanup ?? ioPath;
+        await handle.close().catch(() => { });
+        if (cleanupCreatedPath) {
+            await promises_.rm(cleanupPath, { force: true }).catch(() => { });
+        }
+        throw err;
+    }
+}
+async function appendFileInRoot(root, params) {
+    const target = await openWritableFileInRoot(root, {
+        relativePath: params.relativePath,
+        mkdir: params.mkdir,
+        mode: params.mode,
+        truncateExisting: false,
+        append: true,
+    });
+    try {
+        let prefix = "";
+        if (params.prependNewlineIfNeeded === true &&
+            !target.createdForWrite &&
+            target.stat.size > 0 &&
+            ((typeof params.data === "string" && !params.data.startsWith("\n")) ||
+                (Buffer.isBuffer(params.data) && params.data.length > 0 && params.data[0] !== 0x0a))) {
+            const lastByte = Buffer.alloc(1);
+            const { bytesRead } = await target.handle.read(lastByte, 0, 1, target.stat.size - 1);
+            if (bytesRead === 1 && lastByte[0] !== 0x0a) {
+                prefix = "\n";
+            }
+        }
+        if (typeof params.data === "string") {
+            await target.handle.appendFile(`${prefix}${params.data}`, params.encoding ?? "utf8");
+            return;
+        }
+        const payload = prefix.length > 0 ? Buffer.concat([Buffer.from(prefix, "utf8"), params.data]) : params.data;
+        await target.handle.appendFile(payload);
+    }
+    finally {
+        await target.handle.close().catch(() => { });
+    }
+}
+async function removePathInRoot(root, relativePath) {
+    const resolved = await resolvePinnedRemovePathInRoot(root, relativePath);
+    if (process.platform === "win32") {
+        await removePathFallback(resolved);
+        return;
+    }
+    try {
+        await runPinnedPathHelper({
+            operation: "remove",
+            rootPath: resolved.rootReal,
+            relativePath: resolved.relativePosix,
+        });
+    }
+    catch (error) {
+        if (isPinnedPathHelperSpawnError(error)) {
+            await removePathFallback(resolved);
+            return;
+        }
+        throw normalizePinnedPathError(error);
+    }
+}
+async function mkdirPathInRoot(root, params) {
+    const resolved = await resolvePinnedPathInRoot(root, params);
+    if (process.platform === "win32") {
+        await mkdirPathFallback(resolved);
+        return;
+    }
+    try {
+        await runPinnedPathHelper({
+            operation: "mkdirp",
+            rootPath: resolved.rootReal,
+            relativePath: resolved.relativePosix,
+        });
+    }
+    catch (error) {
+        if (isPinnedPathHelperSpawnError(error)) {
+            await mkdirPathFallback(resolved);
+            return;
+        }
+        throw normalizePinnedPathError(error);
+    }
+}
+async function writeFileInRoot(root, params) {
+    if (process.platform === "win32") {
+        await serializePathWrite(rootWriteQueueKey(root, params.relativePath), async () => {
+            await writeFileFallback(root, params);
+        });
+        return;
+    }
+    const pinned = await resolvePinnedWriteTargetInRoot(root, params.relativePath, params.mode);
+    await serializePathWrite(pinned.targetPath, async () => {
+        let identity;
+        try {
+            identity = await runPinnedWriteHelper({
+                rootPath: pinned.rootReal,
+                relativeParentPath: pinned.relativeParentPath,
+                basename: pinned.basename,
+                mkdir: params.mkdir !== false,
+                mode: params.mode ?? pinned.mode,
+                overwrite: params.overwrite,
+                input: {
+                    kind: "buffer",
+                    data: params.data,
+                    encoding: params.encoding,
+                },
+            });
+        }
+        catch (error) {
+            if (params.overwrite === false && isAlreadyExistsError(error)) {
+                throw new errors_FsSafeError("already-exists", "file already exists", {
+                    cause: error instanceof Error ? error : undefined,
+                });
+            }
+            throw normalizePinnedWriteError(error);
+        }
+        try {
+            await verifyAtomicWriteResult({
+                root,
+                targetPath: pinned.targetPath,
+                expectedIdentity: identity,
+            });
+        }
+        catch (err) {
+            emitWriteBoundaryWarning(`post-write verification failed: ${String(err)}`);
+            throw err;
+        }
+    });
+}
+async function copyFileInRoot(root, params) {
+    assertValidRootRelativePath(params.relativePath);
+    path_assertNoNulPathInput(params.sourcePath, "source path contains a NUL byte");
+    const source = await openVerifiedLocalFile(params.sourcePath, {
+        hardlinks: params.sourceHardlinks,
+    });
+    if (params.maxBytes !== undefined && source.stat.size > params.maxBytes) {
+        await source.handle.close().catch(() => { });
+        throw new errors_FsSafeError("too-large", `file exceeds limit of ${params.maxBytes} bytes (got ${source.stat.size})`);
+    }
+    try {
+        if (process.platform === "win32") {
+            await serializePathWrite(rootWriteQueueKey(root, params.relativePath), async () => {
+                await copyFileFallback(root, params, source);
+            });
+            return;
+        }
+        const pinned = await resolvePinnedWriteTargetInRoot(root, params.relativePath, params.mode);
+        await serializePathWrite(pinned.targetPath, async () => {
+            let identity;
+            try {
+                if (getFsSafePythonConfig().mode === "off") {
+                    await copyFileFallback(root, params, source);
+                    return;
+                }
+                identity = await runPinnedCopyHelper({
+                    rootPath: pinned.rootReal,
+                    relativeParentPath: pinned.relativeParentPath,
+                    basename: pinned.basename,
+                    mkdir: params.mkdir !== false,
+                    mode: pinned.mode,
+                    overwrite: true,
+                    maxBytes: params.maxBytes,
+                    sourcePath: source.realPath,
+                    sourceIdentity: { dev: source.stat.dev, ino: source.stat.ino },
+                });
+            }
+            catch (error) {
+                if (canFallbackFromPythonError(error)) {
+                    await copyFileFallback(root, params, source);
+                    return;
+                }
+                throw normalizePinnedWriteError(error);
+            }
+            try {
+                await verifyAtomicWriteResult({
+                    root,
+                    targetPath: pinned.targetPath,
+                    expectedIdentity: identity,
+                });
+            }
+            catch (err) {
+                emitWriteBoundaryWarning(`post-copy verification failed: ${String(err)}`);
+                throw err;
+            }
+        });
+    }
+    finally {
+        await source.handle.close().catch(() => { });
+    }
+}
+async function resolvePinnedWriteTargetInRoot(root, relativePath, requestedMode) {
+    const { rootReal, rootWithSep, resolved } = await resolvePathInRoot(root, relativePath);
+    try {
+        await assertNoPathAliasEscape({
+            absolutePath: resolved,
+            rootPath: rootReal,
+            boundaryLabel: "root",
+        });
+    }
+    catch (err) {
+        throw new errors_FsSafeError("path-alias", "path alias escape blocked", { cause: err });
+    }
+    // resolvePathInRoot already enforces isPathInside, so any actual escape
+    // is rejected upstream.
+    const relativeResolved = external_node_path_.relative(rootReal, resolved);
+    if (external_node_path_.isAbsolute(relativeResolved)) {
+        throw new errors_FsSafeError("outside-workspace", "file is outside workspace root");
+    }
+    const relativePosix = relativeResolved
+        ? relativeResolved.split(external_node_path_.sep).join(external_node_path_.posix.sep)
+        : "";
+    const basename = external_node_path_.posix.basename(relativePosix);
+    if (!basename || basename === "." || basename === "/") {
+        throw new errors_FsSafeError("invalid-path", "invalid target path");
+    }
+    let mode = requestedMode ?? 0o600;
+    try {
+        const opened = await openFileInRoot(root, {
+            relativePath,
+            hardlinks: "reject",
+            nonBlockingRead: true,
+        });
+        try {
+            mode = requestedMode ?? (opened.stat.mode & 0o777);
+            if (!path_isPathInside(rootWithSep, opened.realPath)) {
+                throw new errors_FsSafeError("outside-workspace", "file is outside workspace root");
+            }
+        }
+        finally {
+            await opened.handle.close().catch(() => { });
+        }
+    }
+    catch (err) {
+        if (!(err instanceof errors_FsSafeError) || err.code !== "not-found") {
+            throw err;
+        }
+    }
+    return {
+        rootReal,
+        targetPath: resolved,
+        relativeParentPath: external_node_path_.posix.dirname(relativePosix) === "." ? "" : external_node_path_.posix.dirname(relativePosix),
+        basename,
+        mode: mode || 0o600,
+    };
+}
+async function resolvePinnedPathInRoot(root, params) {
+    return await resolvePinnedOperationPathInRoot(root, {
+        allowRoot: params.allowRoot,
+        relativePath: params.relativePath,
+        policy: PATH_ALIAS_POLICIES.strict,
+    });
+}
+async function resolvePinnedRemovePathInRoot(root, relativePath) {
+    return await resolvePinnedOperationPathInRoot(root, {
+        relativePath,
+        policy: PATH_ALIAS_POLICIES.unlinkTarget,
+    });
+}
+async function resolvePinnedOperationPathInRoot(root, params) {
+    const resolved = await resolvePinnedRootPathInRoot(root, {
+        relativePath: params.relativePath,
+        policy: params.policy,
+    });
+    const relativeResolved = external_node_path_.relative(resolved.rootReal, resolved.canonicalPath);
+    if ((relativeResolved === "" || relativeResolved === ".") && params.allowRoot === true) {
+        return { rootReal: resolved.rootReal, resolved: resolved.canonicalPath, relativePosix: "" };
+    }
+    const firstSegment = relativeResolved.split(external_node_path_.sep)[0];
+    if (relativeResolved === "" ||
+        relativeResolved === "." ||
+        firstSegment === ".." ||
+        external_node_path_.isAbsolute(relativeResolved)) {
+        throw new errors_FsSafeError("outside-workspace", "file is outside workspace root");
+    }
+    const relativePosix = relativeResolved.split(external_node_path_.sep).join(external_node_path_.posix.sep);
+    if (!path_isPathInside(resolved.rootWithSep, resolved.canonicalPath)) {
+        throw new errors_FsSafeError("outside-workspace", "file is outside workspace root");
+    }
+    return { rootReal: resolved.rootReal, resolved: resolved.canonicalPath, relativePosix };
+}
+async function resolvePinnedRootPathInRoot(root, params) {
+    const rootReal = root.rootReal;
+    let resolved;
+    try {
+        resolved = await resolveRootPath({
+            absolutePath: external_node_path_.resolve(rootReal, await expandRelativePathWithHome(params.relativePath)),
+            rootPath: rootReal,
+            rootCanonicalPath: rootReal,
+            boundaryLabel: "root",
+            policy: params.policy,
+        });
+    }
+    catch (err) {
+        throw new errors_FsSafeError("path-alias", "path alias escape blocked", { cause: err });
+    }
+    const rootWithSep = ensureTrailingSep(resolved.rootCanonicalPath);
+    return {
+        rootReal: resolved.rootCanonicalPath,
+        rootWithSep,
+        canonicalPath: resolved.canonicalPath,
+    };
+}
+async function removePathFallback(resolved) {
+    const guard = await directory_guard_createAsyncDirectoryGuard(external_node_path_.dirname(resolved.resolved));
+    await getFsSafeTestHooks()?.beforeRootFallbackMutation?.("remove", resolved.resolved);
+    await assertAsyncDirectoryGuard(guard);
+    await ((await promises_.lstat(resolved.resolved)).isDirectory() ? promises_.rmdir(resolved.resolved) : promises_.rm(resolved.resolved));
+    await assertAsyncDirectoryGuard(guard).catch(() => undefined);
+}
+async function mkdirPathFallback(resolved) {
+    await mkdirPathComponentsWithGuards({
+        rootReal: resolved.rootReal, targetPath: resolved.resolved,
+        beforeComponent: async (componentPath) => await getFsSafeTestHooks()?.beforeRootFallbackMutation?.("mkdir", componentPath),
+    });
+}
+async function statPathFallback(root, relativePath) {
+    const resolved = await resolvePinnedPathInRoot(root, { relativePath, allowRoot: true });
+    try {
+        return pathStatFromStats(await promises_.lstat(resolved.resolved));
+    }
+    catch (error) {
+        if (path_isNotFoundPathError(error)) {
+            throw new errors_FsSafeError("not-found", "file not found", {
+                cause: error instanceof Error ? error : undefined,
+            });
+        }
+        throw error;
+    }
+}
+async function listPathFallback(root, relativePath, withFileTypes) {
+    const resolved = await resolvePinnedPathInRoot(root, { relativePath, allowRoot: true });
+    try {
+        const names = await promises_.readdir(resolved.resolved);
+        const sortedNames = names.toSorted();
+        if (!withFileTypes) {
+            return sortedNames;
+        }
+        const entries = [];
+        for (const name of sortedNames) {
+            entries.push({
+                name,
+                ...pathStatFromStats(await promises_.lstat(external_node_path_.join(resolved.resolved, name))),
+            });
+        }
+        return entries;
+    }
+    catch (error) {
+        if (path_isNotFoundPathError(error)) {
+            throw new errors_FsSafeError("not-found", "directory not found", {
+                cause: error instanceof Error ? error : undefined,
+            });
+        }
+        throw error;
+    }
+}
+async function movePathFallback(root, params) {
+    const source = await resolvePathInRoot(root, params.fromRelative);
+    await resolvePinnedRootPathInRoot(root, {
+        relativePath: params.fromRelative,
+        policy: PATH_ALIAS_POLICIES.strict,
+    });
+    const target = await resolvePathInRoot(root, params.toRelative);
+    await resolvePinnedRootPathInRoot(root, {
+        relativePath: params.toRelative,
+        policy: PATH_ALIAS_POLICIES.unlinkTarget,
+    });
+    try {
+        await assertNoPathAliasEscape({
+            absolutePath: target.resolved,
+            rootPath: target.rootReal,
+            boundaryLabel: "root",
+        });
+    }
+    catch (error) {
+        throw new errors_FsSafeError("path-alias", "path alias escape blocked", {
+            cause: error instanceof Error ? error : undefined,
+        });
+    }
+    let sourceStat;
+    try {
+        sourceStat = await promises_.lstat(source.resolved);
+    }
+    catch (error) {
+        if (path_isNotFoundPathError(error)) {
+            throw new errors_FsSafeError("not-found", "file not found", {
+                cause: error instanceof Error ? error : undefined,
+            });
+        }
+        throw error;
+    }
+    if (sourceStat.isSymbolicLink()) {
+        throw new errors_FsSafeError("symlink", "symlink not allowed");
+    }
+    if (sourceStat.isFile() && sourceStat.nlink > 1) {
+        throw new errors_FsSafeError("hardlink", "hardlinked path not allowed");
+    }
+    if (!params.overwrite) {
+        try {
+            await promises_.lstat(target.resolved);
+            throw new errors_FsSafeError("already-exists", "destination exists");
+        }
+        catch (error) {
+            if (error instanceof errors_FsSafeError) {
+                throw error;
+            }
+            if (!path_isNotFoundPathError(error)) {
+                throw error;
+            }
+        }
+    }
+    const sourceParentGuard = await directory_guard_createAsyncDirectoryGuard(external_node_path_.dirname(source.resolved));
+    const targetParentGuard = await directory_guard_createNearestExistingDirectoryGuard(target.rootReal, external_node_path_.dirname(target.resolved));
+    await getFsSafeTestHooks()?.beforeRootFallbackMutation?.("move", target.resolved);
+    await assertAsyncDirectoryGuard(sourceParentGuard);
+    await assertAsyncDirectoryGuard(targetParentGuard);
+    try {
+        await promises_.rename(source.resolved, target.resolved);
+    }
+    catch (error) {
+        if (path_isNotFoundPathError(error)) {
+            throw new errors_FsSafeError("not-found", "file not found", {
+                cause: error instanceof Error ? error : undefined,
+            });
+        }
+        if (hasNodeErrorCode(error, "EEXIST")) {
+            throw new errors_FsSafeError("already-exists", "destination exists", {
+                cause: error instanceof Error ? error : undefined,
+            });
+        }
+        throw error;
+    }
+    await assertAsyncDirectoryGuard(targetParentGuard).catch(() => undefined);
+}
+async function writeFileFallback(root, params) {
+    if (params.overwrite === false) {
+        await writeMissingFileFallback(root, params);
+        return;
+    }
+    const target = await openWritableFileInRoot(root, {
+        relativePath: params.relativePath,
+        mkdir: params.mkdir,
+        mode: params.mode,
+        truncateExisting: false,
+    });
+    const destinationPath = target.realPath;
+    const mode = params.mode ?? (target.stat.mode & 0o777);
+    await target.handle.close().catch(() => { });
+    const destinationGuard = await directory_guard_createAsyncDirectoryGuard(external_node_path_.dirname(destinationPath));
+    let tempPath = null;
+    let unregisterTempPath = null;
+    try {
+        tempPath = buildAtomicWriteTempPath(destinationPath);
+        unregisterTempPath = registerTempPathForExit(tempPath);
+        const writtenStat = await writeTempFileForAtomicReplace({
+            tempPath,
+            data: params.data,
+            encoding: params.encoding,
+            mode: mode || 0o600,
+        });
+        const commitTempPath = tempPath;
+        await withAsyncDirectoryGuards([destinationGuard], async () => {
+            await promises_.rename(commitTempPath, destinationPath);
+        });
+        tempPath = null;
+        unregisterTempPath();
+        unregisterTempPath = null;
+        try {
+            await verifyAtomicWriteResult({
+                root,
+                targetPath: destinationPath,
+                expectedIdentity: writtenStat,
+            });
+        }
+        catch (err) {
+            emitWriteBoundaryWarning(`post-write verification failed: ${String(err)}`);
+            throw err;
+        }
+    }
+    finally {
+        if (tempPath) {
+            await promises_.rm(tempPath, { force: true }).catch(() => { });
+        }
+        unregisterTempPath?.();
+    }
+}
+async function writeMissingFileFallback(root, params) {
+    const { rootReal, resolved } = await resolvePathInRoot(root, params.relativePath);
+    try {
+        await assertNoPathAliasEscape({
+            absolutePath: resolved,
+            rootPath: rootReal,
+            boundaryLabel: "root",
+        });
+    }
+    catch (err) {
+        throw new errors_FsSafeError("path-alias", "path alias escape blocked", { cause: err });
+    }
+    if (params.mkdir !== false) {
+        await promises_.mkdir(external_node_path_.dirname(resolved), { recursive: true });
+    }
+    const parentGuard = await directory_guard_createAsyncDirectoryGuard(external_node_path_.dirname(resolved));
+    let created = false;
+    try {
+        const { handle, writtenStat } = await withAsyncDirectoryGuards([parentGuard], async () => {
+            const handle = await promises_.open(resolved, OPEN_WRITE_CREATE_FLAGS, params.mode ?? 0o600);
+            created = true;
+            try {
+                if (typeof params.data === "string") {
+                    await handle.writeFile(params.data, params.encoding ?? "utf8");
+                }
+                else {
+                    await handle.writeFile(params.data);
+                }
+                return { handle, writtenStat: await handle.stat() };
+            }
+            catch (error) {
+                await handle.close().catch(() => undefined);
+                throw error;
+            }
+        }, {
+            onPostGuardFailure: async ({ handle }) => {
+                created = false; // Parent is untrusted now; skip outer path cleanup by name.
+                await handle.close().catch(() => undefined);
+            },
+        });
+        await handle.close();
+        await verifyAtomicWriteResult({
+            root,
+            targetPath: resolved,
+            expectedIdentity: writtenStat,
+        });
+        created = false;
+    }
+    catch (err) {
+        if (hasNodeErrorCode(err, "EEXIST")) {
+            throw new errors_FsSafeError("already-exists", "file already exists", {
+                cause: err instanceof Error ? err : undefined,
+            });
+        }
+        throw err;
+    }
+    finally {
+        if (created) {
+            await promises_.rm(resolved, { force: true }).catch(() => undefined);
+        }
+    }
+}
+async function copyFileFallback(root, params, source) {
+    let target = null;
+    let sourceClosedByStream = false;
+    let targetClosedByUs = false;
+    let tempHandle = null;
+    let tempPath = null;
+    let unregisterTempPath = null;
+    let tempClosedByStream = false;
+    try {
+        target = await openWritableFileInRoot(root, {
+            relativePath: params.relativePath,
+            mkdir: params.mkdir,
+            mode: params.mode,
+            truncateExisting: false,
+        });
+        const destinationPath = target.realPath;
+        const mode = params.mode ?? (target.stat.mode & 0o777);
+        await target.handle.close().catch(() => { });
+        targetClosedByUs = true;
+        const destinationGuard = await directory_guard_createAsyncDirectoryGuard(external_node_path_.dirname(destinationPath));
+        tempPath = buildAtomicWriteTempPath(destinationPath);
+        unregisterTempPath = registerTempPathForExit(tempPath);
+        tempHandle = await promises_.open(tempPath, OPEN_WRITE_CREATE_FLAGS, mode || 0o600);
+        const sourceStream = createBoundedReadStream(source, params.maxBytes);
+        const targetStream = tempHandle.createWriteStream();
+        sourceStream.once("close", () => {
+            sourceClosedByStream = true;
+        });
+        targetStream.once("close", () => {
+            tempClosedByStream = true;
+        });
+        await (0,external_node_stream_promises_.pipeline)(sourceStream, targetStream);
+        const writtenStat = await promises_.stat(tempPath);
+        if (!tempClosedByStream) {
+            await tempHandle.close().catch(() => { });
+            tempClosedByStream = true;
+        }
+        tempHandle = null;
+        const commitTempPath = tempPath;
+        await withAsyncDirectoryGuards([destinationGuard], async () => {
+            await promises_.rename(commitTempPath, destinationPath);
+        });
+        tempPath = null;
+        unregisterTempPath();
+        unregisterTempPath = null;
+        try {
+            await verifyAtomicWriteResult({
+                root,
+                targetPath: destinationPath,
+                expectedIdentity: writtenStat,
+            });
+        }
+        catch (err) {
+            emitWriteBoundaryWarning(`post-copy verification failed: ${String(err)}`);
+            throw err;
+        }
+    }
+    catch (err) {
+        if (target?.createdForWrite) {
+            await promises_.rm(target.realPath, { force: true }).catch(() => { });
+        }
+        throw err;
+    }
+    finally {
+        if (!sourceClosedByStream) {
+            await source.handle.close().catch(() => { });
+        }
+        if (tempHandle && !tempClosedByStream) {
+            await tempHandle.close().catch(() => { });
+        }
+        if (tempPath) {
+            await promises_.rm(tempPath, { force: true }).catch(() => { });
+        }
+        unregisterTempPath?.();
+        if (target && !targetClosedByUs) {
+            await target.handle.close().catch(() => { });
+        }
+    }
 }
-/**
- * List of known action names for convenience
- */ const KNOWN_ACTIONS = Object.keys(DEFAULT_ACTION_VERSIONS);
 
-// EXTERNAL MODULE: external "node:fs"
-var external_node_fs_ = __webpack_require__(3024);
 ;// CONCATENATED MODULE: ../core/src/gateways/file-system-utils.ts
 /**
  * Shared file system utilities for gateways.
  */ 
 
 
+
 /**
  * Checks if a file or directory exists.
  */ async function file_system_utils_fileExists(path) {
@@ -26547,9 +30162,92 @@ var external_node_fs_ = __webpack_require__(3024);
 function isPathWithinRoot(rootPath, candidatePath) {
     return candidatePath === rootPath || candidatePath.startsWith(`${rootPath}${external_node_path_.sep}`);
 }
+function mapFsSafeError(error, relativePath) {
+    if (error instanceof errors_FsSafeError) {
+        switch(error.code){
+            case "outside-workspace":
+            case "invalid-path":
+                throw new Error(`Resolved path is outside target directory: ${relativePath}`, {
+                    cause: error
+                });
+            case "path-alias":
+            case "symlink":
+                throw new Error(`Symlinks are not allowed: path contains symbolic link: ${relativePath}`, {
+                    cause: error
+                });
+            case "too-large":
+                throw new Error(`File ${relativePath} exceeds size limit: ${error.message}`, {
+                    cause: error
+                });
+            default:
+                throw error;
+        }
+    }
+    throw error;
+}
+async function createSafeRoot(targetDir, maxBytes) {
+    return root_impl_root(targetDir, {
+        hardlinks: "reject",
+        maxBytes,
+        symlinks: "reject"
+    });
+}
+async function file_system_utils_readTextWithinRoot(targetDir, relativePath, maxBytes) {
+    try {
+        const safeRoot = await createSafeRoot(targetDir, maxBytes);
+        return await safeRoot.readText(relativePath, {
+            maxBytes
+        });
+    } catch (error) {
+        mapFsSafeError(error, relativePath);
+    }
+}
+async function file_system_utils_listDirectoryWithinRoot(targetDir, relativePath) {
+    try {
+        const safeRoot = await createSafeRoot(targetDir);
+        const entries = await safeRoot.list(relativePath, {
+            withFileTypes: true
+        });
+        return entries.map(toSafeDirEntry);
+    } catch (error) {
+        mapFsSafeError(error, relativePath);
+    }
+}
+function toSafeDirEntry(entry) {
+    return {
+        name: entry.name,
+        isDirectory: ()=>entry.isDirectory,
+        isFile: ()=>entry.isFile,
+        isSymbolicLink: ()=>entry.isSymbolicLink
+    };
+}
+async function file_system_utils_pathExistsWithinRoot(targetDir, relativePath) {
+    try {
+        const safeRoot = await createSafeRoot(targetDir);
+        return await safeRoot.exists(relativePath);
+    } catch (error) {
+        mapFsSafeError(error, relativePath);
+    }
+}
+/**
+ * Returns true if the error originated from an fs-safe security check
+ * (symlink, traversal, or size-limit violation). These errors carry a
+ * 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 errors_FsSafeError;
+}
+async function file_system_utils_statWithinRoot(targetDir, relativePath) {
+    try {
+        const safeRoot = await createSafeRoot(targetDir);
+        return await safeRoot.stat(relativePath);
+    } catch (error) {
+        mapFsSafeError(error, relativePath);
+    }
+}
 /**
  * Resolves a relative path under targetDir and rejects traversal outside the root.
- */ async function resolvePathWithinRoot(targetDir, relativePath) {
+ */ async function file_system_utils_resolvePathWithinRoot(targetDir, relativePath) {
     if (!relativePath) {
         throw new Error("Path must not be empty");
     }
@@ -26591,14 +30289,14 @@ function isPathWithinRoot(rootPath, candidatePath) {
 /**
  * Resolves a relative path under targetDir and validates it does not pass through symlinks.
  */ async function file_system_utils_resolveSafePath(targetDir, relativePath) {
-    const resolvedPath = await resolvePathWithinRoot(targetDir, relativePath);
+    const resolvedPath = await file_system_utils_resolvePathWithinRoot(targetDir, relativePath);
     await file_system_utils_assertPathHasNoSymbolicLinks(targetDir, resolvedPath);
     return resolvedPath;
 }
 /**
  * Enforces a maximum file size before reading/parsing.
- */ async function file_system_utils_assertFileSizeWithinLimit(filePath, maxBytes, context) {
-    const fileStats = await (0,promises_.stat)(filePath);
+ */ async function assertFileSizeWithinLimit(filePath, maxBytes, context) {
+    const fileStats = await stat(filePath);
     if (fileStats.size > maxBytes) {
         throw new Error(`${context} exceeds size limit (${fileStats.size} bytes > ${maxBytes} bytes)`);
     }
@@ -26684,16 +30382,17 @@ function isPathWithinRoot(rootPath, candidatePath) {
  * Handles reading and writing .claude/settings.json and CLAUDE.md files.
  */ 
 
+const MAX_CLAUDE_SETTINGS_BYTES = 1_048_576;
+const MAX_CLAUDE_DOC_BYTES = 1_048_576;
 /**
  * File system implementation of ClaudeFileGateway
  */ class FileSystemClaudeFileGateway {
     async readSettings(targetDir) {
-        const settingsPath = await file_system_utils_resolveSafePath(targetDir, ".claude/settings.json");
-        if (!await file_system_utils_fileExists(settingsPath)) {
+        if (!await file_system_utils_pathExistsWithinRoot(targetDir, ".claude/settings.json")) {
             return null;
         }
+        const content = await file_system_utils_readTextWithinRoot(targetDir, ".claude/settings.json", MAX_CLAUDE_SETTINGS_BYTES);
         try {
-            const content = await (0,promises_.readFile)(settingsPath, "utf-8");
             return JSON.parse(content);
         } catch  {
             // If JSON parsing fails, treat as if file doesn't exist
@@ -26712,11 +30411,10 @@ function isPathWithinRoot(rootPath, candidatePath) {
         await (0,promises_.writeFile)(settingsPath, content, "utf-8");
     }
     async readDocumentation(targetDir) {
-        const docPath = await file_system_utils_resolveSafePath(targetDir, "CLAUDE.md");
-        if (!await file_system_utils_fileExists(docPath)) {
+        if (!await file_system_utils_pathExistsWithinRoot(targetDir, "CLAUDE.md")) {
             return null;
         }
-        return (0,promises_.readFile)(docPath, "utf-8");
+        return file_system_utils_readTextWithinRoot(targetDir, "CLAUDE.md", MAX_CLAUDE_DOC_BYTES);
     }
     async writeDocumentation(targetDir, content) {
         const docPath = await file_system_utils_resolveSafePath(targetDir, "CLAUDE.md");
@@ -26779,7 +30477,7 @@ const _ROOT_FOLDER_RE = /^\/([A-Za-z]:)?$/;
 const _EXTNAME_RE = /.(\.[^./]+|\.)$/;
 const _PATH_ROOT_RE = /^[/\\]|^[a-zA-Z]:[/\\]/;
 const pathe_M_eThtNZ_sep = "/";
-const normalize = function(path) {
+const pathe_M_eThtNZ_normalize = function(path) {
   if (path.length === 0) {
     return ".";
   }
@@ -26827,7 +30525,7 @@ const pathe_M_eThtNZ_join = function(...segments) {
       path += seg;
     }
   }
-  return normalize(path);
+  return pathe_M_eThtNZ_normalize(path);
 };
 function pathe_M_eThtNZ_cwd() {
   if (typeof process !== "undefined" && typeof process.cwd === "function") {
@@ -26980,7 +30678,7 @@ const pathe_M_eThtNZ_parse = function(p) {
   };
 };
 const matchesGlob = (path, pattern) => {
-  return zeptomatch(pattern, normalize(path));
+  return zeptomatch(pattern, pathe_M_eThtNZ_normalize(path));
 };
 
 const pathe_M_eThtNZ_path = (/* unused pure expression or super */ null && ({
@@ -26992,7 +30690,7 @@ const pathe_M_eThtNZ_path = (/* unused pure expression or super */ null && ({
   isAbsolute: pathe_M_eThtNZ_isAbsolute,
   join: pathe_M_eThtNZ_join,
   matchesGlob: matchesGlob,
-  normalize: normalize,
+  normalize: pathe_M_eThtNZ_normalize,
   normalizeString: normalizeString,
   parse: pathe_M_eThtNZ_parse,
   relative: pathe_M_eThtNZ_relative,
@@ -27007,8 +30705,6 @@ const pathe_M_eThtNZ_path = (/* unused pure expression or super */ null && ({
 var lib_main = __webpack_require__(5599);
 // EXTERNAL MODULE: external "node:url"
 var external_node_url_ = __webpack_require__(3136);
-// EXTERNAL MODULE: external "node:os"
-var external_node_os_ = __webpack_require__(8161);
 // EXTERNAL MODULE: external "node:assert"
 var external_node_assert_ = __webpack_require__(4589);
 // EXTERNAL MODULE: external "node:v8"
@@ -28545,8 +32241,8 @@ function findFarthestFile(filename, options = {}) {
 	});
 }
 function _resolvePath(id, opts = {}) {
-	if (id instanceof URL || id.startsWith("file://")) return normalize((0,external_node_url_.fileURLToPath)(id));
-	if (pathe_M_eThtNZ_isAbsolute(id)) return normalize(id);
+	if (id instanceof URL || id.startsWith("file://")) return pathe_M_eThtNZ_normalize((0,external_node_url_.fileURLToPath)(id));
+	if (pathe_M_eThtNZ_isAbsolute(id)) return pathe_M_eThtNZ_normalize(id);
 	return resolveModulePath(id, {
 		...opts,
 		from: opts.from || opts.parent || opts.url
@@ -29155,7 +32851,7 @@ function tryResolve(id, options) {
 		extensions: SUPPORTED_EXTENSIONS,
 		cache: false
 	});
-	return res ? normalize(res) : void 0;
+	return res ? pathe_M_eThtNZ_normalize(res) : void 0;
 }
 //#endregion
 //#region src/types.ts
@@ -29603,11 +33299,9 @@ const CopilotSetupConfigSchema = schemas_object({
 
 
 
-
 const MAX_VERSION_FILE_BYTES = 16 * 1024;
-async function readVersionFileContent(filePath) {
-    await file_system_utils_assertFileSizeWithinLimit(filePath, MAX_VERSION_FILE_BYTES, `Version file '${filePath}'`);
-    const content = await (0,promises_.readFile)(filePath, "utf-8");
+async function readVersionFileContent(targetDir, relativePath) {
+    const content = await file_system_utils_readTextWithinRoot(targetDir, relativePath, MAX_VERSION_FILE_BYTES);
     return content.trim();
 }
 /**
@@ -29636,16 +33330,14 @@ async function readVersionFileContent(filePath) {
         };
     }
     async detectMise(targetDir) {
-        const miseTomlPath = await file_system_utils_resolveSafePath(targetDir, "mise.toml");
-        return file_system_utils_fileExists(miseTomlPath);
+        return file_system_utils_pathExistsWithinRoot(targetDir, "mise.toml");
     }
     async detectVersionFiles(targetDir, config) {
         const filenameToType = getVersionFilenameToTypeMap(config);
         const versionFiles = [];
         for (const fileConfig of config.versionFiles){
-            const filePath = await file_system_utils_resolveSafePath(targetDir, fileConfig.filename);
-            if (await file_system_utils_fileExists(filePath)) {
-                const version = await readVersionFileContent(filePath);
+            if (await file_system_utils_pathExistsWithinRoot(targetDir, fileConfig.filename)) {
+                const version = await readVersionFileContent(targetDir, fileConfig.filename);
                 versionFiles.push({
                     type: filenameToType[fileConfig.filename],
                     filename: fileConfig.filename,
@@ -29674,8 +33366,7 @@ async function readVersionFileContent(filePath) {
         return packageManagers;
     }
     async detectNodePackageManager(targetDir, nodePackageManagers) {
-        const packageJsonPath = await file_system_utils_resolveSafePath(targetDir, "package.json");
-        if (!await file_system_utils_fileExists(packageJsonPath)) {
+        if (!await file_system_utils_pathExistsWithinRoot(targetDir, "package.json")) {
             return null;
         }
         const lockfileOrder = [
@@ -29688,8 +33379,7 @@ async function readVersionFileContent(filePath) {
             if (!pmConfig?.lockfile) {
                 continue;
             }
-            const lockfilePath = await file_system_utils_resolveSafePath(targetDir, pmConfig.lockfile);
-            if (await file_system_utils_fileExists(lockfilePath)) {
+            if (await file_system_utils_pathExistsWithinRoot(targetDir, pmConfig.lockfile)) {
                 return {
                     type: pmConfig.type,
                     filename: pmConfig.manifestFile,
@@ -29713,10 +33403,9 @@ async function readVersionFileContent(filePath) {
             if (!pmConfig) {
                 continue;
             }
-            const manifestPath = await file_system_utils_resolveSafePath(targetDir, pmConfig.manifestFile);
-            if (await file_system_utils_fileExists(manifestPath)) {
+            if (await file_system_utils_pathExistsWithinRoot(targetDir, pmConfig.manifestFile)) {
                 const lockfilePath = pmConfig.lockfile ? await file_system_utils_resolveSafePath(targetDir, pmConfig.lockfile) : undefined;
-                const hasLockfile = lockfilePath ? await file_system_utils_fileExists(lockfilePath) : false;
+                const hasLockfile = lockfilePath ? await file_system_utils_pathExistsWithinRoot(targetDir, pmConfig.lockfile) : false;
                 if (pmConfig.requiresLockfile && !hasLockfile) {
                     continue;
                 }
@@ -29732,10 +33421,9 @@ async function readVersionFileContent(filePath) {
     async detectOtherPackageManagers(targetDir, otherPackageManagers) {
         const packageManagers = [];
         for (const pmConfig of otherPackageManagers){
-            const manifestPath = await file_system_utils_resolveSafePath(targetDir, pmConfig.manifestFile);
-            if (await file_system_utils_fileExists(manifestPath)) {
+            if (await file_system_utils_pathExistsWithinRoot(targetDir, pmConfig.manifestFile)) {
                 const lockfilePath = pmConfig.lockfile ? await file_system_utils_resolveSafePath(targetDir, pmConfig.lockfile) : undefined;
-                const hasLockfile = lockfilePath ? await file_system_utils_fileExists(lockfilePath) : false;
+                const hasLockfile = lockfilePath ? await file_system_utils_pathExistsWithinRoot(targetDir, pmConfig.lockfile) : false;
                 if (pmConfig.requiresLockfile && !hasLockfile) {
                     continue;
                 }
@@ -29756,8 +33444,6 @@ async function readVersionFileContent(filePath) {
     return new FileSystemEnvironmentGateway(cwd);
 }
 
-// EXTERNAL MODULE: external "node:child_process"
-var external_node_child_process_ = __webpack_require__(1421);
 ;// CONCATENATED MODULE: ../core/src/gateways/github-ruleset-gateway.ts
 /**
  * Gateway for interacting with GitHub repository rulesets via Octokit.
@@ -29936,8 +33622,6 @@ function defaultExec(command, args, options) {
     return new OctokitRulesetGateway(octokit);
 }
 
-// EXTERNAL MODULE: external "node:crypto"
-var external_node_crypto_ = __webpack_require__(7598);
 ;// CONCATENATED MODULE: ../core/src/gateways/init-hooks-config-gateway.ts
 
 
@@ -30175,7 +33859,7 @@ function createInitHooksConfigGateway() {
  * Gateway for analyzing repository instructions for feedback loop coverage
  */ 
 
-
+const MAX_INSTRUCTION_FILE_BYTES = 1_048_576;
 /**
  * File system implementation of instruction analysis gateway
  */ class FileSystemInstructionAnalysisGateway {
@@ -30184,17 +33868,17 @@ function createInitHooksConfigGateway() {
         const references = [];
         const documentedTargets = new Set();
         for (const file of instructionFiles){
-            const content = await (0,promises_.readFile)(file, "utf-8");
+            const content = await file_system_utils_readTextWithinRoot(targetDir, file, MAX_INSTRUCTION_FILE_BYTES);
             const lines = content.split("\n");
             for (const script of scripts){
-                const scriptRefs = this.findReferencesInContent(script.name, content, lines, file, targetDir);
+                const scriptRefs = this.findReferencesInContent(script.name, content, lines, (0,external_node_path_.join)(targetDir, file), targetDir);
                 if (scriptRefs.length > 0) {
                     references.push(...scriptRefs);
                     documentedTargets.add(script.name);
                 }
             }
             for (const tool of tools){
-                const toolRefs = this.findReferencesInContent(tool.name, content, lines, file, targetDir);
+                const toolRefs = this.findReferencesInContent(tool.name, content, lines, (0,external_node_path_.join)(targetDir, file), targetDir);
                 if (toolRefs.length > 0) {
                     references.push(...toolRefs);
                     documentedTargets.add(tool.name);
@@ -30223,19 +33907,26 @@ function createInitHooksConfigGateway() {
             }
         };
     }
+    async safePathExists(targetDir, relativePath) {
+        try {
+            return await file_system_utils_pathExistsWithinRoot(targetDir, relativePath);
+        } catch  {
+            return false;
+        }
+    }
     async findInstructionFiles(targetDir) {
         const files = [];
-        const copilotInstructions = (0,external_node_path_.join)(targetDir, ".github", "copilot-instructions.md");
-        if (await file_system_utils_fileExists(copilotInstructions)) {
+        const copilotInstructions = (0,external_node_path_.join)(".github", "copilot-instructions.md");
+        if (await this.safePathExists(targetDir, copilotInstructions)) {
             files.push(copilotInstructions);
         }
-        const instructionsDir = (0,external_node_path_.join)(targetDir, ".github", "instructions");
-        if (await file_system_utils_fileExists(instructionsDir)) {
+        const instructionsDir = (0,external_node_path_.join)(".github", "instructions");
+        if (await this.safePathExists(targetDir, instructionsDir)) {
             try {
-                const instructionFiles = await (0,promises_.readdir)(instructionsDir);
+                const instructionFiles = await file_system_utils_listDirectoryWithinRoot(targetDir, instructionsDir);
                 for (const file of instructionFiles){
-                    if (file.endsWith(".md")) {
-                        files.push((0,external_node_path_.join)(instructionsDir, file));
+                    if (file.isFile() && file.name.endsWith(".md")) {
+                        files.push((0,external_node_path_.join)(instructionsDir, file.name));
                     }
                 }
             } catch  {}
@@ -30390,7 +34081,6 @@ const lesson_schema_LessonFrontmatterSchema = schemas_object({
 
 
 
-
 const MAX_LESSON_FILE_BYTES = 1_048_576; // 1 MB
 const MAX_LESSON_FILES = 500;
 const MAX_AGGREGATE_BYTES = (/* unused pure expression or super */ null && (20 * 1024 * 1024)); // 20 MB
@@ -30420,12 +34110,16 @@ const LESSONS_RELATIVE_PATH = (0,external_node_path_.join)(".lousy-agents", "les
 }
 class LessonFileGateway {
     async readLessons(rootDir) {
-        const realRootDir = await realpath(rootDir);
-        const lessonsDir = join(realRootDir, LESSONS_RELATIVE_PATH);
-        await assertPathHasNoSymbolicLinks(realRootDir, lessonsDir);
-        let dirStat;
+        const lessonsDir = join(rootDir, LESSONS_RELATIVE_PATH);
+        if (!await pathExistsWithinRoot(rootDir, LESSONS_RELATIVE_PATH)) {
+            return {
+                lessons: [],
+                errors: []
+            };
+        }
+        let lessonsStat;
         try {
-            dirStat = await lstat(lessonsDir);
+            lessonsStat = await statWithinRoot(rootDir, LESSONS_RELATIVE_PATH);
         } catch (error) {
             if (error instanceof Error && "code" in error && error.code === "ENOENT") {
                 return {
@@ -30435,14 +34129,12 @@ class LessonFileGateway {
             }
             throw error;
         }
-        if (!dirStat.isDirectory()) {
+        if (!lessonsStat.isDirectory) {
             throw new Error(`Lessons path exists but is not a directory: ${lessonsDir}`);
         }
         let entries;
         try {
-            entries = await readdir(lessonsDir, {
-                withFileTypes: true
-            });
+            entries = await listDirectoryWithinRoot(rootDir, LESSONS_RELATIVE_PATH);
         } catch (error) {
             const reason = error instanceof Error ? error.message : String(error);
             const wrapped = new Error(`Cannot read lessons directory ${lessonsDir}: ${reason}`);
@@ -30453,7 +34145,7 @@ class LessonFileGateway {
             }
             throw wrapped;
         }
-        const mdFiles = entries.filter((e)=>e.isFile() && e.name.endsWith(".md")).map((e)=>join(lessonsDir, e.name)).sort();
+        const mdFiles = entries.filter((e)=>e.isFile() && e.name.endsWith(".md")).map((e)=>join(LESSONS_RELATIVE_PATH, e.name)).sort();
         if (mdFiles.length > MAX_LESSON_FILES) {
             throw new Error(`Lesson file count exceeds limit: ${mdFiles.length} files found (max ${MAX_LESSON_FILES})`);
         }
@@ -30461,13 +34153,14 @@ class LessonFileGateway {
         const errors = [];
         let aggregateBytes = 0;
         for (const filePath of mdFiles){
+            const absoluteFilePath = join(rootDir, filePath);
             let content;
             try {
-                content = await readFileNoFollow(filePath, MAX_LESSON_FILE_BYTES);
+                content = await readTextWithinRoot(rootDir, filePath, MAX_LESSON_FILE_BYTES);
             } catch (error) {
                 const reason = error instanceof Error ? error.message : String(error);
                 errors.push({
-                    filePath,
+                    filePath: absoluteFilePath,
                     reason
                 });
                 continue;
@@ -30481,7 +34174,7 @@ class LessonFileGateway {
             if (!parseResult.ok) {
                 const reason = parseResult.reason === "invalid" ? `Invalid YAML frontmatter: ${parseResult.detail}` : "Missing YAML frontmatter";
                 errors.push({
-                    filePath,
+                    filePath: absoluteFilePath,
                     reason
                 });
                 continue;
@@ -30490,7 +34183,7 @@ class LessonFileGateway {
             if (!schemaResult.success) {
                 const reason = schemaResult.error.issues.map((i)=>`${i.path.join(".")}: ${i.message}`).join("; ");
                 errors.push({
-                    filePath,
+                    filePath: absoluteFilePath,
                     reason
                 });
                 continue;
@@ -30513,7 +34206,7 @@ class LessonFileGateway {
             };
             lessons.push({
                 lesson,
-                filePath
+                filePath: absoluteFilePath
             });
         }
         return {
@@ -31123,11 +34816,11 @@ var external_node_tty_namespaceObject = /*#__PURE__*/__webpack_require__.t(exter
 const {
   env: consola_DXBYu_KD_env = {},
   argv = [],
-  platform = ""
+  platform: consola_DXBYu_KD_platform = ""
 } = typeof process === "undefined" ? {} : process;
 const isDisabled = "NO_COLOR" in consola_DXBYu_KD_env || argv.includes("--no-color");
 const isForced = "FORCE_COLOR" in consola_DXBYu_KD_env || argv.includes("--color");
-const consola_DXBYu_KD_isWindows = platform === "win32";
+const consola_DXBYu_KD_isWindows = consola_DXBYu_KD_platform === "win32";
 const isDumbTerminal = consola_DXBYu_KD_env.TERM === "dumb";
 const isCompatibleTerminal = external_node_tty_namespaceObject && external_node_tty_.isatty && external_node_tty_.isatty(1) && consola_DXBYu_KD_env.TERM && !isDumbTerminal;
 const isCI = "CI" in consola_DXBYu_KD_env && ("GITHUB_ACTIONS" in consola_DXBYu_KD_env || "GITLAB_CI" in consola_DXBYu_KD_env || "CIRCLECI" in consola_DXBYu_KD_env);
@@ -32077,12 +35770,10 @@ const MAX_NPMRC_BYTES = (/* unused pure expression or super */ null && (64 * 102
         this.dryRun = dryRun;
     }
     async readNpmrc(targetDir) {
-        const npmrcPath = await resolveSafePath(targetDir, ".npmrc");
-        if (!await fileExists(npmrcPath)) {
+        if (!await pathExistsWithinRoot(targetDir, ".npmrc")) {
             return null;
         }
-        await assertFileSizeWithinLimit(npmrcPath, MAX_NPMRC_BYTES, "`.npmrc` file");
-        return readFile(npmrcPath, "utf-8");
+        return readTextWithinRoot(targetDir, ".npmrc", MAX_NPMRC_BYTES);
     }
     async writeNpmrc(targetDir, content) {
         const npmrcPath = await resolveSafePath(targetDir, ".npmrc");
@@ -32341,7 +36032,6 @@ 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.
@@ -32356,30 +36046,22 @@ const PackageJsonSchema = schemas_object({
     async discoverSkills(targetDir) {
         const skills = [];
         for (const relativeDir of SKILL_DIRECTORIES){
-            const skillsDir = join(targetDir, relativeDir);
-            const discovered = await this.discoverSkillsInDir(skillsDir);
+            const discovered = await this.discoverSkillsInDir(targetDir, relativeDir);
             skills.push(...discovered);
         }
         return skills;
     }
-    async discoverSkillsInDir(skillsDir) {
-        let dirStats;
+    async discoverSkillsInDir(targetDir, skillsDir) {
         try {
-            dirStats = await lstat(skillsDir);
-        } catch (error) {
-            if (error instanceof Error && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR")) {
+            if (!await pathExistsWithinRoot(targetDir, skillsDir)) {
                 return [];
             }
-            throw error;
-        }
-        if (dirStats.isSymbolicLink() || !dirStats.isDirectory()) {
+        } catch  {
             return [];
         }
         let entries;
         try {
-            entries = await readdir(skillsDir, {
-                withFileTypes: true
-            });
+            entries = await listDirectoryWithinRoot(targetDir, skillsDir);
         } catch (error) {
             if (error instanceof Error && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR")) {
                 return [];
@@ -32394,20 +36076,16 @@ const PackageJsonSchema = schemas_object({
             if (entry.name.includes("..") || entry.name.includes("/") || entry.name.includes("\\")) {
                 continue;
             }
-            const skillFilePath = join(skillsDir, entry.name, "SKILL.md");
-            let skillStat;
+            const skillRelativePath = join(skillsDir, entry.name, "SKILL.md");
+            let hasSkillFile = false;
             try {
-                skillStat = await lstat(skillFilePath);
-            } catch (error) {
-                if (error instanceof Error && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR")) {
-                    skillStat = null;
-                } else {
-                    throw error;
-                }
+                hasSkillFile = await pathExistsWithinRoot(targetDir, skillRelativePath);
+            } catch  {
+                hasSkillFile = false;
             }
-            if (skillStat && !skillStat.isSymbolicLink() && skillStat.isFile()) {
+            if (hasSkillFile) {
                 skills.push({
-                    filePath: skillFilePath,
+                    filePath: join(targetDir, skillRelativePath),
                     skillName: entry.name
                 });
             }
@@ -32434,26 +36112,30 @@ const PackageJsonSchema = schemas_object({
 
 
 
-
+const MAX_WORKFLOW_FILE_BYTES = 1_048_576;
 /**
  * File system implementation of tool discovery gateway
  */ class FileSystemToolDiscoveryGateway {
     async discoverTools(targetDir) {
-        const workflowsDir = (0,external_node_path_.join)(targetDir, ".github", "workflows");
-        if (!await file_system_utils_fileExists(workflowsDir)) {
+        const workflowsDir = (0,external_node_path_.join)(".github", "workflows");
+        if (!await file_system_utils_pathExistsWithinRoot(targetDir, workflowsDir)) {
             return [];
         }
-        const files = await (0,promises_.readdir)(workflowsDir);
-        const yamlFiles = files.filter((f)=>f.endsWith(".yml") || f.endsWith(".yaml"));
+        const files = await file_system_utils_listDirectoryWithinRoot(targetDir, workflowsDir);
+        const yamlFiles = files.filter((f)=>f.isFile() && (f.name.endsWith(".yml") || f.name.endsWith(".yaml")));
         const allTools = [];
         for (const file of yamlFiles){
-            const filePath = (0,external_node_path_.join)(workflowsDir, file);
+            const filePath = (0,external_node_path_.join)(workflowsDir, file.name);
             try {
-                const content = await (0,promises_.readFile)(filePath, "utf-8");
+                const content = await file_system_utils_readTextWithinRoot(targetDir, filePath, MAX_WORKFLOW_FILE_BYTES);
                 const workflow = (0,yaml_dist/* .parse */.qg)(content);
-                const tools = this.extractToolsFromWorkflow(workflow, file);
+                const tools = this.extractToolsFromWorkflow(workflow, file.name);
                 allTools.push(...tools);
-            } catch  {}
+            } catch (error) {
+                if (isFsSafeViolation(error)) {
+                    throw error;
+                }
+            }
         }
         return this.deduplicateTools(allTools);
     }
@@ -32768,7 +36450,7 @@ const COPILOT_SETUP_WORKFLOW_FILENAMES = [
     "copilot-setup-steps.yml",
     "copilot-setup-steps.yaml"
 ];
-const MAX_WORKFLOW_FILE_BYTES = 1024 * 1024;
+const file_system_workflow_gateway_MAX_WORKFLOW_FILE_BYTES = 1024 * 1024;
 class FileSystemWorkflowGateway {
     cwd;
     config = null;
@@ -32783,31 +36465,35 @@ class FileSystemWorkflowGateway {
     }
     async findCopilotSetupWorkflowPath(targetDir) {
         for (const filename of COPILOT_SETUP_WORKFLOW_FILENAMES){
-            const workflowPath = await file_system_utils_resolveSafePath(targetDir, `.github/workflows/${filename}`);
-            if (await file_system_utils_fileExists(workflowPath)) {
-                return workflowPath;
+            const relativePath = `.github/workflows/${filename}`;
+            if (await file_system_utils_pathExistsWithinRoot(targetDir, relativePath)) {
+                return file_system_utils_resolveSafePath(targetDir, relativePath);
             }
         }
         return null;
     }
     async parseWorkflowsForSetupActions(targetDir) {
-        const workflowsDir = await file_system_utils_resolveSafePath(targetDir, ".github/workflows");
-        if (!await file_system_utils_fileExists(workflowsDir)) {
+        const workflowsRelativeDir = ".github/workflows";
+        if (!await file_system_utils_pathExistsWithinRoot(targetDir, workflowsRelativeDir)) {
             return [];
         }
-        const files = await (0,promises_.readdir)(workflowsDir);
-        const yamlFiles = files.filter((f)=>f.endsWith(".yml") || f.endsWith(".yaml"));
+        const files = await file_system_utils_listDirectoryWithinRoot(targetDir, workflowsRelativeDir);
+        const yamlFiles = files.filter((f)=>f.isFile() && (f.name.endsWith(".yml") || f.name.endsWith(".yaml")));
         const config = await this.getConfig();
         const allCandidates = [];
         for (const file of yamlFiles){
-            const filePath = await file_system_utils_resolveSafePath(targetDir, `.github/workflows/${file}`);
-            await file_system_utils_assertFileSizeWithinLimit(filePath, MAX_WORKFLOW_FILE_BYTES, `Workflow file '${file}'`);
+            const relativePath = `.github/workflows/${file.name}`;
             try {
-                const content = await (0,promises_.readFile)(filePath, "utf-8");
+                const content = await file_system_utils_readTextWithinRoot(targetDir, relativePath, file_system_workflow_gateway_MAX_WORKFLOW_FILE_BYTES);
                 const workflow = (0,yaml_dist/* .parse */.qg)(content);
                 const candidates = extractSetupStepsFromWorkflow(workflow, config.setupActionPatterns);
                 allCandidates.push(...candidates);
-            } catch  {}
+            } catch (error) {
+                if (isFsSafeViolation(error)) {
+                    throw error;
+                }
+            // Skip workflow files with YAML parse errors or transient I/O failures
+            }
         }
         return deduplicateCandidates(allCandidates);
     }
@@ -32827,8 +36513,8 @@ class FileSystemWorkflowGateway {
         if (!workflowPath) {
             return null;
         }
-        await file_system_utils_assertFileSizeWithinLimit(workflowPath, MAX_WORKFLOW_FILE_BYTES, "Copilot setup workflow");
-        const content = await (0,promises_.readFile)(workflowPath, "utf-8");
+        const workflowRelativePath = workflowPath.endsWith("copilot-setup-steps.yaml") ? ".github/workflows/copilot-setup-steps.yaml" : ".github/workflows/copilot-setup-steps.yml";
+        const content = await file_system_utils_readTextWithinRoot(targetDir, workflowRelativePath, file_system_workflow_gateway_MAX_WORKFLOW_FILE_BYTES);
         return (0,yaml_dist/* .parse */.qg)(content);
     }
     async writeCopilotSetupWorkflow(targetDir, content) {
@@ -32907,12 +36593,11 @@ function createWorkflowGateway(cwd) {
 
 
 
-
 /**
  * Parses a workflow file and extracts action references.
- */ async function parseWorkflowFile(filePath) {
+ */ async function parseWorkflowFile(rootDir, relativePath) {
     try {
-        const content = await (0,promises_.readFile)(filePath, "utf-8");
+        const content = await file_system_utils_readTextWithinRoot(rootDir, relativePath, 1_048_576);
         const workflow = (0,yaml_dist/* .parse */.qg)(content);
         return extractActionsFromWorkflow(workflow);
     } catch  {
@@ -32941,8 +36626,8 @@ function createWorkflowGateway(cwd) {
     if (!await file_system_utils_fileExists(dir)) {
         return types_errorResponse(`Target directory does not exist: ${dir}`);
     }
-    const workflowsDir = (0,external_node_path_.join)(dir, ".github", "workflows");
-    if (!await file_system_utils_fileExists(workflowsDir)) {
+    const workflowsRelativeDir = (0,external_node_path_.join)(".github", "workflows");
+    if (!await file_system_utils_pathExistsWithinRoot(dir, workflowsRelativeDir)) {
         return successResponse({
             workflows: [],
             uniqueActions: [],
@@ -32950,12 +36635,13 @@ function createWorkflowGateway(cwd) {
         });
     }
     // Read all workflow files
-    const files = await (0,promises_.readdir)(workflowsDir);
+    const entries = await file_system_utils_listDirectoryWithinRoot(dir, workflowsRelativeDir);
+    const files = entries.filter((entry)=>entry.isFile()).map((entry)=>entry.name);
     const yamlFiles = files.filter((f)=>f.endsWith(".yml") || f.endsWith(".yaml"));
     const workflows = [];
     for (const file of yamlFiles){
-        const filePath = (0,external_node_path_.join)(workflowsDir, file);
-        const actions = await parseWorkflowFile(filePath);
+        const filePath = (0,external_node_path_.join)(workflowsRelativeDir, file);
+        const actions = await parseWorkflowFile(dir, filePath);
         if (actions && actions.length > 0) {
             workflows.push({
                 file,
@@ -32983,53 +36669,57 @@ function createWorkflowGateway(cwd) {
  * Supports GitHub Copilot, Claude Code, and community agent instruction formats.
  */ 
 
-
 /**
  * File system implementation of the instruction file discovery gateway.
  */ class FileSystemInstructionFileDiscoveryGateway {
     async discoverInstructionFiles(targetDir) {
         const files = [];
         // .github/copilot-instructions.md
-        const copilotInstructions = (0,external_node_path_.join)(targetDir, ".github", "copilot-instructions.md");
-        if (await file_system_utils_fileExists(copilotInstructions) && !await this.isSymlink(copilotInstructions)) {
+        const copilotInstructions = (0,external_node_path_.join)(".github", "copilot-instructions.md");
+        if (await this.safePathExists(targetDir, copilotInstructions)) {
             files.push({
-                filePath: copilotInstructions,
+                filePath: (0,external_node_path_.join)(targetDir, copilotInstructions),
                 format: "copilot-instructions"
             });
         }
         // .github/instructions/*.md
-        const instructionsDir = (0,external_node_path_.join)(targetDir, ".github", "instructions");
-        await this.discoverMdFilesInDir(instructionsDir, "copilot-scoped", files);
+        const instructionsDir = (0,external_node_path_.join)(".github", "instructions");
+        await this.discoverMdFilesInDir(targetDir, instructionsDir, "copilot-scoped", files);
         // .github/agents/*.md
-        const agentsDir = (0,external_node_path_.join)(targetDir, ".github", "agents");
-        await this.discoverMdFilesInDir(agentsDir, "copilot-agent", files);
+        const agentsDir = (0,external_node_path_.join)(".github", "agents");
+        await this.discoverMdFilesInDir(targetDir, agentsDir, "copilot-agent", files);
         // AGENTS.md at repo root
-        const agentsMd = (0,external_node_path_.join)(targetDir, "AGENTS.md");
-        if (await file_system_utils_fileExists(agentsMd) && !await this.isSymlink(agentsMd)) {
+        const agentsMd = "AGENTS.md";
+        if (await this.safePathExists(targetDir, agentsMd)) {
             files.push({
-                filePath: agentsMd,
+                filePath: (0,external_node_path_.join)(targetDir, agentsMd),
                 format: "agents-md"
             });
         }
         // CLAUDE.md at repo root
-        const claudeMd = (0,external_node_path_.join)(targetDir, "CLAUDE.md");
-        if (await file_system_utils_fileExists(claudeMd) && !await this.isSymlink(claudeMd)) {
+        const claudeMd = "CLAUDE.md";
+        if (await this.safePathExists(targetDir, claudeMd)) {
             files.push({
-                filePath: claudeMd,
+                filePath: (0,external_node_path_.join)(targetDir, claudeMd),
                 format: "claude-md"
             });
         }
         return files;
     }
-    async discoverMdFilesInDir(dirPath, format, files) {
-        if (!await file_system_utils_fileExists(dirPath)) {
+    async safePathExists(targetDir, relativePath) {
+        try {
+            return await file_system_utils_pathExistsWithinRoot(targetDir, relativePath);
+        } catch  {
+            return false;
+        }
+    }
+    async discoverMdFilesInDir(targetDir, dirPath, format, files) {
+        if (!await this.safePathExists(targetDir, dirPath)) {
             return;
         }
         try {
-            const entries = await (0,promises_.readdir)(dirPath, {
-                withFileTypes: true
-            });
-            const resolvedDirPath = (0,external_node_path_.resolve)(dirPath);
+            const entries = await file_system_utils_listDirectoryWithinRoot(targetDir, dirPath);
+            const resolvedDirPath = (0,external_node_path_.resolve)(targetDir, dirPath);
             for (const entry of entries){
                 if (entry.isSymbolicLink()) {
                     continue;
@@ -33042,7 +36732,7 @@ function createWorkflowGateway(cwd) {
                     continue;
                 }
                 if (name.endsWith(".md")) {
-                    const filePath = (0,external_node_path_.join)(dirPath, name);
+                    const filePath = (0,external_node_path_.join)(targetDir, dirPath, name);
                     const resolvedFilePath = (0,external_node_path_.resolve)(filePath);
                     const rel = (0,external_node_path_.relative)(resolvedDirPath, resolvedFilePath);
                     if (rel.startsWith("..") || rel.startsWith(external_node_path_.sep)) {
@@ -33058,14 +36748,6 @@ function createWorkflowGateway(cwd) {
         // Skip directory if we can't read it
         }
     }
-    async isSymlink(filePath) {
-        try {
-            const stats = await (0,promises_.lstat)(filePath);
-            return stats.isSymbolicLink();
-        } catch  {
-            return false;
-        }
-    }
 }
 /**
  * Creates and returns the default instruction file discovery gateway.
@@ -51906,12 +55588,12 @@ const remark = unified().use(remarkParse).use(remarkStringify).freeze()
  */ 
 
 
-/** Maximum instruction file size: 1 MB */ const MAX_INSTRUCTION_FILE_BYTES = 1_048_576;
+/** Maximum instruction file size: 1 MB */ const markdown_ast_gateway_MAX_INSTRUCTION_FILE_BYTES = 1_048_576;
 /**
  * Remark-based implementation of the Markdown AST gateway.
  */ class RemarkMarkdownAstGateway {
     async parseFile(filePath) {
-        const content = await file_system_utils_readFileNoFollow(filePath, MAX_INSTRUCTION_FILE_BYTES);
+        const content = await file_system_utils_readFileNoFollow(filePath, markdown_ast_gateway_MAX_INSTRUCTION_FILE_BYTES);
         return this.parseContent(content);
     }
     parseContent(content) {
@@ -64368,4 +68050,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__(8050);
+var __webpack_exports__ = __webpack_require__(2415);