claude-multiacc 2.0.31 → 2.0.33

package/lib/shim_path.py

@@ -0,0 +1,306 @@
+"""Does a FRESH shell resolve `claude` / `codex` to this addon's shims?
+
+The shims shadow the real binaries by PATH ORDER, and the rc-file block that puts them
+first is only as good as the shell startup that runs it. Three ways it silently is not:
+a ~/.profile with no block (every `bash -l` / `sh -l` on my-mini resolved the real
+binary, 2026-09-17), an rc file interrupted half-way (a Ctrl-C at a slow `conda` hook
+left ~/.local/bin in front, and the next `claude` at that prompt opened on the
+un-pooled ~/.claude login: "Not logged in · Please run /login"), or a later
+`export PATH=` that re-prepends ~/.local/bin. Nothing inside the shim can notice a
+launch that never reached it, so this is checked from the OUTSIDE: start each login
+shell the way a terminal or a `bash -lc` launcher would — clean environment, the user's
+own rc files — and ask what the command names resolve to.
+
+Interactive modes (`-li`) are fed the probe on stdin, so the shell runs its prompt loop
+and the rc block's prompt hook (lib/install_actions.sh path_guard_body) gets its turn,
+exactly as it does for a person at a prompt. The `-lc` modes are what a launcher that
+runs `bash -lc claude` gets: rc order alone, no prompt hook.
+
+What is measured is the PATH search — `whence -p` / `type -P`, aliases and functions set
+aside — because the incident was a PATH-order failure and an `alias claude='claude
+--flags'` still resolves through PATH. A function or alias that names the real binary
+outright is not detected here; it is also not something an installer can fix.
+
+Every answer line carries a sentinel, the first answer per name wins, and a name the
+shell never answered for is an ERROR on that row, not a bypass: an rc file that reads a
+line of stdin (an update prompt, a `read`) can eat part of the fed script. Nothing
+touches the operator's shell history — the script disables it first thing.
+
+probe(repo_dir) -> [ {shell, mode, argv, results: {name: {resolved, ok}}, error} ... ]
+    ok is True for the shim, False for anything else (the real binary, or nothing on
+    PATH at all), None when the shell could not answer (timeout / no output).
+bypassed(rows) -> the (mode, name, resolved) triples with ok False.
+
+Run directly:  python3 lib/shim_path.py <repo-dir> [--json] [--timeout=SECONDS]
+Prints the report; exit 1 when any mode bypasses the shim, 2 on usage, else 0.
+CLAUDE_MULTIACC_PATH_PROBE=0 makes probe() return [] (the sandboxed suites run with the
+operator's real HOME and must not depend on its rc files).
+"""
+from __future__ import annotations
+
+import getpass
+import json
+import os
+import shutil
+import signal
+import subprocess
+import sys
+import tempfile
+from concurrent.futures import ThreadPoolExecutor
+
+NAMES = ('claude', 'codex')
+# The marker every shim carries in its header; lib/common.sh is_shim_file greps the
+# same word, so a /usr/local/bin/claude -> shim symlink (Linux) counts as the shim too.
+SHIM_MARK = 'multiacc-shim'
+DEFAULT_TIMEOUT = 25
+# (shell, flags, interactive) — a terminal is a login AND interactive shell; a
+# `bash -lc` launcher is login only; sh has no interactive rc worth probing.
+MODES = (
+    ('zsh', '-li', True), ('zsh', '-lc', False),
+    ('bash', '-li', True), ('bash', '-lc', False),
+    ('sh', '-lc', False),
+)
+# What resolves a NAME to the executable a shell would run, per shell, bypassing
+# aliases and functions (an interactive zsh answers `command -v claude` with the
+# user's alias text, which says nothing about the file). POSIX sh has only `command -v`,
+# which reports an alias or a function by name, so the sh script drops those first.
+_RESOLVERS = {'zsh': 'whence -p', 'bash': 'type -P', 'sh': 'command -v'}
+SENTINEL = '__claude_multiacc_probe__'
+# The PATH a login shell STARTS from before any rc file runs — what sshd/login/launchd
+# hand it. /usr/local/bin matters on Linux: the root install's /usr/local/bin/claude
+# symlink is how a shell with no rc block still reaches the shim, so leaving it out
+# would call a working server login a bypass. macOS's path_helper rebuilds PATH from
+# /etc/paths anyway.
+_SEED_PATH = {'darwin': '/usr/bin:/bin:/usr/sbin:/sbin'}
+_SEED_PATH_DEFAULT = '/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin'
+
+
+def enabled():
+    return os.environ.get('CLAUDE_MULTIACC_PATH_PROBE', '').strip().lower() \
+        not in ('0', 'false', 'no', 'off')
+
+
+def shell_path(name):
+    """The shell binary a terminal would start, or None when it is not installed."""
+    found = shutil.which(name, path='/bin:/usr/bin:/usr/local/bin:/opt/homebrew/bin')
+    if found:
+        return found
+    candidate = os.path.join('/bin', name)
+    return candidate if os.access(candidate, os.X_OK) else None
+
+
+def _script(shell, names):
+    resolver = _RESOLVERS[shell]
+    # First thing, before any answer: no history. The interactive shells would otherwise
+    # save these lines into the operator's real ~/.zsh_history / ~/.bash_history on exit
+    # (macOS /etc/zshrc sets HISTFILE unconditionally, so an env var is not enough — this
+    # runs AFTER the rc files and wins). bash honours `unset HISTFILE`; zsh honours
+    # SAVEHIST=0. The stderr redirect swallows "no such option" from the other shell.
+    # `set +o history` is bash-only: zsh's `set` rejects the option, and a NON-interactive
+    # zsh exits on a special-builtin error — the whole `-lc` row would read as "exited
+    # without answering". zsh needs nothing beyond SAVEHIST=0.
+    lines = ['unset HISTFILE 2>/dev/null; HISTFILE=/dev/null; SAVEHIST=0; HISTSIZE=0; '
+             '[ -z "${BASH_VERSION:-}" ] || set +o history; true']
+    if shell == 'sh':
+        # `command -v` answers with alias text or a bare function name; the PATH search
+        # is the question, so those go first (the shell is a throwaway).
+        lines.append('unalias -a 2>/dev/null; unset -f ' + ' '.join(names) + ' 2>/dev/null; true')
+    lines += [f'printf \'%s %s=%s\\n\' {SENTINEL} {n} "$({resolver} {n} 2>/dev/null)"'
+              for n in names]
+    # The interactive shells read this on stdin; without the exit an rc file that
+    # left the shell in a state where EOF is ignored (IGNOREEOF) would hang to timeout.
+    lines.append('exit 0')
+    return '\n'.join(lines) + '\n'
+
+
+def _env(home, user, shell):
+    # A TERM a terminal would set: rc files commonly bail out early on TERM=dumb (the
+    # Emacs TRAMP guard), which would judge a branch no person at a prompt ever sees.
+    return {'HOME': home, 'USER': user, 'LOGNAME': user, 'SHELL': shell,
+            'TERM': 'xterm-256color',
+            'PATH': _SEED_PATH.get(sys.platform, _SEED_PATH_DEFAULT),
+            'LANG': os.environ.get('LANG', 'C.UTF-8'),
+            'CLAUDE_MULTIACC_PATH_PROBE': '1'}
+
+
+def is_shim(path, repo_dir, name):
+    if not path:
+        return False
+    try:
+        if os.path.realpath(path) == os.path.realpath(os.path.join(repo_dir, 'bin', name)):
+            return True
+        with open(path, 'rb') as f:
+            return SHIM_MARK.encode() in f.read(300)
+    except OSError:
+        return False
+
+
+def _parse(text, names):
+    """First sentinel answer per name. Anything else the shell printed is ignored."""
+    answers = {}
+    for line in text.splitlines():
+        if not line.startswith(SENTINEL + ' '):
+            continue
+        body = line[len(SENTINEL) + 1:]
+        name, _sep, value = body.partition('=')
+        if name in names and name not in answers:
+            answers[name] = value.strip()
+    return answers
+
+
+def _run_mode(shell, flags, interactive, names, repo_dir, home, user, timeout):
+    exe = shell_path(shell)
+    mode = f'{shell} {flags}'
+    row = {'shell': shell, 'mode': mode, 'interactive': interactive, 'argv': None,
+           'results': {}, 'error': None}
+    if not exe:
+        row['error'] = 'shell not installed'
+        return row
+    script = _script(shell, names)
+    argv = [exe, flags] if interactive else [exe, flags, script]
+    row['argv'] = argv
+    try:
+        text, timed_out, returncode = _run_shell(argv, script if interactive else '',
+                                                 _env(home, user, exe), home, timeout)
+    except Exception as e:  # noqa: BLE001 — one mode must never take down the report
+        row['error'] = f'probe could not run: {e!r}'[:200]
+        return row
+    answers = _parse(text, names)
+    missing = [n for n in names if n not in answers]
+    if timed_out and missing:
+        row['error'] = f'no answer within {timeout}s (an rc file is hanging or prompting)'
+        return row
+    if not answers:
+        row['error'] = (f'shell exited {returncode} without answering '
+                        '(an rc file exec\'d something, exited early, or read the probe)')
+        return row
+    for n in names:
+        if n in answers:
+            resolved = answers[n] or None
+            row['results'][n] = {'resolved': resolved, 'ok': is_shim(resolved, repo_dir, n)}
+        else:
+            row['results'][n] = {'resolved': None, 'ok': None}
+    if missing:
+        row['error'] = (f'no answer for {", ".join(missing)} — an rc file consumed part of '
+                        'the probe (a prompt or `read` on stdin?)')
+    return row
+
+
+def _run_shell(argv, stdin_text, env, cwd, timeout):
+    """(stdout text, timed_out, returncode). stdout goes to a temp FILE, not a pipe:
+    a pipe only closes when every process holding it is gone, so an rc line that
+    backgrounds something (`ssh-agent`, `tmux new -d`, `cmd &`) would keep a pipe open
+    long after the shell answered and exited, and the whole answer would be lost to
+    the timeout. The shell gets its own session so a timeout can kill everything it
+    started. Whatever was written before a timeout is still returned."""
+    with tempfile.TemporaryFile() as out:
+        p = subprocess.Popen(argv, stdin=subprocess.PIPE, stdout=out, stderr=subprocess.DEVNULL,
+                             env=env, cwd=cwd if os.path.isdir(cwd) else None,
+                             start_new_session=True)
+        timed_out = False
+        try:
+            p.communicate(stdin_text.encode('utf-8'), timeout=timeout)
+        except subprocess.TimeoutExpired:
+            timed_out = True
+            try:
+                os.killpg(p.pid, signal.SIGKILL)
+            except OSError:
+                pass
+            try:
+                p.wait(timeout=5)
+            except subprocess.TimeoutExpired:
+                pass
+        out.seek(0)
+        text = out.read().decode('utf-8', errors='replace')
+    return text, timed_out, p.returncode
+
+
+def probe(repo_dir, home=None, user=None, names=NAMES, timeout=DEFAULT_TIMEOUT, modes=MODES):
+    if not enabled():
+        return []
+    home = home or os.path.expanduser('~')
+    try:
+        user = user or getpass.getuser()
+    except Exception:  # noqa: BLE001 — no passwd entry; the name only seeds $USER
+        user = os.environ.get('USER') or 'user'
+    with ThreadPoolExecutor(max_workers=len(modes)) as pool:
+        return list(pool.map(
+            lambda m: _run_mode(m[0], m[1], m[2], names, repo_dir, home, user, timeout), modes))
+
+
+def bypassed(rows):
+    out = []
+    for row in rows:
+        for name, r in row['results'].items():
+            if r['ok'] is False:
+                out.append((row['mode'], name, r['resolved']))
+    return out
+
+
+def render(rows):
+    """Operator-facing lines. The verdict line is the one that matters; the per-mode
+    lines say WHICH shell to open to reproduce it."""
+    lines = ['shim on PATH (fresh login shells, this user\'s rc files):']
+    if not rows:
+        lines.append('  (probe disabled: CLAUDE_MULTIACC_PATH_PROBE=0)')
+        return lines
+    for row in rows:
+        cell = f'  {row["mode"]:<8}'
+        if row['error']:
+            lines.append(f'{cell} ?  {row["error"]}')
+            continue
+        parts = []
+        for name, r in row['results'].items():
+            if r['ok'] is None:
+                parts.append(f'{name}: ?')
+            elif r['ok']:
+                parts.append(f'{name}: OK')
+            elif r['resolved']:
+                parts.append(f'{name}: BYPASSED -> {r["resolved"]}')
+            else:
+                parts.append(f'{name}: NOT ON PATH')
+        lines.append(f'{cell} {"   ".join(parts)}' + (f'   ({row["error"]})' if row['error'] else ''))
+    bad = bypassed(rows)
+    if bad:
+        modes = sorted({m for m, _n, _r in bad})
+        lines.append(f'  ** {len(modes)} shell mode(s) start `claude`/`codex` OUTSIDE the pool '
+                     f'({", ".join(modes)}): such a session runs the real binary on the '
+                     'machine\'s own ~/.claude login — or on no login at all ("Not logged '
+                     'in · Please run /login"). **')
+        lines.append('     fix: claude-multiacc install   # rewrites the rc blocks (~/.zshenv, '
+                     '~/.zprofile, ~/.zshrc, ~/.profile, bash rc files) with the prompt hook')
+        lines.append('     then open a new shell (or run: exec "$SHELL" -l) — an already-open '
+                     'shell keeps the PATH it has')
+    unanswered = [row['mode'] for row in rows
+                  if row['error'] and row['error'] != 'shell not installed' and not row['results']]
+    if unanswered:
+        lines.append(f'  note: {", ".join(unanswered)} could not be probed — open one by hand '
+                     'and run: command -v claude')
+    return lines
+
+
+def main(argv):
+    args = [a for a in argv[1:] if not a.startswith('--')]
+    flags = [a for a in argv[1:] if a.startswith('--')]
+    if len(args) != 1 or any(f not in ('--json',) and not f.startswith('--timeout=') for f in flags):
+        print('usage: shim_path.py <repo-dir> [--json] [--timeout=SECONDS]', file=sys.stderr)
+        return 2
+    timeout = DEFAULT_TIMEOUT
+    for f in flags:
+        if f.startswith('--timeout='):
+            try:
+                timeout = max(1, int(f.split('=', 1)[1]))
+            except ValueError:
+                print('usage: --timeout takes an integer number of seconds', file=sys.stderr)
+                return 2
+    rows = probe(args[0], timeout=timeout)
+    if '--json' in flags:
+        print(json.dumps({'repo_dir': args[0], 'enabled': enabled(), 'modes': rows,
+                          'bypassed': [list(b) for b in bypassed(rows)]}, indent=2))
+    else:
+        print('\n'.join(render(rows)))
+    return 1 if bypassed(rows) else 0
+
+
+if __name__ == '__main__':
+    sys.exit(main(sys.argv))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-multiacc",
-  "version": "2.0.31",
+  "version": "2.0.33",
   "description": "Unified Claude Code and OpenAI Codex subscription pooling with quota-aware selection.",
   "type": "module",
   "bin": {
@@ -56,7 +56,7 @@
   "scripts": {
     "postinstall": "node scripts/postinstall.mjs",
     "test": "npm run test:core && npm run test:seeding && npm run test:commands",
-    "test:core": "bash tests/run-tests.sh && python3 tests/test_selector.py",
+    "test:core": "bash tests/run-tests.sh && python3 tests/test_selector.py && python3 tests/test_shim_path.py",
     "test:seeding": "python3 tests/test_account_seeding.py && npm run test:codex-settings",
     "test:codex-settings": "python3 tests/test_codex_config_edit.py && python3 tests/test_codex_settings.py",
     "test:commands": "python3 tests/test_packaged_commands.py"

package/tests/run-tests.sh

@@ -292,6 +292,10 @@ export CLAUDE_MULTIACC_USAGE_URL="file://$WORK/usage-endpoint-missing.json"
 # extra `security` process per account would only slow them down); section 17 turns
 # them on explicitly against the fake `security` above.
 export CLAUDE_MULTIACC_KEYCHAIN=0
+# `status` probes fresh login shells with $HOME's rc files (lib/shim_path.py). This suite
+# runs under the operator's real HOME, whose rc files are not under test — section 18
+# turns the probe on against its own fake HOME.
+export CLAUDE_MULTIACC_PATH_PROBE=0
 
 now="$(date +%s)"
 
@@ -6897,6 +6901,116 @@ grep -q '"acct-04"' "$KCP/accounts.json" \
 export CLAUDE_MULTIACC_KEYCHAIN=0
 unset FAKE_KEYCHAIN_DIR
 
+# ---- 18. the rc block shadows `claude` even when the rc file that carries it is cut short ----
+# 2026-09-17: a Ctrl-C at the slow conda hook in ~/.zshrc stopped the file before the
+# multiacc block, ~/.local/bin stayed in front, and the next `claude` at that prompt ran
+# the real binary on ~/.claude — "Not logged in · Please run /login". Every `bash -l` and
+# `sh -l` on that Mac bypassed the shim too: ~/.profile (read when there is no
+# ~/.bash_profile) carried no block at all. The block now ends with a prompt hook that
+# re-asserts the shim dir before every prompt, the installer appends to ~/.profile, and
+# `status` probes fresh login shells so a bypass is reported instead of guessed at.
+RCH="$WORK/rc-home"
+mkdir -p "$RCH/.local/bin"
+printf '#!/bin/sh\necho REAL\n' > "$RCH/.local/bin/claude"
+cp "$RCH/.local/bin/claude" "$RCH/.local/bin/codex"
+chmod +x "$RCH/.local/bin/claude" "$RCH/.local/bin/codex"
+rc_block_text() { # the block the installer writes, for THIS repo
+  REPO_DIR="$REPO_DIR" MARK_BEGIN='# >>> claude-multiacc >>>' MARK_END='# <<< claude-multiacc <<<' \
+    bash -c '. "$REPO_DIR/lib/install_actions.sh"; rc_block'
+}
+rc_block_text > "$WORK/rc-block.sh"
+for rsh in sh bash zsh; do
+  command -v "$rsh" >/dev/null 2>&1 || continue
+  if "$rsh" -n "$WORK/rc-block.sh" 2>/dev/null; then t_ok "rc block parses under $rsh"
+  else t_fail "rc block parses under $rsh" "$("$rsh" -n "$WORK/rc-block.sh" 2>&1 | head -2)"; fi
+done
+grep -q '_claude_multiacc_path_guard' "$WORK/rc-block.sh" \
+  && t_ok "rc block carries the prompt hook" || t_fail "rc block carries the prompt hook"
+# bash: the PROMPT_COMMAND hook undoes a later re-prepend, and registers itself once
+out="$(HOME="$RCH" bash -c '. "$1"; . "$1"; PATH="$HOME/.local/bin:$PATH"; eval "$PROMPT_COMMAND"; printf "%s|%s" "${PATH%%:*}" "$PROMPT_COMMAND"' _ "$WORK/rc-block.sh" 2>&1)"
+[ "$out" = "$REPO_DIR/bin|_claude_multiacc_path_guard" ] \
+  && t_ok "bash prompt hook re-asserts the shim dir (registered once)" \
+  || t_fail "bash prompt hook re-asserts the shim dir" "got: $out"
+if command -v zsh >/dev/null 2>&1; then
+  out="$(HOME="$RCH" zsh -c '. "$1"; . "$1"; PATH="$HOME/.local/bin:$PATH"; _claude_multiacc_path_guard; print -r -- "${PATH%%:*}|${(j:,:)precmd_functions}"' _ "$WORK/rc-block.sh" 2>&1)"
+  [ "$out" = "$REPO_DIR/bin|_claude_multiacc_path_guard" ] \
+    && t_ok "zsh precmd hook re-asserts the shim dir (registered once)" \
+    || t_fail "zsh precmd hook re-asserts the shim dir" "got: $out"
+fi
+# ORDER: a hook registered before ours that rewrites PATH (direnv, a venv) must not have
+# the final word — bash appends after it, zsh moves itself behind hooks ~/.zshrc added.
+out="$(HOME="$RCH" bash -c 'PROMPT_COMMAND="other_hook"; . "$1"; printf %s "$PROMPT_COMMAND"' _ "$WORK/rc-block.sh" 2>&1)"
+[ "$out" = "other_hook;_claude_multiacc_path_guard" ] \
+  && t_ok "bash hook is appended after an existing PROMPT_COMMAND" \
+  || t_fail "bash hook is appended after an existing PROMPT_COMMAND" "got: $out"
+if command -v zsh >/dev/null 2>&1; then
+  out="$(HOME="$RCH" zsh -c '. "$1"; precmd_functions+=(later_hook); . "$1"; print -r -- "${(j:,:)precmd_functions}"' _ "$WORK/rc-block.sh" 2>&1)"
+  [ "$out" = "later_hook,_claude_multiacc_path_guard" ] \
+    && t_ok "zsh hook re-registers itself LAST when the block is sourced again" \
+    || t_fail "zsh hook re-registers itself LAST" "got: $out"
+  out="$(HOME="$RCH" zsh -c 'IFS=":"; . "$1"; . "$1"; print -r -- "${(j:,:)precmd_functions}"' _ "$WORK/rc-block.sh" 2>&1)"
+  [ "$out" = "_claude_multiacc_path_guard" ] \
+    && t_ok "zsh hook registers once whatever IFS is" \
+    || t_fail "zsh hook registers once whatever IFS is" "got: $out"
+fi
+# the hook is inert once the shim dir is gone: no error, PATH left alone
+out="$(HOME="$RCH" bash -c 'sed "s|'"$REPO_DIR"'|/nonexistent/multiacc|g" "$1" > "$1.gone"; . "$1.gone"; PATH="$HOME/.local/bin:$PATH"; _claude_multiacc_path_guard; printf "rc=%s %s" "$?" "${PATH%%:*}"' _ "$WORK/rc-block.sh" 2>&1)"
+[ "$out" = "rc=0 $RCH/.local/bin" ] \
+  && t_ok "prompt hook is inert when the shim dir is gone" \
+  || t_fail "prompt hook is inert when the shim dir is gone" "got: $out"
+# ~/.profile: CREATED when absent (a stock Mac has none — without it every bash/sh login
+# shell stays bypassed and the probe would fail health with a remedy that does nothing),
+# appended to exactly once when present, and ~/.bash_profile is never created.
+rm -f "$RCH/.profile"
+HOME="$RCH" REPO_DIR="$REPO_DIR" MARK_BEGIN='# >>> claude-multiacc >>>' MARK_END='# <<< claude-multiacc <<<' \
+  bash -c '. "$REPO_DIR/lib/install_actions.sh"; install_profile_block' >/dev/null
+[ -f "$RCH/.profile" ] && [ "$(grep -c '# >>> claude-multiacc >>>' "$RCH/.profile")" = "1" ] \
+  && t_ok "~/.profile is created with the block when absent" \
+  || t_fail "~/.profile is created with the block when absent"
+printf 'export PATH="$HOME/.local/bin:$PATH"\n' > "$RCH/.profile"
+for _ in 1 2; do
+  HOME="$RCH" REPO_DIR="$REPO_DIR" MARK_BEGIN='# >>> claude-multiacc >>>' MARK_END='# <<< claude-multiacc <<<' \
+    bash -c '. "$REPO_DIR/lib/install_actions.sh"; install_profile_block' >/dev/null
+done
+[ "$(grep -c '# >>> claude-multiacc >>>' "$RCH/.profile")" = "1" ] \
+  && t_ok "~/.profile gets the block exactly once" || t_fail "~/.profile gets the block exactly once"
+[ ! -e "$RCH/.bash_profile" ] && t_ok "installer never creates ~/.bash_profile" \
+  || t_fail "installer never creates ~/.bash_profile" "it exists"
+for lsh in sh bash; do
+  out="$(env -i HOME="$RCH" USER="${USER:-tester}" TERM=dumb PATH=/usr/bin:/bin "$lsh" -lc 'command -v claude' 2>/dev/null)"
+  [ "$out" = "$REPO_DIR/bin/claude" ] && t_ok "$lsh -l resolves the shim through ~/.profile" \
+    || t_fail "$lsh -l resolves the shim through ~/.profile" "got: $out"
+done
+# the interrupted-rc incident, end to end, through the probe `status` prints
+if command -v zsh >/dev/null 2>&1; then
+  cp "$WORK/rc-block.sh" "$RCH/.zshenv"
+  { printf 'export PATH="$HOME/.local/bin:$PATH"\n'; cat "$WORK/rc-block.sh"; } > "$RCH/.zprofile"
+  printf 'export PATH="$HOME/.local/bin:$PATH"\nreturn 0  # the rest of this rc file was never reached\n' > "$RCH/.zshrc"
+  cat "$WORK/rc-block.sh" >> "$RCH/.zshrc"
+  out="$(HOME="$RCH" CLAUDE_MULTIACC_PATH_PROBE=1 python3 "$REPO_DIR/lib/shim_path.py" "$REPO_DIR" 2>&1)"; rc=$?
+  [ "$rc" = 0 ] && case "$out" in *"zsh -li"*"claude: OK"*) t_ok "interrupted ~/.zshrc: the prompt hook still hands claude to the shim" ;; *) t_fail "interrupted ~/.zshrc probe" "$out" ;; esac
+  [ "$rc" = 0 ] || t_fail "interrupted ~/.zshrc probe exit" "rc=$rc: $out"
+  # the same rc files with the OLD two-line block (no hook) are the incident itself
+  for f in .zshenv .zprofile .zshrc; do
+    awk '/^_claude_multiacc_path_guard\(\)/{skip=1} /^# <<< claude-multiacc <<</{skip=0} !skip' "$RCH/$f" > "$RCH/$f.old" && mv "$RCH/$f.old" "$RCH/$f"
+  done
+  out="$(HOME="$RCH" CLAUDE_MULTIACC_PATH_PROBE=1 python3 "$REPO_DIR/lib/shim_path.py" "$REPO_DIR" 2>&1)"; rc=$?
+  case "$rc:$out" in 1:*"zsh -li"*"BYPASSED -> $RCH/.local/bin/claude"*) t_ok "the probe catches the pre-fix block (zsh -li bypassed)" ;;
+    *) t_fail "the probe catches the pre-fix block" "rc=$rc: $out" ;; esac
+  out="$(HOME="$RCH" CLAUDE_MULTIACC_PATH_PROBE=1 claude-accounts status 2>&1)"
+  check "status reports the bypass" "BYPASSED -> $RCH/.local/bin/claude" "$out"
+  check "status names the fix" "claude-multiacc install" "$out"
+  # restore the hook: status is clean again
+  cp "$WORK/rc-block.sh" "$RCH/.zshenv"
+  { printf 'export PATH="$HOME/.local/bin:$PATH"\n'; cat "$WORK/rc-block.sh"; } > "$RCH/.zprofile"
+  out="$(HOME="$RCH" CLAUDE_MULTIACC_PATH_PROBE=1 claude-accounts status 2>&1)"
+  case "$out" in *BYPASSED*|*"NOT ON PATH"*) t_fail "status is clean with the hooked block" "$out" ;;
+    *"shim on PATH"*) t_ok "status is clean with the hooked block" ;;
+    *) t_fail "status prints the shim probe" "$out" ;; esac
+fi
+out="$(HOME="$RCH" claude-accounts status 2>&1)"
+check "status honours CLAUDE_MULTIACC_PATH_PROBE=0" "probe disabled" "$out"
+
 # The reset-credit contract is easier to prove against a stateful local HTTP server
 # than file:// fixtures: it pins thresholding, credit ordering and idempotent POST retry.
 if CODEX_MULTIACC_AUTO_RESET=1 python3 -m unittest discover -s "$REPO_DIR/tests" -p 'test_codex_reset*.py'; then

package/tests/test_codex_config_edit.py

@@ -33,14 +33,30 @@ class CodexConfigEditTests(unittest.TestCase):
                 self.assertEqual(tomllib.loads(updated)["agents"][KEY], 8)
                 self.assertEqual(updated_config(updated, 8), updated)
 
-    def test_conflicting_feature_and_profile_overrides_are_rejected(self):
-        for source in ('[features.multi_agent_v2]\nmax_concurrent_threads_per_session = 20\n',
+    def test_conflicting_profile_overrides_are_rejected(self):
+        for source in ('[profiles.quick.features.multi_agent_v2]\nmax_concurrent_threads_per_session = 20\n',
                        '[profiles.quick.agents]\nmax_threads = 20\n'):
             with self.subTest(source=source), self.assertRaisesRegex(ValueError, "overrides"):
                 updated_config(source, 8)
         source = '[features.multi_agent_v2]\nmax_concurrent_threads_per_session = 8\n'
         self.assertEqual(tomllib.loads(updated_config(source, 8))["agents"][KEY], 8)
 
+    def test_existing_eight_thread_policies_and_feature_overrides_change_to_seven(self):
+        for feature in ('[features]\nmulti_agent_v2 = true\n',
+                        '[features]\nmulti_agent_v2 = false\n',
+                        '[features.multi_agent_v2]\nenabled = true\nmax_concurrent_threads_per_session = 20\n',
+                        'features.multi_agent_v2.max_concurrent_threads_per_session = 8\n',
+                        '[features]\nmulti_agent_v2.max_concurrent_threads_per_session = 8\n'):
+            source = feature + '[agents]\nmax_concurrent_threads_per_session = 8\n'
+            with self.subTest(feature=feature):
+                updated = updated_config(source, 7)
+                document = tomllib.loads(updated)
+                self.assertEqual(document["agents"][KEY], 7)
+                self.assertEqual(document["features"]["multi_agent_v2"][KEY], 7)
+                if 'false' in feature:
+                    self.assertFalse(document["features"]["multi_agent_v2"]["enabled"])
+                self.assertEqual(updated_config(updated, 7), updated)
+
     def test_unsupported_layouts_and_string_lookalikes_fail_safely(self):
         for source in ('agents = { max_threads = 4 }\n',
                        'instructions = """\n[agents]\nmax_threads = 99\n"""\n'):

package/tests/test_codex_settings.py

@@ -79,13 +79,31 @@ class CodexSettingsTests(unittest.TestCase):
 
     def test_invalid_config_is_rejected_before_any_configuration_is_changed(self):
         before = self.account.read_text()
-        self.global_config.write_text('[features.multi_agent_v2]\nmax_concurrent_threads_per_session = 20\n')
+        self.global_config.write_text('[profiles.quick.features.multi_agent_v2]\n'
+                                      'max_concurrent_threads_per_session = 20\n')
         result = self.command("configure", "--max-subagents", "8", "--include-global", "--json")
         self.assertNotEqual(result.returncode, 0)
         self.assertIn("overrides", result.stderr)
         self.assertEqual(self.account.read_text(), before)
         self.assertFalse((self.pool / "codex-settings-policy.json").exists())
 
+    def test_seven_thread_policy_requires_v2_setting_and_repairs_legacy_only_configs(self):
+        result = self.command("configure", "--max-subagents", "8", "--include-global", "--json")
+        self.assertEqual(result.returncode, 0, result.stderr)
+        result = self.command("configure", "--max-subagents", "7", "--include-global", "--json")
+        self.assertEqual(result.returncode, 0, result.stderr)
+        for path in (self.account, self.global_config):
+            config = tomllib.loads(path.read_text())
+            self.assertEqual(config["features"]["multi_agent_v2"][KEY], 7)
+            self.assertEqual(config["agents"][KEY], 7)
+        self.account.write_text('[agents]\nmax_concurrent_threads_per_session = 7\n')
+        result = self.command("configure", "--include-global", "--check", "--json")
+        self.assertEqual(result.returncode, 1, result.stderr)
+        self.assertEqual(json.loads(result.stdout)["mismatch_count"], 1)
+        result = self.command("configure", "--max-subagents", "7", "--include-global", "--json")
+        self.assertEqual(result.returncode, 0, result.stderr)
+        self.assertTrue(json.loads(result.stdout)["verified"])
+
     def test_symlinked_global_config_remains_linked(self):
         self.account.unlink()
         self.account.symlink_to(self.global_config)

package/tests/test_packaged_commands.py

@@ -6,6 +6,7 @@ import plistlib
 import re
 import shlex
 import shutil
+import sys
 import unittest
 
 from packaged_command_support import ROOT, install_package, run, seed_pools
@@ -117,13 +118,46 @@ class PackagedCommandsTests(unittest.TestCase):
         identity.write_text('#!/usr/bin/env bash\necho 0\n')
         uname.chmod(0o755)
         identity.chmod(0o755)
+        # bash/sh login shells read ~/.profile when ~/.bash_profile is absent, and a
+        # ~/.bashrc exists on most machines: both must end with the block, ~/.bash_profile
+        # must NOT be created (its existence would stop bash reading ~/.profile).
+        prepend = 'export PATH="$HOME/.local/bin:$PATH"\n'
+        for rc in (".profile", ".bashrc"):
+            (self.home / rc).write_text(prepend)
+        real_bin = self.home / ".local/bin"
+        real_bin.mkdir(parents=True)
+        for name in ("claude", "codex"):
+            (real_bin / name).write_text('#!/bin/sh\necho REAL\n')
+            (real_bin / name).chmod(0o755)
         try:
             for _ in range(2):
                 result = run(["claude-multiacc", "install", "--no-server", "--no-schedule"], self.env, self.work)
                 self.assertEqual(result.returncode, 0, result.stderr)
                 self.assertNotIn("status |", result.stdout)
-            for rc in (".zshenv", ".zprofile", ".zshrc"):
-                self.assertEqual((self.home / rc).read_text().count("# >>> claude-multiacc >>>"), 1)
+            for rc in (".zshenv", ".zprofile", ".zshrc", ".profile", ".bashrc"):
+                text = (self.home / rc).read_text()
+                self.assertEqual(text.count("# >>> claude-multiacc >>>"), 1, rc)
+                self.assertEqual(text.count("_claude_multiacc_path_guard() {"), 1, rc)
+                self.assertTrue(text.rstrip().endswith("# <<< claude-multiacc <<<"), rc)
+            self.assertFalse((self.home / ".bash_profile").exists())
+            # ...and fresh login shells of every flavour now resolve the package's shims,
+            # the real binaries in ~/.local/bin notwithstanding (lib/shim_path.py is the
+            # same probe `claude-accounts status` and `health` print).
+            probe_env = {**self.env, "CLAUDE_MULTIACC_PATH_PROBE": "1", "USER": "tester"}
+            result = run([sys.executable, str(self.package / "lib/shim_path.py"), str(self.package), "--json"],
+                         probe_env, self.work)
+            self.assertEqual(result.returncode, 0, result.stdout + result.stderr)
+            report = json.loads(result.stdout)
+            self.assertEqual(report["bypassed"], [])
+            answered = [m for m in report["modes"] if m["error"] != "shell not installed"]
+            self.assertGreaterEqual(len(answered), 2)
+            for mode in answered:
+                self.assertIsNone(mode["error"], mode)
+                for name in ("claude", "codex"):
+                    self.assertTrue(mode["results"][name]["ok"], mode)
+            status = run(["claude-accounts", "status"], probe_env, self.work)
+            self.assertIn("shim on PATH", status.stdout)
+            self.assertNotIn("BYPASSED", status.stdout)
             calls = (self.home / "tool-calls").read_text()
             self.assertNotRegex(calls, r"/(launchctl|crontab|ln) ")
             script = 'source "$0" --no-server --no-schedule; mac_schedule_install'
@@ -137,7 +171,9 @@ class PackagedCommandsTests(unittest.TestCase):
                 self.assertTrue(Path(job["ProgramArguments"][0]).is_file())
             result = run(["claude-multiacc", "uninstall"], self.env, self.work)
             self.assertEqual(result.returncode, 0, result.stderr)
-            self.assertNotIn("claude-multiacc", (self.home / ".zshrc").read_text())
+            for rc in (".zshenv", ".zprofile", ".zshrc", ".profile", ".bashrc"):
+                self.assertNotIn("claude-multiacc", (self.home / rc).read_text(), rc)
+            self.assertEqual((self.home / ".profile").read_text(), prepend)
             self.assertTrue((self.home / ".codex-accounts/accounts.json").exists())
             uname.write_text('#!/usr/bin/env bash\necho Linux\n')
             (self.home / "tool-calls").write_text("")