@akms/mcp 0.3.1 → 0.4.0

package/lib/cli.js

@@ -1,11 +1,22 @@
 #!/usr/bin/env node
+import fs, { existsSync, readFileSync } from 'fs';
+import path2, { dirname, join } from 'path';
+import { createHash, randomUUID } from 'crypto';
+import os5 from 'os';
+import { spawn, execFile, spawnSync } from 'child_process';
+import { promisify, stripVTControlCharacters, isDeepStrictEqual } from 'util';
+import { parse, TomlError } from 'smol-toml';
+import { fileURLToPath } from 'url';
+
+// src/_defs/version.ts
+var PACKAGE_VERSION = "0.4.0" ;
 
 // src/_defs/index.ts
 var MCP_PACKAGES = {
-  db: { label: "Database", packageName: "@akms/mcp-db", command: "akms-mcp-db", setupCommand: "config" },
-  ssh: { label: "SSH", packageName: "@akms/mcp-ssh", command: "akms-mcp-ssh", setupCommand: "config" },
-  wsl: { label: "WSL", packageName: "@akms/mcp-wsl", command: "akms-mcp-wsl", setupCommand: "config" },
-  s3: { label: "S3", packageName: "@akms/mcp-s3", command: "akms-mcp-s3", setupCommand: "config" }
+  db: { label: "Database", command: "akms-mcp-db", setupCommand: "config" },
+  ssh: { label: "SSH", command: "akms-mcp-ssh", setupCommand: "config" },
+  wsl: { label: "WSL", command: "akms-mcp-wsl", setupCommand: "config" },
+  s3: { label: "S3", command: "akms-mcp-s3", setupCommand: "config" }
 };
 var CLIENT_LABELS = {
   "claude-code": "Claude Code",
@@ -57,16 +68,6 @@ function parseArguments(argv) {
   }
   return parsed;
 }
-
-// src/modules/registration/registry.ts
-import fs4 from "fs";
-import path5 from "path";
-import { createHash } from "crypto";
-
-// src/modules/registration/config-file.ts
-import fs from "fs";
-import path from "path";
-import { randomUUID } from "crypto";
 function readExisting(filePath) {
   try {
     return fs.readFileSync(filePath, "utf8");
@@ -96,8 +97,8 @@ function updateConfigFile(filePath, update, options = {}) {
   if (before != null) {
     fs.accessSync(destination, fs.constants.W_OK);
   }
-  fs.mkdirSync(path.dirname(destination), { recursive: true });
-  const temporary = path.join(path.dirname(destination), `.${path.basename(destination)}.${randomUUID()}.tmp`);
+  fs.mkdirSync(path2.dirname(destination), { recursive: true });
+  const temporary = path2.join(path2.dirname(destination), `.${path2.basename(destination)}.${randomUUID()}.tmp`);
   const mode = options.mode ?? (before == null ? 384 : fs.statSync(destination).mode & 511);
   let descriptor;
   let ownsTemporary = false;
@@ -136,25 +137,25 @@ var CLIENT_LABELS2 = {
   cursor: "Cursor"
 };
 var KINDS = ["db", "ssh", "wsl", "s3"];
-
-// src/modules/registration/runtime.ts
-import fs2 from "fs";
-import os from "os";
-import path2 from "path";
-import { execFile } from "child_process";
-import { promisify, stripVTControlCharacters } from "util";
-var packageName = (kind) => `@akms/mcp-${kind}`;
+var KIND_LABELS = { db: "Database", ssh: "SSH", wsl: "WSL", s3: "S3" };
+var PACKAGE_NAME = "@akms/mcp";
+var legacyPackageName = (kind) => `@akms/mcp-${kind}`;
 var binary = (command) => command.replace(/\\/g, "/").split("/").pop().toLowerCase();
+var posixPath = (value) => value?.replace(/\\/g, "/") ?? "";
+var isNode = (command) => /^(node|nodejs)(\.exe)?$/.test(binary(command));
+var isCurrentScript = (script, kind) => posixPath(script).endsWith(`/node_modules/@akms/mcp/lib/${kind}.js`);
+var isLegacyScript = (script, kind) => posixPath(script).endsWith(`/node_modules/@akms/mcp-${kind}/lib/cli.js`);
+var isLegacyPackageArgument = (argument, kind) => new RegExp(`^@akms/mcp-${kind}(?:@[^\\s]+)?$`).test(argument);
 function runtimePrefix() {
-  return path2.join(process.env.AKMS_MCP_HOME ? path2.resolve(process.env.AKMS_MCP_HOME) : path2.join(os.homedir(), ".akms", "mcp"), "runtime");
+  return path2.join(process.env.AKMS_MCP_HOME ? path2.resolve(process.env.AKMS_MCP_HOME) : path2.join(os5.homedir(), ".akms", "mcp"), "runtime");
 }
 function runtimeRoot(prefix = runtimePrefix(), platform = process.platform) {
   return path2.join(prefix, ...platform === "win32" ? [] : ["lib"], "node_modules");
 }
-var runtimeInstallCommand = (kind) => `npm install --global --prefix "${runtimePrefix()}" ${packageName(kind)}@latest`;
-async function latestRuntimeVersion(kind, timeoutMs = 6e3) {
+var runtimeInstallCommand = () => `npm install --global --prefix "${runtimePrefix()}" ${PACKAGE_NAME}@latest`;
+async function latestRuntimeVersion(timeoutMs = 6e3) {
   try {
-    const { stdout } = await promisify(execFile)(process.execPath, [npmCli(), "view", `${packageName(kind)}@latest`, "version", "--json", "--prefer-online", "--fetch-retries=0", "--fetch-timeout=4000"], {
+    const { stdout } = await promisify(execFile)(process.execPath, [npmCli(), "view", `${PACKAGE_NAME}@latest`, "version", "--json", "--prefer-online", "--fetch-retries=0", "--fetch-timeout=4000"], {
       windowsHide: true,
       timeout: timeoutMs,
       maxBuffer: 65536
@@ -186,26 +187,33 @@ function runtimeIsOlder(installed, current) {
 }
 function launchKind(entry) {
   for (const kind of KINDS) {
-    if (new RegExp(`^akms-mcp-${kind}(?:\\.cmd|\\.exe)?$`).test(binary(entry.command)) || entry.args.some((arg) => new RegExp(`^@akms/mcp-${kind}(?:@[^\\s]+)?$`).test(arg))) return kind;
-    if (/^(node|nodejs)(\.exe)?$/.test(binary(entry.command)) && entry.args[0]?.replace(/\\/g, "/").endsWith(`/node_modules/@akms/mcp-${kind}/lib/cli.js`)) return kind;
+    if (new RegExp(`^akms-mcp-${kind}(?:\\.cmd|\\.exe)?$`).test(binary(entry.command)) || entry.args.some((arg) => isLegacyPackageArgument(arg, kind))) return kind;
+    if (isNode(entry.command) && (isCurrentScript(entry.args[0], kind) || isLegacyScript(entry.args[0], kind))) return kind;
   }
   return null;
 }
 function standardLaunch(entry, kind) {
   if (launchKind(entry) !== kind) return false;
   const command = binary(entry.command);
-  if (/^(node|nodejs)(\.exe)?$/.test(command)) return entry.args.length === 1 && entry.args[0].replace(/\\/g, "/").endsWith(`/node_modules/@akms/mcp-${kind}/lib/cli.js`);
+  if (isNode(entry.command)) return entry.args.length === 1 && (isCurrentScript(entry.args[0], kind) || isLegacyScript(entry.args[0], kind));
   if (new RegExp(`^akms-mcp-${kind}(?:\\.cmd|\\.exe)?$`).test(command)) return entry.args.length === 0;
   let args = entry.args;
   if (command === "cmd" || command === "cmd.exe") {
     if (args[0]?.toLowerCase() !== "/c" || !/^npx(?:\.cmd)?$/i.test(args[1] ?? "")) return false;
     args = args.slice(2);
   } else if (!/^npx(?:\.cmd)?$/.test(command)) return false;
-  return args.length === 2 && ["-y", "--yes"].includes(args[0]) && new RegExp(`^@akms/mcp-${kind}(?:@[^\\s]+)?$`).test(args[1]);
+  return args.length === 2 && ["-y", "--yes"].includes(args[0]) && isLegacyPackageArgument(args[1], kind);
 }
 function catalogLaunch(entry, kind = launchKind(entry)) {
   return !!kind && entry.args.length === 2 && entry.args[1] === "--catalog" && standardLaunch({ ...entry, args: entry.args.slice(0, 1) }, kind);
 }
+function legacyLaunch(entry, kind = launchKind(entry)) {
+  if (!kind) return false;
+  const launch = catalogLaunch(entry, kind) ? { ...entry, args: entry.args.slice(0, 1) } : entry;
+  if (!standardLaunch(launch, kind)) return false;
+  if (isNode(launch.command)) return isLegacyScript(launch.args[0], kind);
+  return launch.args.some((arg) => isLegacyPackageArgument(arg, kind));
+}
 function npmCli() {
   const candidates = [
     path2.join(path2.dirname(process.execPath), "node_modules", "npm", "bin", "npm-cli.js"),
@@ -219,8 +227,8 @@ function npmCli() {
   }
   for (const file of candidates) {
     try {
-      const resolved = fs2.realpathSync(file);
-      if (resolved.endsWith(".js") && fs2.statSync(resolved).isFile()) return resolved;
+      const resolved = fs.realpathSync(file);
+      if (resolved.endsWith(".js") && fs.statSync(resolved).isFile()) return resolved;
     } catch {
     }
   }
@@ -228,34 +236,46 @@ function npmCli() {
 }
 function findGlobalRuntime(kind, root) {
   try {
-    const directory = path2.join(root ?? runtimeRoot(), "@akms", `mcp-${kind}`);
-    const metadata = JSON.parse(fs2.readFileSync(path2.join(directory, "package.json"), "utf8"));
-    const bin = typeof metadata.bin === "string" ? metadata.bin : metadata.bin?.[`akms-mcp-${kind}`];
-    const script = path2.join(directory, "lib", "cli.js");
-    if (metadata.name !== packageName(kind) || !["lib/cli.js", "./lib/cli.js"].includes(bin) || typeof metadata.version !== "string" || !fs2.statSync(script).isFile()) return null;
-    return { command: process.execPath, args: [script], version: metadata.version, linked: fs2.lstatSync(directory).isSymbolicLink() };
+    const directory = path2.join(root ?? runtimeRoot(), "@akms", "mcp");
+    const metadata = JSON.parse(fs.readFileSync(path2.join(directory, "package.json"), "utf8"));
+    const script = path2.join(directory, "lib", `${kind}.js`);
+    if (metadata.name !== PACKAGE_NAME || typeof metadata.version !== "string" || !fs.statSync(script).isFile()) return null;
+    return { command: process.execPath, args: [script], version: metadata.version, linked: fs.lstatSync(directory).isSymbolicLink() };
   } catch {
     return null;
   }
 }
-async function installGlobalRuntime(kind) {
+function findLegacyRuntimes(root) {
+  const found = [];
+  for (const kind of KINDS) {
+    try {
+      const directory = path2.join(root ?? runtimeRoot(), "@akms", `mcp-${kind}`);
+      const metadata = JSON.parse(fs.readFileSync(path2.join(directory, "package.json"), "utf8"));
+      if (metadata.name !== legacyPackageName(kind)) continue;
+      found.push({ kind, packageName: legacyPackageName(kind), version: typeof metadata.version === "string" ? metadata.version : "unknown", linked: fs.lstatSync(directory).isSymbolicLink() });
+    } catch {
+    }
+  }
+  return found;
+}
+async function runNpm(argumentsList, failure, retry) {
   const cancellation = new AbortController();
   const cancel = () => cancellation.abort();
   process.on("SIGINT", cancel);
   process.on("SIGTERM", cancel);
   try {
-    await promisify(execFile)(process.execPath, [npmCli(), "install", "--global", "--prefix", runtimePrefix(), "--prefer-online", "--no-fund", "--no-audit", `${packageName(kind)}@latest`], {
+    await promisify(execFile)(process.execPath, [npmCli(), ...argumentsList], {
       windowsHide: true,
       timeout: 18e4,
       maxBuffer: 1024 * 1024,
       signal: cancellation.signal,
-      cwd: os.homedir()
+      cwd: os5.homedir()
     });
   } catch (error) {
     if (cancellation.signal.aborted) throw new Error("AKMS runtime installation cancelled.");
     const stderr = error.stderr;
     const detail = stripVTControlCharacters(typeof stderr === "string" ? stderr : error instanceof Error ? error.message : "").replace(/[\x00-\x08\x0b-\x1f\x7f]/g, "").trim().split(/\r?\n/).slice(-6).map((line) => line.slice(0, 500)).join("\n");
-    throw new Error(`AKMS runtime installation failed. Run ${runtimeInstallCommand(kind)} in your terminal and retry.${detail ? `
+    throw new Error(`${failure} Run ${retry} in your terminal and retry.${detail ? `
 
 ${detail}` : ""}`);
   } finally {
@@ -263,13 +283,24 @@ ${detail}` : ""}`);
     process.off("SIGTERM", cancel);
   }
 }
+async function installGlobalRuntime() {
+  await runNpm(
+    ["install", "--global", "--prefix", runtimePrefix(), "--prefer-online", "--no-fund", "--no-audit", `${PACKAGE_NAME}@latest`],
+    "AKMS runtime installation failed.",
+    runtimeInstallCommand()
+  );
+}
+async function removeLegacyRuntimes(kinds) {
+  if (!kinds.length) return;
+  const names = kinds.map(legacyPackageName);
+  await runNpm(
+    ["uninstall", "--global", "--prefix", runtimePrefix(), "--no-fund", "--no-audit", ...names],
+    "Removing the old packages failed.",
+    `npm uninstall --global --prefix "${runtimePrefix()}" ${names.join(" ")}`
+  );
+}
 
-// src/modules/registration/startup-check.ts
-import { spawn, execFile as execFile2 } from "child_process";
-import path3 from "path";
-import { stripVTControlCharacters as stripVTControlCharacters2 } from "util";
-
-// src/modules/launcher/prompter.ts
+// src/modules/prompt-errors.ts
 var PromptClosedError = class extends Error {
   constructor() {
     super("input closed before the prompt was answered");
@@ -282,6 +313,8 @@ var PromptBackError = class extends Error {
     this.name = "PromptBackError";
   }
 };
+
+// src/modules/launcher/prompter.ts
 var ESC = "\x1B";
 var KEY_UP = [`${ESC}[A`, `${ESC}OA`];
 var KEY_DOWN = [`${ESC}[B`, `${ESC}OB`];
@@ -373,6 +406,8 @@ function createStyle(enabled) {
   return {
     accent: paint(36, 39),
     success: paint(32, 39),
+    warning: paint(33, 39),
+    error: paint(31, 39),
     dim: paint(2, 22),
     bold: paint(1, 22)
   };
@@ -381,6 +416,26 @@ var Prompter = class {
   constructor(input, output, initialInput = "") {
     this.input = input;
     this.output = output;
+    this.lineBuffer = "";
+    this.pendingLines = [];
+    this.lineWaiter = null;
+    this.inputEnded = false;
+    this.onInputData = (chunk) => {
+      this.onData(chunk);
+    };
+    this.onInputEnd = () => {
+      this.inputEnded = true;
+      if (this.lineWaiter != null) {
+        const waiter = this.lineWaiter;
+        this.lineWaiter = null;
+        waiter(null);
+      }
+      if (this.keyHandler != null) {
+        this.keyHandler(KEY_CTRL_D);
+      }
+    };
+    /** Set while a key-driven prompt owns the input. */
+    this.keyHandler = null;
     const ttyInput = input;
     const ttyOutput = output;
     this.interactive = ttyInput.isTTY == true && ttyInput.setRawMode != null && ttyOutput.isTTY == true;
@@ -396,31 +451,6 @@ var Prompter = class {
     input.on("end", this.onInputEnd);
     if (initialInput) this.onData(initialInput);
   }
-  input;
-  output;
-  lineBuffer = "";
-  pendingLines = [];
-  lineWaiter = null;
-  inputEnded = false;
-  onInputData = (chunk) => {
-    this.onData(chunk);
-  };
-  onInputEnd = () => {
-    this.inputEnded = true;
-    if (this.lineWaiter != null) {
-      const waiter = this.lineWaiter;
-      this.lineWaiter = null;
-      waiter(null);
-    }
-    if (this.keyHandler != null) {
-      this.keyHandler(KEY_CTRL_D);
-    }
-  };
-  /** Set while a key-driven prompt owns the input. */
-  keyHandler = null;
-  interactive;
-  style;
-  symbols;
   /** Stops reading so the process can exit once the command is done. */
   close() {
     if (this.interactive == true) {
@@ -595,6 +625,9 @@ var Prompter = class {
       if (item.hint != null && item.hint !== "") {
         line += `  ${item.hint}`;
       }
+      if (item.notice != null && item.notice !== "") {
+        line += `  ${item.notice}`;
+      }
       this.output.write(`${line.trimEnd()}
 `);
     }
@@ -719,6 +752,9 @@ var Prompter = class {
         if (item.hint != null && item.hint !== "") {
           parts.push({ text: `  ${item.hint}`, paint: this.style.dim });
         }
+        if (item.notice != null && item.notice !== "") {
+          parts.push({ text: `  ${item.notice}`, paint: this.style[item.noticeTone ?? "warning"] });
+        }
         lines.push(this.fitLine(parts, width));
       }
       lines.push(this.fitLine([{ text: "\u2191\u2193 move \xB7 enter select \xB7 esc back", paint: this.style.dim }], width));
@@ -789,14 +825,14 @@ var fieldName = (field) => {
   const names = { command: "Launch command", args: "Launch arguments", DB_HOST: "Host", SSH_HOST: "Host", DB_PORT: "Port", SSH_PORT: "Port", DB_NAME: "Database", DB_USER: "User", SSH_USER: "User", WSL_USER: "User", WSL_DISTRO: "Linux distribution", S3_BUCKET: "Bucket", S3_REGION: "Region", S3_PREFIX: "Key prefix" };
   return Object.hasOwn(names, key) ? names[key] : plainText(key);
 };
-function writeWrapped(prompter, text, indent = "", changed) {
+function writeWrapped(prompter, text, indent = "", changed, style) {
   const characters = Array.from(plainText(text));
   let line = indent;
   let width = displayWidth(indent);
   let segment = "";
   let highlighted = false;
   const flush = () => {
-    line += highlighted ? prompter.paint.accent(prompter.paint.bold(segment)) : segment;
+    line += highlighted ? prompter.paint.accent(prompter.paint.bold(segment)) : style ? style(segment) : segment;
     segment = "";
   };
   for (let index = 0; index < characters.length; index++) {
@@ -834,20 +870,54 @@ function changedRange(values, index) {
 function compareEntries(prompter, versions) {
   const entries = versions.map((version) => version.entry);
   const fields = differingFields(entries);
-  writeWrapped(prompter, descriptionOnly(entries) ? "Description differs. Connection settings match." : `${fields.length} setting(s) differ.`);
+  if (descriptionOnly(entries)) prompter.write(`${prompter.paint.warning("Description differs.")} ${prompter.paint.dim("Connection settings match.")}
+`);
+  else prompter.write(`${prompter.paint.accent(String(fields.length))} ${prompter.paint.warning("setting(s) differ.")}
+`);
   const values = fields.map((field) => {
     const key = field.replace(/^env\./, "");
     return versions.map(({ entry }) => field.startsWith("env.") && visibleField.test(key) ? Object.hasOwn(entry.env, key) ? plainText(entry.env[key]) || "(empty)" : "(not set)" : "(hidden)");
   });
+  if (versions.length === 2 && prompter.width >= 90) {
+    const width = Math.floor((prompter.width - 3) / 2);
+    const wrap = (value, changed) => {
+      const lines = [{ text: "", width: 0 }];
+      for (const [index, character] of Array.from(value).entries()) {
+        const size = displayWidth(character);
+        if (lines[lines.length - 1].width + size > width) lines.push({ text: "", width: 0 });
+        const line = lines[lines.length - 1];
+        line.text += prompter.paint.accent(changed && index >= changed[0] && index < changed[1] ? prompter.paint.bold(character) : character);
+        line.width += size;
+      }
+      return lines;
+    };
+    const row = (left, right) => {
+      for (let line = 0; line < Math.max(left.length, right.length); line++) {
+        prompter.write(`${left[line]?.text ?? ""}${" ".repeat(width - (left[line]?.width ?? 0))} | ${right[line]?.text ?? ""}
+`);
+      }
+    };
+    prompter.write("\n");
+    row(wrap(`[1] ${plainText(versions[0].label)}`), wrap(`[2] ${plainText(versions[1].label)}`));
+    for (let field = 0; field < fields.length; field++) {
+      prompter.write(`
+${prompter.paint.dim(fieldName(fields[field]))}
+`);
+      row(wrap(values[field][0], changedRange(values[field], 0)), wrap(values[field][1], changedRange(values[field], 1)));
+    }
+    if (values.some((row2) => row2.includes("(hidden)"))) prompter.write(prompter.paint.dim("\nSecret values are hidden.\n"));
+    prompter.write("\n");
+    return;
+  }
   for (let index = 0; index < versions.length; index++) {
     prompter.write("\n");
-    writeWrapped(prompter, `[${index + 1}] ${versions[index].label}`);
+    writeWrapped(prompter, `[${index + 1}] ${versions[index].label}`, "", void 0, prompter.paint.bold);
     for (let field = 0; field < fields.length; field++) {
-      writeWrapped(prompter, fieldName(fields[field]), "  ");
-      writeWrapped(prompter, values[field][index], "    ", changedRange(values[field], index));
+      writeWrapped(prompter, fieldName(fields[field]), "  ", void 0, prompter.paint.dim);
+      writeWrapped(prompter, values[field][index], "    ", changedRange(values[field], index), prompter.paint.accent);
     }
   }
-  if (values.some((row) => row.includes("(hidden)"))) prompter.write("\nSecret values are hidden.\n");
+  if (values.some((row) => row.includes("(hidden)"))) prompter.write(prompter.paint.dim("\nSecret values are hidden.\n"));
   prompter.write("\n");
 }
 
@@ -857,7 +927,7 @@ function visibleRuntimePath(entry) {
   return kind && standardLaunch({ ...entry, args: entry.args.slice(0, 1) }, kind) && (entry.args.length === 1 || entry.args.length === 2 && entry.args[1] === "--catalog") ? entry.args[0] : void 0;
 }
 function redactStartupText(text, entry) {
-  const normalize2 = (value) => stripVTControlCharacters2(value).replace(/[\x00-\x08\x0b-\x1f\x7f]/g, "");
+  const normalize2 = (value) => stripVTControlCharacters(value).replace(/[\x00-\x08\x0b-\x1f\x7f]/g, "");
   const direct = visibleRuntimePath(entry);
   const privateValues = [...Object.entries(entry.env).filter(([key]) => !visibleField.test(key)).map(([, value]) => value), ...entry.args.slice(direct ? 1 : 0)];
   const secrets = /* @__PURE__ */ new Set();
@@ -926,7 +996,7 @@ async function checkStartup(entry, timeoutMs = 1e4) {
       child.stdin?.end();
       killTimer = setTimeout(() => {
         if (process.platform === "win32" && child.pid) {
-          execFile2(path3.join(process.env.SYSTEMROOT ?? "C:\\Windows", "System32", "taskkill.exe"), ["/PID", String(child.pid), "/T", "/F"], { windowsHide: true, timeout: 4e3 }, () => {
+          execFile(path2.join(process.env.SYSTEMROOT ?? "C:\\Windows", "System32", "taskkill.exe"), ["/PID", String(child.pid), "/T", "/F"], { windowsHide: true, timeout: 4e3 }, () => {
           });
         } else if (child.pid) {
           try {
@@ -1045,28 +1115,32 @@ async function checkConnections(prompter, entries, check = checkStartup) {
     const missing = prefixes?.filter((prefix) => !covered.has(prefix)) ?? [];
     if (result.ok && missing.length) result = { ...result, ok: false, detail: `Missing connection tools: ${missing.map((prefix) => prefix.slice(0, -2)).join(", ")}. Review catalog status before reconnecting.` };
     const safe = (value) => [entry, ...maskEntries ?? []].reduce((text, source) => redactStartupText(text, source), value);
-    writeWrapped(prompter, safe(result.ok ? `OK ${name}: ${result.server}@${result.version}, ${result.tools} tools` : `FAILED ${name}: exit ${result.exitCode ?? "unavailable"}. ${result.detail ?? "Server failed to start."}`));
+    writeWrapped(prompter, safe(result.ok ? `OK ${name}: ${result.server}@${result.version}, ${result.tools} tools` : `FAILED ${name}: exit ${result.exitCode ?? "unavailable"}. ${result.detail ?? "Server failed to start."}`), "", void 0, result.ok ? prompter.paint.success : prompter.paint.error);
     if (!result.ok) {
       failed = true;
-      for (const line of result.stderr) writeWrapped(prompter, safe(line), "  ");
+      for (const line of result.stderr) writeWrapped(prompter, safe(line), "  ", void 0, prompter.paint.dim);
     }
   }
   if (failed) prompter.write("Settings remain saved. Fix failed startup checks before restarting or reconnecting your AI clients.\n");
 }
-
-// src/modules/registration/catalog.ts
-import fs3 from "fs";
-import os2 from "os";
-import path4 from "path";
 var LONGEST_TOOL_NAME_LENGTH = { db: 13, ssh: 17, wsl: 17, s3: 11 };
 var maxConnectionNameLength = (kind) => 64 - `mcp__akms_${kind}__`.length - 2 - LONGEST_TOOL_NAME_LENGTH[kind];
-var defaultCatalogPath = () => path4.join(process.env.AKMS_MCP_HOME ? path4.resolve(process.env.AKMS_MCP_HOME) : path4.join(os2.homedir(), ".akms", "mcp"), "registry.json");
+var defaultCatalogPath = () => path2.join(process.env.AKMS_MCP_HOME ? path2.resolve(process.env.AKMS_MCP_HOME) : path2.join(os5.homedir(), ".akms", "mcp"), "registry.json");
 
 // src/modules/registration/registry.ts
 var sessionName = (kind) => `akms_${kind}`;
+function legacyLaunches(state) {
+  return KINDS.map((kind) => ({ kind, names: [
+    ...state.sessions?.[kind] && legacyLaunch(state.sessions[kind].entry, kind) ? [sessionName(kind)] : [],
+    ...Object.entries(state.connections).filter(([, item]) => item.kind === kind && item.entry && legacyLaunch(item.entry, kind)).map(([name]) => name)
+  ] })).filter((item) => item.names.length);
+}
 var MIGRATION_STEPS = [
   { id: "v1_to_v2", label: "Upgrade registry version 1 to version 2", needed: (state) => state.version === 1 },
-  { id: "catalog_default", label: "Record catalog mode as the default for new kinds", needed: (state) => state.defaultMode === void 0 }
+  { id: "catalog_default", label: "Make one entry per kind the default", needed: (state) => state.defaultMode === void 0 },
+  // Every kind is grouped: one akms_<kind> entry per AI service. Per-connection entries are a 0.2 layout to convert, not a choice.
+  { id: "group_all", label: "Group every kind's connections into one akms_<kind> entry", needed: (state) => state.version === 2 && (state.defaultMode === "individual" || Object.values(state.sessions ?? {}).some((session) => session?.mode === "individual")) },
+  { id: "single_package", label: "Start servers from @akms/mcp instead of the separate per-kind packages", needed: (state) => legacyLaunches(state).length > 0 }
 ];
 var own = (value, key) => Object.hasOwn(value, key);
 var record = (value) => value != null && typeof value === "object" && !Array.isArray(value);
@@ -1101,18 +1175,45 @@ var Registry = class {
   constructor(targets, file = defaultRegistryPath(), runtimeOptions = {}) {
     this.targets = targets;
     this.runtimeOptions = runtimeOptions;
+    this.backupCaptured = false;
     this.file = file;
   }
-  targets;
-  runtimeOptions;
-  file;
-  observedText;
-  backupCaptured = false;
   globalRuntime(kind) {
     return (this.runtimeOptions.find ?? findGlobalRuntime)(kind);
   }
-  latestRuntime(kind) {
-    return (this.runtimeOptions.latest ?? latestRuntimeVersion)(kind);
+  /** The installed @akms/mcp, whichever kind is asked: one package carries them all. */
+  installedRuntime() {
+    return this.globalRuntime("db");
+  }
+  latestRuntime() {
+    return (this.runtimeOptions.latest ?? latestRuntimeVersion)();
+  }
+  /**
+   * Per-kind packages left in the runtime directory, with the services or catalog entries
+   * that still start them. A service that cannot be read counts as using every one of them.
+   */
+  legacyRuntimes() {
+    const state = this.read();
+    return (this.runtimeOptions.legacy ?? findLegacyRuntimes)().map((runtime) => {
+      const usedBy = legacyLaunches(state).filter((item) => item.kind === runtime.kind).flatMap((item) => item.names.map((name) => `AKMS catalog: ${name}`));
+      for (const target of this.targets) {
+        try {
+          for (const [name, entry] of Object.entries(target.readEntries())) {
+            const launch = catalogLaunch(entry, runtime.kind) ? { ...entry, args: entry.args.slice(0, 1) } : entry;
+            if (legacyLaunch(launch, runtime.kind) && /^(node|nodejs)(\.exe)?$/i.test(path2.basename(launch.command))) usedBy.push(`${target.label}: ${name}`);
+          }
+        } catch {
+          usedBy.push(`${target.label}: cannot be read`);
+        }
+      }
+      return { runtime, usedBy };
+    });
+  }
+  /** Removes only packages nothing uses at the moment of removal. */
+  async removeLegacyRuntimes(kinds) {
+    const inUse = this.legacyRuntimes().filter((item) => kinds.includes(item.runtime.kind) && item.usedBy.length);
+    if (inUse.length) throw new RegistryError(`Still in use: ${inUse.map((item) => item.runtime.packageName).join(", ")}. Run Migrate registry and Sync first.`);
+    await (this.runtimeOptions.removeLegacy ?? removeLegacyRuntimes)(kinds);
   }
   isSessionMode(kind, state = this.read()) {
     return state.version === 2 && (state.sessions?.[kind]?.mode ?? state.defaultMode) === "catalog";
@@ -1123,9 +1224,10 @@ var Registry = class {
   planMigration() {
     const state = this.read();
     const steps = MIGRATION_STEPS.filter((step) => step.needed(state)).map(({ id, label }) => ({ id, label }));
-    const kinds = steps.length ? KINDS.map((kind) => {
+    const launches = legacyLaunches(state).map((item) => ({ ...item, ready: this.globalRuntime(item.kind) != null }));
+    const layoutChanges = steps.some((step) => step.id === "v1_to_v2" || step.id === "catalog_default" || step.id === "group_all");
+    const kinds = layoutChanges ? KINDS.map((kind) => {
       const names = Object.entries(state.connections).filter(([, item]) => item.kind === kind && item.entry).map(([name]) => name);
-      if (state.sessions?.[kind]?.mode === "individual") return { kind, names, status: "individual" };
       if (this.isSessionMode(kind, state)) return { kind, names, status: "catalog" };
       if (!names.length) return { kind, names, status: "empty" };
       try {
@@ -1152,7 +1254,7 @@ var Registry = class {
         return { kind, names, status: "blocked", detail: error instanceof RegistryError ? error.message : "Cannot preview this kind. Check its runtime and catalog settings." };
       }
     }) : [];
-    return { expected: JSON.stringify(state), steps, kinds };
+    return { expected: JSON.stringify(state), steps, kinds, launches };
   }
   applyMigration(plan) {
     if (!plan.steps.length) return this.locked(() => {
@@ -1171,21 +1273,28 @@ var Registry = class {
           state.version = 2;
           state.sessions ??= {};
         } else if (step.id === "catalog_default") state.defaultMode = "catalog";
-        else throw new RegistryError("Unknown registry migration step. Reopen Migrate registry.");
-      }
-    }, plan.kinds.filter((item) => item.status === "convert" || item.status === "pending-runtime").map((item) => item.kind));
-  }
-  setDefaultMode(mode) {
-    return this.change((state) => {
-      if (state.version !== 2 || state.defaultMode === void 0) throw new RegistryError("Migrate registry before changing the default for new kinds.");
-      if (state.defaultMode === mode) return;
-      for (const kind of KINDS) if (!state.sessions?.[kind] && Object.values(state.connections).some((item) => item.kind === kind && item.entry)) {
-        if (!this.globalRuntime(kind)) throw new RegistryError("Set up the pending runtimes and run Sync before changing the default for new kinds.");
-        state.sessions ??= {};
-        state.sessions[kind] = { mode: this.isSessionMode(kind, state) ? "catalog" : "individual", entry: this.sessionEntry(kind), applied: {} };
+        else if (step.id === "group_all") {
+          state.defaultMode = "catalog";
+          for (const kind of KINDS) if (state.sessions?.[kind]?.mode === "individual") delete state.sessions[kind];
+        } else if (step.id === "single_package") {
+          for (const item of plan.launches) {
+            const runtime = this.globalRuntime(item.kind);
+            if (runtime != null !== item.ready) throw new RegistryError("Runtime availability changed since review. Reopen Migrate registry.");
+            if (!runtime) continue;
+            const session = state.sessions?.[item.kind];
+            if (session && legacyLaunch(session.entry, item.kind)) session.entry = this.sessionEntry(item.kind);
+            for (const connection of Object.values(state.connections)) {
+              if (connection.kind === item.kind && connection.entry && legacyLaunch(connection.entry, item.kind)) {
+                connection.entry = { ...connection.entry, command: runtime.command, args: [...runtime.args] };
+              }
+            }
+          }
+        } else throw new RegistryError("Unknown registry migration step. Reopen Migrate registry.");
       }
-      state.defaultMode = mode;
-    }, []);
+    }, [.../* @__PURE__ */ new Set([
+      ...plan.kinds.filter((item) => item.status === "convert" || item.status === "pending-runtime").map((item) => item.kind),
+      ...plan.launches.filter((item) => item.ready).map((item) => item.kind)
+    ])]);
   }
   kindForName(name, state = this.read()) {
     return own(state.connections, name) ? state.connections[name].kind : KINDS.find((kind) => sessionName(kind) === name && (state.sessions?.[kind] || this.isSessionMode(kind, state)));
@@ -1195,10 +1304,10 @@ var Registry = class {
     if (KINDS.some((value) => sessionName(value) === name)) throw new RegistryError("Names akms_db, akms_ssh, akms_wsl and akms_s3 are reserved for session servers. Choose another name.");
   }
   sessionEntry(kind) {
-    if (path5.basename(this.file) !== "registry.json") throw new RegistryError("Session mode requires a catalog named registry.json in the AKMS catalog directory.");
+    if (path2.basename(this.file) !== "registry.json") throw new RegistryError("Session mode requires a catalog named registry.json in the AKMS catalog directory.");
     const runtime = this.requireRuntime(kind);
     const env = {};
-    if (process.env.AKMS_MCP_HOME || path5.resolve(this.file) !== path5.resolve(defaultCatalogPath())) env.AKMS_MCP_HOME = path5.dirname(path5.resolve(this.file));
+    if (process.env.AKMS_MCP_HOME || path2.resolve(this.file) !== path2.resolve(defaultCatalogPath())) env.AKMS_MCP_HOME = path2.dirname(path2.resolve(this.file));
     return { command: runtime.command, args: [...runtime.args, "--catalog"], env };
   }
   planSession(kind, mode) {
@@ -1266,49 +1375,21 @@ var Registry = class {
     }
     await checkConnections(prompter, entries, this.runtimeOptions.check);
   }
-  async installRuntime(kind) {
-    if (this.globalRuntime(kind)?.linked) throw new RegistryError("This is a linked development installation. Build or update its source checkout instead.");
-    await (this.runtimeOptions.install ?? installGlobalRuntime)(kind);
+  /** Installs or updates @akms/mcp, which carries every kind; returns the given kind's launch. */
+  async installRuntime(kind = "db") {
+    if (this.installedRuntime()?.linked) throw new RegistryError("This is a linked development installation. Build or update its source checkout instead.");
+    await (this.runtimeOptions.install ?? installGlobalRuntime)();
     return this.requireRuntime(kind);
   }
   requireRuntime(kind) {
     const runtime = this.globalRuntime(kind);
-    if (!runtime) throw new RegistryError(`Install the AKMS runtime first: ${runtimeInstallCommand(kind)}. Then reopen Runtime.`);
+    if (!runtime) throw new RegistryError(`Install the AKMS runtime first: ${runtimeInstallCommand()}. Then reopen Runtime.`);
     return runtime;
   }
-  runtimeSnapshot(state, kind) {
-    return JSON.stringify([state.clients, Object.entries(state.connections).filter(([, item]) => item.kind === kind).map(([name, item]) => [name, item.entry ? entryHash(item.entry) : null]).sort(([a], [b]) => String(a).localeCompare(String(b)))]);
-  }
-  planRuntime(kind) {
-    const state = this.read();
-    const runtime = this.requireRuntime(kind);
-    const names = [], skipped = [];
-    for (const [name, item] of Object.entries(state.connections)) {
-      if (item.kind !== kind || !item.entry) continue;
-      if (!standardLaunch(item.entry, kind)) {
-        skipped.push(name);
-        continue;
-      }
-      if (item.entry.command !== runtime.command || JSON.stringify(item.entry.args) !== JSON.stringify(runtime.args)) names.push(name);
-    }
-    return { kind, runtime, names, skipped, expected: this.runtimeSnapshot(state, kind) };
-  }
-  applyRuntime(plan) {
-    return this.change((state) => {
-      if (this.runtimeSnapshot(state, plan.kind) !== plan.expected) throw new RegistryError("Connections or registration changed since review. Reopen Runtime before applying.");
-      const runtime = this.requireRuntime(plan.kind);
-      if (JSON.stringify(runtime) !== JSON.stringify(plan.runtime)) throw new RegistryError("The global installation changed since review. Reopen Runtime before applying.");
-      for (const name of plan.names) {
-        const item = state.connections[name];
-        if (!item?.entry || item.kind !== plan.kind || !standardLaunch(item.entry, plan.kind)) throw new RegistryError("This connection has a custom launch command. Review it individually.");
-        item.entry = { ...item.entry, command: runtime.command, args: [...runtime.args] };
-      }
-    });
-  }
   read() {
     let text;
     try {
-      text = fs4.readFileSync(this.file, "utf8");
+      text = fs.readFileSync(this.file, "utf8");
       this.observedText = text;
     } catch (error) {
       if (error.code === "ENOENT") {
@@ -1344,7 +1425,7 @@ var Registry = class {
       return after;
     }, { beforeCommit: (before) => {
       if (before !== null && !this.backupCaptured) {
-        updateConfigFile(path5.join(path5.dirname(this.file), "registry.previous.json"), () => before, { mode: fs4.statSync(this.file).mode & 511 });
+        updateConfigFile(path2.join(path2.dirname(this.file), "registry.previous.json"), () => before, { mode: fs.statSync(this.file).mode & 511 });
         this.backupCaptured = true;
       }
     } });
@@ -1352,16 +1433,16 @@ var Registry = class {
   }
   /** Serializes standalone editors across packages, including their config-file writes. */
   locked(action) {
-    fs4.mkdirSync(path5.dirname(this.file), { recursive: true, mode: 448 });
+    fs.mkdirSync(path2.dirname(this.file), { recursive: true, mode: 448 });
     const lock = this.file + ".lock";
     let descriptor;
     try {
-      descriptor = fs4.openSync(lock, "wx", 384);
+      descriptor = fs.openSync(lock, "wx", 384);
     } catch (error) {
       if (error.code !== "EEXIST") throw error;
       let abandoned = false;
       try {
-        const pid = Number(fs4.readFileSync(lock, "utf8"));
+        const pid = Number(fs.readFileSync(lock, "utf8"));
         if (Number.isSafeInteger(pid) && pid > 0) {
           try {
             process.kill(pid, 0);
@@ -1372,17 +1453,17 @@ var Registry = class {
       } catch {
       }
       if (!abandoned) throw new RegistryError("Another AKMS configuration command is running. Finish it and retry.");
-      fs4.unlinkSync(lock);
-      descriptor = fs4.openSync(lock, "wx", 384);
+      fs.unlinkSync(lock);
+      descriptor = fs.openSync(lock, "wx", 384);
     }
     this.backupCaptured = false;
     try {
-      fs4.writeFileSync(descriptor, String(process.pid));
+      fs.writeFileSync(descriptor, String(process.pid));
       return action();
     } finally {
       this.backupCaptured = false;
-      fs4.closeSync(descriptor);
-      fs4.unlinkSync(lock);
+      fs.closeSync(descriptor);
+      fs.unlinkSync(lock);
     }
   }
   change(action, kinds) {
@@ -1478,11 +1559,26 @@ var Registry = class {
   inspect() {
     return this.reconcile(this.read(), false);
   }
+  formatResults(results, prefix = "", paint, reviewHint) {
+    return formatResults(results, prefix, {
+      paint,
+      reviewHint,
+      connectionCount: Object.values(this.read().connections).filter((item) => item.entry).length
+    });
+  }
   reconcile(state, apply, kinds) {
     const results = [];
     const active = (kind) => Object.entries(state.connections).filter(([, item]) => item.kind === kind && item.entry);
     for (const kind of kinds ?? KINDS) if (this.isSessionMode(kind, state) && active(kind).length && !state.sessions?.[kind]) {
-      for (const client of state.clients) results.push({ client, name: sessionName(kind), status: "pending", detail: "Install this kind's runtime from Runtime, then run Sync. Existing client entries are kept." });
+      for (const client of state.clients) results.push({
+        client,
+        name: sessionName(kind),
+        kind,
+        connections: active(kind).map(([name]) => name),
+        status: "pending",
+        waitingFor: "runtime",
+        detail: "Install it from Runtime, then run Sync. Your existing entries keep working."
+      });
     }
     const work = [
       ...Object.entries(state.connections).filter(([, connection]) => !kinds || kinds.includes(connection.kind)).map(([name, connection]) => ({ name, connection, bundle: false })),
@@ -1498,7 +1594,15 @@ var Registry = class {
         const previous = connection.applied[client];
         if (!desired && !previous) continue;
         const target = this.targets.find((candidate) => candidate.id === client);
-        const report = (status, detail) => results.push({ client, name, status, detail });
+        const report = (status, detail, waitingFor) => results.push({
+          client,
+          name,
+          status,
+          detail,
+          kind: connection.kind,
+          connections: bundle ? active(connection.kind).map(([name2]) => name2) : [name],
+          ...waitingFor ? { waitingFor } : {}
+        });
         if (!target) {
           report("error", "Service adapter unavailable; use a newer package to retry.");
           continue;
@@ -1516,20 +1620,18 @@ var Registry = class {
             report("removed", "Removed");
           } else if (exists && (!actual || !previous || hash !== previous)) {
             report("conflict", actual && desired ? describeDifferences([desired, actual]) : actual ? "Changed outside AKMS; review before removing this entry." : "This name is used by another server type; choose another name.");
-          } else if (!apply) {
-            report("pending", desired ? "Needs applying" : "Needs removal");
           } else {
             if (!desired && state.clients.includes(client)) {
               if (!bundle && this.isSessionMode(connection.kind, state) && active(connection.kind).length) {
                 const session = state.sessions?.[connection.kind];
                 const replacement2 = entries[sessionName(connection.kind)];
                 if (!session || !replacement2 || entryHash(replacement2) !== entryHash(session.entry) || session.applied[client] !== entryHash(session.entry)) {
-                  report("pending", "Connection entry kept until the session server is applied.");
+                  report("pending", "Connection entry kept until the session server is applied.", "session");
                   continue;
                 }
               }
               if (bundle && !this.isSessionMode(connection.kind, state) && active(connection.kind).some(([connectionName, value]) => !entries[connectionName] || entryHash(entries[connectionName]) !== entryHash(value.entry))) {
-                report("pending", "Session entry kept until all connection entries are applied.");
+                report("pending", "Session entry kept until all connection entries are applied.", "connections");
                 continue;
               }
             }
@@ -1540,7 +1642,11 @@ var Registry = class {
               replacement = state.connections[replacement.replacement];
             }
             if (!desired && state.clients.includes(client) && !this.isSessionMode(connection.kind, state) && replacement && replacement.entry && replacement.applied[client] !== entryHash(replacement.entry)) {
-              report("pending", "Old name kept until the new name is applied.");
+              report("pending", "Old name kept until the new name is applied.", "rename");
+              continue;
+            }
+            if (!apply) {
+              report("pending", desired ? "Needs applying" : "Needs removal");
               continue;
             }
             const result = desired ? target.writeEntry(name, desired) : target.removeEntry(name);
@@ -1631,7 +1737,7 @@ var Registry = class {
     const registry = this;
     let snapshot;
     const expected = (name) => snapshot ? own(snapshot, name) ? entryHash(snapshot[name]) : null : void 0;
-    const saved = (results) => ({ status: "written", detail: formatResults(results, "Saved in the shared AKMS catalog.") });
+    const saved = (results) => ({ status: "written", detail: registry.formatResults(results, "Saved in the shared AKMS catalog.") });
     const prepare = (name, entry, oldName) => {
       if (!registry.read().clients.length) throw new RegistryError("Register at least one AI service before saving a connection.");
       const prior = snapshot && own(snapshot, oldName ?? name) ? snapshot[oldName ?? name] : void 0;
@@ -1660,283 +1766,437 @@ var Registry = class {
     };
   }
 };
-function formatResults(results, prefix = "") {
-  const lines = prefix ? [prefix] : [];
-  if (!results.length) return [...lines, "  No shared connections need applying."].join("\n");
-  const attention = results.filter((item) => !["synced", "removed"].includes(item.status));
-  const total = new Set(results.map((item) => item.name)).size;
-  const unresolved = new Set(attention.map((item) => item.name)).size;
-  lines.push(`  Connections: ${total - unresolved} complete \xB7 ${unresolved} need attention`);
+function formatResults(results, prefix = "", options = {}) {
+  const plain = (text) => text;
+  const paint = options.paint ?? { success: plain, warning: plain, error: plain, dim: plain, bold: plain };
+  const accent = options.paint?.accent ?? paint.bold;
+  const safe = (text) => text.replace(/[\x00-\x1f\x7f]/g, " ");
+  const lines = prefix ? [paint.bold(prefix)] : [];
+  const total = options.connectionCount ?? new Set(results.flatMap((item) => item.connections ?? [item.name])).size;
+  lines.push(`${paint.dim("  Connections: ")}${accent(String(total))}`);
   const updated = results.filter((item) => item.status === "synced" && item.detail === "Applied").length;
   const unchanged = results.filter((item) => item.status === "synced" && item.detail !== "Applied").length;
   const removed = results.filter((item) => item.status === "removed").length;
-  lines.push(`  Service entries: ${updated} updated \xB7 ${unchanged} already up to date${removed ? ` \xB7 ${removed} removed` : ""}`);
-  for (const [heading, rows] of [
-    ["Needs review (existing settings kept)", attention.filter((item) => item.status === "conflict")],
-    ["Could not finish", attention.filter((item) => item.status !== "conflict")]
+  const failed = results.filter((item) => item.status === "error");
+  const count = (value, label, tone) => value ? `${accent(String(value))} ${paint[tone](label)}` : paint.dim(`0 ${label}`);
+  lines.push(`${paint.dim("  Service entries: ")}${count(updated, "updated", "success")} ${paint.dim("\xB7")} ${count(unchanged, "already up to date", "dim")}${removed ? ` ${paint.dim("\xB7")} ${count(removed, "removed", "success")}` : ""} ${paint.dim("\xB7")} ${count(failed.length, "failed", "error")}`);
+  if (!results.length) lines.push(paint.dim("  No shared connections need applying."));
+  if (results.length && results.every((item) => item.status === "synced" || item.status === "removed")) lines.push(`${paint.success("  OK:")} ${paint.dim("all service entries are up to date.")}`);
+  const waiting = results.filter((item) => item.status === "pending");
+  for (const kind of KINDS) {
+    const runtime = waiting.filter((item) => item.kind === kind && item.waitingFor === "runtime");
+    const kept = waiting.filter((item) => item.kind === kind && item.waitingFor === "session");
+    if (!runtime.length && !kept.length) continue;
+    lines.push(runtime.length ? `
+${paint.warning("Waiting for runtime")} - ${accent(kind.toUpperCase())}` : `
+${paint.warning("Waiting for")} ${accent(sessionName(kind))}`);
+    if (runtime.length) lines.push(paint.dim("  Install it from Runtime, then run Sync. Your existing entries keep working."));
+    else lines.push(paint.dim("  Resolve this session entry in Sync. Existing connection entries stay until it is ready."));
+    const retained = /* @__PURE__ */ new Map();
+    for (const client of new Set(kept.map((item) => item.client))) {
+      const names = [...new Set(kept.filter((item) => item.client === client).map((item) => item.name))];
+      const key = JSON.stringify([...names].sort());
+      const group = retained.get(key);
+      if (group) group.clients.push(client);
+      else retained.set(key, { clients: [client], names });
+    }
+    for (const group of retained.values()) {
+      const clients = group.clients.map((client) => CLIENT_LABELS2[client]).join(" \xB7 ");
+      lines.push(`${paint.dim("  Kept in ")}${paint.bold(clients)}${paint.dim(` until ${sessionName(kind)} is applied: `)}${accent(group.names.map(safe).join(", "))}`);
+    }
+  }
+  for (const [heading, rows, color] of [
+    ["Needs review (existing settings kept)", results.filter((item) => item.status === "conflict"), paint.warning],
+    ["Waiting for Sync", waiting.filter((item) => !item.waitingFor || !["runtime", "session"].includes(item.waitingFor)), paint.warning],
+    ["Could not finish", failed, paint.error]
   ]) {
     if (!rows.length) continue;
     lines.push(`
-${heading}:`);
+${color(`${heading}:`)}`);
     for (const name of new Set(rows.map((item) => item.name))) {
-      lines.push(`  ${name.replace(/[\x00-\x1f\x7f]/g, " ")}`);
-      for (const row of rows.filter((item) => item.name === name)) lines.push(`    ${CLIENT_LABELS2[row.client]}: ${row.detail}`);
+      lines.push(`  ${accent(safe(name))}`);
+      for (const row of rows.filter((item) => item.name === name)) lines.push(`    ${row.status === "error" ? paint.error("FAILED ") : ""}${paint.dim(`${CLIENT_LABELS2[row.client]}: `)}${safe(row.detail)}`);
     }
   }
-  if (attention.length) lines.push("\nNext: open Sync to compare settings or retry unfinished changes.");
+  if (results.some((item) => item.status === "conflict")) lines.push(paint.dim(`
+${options.reviewHint ?? "Next: open Sync to compare settings and choose which version to use."}`));
+  if (failed.length) lines.push(`${paint.dim("\nNext: ")}${paint.error("fix the errors above")}${paint.dim(", then run ")}${accent("Sync")}${paint.dim(" again.")}`);
   return lines.join("\n");
 }
 
-// src/modules/registration/runtime-menu.ts
-async function runtimeMenu(prompter, registry, requestedKind) {
-  let kind = requestedKind;
-  for (; ; ) {
-    prompter.clearScreen();
-    if (!kind) {
-      const selected = await prompter.select("Runtime / choose MCP", [
-        ...KINDS.map((value) => ({ value, label: packageName(value) })),
-        { value: "back", key: "b", label: "Back" }
-      ], { cancelValue: "back" });
-      if (selected === "back") return;
-      kind = selected;
-    }
-    try {
-      const installed = registry.globalRuntime(kind);
-      const sessionMode = registry.isSessionMode(kind);
-      writeWrapped(prompter, `Runtime / ${packageName(kind)}`);
-      writeWrapped(prompter, installed ? `Installed: ${installed.version}${installed.linked ? " (linked development checkout)" : ""}` : "Not installed in the AKMS runtime directory.");
-      writeWrapped(prompter, `Runtime directory: ${runtimePrefix()}`);
-      prompter.write("Connections start Node directly, without a resident npm/npx process.\n");
-      prompter.write(`Configuration: ${sessionMode ? "one session server for this kind" : "one entry per connection"}.
-`);
-      if (installed) writeWrapped(prompter, installed.args[0]);
-      const picked = await prompter.select("AKMS runtime", [
-        ...installed && !sessionMode ? [{ value: "apply", label: "Use for existing connections", hint: "convert npx and old runtime paths together" }] : [],
-        ...installed ? [{ value: "catalog", key: "catalog", label: sessionMode ? "Reapply session launch command" : "Switch to session server", hint: `one ${sessionName(kind)} entry per registered service` }] : [],
-        ...sessionMode && (installed || registry.read().sessions?.[kind]) ? [{ value: "individual", key: "individual", label: "Switch back to per-connection entries", hint: "restore connection settings from the catalog" }] : [],
-        ...!installed?.linked ? [{ value: "install", label: installed ? "Update runtime installation" : "Install AKMS runtime", hint: runtimeInstallCommand(kind) }] : [],
-        ...!registry.needsMigration() ? [{ value: "default", key: "default", label: registry.read().defaultMode === "catalog" ? "Use individual entries for new kinds" : "Start new kinds as session servers", hint: "keep existing kinds and rollback choices" }] : [],
-        { value: "back", key: "b", label: "Back" }
-      ], { cancelValue: "back" });
-      if (picked === "back") {
-        if (requestedKind) return;
-        kind = void 0;
-        continue;
-      }
-      if (picked === "default") {
-        const mode = registry.read().defaultMode === "catalog" ? "individual" : "catalog";
-        prompter.write(`New kinds will use ${mode === "catalog" ? "session servers" : "individual entries"}. Existing kinds keep their settings.
+// src/modules/registration/migration-menu.ts
+function migrationStatus(registry) {
+  if (!registry.needsMigration()) return { status: "none" };
+  const plan = registry.planMigration();
+  const blocked = plan.kinds.find((item) => item.status === "blocked");
+  if (blocked) return { status: "blocked", detail: blocked.detail };
+  if (plan.steps.some((step) => step.id !== "single_package") || plan.launches.some((item) => item.ready)) return { status: "ready" };
+  return { status: "waiting", detail: `Install ${PACKAGE_NAME} first.` };
+}
+function migrationVersions(registry, plan = registry.planMigration()) {
+  const pairs = [];
+  if (plan.steps.some((step) => step.id === "v1_to_v2")) pairs.push({ label: "Registry", from: "v1", to: "v2" });
+  const ready = plan.launches.filter((item) => item.ready);
+  if (ready.length) {
+    const installed = new Map(registry.legacyRuntimes().map((item) => [item.runtime.kind, `${item.runtime.packageName} ${item.runtime.version}`]));
+    const from = [...new Set(ready.map((item) => installed.get(item.kind) ?? legacyPackageName(item.kind)))].join(", ");
+    pairs.push({ label: "Servers", from, to: `${PACKAGE_NAME} ${registry.installedRuntime()?.version ?? ""}`.trim() });
+  }
+  return pairs;
+}
+function writePlan(prompter, registry, plan) {
+  const paint = prompter.paint;
+  prompter.clearScreen();
+  prompter.write(`${paint.bold("Migrate registry")}
 `);
-        if (await prompter.askYesNo("Change the default for new kinds?", false)) {
-          prompter.write(`${formatResults(registry.setDefaultMode(mode), "Default for new kinds saved.")}
+  for (const pair of migrationVersions(registry, plan)) {
+    prompter.write(`  ${paint.dim(pair.label.padEnd(10))}${paint.warning(plainText(pair.from))} ${paint.dim("\u2192")} ${paint.bold(paint.success(plainText(pair.to)))}
 `);
-          await prompter.acknowledge();
-        }
-        continue;
-      }
-      if (picked === "catalog" || picked === "individual") {
-        const plan2 = registry.planSession(kind, picked);
-        prompter.clearScreen();
-        writeWrapped(prompter, picked === "catalog" ? `Switch to session server: ${sessionName(kind)}` : "Switch back to per-connection entries");
-        prompter.write("Registry version 2 prevents older AKMS setup packages from changing these settings.\nThe previous catalog revision is kept as registry.previous.json.\n\n");
-        for (const change of plan2.changes) {
-          writeWrapped(prompter, CLIENT_LABELS2[change.client]);
-          writeWrapped(prompter, `Apply: ${change.add.join(", ") || "none"}`, "  ");
-          writeWrapped(prompter, `Remove after replacements are applied: ${change.remove.join(", ") || "none"}`, "  ");
-          if (change.review.length) writeWrapped(prompter, `Keep for Sync review: ${change.review.join(", ")}`, "  ");
-        }
-        if (picked === "catalog") {
-          prompter.write("\nPasswords stay in the catalog and its previous-revision copy. Session entries contain no connection credentials.\n");
-          writeWrapped(prompter, `Command: ${plan2.entry.command}`);
-          writeWrapped(prompter, `Runtime: ${plan2.entry.args[0]} --catalog`);
-          if (plan2.custom.length) {
-            prompter.write("Custom commands will not run in catalog mode; they are retained for switching back:\n");
-            for (const name of plan2.custom) writeWrapped(prompter, plainText(name), "  ");
-          }
-        } else prompter.write("\nConnection credentials will be copied back into registered client settings. The registry stays version 2.\n");
-        if (!await prompter.askYesNo("Apply this configuration mode?", false)) continue;
-        const results2 = registry.applySession(plan2);
-        prompter.clearScreen();
-        prompter.write(`${formatResults(results2, "Configuration mode saved.")}
+  }
+  plan.steps.forEach((step, index) => prompter.write(`  ${paint.accent(`${index + 1}.`)} ${step.label}
+`));
+  if (plan.kinds.length) prompter.write(paint.dim("  Every kind is listed as one akms_<kind> entry in each AI service; connection settings stay in the catalog.\n"));
+  prompter.write("\n");
+  for (const item of plan.launches) {
+    const names = item.names.length > 3 ? `${item.names.length} entries` : item.names.map(plainText).join(", ");
+    prompter.write(`  ${paint.dim(KIND_LABELS[item.kind].padEnd(10))}${names} ${paint.dim("\u2192")} ${paint.accent(`${PACKAGE_NAME}/lib/${item.kind}.js`)}${item.ready ? "" : paint.warning("  after installing it")}
 `);
-        await registry.checkSaved(prompter, plan2.names);
-        prompter.write("Restart or reconnect your AI clients to load the new server layout. Fix startup failures first.\n");
-        await prompter.acknowledge();
-        continue;
-      }
-      if (picked === "install") {
-        prompter.clearScreen();
-        writeWrapped(prompter, `Installing ${packageName(kind)}@latest in ${runtimePrefix()}...`);
-        const runtime = await registry.installRuntime(kind);
-        prompter.write(`Installed ${runtime.version}. Reconnect your AI clients to load the update.
+  }
+  for (const item of plan.kinds) {
+    const target = sessionName(item.kind);
+    const action = item.status === "catalog" ? `already ${target}` : item.status === "empty" ? `no connections \xB7 new ones use ${target}` : item.status === "blocked" ? paint.error("blocked") : `${item.names.length} entries \u2192 ${target}${item.status === "pending-runtime" ? paint.warning("  after Runtime + Sync") : ""}`;
+    prompter.write(`  ${paint.dim(KIND_LABELS[item.kind].padEnd(10))}${action}
 `);
-        await prompter.acknowledge();
-        continue;
-      }
-      const plan = registry.planRuntime(kind);
-      prompter.clearScreen();
-      writeWrapped(prompter, `Use AKMS runtime ${packageName(kind)} ${plan.runtime.version}`);
-      prompter.write(`
-Convert ${plan.names.length} connection(s):
+    if (item.detail) prompter.write(`  ${" ".repeat(10)}${paint.dim(plainText(item.detail))}
 `);
-      for (const name of plan.names) writeWrapped(prompter, plainText(name), "  ");
-      if (plan.skipped.length) {
-        prompter.write("Custom commands kept for individual review:\n");
-        for (const name of plan.skipped) writeWrapped(prompter, plainText(name), "  ");
-      }
-      prompter.write("\nConnection values and credentials stay the same.\nVersion-pinned npx entries will use the installed version shown above.\n");
-      if (!plan.names.length) {
-        prompter.write("No saved launch commands need converting.\nIf a legacy client entry is missing here, import it from Register or Import existing connections first.\n");
-        await prompter.acknowledge();
-        continue;
-      }
-      if (!await prompter.askYesNo("Apply these launch commands to registered services?", true)) continue;
-      const results = registry.applyRuntime(plan);
-      prompter.clearScreen();
-      prompter.write(`${formatResults(results, "Runtime settings saved.")}
-
-Restart or reconnect AI clients to replace running npx processes.
+    for (const change of item.session?.changes ?? item.changes ?? []) {
+      const remove = change.remove.length > 3 ? `${change.remove.length} entries` : change.remove.join(", ") || "nothing";
+      prompter.write(`  ${" ".repeat(10)}${paint.dim(CLIENT_LABELS2[change.client].padEnd(15))}${paint.accent(change.add.join(", ") || "nothing")} ${paint.dim("\xB7 then remove")} ${plainText(remove)}
 `);
-      await registry.checkSaved(prompter, plan.names);
-      await prompter.acknowledge();
-    } catch (error) {
-      if (error instanceof PromptClosedError) throw error;
-      if (error instanceof PromptBackError) continue;
-      prompter.write(`${error instanceof Error ? error.message : "Could not configure the AKMS runtime."}
+      if (change.review.length) prompter.write(`  ${" ".repeat(25)}${paint.warning(`kept for Sync review: ${change.review.map(plainText).join(", ")}`)}
 `);
-      await prompter.acknowledge();
     }
+    if (item.session?.custom.length) prompter.write(`  ${" ".repeat(10)}${paint.dim(`custom commands are not started; their settings still load in the grouped entry: ${item.session.custom.map(plainText).join(", ")}`)}
+`);
   }
+  prompter.write(paint.dim("\nServer entries hold no passwords; they stay in the catalog. The previous catalog is kept as registry.previous.json.\n"));
 }
-
-// src/modules/registration/updates-menu.ts
-async function updatesMenu(prompter, registry) {
-  const kinds = KINDS.filter((kind) => kind !== "wsl" || process.platform === "win32");
-  const latest = /* @__PURE__ */ new Map();
-  const refresh = async () => {
-    prompter.clearScreen();
-    prompter.write("Updates / checking published runtime versions...\n");
-    await Promise.all(kinds.map(async (kind) => {
-      try {
-        latest.set(kind, await registry.latestRuntime(kind));
-      } catch {
-        latest.set(kind, null);
-      }
-    }));
-  };
-  await refresh();
-  for (; ; ) {
-    try {
-      prompter.clearScreen();
-      prompter.write("Updates / AKMS runtimes\n\n");
-      const rows = kinds.map((kind) => {
-        const installed = registry.globalRuntime(kind), published = latest.get(kind);
-        const update = !!installed && !installed.linked && !!published && runtimeIsOlder(installed.version, published);
-        const status = installed?.linked ? "Development link" : !published ? "Unavailable" : !installed ? "Not installed" : update ? "Update available" : "Up to date";
-        writeWrapped(prompter, `${packageName(kind)} | installed: ${installed?.version ?? "not installed"} | latest: ${published ?? "unavailable"} | ${status}`);
-        return { kind, installed, published, update };
-      });
-      const updates = rows.filter((row) => row.update);
-      const available = rows.filter((row) => row.published && !row.installed?.linked && (!row.installed || row.update));
-      prompter.write("\nDevelopment links are managed in their source checkouts.\n");
-      const picked = await prompter.select("Updates", [
-        ...available.map((row) => ({ value: row.kind, key: row.kind, label: `${row.installed ? "Update" : "Install"} ${packageName(row.kind)}` })),
-        ...updates.length ? [{ value: "all", key: "a", label: `Update all available (${updates.length})` }] : [],
-        { value: "refresh", key: "r", label: "Refresh versions" },
-        { value: "back", key: "b", label: "Back" }
-      ], { cancelValue: "back" });
-      if (picked === "back") return;
-      if (picked === "refresh") {
-        await refresh();
-        continue;
-      }
-      const selected = picked === "all" ? updates : available.filter((row) => row.kind === picked);
-      if (!selected.length) continue;
-      if (!await prompter.askYesNo(`Install latest published releases for ${selected.map((row) => packageName(row.kind)).join(", ")}?`, true)) continue;
+async function migrationMenu(prompter, registry) {
+  try {
+    const paint = prompter.paint;
+    let plan = registry.planMigration();
+    if (!plan.steps.length) {
       prompter.clearScreen();
-      for (const row of selected) {
-        writeWrapped(prompter, `Updating ${packageName(row.kind)}...`);
+      prompter.write(`${paint.bold("Migrate registry")}
+${paint.success("Up to date")} ${paint.dim("\xB7 the registry is already in the current format")}
+`);
+      await prompter.acknowledge();
+      return;
+    }
+    writePlan(prompter, registry, plan);
+    if (plan.launches.some((item) => !item.ready) && !registry.installedRuntime()?.linked) {
+      prompter.write(paint.warning(`! ${PACKAGE_NAME} is not installed in the runtime directory yet.
+`));
+      if (await prompter.askYesNo(`Install ${PACKAGE_NAME} now?`, true)) {
+        prompter.write(`Installing ${PACKAGE_NAME}@latest...
+`);
         try {
-          const installed = await registry.installRuntime(row.kind);
-          writeWrapped(prompter, `Installed ${packageName(row.kind)} ${installed.version}.`);
-          const names = Object.entries(registry.read().connections).filter(([, item]) => item.kind === row.kind && item.entry).map(([name]) => name);
-          await registry.checkSaved(prompter, names);
+          await registry.installRuntime();
         } catch (error) {
-          let detail = error instanceof Error ? error.message : "Installation failed.";
-          for (const item of Object.values(registry.read().connections)) if (item.entry) detail = redactStartupText(detail, item.entry);
-          writeWrapped(prompter, `FAILED ${packageName(row.kind)}: ${detail}`);
-          if (/\b(?:EBUSY|EPERM|EACCES)\b/i.test(detail)) prompter.write("Close your AI clients, then retry the update. A running runtime may have locked its files.\n");
+          prompter.write(`${paint.error("Failed")} ${plainText(error instanceof Error ? error.message : "Installation failed.")}
+`);
+          await prompter.acknowledge();
         }
+        plan = registry.planMigration();
+        writePlan(prompter, registry, plan);
       }
-      prompter.write("Reconnect or restart your AI clients to load updated runtimes. Fix any failed startup checks first.\n");
-      await prompter.acknowledge();
-    } catch (error) {
-      if (error instanceof PromptClosedError) throw error;
-      if (error instanceof PromptBackError) continue;
-      throw error;
     }
-  }
-}
-
-// src/modules/registration/migration-menu.ts
-async function migrationMenu(prompter, registry) {
-  try {
-    prompter.clearScreen();
-    const plan = registry.planMigration();
-    prompter.write("Migrate registry\n\n");
-    if (!plan.steps.length) {
-      prompter.write("The registry is already in the current format.\n");
+    if (plan.kinds.some((item) => item.status === "blocked")) {
+      prompter.write(paint.warning("! Resolve blocked kinds before migrating. No migration was applied.\n"));
       await prompter.acknowledge();
       return;
     }
-    prompter.write("Steps:\n");
-    plan.steps.forEach((step, index) => writeWrapped(prompter, `${index + 1}. ${step.label}`, "  "));
-    prompter.write('\nThe registry will record defaultMode: "catalog" for new kinds.\nA kind explicitly switched back to individual entries keeps that choice.\n');
-    for (const item of plan.kinds) {
-      prompter.write("\n");
-      const target = sessionName(item.kind);
-      const action = item.status === "catalog" ? `already ${target}; keep` : item.status === "individual" ? "keep explicit per-connection choice (rollback)" : item.status === "empty" ? `no connections; future connections use ${target}` : item.status === "blocked" ? "blocked" : `per-connection entries -> ${target}${item.status === "pending-runtime" ? " after runtime setup" : ""}`;
-      writeWrapped(prompter, `${item.kind.toUpperCase()}: ${item.names.length} connection(s), ${action}`);
-      if (item.detail) writeWrapped(prompter, plainText(item.detail), "  ");
-      for (const change of item.session?.changes ?? item.changes ?? []) {
-        writeWrapped(prompter, `${CLIENT_LABELS2[change.client]}${item.status === "pending-runtime" ? " (after Runtime + Sync)" : ""}`, "  ");
-        writeWrapped(prompter, `Apply: ${change.add.join(", ") || "none"}`, "    ");
-        writeWrapped(prompter, `Remove after verification: ${change.remove.join(", ") || "none"}`, "    ");
-        if (change.review.length) writeWrapped(prompter, `Keep for Sync review: ${change.review.map(plainText).join(", ")}`, "    ");
-      }
-      if (item.session?.custom.length) writeWrapped(prompter, `Custom commands retained for rollback: ${item.session.custom.map(plainText).join(", ")}`, "  ");
-    }
-    prompter.write("\nThe previous catalog revision is kept in registry.previous.json.\nSession entries contain no connection credentials; those stay in the catalog and its previous revision.\n");
-    if (plan.kinds.some((item) => item.status === "blocked")) {
-      prompter.write("Resolve blocked kinds before migrating. No migration was applied.\n");
+    if (plan.steps.every((step) => step.id === "single_package") && plan.launches.every((item) => !item.ready)) {
+      prompter.write(`Nothing can be migrated until ${PACKAGE_NAME} is installed. Install it from Runtime, then reopen Migrate registry.
+`);
       await prompter.acknowledge();
       return;
     }
-    if (!await prompter.askYesNo("Migrate registry and apply these changes?", false)) return;
+    if (!await prompter.askYesNo("Migrate the registry and apply these changes?", false)) return;
     const results = registry.applyMigration(plan);
     prompter.clearScreen();
-    prompter.write(`${formatResults(results, "Registry migration saved.")}
+    prompter.write(`${registry.formatResults(results, "Registry migration saved.", prompter.paint)}
 `);
-    await registry.checkSaved(prompter, plan.kinds.filter((item) => item.status !== "individual").flatMap((item) => item.names));
-    prompter.write("Reconnect affected clients after changes to their server layout. Fix startup failures first.\n");
+    const state = registry.read();
+    const launchKinds = plan.launches.filter((item) => item.ready).map((item) => item.kind);
+    await registry.checkSaved(prompter, [.../* @__PURE__ */ new Set([
+      ...plan.kinds.flatMap((item) => item.names),
+      ...Object.entries(state.connections).filter(([, item]) => item.entry && launchKinds.includes(item.kind)).map(([name]) => name)
+    ])]);
+    if (plan.launches.some((item) => !item.ready)) prompter.write(paint.warning(`! Entries waiting for ${PACKAGE_NAME} keep their old launch. Install it from Runtime, then reopen Migrate registry.
+`));
+    prompter.write("Reconnect affected clients to load the new launch commands. Fix startup failures first.\n");
     await prompter.acknowledge();
   } catch (error) {
     if (error instanceof PromptClosedError) throw error;
     if (error instanceof PromptBackError) return;
-    prompter.write(`${error instanceof Error ? error.message : "Could not migrate the registry."}
+    prompter.write(`${error instanceof Error ? plainText(error.message) : "Could not migrate the registry."}
 `);
     await prompter.acknowledge();
   }
 }
 
+// src/modules/registration/runtime-menu.ts
+function updateTarget(installed, latest) {
+  let target = null;
+  for (const candidate of [PACKAGE_VERSION, latest]) {
+    if (typeof candidate !== "string" || !runtimeIsOlder(installed, candidate)) continue;
+    if (target == null || runtimeIsOlder(target, candidate)) target = candidate;
+  }
+  return target;
+}
+function runtimeNotice(registry) {
+  const installed = registry.installedRuntime();
+  if (!installed) return { hint: PACKAGE_NAME, notice: "Not installed" };
+  const notices = [];
+  const migration = migrationStatus(registry).status;
+  if (migration === "ready") notices.push("Registry update available");
+  else if (migration === "blocked") notices.push("Registry update blocked");
+  const target = installed.linked ? null : updateTarget(installed.version, void 0);
+  if (target) notices.push(`Update available ${target}`);
+  const hint = `${PACKAGE_NAME} ${installed.version}${installed.linked ? " \xB7 development link" : ""}`;
+  return notices.length ? { hint, notice: notices.join(" \xB7 ") } : { hint };
+}
+function connectionNames(registry, kind) {
+  return Object.entries(registry.read().connections).filter(([, item]) => item.entry && (true)).map(([name]) => name);
+}
+function outdatedKinds(registry) {
+  return KINDS.filter((kind) => {
+    if (!registry.isSessionMode(kind) || !registry.globalRuntime(kind)) return false;
+    const saved = registry.read().sessions?.[kind]?.entry;
+    try {
+      return saved != null && entryHash(saved) !== entryHash(registry.sessionEntry(kind));
+    } catch {
+      return false;
+    }
+  });
+}
+async function installOrUpdate(prompter, registry) {
+  const paint = prompter.paint;
+  prompter.clearScreen();
+  prompter.write(`Installing ${paint.accent(`${PACKAGE_NAME}@latest`)} into ${plainText(runtimePrefix())}...
+`);
+  try {
+    const runtime = await registry.installRuntime();
+    prompter.write(`${paint.success("Installed")} ${PACKAGE_NAME} ${paint.accent(runtime.version)}.
+`);
+    const names = connectionNames(registry);
+    if (names.length) await registry.checkSaved(prompter, names);
+    prompter.write("Reconnect or restart your AI clients to load it.\n");
+    if (migrationStatus(registry).status === "ready") prompter.write(paint.warning("! Registry update available. Choose Migrate registry below.\n"));
+  } catch (error) {
+    let detail = error instanceof Error ? error.message : "Installation failed.";
+    for (const item of Object.values(registry.read().connections)) if (item.entry) detail = redactStartupText(detail, item.entry);
+    prompter.write(`${paint.error("Failed")} ${plainText(detail)}
+`);
+    if (/\b(?:EBUSY|EPERM|EACCES)\b/i.test(detail)) prompter.write("Close your AI clients, then retry. A running server may have locked its files.\n");
+  }
+  await prompter.acknowledge();
+}
+async function runtimeMenu(prompter, registry) {
+  let latest;
+  for (; ; ) {
+    try {
+      prompter.clearScreen();
+      const paint = prompter.paint;
+      const installed = registry.installedRuntime();
+      const target = installed && !installed.linked ? updateTarget(installed.version, latest) : null;
+      const legacy = registry.legacyRuntimes();
+      const removable = legacy.filter((item) => !item.usedBy.length);
+      const inUse = legacy.filter((item) => item.usedBy.length);
+      const migration = migrationStatus(registry);
+      const packages = (list) => [...new Set(list.map((item) => item.runtime.version))].map((version) => `${list.filter((item) => item.runtime.version === version).map((item) => item.runtime.packageName).join(", ")} ${version}`).join("; ");
+      const row = (label, value) => prompter.write(`  ${paint.dim(label.padEnd(10))}${value}
+`);
+      prompter.write(`${paint.bold("Runtime")}   ${PACKAGE_NAME} ${installed ? paint.accent(installed.version) : paint.warning("not installed")}${installed?.linked ? paint.dim("  development link") : ""}
+`);
+      row("Location", plainText(runtimePrefix()));
+      if (inUse.length) row("In use", `${paint.warning(packages(inUse))} ${paint.dim("\xB7 old packages")}`);
+      if (removable.length) row("Unused", `${packages(removable)} ${paint.dim("\xB7 old packages")}`);
+      if (latest === null) prompter.write(paint.warning("! Could not reach npm to check for updates.\n"));
+      else if (latest !== void 0 && installed && !target) prompter.write(`${paint.success("Up to date")} ${paint.dim(`\xB7 latest ${latest}`)}
+`);
+      const upgrading = legacy.length > 0 || migration.status !== "none";
+      let next = null;
+      if (upgrading) {
+        const plan = migration.status === "none" ? null : registry.planMigration();
+        const sessions = (plan?.launches ?? []).flatMap((item) => item.names.filter((name) => /^akms_/.test(name)));
+        const pairs = migration.status === "ready" ? migrationVersions(registry, plan ?? void 0) : [];
+        const moves = pairs.map((pair) => pair.label === "Registry" ? `registry ${pair.from} \u2192 ${pair.to}` : `${pair.from} \u2192 ${pair.to}`).join(" \xB7 ");
+        const steps = [
+          {
+            id: "install",
+            label: `Install ${PACKAGE_NAME}`,
+            done: installed != null,
+            blocked: false,
+            detail: installed ? installed.version : "one package for every kind"
+          },
+          {
+            id: "migrate",
+            label: "Migrate registry",
+            done: migration.status === "none",
+            blocked: migration.status === "blocked",
+            detail: migration.status === "none" ? "" : migration.status === "blocked" ? plainText(migration.detail ?? "") : moves || (sessions.length ? `moves ${sessions.join(", ")} to ${PACKAGE_NAME}` : "one akms_<kind> entry per kind")
+          },
+          {
+            id: "remove",
+            label: "Remove old packages",
+            done: legacy.length === 0,
+            blocked: false,
+            detail: inUse.length && migration.status === "none" ? "run Sync first: an AI service still starts them" : "then restart your AI clients"
+          }
+        ];
+        prompter.write(`
+${paint.bold("Upgrade steps")}
+`);
+        for (const [index, step] of steps.entries()) {
+          let state = paint.dim("later  ");
+          if (step.done) state = paint.success("done   ");
+          else if (step.blocked) state = paint.error("blocked");
+          else if (next == null) {
+            state = paint.warning("next   ");
+            next = step.id;
+          }
+          const label = step.done ? paint.dim(step.label.padEnd(22)) : step.id === next ? paint.bold(step.label.padEnd(22)) : step.label.padEnd(22);
+          prompter.write(`  ${paint.dim(`${index + 1}`)}  ${label}${state}  ${step.id === next ? step.detail : paint.dim(step.detail)}
+`);
+        }
+      }
+      prompter.write("\n");
+      const items = [];
+      if (!installed) items.push({ value: "install", key: "install", label: `Install ${PACKAGE_NAME}`, hint: upgrading ? "step 1" : "one package for every kind" });
+      else if (target) items.push({ value: "update", key: "update", label: `Update to ${target}`, hint: `installed ${installed.version}` });
+      else if (!installed.linked) items.push({ value: "check", key: "check", label: "Check for updates", hint: "asks npm for the latest release" });
+      if (migration.status === "ready") {
+        const pairs = migrationVersions(registry).map((pair) => pair.label === "Registry" ? { from: `registry ${pair.from}`, to: pair.to } : pair);
+        const last = pairs.at(-1);
+        items.push({
+          value: "migrate",
+          key: "migrate",
+          label: "Migrate registry",
+          hint: last ? ["step 2", ...pairs.slice(0, -1).map((pair) => `${pair.from} \u2192 ${pair.to}`), `${last.from} \u2192`].join(" \xB7 ") : "step 2 \xB7 one akms_<kind> entry per kind",
+          ...last ? { notice: last.to, noticeTone: "success" } : {}
+        });
+      }
+      const outdated = migration.status === "none" ? outdatedKinds(registry) : [];
+      if (outdated.length) items.push({ value: "relaunch", key: "relaunch", label: "Update launch commands", hint: outdated.map(sessionName).join(", "), notice: "out of date" });
+      if (removable.length) {
+        items.push({
+          value: "remove",
+          key: "remove",
+          label: inUse.length ? "Remove unused packages" : "Remove old packages",
+          hint: `${inUse.length ? "" : "step 3 \xB7 "}${removable.map((item) => item.runtime.packageName).join(", ")}`
+        });
+      }
+      items.push({ value: "back", key: "b", label: "Back" });
+      const defaultValue = next === "migrate" && migration.status === "ready" ? "migrate" : next === "remove" && removable.length && !inUse.length ? "remove" : void 0;
+      const picked = await prompter.select("Runtime", items, { cancelValue: "back", ...defaultValue ? { defaultValue } : {} });
+      if (picked === "back") return;
+      if (picked === "migrate") {
+        await migrationMenu(prompter, registry);
+        continue;
+      }
+      if (picked === "install" || picked === "update") {
+        await installOrUpdate(prompter, registry);
+        latest = void 0;
+        continue;
+      }
+      if (picked === "check") {
+        prompter.write(`Checking the latest ${PACKAGE_NAME} release...
+`);
+        latest = await registry.latestRuntime();
+        continue;
+      }
+      if (picked === "relaunch") {
+        await updateLaunchCommands(prompter, registry, outdated);
+        continue;
+      }
+      if (picked === "remove") {
+        prompter.clearScreen();
+        prompter.write(`${paint.bold("Remove old packages")}
+`);
+        for (const item of removable) prompter.write(`  ${item.runtime.packageName} ${paint.dim(`${item.runtime.version}${item.runtime.linked ? " \xB7 development link (the checkout stays)" : ""}`)}
+`);
+        prompter.write(paint.dim("No AI service starts them any more; every kind now runs from @akms/mcp.\n"));
+        if (!await prompter.askYesNo("Remove these packages?", false)) continue;
+        await registry.removeLegacyRuntimes(removable.map((item) => item.runtime.kind));
+        prompter.write(`${paint.success("Removed")} ${removable.map((item) => item.runtime.packageName).join(", ")}.
+`);
+        await prompter.acknowledge();
+      }
+    } catch (error) {
+      if (error instanceof PromptClosedError) throw error;
+      if (error instanceof PromptBackError) continue;
+      prompter.write(`${error instanceof Error ? plainText(error.message) : "Could not configure the AKMS runtime."}
+`);
+      await prompter.acknowledge();
+    }
+  }
+}
+async function updateLaunchCommands(prompter, registry, kinds) {
+  const paint = prompter.paint;
+  prompter.clearScreen();
+  prompter.write(`${paint.bold("Update launch commands")}
+`);
+  for (const kind of kinds) prompter.write(`  ${paint.dim(sessionName(kind).padEnd(10))}${paint.accent(plainText(registry.sessionEntry(kind).args[0]))} --catalog
+`);
+  prompter.write(paint.dim("Only the command that starts each entry changes; connection settings stay in the catalog.\n"));
+  if (!await prompter.askYesNo("Update these entries?", true)) return;
+  const results = [];
+  for (const kind of kinds) results.push(...registry.applySession(registry.planSession(kind, "catalog")));
+  prompter.clearScreen();
+  prompter.write(`${registry.formatResults(results, "Launch commands saved.", prompter.paint)}
+`);
+  const connections = registry.read().connections;
+  await registry.checkSaved(prompter, connectionNames(registry).filter((name) => kinds.includes(connections[name].kind)));
+  prompter.write("Restart or reconnect your AI clients to use them.\n");
+  await prompter.acknowledge();
+}
+var screenText = (value) => stripVTControlCharacters(value).replace(/[\x00-\x1f\x7f]/g, " ");
+var countLabel = (count, noun, plural = `${noun}s`) => `${count} ${count === 1 ? noun : plural}`;
+function writeHeading(screen, title) {
+  screen.write(`${screen.paint.bold(screenText(title))}
+`);
+}
+function writeField(screen, label, value, note = "", tone = "accent") {
+  const paint = screen.paint;
+  const key = screenText(label);
+  const padded = key.padEnd(Math.max(13, key.length + 2));
+  screen.write(`  ${paint.dim(padded)}${paint[tone](screenText(value))}${note ? `  ${paint.dim(screenText(note))}` : ""}
+`);
+}
+function writeHint(screen, text) {
+  screen.write(`${screen.paint.dim(screenText(text))}
+`);
+}
+function writeWarning(screen, text) {
+  screen.write(`${screen.paint.warning(`! ${screenText(text)}`)}
+`);
+}
+
 // src/modules/registration/menu.ts
+function pendingImports(registry, kind) {
+  const state = registry.read();
+  const entries = registry.candidates(kind).entries.filter((candidate) => !Object.hasOwn(state.connections, candidate.name));
+  const names = [...new Set(entries.map((candidate) => candidate.name))];
+  return { names, differing: names.filter((name) => new Set(entries.filter((item) => item.name === name).map((item) => entryHash(item.entry))).size > 1).length };
+}
 function preview(prompter, entry) {
   if (!entry) {
-    prompter.write("  Remove this connection from the service.\n");
+    writeField(prompter, "Action", "Remove from service", "", "warning");
     return;
   }
-  for (const [key, value] of Object.entries(entry.env)) prompter.write(`  ${plainText(key)}: ${visibleField.test(key) ? plainText(value) : "(hidden)"}
-`);
+  for (const [key, value] of Object.entries(entry.env)) writeField(prompter, key, visibleField.test(key) ? value : "(hidden)", "", visibleField.test(key) ? "accent" : "dim");
 }
 async function registrationMenu(prompter, registry, initialClient) {
   const initial = registry.read();
@@ -1948,9 +2208,9 @@ async function registrationMenu(prompter, registry, initialClient) {
   for (; ; ) {
     try {
       prompter.clearScreen();
-      prompter.write("\nRegister \xB7 AI services\nShared by Database, SSH, WSL and S3.\nEnter toggles a service; Apply saves the selection.\nMatching existing connections are imported on Apply; differing settings stay unchanged.\n\n");
-      for (const error of discovered.errors) prompter.write(`  ${error}
-`);
+      writeHeading(prompter, "Register \xB7 AI services");
+      writeHint(prompter, "Toggle services, then Apply. Matching connections are imported; differences stay for review.");
+      if (discovered.errors.length) writeWarning(prompter, discovered.errors.join(" "));
       const picked = await prompter.select("Register", [
         ...registry.targets.filter((target) => target.id !== "registered").map((target) => ({
           value: target.id,
@@ -1970,64 +2230,59 @@ async function registrationMenu(prompter, registry, initialClient) {
         continue;
       }
       const removed = initial.clients.filter((id) => !selected.has(id));
-      const count = Object.values(registry.read().connections).filter((item) => item.entry).length;
+      const current = registry.read();
       const plan = registry.planRegistration([...selected]);
       const importNames = [...new Set(plan.imports.map((entry) => entry.name))];
+      const connections = new Map(Object.entries(current.connections).filter(([, item]) => item.entry).map(([name, item]) => [name, item.kind]));
+      for (const item of plan.imports) connections.set(item.name, item.kind);
+      const kinds = KINDS.filter((kind) => [...connections.values()].includes(kind));
+      const sessions = kinds.filter((kind) => registry.isSessionMode(kind, current)).map(sessionName);
+      const individuals = [...connections].filter(([, kind]) => !registry.isSessionMode(kind, current)).map(([name]) => name);
+      const imported = new Set(plan.imports.map((item) => `${item.client}:${item.name}:${entryHash(item.entry)}`));
+      const retiring = discovered.entries.filter((item) => selected.has(item.client) && connections.has(item.name) && registry.isSessionMode(item.kind, current));
+      const owned = (item) => imported.has(`${item.client}:${item.name}:${entryHash(item.entry)}`) || Object.hasOwn(current.connections, item.name) && current.connections[item.name].applied[item.client] === entryHash(item.entry);
+      const replaces = [...new Set(retiring.filter(owned).map((item) => item.name))];
+      const kept = [.../* @__PURE__ */ new Set([...plan.conflicts, ...retiring.filter((item) => !owned(item)).map((item) => item.name)])];
       prompter.clearScreen();
-      prompter.write("Review registration\n");
-      prompter.write(`
-Selected: ${[...selected].map((id) => CLIENT_LABELS2[id]).join(" \xB7 ") || "none"}
-Apply ${count + importNames.length} shared connection(s) to these services.
-`);
-      if (importNames.length) prompter.write(`Import ${importNames.length} existing connection(s); identical copies become one shared item:
-  ${importNames.join("\n  ")}
-`);
-      if (plan.conflicts.length) prompter.write(`Keep ${plan.conflicts.length} differing connection(s) unchanged until you choose a version:
-  ${plan.conflicts.join("\n  ")}
-`);
-      for (const error of plan.errors) prompter.write(`  ${error}
-`);
+      writeHeading(prompter, "Review registration");
+      writeField(prompter, "Services", [...selected].map((id) => CLIENT_LABELS2[id]).join(" \xB7 ") || "none");
+      writeField(prompter, "Connections", String(connections.size), kinds.length ? `(${kinds.map((kind) => `${KIND_LABELS[kind]} ${[...connections.values()].filter((value) => value === kind).length}`).join(" \xB7 ")})` : "");
+      writeField(prompter, "Entries", [...sessions, ...individuals.length ? [`${individuals.length} individual entries`] : []].join(" \xB7 ") || "none", "in each service");
+      if (replaces.length) writeField(prompter, "Replaces", `${replaces.length} individual entries`, `with ${sessions.join(" \xB7 ")}`);
+      if (importNames.length) writeField(prompter, "Import", countLabel(importNames.length, "matching connection"));
+      if (kept.length) writeField(prompter, "Kept", `${kept.length} need a version choice`, kept.join(", "), "warning");
+      if (plan.errors.length) writeField(prompter, "Unavailable", countLabel(plan.errors.length, "service"), plan.errors.join(" "), "error");
       if (initial.defaultMode === "catalog") {
-        prompter.write("Services use one session entry per kind. Imported individual entries are removed after that session entry is verified.\n");
-        if (plan.imports.some((item) => !registry.globalRuntime(item.kind))) prompter.write("Install missing runtimes from Runtime, then run Sync. Existing entries stay until then.\n");
-        if (plan.imports.some((item) => !standardLaunch(item.entry, item.kind))) prompter.write("Custom launch commands are retained for rollback; session mode uses each connection's saved environment.\n");
+        if (plan.imports.some((item) => !registry.globalRuntime(item.kind))) writeField(prompter, "Runtime", "Waiting", "install from Runtime, then Sync; existing entries stay", "warning");
+        if (plan.imports.some((item) => !standardLaunch(item.entry, item.kind))) writeHint(prompter, "Custom commands are not started; the grouped entry loads their saved settings.");
       }
-      if (removed.length) prompter.write(`Unregister: ${removed.map((id) => CLIENT_LABELS2[id]).join(" \xB7 ")}
-Remove only AKMS-managed entries from these services; keep the shared catalog.
-`);
+      if (removed.length) writeField(prompter, "Unregister", removed.map((id) => CLIENT_LABELS2[id]).join(" \xB7 "), "remove managed entries; keep the catalog");
       if (!privacyNoticeShown) {
-        writeWrapped(prompter, `Connection settings, including passwords, are stored in ${plainText(registry.file)}.`);
-        prompter.write("Keep this file private: do not share, sync or commit it.\n");
-        prompter.write("Its previous revision, registry.previous.json, also contains saved credentials.\n");
+        writeWarning(prompter, `Plaintext passwords: ${registry.file} + registry.previous.json. Do not share, sync or commit.`);
         privacyNoticeShown = true;
       }
       if (!await prompter.askYesNo("Apply this registration?", removed.length === 0)) continue;
       const results = registry.register([...selected], initial.clients, plan.imports);
       prompter.clearScreen();
-      prompter.write(`
-${formatResults(results, `Registration saved.
-  AI services: ${[...selected].map((id) => CLIENT_LABELS2[id]).join(" \xB7 ") || "none"}`)}
-`);
-      if (importNames.length) prompter.write(`Imported ${importNames.length} existing connection(s) into the shared list.
+      writeHeading(prompter, "Registration saved.");
+      writeField(prompter, "Services", [...selected].map((id) => CLIENT_LABELS2[id]).join(" \xB7 ") || "none");
+      prompter.write(`${registry.formatResults(results, "", prompter.paint)}
 `);
+      if (importNames.length) writeField(prompter, "Imported", countLabel(importNames.length, "connection"), "saved in the shared catalog", "success");
       try {
         const conflicts = new Set(results.filter((result) => result.status === "conflict").map((result) => result.name));
         if (conflicts.size && await prompter.askYesNo(`Compare settings for ${conflicts.size} connection(s) now?`, true)) await syncMenu(prompter, registry);
-        const current = registry.read();
-        const remaining = registry.candidates().entries.filter((candidate) => !Object.hasOwn(current.connections, candidate.name));
+        const current2 = registry.read();
+        const remaining = registry.candidates().entries.filter((candidate) => !Object.hasOwn(current2.connections, candidate.name));
         const names = [...new Set(remaining.map((candidate) => candidate.name))];
         if (names.length) {
-          prompter.write(`
-${names.length} existing connection(s) still need a choice before joining the shared list:
-`);
+          writeField(prompter, "Not imported", countLabel(names.length, "connection"), "choose a version", "warning");
           for (const name of names) {
             const copies = remaining.filter((candidate) => candidate.name === name);
-            prompter.write(`  ${plainText(name)} \xB7 ${copies.map((copy) => CLIENT_LABELS2[copy.client]).join(" \xB7 ")}
-`);
-            if (new Set(copies.map((copy) => entryHash(copy.entry))).size > 1) prompter.write(`    ${describeDifferences(copies.map((copy) => copy.entry))}
-`);
+            writeField(prompter, name, copies.map((copy) => CLIENT_LABELS2[copy.client]).join(" \xB7 "));
+            if (new Set(copies.map((copy) => entryHash(copy.entry))).size > 1) writeHint(prompter, `  ${describeDifferences(copies.map((copy) => copy.entry))}`);
           }
-          prompter.write("Their existing settings are unchanged. Compare them now, or use Import existing connections later.\n");
+          writeHint(prompter, "Existing settings stay. Compare now or open Import existing connections later.");
           if (await prompter.askYesNo("Compare existing settings and choose which to share?", true)) await importMenu(prompter, registry);
         }
         if (!conflicts.size && !names.length) await prompter.acknowledge();
@@ -2038,8 +2293,7 @@ ${names.length} existing connection(s) still need a choice before joining the sh
     } catch (error) {
       if (error instanceof PromptClosedError) throw error;
       if (error instanceof PromptBackError) continue;
-      prompter.write(`  ${error instanceof Error ? error.message : "Registration could not be saved."}
-`);
+      writeWarning(prompter, error instanceof Error ? error.message : "Registration could not be saved.");
       await prompter.acknowledge();
     }
   }
@@ -2047,10 +2301,9 @@ ${names.length} existing connection(s) still need a choice before joining the sh
 async function importMenu(prompter, registry, kind) {
   for (; ; ) {
     prompter.clearScreen();
-    prompter.write("Import existing connections\n\n");
+    writeHeading(prompter, "Import existing connections");
     const { entries, errors } = registry.candidates(kind);
-    for (const error of errors) prompter.write(`  ${error}
-`);
+    for (const error of errors) writeWarning(prompter, error);
     const state = registry.read();
     const matching = registry.planRegistration(state.clients, kind);
     const matchingNames = [...new Set(matching.imports.map((entry) => entry.name))];
@@ -2059,10 +2312,11 @@ async function importMenu(prompter, registry, kind) {
       return !current?.entry || current.applied[candidate.client] !== entryHash(candidate.entry) || entryHash(current.entry) !== entryHash(candidate.entry);
     }).map((entry) => entry.name))];
     if (!names.length) {
-      prompter.write("  No existing connections need importing.\n");
+      writeHint(prompter, "No existing connections need importing.");
       await prompter.acknowledge();
       return;
     }
+    writeField(prompter, "Available", countLabel(names.length, "connection"), `${matchingNames.length} matching`);
     const picked = await prompter.select("Import existing connections", [
       ...names.map((name) => ({ value: `entry:${name}`, key: name, label: name, hint: [...new Set(entries.filter((entry) => entry.name === name).map((entry) => CLIENT_LABELS2[entry.client]))].join(" \xB7 ") })),
       ...matchingNames.length ? [{ value: "matching", key: "all", label: "Import all matching connections", hint: `${matchingNames.length} connections; differing versions stay unchanged` }] : [],
@@ -2072,14 +2326,13 @@ async function importMenu(prompter, registry, kind) {
     try {
       prompter.clearScreen();
       if (picked === "matching") {
-        prompter.write(`
-Import existing connections:
-  ${matchingNames.join("\n  ")}
-`);
+        writeHeading(prompter, "Review import");
+        writeField(prompter, "Connections", String(matchingNames.length), matchingNames.join(", "));
+        writeField(prompter, "Services", state.clients.map((client) => CLIENT_LABELS2[client]).join(" \xB7 ") || "none");
         if (await prompter.askYesNo("Import matching connections and apply them?", true)) {
           const results2 = registry.register(state.clients, state.clients, matching.imports);
           prompter.clearScreen();
-          prompter.write(`${formatResults(results2, "Import complete")}
+          prompter.write(`${registry.formatResults(results2, "Import complete", prompter.paint)}
 `);
           await prompter.acknowledge();
         }
@@ -2089,9 +2342,8 @@ Import existing connections:
       const candidates = entries.filter((entry) => entry.name === name);
       let chosen = candidates[0];
       if (new Set(candidates.map((candidate) => entryHash(candidate.entry))).size > 1) {
-        prompter.write(`
-${plainText(name)} \xB7 Choose the settings to use on all registered services.
-`);
+        writeHeading(prompter, `Compare ${name}`);
+        writeField(prompter, "Services", state.clients.map((client) => CLIENT_LABELS2[client]).join(" \xB7 ") || "none");
         compareEntries(prompter, candidates.map((candidate) => ({ label: CLIENT_LABELS2[candidate.client], entry: candidate.entry })));
         const choice = await prompter.select("Use settings from", [
           ...candidates.map((candidate, index) => ({ value: String(index), label: `Use ${index + 1}: ${CLIENT_LABELS2[candidate.client]}` })),
@@ -2100,22 +2352,23 @@ ${plainText(name)} \xB7 Choose the settings to use on all registered services.
         if (choice === "back") continue;
         chosen = candidates[Number(choice)];
       }
+      writeField(prompter, "Connection", name);
+      writeField(prompter, "Version", CLIENT_LABELS2[chosen.client]);
       preview(prompter, chosen.entry);
       const destination = await prompter.askRequired("Shared connection name (change it to keep both)", name);
-      prompter.write("The selected version will be used by every registered service.\n");
+      writeField(prompter, "Apply to", state.clients.map((client) => CLIENT_LABELS2[client]).join(" \xB7 ") || "none");
       if (!await prompter.askYesNo(`Import ${destination} and apply it?`, true)) continue;
       const results = registry.importEntry(destination, chosen, candidates);
       prompter.clearScreen();
       prompter.write(`
-${formatResults(results, "Import complete")}
+${registry.formatResults(results, "Import complete", prompter.paint)}
 `);
-      if (destination !== name) prompter.write("  The original entries were kept under their old name.\n");
+      if (destination !== name) writeField(prompter, "Kept", name, "original entries retain this name", "warning");
       await prompter.acknowledge();
     } catch (error) {
       if (error instanceof PromptClosedError) throw error;
       if (error instanceof PromptBackError) continue;
-      prompter.write(`  ${error instanceof Error ? error.message : "Import failed."}
-`);
+      writeWarning(prompter, error instanceof Error ? error.message : "Import failed.");
       await prompter.acknowledge();
     }
   }
@@ -2127,19 +2380,26 @@ async function syncMenu(prompter, registry) {
     const results = pendingResults ?? registry.sync();
     pendingResults = void 0;
     prompter.write(`
-${formatResults(results, "Sync results")}
+${registry.formatResults(results, "Sync results", prompter.paint, "Next: choose an item below to compare settings and pick a version.")}
 `);
+    const imports = pendingImports(registry);
+    if (imports.names.length) writeField(prompter, "Not imported", countLabel(imports.names.length, "connection"), `${imports.differing === imports.names.length ? "different settings \xB7 " : ""}choose Import existing connections`, "warning");
     const conflicts = results.filter((result) => result.status === "conflict");
-    if (!conflicts.length) {
+    if (!conflicts.length && !imports.names.length) {
       await prompter.acknowledge();
       return;
     }
     const picked = await prompter.select("Review differences", [
       ...conflicts.map((item, index) => ({ value: String(index), label: `${CLIENT_LABELS2[item.client]} \xB7 ${item.name}` })),
+      ...imports.names.length ? [{ value: "import", key: "import", label: "Import existing connections", hint: `${imports.names.length} connection(s) to review` }] : [],
       { value: "back", key: "b", label: "Later \u2014 keep existing settings" }
     ], { cancelValue: "back" });
     if (picked === "back") return;
     try {
+      if (picked === "import") {
+        await importMenu(prompter, registry);
+        continue;
+      }
       prompter.clearScreen();
       const conflict = conflicts[Number(picked)];
       const state = registry.read();
@@ -2148,12 +2408,14 @@ ${formatResults(results, "Sync results")}
         const session = state.sessions[sessionKind];
         const actual2 = registry.targets.find((target) => target.id === conflict.client)?.readEntries()[conflict.name];
         if (!actual2 || entryKind(actual2) !== sessionKind) {
-          prompter.write("This session name belongs to an unsupported or different server. Rename the external entry manually; it was kept.\n");
+          writeWarning(prompter, "This name belongs to another server. Rename its external entry; existing settings stay.");
           await prompter.acknowledge();
           continue;
         }
         const removing2 = !registry.isSessionMode(sessionKind, state) || !state.clients.includes(conflict.client) || !Object.values(state.connections).some((item) => item.kind === sessionKind && item.entry);
-        writeWrapped(prompter, `Session server / ${conflict.name} / ${CLIENT_LABELS2[conflict.client]}`);
+        writeHeading(prompter, "Review session launch");
+        writeField(prompter, "Server", conflict.name);
+        writeField(prompter, "Service", CLIENT_LABELS2[conflict.client]);
         compareEntries(prompter, [{ label: "AKMS session launch", entry: session.entry }, { label: "External settings", entry: actual2 }]);
         const choice2 = await prompter.select("Resolve session launch", [
           { value: "apply", label: removing2 ? "Remove the old session entry" : "Restore the AKMS session launch" },
@@ -2166,71 +2428,61 @@ ${formatResults(results, "Sync results")}
       if (!connection) throw new Error("This connection changed. Reopen Sync to review its current settings.");
       const actual = registry.targets.find((target) => target.id === conflict.client)?.readEntries()[conflict.name];
       if (!actual || entryKind(actual) !== connection.kind) {
-        prompter.write("  This name belongs to a different or unsupported server. Rename that entry manually, or rename the shared connection.\n");
+        writeWarning(prompter, "This name belongs to another server. Rename that entry or the shared connection.");
         await prompter.acknowledge();
         continue;
       }
       const client = CLIENT_LABELS2[conflict.client];
       const registered = state.clients.includes(conflict.client);
       const sessionMode = registry.isSessionMode(connection.kind, state);
-      const removing = !connection.entry || !registered || sessionMode;
+      const removing = !connection.entry || !registered;
+      const retiring = sessionMode && !removing;
       const subject = connection.entry && descriptionOnly([connection.entry, actual]) ? "description" : "settings";
-      writeWrapped(prompter, `Sync / ${plainText(conflict.name)}`);
-      writeWrapped(prompter, `Registered services: ${state.clients.map((id) => CLIENT_LABELS2[id]).join(" \xB7 ") || "none"}`);
+      writeHeading(prompter, `Sync / ${conflict.name}`);
+      writeField(prompter, "Services", state.clients.map((id) => CLIENT_LABELS2[id]).join(" \xB7 ") || "none");
       prompter.write("\n");
       if (!removing && connection.entry) {
+        if (retiring) {
+          writeField(prompter, "Server", sessionName(connection.kind));
+          writeField(prompter, "Kept in", client, "old entry stays until this server is ready", "warning");
+        }
         compareEntries(prompter, [{ label: "Saved in AKMS", entry: connection.entry }, { label: `Currently in ${client}`, entry: actual }]);
       } else {
-        writeWrapped(prompter, !registered ? `${client} is no longer registered.` : sessionMode ? `This kind now uses ${sessionName(connection.kind)}. The individual client entry is no longer needed.` : "This connection was removed from AKMS.");
-        writeWrapped(prompter, `Its settings in ${client} changed before removal could finish.`);
-        prompter.write(`
-Currently in ${client}
-`);
+        writeField(prompter, "Action", !registered ? `${client} unregistered` : "Remove connection", "", "warning");
+        writeHint(prompter, `Settings changed in ${client}; choose what to keep.`);
+        writeHeading(prompter, `Currently in ${client}`);
         preview(prompter, actual);
         prompter.write("\n");
       }
       const choices = [
-        { value: "shared", label: removing ? `Remove from ${client}` : `Use 1: AKMS -> ${client}`, hint: removing ? "finish the pending removal" : `replace its ${subject} with version 1` },
-        ...registered ? [{ value: "client", label: sessionMode ? `Import ${client} settings into the catalog, then remove this entry` : removing ? `Restore from ${client}` : `Use 2: ${client} -> all ${state.clients.length} services`, hint: "save in AKMS and sync registered services" }] : [],
+        { value: "shared", label: removing ? `Remove from ${client}` : retiring ? "Use 1: keep AKMS settings" : `Use 1: AKMS -> ${client}`, hint: removing ? "finish the pending removal" : retiring ? `use version 1 in ${sessionName(connection.kind)}` : `replace its ${subject} with version 1` },
+        ...registered ? [{ value: "client", label: removing ? `Restore from ${client}` : `Use 2: ${client} -> all ${state.clients.length} services`, hint: retiring ? `save version 2 in AKMS for ${sessionName(connection.kind)}` : "save in AKMS and sync registered services" }] : [],
         { value: "back", key: "b", label: "Back without changes" }
       ];
       const choice = await prompter.select(removing ? registered ? "Remove or restore this connection?" : `Remove this connection from ${client}?` : `Which ${subject} should be used?`, choices, { cancelValue: "back" });
       if (choice === "back") continue;
       prompter.write("\n");
       if (choice === "client") {
-        writeWrapped(prompter, `Save the ${client} version in AKMS.`);
-        writeWrapped(prompter, `Sync to: ${state.clients.map((id) => CLIENT_LABELS2[id]).join(" \xB7 ")}`);
-      } else writeWrapped(prompter, removing ? `Remove ${plainText(conflict.name)} from ${client}.` : `Copy the saved AKMS ${subject} to ${client}.`);
-      const confirmation = choice === "client" ? `Save in AKMS and sync ${state.clients.length} services?` : removing ? `Remove from ${client}?` : `Update ${client} with version 1?`;
+        writeField(prompter, "Save version", client, "in AKMS");
+        writeField(prompter, "Apply to", state.clients.map((id) => CLIENT_LABELS2[id]).join(" \xB7 "));
+      } else writeField(prompter, removing ? "Remove" : "Keep version", removing ? `${conflict.name} in ${client}` : "AKMS", removing ? "" : retiring ? `for ${sessionName(connection.kind)}` : `apply ${subject} to ${client}`);
+      if (retiring) writeHint(prompter, `The old ${client} entry stays until ${sessionName(connection.kind)} is ready.`);
+      const confirmation = choice === "client" ? `Save in AKMS and sync ${state.clients.length} services?` : removing ? `Remove from ${client}?` : retiring ? "Keep version 1 and finish Sync?" : `Update ${client} with version 1?`;
       if (await prompter.askYesNo(confirmation, false)) {
         pendingResults = registry.resolve(conflict.client, conflict.name, actual, choice === "client");
       }
     } catch (error) {
       if (error instanceof PromptClosedError) throw error;
       if (error instanceof PromptBackError) continue;
-      prompter.write(`  ${error instanceof Error ? error.message : "Could not resolve the difference."}
+      prompter.write(`${prompter.paint.error("Failed")} ${screenText(error instanceof Error ? error.message : "Could not resolve the difference.")}
 `);
       await prompter.acknowledge();
     }
   }
 }
-
-// src/modules/registration/targets/index.ts
-import os5 from "os";
-import path10 from "path";
-
-// src/modules/registration/targets/claude-code.ts
-import { spawnSync } from "child_process";
-import fs8 from "fs";
-import os3 from "os";
-import path8 from "path";
-
-// src/modules/registration/paths.ts
-import fs5 from "fs";
-import path6 from "path";
 function findExecutable(name) {
   const searchPath = process.env.PATH ?? "";
-  const directories = searchPath.split(path6.delimiter).filter((directory) => directory !== "");
+  const directories = searchPath.split(path2.delimiter).filter((directory) => directory !== "");
   let suffixes = [""];
   if (process.platform === "win32") {
     const pathExt = process.env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD";
@@ -2238,25 +2490,17 @@ function findExecutable(name) {
   }
   for (const directory of directories) {
     for (const suffix of suffixes) {
-      const candidate = path6.join(directory, `${name}${suffix}`);
-      if (fs5.existsSync(candidate) == true && fs5.statSync(candidate).isFile() == true) {
+      const candidate = path2.join(directory, `${name}${suffix}`);
+      if (fs.existsSync(candidate) == true && fs.statSync(candidate).isFile() == true) {
         return candidate;
       }
     }
   }
   return null;
 }
-
-// src/modules/registration/targets/json-file.ts
-import fs7 from "fs";
-
-// src/modules/registration/targets/config-file.ts
-import fs6 from "fs";
-import path7 from "path";
-import { randomUUID as randomUUID2 } from "crypto";
 function readExisting2(filePath) {
   try {
-    return fs6.readFileSync(filePath, "utf8");
+    return fs.readFileSync(filePath, "utf8");
   } catch (error) {
     if (error.code === "ENOENT") {
       return null;
@@ -2268,45 +2512,45 @@ function updateConfigFile2(filePath, update) {
   let destination = filePath;
   let symbolicLink = false;
   try {
-    symbolicLink = fs6.lstatSync(filePath).isSymbolicLink();
+    symbolicLink = fs.lstatSync(filePath).isSymbolicLink();
   } catch (error) {
     if (error.code !== "ENOENT") {
       throw error;
     }
   }
   if (symbolicLink) {
-    destination = fs6.realpathSync(filePath);
+    destination = fs.realpathSync(filePath);
   }
   const before = readExisting2(destination);
   const updated = update(before ?? "");
   if (before != null) {
-    fs6.accessSync(destination, fs6.constants.W_OK);
+    fs.accessSync(destination, fs.constants.W_OK);
   }
-  fs6.mkdirSync(path7.dirname(destination), { recursive: true });
-  const temporary = path7.join(path7.dirname(destination), `.${path7.basename(destination)}.${randomUUID2()}.tmp`);
-  const mode = before == null ? 384 : fs6.statSync(destination).mode & 511;
+  fs.mkdirSync(path2.dirname(destination), { recursive: true });
+  const temporary = path2.join(path2.dirname(destination), `.${path2.basename(destination)}.${randomUUID()}.tmp`);
+  const mode = before == null ? 384 : fs.statSync(destination).mode & 511;
   let descriptor;
   let ownsTemporary = false;
   try {
-    descriptor = fs6.openSync(temporary, "wx", mode);
+    descriptor = fs.openSync(temporary, "wx", mode);
     ownsTemporary = true;
-    fs6.writeFileSync(descriptor, updated, "utf8");
-    fs6.fsyncSync(descriptor);
-    fs6.closeSync(descriptor);
+    fs.writeFileSync(descriptor, updated, "utf8");
+    fs.fsyncSync(descriptor);
+    fs.closeSync(descriptor);
     descriptor = void 0;
     if (readExisting2(destination) !== before) {
       throw new Error("The config changed while saving; reload it and try again.");
     }
-    fs6.renameSync(temporary, destination);
+    fs.renameSync(temporary, destination);
     ownsTemporary = false;
   } finally {
     try {
       if (descriptor != null) {
-        fs6.closeSync(descriptor);
+        fs.closeSync(descriptor);
       }
     } finally {
       if (ownsTemporary) {
-        fs6.unlinkSync(temporary);
+        fs.unlinkSync(temporary);
       }
     }
   }
@@ -2359,10 +2603,10 @@ function readMcpServersJson(document) {
   return entries;
 }
 function readDocument(filePath, contents) {
-  if (contents == null && fs7.existsSync(filePath) == false) {
+  if (contents == null && fs.existsSync(filePath) == false) {
     return {};
   }
-  const text = contents ?? fs7.readFileSync(filePath, "utf8");
+  const text = contents ?? fs.readFileSync(filePath, "utf8");
   if (text.trim() === "") {
     return {};
   }
@@ -2387,7 +2631,7 @@ function createJsonFileTarget(options) {
     id,
     label,
     location: filePath,
-    detected: fs7.existsSync(filePath),
+    detected: fs.existsSync(filePath),
     readEntries() {
       const document = readDocument(filePath);
       return readMcpServersJson(document);
@@ -2418,7 +2662,7 @@ function createJsonFileTarget(options) {
 }
 
 // src/modules/registration/targets/claude-code.ts
-var CLAUDE_CODE_CONFIG_PATH = path8.join(os3.homedir(), ".claude.json");
+var CLAUDE_CODE_CONFIG_PATH = path2.join(os5.homedir(), ".claude.json");
 var CMD_META_CHARACTER_PATTERN = /([()\][%!^"`<>&|;, *?])/g;
 function toClaudeAddJsonPayload(entry) {
   return JSON.stringify({ type: "stdio", command: entry.command, args: entry.args, env: entry.env });
@@ -2460,10 +2704,10 @@ function runClaude(executable, args) {
   return { status: "written", detail: CLAUDE_CODE_CONFIG_PATH };
 }
 function readRawClaudeEntries() {
-  if (fs8.existsSync(CLAUDE_CODE_CONFIG_PATH) == false) {
+  if (fs.existsSync(CLAUDE_CODE_CONFIG_PATH) == false) {
     return {};
   }
-  const text = fs8.readFileSync(CLAUDE_CODE_CONFIG_PATH, "utf8");
+  const text = fs.readFileSync(CLAUDE_CODE_CONFIG_PATH, "utf8");
   let document;
   try {
     document = JSON.parse(text);
@@ -2482,7 +2726,7 @@ function createClaudeCodeTarget() {
     id: "claude-code",
     label: "Claude Code (user scope)",
     location: CLAUDE_CODE_CONFIG_PATH,
-    detected: executable != null || fs8.existsSync(CLAUDE_CODE_CONFIG_PATH) == true,
+    detected: executable != null || fs.existsSync(CLAUDE_CODE_CONFIG_PATH) == true,
     readEntries() {
       return readMcpServersJson({ mcpServers: readRawClaudeEntries() });
     },
@@ -2527,11 +2771,6 @@ function createClaudeCodeTarget() {
   };
 }
 
-// src/modules/registration/targets/codex.ts
-import fs9 from "fs";
-import os4 from "os";
-import path9 from "path";
-
 // src/modules/registration/targets/toml-lines.ts
 function lineState() {
   return { quote: null, multiline: false, depth: 0 };
@@ -2571,10 +2810,6 @@ function scanTomlLine(line, state) {
     }
   }
 }
-
-// src/modules/registration/targets/toml-validation.ts
-import { isDeepStrictEqual } from "util";
-import { parse, TomlError } from "smol-toml";
 function isTable(value) {
   return value != null && typeof value === "object" && !Array.isArray(value) && !(value instanceof Date);
 }
@@ -2825,18 +3060,18 @@ function editMcpServerToml(text, name, entry) {
 
 // src/modules/registration/targets/codex.ts
 function createCodexTarget() {
-  const CODEX_CONFIG_PATH = path9.join(process.env.CODEX_HOME ? path9.resolve(process.env.CODEX_HOME) : path9.join(os4.homedir(), ".codex"), "config.toml");
+  const CODEX_CONFIG_PATH = path2.join(process.env.CODEX_HOME ? path2.resolve(process.env.CODEX_HOME) : path2.join(os5.homedir(), ".codex"), "config.toml");
   function readText() {
-    if (fs9.existsSync(CODEX_CONFIG_PATH) == false) {
+    if (fs.existsSync(CODEX_CONFIG_PATH) == false) {
       return "";
     }
-    return fs9.readFileSync(CODEX_CONFIG_PATH, "utf8");
+    return fs.readFileSync(CODEX_CONFIG_PATH, "utf8");
   }
   return {
     id: "codex",
     label: "Codex CLI",
     location: CODEX_CONFIG_PATH,
-    detected: findExecutable("codex") != null || fs9.existsSync(CODEX_CONFIG_PATH) == true,
+    detected: findExecutable("codex") != null || fs.existsSync(CODEX_CONFIG_PATH) == true,
     readEntries() {
       const text = readText();
       return parseMcpServersToml(text);
@@ -2864,20 +3099,20 @@ function createCodexTarget() {
 // src/modules/registration/targets/index.ts
 function claudeDesktopConfigPath() {
   if (process.platform === "win32") {
-    const appData = process.env.APPDATA ?? path10.join(os5.homedir(), "AppData", "Roaming");
-    return path10.join(appData, "Claude", "claude_desktop_config.json");
+    const appData = process.env.APPDATA ?? path2.join(os5.homedir(), "AppData", "Roaming");
+    return path2.join(appData, "Claude", "claude_desktop_config.json");
   }
   if (process.platform === "darwin") {
-    return path10.join(os5.homedir(), "Library", "Application Support", "Claude", "claude_desktop_config.json");
+    return path2.join(os5.homedir(), "Library", "Application Support", "Claude", "claude_desktop_config.json");
   }
-  return path10.join(os5.homedir(), ".config", "Claude", "claude_desktop_config.json");
+  return path2.join(os5.homedir(), ".config", "Claude", "claude_desktop_config.json");
 }
 function listConfigTargets() {
   const targets = [
     createClaudeCodeTarget(),
     createCodexTarget(),
     createJsonFileTarget({ id: "claude-desktop", label: "Claude Desktop", filePath: claudeDesktopConfigPath() }),
-    createJsonFileTarget({ id: "cursor", label: "Cursor", filePath: path10.join(os5.homedir(), ".cursor", "mcp.json") })
+    createJsonFileTarget({ id: "cursor", label: "Cursor", filePath: path2.join(os5.homedir(), ".cursor", "mcp.json") })
   ];
   const detected = targets.filter((target) => target.detected == true);
   const others = targets.filter((target) => target.detected == false);
@@ -2919,8 +3154,7 @@ ${failure}
         prompter.clearScreen();
         const state = registry.read();
         const clients = state.clients;
-        const migration = registry.needsMigration(state);
-        if (migration) prompter.write("Registry update available. Choose Migrate registry to review the changes.\n");
+        const runtime = runtimeNotice(registry);
         const picked = await prompter.select("AKMS MCP \xB7 Connection setup", [
           { value: "db", label: "Database", hint: "PostgreSQL connections" },
           { value: "ssh", label: "SSH", hint: "Remote hosts" },
@@ -2929,20 +3163,16 @@ ${failure}
           { separator: true },
           { value: "register", label: "Register", hint: clients.length ? clients.map((id) => CLIENT_LABELS2[id]).join(" \xB7 ") : "Choose AI services once" },
           { value: "sync", label: "Sync", hint: "Review and retry shared settings" },
-          { value: "runtime", label: "Runtime", hint: "AKMS installation / replace npx launches" },
-          { value: "updates", label: "Updates", hint: "Check installed MCP releases" },
-          ...migration ? [{ value: "migrate", key: "migrate", label: "Migrate registry", hint: "Review older registry format and session layout" }] : [],
+          { value: "runtime", label: "Runtime", hint: runtime.hint, notice: runtime.notice },
           { value: "quit", label: "Quit" }
         ], { defaultValue, cancelValue: "quit" });
-        if (picked !== "register" && picked !== "sync" && picked !== "runtime" && picked !== "updates" && picked !== "migrate") {
+        if (picked !== "register" && picked !== "sync" && picked !== "runtime") {
           selected = picked;
           break;
         }
         try {
           if (picked === "register") await registrationMenu(prompter, registry, options.targetId);
           else if (picked === "runtime") await runtimeMenu(prompter, registry);
-          else if (picked === "updates") await updatesMenu(prompter, registry);
-          else if (picked === "migrate") await migrationMenu(prompter, registry);
           else await syncMenu(prompter, registry);
         } catch (error) {
           if (error instanceof PromptClosedError) throw error;
@@ -2971,66 +3201,18 @@ ${error instanceof Error ? error.message : "Could not update settings."}
     }
   }
 }
-
-// src/modules/launcher/npm.ts
-import { execFile as execFile3, spawn as spawn2 } from "child_process";
-import { existsSync } from "fs";
-import { mkdtemp, realpath, rm } from "fs/promises";
-import { tmpdir } from "os";
-import { basename, delimiter, dirname, join } from "path";
-import { promisify as promisify2 } from "util";
-var execFileAsync = promisify2(execFile3);
-async function findNpmCli() {
-  const candidates = [];
-  const npmExecPath = process.env.npm_execpath;
-  if (npmExecPath != null && ["npm-cli.js", "npx-cli.js"].includes(basename(npmExecPath)) == true) {
-    candidates.push(join(dirname(npmExecPath), "npm-cli.js"));
-  }
-  candidates.push(join(dirname(process.execPath), "node_modules", "npm", "bin", "npm-cli.js"));
-  candidates.push(join(dirname(process.execPath), "..", "lib", "node_modules", "npm", "bin", "npm-cli.js"));
-  for (const directory of (process.env.PATH ?? "").split(delimiter)) {
-    if (directory === "") {
-      continue;
-    }
-    if (process.platform === "win32") {
-      candidates.push(join(directory, "node_modules", "npm", "bin", "npm-cli.js"));
-    } else {
-      candidates.push(join(directory, "npm"));
+function bundledEntry(kind) {
+  let directory = dirname(fileURLToPath(import.meta.url));
+  for (; ; ) {
+    const manifest = join(directory, "package.json");
+    if (existsSync(manifest) == true && JSON.parse(readFileSync(manifest, "utf8")).name === PACKAGE_NAME) {
+      return { command: process.execPath, args: [join(directory, "lib", `${kind}.js`)] };
     }
-  }
-  for (const candidate of candidates) {
-    if (existsSync(candidate) == true) {
-      const resolved = await realpath(candidate);
-      if (resolved.endsWith(".js")) return resolved;
+    const parent = dirname(directory);
+    if (parent === directory) {
+      throw new Error("The AKMS MCP package could not be located; setup was not started.");
     }
-  }
-  throw new Error("npm could not be found. Install Node.js with npm, then reopen your terminal.");
-}
-async function resolveLatestVersion(options) {
-  const metadataCache = await mkdtemp(join(tmpdir(), "akms-mcp-latest-"));
-  try {
-    const result = await execFileAsync(process.execPath, [
-      options.npmCli,
-      "view",
-      `${options.packageName}@latest`,
-      "version",
-      "--json",
-      "--prefer-online",
-      "--prefer-offline=false",
-      "--offline=false",
-      "--fetch-retries=0",
-      "--fetch-timeout=15000",
-      "--update-notifier=false",
-      "--cache",
-      metadataCache
-    ], { signal: options.signal, timeout: 2e4, windowsHide: true });
-    const version = JSON.parse(result.stdout);
-    if (typeof version !== "string" || /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/.test(version) == false) {
-      throw new Error("npm returned an invalid latest version.");
-    }
-    return version;
-  } finally {
-    await rm(metadataCache, { recursive: true, force: true });
+    directory = parent;
   }
 }
 async function launchMcp(options, dependencies = {}) {
@@ -3046,20 +3228,20 @@ async function launchMcp(options, dependencies = {}) {
     const prompter = new Prompter(dependencies.input ?? process.stdin, output, pendingInput);
     try {
       prompter.write(`
-${selected.packageName} is not installed in the AKMS runtime directory.
+${PACKAGE_NAME} is not installed in the AKMS runtime directory.
 `);
       if (!await prompter.askYesNo("Install the AKMS runtime before opening setup?", true)) return 0;
       try {
-        prompter.write(`Installing ${selected.packageName}...
+        prompter.write(`Installing ${PACKAGE_NAME}...
 `);
-        await (dependencies.installRuntime ?? installGlobalRuntime)(options.mcpId);
+        await (dependencies.installRuntime ?? installGlobalRuntime)();
         runtime = findRuntime(options.mcpId);
         if (!runtime) throw new Error("Installation completed but the AKMS runtime could not be found.");
       } catch (error) {
         if (error instanceof Error && error.message === "AKMS runtime installation cancelled.") return 130;
         prompter.write(`${error instanceof Error ? error.message : "AKMS runtime installation failed."}
 `);
-        if (!await prompter.askYesNo("Open the latest setup with npm exec instead?", false)) return 1;
+        if (!await prompter.askYesNo("Open setup from this launcher instead?", false)) return 1;
       }
     } catch (error) {
       if (error instanceof PromptClosedError || error instanceof PromptBackError) return 0;
@@ -3069,61 +3251,16 @@ ${selected.packageName} is not installed in the AKMS runtime directory.
       pendingInput = prompter.takePendingInput();
     }
   }
-  if (runtime) {
-    const argumentsList = [...runtime.args, selected.setupCommand];
-    if (options.targetId) argumentsList.push("--target", options.targetId);
-    output.write(`Opening ${selected.packageName} ${runtime.version}${runtime.linked ? " (linked development checkout)" : ""}
+  const launch = runtime ?? (dependencies.bundledEntry ?? bundledEntry)(options.mcpId);
+  const argumentsList = [...launch.args, selected.setupCommand];
+  if (options.targetId) argumentsList.push("--target", options.targetId);
+  if (runtime) output.write(`Opening ${selected.label} setup \xB7 ${PACKAGE_NAME} ${runtime.version}${runtime.linked ? " (linked development checkout)" : ""}
 
 `);
-    return (dependencies.runChild ?? runChild)(runtime.command, argumentsList, pendingInput);
-  }
-  return launchLatestSetup(options, dependencies, pendingInput);
-}
-async function launchLatestSetup(options, dependencies, pendingInput) {
-  const selected = MCP_PACKAGES[options.mcpId];
-  const output = dependencies.output ?? process.stdout;
-  const npmCli2 = await (dependencies.findNpmCli ?? findNpmCli)();
-  const cancellation = new AbortController();
-  const cancelLookup = () => {
-    cancellation.abort();
-  };
-  process.on("SIGINT", cancelLookup);
-  process.on("SIGTERM", cancelLookup);
-  let version;
-  try {
-    output.write(`
-Checking the latest ${selected.packageName} release...
-`);
-    version = await (dependencies.resolveLatestVersion ?? resolveLatestVersion)({ npmCli: npmCli2, packageName: selected.packageName, signal: cancellation.signal });
-  } catch (error) {
-    if (cancellation.signal.aborted == true) {
-      return 130;
-    }
-    throw new Error(`Could not check the latest ${selected.packageName} release; setup was not started.
-${String(error)}`, { cause: error });
-  } finally {
-    process.off("SIGINT", cancelLookup);
-    process.off("SIGTERM", cancelLookup);
-  }
-  const argumentsList = [
-    npmCli2,
-    "exec",
-    "--yes",
-    "--prefer-online",
-    "--prefer-offline=false",
-    "--offline=false",
-    `--package=${selected.packageName}@${version}`,
-    "--",
-    selected.command,
-    selected.setupCommand
-  ];
-  if (options.targetId != null) {
-    argumentsList.push("--target", options.targetId);
-  }
-  output.write(`Opening ${selected.packageName} ${version} with npm exec
+  else output.write(`Opening ${selected.label} setup \xB7 ${PACKAGE_NAME} ${PACKAGE_VERSION} from this launcher
 
 `);
-  return (dependencies.runChild ?? runChild)(process.execPath, argumentsList, pendingInput);
+  return (dependencies.runChild ?? runChild)(launch.command, argumentsList, pendingInput);
 }
 async function runChild(command, argumentsList, pendingInput) {
   return new Promise((resolve, reject) => {
@@ -3132,9 +3269,10 @@ async function runChild(command, argumentsList, pendingInput) {
     if (interactiveInput == true) {
       inputMode = "inherit";
     }
-    const child = spawn2(command, argumentsList, {
+    const child = spawn(command, argumentsList, {
       stdio: [inputMode, "inherit", "inherit"],
-      windowsHide: true
+      windowsHide: true,
+      env: { ...process.env, AKMS_MCP_MENU: "1" }
     });
     const interrupt = () => {
       child.kill("SIGINT");
@@ -3206,11 +3344,7 @@ async function main() {
     return;
   }
   if (argumentsList.showVersion == true) {
-    let version = "development";
-    if (true) {
-      version = "0.3.1";
-    }
-    process.stdout.write(`${version}
+    process.stdout.write(`${PACKAGE_VERSION}
 `);
     return;
   }
@@ -3234,3 +3368,5 @@ main().catch((error) => {
 `);
   process.exitCode = 1;
 });
+//# sourceMappingURL=cli.js.map
+//# sourceMappingURL=cli.js.map