@lousy-agents/agent-shell 5.14.1 → 5.14.2

package/dist/index.js

@@ -2,7 +2,7 @@
 import { createRequire as __rspack_createRequire } from "node:module";
 const __rspack_createRequire_require = __rspack_createRequire(import.meta.url);
 var __webpack_modules__ = ({
-176(__unused_rspack_module, __unused_rspack___webpack_exports__, __webpack_require__) {
+391(__unused_rspack_module, __unused_rspack___webpack_exports__, __webpack_require__) {
 
 ;// CONCATENATED MODULE: external "node:child_process"
 const external_node_child_process_namespaceObject = __rspack_createRequire_require("node:child_process");
@@ -77,6 +77,3706 @@ function defaultExecutor(env) {
 }
 /** Process-scoped singleton for production use. */ const git_utils_getRepositoryRoot = createGetRepositoryRoot();
 
+;// 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);
+    }
+}
+
+;// CONCATENATED MODULE: external "node:fs"
+const external_node_fs_namespaceObject = __rspack_createRequire_require("node:fs");
+;// CONCATENATED MODULE: external "node:stream/promises"
+const external_node_stream_promises_namespaceObject = __rspack_createRequire_require("node:stream/promises");
+;// CONCATENATED MODULE: external "node:stream"
+const external_node_stream_namespaceObject = __rspack_createRequire_require("node:stream");
+;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/bounded-read-stream.js
+
+
+function createMaxBytesTransform(maxBytes) {
+    let bytes = 0;
+    return new external_node_stream_namespaceObject.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_namespaceObject.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_namespaceObject.win32.resolve(root));
+        const targetForCompare = normalizeWindowsPathForComparison(external_node_path_namespaceObject.win32.resolve(target));
+        const relative = external_node_path_namespaceObject.win32.relative(rootForCompare, targetForCompare);
+        const firstSegment = relative.split(external_node_path_namespaceObject.win32.sep)[0];
+        return (relative === "" || (firstSegment !== ".." && !external_node_path_namespaceObject.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_namespaceObject.resolve(root);
+    const resolvedTarget = external_node_path_namespaceObject.resolve(target);
+    const relative = external_node_path_namespaceObject.relative(resolvedRoot, resolvedTarget);
+    const firstSegment = relative.split(external_node_path_namespaceObject.posix.sep)[0];
+    return relative === "" || (firstSegment !== ".." && !external_node_path_namespaceObject.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_namespaceObject.lstat(dir);
+    if (stat.isSymbolicLink() || !stat.isDirectory()) {
+        throw new errors_FsSafeError("not-file", "directory component must be a directory");
+    }
+    return { dir, realPath: await promises_namespaceObject.realpath(dir), stat };
+}
+async function assertAsyncDirectoryGuard(guard) {
+    const stat = await promises_namespaceObject.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_namespaceObject.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_namespaceObject.resolve(targetPath);
+    const root = external_node_path_namespaceObject.resolve(rootReal);
+    while (current !== root) {
+        try {
+            return await directory_guard_createAsyncDirectoryGuard(current);
+        }
+        catch (error) {
+            if (!path_isNotFoundPathError(error)) {
+                throw error;
+            }
+            current = external_node_path_namespaceObject.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_namespaceObject.sep}`);
+}
+function isPathEscape(relativePath) {
+    return relativePath === ".." || relativePath.startsWith(`..${external_node_path_namespaceObject.sep}`) || external_node_path_namespaceObject.isAbsolute(relativePath);
+}
+async function mkdirPathComponentsWithGuards(params) {
+    const root = external_node_path_namespaceObject.resolve(params.rootReal);
+    const target = external_node_path_namespaceObject.resolve(params.targetPath);
+    const relative = external_node_path_namespaceObject.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_namespaceObject.sep).filter(Boolean)) {
+        const next = external_node_path_namespaceObject.join(current, part);
+        const parentGuard = await directory_guard_createAsyncDirectoryGuard(current);
+        await params.beforeComponent?.(next);
+        await assertAsyncDirectoryGuard(parentGuard);
+        try {
+            await promises_namespaceObject.mkdir(next);
+        }
+        catch (error) {
+            if (!error || typeof error !== "object" || !("code" in error) || error.code !== "EEXIST") {
+                throw error;
+            }
+        }
+        const stat = await promises_namespaceObject.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_namespaceObject.resolve(await promises_namespaceObject.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");
+}
+
+;// 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_namespaceObject.accessSync(binPath, external_node_fs_namespaceObject.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_namespaceObject.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 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_namespaceObject.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_namespaceObject.pipeline)(stream, limiter, destination);
+        return;
+    }
+    await (0,external_node_stream_promises_namespaceObject.pipeline)(stream, destination);
+}
+async function inputToBase64(input, maxBytes) {
+    if (input.kind === "buffer") {
+        assertWithinMaxBytes(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_namespaceObject.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_namespaceObject.mkdir(parentPath, { recursive: true });
+        });
+    }
+    const targetPath = external_node_path_namespaceObject.join(parentPath, params.basename);
+    if (params.overwrite === false) {
+        let handle = await withAsyncDirectoryGuards([parentGuard], async () => await promises_namespaceObject.open(targetPath, external_node_fs_namespaceObject.constants.O_WRONLY | external_node_fs_namespaceObject.constants.O_CREAT | external_node_fs_namespaceObject.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(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_namespaceObject.rm(targetPath, { force: true }).catch(() => undefined);
+            }
+        }
+    }
+    const tempPath = external_node_path_namespaceObject.join(parentPath, `.${params.basename}.${(0,external_node_crypto_namespaceObject.randomUUID)()}.fallback.tmp`);
+    const tempFlags = external_node_fs_namespaceObject.constants.O_WRONLY |
+        external_node_fs_namespaceObject.constants.O_CREAT |
+        external_node_fs_namespaceObject.constants.O_EXCL |
+        (process.platform !== "win32" && "O_NOFOLLOW" in external_node_fs_namespaceObject.constants
+            ? external_node_fs_namespaceObject.constants.O_NOFOLLOW
+            : 0);
+    let handle;
+    let handleClosedByStream = false;
+    try {
+        handle = await promises_namespaceObject.open(tempPath, tempFlags, params.mode);
+        if (params.input.kind === "buffer") {
+            assertWithinMaxBytes(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_namespaceObject.rename(tempPath, targetPath);
+        });
+    }
+    catch (error) {
+        if (handle && !handleClosedByStream) {
+            await handle.close().catch(() => undefined);
+        }
+        await promises_namespaceObject.rm(tempPath, { force: true }).catch(() => undefined);
+        throw error;
+    }
+    const stat = await promises_namespaceObject.stat(targetPath);
+    return { dev: stat.dev, ino: stat.ino };
+}
+
+;// CONCATENATED MODULE: external "node:os"
+const external_node_os_namespaceObject = __rspack_createRequire_require("node:os");
+;// 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_namespaceObject.resolve(params.rootPath);
+    const absolutePath = external_node_path_namespaceObject.resolve(params.absolutePath);
+    const rootCanonicalPath = params.rootCanonicalPath
+        ? external_node_path_namespaceObject.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_namespaceObject.relative(params.rootPath, params.absolutePath);
+    return {
+        segments: relative.split(external_node_path_namespaceObject.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_namespaceObject.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_namespaceObject.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_namespaceObject.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_namespaceObject.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_namespaceObject.resolve(targetPath);
+    let cursor = normalized;
+    const missingSuffix = [];
+    while (!isFilesystemRoot(cursor) && !(await pathExists(cursor))) {
+        missingSuffix.unshift(external_node_path_namespaceObject.basename(cursor));
+        const parent = external_node_path_namespaceObject.dirname(cursor);
+        if (parent === cursor) {
+            break;
+        }
+        cursor = parent;
+    }
+    if (!(await pathExists(cursor))) {
+        return normalized;
+    }
+    try {
+        const resolvedAncestor = external_node_path_namespaceObject.resolve(await promises_namespaceObject.realpath(cursor));
+        if (missingSuffix.length === 0) {
+            return resolvedAncestor;
+        }
+        return external_node_path_namespaceObject.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_namespaceObject.lstat(absolutePath)
+            : await promises_namespaceObject.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_namespaceObject.relative(external_node_path_namespaceObject.resolve(rootPath), external_node_path_namespaceObject.resolve(targetPath));
+    if (!relative || relative === ".") {
+        return "";
+    }
+    if (relative.startsWith("..") || external_node_path_namespaceObject.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_namespaceObject.homedir();
+    if (value.startsWith(home)) {
+        return `~${value.slice(home.length)}`;
+    }
+    return value;
+}
+function isFilesystemRoot(candidate) {
+    return external_node_path_namespaceObject.parse(candidate).root === candidate;
+}
+async function pathExists(targetPath) {
+    try {
+        await promises_namespaceObject.lstat(targetPath);
+        return true;
+    }
+    catch (error) {
+        if (path_isNotFoundPathError(error)) {
+            return false;
+        }
+        throw error;
+    }
+}
+async function resolveSymlinkHopPath(symlinkPath) {
+    try {
+        return external_node_path_namespaceObject.resolve(await promises_namespaceObject.realpath(symlinkPath));
+    }
+    catch (error) {
+        if (!path_isNotFoundPathError(error)) {
+            throw error;
+        }
+        const linkTarget = await promises_namespaceObject.readlink(symlinkPath);
+        const linkAbsolute = external_node_path_namespaceObject.resolve(external_node_path_namespaceObject.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_namespaceObject.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_namespaceObject.homedir())) {
+        return `~${value.slice(external_node_os_namespaceObject.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_namespaceObject.homedir) {
+    const raw = resolveRawHomeDir(env, homedir);
+    return raw ? external_node_path_namespaceObject.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_namespaceObject.normalize(explicitHome).split(external_node_path_namespaceObject.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_namespaceObject.normalize(input).split(external_node_path_namespaceObject.sep);
+    if (segments[0] !== "~") {
+        return input;
+    }
+    const home = normalize(opts?.home) ??
+        resolveEffectiveHomeDir(opts?.env ?? process.env, opts?.homedir ?? external_node_os_namespaceObject.homedir);
+    if (!home) {
+        return input;
+    }
+    return external_node_path_namespaceObject.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_namespaceObject.sep) ? value : value + external_node_path_namespaceObject.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_namespaceObject.homedir();
+    if (cachedHomePath?.raw !== rawHome) {
+        let realHome = rawHome;
+        try {
+            realHome = await promises_namespaceObject.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_namespaceObject.realpath(rootDir);
+        const rootStat = await promises_namespaceObject.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_namespaceObject.resolve(rootDir),
+        rootReal,
+        rootWithSep: ensureTrailingSep(rootReal),
+    };
+}
+async function resolvePathInRoot(root, relativePath) {
+    assertValidRootRelativePath(relativePath);
+    const expanded = await expandRelativePathWithHome(relativePath);
+    const resolved = external_node_path_namespaceObject.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_namespaceObject.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_namespaceObject.constants;
+const NONBLOCK_OPEN_FLAG = "O_NONBLOCK" in external_node_fs_namespaceObject.constants ? external_node_fs_namespaceObject.constants.O_NONBLOCK : 0;
+const OPEN_READ_FLAGS = external_node_fs_namespaceObject.constants.O_RDONLY | (SUPPORTS_NOFOLLOW ? external_node_fs_namespaceObject.constants.O_NOFOLLOW : 0);
+const OPEN_READ_NONBLOCK_FLAGS = OPEN_READ_FLAGS | NONBLOCK_OPEN_FLAG;
+const OPEN_READ_FOLLOW_FLAGS = external_node_fs_namespaceObject.constants.O_RDONLY;
+const OPEN_READ_FOLLOW_NONBLOCK_FLAGS = OPEN_READ_FOLLOW_FLAGS | NONBLOCK_OPEN_FLAG;
+const OPEN_WRITE_EXISTING_FLAGS = external_node_fs_namespaceObject.constants.O_WRONLY | (SUPPORTS_NOFOLLOW ? external_node_fs_namespaceObject.constants.O_NOFOLLOW : 0);
+const OPEN_WRITE_CREATE_FLAGS = external_node_fs_namespaceObject.constants.O_WRONLY |
+    external_node_fs_namespaceObject.constants.O_CREAT |
+    external_node_fs_namespaceObject.constants.O_EXCL |
+    (SUPPORTS_NOFOLLOW ? external_node_fs_namespaceObject.constants.O_NOFOLLOW : 0);
+const OPEN_APPEND_EXISTING_FLAGS = external_node_fs_namespaceObject.constants.O_RDWR | external_node_fs_namespaceObject.constants.O_APPEND | (SUPPORTS_NOFOLLOW ? external_node_fs_namespaceObject.constants.O_NOFOLLOW : 0);
+const OPEN_APPEND_CREATE_FLAGS = external_node_fs_namespaceObject.constants.O_RDWR |
+    external_node_fs_namespaceObject.constants.O_APPEND |
+    external_node_fs_namespaceObject.constants.O_CREAT |
+    external_node_fs_namespaceObject.constants.O_EXCL |
+    (SUPPORTS_NOFOLLOW ? external_node_fs_namespaceObject.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_namespaceObject.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_namespaceObject.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_namespaceObject.stat(filePath);
+            if (!file_identity_sameFileIdentity(stat, pathStat)) {
+                throw new errors_FsSafeError("path-mismatch", "path changed during read");
+            }
+        }
+        else {
+            const pathStat = await promises_namespaceObject.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_namespaceObject.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;
+        }
+    }
+}
+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_namespaceObject.isAbsolute(params.filePath)
+        ? external_node_path_namespaceObject.resolve(params.filePath)
+        : external_node_path_namespaceObject.resolve(rootDir, params.filePath);
+    const relativePath = external_node_path_namespaceObject.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_namespaceObject.dirname(targetPath);
+    const base = external_node_path_namespaceObject.basename(targetPath);
+    return external_node_path_namespaceObject.join(dir, `.${base}.${process.pid}.${(0,external_node_crypto_namespaceObject.randomUUID)()}.tmp`);
+}
+function rootWriteQueueKey(root, relativePath) {
+    return `${root.rootReal}\0${relativePath}`;
+}
+async function writeTempFileForAtomicReplace(params) {
+    const tempHandle = await promises_namespaceObject.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_namespaceObject.realpath(fdPath);
+            const fdRealStat = await promises_namespaceObject.stat(fdRealPath);
+            if (file_identity_sameFileIdentity(handleStat, fdRealStat)) {
+                return fdRealPath;
+            }
+        }
+        catch {
+            // try next fd path
+        }
+    }
+    try {
+        const ioRealPath = await promises_namespaceObject.realpath(ioPath);
+        const ioRealStat = await promises_namespaceObject.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_namespaceObject.realpath(external_node_path_namespaceObject.dirname(ioPath));
+    }
+    catch (err) {
+        if (path_isNotFoundPathError(err)) {
+            return null;
+        }
+        throw err;
+    }
+    let entries;
+    try {
+        entries = await promises_namespaceObject.readdir(parentReal);
+    }
+    catch (err) {
+        if (path_isNotFoundPathError(err)) {
+            return null;
+        }
+        throw err;
+    }
+    for (const entry of entries.toSorted()) {
+        const candidatePath = external_node_path_namespaceObject.join(parentReal, entry);
+        try {
+            const candidateStat = await promises_namespaceObject.lstat(candidatePath);
+            if (candidateStat.isFile() && file_identity_sameFileIdentity(handleStat, candidateStat)) {
+                return await promises_namespaceObject.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_namespaceObject.dirname(resolved));
+        await withAsyncDirectoryGuards([parentGuard], async () => {
+            await promises_namespaceObject.mkdir(external_node_path_namespaceObject.dirname(resolved), { recursive: true });
+        });
+    }
+    let ioPath = resolved;
+    try {
+        const resolvedRealPath = await promises_namespaceObject.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_namespaceObject.open(ioPath, existingFlags, mode);
+        }
+        catch (err) {
+            if (!path_isNotFoundPathError(err)) {
+                throw err;
+            }
+            handle = await promises_namespaceObject.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_namespaceObject.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_namespaceObject.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_namespaceObject.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_namespaceObject.relative(rootReal, resolved);
+    if (external_node_path_namespaceObject.isAbsolute(relativeResolved)) {
+        throw new errors_FsSafeError("outside-workspace", "file is outside workspace root");
+    }
+    const relativePosix = relativeResolved
+        ? relativeResolved.split(external_node_path_namespaceObject.sep).join(external_node_path_namespaceObject.posix.sep)
+        : "";
+    const basename = external_node_path_namespaceObject.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_namespaceObject.posix.dirname(relativePosix) === "." ? "" : external_node_path_namespaceObject.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_namespaceObject.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_namespaceObject.sep)[0];
+    if (relativeResolved === "" ||
+        relativeResolved === "." ||
+        firstSegment === ".." ||
+        external_node_path_namespaceObject.isAbsolute(relativeResolved)) {
+        throw new errors_FsSafeError("outside-workspace", "file is outside workspace root");
+    }
+    const relativePosix = relativeResolved.split(external_node_path_namespaceObject.sep).join(external_node_path_namespaceObject.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_namespaceObject.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_namespaceObject.dirname(resolved.resolved));
+    await getFsSafeTestHooks()?.beforeRootFallbackMutation?.("remove", resolved.resolved);
+    await assertAsyncDirectoryGuard(guard);
+    await ((await promises_namespaceObject.lstat(resolved.resolved)).isDirectory() ? promises_namespaceObject.rmdir(resolved.resolved) : promises_namespaceObject.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_namespaceObject.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_namespaceObject.readdir(resolved.resolved);
+        const sortedNames = names.toSorted();
+        if (!withFileTypes) {
+            return sortedNames;
+        }
+        const entries = [];
+        for (const name of sortedNames) {
+            entries.push({
+                name,
+                ...pathStatFromStats(await promises_namespaceObject.lstat(external_node_path_namespaceObject.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_namespaceObject.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_namespaceObject.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_namespaceObject.dirname(source.resolved));
+    const targetParentGuard = await directory_guard_createNearestExistingDirectoryGuard(target.rootReal, external_node_path_namespaceObject.dirname(target.resolved));
+    await getFsSafeTestHooks()?.beforeRootFallbackMutation?.("move", target.resolved);
+    await assertAsyncDirectoryGuard(sourceParentGuard);
+    await assertAsyncDirectoryGuard(targetParentGuard);
+    try {
+        await promises_namespaceObject.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_namespaceObject.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_namespaceObject.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_namespaceObject.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_namespaceObject.mkdir(external_node_path_namespaceObject.dirname(resolved), { recursive: true });
+    }
+    const parentGuard = await directory_guard_createAsyncDirectoryGuard(external_node_path_namespaceObject.dirname(resolved));
+    let created = false;
+    try {
+        const { handle, writtenStat } = await withAsyncDirectoryGuards([parentGuard], async () => {
+            const handle = await promises_namespaceObject.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_namespaceObject.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_namespaceObject.dirname(destinationPath));
+        tempPath = buildAtomicWriteTempPath(destinationPath);
+        unregisterTempPath = registerTempPathForExit(tempPath);
+        tempHandle = await promises_namespaceObject.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_namespaceObject.pipeline)(sourceStream, targetStream);
+        const writtenStat = await promises_namespaceObject.stat(tempPath);
+        if (!tempClosedByStream) {
+            await tempHandle.close().catch(() => { });
+            tempClosedByStream = true;
+        }
+        tempHandle = null;
+        const commitTempPath = tempPath;
+        await withAsyncDirectoryGuards([destinationGuard], async () => {
+            await promises_namespaceObject.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_namespaceObject.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_namespaceObject.rm(tempPath, { force: true }).catch(() => { });
+        }
+        unregisterTempPath?.();
+        if (target && !targetClosedByUs) {
+            await target.handle.close().catch(() => { });
+        }
+    }
+}
+
+;// CONCATENATED MODULE: ./src/lib/safe-fs.ts
+
+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"
+    });
+}
+function toSafeDirEntry(entry) {
+    return {
+        name: entry.name,
+        isDirectory: ()=>entry.isDirectory,
+        isFile: ()=>entry.isFile,
+        isSymbolicLink: ()=>entry.isSymbolicLink
+    };
+}
+async function readBytesWithinRoot(targetDir, relativePath, maxBytes) {
+    try {
+        const safeRoot = await createSafeRoot(targetDir, maxBytes);
+        return await safeRoot.readBytes(relativePath, {
+            maxBytes
+        });
+    } catch (error) {
+        mapFsSafeError(error, relativePath);
+    }
+}
+async function readTextWithinRoot(targetDir, relativePath, maxBytes) {
+    try {
+        const safeRoot = await createSafeRoot(targetDir, maxBytes);
+        return await safeRoot.readText(relativePath, {
+            maxBytes
+        });
+    } catch (error) {
+        mapFsSafeError(error, relativePath);
+    }
+}
+async function 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);
+    }
+}
+async function statWithinRoot(targetDir, relativePath) {
+    try {
+        const safeRoot = await createSafeRoot(targetDir);
+        return await safeRoot.stat(relativePath);
+    } catch (error) {
+        mapFsSafeError(error, relativePath);
+    }
+}
+async function pathExistsWithinRoot(targetDir, relativePath) {
+    try {
+        const safeRoot = await createSafeRoot(targetDir);
+        return await safeRoot.exists(relativePath);
+    } catch (error) {
+        mapFsSafeError(error, relativePath);
+    }
+}
+
 ;// CONCATENATED MODULE: ./src/gateways/project-scanner.ts
 
 
@@ -97,33 +3797,39 @@ const LANGUAGE_MARKERS = {
     "build.gradle": "java",
     "build.gradle.kts": "java"
 };
-async function fileExists(path) {
+async function fileExists(rootDir, relativePath) {
     try {
-        const s = await (0,promises_namespaceObject.stat)(path);
-        return s.isFile();
+        if (!await pathExistsWithinRoot(rootDir, relativePath)) {
+            return false;
+        }
+        const s = await statWithinRoot(rootDir, relativePath);
+        return s.isFile;
     } catch  {
         return false;
     }
 }
-async function dirExists(path) {
+async function dirExists(rootDir, relativePath) {
     try {
-        const s = await (0,promises_namespaceObject.stat)(path);
-        return s.isDirectory();
+        if (!await pathExistsWithinRoot(rootDir, relativePath)) {
+            return false;
+        }
+        const s = await statWithinRoot(rootDir, relativePath);
+        return s.isDirectory;
     } catch  {
         return false;
     }
 }
 async function discoverScripts(targetDir) {
-    const packageJsonPath = (0,external_node_path_namespaceObject.join)(targetDir, "package.json");
-    if (!await fileExists(packageJsonPath)) {
+    const packageJsonPath = "package.json";
+    if (!await fileExists(targetDir, packageJsonPath)) {
         return [];
     }
     try {
-        const fileStat = await (0,promises_namespaceObject.stat)(packageJsonPath);
+        const fileStat = await statWithinRoot(targetDir, packageJsonPath);
         if (fileStat.size > MAX_FILE_SIZE_BYTES) {
             return [];
         }
-        const content = await (0,promises_namespaceObject.readFile)(packageJsonPath, "utf-8");
+        const content = await readTextWithinRoot(targetDir, packageJsonPath, MAX_FILE_SIZE_BYTES);
         const parsed = JSON.parse(content);
         if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
             return [];
@@ -148,13 +3854,14 @@ async function discoverScripts(targetDir) {
     }
 }
 async function discoverWorkflowCommands(targetDir) {
-    const workflowsDir = (0,external_node_path_namespaceObject.join)(targetDir, ".github", "workflows");
-    if (!await dirExists(workflowsDir)) {
+    const workflowsDir = (0,external_node_path_namespaceObject.join)(".github", "workflows");
+    if (!await dirExists(targetDir, workflowsDir)) {
         return [];
     }
     let files;
     try {
-        files = await (0,promises_namespaceObject.readdir)(workflowsDir);
+        const entries = await listDirectoryWithinRoot(targetDir, workflowsDir);
+        files = entries.filter((entry)=>entry.isFile()).map((entry)=>entry.name);
     } catch  {
         return [];
     }
@@ -163,11 +3870,11 @@ async function discoverWorkflowCommands(targetDir) {
     for (const file of yamlFiles){
         try {
             const filePath = (0,external_node_path_namespaceObject.join)(workflowsDir, file);
-            const fileStat = await (0,promises_namespaceObject.stat)(filePath);
+            const fileStat = await statWithinRoot(targetDir, filePath);
             if (fileStat.size > MAX_FILE_SIZE_BYTES) {
                 continue;
             }
-            const content = await (0,promises_namespaceObject.readFile)(filePath, "utf-8");
+            const content = await readTextWithinRoot(targetDir, filePath, MAX_FILE_SIZE_BYTES);
             const commands = extractRunCommandsFromYaml(content);
             allCommands.push(...commands);
         } catch  {}
@@ -299,16 +4006,16 @@ function isUsefulCommand(cmd) {
  * Parse mise.toml to extract task definitions.
  * Uses simple line-based parsing for [tasks.*] sections.
  */ async function discoverMiseTasks(targetDir) {
-    const miseTomlPath = (0,external_node_path_namespaceObject.join)(targetDir, "mise.toml");
-    if (!await fileExists(miseTomlPath)) {
+    const miseTomlPath = "mise.toml";
+    if (!await fileExists(targetDir, miseTomlPath)) {
         return [];
     }
     try {
-        const fileStat = await (0,promises_namespaceObject.stat)(miseTomlPath);
+        const fileStat = await statWithinRoot(targetDir, miseTomlPath);
         if (fileStat.size > MAX_FILE_SIZE_BYTES) {
             return [];
         }
-        const content = await (0,promises_namespaceObject.readFile)(miseTomlPath, "utf-8");
+        const content = await readTextWithinRoot(targetDir, miseTomlPath, MAX_FILE_SIZE_BYTES);
         return parseMiseTomlTasks(content);
     } catch  {
         return [];
@@ -373,7 +4080,7 @@ function parseMiseTomlTasks(content) {
 async function detectLanguages(targetDir) {
     const detected = new Set();
     for (const [filename, language] of Object.entries(LANGUAGE_MARKERS)){
-        if (await fileExists((0,external_node_path_namespaceObject.join)(targetDir, filename))) {
+        if (await fileExists(targetDir, filename)) {
             detected.add(language);
         }
     }
@@ -727,7 +4434,7 @@ function jsonStringifyReplacer(_, value) {
         return value.toString();
     return value;
 }
-function cached(getter) {
+function util_cached(getter) {
     const set = false;
     return {
         get value() {
@@ -843,7 +4550,7 @@ const captureStackTrace = ("captureStackTrace" in Error ? Error.captureStackTrac
 function util_isObject(data) {
     return typeof data === "object" && data !== null && !Array.isArray(data);
 }
-const util_allowsEval = /* @__PURE__*/ cached(() => {
+const util_allowsEval = /* @__PURE__*/ util_cached(() => {
     // Skip the probe under `jitless`: strict CSPs report the caught `new Function`
     // as a `securitypolicyviolation` even though the throw is swallowed.
     if (globalConfig.jitless) {
@@ -3093,7 +6800,7 @@ const $ZodObject = /*@__PURE__*/ $constructor("$ZodObject", (inst, def) => {
             },
         });
     }
-    const _normalized = cached(() => normalizeDef(def));
+    const _normalized = util_cached(() => normalizeDef(def));
     defineLazy(inst._zod, "propValues", () => {
         const shape = def.shape;
         const propValues = {};
@@ -3147,7 +6854,7 @@ const $ZodObjectJIT = /*@__PURE__*/ $constructor("$ZodObjectJIT", (inst, def) =>
     // requires cast because technically $ZodObject doesn't extend
     $ZodObject.init(inst, def);
     const superParse = inst._zod.parse;
-    const _normalized = cached(() => normalizeDef(def));
+    const _normalized = util_cached(() => normalizeDef(def));
     const generateFastpass = (shape) => {
         const doc = new Doc(["shape", "payload", "ctx"]);
         const normalized = _normalized.value;
@@ -3421,7 +7128,7 @@ $constructor("$ZodDiscriminatedUnion", (inst, def) => {
         }
         return propValues;
     });
-    const disc = cached(() => {
+    const disc = util_cached(() => {
         const opts = def.options;
         const map = new Map();
         for (const o of opts) {
@@ -8797,8 +12504,6 @@ function hasProtoKey(value) {
     return hasProtoKeyAtDepth(value, 0);
 }
 
-;// CONCATENATED MODULE: external "node:fs"
-const external_node_fs_namespaceObject = __rspack_createRequire_require("node:fs");
 ;// CONCATENATED MODULE: external "node:module"
 const external_node_module_namespaceObject = __rspack_createRequire_require("node:module");
 ;// CONCATENATED MODULE: external "node:url"
@@ -8984,6 +12689,7 @@ ${miseList}
 
 const DEFAULT_MODEL = "claude-sonnet-4-6";
 const MAX_FILE_READ_BYTES = 102_400;
+const MAX_PROJECT_FILE_BYTES = 20 * 1024 * 1024;
 const AnalysisResponseSchema = schemas_object({
     additionalAllowRules: schemas_array(schemas_string().max(512)).max(100),
     suggestions: schemas_array(schemas_string().max(1024)).max(100)
@@ -9044,28 +12750,33 @@ const AnalysisResponseSchema = schemas_object({
             error: "Path is outside the repository"
         };
     }
+    const cleanRoot = repoRoot.replace(/\/+$/, "") || "/";
+    const relPath = (0,external_node_path_namespaceObject.relative)(cleanRoot, safePath);
     let fileBuffer;
+    let truncated = false;
     try {
-        const root = repoRoot.replace(/\/+$/, "") || "/";
-        const [realRoot, realPath] = await Promise.all([
-            (0,promises_namespaceObject.realpath)(root),
-            (0,promises_namespaceObject.realpath)(safePath)
-        ]);
-        const realPrefix = realRoot === "/" ? "/" : `${realRoot}/`;
-        if (!realPath.startsWith(realPrefix) && realPath !== realRoot) {
+        const fileStat = await statWithinRoot(repoRoot, relPath);
+        truncated = fileStat.size > MAX_FILE_READ_BYTES;
+        if (fileStat.size > MAX_PROJECT_FILE_BYTES) {
+            return {
+                error: "File not found or unreadable"
+            };
+        }
+        fileBuffer = await readBytesWithinRoot(repoRoot, relPath, MAX_PROJECT_FILE_BYTES);
+    } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (message.includes("symbolic link")) {
             return {
                 error: "Path is outside the repository"
             };
         }
-        fileBuffer = await (0,promises_namespaceObject.readFile)(realPath);
-    } catch  {
         return {
             error: "File not found or unreadable"
         };
     }
     // Buffer processing outside I/O catch — programming bugs in
     // findUtf8Boundary propagate instead of being silently swallowed.
-    if (fileBuffer.length <= MAX_FILE_READ_BYTES) {
+    if (!truncated) {
         return {
             content: fileBuffer.toString("utf-8"),
             truncated: false
@@ -9574,9 +13285,9 @@ function detectExistingFeatures(config) {
         hasPostToolUse: hasHookCommand(config.hooks.postToolUse, AGENT_SHELL_RECORD)
     };
 }
-async function loadExistingHooksConfig(hooksPath, deps) {
+async function loadExistingHooksConfig(repoRoot, hooksPath, deps) {
     try {
-        const raw = await deps.readFile(hooksPath, "utf-8");
+        const raw = deps.readFileWithinRoot ? await deps.readFileWithinRoot(repoRoot, init_command_HOOKS_SUBPATH, 524_288) : await deps.readFile(hooksPath, "utf-8");
         const parsed = JSON.parse(raw);
         if (hasProtoKey(parsed)) {
             throw new Error("hooks schema validation failed");
@@ -9720,7 +13431,7 @@ async function writeConfigFile(repoRoot, subpath, content, deps) {
 async function handleInit(flags, deps) {
     const repoRoot = deps.getRepositoryRoot();
     const hooksPath = (0,external_node_path_namespaceObject.join)(repoRoot, init_command_HOOKS_SUBPATH);
-    const { config: existingConfig, error: loadError } = await loadExistingHooksConfig(hooksPath, deps);
+    const { config: existingConfig, error: loadError } = await loadExistingHooksConfig(repoRoot, hooksPath, deps);
     if (loadError) {
         return false;
     }
@@ -9813,7 +13524,7 @@ async function handleInit(flags, deps) {
         const policyPath = (0,external_node_path_namespaceObject.join)(repoRoot, init_command_POLICY_SUBPATH);
         let existingContent = null;
         try {
-            existingContent = await deps.readFile(policyPath, "utf-8");
+            existingContent = deps.readFileWithinRoot ? await deps.readFileWithinRoot(repoRoot, init_command_POLICY_SUBPATH, 524_288) : await deps.readFile(policyPath, "utf-8");
         } catch (error) {
             if (!isPathNotFoundError(error)) {
                 throw error;
@@ -9905,7 +13616,7 @@ async function resolveReadEventsDir(env, deps) {
     if (logDir !== undefined && logDir !== "") {
         const projectRootReal = await deps.realpath(projectRoot);
         const candidate = (0,external_node_path_namespaceObject.resolve)(projectRoot, logDir);
-        if (!isWithinProjectRoot(candidate, projectRoot) && !isWithinProjectRoot(candidate, projectRootReal)) {
+        if (!(0,external_node_path_namespaceObject.isAbsolute)(logDir) && !isWithinProjectRoot(candidate, projectRoot) && !isWithinProjectRoot(candidate, projectRootReal)) {
             return {
                 dir: "",
                 error: "AGENTSHELL_LOG_DIR resolves outside project root"
@@ -10161,6 +13872,8 @@ function formatEventsJson(events) {
 
 
 
+
+
 function parseLogArgs(args) {
     const options = {
         failures: false,
@@ -10209,19 +13922,42 @@ function parseLogArgs(args) {
     }
     return options;
 }
+function relativePathUnderRoot(rootDir, path) {
+    const relativePath = (0,external_node_path_namespaceObject.relative)(rootDir, path);
+    if (relativePath === "" || relativePath === ".." || relativePath.startsWith(`..${external_node_path_namespaceObject.sep}`) || (0,external_node_path_namespaceObject.isAbsolute)(relativePath)) {
+        throw new Error("Path resolves outside project root");
+    }
+    return relativePath;
+}
+async function* readSafeFileLines(rootDir, path) {
+    const relativePath = relativePathUnderRoot(rootDir, path);
+    await statWithinRoot(rootDir, relativePath);
+    const rl = (0,external_node_readline_namespaceObject.createInterface)({
+        input: (0,external_node_fs_namespaceObject.createReadStream)((0,external_node_path_namespaceObject.join)(rootDir, relativePath)),
+        crlfDelay: Infinity
+    });
+    for await (const line of rl){
+        yield line;
+    }
+}
 function createDefaultQueryDeps() {
+    const rootDir = process.cwd();
     return {
-        readdir: (path)=>(0,promises_namespaceObject.readdir)(path),
-        stat: (path)=>(0,promises_namespaceObject.stat)(path).then((s)=>({
-                    mtimeMs: s.mtimeMs
-                })),
+        readdir: async (path)=>{
+            const relativePath = relativePathUnderRoot(rootDir, path);
+            const entries = await listDirectoryWithinRoot(rootDir, relativePath);
+            return entries.map((entry)=>entry.name);
+        },
+        stat: async (path)=>{
+            const relativePath = relativePathUnderRoot(rootDir, path);
+            const s = await statWithinRoot(rootDir, relativePath);
+            return {
+                mtimeMs: s.mtimeMs
+            };
+        },
         realpath: (path)=>(0,promises_namespaceObject.realpath)(path),
         cwd: ()=>process.cwd(),
-        readFileLines: (path)=>(0,external_node_readline_namespaceObject.createInterface)({
-                input: (0,external_node_fs_namespaceObject.createReadStream)(path, {
-                    encoding: "utf-8"
-                })
-            }),
+        readFileLines: (path)=>readSafeFileLines(rootDir, path),
         writeStderr: (msg)=>{
             process.stderr.write(msg);
         }
@@ -10390,6 +14126,13 @@ function resolvePolicyPath(env, repoRoot) {
         isOverride: false
     };
 }
+function policy_relativePathUnderRoot(repoRoot, path) {
+    const relativePath = (0,external_node_path_namespaceObject.relative)(repoRoot, path);
+    if (relativePath === "" || relativePath === ".." || relativePath.startsWith(`..${external_node_path_namespaceObject.sep}`) || (0,external_node_path_namespaceObject.isAbsolute)(relativePath)) {
+        return null;
+    }
+    return relativePath;
+}
 async function loadPolicy(env, deps) {
     const rawRepoRoot = deps.getRepositoryRoot();
     const repoRoot = await deps.realpath(rawRepoRoot);
@@ -10410,8 +14153,12 @@ async function loadPolicy(env, deps) {
         throw new Error(`Policy file path resolves outside the repository root: ${sanitizePath(resolvedPath)}`);
     }
     let content;
+    const relativePolicyPath = policy_relativePathUnderRoot(repoRoot, candidatePath);
+    if (relativePolicyPath === null) {
+        throw new Error(`Policy file path resolves outside the repository root: ${sanitizePath(candidatePath)}`);
+    }
     try {
-        content = await deps.readFile(resolvedPath, "utf-8");
+        content = deps.readFileWithinRoot ? await deps.readFileWithinRoot(repoRoot, relativePolicyPath, 524_288) : await deps.readFile(resolvedPath, "utf-8");
     } catch (error) {
         if (isPathNotFoundError(error)) {
             if (isOverride) {
@@ -10691,6 +14438,7 @@ async function handleRecord(deps) {
 
 
 
+
 const VERSION = "0.1.0";
 const USAGE = `Usage: agent-shell -c <command>
        agent-shell init [--flight-recorder] [--policy] [--no-flight-recorder] [--no-policy]
@@ -10735,6 +14483,7 @@ async function main() {
                     policyDeps: {
                         realpath: (path)=>(0,promises_namespaceObject.realpath)(path),
                         readFile: (path, encoding)=>(0,promises_namespaceObject.readFile)(path, encoding),
+                        readFileWithinRoot: (rootDir, relativePath, maxBytes)=>readTextWithinRoot(rootDir, relativePath, maxBytes),
                         getRepositoryRoot
                     },
                     telemetryDeps: createDefaultDeps()
@@ -10818,6 +14567,7 @@ async function main() {
                         writeStdout: (data)=>process.stdout.write(data),
                         writeStderr: (data)=>process.stderr.write(data),
                         readFile: (path, encoding)=>(0,promises_namespaceObject.readFile)(path, encoding),
+                        readFileWithinRoot: (rootDir, relativePath, maxBytes)=>readTextWithinRoot(rootDir, relativePath, maxBytes),
                         writeFile: (path, content, options)=>(0,promises_namespaceObject.writeFile)(path, content, options),
                         rename: (oldPath, newPath)=>(0,promises_namespaceObject.rename)(oldPath, newPath),
                         unlink: (path)=>(0,promises_namespaceObject.unlink)(path),
@@ -11033,4 +14783,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__(176);
+var __webpack_exports__ = __webpack_require__(391);