@remnic/plugin-openclaw 9.65.2 → 9.65.4

package/dist/index.js

@@ -3180,7 +3180,7 @@ __reExport(access_http_exports, access_http_star);
 import * as access_http_star from "@remnic/core/access-http";
 
 // ../../src/index.ts
-import path10 from "path";
+import path11 from "path";
 import os from "os";
 
 // ../../src/opik-exporter.ts
@@ -4443,8 +4443,8 @@ function parseProcessedMarkerChunks(rawChunks) {
 }
 async function readProcessedMarker(markerPath) {
   try {
-    const stat2 = await lstat2(markerPath);
-    if (stat2.isSymbolicLink() || !stat2.isFile()) return void 0;
+    const stat3 = await lstat2(markerPath);
+    if (stat3.isSymbolicLink() || !stat3.isFile()) return void 0;
     return parseProcessedMarker(await readFile(markerPath, "utf8"));
   } catch (error) {
     if (error?.code === "ENOENT") return void 0;
@@ -4501,8 +4501,8 @@ function isMeaningfulFlushPlanContent(content) {
 }
 async function isSafeFlushPlanAppendTarget(flushPlanPath) {
   try {
-    const stat2 = await lstat2(flushPlanPath);
-    return !stat2.isSymbolicLink() && stat2.isFile();
+    const stat3 = await lstat2(flushPlanPath);
+    return !stat3.isSymbolicLink() && stat3.isFile();
   } catch (error) {
     if (error?.code === "ENOENT") return true;
     throw error;
@@ -4603,21 +4603,21 @@ async function validateFlushPlanLocation(params) {
   let currentPath = workspaceRoot;
   for (const segment of parentSegments) {
     currentPath = path2.join(currentPath, segment);
-    let stat2;
+    let stat3;
     try {
-      stat2 = await lstat2(currentPath);
+      stat3 = await lstat2(currentPath);
     } catch (error) {
       if (error?.code === "ENOENT") break;
       throw error;
     }
-    if (stat2.isSymbolicLink()) {
+    if (stat3.isSymbolicLink()) {
       return {
         status: "skipped",
         path: params.flushPlanPath,
         reason: "flush plan parent path contains a symlink"
       };
     }
-    if (!stat2.isDirectory()) {
+    if (!stat3.isDirectory()) {
       return {
         status: "skipped",
         path: params.flushPlanPath,
@@ -4663,14 +4663,14 @@ async function recoverInterruptedCleanupSnapshots(params) {
     if (error?.code !== "ENOENT") throw error;
   }
   for (const cleanupPath of cleanupPaths) {
-    let stat2;
+    let stat3;
     try {
-      stat2 = await lstat2(cleanupPath);
+      stat3 = await lstat2(cleanupPath);
     } catch (error) {
       if (error?.code === "ENOENT") continue;
       throw error;
     }
-    if (stat2.isSymbolicLink() || !stat2.isFile()) {
+    if (stat3.isSymbolicLink() || !stat3.isFile()) {
       params.logger?.warn(
         `OpenClaw flush-plan cleanup recovery skipped unsafe snapshot ${path2.basename(cleanupPath)}`
       );
@@ -5002,23 +5002,23 @@ function buildFlushPlanImportTurns(params) {
   );
 }
 async function readFlushPlanSnapshot(flushPlanPath) {
-  let stat2;
+  let stat3;
   try {
-    stat2 = await lstat2(flushPlanPath);
+    stat3 = await lstat2(flushPlanPath);
   } catch (error) {
     if (error?.code === "ENOENT") {
       return { status: "missing", path: flushPlanPath };
     }
     throw error;
   }
-  if (stat2.isSymbolicLink()) {
+  if (stat3.isSymbolicLink()) {
     return {
       status: "skipped",
       path: flushPlanPath,
       reason: "flush plan path is a symlink"
     };
   }
-  if (!stat2.isFile()) {
+  if (!stat3.isFile()) {
     return {
       status: "skipped",
       path: flushPlanPath,
@@ -5088,8 +5088,8 @@ async function removeProcessedFlushPlanContent(params) {
   const processedBytes = Buffer.byteLength(params.processedContent, "utf8");
   let cleanupPath;
   try {
-    const stat2 = await lstat2(params.flushPlanPath);
-    if (stat2.isSymbolicLink()) {
+    const stat3 = await lstat2(params.flushPlanPath);
+    if (stat3.isSymbolicLink()) {
       return {
         status: "processed_cleanup_deferred",
         path: params.flushPlanPath,
@@ -5097,7 +5097,7 @@ async function removeProcessedFlushPlanContent(params) {
         reason: "flush plan path became a symlink before cleanup"
       };
     }
-    if (!stat2.isFile()) {
+    if (!stat3.isFile()) {
       return {
         status: "processed_cleanup_deferred",
         path: params.flushPlanPath,
@@ -5395,7 +5395,7 @@ async function processOpenClawFlushPlanFile(params) {
 }
 
 // src/delegate-runtime.ts
-import path8 from "path";
+import path9 from "path";
 import {
   renderMemoryContextPrompt
 } from "@remnic/core";
@@ -6902,12 +6902,93 @@ function daemonTargetFor(bridge) {
 }
 
 // src/delegate-flush-plan-ingest.ts
-import { constants } from "fs";
-import { lstat as lstat3, open, rename as rename2, unlink as unlink2, writeFile as writeFile2 } from "fs/promises";
-import path7 from "path";
+import { constants as constants2 } from "fs";
+import { lstat as lstat4, open as open2, rename as rename2, unlink as unlink2, writeFile as writeFile2 } from "fs/promises";
+import path8 from "path";
 import { log as log4 } from "@remnic/core/logger";
 import { withHeldFileLock } from "@remnic/core/utils/serialize-mutations";
 
+// src/delegate-flush-plan-directory.ts
+import { constants } from "fs";
+import { lstat as lstat3, open, stat as stat2 } from "fs/promises";
+import path7 from "path";
+function buildSnapshotPaths(planPath) {
+  return {
+    plan: planPath,
+    inflight: `${planPath}.inflight`,
+    rotating: `${planPath}.rotating`,
+    oversized: `${planPath}.oversized`,
+    lock: `${planPath}.lock`,
+    oversizedLabel: `${planPath}.oversized`
+  };
+}
+function descriptorDirectoryRoot(platform = process.platform) {
+  if (platform === "linux") return "/proc/self/fd";
+  if (platform === "darwin" || platform === "freebsd" || platform === "openbsd") return "/dev/fd";
+  return void 0;
+}
+async function pinSnapshotDirectory(paths, options = {}) {
+  const descriptorRoot = options.descriptorRoot ?? descriptorDirectoryRoot();
+  if (descriptorRoot === void 0) return { kind: "unsupported" };
+  const directory = path7.dirname(paths.plan);
+  let before;
+  try {
+    before = await lstat3(directory);
+  } catch {
+    return { kind: "unstable" };
+  }
+  if (before.isSymbolicLink() || !before.isDirectory()) return { kind: "unstable" };
+  let handle;
+  try {
+    handle = await open(directory, constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW);
+  } catch {
+    return { kind: "unstable" };
+  }
+  try {
+    const opened = await handle.stat();
+    const after = await lstat3(directory);
+    if (!opened.isDirectory() || after.isSymbolicLink() || !after.isDirectory() || !isSameInode(before, opened) || !isSameInode(after, opened)) {
+      await closeQuietly(handle);
+      return { kind: "unstable" };
+    }
+    const pinnedDirectory = path7.join(descriptorRoot, String(handle.fd));
+    let anchored;
+    try {
+      anchored = await stat2(pinnedDirectory);
+    } catch {
+      await closeQuietly(handle);
+      return { kind: "unsupported" };
+    }
+    if (!anchored.isDirectory() || !isSameInode(anchored, opened)) {
+      await closeQuietly(handle);
+      return { kind: "unsupported" };
+    }
+    return {
+      kind: "pinned",
+      paths: {
+        ...paths,
+        plan: anchoredChild(pinnedDirectory, paths.plan),
+        inflight: anchoredChild(pinnedDirectory, paths.inflight),
+        rotating: anchoredChild(pinnedDirectory, paths.rotating),
+        oversized: anchoredChild(pinnedDirectory, paths.oversized)
+      },
+      close: () => closeQuietly(handle)
+    };
+  } catch (err) {
+    await closeQuietly(handle);
+    throw err;
+  }
+}
+function anchoredChild(pinnedDirectory, realPath) {
+  return path7.join(pinnedDirectory, path7.basename(realPath));
+}
+function isSameInode(left, right) {
+  return left.dev === right.dev && left.ino === right.ino;
+}
+async function closeQuietly(handle) {
+  await handle.close().catch(() => void 0);
+}
+
 // src/memory-flush-plan.ts
 var DEFAULT_MAX_TURN_CHARS = 8e3;
 var MIN_MAX_TURN_CHARS = 1e3;
@@ -6993,17 +7074,11 @@ var MAX_RECLAIM_PASSES = 4;
 async function ingestFlushPlanNotes(options) {
   if (options.workspaceDir === void 0) return;
   const workspaceDir = options.workspaceDir;
-  const planPath = path7.join(
+  const planPath = path8.join(
     workspaceDir,
     ...buildMemoryFlushPlan({ serviceId: options.serviceId }).relativePath.split("/")
   );
-  const paths = {
-    plan: planPath,
-    inflight: `${planPath}.inflight`,
-    rotating: `${planPath}.rotating`,
-    oversized: `${planPath}.oversized`,
-    lock: `${planPath}.lock`
-  };
+  const paths = buildSnapshotPaths(planPath);
   for (const candidate of [paths.plan, paths.inflight, paths.rotating, paths.oversized]) {
     if (await isLinkFreeUnder(workspaceDir, candidate)) continue;
     log4.warn(
@@ -7029,7 +7104,18 @@ async function ingestFlushPlanNotes(options) {
         );
         return;
       }
-      await ingestUnderLock(options, paths, lock);
+      const pinned = await pinSnapshotDirectory(paths);
+      if (pinned.kind === "unstable") {
+        log4.warn(
+          `[${options.serviceId}] flush-plan ingestion skipped: the snapshot directory changed identity while it was being opened`
+        );
+        return;
+      }
+      try {
+        await ingestUnderLock(options, pinned.kind === "pinned" ? pinned.paths : paths, lock);
+      } finally {
+        if (pinned.kind === "pinned") await pinned.close();
+      }
     }
   );
 }
@@ -7189,9 +7275,9 @@ async function quarantineOversizedLine(paths, pending, serviceId) {
   const breakAt = pending.indexOf("\n");
   const line = breakAt === -1 ? pending : pending.slice(0, breakAt + 1);
   const rest = breakAt === -1 ? "" : pending.slice(breakAt + 1);
-  const handle = await open(
+  const handle = await open2(
     paths.oversized,
-    constants.O_WRONLY | constants.O_CREAT | constants.O_APPEND | constants.O_NOFOLLOW,
+    constants2.O_WRONLY | constants2.O_CREAT | constants2.O_APPEND | constants2.O_NOFOLLOW,
     384
   );
   try {
@@ -7201,14 +7287,14 @@ async function quarantineOversizedLine(paths, pending, serviceId) {
     await handle.close();
   }
   log4.warn(
-    `[${serviceId}] a flush-plan note exceeds the daemon's body limit; moved it to ${paths.oversized} so the remaining notes can drain`
+    `[${serviceId}] a flush-plan note exceeds the daemon's body limit; moved it to ${paths.oversizedLabel} so the remaining notes can drain`
   );
   return rest;
 }
 async function readIfPresent(filePath) {
   let handle;
   try {
-    handle = await open(filePath, constants.O_RDONLY | constants.O_NOFOLLOW);
+    handle = await open2(filePath, constants2.O_RDONLY | constants2.O_NOFOLLOW);
     return await handle.readFile("utf8");
   } catch (err) {
     if (err?.code === "ENOENT") return void 0;
@@ -7249,18 +7335,18 @@ function chunkOnLineBoundaries(text, limit) {
   return chunks;
 }
 async function isLinkFreeUnder(root, target) {
-  const relative = path7.relative(root, target);
-  if (relative.startsWith("..") || path7.isAbsolute(relative)) return false;
+  const relative = path8.relative(root, target);
+  if (relative.startsWith("..") || path8.isAbsolute(relative)) return false;
   let current = root;
   try {
-    if ((await lstat3(current)).isSymbolicLink()) return false;
+    if ((await lstat4(current)).isSymbolicLink()) return false;
   } catch {
     return true;
   }
-  for (const segment of relative.split(path7.sep)) {
-    current = path7.join(current, segment);
+  for (const segment of relative.split(path8.sep)) {
+    current = path8.join(current, segment);
     try {
-      if ((await lstat3(current)).isSymbolicLink()) return false;
+      if ((await lstat4(current)).isSymbolicLink()) return false;
     } catch {
       return true;
     }
@@ -8521,7 +8607,7 @@ var queueDelegateNamespaceMigration = (bindingPath, sessionKey, operation) => {
   return run;
 };
 function createDelegateNamespaceBindingStore(memoryDir, serviceId, isLegacyAdapterActive) {
-  const bindingPath = (pluginId) => path8.join(memoryDir, "state", "plugins", pluginId, "session-namespace-bindings.json");
+  const bindingPath = (pluginId) => path9.join(memoryDir, "state", "plugins", pluginId, "session-namespace-bindings.json");
   const primaryPath = bindingPath(serviceId);
   const primary = createFileSessionNamespaceBindingStore(primaryPath);
   if (serviceId !== REMNIC_OPENCLAW_PLUGIN_ID) return primary;
@@ -8695,9 +8781,9 @@ function maybeRegisterDelegateRuntime(api, options, deps = { checkHealth: checkD
     delegateBoundApis.add(api);
   }
   const toggleStore = options.sessionTogglesEnabled ? createFileToggleStore(
-    path8.join(options.memoryDir, "state", "plugins", options.serviceId, "session-toggles.json"),
+    path9.join(options.memoryDir, "state", "plugins", options.serviceId, "session-toggles.json"),
     {
-      secondaryReadOnlyPath: options.respectBundledActiveMemoryToggle ? path8.join(options.memoryDir, "state", "plugins", "active-memory", "session-toggles.json") : void 0
+      secondaryReadOnlyPath: options.respectBundledActiveMemoryToggle ? path9.join(options.memoryDir, "state", "plugins", "active-memory", "session-toggles.json") : void 0
     }
   ) : null;
   const target = daemonTargetFor(bridge);
@@ -8870,23 +8956,23 @@ __export(resolve_provider_secret_exports, {
   findGatewayRuntimeModules: () => findGatewayRuntimeModules
 });
 __reExport(resolve_provider_secret_exports, resolve_provider_secret_star);
-import path9 from "path";
+import path10 from "path";
 import * as resolve_provider_secret_star from "@remnic/core/resolve-provider-secret";
 async function findGatewayRuntimeModules(filePrefix) {
   const { existsSync, readFileSync, readdirSync, realpathSync: realpathSync2 } = await import("fs");
   const { createRequire: createRequire2 } = await import("module");
   const candidates = [];
   const isWithinRoot = (root, candidate) => {
-    const relative = path9.relative(root, candidate);
-    return relative.length === 0 || !relative.startsWith("..") && !path9.isAbsolute(relative);
+    const relative = path10.relative(root, candidate);
+    return relative.length === 0 || !relative.startsWith("..") && !path10.isAbsolute(relative);
   };
   let packageRoot;
   try {
     const req = createRequire2(import.meta.url);
     const openclawEntrypoint = realpathSync2(req.resolve("openclaw"));
-    let currentDir = path9.dirname(openclawEntrypoint);
+    let currentDir = path10.dirname(openclawEntrypoint);
     while (true) {
-      const packageJsonPath = path9.join(currentDir, "package.json");
+      const packageJsonPath = path10.join(currentDir, "package.json");
       if (existsSync(packageJsonPath)) {
         const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
         if (packageJson.name !== "openclaw") {
@@ -8895,7 +8981,7 @@ async function findGatewayRuntimeModules(filePrefix) {
         packageRoot = realpathSync2(currentDir);
         break;
       }
-      const parent = path9.dirname(currentDir);
+      const parent = path10.dirname(currentDir);
       if (parent === currentDir) {
         return [];
       }
@@ -8905,14 +8991,14 @@ async function findGatewayRuntimeModules(filePrefix) {
     return [];
   }
   try {
-    const distDir = realpathSync2(path9.join(packageRoot, "dist"));
+    const distDir = realpathSync2(path10.join(packageRoot, "dist"));
     if (!isWithinRoot(packageRoot, distDir)) {
       return [];
     }
     const files = readdirSync(distDir);
     for (const f of files) {
       if (f.startsWith(filePrefix) && f.endsWith(".js")) {
-        const candidate = realpathSync2(path9.join(distDir, f));
+        const candidate = realpathSync2(path10.join(distDir, f));
         if (isWithinRoot(packageRoot, candidate) && isWithinRoot(distDir, candidate)) {
           candidates.push(candidate);
         }
@@ -9255,7 +9341,7 @@ function resolveOpenClawConfigFilePath() {
   if (explicitConfigPath && explicitConfigPath.length > 0) {
     return expandTildePath4(explicitConfigPath);
   }
-  return path10.join(resolveHomeDir3(), ".openclaw", "openclaw.json");
+  return path11.join(resolveHomeDir3(), ".openclaw", "openclaw.json");
 }
 function coerceRawConfigBoolean(value) {
   if (typeof value === "boolean") return value;
@@ -9302,7 +9388,7 @@ function readPluginHooksPolicy(apiConfig, pluginId) {
 }
 async function maybeRegisterLiveConnectorCron(orchestrator) {
   if (!hasEnabledLiveConnectorConfig(orchestrator.config.connectors)) return;
-  const jobsPath = path10.join(resolveHomeDir3(), ".openclaw", "cron", "jobs.json");
+  const jobsPath = path11.join(resolveHomeDir3(), ".openclaw", "cron", "jobs.json");
   try {
     if (!fileExistsNow(jobsPath)) {
       logger_exports.log.debug("live connectors cron: jobs.json not found, skipping auto-register");
@@ -9871,9 +9957,9 @@ var pluginDefinition = {
       emitLegacyTools: cfg.emitLegacyTools
     });
     globalThis[keys.ACCESS_HTTP_SERVER] = accessHttpServer;
-    const pluginStateDir = path10.join(cfg.memoryDir, "state", "plugins", serviceId);
-    const togglePrimaryPath = path10.join(pluginStateDir, "session-toggles.json");
-    const toggleSecondaryPath = cfg.respectBundledActiveMemoryToggle ? path10.join(cfg.memoryDir, "state", "plugins", "active-memory", "session-toggles.json") : void 0;
+    const pluginStateDir = path11.join(cfg.memoryDir, "state", "plugins", serviceId);
+    const togglePrimaryPath = path11.join(pluginStateDir, "session-toggles.json");
+    const toggleSecondaryPath = cfg.respectBundledActiveMemoryToggle ? path11.join(cfg.memoryDir, "state", "plugins", "active-memory", "session-toggles.json") : void 0;
     const sessionToggleStore = createFileToggleStore2(togglePrimaryPath, {
       secondaryReadOnlyPath: toggleSecondaryPath
     });
@@ -9895,11 +9981,11 @@ var pluginDefinition = {
     }
     function resolveDreamJournalPath(runtimeWorkspaceDir) {
       const workspaceRoot = resolveWorkspaceRoot(runtimeWorkspaceDir);
-      return path10.isAbsolute(cfg.dreaming.journalPath) ? cfg.dreaming.journalPath : path10.join(workspaceRoot, cfg.dreaming.journalPath);
+      return path11.isAbsolute(cfg.dreaming.journalPath) ? cfg.dreaming.journalPath : path11.join(workspaceRoot, cfg.dreaming.journalPath);
     }
     function resolveHeartbeatJournalPath(runtimeWorkspaceDir) {
       const workspaceRoot = resolveWorkspaceRoot(runtimeWorkspaceDir);
-      return path10.isAbsolute(cfg.heartbeat.journalPath) ? cfg.heartbeat.journalPath : path10.join(workspaceRoot, cfg.heartbeat.journalPath);
+      return path11.isAbsolute(cfg.heartbeat.journalPath) ? cfg.heartbeat.journalPath : path11.join(workspaceRoot, cfg.heartbeat.journalPath);
     }
     const existingFlushPlanProcessingChains = globalThis[keys.FLUSH_PLAN_PROCESSING_CHAINS];
     const flushPlanProcessingChains = existingFlushPlanProcessingChains instanceof Map ? existingFlushPlanProcessingChains : /* @__PURE__ */ new Map();
@@ -10176,7 +10262,7 @@ Keep the reflection grounded in the evidence below.
         timeoutMs: cfg.activeRecallTimeoutMs,
         cacheTtlMs: cfg.activeRecallCacheTtlMs,
         persistTranscripts: cfg.activeRecallPersistTranscripts,
-        transcriptDir: path10.isAbsolute(cfg.activeRecallTranscriptDir) ? cfg.activeRecallTranscriptDir : path10.join(pluginStateDir, cfg.activeRecallTranscriptDir),
+        transcriptDir: path11.isAbsolute(cfg.activeRecallTranscriptDir) ? cfg.activeRecallTranscriptDir : path11.join(pluginStateDir, cfg.activeRecallTranscriptDir),
         entityGraphDepth: cfg.activeRecallEntityGraphDepth,
         includeCausalTrajectories: cfg.activeRecallIncludeCausalTrajectories,
         includeDaySummary: cfg.activeRecallIncludeDaySummary,
@@ -11725,7 +11811,7 @@ Keep the reflection grounded in the evidence below.
                   `session reset via API for ${sessionKey}, new sessionId=${result.sessionId}`
                 );
                 const safeSessionKey = sanitizeSessionKeyForFilename(sessionKey);
-                const signalPath = path10.join(
+                const signalPath = path11.join(
                   workspaceDir,
                   `.compaction-reset-signal-${safeSessionKey}`
                 );
@@ -11944,7 +12030,7 @@ Keep the reflection grounded in the evidence below.
     }
     async function ensureHourlySummaryCron(api2) {
       const jobId = "engram-hourly-summary";
-      const cronFilePath = path10.join(
+      const cronFilePath = path11.join(
         os.homedir(),
         ".openclaw",
         "cron",
@@ -12003,32 +12089,32 @@ Keep the reflection grounded in the evidence below.
       };
       const normalizeCorpusPath = (value) => value.trim().replace(/\\/g, "/").replace(/^\.\//, "");
       const pathIsInside = (root, candidate) => {
-        const relative = path10.relative(root, candidate);
-        return relative === "" || !relative.startsWith("..") && !path10.isAbsolute(relative);
+        const relative = path11.relative(root, candidate);
+        return relative === "" || !relative.startsWith("..") && !path11.isAbsolute(relative);
       };
       const corpusPathCandidates = (rawPath, storageDir) => {
         const candidates = /* @__PURE__ */ new Set();
         const trimmed = rawPath.trim();
         if (!trimmed) return [];
         candidates.add(normalizeCorpusPath(trimmed));
-        if (path10.isAbsolute(trimmed)) {
-          const absolutePath = path10.resolve(trimmed);
-          const absoluteStorageDir = path10.resolve(storageDir);
+        if (path11.isAbsolute(trimmed)) {
+          const absolutePath = path11.resolve(trimmed);
+          const absoluteStorageDir = path11.resolve(storageDir);
           if (pathIsInside(absoluteStorageDir, absolutePath)) {
-            candidates.add(normalizeCorpusPath(path10.relative(absoluteStorageDir, absolutePath)));
+            candidates.add(normalizeCorpusPath(path11.relative(absoluteStorageDir, absolutePath)));
           }
         }
-        candidates.add(path10.basename(trimmed));
+        candidates.add(path11.basename(trimmed));
         return [...candidates].filter((candidate) => candidate.length > 0);
       };
       const displayCorpusPath = (rawPath, storageDir) => {
         const trimmed = rawPath.trim();
         if (!trimmed) return "";
-        if (path10.isAbsolute(trimmed)) {
-          const absolutePath = path10.resolve(trimmed);
-          const absoluteStorageDir = path10.resolve(storageDir);
+        if (path11.isAbsolute(trimmed)) {
+          const absolutePath = path11.resolve(trimmed);
+          const absoluteStorageDir = path11.resolve(storageDir);
           if (pathIsInside(absoluteStorageDir, absolutePath)) {
-            return normalizeCorpusPath(path10.relative(absoluteStorageDir, absolutePath));
+            return normalizeCorpusPath(path11.relative(absoluteStorageDir, absolutePath));
           }
         }
         return normalizeCorpusPath(trimmed);
@@ -12542,9 +12628,9 @@ function truncateMetadataValue(value, maxChars) {
   return value.length <= maxChars ? value : value.slice(0, maxChars);
 }
 async function resolveFlushPlanProcessingChainKey(workspaceRoot) {
-  const lexicalRoot = path10.resolve(workspaceRoot);
+  const lexicalRoot = path11.resolve(workspaceRoot);
   try {
-    return path10.resolve(await realPathLater(lexicalRoot));
+    return path11.resolve(await realPathLater(lexicalRoot));
   } catch {
     return lexicalRoot;
   }