@bordoni/claudep 0.1.1 → 0.2.1

package/CHANGELOG.md

@@ -6,6 +6,38 @@ The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and
 
 ## [Unreleased]
 
+## [0.2.1] - 2026-09-08
+
+### Changed
+
+- `rules/`, `output-styles/`, `themes/` and `workflows/` are shared with every profile, matching what Claude Code 2.1.263 reads from the user config directory. A custom theme named in the shared `settings.json` now resolves inside a profile. Existing profiles pick the links up on their next `claudep init <name>`.
+- `teams/`, `uploads/`, `usage-data/`, `mcp-discovery-cache/`, `mcp-skill-archives/`, `daemon.json`, `launch.json`, `scheduled_tasks.json` and `seed-admin` are known-private, so `claudep doctor` no longer reports them as unclassified.
+- The README notes that `claude --bg` sessions and `claude daemon install` do not work under a profile in Claude Code 2.1.263.
+
+## [0.2.0] - 2026-09-07
+
+### Added
+
+- Windows support, from PowerShell 5.1, PowerShell 7 and Git Bash, with a native `claude.exe` or an npm-installed `claude.cmd`. Install with `bun add -g @bordoni/claudep`. cmd.exe is not a target. The README has a Windows section.
+- `claudep init` on Windows stops with instructions to turn on Developer Mode when Windows refuses to create a symlink, and finishes the profile on the next run. Symlinks are always created with their kind, which Windows needs and other systems ignore.
+- `claudep shell-init powershell` prints a hook for `$PROFILE` that follows `.claudep` pins by wrapping `prompt`. `shell-init` with no argument picks the shell from `$SHELL`, or PowerShell on Windows outside Git Bash.
+- `claudep env` prints `$env:` syntax when run from PowerShell, so `claudep env work | Invoke-Expression` works there and `eval "$(claudep env work)"` keeps working in Git Bash and elsewhere.
+- `claudep alias` on Windows writes `<command>.cmd`, which PowerShell finds through `PATHEXT`, next to the sh shim Git Bash runs.
+- An npm-installed `claude.cmd` is launched through cmd.exe; `claude.exe` is preferred when both are on PATH, and `claudep doctor` says which one it found.
+- `claudep current` and `claudep doctor` warn on Windows when `CLAUDE_CONFIG_DIR` is a POSIX-style path that `claude.exe` cannot read.
+- CI runs the suite on Windows as well as macOS and Linux, including the shell hook under Git Bash, `pwsh` and Windows PowerShell 5.1.
+
+### Changed
+
+- `claudep doctor` on Linux and Windows checks that the profile has a `.credentials.json` instead of printing `keychain check skipped`. `Thumbs.db` and `desktop.ini` are known-private.
+- Path comparisons for pins, the `claudep rm` safety check and `~` shortening accept `~\`, drive letters and MSYS `/c/` paths, and are case-insensitive on Windows only. No behaviour change on macOS or Linux.
+- `claudep rm` unlinks the shared items itself before deleting the profile directory.
+- The bash hook under Git Bash exports the native `C:\` path for the pinned profile while still walking the POSIX `$PWD`.
+
+### Fixed
+
+- The shell hook reads `.claudep` pin files with CRLF line endings. The `\r` used to become part of the profile name.
+
 ## [0.1.1] - 2026-09-03
 
 ### Fixed
@@ -31,6 +63,8 @@ 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.1.1...HEAD
+[Unreleased]: https://github.com/bordoni/claudep/compare/0.2.1...HEAD
+[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
 [0.1.1]: https://github.com/bordoni/claudep/compare/0.1.0...0.1.1
 [0.1.0]: https://github.com/bordoni/claudep/releases/tag/0.1.0

package/README.md

@@ -34,6 +34,21 @@ git clone git@github.com:bordoni/claudep.git ~/workspace/claudep
 ln -s ~/workspace/claudep/claudep.ts ~/.local/bin/claudep
 ```
 
+### Windows
+
+claudep runs natively on Windows from PowerShell 5.1, PowerShell 7 and Git Bash. Install it with bun, which writes `claudep.exe` into `%USERPROFILE%\.bun\bin`:
+
+```powershell
+bun add -g @bordoni/claudep
+```
+
+Two things differ from macOS:
+
+- Profiles share configuration through symlinks, and Windows lets a normal user create symlinks only with Developer Mode on (Settings > For developers > Developer Mode). `claudep init` stops and says so when it is off. Turn it on, open a new terminal and run the same command again.
+- There is no keychain. Claude Code keeps each profile's login in `<profile>\.credentials.json`, and `claudep doctor` checks that the file is there.
+
+`claudep env` prints PowerShell syntax when run from PowerShell and sh syntax from Git Bash, so `claudep env work | Invoke-Expression` and `eval "$(claudep env work)"` both work. Git Bash otherwise behaves like bash elsewhere: put `eval "$(claudep shell-init bash)"` in `~/.bashrc`. An npm-installed `claude.cmd` runs through cmd.exe; the native installer's `claude.exe` avoids that hop and is what `claudep doctor` recommends. cmd.exe itself is not supported.
+
 ## Usage
 
 ```
@@ -48,7 +63,7 @@ claudep doctor [name]                verify symlinks, keychain entry, unclassifi
 claudep rm <name> [--keep-login]     log out and delete a profile (base is never touched)
 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]        print the hook that applies pins on cd
+claudep shell-init [zsh|bash|powershell]   print the hook that applies pins on cd
 claudep --version
 ```
 
@@ -63,16 +78,22 @@ cd ~/work/acme
 claudep local enterprise          # writes ./.claudep containing "enterprise"
 ```
 
-Shells apply pins through a hook. Add one line to `~/.zshrc` (or `~/.bashrc` with `bash`):
+Shells apply pins through a hook. Add one line to `~/.zshrc` (or `~/.bashrc` with `bash`, including Git Bash on Windows):
 
 ```sh
 eval "$(claudep shell-init zsh)"
 ```
 
-From then on, `cd` into a pinned tree sets `CLAUDE_CONFIG_DIR` for that profile and `cd` out of it returns the shell to `~/.claude`. The hook is pure shell with no subprocess, so it costs nothing at the prompt. The rules:
+In PowerShell the line goes in `$PROFILE`:
+
+```powershell
+claudep shell-init powershell | Out-String | Invoke-Expression
+```
+
+From then on, `cd` into a pinned tree sets `CLAUDE_CONFIG_DIR` for that profile and `cd` out of it returns the shell to `~/.claude`. The hook is pure shell with no subprocess (cmdlets only in PowerShell), so it costs nothing at the prompt. The rules:
 
 - The nearest `.claudep` file upward from the current directory wins. An empty one cancels a parent pin.
-- The hook only changes a `CLAUDE_CONFIG_DIR` it set itself. It tracks that in `CLAUDEP_AUTO`, so a manual pin from `eval "$(claudep env work)"` or a plain `export` stays put until you `eval "$(claudep env --unset)"`.
+- The hook only changes a `CLAUDE_CONFIG_DIR` it set itself. It tracks that in `CLAUDEP_AUTO`, so a manual pin from `eval "$(claudep env work)"` (`claudep env work | Invoke-Expression` in PowerShell) or a plain `export` stays put until you `eval "$(claudep env --unset)"`.
 - A pin that names a profile you have not created prints one warning per directory change and sets nothing.
 
 `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.
@@ -85,10 +106,10 @@ From then on, `cd` into a pinned tree sets `CLAUDE_CONFIG_DIR` for that profile
 |---|---|
 | `CLAUDE.md` and other top-level `*.md` | `.claude.json` (login identity, user-scope MCP servers, folder trust) |
 | `settings.json`, `keybindings.json`, `statusline-command.sh` | org-pushed `remote-settings.json`, `policy-limits.json` |
-| `hooks/`, `skills/`, `commands/`, `agents/`, `plugins/`, `plans/` | `history.jsonl`, `todos/`, `sessions/`, caches, telemetry |
-| `projects/` (session transcripts and auto-memory) | credentials |
+| `hooks/`, `skills/`, `commands/`, `agents/`, `rules/`, `output-styles/`, `themes/`, `workflows/` | `history.jsonl`, `todos/`, `sessions/`, `teams/`, caches, telemetry |
+| `plugins/`, `plans/`, `projects/` (session transcripts and auto-memory) | credentials |
 
-Credentials never touch the profile directory. On macOS, Claude Code stores them in the Keychain under `Claude Code-credentials-<sha256(CLAUDE_CONFIG_DIR)[0:8]>`, so every profile has its own login and refresh token and they cannot overwrite each other. I verified this against Claude Code 2.1.259. An older bug where every config dir shared one Keychain entry no longer applies.
+On macOS, credentials never touch the profile directory: Claude Code stores them in the Keychain under `Claude Code-credentials-<sha256(CLAUDE_CONFIG_DIR)[0:8]>`, so every profile has its own login and refresh token and they cannot overwrite each other. I verified this against Claude Code 2.1.259. An older bug where every config dir shared one Keychain entry no longer applies. On Linux and Windows the login is `<profile>/.credentials.json`, a real file inside the profile that is never shared.
 
 The shared list is an allowlist, so an account-specific file cannot leak across profiles by accident. `claudep doctor` reports any base file that is neither shared nor known-private. That is how you notice when a new Claude Code version adds something.
 
@@ -96,6 +117,7 @@ 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.
 - 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.
 

package/claudep.ts

@@ -24,13 +24,15 @@ import {
   readFileSync,
   readlinkSync,
   realpathSync,
+  rmdirSync,
   rmSync,
   statSync,
   symlinkSync,
+  unlinkSync,
   writeFileSync,
 } from "node:fs";
 import { homedir, userInfo } from "node:os";
-import { dirname, join, resolve } from "node:path";
+import { dirname, join, posix, resolve, win32 } from "node:path";
 
 // ---------------------------------------------------------------------------
 // Layout
@@ -38,21 +40,94 @@ import { dirname, join, resolve } from "node:path";
 
 export type Env = Record<string, string | undefined>;
 
+/** The path module for a platform. Every helper that must be exercised for
+ *  win32 on a macOS or Linux host takes `platform` as a parameter and goes
+ *  through this instead of the ambient `node:path`. */
+export function pathApi(platform: NodeJS.Platform = process.platform): typeof posix | typeof win32 {
+  return platform === "win32" ? win32 : posix;
+}
+
+/** An MSYS or Git Bash style path such as /c/Users/me. */
+export function isMsysPath(p: string): boolean {
+  return /^\/[a-zA-Z](\/|$)/.test(p);
+}
+
+/** win32 only: drop the \\?\ and \\?\UNC\ prefixes readlink and realpath can
+ *  add, and rewrite an MSYS /c/x path to C:/x. A pure string operation; the
+ *  result still goes through resolve() to pick the separator. */
+export function toNativePath(p: string, platform: NodeJS.Platform = process.platform): string {
+  if (platform !== "win32") return p;
+  let out = p;
+  if (out.startsWith("\\\\?\\UNC\\")) out = `\\\\${out.slice(8)}`;
+  else if (out.startsWith("\\\\?\\")) out = out.slice(4);
+  if (isMsysPath(out)) out = `${(out[1] as string).toUpperCase()}:${out.slice(2) || "/"}`;
+  return out;
+}
+
 /** Home directory. $HOME wins so tests and containers can redirect it; bun's
- *  os.homedir() reads getpwuid() and ignores the variable. */
-export function homeDir(env: Env = process.env): string {
+ *  os.homedir() reads getpwuid() and ignores the variable. On Windows
+ *  USERPROFILE is the native home; Git Bash sets HOME to a POSIX-style path
+ *  that claude.exe would not understand. */
+export function homeDir(env: Env = process.env, platform: NodeJS.Platform = process.platform): string {
+  if (platform === "win32") return toNativePath(env.USERPROFILE || env.HOME || homedir(), platform);
   return env.HOME || homedir();
 }
 
-/** Canonical form of a config dir: absolute, no trailing slash, NFC.
- *  Claude Code hashes the *literal* CLAUDE_CONFIG_DIR string for the keychain
- *  service name, so the same profile must always produce the same string. */
-export function canon(p: string, home: string = homeDir()): string {
-  const expanded = p.startsWith("~/") ? join(home, p.slice(2)) : p;
-  return resolve(expanded).replace(/\/+$/, "").normalize("NFC");
+/** Canonical form of a config dir: absolute, no trailing separator, NFC, and
+ *  on Windows an upper-case drive letter and backslashes. Claude Code hashes
+ *  the *literal* CLAUDE_CONFIG_DIR string for the keychain service name and
+ *  compares it literally elsewhere, so the same profile must always produce
+ *  the same string. */
+export function canon(p: string, home: string = homeDir(), platform: NodeJS.Platform = process.platform): string {
+  const P = pathApi(platform);
+  const tilde = p.startsWith("~/") || (platform === "win32" && p.startsWith("~\\"));
+  const expanded = tilde ? P.join(home, p.slice(2)) : toNativePath(p, platform);
+  let out = P.resolve(expanded);
+  if (platform === "win32" && /^[a-z]:/.test(out)) out = `${(out[0] as string).toUpperCase()}${out.slice(1)}`;
+  return out.normalize("NFC");
+}
+
+/** Comparison key for a path. Identity on POSIX, where two spellings are two
+ *  directories. On Windows the file system is case-insensitive and readlink
+ *  may add a \\?\ prefix or use forward slashes, so the key folds all of that. */
+export function pathKey(p: string, platform: NodeJS.Platform = process.platform): string {
+  if (platform !== "win32") return p;
+  return toNativePath(p, platform).replace(/\//g, "\\").replace(/\\+$/, "").toLowerCase();
+}
+
+export function samePath(a: string, b: string, platform: NodeJS.Platform = process.platform): boolean {
+  return pathKey(a, platform) === pathKey(b, platform);
+}
+
+/** True when `child` is strictly inside `parent`. Never use startsWith for
+ *  this: "/r" is not a parent of "/rx", and on Windows case must not matter. */
+export function isInside(parent: string, child: string, platform: NodeJS.Platform = process.platform): boolean {
+  const sep = pathApi(platform).sep;
+  const pk = pathKey(parent, platform);
+  const prefix = pk.endsWith(sep) ? pk : `${pk}${sep}`;
+  return pathKey(child, platform).startsWith(prefix);
+}
+
+/** `~` plus the tail of `p` when it lives under `home`, otherwise `p` unchanged. */
+export function shortHome(p: string, home: string, platform: NodeJS.Platform = process.platform): string {
+  const np = toNativePath(p, platform);
+  if (samePath(np, home, platform)) return "~";
+  return isInside(home, np, platform) ? `~${np.slice(home.length)}` : np;
+}
+
+/** Delete a variable from an env copy. Windows environments are
+ *  case-insensitive, so every spelling of the name goes. */
+export function deleteEnv(env: Env, name: string, platform: NodeJS.Platform = process.platform): void {
+  if (platform !== "win32") {
+    delete env[name];
+    return;
+  }
+  const want = name.toUpperCase();
+  for (const k of Object.keys(env)) if (k.toUpperCase() === want) delete env[k];
 }
 
 export type Layout = {
+  platform: NodeJS.Platform;
   home: string;
   /** CLAUDE_CONFIG_DIR as set in the caller's shell, if any. */
   callerConfigDir: string | undefined;
@@ -69,25 +144,27 @@ export type Layout = {
   profilesRoot: string;
 };
 
-export function layout(env: Env = process.env): Layout {
-  const home = homeDir(env);
+export function layout(env: Env = process.env, platform: NodeJS.Platform = process.platform): Layout {
+  const P = pathApi(platform);
+  const home = homeDir(env, platform);
   const callerConfigDir = env.CLAUDE_CONFIG_DIR;
-  const profilesRoot = canon(env.CLAUDE_PROFILES_DIR ?? join(home, ".claudep"), home);
-  const callerCanon = callerConfigDir !== undefined ? canon(callerConfigDir, home) : undefined;
-  const managed = callerCanon !== undefined && callerCanon.startsWith(`${profilesRoot}/`);
+  const profilesRoot = canon(env.CLAUDE_PROFILES_DIR ?? P.join(home, ".claudep"), home, platform);
+  const callerCanon = callerConfigDir !== undefined ? canon(callerConfigDir, home, platform) : undefined;
+  const managed = callerCanon !== undefined && isInside(profilesRoot, callerCanon, platform);
   const tail = managed && callerCanon !== undefined ? callerCanon.slice(profilesRoot.length + 1) : undefined;
   const activeProfile = tail !== undefined && NAME_RE.test(tail) ? tail : undefined;
   // A custom CLAUDE_CONFIG_DIR outside the profiles root is the user's real base.
   // One inside it is a claudep profile and must never be treated as the base.
   const customBase = callerCanon !== undefined && !managed;
-  const base = customBase && callerCanon !== undefined ? callerCanon : canon(join(home, ".claude"), home);
+  const base = customBase && callerCanon !== undefined ? callerCanon : canon(P.join(home, ".claude"), home, platform);
   return {
+    platform,
     home,
     callerConfigDir,
     managed,
     activeProfile,
     base,
-    baseGlobalJson: customBase ? join(base, ".claude.json") : join(home, ".claude.json"),
+    baseGlobalJson: customBase ? P.join(base, ".claude.json") : P.join(home, ".claude.json"),
     profilesRoot,
   };
 }
@@ -140,9 +217,9 @@ export type Current = {
 export function currentProfile(L: Layout, env: Env = process.env): Current {
   const cfg = env.CLAUDE_CONFIG_DIR;
   if (!cfg) return { kind: "base", name: undefined, dir: L.base, setBy: "none" };
-  const dir = canon(cfg, L.home);
+  const dir = canon(cfg, L.home, L.platform);
   const auto = env.CLAUDEP_AUTO;
-  const setBy = auto !== undefined && canon(auto, L.home) === dir ? "hook" : "manual";
+  const setBy = auto !== undefined && samePath(canon(auto, L.home, L.platform), dir, L.platform) ? "hook" : "manual";
   if (L.activeProfile !== undefined) return { kind: "profile", name: L.activeProfile, dir, setBy };
   return { kind: "custom", name: undefined, dir, setBy };
 }
@@ -159,7 +236,19 @@ export function version(): string {
 
 /** Top-level base items symlinked into every profile (only if they exist). */
 export const SHARED_FILES = ["CLAUDE.md", "settings.json", "keybindings.json", "statusline-command.sh"] as const;
-export const SHARED_DIRS = ["hooks", "skills", "commands", "agents", "plugins", "plans", "projects"] as const;
+export const SHARED_DIRS = [
+  "hooks",
+  "skills",
+  "commands",
+  "agents",
+  "plugins",
+  "plans",
+  "projects",
+  "rules",
+  "output-styles",
+  "themes",
+  "workflows",
+] as const;
 
 /** Per-profile state. First block is Claude Code's own runtime-state list;
  *  the rest are observed extras. Never shared. */
@@ -196,11 +285,22 @@ export const KNOWN_PRIVATE = new Set<string>([
   "local",
   "settings.local.json",
   ".DS_Store",
+  "Thumbs.db",
+  "desktop.ini",
   ".config.json",
   ".last-cleanup",
   ".last-update-result.json",
   "daemon-auth-cooldown",
   "daemon-auth-status.json",
+  "teams",
+  "uploads",
+  "usage-data",
+  "mcp-discovery-cache",
+  "mcp-skill-archives",
+  "daemon.json",
+  "launch.json",
+  "scheduled_tasks.json",
+  "seed-admin",
 ]);
 
 /** Keys copied from the base .claude.json into a fresh profile so first-run
@@ -266,11 +366,11 @@ export function die(msg: string, code = 1): never {
 export function profileDir(L: Layout, name: string): string {
   if (!NAME_RE.test(name)) die(`invalid profile name "${name}" (use [a-z0-9_-], starting with a letter or digit)`);
   if (RESERVED.has(name)) die(`"${name}" is a reserved word and cannot be a profile name`);
-  return canon(join(L.profilesRoot, name), L.home);
+  return canon(pathApi(L.platform).join(L.profilesRoot, name), L.home, L.platform);
 }
 
 export function profileExists(L: Layout, name: string): boolean {
-  return NAME_RE.test(name) && !RESERVED.has(name) && existsSync(join(L.profilesRoot, name));
+  return NAME_RE.test(name) && !RESERVED.has(name) && existsSync(pathApi(L.platform).join(L.profilesRoot, name));
 }
 
 export function listProfileNames(L: Layout): string[] {
@@ -309,34 +409,107 @@ export function sharedItems(base: string): SharedItem[] {
   return items;
 }
 
-export type LinkResult = "linked" | "ok" | "wrong-target" | "conflict";
+/** The two file-system calls link() makes, injectable so the tests can record
+ *  the symlink type and simulate Windows refusing to create one. */
+export type LinkDeps = {
+  platform: NodeJS.Platform;
+  symlink: (target: string, dest: string, type: SharedItem["kind"]) => void;
+  readlink: (p: string) => string;
+};
+
+export const defaultLinkDeps = (): LinkDeps => ({
+  platform: process.platform,
+  symlink: (target, dest, type) => symlinkSync(target, dest, type),
+  readlink: (p) => readlinkSync(p),
+});
+
+export type LinkResult = "linked" | "ok" | "wrong-target" | "conflict" | "denied";
 
-/** Idempotent symlink profile/<name> -> base/<name>. Never overwrites real files. */
-export function link(base: string, dir: string, name: string, force: boolean): LinkResult {
-  const target = join(base, name);
-  const dest = join(dir, name);
+/** Remove a symlink. On Windows a directory symlink is removed with rmdir. */
+function removeLink(p: string): void {
+  try {
+    unlinkSync(p);
+  } catch {
+    rmdirSync(p);
+  }
+}
+
+/** false when the OS refused with EPERM, which on Windows means Developer
+ *  Mode is off. Anything else propagates. */
+function trySymlink(deps: LinkDeps, target: string, dest: string, type: SharedItem["kind"]): boolean {
+  try {
+    deps.symlink(target, dest, type);
+    return true;
+  } catch (e) {
+    if ((e as { code?: string }).code === "EPERM") return false;
+    throw e;
+  }
+}
+
+/** Idempotent symlink profile/<name> -> base/<name>. Never overwrites real
+ *  files. The type is always passed: POSIX ignores it, Windows needs it. */
+export function link(
+  base: string,
+  dir: string,
+  item: SharedItem,
+  force: boolean,
+  deps: LinkDeps = defaultLinkDeps(),
+): LinkResult {
+  const target = join(base, item.name);
+  const dest = join(dir, item.name);
   let st: ReturnType<typeof lstatSync> | undefined;
   try {
     st = lstatSync(dest);
   } catch {
     st = undefined;
   }
-  if (!st) {
-    symlinkSync(target, dest);
-    return "linked";
-  }
+  if (!st) return trySymlink(deps, target, dest, item.kind) ? "linked" : "denied";
   if (st.isSymbolicLink()) {
-    if (readlinkSync(dest) === target) return "ok";
+    if (samePath(deps.readlink(dest), target, deps.platform)) return "ok";
     if (force) {
-      rmSync(dest);
-      symlinkSync(target, dest);
-      return "linked";
+      removeLink(dest);
+      return trySymlink(deps, target, dest, item.kind) ? "linked" : "denied";
     }
     return "wrong-target";
   }
   return "conflict";
 }
 
+export type LinkState = "ok" | "missing" | "shadowed" | "wrong-target" | "broken";
+
+/** What doctor reports for one shared item. Read-only twin of link(). */
+export function linkState(
+  base: string,
+  dir: string,
+  item: SharedItem,
+  deps: Pick<LinkDeps, "platform" | "readlink"> = defaultLinkDeps(),
+): LinkState {
+  const dest = join(dir, item.name);
+  let st: ReturnType<typeof lstatSync> | undefined;
+  try {
+    st = lstatSync(dest);
+  } catch {
+    st = undefined;
+  }
+  if (!st) return "missing";
+  if (!st.isSymbolicLink()) return "shadowed";
+  if (!samePath(deps.readlink(dest), join(base, item.name), deps.platform)) return "wrong-target";
+  return existsSync(dest) ? "ok" : "broken";
+}
+
+/** 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")
+    return `Windows refused to create a symlink. Turn on Developer Mode (Settings > For developers > Developer Mode), open a new terminal and run: claudep init ${name}`;
+  return `the OS refused to create a symlink (EPERM). Check the permissions on the profiles root, then run: claudep init ${name}`;
+}
+
+/** True when the profile has Claude Code's file credential store. Existence
+ *  only; the file is never read. This is the login check everywhere but macOS. */
+export function credentialsFileHas(dir: string, exists: (p: string) => boolean = existsSync): boolean {
+  return exists(join(dir, ".credentials.json"));
+}
+
 export type JsonObject = Record<string, unknown>;
 
 export async function readJson(path: string): Promise<JsonObject | undefined> {
@@ -366,17 +539,114 @@ export async function seedGlobalJson(baseGlobalJson: string, dir: string, copyMc
 // Running claude
 // ---------------------------------------------------------------------------
 
-function claudeBin(): string {
-  const bin = Bun.which("claude");
-  if (!bin) die("`claude` not found on PATH. Install Claude Code first: https://code.claude.com/docs/en/setup");
-  return bin;
+/** How `claude` is installed. A native binary or npm's Windows shims. */
+export type ClaudeLaunch = { bin: string; kind: "exe" | "cmd" | "ps1" };
+
+export type FindDeps = {
+  platform: NodeJS.Platform;
+  pathVar: string;
+  exists: (p: string) => boolean;
+  which: (name: string) => string | null;
+};
+
+export const defaultFindDeps = (): FindDeps => ({
+  platform: process.platform,
+  pathVar: process.env.PATH ?? "",
+  exists: existsSync,
+  which: (name) => Bun.which(name),
+});
+
+/** Locate claude. POSIX asks which(). Windows walks PATH one directory at a
+ *  time so the first directory wins even when a later one has claude.exe,
+ *  and prefers claude.exe over the npm shims inside a directory. */
+export function findClaude(deps: FindDeps = defaultFindDeps()): ClaudeLaunch | undefined {
+  if (deps.platform !== "win32") {
+    const bin = deps.which("claude");
+    return bin ? { bin, kind: "exe" } : undefined;
+  }
+  const candidates: [string, ClaudeLaunch["kind"]][] = [
+    ["claude.exe", "exe"],
+    ["claude.cmd", "cmd"],
+    ["claude.bat", "cmd"],
+    ["claude.ps1", "ps1"],
+  ];
+  for (const dir of splitPathVar(deps.pathVar, "win32")) {
+    for (const [file, kind] of candidates) {
+      const bin = win32.join(dir, file);
+      if (deps.exists(bin)) return { bin, kind };
+    }
+  }
+  return undefined;
+}
+
+const CMD_META = /([()\][%!^"`<>&|;, *?])/g;
+
+/** The command word for `cmd.exe /d /s /c "..."`, the way cross-spawn does
+ *  it: caret-escape cmd's metacharacters, spaces included, and no quotes. */
+export function cmdExeCommand(cmd: string): string {
+  return cmd.replace(CMD_META, "^$1");
+}
+
+/** One argument for the same line: double backslashes before quotes, escape
+ *  quotes, wrap in quotes, then caret-escape every metacharacter. Twice when
+ *  the target is a .cmd shim, because its own cmd.exe parses `%*` again. */
+export function cmdExeQuote(arg: string, doubleEscape = true): string {
+  let out = arg.replace(/(?=(\\+?)?)"/g, '$1$1\\"');
+  out = out.replace(/(\\+)$/, "$1$1");
+  out = `"${out}"`.replace(CMD_META, "^$1");
+  if (doubleEscape) out = out.replace(CMD_META, "^$1");
+  return out;
+}
+
+/** argv and spawn option for a launch. A .cmd shim cannot be executed
+ *  directly; it runs through cmd.exe with one pre-quoted command line. */
+export function claudeSpawn(launch: ClaudeLaunch, args: string[]): { cmd: string[]; verbatim: boolean } {
+  if (launch.kind !== "cmd") return { cmd: [launch.bin, ...args], verbatim: false };
+  const line = [cmdExeCommand(launch.bin), ...args.map((a) => cmdExeQuote(a))].join(" ");
+  return { cmd: ["cmd.exe", "/d", "/s", "/c", `"${line}"`], verbatim: true };
+}
+
+/** Signals the wrapper ignores (so it survives to report the child's exit
+ *  code; the terminal delivers Ctrl+C to the child itself) and forwards.
+ *  Windows has no SIGHUP. */
+export function wrapperSignals(platform: NodeJS.Platform): { ignore: NodeJS.Signals[]; forward: NodeJS.Signals[] } {
+  if (platform === "win32") return { ignore: ["SIGINT"], forward: ["SIGTERM"] };
+  return { ignore: ["SIGINT"], forward: ["SIGTERM", "SIGHUP"] };
+}
+
+function claudeLaunch(): ClaudeLaunch {
+  const launch = findClaude();
+  if (!launch) die("`claude` not found on PATH. Install Claude Code first: https://code.claude.com/docs/en/setup");
+  if (launch.kind === "ps1")
+    die(
+      `only ${launch.bin} was found. Install Claude Code with the native installer or npm so claude.exe or claude.cmd exists: https://code.claude.com/docs/en/setup`,
+    );
+  return launch;
+}
+
+function spawnClaude(L: Layout, dir: string | undefined, args: string[], io: "inherit" | "pipe") {
+  const { cmd, verbatim } = claudeSpawn(claudeLaunch(), args);
+  return Bun.spawn(cmd, {
+    env: claudeEnv(L, dir),
+    stdin: io === "inherit" ? "inherit" : "ignore",
+    stdout: io,
+    stderr: io,
+    windowsVerbatimArguments: verbatim,
+  });
 }
 
 /** Environment for a profile. `undefined` dir means "the base", i.e. leave the
  *  caller's CLAUDE_CONFIG_DIR exactly as it is (set or unset). */
-export function envFor(dir: string | undefined, env: Env = process.env): Env {
+export function envFor(
+  dir: string | undefined,
+  env: Env = process.env,
+  platform: NodeJS.Platform = process.platform,
+): Env {
   const out: Env = { ...env };
-  if (dir !== undefined) out.CLAUDE_CONFIG_DIR = dir;
+  if (dir !== undefined) {
+    deleteEnv(out, "CLAUDE_CONFIG_DIR", platform);
+    out.CLAUDE_CONFIG_DIR = dir;
+  }
   return out;
 }
 
@@ -386,28 +656,23 @@ export function envFor(dir: string | undefined, env: Env = process.env): Env {
 export function baseEnv(L: Layout, env: Env = process.env): Env {
   const out: Env = { ...env };
   if (L.managed) {
-    delete out.CLAUDE_CONFIG_DIR;
-    delete out.CLAUDEP_AUTO;
+    deleteEnv(out, "CLAUDE_CONFIG_DIR", L.platform);
+    deleteEnv(out, "CLAUDEP_AUTO", L.platform);
   }
   return out;
 }
 
 function claudeEnv(L: Layout, dir: string | undefined): Env {
-  return dir === undefined ? baseEnv(L) : envFor(dir);
+  return dir === undefined ? baseEnv(L) : envFor(dir, process.env, L.platform);
 }
 
 async function execClaude(L: Layout, dir: string | undefined, args: string[]): Promise<never> {
-  const proc = Bun.spawn([claudeBin(), ...args], {
-    env: claudeEnv(L, dir),
-    stdin: "inherit",
-    stdout: "inherit",
-    stderr: "inherit",
-  });
+  const proc = spawnClaude(L, dir, args, "inherit");
   // Ctrl+C reaches the child through the terminal; keep the wrapper alive so
   // it can report the child's real exit code.
-  process.on("SIGINT", () => {});
-  process.on("SIGTERM", () => proc.kill("SIGTERM"));
-  process.on("SIGHUP", () => proc.kill("SIGHUP"));
+  const signals = wrapperSignals(L.platform);
+  for (const s of signals.ignore) process.on(s, () => {});
+  for (const s of signals.forward) process.on(s, () => proc.kill(s));
   await proc.exited;
   process.exit(proc.exitCode ?? 1);
 }
@@ -417,12 +682,7 @@ async function captureClaude(
   dir: string | undefined,
   args: string[],
 ): Promise<{ code: number; out: string }> {
-  const proc = Bun.spawn([claudeBin(), ...args], {
-    env: claudeEnv(L, dir),
-    stdin: "ignore",
-    stdout: "pipe",
-    stderr: "pipe",
-  });
+  const proc = spawnClaude(L, dir, args, "pipe");
   const out = await new Response(proc.stdout).text();
   const code = await proc.exited;
   return { code, out };
@@ -528,9 +788,10 @@ async function cmdInit(L: Layout, args: string[]): Promise<void> {
 
   let conflicts = 0;
   for (const item of sharedItems(L.base)) {
-    const r = link(L.base, dir, item.name, f.bools.has("--force"));
+    const r = link(L.base, dir, item, f.bools.has("--force"));
     if (r === "linked") ok(`${item.name} → shared`);
     else if (r === "ok") console.log(`${c.dim("·")} ${item.name} ${c.dim("already shared")}`);
+    else if (r === "denied") die(symlinkDeniedHint(L.platform, name));
     else if (r === "wrong-target") {
       warn(`${item.name} is a symlink to somewhere else (re-run with --force to relink)`);
       conflicts++;
@@ -547,7 +808,7 @@ async function cmdInit(L: Layout, args: string[]): Promise<void> {
   else warn(`could not read ${L.baseGlobalJson}; Claude Code will run its first-time onboarding`);
 
   const alias = f.strs.get("--alias");
-  if (alias !== undefined) writeAlias(name, alias);
+  if (alias !== undefined) writeAlias(L, name, alias);
 
   if (conflicts) warn(`${conflicts} item(s) need attention, see above`);
 
@@ -575,42 +836,75 @@ export function aliasDir(): string {
   return onPathBin ? dirname(onPathBin) : scriptDir();
 }
 
+/** PATH entries. `:` on POSIX, `;` on Windows, where `:` would split every
+ *  entry at its drive letter. */
+export function splitPathVar(pathVar: string, platform: NodeJS.Platform = process.platform): string[] {
+  return pathVar.split(pathApi(platform).delimiter).filter((p) => p !== "");
+}
+
 /** True when some PATH entry resolves (through symlinks) to `dir`. */
-export function onPath(dir: string, pathVar: string = process.env.PATH ?? ""): boolean {
+export function onPath(
+  dir: string,
+  pathVar: string = process.env.PATH ?? "",
+  platform: NodeJS.Platform = process.platform,
+): boolean {
   const want = realpathSync(dir);
-  return pathVar.split(":").some((p) => {
+  return splitPathVar(pathVar, platform).some((p) => {
     try {
-      return realpathSync(canon(p)) === want;
+      return samePath(realpathSync(canon(p, undefined, platform)), want, platform);
     } catch {
       return false;
     }
   });
 }
 
-/** Write a tiny shim `<cmd>` next to the claudep on PATH: `exec claudep run <name> -- "$@"`. */
-function writeAlias(name: string, cmd: string): void {
+export type AliasKind = "sh" | "cmd";
+
+/** The shim text. Both say "generated by claudep" and ` run <name> -- ` so
+ *  `claudep rm` can find them. */
+export function aliasShim(kind: AliasKind, self: string, name: string): string {
+  if (kind === "cmd")
+    return `@echo off\r\nREM generated by claudep. Runs Claude Code under the "${name}" profile\r\nbun "${self}" run ${name} -- %*\r\n`;
+  return `#!/bin/sh\n# generated by claudep. Runs Claude Code under the "${name}" profile\nexec bun "${self}" run ${name} -- "$@"\n`;
+}
+
+/** Where the shims for `<cmd>` go. One sh file on POSIX. On Windows a .cmd
+ *  file, which PowerShell finds through PATHEXT, plus the sh file for Git Bash. */
+export function aliasFiles(
+  dir: string,
+  cmd: string,
+  platform: NodeJS.Platform = process.platform,
+): { path: string; kind: AliasKind }[] {
+  const P = pathApi(platform);
+  const sh = { path: P.join(dir, cmd), kind: "sh" as const };
+  if (platform !== "win32") return [sh];
+  return [{ path: P.join(dir, `${cmd}.cmd`), kind: "cmd" as const }, sh];
+}
+
+/** Write the shim(s) for `<cmd>` next to the claudep on PATH: `claudep run <name> -- "$@"`. */
+function writeAlias(L: Layout, name: string, cmd: string): void {
   if (!NAME_RE.test(cmd)) die(`invalid alias command name "${cmd}"`);
-  const dest = join(aliasDir(), cmd);
   const self = realpathSync(Bun.main);
-  if (existsSync(dest)) {
-    const current = Bun.file(dest);
-    if (!lstatSync(dest).isSymbolicLink() && current.size > 0) {
-      warn(`${dest} already exists. Not overwriting; remove it first to regenerate`);
-      return;
+  for (const { path: dest, kind } of aliasFiles(aliasDir(), cmd, L.platform)) {
+    if (existsSync(dest)) {
+      const current = Bun.file(dest);
+      if (!lstatSync(dest).isSymbolicLink() && current.size > 0) {
+        warn(`${dest} already exists. Not overwriting; remove it first to regenerate`);
+        continue;
+      }
     }
+    writeFileSync(dest, aliasShim(kind, self, name));
+    if (kind === "sh") chmodSync(dest, 0o755);
+    ok(`alias ${c.bold(cmd)} → profile ${name} (${dest})`);
   }
-  const shim = `#!/bin/sh\n# generated by claudep. Runs Claude Code under the "${name}" profile\nexec bun "${self}" run ${name} -- "$@"\n`;
-  writeFileSync(dest, shim);
-  chmodSync(dest, 0o755);
-  ok(`alias ${c.bold(cmd)} → profile ${name} (${dest})`);
-  if (!onPath(aliasDir())) warn(`${aliasDir()} is not on your PATH`);
+  if (!onPath(aliasDir(), undefined, L.platform)) warn(`${aliasDir()} is not on your PATH`);
 }
 
 async function cmdAlias(L: Layout, args: string[]): Promise<void> {
   const [name, cmd] = args;
   if (!name || !cmd) die("usage: claudep alias <profile> <command>   e.g. claudep alias enterprise eclaude");
   if (!profileExists(L, name)) die(`profile "${name}" does not exist. Run: claudep init ${name}`);
-  writeAlias(name, cmd);
+  writeAlias(L, name, cmd);
 }
 
 async function cmdRun(L: Layout, args: string[]): Promise<never> {
@@ -635,7 +929,7 @@ async function collectRows(L: Layout, names: string[]): Promise<Row[]> {
   );
 }
 
-export function formatTable(rows: Row[], home: string): string[] {
+export function formatTable(rows: Row[], home: string, platform: NodeJS.Platform = process.platform): string[] {
   const cols = ["PROFILE", "LOGIN", "EMAIL", "ORG", "PLAN", "DIR"];
   const data = rows.map((r) => [
     r.name,
@@ -643,15 +937,15 @@ export function formatTable(rows: Row[], home: string): string[] {
     r.status.email ?? "-",
     r.status.orgName ?? "-",
     r.status.subscriptionType ?? "-",
-    r.dir.startsWith(home) ? `~${r.dir.slice(home.length)}` : r.dir,
+    shortHome(r.dir, home, platform),
   ]);
   const widths = cols.map((h, i) => Math.max(h.length, ...data.map((d) => (d[i] as string).length)));
   const fmt = (cells: string[]) => cells.map((v, i) => v.padEnd(widths[i] as number)).join("  ");
   return [fmt(cols), ...data.map((d) => fmt(d))];
 }
 
-function printTable(rows: Row[], home: string): void {
-  const [header, ...lines] = formatTable(rows, home);
+function printTable(rows: Row[], home: string, platform: NodeJS.Platform): void {
+  const [header, ...lines] = formatTable(rows, home, platform);
   console.log(c.bold(header as string));
   lines.forEach((line, i) => {
     console.log(rows[i]?.status.loggedIn ? line : c.dim(line));
@@ -660,7 +954,7 @@ function printTable(rows: Row[], home: string): void {
 
 async function cmdList(L: Layout): Promise<void> {
   const names = ["default", ...listProfileNames(L)];
-  printTable(await collectRows(L, names), L.home);
+  printTable(await collectRows(L, names), L.home, L.platform);
   if (names.length === 1) console.log(c.dim("\nNo profiles yet. Create one: claudep init <name>"));
   const cur = currentProfile(L);
   if (cur.kind !== "base") console.log(c.dim(`\nactive in this shell: ${describeCurrent(cur)}`));
@@ -674,21 +968,25 @@ async function cmdStatus(L: Layout, args: string[]): Promise<void> {
   const [row] = await collectRows(L, [name]);
   if (!row) return;
   if (f.bools.has("--json")) console.log(JSON.stringify({ name: row.name, dir: row.dir, ...row.status }, null, 2));
-  else printTable([row], L.home);
+  else printTable([row], L.home, L.platform);
 }
 
 function cmdEnv(L: Layout, args: string[]): void {
   const name = args[0];
-  if (!name) die('usage: eval "$(claudep env <name>)"   or   eval "$(claudep env --unset)"');
+  const syntax = shellSyntax(process.env, L.platform);
+  if (!name)
+    die(
+      syntax === "powershell"
+        ? "usage: claudep env <name> | Invoke-Expression   or   claudep env --unset | Invoke-Expression"
+        : 'usage: eval "$(claudep env <name>)"   or   eval "$(claudep env --unset)"',
+    );
   if (name === "--unset") {
-    console.log("unset CLAUDE_CONFIG_DIR CLAUDEP_AUTO");
+    process.stdout.write(envScript(undefined, syntax));
     return;
   }
   const dir = profileDir(L, name);
   if (!existsSync(dir)) die(`profile "${name}" does not exist`);
-  // Clearing CLAUDEP_AUTO turns this into a manual pin the shell hook will not touch.
-  console.log(`export CLAUDE_CONFIG_DIR='${dir.replace(/'/g, `'\\''`)}'`);
-  console.log("unset CLAUDEP_AUTO");
+  process.stdout.write(envScript(dir, syntax));
 }
 
 function describeCurrent(cur: Current): string {
@@ -697,10 +995,6 @@ function describeCurrent(cur: Current): string {
   return `${label} (${how})`;
 }
 
-function shortHome(p: string, home: string): string {
-  return p.startsWith(home) ? `~${p.slice(home.length)}` : p;
-}
-
 function cmdCurrent(L: Layout, args: string[]): void {
   const f = parseFlags(args, ["--json"], []);
   const cur = currentProfile(L);
@@ -710,16 +1004,18 @@ function cmdCurrent(L: Layout, args: string[]): void {
     return;
   }
   const label = cur.kind === "profile" ? (cur.name ?? "?") : cur.kind === "custom" ? "custom" : "default";
-  console.log(`${c.bold(label)}  ${c.dim(shortHome(cur.dir, L.home))}`);
+  console.log(`${c.bold(label)}  ${c.dim(shortHome(cur.dir, L.home, L.platform))}`);
   if (cur.setBy === "hook")
-    console.log(`set by: shell hook${pin ? ` (${PIN_FILE} in ${shortHome(pin.dir, L.home)})` : ""}`);
+    console.log(`set by: shell hook${pin ? ` (${PIN_FILE} in ${shortHome(pin.dir, L.home, L.platform)})` : ""}`);
   else if (cur.setBy === "manual") console.log("set by: manual pin (claudep env or export CLAUDE_CONFIG_DIR)");
   else console.log("set by: nothing pinned; this is ~/.claude");
   if (cur.kind === "custom") console.log(c.dim("CLAUDE_CONFIG_DIR points outside the claudep profiles root"));
+  const msysWarning = msysConfigDirWarning(L);
+  if (msysWarning) console.log(c.yellow(msysWarning));
   if (pin && pin.name !== "" && pin.name !== cur.name) {
     console.log(
       c.yellow(
-        `pinned here: ${pin.name} (${shortHome(pin.file, L.home)}), but this shell is on ${label}. Load the hook: eval "$(claudep shell-init zsh)"`,
+        `pinned here: ${pin.name} (${shortHome(pin.file, L.home, L.platform)}), but this shell is on ${label}. Load the hook: ${hookHint(defaultShell(process.env, L.platform))}`,
       ),
     );
   }
@@ -749,28 +1045,129 @@ function cmdLocal(L: Layout, args: string[]): void {
   if (!name) {
     const pin = resolvePin(process.cwd());
     if (!pin || pin.name === "") {
-      console.log(`no ${PIN_FILE} pin from ${shortHome(process.cwd(), L.home)} upward`);
+      console.log(`no ${PIN_FILE} pin from ${shortHome(process.cwd(), L.home, L.platform)} upward`);
       process.exit(1);
     }
-    console.log(`${pin.name}  ${c.dim(shortHome(pin.file, L.home))}`);
+    console.log(`${pin.name}  ${c.dim(shortHome(pin.file, L.home, L.platform))}`);
     return;
   }
   if (!NAME_RE.test(name)) die(`invalid profile name "${name}"`);
   if (!f.bools.has("--force") && !profileExists(L, name))
     die(`profile "${name}" does not exist. Run: claudep init ${name}   (or pass --force to pin it anyway)`);
   writeFileSync(file, `${name}\n`);
-  ok(`${shortHome(file, L.home)} pins this directory tree to ${c.bold(name)}`);
+  ok(`${shortHome(file, L.home, L.platform)} pins this directory tree to ${c.bold(name)}`);
   if (!process.env.CLAUDEP_AUTO && !process.env.CLAUDE_CONFIG_DIR)
-    console.log(c.dim(`Shells load pins through the hook: eval "$(claudep shell-init zsh)"`));
+    console.log(c.dim(`Shells load pins through the hook: ${hookHint(defaultShell(process.env, L.platform))}`));
 }
 
 /** 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 function shellInit(shell: "zsh" | "bash", profilesRoot: string): string {
+export type Shell = "zsh" | "bash" | "powershell";
+export const SHELLS: readonly Shell[] = ["zsh", "bash", "powershell"];
+
+/** 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 {
+  if (platform === "win32") return env.MSYSTEM ? "bash" : "powershell";
+  const name = env.SHELL ? posix.basename(env.SHELL) : "";
+  if (name === "zsh" || name === "bash") return name;
+  return platform === "darwin" ? "zsh" : "bash";
+}
+
+/** The one line that loads the hook in a shell's rc file. */
+export function hookHint(shell: Shell): string {
+  if (shell === "powershell") return "claudep shell-init powershell | Out-String | Invoke-Expression";
+  return `eval "$(claudep shell-init ${shell})"`;
+}
+
+export type EnvSyntax = "sh" | "powershell";
+
+/** What `claudep env` prints. PowerShell syntax only on Windows outside Git Bash. */
+export function shellSyntax(env: Env = process.env, platform: NodeJS.Platform = process.platform): EnvSyntax {
+  return platform === "win32" && !env.MSYSTEM ? "powershell" : "sh";
+}
+
+/** The `claudep env` script: pin the shell to `dir`, or clear the pin. */
+export function envScript(dir: string | undefined, syntax: EnvSyntax): string {
+  if (syntax === "powershell") {
+    if (dir === undefined) return "Remove-Item Env:CLAUDE_CONFIG_DIR, Env:CLAUDEP_AUTO -ErrorAction SilentlyContinue\n";
+    // Clearing CLAUDEP_AUTO turns this into a manual pin the shell hook will not touch.
+    return `$env:CLAUDE_CONFIG_DIR = '${dir.replace(/'/g, "''")}'\nRemove-Item Env:CLAUDEP_AUTO -ErrorAction SilentlyContinue\n`;
+  }
+  if (dir === undefined) return "unset CLAUDE_CONFIG_DIR CLAUDEP_AUTO\n";
+  return `export CLAUDE_CONFIG_DIR='${dir.replace(/'/g, `'\\''`)}'\nunset CLAUDEP_AUTO\n`;
+}
+
+export function shellInit(shell: Shell, profilesRoot: string, platform: NodeJS.Platform = process.platform): string {
+  return shell === "powershell" ? powershellHook(profilesRoot) : shHook(shell, profilesRoot, platform);
+}
+
+/** The PowerShell hook, for Windows PowerShell 5.1 and PowerShell 7. Wraps
+ *  `prompt` because there is no chpwd and LocationChangedAction is 7 only.
+ *  Cmdlets and builtins only, ASCII only, and every value it manages lives
+ *  in $global: because the profile dot-sources what Invoke-Expression ran.
+ *  The parent step is .NET GetDirectoryName: Split-Path cannot combine
+ *  -LiteralPath with -Parent, and -Path would expand wildcards. */
+function powershellHook(profilesRoot: string): string {
+  const q = profilesRoot.replace(/'/g, "''");
+  return `# claudep shell hook. Load it from your $PROFILE:  ${hookHint("powershell")}
+$global:_claudep_root = '${q}'
+function global:_claudep_auto {
+  $here = $ExecutionContext.SessionState.Path.CurrentFileSystemLocation.ProviderPath
+  if ($here -ceq $global:_claudep_last_pwd) { return }
+  $global:_claudep_last_pwd = $here
+  # Only manage a CLAUDE_CONFIG_DIR this hook set itself. A manual pin wins.
+  if ($env:CLAUDE_CONFIG_DIR -and ($env:CLAUDE_CONFIG_DIR -cne $env:CLAUDEP_AUTO)) { return }
+  $dir = $here
+  $name = ''
+  $found = ''
+  while ($true) {
+    $pin = Join-Path $dir '${PIN_FILE}'
+    if (Test-Path -LiteralPath $pin -PathType Leaf) {
+      $found = $dir
+      foreach ($line in @(Get-Content -LiteralPath $pin)) {
+        $t = ([string]$line).Trim()
+        if ($t -eq '' -or $t.StartsWith('#')) { continue }
+        $name = $t
+        break
+      }
+      break
+    }
+    $parent = [System.IO.Path]::GetDirectoryName($dir)
+    if (-not $parent -or ($parent -ceq $dir)) { break }
+    $dir = $parent
+  }
+  if ($name -eq '') {
+    # No pin here: hand the shell back to the base account.
+    if ($env:CLAUDEP_AUTO) { Remove-Item Env:CLAUDE_CONFIG_DIR, Env:CLAUDEP_AUTO -ErrorAction SilentlyContinue }
+    return
+  }
+  $target = Join-Path $global:_claudep_root $name
+  if (-not (Test-Path -LiteralPath $target -PathType Container)) {
+    if ($env:CLAUDEP_AUTO) { Remove-Item Env:CLAUDE_CONFIG_DIR, Env:CLAUDEP_AUTO -ErrorAction SilentlyContinue }
+    [Console]::Error.WriteLine('claudep: ' + (Join-Path $found '${PIN_FILE}') + ' names profile "' + $name + '", which does not exist. Run: claudep init ' + $name)
+    return
+  }
+  $env:CLAUDE_CONFIG_DIR = $target
+  $env:CLAUDEP_AUTO = $target
+}
+if (-not $global:_claudep_prompt_orig) {
+  $global:_claudep_prompt_orig = if (Test-Path Function:\\prompt) { $function:prompt } else { { 'PS> ' } }
+  function global:prompt { _claudep_auto; & $global:_claudep_prompt_orig }
+}
+_claudep_auto
+`;
+}
+
+function shHook(shell: "zsh" | "bash", profilesRoot: string, platform: NodeJS.Platform): string {
   const q = profilesRoot.replace(/'/g, `'\\''`);
+  // Under Git Bash $PWD is POSIX-style but the exported value must be the
+  // native path claude.exe reads, so the root and its separator are embedded
+  // as the native bun saw them and only the walk uses $PWD.
+  const sep = platform === "win32" ? "\\" : "/";
   const core = `# claudep shell hook. Load it from your rc file:  eval "$(claudep shell-init ${shell})"
 _claudep_root='${q}'
+_claudep_sep='${sep}'
 _claudep_auto() {
   [ "$PWD" = "\${_claudep_last_pwd:-}" ] && return 0
   _claudep_last_pwd="$PWD"
@@ -783,6 +1180,7 @@ _claudep_auto() {
     if [ -f "\${_claudep_dir%/}/${PIN_FILE}" ]; then
       _claudep_found="\${_claudep_dir:-/}"
       while read -r _claudep_line || [ -n "$_claudep_line" ]; do
+        _claudep_line="\${_claudep_line%$'\\r'}"
         case "$_claudep_line" in "" | "#"*) continue ;; esac
         _claudep_name="$_claudep_line"
         break
@@ -797,12 +1195,12 @@ _claudep_auto() {
     [ -n "\${CLAUDEP_AUTO:-}" ] && unset CLAUDE_CONFIG_DIR CLAUDEP_AUTO
     return 0
   fi
-  if [ ! -d "$_claudep_root/$_claudep_name" ]; then
+  if [ ! -d "$_claudep_root$_claudep_sep$_claudep_name" ]; then
     [ -n "\${CLAUDEP_AUTO:-}" ] && unset CLAUDE_CONFIG_DIR CLAUDEP_AUTO
     printf 'claudep: %s/${PIN_FILE} names profile "%s", which does not exist. Run: claudep init %s\\n' "$_claudep_found" "$_claudep_name" "$_claudep_name" >&2
     return 0
   fi
-  export CLAUDE_CONFIG_DIR="$_claudep_root/$_claudep_name" CLAUDEP_AUTO="$_claudep_root/$_claudep_name"
+  export CLAUDE_CONFIG_DIR="$_claudep_root$_claudep_sep$_claudep_name" CLAUDEP_AUTO="$_claudep_root$_claudep_sep$_claudep_name"
 }
 `;
   const tail =
@@ -818,19 +1216,33 @@ _claudep_auto
 }
 
 function cmdShellInit(L: Layout, args: string[]): void {
-  const shell = args[0] ?? "zsh";
-  if (shell !== "zsh" && shell !== "bash") die(`unsupported shell "${shell}". Use zsh or bash`);
-  process.stdout.write(shellInit(shell, L.profilesRoot));
+  const shell = args[0] ?? defaultShell(process.env, L.platform);
+  if (!SHELLS.includes(shell as Shell)) die(`unsupported shell "${shell}". Use zsh, bash or powershell`);
+  process.stdout.write(shellInit(shell as Shell, L.profilesRoot, L.platform));
+}
+
+/** 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;
+  if (L.platform !== "win32" || !cfg || !isMsysPath(cfg)) return undefined;
+  return `CLAUDE_CONFIG_DIR is a POSIX-style path (${cfg}); claude.exe will not read it. Set it with: eval "$(claudep env <name>)"`;
 }
 
 async function cmdDoctor(L: Layout, args: string[]): Promise<void> {
   const names = args[0] ? [args[0]] : listProfileNames(L);
-  const bin = Bun.which("claude");
-  if (bin) {
+  const launch = findClaude();
+  if (launch && launch.kind !== "ps1") {
     const { out } = await captureClaude(L, undefined, ["--version"]);
-    ok(`claude: ${bin} (${out.trim() || "version unknown"})`);
-  } else bad("claude binary not found on PATH");
+    ok(`claude: ${launch.bin} (${out.trim() || "version unknown"})`);
+    if (launch.kind === "cmd")
+      console.log(
+        `${c.dim("·")} claude is the npm cmd shim and runs through cmd.exe; the native installer's claude.exe avoids that hop`,
+      );
+  } else if (launch) bad(`only ${launch.bin} found; claudep needs claude.exe or claude.cmd`);
+  else bad("claude binary not found on PATH");
   ok(`base: ${L.base}${L.callerConfigDir && !L.managed ? c.yellow("  (from CLAUDE_CONFIG_DIR in your shell)") : ""}`);
+  const msysWarning = msysConfigDirWarning(L);
+  if (msysWarning) warn(msysWarning);
   ok(`profiles root: ${L.profilesRoot}`);
 
   const shared = sharedItems(L.base);
@@ -853,36 +1265,32 @@ async function cmdDoctor(L: Layout, args: string[]): Promise<void> {
       problems++;
       continue;
     }
+    let missing = 0;
     for (const item of shared) {
-      const dest = join(dir, item.name);
-      let st: ReturnType<typeof lstatSync> | undefined;
-      try {
-        st = lstatSync(dest);
-      } catch {
-        st = undefined;
-      }
-      if (!st) {
+      const state = linkState(L.base, dir, item);
+      if (state === "ok") continue;
+      problems++;
+      if (state === "missing") {
+        missing++;
         warn(`${item.name}: not linked (run: claudep init ${name})`);
-        problems++;
-      } else if (!st.isSymbolicLink()) {
-        warn(`${item.name}: real ${item.kind} shadows the shared one`);
-        problems++;
-      } else if (readlinkSync(dest) !== join(L.base, item.name)) {
-        bad(`${item.name}: symlink points elsewhere (${readlinkSync(dest)})`);
-        problems++;
-      } else if (!existsSync(dest)) {
-        bad(`${item.name}: broken symlink`);
-        problems++;
-      }
+      } else if (state === "shadowed") warn(`${item.name}: real ${item.kind} shadows the shared one`);
+      else if (state === "wrong-target")
+        bad(`${item.name}: symlink points elsewhere (${readlinkSync(join(dir, item.name))})`);
+      else bad(`${item.name}: broken symlink`);
     }
+    if (missing && L.platform === "win32")
+      console.log(
+        `${c.dim("·")} Windows creates symlinks only with Developer Mode on; claudep init ${name} says so when it is off`,
+      );
     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(", ")}`);
-    const svc = keychainService(dir);
-    const has = await keychainHas(svc);
-    if (has === undefined) console.log(`${c.dim("·")} keychain check skipped (not macOS)`);
-    else if (has) ok(`keychain item "${svc}" present`);
-    else warn(`no keychain item "${svc}". Not logged in yet (claudep ${name} auth login)`);
+    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 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");
@@ -901,7 +1309,11 @@ async function cmdRm(L: Layout, args: string[]): Promise<void> {
   const dir = profileDir(L, name);
   if (!existsSync(dir)) die(`profile "${name}" does not exist`);
   const real = realpathSync(dir);
-  if (!real.startsWith(`${realpathSync(L.profilesRoot)}/`) || real === realpathSync(L.base) || real === L.home)
+  if (
+    !isInside(realpathSync(L.profilesRoot), real, L.platform) ||
+    samePath(real, realpathSync(L.base), L.platform) ||
+    samePath(real, L.home, L.platform)
+  )
     die(`refusing to remove ${real}: not inside ${L.profilesRoot}`);
   if (!f.bools.has("--yes")) {
     const yes = confirm(`Remove profile "${name}" (${dir})? Shared items are only unlinked; ${L.base} is untouched.`);
@@ -911,15 +1323,16 @@ async function cmdRm(L: Layout, args: string[]): Promise<void> {
     }
   }
   if (!f.bools.has("--keep-login")) {
-    const proc = Bun.spawn([claudeBin(), "auth", "logout"], {
-      env: envFor(dir),
-      stdin: "inherit",
-      stdout: "inherit",
-      stderr: "inherit",
-    });
-    if ((await proc.exited) === 0) ok("logged out (token revoked, keychain item removed)");
+    const proc = spawnClaude(L, dir, ["auth", "logout"], "inherit");
+    if ((await proc.exited) === 0) ok("logged out (token revoked, credentials removed)");
     else warn("logout failed or was not logged in. Continuing");
   }
+  // Unlink the shared items first so no recursive delete ever looks through
+  // a symlink into the base, whatever the platform's rm does with them.
+  for (const entry of readdirSync(dir)) {
+    const p = join(dir, entry);
+    if (lstatSync(p).isSymbolicLink()) removeLink(p);
+  }
   rmSync(dir, { recursive: true, force: true });
   ok(`removed ${dir}`);
   const shims = aliasDir();
@@ -937,7 +1350,7 @@ async function cmdRm(L: Layout, args: string[]): Promise<void> {
 }
 
 function help(L: Layout): void {
-  const root = L.profilesRoot.startsWith(L.home) ? `~${L.profilesRoot.slice(L.home.length)}` : L.profilesRoot;
+  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
 
 ${c.bold("USAGE")}
@@ -946,7 +1359,7 @@ ${c.bold("USAGE")}
   claudep list                         show every profile and who it is logged in as
   claudep status <name> [--json]       login state for one profile ("default" = ~/.claude)
   claudep current [--json]             which profile this shell is on, and why
-  claudep env <name> | --unset         print "export CLAUDE_CONFIG_DIR=…" (or the unset) for eval
+  claudep env <name> | --unset         print the CLAUDE_CONFIG_DIR export (or the unset) for eval / Invoke-Expression
   claudep alias <name> <command>       write a shim so "<command>" == "claudep <name>"
   claudep doctor [name]                verify symlinks, keychain entry, unclassified files
   claudep rm <name> [--keep-login]     log out and delete a profile (base is never touched)
@@ -956,7 +1369,7 @@ ${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]        print the hook that applies pins on cd; eval it in your rc file
+  claudep shell-init [zsh|bash|powershell]   print the hook that applies pins on cd; load it from your rc file
 
 ${c.bold("INIT OPTIONS")}
   --sso               force the SSO login flow (Enterprise orgs)
@@ -973,8 +1386,10 @@ ${c.bold("EXAMPLES")}
   claude                                        # Claude Code as whatever ~/.claude is logged in as
   claudep enterprise -p "summarize this repo"
   eval "$(claudep env enterprise)"              # pin the whole shell to a profile
+  claudep env enterprise | Invoke-Expression    # the same from PowerShell
   claudep local enterprise                      # pin this repo; commit the ${PIN_FILE} file for the team
   eval "$(claudep shell-init zsh)"              # in .zshrc: shells follow ${PIN_FILE} pins on cd
+  ${hookHint("powershell")}   # the same line for $PROFILE
 
 ${c.bold("HOW IT WORKS")}
   ~/.claude stays exactly as it is and remains the "default" profile. Each named profile is a
@@ -983,9 +1398,10 @@ ${c.bold("HOW IT WORKS")}
     ${[...SHARED_FILES, "*.md", ...SHARED_DIRS].join("  ")}
   Everything account-specific is real and per profile: .claude.json (login identity, MCP
   servers, folder trust), org-pushed remote-settings.json, history, todos, caches.
-  Credentials never touch the profile dir: Claude Code stores them in the macOS Keychain under
+  On macOS credentials never touch the profile dir: Claude Code stores them in the Keychain under
   "Claude Code-credentials-<sha256(CLAUDE_CONFIG_DIR)[0:8]>", so every profile has its own
-  login and refresh token and they cannot clobber each other.
+  login and refresh token and they cannot clobber each other. On Linux and Windows the login is
+  <profile>/.credentials.json, a real file inside the profile that is never shared.
 
 ${c.bold("PIN RULES")}
   The nearest ${PIN_FILE} file upward from the current directory wins; an empty one cancels a

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bordoni/claudep",
-  "version": "0.1.1",
+  "version": "0.2.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",
@@ -38,7 +38,7 @@
     "access": "public"
   },
   "scripts": {
-    "test": "bun test --timeout 20000",
+    "test": "bun test --timeout 30000",
     "test:watch": "bun test --watch",
     "test:coverage": "bun test --coverage",
     "typecheck": "tsc --noEmit",