@bcmyguest/openmem 0.0.0-stage → 0.8.0

package/providers/hindsight/lib/coding-agent.mjs

@@ -0,0 +1,204 @@
+/**
+ * Step "9. Coding-agent plugin", Hindsight half: ensure ~/.hindsight/coding-agent.json
+ * exists (seeded from the tracked template when missing) and check that its optInPaths
+ * cover the indexed roots. Machine-local keys such as notebooklmAccess must live in a
+ * real file — never in the repo template — so we do not replace a materialised config
+ * with a symlink (that used to wipe notebooklmAccess.enabled after step 6).
+ * The meta wizard installs the plugin package itself from the manifest.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { realpathSync } from "node:fs";
+import { installNotebooklmMcp } from "./notebooklm-mcp-install.mjs";
+import { setNotebooklmAccessEnabled } from "../../../wizard/lib/notebooklm-agent-access.mjs";
+import { ensureState } from "./state.mjs";
+
+/** @typedef {import("../../../wizard/lib/provider-wizard/helpers.mjs").ProviderWizardHelpers} Helpers */
+
+function realpathSafe(p) {
+  try {
+    return realpathSync(p);
+  } catch {
+    return path.resolve(p);
+  }
+}
+
+/** @param {string} filePath */
+function readJsonSafe(filePath) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+/** True when notebooklm.yml opts the sync service in. */
+function notebooklmSyncEnabled(ctx) {
+  const yml = ctx.notebookFile || path.join(ctx.home, ".config/hindsight/notebooklm.yml");
+  if (!fs.existsSync(yml)) return false;
+  return /^enabled:\s*true\b/m.test(fs.readFileSync(yml, "utf8"));
+}
+
+/**
+ * Seed or keep a real coding-agent.json. Never leave (or create) a symlink to the shipped
+ * template — machine keys such as notebooklmAccess must not write into the repo.
+ *
+ * @param {Record<string, any>} ctx
+ * @param {Helpers} h
+ */
+async function linkAgentConfig(ctx, h) {
+  const rel = ctx.memoryProvider.codingAgent?.configTemplate;
+  if (!rel) return;
+  const target = path.join(ctx.repoRoot, rel);
+  let stat;
+  try {
+    stat = fs.lstatSync(ctx.agentJson);
+  } catch {
+    stat = null;
+  }
+  if (stat?.isSymbolicLink()) {
+    // Copy current contents into a regular file so later writes never hit the template.
+    if (ctx.dry) {
+      h.info(`[dry-run] materialize ${ctx.agentJson} (symlink → regular file)`);
+      return;
+    }
+    const raw = fs.readFileSync(ctx.agentJson, "utf8");
+    fs.unlinkSync(ctx.agentJson);
+    fs.mkdirSync(path.dirname(ctx.agentJson), { recursive: true });
+    fs.writeFileSync(ctx.agentJson, raw.endsWith("\n") ? raw : `${raw}\n`);
+    h.ok(`materialized ${ctx.agentJson} (was symlink → regular file)`);
+    return;
+  }
+  if (stat?.isFile()) {
+    // Keep the real file. Replacing it with a symlink to the shipped template drops
+    // notebooklmAccess.enabled and breaks the NotebookLM MCP on the next Cursor start.
+    h.ok(`${ctx.agentJson} is a machine-local file (not replaced with a symlink)`);
+    return;
+  }
+  // Missing: copy the template into a real file so later notebooklmAccess writes never
+  // land in the repo.
+  if (ctx.dry) {
+    h.info(`[dry-run] create ${ctx.agentJson} from ${rel} (regular file, not a symlink)`);
+    return;
+  }
+  fs.mkdirSync(path.dirname(ctx.agentJson), { recursive: true });
+  const seeded = readJsonSafe(target) || {
+    serverMode: "self-hosted",
+    apiUrl: "http://127.0.0.1:8888",
+    optInOnly: true,
+    optInPaths: [],
+    mapPathToBank: {},
+    notebooklmAccess: { enabled: false, banks: ["*"] },
+  };
+  fs.writeFileSync(ctx.agentJson, `${JSON.stringify(seeded, null, 2)}\n`);
+  h.ok(`created ${ctx.agentJson} from ${rel}`);
+}
+
+/**
+ * If NotebookLM sync is on, keep notebooklmAccess.enabled and the Cursor MCP entry.
+ * Materialises a symlink into a real file first so the flag never writes into the template.
+ *
+ * @param {Record<string, any>} ctx
+ * @param {Helpers} h
+ */
+async function ensureNotebooklmAccess(ctx, h) {
+  if (!notebooklmSyncEnabled(ctx)) return;
+  const templatePath = path.join(ctx.repoRoot, "config/coding-agent.json");
+  if (ctx.dry) {
+    h.info(`[dry-run] keep notebooklmAccess.enabled=true (NotebookLM sync is on)`);
+    return;
+  }
+  const result = setNotebooklmAccessEnabled(ctx.agentJson, templatePath, true);
+  h.ok(
+    `notebooklmAccess.enabled=true in ${ctx.agentJson}` +
+      (result.action === "materialized" ? " (materialized symlink → regular file)" : ""),
+  );
+  await installNotebooklmMcp(
+    { home: ctx.home, repoRoot: ctx.repoRoot, agentJson: ctx.agentJson, dry: false },
+    h,
+  );
+}
+
+/**
+ * @param {Record<string, any>} ctx
+ * @param {Helpers} h
+ * @returns {string[]}
+ */
+function indexRoots(ctx, h) {
+  const source = fs.existsSync(ctx.indexFile)
+    ? ctx.indexFile
+    : path.join(ctx.repoRoot, "config/index.yml");
+  const roots = [];
+  for (const line of fs.readFileSync(source, "utf8").split("\n")) {
+    const m = line.match(/^\s*- path:\s*"?([^"]+)"?/);
+    if (m) roots.push(h.expandHome(m[1].trim(), ctx.home));
+  }
+  return roots;
+}
+
+/**
+ * @param {Record<string, any>} ctx
+ * @param {Helpers} h
+ */
+async function checkOptIn(ctx, h) {
+  // Prefer the live agent config (real file or symlink target). Never write
+  // machine paths into the shipped template unless that is what agentJson resolves to.
+  let target = ctx.agentJson;
+  try {
+    if (fs.lstatSync(ctx.agentJson).isSymbolicLink()) {
+      target = realpathSafe(fs.readlinkSync(ctx.agentJson));
+    }
+  } catch {
+    target = path.join(ctx.repoRoot, "config/coding-agent.json");
+  }
+  if (!fs.existsSync(target)) {
+    target = path.join(ctx.repoRoot, "config/coding-agent.json");
+  }
+  const cfg = JSON.parse(fs.readFileSync(target, "utf8"));
+  if (!Array.isArray(cfg.optInPaths)) cfg.optInPaths = [];
+  const opt = cfg.optInPaths.map((p) => path.resolve(h.expandHome(p, ctx.home)));
+  const missing = [];
+  for (const root of indexRoots(ctx, h)) {
+    const abs = path.resolve(root);
+    const covered = opt.some((p) => abs === p || abs.startsWith(`${p.replace(/\/$/, "")}/`));
+    if (!covered) missing.push(root);
+  }
+  if (!missing.length) {
+    h.ok(`optInPaths in ${target} covers the indexed roots`);
+    return;
+  }
+  h.warn("optInPaths does not cover:");
+  for (const m of missing) h.info(`    ${m}`);
+  if (ctx.dry) {
+    h.info(`[dry-run] offer to add these to optInPaths in ${target}`);
+    return;
+  }
+  const tracked = path.join(ctx.repoRoot, "config/coding-agent.json");
+  const prompt =
+    realpathSafe(target) === realpathSafe(tracked)
+      ? "Add them to optInPaths in the tracked file config/coding-agent.json (shows in git status)?"
+      : `Add them to optInPaths in ${target}?`;
+  if (await h.confirm(ctx, prompt, "n")) {
+    for (const root of missing) {
+      if (!cfg.optInPaths.includes(root)) cfg.optInPaths.push(root);
+    }
+    fs.writeFileSync(target, `${JSON.stringify(cfg, null, 2)}\n`);
+    h.ok(`updated ${target}`);
+  }
+}
+
+/**
+ * @param {Record<string, any>} ctx
+ * @param {Helpers} h
+ */
+export async function setupCodingAgent(ctx, h) {
+  ensureState(ctx);
+  await linkAgentConfig(ctx, h);
+  await checkOptIn(ctx, h);
+  // Step 6 may have set notebooklmAccess on a real file; linkAgentConfig used to
+  // symlink over it. Re-assert after linking, then register the MCP.
+  await ensureNotebooklmAccess(ctx, h);
+  if (!notebooklmSyncEnabled(ctx)) {
+    await installNotebooklmMcp(ctx, h);
+  }
+}

package/providers/hindsight/lib/config.mjs

@@ -0,0 +1,79 @@
+/**
+ * Hindsight's slice of ~/.config/personal-memory/config.toml: [stack] ports and the
+ * [model] table. The meta wizard owns [memory], [stack].project, [wizard] and [tasks].
+ */
+
+/**
+ * Flat Hindsight defaults from a merged TOML config.
+ * @param {Record<string, unknown>} cfg
+ */
+export function defaultsFromConfig(cfg) {
+  const stack = /** @type {Record<string, unknown>} */ (cfg.stack || {});
+  const model = /** @type {Record<string, unknown>} */ (cfg.model || {});
+  const lemond = /** @type {Record<string, unknown>} */ (model.lemond || {});
+  const ollama = /** @type {Record<string, unknown>} */ (model.ollama || {});
+  const meridian = /** @type {Record<string, unknown>} */ (model.meridian || {});
+  return {
+    apiPort: stack.api_port != null ? String(stack.api_port) : "",
+    cpPort: stack.control_plane_port != null ? String(stack.control_plane_port) : "",
+    modelBackend: String(model.backend || ""),
+    modelRetain: String(model.retain || ""),
+    modelReflect: String(model.reflect || ""),
+    modelApiBase: String(model.api_base || ""),
+    lemondHost: String(lemond.host || ""),
+    ollamaHost: String(ollama.host || ""),
+    meridianHost: String(meridian.host || ""),
+  };
+}
+
+/**
+ * Apply config defaults into process.env when env/CLI did not set them.
+ * @param {Record<string, unknown>} cfg
+ */
+export function applyConfigEnv(cfg) {
+  const d = defaultsFromConfig(cfg);
+  if (d.apiPort && !process.env.HINDSIGHT_PORT) process.env.HINDSIGHT_PORT = d.apiPort;
+  if (d.cpPort && !process.env.HINDSIGHT_CP_PORT) process.env.HINDSIGHT_CP_PORT = d.cpPort;
+  if (d.modelBackend && !process.env.PM_BACKEND) process.env.PM_BACKEND = d.modelBackend;
+  if (d.modelRetain && !process.env.PM_DEFAULT_MODEL) {
+    process.env.PM_DEFAULT_MODEL = d.modelRetain;
+  }
+  if (d.modelReflect && !process.env.PM_REFLECT_MODEL) {
+    process.env.PM_REFLECT_MODEL = d.modelReflect;
+  }
+  if (d.modelApiBase && !process.env.MEMORY_API_BASE) {
+    process.env.MEMORY_API_BASE = d.modelApiBase;
+  }
+  if (d.lemondHost && !process.env.LEMOND_BASE) process.env.LEMOND_BASE = d.lemondHost;
+  if (d.meridianHost && !process.env.MERIDIAN_BASE) process.env.MERIDIAN_BASE = d.meridianHost;
+}
+
+/**
+ * Tables merged into config.toml when the wizard saves it.
+ * @param {Record<string, any>} ctx
+ * @returns {Record<string, Record<string, unknown>>}
+ */
+export function configToml(ctx) {
+  const model = {
+    backend: ctx.backend,
+    retain: ctx.model,
+    reflect: ctx.reflectModel || "",
+    api_base: ctx.apiBase || "",
+  };
+  if (ctx.backend === "lemond" || ctx.lemondBase) {
+    model.lemond = { host: ctx.lemondBase };
+  }
+  if (ctx.backend === "ollama" || ctx.ollamaBase) {
+    model.ollama = { host: ctx.ollamaBase };
+  }
+  if (ctx.backend === "meridian" && ctx.meridianBase) {
+    model.meridian = { host: ctx.meridianBase };
+  }
+  return {
+    stack: {
+      api_port: Number(ctx.portApi || 8888),
+      control_plane_port: Number(ctx.portCp || 9999),
+    },
+    model,
+  };
+}

package/providers/hindsight/lib/env-setup.mjs

@@ -0,0 +1,72 @@
+/**
+ * Step "4. Secrets and env", Hindsight half: ~/.config/hindsight/hindsight.env from the
+ * shipped example, then the stack setup script (litellm.env, .env, compose.override.yaml),
+ * then wiring hindsight.env to the LiteLLM proxy.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { ensureState } from "./state.mjs";
+
+/** @typedef {import("../../../wizard/lib/provider-wizard/helpers.mjs").ProviderWizardHelpers} Helpers */
+
+/**
+ * True when hindsight.env points Hindsight at the LiteLLM proxy with the master key.
+ * @param {Record<string, any>} ctx
+ * @param {Helpers} h
+ */
+export function llmWired(ctx, h) {
+  if (h.envValue(ctx.envFile, "HINDSIGHT_API_LLM_BASE_URL") !== "http://litellm:4000/v1") {
+    return false;
+  }
+  const key = h.envValue(ctx.envFile, "HINDSIGHT_API_LLM_API_KEY");
+  const master = h.envValue(ctx.litellmEnv, "LITELLM_MASTER_KEY");
+  return Boolean(key && master && key === master);
+}
+
+/**
+ * Arguments for the meta wizard's stack setup script.
+ * @param {Record<string, any>} ctx
+ */
+export function stackEnv(ctx) {
+  ensureState(ctx);
+  let backend = ctx.backend;
+  // Own-route backends run from litellm.yaml; setup.mjs only knows lemond and ollama.
+  if (backend === "custom" || backend === "meridian") backend = "lemond";
+  /** @type {Record<string, string>} */
+  const env = { MEMORY_BACKEND: backend };
+  if (ctx.ollamaInCompose) env.MEMORY_OLLAMA_IN_COMPOSE = "1";
+  return {
+    description:
+      "scripts/setup.sh: write .env, litellm.env (mode 600 when new), compose.override.yaml",
+    env,
+  };
+}
+
+/**
+ * @param {Record<string, any>} ctx
+ * @param {Helpers} h
+ */
+export async function setupEnv(ctx, h) {
+  ensureState(ctx);
+  const example = path.join(ctx.repoRoot, "config/hindsight.env.example");
+  if (fs.existsSync(ctx.envFile)) h.ok(`kept ${ctx.envFile}`);
+  else if (ctx.dry) h.info(`[dry-run] create ${ctx.envFile} from config/hindsight.env.example (mode 600)`);
+  else {
+    fs.copyFileSync(example, ctx.envFile);
+    fs.chmodSync(ctx.envFile, 0o600);
+    h.ok(`created ${ctx.envFile} (mode 600)`);
+  }
+  await h.runStackSetup(ctx);
+  if (ctx.dry) {
+    h.info(
+      `[dry-run] run setup.sh --migrate-env unless ${ctx.envFile} already uses the LiteLLM proxy and master key`,
+    );
+  } else if (llmWired(ctx, h)) h.ok("Hindsight calls the LiteLLM proxy with the master key");
+  else if (await h.confirm(ctx, `Point ${ctx.envFile} at the LiteLLM proxy now (backs up the file, prints no values)?`, "y")) {
+    await h.runStackSetup(ctx, {
+      description: "migrate hindsight.env",
+      args: ["--migrate-env"],
+      env: {},
+    });
+  } else h.warn("Hindsight is not wired to the LiteLLM proxy; the stack will not work until you migrate");
+}

package/providers/hindsight/lib/litellm-routes.mjs

@@ -0,0 +1,196 @@
+import fs from "node:fs";
+import path from "node:path";
+import { configToml } from "./config.mjs";
+import { renderMeridianRoutes } from "./meridian.mjs";
+import { OLLAMA_HOST_API_BASE } from "./state.mjs";
+
+/** @typedef {import("../../../wizard/lib/provider-wizard/helpers.mjs").ProviderWizardHelpers} Helpers */
+
+/** Shipped litellm.<backend>.yaml api_base for the host-side model server. */
+function shippedApiBase(backend) {
+  if (backend === "ollama") return OLLAMA_HOST_API_BASE;
+  if (backend === "lemond") return "http://host.docker.internal:13305/v1";
+  return "";
+}
+
+/**
+ * @param {Record<string, any>} ctx
+ * @param {string} alias
+ * @param {string} litellmModel
+ */
+function renderRoute(ctx, alias, litellmModel) {
+  let out = `  - model_name: ${alias}\n    litellm_params:\n      model: ${litellmModel}\n      api_base: ${ctx.apiBase}\n`;
+  if (ctx.backend === "ollama") {
+    out += "      extra_body:\n        think: false\n";
+  } else {
+    out += "      api_key: os.environ/LEMOND_API_KEY\n      extra_body:\n        chat_template_kwargs:\n          enable_thinking: false\n";
+  }
+  return out;
+}
+
+/**
+ * @param {Record<string, any>} ctx
+ * @param {string} litellmModel
+ */
+function renderOverride(ctx, litellmModel) {
+  return (
+    "# Written by ./setup. Replaces config/litellm.*.yaml while this file exists.\n" +
+    "# Delete it, or rerun ./setup with the shipped model, to use the shipped routes again.\n" +
+    "# Thinking is off for all three aliases. Non-ollama servers get chat_template_kwargs; a server that rejects it needs a different route.\n" +
+    "model_list:\n" +
+    renderRoute(ctx, "memory-retain", litellmModel) +
+    renderRoute(ctx, "memory-reflect", litellmModel) +
+    renderRoute(ctx, "memory-consolidate", litellmModel) +
+    "general_settings:\n  master_key: os.environ/LITELLM_MASTER_KEY\n"
+  );
+}
+
+/**
+ * @param {Record<string, any>} ctx
+ * @param {string} litellmModel
+ * @param {string} reflectLitellmModel
+ */
+function renderShipped(ctx, litellmModel, reflectLitellmModel) {
+  const src = path.join(ctx.repoRoot, "config", `litellm.${ctx.backend}.yaml`);
+  const lines = fs.readFileSync(src, "utf8").split("\n");
+  const out = [
+    `# Written by ./setup from config/litellm.${ctx.backend}.yaml. Replaces the shipped routes while this file exists.`,
+    "# Delete it, or rerun ./setup with the shipped models, to use the shipped routes again.",
+  ];
+  let name = "";
+  for (const line of lines) {
+    const mn = line.match(/^  - model_name: (\S+)/);
+    if (mn) name = mn[1];
+    if (/^      api_base: /.test(line)) {
+      out.push(`      api_base: ${ctx.apiBase}`);
+      continue;
+    }
+    if (/^      model: /.test(line)) {
+      if (name !== "memory-reflect") out.push(`      model: ${litellmModel}`);
+      else if (reflectLitellmModel) out.push(`      model: ${reflectLitellmModel}`);
+      else out.push(line);
+      continue;
+    }
+    out.push(line);
+  }
+  return `${out.join("\n")}\n`;
+}
+
+/**
+ * @param {Record<string, any>} ctx
+ * @returns {string}
+ */
+export function litellmConfig(ctx) {
+  if (ctx.backend === "meridian") return renderMeridianRoutes(ctx);
+  let prefix = "openai/";
+  if (ctx.backend === "ollama") prefix = "ollama_chat/";
+  if (ctx.backend === "custom") return renderOverride(ctx, `${prefix}${ctx.model}`);
+  let reflect = "";
+  if (ctx.reflectModel) reflect = `${prefix}${ctx.reflectModel}`;
+  return renderShipped(ctx, `${prefix}${ctx.model}`, reflect);
+}
+
+/**
+ * @param {Record<string, any>} ctx
+ * @param {Helpers} h
+ */
+export async function removeOverrideIfAsked(ctx, h) {
+  if (!fs.existsSync(ctx.litellmOverride)) return;
+  if (ctx.dry) {
+    h.info(`[dry-run] move ${ctx.litellmOverride} aside so the shipped ${ctx.backend} routes apply`);
+    return;
+  }
+  if (!(await h.confirm(ctx, `Move ${ctx.litellmOverride} aside so the shipped ${ctx.backend} routes apply?`, "y"))) {
+    h.warn("kept the override; it still takes precedence over the shipped routes");
+    return;
+  }
+  const bak = `${ctx.litellmOverride}.bak-${timestamp()}`;
+  fs.renameSync(ctx.litellmOverride, bak);
+  h.ok("moved the override aside");
+}
+
+/**
+ * @param {Record<string, any>} ctx
+ * @param {Helpers} h
+ */
+export async function writeOverride(ctx, h) {
+  if (ctx.dry && ctx.backend === "meridian") {
+    const backup = fs.existsSync(ctx.litellmOverride) ? " (backs up the existing file)" : "";
+    h.info(
+      `[dry-run] write ${ctx.litellmOverride}${backup}: Meridian routes, retain and consolidate -> anthropic/${ctx.model}, reflect -> anthropic/${ctx.reflectModel || ctx.model}, at ${ctx.apiBase}`,
+    );
+    return;
+  }
+  if (ctx.dry) {
+    h.info(
+      `[dry-run] write ${ctx.litellmOverride} from config/litellm.${ctx.backend}.yaml: retain and consolidate -> ${ctx.model}, reflect -> ${ctx.reflectModel || "shipped"}, at ${ctx.apiBase}`,
+    );
+    return;
+  }
+  h.ensureConfigDir(ctx);
+  const content = litellmConfig(ctx);
+  const tmp = path.join(ctx.hsDir, `.litellm.yaml.${process.pid}`);
+  fs.writeFileSync(tmp, content, { mode: 0o644 });
+  if (fs.existsSync(ctx.litellmOverride)) {
+    const existing = fs.readFileSync(ctx.litellmOverride);
+    if (Buffer.compare(existing, Buffer.from(content)) === 0) {
+      fs.unlinkSync(tmp);
+      h.ok(`${ctx.litellmOverride} already has this route`);
+      return;
+    }
+    if (!(await h.confirm(ctx, `Replace ${ctx.litellmOverride} (the old file is kept as .bak)?`, "y"))) {
+      fs.unlinkSync(tmp);
+      h.warn("kept the existing override; it still takes precedence");
+      return;
+    }
+    fs.copyFileSync(ctx.litellmOverride, `${ctx.litellmOverride}.bak-${timestamp()}`);
+  }
+  fs.renameSync(tmp, ctx.litellmOverride);
+  h.ok(`wrote ${ctx.litellmOverride}`);
+}
+
+/**
+ * @param {Record<string, any>} ctx
+ * @param {Helpers} h
+ */
+export async function applyRoute(ctx, h) {
+  let shipped = "";
+  if (ctx.backend === "lemond") shipped = ctx.lemondDefaultModel;
+  if (ctx.backend === "ollama") shipped = ctx.ollamaDefaultModel;
+  const defaultBase = shippedApiBase(ctx.backend);
+  const apiMatchesShipped = !ctx.apiBase || ctx.apiBase === defaultBase;
+  const ownRoute = ctx.backend === "custom" || ctx.backend === "meridian";
+  if (!ownRoute && ctx.model === shipped && !ctx.reflectModel && apiMatchesShipped) {
+    await removeOverrideIfAsked(ctx, h);
+  } else {
+    await writeOverride(ctx, h);
+  }
+}
+
+function timestamp() {
+  const d = new Date();
+  const p = (n) => String(n).padStart(2, "0");
+  return `${d.getFullYear()}${p(d.getMonth() + 1)}${p(d.getDate())}${p(d.getHours())}${p(d.getMinutes())}${p(d.getSeconds())}`;
+}
+
+/**
+ * Record the backend choice in wizard.conf (and config.toml).
+ * @param {Record<string, any>} ctx
+ * @param {Helpers} h
+ */
+export function saveConf(ctx, h) {
+  if (ctx.dry) {
+    h.info(`[dry-run] record backend ${ctx.backend} in ${ctx.wizardConf}`);
+    return;
+  }
+  /** @type {Record<string, string>} */
+  const keys = {
+    MEMORY_BACKEND: ctx.backend,
+    MEMORY_MODEL: ctx.model,
+    MEMORY_API_BASE: ctx.apiBase,
+    MEMORY_REFLECT_MODEL: ctx.reflectModel,
+    MEMORY_OLLAMA_IN_COMPOSE: ctx.ollamaInCompose ? "1" : "0",
+  };
+  if (ctx.backend === "meridian") keys.MEMORY_MERIDIAN_URL = ctx.meridianBase;
+  h.saveWizardConf(ctx, keys, { pmSections: configToml(ctx) });
+}