@bordoni/claudep 0.1.0 → 0.2.0

package/CHANGELOG.md

@@ -6,6 +6,36 @@ The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and
 
 ## [Unreleased]
 
+## [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
+
+- The 0.1.0 tarball on npm was published by hand from a commit that predates the notice that claudep is independent and not affiliated with Anthropic. This release is the same code with the notice in the README, in `claudep help` and in the package description.
+
 ## [0.1.0] - 2026-09-03
 
 ### Added
@@ -21,8 +51,11 @@ The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and
 - Directory pins: a `.claudep` file names the profile for a directory tree. `claudep local`, `claudep resolve` and `claudep shell-init zsh|bash` manage and apply pins; the hook only touches a `CLAUDE_CONFIG_DIR` it set itself.
 - `claudep --version`.
 - Published as `@bordoni/claudep` on npm and GitHub Packages; the installed command is `claudep`.
+- A clear notice in the README, in `claudep help` and in the package description that this is an independent tool with no affiliation to Anthropic.
 - 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/v0.1.0...HEAD
-[0.1.0]: https://github.com/bordoni/claudep/releases/tag/v0.1.0
+[Unreleased]: https://github.com/bordoni/claudep/compare/0.2.0...HEAD
+[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

@@ -12,6 +12,10 @@ eclaude          # Claude Code as the enterprise account
 claude           # Claude Code as whatever ~/.claude is logged in as
 ```
 
+## Not affiliated with Anthropic
+
+claudep is an independent, unofficial tool written by me, Gustavo Bordoni. I have no affiliation with Anthropic. Anthropic has not endorsed, sponsored, reviewed or supported this project in any way. "Claude" and "Claude Code" are Anthropic's names and trademarks and appear here only to describe what the tool works with. Use it at your own risk and under the terms of your own Claude account.
+
 ## Install
 
 Requires [bun](https://bun.sh) and an existing Claude Code install (`claude` on your PATH).
@@ -30,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
 
 ```
@@ -44,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
 ```
 
@@ -59,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.
@@ -84,7 +109,7 @@ From then on, `cd` into a pinned tree sets `CLAUDE_CONFIG_DIR` for that profile
 | `hooks/`, `skills/`, `commands/`, `agents/`, `plugins/`, `plans/` | `history.jsonl`, `todos/`, `sessions/`, caches, telemetry |
 | `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.
 
@@ -97,7 +122,7 @@ The shared list is an allowlist, so an account-specific file cannot leak across
 
 ## Releases
 
-Versions, dates and changes are in [`CHANGELOG.md`](./CHANGELOG.md). Releases are tagged `vX.Y.Z` and published to npm with provenance by GitHub Actions.
+Versions, dates and changes are in [`CHANGELOG.md`](./CHANGELOG.md). Releases are tagged with the bare version, `0.1.0`, and published to npm with provenance by GitHub Actions.
 
 ## Development
 

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 };
 }
@@ -196,6 +273,8 @@ 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",
@@ -266,11 +345,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 +388,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";
+
+/** 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. */
-export function link(base: string, dir: string, name: string, force: boolean): LinkResult {
-  const target = join(base, name);
-  const dest = join(dir, name);
+/** 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 +518,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 +635,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 +661,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 +767,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 +787,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 +815,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 +908,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 +916,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 +933,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 +947,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 +974,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 +983,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 +1024,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 +1159,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 +1174,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 +1195,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 +1244,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 +1288,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 +1302,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 +1329,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 +1338,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 +1348,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 +1365,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 +1377,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
@@ -996,6 +1391,8 @@ ${c.bold("PIN RULES")}
 ${c.bold("ENVIRONMENT")}
   CLAUDE_PROFILES_DIR   where profiles live (default ~/.claudep; keep it out of iCloud/Dropbox)
   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.")}
 `);
 }
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@bordoni/claudep",
-  "version": "0.1.0",
-  "description": "Run Claude Code under separate accounts on one machine (work + personal) with isolated logins and shared config.",
+  "version": "0.2.0",
+  "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",
   "author": "Gustavo Bordoni",
@@ -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",