cchost 0.4.4 → 0.5.0

package/lib/color.js

@@ -1,7 +1,9 @@
 'use strict';
 
 function colorEnabled(stream) {
-  if (process.env.NO_COLOR && process.env.NO_COLOR.length > 0) return false;
+  // Per no-color.org, NO_COLOR disables color only when set to a non-empty
+  // value; NO_COLOR="" leaves color enabled.
+  if (process.env.NO_COLOR) return false;
   if (process.env.FORCE_COLOR && process.env.FORCE_COLOR !== '0') return true;
   const s = stream || process.stdout;
   return Boolean(s && s.isTTY);

package/lib/copy.js

@@ -1,17 +1,17 @@
 'use strict';
 
-// `cc copy` — copy mcp.json / settings.json / CLAUDE.md / artifact dirs from
-// ~/.claude/ (default) into a profile. Renamed from `cc migrate` in v0.4.1;
-// `cc migrate` still works as a deprecation alias.
+// `cchost copy` — copy mcp.json / settings.json / CLAUDE.md / artifact dirs from
+// ~/.claude/ (default) into a profile. Renamed from `cchost migrate` in v0.4.1;
+// `cchost migrate` still works as a deprecation alias.
 //
 // Only direction supported: default → <profile>. The reverse and profile→
 // profile were considered and dropped — they're rare enough that a manual
 // `cp -r` is fine and keeps the surface small.
 //
 // Most v0.4 profiles have all 7 resources symlinked into the pool, so
-// `cc copy default foo` is usually a no-op (every resource resolves to the
+// `cchost copy default foo` is usually a no-op (every resource resolves to the
 // same path as the source). The command is meaningful only when a resource
-// has been unlinked via `cc unlink`.
+// has been unlinked via `cchost unlink`.
 
 const fs = require('fs');
 const path = require('path');
@@ -35,7 +35,7 @@ function rejectSharedKeyword(role) {
   return usageError(
     `'shared' is not a valid copy ${role} in v0.4. ` +
       "The shared pool is now ~/.claude/ itself, reached via per-profile " +
-      "symlinks. Use `cc link <profile>` / `cc unlink <profile>` to manage " +
+      "symlinks. Use `cchost link <profile>` / `cchost unlink <profile>` to manage " +
       "which resources are shared.",
   );
 }
@@ -86,10 +86,11 @@ function sameOnDisk(a, b) {
 }
 
 // Copy directory contents item-by-item with skip-on-collision (default) or
-// overwrite (force). Returns { copied, skipped }.
-function copyDirContents(srcRoot, dstRoot, { force = false } = {}) {
+// overwrite (force). Returns { copied, skipped }. With dryRun the counts are
+// what a real run would produce, and nothing is written.
+function copyDirContents(srcRoot, dstRoot, { force = false, dryRun = false } = {}) {
   if (!fs.existsSync(srcRoot)) return { copied: 0, skipped: 0 };
-  fs.mkdirSync(dstRoot, { recursive: true });
+  if (!dryRun) fs.mkdirSync(dstRoot, { recursive: true });
   let copied = 0;
   let skipped = 0;
   for (const ent of fs.readdirSync(srcRoot, { withFileTypes: true })) {
@@ -97,29 +98,26 @@ function copyDirContents(srcRoot, dstRoot, { force = false } = {}) {
     const from = path.join(srcRoot, ent.name);
     const to = path.join(dstRoot, ent.name);
     if (fs.existsSync(to)) {
-      if (force) {
-        fs.rmSync(to, { recursive: true, force: true });
-      } else {
+      if (!force) {
         skipped += 1;
         continue;
       }
+      if (!dryRun) fs.rmSync(to, { recursive: true, force: true });
     }
-    fs.cpSync(from, to, { recursive: true, verbatimSymlinks: true });
+    if (!dryRun) fs.cpSync(from, to, { recursive: true, verbatimSymlinks: true });
     copied += 1;
   }
   return { copied, skipped };
 }
 
 // Copy a single file. Returns 'copied' | 'skipped' | 'absent'.
-function copySingleFile(srcPath, dstPath, { force = false } = {}) {
+function copySingleFile(srcPath, dstPath, { force = false, dryRun = false } = {}) {
   if (!fs.existsSync(srcPath)) return 'absent';
   if (fs.existsSync(dstPath)) {
-    if (force) {
-      fs.rmSync(dstPath, { recursive: true, force: true });
-    } else {
-      return 'skipped';
-    }
+    if (!force) return 'skipped';
+    if (!dryRun) fs.rmSync(dstPath, { recursive: true, force: true });
   }
+  if (dryRun) return 'copied';
   fs.mkdirSync(path.dirname(dstPath), { recursive: true });
   fs.copyFileSync(srcPath, dstPath);
   return 'copied';
@@ -131,8 +129,9 @@ function formatResourceLabel(resource) {
 
 // Main entry: copy each of the 7 shared resources from src → dest, honoring
 // the v0.4 symlink semantics. Logs per-resource progress and a closing
-// summary line. Returns a structured result for tests.
-function copy(srcArg, destArg, { force = false } = {}) {
+// summary line. Returns a structured result for tests. With dryRun the same
+// report is printed in the conditional ("would copy") and nothing is written.
+function copy(srcArg, destArg, { force = false, dryRun = false } = {}) {
   const src = resolveSource(srcArg);
   const dest = resolveDest(destArg);
 
@@ -140,7 +139,8 @@ function copy(srcArg, destArg, { force = false } = {}) {
     throw usageError(`Source and destination resolve to the same directory (${src.dir}).`);
   }
 
-  profiles.ensureProfileDir(dest.name);
+  if (!dryRun) profiles.ensureProfileDir(dest.name);
+  const copiedWord = dryRun ? 'would copy' : 'copied';
   if (!fs.existsSync(src.dir)) {
     console.log(`Source ${src.dir} does not exist. Nothing to copy.`);
     return { copied: 0, skipped: 0, shared: 0, results: [] };
@@ -178,9 +178,9 @@ function copy(srcArg, destArg, { force = false } = {}) {
     }
 
     if (isFile) {
-      const r = copySingleFile(srcPath, dstPath, { force });
+      const r = copySingleFile(srcPath, dstPath, { force, dryRun });
       if (r === 'copied') {
-        console.log(`  ${label} copied`);
+        console.log(`  ${label} ${copiedWord}`);
         totalCopied += 1;
       } else if (r === 'skipped') {
         console.log(`  ${label} skipped (already present — pass --force to overwrite)`);
@@ -192,12 +192,12 @@ function copy(srcArg, destArg, { force = false } = {}) {
       continue;
     }
 
-    const { copied, skipped } = copyDirContents(srcPath, dstPath, { force });
+    const { copied, skipped } = copyDirContents(srcPath, dstPath, { force, dryRun });
     if (copied === 0 && skipped === 0) {
       console.log(`  ${label} empty at source`);
     } else if (copied > 0) {
       const more = skipped > 0 ? `, skipped ${skipped} (already present)` : '';
-      console.log(`  ${label} copied ${copied} item(s)${more}`);
+      console.log(`  ${label} ${copiedWord} ${copied} item(s)${more}`);
     } else {
       console.log(
         `  ${label} skipped ${skipped} item(s) (all already present — pass --force to overwrite)`,
@@ -214,15 +214,17 @@ function copy(srcArg, destArg, { force = false } = {}) {
       `Nothing to copy — all ${share.SHARED_RESOURCES.length} resources are already shared via symlinks.`,
     );
     console.log(
-      `Tip: run \`cc unlink ${dest.name}\` first if you want private copies in this profile.`,
+      `Tip: run \`cchost unlink ${dest.name}\` first if you want private copies in this profile.`,
     );
   } else if (totalCopied === 0) {
     console.log(
-      `Nothing copied. ${totalShared} shared via symlink, ${totalSkipped} skipped (already present).`,
+      `${dryRun ? 'Nothing would be copied' : 'Nothing copied'}. ` +
+        `${totalShared} shared via symlink, ${totalSkipped} skipped (already present).`,
     );
   } else {
     console.log(
-      `Done. Copied ${totalCopied} item(s), ${totalShared} already shared via symlinks` +
+      `${dryRun ? 'Dry run: would copy' : 'Done. Copied'} ${totalCopied} item(s), ` +
+        `${totalShared} already shared via symlinks` +
         (totalSkipped > 0 ? `, ${totalSkipped} skipped (already present)` : '') +
         '.',
     );

package/lib/doctor.js

@@ -6,16 +6,20 @@ const os = require('os');
 
 const profiles = require('./profiles');
 const share = require('./share');
+const envLib = require('./env');
 const { findClaude, getClaudeVersion, compareVersion, MIN_VERSION } = require('./spawn');
 const color = require('./color');
 
 const GROUP_ORDER = ['Environment', 'Storage', 'Platform', 'Sanity'];
 
+// Default sink for fix progress. JSON mode passes a stderr writer instead.
+const stdoutWrite = (text) => process.stdout.write(text);
+
 // fix: { safe, description, cmd, apply }
 //   safe=true  → auto-applied by --fix
-//   safe=false → needs --fix --force, prompted y/n
+//   safe=false → needs --fix --force, prompted y/N
 //   cmd        → printed when fix cannot be auto-applied
-//   apply      → async fn to execute
+//   apply      → async fn to execute, receives the progress writer
 
 function mk(group, name, status, message, fix) {
   return { group, name, status, message, fix: fix || null };
@@ -60,23 +64,21 @@ function checkClaudeVersion() {
   });
 }
 
-const CONFLICT_VARS = ['ANTHROPIC_API_KEY', 'ANTHROPIC_AUTH_TOKEN', 'CLAUDE_CODE_OAUTH_TOKEN'];
-
 function checkConflictingEnv() {
-  const set = CONFLICT_VARS.filter(k => process.env[k]);
+  const set = envLib.authEnvConflicts();
   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,
+    safe: false, description: 'Unset to avoid auth interference with cchost use', cmd, apply: null,
   });
 }
 
-function findAllOnPath(name) {
+function findAllOnPath(name, platform = process.platform) {
   const PATH = process.env.PATH || process.env.Path || '';
-  const sep = process.platform === 'win32' ? ';' : ':';
-  const exts = process.platform === 'win32'
+  const sep = platform === 'win32' ? ';' : ':';
+  const exts = platform === 'win32'
     ? (process.env.PATHEXT || '.COM;.EXE;.BAT;.CMD').split(';').map(s => s.trim()).filter(Boolean)
     : [''];
   const found = [];
@@ -86,7 +88,7 @@ function findAllOnPath(name) {
       try {
         const full = path.join(dir, name + ext);
         if (fs.statSync(full).isFile()) {
-          const key = process.platform === 'win32' ? full.toLowerCase() : full;
+          const key = platform === 'win32' ? full.toLowerCase() : full;
           if (!seen.has(key)) { seen.add(key); found.push(full); }
           break;
         }
@@ -96,13 +98,94 @@ function findAllOnPath(name) {
   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)');
+// Resolve a path to the object it points at.
+function pathIdentity(p) {
+  try {
+    return fs.realpathSync(p);
+  } catch {
+    return path.resolve(p);
   }
-  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,
+}
+
+// True only when `p` really is the cchost CLI. A bare `cc` may be a compiler
+// (clang, gcc, ccache, conda) and must not be mistaken for the legacy alias.
+function isCchostBinary(p) {
+  const target = pathIdentity(p);
+  if (/[\\/]cchost[\\/]bin[\\/]cc\.js$/i.test(target)) return true;
+  try {
+    const st = fs.statSync(target);
+    if (!st.isFile() || st.size > 256 * 1024) return false;
+    const text = fs.readFileSync(target, 'utf8');
+    return /cchost/i.test(text) && /(node_modules|cc\.js)/i.test(text);
+  } catch {
+    return false;
+  }
+}
+
+// Windows npm writes separate cc.cmd and cchost.cmd shims. Extract the
+// bin/cc.js they invoke so shims from the same install share an identity while
+// a stale shim pointing elsewhere still counts as a separate install.
+function shimTarget(p) {
+  if (!/\.(cmd|bat|ps1)$/i.test(p)) return null;
+  try {
+    const text = fs.readFileSync(p, 'utf8');
+    const m = text.match(
+      /(?:[A-Za-z]:[\\/]|%dp0%[\\/]|%~dp0[\\/]|(?:\.\.?[\\/]))[^"\r\n]*?node_modules[\\/]+cchost[\\/]+bin[\\/]+cc\.js/i,
+    );
+    if (!m) return null;
+    const raw = m[0];
+    if (/^[A-Za-z]:[\\/]/.test(raw)) {
+      return raw.replace(/[\\/]/g, '\\').toLowerCase();
+    }
+    const relative = raw
+      .replace(/^%dp0%|^%~dp0/i, '')
+      .replace(/^[\\/]+/, '')
+      .replace(/[\\/]/g, path.sep);
+    return path.resolve(path.dirname(p), relative).replace(/[\\/]/g, '\\').toLowerCase();
+  } catch {
+    return null;
+  }
+}
+
+function shadowIdentity(p, platform = process.platform) {
+  if (platform === 'win32') {
+    const target = shimTarget(p);
+    if (target) return `shim:${target}`;
+  }
+  return pathIdentity(p);
+}
+
+function checkCcShadow(platform = process.platform) {
+  const found = [];
+  for (const name of ['cchost', 'cc']) {
+    for (const p of findAllOnPath(name, platform)) {
+      if (name === 'cc' && !isCchostBinary(p)) continue;
+      found.push({ name, path: p });
+    }
+  }
+
+  const unique = [];
+  const seen = new Set();
+  for (const entry of found) {
+    const key = shadowIdentity(entry.path, platform);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    unique.push(entry);
+  }
+
+  if (unique.length <= 1) {
+    return mk(
+      'Environment',
+      'cchost on PATH',
+      'ok',
+      unique.length ? unique[0].path : 'not found yet (expected after npm install -g cchost)',
+    );
+  }
+  return mk('Environment', 'cchost on PATH', 'warn', `multiple: ${unique.map((e) => e.path).join(', ')}`, {
+    safe: false,
+    description: 'Remove duplicate cchost/cc entries to avoid version confusion',
+    cmd: null,
+    apply: null,
   });
 }
 
@@ -115,9 +198,9 @@ function checkProfilesDirWritable() {
       safe: true,
       description: `Create ${base}`,
       cmd: null,
-      apply: async () => {
+      apply: async (write = stdoutWrite) => {
         fs.mkdirSync(base, { recursive: true });
-        process.stdout.write(`  Created ${base}\n`);
+        write(`  Created ${base}\n`);
       },
     });
   }
@@ -146,11 +229,11 @@ function checkProfileClaudeJson(prof) {
       safe: false,
       description: `Back up ${path.basename(p)} and reset to {}`,
       cmd: null,
-      apply: async () => {
+      apply: async (write = stdoutWrite) => {
         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`);
+        write(`  Backed up to ${path.basename(bak)}, reset to {}\n`);
       },
     });
   }
@@ -174,12 +257,12 @@ function checkProfileLinks(prof) {
           safe: true,
           description: `Create link to ~/.claude/${resource}`,
           cmd: null,
-          apply: async () => {
+          apply: async (write = stdoutWrite) => {
             const r = share.shareLink(prof.name, subsetForResource(resource))[0];
             if (r && r.status === 'linked') {
-              process.stdout.write(`  Linked: ${pp} -> ${expected}\n`);
+              write(`  Linked: ${pp} -> ${expected}\n`);
             } else if (r) {
-              process.stdout.write(`  Could not link ${pp}: ${r.message || r.status}\n`);
+              write(`  Could not link ${pp}: ${r.message || r.status}\n`);
             }
           },
         }),
@@ -199,13 +282,13 @@ function checkProfileLinks(prof) {
           safe: true,
           description: `Recreate link to ${expected}`,
           cmd: null,
-          apply: async () => {
+          apply: async (write = stdoutWrite) => {
             share.removeLink(pp);
             const r = share.shareLink(prof.name, subsetForResource(resource))[0];
             if (r && (r.status === 'linked' || r.status === 'already-linked')) {
-              process.stdout.write(`  Recreated: ${pp} -> ${expected}\n`);
+              write(`  Recreated: ${pp} -> ${expected}\n`);
             } else if (r) {
-              process.stdout.write(`  Could not recreate ${pp}: ${r.message || r.status}\n`);
+              write(`  Could not recreate ${pp}: ${r.message || r.status}\n`);
             }
           },
         }),
@@ -233,16 +316,16 @@ function checkProfileLinks(prof) {
           safe: true,
           description: `Replace with link to ~/.claude/${resource}`,
           cmd: null,
-          apply: async () => {
+          apply: async (write = stdoutWrite) => {
             try {
               if (isFile) fs.unlinkSync(pp);
               else fs.rmdirSync(pp);
             } catch { /* fall through */ }
             const r = share.shareLink(prof.name, subsetForResource(resource))[0];
             if (r && r.status === 'linked') {
-              process.stdout.write(`  Linked: ${pp} -> ${expected}\n`);
+              write(`  Linked: ${pp} -> ${expected}\n`);
             } else if (r) {
-              process.stdout.write(`  Could not link ${pp}: ${r.message || r.status}\n`);
+              write(`  Could not link ${pp}: ${r.message || r.status}\n`);
             }
           },
         }),
@@ -253,9 +336,9 @@ function checkProfileLinks(prof) {
     results.push(
       mk('Storage', `"${prof.name}" ${label}`, 'warn', 'private (has content) — not linked', {
         safe: false,
-        description: 'Move or remove the private content, then re-run cc link',
-        cmd: `cc copy default ${prof.name}  # if you want to merge it the other way; ` +
-          `or manually move ${pp} aside, then: cc link ${prof.name}`,
+        description: 'Move or remove the private content, then re-run cchost link',
+        cmd: `cchost copy default ${prof.name}  # if you want to merge it the other way; ` +
+          `or manually move ${pp} aside, then: cchost link ${prof.name}`,
         apply: null,
       }),
     );
@@ -315,9 +398,9 @@ function checkLegacyPool() {
       safe: true,
       description: 'Remove the empty legacy pool',
       cmd: null,
-      apply: async () => {
-        try { fs.rmdirSync(legacy); process.stdout.write(`  Removed ${legacy}\n`); } catch (e) {
-          process.stdout.write(`  Could not remove ${legacy}: ${e.message}\n`);
+      apply: async (write = stdoutWrite) => {
+        try { fs.rmdirSync(legacy); write(`  Removed ${legacy}\n`); } catch (e) {
+          write(`  Could not remove ${legacy}: ${e.message}\n`);
         }
       },
     });
@@ -326,9 +409,9 @@ function checkLegacyPool() {
     safe: true,
     description: 'Move legacy pool contents into ~/.claude/ and re-point profile symlinks',
     cmd: null,
-    apply: async () => {
-      const result = share.migrateLegacyPool({ log: (line) => process.stdout.write(`  ${line}\n`) });
-      process.stdout.write(
+    apply: async (write = stdoutWrite) => {
+      const result = share.migrateLegacyPool({ log: (line) => write(`  ${line}\n`) });
+      write(
         `  Done: ${result.moves.length} item(s) moved, ${result.relinked.length} link(s) repointed.\n`,
       );
     },
@@ -377,16 +460,16 @@ function checkDamagedSessionFilenames() {
       safe: true,
       description: 'Restore <uuid>.jsonl filenames (reissue a fresh UUID when canonical is taken)',
       cmd: null,
-      apply: async () => {
+      apply: async (write = stdoutWrite) => {
         const result = share.repairProjectFilenames({
-          log: (line) => process.stdout.write(`${line}\n`),
+          log: (line) => write(`${line}\n`),
         });
-        process.stdout.write(
+        write(
           `  Done: ${result.repaired.length} filename${result.repaired.length === 1 ? '' : 's'} restored.\n`,
         );
         if (result.failures.length) {
           for (const f of result.failures) {
-            process.stdout.write(`  Failure (${f.kind}): ${f.folder ? f.folder + '/' : ''}${f.name || ''} ${f.message}\n`);
+            write(`  Failure (${f.kind}): ${f.folder ? f.folder + '/' : ''}${f.name || ''} ${f.message}\n`);
           }
         }
       },
@@ -419,16 +502,16 @@ function checkLegacyProjectFolders() {
       safe: true,
       description: 'Merge each legacy projects/ folder into its canonical sibling',
       cmd: null,
-      apply: async () => {
+      apply: async (write = stdoutWrite) => {
         const result = share.healProjectsLegacy({
-          log: (line) => process.stdout.write(`  ${line}\n`),
+          log: (line) => write(`  ${line}\n`),
         });
-        process.stdout.write(
+        write(
           `  Done: ${result.healed.length} folder${result.healed.length === 1 ? '' : 's'} healed.\n`,
         );
         if (result.failures.length) {
           for (const f of result.failures) {
-            process.stdout.write(`  Failure (${f.kind}): ${f.name || ''} ${f.message}\n`);
+            write(`  Failure (${f.kind}): ${f.name || ''} ${f.message}\n`);
           }
         }
       },
@@ -453,7 +536,7 @@ 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`, {
+  return mk('Platform', 'WindowsApps cc.cmd', 'warn', `${p} may shadow npm-installed cchost`, {
     safe: false, description: 'Delete the stale stub', cmd: `del "${p}"`, apply: null,
   });
 }
@@ -462,7 +545,7 @@ 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`, {
+  return mk('Platform', '~/bin/cc', 'warn', `${p} may be an old version shadowing npm-installed cchost`, {
     safe: false, description: 'Remove the old script', cmd: `Remove-Item "${p}"`, apply: null,
   });
 }
@@ -476,6 +559,31 @@ function checkCygpath() {
   });
 }
 
+// macOS keeps OAuth tokens in the login Keychain rather than in the profile
+// directory. Current Claude Code versions namespace the entry by the exact
+// CLAUDE_CONFIG_DIR path, so profiles get separate logins; renaming or moving
+// a profile changes the path and requires a fresh login.
+function checkMacKeychain(platform = process.platform) {
+  if (platform !== 'darwin') return null;
+  let profilesList = [];
+  try {
+    profilesList = profiles.listProfiles(platform);
+  } catch {
+    return null;
+  }
+  const keychainProfiles = profilesList.filter(
+    (p) => !envLib.hasEnvConfig(p.dir) && p.credentialSource === 'keychain',
+  );
+  // Nothing to explain until some profile actually logs in through the Keychain.
+  if (keychainProfiles.length === 0) return null;
+  return mk(
+    'Platform',
+    'macOS credentials (Keychain)',
+    'ok',
+    `${keychainProfiles.length} profile(s) with a Keychain login; entries are namespaced by CLAUDE_CONFIG_DIR path (renaming or moving a profile requires a new login)`,
+  );
+}
+
 // --- Sanity ---
 
 function checkSpawnClaude() {
@@ -507,6 +615,7 @@ function runChecks() {
     results.push(...checkProfileLinks(prof));
   }
   results.push(
+    checkMacKeychain(),
     checkOneDrive(),
     checkWindowsAppsCc(),
     checkStaleBinCc(),
@@ -543,7 +652,7 @@ function formatText(results) {
         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(`       → Run: ${r.fix.safe ? 'cchost doctor --fix' : 'cchost doctor --fix --force'}`);
         }
       }
     }
@@ -571,42 +680,68 @@ function formatJson(results) {
 
 // --- Fix runner ---
 
-async function applyFixes(results, force, promptFn) {
+async function applyFixes(results, force, promptFn, write = stdoutWrite) {
   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;
+    write('Nothing auto-fixable found.\n');
+    return 0;
   }
+  let applied = 0;
   for (const r of toFix) {
     if (r.fix.safe) {
-      process.stdout.write(`Fixing: ${r.name}\n`);
-      await r.fix.apply();
+      write(`Fixing: ${r.name}\n`);
+      await r.fix.apply(write);
+      applied += 1;
     } else {
       const ans = await promptFn(`Fix "${r.name}" — ${r.fix.description || r.name}? [y/N]: `);
       if (ans.trim().toLowerCase() === 'y') {
-        await r.fix.apply();
+        await r.fix.apply(write);
+        applied += 1;
       } else {
-        process.stdout.write('  Skipped.\n');
+        write('  Skipped.\n');
       }
     }
   }
+  return applied;
+}
+
+function doctorExitCode(results) {
+  if (results.some(r => r.status === 'error')) return 2;
+  if (results.some(r => r.status === 'warn')) return 1;
+  return 0;
 }
 
 // --- Entry point ---
 
 async function runDoctor({ fix, force, json, prompt: promptFn }) {
-  const results = runChecks();
+  let results = runChecks();
+
+  if (json && fix) {
+    // Fix progress must not corrupt the JSON document: send it (and any
+    // prompts) to stderr, then emit one report of the post-fix state.
+    const stderrWrite = (text) => process.stderr.write(text);
+    const promptOnStderr = (question) => promptFn(question, process.stderr);
+    const applied = await applyFixes(results, force, promptOnStderr, stderrWrite);
+    if (applied > 0) results = runChecks();
+    process.stdout.write(formatJson(results) + '\n');
+    return doctorExitCode(results);
+  }
 
   if (json) {
     process.stdout.write(formatJson(results) + '\n');
-  } else {
-    process.stdout.write(formatText(results));
+    return doctorExitCode(results);
   }
 
+  process.stdout.write(formatText(results));
+
   if (fix) {
-    if (!json) process.stdout.write('Applying fixes...\n');
-    await applyFixes(results, force, promptFn);
-  } else if (!json) {
+    process.stdout.write('Applying fixes...\n');
+    const applied = await applyFixes(results, force, promptFn);
+    if (applied > 0) {
+      results = runChecks();
+      process.stdout.write('\nAfter fixes:\n' + formatText(results));
+    }
+  } else {
     const errors = results.filter(r => r.status === 'error');
     const warns = results.filter(r => r.status === 'warn');
     if (errors.length === 0 && warns.length === 0) {
@@ -618,14 +753,12 @@ async function runDoctor({ fix, force, json, prompt: promptFn }) {
       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 (hasAutoFix) process.stdout.write('Run: cchost doctor --fix\n');
+      else if (hasForce) process.stdout.write('Run: cchost doctor --fix --force\n');
     }
   }
 
-  if (results.some(r => r.status === 'error')) return 2;
-  if (results.some(r => r.status === 'warn')) return 1;
-  return 0;
+  return doctorExitCode(results);
 }
 
-module.exports = { runChecks, runDoctor };
+module.exports = { runChecks, runDoctor, checkCcShadow, checkMacKeychain };