@bordoni/claudep 0.3.0 → 0.4.1

package/CHANGELOG.md

@@ -6,6 +6,31 @@ The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and
 
 ## [Unreleased]
 
+## [0.4.1] - 2026-10-01
+
+### Added
+
+- `claudep doctor` warns when your Claude Code asks for approval on every auto-memory write in a profile. Since 2.1.280 a write through the shared `projects/` symlink is judged at `~/.claude/projects`, which auto mode cannot approve ([anthropics/claude-code#98044](https://github.com/anthropics/claude-code/issues/98044)). The README explains it.
+
+### Changed
+
+- Caught up with Claude Code 2.1.280, whose list of per-instance files grew. `state/`, `policy-limits.json.stamp.json`, the `.signature.json` files next to `policy-limits.json` and `remote-settings.json`, `daemon.lock`, `shares/`, `storage-v2/` and about twenty-five caches and locks are known-private, so `doctor` stops calling them unclassified.
+
+### Fixed
+
+- `loop.md`, which Claude Code keeps per instance, is no longer shared by the rule that links every top-level `*.md`. `claudep doctor` names any `loop.md` symlink an older claudep left in a profile and tells you to remove it.
+- `claudep doctor` on Linux and Windows no longer calls a profile "not logged in yet" when it has no `.credentials.json` but Claude Code reports it logged in. Claude Code can keep the login elsewhere, such as Windows Credential Manager behind a feature flag.
+
+## [0.4.0] - 2026-09-14
+
+### Added
+
+- `claudep completion zsh|bash|fish` prints tab completions for every subcommand, its flags, the values `--shell`, `shell-init` and `completion` take, and your profile names. Load it with `eval "$(claudep completion zsh)"` after `compinit`, `eval "$(claudep completion bash)"`, or `claudep completion fish | source`. Profile names are read from `~/.claudep` when you press Tab, so the script never runs claudep.
+
+### Changed
+
+- **Breaking:** `completion` is now a reserved word. A profile named `completion` stops resolving; recreate it under another name. Reserved words, flag parsing and the completion scripts now come from one command table, so they cannot drift apart.
+
 ## [0.3.0] - 2026-09-10
 
 ### Added
@@ -76,7 +101,9 @@ The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and
 - Keychain isolation per config dir verified against Claude Code 2.1.259: the service name is `Claude Code-credentials-<sha256(dir)[0:8]>`.
 - Test suite with `bun test`, a sandboxed `$HOME`, a fake `claude` and `security` on PATH, and a real-shell test for the hook. CI runs typecheck, lint and tests on macOS and Linux.
 
-[Unreleased]: https://github.com/bordoni/claudep/compare/0.3.0...HEAD
+[Unreleased]: https://github.com/bordoni/claudep/compare/0.4.1...HEAD
+[0.4.1]: https://github.com/bordoni/claudep/compare/0.4.0...0.4.1
+[0.4.0]: https://github.com/bordoni/claudep/compare/0.3.0...0.4.0
 [0.3.0]: https://github.com/bordoni/claudep/compare/0.2.1...0.3.0
 [0.2.1]: https://github.com/bordoni/claudep/compare/0.2.0...0.2.1
 [0.2.0]: https://github.com/bordoni/claudep/compare/0.1.1...0.2.0

package/README.md

@@ -64,6 +64,7 @@ claudep rm <name> [--keep-login]     log out and delete a profile (base is never
 claudep local <name> | --remove      pin the current directory tree to a profile (see below)
 claudep resolve [dir]                print the profile pinned for a directory
 claudep shell-init [zsh|bash|fish|powershell]   print the hook that applies pins on cd
+claudep completion [zsh|bash|fish]   print tab completions for commands, flags and profile names
 claudep --version
 ```
 
@@ -104,6 +105,21 @@ From then on, `cd` into a pinned tree sets `CLAUDE_CONFIG_DIR` for that profile
 
 `claudep current` tells you which profile the shell is on and how it got there (hook, manual pin, or nothing). `claudep list` adds the same line at the bottom.
 
+## Tab completion
+
+One line in your rc file completes subcommands, their flags, the values `--shell` and `shell-init` take, and your profile names:
+
+```sh
+eval "$(claudep completion zsh)"      # ~/.zshrc, after compinit
+eval "$(claudep completion bash)"     # ~/.bashrc
+```
+
+```fish
+claudep completion fish | source      # ~/.config/fish/config.fish
+```
+
+Profile names come from a directory listing of `~/.claudep` at the moment you press Tab, so the script never runs claudep and a new profile shows up without reloading anything. In zsh the same output also works as a file: `claudep completion zsh > ~/.zfunc/_claudep` with `~/.zfunc` on `fpath` before `compinit`, if you prefer autoloading over `eval`.
+
 ## Show the profile in your prompt or statusline
 
 In a shell prompt use the variable itself; no command runs:
@@ -139,7 +155,11 @@ The shared list is an allowlist, so an account-specific file cannot leak across
 
 - The first time you open a repository under a new profile you will re-accept folder trust, and claude.ai connectors need their OAuth redone in that profile.
 - Two profiles running at the same time write the same `settings.json` and `plugins/`. That is the same situation as two terminals today.
-- Background sessions and the daemon are tied to `~/.claude`. As of Claude Code 2.1.263, `claude daemon install` refuses to run with `CLAUDE_CONFIG_DIR` set, and `claude --bg` under a profile runs without the daemon.
+- Background sessions and the daemon are tied to `~/.claude`. As of Claude Code 2.1.280, `claude daemon install` refuses to run with `CLAUDE_CONFIG_DIR` set, and the launcher skips the daemon for `claude --bg` under a profile. Anthropic's docs describe a separate background supervisor per config dir; I have not verified that here.
+- Since Claude Code 2.1.280, every auto-memory write in a profile asks for approval, and auto mode cannot give it. The memory directory sits under the shared `projects/` symlink, and Claude Code now checks a write at the path it lands on, `~/.claude/projects/...`, which it treats as sensitive. This is [anthropics/claude-code#98044](https://github.com/anthropics/claude-code/issues/98044), open upstream. `claudep doctor` warns while your Claude Code is affected. The default profile is not.
+- Skills and plugins synced from claude.ai land in the shared `skills/synced/` and `plugins/synced/`, in one folder per account, so profiles do not mix them. The `syncClaudeAiSkills` and `syncClaudeAiPlugins` switches live in the shared `settings.json` and apply to every profile.
+- Console sign-ins made without an API key live in `~/.config/anthropic`, outside every config dir, so all profiles see the same ones. `ANTHROPIC_PROFILE` picks which one Claude Code uses.
+- In VS Code, `CLAUDE_CONFIG_DIR` in `claudeCode.environmentVariables` must be an absolute path. The session list ignores it when `claudeProcessWrapper` is set.
 - Set `CLAUDE_PROFILES_DIR` to move the profiles root. Keep it out of iCloud or Dropbox; `.claude.json` is rewritten constantly and sync tools create conflict copies.
 - Never put `CLAUDE_CONFIG_DIR` in a `settings.json` `env` block. Claude Code detects that mismatch and disables features; `claudep doctor` reports it.
 - `ANTHROPIC_API_KEY`, `ANTHROPIC_AUTH_TOKEN` and `CLAUDE_CODE_OAUTH_TOKEN` override the login in any config dir, always in `-p` mode. `claudep <name>` and `claudep doctor` warn when one is set and leave it alone.

package/claudep.ts

@@ -250,8 +250,9 @@ export const SHARED_DIRS = [
   "workflows",
 ] as const;
 
-/** Per-profile state. First block is Claude Code's own runtime-state list;
- *  the rest are observed extras. Never shared. */
+/** Per-profile state. First block is Claude Code's own runtime-state list as of
+ *  2.1.263, then observed extras, then what 2.1.280 added to that list. Never
+ *  shared, and a name here is never shared by the top-level *.md rule either. */
 export const KNOWN_PRIVATE = new Set<string>([
   ".claude.json",
   ".claude.json.backup",
@@ -301,6 +302,42 @@ export const KNOWN_PRIVATE = new Set<string>([
   "launch.json",
   "scheduled_tasks.json",
   "seed-admin",
+  // Added to Claude Code's runtime-state list by 2.1.280 (checked 2026-09-30).
+  "state",
+  "policy-limits.json.stamp.json",
+  "policy-limits.json.signature.json",
+  "policy-limits.json.signature-iat.json",
+  "remote-settings.json.signature.json",
+  "remote-settings.json.signature-iat.json",
+  "remote-settings-consent.json",
+  "remote-settings-helper-consent",
+  "hfi-auth.json",
+  "shares",
+  "storage-v2",
+  "daemon.lock",
+  "gh-pr-status-cache.json",
+  "active-time.json",
+  "server-sessions.json",
+  "image-cache",
+  "file-transfers",
+  "computer-use.lock",
+  "server.lock",
+  "downloads",
+  "scratch",
+  "traces",
+  "startup-perf",
+  "feedback-bundles",
+  "ccr",
+  "bridge-spawn",
+  "local-settings",
+  "project-settings",
+  "remote",
+  "systemd",
+  "api-dumps",
+  "dump-prompts",
+  "antproto.json",
+  ".cc-writes",
+  "loop.md",
 ]);
 
 /** Keys copied from the base .claude.json into a fresh profile so first-run
@@ -317,27 +354,87 @@ export const SEED_KEYS = [
 ] as const;
 
 export const NAME_RE = /^[a-z0-9][a-z0-9_-]*$/;
+
+/** Shells with a directory-pin hook, and the subset with tab completions. */
+export type Shell = "zsh" | "bash" | "fish" | "powershell";
+export const SHELLS: readonly Shell[] = ["zsh", "bash", "fish", "powershell"];
+export const COMPLETION_SHELLS = ["zsh", "bash", "fish"] as const;
+export type CompletionShell = (typeof COMPLETION_SHELLS)[number];
+/** What `claudep env --shell` accepts. */
+export const ENV_SHELLS = ["sh", "zsh", "bash", "fish", "powershell"] as const;
+
+export type ValueFlag = { name: string; values?: readonly string[] };
+export type Command = {
+  name: string;
+  /** One line, no colons: it becomes the zsh _describe and fish -d text. */
+  desc: string;
+  aliases?: readonly string[];
+  /** What the first positional completes to. */
+  arg?: "profile" | "dir" | readonly string[];
+  flags?: readonly string[];
+  valueFlags?: readonly ValueFlag[];
+  /** A real command that the top-level completion does not offer. */
+  hidden?: boolean;
+};
+
+/** One table for the dispatcher's reserved words, every parseFlags call and
+ *  the completion scripts, so none of them can drift from the others. */
+export const COMMANDS: readonly Command[] = [
+  {
+    name: "init",
+    desc: "create or update a profile and log in",
+    arg: "profile",
+    flags: ["--sso", "--console", "--copy-mcp", "--no-login", "--force"],
+    valueFlags: [{ name: "--email" }, { name: "--alias" }],
+  },
+  { name: "run", desc: "run claude with a profile", arg: "profile", hidden: true },
+  { name: "list", desc: "show every profile and who it is logged in as", aliases: ["ls"], flags: ["--json"] },
+  { name: "status", desc: "login state for one profile", arg: "profile", flags: ["--json"] },
+  { name: "current", desc: "which profile this shell is on, and why", flags: ["--json", "--name"] },
+  {
+    name: "env",
+    desc: "print the CLAUDE_CONFIG_DIR pin, or the unset, for your shell",
+    arg: "profile",
+    flags: ["--unset"],
+    valueFlags: [{ name: "--shell", values: ENV_SHELLS }],
+  },
+  { name: "alias", desc: "write a shim command that runs claudep with a profile", arg: "profile" },
+  { name: "doctor", desc: "verify symlinks, keychain entry, unclassified files, Claude Code version", arg: "profile" },
+  {
+    name: "rm",
+    desc: "log out and delete a profile",
+    aliases: ["remove"],
+    arg: "profile",
+    flags: ["--keep-login", "--yes"],
+  },
+  { name: "local", desc: "pin this directory tree to a profile", arg: "profile", flags: ["--remove", "--force"] },
+  { name: "resolve", desc: "print the profile pinned for a directory", arg: "dir", flags: ["--json"] },
+  { name: "shell-init", desc: "print the hook that applies pins on cd", arg: SHELLS },
+  { name: "completion", desc: "print tab completions for a shell", arg: COMPLETION_SHELLS },
+  { name: "help", desc: "show the help" },
+  { name: "version", desc: "print the version", aliases: ["--version"] },
+];
+
+/** The words a completion offers for a command: its name and the aliases
+ *  that are words (a `--version` alias is a flag, not a word). */
+export function commandWords(c: Command): string[] {
+  return [c.name, ...(c.aliases ?? [])].filter((w) => !w.startsWith("-"));
+}
+
+/** Profile names that would collide with the dispatcher. Derived from the
+ *  table plus the two names for the base. */
 export const RESERVED = new Set([
   "default",
   "base",
-  "init",
-  "run",
-  "list",
-  "ls",
-  "status",
-  "env",
-  "doctor",
-  "rm",
-  "remove",
-  "alias",
-  "help",
-  "current",
-  "local",
-  "resolve",
-  "shell-init",
-  "version",
+  ...COMMANDS.flatMap((c) => [c.name, ...(c.aliases ?? [])]).filter((w) => NAME_RE.test(w)),
 ]);
 
+/** The boolean and value flag names a command accepts, for parseFlags. */
+export function flagSpec(name: string): [readonly string[], readonly string[]] {
+  const c = COMMANDS.find((x) => x.name === name);
+  return [c?.flags ?? [], (c?.valueFlags ?? []).map((v) => v.name)];
+}
+
 // ---------------------------------------------------------------------------
 // Output helpers
 // ---------------------------------------------------------------------------
@@ -402,7 +499,8 @@ export function sharedItems(base: string): SharedItem[] {
   for (const f of SHARED_FILES) push(f, "file");
   if (existsSync(base)) {
     for (const entry of readdirSync(base, { withFileTypes: true })) {
-      if (entry.name.endsWith(".md") && !entry.isDirectory()) push(entry.name, "file");
+      if (entry.name.endsWith(".md") && !entry.isDirectory() && !KNOWN_PRIVATE.has(entry.name))
+        push(entry.name, "file");
     }
   }
   for (const d of SHARED_DIRS) push(d, "dir");
@@ -497,6 +595,18 @@ export function linkState(
   return existsSync(dest) ? "ok" : "broken";
 }
 
+/** Known-private names in a profile that are still symlinks into the base.
+ *  An older claudep linked every top-level *.md, which once included loop.md;
+ *  link() never deletes, so doctor names them for the user to remove. */
+export function staleSharedLinks(base: string, dir: string, platform: NodeJS.Platform = process.platform): string[] {
+  if (!existsSync(dir)) return [];
+  return readdirSync(dir, { withFileTypes: true })
+    .filter((e) => e.isSymbolicLink() && KNOWN_PRIVATE.has(e.name))
+    .filter((e) => samePath(readlinkSync(join(dir, e.name)), join(base, e.name), platform))
+    .map((e) => e.name)
+    .sort();
+}
+
 /** What to tell the user when the OS refused to create a symlink. */
 export function symlinkDeniedHint(platform: NodeJS.Platform, name: string): string {
   if (platform === "win32")
@@ -538,8 +648,23 @@ export function authEnvOverrides(env: Env = process.env, platform: NodeJS.Platfo
  *  dir. Before it every config dir shared one login. */
 export const MIN_CLAUDE_VERSION = "2.1.144";
 
+/** From this Claude Code on, a write through a symlink is also judged at the
+ *  path it lands on. Auto memory in a profile whose projects/ is shared lands
+ *  in ~/.claude/projects and asks for approval on every write, which auto mode
+ *  cannot give (anthropics/claude-code#98044). No fixed version yet. */
+export const MEMORY_SYMLINK_PROMPT_FROM = "2.1.280";
+export const MEMORY_SYMLINK_ISSUE = "https://github.com/anthropics/claude-code/issues/98044";
+
 export type Version = [number, number, number];
 
+/** True when this Claude Code prompts on every auto-memory write through the
+ *  shared projects/ symlink. An unknown version is not reported. */
+export function memoryWritesPrompt(v: Version | undefined, shared: readonly SharedItem[]): boolean {
+  const from = parseVersion(MEMORY_SYMLINK_PROMPT_FROM);
+  if (!v || !from || versionBelow(v, from)) return false;
+  return shared.some((s) => s.name === "projects");
+}
+
 /** The first x.y.z in `claude --version` output. */
 export function parseVersion(text: string): Version | undefined {
   const m = /(\d+)\.(\d+)\.(\d+)/.exec(text);
@@ -817,7 +942,7 @@ export function parseFlags(args: string[], boolNames: readonly string[], strName
 // ---------------------------------------------------------------------------
 
 async function cmdInit(L: Layout, args: string[]): Promise<void> {
-  const f = parseFlags(args, ["--copy-mcp", "--no-login", "--sso", "--console", "--force"], ["--email", "--alias"]);
+  const f = parseFlags(args, ...flagSpec("init"));
   const name = f.rest[0];
   if (!name)
     die(
@@ -1003,7 +1128,7 @@ function rowJson(row: Row): JsonObject {
 }
 
 async function cmdList(L: Layout, args: string[]): Promise<void> {
-  const f = parseFlags(args, ["--json"], []);
+  const f = parseFlags(args, ...flagSpec("list"));
   const names = ["default", ...listProfileNames(L)];
   const rows = await collectRows(L, names);
   if (f.bools.has("--json")) {
@@ -1017,7 +1142,7 @@ async function cmdList(L: Layout, args: string[]): Promise<void> {
 }
 
 async function cmdStatus(L: Layout, args: string[]): Promise<void> {
-  const f = parseFlags(args, ["--json"], []);
+  const f = parseFlags(args, ...flagSpec("status"));
   const name = f.rest[0];
   if (!name) die("usage: claudep status <name> [--json]");
   if (name !== "default" && !profileExists(L, name)) die(`profile "${name}" does not exist`);
@@ -1042,7 +1167,7 @@ export function envUnsetHint(syntax: EnvSyntax): string {
 }
 
 function cmdEnv(L: Layout, args: string[]): void {
-  const f = parseFlags(args, ["--unset"], ["--shell"]);
+  const f = parseFlags(args, ...flagSpec("env"));
   const forced = f.strs.get("--shell");
   const syntax =
     forced === undefined ? shellSyntax(process.env, L.platform, parentProcessName(L.platform)) : envSyntaxOf(forced);
@@ -1070,7 +1195,7 @@ export function currentLabel(cur: Current): string {
 }
 
 function cmdCurrent(L: Layout, args: string[]): void {
-  const f = parseFlags(args, ["--json", "--name"], []);
+  const f = parseFlags(args, ...flagSpec("current"));
   const cur = currentProfile(L);
   const label = currentLabel(cur);
   if (f.bools.has("--name")) {
@@ -1100,7 +1225,7 @@ function cmdCurrent(L: Layout, args: string[]): void {
 }
 
 function cmdResolve(L: Layout, args: string[]): void {
-  const f = parseFlags(args, ["--json"], []);
+  const f = parseFlags(args, ...flagSpec("resolve"));
   const start = f.rest[0] ?? process.cwd();
   const pin = resolvePin(start);
   if (!pin || pin.name === "") process.exit(1);
@@ -1111,7 +1236,7 @@ function cmdResolve(L: Layout, args: string[]): void {
 }
 
 function cmdLocal(L: Layout, args: string[]): void {
-  const f = parseFlags(args, ["--remove", "--force"], []);
+  const f = parseFlags(args, ...flagSpec("local"));
   const file = join(process.cwd(), PIN_FILE);
   if (f.bools.has("--remove")) {
     if (!existsSync(file)) die(`no ${PIN_FILE} in ${process.cwd()}`);
@@ -1140,9 +1265,8 @@ function cmdLocal(L: Layout, args: string[]): void {
 
 /** The shell hook. Pure parameter expansion and builtins: it runs on every
  *  directory change (zsh chpwd) or prompt (bash PROMPT_COMMAND), so no
- *  subprocess is allowed here. Logic mirrors resolvePin(). */
-export type Shell = "zsh" | "bash" | "fish" | "powershell";
-export const SHELLS: readonly Shell[] = ["zsh", "bash", "fish", "powershell"];
+ *  subprocess is allowed here. Logic mirrors resolvePin(). `Shell` and
+ *  `SHELLS` live next to the command table. */
 
 /** The shell to name in hints and to default `shell-init` to. */
 export function defaultShell(env: Env = process.env, platform: NodeJS.Platform = process.platform): Shell {
@@ -1423,6 +1547,186 @@ function cmdShellInit(L: Layout, args: string[]): void {
   process.stdout.write(shellInit(shell as Shell, L.profilesRoot, L.platform));
 }
 
+// ---------------------------------------------------------------------------
+// Tab completions, generated from COMMANDS. Profile names come from a glob
+// over the profiles root at completion time; no script ever runs claudep.
+// ---------------------------------------------------------------------------
+
+/** The one rc-file line that loads the completions. */
+export function completionHint(shell: CompletionShell): string {
+  return shell === "fish" ? "claudep completion fish | source" : `eval "$(claudep completion ${shell})"`;
+}
+
+const visibleCommands = () => COMMANDS.filter((c) => !c.hidden);
+const isList = (arg: Command["arg"]): arg is readonly string[] => arg !== undefined && typeof arg !== "string";
+
+export function completionScript(shell: CompletionShell, profilesRoot: string): string {
+  if (shell === "zsh") return zshCompletion(profilesRoot);
+  if (shell === "bash") return bashCompletion(profilesRoot);
+  return fishCompletion(profilesRoot);
+}
+
+/** Dual-mode: `eval "$(claudep completion zsh)"` after compinit registers it
+ *  with compdef; saved as `_claudep` on fpath, the #compdef line and the
+ *  funcstack check make it autoload. Names come from a glob with (N/:t):
+ *  nothing on an empty root, directories only, basename. */
+function zshCompletion(profilesRoot: string): string {
+  const q = `'${profilesRoot.replace(/'/g, `'\\''`)}'`;
+  const noColon = (s: string) => s.replace(/:/g, "\\:");
+  const cmds = visibleCommands().flatMap((c) => commandWords(c).map((w) => `    '${w}:${noColon(c.desc)}'`));
+  const cases = COMMANDS.filter((c) => c.arg || c.flags || c.valueFlags).map((c) => {
+    const specs: string[] = [];
+    if (c.arg === "profile") specs.push("'1:profile:_claudep_profiles'");
+    else if (c.arg === "dir") specs.push("'1:directory:_files -/'");
+    else if (isList(c.arg)) specs.push(`'1:shell:(${c.arg.join(" ")})'`);
+    if (c.name === "run") specs.push("'*:claude arguments:'");
+    for (const f of c.flags ?? []) specs.push(`'${f}'`);
+    for (const v of c.valueFlags ?? [])
+      specs.push(`'${v.name}=-:${v.name.slice(2)}:${v.values ? `(${v.values.join(" ")})` : ""}'`);
+    return `        ${commandWords(c).join("|")}) _arguments ${specs.join(" ")} ;;`;
+  });
+  return `#compdef claudep
+# claudep completions. Load them after compinit in ~/.zshrc:  ${completionHint("zsh")}
+_claudep_profiles() {
+  local -a names
+  names=(default ${q}/*(N/:t))
+  _describe -t profiles 'profile' names
+}
+_claudep() {
+  local -a cmds
+  cmds=(
+${cmds.join("\n")}
+  )
+  _arguments -C '1:command:->cmd' '*::arg:->args'
+  case $state in
+    cmd)
+      _describe -t commands 'claudep command' cmds
+      _claudep_profiles
+      ;;
+    args)
+      case $words[1] in
+${cases.join("\n")}
+      esac
+      ;;
+  esac
+}
+if [ "\${funcstack[1]}" = "_claudep" ]; then _claudep "$@"; else compdef _claudep claudep; fi
+`;
+}
+
+/** bash 3.2 safe: no mapfile, no compopt. The root's backslashes become
+ *  slashes so a Git Bash user with a C:\\ root still globs. */
+function bashCompletion(profilesRoot: string): string {
+  const q = `'${profilesRoot.replace(/'/g, `'\\''`)}'`;
+  const top = [...visibleCommands().flatMap(commandWords), "default"].join(" ");
+  const flagCases = COMMANDS.filter((c) => c.flags || c.valueFlags).map(
+    (c) =>
+      `        ${commandWords(c).join("|")}) words="${[...(c.flags ?? []), ...(c.valueFlags ?? []).map((v) => v.name)].join(" ")}" ;;`,
+  );
+  const valued = COMMANDS.flatMap((c) => (c.valueFlags ?? []).filter((v) => v.values));
+  const valueBranches = valued.map(
+    (v, i) => `      ${i === 0 ? "if" : "elif"} [ "$prev" = "${v.name}" ]; then words="${(v.values ?? []).join(" ")}"`,
+  );
+  const argCases = COMMANDS.filter((c) => c.arg).map((c) => {
+    const names = commandWords(c).join("|");
+    if (c.arg === "profile") return `          ${names}) words="default $(_claudep_profiles)" ;;`;
+    if (c.arg === "dir") return `          ${names}) COMPREPLY=($(compgen -d -- "$cur")); return 0 ;;`;
+    return `          ${names}) words="${isList(c.arg) ? c.arg.join(" ") : ""}" ;;`;
+  });
+  return `# claudep completions. Load them from ~/.bashrc:  ${completionHint("bash")}
+_claudep_profiles() {
+  local root=${q} d
+  root=\${root//\\\\//}
+  for d in "$root"/*/; do
+    d=\${d%/}
+    [ -d "$d" ] && printf '%s\\n' "\${d##*/}"
+  done
+}
+_claudep() {
+  local cur prev cmd words=""
+  cur=\${COMP_WORDS[COMP_CWORD]}
+  prev=\${COMP_WORDS[COMP_CWORD-1]}
+  cmd=\${COMP_WORDS[1]}
+  COMPREPLY=()
+  if [ "$COMP_CWORD" -eq 1 ]; then
+    COMPREPLY=($(compgen -W "${top} $(_claudep_profiles)" -- "$cur"))
+    return 0
+  fi
+  case $cur in
+    -*)
+      case $cmd in
+${flagCases.join("\n")}
+      esac
+      ;;
+    *)
+${valueBranches.join("\n")}
+      ${valueBranches.length ? "elif" : "if"} [ "$COMP_CWORD" -eq 2 ]; then
+        case $cmd in
+${argCases.join("\n")}
+        esac
+      fi
+      ;;
+  esac
+  COMPREPLY=($(compgen -W "$words" -- "$cur"))
+}
+complete -F _claudep claudep
+`;
+}
+
+/** The two conditions are written out over `commandline -opc` instead of
+ *  fish's __fish_use_subcommand and __fish_seen_subcommand_from, whose
+ *  names moved between versions. `for` over an unmatched glob runs zero
+ *  times, so an empty root offers only `default`. */
+function fishCompletion(profilesRoot: string): string {
+  const lines: string[] = [];
+  for (const c of visibleCommands())
+    for (const w of commandWords(c))
+      lines.push(`complete -c claudep -n '__claudep_at 1' -a ${w} -d ${fishQuote(c.desc)}`);
+  lines.push("complete -c claudep -n '__claudep_at 1' -a '(__claudep_profiles)' -d profile");
+  const profileCmds = COMMANDS.filter((c) => c.arg === "profile")
+    .flatMap(commandWords)
+    .join(" ");
+  lines.push(
+    `complete -c claudep -n '__claudep_cmd ${profileCmds}; and __claudep_at 2' -a '(__claudep_profiles)' -d profile`,
+  );
+  for (const c of COMMANDS) {
+    const ws = commandWords(c).join(" ");
+    if (isList(c.arg))
+      lines.push(`complete -c claudep -n '__claudep_cmd ${ws}; and __claudep_at 2' -a '${c.arg.join(" ")}'`);
+    if (c.arg === "dir")
+      lines.push(`complete -c claudep -n '__claudep_cmd ${ws}; and __claudep_at 2' -a '(__fish_complete_directories)'`);
+    for (const f of c.flags ?? []) lines.push(`complete -c claudep -n '__claudep_cmd ${ws}' -l ${f.slice(2)}`);
+    for (const v of c.valueFlags ?? [])
+      lines.push(
+        `complete -c claudep -n '__claudep_cmd ${ws}' -l ${v.name.slice(2)} -x${v.values ? ` -a '${v.values.join(" ")}'` : ""}`,
+      );
+  }
+  return `# claudep completions. Load them from ~/.config/fish/config.fish:  ${completionHint("fish")}
+function __claudep_profiles
+  echo default
+  for d in ${fishQuote(profilesRoot)}/*/
+    string replace -r -- '^.*/([^/]+)/$' '$1' $d
+  end
+end
+function __claudep_at -a n
+  test (count (commandline -opc)) -eq $n
+end
+function __claudep_cmd
+  set -l t (commandline -opc)
+  test (count $t) -ge 2; and contains -- $t[2] $argv
+end
+complete -c claudep -f
+${lines.join("\n")}
+`;
+}
+
+function cmdCompletion(L: Layout, args: string[]): void {
+  const shell = args[0] ?? defaultShell(process.env, L.platform);
+  if (!COMPLETION_SHELLS.includes(shell as CompletionShell))
+    die(`no completions for "${shell}". Use ${COMPLETION_SHELLS.join(", ")}`);
+  process.stdout.write(completionScript(shell as CompletionShell, L.profilesRoot));
+}
+
 /** A POSIX-style CLAUDE_CONFIG_DIR on Windows is one claude.exe cannot read. */
 function msysConfigDirWarning(L: Layout, env: Env = process.env): string | undefined {
   const cfg = env.CLAUDE_CONFIG_DIR;
@@ -1433,6 +1737,7 @@ function msysConfigDirWarning(L: Layout, env: Env = process.env): string | undef
 async function cmdDoctor(L: Layout, args: string[]): Promise<void> {
   const names = args[0] ? [args[0]] : listProfileNames(L);
   let problems = 0;
+  let v: Version | undefined;
   const launch = findClaude();
   if (launch && launch.kind !== "ps1") {
     const { out } = await captureClaude(L, undefined, ["--version"]);
@@ -1441,7 +1746,7 @@ async function cmdDoctor(L: Layout, args: string[]): Promise<void> {
       console.log(
         `${c.dim("·")} claude is the npm cmd shim and runs through cmd.exe; the native installer's claude.exe avoids that hop`,
       );
-    const v = parseVersion(out);
+    v = parseVersion(out);
     const floor = parseVersion(MIN_CLAUDE_VERSION);
     if (L.platform === "darwin" && v && floor && versionBelow(v, floor)) {
       bad(
@@ -1476,6 +1781,10 @@ async function cmdDoctor(L: Layout, args: string[]): Promise<void> {
   if (unclassified.length) {
     warn(`base items neither shared nor known-private (they stay per-profile): ${unclassified.join(", ")}`);
   }
+  if (memoryWritesPrompt(v, shared))
+    warn(
+      `Claude Code ${v?.join(".")} asks for approval on every auto-memory write in a profile, because projects/ is shared through a symlink; auto mode cannot approve it. Known upstream bug: ${MEMORY_SYMLINK_ISSUE}`,
+    );
 
   for (const name of names) {
     const dir = profileDir(L, name);
@@ -1505,13 +1814,23 @@ async function cmdDoctor(L: Layout, args: string[]): Promise<void> {
     ok(`${shared.length} shared item(s) checked`);
     const strays = readdirSync(dir).filter((n) => !sharedNames.has(n) && !KNOWN_PRIVATE.has(n) && !n.endsWith(".md"));
     if (strays.length) warn(`unexpected private items: ${strays.join(", ")}`);
+    for (const n of staleSharedLinks(L.base, dir, L.platform)) {
+      bad(
+        `${n}: linked to the base by an older claudep, but it is per-profile state now. Remove the symlink: ${join(dir, n)}`,
+      );
+      problems++;
+    }
+    const s = await authStatus(L, dir);
     if (L.platform === "darwin") {
       const svc = keychainService(dir);
       if (await keychainHas(svc)) ok(`keychain item "${svc}" present`);
       else warn(`no keychain item "${svc}". Not logged in yet (claudep ${name} auth login)`);
     } else if (credentialsFileHas(dir)) ok(".credentials.json present");
+    else if (s.loggedIn)
+      console.log(
+        `${c.dim("·")} no .credentials.json in the profile; Claude Code keeps this login elsewhere (on Windows, possibly Credential Manager)`,
+      );
     else warn(`no .credentials.json in the profile. Not logged in yet (claudep ${name} auth login)`);
-    const s = await authStatus(L, dir);
     if (s.loggedIn) ok(`logged in as ${s.email ?? "?"} (${s.orgName ?? "?"}, ${s.subscriptionType ?? "?"})`);
     else warn("not logged in");
   }
@@ -1523,7 +1842,7 @@ async function cmdDoctor(L: Layout, args: string[]): Promise<void> {
 }
 
 async function cmdRm(L: Layout, args: string[]): Promise<void> {
-  const f = parseFlags(args, ["--keep-login", "--yes"], []);
+  const f = parseFlags(args, ...flagSpec("rm"));
   const name = f.rest[0];
   if (!name) die("usage: claudep rm <name> [--keep-login] [--yes]");
   const dir = profileDir(L, name);
@@ -1582,8 +1901,14 @@ async function cmdRm(L: Layout, args: string[]): Promise<void> {
 }
 
 function help(L: Layout): void {
+  console.log(helpText(L));
+}
+
+/** Hand-written on purpose: the layout says more than the table can. A test
+ *  checks that every command in COMMANDS appears in it. */
+export function helpText(L: Layout): string {
   const root = shortHome(L.profilesRoot, L.home, L.platform);
-  console.log(`${c.bold("claudep")} ${c.dim(version())}: run Claude Code under separate accounts on one machine
+  return `${c.bold("claudep")} ${c.dim(version())}: run Claude Code under separate accounts on one machine
 
 ${c.bold("USAGE")}
   claudep <name> [claude args…]        run claude with profile <name>  (alias for "run")
@@ -1596,13 +1921,18 @@ ${c.bold("USAGE")}
   claudep alias <name> <command>       write a shim so "<command>" == "claudep <name>"
   claudep doctor [name]                verify symlinks, keychain entry, unclassified files, Claude Code version
   claudep rm <name> [--keep-login]     log out and delete a profile (base is never touched)
+  claudep help                         show this text
   claudep --version                    print the version
 
 ${c.bold("DIRECTORY PINS")}
   claudep local <name> [--force]       write ./${PIN_FILE} so this tree uses <name>; --remove deletes it
   claudep local                        show the pin that applies to the current directory
   claudep resolve [dir] [--json]       print the profile pinned for a directory (exit 1 when none)
-  claudep shell-init [zsh|bash|fish|powershell]   print the hook that applies pins on cd; load it from your rc file
+  claudep shell-init [${SHELLS.join("|")}]   print the hook that applies pins on cd; load it from your rc file
+
+${c.bold("TAB COMPLETION")}
+  claudep completion [${COMPLETION_SHELLS.join("|")}]   print completions for commands, flags and profile names;
+                                       load them from your rc file (after compinit in zsh)
 
 ${c.bold("INIT OPTIONS")}
   --sso               force the SSO login flow (Enterprise orgs)
@@ -1625,6 +1955,7 @@ ${c.bold("EXAMPLES")}
   eval "$(claudep shell-init zsh)"              # in .zshrc: shells follow ${PIN_FILE} pins on cd
   ${hookHint("fish")}              # the same line for config.fish
   ${hookHint("powershell")}   # the same line for $PROFILE
+  ${completionHint("zsh")}             # in .zshrc after compinit: tab completion
 
 ${c.bold("HOW IT WORKS")}
   ~/.claude stays exactly as it is and remains the "default" profile. Each named profile is a
@@ -1649,7 +1980,7 @@ ${c.bold("ENVIRONMENT")}
   CLAUDEP_AUTO          set by the hook next to CLAUDE_CONFIG_DIR; marks the pin as hook-managed
 
 ${c.dim("claudep is an independent, unofficial tool. It is not affiliated with, endorsed by or supported by Anthropic.")}
-`);
+`;
 }
 
 // ---------------------------------------------------------------------------
@@ -1685,6 +2016,8 @@ export async function main(argv: string[]): Promise<void> {
       return cmdResolve(L, args);
     case "shell-init":
       return cmdShellInit(L, args);
+    case "completion":
+      return cmdCompletion(L, args);
     case "version":
     case "--version":
     case "-v":

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bordoni/claudep",
-  "version": "0.3.0",
+  "version": "0.4.1",
   "description": "Unofficial, not affiliated with Anthropic. Run Claude Code under separate accounts on one machine (work + personal) with isolated logins and shared config.",
   "type": "module",
   "license": "MIT",