claude-multiacc 2.0.59 → 2.0.60

package/README.md

@@ -568,7 +568,20 @@ claude-accounts mcp apply                        # re-apply now (repair drift)
   outcome into the registry and every other account (`learn`). This includes a command run
   from **inside** a pooled session (an agent's Bash tool, `npx appinspire-mcp install` run by
   an agent): the session's config dir is a pool account, so the same mirror applies. A
-  config dir outside the pool is plain passthrough.
+  config dir outside the pool is plain passthrough. Global options in front of `mcp` are
+  looked past the way the real parser does (`alias claude='claude
+  --dangerously-skip-permissions'` puts one before every typed `claude mcp add`; until
+  2026-10-22 that kept motionsites in 2 of 11 accounts).
+- **Adoption**: whatever reached an account by another route — the real binary run
+  directly, a hand edit, another tool's installer — is adopted by the next reconcile: a
+  server (user scope or a project entry) or a project's `.mcp.json` approval that no section
+  names, live or retired, joins the registry (a replica: its overlay) and so every account.
+  Several definitions of one name: the one most accounts hold wins, then the newest config
+  file. Every limits pass reconciles all accounts this way, so an idle account catches up too.
+  Never adopted: anything the pool itself once wrote into that account (`<acct>/.mcp-managed.json`
+  — so a stray synced entry dropped without a tombstone, or a vanished overlay owner's
+  server, stays out of the synced registry), tombstoned names, and nothing at all with
+  `CLAUDE_MULTIACC_MCP_ADOPT=0` / `CODEX_MULTIACC_MCP_ADOPT=0`.
 - **Runner-managed servers**: on app-robot fleet Macs the runner publishes `appinspire-mcp` into
   each Mac's machine-local overlay with that Mac's own paths. Never `mcp add` it to the synced
   registry (directly, through a mirrored `claude|codex mcp add`, or via `appinspire-mcp install`):

package/bin/claude

@@ -167,14 +167,71 @@ mcp_oauth_ensure() { # $1 acct dir — silent, never changes the exit status
 # account against a snapshot taken just before). The real CLI's own parser and writer do
 # the work; the shim only copies the outcome. Exits with the real binary's status; a
 # mirror failure is one hint line. Returns 1 when this run is not such a command.
+# The index of the first positional argument as the real CLI's parser (commander) finds
+# it: global options may come first, in any number. The operator's `alias claude='claude
+# --dangerously-skip-permissions'` puts one in front of every `claude mcp add` typed at a
+# prompt, and the scoped-limit fallback prepends `--model X`; the mirror once looked at $1
+# alone, so on 2026-10-22 motionsites (and playwright, inspo) sat in the one account a
+# typed add ran under. A value option skips its value; an optional-value one the next
+# word unless it is an option; a variadic one every word up to the next option. `--`, or
+# a positional after `--` counts (commander's own rule). No positional: status 1. Options
+# of claude 2.1.308 (`claude --help`; hidden ones left out on purpose): an unknown one
+# counts as a flag — at worst its value is taken for the positional, which is then no
+# `mcp`, the run is not mirrored, and the registry's adoption picks the server up instead.
+CLI_VALUE_OPTS=" --agent --agents --append-system-prompt --append-system-prompt-file \
+--autocompact --debug-file --effort --environment --fallback-model --input-format \
+--json-schema --max-budget-usd --model -n --name --output-format --permission-mode \
+--permission-prompts --permission-prompt-tool --plugin-dir --plugin-url \
+--remote-control-session-name-prefix --session-id --setting-sources --settings \
+--system-prompt --system-prompt-file --system-prompt-snapshot "
+CLI_OPTIONAL_OPTS=" -d --debug --cloud --from-pr --prompt-suggestions --remote-control --rc \
+--remote -r --resume --teleport -w --worktree "
+CLI_VARIADIC_OPTS=" --add-dir --allowedTools --allowed-tools --betas --disallowedTools \
+--disallowed-tools --file --mcp-config --tools "
+cli_positional_at() { # argv -> prints the index of its first positional argument
+  local i=1 a nx
+  while [ "$i" -le "$#" ]; do
+    a="${!i}"
+    case "$a" in
+      --) i=$((i + 1)); [ "$i" -le "$#" ] || return 1; printf '%s\n' "$i"; return 0 ;;
+      --*=*) i=$((i + 1)); continue ;;
+      -?*) ;;
+      *) printf '%s\n' "$i"; return 0 ;;
+    esac
+    i=$((i + 1))
+    case "$CLI_VALUE_OPTS" in *" $a "*) i=$((i + 1)); continue ;; esac
+    case "$CLI_OPTIONAL_OPTS" in
+      *" $a "*) nx="${!i:-}"; case "$nx" in ''|-*) ;; *) i=$((i + 1)) ;; esac; continue ;;
+    esac
+    case "$CLI_VARIADIC_OPTS" in
+      *" $a "*)
+        while [ "$i" -le "$#" ]; do
+          nx="${!i}"; case "$nx" in -*) break ;; esac; i=$((i + 1))
+        done ;;
+    esac
+  done
+  return 1
+}
+
+# Whether argv is `claude [global options] mcp add|add-json|add-from-claude-desktop|remove …`.
+# The exact word -p/--print (or --bg/--background) anywhere before a `--` puts the client in
+# print/background mode, which never runs the subcommand.
+mcp_mutation_argv() {
+  local i j a
+  for a in "$@"; do
+    case "$a" in --) break ;; -p|--print|--bg|--background) return 1 ;; esac
+  done
+  i="$(cli_positional_at "$@")" || return 1
+  [ "${!i}" = "mcp" ] || return 1
+  j=$((i + 1))
+  case "${!j:-}" in add|add-json|add-from-claude-desktop|remove) return 0 ;; esac
+  return 1
+}
+
 mcp_mirror_run() { # $1 acct dir, then the user's argv — exits when it handled the run
-  local d="$1" snap="" rc verb="${2:-}" sub="${3:-}"
+  local d="$1" snap="" rc
   shift
-  # The scoped-limit fallback may have prepended `--model X` (a global option the real
-  # CLI accepts in front of any subcommand): look past it.
-  if [ "$verb" = "--model" ]; then verb="${3:-}"; sub="${4:-}"; fi
-  [ "$verb" = "mcp" ] || return 1
-  case "$sub" in add|add-json|remove) ;; *) return 1 ;; esac
+  mcp_mutation_argv "$@" || return 1
   [ "${CLAUDE_MULTIACC_MCP:-1}" != "0" ] && [ -f "$MCP_PY" ] || return 1
   mcp_ensure "$d"
   snap="$(mktemp "${TMPDIR:-/tmp}/claude-mcp-snap.XXXXXX" 2>/dev/null)" || snap=""
@@ -207,9 +264,8 @@ mcp_nested_mirror() {
   [ "${CLAUDE_MULTIACC_DISABLE:-0}" = "1" ] && return 1
   [ "${CLAUDE_MULTIACC_MCP:-1}" = "0" ] && return 1
   [ -n "${CLAUDE_CONFIG_DIR:-}" ] || return 1
-  local verb="${1:-}" cfg="${CLAUDE_CONFIG_DIR%/}" d=""
-  if [ "$verb" = "--model" ]; then verb="${3:-}"; fi
-  [ "$verb" = "mcp" ] || return 1
+  local cfg="${CLAUDE_CONFIG_DIR%/}" d=""
+  mcp_mutation_argv "$@" || return 1
   # A DIRECT child of the pool root, by its given spelling or its physical one (an
   # adopted account is a symlink whose target is the operator's ~/.claude).
   case "$cfg" in
@@ -2522,7 +2578,7 @@ export CLAUDE_SHIM_ACTIVE=1
 
 # A `claude mcp add|add-json|remove` is run as a child under the picked account and
 # mirrored to every other one (exits inside); anything else falls through to exec.
-if [ "${1:-}" = "mcp" ] || { [ "${1:-}" = "--model" ] && [ "${3:-}" = "mcp" ]; }; then
+if mcp_mutation_argv "$@"; then
   export CLAUDE_CONFIG_DIR="$pick"
   tok="$PICK_TOKEN"
   [ -n "$tok" ] && export CLAUDE_CODE_OAUTH_TOKEN="$tok"

package/bin/claude-accounts

@@ -2963,6 +2963,9 @@ PYEOF
   # lock while a consumer reads its output.
   limits_lock_release
   trap - EXIT
+  # Every account's MCP servers, adopting what one holds that the registry does not know
+  # (lib/common.sh) — before the push below, which carries the registry to the peers.
+  mcp_registry_pass
   # Whoever just refreshed is the only machine that CAN — pass it on before the
   # report, so a blind peer stops picking drained accounts within one cycle.
   limits_distribute

package/bin/codex

@@ -119,11 +119,60 @@ mcp_ensure() { # $1 acct dir — silent, never changes the exit status
 # snapshot taken just before). The real CLI's own parser and writer do the work; the shim
 # only copies the outcome. Exits with the real binary's status; a mirror failure is one
 # hint line. Returns 1 when this run is not such a command.
+# The index of the first positional argument as the real CLI's parser (clap) finds it:
+# global options may come first, in any number. The operator's `alias codex='codex
+# --dangerously-bypass-approvals-and-sandbox'` puts one in front of every `codex mcp add`
+# typed at a prompt, and the mirror once looked at $1 alone (bin/claude met the same on
+# 2026-10-22). A value option skips its value (attached `-mX`/`--model=X` is one word); a
+# variadic one every word up to the next option. `--`, or no positional: status 1.
+# Options of codex-cli 0.163 (`codex --help`); an unknown one counts as a flag.
+CLI_VALUE_OPTS=" -c --config --enable --disable --remote --remote-auth-token-env -m --model \
+--local-provider -p --profile -s --sandbox -C --cd --add-dir -a --ask-for-approval "
+CLI_VARIADIC_OPTS=" -i --image "
+cli_positional_at() { # argv -> prints the index of its first positional argument
+  local i=1 a nx
+  while [ "$i" -le "$#" ]; do
+    a="${!i}"
+    case "$a" in
+      --) return 1 ;;
+      --*=*) i=$((i + 1)); continue ;;
+      -?*) ;;
+      *) printf '%s\n' "$i"; return 0 ;;
+    esac
+    i=$((i + 1))
+    case "$CLI_VALUE_OPTS" in *" $a "*) i=$((i + 1)); continue ;; esac
+    case "$CLI_VARIADIC_OPTS" in
+      *" $a "*)
+        while [ "$i" -le "$#" ]; do
+          nx="${!i}"; case "$nx" in -*) break ;; esac; i=$((i + 1))
+        done ;;
+    esac
+  done
+  return 1
+}
+
+# Whether argv is `codex [global options] mcp add|remove …`.
+mcp_mutation_argv() {
+  local i j
+  i="$(cli_positional_at "$@")" || return 1
+  [ "${!i}" = "mcp" ] || return 1
+  j=$((i + 1))
+  # `mcp` takes options of its own before its subcommand: -c/--config, --enable, --disable
+  while :; do
+    case "${!j:-}" in
+      -c|--config|--enable|--disable) j=$((j + 2)) ;;
+      --*=*|-c?*) j=$((j + 1)) ;;
+      *) break ;;
+    esac
+  done
+  case "${!j:-}" in add|remove) return 0 ;; esac
+  return 1
+}
+
 mcp_mirror_run() { # $1 acct dir, then the user's argv — exits when it handled the run
   local d="$1" snap="" rc
   shift
-  [ "${1:-}" = "mcp" ] || return 1
-  case "${2:-}" in add|remove) ;; *) return 1 ;; esac
+  mcp_mutation_argv "$@" || return 1
   [ "${CODEX_MULTIACC_MCP:-1}" != "0" ] && [ -f "$MCP_PY" ] || return 1
   mcp_ensure "$d"
   snap="$(mktemp "${TMPDIR:-/tmp}/codex-mcp-snap.XXXXXX" 2>/dev/null)" || snap=""
@@ -156,8 +205,8 @@ mcp_nested_mirror() {
   [ "${CODEX_MULTIACC_DISABLE:-0}" = "1" ] && return 1
   [ "${CODEX_MULTIACC_MCP:-1}" = "0" ] && return 1
   [ -n "${CODEX_HOME:-}" ] || return 1
-  local verb="${1:-}" cfg="${CODEX_HOME%/}" d=""
-  [ "$verb" = "mcp" ] || return 1
+  local cfg="${CODEX_HOME%/}" d=""
+  mcp_mutation_argv "$@" || return 1
   # A DIRECT child of the pool root, by its given spelling or its physical one (an
   # adopted account is a symlink whose target is the operator's ~/.claude).
   case "$cfg" in
@@ -1526,7 +1575,7 @@ export CODEX_SHIM_ACTIVE=1
 
 # A `codex mcp add|remove` is run as a child under the picked account and mirrored to
 # every other one (exits inside); anything else falls through to exec.
-if [ "${1:-}" = "mcp" ]; then
+if mcp_mutation_argv "$@"; then
   share_state_index "$pick"
   export CODEX_HOME="$pick"
   mcp_mirror_run "$pick" "$@" || true

package/bin/codex-accounts

@@ -1846,6 +1846,8 @@ PYEOF
   # lock while a consumer reads its output.
   codex_limits_lock_release
   trap - EXIT
+  # Every account's MCP servers, adopting what one holds that the registry does not know.
+  mcp_registry_pass
   # This pool's model catalog, once its copy is an hour old (lib/common.sh).
   model_catalog_backstop
   # The refresher fails open per account; a NON-zero status means the pass itself

package/lib/common.sh

@@ -771,6 +771,21 @@ seed_mcp_registry() { # $1 = acct dir
   return 0
 }
 
+# Once per scheduled limits pass: reconcile EVERY account, which first adopts what any
+# one of them holds that the registry does not know (lib/mcp_registry.py adopt) — the
+# backstop for a server added where the shims' mirror never saw it, reaching accounts no
+# session launched on since. Unlike the shims' pre-exec apply it also runs before this
+# pool has a registry at all. Inline, quiet, fail-open: a pass never dies on it.
+mcp_registry_pass() {
+  local off
+  if [ "$MULTIACC_PROVIDER" = "codex" ]; then off="${CODEX_MULTIACC_MCP:-1}"; else off="${CLAUDE_MULTIACC_MCP:-1}"; fi
+  [ "$off" = "0" ] && return 0
+  [ -f "$LIB_DIR/mcp_registry.py" ] || return 0
+  "$PYBIN" "$LIB_DIR/mcp_registry.py" --root "$ACC_ROOT" --provider "$MULTIACC_PROVIDER" apply \
+    --all --fail-open --quiet >/dev/null 2>&1 </dev/null || true
+  return 0
+}
+
 seed_account_dir() { # $1 = acct dir
   local d="$1"
   mkdir -p "$d"

package/lib/mcp_registry.py

@@ -33,8 +33,12 @@ Reconcile rules, the same for both providers:
     any more" needs to hold fleet-wide; a name in `retiredUser` (a learned stock
     `claude mcp remove -s user`, or `mcp remove --user-only`) leaves project
     entries alone, exactly as the client itself did;
-  * anything else the account holds is left alone (an account may carry its own
-    extras);
+  * a server an account holds that no section names, live or retired, is ADOPTED
+    into the registry before the reconcile (`adopt`), and so reaches every account:
+    some route around the shims' mirror put it there (2026-10-22: the operator's
+    `alias claude='claude --dangerously-skip-permissions'` hid every typed
+    `claude mcp add` from it, and motionsites sat in 2 of 11 accounts). Kill switch
+    `<PROVIDER>_MULTIACC_MCP_ADOPT=0`;
   * project-scoped entries (`projects` in the registry) exist for claude only:
     Codex 0.156 reads no per-project config at all.
 
@@ -73,6 +77,12 @@ sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
 REGISTRY_FILE = "mcp-servers.json"
 OVERLAY_FILE = "mcp-servers.local.json"
 STAMP_FILE = ".mcp-applied"
+#: Every name the pool itself ever wrote into the account (from any section): adoption
+#: never takes one of those back, so a server dropped from a section without a tombstone
+#: (README's recovery for a stray synced entry) or one whose overlay owner vanished is a
+#: stale copy, not a new server — app-robot's machine-specific appinspire-mcp must never
+#: reach the synced registry that way.
+MANAGED_FILE = ".mcp-managed.json"
 LOCK_DIR = os.path.join(".locks", "mcp")
 PROVIDERS = ("claude", "codex")
 CONFIG_FILE = {"claude": ".claude.json", "codex": "config.toml"}
@@ -168,13 +178,14 @@ def _log(root, message):
 class _Lock:
     """mkdir lock, the same shape as lib/common.sh mutate_lock (30 s stale)."""
 
-    def __init__(self, root):
+    def __init__(self, root, wait=60):
         self.path = os.path.join(root, LOCK_DIR)
         self.held = False
+        self.wait = wait
 
     def __enter__(self):
         os.makedirs(os.path.dirname(self.path), exist_ok=True)
-        deadline = time.time() + 60
+        deadline = time.time() + self.wait
         while True:
             try:
                 os.mkdir(self.path)
@@ -864,18 +875,215 @@ def snapshot_codex(account_dir):
 
 # ---------------------------------------------------------------- reconcile
 
+def load_managed(account_dir):
+    """{"user": set(names), "projects": {path: set(names)}} — the account's ledger."""
+    doc = _read_json(os.path.join(account_dir, MANAGED_FILE), {})
+    doc = doc if isinstance(doc, dict) else {}
+    user = doc.get("user") if isinstance(doc.get("user"), list) else []
+    projects = doc.get("projects") if isinstance(doc.get("projects"), dict) else {}
+    return {"user": {str(n) for n in user},
+            "projects": {str(p): {str(n) for n in names} for p, names in projects.items()
+                         if isinstance(names, list)}}
+
+
+def record_managed(provider, account_dir, eff):
+    """Add what this reconcile wrote to the ledger (it only ever grows)."""
+    managed = load_managed(account_dir)
+    user = managed["user"] | set(eff.servers)
+    projects = {path: set(names) for path, names in managed["projects"].items()}
+    if provider == "claude":
+        for path, spec in eff.projects.items():
+            names = set(spec.get("mcpServers") or {})
+            if names:
+                projects[path] = projects.get(path, set()) | names
+    if user == managed["user"] and projects == managed["projects"]:
+        return
+    try:
+        _atomic_write(os.path.join(account_dir, MANAGED_FILE), json.dumps(
+            {"user": sorted(user), "projects": {p: sorted(n) for p, n in sorted(projects.items())}},
+            indent=2) + "\n")
+    except OSError:
+        pass
+
+
 def apply_account(root, provider, account_dir):
     eff = effective(load_registry(root), load_overlay(root))
     if provider == "claude":
         state = apply_claude(account_dir, eff)
     else:
         state = apply_codex(account_dir, eff)
+    record_managed(provider, account_dir, eff)
     write_stamp(root, provider, account_dir)
     return state
 
 
+def _adopt_enabled(provider):
+    return os.environ.get(f"{provider.upper()}_MULTIACC_MCP_ADOPT", "1") != "0"
+
+
+def _unknown(eff, snap, managed=None):
+    """What one account's snapshot holds that no section names, live or retired:
+    [(scope, path, name, block)] (path None for user scope). A project's `.mcp.json`
+    approvals are NOT adopted: one account's click would override another's rejection
+    (`disabledMcpjsonServers`) everywhere — only a mirrored `claude mcp` command carries one."""
+    managed = managed or {"user": set(), "projects": {}}
+    found = []
+    for name, block in (snap.get("user") or {}).items():
+        if not isinstance(block, dict):
+            continue
+        if name in eff.servers or name in eff.retired or name in eff.retired_user \
+                or name in managed["user"]:
+            continue
+        found.append(("user", None, name, block))
+    if snap.get("provider") != "claude":
+        return found
+    for path, entry in (snap.get("projects") or {}).items():
+        spec = eff.projects.get(path) or {}
+        known = set(spec.get("mcpServers") or {}) | set(spec.get("retired") or []) \
+            | eff.retired | managed["projects"].get(path, set())
+        for name, block in (entry.get("mcpServers") or {}).items():
+            if isinstance(block, dict) and name not in known:
+                found.append(("project", path, name, block))
+    return found
+
+
+def _still_unknown(eff, scope, path, name):
+    if scope == "user":
+        return not (name in eff.servers or name in eff.retired or name in eff.retired_user)
+    spec = eff.projects.get(path) or {}
+    return not (name in (spec.get("mcpServers") or {}) or name in (spec.get("retired") or [])
+                or name in eff.retired)
+
+
+def _config_mtime(provider, account_dir):
+    try:
+        return os.stat(os.path.join(account_dir, CONFIG_FILE[provider])).st_mtime
+    except OSError:
+        return 0.0
+
+
+def _codex_faithful(name, table):
+    """Whether the registry's codex translation gives this table back as it is (bar the
+    startup timeout default it adds to a stdio server): only then is a codex table adopted,
+    because the reconcile then rewrites the user's own table in that translation."""
+    try:
+        again, _notes = codex_block(name, codex_to_claude(name, table))
+    except RegistryError:
+        return False
+    if again is None:
+        return False
+    again = dict(again)
+    if "startup_timeout_sec" not in table and again.get("startup_timeout_sec") == 60:
+        again.pop("startup_timeout_sec")
+    if not table.get("args") and again.get("args") == []:
+        again.pop("args", None)
+    return again == {k: v for k, v in table.items()}
+
+
+def _carries_values(block):
+    """A block whose env or headers hold literal values — a token, an API key — stays on
+    this machine: the synced registry is a plain file pushed to every peer."""
+    for key in ("env", "headers"):
+        values = block.get(key)
+        if isinstance(values, dict) and any(str(v) and not str(v).startswith("${")
+                                            for v in values.values()):
+            return True
+    return False
+
+
+def adopt(root, provider, account_dirs, dry=False, lock_wait=60):
+    """Take every server these accounts hold that no section names into the registry
+    (on a replica: this machine's overlay, like any learned change). The mirror
+    (`learn`) sees only a `mcp add` the shim recognised; anything else — a global
+    option in front of `mcp` (the operator's aliases), the real binary run directly, a
+    hand edit, another tool's installer — left the server in the one account it ran
+    under, for ever. Several accounts holding different definitions of one name: the
+    one most of them hold wins, then the newest config file. Returns the change list
+    (dry: the names it would adopt, nothing written)."""
+    if not account_dirs or not _adopt_enabled(provider):
+        return []
+    eff = effective(load_registry(root), load_overlay(root))
+    variants = {}  # (scope, path, name) -> {canonical json: [count, newest mtime, block]}
+    # Every account votes, whichever one this run reconciles: a single-account apply (the
+    # shim's, before exec) must choose what `apply --all` would, never its own stale copy.
+    voters = list(dict.fromkeys(list(account_dirs) + manifest_account_dirs(root)))
+    for account_dir in voters:
+        try:
+            snap = snapshot(provider, account_dir)
+        except RegistryError:
+            continue  # apply reports an unreadable config itself
+        mtime = _config_mtime(provider, account_dir)
+        for scope, path, name, block in _unknown(eff, snap, load_managed(account_dir)):
+            slot = variants.setdefault((scope, path, name), {})
+            key = json.dumps(block, sort_keys=True)
+            count = slot.setdefault(key, [0, 0.0, block])
+            count[0] += 1
+            count[1] = max(count[1], mtime)
+    if not variants or dry:
+        return sorted(name for _scope, _path, name in variants)  # dry: what would be adopted
+    changes = []
+    synced_changed = local_changed = False
+    with _Lock(root, wait=lock_wait):
+        target = _Target(root)
+        local_overlay = target.overlay if target.replica else load_overlay(root)
+        eff = effective(load_registry(root), load_overlay(root))  # what holds under the lock
+        for (scope, path, name), slot in sorted(variants.items(), key=lambda kv: (
+                kv[0][0], kv[0][1] or "", kv[0][2])):
+            if not _still_unknown(eff, scope, path, name):
+                continue  # named meanwhile (a concurrent add, another machine's push)
+            count, _mtime, block = max(slot.values(), key=lambda v: (v[0], v[1]))
+            if provider == "codex" and not _codex_faithful(name, block):
+                _warn(f'not adopted: "{name}" — the registry cannot express its codex table '
+                      f"as it is; register it with: codex-accounts mcp add")
+                continue
+            try:
+                learned = block if provider == "claude" else codex_to_claude(name, block)
+                validate_block(name, learned)
+            except RegistryError as exc:
+                _warn(f"not adopted: {exc}")
+                continue
+            where = f" (project {path})" if path else ""
+            if _carries_values(learned) and not target.replica:
+                local = local_overlay.setdefault("owners", {}).setdefault(
+                    "local", _normalize_section({}))
+                _upsert(local, name, learned, scope, path)
+                local_changed = True
+                where += " (this machine only: it carries env/header values)"
+            else:
+                _upsert(target.section, name, learned, scope, path)
+                synced_changed = True
+            if len(slot) > 1:
+                changes.append(f'"{name}"{where} (the definition {count} of '
+                               f'{sum(v[0] for v in slot.values())} accounts hold)')
+            else:
+                changes.append(f'"{name}"{where}')
+        if synced_changed:
+            target.save()
+        if local_changed:
+            save_overlay(root, local_overlay)
+    if changes:
+        _log(root, f"adopt {', '.join(changes)} into {target.where}")
+    return changes
+
+
 def apply_many(root, provider, account_dirs, quiet=False, fail_open=False):
-    """Reconcile each dir; returns the number of accounts that could not be."""
+    """Adopt what these accounts hold that no section names, then reconcile each dir;
+    returns the number of accounts that could not be."""
+    try:
+        # a launch must not wait long on a lock left by a killed holder: the next launch
+        # or the limits pass adopts instead
+        adopted = adopt(root, provider, account_dirs, lock_wait=2 if fail_open else 60)
+    except Exception as exc:  # noqa: BLE001 — adoption must never stop a reconcile
+        adopted = []
+        _warn(f"adopt: {type(exc).__name__}: {exc}")
+    if adopted and not quiet:
+        print(f"adopted {', '.join(adopted)}: every {provider} account gets "
+              f"{'it' if len(adopted) == 1 else 'them'}")
+    if adopted and len(account_dirs) < len(manifest_account_dirs(root)):
+        # One account told the registry something new: the others need it as well (the
+        # shims would bring it to each on its next launch; an idle one would wait).
+        # (a dir being seeded is not in the manifest yet: it stays in the list)
+        account_dirs = list(dict.fromkeys(list(account_dirs) + manifest_account_dirs(root)))
     failures = 0
     for account_dir in account_dirs:
         label = os.path.basename(account_dir.rstrip("/"))
@@ -1194,7 +1402,8 @@ def cmd_apply(args, leftovers):
     if args.all or not args.account_dir:
         rc = _apply_all(args, quiet=args.quiet)
         return 0 if args.fail_open else rc
-    failures = apply_many(args.root, args.provider, args.account_dir, quiet=args.quiet)
+    failures = apply_many(args.root, args.provider, args.account_dir, quiet=args.quiet,
+                          fail_open=args.fail_open)
     return 0 if args.fail_open or not failures else 1
 
 
@@ -1251,8 +1460,12 @@ def cmd_import_local(args):
         # it: an owner that stops shipping a server means it, and every account
         # would otherwise keep the stale copy for ever.
         dropped = [name for name in previous["mcpServers"] if name not in servers]
+        # ...and stays retired until it publishes the name again: an account still holding
+        # a copy must never have it adopted into the synced registry (adopt) once the next
+        # import has forgotten the drop.
+        kept = [name for name in previous["retired"] if name not in servers]
         section = _normalize_section({"mcpServers": servers,
-                                      "retired": sorted(set(retired) | set(dropped))})
+                                      "retired": sorted(set(retired) | set(dropped) | set(kept))})
         if previous == section and owner in overlay["owners"]:
             changed = False
         else:
@@ -1330,7 +1543,16 @@ def main(argv=None):
         from codex_python import require_python311
         require_python311(os.path.abspath(__file__))
     if args.mode == "apply" and not _registry_present(args.root):
-        return 0   # nothing registered: every account is already "reconciled"
+        # Nothing registered: every account is already "reconciled" — unless one holds a
+        # server to adopt (the first this pool ever had, added where the mirror never saw).
+        dirs = args.account_dir if args.account_dir and not args.all \
+            else manifest_account_dirs(args.root)
+        try:
+            if not adopt(args.root, args.provider, dirs, dry=True):
+                return 0
+        except Exception as exc:  # noqa: BLE001 — the old no-op, never a failure
+            _warn(f"adopt: {type(exc).__name__}: {exc}")
+            return 0
     if args.mode == "list":
         return cmd_list(args)
     if args.mode == "add":

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-multiacc",
-  "version": "2.0.59",
+  "version": "2.0.60",
   "description": "Unified Claude Code and OpenAI Codex subscription pooling with quota-aware selection.",
   "type": "module",
   "bin": {