@remnic/core 9.63.1 → 9.63.2

package/dist/{chunk-ANMIOQPU.js → chunk-4XN35YQD.js}

@@ -33,9 +33,9 @@ import {
 } from "./chunk-3WCASNQZ.js";
 
 // src/connectors/index.ts
-import fs3 from "fs";
-import path3 from "path";
-import os from "os";
+import fs4 from "fs";
+import path4 from "path";
+import os2 from "os";
 import { createRequire } from "module";
 import { fileURLToPath } from "url";
 
@@ -398,9 +398,265 @@ function assertConfigComponentsNotSymlinked(cfgPath) {
   }
 }
 
-// src/connectors/codex-marketplace.ts
+// src/connectors/droid-mcp.ts
 import fs2 from "fs";
 import path2 from "path";
+import os from "os";
+var DROID_CONNECTOR_MANIFEST = {
+  id: "droid",
+  name: "Factory Droid",
+  version: "1.0.0",
+  description: "Factory Droid \u2014 AI software engineering agent; memory via HTTP MCP with bearer auth",
+  capabilities: {
+    observe: true,
+    recall: true,
+    store: true,
+    search: true,
+    entities: true,
+    realtimeSync: true,
+    batch: true,
+    maxBudgetChars: 32e3,
+    connectionType: "mcp"
+  },
+  configSchema: {
+    mcpServerUrl: "URL of the MCP Remnic: server (default: http://127.0.0.1:4318/mcp)",
+    namespace: "Optional namespace"
+  },
+  homepage: "https://factory.ai",
+  author: "Remnic",
+  tags: ["official", "ai", "droid", "factory"],
+  requiresToken: true
+};
+function droidInstallStep(authToken, resolvedConfig, requiresToken, tokenEntry, priorTokenStore, saveTokenStoreFn) {
+  try {
+    const result = writeDroidMcpEntry(authToken, resolvedConfig);
+    return { ok: true, rollback: result.rollback, mcpPath: result.mcpPath };
+  } catch (droidErr) {
+    const errMsg = droidErr instanceof Error ? droidErr.message : String(droidErr);
+    let tokenSuffix = "";
+    if (requiresToken && tokenEntry !== null && priorTokenStore !== null) {
+      try {
+        saveTokenStoreFn(priorTokenStore);
+        tokenSuffix = " Token has been rolled back.";
+      } catch (e) {
+        tokenSuffix = ` Token rollback FAILED (${e instanceof Error ? e.message : String(e)}) \u2014 manually inspect ~/.remnic/tokens.json and reinstall.`;
+      }
+    }
+    return {
+      ok: false,
+      errorMessage: `Droid install aborted: ~/.factory/mcp.json write failed \u2014 ${errMsg}.${tokenSuffix} Resolve the write permission issue on ~/.factory/, then reinstall.`
+    };
+  }
+}
+function readDroidMcpProvenance(configPath) {
+  let mcpConfigPath = null;
+  let registryParseFailed = false;
+  if (!fs2.existsSync(configPath)) {
+    return { mcpConfigPath: null, registryParseFailed: false };
+  }
+  try {
+    const stored = JSON.parse(fs2.readFileSync(configPath, "utf8"));
+    if (typeof stored.factoryMcpPath === "string" && stored.factoryMcpPath.length > 0) {
+      mcpConfigPath = stored.factoryMcpPath;
+    }
+  } catch {
+    registryParseFailed = true;
+  }
+  if (mcpConfigPath === null && !registryParseFailed) {
+    try {
+      mcpConfigPath = resolveFactoryMcpPath();
+    } catch {
+    }
+  }
+  return { mcpConfigPath, registryParseFailed };
+}
+function writeSecretFileSync(filePath, data) {
+  const dir = path2.dirname(filePath);
+  const base = path2.basename(filePath);
+  const tmpPath = path2.join(
+    dir,
+    `.${base}.${process.pid}.${Date.now()}.${Math.random().toString(16).slice(2)}.tmp`
+  );
+  let wroteTemp = false;
+  try {
+    fs2.writeFileSync(tmpPath, data, { mode: 384, flag: "wx" });
+    wroteTemp = true;
+    try {
+      fs2.chmodSync(tmpPath, 384);
+    } catch {
+    }
+    fs2.renameSync(tmpPath, filePath);
+    try {
+      fs2.chmodSync(filePath, 384);
+    } catch {
+    }
+  } catch (err) {
+    if (wroteTemp) {
+      try {
+        fs2.unlinkSync(tmpPath);
+      } catch {
+      }
+    }
+    throw err;
+  }
+}
+function writeDroidMcpEntry(authToken, resolvedConfig) {
+  const mcpPath = resolveFactoryMcpPath();
+  const priorContent = readFactoryMcpIfExists(mcpPath);
+  const mcpConfig = upsertFactoryMcpRemnicEntry(priorContent, authToken, resolvedConfig);
+  fs2.mkdirSync(path2.dirname(mcpPath), { recursive: true });
+  const rollback = () => {
+    try {
+      if (priorContent === null) {
+        if (fs2.existsSync(mcpPath)) fs2.unlinkSync(mcpPath);
+      } else {
+        writeSecretFileSync(mcpPath, priorContent);
+      }
+    } catch {
+    }
+  };
+  try {
+    writeSecretFileSync(mcpPath, JSON.stringify(mcpConfig, null, 2));
+  } catch (writeErr) {
+    try {
+      rollback();
+    } catch {
+    }
+    throw writeErr;
+  }
+  return { mcpPath, rollback };
+}
+function removeDroidMcpEntry(mcpPath) {
+  const expectedSuffix = path2.join(".factory", "mcp.json");
+  if (!path2.isAbsolute(mcpPath) || !mcpPath.endsWith(expectedSuffix)) {
+    throw new Error(
+      `MCP config path ${JSON.stringify(mcpPath)} failed safety validation (must be absolute and end with "${expectedSuffix}"). Refusing to modify \u2014 remove the "remnic" entry manually if it exists.`
+    );
+  }
+  const priorContent = readFactoryMcpIfExists(mcpPath);
+  if (priorContent === null) return null;
+  const updated = removeFactoryMcpRemnicEntry(priorContent);
+  if (updated === null) return null;
+  writeSecretFileSync(mcpPath, JSON.stringify(updated, null, 2));
+  return `Removed remnic entry from Droid MCP config: ${mcpPath}`;
+}
+function droidMcpDoctorCheck(savedPath) {
+  const mcpPath = savedPath ?? resolveFactoryMcpPath();
+  if (savedPath !== void 0) {
+    const expectedSuffix = path2.join(".factory", "mcp.json");
+    if (!path2.isAbsolute(savedPath) || !savedPath.endsWith(expectedSuffix)) {
+      return { name: "Droid MCP config", ok: false, detail: `Unsafe path in droid.json: ${savedPath}` };
+    }
+  }
+  try {
+    const raw = fs2.readFileSync(mcpPath, "utf8");
+    const parsed = JSON.parse(raw);
+    const servers = parsed.mcpServers;
+    if (typeof servers !== "object" || servers === null || !("remnic" in servers)) {
+      return { name: "Droid MCP config", ok: false, detail: `remnic entry missing in ${mcpPath} \u2014 run \`remnic connectors install droid\`` };
+    }
+    const remnic = servers.remnic;
+    if (remnic.type !== "http" || typeof remnic.url !== "string") {
+      return { name: "Droid MCP config", ok: false, detail: `remnic entry malformed in ${mcpPath}` };
+    }
+    const headers = remnic.headers;
+    const hasAuth = headers && typeof headers["Authorization"] === "string" && headers["Authorization"].startsWith("Bearer ");
+    return {
+      name: "Droid MCP config",
+      ok: !!hasAuth,
+      detail: hasAuth ? `remnic entry present in ${mcpPath}` : `remnic entry missing Authorization header in ${mcpPath} \u2014 run \`remnic connectors install droid\``
+    };
+  } catch {
+    return { name: "Droid MCP config", ok: false, detail: `Cannot read ${mcpPath} \u2014 run \`remnic connectors install droid\`` };
+  }
+}
+function resolveFactoryMcpPath() {
+  const envHome = readEnvVar("HOME");
+  const home = envHome && envHome.length > 0 ? envHome : os.homedir();
+  return path2.resolve(home, ".factory", "mcp.json");
+}
+function readFactoryMcpIfExists(mcpPath) {
+  try {
+    if (!fs2.existsSync(mcpPath)) return null;
+    return fs2.readFileSync(mcpPath, "utf8");
+  } catch {
+    return null;
+  }
+}
+var REMNIC_DEFAULT_MCP_URL = "http://127.0.0.1:4318/mcp";
+function upsertFactoryMcpRemnicEntry(priorContent, authToken, resolvedConfig) {
+  let config;
+  if (priorContent !== null) {
+    try {
+      const parsed = JSON.parse(priorContent);
+      if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+        config = parsed;
+      } else {
+        console.warn("[remnic/connectors] ~/.factory/mcp.json contained non-object JSON; starting fresh.");
+        config = {};
+      }
+    } catch {
+      throw new Error(
+        "~/.factory/mcp.json contains malformed JSON and cannot be parsed. Fix the file manually before reinstalling, or use --force to overwrite (this will lose existing MCP server entries)."
+      );
+    }
+  } else {
+    config = {};
+  }
+  if (typeof config.mcpServers !== "object" || config.mcpServers === null || Array.isArray(config.mcpServers)) {
+    config.mcpServers = {};
+  }
+  const servers = config.mcpServers;
+  const mcpUrl = typeof resolvedConfig.mcpServerUrl === "string" && resolvedConfig.mcpServerUrl.length > 0 ? resolvedConfig.mcpServerUrl : REMNIC_DEFAULT_MCP_URL;
+  const remnicEntry = { type: "http", url: mcpUrl };
+  const REMNIC_MANAGED_HEADERS = /* @__PURE__ */ new Set(["Authorization", "X-Engram-Namespace"]);
+  const headers = {};
+  if (typeof servers.remnic === "object" && servers.remnic !== null && typeof servers.remnic.headers === "object" && servers.remnic.headers !== null) {
+    const priorHeaders = servers.remnic.headers;
+    for (const [key, value] of Object.entries(priorHeaders)) {
+      if (!REMNIC_MANAGED_HEADERS.has(key) && typeof value === "string") {
+        headers[key] = value;
+      }
+    }
+  }
+  if (authToken && authToken.length > 0) {
+    headers["Authorization"] = `Bearer ${authToken}`;
+  }
+  const namespace = typeof resolvedConfig.namespace === "string" && resolvedConfig.namespace.length > 0 ? resolvedConfig.namespace : void 0;
+  if (namespace) {
+    headers["X-Engram-Namespace"] = namespace;
+  }
+  if (Object.keys(headers).length > 0) {
+    remnicEntry.headers = headers;
+  }
+  servers.remnic = remnicEntry;
+  return config;
+}
+function removeFactoryMcpRemnicEntry(priorContent) {
+  let config;
+  try {
+    const parsed = JSON.parse(priorContent);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      return null;
+    }
+    config = parsed;
+  } catch {
+    return null;
+  }
+  if (typeof config.mcpServers !== "object" || config.mcpServers === null) {
+    return null;
+  }
+  const servers = config.mcpServers;
+  if (!("remnic" in servers)) {
+    return null;
+  }
+  delete servers.remnic;
+  return config;
+}
+
+// src/connectors/codex-marketplace.ts
+import fs3 from "fs";
+import path3 from "path";
 var MARKETPLACE_SCHEMA_VERSION = 1;
 var MARKETPLACE_MANIFEST_FILENAME = "marketplace.json";
 var VALID_INSTALL_TYPES = /* @__PURE__ */ new Set(["github", "git", "local", "url"]);
@@ -502,12 +758,12 @@ async function writeMarketplaceManifest(outputDir, manifest) {
       `Refusing to write invalid manifest: ${validation.errors.join("; ")}`
     );
   }
-  fs2.mkdirSync(outputDir, { recursive: true });
-  const destPath = path2.join(outputDir, MARKETPLACE_MANIFEST_FILENAME);
+  fs3.mkdirSync(outputDir, { recursive: true });
+  const destPath = path3.join(outputDir, MARKETPLACE_MANIFEST_FILENAME);
   const tmpPath = `${destPath}.tmp.${process.pid}`;
   const content = JSON.stringify(manifest, null, 2) + "\n";
-  fs2.writeFileSync(tmpPath, content);
-  fs2.renameSync(tmpPath, destPath);
+  fs3.writeFileSync(tmpPath, content);
+  fs3.renameSync(tmpPath, destPath);
 }
 async function installFromMarketplace(source, sourceType, config, logger) {
   const _log = logger ?? {
@@ -567,12 +823,12 @@ async function resolveManifest(source, sourceType, logger) {
   }
 }
 function resolveLocal(dirPath, logger) {
-  const manifestPath = path2.join(dirPath, MARKETPLACE_MANIFEST_FILENAME);
-  if (!fs2.existsSync(manifestPath)) {
+  const manifestPath = path3.join(dirPath, MARKETPLACE_MANIFEST_FILENAME);
+  if (!fs3.existsSync(manifestPath)) {
     throw new Error(`marketplace.json not found at ${manifestPath}`);
   }
   logger.debug?.(`reading local marketplace manifest: ${manifestPath}`);
-  const raw = fs2.readFileSync(manifestPath, "utf-8");
+  const raw = fs3.readFileSync(manifestPath, "utf-8");
   let parsed;
   try {
     parsed = JSON.parse(raw);
@@ -624,15 +880,15 @@ async function resolveGit(gitUrl, logger) {
 }
 function readPackageVersion() {
   const candidates = [
-    path2.resolve(import.meta.dirname ?? ".", "../../../.."),
-    path2.resolve(import.meta.dirname ?? ".", "../../../../.."),
-    path2.resolve(import.meta.dirname ?? ".", "..")
+    path3.resolve(import.meta.dirname ?? ".", "../../../.."),
+    path3.resolve(import.meta.dirname ?? ".", "../../../../.."),
+    path3.resolve(import.meta.dirname ?? ".", "..")
   ];
   for (const candidate of candidates) {
-    const pkgPath = path2.join(candidate, "package.json");
+    const pkgPath = path3.join(candidate, "package.json");
     try {
-      if (!fs2.existsSync(pkgPath)) continue;
-      const raw = fs2.readFileSync(pkgPath, "utf-8");
+      if (!fs3.existsSync(pkgPath)) continue;
+      const raw = fs3.readFileSync(pkgPath, "utf-8");
       const parsed = JSON.parse(raw);
       if (typeof parsed === "object" && parsed !== null && typeof parsed.version === "string") {
         return parsed.version;
@@ -991,7 +1247,8 @@ var BUILTIN_CONNECTORS = [
     author: "Remnic",
     tags: ["official", "python", "hermes"],
     requiresToken: true
-  }
+  },
+  DROID_CONNECTOR_MANIFEST
 ];
 var CONNECTOR_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
 function isValidConnectorId(connectorId) {
@@ -1002,7 +1259,7 @@ function isConnectorManifest(value) {
 }
 function loadRegistry() {
   const regPath = getRegistryPath();
-  if (!fs3.existsSync(regPath)) {
+  if (!fs4.existsSync(regPath)) {
     const registry = {
       connectors: BUILTIN_CONNECTORS,
       registryPath: regPath
@@ -1011,7 +1268,7 @@ function loadRegistry() {
     return registry;
   }
   try {
-    const raw = fs3.readFileSync(regPath, "utf8");
+    const raw = fs4.readFileSync(regPath, "utf8");
     const parsed = JSON.parse(raw);
     if (typeof parsed !== "object" || parsed === null || !Array.isArray(parsed.connectors)) {
       throw new Error("invalid registry schema");
@@ -1034,19 +1291,19 @@ function loadRegistry() {
 }
 function saveRegistry(registry) {
   const regPath = registry.registryPath;
-  fs3.mkdirSync(path3.dirname(regPath), { recursive: true });
-  fs3.writeFileSync(regPath, JSON.stringify({ connectors: registry.connectors }, null, 2));
+  fs4.mkdirSync(path4.dirname(regPath), { recursive: true });
+  fs4.writeFileSync(regPath, JSON.stringify({ connectors: registry.connectors }, null, 2));
 }
 function listConnectors() {
   const registry = loadRegistry();
   const connectorsDir = getConnectorsDir();
   const installedIds = /* @__PURE__ */ new Set();
-  if (fs3.existsSync(connectorsDir)) {
-    for (const entry of fs3.readdirSync(connectorsDir)) {
+  if (fs4.existsSync(connectorsDir)) {
+    for (const entry of fs4.readdirSync(connectorsDir)) {
       if (entry.endsWith(".json")) {
         try {
           const config = JSON.parse(
-            fs3.readFileSync(path3.join(connectorsDir, entry), "utf8")
+            fs4.readFileSync(path4.join(connectorsDir, entry), "utf8")
           );
           if (isValidConnectorId(config.connectorId)) {
             installedIds.add(config.connectorId);
@@ -1062,9 +1319,9 @@ function listConnectors() {
   }));
   const installed = [];
   for (const id of installedIds) {
-    const configPath = path3.join(connectorsDir, `${id}.json`);
+    const configPath = path4.join(connectorsDir, `${id}.json`);
     try {
-      const raw = JSON.parse(fs3.readFileSync(configPath, "utf8"));
+      const raw = JSON.parse(fs4.readFileSync(configPath, "utf8"));
       const { token: _redacted, ...config } = raw;
       installed.push({
         connectorId: id,
@@ -1088,9 +1345,9 @@ function getConnectorToken(connectorId) {
   }
 }
 function readSavedConnectorConfig(configPath) {
-  if (!fs3.existsSync(configPath)) return {};
+  if (!fs4.existsSync(configPath)) return {};
   try {
-    const parsed = JSON.parse(fs3.readFileSync(configPath, "utf8"));
+    const parsed = JSON.parse(fs4.readFileSync(configPath, "utf8"));
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return {};
     const {
       connectorId: _connectorId,
@@ -1144,10 +1401,10 @@ function installConnector(options) {
     let backfillNote = "";
     if (options.connectorId === "hermes") {
       try {
-        const hermesJsonPath = path3.join(getConnectorsDir(), "hermes.json");
+        const hermesJsonPath = path4.join(getConnectorsDir(), "hermes.json");
         let parsed = null;
         try {
-          const parsedRaw = JSON.parse(fs3.readFileSync(hermesJsonPath, "utf8"));
+          const parsedRaw = JSON.parse(fs4.readFileSync(hermesJsonPath, "utf8"));
           if (parsedRaw !== null && typeof parsedRaw === "object" && !Array.isArray(parsedRaw)) {
             parsed = parsedRaw;
           }
@@ -1163,7 +1420,7 @@ function installConnector(options) {
           currentConfigPath = hermesConfigPath(
             typeof profileRaw === "string" && profileRaw.length > 0 ? profileRaw : "default"
           );
-          activeConfigHasBlock = fs3.existsSync(currentConfigPath) && /^remnic:/m.test(fs3.readFileSync(currentConfigPath, "utf8"));
+          activeConfigHasBlock = fs4.existsSync(currentConfigPath) && /^remnic:/m.test(fs4.readFileSync(currentConfigPath, "utf8"));
         } catch (resolveErr) {
           configResolutionError = resolveErr instanceof Error ? resolveErr.message : String(resolveErr);
           activeConfigHasBlock = false;
@@ -1226,7 +1483,7 @@ function installConnector(options) {
             parsed.pluginShimPath = outcome.persistPath;
           }
           try {
-            writeSecretFileSync(hermesJsonPath, JSON.stringify(parsed, null, 2));
+            writeSecretFileSync2(hermesJsonPath, JSON.stringify(parsed, null, 2));
           } catch (persistErr) {
             const rollbackFailures = [];
             if (outcome.materializedAt !== null && outcome.createdNew && (priorPersisted === null || !sameShimTarget(outcome.materializedAt, priorPersisted))) {
@@ -1267,8 +1524,8 @@ function installConnector(options) {
     };
   }
   const configDir = getConnectorsDir();
-  fs3.mkdirSync(configDir, { recursive: true });
-  const configPath = path3.join(configDir, `${options.connectorId}.json`);
+  fs4.mkdirSync(configDir, { recursive: true });
+  const configPath = path4.join(configDir, `${options.connectorId}.json`);
   const savedConnectorConfig = existing ? readSavedConnectorConfig(configPath) : {};
   let hermesSavedProfile;
   let hermesSavedHost;
@@ -1279,9 +1536,9 @@ function installConnector(options) {
   let hermesResolvedPort;
   let hermesResolvedAllowInsecureHttp = false;
   if (options.connectorId === "hermes") {
-    if (fs3.existsSync(configPath)) {
+    if (fs4.existsSync(configPath)) {
       try {
-        const prev = JSON.parse(fs3.readFileSync(configPath, "utf8"));
+        const prev = JSON.parse(fs4.readFileSync(configPath, "utf8"));
         if (prev?.profile != null) {
           try {
             hermesSavedProfile = sanitizeHermesProfile(String(prev.profile));
@@ -1428,7 +1685,7 @@ function installConnector(options) {
       const envHermesHome = readEnvVar("HERMES_HOME");
       if (typeof envHermesHome === "string" && envHermesHome.trim().length > 0) {
         try {
-          fs3.mkdirSync(path3.dirname(hermesConfigPath(hermesProfile)), { recursive: true });
+          fs4.mkdirSync(path4.dirname(hermesConfigPath(hermesProfile)), { recursive: true });
         } catch {
         }
       }
@@ -1474,9 +1731,9 @@ function installConnector(options) {
       let yamlRollbackErrMsg = "";
       try {
         if (yamlResult.priorContent === null) {
-          fs3.unlinkSync(yamlResult.configPath);
+          fs4.unlinkSync(yamlResult.configPath);
         } else if (typeof yamlResult.priorContent === "string") {
-          writeSecretFileSync(yamlResult.configPath, yamlResult.priorContent);
+          writeSecretFileSync2(yamlResult.configPath, yamlResult.priorContent);
         }
       } catch (yamlRestoreErr) {
         yamlRolledBack = false;
@@ -1549,7 +1806,7 @@ function installConnector(options) {
       let fallbackDetail = "";
       if (isPlausibleHermesConfigPath(priorConfigPath)) {
         try {
-          const beforeRefresh = fs3.readFileSync(priorConfigPath, "utf8");
+          const beforeRefresh = fs4.readFileSync(priorConfigPath, "utf8");
           const refresh = upsertHermesConfigAt(priorConfigPath, {
             host: hermesHost,
             port: hermesPort,
@@ -1596,7 +1853,7 @@ function installConnector(options) {
             continue;
           }
           try {
-            const beforeCleanup = fs3.readFileSync(candidate, "utf8");
+            const beforeCleanup = fs4.readFileSync(candidate, "utf8");
             const cleanup = removeHermesConfigFile(candidate);
             if (cleanup.updated) {
               hermesPriorConfigMutations.push({ mutatedPath: candidate, priorContent: beforeCleanup });
@@ -1619,7 +1876,7 @@ function installConnector(options) {
         }
         let blockSurvives = false;
         try {
-          blockSurvives = /^remnic:/m.test(fs3.readFileSync(candidate, "utf8"));
+          blockSurvives = /^remnic:/m.test(fs4.readFileSync(candidate, "utf8"));
         } catch {
           blockSurvives = false;
         }
@@ -1635,7 +1892,7 @@ function installConnector(options) {
       delete resolvedConfig.priorHermesConfigPath;
     }
     try {
-      writeSecretFileSync(configPath, JSON.stringify(resolvedConfig, null, 2));
+      writeSecretFileSync2(configPath, JSON.stringify(resolvedConfig, null, 2));
     } catch (writeErr) {
       let tokenRollbackFailed = false;
       let tokenRollbackMsg = "token store restored to pre-install snapshot";
@@ -1651,7 +1908,7 @@ function installConnector(options) {
           let unlinkSucceeded = false;
           let unlinkErr;
           try {
-            fs3.unlinkSync(yamlResult.configPath);
+            fs4.unlinkSync(yamlResult.configPath);
             unlinkSucceeded = true;
           } catch (err) {
             unlinkErr = err;
@@ -1663,7 +1920,7 @@ function installConnector(options) {
             yamlRollbackMsg = `config.yaml rollback failed: could not remove newly-created file \u2014 ${unlinkMsg}`;
           }
         } else if (typeof yamlResult.priorContent === "string") {
-          writeSecretFileSync(yamlResult.configPath, yamlResult.priorContent);
+          writeSecretFileSync2(yamlResult.configPath, yamlResult.priorContent);
           yamlRollbackMsg = "config.yaml restored to prior content";
         }
       } catch (yamlRollbackErr) {
@@ -1710,7 +1967,7 @@ function installConnector(options) {
         const priorConfigRollbackFailures = [];
         for (const mutation of [...hermesPriorConfigMutations].reverse()) {
           try {
-            writeSecretFileSync(mutation.mutatedPath, mutation.priorContent);
+            writeSecretFileSync2(mutation.mutatedPath, mutation.priorContent);
           } catch (restoreErr) {
             priorConfigRollbackFailures.push(
               `could not restore ${mutation.mutatedPath} (${restoreErr instanceof Error ? restoreErr.message : String(restoreErr)})`
@@ -1839,9 +2096,9 @@ function installConnector(options) {
   if (options.connectorId === "weclone") {
     try {
       let proxyConfigPath = null;
-      if (existing && fs3.existsSync(configPath)) {
+      if (existing && fs4.existsSync(configPath)) {
         try {
-          const savedRegistryConfig = JSON.parse(fs3.readFileSync(configPath, "utf8"));
+          const savedRegistryConfig = JSON.parse(fs4.readFileSync(configPath, "utf8"));
           if (typeof savedRegistryConfig.proxyConfigPath === "string" && savedRegistryConfig.proxyConfigPath.length > 0) {
             proxyConfigPath = savedRegistryConfig.proxyConfigPath;
           }
@@ -1857,21 +2114,21 @@ function installConnector(options) {
         priorConfig: prior ? safeParseJson(prior) : null,
         authToken: tokenEntry?.token
       });
-      fs3.mkdirSync(path3.dirname(proxyConfigPath), { recursive: true });
+      fs4.mkdirSync(path4.dirname(proxyConfigPath), { recursive: true });
       weCloneProxyHandleRollback = () => {
         try {
           if (prior === null) {
-            if (fs3.existsSync(proxyConfigPath)) {
-              fs3.unlinkSync(proxyConfigPath);
+            if (fs4.existsSync(proxyConfigPath)) {
+              fs4.unlinkSync(proxyConfigPath);
             }
           } else {
-            writeSecretFileSync(proxyConfigPath, prior);
+            writeSecretFileSync2(proxyConfigPath, prior);
           }
         } catch {
         }
       };
       try {
-        writeSecretFileSync(
+        writeSecretFileSync2(
           proxyConfigPath,
           JSON.stringify(proxyConfig, null, 2)
         );
@@ -1908,6 +2165,22 @@ function installConnector(options) {
       };
     }
   }
+  let droidMcpRollback = null;
+  if (options.connectorId === "droid") {
+    const stepResult = droidInstallStep(
+      tokenEntry?.token,
+      resolvedConfig,
+      manifest.requiresToken ?? false,
+      tokenEntry,
+      nonHermesPriorTokenStore,
+      saveTokenStore
+    );
+    if (!stepResult.ok) {
+      return { connectorId: options.connectorId, status: "error", message: stepResult.errorMessage };
+    }
+    droidMcpRollback = stepResult.rollback;
+    resolvedConfig.factoryMcpPath = stepResult.mcpPath;
+  }
   const INTERNAL_KEYS_DENYLIST = [
     "extensionSourceDir"
     // test-only override for the plugin-codex source path
@@ -1916,7 +2189,7 @@ function installConnector(options) {
     delete resolvedConfig[key];
   }
   try {
-    writeSecretFileSync(configPath, JSON.stringify(resolvedConfig, null, 2));
+    writeSecretFileSync2(configPath, JSON.stringify(resolvedConfig, null, 2));
   } catch (writeErr) {
     let configWriteTokenRolledBack = false;
     let configWriteTokenRollbackMsg = "";
@@ -1944,6 +2217,12 @@ function installConnector(options) {
       } catch {
       }
     }
+    if (droidMcpRollback !== null) {
+      try {
+        droidMcpRollback();
+      } catch {
+      }
+    }
     const configWriteTokenSuffix = manifest.requiresToken && tokenEntry !== null ? configWriteTokenRolledBack ? " Token has been rolled back." : ` Token rollback FAILED (${configWriteTokenRollbackMsg}) \u2014 tokens.json may contain an orphaned entry. Manually inspect ~/.remnic/tokens.json and reinstall.` : "";
     return {
       connectorId: options.connectorId,
@@ -1972,13 +2251,13 @@ function removeConnector(connectorId) {
       message: `Removal aborted: invalid connector ID ${JSON.stringify(connectorId)}. Connector IDs must match [A-Za-z0-9][A-Za-z0-9._-]*.`
     };
   }
-  const configPath = path3.join(configDir, `${connectorId}.json`);
+  const configPath = path4.join(configDir, `${connectorId}.json`);
   let codexHomeOverride = null;
   let savedInstallExtension = void 0;
   let configParsed = false;
-  if (connectorId === "codex-cli" && fs3.existsSync(configPath)) {
+  if (connectorId === "codex-cli" && fs4.existsSync(configPath)) {
     try {
-      const parsed = JSON.parse(fs3.readFileSync(configPath, "utf8"));
+      const parsed = JSON.parse(fs4.readFileSync(configPath, "utf8"));
       configParsed = true;
       if (typeof parsed.codexHome === "string" && parsed.codexHome.length > 0) {
         codexHomeOverride = parsed.codexHome;
@@ -1997,9 +2276,9 @@ function removeConnector(connectorId) {
   let savedHermesConfigPath = null;
   const savedPriorHermesConfigPaths = [];
   const savedPriorHermesShimPaths = [];
-  if (connectorId === "hermes" && fs3.existsSync(configPath)) {
+  if (connectorId === "hermes" && fs4.existsSync(configPath)) {
     try {
-      const parsedRaw = JSON.parse(fs3.readFileSync(configPath, "utf8"));
+      const parsedRaw = JSON.parse(fs4.readFileSync(configPath, "utf8"));
       if (parsedRaw === null || typeof parsedRaw !== "object" || Array.isArray(parsedRaw)) {
         throw new Error("hermes.json is not a JSON object");
       }
@@ -2036,7 +2315,7 @@ function removeConnector(connectorId) {
       };
     }
   }
-  if (!fs3.existsSync(configPath)) {
+  if (!fs4.existsSync(configPath)) {
     let staleTokenRevoked = false;
     try {
       staleTokenRevoked = revokeToken(connectorId);
@@ -2053,7 +2332,7 @@ function removeConnector(connectorId) {
   let storedProfile = "default";
   if (connectorId === "hermes") {
     try {
-      const stored = JSON.parse(fs3.readFileSync(configPath, "utf8"));
+      const stored = JSON.parse(fs4.readFileSync(configPath, "utf8"));
       if (typeof stored?.profile === "string") storedProfile = stored.profile;
     } catch {
     }
@@ -2062,7 +2341,7 @@ function removeConnector(connectorId) {
   let weCloneRegistryParseFailed = false;
   if (connectorId === "weclone") {
     try {
-      const stored = JSON.parse(fs3.readFileSync(configPath, "utf8"));
+      const stored = JSON.parse(fs4.readFileSync(configPath, "utf8"));
       if (typeof stored.proxyConfigPath === "string" && stored.proxyConfigPath.length > 0) {
         weCloneProxyConfigPath = stored.proxyConfigPath;
       }
@@ -2076,6 +2355,17 @@ function removeConnector(connectorId) {
       }
     }
   }
+  let droidMcpConfigPath = null;
+  let droidRegistryParseFailed = false;
+  if (connectorId === "droid") {
+    const prov = readDroidMcpProvenance(configPath);
+    droidMcpConfigPath = prov.mcpConfigPath;
+    droidRegistryParseFailed = prov.registryParseFailed;
+  }
+  if (connectorId === "droid" && droidRegistryParseFailed) {
+    console.warn(`[remnic/connectors] removeConnector: droid.json malformed \u2014 aborting. Fix or delete ${configPath} manually and retry.`);
+    return { connectorId, configPath, message: "Removal aborted: droid.json is malformed. Registry config left in place.", status: "skipped", reason: "config-parse-failed" };
+  }
   if (connectorId === "weclone" && weCloneRegistryParseFailed) {
     console.warn(
       "[remnic/connectors] removeConnector: weclone.json is malformed \u2014 aborting removal to preserve provenance. Fix or delete " + configPath + " manually and retry."
@@ -2088,7 +2378,7 @@ function removeConnector(connectorId) {
       reason: "config-parse-failed"
     };
   }
-  if (connectorId === "codex-cli" && fs3.existsSync(configPath) && !configParsed) {
+  if (connectorId === "codex-cli" && fs4.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."
     );
@@ -2131,7 +2421,7 @@ function removeConnector(connectorId) {
     for (const candidate of uniqueCandidates) {
       let needsCleanup = false;
       try {
-        needsCleanup = /^remnic:/m.test(fs3.readFileSync(candidate, "utf8"));
+        needsCleanup = /^remnic:/m.test(fs4.readFileSync(candidate, "utf8"));
       } catch {
         needsCleanup = false;
       }
@@ -2145,8 +2435,8 @@ function removeConnector(connectorId) {
         continue;
       }
       try {
-        fs3.accessSync(candidate, fs3.constants.W_OK);
-        fs3.accessSync(path3.dirname(candidate), fs3.constants.W_OK);
+        fs4.accessSync(candidate, fs4.constants.W_OK);
+        fs4.accessSync(path4.dirname(candidate), fs4.constants.W_OK);
       } catch {
         blocked.push(`${candidate} (not writable)`);
       }
@@ -2161,7 +2451,7 @@ function removeConnector(connectorId) {
     }
   }
   try {
-    fs3.unlinkSync(configPath);
+    fs4.unlinkSync(configPath);
   } catch (unlinkErr) {
     const sanitizedErr = unlinkErr instanceof Error ? unlinkErr.message : String(unlinkErr);
     return {
@@ -2187,14 +2477,14 @@ function removeConnector(connectorId) {
         "WeClone proxy config cleanup skipped: no persisted path found in saved config (likely a legacy install predating proxyConfigPath provenance)."
       );
     } else {
-      const expectedSuffix = path3.join("connectors", "weclone.json");
-      const isSafePath = path3.isAbsolute(weCloneProxyConfigPath) && weCloneProxyConfigPath.endsWith(expectedSuffix);
+      const expectedSuffix = path4.join("connectors", "weclone.json");
+      const isSafePath = path4.isAbsolute(weCloneProxyConfigPath) && weCloneProxyConfigPath.endsWith(expectedSuffix);
       if (!isSafePath) {
         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 (fs3.existsSync(weCloneProxyConfigPath)) {
-            fs3.unlinkSync(weCloneProxyConfigPath);
+          if (fs4.existsSync(weCloneProxyConfigPath)) {
+            fs4.unlinkSync(weCloneProxyConfigPath);
             notes.push(`Removed WeClone proxy config: ${weCloneProxyConfigPath}`);
           }
         } catch (err) {
@@ -2212,6 +2502,23 @@ function removeConnector(connectorId) {
       message: `WeClone remove partially succeeded: ${tokenStatus}, but the proxy config at ${weCloneProxyConfigPath} could not be deleted (${weCloneProxyDeleteFailed}). Manually remove that file \u2014 it may still contain a Remnic daemon bearer token.`
     };
   }
+  let droidMcpDeleteFailed = null;
+  if (connectorId === "droid") {
+    if (droidMcpConfigPath === null) {
+      notes.push("Droid MCP config cleanup skipped: no persisted path found (legacy install).");
+    } else {
+      try {
+        const note = removeDroidMcpEntry(droidMcpConfigPath);
+        if (note) notes.push(note);
+      } catch (err) {
+        droidMcpDeleteFailed = err instanceof Error ? err.message : String(err);
+      }
+    }
+  }
+  if (droidMcpDeleteFailed !== null && droidMcpConfigPath !== null) {
+    const ts = tokenRevoked ? "token was revoked" : "TOKEN REVOCATION ALSO FAILED \u2014 inspect ~/.remnic/tokens.json and revoke manually";
+    return { connectorId, configPath, status: "error", message: `Droid remove partially succeeded: registry config deleted, ${ts}, but the MCP config at ${droidMcpConfigPath} could not be updated (${droidMcpDeleteFailed}). Manually remove the "remnic" entry.` };
+  }
   if (connectorId === "hermes") {
     try {
       const shimCandidates = [];
@@ -2286,17 +2593,17 @@ function sanitizeHermesProfile(profile) {
 function hermesConfigPath(profile) {
   const safeProfile = sanitizeHermesProfile(profile);
   const hermesRoot = resolveHermesRoot();
-  const rootConfigPath = path3.join(hermesRoot, "config.yaml");
-  const profilesRoot = path3.join(hermesRoot, "profiles");
+  const rootConfigPath = path4.join(hermesRoot, "config.yaml");
+  const profilesRoot = path4.join(hermesRoot, "profiles");
   if (safeProfile === "default") {
-    const defaultProfileDir = path3.join(profilesRoot, safeProfile);
-    if (isFile(rootConfigPath) || !fs3.existsSync(rootConfigPath) && !isDirectory(defaultProfileDir)) {
+    const defaultProfileDir = path4.join(profilesRoot, safeProfile);
+    if (isFile(rootConfigPath) || !fs4.existsSync(rootConfigPath) && !isDirectory(defaultProfileDir)) {
       return rootConfigPath;
     }
   }
-  const cfgPath = path3.resolve(profilesRoot, safeProfile, "config.yaml");
-  const rel = path3.relative(profilesRoot, cfgPath);
-  if (rel.startsWith("..") || path3.isAbsolute(rel)) {
+  const cfgPath = path4.resolve(profilesRoot, safeProfile, "config.yaml");
+  const rel = path4.relative(profilesRoot, cfgPath);
+  if (rel.startsWith("..") || path4.isAbsolute(rel)) {
     throw new Error(
       `Invalid Hermes profile path: resolved outside ${profilesRoot}`
     );
@@ -2305,30 +2612,30 @@ function hermesConfigPath(profile) {
 }
 function isDirectory(filePath) {
   try {
-    return fs3.statSync(filePath).isDirectory();
+    return fs4.statSync(filePath).isDirectory();
   } catch {
     return false;
   }
 }
 function isFile(filePath) {
   try {
-    return fs3.statSync(filePath).isFile();
+    return fs4.statSync(filePath).isFile();
   } catch {
     return false;
   }
 }
 function hermesConfigTarget(filePath) {
   try {
-    return fs3.realpathSync.native(filePath);
+    return fs4.realpathSync.native(filePath);
   } catch {
-    return path3.resolve(filePath);
+    return path4.resolve(filePath);
   }
 }
 function sameHermesConfigTarget(leftPath, rightPath) {
   return hermesConfigTarget(leftPath) === hermesConfigTarget(rightPath);
 }
 function hermesDefaultProfileConfigPath() {
-  return path3.join(resolveHermesRoot(), "profiles", "default", "config.yaml");
+  return path4.join(resolveHermesRoot(), "profiles", "default", "config.yaml");
 }
 function hermesConfigCleanupPaths(profile) {
   const cfgPath = hermesConfigPath(profile);
@@ -2383,30 +2690,30 @@ function sanitizeHermesPort(port) {
   }
   return numeric;
 }
-function writeSecretFileSync(filePath, data) {
-  const dir = path3.dirname(filePath);
-  const base = path3.basename(filePath);
-  const tmpPath = path3.join(
+function writeSecretFileSync2(filePath, data) {
+  const dir = path4.dirname(filePath);
+  const base = path4.basename(filePath);
+  const tmpPath = path4.join(
     dir,
     `.${base}.${process.pid}.${Date.now()}.${Math.random().toString(16).slice(2)}.tmp`
   );
   let wroteTemp = false;
   try {
-    fs3.writeFileSync(tmpPath, data, { mode: 384, flag: "wx" });
+    fs4.writeFileSync(tmpPath, data, { mode: 384, flag: "wx" });
     wroteTemp = true;
     try {
-      fs3.chmodSync(tmpPath, 384);
+      fs4.chmodSync(tmpPath, 384);
     } catch {
     }
-    fs3.renameSync(tmpPath, filePath);
+    fs4.renameSync(tmpPath, filePath);
     try {
-      fs3.chmodSync(filePath, 384);
+      fs4.chmodSync(filePath, 384);
     } catch {
     }
   } catch (err) {
     if (wroteTemp) {
       try {
-        fs3.unlinkSync(tmpPath);
+        fs4.unlinkSync(tmpPath);
       } catch {
       }
     }
@@ -2418,7 +2725,7 @@ function upsertHermesConfig(opts) {
 }
 function upsertHermesConfigAt(cfgPath, opts) {
   assertConfigComponentsNotSymlinked(cfgPath);
-  const profileDir = path3.dirname(cfgPath);
+  const profileDir = path4.dirname(cfgPath);
   const safeHost = sanitizeHermesHost(opts.host);
   const safePort = sanitizeHermesPort(opts.port);
   const allowInsecureHttp = opts.allowInsecureHttp ?? false;
@@ -2440,15 +2747,15 @@ function upsertHermesConfigAt(cfgPath, opts) {
     `  token: "${opts.token}"`,
     `  allow_insecure_http: ${allowInsecureHttp}`
   ].join("\n");
-  if (!fs3.existsSync(cfgPath)) {
-    writeSecretFileSync(cfgPath, block + "\n");
+  if (!fs4.existsSync(cfgPath)) {
+    writeSecretFileSync2(cfgPath, block + "\n");
     return { updated: true, skipped: false, configPath: cfgPath, priorContent: null };
   }
-  const raw = fs3.readFileSync(cfgPath, "utf8");
+  const raw = fs4.readFileSync(cfgPath, "utf8");
   const hasRemnicBlock = /^remnic:/m.test(raw);
   if (!hasRemnicBlock) {
     const separator = raw.endsWith("\n") ? "\n" : "\n\n";
-    writeSecretFileSync(cfgPath, raw + separator + block + "\n");
+    writeSecretFileSync2(cfgPath, raw + separator + block + "\n");
     return { updated: true, skipped: false, configPath: cfgPath, priorContent: raw };
   }
   const splitLines = raw.split("\n");
@@ -2503,7 +2810,7 @@ function upsertHermesConfigAt(cfgPath, opts) {
     if (!written.token) newLines.push(`  token: "${opts.token}"`);
     if (!written.allowInsecureHttp) newLines.push(`  allow_insecure_http: ${allowInsecureHttp}`);
   }
-  writeSecretFileSync(cfgPath, newLines.join("\n") + "\n");
+  writeSecretFileSync2(cfgPath, newLines.join("\n") + "\n");
   return { updated: true, skipped: false, configPath: cfgPath, priorContent: raw };
 }
 function removeHermesConfig(opts) {
@@ -2592,7 +2899,7 @@ function removeHermesConfigFile(cfgPath) {
       configPath: cfgPath
     };
   }
-  if (!fs3.existsSync(cfgPath)) {
+  if (!fs4.existsSync(cfgPath)) {
     return {
       updated: false,
       skipped: true,
@@ -2600,7 +2907,7 @@ function removeHermesConfigFile(cfgPath) {
       configPath: cfgPath
     };
   }
-  const raw = fs3.readFileSync(cfgPath, "utf8");
+  const raw = fs4.readFileSync(cfgPath, "utf8");
   if (!/^remnic:/m.test(raw)) {
     return {
       updated: false,
@@ -2629,7 +2936,7 @@ function removeHermesConfigFile(cfgPath) {
   while (newLines.length > 0 && newLines[newLines.length - 1]?.trim() === "") {
     newLines.pop();
   }
-  writeSecretFileSync(cfgPath, newLines.length > 0 ? newLines.join("\n") + "\n" : "");
+  writeSecretFileSync2(cfgPath, newLines.length > 0 ? newLines.join("\n") + "\n" : "");
   return { updated: true, skipped: false, configPath: cfgPath };
 }
 async function doctorConnector(connectorId) {
@@ -2642,15 +2949,15 @@ async function doctorConnector(connectorId) {
       healthy: false
     };
   }
-  const configPath = path3.join(getConnectorsDir(), `${connectorId}.json`);
+  const configPath = path4.join(getConnectorsDir(), `${connectorId}.json`);
   const checks = [];
   checks.push({
     name: "Config file",
-    ok: fs3.existsSync(configPath),
+    ok: fs4.existsSync(configPath),
     detail: configPath
   });
   try {
-    const raw = fs3.readFileSync(configPath, "utf8");
+    const raw = fs4.readFileSync(configPath, "utf8");
     JSON.parse(raw);
     checks.push({ name: "Config valid", ok: true, detail: "OK" });
   } catch (e) {
@@ -2674,12 +2981,15 @@ async function doctorConnector(connectorId) {
   }
   const memoryDir = instance.config.memoryDir;
   if (memoryDir) {
-    if (fs3.existsSync(memoryDir)) {
+    if (fs4.existsSync(memoryDir)) {
       checks.push({ name: "Memory directory", ok: true, detail: memoryDir });
     } else {
       checks.push({ name: "Memory directory", ok: false, detail: `Not found: ${memoryDir}` });
     }
   }
+  if (connectorId === "droid") {
+    checks.push(droidMcpDoctorCheck(instance.config.factoryMcpPath));
+  }
   const healthy = checks.every((c) => c.ok);
   return { connectorId, checks, healthy };
 }
@@ -2688,32 +2998,32 @@ var CODEX_EXTENSIONS_SUBDIR = "memories_extensions";
 var REMNIC_EXTENSION_DIR_NAME = "remnic";
 function resolveCodexHome(override) {
   if (override && typeof override === "string" && override.trim().length > 0) {
-    return path3.resolve(override.trim());
+    return path4.resolve(override.trim());
   }
   const envHome = readEnvVar("CODEX_HOME");
   if (envHome && envHome.trim().length > 0) {
-    return path3.resolve(envHome.trim());
+    return path4.resolve(envHome.trim());
   }
   const home = readEnvVar("HOME") || readEnvVar("USERPROFILE") || resolveHomeDir();
-  return path3.resolve(home, ".codex");
+  return path4.resolve(home, ".codex");
 }
 function resolveCodexMemoryExtensionPaths(codexHomeOverride) {
   const codexHome = resolveCodexHome(codexHomeOverride);
-  const memoriesDir = path3.join(codexHome, CODEX_MEMORIES_SUBDIR);
-  const extensionsRoot = path3.join(path3.dirname(memoriesDir), CODEX_EXTENSIONS_SUBDIR);
-  const remnicExtensionDir = path3.join(extensionsRoot, REMNIC_EXTENSION_DIR_NAME);
+  const memoriesDir = path4.join(codexHome, CODEX_MEMORIES_SUBDIR);
+  const extensionsRoot = path4.join(path4.dirname(memoriesDir), CODEX_EXTENSIONS_SUBDIR);
+  const remnicExtensionDir = path4.join(extensionsRoot, REMNIC_EXTENSION_DIR_NAME);
   return { codexHome, memoriesDir, extensionsRoot, remnicExtensionDir };
 }
 function locatePluginCodexExtensionSource(override) {
   if (override && typeof override === "string" && override.trim().length > 0) {
-    const resolved = path3.resolve(override.trim());
-    if (fs3.existsSync(resolved) && fs3.statSync(resolved).isDirectory()) {
+    const resolved = path4.resolve(override.trim());
+    if (fs4.existsSync(resolved) && fs4.statSync(resolved).isDirectory()) {
       return resolved;
     }
     throw new Error(`Codex extension source directory not found: ${resolved}`);
   }
-  const EXTENSION_SUBPATH = path3.join("memories_extensions", "remnic");
-  const WORKSPACE_RELATIVE_PATH = path3.join(
+  const EXTENSION_SUBPATH = path4.join("memories_extensions", "remnic");
+  const WORKSPACE_RELATIVE_PATH = path4.join(
     "packages",
     "plugin-codex",
     "memories_extensions",
@@ -2721,15 +3031,15 @@ function locatePluginCodexExtensionSource(override) {
   );
   const searched = [];
   try {
-    const moduleDir = path3.dirname(fileURLToPath(import.meta.url));
-    const bundledCandidate = path3.join(moduleDir, "codex");
+    const moduleDir = path4.dirname(fileURLToPath(import.meta.url));
+    const bundledCandidate = path4.join(moduleDir, "codex");
     searched.push(bundledCandidate);
-    if (fs3.existsSync(bundledCandidate) && fs3.statSync(bundledCandidate).isDirectory()) {
+    if (fs4.existsSync(bundledCandidate) && fs4.statSync(bundledCandidate).isDirectory()) {
       return bundledCandidate;
     }
-    const distConnectorsCandidate = path3.join(moduleDir, "connectors", "codex");
+    const distConnectorsCandidate = path4.join(moduleDir, "connectors", "codex");
     searched.push(distConnectorsCandidate);
-    if (fs3.existsSync(distConnectorsCandidate) && fs3.statSync(distConnectorsCandidate).isDirectory()) {
+    if (fs4.existsSync(distConnectorsCandidate) && fs4.statSync(distConnectorsCandidate).isDirectory()) {
       return distConnectorsCandidate;
     }
   } catch {
@@ -2737,19 +3047,19 @@ function locatePluginCodexExtensionSource(override) {
   try {
     const requireFromHere = createRequire(import.meta.url);
     const pluginPkgJsonPath = requireFromHere.resolve("@remnic/plugin-codex/package.json");
-    const pluginPkgRoot = path3.dirname(pluginPkgJsonPath);
-    const candidate = path3.join(pluginPkgRoot, EXTENSION_SUBPATH);
+    const pluginPkgRoot = path4.dirname(pluginPkgJsonPath);
+    const candidate = path4.join(pluginPkgRoot, EXTENSION_SUBPATH);
     searched.push(candidate);
-    if (fs3.existsSync(candidate) && fs3.statSync(candidate).isDirectory()) {
+    if (fs4.existsSync(candidate) && fs4.statSync(candidate).isDirectory()) {
       return candidate;
     }
   } catch {
   }
   try {
-    const moduleDir = path3.dirname(fileURLToPath(import.meta.url));
+    const moduleDir = path4.dirname(fileURLToPath(import.meta.url));
     let dir = moduleDir;
     for (let depth = 0; depth < 8; depth += 1) {
-      const candidate = path3.join(
+      const candidate = path4.join(
         dir,
         "node_modules",
         "@remnic",
@@ -2757,10 +3067,10 @@ function locatePluginCodexExtensionSource(override) {
         EXTENSION_SUBPATH
       );
       searched.push(candidate);
-      if (fs3.existsSync(candidate) && fs3.statSync(candidate).isDirectory()) {
+      if (fs4.existsSync(candidate) && fs4.statSync(candidate).isDirectory()) {
         return candidate;
       }
-      const parent = path3.dirname(dir);
+      const parent = path4.dirname(dir);
       if (parent === dir) break;
       dir = parent;
     }
@@ -2768,19 +3078,19 @@ function locatePluginCodexExtensionSource(override) {
   }
   const anchors = [];
   try {
-    anchors.push(path3.dirname(fileURLToPath(import.meta.url)));
+    anchors.push(path4.dirname(fileURLToPath(import.meta.url)));
   } catch {
   }
   anchors.push(process.cwd());
   for (const anchor of anchors) {
     let dir = anchor;
     for (let depth = 0; depth < 12; depth += 1) {
-      const candidate = path3.join(dir, WORKSPACE_RELATIVE_PATH);
+      const candidate = path4.join(dir, WORKSPACE_RELATIVE_PATH);
       searched.push(candidate);
-      if (fs3.existsSync(candidate) && fs3.statSync(candidate).isDirectory()) {
+      if (fs4.existsSync(candidate) && fs4.statSync(candidate).isDirectory()) {
         return candidate;
       }
-      const parent = path3.dirname(dir);
+      const parent = path4.dirname(dir);
       if (parent === dir) break;
       dir = parent;
     }
@@ -2791,15 +3101,15 @@ function locatePluginCodexExtensionSource(override) {
 }
 function copyDirRecursiveSync(src, dest) {
   let count = 0;
-  fs3.mkdirSync(dest, { recursive: true });
-  const entries = fs3.readdirSync(src, { withFileTypes: true });
+  fs4.mkdirSync(dest, { recursive: true });
+  const entries = fs4.readdirSync(src, { withFileTypes: true });
   for (const entry of entries) {
-    const from = path3.join(src, entry.name);
-    const to = path3.join(dest, entry.name);
+    const from = path4.join(src, entry.name);
+    const to = path4.join(dest, entry.name);
     if (entry.isDirectory()) {
       count += copyDirRecursiveSync(from, to);
     } else if (entry.isFile()) {
-      fs3.copyFileSync(from, to);
+      fs4.copyFileSync(from, to);
       count += 1;
     }
   }
@@ -2808,29 +3118,29 @@ function copyDirRecursiveSync(src, dest) {
 function installCodexMemoryExtension(options = {}) {
   const paths = resolveCodexMemoryExtensionPaths(options.codexHome ?? null);
   const sourceDir = locatePluginCodexExtensionSource(options.sourceDir ?? null);
-  fs3.mkdirSync(paths.extensionsRoot, { recursive: true });
+  fs4.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 = fs3.readdirSync(paths.extensionsRoot);
+    const existingEntries = fs4.readdirSync(paths.extensionsRoot);
     for (const entry of existingEntries) {
       if (!entry.startsWith(tmpPrefix)) continue;
-      const stalePath = path3.join(paths.extensionsRoot, entry);
+      const stalePath = path4.join(paths.extensionsRoot, entry);
       try {
-        const stat = fs3.statSync(stalePath);
+        const stat = fs4.statSync(stalePath);
         const ageMs = now - stat.mtimeMs;
         if (ageMs < STALE_TMP_THRESHOLD_MS) {
           continue;
         }
-        fs3.rmSync(stalePath, { recursive: true, force: true });
+        fs4.rmSync(stalePath, { recursive: true, force: true });
       } catch {
       }
     }
   } catch {
   }
   const tmpName = `${tmpPrefix}${process.pid}-${Date.now()}`;
-  const tmpDir = path3.join(paths.extensionsRoot, tmpName);
+  const tmpDir = path4.join(paths.extensionsRoot, tmpName);
   let filesCopied = 0;
   let commitFn = () => {
   };
@@ -2839,16 +3149,16 @@ function installCodexMemoryExtension(options = {}) {
   try {
     filesCopied = copyDirRecursiveSync(sourceDir, tmpDir);
     const backupDir = `${paths.remnicExtensionDir}.bak-${Date.now()}`;
-    const hadExisting = fs3.existsSync(paths.remnicExtensionDir);
+    const hadExisting = fs4.existsSync(paths.remnicExtensionDir);
     if (hadExisting) {
-      fs3.renameSync(paths.remnicExtensionDir, backupDir);
+      fs4.renameSync(paths.remnicExtensionDir, backupDir);
     }
     try {
-      fs3.renameSync(tmpDir, paths.remnicExtensionDir);
+      fs4.renameSync(tmpDir, paths.remnicExtensionDir);
     } catch (renameErr) {
       if (hadExisting) {
         try {
-          fs3.renameSync(backupDir, paths.remnicExtensionDir);
+          fs4.renameSync(backupDir, paths.remnicExtensionDir);
         } catch {
         }
       }
@@ -2857,7 +3167,7 @@ function installCodexMemoryExtension(options = {}) {
     commitFn = () => {
       if (hadExisting) {
         try {
-          fs3.rmSync(backupDir, { recursive: true, force: true });
+          fs4.rmSync(backupDir, { recursive: true, force: true });
         } catch {
         }
       }
@@ -2865,31 +3175,31 @@ function installCodexMemoryExtension(options = {}) {
     rollbackFn = () => {
       if (hadExisting) {
         try {
-          if (fs3.existsSync(paths.remnicExtensionDir)) {
-            fs3.rmSync(paths.remnicExtensionDir, { recursive: true, force: true });
+          if (fs4.existsSync(paths.remnicExtensionDir)) {
+            fs4.rmSync(paths.remnicExtensionDir, { recursive: true, force: true });
           }
-          fs3.renameSync(backupDir, paths.remnicExtensionDir);
+          fs4.renameSync(backupDir, paths.remnicExtensionDir);
         } catch {
         }
       } else {
         try {
-          if (fs3.existsSync(paths.remnicExtensionDir)) {
-            fs3.rmSync(paths.remnicExtensionDir, { recursive: true, force: true });
+          if (fs4.existsSync(paths.remnicExtensionDir)) {
+            fs4.rmSync(paths.remnicExtensionDir, { recursive: true, force: true });
           }
         } catch {
         }
       }
     };
   } catch (err) {
-    if (fs3.existsSync(tmpDir)) {
+    if (fs4.existsSync(tmpDir)) {
       try {
-        fs3.rmSync(tmpDir, { recursive: true, force: true });
+        fs4.rmSync(tmpDir, { recursive: true, force: true });
       } catch {
       }
     }
     throw err;
   }
-  const instructionsPath = path3.join(paths.remnicExtensionDir, "instructions.md");
+  const instructionsPath = path4.join(paths.remnicExtensionDir, "instructions.md");
   return {
     ...paths,
     instructionsPath,
@@ -2901,8 +3211,8 @@ function installCodexMemoryExtension(options = {}) {
 function removeCodexMemoryExtension(options = {}) {
   const paths = resolveCodexMemoryExtensionPaths(options.codexHome ?? null);
   let removed = false;
-  if (fs3.existsSync(paths.remnicExtensionDir)) {
-    fs3.rmSync(paths.remnicExtensionDir, { recursive: true, force: true });
+  if (fs4.existsSync(paths.remnicExtensionDir)) {
+    fs4.rmSync(paths.remnicExtensionDir, { recursive: true, force: true });
     removed = true;
   }
   return { ...paths, removed };
@@ -2913,11 +3223,11 @@ function resolveWeCloneProxyConfigPath() {
   const remnicHome = readEnvVar("REMNIC_HOME");
   const override = remnicHome && remnicHome.length > 0 ? remnicHome : readEnvVar("ENGRAM_HOME");
   if (override && override.length > 0) {
-    return path3.resolve(expandTildePath(override), "connectors", WECLONE_PROXY_CONFIG_FILENAME);
+    return path4.resolve(expandTildePath(override), "connectors", WECLONE_PROXY_CONFIG_FILENAME);
   }
   const envHome = readEnvVar("HOME");
-  const home = envHome && envHome.length > 0 ? envHome : os.homedir();
-  return path3.resolve(
+  const home = envHome && envHome.length > 0 ? envHome : os2.homedir();
+  return path4.resolve(
     home,
     WECLONE_PROXY_CONFIG_DIRNAME,
     "connectors",
@@ -2926,8 +3236,8 @@ function resolveWeCloneProxyConfigPath() {
 }
 function readWeCloneProxyConfigIfExists(configPath) {
   try {
-    if (!fs3.existsSync(configPath)) return null;
-    return fs3.readFileSync(configPath, "utf8");
+    if (!fs4.existsSync(configPath)) return null;
+    return fs4.readFileSync(configPath, "utf8");
   } catch {
     return null;
   }
@@ -3047,6 +3357,10 @@ function buildWeCloneProxyConfig(args) {
 }
 
 export {
+  DROID_CONNECTOR_MANIFEST,
+  resolveFactoryMcpPath,
+  upsertFactoryMcpRemnicEntry,
+  removeFactoryMcpRemnicEntry,
   MARKETPLACE_SCHEMA_VERSION,
   MARKETPLACE_MANIFEST_FILENAME,
   generateMarketplaceManifest,
@@ -3074,4 +3388,4 @@ export {
   resolveWeCloneProxyConfigPath,
   buildWeCloneProxyConfig
 };
-//# sourceMappingURL=chunk-ANMIOQPU.js.map
+//# sourceMappingURL=chunk-4XN35YQD.js.map