@remnic/core 9.69.56 → 9.69.57

package/dist/chunk-GK6NOQE6.js

@@ -0,0 +1,3400 @@
+import {
+  buildTokenEntry,
+  commitTokenEntry,
+  generateToken,
+  loadTokenStore,
+  revokeToken,
+  saveTokenStore
+} from "./chunk-754XN6LX.js";
+import {
+  getConnectorsDir,
+  getRegistryPath
+} from "./chunk-ADXCCZL2.js";
+import {
+  coerceBool,
+  coerceInstallExtension
+} from "./chunk-PQVCH2AE.js";
+import {
+  httpProtocolForHost
+} from "./chunk-C5C7IJ4Q.js";
+import {
+  resolveConversationContextCapabilities
+} from "./chunk-JUOZ62Y7.js";
+import {
+  launchProcessSync
+} from "./chunk-ZEFVK7XC.js";
+import {
+  expandTildePath
+} from "./chunk-6KH5NLQS.js";
+import {
+  mergeEnv,
+  readEnvVar,
+  resolveHomeDir
+} from "./chunk-P2QRMMVQ.js";
+import {
+  log
+} from "./chunk-3WCASNQZ.js";
+
+// src/connectors/index.ts
+import fs4 from "fs";
+import path4 from "path";
+import os2 from "os";
+import { createRequire } from "module";
+import { fileURLToPath } from "url";
+
+// src/runtime/daemon-health.ts
+var HEALTH_EXIT_OK = 0;
+var HEALTH_EXIT_UNAUTHORIZED = 2;
+function checkDaemonHealth(host, port, authToken, allowInsecureHttp = false) {
+  try {
+    const safePort = Math.trunc(Number(port));
+    if (!Number.isFinite(safePort) || safePort < 1 || safePort > 65535) return false;
+    const bareHost = host.startsWith("[") && host.endsWith("]") ? host.slice(1, -1) : host;
+    const script = [
+      "const env = process['env'];",
+      "const protocol = env.REMNIC_HEALTH_PROTOCOL;",
+      "if (protocol !== 'http' && protocol !== 'https') process.exit(1);",
+      "const transport = require(protocol);",
+      "const headers = {};",
+      "if (env.REMNIC_HEALTH_TOKEN) headers['authorization'] = 'Bearer ' + env.REMNIC_HEALTH_TOKEN;",
+      "const req = transport.get({",
+      "  host: env.REMNIC_HEALTH_HOST,",
+      "  port: parseInt(env.REMNIC_HEALTH_PORT, 10),",
+      "  path: '/engram/v1/health', headers, timeout: 3000,",
+      "}, (res) => { process.exit(res.statusCode === 200 ? 0 : res.statusCode === 401 ? 2 : 1); });",
+      "req.on('error', () => process.exit(1));",
+      "req.on('timeout', () => { req.destroy(); process.exit(1); });"
+    ].join("\n");
+    const env = mergeEnv({
+      REMNIC_HEALTH_HOST: bareHost,
+      REMNIC_HEALTH_PORT: String(safePort),
+      REMNIC_HEALTH_PROTOCOL: httpProtocolForHost(host, allowInsecureHttp)
+    });
+    if (authToken) env.REMNIC_HEALTH_TOKEN = authToken;
+    const launchOptions = { timeout: 4e3, env };
+    const result = launchProcessSync(process.execPath, ["-e", script], launchOptions);
+    if (result.status === HEALTH_EXIT_OK) return true;
+    if (result.status !== HEALTH_EXIT_UNAUTHORIZED) return false;
+    console.error("[remnic/connectors] health probe got 401 \u2014 retrying after token cache TTL...");
+    launchProcessSync(process.execPath, ["-e", "setTimeout(() => {}, 6000)"], { timeout: 7e3, env: {} });
+    const retry = launchProcessSync(process.execPath, ["-e", script], launchOptions);
+    return retry.status === HEALTH_EXIT_OK;
+  } catch {
+    return false;
+  }
+}
+
+// src/connectors/hermes-shim.ts
+import fs from "fs";
+import path from "path";
+var HERMES_SHIM_MARKER = "generated by `remnic connectors install hermes`";
+function resolveHermesRoot() {
+  const envHome = readEnvVar("HERMES_HOME");
+  if (typeof envHome === "string" && envHome.trim().length > 0) {
+    const expanded = path.resolve(expandTildePath(envHome.trim()));
+    try {
+      const stat = fs.lstatSync(expanded);
+      if (stat.isSymbolicLink()) {
+        throw new Error(`HERMES_HOME must not be a symbolic link: ${expanded}`);
+      }
+      if (!stat.isDirectory()) {
+        throw new Error(`HERMES_HOME is not a directory: ${expanded}`);
+      }
+    } catch (err) {
+      if (err.code !== "ENOENT") {
+        throw err;
+      }
+    }
+    return expanded;
+  }
+  if (process.platform === "win32") {
+    const localAppData = (readEnvVar("LOCALAPPDATA") ?? "").trim();
+    const base = localAppData.length > 0 ? path.resolve(localAppData) : path.join(resolveHomeDir(), "AppData", "Local");
+    return resolveDefaultRoot(path.join(base, "hermes"));
+  }
+  return resolveDefaultRoot(path.resolve(resolveHomeDir(), ".hermes"));
+}
+function resolveDefaultRoot(candidate) {
+  try {
+    return fs.realpathSync.native(candidate);
+  } catch {
+    return candidate;
+  }
+}
+function hermesShimPath() {
+  return path.join(resolveHermesRoot(), "plugins", "remnic", "__init__.py");
+}
+function writePlainFileAtomicSync(filePath, data) {
+  const dir = path.dirname(filePath);
+  const base = path.basename(filePath);
+  const tmpPath = path.join(dir, `.${base}.${process.pid}.${Date.now()}.${Math.random().toString(16).slice(2)}.tmp`);
+  let wroteTemp = false;
+  try {
+    fs.writeFileSync(tmpPath, data, { mode: 420, flag: "wx" });
+    wroteTemp = true;
+    fs.renameSync(tmpPath, filePath);
+    try {
+      fs.chmodSync(filePath, 420);
+    } catch {
+    }
+  } catch (err) {
+    if (wroteTemp) {
+      try {
+        fs.unlinkSync(tmpPath);
+      } catch {
+      }
+    }
+    throw err;
+  }
+}
+function assertShimComponentsNotSymlinked(shimPath) {
+  const remnicDir = path.dirname(shimPath);
+  const pluginsDir = path.dirname(remnicDir);
+  for (const component of [pluginsDir, remnicDir, shimPath]) {
+    let isLink = false;
+    try {
+      isLink = fs.lstatSync(component).isSymbolicLink();
+    } catch {
+      continue;
+    }
+    if (isLink) {
+      throw new Error(`refusing to operate through a symbolic link: ${component}`);
+    }
+  }
+}
+function materializeHermesShim(shimPath) {
+  assertShimComponentsNotSymlinked(shimPath);
+  if (fs.existsSync(shimPath)) {
+    let existing;
+    try {
+      existing = fs.readFileSync(shimPath, "utf8");
+    } catch (readErr) {
+      throw new Error(
+        `cannot read existing shim at ${shimPath}: ${readErr instanceof Error ? readErr.message : String(readErr)}`
+      );
+    }
+    if (!existing.includes(HERMES_SHIM_MARKER)) {
+      return {
+        note: `Hermes plugin shim already exists and was NOT generated by Remnic \u2014 left untouched: ${shimPath}. If the provider is not discovered, ensure that file imports remnic_hermes.register AND contains the literal text register_memory_provider (or MemoryProvider) \u2014 Hermes' discovery text-scan skips the directory without it.`,
+        wrote: false
+      };
+    }
+  }
+  fs.mkdirSync(path.dirname(shimPath), { recursive: true });
+  const content = [
+    `"""Remnic memory provider shim for Hermes Agent (${HERMES_SHIM_MARKER}).`,
+    "",
+    "Hermes memory-provider discovery calls register(collector);",
+    "collector.register_memory_provider() receives the provider.",
+    `"""`,
+    "",
+    "from remnic_hermes import register  # noqa: F401  (register() loads Hermes config itself)",
+    ""
+  ].join("\n");
+  writePlainFileAtomicSync(shimPath, content);
+  return { note: `Materialized Hermes plugin shim: ${shimPath}`, wrote: true };
+}
+function reconcileHermesShim(priorPersistedPath) {
+  const notes = [];
+  let target = null;
+  let materialized = false;
+  let createdNew = false;
+  try {
+    target = hermesShimPath();
+    const existedBefore = fs.existsSync(target);
+    const result = materializeHermesShim(target);
+    notes.push(result.note);
+    materialized = result.wrote;
+    createdNew = result.wrote && !existedBefore;
+  } catch (shimErr) {
+    const shimPathHint = target ?? "<hermesRoot>/plugins/remnic/__init__.py";
+    notes.push(
+      `Note: could not materialize the Hermes plugin shim (${shimErr instanceof Error ? shimErr.message : String(shimErr)}). Create ${shimPathHint} manually with exactly these two lines:
+    """Remnic memory provider shim. Calls collector.register_memory_provider()."""
+    from remnic_hermes import register`
+    );
+  }
+  if (!materialized || target === null) {
+    return {
+      notes,
+      persistPath: priorPersistedPath,
+      materializedAt: null,
+      createdNew: false,
+      priorCleanedAt: null
+    };
+  }
+  const confirmedTarget = target;
+  let priorCleanedAt = null;
+  if (priorPersistedPath !== null && !sameShimTarget(priorPersistedPath, confirmedTarget)) {
+    try {
+      const stale = removeHermesShim([priorPersistedPath]);
+      if (stale.notes.length > 0) {
+        notes.push(`Cleaned prior-install shim: ${stale.notes.join("; ")}`);
+      }
+      priorCleanedAt = stale.removedPaths.includes(priorPersistedPath) ? priorPersistedPath : null;
+    } catch {
+      notes.push(
+        `Note: could not clean the prior-install Hermes plugin shim at ${priorPersistedPath} \u2014 remove it manually if present.`
+      );
+    }
+  }
+  return { notes, persistPath: target, materializedAt: target, createdNew, priorCleanedAt };
+}
+function sameShimTarget(leftPath, rightPath) {
+  return resolveShimTarget(leftPath) === resolveShimTarget(rightPath);
+}
+function resolveShimTarget(candidate) {
+  try {
+    return fs.realpathSync.native(candidate);
+  } catch {
+    return path.resolve(candidate);
+  }
+}
+function removeHermesShim(candidatePaths) {
+  const notes = [];
+  const removedPaths = [];
+  for (const shimPath of new Set(candidatePaths)) {
+    if (!isPlausibleHermesShimPath(shimPath)) {
+      continue;
+    }
+    try {
+      assertShimComponentsNotSymlinked(shimPath);
+    } catch {
+      notes.push(`Hermes plugin shim left untouched (symlinked path component): ${shimPath}`);
+      continue;
+    }
+    if (!fs.existsSync(shimPath)) {
+      continue;
+    }
+    let content;
+    try {
+      content = fs.readFileSync(shimPath, "utf8");
+    } catch {
+      notes.push(`Hermes plugin shim left untouched (unreadable): ${shimPath}`);
+      continue;
+    }
+    if (!content.includes(HERMES_SHIM_MARKER)) {
+      notes.push(`Hermes plugin shim left untouched (not Remnic-generated): ${shimPath}`);
+      continue;
+    }
+    try {
+      fs.unlinkSync(shimPath);
+    } catch (unlinkErr) {
+      notes.push(
+        `Hermes plugin shim could not be removed (${unlinkErr instanceof Error ? unlinkErr.message : String(unlinkErr)}): ${shimPath} \u2014 remove it manually or re-run after fixing permissions.`
+      );
+      continue;
+    }
+    removedPaths.push(shimPath);
+    try {
+      fs.rmdirSync(path.dirname(shimPath));
+    } catch {
+    }
+    notes.push(`Removed Hermes plugin shim: ${shimPath}`);
+  }
+  return { removedPaths, notes };
+}
+function isPlausibleHermesShimPath(candidate) {
+  if (typeof candidate !== "string" || candidate.length === 0 || !path.isAbsolute(candidate)) {
+    return false;
+  }
+  const dir = path.dirname(candidate);
+  return path.basename(candidate) === "__init__.py" && path.basename(dir) === "remnic" && path.basename(path.dirname(dir)) === "plugins";
+}
+function isPlausibleHermesConfigPath(candidate) {
+  if (typeof candidate !== "string" || candidate.length === 0 || !path.isAbsolute(candidate)) {
+    return false;
+  }
+  if (path.basename(candidate) !== "config.yaml") {
+    return false;
+  }
+  const dir = path.dirname(candidate);
+  const dirName = path.basename(dir).toLowerCase();
+  if (dirName === ".hermes" || dirName === "hermes") {
+    return true;
+  }
+  if (path.basename(path.dirname(dir)) === "profiles") {
+    return true;
+  }
+  if (["plugins", "profiles"].some((sibling) => {
+    try {
+      return fs.statSync(path.join(dir, sibling)).isDirectory();
+    } catch {
+      return false;
+    }
+  })) {
+    return true;
+  }
+  try {
+    const stat = fs.statSync(candidate);
+    if (!stat.isFile() || stat.size > 1024 * 1024) {
+      return false;
+    }
+    return /^remnic:/m.test(fs.readFileSync(candidate, "utf8"));
+  } catch {
+    return false;
+  }
+}
+function survivingMarkerShims(candidates, excludeTarget) {
+  const survivors = [];
+  for (const candidate of new Set(candidates)) {
+    if (!isPlausibleHermesShimPath(candidate)) {
+      continue;
+    }
+    if (excludeTarget !== null && sameShimTarget(candidate, excludeTarget)) {
+      continue;
+    }
+    if (survivors.some((kept) => sameShimTarget(kept, candidate))) {
+      continue;
+    }
+    let carriesMarker = false;
+    try {
+      carriesMarker = fs.readFileSync(candidate, "utf8").includes(HERMES_SHIM_MARKER);
+    } catch {
+      carriesMarker = false;
+    }
+    if (carriesMarker) {
+      survivors.push(candidate);
+    }
+  }
+  return survivors;
+}
+function assertConfigComponentsNotSymlinked(cfgPath) {
+  const dir = path.dirname(cfgPath);
+  const components = [cfgPath, dir];
+  const grandparent = path.dirname(dir);
+  if (path.basename(grandparent) === "profiles") {
+    components.push(grandparent);
+  }
+  for (const component of components) {
+    let isLink = false;
+    try {
+      isLink = fs.lstatSync(component).isSymbolicLink();
+    } catch {
+      continue;
+    }
+    if (isLink) {
+      throw new Error(`refusing to operate through a symbolic link: ${component}`);
+    }
+  }
+}
+
+// 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/prime-agent.ts
+var PRIME_AGENT_CONNECTOR_MANIFEST = {
+  id: "prime-agent",
+  name: "Prime Agent",
+  version: "1.0.0",
+  description: "Prime Agent \u2014 Pi-fork coding agent; native extension for recall, observe, MCP tools, and compaction coordination",
+  capabilities: {
+    observe: true,
+    recall: true,
+    store: true,
+    search: true,
+    entities: true,
+    realtimeSync: true,
+    batch: true,
+    maxBudgetChars: 32e3,
+    connectionType: "http"
+  },
+  configSchema: {
+    remnicDaemonUrl: "URL of the Remnic daemon (default: http://127.0.0.1:4318)",
+    namespace: "Optional namespace",
+    installExtension: "Install the Prime Agent extension into ~/.prime/agent/extensions/remnic (default: true)"
+  },
+  author: "Remnic",
+  tags: ["official", "ai", "prime-agent", "pi", "coding-agent"],
+  requiresToken: true
+};
+
+// 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"]);
+function generateMarketplaceManifest(options) {
+  const version = options?.packageVersion ?? readPackageVersion() ?? "0.0.0";
+  return {
+    version: MARKETPLACE_SCHEMA_VERSION,
+    name: "remnic",
+    description: "Remnic: Local-first AI memory with semantic search and consolidation",
+    plugins: [
+      {
+        name: "remnic",
+        version,
+        description: "Persistent memory plugin for Codex CLI",
+        repository: "joshuaswarren/remnic",
+        installType: "github",
+        entry: "packages/plugin-codex",
+        configSchema: "openclaw.plugin.json"
+      }
+    ]
+  };
+}
+function validateMarketplaceManifest(manifest) {
+  const validation = checkMarketplaceManifest(manifest);
+  if (!validation.valid) {
+    throw new Error(
+      `Invalid marketplace manifest: ${validation.errors.join("; ")}`
+    );
+  }
+  return manifest;
+}
+function checkMarketplaceManifest(manifest) {
+  const errors = [];
+  if (typeof manifest !== "object" || manifest === null) {
+    return { valid: false, errors: ["manifest must be a non-null object"] };
+  }
+  const obj = manifest;
+  if (obj.version !== MARKETPLACE_SCHEMA_VERSION) {
+    errors.push(`version must be ${MARKETPLACE_SCHEMA_VERSION}, got ${JSON.stringify(obj.version)}`);
+  }
+  if (typeof obj.name !== "string" || obj.name.trim().length === 0) {
+    errors.push("name must be a non-empty string");
+  }
+  if (typeof obj.description !== "string" || obj.description.trim().length === 0) {
+    errors.push("description must be a non-empty string");
+  }
+  if (!Array.isArray(obj.plugins)) {
+    errors.push("plugins must be an array");
+  } else if (obj.plugins.length === 0) {
+    errors.push("plugins must contain at least one entry");
+  } else {
+    for (let i = 0; i < obj.plugins.length; i++) {
+      const plugin = obj.plugins[i];
+      const prefix = `plugins[${i}]`;
+      if (typeof plugin !== "object" || plugin === null) {
+        errors.push(`${prefix} must be a non-null object`);
+        continue;
+      }
+      if (typeof plugin.name !== "string" || plugin.name.trim().length === 0) {
+        errors.push(`${prefix}.name must be a non-empty string`);
+      }
+      if (typeof plugin.version !== "string" || plugin.version.trim().length === 0) {
+        errors.push(`${prefix}.version must be a non-empty string`);
+      }
+      if (typeof plugin.description !== "string" || plugin.description.trim().length === 0) {
+        errors.push(`${prefix}.description must be a non-empty string`);
+      }
+      if (typeof plugin.repository !== "string" || plugin.repository.trim().length === 0) {
+        errors.push(`${prefix}.repository must be a non-empty string`);
+      }
+      if (typeof plugin.installType !== "string" || !VALID_INSTALL_TYPES.has(plugin.installType)) {
+        errors.push(
+          `${prefix}.installType must be one of: ${[...VALID_INSTALL_TYPES].join(", ")}; got ${JSON.stringify(plugin.installType)}`
+        );
+      }
+      if ("manifestUrl" in plugin && plugin.manifestUrl !== void 0) {
+        if (typeof plugin.manifestUrl !== "string" || plugin.manifestUrl.trim().length === 0) {
+          errors.push(`${prefix}.manifestUrl must be a non-empty string when provided`);
+        }
+      }
+      if ("entry" in plugin && plugin.entry !== void 0) {
+        if (typeof plugin.entry !== "string" || plugin.entry.trim().length === 0) {
+          errors.push(`${prefix}.entry must be a non-empty string when provided`);
+        }
+      }
+      if ("configSchema" in plugin && plugin.configSchema !== void 0) {
+        if (typeof plugin.configSchema !== "string" || plugin.configSchema.trim().length === 0) {
+          errors.push(`${prefix}.configSchema must be a non-empty string when provided`);
+        }
+      }
+    }
+  }
+  return { valid: errors.length === 0, errors };
+}
+async function writeMarketplaceManifest(outputDir, manifest) {
+  const validation = checkMarketplaceManifest(manifest);
+  if (!validation.valid) {
+    throw new Error(
+      `Refusing to write invalid manifest: ${validation.errors.join("; ")}`
+    );
+  }
+  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";
+  fs3.writeFileSync(tmpPath, content);
+  fs3.renameSync(tmpPath, destPath);
+}
+async function installFromMarketplace(source, sourceType, config, logger) {
+  const _log = logger ?? {
+    info: (msg) => log.info(`[marketplace] ${msg}`),
+    warn: (msg) => log.warn(`[marketplace] ${msg}`),
+    debug: (msg) => log.debug(`[marketplace] ${msg}`)
+  };
+  if (!resolveConversationContextCapabilities(config).codexMarketplace) {
+    return {
+      ok: false,
+      message: "Codex marketplace is disabled in config (codexMarketplaceEnabled: false)",
+      source,
+      sourceType,
+      pluginsFound: [],
+      errors: ["marketplace_disabled"]
+    };
+  }
+  try {
+    const manifest = await resolveManifest(source, sourceType, _log);
+    const pluginNames = manifest.plugins.map((p) => p.name);
+    _log.info(`marketplace install: found ${pluginNames.length} plugin(s) from ${sourceType}://${source}`);
+    return {
+      ok: true,
+      message: `Successfully resolved ${pluginNames.length} plugin(s) from marketplace: ${pluginNames.join(", ")}`,
+      source,
+      sourceType,
+      pluginsFound: pluginNames,
+      errors: []
+    };
+  } catch (err) {
+    const errMsg = err instanceof Error ? err.message : String(err);
+    _log.warn(`marketplace install failed: ${errMsg}`);
+    return {
+      ok: false,
+      message: `Failed to install from marketplace: ${errMsg}`,
+      source,
+      sourceType,
+      pluginsFound: [],
+      errors: [errMsg]
+    };
+  }
+}
+async function resolveManifest(source, sourceType, logger) {
+  switch (sourceType) {
+    case "local":
+      return resolveLocal(source, logger);
+    case "url":
+      return resolveUrl(source, logger);
+    case "github":
+      return resolveGithub(source, logger);
+    case "git":
+      return resolveGit(source, logger);
+    default: {
+      const _ = sourceType;
+      throw new Error(`Invalid source type: ${String(_)}`);
+    }
+  }
+}
+function resolveLocal(dirPath, logger) {
+  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 = fs3.readFileSync(manifestPath, "utf-8");
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new Error(`Invalid JSON in ${manifestPath}`);
+  }
+  if (typeof parsed !== "object" || parsed === null) {
+    throw new Error(`marketplace.json at ${manifestPath} is not a valid object`);
+  }
+  return validateMarketplaceManifest(parsed);
+}
+async function resolveUrl(url, logger) {
+  logger.debug?.(`fetching marketplace manifest from URL: ${url}`);
+  let parsedUrl;
+  try {
+    parsedUrl = new URL(url);
+  } catch {
+    throw new Error(`Invalid URL: ${url}`);
+  }
+  if (parsedUrl.protocol !== "https:" && parsedUrl.protocol !== "http:") {
+    throw new Error(`Unsupported URL protocol: ${parsedUrl.protocol} (use https or http)`);
+  }
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`HTTP ${response.status} fetching ${url}`);
+  }
+  const body = await response.json();
+  return validateMarketplaceManifest(body);
+}
+async function resolveGithub(repo, logger) {
+  if (!/^[a-zA-Z0-9._-]+\/[a-zA-Z0-9._-]+$/u.test(repo)) {
+    throw new Error(`Invalid GitHub repo format: "${repo}" (expected owner/repo)`);
+  }
+  const rawUrl = `https://raw.githubusercontent.com/${repo}/HEAD/${MARKETPLACE_MANIFEST_FILENAME}`;
+  logger.debug?.(`fetching marketplace manifest from GitHub: ${rawUrl}`);
+  return resolveUrl(rawUrl, logger);
+}
+async function resolveGit(gitUrl, logger) {
+  const ghMatch = gitUrl.match(
+    /^(?:https?:\/\/)?github\.com\/([a-zA-Z0-9._-]+\/[a-zA-Z0-9._-]+?)(?:\.git)?$/u
+  );
+  if (ghMatch?.[1]) {
+    logger.debug?.(`git URL looks like GitHub \u2014 delegating to github resolver`);
+    return resolveGithub(ghMatch[1], logger);
+  }
+  throw new Error(
+    `Git URL resolution requires a GitHub-format URL for now. Got: ${gitUrl}. Use --type github or --type url instead.`
+  );
+}
+function readPackageVersion() {
+  const candidates = [
+    path3.resolve(import.meta.dirname ?? ".", "../../../.."),
+    path3.resolve(import.meta.dirname ?? ".", "../../../../.."),
+    path3.resolve(import.meta.dirname ?? ".", "..")
+  ];
+  for (const candidate of candidates) {
+    const pkgPath = path3.join(candidate, "package.json");
+    try {
+      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;
+      }
+    } catch {
+    }
+  }
+  return void 0;
+}
+
+// src/connectors/index.ts
+var BUILTIN_CONNECTORS = [
+  {
+    id: "claude-code",
+    name: "Claude Code",
+    version: "1.0.0",
+    description: "Anthropic's Claude Code CLI \u2014 direct memory access via MCP",
+    capabilities: {
+      observe: true,
+      recall: true,
+      store: true,
+      search: true,
+      entities: true,
+      realtimeSync: true,
+      batch: false,
+      maxBudgetChars: 32e3,
+      connectionType: "mcp"
+    },
+    configSchema: {
+      mcpServerUrl: "URL of the MCP Remnic server",
+      namespace: "Optional namespace (default: 'default')"
+    },
+    homepage: "https://claude.ai/code",
+    author: "Anthropic",
+    tags: ["official", "ai", "claude"],
+    requiresToken: true
+  },
+  {
+    id: "codex-cli",
+    name: "Codex CLI",
+    version: "1.0.0",
+    description: "OpenAI Codex CLI \u2014 memory via MCP tool",
+    capabilities: {
+      observe: true,
+      recall: true,
+      store: true,
+      search: false,
+      entities: false,
+      realtimeSync: false,
+      batch: true,
+      maxBudgetChars: 8e3,
+      connectionType: "mcp"
+    },
+    configSchema: {
+      mcpServerUrl: "URL of the MCP Remnic server",
+      namespace: "Optional namespace"
+    },
+    homepage: "https://openai.com/codex",
+    author: "OpenAI",
+    tags: ["official", "ai", "codex"],
+    requiresToken: true
+  },
+  {
+    id: "cursor",
+    name: "Cursor IDE",
+    version: "1.0.0",
+    description: "Cursor IDE \u2014 memory via config file + tool calls",
+    capabilities: {
+      observe: false,
+      recall: true,
+      store: false,
+      search: true,
+      entities: false,
+      realtimeSync: false,
+      batch: false,
+      maxBudgetChars: 32e3,
+      connectionType: "embedded"
+    },
+    configSchema: {
+      memoryDir: "Path to Remnic memory directory"
+    },
+    homepage: "https://cursor.com",
+    author: "Cursor Inc.",
+    tags: ["official", "ide"]
+  },
+  {
+    id: "cline",
+    name: "Cline",
+    version: "1.0.0",
+    description: "VS Code Cline extension \u2014 memory via MCP",
+    capabilities: {
+      observe: true,
+      recall: true,
+      store: true,
+      search: false,
+      entities: false,
+      realtimeSync: false,
+      batch: true,
+      maxBudgetChars: 8e3,
+      connectionType: "mcp"
+    },
+    configSchema: {
+      mcpServerUrl: "URL of the MCP Remnic server",
+      namespace: "Optional namespace"
+    },
+    homepage: "https://github.com/cline/cline",
+    author: "Cline",
+    tags: ["community", "vscode"]
+  },
+  {
+    id: "github-copilot",
+    name: "GitHub Copilot",
+    version: "1.0.0",
+    description: "GitHub Copilot \u2014 memory via MCP server",
+    capabilities: {
+      observe: false,
+      recall: true,
+      store: false,
+      search: true,
+      entities: false,
+      realtimeSync: false,
+      batch: false,
+      maxBudgetChars: 16e3,
+      connectionType: "mcp"
+    },
+    configSchema: {
+      mcpServerUrl: "URL of the MCP Remnic server"
+    },
+    homepage: "https://github.com/features/copilot",
+    author: "GitHub",
+    tags: ["official", "ai", "github"]
+  },
+  {
+    id: "roo-code",
+    name: "Roo Code",
+    version: "1.0.0",
+    description: "Roo Code \u2014 memory via MCP",
+    capabilities: {
+      observe: true,
+      recall: true,
+      store: true,
+      search: false,
+      entities: false,
+      realtimeSync: false,
+      batch: true,
+      maxBudgetChars: 16e3,
+      connectionType: "mcp"
+    },
+    configSchema: {
+      mcpServerUrl: "URL of the MCP Remnic server",
+      namespace: "Optional namespace"
+    },
+    homepage: "https://roocode.com",
+    author: "Roo Code",
+    tags: ["community", "vscode"]
+  },
+  {
+    id: "windsurf",
+    name: "Windsurf",
+    version: "1.0.0",
+    description: "Windsurf IDE \u2014 memory via MCP",
+    capabilities: {
+      observe: true,
+      recall: true,
+      store: true,
+      search: true,
+      entities: false,
+      realtimeSync: false,
+      batch: false,
+      maxBudgetChars: 32e3,
+      connectionType: "mcp"
+    },
+    configSchema: {
+      mcpServerUrl: "URL of the MCP Remnic server"
+    },
+    homepage: "https://windsurf.com",
+    author: "Codeium",
+    tags: ["official", "ide"]
+  },
+  {
+    id: "amp",
+    name: "Amp",
+    version: "1.0.0",
+    description: "Amp coding agent \u2014 memory via MCP",
+    capabilities: {
+      observe: true,
+      recall: true,
+      store: true,
+      search: true,
+      entities: false,
+      realtimeSync: false,
+      batch: false,
+      maxBudgetChars: 32e3,
+      connectionType: "mcp"
+    },
+    configSchema: {
+      mcpServerUrl: "URL of the MCP Remnic server"
+    },
+    homepage: "https://ampcode.com",
+    author: "Sourcegraph",
+    tags: ["official", "ai"]
+  },
+  {
+    id: "pi",
+    name: "Pi Coding Agent",
+    version: "1.0.0",
+    description: "Pi Coding Agent \u2014 native extension for recall, observe, MCP tools, and compaction coordination",
+    capabilities: {
+      observe: true,
+      recall: true,
+      store: true,
+      search: true,
+      entities: true,
+      realtimeSync: true,
+      batch: true,
+      maxBudgetChars: 32e3,
+      connectionType: "http"
+    },
+    configSchema: {
+      remnicDaemonUrl: "URL of the Remnic daemon (default: http://127.0.0.1:4318)",
+      namespace: "Optional namespace",
+      installExtension: "Install the Pi extension into ~/.pi/agent/extensions/remnic (default: true)"
+    },
+    homepage: "https://pi.dev",
+    author: "Remnic",
+    tags: ["official", "ai", "pi", "coding-agent"],
+    requiresToken: true
+  },
+  {
+    id: "omp",
+    name: "Oh My Pi (omp)",
+    version: "1.0.0",
+    description: "Oh My Pi (omp) \u2014 Pi-fork coding agent; native extension for recall, observe, MCP tools, and compaction coordination",
+    capabilities: {
+      observe: true,
+      recall: true,
+      store: true,
+      search: true,
+      entities: true,
+      realtimeSync: true,
+      batch: true,
+      maxBudgetChars: 32e3,
+      connectionType: "http"
+    },
+    configSchema: {
+      remnicDaemonUrl: "URL of the Remnic daemon (default: http://127.0.0.1:4318)",
+      namespace: "Optional namespace",
+      installExtension: "Install the omp extension into ~/.omp/agent/extensions/remnic (default: true)"
+    },
+    homepage: "https://omp.sh",
+    author: "Remnic",
+    tags: ["official", "ai", "omp", "pi", "coding-agent"],
+    requiresToken: true
+  },
+  PRIME_AGENT_CONNECTOR_MANIFEST,
+  {
+    id: "replit",
+    name: "Replit Agent",
+    version: "1.0.0",
+    description: "Replit Agent \u2014 memory via HTTP API (reduced capabilities)",
+    capabilities: {
+      observe: true,
+      recall: true,
+      store: true,
+      search: false,
+      entities: false,
+      realtimeSync: false,
+      batch: false,
+      maxBudgetChars: 8e3,
+      connectionType: "http"
+    },
+    configSchema: {
+      apiUrl: "URL of the Remnic HTTP API",
+      authToken: "Bearer token for authentication"
+    },
+    homepage: "https://replit.com",
+    author: "Replit",
+    tags: ["official", "cloud"],
+    requiresToken: true
+  },
+  {
+    id: "generic-mcp",
+    name: "Generic MCP Client",
+    version: "1.0.0",
+    description: "Any MCP-compatible client \u2014 connect via standard MCP protocol",
+    capabilities: {
+      observe: true,
+      recall: true,
+      store: true,
+      search: true,
+      entities: true,
+      realtimeSync: true,
+      batch: true,
+      maxBudgetChars: 64e3,
+      connectionType: "mcp"
+    },
+    configSchema: {
+      mcpServerUrl: "URL of the MCP Remnic server",
+      namespace: "Optional namespace",
+      authToken: "Bearer token for authentication"
+    },
+    homepage: "https://github.com/joshuaswarren/remnic",
+    author: "Remnic",
+    tags: ["generic", "mcp"],
+    requiresToken: true
+  },
+  {
+    id: "weclone",
+    name: "WeClone Avatar",
+    version: "1.0.0",
+    description: "Memory-aware OpenAI-compatible proxy for deployed WeClone avatars \u2014 injects Remnic recall into chat completions and buffers turns via observe",
+    capabilities: {
+      observe: true,
+      recall: true,
+      store: false,
+      search: false,
+      entities: false,
+      realtimeSync: false,
+      batch: false,
+      maxBudgetChars: 32e3,
+      connectionType: "http"
+    },
+    configSchema: {
+      wecloneApiUrl: "Base URL of the WeClone OpenAI-compatible API (e.g. http://localhost:8000/v1)",
+      proxyPort: "Local port where the memory proxy will listen (default 8100)",
+      remnicDaemonUrl: "URL of the Remnic daemon exposing /engram/v1/recall and /engram/v1/observe",
+      sessionStrategy: "Per-caller session mapping strategy: 'caller-id' | 'single'",
+      wecloneModelName: "Optional fine-tuned model name passed through to WeClone"
+    },
+    homepage: "https://github.com/xming521/weclone",
+    author: "Remnic",
+    tags: ["official", "ai", "weclone", "proxy"],
+    requiresToken: true
+  },
+  {
+    id: "hermes",
+    name: "Hermes Agent",
+    version: "1.0.0",
+    description: "Hermes Agent MemoryProvider \u2014 automatic recall/observe on every turn via Python plugin protocol",
+    capabilities: {
+      observe: true,
+      recall: true,
+      store: true,
+      search: true,
+      entities: false,
+      realtimeSync: true,
+      batch: false,
+      maxBudgetChars: 32e3,
+      connectionType: "http"
+    },
+    configSchema: {
+      host: "Remnic daemon host (default: 127.0.0.1)",
+      port: "Remnic daemon port (default: 4318)",
+      profile: "Hermes profile name (default: default)"
+    },
+    homepage: "https://github.com/joshuaswarren/remnic/tree/main/packages/plugin-hermes",
+    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) {
+  return typeof connectorId === "string" && CONNECTOR_ID_PATTERN.test(connectorId);
+}
+function isConnectorManifest(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && isValidConnectorId(value.id);
+}
+function loadRegistry() {
+  const regPath = getRegistryPath();
+  if (!fs4.existsSync(regPath)) {
+    const registry = {
+      connectors: BUILTIN_CONNECTORS,
+      registryPath: regPath
+    };
+    saveRegistry(registry);
+    return registry;
+  }
+  try {
+    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");
+    }
+    const builtinIds = new Set(BUILTIN_CONNECTORS.map((b) => b.id));
+    const customOnly = parsed.connectors.filter(
+      (c) => isConnectorManifest(c) && !builtinIds.has(c.id)
+    );
+    const merged = [...BUILTIN_CONNECTORS, ...customOnly];
+    return {
+      connectors: merged,
+      registryPath: regPath
+    };
+  } catch {
+    return {
+      connectors: BUILTIN_CONNECTORS,
+      registryPath: regPath
+    };
+  }
+}
+function saveRegistry(registry) {
+  const regPath = registry.registryPath;
+  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 (fs4.existsSync(connectorsDir)) {
+    for (const entry of fs4.readdirSync(connectorsDir)) {
+      if (entry.endsWith(".json")) {
+        try {
+          const config = JSON.parse(
+            fs4.readFileSync(path4.join(connectorsDir, entry), "utf8")
+          );
+          if (isValidConnectorId(config.connectorId)) {
+            installedIds.add(config.connectorId);
+          }
+        } catch {
+        }
+      }
+    }
+  }
+  const available = registry.connectors.map((manifest) => ({
+    ...manifest,
+    installed: installedIds.has(manifest.id)
+  }));
+  const installed = [];
+  for (const id of installedIds) {
+    const configPath = path4.join(connectorsDir, `${id}.json`);
+    try {
+      const raw = JSON.parse(fs4.readFileSync(configPath, "utf8"));
+      const { token: _redacted, ...config } = raw;
+      installed.push({
+        connectorId: id,
+        config,
+        status: "installed",
+        installedAt: raw.installedAt
+      });
+    } catch {
+    }
+  }
+  return { installed, available };
+}
+function getConnectorToken(connectorId) {
+  if (!isValidConnectorId(connectorId)) {
+    return void 0;
+  }
+  try {
+    return loadTokenStore().tokens.find((t) => t.connector === connectorId)?.token;
+  } catch {
+    return void 0;
+  }
+}
+function readSavedConnectorConfig(configPath) {
+  if (!fs4.existsSync(configPath)) return {};
+  try {
+    const parsed = JSON.parse(fs4.readFileSync(configPath, "utf8"));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return {};
+    const {
+      connectorId: _connectorId,
+      installedAt: _installedAt,
+      token: _token,
+      ...config
+    } = parsed;
+    return config;
+  } catch {
+    return {};
+  }
+}
+function removeClearedSavedConnectorConfig(savedConnectorConfig, rawUserConfig) {
+  const merged = { ...savedConnectorConfig };
+  for (const [key, value] of Object.entries(rawUserConfig)) {
+    if (value === void 0 || value === null || value === "") {
+      delete merged[key];
+    }
+  }
+  return merged;
+}
+function compactConnectorConfigOverrides(rawUserConfig) {
+  const safeUserConfig = {};
+  for (const [key, value] of Object.entries(rawUserConfig)) {
+    if (value === void 0 || value === null || value === "") continue;
+    safeUserConfig[key] = value;
+  }
+  return safeUserConfig;
+}
+function installConnector(options) {
+  if (!isValidConnectorId(options.connectorId)) {
+    return {
+      connectorId: options.connectorId,
+      status: "error",
+      message: `Invalid connector ID ${JSON.stringify(options.connectorId)}. Connector IDs must match [A-Za-z0-9][A-Za-z0-9._-]*.`
+    };
+  }
+  const registry = loadRegistry();
+  const manifest = registry.connectors.find((c) => c.id === options.connectorId);
+  if (!manifest) {
+    return {
+      connectorId: options.connectorId,
+      status: "error",
+      message: `Unknown connector: ${options.connectorId}`
+    };
+  }
+  const existing = listConnectors().installed.find(
+    (c) => c.connectorId === options.connectorId
+  );
+  if (existing && !options.force) {
+    let backfillNote = "";
+    if (options.connectorId === "hermes") {
+      try {
+        const hermesJsonPath = path4.join(getConnectorsDir(), "hermes.json");
+        let parsed = null;
+        try {
+          const parsedRaw = JSON.parse(fs4.readFileSync(hermesJsonPath, "utf8"));
+          if (parsedRaw !== null && typeof parsedRaw === "object" && !Array.isArray(parsedRaw)) {
+            parsed = parsedRaw;
+          }
+        } catch {
+        }
+        const priorRaw = parsed?.pluginShimPath;
+        const priorPersisted = typeof priorRaw === "string" && priorRaw.length > 0 ? priorRaw : null;
+        const profileRaw = parsed?.profile;
+        let currentConfigPath = null;
+        let activeConfigHasBlock = false;
+        let configResolutionError = null;
+        try {
+          currentConfigPath = hermesConfigPath(
+            typeof profileRaw === "string" && profileRaw.length > 0 ? profileRaw : "default"
+          );
+          activeConfigHasBlock = fs4.existsSync(currentConfigPath) && /^remnic:/m.test(fs4.readFileSync(currentConfigPath, "utf8"));
+        } catch (resolveErr) {
+          configResolutionError = resolveErr instanceof Error ? resolveErr.message : String(resolveErr);
+          activeConfigHasBlock = false;
+        }
+        if (!activeConfigHasBlock) {
+          backfillNote = configResolutionError ? ` Note: could not resolve the active Hermes home (${configResolutionError}) \u2014 skipped the shim backfill. Fix the HERMES_HOME/profile configuration and re-run.` : " Note: the active Hermes home's config.yaml has no remnic: block \u2014 skipped the shim backfill so Hermes cannot discover an unconfigured provider. If Hermes was installed under a different HERMES_HOME, re-run with --force to rewrite the config (and token) and migrate the shim under the current home.";
+          return {
+            connectorId: options.connectorId,
+            status: "already_installed",
+            message: `Already installed. Use --force to reinstall.${backfillNote}`
+          };
+        }
+        const outcome = reconcileHermesShim(priorPersisted);
+        if (outcome.notes.length > 0) {
+          backfillNote = ` ${outcome.notes.join(" ")}`;
+        }
+        let configProvenanceAdded = false;
+        if (parsed !== null && currentConfigPath !== null && (typeof parsed.hermesConfigPath !== "string" || parsed.hermesConfigPath.length === 0)) {
+          parsed.hermesConfigPath = currentConfigPath;
+          configProvenanceAdded = true;
+        }
+        let shimPriorsChanged = false;
+        const cleanedInheritedBackfillShims = [];
+        if (parsed !== null) {
+          const shimPriorCandidates = [];
+          if (priorPersisted !== null) {
+            shimPriorCandidates.push(priorPersisted);
+          }
+          if (Array.isArray(parsed.priorPluginShimPaths)) {
+            for (const entry of parsed.priorPluginShimPaths) {
+              if (typeof entry === "string" && entry.length > 0) {
+                shimPriorCandidates.push(entry);
+              }
+            }
+          }
+          if (outcome.materializedAt !== null && shimPriorCandidates.length > 0) {
+            const cleanupTargets = shimPriorCandidates.filter(
+              (candidate) => outcome.persistPath === null || !sameShimTarget(candidate, outcome.persistPath)
+            );
+            if (cleanupTargets.length > 0) {
+              try {
+                const cleaned = removeHermesShim(cleanupTargets);
+                cleanedInheritedBackfillShims.push(...cleaned.removedPaths);
+              } catch {
+              }
+            }
+          }
+          const survivingShims = survivingMarkerShims(shimPriorCandidates, outcome.persistPath);
+          const persistedShimPriors = Array.isArray(parsed.priorPluginShimPaths) ? parsed.priorPluginShimPaths : null;
+          shimPriorsChanged = persistedShimPriors === null ? survivingShims.length > 0 : persistedShimPriors.length !== survivingShims.length || survivingShims.some((entry, index) => persistedShimPriors[index] !== entry);
+          if (survivingShims.length > 0) {
+            parsed.priorPluginShimPaths = survivingShims;
+          } else {
+            delete parsed.priorPluginShimPaths;
+          }
+        }
+        const shimPathChanged = parsed !== null && outcome.persistPath !== null && parsed.pluginShimPath !== outcome.persistPath;
+        if (parsed !== null && (shimPathChanged || configProvenanceAdded || shimPriorsChanged)) {
+          if (outcome.persistPath !== null) {
+            parsed.pluginShimPath = outcome.persistPath;
+          }
+          try {
+            writeSecretFileSync2(hermesJsonPath, JSON.stringify(parsed, null, 2));
+          } catch (persistErr) {
+            const rollbackFailures = [];
+            if (outcome.materializedAt !== null && outcome.createdNew && (priorPersisted === null || !sameShimTarget(outcome.materializedAt, priorPersisted))) {
+              try {
+                removeHermesShim([outcome.materializedAt]);
+              } catch {
+                rollbackFailures.push(`remove ${outcome.materializedAt} manually`);
+              }
+            }
+            if (outcome.priorCleanedAt !== null) {
+              try {
+                materializeHermesShim(outcome.priorCleanedAt);
+              } catch {
+                rollbackFailures.push(`restore the shim at ${outcome.priorCleanedAt} manually`);
+              }
+            }
+            for (const cleanedPath of cleanedInheritedBackfillShims) {
+              if (outcome.priorCleanedAt !== null && sameShimTarget(cleanedPath, outcome.priorCleanedAt)) {
+                continue;
+              }
+              try {
+                materializeHermesShim(cleanedPath);
+              } catch {
+                rollbackFailures.push(`restore the shim at ${cleanedPath} manually`);
+              }
+            }
+            const persistMsg = persistErr instanceof Error ? persistErr.message : String(persistErr);
+            backfillNote = rollbackFailures.length === 0 ? ` Note: could not persist the shim path (${persistMsg}); shim changes were rolled back.` : ` Note: could not persist the shim path (${persistMsg}) and rollback was incomplete \u2014 ${rollbackFailures.join("; ")}.`;
+          }
+        }
+      } catch {
+      }
+    }
+    return {
+      connectorId: options.connectorId,
+      status: "already_installed",
+      message: `Already installed. Use --force to reinstall.${backfillNote}`
+    };
+  }
+  const configDir = getConnectorsDir();
+  fs4.mkdirSync(configDir, { recursive: true });
+  const configPath = path4.join(configDir, `${options.connectorId}.json`);
+  const savedConnectorConfig = existing ? readSavedConnectorConfig(configPath) : {};
+  let hermesSavedProfile;
+  let hermesSavedHost;
+  let hermesSavedPort;
+  let hermesSavedAllowInsecureHttp;
+  let hermesResolvedProfile;
+  let hermesResolvedHost;
+  let hermesResolvedPort;
+  let hermesResolvedAllowInsecureHttp = false;
+  if (options.connectorId === "hermes") {
+    if (fs4.existsSync(configPath)) {
+      try {
+        const prev = JSON.parse(fs4.readFileSync(configPath, "utf8"));
+        if (prev?.profile != null) {
+          try {
+            hermesSavedProfile = sanitizeHermesProfile(String(prev.profile));
+          } catch {
+          }
+        }
+        if (prev?.host != null) {
+          try {
+            hermesSavedHost = sanitizeHermesHost(String(prev.host));
+          } catch {
+          }
+        }
+        if (prev?.port != null) {
+          try {
+            const coercedPort = Number(String(prev.port));
+            hermesSavedPort = sanitizeHermesPort(coercedPort);
+          } catch {
+          }
+        }
+        if (prev?.allow_insecure_http != null) {
+          hermesSavedAllowInsecureHttp = coerceBool(prev.allow_insecure_http, "allow_insecure_http");
+        }
+      } catch {
+      }
+    }
+    hermesResolvedProfile = hermesSavedProfile ?? "default";
+    hermesResolvedHost = hermesSavedHost ?? "127.0.0.1";
+    hermesResolvedAllowInsecureHttp = hermesSavedAllowInsecureHttp ?? false;
+    if (options.config?.port !== void 0) {
+      try {
+        hermesResolvedPort = sanitizeHermesPort(Number(String(options.config.port)));
+      } catch (err) {
+        return {
+          connectorId: options.connectorId,
+          status: "error",
+          message: `Invalid Hermes config: ${err instanceof Error ? err.message : String(err)}`
+        };
+      }
+    }
+    if (hermesResolvedPort === void 0) {
+      hermesResolvedPort = hermesSavedPort ?? 4318;
+    }
+    if (options.config?.profile !== void 0) {
+      try {
+        hermesResolvedProfile = sanitizeHermesProfile(String(options.config.profile));
+      } catch (err) {
+        return {
+          connectorId: options.connectorId,
+          status: "error",
+          message: `Invalid Hermes config: ${err instanceof Error ? err.message : String(err)}`
+        };
+      }
+    }
+    if (options.config?.host !== void 0) {
+      try {
+        hermesResolvedHost = sanitizeHermesHost(String(options.config.host));
+      } catch (err) {
+        return {
+          connectorId: options.connectorId,
+          status: "error",
+          message: `Invalid Hermes config: ${err instanceof Error ? err.message : String(err)}`
+        };
+      }
+    }
+    if (options.config?.allow_insecure_http !== void 0) {
+      const allowInsecureHttp = coerceBool(options.config.allow_insecure_http, "allow_insecure_http");
+      if (allowInsecureHttp === void 0) {
+        return {
+          connectorId: options.connectorId,
+          status: "error",
+          message: "Invalid Hermes config: allow_insecure_http must be true or false"
+        };
+      }
+      hermesResolvedAllowInsecureHttp = allowInsecureHttp;
+    }
+  }
+  const nonHermesPriorTokenStore = options.connectorId !== "hermes" && manifest.requiresToken ? loadTokenStore() : null;
+  let tokenEntry = null;
+  if (options.connectorId === "hermes") {
+    try {
+      tokenEntry = buildTokenEntry(options.connectorId);
+    } catch {
+    }
+  } else if (manifest.requiresToken) {
+    try {
+      tokenEntry = generateToken(options.connectorId);
+    } catch {
+      if (nonHermesPriorTokenStore !== null) {
+        try {
+          saveTokenStore(nonHermesPriorTokenStore);
+        } catch {
+        }
+      }
+    }
+  }
+  if (options.connectorId !== "hermes" && manifest.requiresToken && tokenEntry === null) {
+    return {
+      connectorId: options.connectorId,
+      status: "error",
+      message: `${manifest.name} install aborted: token generation failed. Run \`remnic token generate ${options.connectorId}\` to create the token, then reinstall.`
+    };
+  }
+  const { token: _callerToken, ...rawUserConfig } = options.config ?? {};
+  const savedConnectorConfigForMerge = removeClearedSavedConnectorConfig(savedConnectorConfig, rawUserConfig);
+  const safeUserConfig = compactConnectorConfigOverrides(rawUserConfig);
+  const resolvedConfig = {
+    ...savedConnectorConfigForMerge,
+    ...safeUserConfig,
+    connectorId: options.connectorId,
+    installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    // For hermes, always overlay the sanitized/coerced resolved values so that
+    // the connector JSON always has a numeric port and validated profile/host.
+    // This also ensures options.config string values (from --config=port=5555)
+    // are replaced with their sanitized numeric equivalents (Fix 2 root cause).
+    ...hermesResolvedProfile !== void 0 ? {
+      profile: hermesResolvedProfile,
+      host: hermesResolvedHost,
+      port: hermesResolvedPort,
+      allow_insecure_http: hermesResolvedAllowInsecureHttp
+    } : {}
+  };
+  if (options.connectorId === "hermes") {
+    const rawProfile = hermesResolvedProfile;
+    const hermesHost = hermesResolvedHost;
+    const hermesPort = hermesResolvedPort;
+    let hermesProfile;
+    try {
+      hermesProfile = sanitizeHermesProfile(rawProfile);
+    } catch (err) {
+      return {
+        connectorId: options.connectorId,
+        status: "error",
+        message: `Hermes install aborted: ${err instanceof Error ? err.message : String(err)}`
+      };
+    }
+    if (!tokenEntry) {
+      return {
+        connectorId: options.connectorId,
+        status: "error",
+        message: "Hermes install aborted: token store unavailable. Run `remnic token generate hermes` then reinstall to complete setup."
+      };
+    }
+    {
+      const envHermesHome = readEnvVar("HERMES_HOME");
+      if (typeof envHermesHome === "string" && envHermesHome.trim().length > 0) {
+        try {
+          fs4.mkdirSync(path4.dirname(hermesConfigPath(hermesProfile)), { recursive: true });
+        } catch {
+        }
+      }
+    }
+    let yamlResult;
+    try {
+      yamlResult = upsertHermesConfig({
+        profile: hermesProfile,
+        host: hermesHost,
+        port: hermesPort,
+        token: tokenEntry.token,
+        allowInsecureHttp: hermesResolvedAllowInsecureHttp
+      });
+    } catch (err) {
+      return {
+        connectorId: options.connectorId,
+        status: "error",
+        message: `Hermes install aborted: config.yaml write failed \u2014 ${err instanceof Error ? err.message : String(err)}`
+      };
+    }
+    if (!yamlResult.updated) {
+      return {
+        connectorId: options.connectorId,
+        status: "error",
+        message: `Hermes install aborted: ${yamlResult.reason ?? "config.yaml not written"}. Create the Hermes profile directory first, then reinstall.`
+      };
+    }
+    const priorTokenStore = loadTokenStore();
+    let committed = false;
+    try {
+      commitTokenEntry(tokenEntry);
+      committed = true;
+    } catch (commitErr) {
+      let tokensRolledBack = true;
+      let tokensRollbackErrMsg = "";
+      try {
+        saveTokenStore(priorTokenStore);
+      } catch (tokenRestoreErr) {
+        tokensRolledBack = false;
+        tokensRollbackErrMsg = tokenRestoreErr instanceof Error ? tokenRestoreErr.message : String(tokenRestoreErr);
+      }
+      let yamlRolledBack = true;
+      let yamlRollbackErrMsg = "";
+      try {
+        if (yamlResult.priorContent === null) {
+          fs4.unlinkSync(yamlResult.configPath);
+        } else if (typeof yamlResult.priorContent === "string") {
+          writeSecretFileSync2(yamlResult.configPath, yamlResult.priorContent);
+        }
+      } catch (yamlRestoreErr) {
+        yamlRolledBack = false;
+        yamlRollbackErrMsg = yamlRestoreErr instanceof Error ? yamlRestoreErr.message : String(yamlRestoreErr);
+      }
+      const commitErrMsg = commitErr instanceof Error ? commitErr.message : String(commitErr);
+      let message;
+      if (tokensRolledBack && yamlRolledBack) {
+        message = `Hermes install failed during token commit \u2014 ${commitErrMsg}. config.yaml and tokens.json restored to prior state. Resolve the tokens.json access issue, then reinstall.`;
+      } else if (!yamlRolledBack && tokensRolledBack) {
+        message = `Hermes install failed during token commit \u2014 ${commitErrMsg}. tokens.json restored but config.yaml rollback ALSO failed (${yamlRollbackErrMsg}). Hermes daemon may be in an inconsistent state: config references a stale token. Manually inspect ${yamlResult.configPath} and reinstall.`;
+      } else if (yamlRolledBack && !tokensRolledBack) {
+        message = `Hermes install failed during token commit \u2014 ${commitErrMsg}. config.yaml restored but tokens.json rollback ALSO failed (${tokensRollbackErrMsg}). Hermes daemon may be in an inconsistent state: tokens.json is corrupt or incomplete. Manually inspect ~/.remnic/tokens.json and reinstall.`;
+      } else {
+        message = `Hermes install failed during token commit \u2014 ${commitErrMsg}. BOTH rollbacks failed: config.yaml rollback failed (${yamlRollbackErrMsg}); tokens.json rollback failed (${tokensRollbackErrMsg}). Hermes daemon is likely in an inconsistent state. Manually inspect ${yamlResult.configPath} and ~/.remnic/tokens.json, then reinstall.`;
+      }
+      return {
+        connectorId: options.connectorId,
+        status: "error",
+        message
+      };
+    }
+    const priorShimPathRaw = savedConnectorConfig.pluginShimPath;
+    const shimOutcome = reconcileHermesShim(
+      typeof priorShimPathRaw === "string" && priorShimPathRaw.length > 0 ? priorShimPathRaw : null
+    );
+    if (shimOutcome.persistPath !== null) {
+      resolvedConfig.pluginShimPath = shimOutcome.persistPath;
+    }
+    const cleanedInheritedShims = [];
+    {
+      const shimPriorCandidates = [];
+      if (typeof priorShimPathRaw === "string" && priorShimPathRaw.length > 0) {
+        shimPriorCandidates.push(priorShimPathRaw);
+      }
+      const inheritedShimPriorsRaw = savedConnectorConfig.priorPluginShimPaths;
+      if (Array.isArray(inheritedShimPriorsRaw)) {
+        for (const entry of inheritedShimPriorsRaw) {
+          if (typeof entry === "string" && entry.length > 0) {
+            shimPriorCandidates.push(entry);
+          }
+        }
+      }
+      if (shimOutcome.materializedAt !== null && shimPriorCandidates.length > 0) {
+        const cleanupTargets = shimPriorCandidates.filter(
+          (candidate) => shimOutcome.persistPath === null || !sameShimTarget(candidate, shimOutcome.persistPath)
+        );
+        if (cleanupTargets.length > 0) {
+          try {
+            const cleaned = removeHermesShim(cleanupTargets);
+            cleanedInheritedShims.push(...cleaned.removedPaths);
+          } catch {
+          }
+        }
+      }
+      const survivingShims = survivingMarkerShims(shimPriorCandidates, shimOutcome.persistPath);
+      if (survivingShims.length > 0) {
+        resolvedConfig.priorPluginShimPaths = survivingShims;
+      } else {
+        delete resolvedConfig.priorPluginShimPaths;
+      }
+    }
+    resolvedConfig.hermesConfigPath = yamlResult.configPath;
+    const hermesPriorNotes = [];
+    const priorConfigPathRaw = savedConnectorConfig.hermesConfigPath;
+    const priorConfigPath = typeof priorConfigPathRaw === "string" && priorConfigPathRaw.length > 0 ? priorConfigPathRaw : null;
+    const priorConfigDiffers = priorConfigPath !== null && !sameHermesConfigTarget(priorConfigPath, yamlResult.configPath);
+    const hermesPriorConfigMutations = [];
+    if (priorConfigDiffers && priorConfigPath !== null && shimOutcome.materializedAt === null) {
+      let fallbackDetail = "";
+      if (isPlausibleHermesConfigPath(priorConfigPath)) {
+        try {
+          const beforeRefresh = fs4.readFileSync(priorConfigPath, "utf8");
+          const refresh = upsertHermesConfigAt(priorConfigPath, {
+            host: hermesHost,
+            port: hermesPort,
+            token: tokenEntry.token,
+            allowInsecureHttp: hermesResolvedAllowInsecureHttp
+          });
+          if (refresh.updated) {
+            hermesPriorConfigMutations.push({ mutatedPath: priorConfigPath, priorContent: beforeRefresh });
+          }
+          fallbackDetail = refresh.updated ? " Its remnic: block was refreshed with the newly-issued token so it keeps working." : ` Note: its token could not be refreshed (${refresh.reason ?? "config not writable"}) \u2014 re-run install with HERMES_HOME pointing there to restore daemon auth.`;
+        } catch (refreshErr) {
+          fallbackDetail = ` Note: its token could not be refreshed (${refreshErr instanceof Error ? refreshErr.message : String(refreshErr)}) \u2014 re-run install with HERMES_HOME pointing there to restore daemon auth.`;
+        }
+      } else {
+        fallbackDetail = " Note: its token was rotated by this install \u2014 re-run install with HERMES_HOME pointing there to restore daemon auth.";
+      }
+      hermesPriorNotes.push(
+        `Note: left the prior-install Hermes config in place at ${priorConfigPath} \u2014 no Remnic shim could be written under the current Hermes home, so the prior installation remains the working fallback.${fallbackDetail} Resolve the shim collision/failure above and re-run with --force to complete the migration.`
+      );
+    }
+    {
+      const candidates = [];
+      if (priorConfigDiffers && priorConfigPath !== null) {
+        candidates.push(priorConfigPath);
+      }
+      const inheritedArrayRaw = savedConnectorConfig.priorHermesConfigPaths;
+      if (Array.isArray(inheritedArrayRaw)) {
+        for (const entry of inheritedArrayRaw) {
+          if (typeof entry === "string" && entry.length > 0) {
+            candidates.push(entry);
+          }
+        }
+      }
+      const inheritedLegacyRaw = savedConnectorConfig.priorHermesConfigPath;
+      if (typeof inheritedLegacyRaw === "string" && inheritedLegacyRaw.length > 0) {
+        candidates.push(inheritedLegacyRaw);
+      }
+      if (shimOutcome.materializedAt !== null) {
+        for (const candidate of candidates) {
+          if (sameHermesConfigTarget(candidate, yamlResult.configPath)) {
+            continue;
+          }
+          if (!isPlausibleHermesConfigPath(candidate)) {
+            continue;
+          }
+          try {
+            const beforeCleanup = fs4.readFileSync(candidate, "utf8");
+            const cleanup = removeHermesConfigFile(candidate);
+            if (cleanup.updated) {
+              hermesPriorConfigMutations.push({ mutatedPath: candidate, priorContent: beforeCleanup });
+              hermesPriorNotes.push(`Cleaned remnic: block from prior-install Hermes config: ${candidate}`);
+            }
+          } catch {
+            hermesPriorNotes.push(
+              `Note: could not clean the remnic: block from the prior-install Hermes config at ${candidate} \u2014 remove it manually.`
+            );
+          }
+        }
+      }
+      const survivingPriors = [];
+      for (const candidate of candidates) {
+        if (sameHermesConfigTarget(candidate, yamlResult.configPath)) {
+          continue;
+        }
+        if (survivingPriors.some((kept) => sameHermesConfigTarget(kept, candidate))) {
+          continue;
+        }
+        let blockSurvives = false;
+        try {
+          blockSurvives = /^remnic:/m.test(fs4.readFileSync(candidate, "utf8"));
+        } catch {
+          blockSurvives = false;
+        }
+        if (blockSurvives) {
+          survivingPriors.push(candidate);
+        }
+      }
+      if (survivingPriors.length > 0) {
+        resolvedConfig.priorHermesConfigPaths = survivingPriors;
+      } else {
+        delete resolvedConfig.priorHermesConfigPaths;
+      }
+      delete resolvedConfig.priorHermesConfigPath;
+    }
+    try {
+      writeSecretFileSync2(configPath, JSON.stringify(resolvedConfig, null, 2));
+    } catch (writeErr) {
+      let tokenRollbackFailed = false;
+      let tokenRollbackMsg = "token store restored to pre-install snapshot";
+      try {
+        saveTokenStore(priorTokenStore);
+      } catch (tokenRestoreErr) {
+        tokenRollbackFailed = true;
+        tokenRollbackMsg = `token rollback failed: ${tokenRestoreErr instanceof Error ? tokenRestoreErr.message : String(tokenRestoreErr)}`;
+      }
+      let yamlRollbackMsg = "config.yaml restored";
+      try {
+        if (yamlResult.priorContent === null) {
+          let unlinkSucceeded = false;
+          let unlinkErr;
+          try {
+            fs4.unlinkSync(yamlResult.configPath);
+            unlinkSucceeded = true;
+          } catch (err) {
+            unlinkErr = err;
+          }
+          if (unlinkSucceeded) {
+            yamlRollbackMsg = "config.yaml removed (was newly created)";
+          } else {
+            const unlinkMsg = unlinkErr instanceof Error ? unlinkErr.message : String(unlinkErr);
+            yamlRollbackMsg = `config.yaml rollback failed: could not remove newly-created file \u2014 ${unlinkMsg}`;
+          }
+        } else if (typeof yamlResult.priorContent === "string") {
+          writeSecretFileSync2(yamlResult.configPath, yamlResult.priorContent);
+          yamlRollbackMsg = "config.yaml restored to prior content";
+        }
+      } catch (yamlRollbackErr) {
+        yamlRollbackMsg = `config.yaml rollback failed: ${yamlRollbackErr instanceof Error ? yamlRollbackErr.message : String(yamlRollbackErr)}`;
+      }
+      let shimRollbackMsg = "no shim changes to roll back";
+      const shimRollbackFailures = [];
+      const priorPersisted = typeof priorShimPathRaw === "string" && priorShimPathRaw.length > 0 ? priorShimPathRaw : null;
+      if (shimOutcome.materializedAt !== null && shimOutcome.createdNew && (priorPersisted === null || !sameShimTarget(shimOutcome.materializedAt, priorPersisted))) {
+        try {
+          removeHermesShim([shimOutcome.materializedAt]);
+        } catch (err) {
+          shimRollbackFailures.push(
+            `could not remove the newly-written shim at ${shimOutcome.materializedAt} (${err instanceof Error ? err.message : String(err)})`
+          );
+        }
+      }
+      if (shimOutcome.priorCleanedAt !== null) {
+        try {
+          materializeHermesShim(shimOutcome.priorCleanedAt);
+        } catch (err) {
+          shimRollbackFailures.push(
+            `could not restore the prior shim at ${shimOutcome.priorCleanedAt} (${err instanceof Error ? err.message : String(err)})`
+          );
+        }
+      }
+      for (const cleanedPath of cleanedInheritedShims) {
+        if (shimOutcome.priorCleanedAt !== null && sameShimTarget(cleanedPath, shimOutcome.priorCleanedAt)) {
+          continue;
+        }
+        try {
+          materializeHermesShim(cleanedPath);
+        } catch (err) {
+          shimRollbackFailures.push(
+            `could not restore the prior shim at ${cleanedPath} (${err instanceof Error ? err.message : String(err)})`
+          );
+        }
+      }
+      if (shimOutcome.materializedAt !== null || shimOutcome.priorCleanedAt !== null || cleanedInheritedShims.length > 0) {
+        shimRollbackMsg = shimRollbackFailures.length === 0 ? "plugin shim changes rolled back" : `plugin shim rollback incomplete: ${shimRollbackFailures.join("; ")}`;
+      }
+      let priorConfigRollbackMsg = "no prior-config changes to roll back";
+      if (hermesPriorConfigMutations.length > 0) {
+        const priorConfigRollbackFailures = [];
+        for (const mutation of [...hermesPriorConfigMutations].reverse()) {
+          try {
+            writeSecretFileSync2(mutation.mutatedPath, mutation.priorContent);
+          } catch (restoreErr) {
+            priorConfigRollbackFailures.push(
+              `could not restore ${mutation.mutatedPath} (${restoreErr instanceof Error ? restoreErr.message : String(restoreErr)})`
+            );
+          }
+        }
+        priorConfigRollbackMsg = priorConfigRollbackFailures.length === 0 ? "prior-install config(s) restored" : `prior-install config rollback incomplete: ${priorConfigRollbackFailures.join("; ")}`;
+      }
+      const urgentSuffix = tokenRollbackFailed ? ` tokens.json may be in an inconsistent state \u2014 manually restore hermes token with 'remnic token generate hermes'.` : "";
+      return {
+        connectorId: options.connectorId,
+        status: "error",
+        message: `Hermes install aborted: connector config write failed \u2014 connector directory may not be writable. Rollback: ${tokenRollbackMsg}; ${yamlRollbackMsg}; ${shimRollbackMsg}; ${priorConfigRollbackMsg}.${urgentSuffix} Resolve the permission issue, then reinstall.`
+      };
+    }
+    const notes = [];
+    notes.push(`Updated Hermes config: ${yamlResult.configPath}`);
+    notes.push(...shimOutcome.notes);
+    notes.push(...hermesPriorNotes);
+    notes.push(
+      "Next step: set `memory.provider: remnic` (and `memory_enabled: true`) in your Hermes config.yaml to activate the provider."
+    );
+    if (hermesProfile === "default") {
+      const legacyDefaultConfigPath = hermesDefaultProfileConfigPath();
+      if (!sameHermesConfigTarget(yamlResult.configPath, legacyDefaultConfigPath)) {
+        try {
+          const legacyDefaultCleanResult = removeHermesConfigFile(legacyDefaultConfigPath);
+          if (legacyDefaultCleanResult.updated) {
+            notes.push(`Cleaned stale remnic: block from legacy default profile: ${legacyDefaultConfigPath}`);
+          }
+        } catch {
+          notes.push("Note: could not clean stale remnic: block from legacy default profile");
+        }
+      }
+    }
+    let oldProfileResolvesToDifferentFile = false;
+    if (hermesSavedProfile !== void 0) {
+      try {
+        oldProfileResolvesToDifferentFile = !sameHermesConfigTarget(hermesConfigPath(hermesSavedProfile), hermesConfigPath(hermesProfile));
+      } catch {
+        oldProfileResolvesToDifferentFile = false;
+      }
+    }
+    if (oldProfileResolvesToDifferentFile) {
+      try {
+        const oldCleanResult = removeHermesConfig({ profile: hermesSavedProfile });
+        if (oldCleanResult.updated) {
+          notes.push(`Cleaned stale remnic: block from previous profile: ${oldCleanResult.configPath}`);
+        }
+      } catch {
+        notes.push(`Note: could not clean stale remnic: block from previous profile "${hermesSavedProfile}"`);
+      }
+    }
+    if (committed && tokenEntry) {
+      const daemonOk = checkDaemonHealth(
+        hermesHost,
+        hermesPort,
+        tokenEntry.token,
+        hermesResolvedAllowInsecureHttp
+      );
+      if (daemonOk) {
+        notes.push("Daemon health check: OK");
+      } else {
+        notes.push(
+          `Daemon not reachable at ${hermesHost}:${hermesPort} \u2014 start with: remnic daemon start`
+        );
+      }
+    }
+    const suffix = notes.length > 0 ? `
+  ${notes.join("\n  ")}` : "";
+    return {
+      connectorId: options.connectorId,
+      status: "installed",
+      configPath,
+      message: `Installed ${manifest.name} v${manifest.version}${suffix}`
+    };
+  }
+  let extensionMessage = "";
+  let extensionInstalled = false;
+  let extensionHandle = null;
+  if (options.connectorId === "codex-cli") {
+    const coerced = coerceInstallExtension(resolvedConfig.installExtension);
+    if (coerced !== void 0) {
+      resolvedConfig.installExtension = coerced;
+    }
+    const shouldInstall = resolvedConfig.installExtension !== false;
+    resolvedConfig.installExtension = shouldInstall;
+    const codexHomeOverride = typeof resolvedConfig.codexHome === "string" && resolvedConfig.codexHome.length > 0 ? resolvedConfig.codexHome : null;
+    const resolvedCodexHome = resolveCodexHome(codexHomeOverride);
+    resolvedConfig.codexHome = resolvedCodexHome;
+    if (shouldInstall) {
+      try {
+        const extensionSourceOverride = typeof resolvedConfig.extensionSourceDir === "string" && resolvedConfig.extensionSourceDir.length > 0 ? resolvedConfig.extensionSourceDir : null;
+        const extResult = installCodexMemoryExtension({
+          codexHome: resolvedCodexHome,
+          sourceDir: extensionSourceOverride
+        });
+        extensionMessage = ` (memory extension: ${extResult.remnicExtensionDir})`;
+        extensionInstalled = true;
+        extensionHandle = extResult;
+      } catch (err) {
+        const errMsg = err instanceof Error ? err.message : "unknown error";
+        let extensionErrTokenRolledBack = false;
+        let extensionErrTokenRollbackMsg = "";
+        if (tokenEntry !== null && nonHermesPriorTokenStore !== null) {
+          try {
+            saveTokenStore(nonHermesPriorTokenStore);
+            extensionErrTokenRolledBack = true;
+          } catch (tokenRestoreErr) {
+            extensionErrTokenRolledBack = false;
+            extensionErrTokenRollbackMsg = tokenRestoreErr instanceof Error ? tokenRestoreErr.message : String(tokenRestoreErr);
+          }
+        }
+        const tokenRollbackSuffix = manifest.requiresToken ? extensionErrTokenRolledBack ? " Token has been rolled back." : ` Token rollback FAILED (${extensionErrTokenRollbackMsg}) \u2014 tokens.json may contain an orphaned entry. Manually inspect ~/.remnic/tokens.json and reinstall.` : "";
+        return {
+          connectorId: options.connectorId,
+          status: "error",
+          message: `Memory extension install failed \u2014 ${errMsg}.${tokenRollbackSuffix} Resolve the issue, then reinstall.`
+        };
+      }
+    } else {
+      extensionMessage = " (memory extension: skipped via installExtension=false)";
+    }
+  }
+  let weCloneProxyHandleRollback = null;
+  if (options.connectorId === "weclone") {
+    try {
+      let proxyConfigPath = null;
+      if (existing && fs4.existsSync(configPath)) {
+        try {
+          const savedRegistryConfig = JSON.parse(fs4.readFileSync(configPath, "utf8"));
+          if (typeof savedRegistryConfig.proxyConfigPath === "string" && savedRegistryConfig.proxyConfigPath.length > 0) {
+            proxyConfigPath = savedRegistryConfig.proxyConfigPath;
+          }
+        } catch {
+        }
+      }
+      if (proxyConfigPath === null) {
+        proxyConfigPath = resolveWeCloneProxyConfigPath();
+      }
+      const prior = readWeCloneProxyConfigIfExists(proxyConfigPath);
+      const proxyConfig = buildWeCloneProxyConfig({
+        userConfig: safeUserConfig,
+        priorConfig: prior ? safeParseJson(prior) : null,
+        authToken: tokenEntry?.token
+      });
+      fs4.mkdirSync(path4.dirname(proxyConfigPath), { recursive: true });
+      weCloneProxyHandleRollback = () => {
+        try {
+          if (prior === null) {
+            if (fs4.existsSync(proxyConfigPath)) {
+              fs4.unlinkSync(proxyConfigPath);
+            }
+          } else {
+            writeSecretFileSync2(proxyConfigPath, prior);
+          }
+        } catch {
+        }
+      };
+      try {
+        writeSecretFileSync2(
+          proxyConfigPath,
+          JSON.stringify(proxyConfig, null, 2)
+        );
+      } catch (writeErr) {
+        try {
+          weCloneProxyHandleRollback();
+        } catch {
+        }
+        weCloneProxyHandleRollback = null;
+        throw writeErr;
+      }
+      resolvedConfig.proxyConfigPath = proxyConfigPath;
+      resolvedConfig.proxyPort = proxyConfig.proxyPort;
+      resolvedConfig.wecloneApiUrl = proxyConfig.wecloneApiUrl;
+      resolvedConfig.remnicDaemonUrl = proxyConfig.remnicDaemonUrl;
+      resolvedConfig.sessionStrategy = proxyConfig.sessionStrategy;
+    } catch (weCloneErr) {
+      let tokenRolledBack = false;
+      let tokenRollbackMsg = "";
+      if (tokenEntry !== null && nonHermesPriorTokenStore !== null) {
+        try {
+          saveTokenStore(nonHermesPriorTokenStore);
+          tokenRolledBack = true;
+        } catch (tokenRestoreErr) {
+          tokenRolledBack = false;
+          tokenRollbackMsg = tokenRestoreErr instanceof Error ? tokenRestoreErr.message : String(tokenRestoreErr);
+        }
+      }
+      const tokenSuffix = manifest.requiresToken && tokenEntry !== null ? tokenRolledBack ? " Token has been rolled back." : ` Token rollback FAILED (${tokenRollbackMsg}) \u2014 tokens.json may contain an orphaned entry. Manually inspect ~/.remnic/tokens.json and reinstall.` : "";
+      return {
+        connectorId: options.connectorId,
+        status: "error",
+        message: `WeClone install aborted: proxy config write failed \u2014 ${weCloneErr instanceof Error ? weCloneErr.message : String(weCloneErr)}.${tokenSuffix} Resolve the write permission issue on ~/.remnic/connectors/, then reinstall.`
+      };
+    }
+  }
+  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
+  ];
+  for (const key of INTERNAL_KEYS_DENYLIST) {
+    delete resolvedConfig[key];
+  }
+  try {
+    writeSecretFileSync2(configPath, JSON.stringify(resolvedConfig, null, 2));
+  } catch (writeErr) {
+    let configWriteTokenRolledBack = false;
+    let configWriteTokenRollbackMsg = "";
+    if (tokenEntry !== null && nonHermesPriorTokenStore !== null) {
+      try {
+        saveTokenStore(nonHermesPriorTokenStore);
+        configWriteTokenRolledBack = true;
+      } catch (tokenRestoreErr) {
+        configWriteTokenRolledBack = false;
+        configWriteTokenRollbackMsg = tokenRestoreErr instanceof Error ? tokenRestoreErr.message : String(tokenRestoreErr);
+      }
+    }
+    if (extensionInstalled && extensionHandle !== null) {
+      try {
+        extensionHandle.rollback();
+      } catch {
+        console.warn(
+          "[remnic/connectors] installConnector: config write failed and extension rollback also failed \u2014 manual cleanup of memories_extensions/remnic may be required."
+        );
+      }
+    }
+    if (weCloneProxyHandleRollback !== null) {
+      try {
+        weCloneProxyHandleRollback();
+      } 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,
+      status: "error",
+      message: `${manifest.name} install aborted: connector config write failed \u2014 ${writeErr instanceof Error ? writeErr.message : String(writeErr)}.${configWriteTokenSuffix} Resolve the write permission issue, then reinstall.`
+    };
+  }
+  if (extensionInstalled && extensionHandle !== null) {
+    extensionHandle.commit();
+  }
+  return {
+    connectorId: options.connectorId,
+    status: "installed",
+    configPath,
+    message: `Installed ${manifest.name} v${manifest.version}${extensionMessage}`
+  };
+}
+function removeConnector(connectorId) {
+  const configDir = getConnectorsDir();
+  if (!isValidConnectorId(connectorId)) {
+    return {
+      connectorId,
+      configPath: configDir,
+      status: "skipped",
+      reason: "invalid-connector-id",
+      message: `Removal aborted: invalid connector ID ${JSON.stringify(connectorId)}. Connector IDs must match [A-Za-z0-9][A-Za-z0-9._-]*.`
+    };
+  }
+  const configPath = path4.join(configDir, `${connectorId}.json`);
+  let codexHomeOverride = null;
+  let savedInstallExtension = void 0;
+  let configParsed = false;
+  if (connectorId === "codex-cli" && fs4.existsSync(configPath)) {
+    try {
+      const parsed = JSON.parse(fs4.readFileSync(configPath, "utf8"));
+      configParsed = true;
+      if (typeof parsed.codexHome === "string" && parsed.codexHome.length > 0) {
+        codexHomeOverride = parsed.codexHome;
+      }
+      const coerced = coerceInstallExtension(parsed.installExtension);
+      if (coerced !== void 0) {
+        savedInstallExtension = coerced;
+      }
+    } catch {
+      console.debug(
+        "[remnic/connectors] removeConnector: codex-cli.json parse failed \u2014 skipping extension removal to avoid touching unverified paths"
+      );
+    }
+  }
+  let savedHermesShimPath = null;
+  let savedHermesConfigPath = null;
+  const savedPriorHermesConfigPaths = [];
+  const savedPriorHermesShimPaths = [];
+  if (connectorId === "hermes" && fs4.existsSync(configPath)) {
+    try {
+      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");
+      }
+      const parsed = parsedRaw;
+      if (typeof parsed.pluginShimPath === "string" && parsed.pluginShimPath.length > 0) {
+        savedHermesShimPath = parsed.pluginShimPath;
+      }
+      if (Array.isArray(parsed.priorPluginShimPaths)) {
+        for (const entry of parsed.priorPluginShimPaths) {
+          if (typeof entry === "string" && entry.length > 0) {
+            savedPriorHermesShimPaths.push(entry);
+          }
+        }
+      }
+      if (typeof parsed.hermesConfigPath === "string" && parsed.hermesConfigPath.length > 0) {
+        savedHermesConfigPath = parsed.hermesConfigPath;
+      }
+      if (Array.isArray(parsed.priorHermesConfigPaths)) {
+        for (const entry of parsed.priorHermesConfigPaths) {
+          if (typeof entry === "string" && entry.length > 0) {
+            savedPriorHermesConfigPaths.push(entry);
+          }
+        }
+      }
+      if (typeof parsed.priorHermesConfigPath === "string" && parsed.priorHermesConfigPath.length > 0) {
+        savedPriorHermesConfigPaths.push(parsed.priorHermesConfigPath);
+      }
+    } catch {
+      return {
+        connectorId,
+        configPath,
+        status: "error",
+        message: `Removal aborted: ${configPath} is malformed and cannot be parsed. It records where the Hermes plugin shim was installed; removing the connector without it could orphan the shim. Fix or delete the file (and remove any plugins/remnic/__init__.py under your Hermes home manually), then re-run removal.`
+      };
+    }
+  }
+  if (!fs4.existsSync(configPath)) {
+    let staleTokenRevoked = false;
+    try {
+      staleTokenRevoked = revokeToken(connectorId);
+    } catch {
+    }
+    const message = staleTokenRevoked ? `${connectorId} is not installed. Removed stale token entry for ${connectorId}.` : "Not installed";
+    return {
+      connectorId,
+      configPath,
+      status: "not_found",
+      message
+    };
+  }
+  let storedProfile = "default";
+  if (connectorId === "hermes") {
+    try {
+      const stored = JSON.parse(fs4.readFileSync(configPath, "utf8"));
+      if (typeof stored?.profile === "string") storedProfile = stored.profile;
+    } catch {
+    }
+  }
+  let weCloneProxyConfigPath = null;
+  let weCloneRegistryParseFailed = false;
+  if (connectorId === "weclone") {
+    try {
+      const stored = JSON.parse(fs4.readFileSync(configPath, "utf8"));
+      if (typeof stored.proxyConfigPath === "string" && stored.proxyConfigPath.length > 0) {
+        weCloneProxyConfigPath = stored.proxyConfigPath;
+      }
+    } catch {
+      weCloneRegistryParseFailed = true;
+    }
+    if (weCloneProxyConfigPath === null && !weCloneRegistryParseFailed) {
+      try {
+        weCloneProxyConfigPath = resolveWeCloneProxyConfigPath();
+      } catch {
+      }
+    }
+  }
+  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."
+    );
+    return {
+      connectorId,
+      configPath,
+      message: "Removal aborted: weclone.json is malformed. Registry config left in place for inspection; proxy config NOT removed.",
+      status: "skipped",
+      reason: "config-parse-failed"
+    };
+  }
+  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."
+    );
+    return {
+      connectorId,
+      configPath,
+      message: "Removal aborted: codex-cli.json is malformed. Config file left in place for inspection.",
+      status: "skipped",
+      reason: "config-parse-failed"
+    };
+  }
+  let extensionMessage = "";
+  if (connectorId === "codex-cli") {
+    if (savedInstallExtension === false) {
+      extensionMessage = " (memory extension: skipped \u2014 installExtension=false)";
+    } else if (savedInstallExtension !== true || codexHomeOverride === null) {
+      extensionMessage = " (memory extension: skipped \u2014 no install provenance in saved config)";
+    } else {
+      const extResult = removeCodexMemoryExtension({ codexHome: codexHomeOverride });
+      extensionMessage = extResult.removed ? ` (memory extension removed: ${extResult.remnicExtensionDir})` : " (no memory extension present)";
+    }
+  }
+  if (connectorId === "hermes") {
+    const preflightCandidates = [];
+    try {
+      preflightCandidates.push(...hermesConfigCleanupPaths(storedProfile));
+    } catch {
+    }
+    if (savedHermesConfigPath !== null && isPlausibleHermesConfigPath(savedHermesConfigPath)) {
+      preflightCandidates.push(savedHermesConfigPath);
+    }
+    preflightCandidates.push(...savedPriorHermesConfigPaths.filter(isPlausibleHermesConfigPath));
+    const uniqueCandidates = [];
+    for (const candidate of preflightCandidates) {
+      if (!uniqueCandidates.some((kept) => sameHermesConfigTarget(kept, candidate))) {
+        uniqueCandidates.push(candidate);
+      }
+    }
+    const blocked = [];
+    for (const candidate of uniqueCandidates) {
+      let needsCleanup = false;
+      try {
+        needsCleanup = /^remnic:/m.test(fs4.readFileSync(candidate, "utf8"));
+      } catch {
+        needsCleanup = false;
+      }
+      if (!needsCleanup) {
+        continue;
+      }
+      try {
+        assertConfigComponentsNotSymlinked(candidate);
+      } catch {
+        blocked.push(`${candidate} (symlinked path component)`);
+        continue;
+      }
+      try {
+        fs4.accessSync(candidate, fs4.constants.W_OK);
+        fs4.accessSync(path4.dirname(candidate), fs4.constants.W_OK);
+      } catch {
+        blocked.push(`${candidate} (not writable)`);
+      }
+    }
+    if (blocked.length > 0) {
+      return {
+        connectorId,
+        configPath,
+        status: "error",
+        message: `Hermes remove aborted: the following config.yaml path(s) hold a remnic: block but cannot be cleaned: ${blocked.join(", ")}. The connector registry entry, provenance, and token were left untouched \u2014 fix the permissions or resolve the symlink and re-run removal.`
+      };
+    }
+  }
+  try {
+    fs4.unlinkSync(configPath);
+  } catch (unlinkErr) {
+    const sanitizedErr = unlinkErr instanceof Error ? unlinkErr.message : String(unlinkErr);
+    return {
+      connectorId,
+      configPath,
+      status: "error",
+      message: `${connectorId} remove aborted: could not delete connector file (${sanitizedErr}). Token and any connector-specific state were not modified.`
+    };
+  }
+  const notes = [];
+  let tokenRevoked = true;
+  try {
+    revokeToken(connectorId);
+  } catch (revokeErr) {
+    tokenRevoked = false;
+    const revokeMsg = revokeErr instanceof Error ? revokeErr.message : String(revokeErr);
+    notes.push(`Warning: token revocation failed \u2014 ${revokeMsg}. The token for ${connectorId} may still be present in tokens.json.`);
+  }
+  let weCloneProxyDeleteFailed = null;
+  if (connectorId === "weclone") {
+    if (weCloneProxyConfigPath === null) {
+      notes.push(
+        "WeClone proxy config cleanup skipped: no persisted path found in saved config (likely a legacy install predating proxyConfigPath provenance)."
+      );
+    } else {
+      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 (fs4.existsSync(weCloneProxyConfigPath)) {
+            fs4.unlinkSync(weCloneProxyConfigPath);
+            notes.push(`Removed WeClone proxy config: ${weCloneProxyConfigPath}`);
+          }
+        } catch (err) {
+          weCloneProxyDeleteFailed = err instanceof Error ? err.message : String(err);
+        }
+      }
+    }
+  }
+  if (weCloneProxyDeleteFailed !== null && weCloneProxyConfigPath !== null) {
+    const tokenStatus = tokenRevoked ? "the registry config was deleted and the token was revoked" : "the registry config was deleted but TOKEN REVOCATION ALSO FAILED \u2014 inspect ~/.remnic/tokens.json and revoke manually";
+    return {
+      connectorId,
+      configPath,
+      status: "error",
+      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 = [];
+      if (savedHermesShimPath !== null) {
+        shimCandidates.push(savedHermesShimPath);
+      }
+      shimCandidates.push(...savedPriorHermesShimPaths);
+      try {
+        shimCandidates.push(hermesShimPath());
+      } catch {
+      }
+      const shimResult = removeHermesShim(shimCandidates);
+      if (shimResult.notes.length > 0) {
+        notes.push(shimResult.notes.join("; "));
+      }
+    } catch (shimErr) {
+      notes.push(
+        `Hermes plugin shim cleanup skipped: ${shimErr instanceof Error ? shimErr.message : String(shimErr)}`
+      );
+    }
+    try {
+      const yamlResult = removeHermesConfig({
+        profile: storedProfile,
+        extraConfigPaths: [
+          ...savedHermesConfigPath !== null ? [savedHermesConfigPath] : [],
+          ...savedPriorHermesConfigPaths
+        ]
+      });
+      if (yamlResult.updated) {
+        notes.push(`Removed remnic: block from Hermes config: ${yamlResult.configPath}`);
+      } else if (yamlResult.reason?.startsWith("Hermes config cleanup partially failed:")) {
+        const tokenStatus = tokenRevoked ? "the connector registry config was deleted and the token was revoked" : "the connector registry config was deleted but TOKEN REVOCATION ALSO FAILED \u2014 inspect ~/.remnic/tokens.json and revoke manually";
+        const shimSuffix = notes.length > 0 ? ` Completed cleanup: ${notes.join("; ")}.` : "";
+        return {
+          connectorId,
+          configPath,
+          status: "error",
+          message: `Hermes remove partially succeeded: ${tokenStatus}, but ${yamlResult.reason}. Updated paths: ${yamlResult.configPath}. Manually remove any stale remnic: block and token material from the failed Hermes config path.` + shimSuffix
+        };
+      } else if (yamlResult.skipped) {
+        notes.push(`Hermes config cleanup skipped: ${yamlResult.reason}`);
+      }
+    } catch (err) {
+      notes.push(
+        `Hermes config cleanup skipped: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  const suffix = notes.length > 0 ? `
+  ${notes.join("\n  ")}` : "";
+  return {
+    connectorId,
+    configPath,
+    status: "removed",
+    message: `Removed${extensionMessage}${suffix}`
+  };
+}
+function sanitizeHermesProfile(profile) {
+  if (typeof profile !== "string" || profile.length === 0) {
+    throw new Error("Hermes profile name must be a non-empty string");
+  }
+  if (!/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(profile)) {
+    throw new Error(
+      `Invalid Hermes profile name: ${JSON.stringify(profile)} \u2014 must match [A-Za-z0-9][A-Za-z0-9._-]*`
+    );
+  }
+  if (profile.includes("..")) {
+    throw new Error(`Invalid Hermes profile name: ${JSON.stringify(profile)} \u2014 must not contain ".."`);
+  }
+  return profile;
+}
+function hermesConfigPath(profile) {
+  const safeProfile = sanitizeHermesProfile(profile);
+  const hermesRoot = resolveHermesRoot();
+  const rootConfigPath = path4.join(hermesRoot, "config.yaml");
+  const profilesRoot = path4.join(hermesRoot, "profiles");
+  if (safeProfile === "default") {
+    const defaultProfileDir = path4.join(profilesRoot, safeProfile);
+    if (isFile(rootConfigPath) || !fs4.existsSync(rootConfigPath) && !isDirectory(defaultProfileDir)) {
+      return rootConfigPath;
+    }
+  }
+  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}`
+    );
+  }
+  return cfgPath;
+}
+function isDirectory(filePath) {
+  try {
+    return fs4.statSync(filePath).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function isFile(filePath) {
+  try {
+    return fs4.statSync(filePath).isFile();
+  } catch {
+    return false;
+  }
+}
+function hermesConfigTarget(filePath) {
+  try {
+    return fs4.realpathSync.native(filePath);
+  } catch {
+    return path4.resolve(filePath);
+  }
+}
+function sameHermesConfigTarget(leftPath, rightPath) {
+  return hermesConfigTarget(leftPath) === hermesConfigTarget(rightPath);
+}
+function hermesDefaultProfileConfigPath() {
+  return path4.join(resolveHermesRoot(), "profiles", "default", "config.yaml");
+}
+function hermesConfigCleanupPaths(profile) {
+  const cfgPath = hermesConfigPath(profile);
+  const safeProfile = sanitizeHermesProfile(profile);
+  if (safeProfile !== "default") {
+    return [cfgPath];
+  }
+  return [.../* @__PURE__ */ new Set([cfgPath, hermesDefaultProfileConfigPath()])];
+}
+function sanitizeHermesHost(host) {
+  if (typeof host !== "string" || host.length === 0) {
+    throw new Error("Hermes host must be a non-empty string");
+  }
+  if (host.length > 253) {
+    throw new Error(`Hermes host too long (max 253 chars): ${JSON.stringify(host.slice(0, 32))}\u2026`);
+  }
+  if (host.startsWith("[")) {
+    if (!host.endsWith("]")) {
+      throw new Error(
+        `Invalid Hermes host: ${JSON.stringify(host)} \u2014 unbalanced brackets in IPv6 literal`
+      );
+    }
+    const inner = host.slice(1, -1);
+    if (inner.length === 0 || !/^[0-9A-Fa-f:]+$/.test(inner)) {
+      throw new Error(
+        `Invalid Hermes host: ${JSON.stringify(host)} \u2014 bracketed IPv6 literal must contain only hex digits and colons`
+      );
+    }
+    return host;
+  }
+  if (host.includes(":")) {
+    throw new Error(
+      `Invalid Hermes host: ${JSON.stringify(host)} \u2014 host must not include a port; supply the port separately with --config port=<n>`
+    );
+  }
+  if (!/^[A-Za-z0-9._\-]+$/.test(host)) {
+    throw new Error(
+      `Invalid Hermes host: ${JSON.stringify(host)} \u2014 must be a plain hostname or IP literal`
+    );
+  }
+  return host;
+}
+function sanitizeHermesPort(port) {
+  const numeric = Number(port);
+  if (!Number.isInteger(numeric)) {
+    throw new Error(
+      `Invalid Hermes port "${port}": must be a positive integer`
+    );
+  }
+  if (numeric < 1 || numeric > 65535) {
+    throw new Error(`Invalid Hermes port: ${JSON.stringify(port)} \u2014 must be an integer in [1, 65535]`);
+  }
+  return numeric;
+}
+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 {
+    fs4.writeFileSync(tmpPath, data, { mode: 384, flag: "wx" });
+    wroteTemp = true;
+    try {
+      fs4.chmodSync(tmpPath, 384);
+    } catch {
+    }
+    fs4.renameSync(tmpPath, filePath);
+    try {
+      fs4.chmodSync(filePath, 384);
+    } catch {
+    }
+  } catch (err) {
+    if (wroteTemp) {
+      try {
+        fs4.unlinkSync(tmpPath);
+      } catch {
+      }
+    }
+    throw err;
+  }
+}
+function upsertHermesConfig(opts) {
+  return upsertHermesConfigAt(hermesConfigPath(opts.profile), opts);
+}
+function upsertHermesConfigAt(cfgPath, opts) {
+  assertConfigComponentsNotSymlinked(cfgPath);
+  const profileDir = path4.dirname(cfgPath);
+  const safeHost = sanitizeHermesHost(opts.host);
+  const safePort = sanitizeHermesPort(opts.port);
+  const allowInsecureHttp = opts.allowInsecureHttp ?? false;
+  if (!/^[A-Za-z0-9_]+$/.test(opts.token)) {
+    throw new Error("Invalid Hermes token: contains non-alphanumeric characters");
+  }
+  if (!isDirectory(profileDir)) {
+    return {
+      updated: false,
+      skipped: true,
+      reason: `Hermes profile directory not found: ${profileDir}`,
+      configPath: cfgPath
+    };
+  }
+  const block = [
+    "remnic:",
+    `  host: "${safeHost}"`,
+    `  port: ${safePort}`,
+    `  token: "${opts.token}"`,
+    `  allow_insecure_http: ${allowInsecureHttp}`
+  ].join("\n");
+  if (!fs4.existsSync(cfgPath)) {
+    writeSecretFileSync2(cfgPath, block + "\n");
+    return { updated: true, skipped: false, configPath: cfgPath, priorContent: null };
+  }
+  const raw = fs4.readFileSync(cfgPath, "utf8");
+  const hasRemnicBlock = /^remnic:/m.test(raw);
+  if (!hasRemnicBlock) {
+    const separator = raw.endsWith("\n") ? "\n" : "\n\n";
+    writeSecretFileSync2(cfgPath, raw + separator + block + "\n");
+    return { updated: true, skipped: false, configPath: cfgPath, priorContent: raw };
+  }
+  const splitLines = raw.split("\n");
+  if (splitLines.length > 0 && splitLines[splitLines.length - 1] === "") {
+    splitLines.pop();
+  }
+  const lines = splitLines;
+  const newLines = [];
+  let inRemnicBlock = false;
+  let blockWritten = false;
+  const written = { host: false, port: false, token: false, allowInsecureHttp: false };
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (/^remnic:/.test(line)) {
+      inRemnicBlock = true;
+      newLines.push(line);
+      continue;
+    }
+    if (inRemnicBlock) {
+      if (line.length > 0 && !/^\s/.test(line)) {
+        if (!written.host) newLines.push(`  host: "${safeHost}"`);
+        if (!written.port) newLines.push(`  port: ${safePort}`);
+        if (!written.token) newLines.push(`  token: "${opts.token}"`);
+        if (!written.allowInsecureHttp) newLines.push(`  allow_insecure_http: ${allowInsecureHttp}`);
+        blockWritten = true;
+        inRemnicBlock = false;
+        newLines.push(line);
+        continue;
+      }
+      if (/^\s+host:/.test(line)) {
+        newLines.push(`  host: "${safeHost}"`);
+        written.host = true;
+      } else if (/^\s+port:/.test(line)) {
+        newLines.push(`  port: ${safePort}`);
+        written.port = true;
+      } else if (/^\s+token:/.test(line)) {
+        newLines.push(`  token: "${opts.token}"`);
+        written.token = true;
+      } else if (/^\s+allow_insecure_http:/.test(line)) {
+        newLines.push(`  allow_insecure_http: ${allowInsecureHttp}`);
+        written.allowInsecureHttp = true;
+      } else {
+        newLines.push(line);
+      }
+      continue;
+    }
+    newLines.push(line);
+  }
+  if (inRemnicBlock && !blockWritten) {
+    if (!written.host) newLines.push(`  host: "${safeHost}"`);
+    if (!written.port) newLines.push(`  port: ${safePort}`);
+    if (!written.token) newLines.push(`  token: "${opts.token}"`);
+    if (!written.allowInsecureHttp) newLines.push(`  allow_insecure_http: ${allowInsecureHttp}`);
+  }
+  writeSecretFileSync2(cfgPath, newLines.join("\n") + "\n");
+  return { updated: true, skipped: false, configPath: cfgPath, priorContent: raw };
+}
+function removeHermesConfig(opts) {
+  let envCfgPaths;
+  let envResolutionError = null;
+  try {
+    envCfgPaths = [...hermesConfigCleanupPaths(opts.profile)];
+  } catch (err) {
+    envCfgPaths = [];
+    envResolutionError = err instanceof Error ? err.message : String(err);
+  }
+  const cfgPaths = [];
+  for (const candidate of envCfgPaths) {
+    if (!cfgPaths.some((existing) => sameHermesConfigTarget(existing, candidate))) {
+      cfgPaths.push(candidate);
+    }
+  }
+  for (const extra of opts.extraConfigPaths ?? []) {
+    if (isPlausibleHermesConfigPath(extra) && !cfgPaths.some((existing) => sameHermesConfigTarget(existing, extra))) {
+      cfgPaths.push(extra);
+    }
+  }
+  if (cfgPaths.length === 0) {
+    return {
+      updated: false,
+      skipped: true,
+      reason: envResolutionError ? `Hermes config cleanup failed: ${envResolutionError}` : "Hermes config.yaml not found",
+      configPath: "<unresolved>"
+    };
+  }
+  const results = cfgPaths.map((cfgPath) => {
+    try {
+      return removeHermesConfigFile(cfgPath);
+    } catch (err) {
+      return {
+        updated: false,
+        skipped: true,
+        reason: `Hermes config cleanup failed: ${err instanceof Error ? err.message : String(err)}`,
+        configPath: cfgPath
+      };
+    }
+  });
+  const updated = results.filter((result) => result.updated);
+  const cleanupFailures = results.filter((result) => result.reason?.startsWith("Hermes config cleanup failed:"));
+  if (updated.length > 0) {
+    const updatedPaths = updated.map((result) => result.configPath).join(", ");
+    if (cleanupFailures.length > 0) {
+      const failedPaths = cleanupFailures.map((result) => result.configPath).join(", ");
+      return {
+        updated: false,
+        skipped: true,
+        reason: `Hermes config cleanup partially failed: updated ${updatedPaths}; failed ${failedPaths}`,
+        configPath: `${updatedPaths}; failed: ${failedPaths}`
+      };
+    }
+    return {
+      updated: true,
+      skipped: false,
+      configPath: updatedPaths
+    };
+  }
+  const cleanupFailure = cleanupFailures[0];
+  if (cleanupFailure) {
+    return cleanupFailure;
+  }
+  const existingWithoutBlock = results.find((result) => result.reason !== "Hermes config.yaml not found");
+  const fallbackResult = existingWithoutBlock ?? results[0];
+  if (fallbackResult) {
+    return fallbackResult;
+  }
+  return {
+    updated: false,
+    skipped: true,
+    reason: "Hermes config.yaml not found",
+    configPath: cfgPaths[0] ?? "<unresolved>"
+  };
+}
+function removeHermesConfigFile(cfgPath) {
+  try {
+    assertConfigComponentsNotSymlinked(cfgPath);
+  } catch (err) {
+    return {
+      updated: false,
+      skipped: true,
+      reason: `Hermes config cleanup skipped: ${err instanceof Error ? err.message : String(err)}`,
+      configPath: cfgPath
+    };
+  }
+  if (!fs4.existsSync(cfgPath)) {
+    return {
+      updated: false,
+      skipped: true,
+      reason: "Hermes config.yaml not found",
+      configPath: cfgPath
+    };
+  }
+  const raw = fs4.readFileSync(cfgPath, "utf8");
+  if (!/^remnic:/m.test(raw)) {
+    return {
+      updated: false,
+      skipped: true,
+      reason: "No remnic: block found in config.yaml",
+      configPath: cfgPath
+    };
+  }
+  const lines = raw.split("\n");
+  const newLines = [];
+  let inRemnicBlock = false;
+  for (const line of lines) {
+    if (/^remnic:/.test(line)) {
+      inRemnicBlock = true;
+      continue;
+    }
+    if (inRemnicBlock) {
+      if (line.length > 0 && !/^\s/.test(line)) {
+        inRemnicBlock = false;
+        newLines.push(line);
+      }
+      continue;
+    }
+    newLines.push(line);
+  }
+  while (newLines.length > 0 && newLines[newLines.length - 1]?.trim() === "") {
+    newLines.pop();
+  }
+  writeSecretFileSync2(cfgPath, newLines.length > 0 ? newLines.join("\n") + "\n" : "");
+  return { updated: true, skipped: false, configPath: cfgPath };
+}
+async function doctorConnector(connectorId) {
+  const installed = listConnectors().installed;
+  const instance = installed.find((c) => c.connectorId === connectorId);
+  if (!instance) {
+    return {
+      connectorId,
+      checks: [{ name: "Installed", ok: false, detail: "Not installed" }],
+      healthy: false
+    };
+  }
+  const configPath = path4.join(getConnectorsDir(), `${connectorId}.json`);
+  const checks = [];
+  checks.push({
+    name: "Config file",
+    ok: fs4.existsSync(configPath),
+    detail: configPath
+  });
+  try {
+    const raw = fs4.readFileSync(configPath, "utf8");
+    JSON.parse(raw);
+    checks.push({ name: "Config valid", ok: true, detail: "OK" });
+  } catch (e) {
+    checks.push({ name: "Config valid", ok: false, detail: String(e) });
+  }
+  const mcpUrl = instance.config.mcpServerUrl;
+  if (mcpUrl) {
+    try {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), 3e3);
+      const response = await fetch(mcpUrl, { signal: controller.signal });
+      clearTimeout(timeoutId);
+      checks.push({ name: "MCP server", ok: response.ok, detail: mcpUrl });
+    } catch (e) {
+      checks.push({
+        name: "MCP server",
+        ok: false,
+        detail: `Cannot reach ${mcpUrl}: ${e instanceof Error ? e.message : "unknown"}`
+      });
+    }
+  }
+  const memoryDir = instance.config.memoryDir;
+  if (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 };
+}
+var CODEX_MEMORIES_SUBDIR = "memories";
+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 path4.resolve(override.trim());
+  }
+  const envHome = readEnvVar("CODEX_HOME");
+  if (envHome && envHome.trim().length > 0) {
+    return path4.resolve(envHome.trim());
+  }
+  const home = readEnvVar("HOME") || readEnvVar("USERPROFILE") || resolveHomeDir();
+  return path4.resolve(home, ".codex");
+}
+function resolveCodexMemoryExtensionPaths(codexHomeOverride) {
+  const codexHome = resolveCodexHome(codexHomeOverride);
+  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 = 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 = path4.join("memories_extensions", "remnic");
+  const WORKSPACE_RELATIVE_PATH = path4.join(
+    "packages",
+    "plugin-codex",
+    "memories_extensions",
+    "remnic"
+  );
+  const searched = [];
+  try {
+    const moduleDir = path4.dirname(fileURLToPath(import.meta.url));
+    const bundledCandidate = path4.join(moduleDir, "codex");
+    searched.push(bundledCandidate);
+    if (fs4.existsSync(bundledCandidate) && fs4.statSync(bundledCandidate).isDirectory()) {
+      return bundledCandidate;
+    }
+    const distConnectorsCandidate = path4.join(moduleDir, "connectors", "codex");
+    searched.push(distConnectorsCandidate);
+    if (fs4.existsSync(distConnectorsCandidate) && fs4.statSync(distConnectorsCandidate).isDirectory()) {
+      return distConnectorsCandidate;
+    }
+  } catch {
+  }
+  try {
+    const requireFromHere = createRequire(import.meta.url);
+    const pluginPkgJsonPath = requireFromHere.resolve("@remnic/plugin-codex/package.json");
+    const pluginPkgRoot = path4.dirname(pluginPkgJsonPath);
+    const candidate = path4.join(pluginPkgRoot, EXTENSION_SUBPATH);
+    searched.push(candidate);
+    if (fs4.existsSync(candidate) && fs4.statSync(candidate).isDirectory()) {
+      return candidate;
+    }
+  } catch {
+  }
+  try {
+    const moduleDir = path4.dirname(fileURLToPath(import.meta.url));
+    let dir = moduleDir;
+    for (let depth = 0; depth < 8; depth += 1) {
+      const candidate = path4.join(
+        dir,
+        "node_modules",
+        "@remnic",
+        "plugin-codex",
+        EXTENSION_SUBPATH
+      );
+      searched.push(candidate);
+      if (fs4.existsSync(candidate) && fs4.statSync(candidate).isDirectory()) {
+        return candidate;
+      }
+      const parent = path4.dirname(dir);
+      if (parent === dir) break;
+      dir = parent;
+    }
+  } catch {
+  }
+  const anchors = [];
+  try {
+    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 = path4.join(dir, WORKSPACE_RELATIVE_PATH);
+      searched.push(candidate);
+      if (fs4.existsSync(candidate) && fs4.statSync(candidate).isDirectory()) {
+        return candidate;
+      }
+      const parent = path4.dirname(dir);
+      if (parent === dir) break;
+      dir = parent;
+    }
+  }
+  throw new Error(
+    "Could not locate the plugin-codex memories_extensions/remnic source directory.\nPaths searched:\n" + searched.map((p) => `  - ${p}`).join("\n") + "\nInstall @remnic/plugin-codex or pass sourceDir explicitly."
+  );
+}
+function copyDirRecursiveSync(src, dest) {
+  let count = 0;
+  fs4.mkdirSync(dest, { recursive: true });
+  const entries = fs4.readdirSync(src, { withFileTypes: true });
+  for (const entry of entries) {
+    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()) {
+      fs4.copyFileSync(from, to);
+      count += 1;
+    }
+  }
+  return count;
+}
+function installCodexMemoryExtension(options = {}) {
+  const paths = resolveCodexMemoryExtensionPaths(options.codexHome ?? null);
+  const sourceDir = locatePluginCodexExtensionSource(options.sourceDir ?? null);
+  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 = fs4.readdirSync(paths.extensionsRoot);
+    for (const entry of existingEntries) {
+      if (!entry.startsWith(tmpPrefix)) continue;
+      const stalePath = path4.join(paths.extensionsRoot, entry);
+      try {
+        const stat = fs4.statSync(stalePath);
+        const ageMs = now - stat.mtimeMs;
+        if (ageMs < STALE_TMP_THRESHOLD_MS) {
+          continue;
+        }
+        fs4.rmSync(stalePath, { recursive: true, force: true });
+      } catch {
+      }
+    }
+  } catch {
+  }
+  const tmpName = `${tmpPrefix}${process.pid}-${Date.now()}`;
+  const tmpDir = path4.join(paths.extensionsRoot, tmpName);
+  let filesCopied = 0;
+  let commitFn = () => {
+  };
+  let rollbackFn = () => {
+  };
+  try {
+    filesCopied = copyDirRecursiveSync(sourceDir, tmpDir);
+    const backupDir = `${paths.remnicExtensionDir}.bak-${Date.now()}`;
+    const hadExisting = fs4.existsSync(paths.remnicExtensionDir);
+    if (hadExisting) {
+      fs4.renameSync(paths.remnicExtensionDir, backupDir);
+    }
+    try {
+      fs4.renameSync(tmpDir, paths.remnicExtensionDir);
+    } catch (renameErr) {
+      if (hadExisting) {
+        try {
+          fs4.renameSync(backupDir, paths.remnicExtensionDir);
+        } catch {
+        }
+      }
+      throw renameErr;
+    }
+    commitFn = () => {
+      if (hadExisting) {
+        try {
+          fs4.rmSync(backupDir, { recursive: true, force: true });
+        } catch {
+        }
+      }
+    };
+    rollbackFn = () => {
+      if (hadExisting) {
+        try {
+          if (fs4.existsSync(paths.remnicExtensionDir)) {
+            fs4.rmSync(paths.remnicExtensionDir, { recursive: true, force: true });
+          }
+          fs4.renameSync(backupDir, paths.remnicExtensionDir);
+        } catch {
+        }
+      } else {
+        try {
+          if (fs4.existsSync(paths.remnicExtensionDir)) {
+            fs4.rmSync(paths.remnicExtensionDir, { recursive: true, force: true });
+          }
+        } catch {
+        }
+      }
+    };
+  } catch (err) {
+    if (fs4.existsSync(tmpDir)) {
+      try {
+        fs4.rmSync(tmpDir, { recursive: true, force: true });
+      } catch {
+      }
+    }
+    throw err;
+  }
+  const instructionsPath = path4.join(paths.remnicExtensionDir, "instructions.md");
+  return {
+    ...paths,
+    instructionsPath,
+    filesCopied,
+    commit: commitFn,
+    rollback: rollbackFn
+  };
+}
+function removeCodexMemoryExtension(options = {}) {
+  const paths = resolveCodexMemoryExtensionPaths(options.codexHome ?? null);
+  let removed = false;
+  if (fs4.existsSync(paths.remnicExtensionDir)) {
+    fs4.rmSync(paths.remnicExtensionDir, { recursive: true, force: true });
+    removed = true;
+  }
+  return { ...paths, removed };
+}
+var WECLONE_PROXY_CONFIG_DIRNAME = ".remnic";
+var WECLONE_PROXY_CONFIG_FILENAME = "weclone.json";
+function resolveWeCloneProxyConfigPath() {
+  const remnicHome = readEnvVar("REMNIC_HOME");
+  const override = remnicHome && remnicHome.length > 0 ? remnicHome : readEnvVar("ENGRAM_HOME");
+  if (override && override.length > 0) {
+    return path4.resolve(expandTildePath(override), "connectors", WECLONE_PROXY_CONFIG_FILENAME);
+  }
+  const envHome = readEnvVar("HOME");
+  const home = envHome && envHome.length > 0 ? envHome : os2.homedir();
+  return path4.resolve(
+    home,
+    WECLONE_PROXY_CONFIG_DIRNAME,
+    "connectors",
+    WECLONE_PROXY_CONFIG_FILENAME
+  );
+}
+function readWeCloneProxyConfigIfExists(configPath) {
+  try {
+    if (!fs4.existsSync(configPath)) return null;
+    return fs4.readFileSync(configPath, "utf8");
+  } catch {
+    return null;
+  }
+}
+function safeParseJson(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+      return parsed;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+var WECLONE_DEFAULTS = {
+  wecloneApiUrl: "http://localhost:8000/v1",
+  wecloneModelName: "weclone-avatar",
+  proxyPort: 8100,
+  remnicDaemonUrl: "http://localhost:4318",
+  sessionStrategy: "single",
+  memoryInjection: {
+    maxTokens: 1500,
+    position: "system-append",
+    template: "[Memory Context]\n{memories}\n[End Memory Context]"
+  }
+};
+function resolveStringField(userConfig, priorConfig, key, fallback) {
+  const fromUser = userConfig[key];
+  if (typeof fromUser === "string" && fromUser.length > 0) return fromUser;
+  if (priorConfig) {
+    const fromPrior = priorConfig[key];
+    if (typeof fromPrior === "string" && fromPrior.length > 0) return fromPrior;
+  }
+  return fallback;
+}
+function coercePort(value) {
+  if (typeof value === "number" && Number.isInteger(value) && value >= 1 && value <= 65535) {
+    return value;
+  }
+  if (typeof value === "string" && value.length > 0) {
+    const n = Number(value);
+    if (Number.isInteger(n) && n >= 1 && n <= 65535) return n;
+  }
+  return null;
+}
+function resolvePort(userConfig, priorConfig, fallback) {
+  const fromUser = coercePort(userConfig.proxyPort);
+  if (fromUser !== null) return fromUser;
+  if (priorConfig) {
+    const fromPrior = coercePort(priorConfig.proxyPort);
+    if (fromPrior !== null) return fromPrior;
+  }
+  return fallback;
+}
+function resolveSessionStrategy(userConfig, priorConfig) {
+  const valid = /* @__PURE__ */ new Set(["caller-id", "single"]);
+  const fromUser = userConfig.sessionStrategy;
+  if (typeof fromUser === "string" && valid.has(fromUser)) {
+    return fromUser;
+  }
+  if (priorConfig) {
+    const fromPrior = priorConfig.sessionStrategy;
+    if (typeof fromPrior === "string" && valid.has(fromPrior)) {
+      return fromPrior;
+    }
+  }
+  return WECLONE_DEFAULTS.sessionStrategy;
+}
+function buildWeCloneProxyConfig(args) {
+  const { userConfig, priorConfig, authToken } = args;
+  const wecloneApiUrl = resolveStringField(
+    userConfig,
+    priorConfig,
+    "wecloneApiUrl",
+    WECLONE_DEFAULTS.wecloneApiUrl
+  );
+  const wecloneModelName = resolveStringField(
+    userConfig,
+    priorConfig,
+    "wecloneModelName",
+    WECLONE_DEFAULTS.wecloneModelName
+  );
+  const remnicDaemonUrl = resolveStringField(
+    userConfig,
+    priorConfig,
+    "remnicDaemonUrl",
+    WECLONE_DEFAULTS.remnicDaemonUrl
+  );
+  const proxyPort = resolvePort(
+    userConfig,
+    priorConfig,
+    WECLONE_DEFAULTS.proxyPort
+  );
+  const sessionStrategy = resolveSessionStrategy(userConfig, priorConfig);
+  const memoryInjection = {
+    ...WECLONE_DEFAULTS.memoryInjection,
+    ...priorConfig && typeof priorConfig.memoryInjection === "object" && priorConfig.memoryInjection !== null && !Array.isArray(priorConfig.memoryInjection) ? priorConfig.memoryInjection : {},
+    ...typeof userConfig.memoryInjection === "object" && userConfig.memoryInjection !== null && !Array.isArray(userConfig.memoryInjection) ? userConfig.memoryInjection : {}
+  };
+  const config = {
+    wecloneApiUrl,
+    wecloneModelName,
+    proxyPort,
+    remnicDaemonUrl,
+    sessionStrategy,
+    memoryInjection
+  };
+  if (authToken && authToken.length > 0) {
+    config.remnicAuthToken = authToken;
+  } else if (typeof userConfig.remnicAuthToken === "string" && userConfig.remnicAuthToken.length > 0) {
+    config.remnicAuthToken = userConfig.remnicAuthToken;
+  } else if (priorConfig && typeof priorConfig.remnicAuthToken === "string" && priorConfig.remnicAuthToken.length > 0) {
+    config.remnicAuthToken = priorConfig.remnicAuthToken;
+  }
+  return config;
+}
+
+export {
+  DROID_CONNECTOR_MANIFEST,
+  resolveFactoryMcpPath,
+  upsertFactoryMcpRemnicEntry,
+  removeFactoryMcpRemnicEntry,
+  MARKETPLACE_SCHEMA_VERSION,
+  MARKETPLACE_MANIFEST_FILENAME,
+  generateMarketplaceManifest,
+  validateMarketplaceManifest,
+  checkMarketplaceManifest,
+  writeMarketplaceManifest,
+  installFromMarketplace,
+  BUILTIN_CONNECTORS,
+  CONNECTOR_ID_PATTERN,
+  isValidConnectorId,
+  loadRegistry,
+  saveRegistry,
+  listConnectors,
+  getConnectorToken,
+  installConnector,
+  removeConnector,
+  upsertHermesConfig,
+  removeHermesConfig,
+  doctorConnector,
+  resolveCodexHome,
+  resolveCodexMemoryExtensionPaths,
+  locatePluginCodexExtensionSource,
+  installCodexMemoryExtension,
+  removeCodexMemoryExtension,
+  resolveWeCloneProxyConfigPath,
+  buildWeCloneProxyConfig
+};
+//# sourceMappingURL=chunk-GK6NOQE6.js.map