@remnic/core 1.1.8 → 1.1.9

package/dist/index.js

@@ -1,4 +1,4 @@
-import "./chunk-3LCWFNVS.js";
+import "./chunk-SKE7JYKA.js";
 import {
   PEERS_DIR_NAME,
   PEER_ID_MAX_LENGTH,
@@ -11,7 +11,7 @@ import {
   readPeerProfile,
   writePeer,
   writePeerProfile
-} from "./chunk-TUFG6VXY.js";
+} from "./chunk-4DWOBS2A.js";
 import {
   buildTokenEntry,
   commitTokenEntry,
@@ -53,19 +53,19 @@ import {
   runBulkImportCliCommand,
   runBulkImportPipeline,
   validateImportTurn
-} from "./chunk-SYWJJTNL.js";
-import "./chunk-XVOIMCVW.js";
+} from "./chunk-XL3UCAZA.js";
+import "./chunk-KMWZXT5T.js";
 import {
   clearAuthTokenSecretCache,
   isAgentAccessSecretRef,
   resolveAgentAccessAuthToken
 } from "./chunk-MXC3AP5I.js";
-import "./chunk-STB3GUYU.js";
+import "./chunk-G3G3LY22.js";
 import {
   parseXrayBudgetFlag,
   parseXrayCliOptions
-} from "./chunk-OJMD2LIW.js";
-import "./chunk-SWRJFKYW.js";
+} from "./chunk-BIHCWSWA.js";
+import "./chunk-M3DK45UM.js";
 import {
   parseStrictCliDate
 } from "./chunk-AJA46VX5.js";
@@ -117,8 +117,8 @@ import {
   saveTaxonomy,
   validateSlug,
   validateTaxonomy
-} from "./chunk-GRDDGNYQ.js";
-import "./chunk-SRIDOT64.js";
+} from "./chunk-FPWUENQH.js";
+import "./chunk-XN4D6Z7X.js";
 import "./chunk-CK5NTM2S.js";
 import "./chunk-FSFEQI74.js";
 import "./chunk-Z5AAYHUC.js";
@@ -128,7 +128,7 @@ import {
 } from "./chunk-S75M5ZRK.js";
 import "./chunk-TPB3I2AC.js";
 import "./chunk-UHGBNIOS.js";
-import "./chunk-S5SQDIF5.js";
+import "./chunk-Y3VT6ZCP.js";
 import "./chunk-ETOW6ACV.js";
 import "./chunk-ZTSE2ZJ6.js";
 import "./chunk-MDYG7VI7.js";
@@ -169,7 +169,7 @@ import {
   builtInLiveConnectorDefinitions,
   hasEnabledLiveConnector,
   runLiveConnectorsOnce
-} from "./chunk-ASIQZXYO.js";
+} from "./chunk-XMVFHBHT.js";
 import "./chunk-YAZNBMNF.js";
 import {
   buildExplicitCueRecallSection,
@@ -179,7 +179,7 @@ import {
   collectQuestionSlotCues,
   collectStructuredPlanCues,
   collectTemporalLexicalCues
-} from "./chunk-KNQ5YJTO.js";
+} from "./chunk-3VRIIII5.js";
 import {
   buildEvidencePack
 } from "./chunk-74WWN7ZW.js";
@@ -196,15 +196,15 @@ import {
 } from "./chunk-C4SQJZAF.js";
 import {
   ExtractionEngine
-} from "./chunk-FCGWNWG4.js";
+} from "./chunk-KIF7QNKL.js";
 import "./chunk-WW3QQF4H.js";
 import "./chunk-54V4BZWP.js";
-import "./chunk-FEMOX5AD.js";
-import "./chunk-R2XRID2N.js";
+import "./chunk-QR3C7BKQ.js";
+import "./chunk-NN3LPQ5D.js";
 import {
   buildExtensionsFooterForSummary,
   loadDaySummaryPrompt
-} from "./chunk-GZCUW5IC.js";
+} from "./chunk-3IQ2TR4N.js";
 import "./chunk-VEWZZM3H.js";
 import {
   resolveCategory
@@ -216,25 +216,25 @@ import {
 import "./chunk-Z2E7VW55.js";
 import {
   buildEntityRecallSection
-} from "./chunk-MYH2IBSP.js";
+} from "./chunk-CTYRIJ5E.js";
 import "./chunk-2NMMFZ5T.js";
 import "./chunk-SRBJUAMP.js";
 import "./chunk-PYXS46O7.js";
 import "./chunk-3QKK7QOS.js";
-import "./chunk-ETA2JXP5.js";
+import "./chunk-2MVUXO4H.js";
 import "./chunk-JRNQ3RNA.js";
-import "./chunk-RLV2F337.js";
+import "./chunk-6OAQEOGV.js";
 import "./chunk-CULXMQJH.js";
 import "./chunk-E6K4NIEU.js";
 import {
   LanceDbBackend,
   MeilisearchBackend,
   OramaBackend
-} from "./chunk-RJSVRPNU.js";
+} from "./chunk-OWGGXPKV.js";
 import "./chunk-YRMVARQP.js";
 import {
   QmdClient
-} from "./chunk-WSZIHQBK.js";
+} from "./chunk-P77UEOU2.js";
 import {
   LEGACY_PLUGIN_ID,
   PLUGIN_ID,
@@ -256,7 +256,7 @@ import {
   defaultGoogleDriveClientFactory,
   validateGoogleDriveConfig,
   validateNotionConfig
-} from "./chunk-L2IO2QPY.js";
+} from "./chunk-4IS4SXIQ.js";
 import {
   CONNECTOR_ID_PATTERN,
   isValidConnectorId,
@@ -272,7 +272,7 @@ import "./chunk-7SEAZFFB.js";
 import {
   coerceInstallExtension,
   parseConfig
-} from "./chunk-QJZ77K7F.js";
+} from "./chunk-6Z6UH6TK.js";
 import "./chunk-Z5LAYHGJ.js";
 import {
   CONNECTORS_OUTPUT_FORMATS,
@@ -303,7 +303,7 @@ import {
   materializeForNamespace,
   runCodexMaterialize,
   runPostConsolidationMaterialize
-} from "./chunk-FIXIX6DE.js";
+} from "./chunk-G6NX57V2.js";
 import {
   REMNIC_EXTENSIONS_TOTAL_TOKEN_LIMIT,
   discoverMemoryExtensions,
@@ -313,9 +313,9 @@ import {
 } from "./chunk-EJI5XIBB.js";
 import {
   FallbackLlmClient
-} from "./chunk-DWMXVUGO.js";
+} from "./chunk-FLBYSB2V.js";
 import "./chunk-Q7FJ5ZHM.js";
-import "./chunk-ODWDQNRE.js";
+import "./chunk-7SI52C65.js";
 import "./chunk-L2EXJQJP.js";
 import "./chunk-UZB5KHKX.js";
 import "./chunk-6HZ6AO2P.js";
@@ -329,10 +329,10 @@ import "./chunk-PVGDJXVK.js";
 import "./chunk-NGAVDO7E.js";
 import {
   EngramAccessHttpServer
-} from "./chunk-65ZPH7QA.js";
+} from "./chunk-PHQH2VUO.js";
 import {
   EngramMcpServer
-} from "./chunk-Q5TJRAGE.js";
+} from "./chunk-A6PGANSE.js";
 import {
   buildCitationGuidance,
   formatOaiMemCitation,
@@ -344,7 +344,7 @@ import {
   EngramAccessService,
   computeProcedureStats,
   formatProcedureStatsText
-} from "./chunk-KHJRMWO4.js";
+} from "./chunk-QPLYTPYL.js";
 import {
   importCapsule
 } from "./chunk-QIGOEM65.js";
@@ -357,9 +357,9 @@ import {
   renderXrayJson,
   renderXrayMarkdown,
   renderXrayText
-} from "./chunk-WXPPM426.js";
+} from "./chunk-J3P6WSFZ.js";
 import "./chunk-SOBJ6NEY.js";
-import "./chunk-E27HOXMX.js";
+import "./chunk-U4SZXGEO.js";
 import {
   normalizeOriginUrl,
   resolveGitContext,
@@ -368,7 +368,7 @@ import {
 import {
   isTrustZoneName
 } from "./chunk-EQINRHYR.js";
-import "./chunk-AV2WSYZY.js";
+import "./chunk-ICULSMDG.js";
 import {
   memoryWorthOutcomeEligibleCategories,
   recordMemoryOutcome
@@ -377,7 +377,7 @@ import {
   expandTildePath
 } from "./chunk-IXEJRKCZ.js";
 import "./chunk-PCUKNJAZ.js";
-import "./chunk-3FPTCC3Z.js";
+import "./chunk-GVPWB7EY.js";
 import "./chunk-2LGMW3DJ.js";
 import "./chunk-EEQLFRUM.js";
 import "./chunk-NBNN5GOB.js";
@@ -414,10 +414,10 @@ import {
   renderBriefingMarkdown,
   resolveBriefingSaveDir,
   validateBriefingFormat
-} from "./chunk-4IT6WL23.js";
+} from "./chunk-7SFAENUZ.js";
 import {
   StorageManager
-} from "./chunk-XGX4TUF6.js";
+} from "./chunk-MJLUHRSF.js";
 import "./chunk-YNJHCGDT.js";
 import {
   CITATION_UNKNOWN,
@@ -429,19 +429,19 @@ import {
   parseAllCitations,
   parseCitation,
   stripCitation
-} from "./chunk-4KAN3GZ3.js";
+} from "./chunk-NN2DKE4T.js";
 import {
   DEFAULT_RECALL_DISCLOSURE,
   RECALL_DISCLOSURE_LEVELS,
   isRecallDisclosure
-} from "./chunk-T65SHTJP.js";
+} from "./chunk-ET4BL42V.js";
 import "./chunk-PFV5C235.js";
 import "./chunk-RULE4VG5.js";
 import "./chunk-SCU65EZI.js";
-import "./chunk-67YLUWLG.js";
+import "./chunk-XJKFSSDW.js";
 import "./chunk-DM2T26WE.js";
 import "./chunk-QSVPYQPG.js";
-import "./chunk-M62O4P4T.js";
+import "./chunk-FVQJYWH7.js";
 import "./chunk-4DJQYKMN.js";
 import "./chunk-G7D6GZ5J.js";
 import {
@@ -2554,14 +2554,14 @@ function hashContent3(content) {
 }
 
 // src/connectors/index.ts
-import fs8 from "fs";
+import fs9 from "fs";
 import path13 from "path";
 import os from "os";
 import { createRequire } from "module";
 import { fileURLToPath } from "url";
 
 // src/connectors/codex-marketplace.ts
-import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "fs";
+import fs8 from "fs";
 import path12 from "path";
 var MARKETPLACE_SCHEMA_VERSION = 1;
 var MARKETPLACE_MANIFEST_FILENAME = "marketplace.json";
@@ -2664,12 +2664,12 @@ async function writeMarketplaceManifest(outputDir, manifest) {
       `Refusing to write invalid manifest: ${validation.errors.join("; ")}`
     );
   }
-  mkdirSync(outputDir, { recursive: true });
+  fs8.mkdirSync(outputDir, { recursive: true });
   const destPath = path12.join(outputDir, MARKETPLACE_MANIFEST_FILENAME);
   const tmpPath = `${destPath}.tmp.${process.pid}`;
   const content = JSON.stringify(manifest, null, 2) + "\n";
-  writeFileSync(tmpPath, content);
-  renameSync(tmpPath, destPath);
+  fs8.writeFileSync(tmpPath, content);
+  fs8.renameSync(tmpPath, destPath);
 }
 async function installFromMarketplace(source, sourceType, config, logger) {
   const _log = logger ?? {
@@ -2730,11 +2730,11 @@ async function resolveManifest(source, sourceType, logger) {
 }
 function resolveLocal(dirPath, logger) {
   const manifestPath2 = path12.join(dirPath, MARKETPLACE_MANIFEST_FILENAME);
-  if (!existsSync(manifestPath2)) {
+  if (!fs8.existsSync(manifestPath2)) {
     throw new Error(`marketplace.json not found at ${manifestPath2}`);
   }
   logger.debug?.(`reading local marketplace manifest: ${manifestPath2}`);
-  const raw = readFileSync(manifestPath2, "utf-8");
+  const raw = fs8.readFileSync(manifestPath2, "utf-8");
   let parsed;
   try {
     parsed = JSON.parse(raw);
@@ -2793,8 +2793,8 @@ function readPackageVersion() {
   for (const candidate of candidates) {
     const pkgPath = path12.join(candidate, "package.json");
     try {
-      if (!existsSync(pkgPath)) continue;
-      const raw = readFileSync(pkgPath, "utf-8");
+      if (!fs8.existsSync(pkgPath)) continue;
+      const raw = fs8.readFileSync(pkgPath, "utf-8");
       const parsed = JSON.parse(raw);
       if (typeof parsed === "object" && parsed !== null && typeof parsed.version === "string") {
         return parsed.version;
@@ -3111,7 +3111,7 @@ function getRegistryPath() {
 }
 function loadRegistry() {
   const regPath = getRegistryPath();
-  if (!fs8.existsSync(regPath)) {
+  if (!fs9.existsSync(regPath)) {
     const registry = {
       connectors: BUILTIN_CONNECTORS,
       registryPath: regPath
@@ -3119,7 +3119,7 @@ function loadRegistry() {
     saveRegistry(registry);
     return registry;
   }
-  const raw = fs8.readFileSync(regPath, "utf8");
+  const raw = fs9.readFileSync(regPath, "utf8");
   try {
     const parsed = JSON.parse(raw);
     const builtinIds = new Set(BUILTIN_CONNECTORS.map((b) => b.id));
@@ -3140,19 +3140,19 @@ function loadRegistry() {
 }
 function saveRegistry(registry) {
   const regPath = registry.registryPath;
-  fs8.mkdirSync(path13.dirname(regPath), { recursive: true });
-  fs8.writeFileSync(regPath, JSON.stringify({ connectors: registry.connectors }, null, 2));
+  fs9.mkdirSync(path13.dirname(regPath), { recursive: true });
+  fs9.writeFileSync(regPath, JSON.stringify({ connectors: registry.connectors }, null, 2));
 }
 function listConnectors() {
   const registry = loadRegistry();
   const connectorsDir = getConnectorsDir();
   const installedIds = /* @__PURE__ */ new Set();
-  if (fs8.existsSync(connectorsDir)) {
-    for (const entry of fs8.readdirSync(connectorsDir)) {
+  if (fs9.existsSync(connectorsDir)) {
+    for (const entry of fs9.readdirSync(connectorsDir)) {
       if (entry.endsWith(".json")) {
         try {
           const config = JSON.parse(
-            fs8.readFileSync(path13.join(connectorsDir, entry), "utf8")
+            fs9.readFileSync(path13.join(connectorsDir, entry), "utf8")
           );
           installedIds.add(config.connectorId);
         } catch {
@@ -3168,7 +3168,7 @@ function listConnectors() {
   for (const id of installedIds) {
     const configPath = path13.join(connectorsDir, `${id}.json`);
     try {
-      const raw = JSON.parse(fs8.readFileSync(configPath, "utf8"));
+      const raw = JSON.parse(fs9.readFileSync(configPath, "utf8"));
       const { token: _redacted, ...config } = raw;
       installed.push({
         connectorId: id,
@@ -3202,7 +3202,7 @@ function installConnector(options) {
     };
   }
   const configDir = getConnectorsDir();
-  fs8.mkdirSync(configDir, { recursive: true });
+  fs9.mkdirSync(configDir, { recursive: true });
   const configPath = path13.join(configDir, `${options.connectorId}.json`);
   let hermesSavedProfile;
   let hermesSavedHost;
@@ -3211,9 +3211,9 @@ function installConnector(options) {
   let hermesResolvedHost;
   let hermesResolvedPort;
   if (options.connectorId === "hermes") {
-    if (fs8.existsSync(configPath)) {
+    if (fs9.existsSync(configPath)) {
       try {
-        const prev = JSON.parse(fs8.readFileSync(configPath, "utf8"));
+        const prev = JSON.parse(fs9.readFileSync(configPath, "utf8"));
         if (prev?.profile != null) {
           try {
             hermesSavedProfile = sanitizeHermesProfile(String(prev.profile));
@@ -3377,7 +3377,7 @@ function installConnector(options) {
       let yamlRollbackErrMsg = "";
       try {
         if (yamlResult.priorContent === null) {
-          fs8.unlinkSync(yamlResult.configPath);
+          fs9.unlinkSync(yamlResult.configPath);
         } else if (typeof yamlResult.priorContent === "string") {
           writeSecretFileSync(yamlResult.configPath, yamlResult.priorContent);
         }
@@ -3419,7 +3419,7 @@ function installConnector(options) {
           let unlinkSucceeded = false;
           let unlinkErr;
           try {
-            fs8.unlinkSync(yamlResult.configPath);
+            fs9.unlinkSync(yamlResult.configPath);
             unlinkSucceeded = true;
           } catch (err) {
             unlinkErr = err;
@@ -3547,9 +3547,9 @@ function installConnector(options) {
   if (options.connectorId === "weclone") {
     try {
       let proxyConfigPath = null;
-      if (existing && fs8.existsSync(configPath)) {
+      if (existing && fs9.existsSync(configPath)) {
         try {
-          const savedRegistryConfig = JSON.parse(fs8.readFileSync(configPath, "utf8"));
+          const savedRegistryConfig = JSON.parse(fs9.readFileSync(configPath, "utf8"));
           if (typeof savedRegistryConfig.proxyConfigPath === "string" && savedRegistryConfig.proxyConfigPath.length > 0) {
             proxyConfigPath = savedRegistryConfig.proxyConfigPath;
           }
@@ -3565,12 +3565,12 @@ function installConnector(options) {
         priorConfig: prior ? safeParseJson(prior) : null,
         authToken: tokenEntry?.token
       });
-      fs8.mkdirSync(path13.dirname(proxyConfigPath), { recursive: true });
+      fs9.mkdirSync(path13.dirname(proxyConfigPath), { recursive: true });
       weCloneProxyHandleRollback = () => {
         try {
           if (prior === null) {
-            if (fs8.existsSync(proxyConfigPath)) {
-              fs8.unlinkSync(proxyConfigPath);
+            if (fs9.existsSync(proxyConfigPath)) {
+              fs9.unlinkSync(proxyConfigPath);
             }
           } else {
             writeSecretFileSync(proxyConfigPath, prior);
@@ -3675,9 +3675,9 @@ function removeConnector(connectorId) {
   let codexHomeOverride = null;
   let savedInstallExtension = void 0;
   let configParsed = false;
-  if (connectorId === "codex-cli" && fs8.existsSync(configPath)) {
+  if (connectorId === "codex-cli" && fs9.existsSync(configPath)) {
     try {
-      const parsed = JSON.parse(fs8.readFileSync(configPath, "utf8"));
+      const parsed = JSON.parse(fs9.readFileSync(configPath, "utf8"));
       configParsed = true;
       if (typeof parsed.codexHome === "string" && parsed.codexHome.length > 0) {
         codexHomeOverride = parsed.codexHome;
@@ -3692,7 +3692,7 @@ function removeConnector(connectorId) {
       );
     }
   }
-  if (!fs8.existsSync(configPath)) {
+  if (!fs9.existsSync(configPath)) {
     let staleTokenRevoked = false;
     try {
       staleTokenRevoked = revokeToken(connectorId);
@@ -3709,7 +3709,7 @@ function removeConnector(connectorId) {
   let storedProfile = "default";
   if (connectorId === "hermes") {
     try {
-      const stored = JSON.parse(fs8.readFileSync(configPath, "utf8"));
+      const stored = JSON.parse(fs9.readFileSync(configPath, "utf8"));
       if (typeof stored?.profile === "string") storedProfile = stored.profile;
     } catch {
     }
@@ -3718,7 +3718,7 @@ function removeConnector(connectorId) {
   let weCloneRegistryParseFailed = false;
   if (connectorId === "weclone") {
     try {
-      const stored = JSON.parse(fs8.readFileSync(configPath, "utf8"));
+      const stored = JSON.parse(fs9.readFileSync(configPath, "utf8"));
       if (typeof stored.proxyConfigPath === "string" && stored.proxyConfigPath.length > 0) {
         weCloneProxyConfigPath = stored.proxyConfigPath;
       }
@@ -3744,7 +3744,7 @@ function removeConnector(connectorId) {
       reason: "config-parse-failed"
     };
   }
-  if (connectorId === "codex-cli" && fs8.existsSync(configPath) && !configParsed) {
+  if (connectorId === "codex-cli" && fs9.existsSync(configPath) && !configParsed) {
     console.warn(
       "[remnic/connectors] removeConnector: codex-cli.json is malformed \u2014 aborting removal to preserve provenance. Fix or delete " + configPath + " manually and retry."
     );
@@ -3768,7 +3768,7 @@ function removeConnector(connectorId) {
     }
   }
   try {
-    fs8.unlinkSync(configPath);
+    fs9.unlinkSync(configPath);
   } catch (unlinkErr) {
     const sanitizedErr = unlinkErr instanceof Error ? unlinkErr.message : String(unlinkErr);
     return {
@@ -3800,8 +3800,8 @@ function removeConnector(connectorId) {
         weCloneProxyDeleteFailed = `Proxy config path ${JSON.stringify(weCloneProxyConfigPath)} failed safety validation (must be absolute and end with "${expectedSuffix}"). Refusing to delete \u2014 remove the file manually if it exists.`;
       } else {
         try {
-          if (fs8.existsSync(weCloneProxyConfigPath)) {
-            fs8.unlinkSync(weCloneProxyConfigPath);
+          if (fs9.existsSync(weCloneProxyConfigPath)) {
+            fs9.unlinkSync(weCloneProxyConfigPath);
             notes.push(`Removed WeClone proxy config: ${weCloneProxyConfigPath}`);
           }
         } catch (err) {
@@ -3871,7 +3871,7 @@ function hermesConfigPath(profile) {
   const profilesRoot = path13.join(hermesRoot, "profiles");
   if (safeProfile === "default") {
     const defaultProfileDir = path13.join(profilesRoot, safeProfile);
-    if (isFile(rootConfigPath) || !fs8.existsSync(rootConfigPath) && !isDirectory(defaultProfileDir)) {
+    if (isFile(rootConfigPath) || !fs9.existsSync(rootConfigPath) && !isDirectory(defaultProfileDir)) {
       return rootConfigPath;
     }
   }
@@ -3886,21 +3886,21 @@ function hermesConfigPath(profile) {
 }
 function isDirectory(filePath) {
   try {
-    return fs8.statSync(filePath).isDirectory();
+    return fs9.statSync(filePath).isDirectory();
   } catch {
     return false;
   }
 }
 function isFile(filePath) {
   try {
-    return fs8.statSync(filePath).isFile();
+    return fs9.statSync(filePath).isFile();
   } catch {
     return false;
   }
 }
 function hermesConfigTarget(filePath) {
   try {
-    return fs8.realpathSync.native(filePath);
+    return fs9.realpathSync.native(filePath);
   } catch {
     return path13.resolve(filePath);
   }
@@ -3966,9 +3966,9 @@ function sanitizeHermesPort(port) {
   return numeric;
 }
 function writeSecretFileSync(filePath, data) {
-  fs8.writeFileSync(filePath, data, { mode: 384 });
+  fs9.writeFileSync(filePath, data, { mode: 384 });
   try {
-    fs8.chmodSync(filePath, 384);
+    fs9.chmodSync(filePath, 384);
   } catch {
   }
 }
@@ -3994,11 +3994,11 @@ function upsertHermesConfig(opts) {
     `  port: ${safePort}`,
     `  token: "${opts.token}"`
   ].join("\n");
-  if (!fs8.existsSync(cfgPath)) {
+  if (!fs9.existsSync(cfgPath)) {
     writeSecretFileSync(cfgPath, block + "\n");
     return { updated: true, skipped: false, configPath: cfgPath, priorContent: null };
   }
-  const raw = fs8.readFileSync(cfgPath, "utf8");
+  const raw = fs9.readFileSync(cfgPath, "utf8");
   const hasRemnicBlock = /^remnic:/m.test(raw);
   if (!hasRemnicBlock) {
     const separator = raw.endsWith("\n") ? "\n" : "\n\n";
@@ -4101,7 +4101,7 @@ function removeHermesConfig(opts) {
   };
 }
 function removeHermesConfigFile(cfgPath) {
-  if (!fs8.existsSync(cfgPath)) {
+  if (!fs9.existsSync(cfgPath)) {
     return {
       updated: false,
       skipped: true,
@@ -4109,7 +4109,7 @@ function removeHermesConfigFile(cfgPath) {
       configPath: cfgPath
     };
   }
-  const raw = fs8.readFileSync(cfgPath, "utf8");
+  const raw = fs9.readFileSync(cfgPath, "utf8");
   if (!/^remnic:/m.test(raw)) {
     return {
       updated: false,
@@ -4210,11 +4210,11 @@ async function doctorConnector(connectorId) {
   const checks = [];
   checks.push({
     name: "Config file",
-    ok: fs8.existsSync(configPath),
+    ok: fs9.existsSync(configPath),
     detail: configPath
   });
   try {
-    const raw = fs8.readFileSync(configPath, "utf8");
+    const raw = fs9.readFileSync(configPath, "utf8");
     JSON.parse(raw);
     checks.push({ name: "Config valid", ok: true, detail: "OK" });
   } catch (e) {
@@ -4238,7 +4238,7 @@ async function doctorConnector(connectorId) {
   }
   const memoryDir = instance.config.memoryDir;
   if (memoryDir) {
-    if (fs8.existsSync(memoryDir)) {
+    if (fs9.existsSync(memoryDir)) {
       checks.push({ name: "Memory directory", ok: true, detail: memoryDir });
     } else {
       checks.push({ name: "Memory directory", ok: false, detail: `Not found: ${memoryDir}` });
@@ -4271,7 +4271,7 @@ function resolveCodexMemoryExtensionPaths(codexHomeOverride) {
 function locatePluginCodexExtensionSource(override) {
   if (override && typeof override === "string" && override.trim().length > 0) {
     const resolved = path13.resolve(override.trim());
-    if (fs8.existsSync(resolved) && fs8.statSync(resolved).isDirectory()) {
+    if (fs9.existsSync(resolved) && fs9.statSync(resolved).isDirectory()) {
       return resolved;
     }
     throw new Error(`Codex extension source directory not found: ${resolved}`);
@@ -4288,12 +4288,12 @@ function locatePluginCodexExtensionSource(override) {
     const moduleDir = path13.dirname(fileURLToPath(import.meta.url));
     const bundledCandidate = path13.join(moduleDir, "codex");
     searched.push(bundledCandidate);
-    if (fs8.existsSync(bundledCandidate) && fs8.statSync(bundledCandidate).isDirectory()) {
+    if (fs9.existsSync(bundledCandidate) && fs9.statSync(bundledCandidate).isDirectory()) {
       return bundledCandidate;
     }
     const distConnectorsCandidate = path13.join(moduleDir, "connectors", "codex");
     searched.push(distConnectorsCandidate);
-    if (fs8.existsSync(distConnectorsCandidate) && fs8.statSync(distConnectorsCandidate).isDirectory()) {
+    if (fs9.existsSync(distConnectorsCandidate) && fs9.statSync(distConnectorsCandidate).isDirectory()) {
       return distConnectorsCandidate;
     }
   } catch {
@@ -4304,7 +4304,7 @@ function locatePluginCodexExtensionSource(override) {
     const pluginPkgRoot = path13.dirname(pluginPkgJsonPath);
     const candidate = path13.join(pluginPkgRoot, EXTENSION_SUBPATH);
     searched.push(candidate);
-    if (fs8.existsSync(candidate) && fs8.statSync(candidate).isDirectory()) {
+    if (fs9.existsSync(candidate) && fs9.statSync(candidate).isDirectory()) {
       return candidate;
     }
   } catch {
@@ -4321,7 +4321,7 @@ function locatePluginCodexExtensionSource(override) {
         EXTENSION_SUBPATH
       );
       searched.push(candidate);
-      if (fs8.existsSync(candidate) && fs8.statSync(candidate).isDirectory()) {
+      if (fs9.existsSync(candidate) && fs9.statSync(candidate).isDirectory()) {
         return candidate;
       }
       const parent = path13.dirname(dir);
@@ -4341,7 +4341,7 @@ function locatePluginCodexExtensionSource(override) {
     for (let depth = 0; depth < 12; depth += 1) {
       const candidate = path13.join(dir, WORKSPACE_RELATIVE_PATH);
       searched.push(candidate);
-      if (fs8.existsSync(candidate) && fs8.statSync(candidate).isDirectory()) {
+      if (fs9.existsSync(candidate) && fs9.statSync(candidate).isDirectory()) {
         return candidate;
       }
       const parent = path13.dirname(dir);
@@ -4355,15 +4355,15 @@ function locatePluginCodexExtensionSource(override) {
 }
 function copyDirRecursiveSync(src, dest) {
   let count = 0;
-  fs8.mkdirSync(dest, { recursive: true });
-  const entries = fs8.readdirSync(src, { withFileTypes: true });
+  fs9.mkdirSync(dest, { recursive: true });
+  const entries = fs9.readdirSync(src, { withFileTypes: true });
   for (const entry of entries) {
     const from = path13.join(src, entry.name);
     const to = path13.join(dest, entry.name);
     if (entry.isDirectory()) {
       count += copyDirRecursiveSync(from, to);
     } else if (entry.isFile()) {
-      fs8.copyFileSync(from, to);
+      fs9.copyFileSync(from, to);
       count += 1;
     }
   }
@@ -4372,22 +4372,22 @@ function copyDirRecursiveSync(src, dest) {
 function installCodexMemoryExtension(options = {}) {
   const paths = resolveCodexMemoryExtensionPaths(options.codexHome ?? null);
   const sourceDir = locatePluginCodexExtensionSource(options.sourceDir ?? null);
-  fs8.mkdirSync(paths.extensionsRoot, { recursive: true });
+  fs9.mkdirSync(paths.extensionsRoot, { recursive: true });
   const tmpPrefix = `.${REMNIC_EXTENSION_DIR_NAME}.tmp-`;
   const STALE_TMP_THRESHOLD_MS = 10 * 60 * 1e3;
   const now = Date.now();
   try {
-    const existingEntries = fs8.readdirSync(paths.extensionsRoot);
+    const existingEntries = fs9.readdirSync(paths.extensionsRoot);
     for (const entry of existingEntries) {
       if (!entry.startsWith(tmpPrefix)) continue;
       const stalePath = path13.join(paths.extensionsRoot, entry);
       try {
-        const stat = fs8.statSync(stalePath);
+        const stat = fs9.statSync(stalePath);
         const ageMs = now - stat.mtimeMs;
         if (ageMs < STALE_TMP_THRESHOLD_MS) {
           continue;
         }
-        fs8.rmSync(stalePath, { recursive: true, force: true });
+        fs9.rmSync(stalePath, { recursive: true, force: true });
       } catch {
       }
     }
@@ -4403,16 +4403,16 @@ function installCodexMemoryExtension(options = {}) {
   try {
     filesCopied = copyDirRecursiveSync(sourceDir, tmpDir);
     const backupDir = `${paths.remnicExtensionDir}.bak-${Date.now()}`;
-    const hadExisting = fs8.existsSync(paths.remnicExtensionDir);
+    const hadExisting = fs9.existsSync(paths.remnicExtensionDir);
     if (hadExisting) {
-      fs8.renameSync(paths.remnicExtensionDir, backupDir);
+      fs9.renameSync(paths.remnicExtensionDir, backupDir);
     }
     try {
-      fs8.renameSync(tmpDir, paths.remnicExtensionDir);
+      fs9.renameSync(tmpDir, paths.remnicExtensionDir);
     } catch (renameErr) {
       if (hadExisting) {
         try {
-          fs8.renameSync(backupDir, paths.remnicExtensionDir);
+          fs9.renameSync(backupDir, paths.remnicExtensionDir);
         } catch {
         }
       }
@@ -4421,7 +4421,7 @@ function installCodexMemoryExtension(options = {}) {
     commitFn = () => {
       if (hadExisting) {
         try {
-          fs8.rmSync(backupDir, { recursive: true, force: true });
+          fs9.rmSync(backupDir, { recursive: true, force: true });
         } catch {
         }
       }
@@ -4429,25 +4429,25 @@ function installCodexMemoryExtension(options = {}) {
     rollbackFn = () => {
       if (hadExisting) {
         try {
-          if (fs8.existsSync(paths.remnicExtensionDir)) {
-            fs8.rmSync(paths.remnicExtensionDir, { recursive: true, force: true });
+          if (fs9.existsSync(paths.remnicExtensionDir)) {
+            fs9.rmSync(paths.remnicExtensionDir, { recursive: true, force: true });
           }
-          fs8.renameSync(backupDir, paths.remnicExtensionDir);
+          fs9.renameSync(backupDir, paths.remnicExtensionDir);
         } catch {
         }
       } else {
         try {
-          if (fs8.existsSync(paths.remnicExtensionDir)) {
-            fs8.rmSync(paths.remnicExtensionDir, { recursive: true, force: true });
+          if (fs9.existsSync(paths.remnicExtensionDir)) {
+            fs9.rmSync(paths.remnicExtensionDir, { recursive: true, force: true });
           }
         } catch {
         }
       }
     };
   } catch (err) {
-    if (fs8.existsSync(tmpDir)) {
+    if (fs9.existsSync(tmpDir)) {
       try {
-        fs8.rmSync(tmpDir, { recursive: true, force: true });
+        fs9.rmSync(tmpDir, { recursive: true, force: true });
       } catch {
       }
     }
@@ -4465,8 +4465,8 @@ function installCodexMemoryExtension(options = {}) {
 function removeCodexMemoryExtension(options = {}) {
   const paths = resolveCodexMemoryExtensionPaths(options.codexHome ?? null);
   let removed = false;
-  if (fs8.existsSync(paths.remnicExtensionDir)) {
-    fs8.rmSync(paths.remnicExtensionDir, { recursive: true, force: true });
+  if (fs9.existsSync(paths.remnicExtensionDir)) {
+    fs9.rmSync(paths.remnicExtensionDir, { recursive: true, force: true });
     removed = true;
   }
   return { ...paths, removed };
@@ -4494,8 +4494,8 @@ function resolveWeCloneProxyConfigPath() {
 }
 function readWeCloneProxyConfigIfExists(configPath) {
   try {
-    if (!fs8.existsSync(configPath)) return null;
-    return fs8.readFileSync(configPath, "utf8");
+    if (!fs9.existsSync(configPath)) return null;
+    return fs9.readFileSync(configPath, "utf8");
   } catch {
     return null;
   }
@@ -4615,7 +4615,7 @@ function buildWeCloneProxyConfig(args) {
 }
 
 // src/spaces/index.ts
-import fs9 from "fs";
+import fs10 from "fs";
 import path14 from "path";
 import crypto6 from "crypto";
 var MANIFEST_VERSION = 1;
@@ -4628,7 +4628,7 @@ function getManifestPath(baseDir) {
 }
 function loadManifest(baseDir, memoryDirOverride) {
   const manifestPath2 = getManifestPath(baseDir);
-  if (!fs9.existsSync(manifestPath2)) {
+  if (!fs10.existsSync(manifestPath2)) {
     const personalSpace = createPersonalSpace(baseDir, memoryDirOverride);
     const manifest = {
       activeSpaceId: personalSpace.id,
@@ -4638,19 +4638,19 @@ function loadManifest(baseDir, memoryDirOverride) {
     saveManifest(manifest, baseDir);
     return manifest;
   }
-  const raw = JSON.parse(fs9.readFileSync(manifestPath2, "utf8"));
+  const raw = JSON.parse(fs10.readFileSync(manifestPath2, "utf8"));
   return raw;
 }
 function saveManifest(manifest, baseDir) {
   const manifestPath2 = getManifestPath(baseDir);
-  fs9.mkdirSync(path14.dirname(manifestPath2), { recursive: true });
-  fs9.writeFileSync(manifestPath2, JSON.stringify(manifest, null, 2) + "\n");
+  fs10.mkdirSync(path14.dirname(manifestPath2), { recursive: true });
+  fs10.writeFileSync(manifestPath2, JSON.stringify(manifest, null, 2) + "\n");
 }
 function createPersonalSpace(baseDir, memoryDirOverride) {
   const homeDir = baseDir ?? resolveHomeDir();
   const standalonePath = path14.join(homeDir, ".engram", "memory");
   const openclawPath = path14.join(homeDir, ".openclaw", "workspace", "memory", "local");
-  const memoryDir = memoryDirOverride ?? readEnvVar("ENGRAM_MEMORY_DIR") ?? (fs9.existsSync(standalonePath) ? standalonePath : fs9.existsSync(openclawPath) ? openclawPath : standalonePath);
+  const memoryDir = memoryDirOverride ?? readEnvVar("ENGRAM_MEMORY_DIR") ?? (fs10.existsSync(standalonePath) ? standalonePath : fs10.existsSync(openclawPath) ? openclawPath : standalonePath);
   const now = (/* @__PURE__ */ new Date()).toISOString();
   return {
     id: "personal",
@@ -4699,7 +4699,7 @@ function createSpace(options) {
     owner: readEnvVar("USER"),
     parentSpaceId: options.parentSpaceId
   };
-  fs9.mkdirSync(memoryDir, { recursive: true });
+  fs10.mkdirSync(memoryDir, { recursive: true });
   manifest.spaces.push(space);
   manifest.updatedAt = now;
   saveManifest(manifest, options.baseDir);
@@ -4874,31 +4874,31 @@ function mergeSpaces(sourceSpaceId, targetSpaceId, options) {
 }
 function getAuditLog(baseDir) {
   const auditPath = path14.join(getSpacesDir(baseDir), "audit.jsonl");
-  if (!fs9.existsSync(auditPath)) return [];
-  const lines = fs9.readFileSync(auditPath, "utf8").trim().split("\n");
+  if (!fs10.existsSync(auditPath)) return [];
+  const lines = fs10.readFileSync(auditPath, "utf8").trim().split("\n");
   return lines.filter((l) => l.trim()).map((l) => JSON.parse(l));
 }
 function appendAudit(entry, baseDir) {
   const auditPath = path14.join(getSpacesDir(baseDir), "audit.jsonl");
-  fs9.mkdirSync(path14.dirname(auditPath), { recursive: true });
+  fs10.mkdirSync(path14.dirname(auditPath), { recursive: true });
   const full = {
     id: crypto6.randomUUID(),
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
     ...entry
   };
-  fs9.appendFileSync(auditPath, JSON.stringify(full) + "\n");
+  fs10.appendFileSync(auditPath, JSON.stringify(full) + "\n");
 }
 function copyMemories(sourceDir, targetDir, options) {
   let merged = 0;
   const conflicts = [];
   let skipped = 0;
-  if (!fs9.existsSync(sourceDir)) {
+  if (!fs10.existsSync(sourceDir)) {
     return { merged: 0, conflicts: [], skipped: 0 };
   }
-  fs9.mkdirSync(targetDir, { recursive: true });
+  fs10.mkdirSync(targetDir, { recursive: true });
   const sourceFiles = walkMd2(sourceDir);
   for (const sourcePath of sourceFiles) {
-    const content = fs9.readFileSync(sourcePath, "utf8");
+    const content = fs10.readFileSync(sourcePath, "utf8");
     const relativePath = path14.relative(sourceDir, sourcePath);
     const targetPath = path14.join(targetDir, relativePath);
     const sourceHash = hashContent4(content);
@@ -4909,8 +4909,8 @@ function copyMemories(sourceDir, targetDir, options) {
         continue;
       }
     }
-    if (fs9.existsSync(targetPath) && !options?.force) {
-      const targetContent = fs9.readFileSync(targetPath, "utf8");
+    if (fs10.existsSync(targetPath) && !options?.force) {
+      const targetContent = fs10.readFileSync(targetPath, "utf8");
       const targetHash = hashContent4(targetContent);
       if (sourceHash !== targetHash) {
         conflicts.push({
@@ -4926,8 +4926,8 @@ function copyMemories(sourceDir, targetDir, options) {
       skipped++;
       continue;
     }
-    fs9.mkdirSync(path14.dirname(targetPath), { recursive: true });
-    fs9.writeFileSync(targetPath, content);
+    fs10.mkdirSync(path14.dirname(targetPath), { recursive: true });
+    fs10.writeFileSync(targetPath, content);
     merged++;
   }
   return { merged, conflicts, skipped };
@@ -4938,7 +4938,7 @@ function hashContent4(content) {
 function walkMd2(dir) {
   const results = [];
   function walk(d) {
-    for (const entry of fs9.readdirSync(d, { withFileTypes: true })) {
+    for (const entry of fs10.readdirSync(d, { withFileTypes: true })) {
       const fullPath = path14.join(d, entry.name);
       if (entry.isDirectory()) {
         walk(fullPath);
@@ -5067,7 +5067,7 @@ var REMNIC_RECALL_DECISION_RULES = `## When to Use Recall vs Direct Read
 `;
 
 // src/memory-extension/codex-publisher.ts
-import fs10 from "fs";
+import fs11 from "fs";
 import os2 from "os";
 import path15 from "path";
 var REMNIC_EXTENSION_DIR_NAME2 = "remnic";
@@ -5086,7 +5086,7 @@ var CodexMemoryExtensionPublisher = class {
   async isHostAvailable() {
     try {
       const home = readEnvVar("CODEX_HOME")?.trim() || path15.join(resolveHomeDir(), ".codex");
-      return fs10.existsSync(home);
+      return fs11.existsSync(home);
     } catch {
       return false;
     }
@@ -5140,18 +5140,18 @@ When running inside the Codex phase-2 consolidation sandbox:
     const filesWritten = [];
     const skipped = [];
     ctx.log.info(`Publishing Codex memory extension to ${extensionRoot}`);
-    fs10.mkdirSync(extensionRoot, { recursive: true });
+    fs11.mkdirSync(extensionRoot, { recursive: true });
     const content = await this.renderInstructions(ctx);
     const tmpPath = `${instructionsPath}.tmp-${process.pid}-${Date.now()}`;
     try {
-      fs10.writeFileSync(tmpPath, content, "utf-8");
-      fs10.renameSync(tmpPath, instructionsPath);
+      fs11.writeFileSync(tmpPath, content, "utf-8");
+      fs11.renameSync(tmpPath, instructionsPath);
       filesWritten.push(instructionsPath);
       ctx.log.info(`Wrote ${instructionsPath}`);
     } catch (err) {
       try {
-        if (fs10.existsSync(tmpPath)) {
-          fs10.unlinkSync(tmpPath);
+        if (fs11.existsSync(tmpPath)) {
+          fs11.unlinkSync(tmpPath);
         }
       } catch {
       }
@@ -5166,8 +5166,8 @@ When running inside the Codex phase-2 consolidation sandbox:
   }
   async unpublish() {
     const extensionRoot = await this.resolveExtensionRoot();
-    if (fs10.existsSync(extensionRoot)) {
-      fs10.rmSync(extensionRoot, { recursive: true, force: true });
+    if (fs11.existsSync(extensionRoot)) {
+      fs11.rmSync(extensionRoot, { recursive: true, force: true });
     }
   }
 };
@@ -5477,7 +5477,7 @@ async function runEnrichmentPipeline(entities, registry, config, log2) {
 
 // src/enrichment/audit.ts
 import { mkdir, readFile, appendFile } from "fs/promises";
-import { existsSync as existsSync2 } from "fs";
+import { existsSync } from "fs";
 import path16 from "path";
 var AUDIT_FILENAME = "enrichment-audit.jsonl";
 function auditFilePath(auditDir) {
@@ -5490,7 +5490,7 @@ async function appendAuditEntry(auditDir, entry) {
 }
 async function readAuditLog(auditDir, since) {
   const filePath = auditFilePath(auditDir);
-  if (!existsSync2(filePath)) return [];
+  if (!existsSync(filePath)) return [];
   const raw = await readFile(filePath, "utf-8");
   const entries = [];
   for (const line of raw.split("\n")) {