wednesdayai 0.5.1-dev.25 → 0.5.1-dev.27

package/dist/subsystem-BZy3aWdW.js

@@ -0,0 +1,2761 @@
+import { d as resolveEffectiveHomeDir, f as resolveRequiredHomeDir, r as resolveConfigPath, u as expandHomePrefix } from "./paths-BIDPYPVC.js";
+import { t as isPlainObject } from "./plain-object-CLm2c5Nu.js";
+import path from "node:path";
+import fs from "node:fs";
+import os from "node:os";
+import chalk, { Chalk } from "chalk";
+import { Logger } from "tslog";
+import JSON5 from "json5";
+import fs$1 from "node:fs/promises";
+import util, { promisify } from "node:util";
+import zlib from "node:zlib";
+
+//#region src/infra/cli-root-options.ts
+const FLAG_TERMINATOR = "--";
+const ROOT_BOOLEAN_FLAGS = new Set(["--dev", "--no-color"]);
+const ROOT_VALUE_FLAGS = new Set(["--profile", "--log-level"]);
+function isValueToken(arg) {
+	if (!arg || arg === FLAG_TERMINATOR) return false;
+	if (!arg.startsWith("-")) return true;
+	return /^-\d+(?:\.\d+)?$/.test(arg);
+}
+function consumeRootOptionToken(args, index) {
+	const arg = args[index];
+	if (!arg) return 0;
+	if (ROOT_BOOLEAN_FLAGS.has(arg)) return 1;
+	if (arg.startsWith("--profile=") || arg.startsWith("--log-level=")) return 1;
+	if (ROOT_VALUE_FLAGS.has(arg)) return isValueToken(args[index + 1]) ? 2 : 1;
+	return 0;
+}
+
+//#endregion
+//#region src/cli/argv.ts
+function getCommandPathWithRootOptions(argv, depth = 2) {
+	return getCommandPathInternal(argv, depth, { skipRootOptions: true });
+}
+function getCommandPathInternal(argv, depth, opts) {
+	const args = argv.slice(2);
+	const path = [];
+	for (let i = 0; i < args.length; i += 1) {
+		const arg = args[i];
+		if (!arg) continue;
+		if (arg === "--") break;
+		if (opts.skipRootOptions) {
+			const consumed = consumeRootOptionToken(args, i);
+			if (consumed > 0) {
+				i += consumed - 1;
+				continue;
+			}
+		}
+		if (arg.startsWith("-")) continue;
+		path.push(arg);
+		if (path.length >= depth) break;
+	}
+	return path;
+}
+
+//#endregion
+//#region src/infra/tmp-openclaw-dir.ts
+const POSIX_OPENCLAW_TMP_DIR = "/tmp/openclaw";
+const TMP_DIR_ACCESS_MODE = fs.constants.W_OK | fs.constants.X_OK;
+function isNodeErrorWithCode(err, code) {
+	return typeof err === "object" && err !== null && "code" in err && err.code === code;
+}
+function resolvePreferredOpenClawTmpDir(options = {}) {
+	const accessSync = options.accessSync ?? fs.accessSync;
+	const chmodSync = options.chmodSync ?? fs.chmodSync;
+	const lstatSync = options.lstatSync ?? fs.lstatSync;
+	const mkdirSync = options.mkdirSync ?? fs.mkdirSync;
+	const warn = options.warn ?? ((message) => console.warn(message));
+	const getuid = options.getuid ?? (() => {
+		try {
+			return typeof process.getuid === "function" ? process.getuid() : void 0;
+		} catch {
+			return;
+		}
+	});
+	const tmpdir = options.tmpdir ?? os.tmpdir;
+	const uid = getuid();
+	const isSecureDirForUser = (st) => {
+		if (uid === void 0) return true;
+		if (typeof st.uid === "number" && st.uid !== uid) return false;
+		if (typeof st.mode === "number" && (st.mode & 18) !== 0) return false;
+		return true;
+	};
+	const fallback = () => {
+		const base = tmpdir();
+		const suffix = uid === void 0 ? "openclaw" : `openclaw-${uid}`;
+		return path.join(base, suffix);
+	};
+	const isTrustedTmpDir = (st) => {
+		return st.isDirectory() && !st.isSymbolicLink() && isSecureDirForUser(st);
+	};
+	const resolveDirState = (candidatePath) => {
+		try {
+			if (!isTrustedTmpDir(lstatSync(candidatePath))) return "invalid";
+			accessSync(candidatePath, TMP_DIR_ACCESS_MODE);
+			return "available";
+		} catch (err) {
+			if (isNodeErrorWithCode(err, "ENOENT")) return "missing";
+			return "invalid";
+		}
+	};
+	const tryRepairWritableBits = (candidatePath) => {
+		try {
+			const st = lstatSync(candidatePath);
+			if (!st.isDirectory() || st.isSymbolicLink()) return false;
+			if (uid !== void 0 && typeof st.uid === "number" && st.uid !== uid) return false;
+			if (typeof st.mode !== "number" || (st.mode & 18) === 0) return false;
+			chmodSync(candidatePath, 448);
+			warn(`[openclaw] tightened permissions on temp dir: ${candidatePath}`);
+			return resolveDirState(candidatePath) === "available";
+		} catch {
+			return false;
+		}
+	};
+	const ensureTrustedFallbackDir = () => {
+		const fallbackPath = fallback();
+		const state = resolveDirState(fallbackPath);
+		if (state === "available") return fallbackPath;
+		if (state === "invalid") {
+			if (tryRepairWritableBits(fallbackPath)) return fallbackPath;
+			throw new Error(`Unsafe fallback OpenClaw temp dir: ${fallbackPath}`);
+		}
+		try {
+			mkdirSync(fallbackPath, {
+				recursive: true,
+				mode: 448
+			});
+			chmodSync(fallbackPath, 448);
+		} catch {
+			throw new Error(`Unable to create fallback OpenClaw temp dir: ${fallbackPath}`);
+		}
+		if (resolveDirState(fallbackPath) !== "available" && !tryRepairWritableBits(fallbackPath)) throw new Error(`Unsafe fallback OpenClaw temp dir: ${fallbackPath}`);
+		return fallbackPath;
+	};
+	const existingPreferredState = resolveDirState(POSIX_OPENCLAW_TMP_DIR);
+	if (existingPreferredState === "available") return POSIX_OPENCLAW_TMP_DIR;
+	if (existingPreferredState === "invalid") {
+		if (tryRepairWritableBits(POSIX_OPENCLAW_TMP_DIR)) return POSIX_OPENCLAW_TMP_DIR;
+		return ensureTrustedFallbackDir();
+	}
+	try {
+		accessSync("/tmp", TMP_DIR_ACCESS_MODE);
+		mkdirSync(POSIX_OPENCLAW_TMP_DIR, {
+			recursive: true,
+			mode: 448
+		});
+		chmodSync(POSIX_OPENCLAW_TMP_DIR, 448);
+		if (resolveDirState(POSIX_OPENCLAW_TMP_DIR) !== "available" && !tryRepairWritableBits(POSIX_OPENCLAW_TMP_DIR)) return ensureTrustedFallbackDir();
+		return POSIX_OPENCLAW_TMP_DIR;
+	} catch {
+		return ensureTrustedFallbackDir();
+	}
+}
+
+//#endregion
+//#region src/utils.ts
+async function ensureDir(dir) {
+	await fs.promises.mkdir(dir, { recursive: true });
+}
+/**
+* Check if a file or directory exists at the given path.
+*/
+async function pathExists$1(targetPath) {
+	try {
+		await fs.promises.access(targetPath);
+		return true;
+	} catch {
+		return false;
+	}
+}
+function clampNumber(value, min, max) {
+	return Math.max(min, Math.min(max, value));
+}
+function clampInt(value, min, max) {
+	return clampNumber(Math.floor(value), min, max);
+}
+/**
+* Escapes special regex characters in a string so it can be used in a RegExp constructor.
+*/
+function escapeRegExp(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/**
+* Safely parse JSON, returning null on error instead of throwing.
+*/
+function safeParseJson(raw) {
+	try {
+		return JSON.parse(raw);
+	} catch {
+		return null;
+	}
+}
+/**
+* Type guard for Record<string, unknown> (less strict than isPlainObject).
+* Accepts any non-null object that isn't an array.
+*/
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function normalizeE164(number) {
+	const digits = number.replace(/^whatsapp:/, "").trim().replace(/[^\d+]/g, "");
+	if (digits.startsWith("+")) return `+${digits.slice(1)}`;
+	return `+${digits}`;
+}
+function sleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function isHighSurrogate(codeUnit) {
+	return codeUnit >= 55296 && codeUnit <= 56319;
+}
+function isLowSurrogate(codeUnit) {
+	return codeUnit >= 56320 && codeUnit <= 57343;
+}
+function sliceUtf16Safe(input, start, end) {
+	const len = input.length;
+	let from = start < 0 ? Math.max(len + start, 0) : Math.min(start, len);
+	let to = end === void 0 ? len : end < 0 ? Math.max(len + end, 0) : Math.min(end, len);
+	if (to < from) {
+		const tmp = from;
+		from = to;
+		to = tmp;
+	}
+	if (from > 0 && from < len) {
+		if (isLowSurrogate(input.charCodeAt(from)) && isHighSurrogate(input.charCodeAt(from - 1))) from += 1;
+	}
+	if (to > 0 && to < len) {
+		if (isHighSurrogate(input.charCodeAt(to - 1)) && isLowSurrogate(input.charCodeAt(to))) to -= 1;
+	}
+	return input.slice(from, to);
+}
+function truncateUtf16Safe(input, maxLen) {
+	const limit = Math.max(0, Math.floor(maxLen));
+	if (input.length <= limit) return input;
+	return sliceUtf16Safe(input, 0, limit);
+}
+function resolveUserPath(input) {
+	if (!input) return "";
+	const trimmed = input.trim();
+	if (!trimmed) return trimmed;
+	if (trimmed.startsWith("~")) {
+		const expanded = expandHomePrefix(trimmed, {
+			home: resolveRequiredHomeDir(process.env, os.homedir),
+			env: process.env,
+			homedir: os.homedir
+		});
+		return path.resolve(expanded);
+	}
+	return path.resolve(trimmed);
+}
+function resolveConfigDir(env = process.env, homedir = os.homedir) {
+	const override = env.OPENCLAW_STATE_DIR?.trim() || env.CLAWDBOT_STATE_DIR?.trim();
+	if (override) return resolveUserPath(override);
+	const newDir = path.join(resolveRequiredHomeDir(env, homedir), ".openclaw");
+	try {
+		if (fs.existsSync(newDir)) return newDir;
+	} catch {}
+	return newDir;
+}
+function resolveHomeDir() {
+	return resolveEffectiveHomeDir(process.env, os.homedir);
+}
+function resolveHomeDisplayPrefix() {
+	const home = resolveHomeDir();
+	if (!home) return;
+	if (process.env.OPENCLAW_HOME?.trim()) return {
+		home,
+		prefix: "$OPENCLAW_HOME"
+	};
+	return {
+		home,
+		prefix: "~"
+	};
+}
+function shortenHomePath(input) {
+	if (!input) return input;
+	const display = resolveHomeDisplayPrefix();
+	if (!display) return input;
+	const { home, prefix } = display;
+	if (input === home) return prefix;
+	if (input.startsWith(`${home}/`) || input.startsWith(`${home}\\`)) return `${prefix}${input.slice(home.length)}`;
+	return input;
+}
+function shortenHomeInString(input) {
+	if (!input) return input;
+	const display = resolveHomeDisplayPrefix();
+	if (!display) return input;
+	return input.split(display.home).join(display.prefix);
+}
+function formatTerminalLink(label, url, opts) {
+	const esc = "\x1B";
+	const safeLabel = label.replaceAll(esc, "");
+	const safeUrl = url.replaceAll(esc, "");
+	if (!(opts?.force === true ? true : opts?.force === false ? false : Boolean(process.stdout.isTTY))) return opts?.fallback ?? `${safeLabel} (${safeUrl})`;
+	return `\u001b]8;;${safeUrl}\u0007${safeLabel}\u001b]8;;\u0007`;
+}
+const CONFIG_DIR = resolveConfigDir();
+
+//#endregion
+//#region src/config/env-substitution.ts
+/**
+* Environment variable substitution for config values.
+*
+* Supports `${VAR_NAME}` syntax in string values, substituted at config load time.
+* - Only uppercase env vars are matched: `[A-Z_][A-Z0-9_]*`
+* - Escape with `$${}` to output literal `${}`
+* - Missing env vars throw `MissingEnvVarError` with context
+*
+* @example
+* ```json5
+* {
+*   models: {
+*     providers: {
+*       "vercel-gateway": {
+*         apiKey: "${VERCEL_GATEWAY_API_KEY}"
+*       }
+*     }
+*   }
+* }
+* ```
+*/
+const ENV_VAR_NAME_PATTERN = /^[A-Z_][A-Z0-9_]*$/;
+var MissingEnvVarError = class extends Error {
+	constructor(varName, configPath) {
+		super(`Missing env var "${varName}" referenced at config path: ${configPath}`);
+		this.varName = varName;
+		this.configPath = configPath;
+		this.name = "MissingEnvVarError";
+	}
+};
+function parseEnvTokenAt(value, index) {
+	if (value[index] !== "$") return null;
+	const next = value[index + 1];
+	const afterNext = value[index + 2];
+	if (next === "$" && afterNext === "{") {
+		const start = index + 3;
+		const end = value.indexOf("}", start);
+		if (end !== -1) {
+			const name = value.slice(start, end);
+			if (ENV_VAR_NAME_PATTERN.test(name)) return {
+				kind: "escaped",
+				name,
+				end
+			};
+		}
+	}
+	if (next === "{") {
+		const start = index + 2;
+		const end = value.indexOf("}", start);
+		if (end !== -1) {
+			const name = value.slice(start, end);
+			if (ENV_VAR_NAME_PATTERN.test(name)) return {
+				kind: "substitution",
+				name,
+				end
+			};
+		}
+	}
+	return null;
+}
+function substituteString(value, env, configPath) {
+	if (!value.includes("$")) return value;
+	const chunks = [];
+	for (let i = 0; i < value.length; i += 1) {
+		const char = value[i];
+		if (char !== "$") {
+			chunks.push(char);
+			continue;
+		}
+		const token = parseEnvTokenAt(value, i);
+		if (token?.kind === "escaped") {
+			chunks.push(`\${${token.name}}`);
+			i = token.end;
+			continue;
+		}
+		if (token?.kind === "substitution") {
+			const envValue = env[token.name];
+			if (envValue === void 0 || envValue === "") throw new MissingEnvVarError(token.name, configPath);
+			chunks.push(envValue);
+			i = token.end;
+			continue;
+		}
+		chunks.push(char);
+	}
+	return chunks.join("");
+}
+function containsEnvVarReference(value) {
+	if (!value.includes("$")) return false;
+	for (let i = 0; i < value.length; i += 1) {
+		if (value[i] !== "$") continue;
+		const token = parseEnvTokenAt(value, i);
+		if (token?.kind === "escaped") {
+			i = token.end;
+			continue;
+		}
+		if (token?.kind === "substitution") return true;
+	}
+	return false;
+}
+function substituteAny(value, env, path) {
+	if (typeof value === "string") return substituteString(value, env, path);
+	if (Array.isArray(value)) return value.map((item, index) => substituteAny(item, env, `${path}[${index}]`));
+	if (isPlainObject(value)) {
+		const result = {};
+		for (const [key, val] of Object.entries(value)) result[key] = substituteAny(val, env, path ? `${path}.${key}` : key);
+		return result;
+	}
+	return value;
+}
+/**
+* Resolves `${VAR_NAME}` environment variable references in config values.
+*
+* @param obj - The parsed config object (after JSON5 parse and $include resolution)
+* @param env - Environment variables to use for substitution (defaults to process.env)
+* @returns The config object with env vars substituted
+* @throws {MissingEnvVarError} If a referenced env var is not set or empty
+*/
+function resolveConfigEnvVars(obj, env = process.env) {
+	return substituteAny(obj, env, "");
+}
+
+//#endregion
+//#region src/infra/host-env-security-policy.json
+var host_env_security_policy_default = {
+	blockedKeys: [
+		"NODE_OPTIONS",
+		"NODE_PATH",
+		"PYTHONHOME",
+		"PYTHONPATH",
+		"PERL5LIB",
+		"PERL5OPT",
+		"RUBYLIB",
+		"RUBYOPT",
+		"BASH_ENV",
+		"ENV",
+		"GIT_EXTERNAL_DIFF",
+		"SHELL",
+		"SHELLOPTS",
+		"PS4",
+		"GCONV_PATH",
+		"IFS",
+		"SSLKEYLOGFILE"
+	],
+	blockedOverrideKeys: ["HOME", "ZDOTDIR"],
+	blockedPrefixes: [
+		"DYLD_",
+		"LD_",
+		"BASH_FUNC_"
+	]
+};
+
+//#endregion
+//#region src/infra/host-env-security.ts
+const PORTABLE_ENV_VAR_KEY = /^[A-Za-z_][A-Za-z0-9_]*$/;
+const HOST_ENV_SECURITY_POLICY = host_env_security_policy_default;
+const HOST_DANGEROUS_ENV_KEY_VALUES = Object.freeze(HOST_ENV_SECURITY_POLICY.blockedKeys.map((key) => key.toUpperCase()));
+const HOST_DANGEROUS_ENV_PREFIXES = Object.freeze(HOST_ENV_SECURITY_POLICY.blockedPrefixes.map((prefix) => prefix.toUpperCase()));
+const HOST_DANGEROUS_OVERRIDE_ENV_KEY_VALUES = Object.freeze((HOST_ENV_SECURITY_POLICY.blockedOverrideKeys ?? []).map((key) => key.toUpperCase()));
+const HOST_SHELL_WRAPPER_ALLOWED_OVERRIDE_ENV_KEY_VALUES = Object.freeze([
+	"TERM",
+	"LANG",
+	"LC_ALL",
+	"LC_CTYPE",
+	"LC_MESSAGES",
+	"COLORTERM",
+	"NO_COLOR",
+	"FORCE_COLOR"
+]);
+const HOST_DANGEROUS_ENV_KEYS = new Set(HOST_DANGEROUS_ENV_KEY_VALUES);
+const HOST_DANGEROUS_OVERRIDE_ENV_KEYS = new Set(HOST_DANGEROUS_OVERRIDE_ENV_KEY_VALUES);
+const HOST_SHELL_WRAPPER_ALLOWED_OVERRIDE_ENV_KEYS = new Set(HOST_SHELL_WRAPPER_ALLOWED_OVERRIDE_ENV_KEY_VALUES);
+function normalizeEnvVarKey(rawKey, options) {
+	const key = rawKey.trim();
+	if (!key) return null;
+	if (options?.portable && !PORTABLE_ENV_VAR_KEY.test(key)) return null;
+	return key;
+}
+function isDangerousHostEnvVarName(rawKey) {
+	const key = normalizeEnvVarKey(rawKey);
+	if (!key) return false;
+	const upper = key.toUpperCase();
+	if (HOST_DANGEROUS_ENV_KEYS.has(upper)) return true;
+	return HOST_DANGEROUS_ENV_PREFIXES.some((prefix) => upper.startsWith(prefix));
+}
+function isDangerousHostEnvOverrideVarName(rawKey) {
+	const key = normalizeEnvVarKey(rawKey);
+	if (!key) return false;
+	return HOST_DANGEROUS_OVERRIDE_ENV_KEYS.has(key.toUpperCase());
+}
+function sanitizeHostExecEnv(params) {
+	const baseEnv = params?.baseEnv ?? process.env;
+	const overrides = params?.overrides ?? void 0;
+	const blockPathOverrides = params?.blockPathOverrides ?? true;
+	const merged = {};
+	for (const [rawKey, value] of Object.entries(baseEnv)) {
+		if (typeof value !== "string") continue;
+		const key = normalizeEnvVarKey(rawKey, { portable: true });
+		if (!key || isDangerousHostEnvVarName(key)) continue;
+		merged[key] = value;
+	}
+	if (!overrides) return merged;
+	for (const [rawKey, value] of Object.entries(overrides)) {
+		if (typeof value !== "string") continue;
+		const key = normalizeEnvVarKey(rawKey, { portable: true });
+		if (!key) continue;
+		const upper = key.toUpperCase();
+		if (blockPathOverrides && upper === "PATH") continue;
+		if (isDangerousHostEnvVarName(upper) || isDangerousHostEnvOverrideVarName(upper)) continue;
+		merged[key] = value;
+	}
+	return merged;
+}
+
+//#endregion
+//#region src/config/env-vars.ts
+function isBlockedConfigEnvVar(key) {
+	return isDangerousHostEnvVarName(key) || isDangerousHostEnvOverrideVarName(key);
+}
+function collectConfigEnvVarsByTarget(cfg) {
+	const envConfig = cfg?.env;
+	if (!envConfig) return {};
+	const entries = {};
+	if (envConfig.vars) for (const [rawKey, value] of Object.entries(envConfig.vars)) {
+		if (!value) continue;
+		const key = normalizeEnvVarKey(rawKey, { portable: true });
+		if (!key) continue;
+		if (isBlockedConfigEnvVar(key)) continue;
+		entries[key] = value;
+	}
+	for (const [rawKey, value] of Object.entries(envConfig)) {
+		if (rawKey === "shellEnv" || rawKey === "vars") continue;
+		if (typeof value !== "string" || !value.trim()) continue;
+		const key = normalizeEnvVarKey(rawKey, { portable: true });
+		if (!key) continue;
+		if (isBlockedConfigEnvVar(key)) continue;
+		entries[key] = value;
+	}
+	return entries;
+}
+function collectConfigRuntimeEnvVars(cfg) {
+	return collectConfigEnvVarsByTarget(cfg);
+}
+function applyConfigEnvVars(cfg, env = process.env) {
+	const entries = collectConfigRuntimeEnvVars(cfg);
+	for (const [key, value] of Object.entries(entries)) {
+		if (env[key]?.trim()) continue;
+		env[key] = value;
+	}
+}
+
+//#endregion
+//#region src/infra/path-guards.ts
+const NOT_FOUND_CODES = new Set(["ENOENT", "ENOTDIR"]);
+const SYMLINK_OPEN_CODES = new Set([
+	"ELOOP",
+	"EINVAL",
+	"ENOTSUP"
+]);
+function normalizeWindowsPathForComparison(input) {
+	let normalized = path.win32.normalize(input);
+	if (normalized.startsWith("\\\\?\\")) {
+		normalized = normalized.slice(4);
+		if (normalized.toUpperCase().startsWith("UNC\\")) normalized = `\\\\${normalized.slice(4)}`;
+	}
+	return normalized.replaceAll("/", "\\").toLowerCase();
+}
+function isNodeError(value) {
+	return Boolean(value && typeof value === "object" && "code" in value);
+}
+function hasNodeErrorCode(value, code) {
+	return isNodeError(value) && value.code === code;
+}
+function 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 isPathInside$1(root, target) {
+	const resolvedRoot = path.resolve(root);
+	const resolvedTarget = path.resolve(target);
+	if (process.platform === "win32") {
+		const rootForCompare = normalizeWindowsPathForComparison(resolvedRoot);
+		const targetForCompare = normalizeWindowsPathForComparison(resolvedTarget);
+		const relative = path.win32.relative(rootForCompare, targetForCompare);
+		return relative === "" || !relative.startsWith("..") && !path.win32.isAbsolute(relative);
+	}
+	const relative = path.relative(resolvedRoot, resolvedTarget);
+	return relative === "" || !relative.startsWith("..") && !path.isAbsolute(relative);
+}
+
+//#endregion
+//#region src/infra/boundary-path.ts
+const BOUNDARY_PATH_ALIAS_POLICIES = {
+	strict: Object.freeze({
+		allowFinalSymlinkForUnlink: false,
+		allowFinalHardlinkForUnlink: false
+	}),
+	unlinkTarget: Object.freeze({
+		allowFinalSymlinkForUnlink: true,
+		allowFinalHardlinkForUnlink: true
+	})
+};
+async function resolveBoundaryPath(params) {
+	const rootPath = path.resolve(params.rootPath);
+	const absolutePath = path.resolve(params.absolutePath);
+	const context = createBoundaryResolutionContext({
+		resolveParams: params,
+		rootPath,
+		absolutePath,
+		rootCanonicalPath: params.rootCanonicalPath ? path.resolve(params.rootCanonicalPath) : await resolvePathViaExistingAncestor(rootPath),
+		outsideLexicalCanonicalPath: await resolveOutsideLexicalCanonicalPathAsync({
+			rootPath,
+			absolutePath
+		})
+	});
+	const outsideResult = await resolveOutsideBoundaryPathAsync({
+		boundaryLabel: params.boundaryLabel,
+		context
+	});
+	if (outsideResult) return outsideResult;
+	return resolveBoundaryPathLexicalAsync({
+		params,
+		absolutePath: context.absolutePath,
+		rootPath: context.rootPath,
+		rootCanonicalPath: context.rootCanonicalPath
+	});
+}
+function resolveBoundaryPathSync(params) {
+	const rootPath = path.resolve(params.rootPath);
+	const absolutePath = path.resolve(params.absolutePath);
+	const context = createBoundaryResolutionContext({
+		resolveParams: params,
+		rootPath,
+		absolutePath,
+		rootCanonicalPath: params.rootCanonicalPath ? path.resolve(params.rootCanonicalPath) : resolvePathViaExistingAncestorSync(rootPath),
+		outsideLexicalCanonicalPath: resolveOutsideLexicalCanonicalPathSync({
+			rootPath,
+			absolutePath
+		})
+	});
+	const outsideResult = resolveOutsideBoundaryPathSync({
+		boundaryLabel: params.boundaryLabel,
+		context
+	});
+	if (outsideResult) return outsideResult;
+	return resolveBoundaryPathLexicalSync({
+		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) {
+	return {
+		segments: path.relative(params.rootPath, params.absolutePath).split(path.sep).filter(Boolean),
+		allowFinalSymlink: params.params.policy?.allowFinalSymlinkForUnlink === true,
+		canonicalCursor: params.rootCanonicalPath,
+		lexicalCursor: params.rootPath,
+		preserveFinalSymlink: false
+	};
+}
+function assertLexicalCursorInsideBoundary(params) {
+	assertInsideBoundary({
+		boundaryLabel: params.params.boundaryLabel,
+		rootCanonicalPath: params.rootCanonicalPath,
+		candidatePath: params.candidatePath,
+		absolutePath: params.absolutePath
+	});
+}
+function applyMissingSuffixToCanonicalCursor(params) {
+	const missingSuffix = params.state.segments.slice(params.missingFromIndex);
+	params.state.canonicalCursor = path.resolve(params.state.canonicalCursor, ...missingSuffix);
+	assertLexicalCursorInsideBoundary({
+		params: params.params,
+		rootCanonicalPath: params.rootCanonicalPath,
+		candidatePath: params.state.canonicalCursor,
+		absolutePath: params.absolutePath
+	});
+}
+function advanceCanonicalCursorForSegment(params) {
+	params.state.canonicalCursor = path.resolve(params.state.canonicalCursor, params.segment);
+	assertLexicalCursorInsideBoundary({
+		params: params.params,
+		rootCanonicalPath: params.rootCanonicalPath,
+		candidatePath: params.state.canonicalCursor,
+		absolutePath: params.absolutePath
+	});
+}
+function finalizeLexicalResolution(params) {
+	assertLexicalCursorInsideBoundary({
+		params: params.params,
+		rootCanonicalPath: params.rootCanonicalPath,
+		candidatePath: params.state.canonicalCursor,
+		absolutePath: params.absolutePath
+	});
+	return buildResolvedBoundaryPath({
+		absolutePath: params.absolutePath,
+		canonicalPath: params.state.canonicalCursor,
+		rootPath: params.rootPath,
+		rootCanonicalPath: params.rootCanonicalPath,
+		kind: params.kind
+	});
+}
+function handleLexicalLstatFailure(params) {
+	if (!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 (!isPathInside$1(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 = path.join(state.lexicalCursor, segment);
+		yield {
+			idx,
+			segment,
+			isLast
+		};
+	}
+}
+async function resolveBoundaryPathLexicalAsync(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) => fs$1.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 resolveBoundaryPathLexicalSync(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;
+		if (isPromiseLike(resolveAndApplySymlinkHop({
+			state,
+			rootCanonicalPath: params.rootCanonicalPath,
+			boundaryLabel: params.params.boundaryLabel,
+			resolveLinkCanonical: (cursor) => resolveSymlinkHopPathSync(cursor)
+		}))) 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 = isPathInside$1(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 resolveOutsideBoundaryPathAsync(params) {
+	if (params.context.lexicalInside) return null;
+	const kind = await getPathKind(params.context.absolutePath, false);
+	return buildOutsideLexicalBoundaryPath({
+		boundaryLabel: params.boundaryLabel,
+		rootCanonicalPath: params.context.rootCanonicalPath,
+		absolutePath: params.context.absolutePath,
+		canonicalOutsideLexicalPath: params.context.canonicalOutsideLexicalPath,
+		rootPath: params.context.rootPath,
+		kind
+	});
+}
+function resolveOutsideBoundaryPathSync(params) {
+	if (params.context.lexicalInside) return null;
+	const kind = getPathKindSync(params.context.absolutePath, false);
+	return buildOutsideLexicalBoundaryPath({
+		boundaryLabel: params.boundaryLabel,
+		rootCanonicalPath: params.context.rootCanonicalPath,
+		absolutePath: params.context.absolutePath,
+		canonicalOutsideLexicalPath: params.context.canonicalOutsideLexicalPath,
+		rootPath: params.context.rootPath,
+		kind
+	});
+}
+async function resolveOutsideLexicalCanonicalPathAsync(params) {
+	if (isPathInside$1(params.rootPath, params.absolutePath)) return;
+	return await resolvePathViaExistingAncestor(params.absolutePath);
+}
+function resolveOutsideLexicalCanonicalPathSync(params) {
+	if (isPathInside$1(params.rootPath, params.absolutePath)) return;
+	return resolvePathViaExistingAncestorSync(params.absolutePath);
+}
+function buildOutsideLexicalBoundaryPath(params) {
+	assertInsideBoundary({
+		boundaryLabel: params.boundaryLabel,
+		rootCanonicalPath: params.rootCanonicalPath,
+		candidatePath: params.canonicalOutsideLexicalPath,
+		absolutePath: params.absolutePath
+	});
+	return buildResolvedBoundaryPath({
+		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 (isPathInside$1(params.rootCanonicalPath, params.canonicalOutsideLexicalPath)) return;
+	throw pathEscapeError({
+		boundaryLabel: params.boundaryLabel,
+		rootPath: params.rootPath,
+		absolutePath: params.absolutePath
+	});
+}
+function buildResolvedBoundaryPath(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 = path.resolve(targetPath);
+	let cursor = normalized;
+	const missingSuffix = [];
+	while (!isFilesystemRoot(cursor) && !await pathExists(cursor)) {
+		missingSuffix.unshift(path.basename(cursor));
+		const parent = path.dirname(cursor);
+		if (parent === cursor) break;
+		cursor = parent;
+	}
+	if (!await pathExists(cursor)) return normalized;
+	try {
+		const resolvedAncestor = path.resolve(await fs$1.realpath(cursor));
+		if (missingSuffix.length === 0) return resolvedAncestor;
+		return path.resolve(resolvedAncestor, ...missingSuffix);
+	} catch {
+		return normalized;
+	}
+}
+function resolvePathViaExistingAncestorSync(targetPath) {
+	const normalized = path.resolve(targetPath);
+	let cursor = normalized;
+	const missingSuffix = [];
+	while (!isFilesystemRoot(cursor) && !fs.existsSync(cursor)) {
+		missingSuffix.unshift(path.basename(cursor));
+		const parent = path.dirname(cursor);
+		if (parent === cursor) break;
+		cursor = parent;
+	}
+	if (!fs.existsSync(cursor)) return normalized;
+	try {
+		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 {
+		return {
+			exists: true,
+			kind: toResolvedKind(preserveFinalSymlink ? await fs$1.lstat(absolutePath) : await fs$1.stat(absolutePath))
+		};
+	} catch (error) {
+		if (isNotFoundPathError(error)) return {
+			exists: false,
+			kind: "missing"
+		};
+		throw error;
+	}
+}
+function getPathKindSync(absolutePath, preserveFinalSymlink) {
+	try {
+		return {
+			exists: true,
+			kind: toResolvedKind(preserveFinalSymlink ? fs.lstatSync(absolutePath) : fs.statSync(absolutePath))
+		};
+	} 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 = path.relative(path.resolve(rootPath), path.resolve(targetPath));
+	if (!relative || relative === ".") return "";
+	if (relative.startsWith("..") || path.isAbsolute(relative)) return "";
+	return relative;
+}
+function assertInsideBoundary(params) {
+	if (isPathInside$1(params.rootCanonicalPath, params.candidatePath)) return;
+	throw new Error(`Path resolves outside ${params.boundaryLabel} (${shortPath(params.rootCanonicalPath)}): ${shortPath(params.absolutePath)}`);
+}
+function pathEscapeError(params) {
+	return /* @__PURE__ */ new Error(`Path escapes ${params.boundaryLabel} (${shortPath(params.rootPath)}): ${shortPath(params.absolutePath)}`);
+}
+function symlinkEscapeError(params) {
+	return /* @__PURE__ */ new Error(`Symlink escapes ${params.boundaryLabel} (${shortPath(params.rootCanonicalPath)}): ${shortPath(params.symlinkPath)}`);
+}
+function shortPath(value) {
+	const home = os.homedir();
+	if (value.startsWith(home)) return `~${value.slice(home.length)}`;
+	return value;
+}
+function isFilesystemRoot(candidate) {
+	return path.parse(candidate).root === candidate;
+}
+async function pathExists(targetPath) {
+	try {
+		await fs$1.lstat(targetPath);
+		return true;
+	} catch (error) {
+		if (isNotFoundPathError(error)) return false;
+		throw error;
+	}
+}
+async function resolveSymlinkHopPath(symlinkPath) {
+	try {
+		return path.resolve(await fs$1.realpath(symlinkPath));
+	} catch (error) {
+		if (!isNotFoundPathError(error)) throw error;
+		const linkTarget = await fs$1.readlink(symlinkPath);
+		return resolvePathViaExistingAncestor(path.resolve(path.dirname(symlinkPath), linkTarget));
+	}
+}
+function resolveSymlinkHopPathSync(symlinkPath) {
+	try {
+		return path.resolve(fs.realpathSync(symlinkPath));
+	} catch (error) {
+		if (!isNotFoundPathError(error)) throw error;
+		const linkTarget = fs.readlinkSync(symlinkPath);
+		return resolvePathViaExistingAncestorSync(path.resolve(path.dirname(symlinkPath), linkTarget));
+	}
+}
+
+//#endregion
+//#region src/infra/file-identity.ts
+function isZero(value) {
+	return value === 0 || value === 0n;
+}
+function sameFileIdentity$1(left, right, platform = process.platform) {
+	if (left.ino !== right.ino) return false;
+	if (left.dev === right.dev) return true;
+	return platform === "win32" && (isZero(left.dev) || isZero(right.dev));
+}
+
+//#endregion
+//#region src/infra/safe-open-sync.ts
+function isExpectedPathError(error) {
+	const code = typeof error === "object" && error !== null && "code" in error ? String(error.code) : "";
+	return code === "ENOENT" || code === "ENOTDIR" || code === "ELOOP";
+}
+function sameFileIdentity(left, right) {
+	return sameFileIdentity$1(left, right);
+}
+function openVerifiedFileSync(params) {
+	const ioFs = params.ioFs ?? fs;
+	const allowedType = params.allowedType ?? "file";
+	const openReadFlags = ioFs.constants.O_RDONLY | (typeof ioFs.constants.O_NOFOLLOW === "number" ? ioFs.constants.O_NOFOLLOW : 0);
+	let fd = null;
+	try {
+		if (params.rejectPathSymlink) {
+			if (ioFs.lstatSync(params.filePath).isSymbolicLink()) return {
+				ok: false,
+				reason: "validation"
+			};
+		}
+		const realPath = params.resolvedPath ?? ioFs.realpathSync(params.filePath);
+		const preOpenStat = ioFs.lstatSync(realPath);
+		if (!isAllowedType(preOpenStat, allowedType)) return {
+			ok: false,
+			reason: "validation"
+		};
+		if (params.rejectHardlinks && preOpenStat.isFile() && preOpenStat.nlink > 1) return {
+			ok: false,
+			reason: "validation"
+		};
+		if (params.maxBytes !== void 0 && preOpenStat.isFile() && preOpenStat.size > params.maxBytes) return {
+			ok: false,
+			reason: "validation"
+		};
+		fd = ioFs.openSync(realPath, openReadFlags);
+		const openedStat = ioFs.fstatSync(fd);
+		if (!isAllowedType(openedStat, allowedType)) return {
+			ok: false,
+			reason: "validation"
+		};
+		if (params.rejectHardlinks && openedStat.isFile() && openedStat.nlink > 1) return {
+			ok: false,
+			reason: "validation"
+		};
+		if (params.maxBytes !== void 0 && openedStat.isFile() && openedStat.size > params.maxBytes) return {
+			ok: false,
+			reason: "validation"
+		};
+		if (!sameFileIdentity(preOpenStat, openedStat)) return {
+			ok: false,
+			reason: "validation"
+		};
+		const opened = {
+			ok: true,
+			path: realPath,
+			fd,
+			stat: openedStat
+		};
+		fd = null;
+		return opened;
+	} catch (error) {
+		if (isExpectedPathError(error)) return {
+			ok: false,
+			reason: "path",
+			error
+		};
+		return {
+			ok: false,
+			reason: "io",
+			error
+		};
+	} finally {
+		if (fd !== null) ioFs.closeSync(fd);
+	}
+}
+function isAllowedType(stat, allowedType) {
+	if (allowedType === "directory") return stat.isDirectory();
+	return stat.isFile();
+}
+
+//#endregion
+//#region src/infra/boundary-file-read.ts
+function canUseBoundaryFileOpen(ioFs) {
+	return typeof ioFs.openSync === "function" && typeof ioFs.closeSync === "function" && typeof ioFs.fstatSync === "function" && typeof ioFs.lstatSync === "function" && typeof ioFs.realpathSync === "function" && typeof ioFs.readFileSync === "function" && typeof ioFs.constants === "object" && ioFs.constants !== null;
+}
+function openBoundaryFileSync(params) {
+	const ioFs = params.ioFs ?? fs;
+	const resolved = resolveBoundaryFilePathGeneric({
+		absolutePath: params.absolutePath,
+		resolve: (absolutePath) => resolveBoundaryPathSync({
+			absolutePath,
+			rootPath: params.rootPath,
+			rootCanonicalPath: params.rootRealPath,
+			boundaryLabel: params.boundaryLabel,
+			skipLexicalRootCheck: params.skipLexicalRootCheck
+		})
+	});
+	if (resolved instanceof Promise) return toBoundaryValidationError(/* @__PURE__ */ new Error("Unexpected async boundary resolution"));
+	return finalizeBoundaryFileOpen({
+		resolved,
+		maxBytes: params.maxBytes,
+		rejectHardlinks: params.rejectHardlinks,
+		allowedType: params.allowedType,
+		ioFs
+	});
+}
+function openBoundaryFileResolved(params) {
+	const opened = openVerifiedFileSync({
+		filePath: params.absolutePath,
+		resolvedPath: params.resolvedPath,
+		rejectHardlinks: params.rejectHardlinks ?? true,
+		maxBytes: params.maxBytes,
+		allowedType: params.allowedType,
+		ioFs: params.ioFs
+	});
+	if (!opened.ok) return opened;
+	return {
+		ok: true,
+		path: opened.path,
+		fd: opened.fd,
+		stat: opened.stat,
+		rootRealPath: params.rootRealPath
+	};
+}
+function finalizeBoundaryFileOpen(params) {
+	if ("ok" in params.resolved) return params.resolved;
+	return openBoundaryFileResolved({
+		absolutePath: params.resolved.absolutePath,
+		resolvedPath: params.resolved.resolvedPath,
+		rootRealPath: params.resolved.rootRealPath,
+		maxBytes: params.maxBytes,
+		rejectHardlinks: params.rejectHardlinks,
+		allowedType: params.allowedType,
+		ioFs: params.ioFs
+	});
+}
+async function openBoundaryFile(params) {
+	const ioFs = params.ioFs ?? fs;
+	const maybeResolved = resolveBoundaryFilePathGeneric({
+		absolutePath: params.absolutePath,
+		resolve: (absolutePath) => resolveBoundaryPath({
+			absolutePath,
+			rootPath: params.rootPath,
+			rootCanonicalPath: params.rootRealPath,
+			boundaryLabel: params.boundaryLabel,
+			policy: params.aliasPolicy,
+			skipLexicalRootCheck: params.skipLexicalRootCheck
+		})
+	});
+	return finalizeBoundaryFileOpen({
+		resolved: maybeResolved instanceof Promise ? await maybeResolved : maybeResolved,
+		maxBytes: params.maxBytes,
+		rejectHardlinks: params.rejectHardlinks,
+		allowedType: params.allowedType,
+		ioFs
+	});
+}
+function toBoundaryValidationError(error) {
+	return {
+		ok: false,
+		reason: "validation",
+		error
+	};
+}
+function mapResolvedBoundaryPath(absolutePath, resolved) {
+	return {
+		absolutePath,
+		resolvedPath: resolved.canonicalPath,
+		rootRealPath: resolved.rootCanonicalPath
+	};
+}
+function resolveBoundaryFilePathGeneric(params) {
+	const absolutePath = path.resolve(params.absolutePath);
+	try {
+		const resolved = params.resolve(absolutePath);
+		if (resolved instanceof Promise) return resolved.then((value) => mapResolvedBoundaryPath(absolutePath, value)).catch((error) => toBoundaryValidationError(error));
+		return mapResolvedBoundaryPath(absolutePath, resolved);
+	} catch (error) {
+		return toBoundaryValidationError(error);
+	}
+}
+
+//#endregion
+//#region src/security/scan-paths.ts
+function isPathInside(basePath, candidatePath) {
+	const base = path.resolve(basePath);
+	const candidate = path.resolve(candidatePath);
+	const rel = path.relative(base, candidate);
+	return rel === "" || !rel.startsWith(`..${path.sep}`) && rel !== ".." && !path.isAbsolute(rel);
+}
+function safeRealpathSync(filePath) {
+	try {
+		return fs.realpathSync(filePath);
+	} catch {
+		return null;
+	}
+}
+function isPathInsideWithRealpath(basePath, candidatePath, opts) {
+	if (!isPathInside(basePath, candidatePath)) return false;
+	const baseReal = safeRealpathSync(basePath);
+	const candidateReal = safeRealpathSync(candidatePath);
+	if (!baseReal || !candidateReal) return opts?.requireRealpath !== true;
+	return isPathInside(baseReal, candidateReal);
+}
+
+//#endregion
+//#region src/infra/prototype-keys.ts
+const BLOCKED_OBJECT_KEYS = new Set([
+	"__proto__",
+	"prototype",
+	"constructor"
+]);
+function isBlockedObjectKey(key) {
+	return BLOCKED_OBJECT_KEYS.has(key);
+}
+
+//#endregion
+//#region src/config/includes.ts
+/**
+* Config includes: $include directive for modular configs
+*
+* @example
+* ```json5
+* {
+*   "$include": "./base.json5",           // single file
+*   "$include": ["./a.json5", "./b.json5"] // merge multiple
+* }
+* ```
+*/
+const INCLUDE_KEY = "$include";
+const MAX_INCLUDE_DEPTH = 10;
+const MAX_INCLUDE_FILE_BYTES = 2 * 1024 * 1024;
+var ConfigIncludeError = class extends Error {
+	constructor(message, includePath, cause) {
+		super(message);
+		this.includePath = includePath;
+		this.cause = cause;
+		this.name = "ConfigIncludeError";
+	}
+};
+var CircularIncludeError = class extends ConfigIncludeError {
+	constructor(chain) {
+		super(`Circular include detected: ${chain.join(" -> ")}`, chain[chain.length - 1]);
+		this.chain = chain;
+		this.name = "CircularIncludeError";
+	}
+};
+/** Deep merge: arrays concatenate, objects merge recursively, primitives: source wins */
+function deepMerge(target, source) {
+	if (Array.isArray(target) && Array.isArray(source)) return [...target, ...source];
+	if (isPlainObject(target) && isPlainObject(source)) {
+		const result = { ...target };
+		for (const key of Object.keys(source)) {
+			if (isBlockedObjectKey(key)) continue;
+			result[key] = key in result ? deepMerge(result[key], source[key]) : source[key];
+		}
+		return result;
+	}
+	return source;
+}
+var IncludeProcessor = class IncludeProcessor {
+	constructor(basePath, resolver, rootDir) {
+		this.basePath = basePath;
+		this.resolver = resolver;
+		this.visited = /* @__PURE__ */ new Set();
+		this.depth = 0;
+		this.visited.add(path.normalize(basePath));
+		this.rootDir = path.normalize(rootDir ?? path.dirname(basePath));
+		this.rootRealDir = path.normalize(safeRealpath(this.rootDir));
+	}
+	process(obj) {
+		if (Array.isArray(obj)) return obj.map((item) => this.process(item));
+		if (!isPlainObject(obj)) return obj;
+		if (!(INCLUDE_KEY in obj)) return this.processObject(obj);
+		return this.processInclude(obj);
+	}
+	processObject(obj) {
+		const result = {};
+		for (const [key, value] of Object.entries(obj)) result[key] = this.process(value);
+		return result;
+	}
+	processInclude(obj) {
+		const includeValue = obj[INCLUDE_KEY];
+		const otherKeys = Object.keys(obj).filter((k) => k !== INCLUDE_KEY);
+		const included = this.resolveInclude(includeValue);
+		if (otherKeys.length === 0) return included;
+		if (!isPlainObject(included)) throw new ConfigIncludeError("Sibling keys require included content to be an object", typeof includeValue === "string" ? includeValue : INCLUDE_KEY);
+		const rest = {};
+		for (const key of otherKeys) rest[key] = this.process(obj[key]);
+		return deepMerge(included, rest);
+	}
+	resolveInclude(value) {
+		if (typeof value === "string") return this.loadFile(value);
+		if (Array.isArray(value)) return value.reduce((merged, item) => {
+			if (typeof item !== "string") throw new ConfigIncludeError(`Invalid $include array item: expected string, got ${typeof item}`, String(item));
+			return deepMerge(merged, this.loadFile(item));
+		}, {});
+		throw new ConfigIncludeError(`Invalid $include value: expected string or array of strings, got ${typeof value}`, String(value));
+	}
+	loadFile(includePath) {
+		const resolvedPath = this.resolvePath(includePath);
+		this.checkCircular(resolvedPath);
+		this.checkDepth(includePath);
+		const raw = this.readFile(includePath, resolvedPath);
+		const parsed = this.parseFile(includePath, resolvedPath, raw);
+		return this.processNested(resolvedPath, parsed);
+	}
+	resolvePath(includePath) {
+		const configDir = path.dirname(this.basePath);
+		const resolved = path.isAbsolute(includePath) ? includePath : path.resolve(configDir, includePath);
+		const normalized = path.normalize(resolved);
+		if (!isPathInside(this.rootDir, normalized)) throw new ConfigIncludeError(`Include path escapes config directory: ${includePath} (root: ${this.rootDir})`, includePath);
+		try {
+			const real = fs.realpathSync(normalized);
+			if (!isPathInside(this.rootRealDir, real)) throw new ConfigIncludeError(`Include path resolves outside config directory (symlink): ${includePath} (root: ${this.rootDir})`, includePath);
+		} catch (err) {
+			if (err instanceof ConfigIncludeError) throw err;
+		}
+		return normalized;
+	}
+	checkCircular(resolvedPath) {
+		if (this.visited.has(resolvedPath)) throw new CircularIncludeError([...this.visited, resolvedPath]);
+	}
+	checkDepth(includePath) {
+		if (this.depth >= MAX_INCLUDE_DEPTH) throw new ConfigIncludeError(`Maximum include depth (${MAX_INCLUDE_DEPTH}) exceeded at: ${includePath}`, includePath);
+	}
+	readFile(includePath, resolvedPath) {
+		try {
+			if (this.resolver.readFileWithGuards) return this.resolver.readFileWithGuards({
+				includePath,
+				resolvedPath,
+				rootRealDir: this.rootRealDir
+			});
+			return this.resolver.readFile(resolvedPath);
+		} catch (err) {
+			if (err instanceof ConfigIncludeError) throw err;
+			throw new ConfigIncludeError(`Failed to read include file: ${includePath} (resolved: ${resolvedPath})`, includePath, err instanceof Error ? err : void 0);
+		}
+	}
+	parseFile(includePath, resolvedPath, raw) {
+		try {
+			return this.resolver.parseJson(raw);
+		} catch (err) {
+			throw new ConfigIncludeError(`Failed to parse include file: ${includePath} (resolved: ${resolvedPath})`, includePath, err instanceof Error ? err : void 0);
+		}
+	}
+	processNested(resolvedPath, parsed) {
+		const nested = new IncludeProcessor(resolvedPath, this.resolver, this.rootDir);
+		nested.visited = new Set([...this.visited, resolvedPath]);
+		nested.depth = this.depth + 1;
+		return nested.process(parsed);
+	}
+};
+function safeRealpath(target) {
+	try {
+		return fs.realpathSync(target);
+	} catch {
+		return target;
+	}
+}
+function readConfigIncludeFileWithGuards(params) {
+	const ioFs = params.ioFs ?? fs;
+	const maxBytes = params.maxBytes ?? MAX_INCLUDE_FILE_BYTES;
+	if (!canUseBoundaryFileOpen(ioFs)) return ioFs.readFileSync(params.resolvedPath, "utf-8");
+	const opened = openBoundaryFileSync({
+		absolutePath: params.resolvedPath,
+		rootPath: params.rootRealDir,
+		rootRealPath: params.rootRealDir,
+		boundaryLabel: "config directory",
+		skipLexicalRootCheck: true,
+		maxBytes,
+		ioFs
+	});
+	if (!opened.ok) {
+		if (opened.reason === "validation") throw new ConfigIncludeError(`Include file failed security checks (regular file, max ${maxBytes} bytes, no hardlinks): ${params.includePath}`, params.includePath);
+		throw new ConfigIncludeError(`Failed to read include file: ${params.includePath} (resolved: ${params.resolvedPath})`, params.includePath, opened.error instanceof Error ? opened.error : void 0);
+	}
+	try {
+		return ioFs.readFileSync(opened.fd, "utf-8");
+	} finally {
+		ioFs.closeSync(opened.fd);
+	}
+}
+const defaultResolver = {
+	readFile: (p) => fs.readFileSync(p, "utf-8"),
+	readFileWithGuards: ({ includePath, resolvedPath, rootRealDir }) => readConfigIncludeFileWithGuards({
+		includePath,
+		resolvedPath,
+		rootRealDir
+	}),
+	parseJson: (raw) => JSON5.parse(raw)
+};
+/**
+* Resolves all $include directives in a parsed config object.
+*/
+function resolveConfigIncludes(obj, configPath, resolver = defaultResolver) {
+	return new IncludeProcessor(configPath, resolver).process(obj);
+}
+
+//#endregion
+//#region src/config/normalize-paths.ts
+const PATH_VALUE_RE = /^~(?=$|[\\/])/;
+const PATH_KEY_RE = /(dir|path|paths|file|root|workspace)$/i;
+const PATH_LIST_KEYS = new Set(["paths", "pathPrepend"]);
+function normalizeStringValue(key, value) {
+	if (!PATH_VALUE_RE.test(value.trim())) return value;
+	if (!key) return value;
+	if (PATH_KEY_RE.test(key) || PATH_LIST_KEYS.has(key)) return resolveUserPath(value);
+	return value;
+}
+function normalizeAny(key, value) {
+	if (typeof value === "string") return normalizeStringValue(key, value);
+	if (Array.isArray(value)) {
+		const normalizeChildren = Boolean(key && PATH_LIST_KEYS.has(key));
+		return value.map((entry) => {
+			if (typeof entry === "string") return normalizeChildren ? normalizeStringValue(key, entry) : entry;
+			if (Array.isArray(entry)) return normalizeAny(void 0, entry);
+			if (isPlainObject(entry)) return normalizeAny(void 0, entry);
+			return entry;
+		});
+	}
+	if (!isPlainObject(value)) return value;
+	for (const [childKey, childValue] of Object.entries(value)) {
+		const next = normalizeAny(childKey, childValue);
+		if (next !== childValue) value[childKey] = next;
+	}
+	return value;
+}
+/**
+* Normalize "~" paths in path-ish config fields.
+*
+* Goal: accept `~/...` consistently across config file + env overrides, while
+* keeping the surface area small and predictable.
+*/
+function normalizeConfigPaths(cfg) {
+	if (!cfg || typeof cfg !== "object") return cfg;
+	normalizeAny(void 0, cfg);
+	return cfg;
+}
+
+//#endregion
+//#region src/logging/config.ts
+function readLoggingConfig() {
+	const configPath = resolveConfigPath();
+	try {
+		if (!fs.existsSync(configPath)) return;
+		const raw = fs.readFileSync(configPath, "utf-8");
+		const resolvedIncludes = resolveConfigIncludes(JSON5.parse(raw), configPath, {
+			readFile: (candidate) => fs.readFileSync(candidate, "utf-8"),
+			readFileWithGuards: ({ includePath, resolvedPath, rootRealDir }) => readConfigIncludeFileWithGuards({
+				includePath,
+				resolvedPath,
+				rootRealDir
+			}),
+			parseJson: (includeRaw) => JSON5.parse(includeRaw)
+		});
+		if (resolvedIncludes && typeof resolvedIncludes === "object" && "env" in resolvedIncludes) applyConfigEnvVars(resolvedIncludes);
+		const resolvedConfig = resolveConfigEnvVars(resolvedIncludes);
+		if (!resolvedConfig || typeof resolvedConfig !== "object" || Array.isArray(resolvedConfig)) return;
+		const logging = normalizeConfigPaths(resolvedConfig).logging;
+		if (!logging || typeof logging !== "object" || Array.isArray(logging)) return;
+		return logging;
+	} catch {
+		return;
+	}
+}
+
+//#endregion
+//#region src/logging/levels.ts
+const ALLOWED_LOG_LEVELS = [
+	"silent",
+	"fatal",
+	"error",
+	"warn",
+	"info",
+	"debug",
+	"trace"
+];
+function tryParseLogLevel(level) {
+	if (typeof level !== "string") return;
+	const candidate = level.trim();
+	return ALLOWED_LOG_LEVELS.includes(candidate) ? candidate : void 0;
+}
+function normalizeLogLevel(level, fallback = "info") {
+	return tryParseLogLevel(level) ?? fallback;
+}
+function levelToMinLevel(level) {
+	return {
+		fatal: 0,
+		error: 1,
+		warn: 2,
+		info: 3,
+		debug: 4,
+		trace: 5,
+		silent: Number.POSITIVE_INFINITY
+	}[level];
+}
+function levelToTslogMinLevel(level) {
+	return {
+		trace: 1,
+		debug: 2,
+		info: 3,
+		warn: 4,
+		error: 5,
+		fatal: 6,
+		silent: Number.POSITIVE_INFINITY
+	}[level];
+}
+
+//#endregion
+//#region src/logging/state.ts
+const loggingState = {
+	cachedLogger: null,
+	cachedSettings: null,
+	cachedConsoleSettings: null,
+	overrideSettings: null,
+	invalidEnvLogLevelValue: null,
+	consolePatched: false,
+	forceConsoleToStderr: false,
+	forceSubsystemConsoleToStderr: false,
+	consoleTimestampPrefix: false,
+	consoleSubsystemFilter: null,
+	resolvingConsoleSettings: false,
+	streamErrorHandlersInstalled: false,
+	rawConsole: null
+};
+
+//#endregion
+//#region src/logging/env-log-level.ts
+function resolveEnvLogLevelOverride() {
+	const raw = process.env.OPENCLAW_LOG_LEVEL;
+	const trimmed = typeof raw === "string" ? raw.trim() : "";
+	if (!trimmed) {
+		loggingState.invalidEnvLogLevelValue = null;
+		return;
+	}
+	const parsed = tryParseLogLevel(trimmed);
+	if (parsed) {
+		loggingState.invalidEnvLogLevelValue = null;
+		return parsed;
+	}
+	if (loggingState.invalidEnvLogLevelValue !== trimmed) {
+		loggingState.invalidEnvLogLevelValue = trimmed;
+		process.stderr.write(`[openclaw] Ignoring invalid OPENCLAW_LOG_LEVEL="${trimmed}" (allowed: ${ALLOWED_LOG_LEVELS.join("|")}).\n`);
+	}
+}
+
+//#endregion
+//#region src/logging/file-log-writer.ts
+const DEFAULT_MAX_FILE_BYTES = 10 * 1024 * 1024;
+const DEFAULT_MAX_BACKUPS = 5;
+const DEFAULT_MAX_QUEUED_BYTES = 1024 * 1024;
+const DEFAULT_COMPRESSION = "gzip";
+const DEFAULT_MODE = "jsonl";
+const gzipAsync = promisify(zlib.gzip);
+const writers = /* @__PURE__ */ new Map();
+const unresolvedWriterKeys = /* @__PURE__ */ new Map();
+function resolveFileLogProfile(config, profileId, overrides, options = {}) {
+	const defaults = config?.fileLogs?.defaults;
+	const profile = config?.fileLogs?.profiles?.[profileId];
+	const merged = {
+		maxFileBytes: DEFAULT_MAX_FILE_BYTES,
+		maxBackups: DEFAULT_MAX_BACKUPS,
+		compress: DEFAULT_COMPRESSION,
+		maxQueuedBytes: DEFAULT_MAX_QUEUED_BYTES,
+		mode: DEFAULT_MODE,
+		...defaults,
+		...overrides
+	};
+	if (profileId === "primary") {
+		if (typeof config?.maxFileBytes === "number") merged.maxFileBytes = config.maxFileBytes;
+		if (typeof config?.maxBackups === "number") merged.maxBackups = config.maxBackups;
+	}
+	if (profile) {
+		let profileOverrides = profile;
+		if (options.allowProfileFileOverride === false && typeof profile.file === "string") {
+			const { file: _file, ...withoutFile } = profile;
+			profileOverrides = withoutFile;
+		}
+		Object.assign(merged, profileOverrides);
+	}
+	return {
+		profileId,
+		file: typeof merged.file === "string" ? merged.file : "",
+		maxFileBytes: normalizePositiveInteger(merged.maxFileBytes, DEFAULT_MAX_FILE_BYTES),
+		maxBackups: normalizeNonnegativeInteger(merged.maxBackups, DEFAULT_MAX_BACKUPS),
+		compress: merged.compress === false ? false : "gzip",
+		maxQueuedBytes: normalizePositiveInteger(merged.maxQueuedBytes, DEFAULT_MAX_QUEUED_BYTES),
+		mode: merged.mode === "text" ? "text" : "jsonl",
+		keepLines: typeof merged.keepLines === "number" && Number.isFinite(merged.keepLines) && merged.keepLines > 0 ? Math.floor(merged.keepLines) : void 0
+	};
+}
+function createFileLogWriter(options) {
+	const { allowProfileFileOverride, config, fileMode, onRotate, profileId, strict, sync, ...overrides } = options;
+	const handleOptions = {
+		sync: sync === true,
+		strict: strict === true,
+		fileMode,
+		onRotate
+	};
+	const unresolvedKey = config === void 0 ? unresolvedWriterKey(profileId, overrides, { allowProfileFileOverride }) : void 0;
+	const cachedKey = unresolvedKey ? unresolvedWriterKeys.get(unresolvedKey) : void 0;
+	const cachedWriter = cachedKey ? writers.get(cachedKey) : void 0;
+	if (cachedWriter) return writerFromState(cachedWriter, handleOptions);
+	const policy = resolveFileLogProfile(config ?? readLoggingConfig(), profileId, overrides, { allowProfileFileOverride });
+	const key = writerKey(policy);
+	const existing = writers.get(key);
+	if (existing) {
+		existing.policy = policy;
+		if (unresolvedKey) unresolvedWriterKeys.set(unresolvedKey, key);
+		return writerFromState(existing, handleOptions);
+	}
+	const state = {
+		profileId: policy.profileId,
+		file: policy.file,
+		pendingWrites: 0,
+		queuedBytes: 0,
+		droppedWrites: 0,
+		activeOperation: "idle",
+		lastRotation: null,
+		policy,
+		queue: Promise.resolve()
+	};
+	writers.set(key, state);
+	if (unresolvedKey) unresolvedWriterKeys.set(unresolvedKey, key);
+	return writerFromState(state, handleOptions);
+}
+function appendFileLog(line, options) {
+	return createFileLogWriter(options).append(line);
+}
+function rotateFileLog(filePath, policy, options = {}) {
+	try {
+		if (currentFileBytes(filePath) <= 0) return {
+			at: (/* @__PURE__ */ new Date()).toISOString(),
+			compressed: policy.compress === "gzip",
+			skipped: true
+		};
+		if (policy.maxBackups <= 0) {
+			fs.rmSync(filePath, { force: true });
+			return {
+				at: (/* @__PURE__ */ new Date()).toISOString(),
+				compressed: policy.compress === "gzip"
+			};
+		}
+		rotateExistingBackups(filePath, policy.maxBackups);
+		const backup = `${filePath}.1${policy.compress === "gzip" ? ".gz" : ""}`;
+		if (policy.compress === "gzip") {
+			fs.writeFileSync(backup, zlib.gzipSync(fs.readFileSync(filePath)), { mode: options.fileMode });
+			fs.rmSync(filePath, { force: true });
+		} else fs.renameSync(filePath, backup);
+		pruneExcessBackups(filePath, policy.maxBackups);
+		return {
+			at: (/* @__PURE__ */ new Date()).toISOString(),
+			backup,
+			compressed: policy.compress === "gzip"
+		};
+	} catch (err) {
+		if (options.strict) throw err;
+		return {
+			at: (/* @__PURE__ */ new Date()).toISOString(),
+			compressed: policy.compress === "gzip",
+			skipped: true
+		};
+	}
+}
+function writerFromState(state, handleOptions) {
+	return {
+		append: (line) => appendWithState(state, line, handleOptions),
+		diagnostics: () => {
+			const { policy: _policy, queue: _queue, ...diagnostics } = state;
+			return { ...diagnostics };
+		}
+	};
+}
+function appendWithState(state, line, opts) {
+	const queuedBytes = Buffer.byteLength(line, "utf8");
+	const policy = state.policy;
+	const isOnlyPendingWrite = state.pendingWrites === 0 && state.queuedBytes === 0;
+	if (state.queuedBytes + queuedBytes > policy.maxQueuedBytes && !isOnlyPendingWrite) {
+		state.droppedWrites += 1;
+		if (opts.strict) return Promise.reject(/* @__PURE__ */ new Error(`file log queue limit exceeded for ${policy.profileId}`));
+		return "dropped";
+	}
+	state.pendingWrites += 1;
+	state.queuedBytes += queuedBytes;
+	if (opts.sync) {
+		appendNow(state, policy, line, queuedBytes, opts);
+		return "queued";
+	}
+	const task = state.queue.then(async () => {
+		await appendNowAsync(state, policy, line, queuedBytes, opts);
+	});
+	state.queue = task.catch(() => void 0);
+	return task.then(() => "queued");
+}
+async function appendNowAsync(state, policy, line, queuedBytes, opts) {
+	try {
+		state.activeOperation = "append";
+		await fs.promises.mkdir(path.dirname(policy.file), { recursive: true });
+		const currentBytes = await currentFileBytesAsync(policy.file);
+		if (currentBytes + queuedBytes > policy.maxFileBytes && currentBytes > 0) {
+			state.activeOperation = "rotate";
+			state.lastRotation = await rotateFileLogAsync(policy.file, policy, {
+				fileMode: opts.fileMode,
+				strict: opts.strict
+			});
+			const rotationLine = state.lastRotation ? opts.onRotate?.(state.lastRotation) : void 0;
+			if (rotationLine) await fs.promises.appendFile(policy.file, rotationLine, {
+				encoding: "utf8",
+				mode: opts.fileMode
+			});
+		}
+		state.activeOperation = "append";
+		await fs.promises.appendFile(policy.file, line, {
+			encoding: "utf8",
+			mode: opts.fileMode
+		});
+	} catch (err) {
+		if (opts.strict) throw err;
+	} finally {
+		state.pendingWrites = Math.max(0, state.pendingWrites - 1);
+		state.queuedBytes = Math.max(0, state.queuedBytes - queuedBytes);
+		state.activeOperation = "idle";
+	}
+}
+function appendNow(state, policy, line, queuedBytes, opts) {
+	try {
+		state.activeOperation = "append";
+		fs.mkdirSync(path.dirname(policy.file), { recursive: true });
+		const currentBytes = currentFileBytes(policy.file);
+		if (currentBytes + queuedBytes > policy.maxFileBytes && currentBytes > 0) {
+			state.activeOperation = "rotate";
+			state.lastRotation = rotateFileLog(policy.file, policy, {
+				fileMode: opts.fileMode,
+				strict: opts.strict
+			});
+			const rotationLine = state.lastRotation ? opts.onRotate?.(state.lastRotation) : void 0;
+			if (rotationLine) fs.appendFileSync(policy.file, rotationLine, {
+				encoding: "utf8",
+				mode: opts.fileMode
+			});
+		}
+		state.activeOperation = "append";
+		fs.appendFileSync(policy.file, line, {
+			encoding: "utf8",
+			mode: opts.fileMode
+		});
+	} catch (err) {
+		if (opts.strict) throw err;
+	} finally {
+		state.pendingWrites = Math.max(0, state.pendingWrites - 1);
+		state.queuedBytes = Math.max(0, state.queuedBytes - queuedBytes);
+		state.activeOperation = "idle";
+	}
+}
+function writerKey(policy) {
+	return `${policy.profileId}:${policy.file}`;
+}
+function unresolvedWriterKey(profileId, overrides, options) {
+	return stableStringify({
+		profileId,
+		allowProfileFileOverride: options.allowProfileFileOverride !== false,
+		overrides
+	});
+}
+function stableStringify(value) {
+	if (Array.isArray(value)) return `[${value.map((item) => stableStringify(item)).join(",")}]`;
+	if (value && typeof value === "object") return `{${Object.entries(value).filter(([, entryValue]) => entryValue !== void 0).toSorted(([a], [b]) => a.localeCompare(b)).map(([key, entryValue]) => `${JSON.stringify(key)}:${stableStringify(entryValue)}`).join(",")}}`;
+	return JSON.stringify(value);
+}
+async function rotateFileLogAsync(filePath, policy, options = {}) {
+	try {
+		if (await currentFileBytesAsync(filePath) <= 0) return {
+			at: (/* @__PURE__ */ new Date()).toISOString(),
+			compressed: policy.compress === "gzip",
+			skipped: true
+		};
+		if (policy.maxBackups <= 0) {
+			await fs.promises.rm(filePath, { force: true });
+			return {
+				at: (/* @__PURE__ */ new Date()).toISOString(),
+				compressed: policy.compress === "gzip"
+			};
+		}
+		await rotateExistingBackupsAsync(filePath, policy.maxBackups);
+		const backup = `${filePath}.1${policy.compress === "gzip" ? ".gz" : ""}`;
+		if (policy.compress === "gzip") {
+			await fs.promises.writeFile(backup, await gzipAsync(await fs.promises.readFile(filePath)), { mode: options.fileMode });
+			await fs.promises.rm(filePath, { force: true });
+		} else await fs.promises.rename(filePath, backup);
+		await pruneExcessBackupsAsync(filePath, policy.maxBackups);
+		return {
+			at: (/* @__PURE__ */ new Date()).toISOString(),
+			backup,
+			compressed: policy.compress === "gzip"
+		};
+	} catch (err) {
+		if (options.strict) throw err;
+		return {
+			at: (/* @__PURE__ */ new Date()).toISOString(),
+			compressed: policy.compress === "gzip",
+			skipped: true
+		};
+	}
+}
+function rotateExistingBackups(filePath, maxBackups) {
+	for (const backup of listBackupEntries(filePath).toSorted((a, b) => b.slot - a.slot)) {
+		if (backup.slot >= maxBackups) {
+			fs.rmSync(backup.path, { force: true });
+			continue;
+		}
+		const target = `${filePath}.${backup.slot + 1}${backup.suffix}`;
+		fs.rmSync(target, { force: true });
+		fs.renameSync(backup.path, target);
+	}
+}
+async function rotateExistingBackupsAsync(filePath, maxBackups) {
+	for (const backup of (await listBackupEntriesAsync(filePath)).toSorted((a, b) => b.slot - a.slot)) {
+		if (backup.slot >= maxBackups) {
+			await fs.promises.rm(backup.path, { force: true });
+			continue;
+		}
+		const target = `${filePath}.${backup.slot + 1}${backup.suffix}`;
+		await fs.promises.rm(target, { force: true });
+		await fs.promises.rename(backup.path, target);
+	}
+}
+function pruneExcessBackups(filePath, maxBackups) {
+	const retained = listBackupEntries(filePath).toSorted((a, b) => a.slot - b.slot || b.mtimeMs - a.mtimeMs);
+	for (const backup of retained.slice(maxBackups)) fs.rmSync(backup.path, { force: true });
+}
+async function pruneExcessBackupsAsync(filePath, maxBackups) {
+	const retained = (await listBackupEntriesAsync(filePath)).toSorted((a, b) => a.slot - b.slot || b.mtimeMs - a.mtimeMs);
+	for (const backup of retained.slice(maxBackups)) await fs.promises.rm(backup.path, { force: true });
+}
+function listBackupEntries(filePath) {
+	const dir = path.dirname(filePath);
+	const base = path.basename(filePath).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+	let names = [];
+	try {
+		names = fs.readdirSync(dir);
+	} catch {
+		return [];
+	}
+	const backupPattern = new RegExp(`^${base}\\.(\\d+)(\\.gz)?$`);
+	return names.flatMap((name) => {
+		const match = backupPattern.exec(name);
+		if (!match) return [];
+		const backupPath = path.join(dir, name);
+		let mtimeMs = 0;
+		try {
+			mtimeMs = fs.statSync(backupPath).mtimeMs;
+		} catch {
+			return [];
+		}
+		return [{
+			path: backupPath,
+			slot: Number(match[1]),
+			suffix: match[2] === ".gz" ? ".gz" : "",
+			mtimeMs
+		}];
+	});
+}
+async function listBackupEntriesAsync(filePath) {
+	const dir = path.dirname(filePath);
+	const base = path.basename(filePath).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+	let names = [];
+	try {
+		names = await fs.promises.readdir(dir);
+	} catch {
+		return [];
+	}
+	const backupPattern = new RegExp(`^${base}\\.(\\d+)(\\.gz)?$`);
+	return (await Promise.all(names.map(async (name) => {
+		const match = backupPattern.exec(name);
+		if (!match) return null;
+		const backupPath = path.join(dir, name);
+		try {
+			const stat = await fs.promises.stat(backupPath);
+			return {
+				path: backupPath,
+				slot: Number(match[1]),
+				suffix: match[2] === ".gz" ? ".gz" : "",
+				mtimeMs: stat.mtimeMs
+			};
+		} catch {
+			return null;
+		}
+	}))).filter((entry) => entry !== null);
+}
+function currentFileBytes(filePath) {
+	try {
+		return fs.statSync(filePath).size;
+	} catch {
+		return 0;
+	}
+}
+async function currentFileBytesAsync(filePath) {
+	try {
+		return (await fs.promises.stat(filePath)).size;
+	} catch {
+		return 0;
+	}
+}
+function normalizePositiveInteger(value, fallback) {
+	return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.floor(value) : fallback;
+}
+function normalizeNonnegativeInteger(value, fallback) {
+	return typeof value === "number" && Number.isFinite(value) && value >= 0 ? Math.floor(value) : fallback;
+}
+
+//#endregion
+//#region src/logging/local-date.ts
+function formatLocalDate(date) {
+	return `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, "0")}-${String(date.getDate()).padStart(2, "0")}`;
+}
+
+//#endregion
+//#region src/logging/node-require.ts
+function resolveNodeRequireFromMeta(metaUrl) {
+	const getBuiltinModule = process.getBuiltinModule;
+	if (typeof getBuiltinModule !== "function") return null;
+	try {
+		const moduleNamespace = getBuiltinModule("module");
+		const createRequire = typeof moduleNamespace.createRequire === "function" ? moduleNamespace.createRequire : null;
+		return createRequire ? createRequire(metaUrl) : null;
+	} catch {
+		return null;
+	}
+}
+
+//#endregion
+//#region src/logging/timestamps.ts
+function isValidTimeZone(tz) {
+	try {
+		new Intl.DateTimeFormat("en", { timeZone: tz });
+		return true;
+	} catch {
+		return false;
+	}
+}
+function formatLocalIsoWithOffset(now, timeZone) {
+	const explicit = timeZone ?? process.env.TZ;
+	const tz = explicit && isValidTimeZone(explicit) ? explicit : Intl.DateTimeFormat().resolvedOptions().timeZone;
+	const fmt = new Intl.DateTimeFormat("en", {
+		timeZone: tz,
+		year: "numeric",
+		month: "2-digit",
+		day: "2-digit",
+		hour: "2-digit",
+		minute: "2-digit",
+		second: "2-digit",
+		hour12: false,
+		fractionalSecondDigits: 3,
+		timeZoneName: "longOffset"
+	});
+	const parts = Object.fromEntries(fmt.formatToParts(now).map((p) => [p.type, p.value]));
+	const offsetRaw = parts.timeZoneName ?? "GMT";
+	const offset = offsetRaw === "GMT" ? "+00:00" : offsetRaw.slice(3);
+	return `${parts.year}-${parts.month}-${parts.day}T${parts.hour}:${parts.minute}:${parts.second}.${parts.fractionalSecond}${offset}`;
+}
+
+//#endregion
+//#region src/logging/logger.ts
+const DEFAULT_LOG_DIR = resolvePreferredOpenClawTmpDir();
+const DEFAULT_LOG_FILE = path.join(DEFAULT_LOG_DIR, "openclaw.log");
+const LOG_PREFIX = "openclaw";
+const LOG_SUFFIX = ".log";
+const MAX_LOG_AGE_MS = 1440 * 60 * 1e3;
+const DEFAULT_MAX_LOG_FILE_BYTES = 10 * 1024 * 1024;
+const DEFAULT_MAX_LOG_BACKUPS = 5;
+const requireConfig$1 = resolveNodeRequireFromMeta(import.meta.url);
+const externalTransports = /* @__PURE__ */ new Set();
+function shouldSkipLoadConfigFallback(argv = process.argv) {
+	const [primary, secondary] = getCommandPathWithRootOptions(argv, 2);
+	return primary === "config" && secondary === "validate";
+}
+function toTslogMinLevel(level) {
+	const minLevel = levelToTslogMinLevel(level);
+	return minLevel >= 0 && minLevel <= 6 ? minLevel : void 0;
+}
+function isSilentLogging() {
+	return loggingState.cachedSettings?.level === "silent";
+}
+function attachExternalTransport(logger, transport) {
+	logger.attachTransport((logObj) => {
+		if (!externalTransports.has(transport) || isSilentLogging()) return;
+		try {
+			transport(logObj);
+		} catch {}
+	});
+}
+function canUseSilentVitestFileLogFastPath(envLevel) {
+	return process.env.VITEST === "true" && process.env.OPENCLAW_TEST_FILE_LOG !== "1" && !envLevel && !loggingState.overrideSettings;
+}
+function resolveSettings(opts = {}) {
+	const envLevel = resolveEnvLogLevelOverride();
+	if (canUseSilentVitestFileLogFastPath(envLevel)) return {
+		level: "silent",
+		file: defaultRollingPathForToday(),
+		maxFileBytes: DEFAULT_MAX_LOG_FILE_BYTES,
+		maxBackups: DEFAULT_MAX_LOG_BACKUPS,
+		fileLogsSignature: ""
+	};
+	let cfg = loggingState.overrideSettings ?? readLoggingConfig();
+	if (!cfg && opts.configLoadFallback !== false && !shouldSkipLoadConfigFallback()) try {
+		cfg = (requireConfig$1?.("../config/config.js"))?.loadConfig?.().logging;
+	} catch {
+		cfg = void 0;
+	}
+	const defaultLevel = process.env.VITEST === "true" && process.env.OPENCLAW_TEST_FILE_LOG !== "1" ? "silent" : "info";
+	const fromConfig = normalizeLogLevel(cfg?.level, defaultLevel);
+	const level = envLevel ?? fromConfig;
+	const configuredFile = cfg?.file ?? defaultRollingPathForToday();
+	const primaryPolicy = resolveFileLogProfile(cfg, "primary", {
+		file: configuredFile,
+		mode: "jsonl",
+		maxQueuedBytes: Number.MAX_SAFE_INTEGER
+	});
+	return {
+		level,
+		file: primaryPolicy.file || configuredFile,
+		maxFileBytes: primaryPolicy.maxFileBytes,
+		maxBackups: primaryPolicy.maxBackups,
+		writerConfig: cfg,
+		fileLogsSignature: JSON.stringify(cfg?.fileLogs ?? null)
+	};
+}
+function settingsChanged(a, b) {
+	if (!a) return true;
+	return a.level !== b.level || a.file !== b.file || a.maxFileBytes !== b.maxFileBytes || a.maxBackups !== b.maxBackups || a.fileLogsSignature !== b.fileLogsSignature;
+}
+function isFileLogLevelEnabled(level) {
+	const settings = loggingState.cachedSettings ?? resolveSettings();
+	if (!loggingState.cachedSettings) loggingState.cachedSettings = settings;
+	if (settings.level === "silent") return false;
+	return levelToMinLevel(level) <= levelToMinLevel(settings.level);
+}
+function buildLogger(settings) {
+	const logger = new Logger({
+		name: "openclaw",
+		minLevel: toTslogMinLevel(settings.level),
+		type: "hidden"
+	});
+	if (settings.level === "silent") {
+		for (const transport of externalTransports) attachExternalTransport(logger, transport);
+		return logger;
+	}
+	fs.mkdirSync(path.dirname(settings.file), { recursive: true });
+	if (isRollingPath(settings.file)) pruneOldRollingLogs(path.dirname(settings.file));
+	const primaryPolicy = resolveFileLogProfile(settings.writerConfig, "primary", {
+		file: settings.file,
+		mode: "jsonl",
+		maxQueuedBytes: Number.MAX_SAFE_INTEGER
+	});
+	const writer = createFileLogWriter({
+		profileId: "primary",
+		file: settings.file,
+		config: settings.writerConfig,
+		mode: "jsonl",
+		maxQueuedBytes: Number.MAX_SAFE_INTEGER,
+		sync: true,
+		onRotate: (rotation) => {
+			const backupSuffix = primaryPolicy.compress === "gzip" ? ".gz" : "";
+			const backup = rotation.backup ?? (!rotation.skipped && primaryPolicy.maxBackups > 0 ? `${primaryPolicy.file}.1${backupSuffix}` : void 0);
+			return `${JSON.stringify({
+				time: formatLocalIsoWithOffset(/* @__PURE__ */ new Date()),
+				level: "info",
+				subsystem: "logging",
+				message: "rotated log file",
+				file: primaryPolicy.file,
+				...backup ? { backup } : {},
+				maxBackups: primaryPolicy.maxBackups
+			})}\n`;
+		}
+	});
+	logger.attachTransport((logObj) => {
+		try {
+			const time = formatLocalIsoWithOffset(logObj.date ?? /* @__PURE__ */ new Date());
+			const payload = `${JSON.stringify({
+				...logObj,
+				time
+			})}\n`;
+			writer.append(payload);
+		} catch {}
+	});
+	for (const transport of externalTransports) attachExternalTransport(logger, transport);
+	return logger;
+}
+function getLogger() {
+	const settings = resolveSettings();
+	const cachedLogger = loggingState.cachedLogger;
+	const cachedSettings = loggingState.cachedSettings;
+	if (!cachedLogger || settingsChanged(cachedSettings, settings)) {
+		loggingState.cachedLogger = buildLogger(settings);
+		loggingState.cachedSettings = settings;
+	}
+	return loggingState.cachedLogger;
+}
+function getChildLogger(bindings, opts) {
+	const base = getLogger();
+	const minLevel = opts?.level ? toTslogMinLevel(opts.level) : void 0;
+	const name = bindings ? JSON.stringify(bindings) : void 0;
+	return base.getSubLogger({
+		name,
+		...minLevel === void 0 ? {} : { minLevel },
+		prefix: bindings ? [name ?? ""] : []
+	});
+}
+function defaultRollingPathForToday() {
+	const today = formatLocalDate(/* @__PURE__ */ new Date());
+	return path.join(DEFAULT_LOG_DIR, `${LOG_PREFIX}-${today}${LOG_SUFFIX}`);
+}
+function isRollingPath(file) {
+	const base = path.basename(file);
+	return base.startsWith(`${LOG_PREFIX}-`) && base.endsWith(LOG_SUFFIX) && base.length === `${LOG_PREFIX}-YYYY-MM-DD${LOG_SUFFIX}`.length;
+}
+function pruneOldRollingLogs(dir) {
+	try {
+		const entries = fs.readdirSync(dir, { withFileTypes: true });
+		const cutoff = Date.now() - MAX_LOG_AGE_MS;
+		for (const entry of entries) {
+			if (!entry.isFile()) continue;
+			const fullPath = path.join(dir, entry.name);
+			const backupDateMs = rollingBackupDateMs(entry.name);
+			if (backupDateMs !== null) {
+				if (backupDateMs < cutoff) try {
+					fs.rmSync(fullPath, { force: true });
+				} catch {}
+				continue;
+			}
+			if (!entry.name.startsWith(`${LOG_PREFIX}-`) || !entry.name.endsWith(LOG_SUFFIX)) continue;
+			try {
+				if (fs.statSync(fullPath).mtimeMs < cutoff) fs.rmSync(fullPath, { force: true });
+			} catch {}
+		}
+	} catch {}
+}
+function rollingBackupDateMs(name) {
+	const match = /^openclaw-(\d{4})-(\d{2})-(\d{2})\.log\.\d+(?:\.gz)?$/.exec(name);
+	if (!match) return null;
+	const ms = new Date(Number(match[1]), Number(match[2]) - 1, Number(match[3]) + 1).getTime();
+	return Number.isNaN(ms) ? null : ms;
+}
+
+//#endregion
+//#region src/terminal/palette.ts
+const LOBSTER_PALETTE = {
+	accent: "#6366F1",
+	accentBright: "#818CF8",
+	accentDim: "#4F46E5",
+	info: "#818CF8",
+	success: "#34D399",
+	warn: "#FBBF24",
+	error: "#EF4444",
+	muted: "#A0A0A0"
+};
+
+//#endregion
+//#region src/terminal/theme.ts
+const hasForceColor = typeof process.env.FORCE_COLOR === "string" && process.env.FORCE_COLOR.trim().length > 0 && process.env.FORCE_COLOR.trim() !== "0";
+const baseChalk = process.env.NO_COLOR && !hasForceColor ? new Chalk({ level: 0 }) : chalk;
+const hex = (value) => baseChalk.hex(value);
+const theme = {
+	accent: hex(LOBSTER_PALETTE.accent),
+	accentBright: hex(LOBSTER_PALETTE.accentBright),
+	accentDim: hex(LOBSTER_PALETTE.accentDim),
+	info: hex(LOBSTER_PALETTE.info),
+	success: hex(LOBSTER_PALETTE.success),
+	warn: hex(LOBSTER_PALETTE.warn),
+	error: hex(LOBSTER_PALETTE.error),
+	muted: hex(LOBSTER_PALETTE.muted),
+	heading: baseChalk.bold.hex(LOBSTER_PALETTE.accent),
+	command: hex(LOBSTER_PALETTE.accentBright),
+	option: hex(LOBSTER_PALETTE.warn)
+};
+const isRich = () => Boolean(baseChalk.level > 0);
+const colorize = (rich, color, value) => rich ? color(value) : value;
+
+//#endregion
+//#region src/globals.ts
+let globalVerbose = false;
+function setVerbose(v) {
+	globalVerbose = v;
+}
+function isVerbose() {
+	return globalVerbose;
+}
+function shouldLogVerbose() {
+	return globalVerbose || isFileLogLevelEnabled("debug");
+}
+function logVerbose(message) {
+	if (!shouldLogVerbose()) return;
+	try {
+		getLogger().debug({ message }, "verbose");
+	} catch {}
+	if (!globalVerbose) return;
+	console.log(theme.muted(message));
+}
+function logVerboseConsole(message) {
+	if (!globalVerbose) return;
+	console.log(theme.muted(message));
+}
+const success = theme.success;
+const warn = theme.warn;
+const info = theme.info;
+const danger = theme.error;
+
+//#endregion
+//#region src/terminal/progress-line.ts
+let activeStream = null;
+function registerActiveProgressLine(stream) {
+	if (!stream.isTTY) return;
+	activeStream = stream;
+}
+function clearActiveProgressLine() {
+	if (!activeStream?.isTTY) return;
+	activeStream.write("\r\x1B[2K");
+}
+function unregisterActiveProgressLine(stream) {
+	if (!activeStream) return;
+	if (stream && activeStream !== stream) return;
+	activeStream = null;
+}
+
+//#endregion
+//#region src/terminal/restore.ts
+const RESET_SEQUENCE = "\x1B[0m\x1B[?25h\x1B[?1000l\x1B[?1002l\x1B[?1003l\x1B[?1006l\x1B[?2004l";
+function reportRestoreFailure(scope, err, reason) {
+	const suffix = reason ? ` (${reason})` : "";
+	const message = `[terminal] restore ${scope} failed${suffix}: ${String(err)}`;
+	try {
+		process.stderr.write(`${message}\n`);
+	} catch (writeErr) {
+		console.error(`[terminal] restore reporting failed${suffix}: ${String(writeErr)}`);
+	}
+}
+function restoreTerminalState(reason, options = {}) {
+	const resumeStdin = options.resumeStdinIfPaused ?? options.resumeStdin ?? false;
+	try {
+		clearActiveProgressLine();
+	} catch (err) {
+		reportRestoreFailure("progress line", err, reason);
+	}
+	const stdin = process.stdin;
+	if (stdin.isTTY && typeof stdin.setRawMode === "function") {
+		try {
+			stdin.setRawMode(false);
+		} catch (err) {
+			reportRestoreFailure("raw mode", err, reason);
+		}
+		if (resumeStdin && typeof stdin.isPaused === "function" && stdin.isPaused()) try {
+			stdin.resume();
+		} catch (err) {
+			reportRestoreFailure("stdin resume", err, reason);
+		}
+	}
+	if (process.stdout.isTTY) try {
+		process.stdout.write(RESET_SEQUENCE);
+	} catch (err) {
+		reportRestoreFailure("stdout reset", err, reason);
+	}
+}
+
+//#endregion
+//#region src/runtime.ts
+function shouldEmitRuntimeLog(env = process.env) {
+	if (env.VITEST !== "true") return true;
+	if (env.OPENCLAW_TEST_RUNTIME_LOG === "1") return true;
+	return typeof console.log.mock === "object";
+}
+function createRuntimeIo() {
+	return {
+		log: (...args) => {
+			if (!shouldEmitRuntimeLog()) return;
+			clearActiveProgressLine();
+			console.log(...args);
+		},
+		error: (...args) => {
+			clearActiveProgressLine();
+			console.error(...args);
+		}
+	};
+}
+const defaultRuntime = {
+	...createRuntimeIo(),
+	exit: (code) => {
+		restoreTerminalState("runtime exit", { resumeStdinIfPaused: false });
+		process.exit(code);
+		throw new Error("unreachable");
+	}
+};
+function createNonExitingRuntime() {
+	return {
+		...createRuntimeIo(),
+		exit: (code) => {
+			throw new Error(`exit ${code}`);
+		}
+	};
+}
+
+//#endregion
+//#region src/shared/text-chunking.ts
+/**
+* Returns a break index that does not fall between a UTF-16 surrogate pair.
+* If `breakIdx` would split a pair (high surrogate at breakIdx-1, low at breakIdx),
+* backs up by 1. Otherwise returns `breakIdx` unchanged.
+*
+* Reference: src/memory/embedding-input-limits.ts:46-56 (the only surrogate-aware
+* split in the fork before this port). Ported from upstream openclaw `18fbcef4966`.
+*/
+function avoidTrailingHighSurrogateBreak(text, breakIdx) {
+	if (breakIdx > 0 && breakIdx < text.length && text.charCodeAt(breakIdx - 1) >= 55296 && text.charCodeAt(breakIdx - 1) <= 56319 && text.charCodeAt(breakIdx) >= 56320 && text.charCodeAt(breakIdx) <= 57343) return breakIdx - 1;
+	return breakIdx;
+}
+function chunkTextByBreakResolver(text, limit, resolveBreakIndex) {
+	if (!text) return [];
+	if (limit <= 0 || text.length <= limit) return [text];
+	const chunks = [];
+	let remaining = text;
+	while (remaining.length > limit) {
+		const candidateBreak = resolveBreakIndex(remaining.slice(0, limit));
+		let breakIdx = avoidTrailingHighSurrogateBreak(remaining, Number.isFinite(candidateBreak) && candidateBreak > 0 && candidateBreak <= limit ? candidateBreak : limit);
+		if (breakIdx <= 0) breakIdx = Math.min(remaining.length, 2);
+		const chunk = remaining.slice(0, breakIdx).trimEnd();
+		if (chunk.length > 0) chunks.push(chunk);
+		const brokeOnSeparator = breakIdx < remaining.length && /\s/.test(remaining[breakIdx]);
+		const nextStart = Math.min(remaining.length, breakIdx + (brokeOnSeparator ? 1 : 0));
+		remaining = remaining.slice(nextStart).trimStart();
+	}
+	if (remaining.length) chunks.push(remaining);
+	return chunks;
+}
+
+//#endregion
+//#region src/terminal/ansi.ts
+const ANSI_SGR_PATTERN = "\\x1b\\[[0-9;]*m";
+const OSC8_PATTERN = "\\x1b\\]8;;.*?\\x1b\\\\|\\x1b\\]8;;\\x1b\\\\";
+const ANSI_REGEX = new RegExp(ANSI_SGR_PATTERN, "g");
+const OSC8_REGEX = new RegExp(OSC8_PATTERN, "g");
+function stripAnsi(input) {
+	return input.replace(OSC8_REGEX, "").replace(ANSI_REGEX, "");
+}
+
+//#endregion
+//#region src/logging/console.ts
+const requireConfig = resolveNodeRequireFromMeta(import.meta.url);
+const loadConfigFallbackDefault = () => {
+	try {
+		return (requireConfig?.("../config/config.js"))?.loadConfig?.().logging;
+	} catch {
+		return;
+	}
+};
+let loadConfigFallback = loadConfigFallbackDefault;
+function normalizeConsoleLevel(level) {
+	if (isVerbose()) return "debug";
+	if (!level && process.env.VITEST === "true" && process.env.OPENCLAW_TEST_CONSOLE !== "1") return "silent";
+	return normalizeLogLevel(level, "info");
+}
+function normalizeConsoleStyle(style) {
+	if (style === "compact" || style === "json" || style === "pretty") return style;
+	if (!process.stdout.isTTY) return "compact";
+	return "pretty";
+}
+function resolveConsoleSettings() {
+	const envLevel = resolveEnvLogLevelOverride();
+	if (process.env.VITEST === "true" && process.env.OPENCLAW_TEST_CONSOLE !== "1" && !isVerbose() && !envLevel && !loggingState.overrideSettings) return {
+		level: "silent",
+		style: normalizeConsoleStyle(void 0)
+	};
+	let cfg = loggingState.overrideSettings ?? readLoggingConfig();
+	if (!cfg) if (loggingState.resolvingConsoleSettings) cfg = void 0;
+	else {
+		loggingState.resolvingConsoleSettings = true;
+		try {
+			cfg = loadConfigFallback();
+		} finally {
+			loggingState.resolvingConsoleSettings = false;
+		}
+	}
+	return {
+		level: envLevel ?? normalizeConsoleLevel(cfg?.consoleLevel),
+		style: normalizeConsoleStyle(cfg?.consoleStyle)
+	};
+}
+function consoleSettingsChanged(a, b) {
+	if (!a) return true;
+	return a.level !== b.level || a.style !== b.style;
+}
+function getConsoleSettings() {
+	const settings = resolveConsoleSettings();
+	const cached = loggingState.cachedConsoleSettings;
+	if (!cached || consoleSettingsChanged(cached, settings)) loggingState.cachedConsoleSettings = settings;
+	return loggingState.cachedConsoleSettings;
+}
+function shouldLogSubsystemToConsole(subsystem) {
+	const filter = loggingState.consoleSubsystemFilter;
+	if (!filter || filter.length === 0) return true;
+	return filter.some((prefix) => subsystem === prefix || subsystem.startsWith(`${prefix}/`));
+}
+
+//#endregion
+//#region src/logging/subsystem.ts
+function shouldLogToConsole(level, settings) {
+	if (settings.level === "silent") return false;
+	return levelToMinLevel(level) <= levelToMinLevel(settings.level);
+}
+const inspectValue = (() => {
+	const getBuiltinModule = process.getBuiltinModule;
+	if (typeof getBuiltinModule !== "function") return null;
+	try {
+		const utilNamespace = getBuiltinModule("util");
+		return typeof utilNamespace.inspect === "function" ? utilNamespace.inspect : null;
+	} catch {
+		return null;
+	}
+})();
+function isRichConsoleEnv() {
+	const term = (process.env.TERM ?? "").toLowerCase();
+	if (process.env.COLORTERM || process.env.TERM_PROGRAM) return true;
+	return term.length > 0 && term !== "dumb";
+}
+function getColorForConsole() {
+	const hasForceColor = typeof process.env.FORCE_COLOR === "string" && process.env.FORCE_COLOR.trim().length > 0 && process.env.FORCE_COLOR.trim() !== "0";
+	if (process.env.NO_COLOR && !hasForceColor) return new Chalk({ level: 0 });
+	const hasTty = Boolean(process.stdout.isTTY || process.stderr.isTTY);
+	return hasForceColor || hasTty || isRichConsoleEnv() ? new Chalk({ level: 1 }) : new Chalk({ level: 0 });
+}
+const SUBSYSTEM_COLORS = [
+	"cyan",
+	"green",
+	"yellow",
+	"blue",
+	"magenta",
+	"red"
+];
+const SUBSYSTEM_COLOR_OVERRIDES = { "gmail-watcher": "blue" };
+const SUBSYSTEM_PREFIXES_TO_DROP = [
+	"gateway",
+	"channels",
+	"providers"
+];
+const SUBSYSTEM_MAX_SEGMENTS = 2;
+const CHANNEL_SUBSYSTEM_PREFIXES = new Set([
+	"telegram",
+	"whatsapp",
+	"discord",
+	"irc",
+	"googlechat",
+	"slack",
+	"signal",
+	"imessage"
+]);
+function pickSubsystemColor(color, subsystem) {
+	const override = SUBSYSTEM_COLOR_OVERRIDES[subsystem];
+	if (override) return color[override];
+	let hash = 0;
+	for (let i = 0; i < subsystem.length; i += 1) hash = hash * 31 + subsystem.charCodeAt(i) | 0;
+	return color[SUBSYSTEM_COLORS[Math.abs(hash) % SUBSYSTEM_COLORS.length]];
+}
+function formatSubsystemForConsole(subsystem) {
+	const parts = subsystem.split("/").filter(Boolean);
+	const original = parts.join("/") || subsystem;
+	while (parts.length > 0 && SUBSYSTEM_PREFIXES_TO_DROP.includes(parts[0])) parts.shift();
+	if (parts.length === 0) return original;
+	if (CHANNEL_SUBSYSTEM_PREFIXES.has(parts[0])) return parts[0];
+	if (parts.length > SUBSYSTEM_MAX_SEGMENTS) return parts.slice(-SUBSYSTEM_MAX_SEGMENTS).join("/");
+	return parts.join("/");
+}
+function stripRedundantSubsystemPrefixForConsole(message, displaySubsystem) {
+	if (!displaySubsystem) return message;
+	if (message.startsWith("[")) {
+		const closeIdx = message.indexOf("]");
+		if (closeIdx > 1) {
+			if (message.slice(1, closeIdx).toLowerCase() === displaySubsystem.toLowerCase()) {
+				let i = closeIdx + 1;
+				while (message[i] === " ") i += 1;
+				return message.slice(i);
+			}
+		}
+	}
+	if (message.slice(0, displaySubsystem.length).toLowerCase() !== displaySubsystem.toLowerCase()) return message;
+	const next = message.slice(displaySubsystem.length, displaySubsystem.length + 1);
+	if (next !== ":" && next !== " ") return message;
+	let i = displaySubsystem.length;
+	while (message[i] === " ") i += 1;
+	if (message[i] === ":") i += 1;
+	while (message[i] === " ") i += 1;
+	return message.slice(i);
+}
+const CONSOLE_META_VALUE_MAX = 200;
+const CONSOLE_META_SUFFIX_MAX = 512;
+const CONSOLE_META_BARE_VALUE = /^[\w./:@+-]+$/;
+function formatConsoleMetaValue(value) {
+	if (value instanceof Error) return JSON.stringify(`${value.name}: ${value.message}`);
+	if (typeof value === "string") {
+		const bounded = value.length > CONSOLE_META_VALUE_MAX ? value.slice(0, CONSOLE_META_VALUE_MAX + 1) : value;
+		return CONSOLE_META_BARE_VALUE.test(bounded) ? bounded : JSON.stringify(bounded);
+	}
+	if (value === null || typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") return `${value}`;
+	if (typeof value === "function" || typeof value === "symbol") return;
+	try {
+		return JSON.stringify(value);
+	} catch {
+		return JSON.stringify("[unserializable]");
+	}
+}
+function truncateConsoleMeta(text, max) {
+	if (text.length <= max) return text;
+	return `${text.slice(0, avoidTrailingHighSurrogateBreak(text, Math.max(0, max - 1)))}…`;
+}
+function formatConsoleMeta(meta) {
+	if (!meta) return "";
+	try {
+		const parts = [];
+		let budget = CONSOLE_META_SUFFIX_MAX;
+		for (const [key, value] of Object.entries(meta)) {
+			if (value === void 0) continue;
+			const rendered = formatConsoleMetaValue(value);
+			if (rendered === void 0) continue;
+			const part = `${key}=${truncateConsoleMeta(rendered, CONSOLE_META_VALUE_MAX)}`;
+			parts.push(part);
+			budget -= part.length + 1;
+			if (budget <= 0) break;
+		}
+		return truncateConsoleMeta(parts.join(" "), CONSOLE_META_SUFFIX_MAX);
+	} catch {
+		return "[meta unavailable]";
+	}
+}
+function formatConsoleLine(opts) {
+	const displaySubsystem = opts.style === "json" ? opts.subsystem : formatSubsystemForConsole(opts.subsystem);
+	if (opts.style === "json") return JSON.stringify({
+		...opts.meta,
+		time: (/* @__PURE__ */ new Date()).toISOString(),
+		level: opts.level,
+		subsystem: displaySubsystem,
+		message: opts.message
+	});
+	const color = getColorForConsole();
+	const prefix = `[${displaySubsystem}]`;
+	const prefixColor = pickSubsystemColor(color, displaySubsystem);
+	const levelColor = opts.level === "error" || opts.level === "fatal" ? color.red : opts.level === "warn" ? color.yellow : opts.level === "debug" || opts.level === "trace" ? color.gray : color.cyan;
+	const displayMessage = stripRedundantSubsystemPrefixForConsole(opts.message, displaySubsystem);
+	const head = [(() => {
+		if (opts.style === "pretty") return color.gray((/* @__PURE__ */ new Date()).toISOString().slice(11, 19));
+		if (loggingState.consoleTimestampPrefix) return color.gray((/* @__PURE__ */ new Date()).toISOString());
+		return "";
+	})(), prefixColor(prefix)].filter(Boolean).join(" ");
+	const metaSuffix = formatConsoleMeta(opts.meta);
+	return metaSuffix ? `${head} ${levelColor(displayMessage)} ${color.gray(metaSuffix)}` : `${head} ${levelColor(displayMessage)}`;
+}
+function writeConsoleLine(level, line) {
+	clearActiveProgressLine();
+	const sanitized = process.platform === "win32" && process.env.GITHUB_ACTIONS === "true" ? line.replace(/[\uD800-\uDBFF][\uDC00-\uDFFF]/g, "?").replace(/[\uD800-\uDFFF]/g, "?") : line;
+	const sink = loggingState.rawConsole ?? console;
+	if (loggingState.forceConsoleToStderr || loggingState.forceSubsystemConsoleToStderr || level === "error" || level === "fatal") (sink.error ?? console.error)(sanitized);
+	else if (level === "warn") (sink.warn ?? console.warn)(sanitized);
+	else (sink.log ?? console.log)(sanitized);
+}
+function logToFile(fileLogger, level, message, meta) {
+	if (level === "silent") return;
+	const method = fileLogger[level];
+	if (typeof method !== "function") return;
+	if (meta && Object.keys(meta).length > 0) method.call(fileLogger, meta, message);
+	else method.call(fileLogger, message);
+}
+function createSubsystemLogger(subsystem) {
+	let fileLogger = null;
+	const getFileLogger = () => {
+		if (!fileLogger) fileLogger = getChildLogger({ subsystem });
+		return fileLogger;
+	};
+	const emit = (level, message, meta) => {
+		const consoleSettings = getConsoleSettings();
+		const consoleEnabled = shouldLogToConsole(level, { level: consoleSettings.level }) && shouldLogSubsystemToConsole(subsystem);
+		const fileEnabled = isFileLogLevelEnabled(level);
+		if (!consoleEnabled && !fileEnabled) return;
+		let consoleMessageOverride;
+		let fileMeta = meta;
+		try {
+			if (meta && Object.keys(meta).length > 0) {
+				const { consoleMessage, ...rest } = meta;
+				if (typeof consoleMessage === "string") consoleMessageOverride = consoleMessage;
+				fileMeta = Object.keys(rest).length > 0 ? rest : void 0;
+			}
+		} catch {
+			consoleMessageOverride = void 0;
+			fileMeta = { meta: "[meta unavailable]" };
+		}
+		if (fileEnabled) logToFile(getFileLogger(), level, message, fileMeta);
+		if (!consoleEnabled) return;
+		const consoleMessage = consoleMessageOverride ?? message;
+		if (!isVerbose() && subsystem === "agent/embedded" && /(sessionId|runId)=probe-/.test(consoleMessage)) return;
+		let line;
+		try {
+			line = formatConsoleLine({
+				level,
+				subsystem,
+				message: consoleSettings.style === "json" ? message : consoleMessage,
+				style: consoleSettings.style,
+				meta: fileMeta
+			});
+		} catch {
+			try {
+				line = formatConsoleLine({
+					level,
+					subsystem,
+					message: consoleSettings.style === "json" ? message : consoleMessage,
+					style: consoleSettings.style,
+					meta: { meta: "[meta unavailable]" }
+				});
+			} catch {
+				line = `[${subsystem}] ${consoleMessage}`;
+			}
+		}
+		writeConsoleLine(level, line);
+	};
+	const isConsoleEnabled = (level) => {
+		return shouldLogToConsole(level, { level: getConsoleSettings().level }) && shouldLogSubsystemToConsole(subsystem);
+	};
+	const isFileEnabled = (level) => isFileLogLevelEnabled(level);
+	return {
+		subsystem,
+		isEnabled: (level, target = "any") => {
+			if (target === "console") return isConsoleEnabled(level);
+			if (target === "file") return isFileEnabled(level);
+			return isConsoleEnabled(level) || isFileEnabled(level);
+		},
+		trace: (message, meta) => emit("trace", message, meta),
+		debug: (message, meta) => emit("debug", message, meta),
+		info: (message, meta) => emit("info", message, meta),
+		warn: (message, meta) => emit("warn", message, meta),
+		error: (message, meta) => emit("error", message, meta),
+		fatal: (message, meta) => emit("fatal", message, meta),
+		raw: (message) => {
+			if (isFileEnabled("info")) logToFile(getFileLogger(), "info", message, { raw: true });
+			if (isConsoleEnabled("info")) {
+				if (!isVerbose() && subsystem === "agent/embedded" && /(sessionId|runId)=probe-/.test(message)) return;
+				writeConsoleLine("info", message);
+			}
+		},
+		child: (name) => createSubsystemLogger(`${subsystem}/${name}`)
+	};
+}
+
+//#endregion
+export { clampNumber as $, resolveConfigIncludes as A, hasNodeErrorCode as B, appendFileLog as C, ConfigIncludeError as D, normalizeConfigPaths as E, openBoundaryFileSync as F, applyConfigEnvVars as G, isPathInside$1 as H, sameFileIdentity$1 as I, MissingEnvVarError as J, isDangerousHostEnvVarName as K, BOUNDARY_PATH_ALIAS_POLICIES as L, isPathInside as M, isPathInsideWithRealpath as N, INCLUDE_KEY as O, openBoundaryFile as P, clampInt as Q, resolveBoundaryPath as R, resolveNodeRequireFromMeta as S, normalizeLogLevel as T, isSymlinkOpenError as U, isNotFoundPathError as V, normalizeWindowsPathForComparison as W, resolveConfigEnvVars as X, containsEnvVarReference as Y, CONFIG_DIR as Z, colorize as _, createNonExitingRuntime as a, pathExists$1 as at, getChildLogger as b, registerActiveProgressLine as c, safeParseJson as ct, info as d, sleep as dt, ensureDir as et, logVerbose as f, sliceUtf16Safe as ft, warn as g, shouldLogVerbose as h, chunkTextByBreakResolver as i, normalizeE164 as it, isBlockedObjectKey as j, readConfigIncludeFileWithGuards as k, unregisterActiveProgressLine as l, shortenHomeInString as lt, setVerbose as m, resolvePreferredOpenClawTmpDir as mt, stripAnsi as n, formatTerminalLink as nt, defaultRuntime as o, resolveConfigDir as ot, logVerboseConsole as p, truncateUtf16Safe as pt, sanitizeHostExecEnv as q, avoidTrailingHighSurrogateBreak as r, isRecord as rt, clearActiveProgressLine as s, resolveUserPath as st, createSubsystemLogger as t, escapeRegExp as tt, danger as u, shortenHomePath as ut, isRich as v, createFileLogWriter as w, getLogger as x, theme as y, resolvePathViaExistingAncestorSync as z };