cchost 0.1.3 → 0.2.1

package/README.md

@@ -16,13 +16,14 @@ Requires Node.js 18+ and Claude Code 2.1.140+ already installed. Get Claude Code
 
 | Command | What it does |
 | --- | --- |
-| `cc add <profile> [--email=] [--org=] [--name=]` | Create a profile directory. Optional alias flags (EXPERIMENTAL, see below). |
+| `cc add <profile>` | Create a profile directory. |
 | `cc use <profile> [...args]` | Launch Claude under that profile. Profile must already exist. Args after the name are forwarded verbatim to `claude`. |
-| `cc list [--original] [--json]` | Show every profile: login state, account email, and storage mode (`shared` / `isolated`). |
-| `cc migrate <src> <dest>` | Copy projects from `default`\|`shared` to `shared`\|`<profile>`. Skip-on-collision; credential files never copied. |
-| `cc link <profile> [<profile>...]` | Link a profile's `projects/` to `~/.claude-shared/projects`. Migrates existing content; renames on collision. |
-| `cc unlink <profile>` | Restore a profile to its own private `projects/` (copies shared content back). |
+| `cc list [--json]` | Show every profile: login state, account email, and how many artifact dirs are linked to shared (N/4). |
+| `cc migrate <src> <dest> [--force]` | Copy artifacts from `default`\|`shared` to `shared`\|`<profile>`. Skip-on-collision by default; `--force` overwrites. |
+| `cc link <profile> [<profile>...]` | Link a profile's artifact dirs to `~/.claude-shared/`. Migrates existing content; renames on collision. |
+| `cc unlink <profile>` | Restore a profile to its own private artifact dirs (copies shared content back). |
 | `cc remove <profile>` | Delete a profile. Requires typing the profile name to confirm. |
+| `cc doctor [--fix [--force]] [--json]` | Diagnose environment, storage, and platform issues. |
 | `cc help [command]` | Print usage (top-level, or for a single command). |
 
 ### Examples
@@ -39,58 +40,72 @@ cc remove old-profile
 `cc list` output:
 
 ```
-Profile   LoggedIn  Email                 Storage
-personal  true      personal@example.com  isolated
-scratch   false     -                     isolated
-work      true      work@example.com      shared
+Profile   LoggedIn  Email                 Shared
+personal  true      personal@example.com  4/4
+scratch   false     -                     0/4
+work      true      work@example.com      0/4
 ```
 
-### Migrating existing projects
+### What migrate copies and what link shares
 
-If you've been using Claude Code without profiles, your history lives in `~/.claude/projects/`. Pull it into a profile or the shared pool:
+| Artifact | `cc migrate` copies it | `cc link` shares it | Notes |
+| --- | :---: | :---: | --- |
+| `projects/` | ✓ | ✓ | Resumable conversation transcripts |
+| `skills/` | ✓ | ✓ | Custom slash-command scripts |
+| `agents/` | ✓ | ✓ | Custom agent definitions |
+| `commands/` | ✓ | ✓ | Custom command configs |
+| `mcp.json` | ✓ (default→profile only) | — | Per-profile MCP server config; may carry auth tokens |
+| `settings.json` | ✓ (default→profile only) | — | Per-profile UI/feature settings |
+| `CLAUDE.md` | ✓ (default→profile only) | — | Per-profile project instructions |
+| `sessions/` | — | — | Transient per-process state; sharing would corrupt bookkeeping |
+| `plugins/` | — | — | Carries auth tokens; deferred to a future opt-in flag |
+| `.credentials.json` | — | — | Never touched — each profile keeps its own auth |
+| `.claude.json` | — | — | Never touched — re-synced from server on every launch |
+
+`mcp.json`, `settings.json`, and `CLAUDE.md` are **not** copied to `shared` and are **not** linked because they typically carry auth tokens or per-profile configuration that should not leak across accounts.
+
+### Migrating existing artifacts
+
+If you've been using Claude Code without profiles, your history lives in `~/.claude/`. Pull it into a profile or the shared pool:
 
 ```bash
-cc migrate default work        # copy ~/.claude/projects → ~/.claude-profiles/work/projects
-cc migrate default shared      # copy ~/.claude/projects → ~/.claude-shared/projects
-cc migrate shared personal     # copy ~/.claude-shared/projects → ~/.claude-profiles/personal/projects
+cc migrate default work        # copy ~/.claude/* → ~/.claude-profiles/work/
+cc migrate default shared      # copy ~/.claude/projects,skills,agents,commands → ~/.claude-shared/
+cc migrate shared personal     # copy ~/.claude-shared/* → ~/.claude-profiles/personal/
+cc migrate default work --force  # same as first, overwriting anything that already exists
 ```
 
-This is a **copy** — the source is left untouched. If an entry already exists at the destination, the source entry is skipped (no overwrite). Credential files (`.credentials.json`, `.claude.json`) are never copied: each profile keeps its own auth state.
+This is a **copy** — the source is left untouched. By default, if an entry already exists at the destination it is silently skipped. Pass `--force` to overwrite instead — existing destination content will be cleared.
+
+Credential files (`.credentials.json`, `.claude.json`) are never copied: each profile keeps its own auth state.
 
-### Shared history across profiles
+### Shared artifacts across profiles
 
-If you want each profile to keep separate credentials but share project history (e.g. rotate accounts on the same project when usage limits hit):
+If you want each profile to keep separate credentials but share project history and skills (e.g. rotate accounts on the same project when usage limits hit):
 
 ```bash
 cc link work
 cc link personal
 ```
 
-`work/projects` and `personal/projects` become links to `~/.claude-shared/projects`. On Windows this uses directory junctions (no admin/Developer Mode required); on macOS/Linux, regular symlinks.
+`work/` and `personal/` each get four linked dirs (`projects`, `skills`, `agents`, `commands`) pointing to `~/.claude-shared/`. On Windows this uses directory junctions (no admin/Developer Mode required); on macOS/Linux, regular symlinks.
 
-**Only `projects/` is shared.** That's the directory Claude Code uses for resumable conversation transcripts (`projects/<project>/<session>.jsonl`). The sibling `sessions/` folder holds transient per-process registry state — PID, working directory, status, timestamps — and is **never** linked, migrated, or copied across profiles. Sharing it would corrupt Claude's running-process bookkeeping. `sessions/` stays per-profile under `~/.claude-profiles/<name>/sessions/`.
+`sessions/` is **never** linked. It holds transient per-process registry state — PID, working directory, status, timestamps — and sharing it would corrupt Claude's running-process bookkeeping. It stays per-profile under `~/.claude-profiles/<name>/sessions/`.
 
 `cc link a b c` links several profiles at once; per-profile failures are reported but don't abort the rest of the batch.
 
 If two profiles share history and you launch them against the same project at the same time, both will write to the same session files (last write wins). Don't do that.
 
-`cc remove` is safe with shared profiles — it deletes only the link, never recursing into the shared target.
-
-### Aliases (`cc add` flags) — EXPERIMENTAL
-
-`cc add work --email=work@example.com --org=Acme --name="Work Account"` stores those values in `~/.claude-profiles/work/.cc-alias.json`. On every `cc use`, they're written into the profile's `.claude.json` `oauthAccount` so `cc list` and Claude's own UI display them instead of the real underlying account.
-
-**EXPERIMENTAL.** Claude Code may overwrite `oauthAccount` on server re-sync; we re-apply on the next `cc use`, but masking across all of Claude's UI surfaces has not been verified. Use `cc list --original` to see the real values from `.claude.json`.
+`cc remove` is safe with shared profiles — it deletes only the links, never recursing into the shared target.
 
 ## How it works
 
 `cc` is a Node CLI with **zero runtime dependencies**. For `cc use` it:
 
 1. Resolves the profile directory under `~/.claude-profiles/<name>/`
-2. Applies any stored alias to `.claude.json` `oauthAccount` (best-effort)
-3. Sets `CLAUDE_CONFIG_DIR` in its **own** spawn environment
-4. Spawns `claude` with `stdio: 'inherit'` so the TUI works correctly
-5. Forwards the child's exit code
+2. Sets `CLAUDE_CONFIG_DIR` in its **own** spawn environment
+3. Spawns `claude` with `stdio: 'inherit'` so the TUI works correctly
+4. Forwards the child's exit code
 
 The env var is set on the child process only — that's all `claude` needs.
 

package/lib/cli.js

@@ -14,13 +14,14 @@ const color = require('./color');
 const HELP = `cc - Multi-profile launcher for Claude Code
 
 Usage:
-  cc add <profile> [--email=] [--org=] [--name=]   Create a profile (EXPERIMENTAL aliases)
+  cc add <profile>                                 Create a profile directory
   cc use <profile> [...args]                       Launch Claude under a named profile
-  cc list [--original] [--json]                    Show all profiles: login state, email, storage (shared/isolated)
-  cc migrate <src> <dest>                          Copy projects from default|shared to shared|<profile>
-  cc link <p>...                                   Replace each profile's projects/ with a link to shared
-  cc unlink <profile>                              Restore a profile's private projects/
+  cc list [--json]                                 Show all profiles: login state, email, shared-dir count (N/4)
+  cc migrate <src> <dest> [--force]                Copy artifact dirs (and config files) between profiles
+  cc link <p>...                                   Link each profile's artifact dirs to ~/.claude-shared/
+  cc unlink <profile>                              Restore a profile's private artifact dirs
   cc remove <profile>                              Delete a profile and all its data (typed confirmation)
+  cc doctor [--fix [--force]] [--json]             Diagnose environment, storage, and platform issues
   cc help [command]                                Show usage (optionally for a single command)
   cc --version                                     Print the installed cchost version
 
@@ -29,18 +30,13 @@ for that launch. Args after the profile name are forwarded verbatim to claude.
 `;
 
 const HELP_BY_CMD = {
-  add: `cc add <profile> [--email=...] [--org=...] [--name=...]
+  add: `cc add <profile>
 
-Create a new profile directory without launching Claude. Optional alias flags
-record account values shown in 'cc list' and written into the profile's
-.claude.json oauthAccount on subsequent 'cc use' launches.
-
-EXPERIMENTAL: Claude Code may overwrite these on server re-sync. Masking
-behavior across all UI surfaces has not been verified.
+Create a new profile directory without launching Claude.
 
 Examples:
   cc add work
-  cc add work --email=work@example.com --org=Acme --name="Work Account"
+  cc add personal
 `,
   use: `cc use <profile> [...args]
 
@@ -56,56 +52,70 @@ Examples:
   cc use work --resume
   cc use personal -p "summarize this codebase"
 `,
-  list: `cc list [--original] [--json]
+  list: `cc list [--json]
 
 Columns:
   Profile   - profile name
   LoggedIn  - true if .credentials.json exists
-  Email     - account email (alias-aware; - if not yet logged in)
-  Storage   - 'shared' if projects/ is linked to ~/.claude-shared, 'isolated' otherwise
+  Email     - account email from .claude.json; - if not yet logged in
+  Shared    - N/4 linked to ~/.claude-shared/ (projects, skills, agents, commands)
+              4/4 = fully shared, 0/4 = fully isolated
               (sessions/ is transient per-process state and is never shared)
 
-By default, the displayed email reflects any alias set via 'cc add'.
-With --original, shows the real value from .claude.json.
-
-With --json, emits an array of {name, dir, loggedIn, email, storage, alias}.
+With --json, emits an array of {name, dir, loggedIn, email, shared}.
 `,
-  migrate: `cc migrate <src> <dest>
+  migrate: `cc migrate <src> <dest> [--force]
 
-Copy projects/ from a source to a destination. sessions/ (transient per-process
-registry state) is never migrated. This is a COPY — the source is left untouched.
+Copy artifact directories from a source to a destination. This is a COPY — the
+source is left untouched. sessions/ is never migrated (transient per-process state).
 
   <src>:   default | shared
            default = ~/.claude/        (Claude's built-in non-profile data)
            shared  = ~/.claude-shared/ (the cc shared pool)
   <dest>:  shared | <profile-name>
 
-On collisions, existing entries at the destination are left alone (the source
-entry is skipped). Credential files (.credentials.json, .claude.json) are
-never copied — the destination keeps its own auth state.
+Directories copied in all cases:
+  projects/, skills/, agents/, commands/
+
+Extra files copied only when src=default and dest=<profile>:
+  mcp.json, settings.json, CLAUDE.md
+  (These carry per-profile config and are NOT copied to shared.)
+
+Never copied: .credentials.json, .claude.json, sessions/, plugins/
+
+Collision behavior (default): existing entries at the destination are silently
+skipped — the source entry is left alone.
+
+--force  Overwrite existing entries instead of skipping.
+         Warning: existing content at the destination will be cleared.
 
 Examples:
-  cc migrate default work     # ~/.claude/projects -> ~/.claude-profiles/work/projects
-  cc migrate default shared   # ~/.claude/projects -> ~/.claude-shared/projects
-  cc migrate shared work      # ~/.claude-shared/projects -> ~/.claude-profiles/work/projects
+  cc migrate default work            # copy ~/.claude/* to ~/.claude-profiles/work/
+  cc migrate default shared          # copy dirs to ~/.claude-shared/
+  cc migrate shared work             # copy shared dirs to ~/.claude-profiles/work/
+  cc migrate default work --force    # same, overwriting any existing items
 `,
   link: `cc link <profile> [<profile>...]
 
-Replace each profile's projects/ with a link to ~/.claude-shared/projects/.
-Existing content is migrated into shared first; collisions are renamed with a
-__<profile> suffix (never overwritten). sessions/ (transient per-process state)
-is intentionally never linked — it stays per-profile.
+Replace each profile's artifact directories with links to ~/.claude-shared/:
+  projects/, skills/, agents/, commands/
+
+Existing content in each directory is migrated into shared first; collisions
+are renamed with a __<profile> suffix (never overwritten). sessions/ (transient
+per-process state) is intentionally never linked — it stays per-profile.
 
 On Windows, link uses directory junctions (no admin/Developer Mode needed).
 On macOS/Linux, regular symlinks.
 
-Multiple profiles can be linked at once: 'cc link a b c'. Per-profile failures
-are reported but don't abort the rest of the batch.
+Multiple profiles can be linked at once: 'cc link a b c'. Failures are handled
+per directory and per profile: one directory failing does not stop the other
+three, and one profile failing does not stop the rest of the batch. A
+per-directory summary is printed; exit code is 1 if anything failed.
 `,
   unlink: `cc unlink <profile>
 
-Remove a profile's projects/ link to ~/.claude-shared/ and copy shared content
-back into the profile as a private dir.
+Remove each linked artifact directory (projects/, skills/, agents/, commands/)
+and copy the shared content back into the profile as private dirs.
 `,
   remove: `cc remove <profile>
 
@@ -115,6 +125,21 @@ name — y/n is intentionally not accepted because credential loss is unrecovera
 
 If the profile's projects/ is a link to ~/.claude-shared/, only the link is
 removed — the shared target is preserved.
+`,
+  doctor: `cc doctor [--fix [--force]] [--json]
+
+Run diagnostic checks across four groups:
+
+  Environment  Node >=18, claude on PATH, claude >=2.1.140, no conflicting env vars, no cc shadow
+  Storage      ~/.claude-profiles/ writable, .claude.json parseable, junctions/symlinks valid
+  Platform     Windows: OneDrive home, WindowsApps stub, stale ~/bin/cc; Git Bash: cygpath
+  Sanity       Test-spawn claude --version through the same code path cc use uses
+
+Exit codes: 0 = all ok, 1 = warnings, 2 = errors.
+
+--fix           Auto-apply safe fixes: create missing dirs, recreate broken junctions
+--fix --force   Also apply confirmation-required fixes (e.g. reset a corrupt .claude.json)
+--json          Machine-readable output for CI / scripting
 `,
   help: `cc help [command]
 
@@ -206,41 +231,12 @@ function parseFlagsStrict(args, flagNames, { allowPositional = false } = {}) {
   return { flags, positional };
 }
 
-function parseAliasFlags(args) {
-  const out = {};
-  for (const a of args) {
-    if (!a.startsWith('--')) {
-      throw usageError(`Unexpected positional argument: ${a}`);
-    }
-    const eq = a.indexOf('=');
-    if (eq === -1) {
-      throw usageError(`Flag must be in --key=value form: ${a}`);
-    }
-    const key = a.slice(2, eq);
-    const value = a.slice(eq + 1);
-    if (!profiles.ALLOWED_ALIAS_KEYS.includes(key)) {
-      throw usageError(`Unknown flag: --${key}. Allowed: --email, --org, --name.`);
-    }
-    if (value.length === 0) {
-      throw usageError(`Flag --${key} requires a non-empty value.`);
-    }
-    out[key] = value;
-  }
-  return out;
-}
-
 async function cmdAdd(rest) {
-  const [name, ...flagArgs] = rest;
-  if (!name) throw usageError('Usage: cc add <profile> [--email=...] [--org=...] [--name=...]');
-  const aliasFlags = parseAliasFlags(flagArgs);
-  const { dir } = profiles.addProfile(name, aliasFlags);
+  const [name, ...extra] = rest;
+  if (!name) throw usageError('Usage: cc add <profile>');
+  if (extra.length > 0) throw usageError(`cc add takes no extra arguments: ${extra[0]}`);
+  const { dir } = profiles.addProfile(name);
   console.log(`Created profile "${name}" at ${dir}.`);
-  if (Object.keys(aliasFlags).length > 0) {
-    process.stderr.write(
-      color.stderr.yellow('Aliases are EXPERIMENTAL — Claude may overwrite them on server re-sync.') + '\n'
-    );
-    console.log(`  Stored aliases: ${JSON.stringify(aliasFlags)}`);
-  }
   console.log(`Next: cc use ${name}`);
   return 0;
 }
@@ -255,33 +251,24 @@ async function cmdUse(rest) {
     err.exitCode = 1;
     throw err;
   }
-  try {
-    profiles.applyAlias(dir);
-  } catch {
-    // best-effort; never block the launch
-  }
-  return spawnClaude({
-    args: passthrough,
-    profileDir: dir,
-  });
+  return spawnClaude({ args: passthrough, profileDir: dir });
 }
 
 function cmdList(rest) {
-  const { flags } = parseFlagsStrict(rest, ['--json', '--original']);
+  const { flags } = parseFlagsStrict(rest, ['--json']);
   const list = profiles.listProfiles();
-  const useOriginal = flags.has('--original');
+  const total = share.SHARED_SUBDIRS.length;
 
   const enriched = list.map((p) => {
-    const alias = p.alias || {};
-    const displayEmail = useOriginal ? p.email : (alias.email || p.email);
-    const storage = isLinkLike(path.join(p.dir, 'projects')) ? 'shared' : 'isolated';
+    const sharedCount = share.SHARED_SUBDIRS.filter(sub =>
+      isLinkLike(path.join(p.dir, sub))
+    ).length;
     return {
       name: p.name,
       dir: p.dir,
       loggedIn: p.loggedIn,
-      email: displayEmail,
-      storage,
-      alias,
+      email: p.email,
+      shared: sharedCount,
     };
   });
 
@@ -296,13 +283,13 @@ function cmdList(rest) {
     return 0;
   }
 
-  const rows = [['Profile', 'LoggedIn', 'Email', 'Storage']];
+  const rows = [['Profile', 'LoggedIn', 'Email', 'Shared']];
   for (const p of enriched) {
     rows.push([
       p.name,
       p.loggedIn ? 'true' : 'false',
       p.email ? p.email : '-',
-      p.storage,
+      `${p.shared}/${total}`,
     ]);
   }
   console.log(renderTable(rows));
@@ -344,36 +331,89 @@ async function cmdRemove(rest) {
 
 async function cmdLink(rest) {
   if (rest.length === 0) throw usageError('Usage: cc link <profile> [<profile>...]');
-  const failures = [];
+  const multi = rest.length > 1;
+  const summary = [];
   for (const name of rest) {
-    if (rest.length > 1) console.log(`\n[${name}]`);
+    if (multi) console.log(`\n[${name}]`);
+    let results;
     try {
-      share.shareLink(name);
+      results = share.shareLink(name);
     } catch (err) {
+      // Profile-level failure (invalid name, profile missing) — nothing linked.
       process.stderr.write(color.stderr.red(`  error: ${err.message}`) + '\n');
-      failures.push({ name, message: err.message });
+      summary.push({ name, linked: 0, total: share.SHARED_SUBDIRS.length, error: err.message });
+      continue;
+    }
+    for (const r of results) {
+      if (r.status === 'failed') {
+        process.stderr.write(color.stderr.red(`  ${r.sub}: failed — ${r.message}`) + '\n');
+      } else if (r.status === 'already-linked') {
+        console.log(`  ${r.sub}: already linked`);
+      } else {
+        const note = r.moved ? ` (migrated ${r.moved} item(s) into shared)` : '';
+        console.log(`  ${r.sub}: linked${note}`);
+      }
     }
+    const failed = results.filter((r) => r.status === 'failed');
+    const linked = results.length - failed.length;
+    console.log(`  ${linked}/${results.length} directories linked${failed.length ? `, ${failed.length} failed` : ''}.`);
+    summary.push({ name, linked, total: results.length, failed: failed.map((f) => f.sub) });
   }
-  if (rest.length > 1) {
-    const ok = rest.length - failures.length;
-    console.log(`\nSummary: ${ok} succeeded, ${failures.length} failed.`);
-    for (const f of failures) console.log(`  ${f.name}: ${f.message}`);
+
+  const anyFailure = summary.some((s) => s.error || (s.failed && s.failed.length));
+  if (multi) {
+    console.log('\nSummary:');
+    for (const s of summary) {
+      if (s.error) {
+        console.log(`  ${s.name}: error — ${s.error}`);
+      } else if (s.failed && s.failed.length) {
+        console.log(`  ${s.name}: ${s.linked}/${s.total} linked (failed: ${s.failed.join(', ')})`);
+      } else {
+        console.log(`  ${s.name}: ${s.linked}/${s.total} linked`);
+      }
+    }
   }
-  return failures.length === 0 ? 0 : 1;
+  return anyFailure ? 1 : 0;
 }
 
 async function cmdUnlink(rest) {
   const [name] = rest;
   if (!name) throw usageError('Usage: cc unlink <profile>');
-  share.shareUnlink(name);
-  return 0;
+  const results = share.shareUnlink(name);
+  let anyFailure = false;
+  for (const r of results) {
+    if (r.status === 'failed') {
+      anyFailure = true;
+      process.stderr.write(color.stderr.red(`  ${r.sub}: failed — ${r.message}`) + '\n');
+    } else if (r.status === 'not-linked') {
+      console.log(`  ${r.sub}: not linked, skipping`);
+    } else {
+      console.log(`  ${r.sub}: unlinked, content copied back`);
+    }
+  }
+  return anyFailure ? 1 : 0;
+}
+
+async function cmdDoctor(rest) {
+  const { flags } = parseFlagsStrict(rest, ['--fix', '--force', '--json']);
+  const fix = flags.has('--fix');
+  const force = flags.has('--force');
+  if (force && !fix) throw usageError('--force requires --fix');
+  const json = flags.has('--json');
+  const doctor = require('./doctor');
+  return doctor.runDoctor({ fix, force, json, prompt });
 }
 
 async function cmdMigrate(rest) {
-  const [src, dest, ...extra] = rest;
-  if (!src || !dest) throw usageError('Usage: cc migrate <src> <dest>');
+  const { flags, positional } = parseFlagsStrict(rest, ['--force'], { allowPositional: true });
+  const [src, dest, ...extra] = positional;
+  if (!src || !dest) throw usageError('Usage: cc migrate <src> <dest> [--force]');
   if (extra.length > 0) throw usageError(`Unexpected extra arguments: ${extra.join(' ')}`);
-  migrateLib.migrate(src, dest);
+  const force = flags.has('--force');
+  if (force) {
+    process.stdout.write('Warning: --force is set. Existing items at the destination will be overwritten and their current content will be cleared.\n');
+  }
+  migrateLib.migrate(src, dest, { force });
   return 0;
 }
 
@@ -407,6 +447,8 @@ async function run(argv) {
       return await cmdUnlink(rest);
     case 'remove':
       return await cmdRemove(rest);
+    case 'doctor':
+      return await cmdDoctor(rest);
     default: {
       process.stderr.write(color.stderr.red(`Unknown command: ${action}`) + '\n\n');
       printHelp();

package/lib/doctor.js

@@ -0,0 +1,375 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const profiles = require('./profiles');
+const { findClaude, getClaudeVersion, compareVersion, MIN_VERSION } = require('./spawn');
+const color = require('./color');
+
+const GROUP_ORDER = ['Environment', 'Storage', 'Platform', 'Sanity'];
+
+// fix: { safe, description, cmd, apply }
+//   safe=true  → auto-applied by --fix
+//   safe=false → needs --fix --force, prompted y/n
+//   cmd        → printed when fix cannot be auto-applied
+//   apply      → async fn to execute
+
+function mk(group, name, status, message, fix) {
+  return { group, name, status, message, fix: fix || null };
+}
+
+// --- Environment ---
+
+function checkNodeVersion() {
+  const v = `v${process.versions.node}`;
+  if (parseInt(process.versions.node.split('.')[0], 10) >= 18) {
+    return mk('Environment', 'Node.js version', 'ok', `${v} (>=18)`);
+  }
+  return mk('Environment', 'Node.js version', 'error', `${v} — requires >=18`, {
+    safe: false, description: 'Install Node.js 18+', cmd: 'https://nodejs.org', apply: null,
+  });
+}
+
+function checkClaudeOnPath() {
+  const bin = findClaude();
+  if (bin) return mk('Environment', 'claude on PATH', 'ok', bin);
+  return mk('Environment', 'claude on PATH', 'error', 'not found', {
+    safe: false,
+    description: 'Install Claude Code',
+    cmd: 'npm install -g @anthropic-ai/claude-code',
+    apply: null,
+  });
+}
+
+function checkClaudeVersion() {
+  const bin = findClaude();
+  if (!bin) return null;
+  const v = getClaudeVersion(bin);
+  const minStr = MIN_VERSION.join('.');
+  if (!v) {
+    return mk('Environment', 'claude version', 'warn', 'could not determine', {
+      safe: false, description: 'Update Claude Code', cmd: 'claude update', apply: null,
+    });
+  }
+  if (compareVersion(v, MIN_VERSION) >= 0) return mk('Environment', 'claude version', 'ok', `${v.raw} (>=${minStr})`);
+  return mk('Environment', 'claude version', 'warn', `${v.raw} < ${minStr} — CLAUDE_CONFIG_DIR isolation unreliable`, {
+    safe: false, description: 'Update Claude Code', cmd: 'claude update', apply: null,
+  });
+}
+
+const CONFLICT_VARS = ['ANTHROPIC_API_KEY', 'ANTHROPIC_AUTH_TOKEN', 'CLAUDE_CODE_OAUTH_TOKEN'];
+
+function checkConflictingEnv() {
+  const set = CONFLICT_VARS.filter(k => process.env[k]);
+  if (set.length === 0) return mk('Environment', 'conflicting env vars', 'ok', 'none set');
+  const cmd = process.platform === 'win32'
+    ? set.map(k => `Remove-Item Env:${k}`).join('; ')
+    : set.map(k => `unset ${k}`).join('; ');
+  return mk('Environment', 'conflicting env vars', 'warn', `set: ${set.join(', ')}`, {
+    safe: false, description: 'Unset to avoid auth interference with cc use', cmd, apply: null,
+  });
+}
+
+function findAllOnPath(name) {
+  const PATH = process.env.PATH || process.env.Path || '';
+  const sep = process.platform === 'win32' ? ';' : ':';
+  const exts = process.platform === 'win32'
+    ? (process.env.PATHEXT || '.COM;.EXE;.BAT;.CMD').split(';').map(s => s.trim()).filter(Boolean)
+    : [''];
+  const found = [];
+  const seen = new Set();
+  for (const dir of PATH.split(sep).filter(Boolean)) {
+    for (const ext of exts) {
+      try {
+        const full = path.join(dir, name + ext);
+        if (fs.statSync(full).isFile()) {
+          const key = process.platform === 'win32' ? full.toLowerCase() : full;
+          if (!seen.has(key)) { seen.add(key); found.push(full); }
+          break;
+        }
+      } catch { /* skip */ }
+    }
+  }
+  return found;
+}
+
+function checkCcShadow() {
+  const all = findAllOnPath('cc');
+  if (all.length <= 1) {
+    return mk('Environment', 'cc on PATH', 'ok', all[0] || 'not found yet (expected after npm install -g)');
+  }
+  return mk('Environment', 'cc on PATH', 'warn', `multiple: ${all.join(', ')}`, {
+    safe: false, description: 'Remove duplicate cc entries to avoid version confusion', cmd: null, apply: null,
+  });
+}
+
+// --- Storage ---
+
+function checkProfilesDirWritable() {
+  const base = profiles.baseDir();
+  if (!fs.existsSync(base)) {
+    return mk('Storage', '~/.claude-profiles/', 'warn', 'does not exist', {
+      safe: true,
+      description: `Create ${base}`,
+      cmd: null,
+      apply: async () => {
+        fs.mkdirSync(base, { recursive: true });
+        process.stdout.write(`  Created ${base}\n`);
+      },
+    });
+  }
+  try {
+    fs.accessSync(base, fs.constants.W_OK);
+    return mk('Storage', '~/.claude-profiles/', 'ok', 'writable');
+  } catch {
+    const cmd = process.platform === 'win32'
+      ? `icacls "${base}" /grant "%USERNAME%:F"`
+      : `chmod u+w "${base}"`;
+    return mk('Storage', '~/.claude-profiles/', 'error', `not writable: ${base}`, {
+      safe: false, description: 'Fix directory permissions', cmd, apply: null,
+    });
+  }
+}
+
+function checkProfileClaudeJson(prof) {
+  const p = path.join(prof.dir, '.claude.json');
+  if (!fs.existsSync(p)) return mk('Storage', `"${prof.name}" .claude.json`, 'ok', 'not yet logged in');
+  try {
+    const raw = fs.readFileSync(p, 'utf8');
+    if (raw.trim()) JSON.parse(raw);
+    return mk('Storage', `"${prof.name}" .claude.json`, 'ok', 'valid JSON');
+  } catch (e) {
+    return mk('Storage', `"${prof.name}" .claude.json`, 'error', `parse error: ${e.message}`, {
+      safe: false,
+      description: `Back up ${path.basename(p)} and reset to {}`,
+      cmd: null,
+      apply: async () => {
+        const bak = `${p}.bak.${Date.now()}`;
+        fs.renameSync(p, bak);
+        fs.writeFileSync(p, '{}');
+        process.stdout.write(`  Backed up to ${path.basename(bak)}, reset to {}\n`);
+      },
+    });
+  }
+}
+
+function checkProfileLinks(prof) {
+  const results = [];
+  const pp = path.join(prof.dir, 'projects');
+  let isLinkNode = false;
+  try { isLinkNode = fs.lstatSync(pp).isSymbolicLink(); } catch { return results; }
+  if (!isLinkNode) return results;
+
+  try {
+    fs.statSync(pp);
+    results.push(mk('Storage', `"${prof.name}" projects/ link`, 'ok', 'valid'));
+    return results;
+  } catch { /* broken */ }
+
+  const expected = path.join(profiles.sharedDir(), 'projects');
+  const targetExists = fs.existsSync(expected);
+  results.push(mk('Storage', `"${prof.name}" projects/ link`, 'error', 'broken — target missing', {
+    safe: targetExists,
+    description: targetExists ? `Recreate junction/symlink to ${expected}` : 'Target missing',
+    cmd: targetExists ? null : `cc link ${prof.name}`,
+    apply: targetExists ? async () => {
+      try { fs.unlinkSync(pp); } catch { try { fs.rmdirSync(pp); } catch { /* ignore */ } }
+      fs.symlinkSync(expected, pp, process.platform === 'win32' ? 'junction' : 'dir');
+      process.stdout.write(`  Recreated: ${pp} -> ${expected}\n`);
+    } : null,
+  }));
+  return results;
+}
+
+// --- Platform ---
+
+function checkOneDrive() {
+  if (process.platform !== 'win32') return null;
+  if (/onedrive/i.test(os.homedir()) || /onedrive/i.test(process.env.USERPROFILE || '')) {
+    return mk('Platform', 'OneDrive home folder', 'warn',
+      'home is OneDrive-synced — can corrupt directory junctions', {
+      safe: false, description: 'Exclude ~/.claude-profiles from OneDrive sync', cmd: null, apply: null,
+    });
+  }
+  return mk('Platform', 'OneDrive home folder', 'ok', 'not OneDrive-redirected');
+}
+
+function checkWindowsAppsCc() {
+  if (process.platform !== 'win32') return null;
+  const p = path.join(process.env.LOCALAPPDATA || '', 'Microsoft', 'WindowsApps', 'cc.cmd');
+  if (!fs.existsSync(p)) return mk('Platform', 'WindowsApps cc.cmd', 'ok', 'not present');
+  return mk('Platform', 'WindowsApps cc.cmd', 'warn', `${p} may shadow npm-installed cc`, {
+    safe: false, description: 'Delete the stale stub', cmd: `del "${p}"`, apply: null,
+  });
+}
+
+function checkStaleBinCc() {
+  if (process.platform !== 'win32') return null;
+  const p = path.join(os.homedir(), 'bin', 'cc');
+  if (!fs.existsSync(p)) return null;
+  return mk('Platform', '~/bin/cc', 'warn', `${p} may be an old version shadowing npm-installed cc`, {
+    safe: false, description: 'Remove the old script', cmd: `Remove-Item "${p}"`, apply: null,
+  });
+}
+
+function checkCygpath() {
+  if (process.platform !== 'win32') return null;
+  if (!process.env.MSYSTEM && !process.env.MINGW_PREFIX) return null;
+  if (findAllOnPath('cygpath').length > 0) return mk('Platform', 'cygpath (Git Bash)', 'ok', 'available');
+  return mk('Platform', 'cygpath (Git Bash)', 'warn', 'not found — path conversion may fail', {
+    safe: false, description: 'Use Git for Windows which bundles cygpath', cmd: null, apply: null,
+  });
+}
+
+// --- Sanity ---
+
+function checkSpawnClaude() {
+  const bin = findClaude();
+  if (!bin) return null;
+  const v = getClaudeVersion(bin);
+  if (v) return mk('Sanity', 'test-spawn claude --version', 'ok', v.raw);
+  return mk('Sanity', 'test-spawn claude --version', 'error', 'no version output', {
+    safe: false, description: 'Reinstall Claude Code', cmd: 'npm install -g @anthropic-ai/claude-code', apply: null,
+  });
+}
+
+// --- Collect all ---
+
+function runChecks() {
+  const results = [
+    checkNodeVersion(),
+    checkClaudeOnPath(),
+    checkClaudeVersion(),
+    checkConflictingEnv(),
+    checkCcShadow(),
+    checkProfilesDirWritable(),
+  ];
+  for (const prof of profiles.listProfiles()) {
+    results.push(checkProfileClaudeJson(prof));
+    results.push(...checkProfileLinks(prof));
+  }
+  results.push(
+    checkOneDrive(),
+    checkWindowsAppsCc(),
+    checkStaleBinCc(),
+    checkCygpath(),
+    checkSpawnClaude(),
+  );
+  return results.filter(Boolean);
+}
+
+// --- Output formatting ---
+
+function colorIcon(status) {
+  const icon = status === 'ok' ? '✓' : status === 'warn' ? '⚠' : '✗';
+  if (!color.colorEnabled(process.stdout)) return icon;
+  if (status === 'ok') return `\x1b[32m${icon}\x1b[39m`;
+  if (status === 'warn') return `\x1b[33m${icon}\x1b[39m`;
+  return `\x1b[31m${icon}\x1b[39m`;
+}
+
+function formatText(results) {
+  const groups = {};
+  for (const g of GROUP_ORDER) groups[g] = [];
+  for (const r of results) {
+    if (groups[r.group]) groups[r.group].push(r);
+  }
+
+  const lines = [];
+  for (const g of GROUP_ORDER) {
+    if (groups[g].length === 0) continue;
+    lines.push(g);
+    for (const r of groups[g]) {
+      lines.push(`  ${colorIcon(r.status)}  ${r.name}: ${r.message}`);
+      if (r.status !== 'ok' && r.fix) {
+        if (r.fix.cmd) {
+          lines.push(`       → Run: ${r.fix.cmd}`);
+        } else if (r.fix.apply) {
+          lines.push(`       → Run: ${r.fix.safe ? 'cc doctor --fix' : 'cc doctor --fix --force'}`);
+        }
+      }
+    }
+    lines.push('');
+  }
+  return lines.join('\n');
+}
+
+function serializeFix(fix) {
+  if (!fix) return null;
+  return { safe: fix.safe, description: fix.description || null, cmd: fix.cmd || null };
+}
+
+function formatJson(results) {
+  const counts = { ok: 0, warn: 0, error: 0 };
+  for (const r of results) counts[r.status] = (counts[r.status] || 0) + 1;
+  return JSON.stringify({
+    summary: counts,
+    checks: results.map(r => ({
+      group: r.group, name: r.name, status: r.status, message: r.message,
+      fix: serializeFix(r.fix),
+    })),
+  }, null, 2);
+}
+
+// --- Fix runner ---
+
+async function applyFixes(results, force, promptFn) {
+  const toFix = results.filter(r => r.fix && r.fix.apply && (r.fix.safe || force));
+  if (toFix.length === 0) {
+    process.stdout.write('Nothing auto-fixable found.\n');
+    return;
+  }
+  for (const r of toFix) {
+    if (r.fix.safe) {
+      process.stdout.write(`Fixing: ${r.name}\n`);
+      await r.fix.apply();
+    } else {
+      const ans = await promptFn(`Fix "${r.name}" — ${r.fix.description || r.name}? [y/N]: `);
+      if (ans.trim().toLowerCase() === 'y') {
+        await r.fix.apply();
+      } else {
+        process.stdout.write('  Skipped.\n');
+      }
+    }
+  }
+}
+
+// --- Entry point ---
+
+async function runDoctor({ fix, force, json, prompt: promptFn }) {
+  const results = runChecks();
+
+  if (json) {
+    process.stdout.write(formatJson(results) + '\n');
+  } else {
+    process.stdout.write(formatText(results));
+  }
+
+  if (fix) {
+    if (!json) process.stdout.write('Applying fixes...\n');
+    await applyFixes(results, force, promptFn);
+  } else if (!json) {
+    const errors = results.filter(r => r.status === 'error');
+    const warns = results.filter(r => r.status === 'warn');
+    if (errors.length === 0 && warns.length === 0) {
+      process.stdout.write('All checks passed.\n');
+    } else {
+      const parts = [];
+      if (errors.length) parts.push(`${errors.length} error${errors.length !== 1 ? 's' : ''}`);
+      if (warns.length) parts.push(`${warns.length} warning${warns.length !== 1 ? 's' : ''}`);
+      process.stdout.write(`${parts.join(', ')}.\n`);
+      const hasAutoFix = results.some(r => r.fix && r.fix.apply && r.fix.safe);
+      const hasForce = results.some(r => r.fix && r.fix.apply && !r.fix.safe);
+      if (hasAutoFix) process.stdout.write('Run: cc doctor --fix\n');
+      else if (hasForce) process.stdout.write('Run: cc doctor --fix --force\n');
+    }
+  }
+
+  if (results.some(r => r.status === 'error')) return 2;
+  if (results.some(r => r.status === 'warn')) return 1;
+  return 0;
+}
+
+module.exports = { runChecks, runDoctor };

package/lib/migrate.js

@@ -6,9 +6,14 @@ const os = require('os');
 
 const profiles = require('./profiles');
 
-// Only projects/ holds the resumable conversation transcripts. sessions/ is transient
-// per-process state and is intentionally not migrated.
-const SUBDIRS = ['projects'];
+// sessions/ is transient per-process state — intentionally not migrated.
+// plugins/ carries auth tokens — excluded until an explicit opt-in flag is added.
+const SUBDIRS = ['projects', 'skills', 'agents', 'commands'];
+
+// Single files copied only when src=default and dest=<profile>.
+// Not copied to shared: these carry per-profile config / auth tokens.
+const SINGLE_FILES = ['mcp.json', 'settings.json', 'CLAUDE.md'];
+
 const EXCLUDED_FILES = new Set(['.credentials.json', '.claude.json']);
 
 function defaultClaudeDir() {
@@ -36,7 +41,7 @@ function resolveDest(dest) {
   return { kind: 'profile', name: dest, dir: profiles.profileDir(dest) };
 }
 
-function copyTreeSkipCollisions(srcRoot, dstRoot) {
+function copyTreeSkipCollisions(srcRoot, dstRoot, { force = false } = {}) {
   if (!fs.existsSync(srcRoot)) return { copied: 0, skipped: 0 };
   fs.mkdirSync(dstRoot, { recursive: true });
   let copied = 0;
@@ -46,8 +51,12 @@ function copyTreeSkipCollisions(srcRoot, dstRoot) {
     const from = path.join(srcRoot, ent.name);
     const to = path.join(dstRoot, ent.name);
     if (fs.existsSync(to)) {
-      skipped += 1;
-      continue;
+      if (force) {
+        fs.rmSync(to, { recursive: true, force: true });
+      } else {
+        skipped += 1;
+        continue;
+      }
     }
     fs.cpSync(from, to, { recursive: true, verbatimSymlinks: true });
     copied += 1;
@@ -55,7 +64,23 @@ function copyTreeSkipCollisions(srcRoot, dstRoot) {
   return { copied, skipped };
 }
 
-function migrate(srcArg, destArg) {
+// Returns 'copied', 'skipped', or 'absent'.
+function copySingleFile(srcDir, dstDir, fileName, { force = false } = {}) {
+  const from = path.join(srcDir, fileName);
+  if (!fs.existsSync(from)) return 'absent';
+  const to = path.join(dstDir, fileName);
+  if (fs.existsSync(to)) {
+    if (force) {
+      fs.rmSync(to, { recursive: true, force: true });
+    } else {
+      return 'skipped';
+    }
+  }
+  fs.copyFileSync(from, to);
+  return 'copied';
+}
+
+function migrate(srcArg, destArg, { force = false } = {}) {
   const src = resolveSource(srcArg);
   const dest = resolveDest(destArg);
 
@@ -71,7 +96,7 @@ function migrate(srcArg, destArg) {
 
   if (!fs.existsSync(src.dir)) {
     console.log(`Source ${src.dir} does not exist. Nothing to migrate.`);
-    return { copied: 0, skipped: 0 };
+    return { copied: 0, skipped: 0, files: {} };
   }
 
   let totalCopied = 0;
@@ -80,13 +105,27 @@ function migrate(srcArg, destArg) {
     const srcSub = path.join(src.dir, sub);
     const dstSub = path.join(dest.dir, sub);
     if (!fs.existsSync(srcSub)) continue;
-    const { copied, skipped } = copyTreeSkipCollisions(srcSub, dstSub);
+    const { copied, skipped } = copyTreeSkipCollisions(srcSub, dstSub, { force });
     console.log(`  ${sub}: copied ${copied}, skipped ${skipped}`);
     totalCopied += copied;
     totalSkipped += skipped;
   }
+
+  // Single config files: only when migrating from default into a profile.
+  const fileResults = {};
+  if (src.kind === 'default' && dest.kind === 'profile') {
+    for (const f of SINGLE_FILES) {
+      const result = copySingleFile(src.dir, dest.dir, f, { force });
+      fileResults[f] = result;
+      const label = result === 'absent' ? 'not present at source' : result;
+      console.log(`  ${f}: ${label}`);
+      if (result === 'copied') totalCopied += 1;
+      else if (result === 'skipped') totalSkipped += 1;
+    }
+  }
+
   console.log(`Done. Total copied: ${totalCopied}, total skipped (already present): ${totalSkipped}.`);
-  return { copied: totalCopied, skipped: totalSkipped };
+  return { copied: totalCopied, skipped: totalSkipped, files: fileResults };
 }
 
 module.exports = {
@@ -95,6 +134,8 @@ module.exports = {
   resolveSource,
   resolveDest,
   copyTreeSkipCollisions,
+  copySingleFile,
   SUBDIRS,
+  SINGLE_FILES,
   EXCLUDED_FILES,
 };

package/lib/profiles.js

@@ -13,14 +13,6 @@ const RESERVED_WIN = new Set([
 const MAX_NAME_LEN = 64;
 const INVALID_CHARS_RE = /[\\/:*?"<>|\x00-\x1f]/;
 
-const ALIAS_FILE = '.cc-alias.json';
-const ALLOWED_ALIAS_KEYS = ['email', 'org', 'name'];
-const OAUTH_FIELD_MAP = {
-  email: 'emailAddress',
-  org: 'organizationName',
-  name: 'displayName',
-};
-
 function baseDir() {
   return path.join(os.homedir(), '.claude-profiles');
 }
@@ -88,31 +80,7 @@ function ensureProfileDir(name) {
   return { dir, created };
 }
 
-function aliasPath(dir) {
-  return path.join(dir, ALIAS_FILE);
-}
-
-function readAlias(dir) {
-  try {
-    const raw = fs.readFileSync(aliasPath(dir), 'utf8');
-    if (!raw.trim()) return {};
-    const data = JSON.parse(raw);
-    if (!data || typeof data !== 'object') return {};
-    const out = {};
-    for (const k of ALLOWED_ALIAS_KEYS) {
-      if (typeof data[k] === 'string' && data[k].length > 0) out[k] = data[k];
-    }
-    return out;
-  } catch {
-    return {};
-  }
-}
-
-function writeAlias(dir, data) {
-  fs.writeFileSync(aliasPath(dir), JSON.stringify(data, null, 2));
-}
-
-function addProfile(name, aliasFlags) {
+function addProfile(name) {
   validateProfileName(name);
   const dir = profileDir(name);
   if (fs.existsSync(dir)) {
@@ -120,57 +88,9 @@ function addProfile(name, aliasFlags) {
     e.exitCode = 1;
     throw e;
   }
-  const alias = {};
-  for (const [k, v] of Object.entries(aliasFlags || {})) {
-    if (!ALLOWED_ALIAS_KEYS.includes(k)) {
-      throw usageError(`Unknown flag: --${k}. Allowed: --email, --org, --name.`);
-    }
-    if (typeof v !== 'string' || v.length === 0) {
-      throw usageError(`Flag --${k} requires a non-empty value.`);
-    }
-    alias[k] = v;
-  }
   ensureBaseDir();
   fs.mkdirSync(dir);
-  if (Object.keys(alias).length > 0) {
-    writeAlias(dir, alias);
-  }
-  return { dir, alias };
-}
-
-function applyAlias(dir) {
-  const alias = readAlias(dir);
-  if (Object.keys(alias).length === 0) return false;
-  const claudeJsonPath = path.join(dir, '.claude.json');
-  if (!fs.existsSync(claudeJsonPath)) return false;
-  let data;
-  try {
-    const raw = fs.readFileSync(claudeJsonPath, 'utf8');
-    if (!raw.trim()) return false;
-    data = JSON.parse(raw);
-  } catch {
-    return false;
-  }
-  if (!data || typeof data !== 'object') return false;
-  if (!data.oauthAccount || typeof data.oauthAccount !== 'object') return false;
-  let mutated = false;
-  for (const [k, v] of Object.entries(alias)) {
-    const oauthKey = OAUTH_FIELD_MAP[k];
-    if (!oauthKey) continue;
-    if (data.oauthAccount[oauthKey] !== v) {
-      data.oauthAccount[oauthKey] = v;
-      mutated = true;
-    }
-  }
-  if (mutated) {
-    try {
-      fs.writeFileSync(claudeJsonPath, JSON.stringify(data, null, 2));
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  return false;
+  return { dir };
 }
 
 function readEmail(dir) {
@@ -214,7 +134,6 @@ function listProfiles() {
       dir,
       loggedIn: hasCredentials(dir),
       email: readEmail(dir),
-      alias: readAlias(dir),
     });
   }
   out.sort((a, b) => a.name.localeCompare(b.name));
@@ -232,9 +151,4 @@ module.exports = {
   hasCredentials,
   listProfiles,
   addProfile,
-  readAlias,
-  writeAlias,
-  applyAlias,
-  ALLOWED_ALIAS_KEYS,
-  OAUTH_FIELD_MAP,
 };

package/lib/share.js

@@ -5,10 +5,11 @@ const path = require('path');
 
 const profiles = require('./profiles');
 
-// Only projects/ holds the resumable conversation transcripts (projects/<proj>/<session>.jsonl).
+// Artifact directories that are safe to share across profiles via junctions/symlinks.
 // sessions/ is transient per-process registry state (PID, cwd, status, timestamps) and
 // must stay per-profile — sharing it would corrupt Claude's running-process bookkeeping.
-const SHARED_SUBDIRS = ['projects'];
+// plugins/ carries auth tokens and is intentionally excluded (future opt-in).
+const SHARED_SUBDIRS = ['projects', 'skills', 'agents', 'commands'];
 
 function symlinkType() {
   return process.platform === 'win32' ? 'junction' : 'dir';
@@ -70,6 +71,11 @@ function migrateIntoShared(profileName, src, sharedTarget) {
   return moved;
 }
 
+// Links each of the four artifact dirs independently. A failure on one
+// directory is recorded and the remaining directories are still attempted —
+// callers get a per-directory result and decide how to report it.
+// Returns [{ sub, status, moved?, message? }]; status is one of:
+//   'linked' | 'already-linked' | 'failed'
 function shareLink(profileName) {
   profiles.validateProfileName(profileName);
   const pdir = profiles.profileDir(profileName);
@@ -79,26 +85,31 @@ function shareLink(profileName) {
     throw err;
   }
   ensureSharedDirs();
+  const results = [];
   for (const sub of SHARED_SUBDIRS) {
     const target = path.join(profiles.sharedDir(), sub);
     const link = path.join(pdir, sub);
-    if (isLink(link)) {
-      console.log(`  ${sub}: already linked`);
-      continue;
-    }
-    if (fs.existsSync(link)) {
-      const moved = migrateIntoShared(profileName, link, target);
-      console.log(`  ${sub}: migrated ${moved} item(s) into shared`);
-    }
     try {
+      if (isLink(link)) {
+        results.push({ sub, status: 'already-linked' });
+        continue;
+      }
+      let moved = 0;
+      if (fs.existsSync(link)) {
+        moved = migrateIntoShared(profileName, link, target);
+      }
       fs.symlinkSync(target, link, symlinkType());
+      results.push({ sub, status: 'linked', moved });
     } catch (err) {
-      throw new Error(`Cannot link ${link} -> ${target}: ${err.message}`);
+      results.push({ sub, status: 'failed', message: err.message });
     }
-    console.log(`  ${sub}: linked -> ${target}`);
   }
+  return results;
 }
 
+// Mirror of shareLink: each directory is restored independently.
+// Returns [{ sub, status, message? }]; status is one of:
+//   'unlinked' | 'not-linked' | 'failed'
 function shareUnlink(profileName) {
   profiles.validateProfileName(profileName);
   const pdir = profiles.profileDir(profileName);
@@ -107,22 +118,28 @@ function shareUnlink(profileName) {
     err.exitCode = 1;
     throw err;
   }
+  const results = [];
   for (const sub of SHARED_SUBDIRS) {
     const link = path.join(pdir, sub);
     const target = path.join(profiles.sharedDir(), sub);
-    if (!isLink(link)) {
-      console.log(`  ${sub}: not linked, skipping`);
-      continue;
-    }
-    removeLink(link);
-    fs.mkdirSync(link, { recursive: true });
-    if (fs.existsSync(target)) {
-      for (const ent of fs.readdirSync(target)) {
-        copyRecursive(path.join(target, ent), path.join(link, ent));
+    try {
+      if (!isLink(link)) {
+        results.push({ sub, status: 'not-linked' });
+        continue;
       }
+      removeLink(link);
+      fs.mkdirSync(link, { recursive: true });
+      if (fs.existsSync(target)) {
+        for (const ent of fs.readdirSync(target)) {
+          copyRecursive(path.join(target, ent), path.join(link, ent));
+        }
+      }
+      results.push({ sub, status: 'unlinked' });
+    } catch (err) {
+      results.push({ sub, status: 'failed', message: err.message });
     }
-    console.log(`  ${sub}: unlinked, content copied back`);
   }
+  return results;
 }
 
 module.exports = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cchost",
-  "version": "0.1.3",
+  "version": "0.2.1",
   "description": "Host multiple isolated Claude Code accounts on one machine via the `cc` command.",
   "keywords": [
     "claude",
@@ -43,4 +43,4 @@
   "devDependencies": {
     "vitest": "^2.1.0"
   }
-}
+}