openclaw-multi-auto 1.8.4 → 1.8.6

package/dist/{query-expansion-BIMwPSMg.js → query-expansion-BMQzl41m.js}

@@ -1,11 +1,11 @@
-import { l as resolveStateDir, p as resolveRequiredHomeDir, u as expandHomePrefix } from "./paths-jtwudEDq.js";
-import { B as shouldLogVerbose, D as resolveUserPath, I as danger, Y as resolveNodeRequireFromMeta, a as createSubsystemLogger, i as logWarn, n as logError, t as logDebug, w as pathExists$1 } from "./logger-mQKrXyAc.js";
+import { l as resolveStateDir, p as resolveRequiredHomeDir, u as expandHomePrefix } from "./paths-BnSNMlFT.js";
+import { B as shouldLogVerbose, D as resolveUserPath, I as danger, Y as resolveNodeRequireFromMeta, a as createSubsystemLogger, i as logWarn, n as logError, t as logDebug, w as pathExists$1 } from "./logger-Budylr6i.js";
 import { createRequire } from "node:module";
-import fs, { constants, readFileSync, statSync } from "node:fs";
+import fsSync, { constants, readFileSync, statSync } from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { promisify } from "node:util";
-import fs$1 from "node:fs/promises";
+import fs from "node:fs/promises";
 import { execFile, spawn } from "node:child_process";
 import process$1 from "node:process";
 import { fileURLToPath } from "node:url";
@@ -569,7 +569,7 @@ async function resolveBoundaryPathLexicalAsync(params) {
 		const stat = await readLexicalStat({
 			...sharedStepParams,
 			missingFromIndex: idx,
-			read: (cursor) => fs$1.lstat(cursor)
+			read: (cursor) => fs.lstat(cursor)
 		});
 		if (!stat) break;
 		const disposition = handleLexicalStatDisposition({
@@ -606,7 +606,7 @@ function resolveBoundaryPathLexicalSync(params) {
 			rootCanonicalPath: params.rootCanonicalPath,
 			resolveParams: params.params,
 			absolutePath: params.absolutePath,
-			read: (cursor) => fs.lstatSync(cursor)
+			read: (cursor) => fsSync.lstatSync(cursor)
 		});
 		if (isPromiseLike(maybeStat)) throw new Error("Unexpected async lexical stat");
 		const stat = maybeStat;
@@ -745,7 +745,7 @@ async function resolvePathViaExistingAncestor(targetPath) {
 	}
 	if (!await pathExists(cursor)) return normalized;
 	try {
-		const resolvedAncestor = path.resolve(await fs$1.realpath(cursor));
+		const resolvedAncestor = path.resolve(await fs.realpath(cursor));
 		if (missingSuffix.length === 0) return resolvedAncestor;
 		return path.resolve(resolvedAncestor, ...missingSuffix);
 	} catch {
@@ -756,15 +756,15 @@ function resolvePathViaExistingAncestorSync(targetPath) {
 	const normalized = path.resolve(targetPath);
 	let cursor = normalized;
 	const missingSuffix = [];
-	while (!isFilesystemRoot(cursor) && !fs.existsSync(cursor)) {
+	while (!isFilesystemRoot(cursor) && !fsSync.existsSync(cursor)) {
 		missingSuffix.unshift(path.basename(cursor));
 		const parent = path.dirname(cursor);
 		if (parent === cursor) break;
 		cursor = parent;
 	}
-	if (!fs.existsSync(cursor)) return normalized;
+	if (!fsSync.existsSync(cursor)) return normalized;
 	try {
-		const resolvedAncestor = path.resolve(fs.realpathSync(cursor));
+		const resolvedAncestor = path.resolve(fsSync.realpathSync(cursor));
 		if (missingSuffix.length === 0) return resolvedAncestor;
 		return path.resolve(resolvedAncestor, ...missingSuffix);
 	} catch {
@@ -775,7 +775,7 @@ async function getPathKind(absolutePath, preserveFinalSymlink) {
 	try {
 		return {
 			exists: true,
-			kind: toResolvedKind(preserveFinalSymlink ? await fs$1.lstat(absolutePath) : await fs$1.stat(absolutePath))
+			kind: toResolvedKind(preserveFinalSymlink ? await fs.lstat(absolutePath) : await fs.stat(absolutePath))
 		};
 	} catch (error) {
 		if (isNotFoundPathError(error)) return {
@@ -789,7 +789,7 @@ function getPathKindSync(absolutePath, preserveFinalSymlink) {
 	try {
 		return {
 			exists: true,
-			kind: toResolvedKind(preserveFinalSymlink ? fs.lstatSync(absolutePath) : fs.statSync(absolutePath))
+			kind: toResolvedKind(preserveFinalSymlink ? fsSync.lstatSync(absolutePath) : fsSync.statSync(absolutePath))
 		};
 	} catch (error) {
 		if (isNotFoundPathError(error)) return {
@@ -831,7 +831,7 @@ function isFilesystemRoot(candidate) {
 }
 async function pathExists(targetPath) {
 	try {
-		await fs$1.lstat(targetPath);
+		await fs.lstat(targetPath);
 		return true;
 	} catch (error) {
 		if (isNotFoundPathError(error)) return false;
@@ -840,19 +840,19 @@ async function pathExists(targetPath) {
 }
 async function resolveSymlinkHopPath(symlinkPath) {
 	try {
-		return path.resolve(await fs$1.realpath(symlinkPath));
+		return path.resolve(await fs.realpath(symlinkPath));
 	} catch (error) {
 		if (!isNotFoundPathError(error)) throw error;
-		const linkTarget = await fs$1.readlink(symlinkPath);
+		const linkTarget = await fs.readlink(symlinkPath);
 		return resolvePathViaExistingAncestor(path.resolve(path.dirname(symlinkPath), linkTarget));
 	}
 }
 function resolveSymlinkHopPathSync(symlinkPath) {
 	try {
-		return path.resolve(fs.realpathSync(symlinkPath));
+		return path.resolve(fsSync.realpathSync(symlinkPath));
 	} catch (error) {
 		if (!isNotFoundPathError(error)) throw error;
-		const linkTarget = fs.readlinkSync(symlinkPath);
+		const linkTarget = fsSync.readlinkSync(symlinkPath);
 		return resolvePathViaExistingAncestorSync(path.resolve(path.dirname(symlinkPath), linkTarget));
 	}
 }
@@ -876,7 +876,7 @@ function sameFileIdentity(left, right) {
 	return sameFileIdentity$1(left, right);
 }
 function openVerifiedFileSync(params) {
-	const ioFs = params.ioFs ?? fs;
+	const ioFs = params.ioFs ?? fsSync;
 	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;
@@ -952,7 +952,7 @@ 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 ioFs = params.ioFs ?? fsSync;
 	const resolved = resolveBoundaryFilePathGeneric({
 		absolutePath: params.absolutePath,
 		resolve: (absolutePath) => resolveBoundaryPathSync({
@@ -1003,7 +1003,7 @@ function finalizeBoundaryFileOpen(params) {
 	});
 }
 async function openBoundaryFile(params) {
-	const ioFs = params.ioFs ?? fs;
+	const ioFs = params.ioFs ?? fsSync;
 	const maybeResolved = resolveBoundaryFilePathGeneric({
 		absolutePath: params.absolutePath,
 		resolve: (absolutePath) => resolveBoundaryPath({
@@ -1168,7 +1168,7 @@ function resolveNpmArgvForWindows(argv) {
 	if (!cliName) return null;
 	const nodeDir = path.dirname(process$1.execPath);
 	const cliPath = path.join(nodeDir, "node_modules", "npm", "bin", cliName);
-	if (!fs.existsSync(cliPath)) {
+	if (!fsSync.existsSync(cliPath)) {
 		const command = argv[0] ?? "";
 		return [path.extname(command).toLowerCase() ? command : `${command}.cmd`, ...argv.slice(1)];
 	}
@@ -1366,14 +1366,14 @@ function parsePackageName(raw) {
 }
 async function readPackageName(dir) {
 	try {
-		return parsePackageName(await fs$1.readFile(path.join(dir, "package.json"), "utf-8"));
+		return parsePackageName(await fs.readFile(path.join(dir, "package.json"), "utf-8"));
 	} catch {
 		return null;
 	}
 }
 function readPackageNameSync(dir) {
 	try {
-		return parsePackageName(fs.readFileSync(path.join(dir, "package.json"), "utf-8"));
+		return parsePackageName(fsSync.readFileSync(path.join(dir, "package.json"), "utf-8"));
 	} catch {
 		return null;
 	}
@@ -1405,7 +1405,7 @@ function candidateDirsFromArgv1(argv1) {
 	const normalized = path.resolve(argv1);
 	const candidates = [path.dirname(normalized)];
 	try {
-		const resolved = fs.realpathSync(normalized);
+		const resolved = fsSync.realpathSync(normalized);
 		if (resolved !== normalized) candidates.push(path.dirname(resolved));
 	} catch {}
 	const parts = normalized.split(path.sep);
@@ -1517,14 +1517,14 @@ async function readWorkspaceFileWithGuards(params) {
 	const identity = workspaceFileIdentity(opened.stat, opened.path);
 	const cached = workspaceFileCache.get(params.filePath);
 	if (cached && cached.identity === identity) {
-		fs.closeSync(opened.fd);
+		fsSync.closeSync(opened.fd);
 		return {
 			ok: true,
 			content: cached.content
 		};
 	}
 	try {
-		const content = fs.readFileSync(opened.fd, "utf-8");
+		const content = fsSync.readFileSync(opened.fd, "utf-8");
 		workspaceFileCache.set(params.filePath, {
 			content,
 			identity
@@ -1541,7 +1541,7 @@ async function readWorkspaceFileWithGuards(params) {
 			error
 		};
 	} finally {
-		fs.closeSync(opened.fd);
+		fsSync.closeSync(opened.fd);
 	}
 }
 function stripFrontMatter(content) {
@@ -1560,7 +1560,7 @@ async function loadTemplate(name) {
 		const templateDir = await resolveWorkspaceTemplateDir();
 		const templatePath = path.join(templateDir, name);
 		try {
-			return stripFrontMatter(await fs$1.readFile(templatePath, "utf-8"));
+			return stripFrontMatter(await fs.readFile(templatePath, "utf-8"));
 		} catch {
 			throw new Error(`Missing workspace template: ${name} (${templatePath}). Ensure docs/reference/templates are packaged.`);
 		}
@@ -1575,7 +1575,7 @@ async function loadTemplate(name) {
 }
 async function writeFileIfMissing(filePath, content) {
 	try {
-		await fs$1.writeFile(filePath, content, {
+		await fs.writeFile(filePath, content, {
 			encoding: "utf-8",
 			flag: "wx"
 		});
@@ -1587,7 +1587,7 @@ async function writeFileIfMissing(filePath, content) {
 }
 async function fileExists(filePath) {
 	try {
-		await fs$1.access(filePath);
+		await fs.access(filePath);
 		return true;
 	} catch {
 		return false;
@@ -1611,27 +1611,27 @@ function parseWorkspaceOnboardingState(raw) {
 }
 async function readWorkspaceOnboardingState(statePath) {
 	try {
-		return parseWorkspaceOnboardingState(await fs$1.readFile(statePath, "utf-8")) ?? { version: WORKSPACE_STATE_VERSION };
+		return parseWorkspaceOnboardingState(await fs.readFile(statePath, "utf-8")) ?? { version: WORKSPACE_STATE_VERSION };
 	} catch (err) {
 		if (err.code !== "ENOENT") throw err;
 		return { version: WORKSPACE_STATE_VERSION };
 	}
 }
 async function writeWorkspaceOnboardingState(statePath, state) {
-	await fs$1.mkdir(path.dirname(statePath), { recursive: true });
+	await fs.mkdir(path.dirname(statePath), { recursive: true });
 	const payload = `${JSON.stringify(state, null, 2)}\n`;
 	const tmpPath = `${statePath}.tmp-${process.pid}-${Date.now().toString(36)}`;
 	try {
-		await fs$1.writeFile(tmpPath, payload, { encoding: "utf-8" });
-		await fs$1.rename(tmpPath, statePath);
+		await fs.writeFile(tmpPath, payload, { encoding: "utf-8" });
+		await fs.rename(tmpPath, statePath);
 	} catch (err) {
-		await fs$1.unlink(tmpPath).catch(() => {});
+		await fs.unlink(tmpPath).catch(() => {});
 		throw err;
 	}
 }
 async function hasGitRepo(dir) {
 	try {
-		await fs$1.stat(path.join(dir, ".git"));
+		await fs.stat(path.join(dir, ".git"));
 		return true;
 	} catch {
 		return false;
@@ -1661,7 +1661,7 @@ async function ensureGitRepo(dir, isBrandNewWorkspace) {
 }
 async function ensureAgentWorkspace(params) {
 	const dir = resolveUserPath(params?.dir?.trim() ? params.dir.trim() : DEFAULT_AGENT_WORKSPACE_DIR);
-	await fs$1.mkdir(dir, { recursive: true });
+	await fs.mkdir(dir, { recursive: true });
 	if (!params?.ensureBootstrapFiles) return { dir };
 	const agentsPath = path.join(dir, DEFAULT_AGENTS_FILENAME);
 	const soulPath = path.join(dir, DEFAULT_SOUL_FILENAME);
@@ -1688,7 +1688,7 @@ async function ensureAgentWorkspace(params) {
 		const paths = [...templatePaths, ...userContentPaths];
 		return (await Promise.all(paths.map(async (p) => {
 			try {
-				await fs$1.access(p);
+				await fs.access(p);
 				return true;
 			} catch {
 				return false;
@@ -1721,7 +1721,7 @@ async function ensureAgentWorkspace(params) {
 	if (!state.bootstrapSeededAt && bootstrapExists) markState({ bootstrapSeededAt: nowIso() });
 	if (!state.onboardingCompletedAt && state.bootstrapSeededAt && !bootstrapExists) markState({ onboardingCompletedAt: nowIso() });
 	if (!state.bootstrapSeededAt && !state.onboardingCompletedAt && !bootstrapExists) {
-		const [identityContent, userContent] = await Promise.all([fs$1.readFile(identityPath, "utf-8"), fs$1.readFile(userPath, "utf-8")]);
+		const [identityContent, userContent] = await Promise.all([fs.readFile(identityPath, "utf-8"), fs.readFile(userPath, "utf-8")]);
 		const hasUserContent = await (async () => {
 			const indicators = [
 				path.join(dir, "memory"),
@@ -1729,7 +1729,7 @@ async function ensureAgentWorkspace(params) {
 				path.join(dir, ".git")
 			];
 			for (const indicator of indicators) try {
-				await fs$1.access(indicator);
+				await fs.access(indicator);
 				return true;
 			} catch {}
 			return false;
@@ -1758,7 +1758,7 @@ async function resolveMemoryBootstrapEntry(resolvedDir) {
 	for (const name of [DEFAULT_MEMORY_FILENAME, DEFAULT_MEMORY_ALT_FILENAME]) {
 		const filePath = path.join(resolvedDir, name);
 		try {
-			await fs$1.access(filePath);
+			await fs.access(filePath);
 			return {
 				name,
 				filePath
@@ -2477,7 +2477,7 @@ async function assertNoHardlinkedFinalPath(params) {
 	if (params.allowFinalHardlinkForUnlink) return;
 	let stat;
 	try {
-		stat = await fs$1.stat(params.filePath);
+		stat = await fs.stat(params.filePath);
 	} catch (err) {
 		if (isNotFoundPathError(err)) return;
 		throw err;
@@ -2663,24 +2663,24 @@ async function runPinnedWriteHelper(params) {
 }
 async function runPinnedWriteFallback(params) {
 	const parentPath = params.relativeParentPath ? path.join(params.rootPath, ...params.relativeParentPath.split("/")) : params.rootPath;
-	if (params.mkdir) await fs$1.mkdir(parentPath, { recursive: true });
+	if (params.mkdir) await fs.mkdir(parentPath, { recursive: true });
 	const targetPath = path.join(parentPath, params.basename);
 	const tempPath = path.join(parentPath, `.${params.basename}.fallback.tmp`);
-	if (params.input.kind === "buffer") if (typeof params.input.data === "string") await fs$1.writeFile(tempPath, params.input.data, {
+	if (params.input.kind === "buffer") if (typeof params.input.data === "string") await fs.writeFile(tempPath, params.input.data, {
 		encoding: params.input.encoding ?? "utf8",
 		mode: params.mode
 	});
-	else await fs$1.writeFile(tempPath, params.input.data, { mode: params.mode });
+	else await fs.writeFile(tempPath, params.input.data, { mode: params.mode });
 	else {
-		const handle = await fs$1.open(tempPath, "w", params.mode);
+		const handle = await fs.open(tempPath, "w", params.mode);
 		try {
 			await pipeline(params.input.stream, handle.createWriteStream());
 		} finally {
 			await handle.close().catch(() => {});
 		}
 	}
-	await fs$1.rename(tempPath, targetPath);
-	const stat = await fs$1.stat(targetPath);
+	await fs.rename(tempPath, targetPath);
+	const stat = await fs.stat(targetPath);
 	return {
 		dev: stat.dev,
 		ino: stat.ino
@@ -2705,19 +2705,19 @@ const ensureTrailingSep = (value) => value.endsWith(path.sep) ? value : value +
 async function expandRelativePathWithHome(relativePath) {
 	let home = process.env.HOME || process.env.USERPROFILE || os.homedir();
 	try {
-		home = await fs$1.realpath(home);
+		home = await fs.realpath(home);
 	} catch {}
 	return expandHomePrefix(relativePath, { home });
 }
 async function openVerifiedLocalFile(filePath, options) {
 	try {
-		if ((await fs$1.lstat(filePath)).isDirectory()) throw new SafeOpenError("not-file", "not a file");
+		if ((await fs.lstat(filePath)).isDirectory()) throw new SafeOpenError("not-file", "not a file");
 	} catch (err) {
 		if (err instanceof SafeOpenError) throw err;
 	}
 	let handle;
 	try {
-		handle = await fs$1.open(filePath, OPEN_READ_FLAGS);
+		handle = await fs.open(filePath, OPEN_READ_FLAGS);
 	} catch (err) {
 		if (isNotFoundPathError(err)) throw new SafeOpenError("not-found", "file not found");
 		if (isSymlinkOpenError(err)) throw new SafeOpenError("symlink", "symlink open blocked", { cause: err });
@@ -2725,13 +2725,13 @@ async function openVerifiedLocalFile(filePath, options) {
 		throw err;
 	}
 	try {
-		const [stat, lstat] = await Promise.all([handle.stat(), fs$1.lstat(filePath)]);
+		const [stat, lstat] = await Promise.all([handle.stat(), fs.lstat(filePath)]);
 		if (lstat.isSymbolicLink()) throw new SafeOpenError("symlink", "symlink not allowed");
 		if (!stat.isFile()) throw new SafeOpenError("not-file", "not a file");
 		if (options?.rejectHardlinks && stat.nlink > 1) throw new SafeOpenError("invalid-path", "hardlinked path not allowed");
 		if (!sameFileIdentity$1(stat, lstat)) throw new SafeOpenError("path-mismatch", "path changed during read");
-		const realPath = await fs$1.realpath(filePath);
-		const realStat = await fs$1.stat(realPath);
+		const realPath = await fs.realpath(filePath);
+		const realStat = await fs.stat(realPath);
 		if (options?.rejectHardlinks && realStat.nlink > 1) throw new SafeOpenError("invalid-path", "hardlinked path not allowed");
 		if (!sameFileIdentity$1(stat, realStat)) throw new SafeOpenError("path-mismatch", "path mismatch");
 		return {
@@ -2749,7 +2749,7 @@ async function openVerifiedLocalFile(filePath, options) {
 async function resolvePathWithinRoot(params) {
 	let rootReal;
 	try {
-		rootReal = await fs$1.realpath(params.rootDir);
+		rootReal = await fs.realpath(params.rootDir);
 	} catch (err) {
 		if (isNotFoundPathError(err)) throw new SafeOpenError("not-found", "root dir not found");
 		throw err;
@@ -2850,7 +2850,7 @@ function buildAtomicWriteTempPath(targetPath) {
 	return path.join(dir, `.${base}.${process.pid}.${randomUUID()}.tmp`);
 }
 async function writeTempFileForAtomicReplace(params) {
-	const tempHandle = await fs$1.open(params.tempPath, OPEN_WRITE_CREATE_FLAGS, params.mode);
+	const tempHandle = await fs.open(params.tempPath, OPEN_WRITE_CREATE_FLAGS, params.mode);
 	try {
 		if (typeof params.data === "string") await tempHandle.writeFile(params.data, params.encoding ?? "utf8");
 		else await tempHandle.writeFile(params.data);
@@ -2860,7 +2860,7 @@ async function writeTempFileForAtomicReplace(params) {
 	}
 }
 async function verifyAtomicWriteResult(params) {
-	const rootWithSep = ensureTrailingSep(await fs$1.realpath(params.rootDir));
+	const rootWithSep = ensureTrailingSep(await fs.realpath(params.rootDir));
 	const opened = await openVerifiedLocalFile(params.targetPath, { rejectHardlinks: true });
 	try {
 		if (!sameFileIdentity$1(opened.stat, params.expectedIdentity)) throw new SafeOpenError("path-mismatch", "path changed during write");
@@ -2871,13 +2871,13 @@ async function verifyAtomicWriteResult(params) {
 }
 async function resolveOpenedFileRealPathForHandle(handle, ioPath) {
 	try {
-		return await fs$1.realpath(ioPath);
+		return await fs.realpath(ioPath);
 	} catch (err) {
 		if (!isNotFoundPathError(err)) throw err;
 	}
 	const fdCandidates = process.platform === "linux" ? [`/proc/self/fd/${handle.fd}`, `/dev/fd/${handle.fd}`] : process.platform === "win32" ? [] : [`/dev/fd/${handle.fd}`];
 	for (const fdPath of fdCandidates) try {
-		return await fs$1.realpath(fdPath);
+		return await fs.realpath(fdPath);
 	} catch {}
 	throw new SafeOpenError("path-mismatch", "unable to resolve opened file path");
 }
@@ -2892,10 +2892,10 @@ async function openWritableFileWithinRoot(params) {
 	} catch (err) {
 		throw new SafeOpenError("invalid-path", "path alias escape blocked", { cause: err });
 	}
-	if (params.mkdir !== false) await fs$1.mkdir(path.dirname(resolved), { recursive: true });
+	if (params.mkdir !== false) await fs.mkdir(path.dirname(resolved), { recursive: true });
 	let ioPath = resolved;
 	try {
-		const resolvedRealPath = await fs$1.realpath(resolved);
+		const resolvedRealPath = await fs.realpath(resolved);
 		if (!isPathInside(rootWithSep, resolvedRealPath)) throw new SafeOpenError("outside-workspace", "file is outside workspace root");
 		ioPath = resolvedRealPath;
 	} catch (err) {
@@ -2909,10 +2909,10 @@ async function openWritableFileWithinRoot(params) {
 	const createFlags = params.append ? OPEN_APPEND_CREATE_FLAGS : OPEN_WRITE_CREATE_FLAGS;
 	try {
 		try {
-			handle = await fs$1.open(ioPath, existingFlags, fileMode);
+			handle = await fs.open(ioPath, existingFlags, fileMode);
 		} catch (err) {
 			if (!isNotFoundPathError(err)) throw err;
-			handle = await fs$1.open(ioPath, createFlags, fileMode);
+			handle = await fs.open(ioPath, createFlags, fileMode);
 			createdForWrite = true;
 		}
 	} catch (err) {
@@ -2926,7 +2926,7 @@ async function openWritableFileWithinRoot(params) {
 		if (!stat.isFile()) throw new SafeOpenError("invalid-path", "path is not a regular file under root");
 		if (stat.nlink > 1) throw new SafeOpenError("invalid-path", "hardlinked path not allowed");
 		try {
-			const lstat = await fs$1.lstat(ioPath);
+			const lstat = await fs.lstat(ioPath);
 			if (lstat.isSymbolicLink() || !lstat.isFile()) throw new SafeOpenError("invalid-path", "path is not a regular file under root");
 			if (!sameFileIdentity$1(stat, lstat)) throw new SafeOpenError("path-mismatch", "path changed during write");
 		} catch (err) {
@@ -2934,7 +2934,7 @@ async function openWritableFileWithinRoot(params) {
 		}
 		const realPath = await resolveOpenedFileRealPathForHandle(handle, ioPath);
 		openedRealPath = realPath;
-		const realStat = await fs$1.stat(realPath);
+		const realStat = await fs.stat(realPath);
 		if (!sameFileIdentity$1(stat, realStat)) throw new SafeOpenError("path-mismatch", "path mismatch");
 		if (realStat.nlink > 1) throw new SafeOpenError("invalid-path", "hardlinked path not allowed");
 		if (!isPathInside(rootWithSep, realPath)) throw new SafeOpenError("outside-workspace", "file is outside workspace root");
@@ -2949,7 +2949,7 @@ async function openWritableFileWithinRoot(params) {
 		const cleanupCreatedPath = createdForWrite && err instanceof SafeOpenError;
 		const cleanupPath = openedRealPath ?? ioPath;
 		await handle.close().catch(() => {});
-		if (cleanupCreatedPath) await fs$1.rm(cleanupPath, { force: true }).catch(() => {});
+		if (cleanupCreatedPath) await fs.rm(cleanupPath, { force: true }).catch(() => {});
 		throw err;
 	}
 }
@@ -3127,7 +3127,7 @@ async function writeFileWithinRootLegacy(params) {
 			encoding: params.encoding,
 			mode: targetMode || 384
 		});
-		await fs$1.rename(tempPath, destinationPath);
+		await fs.rename(tempPath, destinationPath);
 		tempPath = null;
 		try {
 			await verifyAtomicWriteResult({
@@ -3140,7 +3140,7 @@ async function writeFileWithinRootLegacy(params) {
 			throw err;
 		}
 	} finally {
-		if (tempPath) await fs$1.rm(tempPath, { force: true }).catch(() => {});
+		if (tempPath) await fs.rm(tempPath, { force: true }).catch(() => {});
 	}
 }
 async function copyFileWithinRootLegacy(params, source) {
@@ -3162,7 +3162,7 @@ async function copyFileWithinRootLegacy(params, source) {
 		await target.handle.close().catch(() => {});
 		targetClosedByUs = true;
 		tempPath = buildAtomicWriteTempPath(destinationPath);
-		tempHandle = await fs$1.open(tempPath, OPEN_WRITE_CREATE_FLAGS, targetMode || 384);
+		tempHandle = await fs.open(tempPath, OPEN_WRITE_CREATE_FLAGS, targetMode || 384);
 		const sourceStream = source.handle.createReadStream();
 		const targetStream = tempHandle.createWriteStream();
 		sourceStream.once("close", () => {
@@ -3172,13 +3172,13 @@ async function copyFileWithinRootLegacy(params, source) {
 			tempClosedByStream = true;
 		});
 		await import("node:stream/promises").then(({ pipeline }) => pipeline(sourceStream, targetStream));
-		const writtenStat = await fs$1.stat(tempPath);
+		const writtenStat = await fs.stat(tempPath);
 		if (!tempClosedByStream) {
 			await tempHandle.close().catch(() => {});
 			tempClosedByStream = true;
 		}
 		tempHandle = null;
-		await fs$1.rename(tempPath, destinationPath);
+		await fs.rename(tempPath, destinationPath);
 		tempPath = null;
 		try {
 			await verifyAtomicWriteResult({
@@ -3191,10 +3191,10 @@ async function copyFileWithinRootLegacy(params, source) {
 			throw err;
 		}
 	} catch (err) {
-		if (target?.createdForWrite) await fs$1.rm(target.openedRealPath, { force: true }).catch(() => {});
+		if (target?.createdForWrite) await fs.rm(target.openedRealPath, { force: true }).catch(() => {});
 		throw err;
 	} finally {
-		if (tempPath) await fs$1.rm(tempPath, { force: true }).catch(() => {});
+		if (tempPath) await fs.rm(tempPath, { force: true }).catch(() => {});
 		if (!sourceClosedByStream) await source.handle.close().catch(() => {});
 		if (tempHandle && !tempClosedByStream) await tempHandle.close().catch(() => {});
 		if (target && !targetClosedByUs) await target.handle.close().catch(() => {});
@@ -3431,7 +3431,7 @@ function resolveStructuralSessionFallbackPath(candidateAbsPath, expectedAgentId)
 }
 function safeRealpathSync(filePath) {
 	try {
-		return fs.realpathSync(filePath);
+		return fsSync.realpathSync(filePath);
 	} catch {
 		return;
 	}
@@ -3598,7 +3598,7 @@ function isFileMissingError(err) {
 async function statRegularFile(absPath) {
 	let stat;
 	try {
-		stat = await fs$1.lstat(absPath);
+		stat = await fs.lstat(absPath);
 	} catch (err) {
 		if (isFileMissingError(err)) return { missing: true };
 		throw err;
@@ -3674,7 +3674,7 @@ const DISABLED_MULTIMODAL_SETTINGS = {
 };
 function ensureDir(dir) {
 	try {
-		fs.mkdirSync(dir, { recursive: true });
+		fsSync.mkdirSync(dir, { recursive: true });
 	} catch {}
 	return dir;
 }
@@ -3697,7 +3697,7 @@ function isAllowedMemoryFilePath(filePath, multimodal) {
 	return classifyMemoryMultimodalPath(filePath, multimodal ?? DISABLED_MULTIMODAL_SETTINGS) !== null;
 }
 async function walkDir(dir, files, multimodal) {
-	const entries = await fs$1.readdir(dir, { withFileTypes: true });
+	const entries = await fs.readdir(dir, { withFileTypes: true });
 	for (const entry of entries) {
 		const full = path.join(dir, entry.name);
 		if (entry.isSymbolicLink()) continue;
@@ -3717,7 +3717,7 @@ async function listMemoryFiles(workspaceDir, extraPaths, multimodal) {
 	const memoryDir = path.join(workspaceDir, "memory");
 	const addMarkdownFile = async (absPath) => {
 		try {
-			const stat = await fs$1.lstat(absPath);
+			const stat = await fs.lstat(absPath);
 			if (stat.isSymbolicLink() || !stat.isFile()) return;
 			if (!absPath.endsWith(".md")) return;
 			result.push(absPath);
@@ -3726,12 +3726,12 @@ async function listMemoryFiles(workspaceDir, extraPaths, multimodal) {
 	await addMarkdownFile(memoryFile);
 	await addMarkdownFile(altMemoryFile);
 	try {
-		const dirStat = await fs$1.lstat(memoryDir);
+		const dirStat = await fs.lstat(memoryDir);
 		if (!dirStat.isSymbolicLink() && dirStat.isDirectory()) await walkDir(memoryDir, result);
 	} catch {}
 	const normalizedExtraPaths = normalizeExtraMemoryPaths(workspaceDir, extraPaths);
 	if (normalizedExtraPaths.length > 0) for (const inputPath of normalizedExtraPaths) try {
-		const stat = await fs$1.lstat(inputPath);
+		const stat = await fs.lstat(inputPath);
 		if (stat.isSymbolicLink()) continue;
 		if (stat.isDirectory()) {
 			await walkDir(inputPath, result, multimodal);
@@ -3745,7 +3745,7 @@ async function listMemoryFiles(workspaceDir, extraPaths, multimodal) {
 	for (const entry of result) {
 		let key = entry;
 		try {
-			key = await fs$1.realpath(entry);
+			key = await fs.realpath(entry);
 		} catch {}
 		if (seen.has(key)) continue;
 		seen.add(key);
@@ -3759,7 +3759,7 @@ function hashText(value) {
 async function buildFileEntry(absPath, workspaceDir, multimodal) {
 	let stat;
 	try {
-		stat = await fs$1.stat(absPath);
+		stat = await fs.stat(absPath);
 	} catch (err) {
 		if (isFileMissingError(err)) return null;
 		throw err;
@@ -3771,7 +3771,7 @@ async function buildFileEntry(absPath, workspaceDir, multimodal) {
 		if (stat.size > multimodalSettings.maxFileBytes) return null;
 		let buffer;
 		try {
-			buffer = await fs$1.readFile(absPath);
+			buffer = await fs.readFile(absPath);
 		} catch (err) {
 			if (isFileMissingError(err)) return null;
 			throw err;
@@ -3804,7 +3804,7 @@ async function buildFileEntry(absPath, workspaceDir, multimodal) {
 	}
 	let content;
 	try {
-		content = await fs$1.readFile(absPath, "utf-8");
+		content = await fs.readFile(absPath, "utf-8");
 	} catch (err) {
 		if (isFileMissingError(err)) return null;
 		throw err;
@@ -3823,7 +3823,7 @@ async function loadMultimodalEmbeddingInput(entry) {
 	if (entry.kind !== "multimodal" || !entry.contentText || !entry.mimeType) return null;
 	let stat;
 	try {
-		stat = await fs$1.stat(entry.absPath);
+		stat = await fs.stat(entry.absPath);
 	} catch (err) {
 		if (isFileMissingError(err)) return null;
 		throw err;
@@ -3831,7 +3831,7 @@ async function loadMultimodalEmbeddingInput(entry) {
 	if (stat.size !== entry.size) return null;
 	let buffer;
 	try {
-		buffer = await fs$1.readFile(entry.absPath);
+		buffer = await fs.readFile(entry.absPath);
 	} catch (err) {
 		if (isFileMissingError(err)) return null;
 		throw err;
@@ -3984,7 +3984,7 @@ const log = createSubsystemLogger("memory");
 async function listSessionFilesForAgent(agentId) {
 	const dir = resolveSessionTranscriptsDirForAgent(agentId);
 	try {
-		return (await fs$1.readdir(dir, { withFileTypes: true })).filter((entry) => entry.isFile()).map((entry) => entry.name).filter((name) => name.endsWith(".jsonl")).map((name) => path.join(dir, name));
+		return (await fs.readdir(dir, { withFileTypes: true })).filter((entry) => entry.isFile()).map((entry) => entry.name).filter((name) => name.endsWith(".jsonl")).map((name) => path.join(dir, name));
 	} catch {
 		return [];
 	}
@@ -4014,8 +4014,8 @@ function extractSessionText(content) {
 }
 async function buildSessionEntry(absPath) {
 	try {
-		const stat = await fs$1.stat(absPath);
-		const lines = (await fs$1.readFile(absPath, "utf-8")).split("\n");
+		const stat = await fs.stat(absPath);
+		const lines = (await fs.readFile(absPath, "utf-8")).split("\n");
 		const collected = [];
 		const lineMap = [];
 		for (let jsonlIdx = 0; jsonlIdx < lines.length; jsonlIdx++) {