npm - claude-nomad - Versions diffs - 0.53.3 → 0.55.0 - Mend

claude-nomad 0.53.3 → 0.55.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (4) hide show

package/dist/nomad.mjs CHANGED Viewed

@@ -614,19 +614,19 @@ var init_utils_fs = __esm({
 });
 // src/commands.pull.wedge.ts
-import { execFileSync as execFileSync2 } from "node:child_process";
-import { existsSync as existsSync12 } from "node:fs";
-import { join as join14 } from "node:path";
+import { execFileSync as execFileSync3 } from "node:child_process";
+import { existsSync as existsSync13 } from "node:fs";
+import { join as join15 } from "node:path";
 function detectWedge(repo) {
-  const g = join14(repo, ".git");
-  if (existsSync12(join14(g, "rebase-merge")) || existsSync12(join14(g, "rebase-apply"))) return "rebase";
-  if (existsSync12(join14(g, "MERGE_HEAD"))) return "merge";
+  const g = join15(repo, ".git");
+  if (existsSync13(join15(g, "rebase-merge")) || existsSync13(join15(g, "rebase-apply"))) return "rebase";
+  if (existsSync13(join15(g, "MERGE_HEAD"))) return "merge";
   return null;
 }
 function unmergedIndexPresent(repo) {
   let raw;
   try {
-    raw = execFileSync2("git", ["diff", "--diff-filter=U", "--name-only", "-z"], {
+    raw = execFileSync3("git", ["diff", "--diff-filter=U", "--name-only", "-z"], {
       cwd: repo,
       stdio: ["ignore", "pipe", "pipe"],
       maxBuffer: 64 * 1024 * 1024
@@ -660,7 +660,7 @@ function wedgeMarkerRunbookText(state) {
 function orphanedAutostashPresent(repo) {
   let raw;
   try {
-    raw = execFileSync2("git", ["stash", "list"], {
+    raw = execFileSync3("git", ["stash", "list"], {
       cwd: repo,
       stdio: ["ignore", "pipe", "pipe"],
       maxBuffer: 64 * 1024 * 1024
@@ -677,15 +677,15 @@ var init_commands_pull_wedge = __esm({
 });
 // src/push-gitleaks.config.ts
-import { existsSync as existsSync13, mkdtempSync, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "node:fs";
+import { existsSync as existsSync14, mkdtempSync, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "node:fs";
 import { tmpdir } from "node:os";
-import { join as join15 } from "node:path";
+import { join as join16 } from "node:path";
 import { fileURLToPath } from "node:url";
 function resolveTomlPath(repo = repoHome()) {
-  const repoToml = join15(repo, ".gitleaks.toml");
-  if (existsSync13(repoToml)) return repoToml;
+  const repoToml = join16(repo, ".gitleaks.toml");
+  if (existsSync14(repoToml)) return repoToml;
   const bundled = fileURLToPath(new URL("../.gitleaks.toml", import.meta.url));
-  return existsSync13(bundled) ? bundled : null;
+  return existsSync14(bundled) ? bundled : null;
 }
 function assertOverlayAllowlistsScoped(overlayBody) {
   if (OVERLAY_INLINE_ALLOWLIST_RE.test(overlayBody)) {
@@ -723,17 +723,17 @@ function buildOverlayTempConfig(overlayBody, bundled) {
 path = ${JSON.stringify(bundled)}
 ${overlayBody}`;
-  const tempPath = mkdtempSync(join15(tmpdir(), "nomad-gitleaks-cfg-"));
-  const configPath = join15(tempPath, "config.toml");
+  const tempPath = mkdtempSync(join16(tmpdir(), "nomad-gitleaks-cfg-"));
+  const configPath = join16(tempPath, "config.toml");
   writeFileSync3(configPath, tempBody, { mode: 384, flag: "wx" });
   return { configPath, tempPath };
 }
 function resolveTomlConfig() {
   const repo = repoHome();
-  const overlayPath = join15(repo, ".gitleaks.overlay.toml");
-  const repoToml = join15(repo, ".gitleaks.toml");
+  const overlayPath = join16(repo, ".gitleaks.overlay.toml");
+  const repoToml = join16(repo, ".gitleaks.toml");
   const bundled = resolveTomlPath(repo);
-  if (!existsSync13(overlayPath)) {
+  if (!existsSync14(overlayPath)) {
     return { path: bundled, tempPath: null };
   }
   if (bundled === repoToml) {
@@ -779,10 +779,10 @@ var init_push_gitleaks_config = __esm({
 });
 // src/push-checks.ts
-import { execFileSync as execFileSync3 } from "node:child_process";
-import { readdirSync as readdirSync4, rmSync as rmSync5 } from "node:fs";
+import { execFileSync as execFileSync4 } from "node:child_process";
+import { readdirSync as readdirSync5, rmSync as rmSync5 } from "node:fs";
 import { homedir as homedir2, platform } from "node:os";
-import { join as join16 } from "node:path";
+import { join as join17 } from "node:path";
 function gitleaksInstallHint() {
   const head = "gitleaks not on PATH (required for nomad push). Install:";
   const plat = platform();
@@ -820,12 +820,12 @@ function findGitlinks(dir) {
   function walk(current) {
     let entries;
     try {
-      entries = readdirSync4(current, { withFileTypes: true });
+      entries = readdirSync5(current, { withFileTypes: true });
     } catch {
       return;
     }
     for (const e of entries) {
-      const p = join16(current, e.name);
+      const p = join17(current, e.name);
       if (e.name === ".git") {
         hits.push(p);
         continue;
@@ -841,7 +841,7 @@ function probeGitleaks() {
   const args = ["version"];
   if (toml !== null) args.push("--config", toml);
   try {
-    return execFileSync3("gitleaks", args, { stdio: ["ignore", "pipe", "pipe"] }).toString().trim();
+    return execFileSync4("gitleaks", args, { stdio: ["ignore", "pipe", "pipe"] }).toString().trim();
   } catch (err) {
     const e = err;
     if (e.code === "ENOENT") throw new NomadFatal(gitleaksInstallHint());
@@ -861,7 +861,7 @@ function rebaseBeforePush(repo) {
   const wedge = classifyWedge(repo);
   if (wedge !== null) throw new NomadFatal(wedgePreflight(wedge));
   try {
-    execFileSync3("git", ["pull", "--rebase", "--autostash"], {
+    execFileSync4("git", ["pull", "--rebase", "--autostash"], {
       cwd: repo,
       stdio: ["ignore", "pipe", "pipe"]
     });
@@ -883,10 +883,10 @@ var init_push_checks = __esm({
 });
 // src/push-gitleaks.scan.ts
-import { execFileSync as execFileSync6 } from "node:child_process";
+import { execFileSync as execFileSync8 } from "node:child_process";
 import { mkdirSync as mkdirSync3, readFileSync as readFileSync5, rmSync as rmSync6 } from "node:fs";
 import { homedir as homedir3 } from "node:os";
-import { join as join20 } from "node:path";
+import { join as join21 } from "node:path";
 function readGitleaksReport(reportPath) {
   try {
     const raw = readFileSync5(reportPath, "utf8");
@@ -898,9 +898,9 @@ function readGitleaksReport(reportPath) {
   }
 }
 function scanStagedTree(repoDir, forwardStreams = false) {
-  const cacheDir = join20(homedir3(), ".cache", "claude-nomad");
+  const cacheDir = join21(homedir3(), ".cache", "claude-nomad");
   mkdirSync3(cacheDir, { recursive: true });
-  const reportPath = join20(cacheDir, `gitleaks-${nowTimestamp()}-${process.pid}.json`);
+  const reportPath = join21(cacheDir, `gitleaks-${nowTimestamp()}-${process.pid}.json`);
   const { path: toml, tempPath } = resolveTomlConfig();
   const args = [
     "protect",
@@ -913,9 +913,9 @@ function scanStagedTree(repoDir, forwardStreams = false) {
   if (toml !== null) args.push("--config", toml);
   const opts = { cwd: repoDir, stdio: ["ignore", "pipe", "pipe"] };
   try {
-    execFileSync6("git", ["init", "-q"], opts);
-    execFileSync6("git", ["add", "-A"], opts);
-    execFileSync6("gitleaks", args, opts);
+    execFileSync8("git", ["init", "-q"], opts);
+    execFileSync8("git", ["add", "-A"], opts);
+    execFileSync8("gitleaks", args, opts);
     return [];
   } catch (err) {
     const e = err;
@@ -932,9 +932,9 @@ function scanStagedTree(repoDir, forwardStreams = false) {
   }
 }
 function scanFile(filePath, forwardStreams = false) {
-  const cacheDir = join20(homedir3(), ".cache", "claude-nomad");
+  const cacheDir = join21(homedir3(), ".cache", "claude-nomad");
   mkdirSync3(cacheDir, { recursive: true });
-  const reportPath = join20(cacheDir, `gitleaks-file-${nowTimestamp()}-${process.pid}.json`);
+  const reportPath = join21(cacheDir, `gitleaks-file-${nowTimestamp()}-${process.pid}.json`);
   const { path: toml, tempPath } = resolveTomlConfig();
   const args = [
     "detect",
@@ -947,7 +947,7 @@ function scanFile(filePath, forwardStreams = false) {
   if (toml !== null) args.push("--config", toml);
   const opts = { stdio: ["ignore", "pipe", "pipe"] };
   try {
-    execFileSync6("gitleaks", args, opts);
+    execFileSync8("gitleaks", args, opts);
     return [];
   } catch (err) {
     const e = err;
@@ -1505,6 +1505,14 @@ function partitionByCaptureExclusion(keys) {
   }
   return { promotable, excluded };
 }
+function describeSettings(keys) {
+  const one = keys.length === 1;
+  return {
+    phrase: `${keys.length} ${one ? "setting" : "settings"} (${keys.join(", ")})`,
+    pronoun: one ? "it" : "them",
+    verb: one ? "is" : "are"
+  };
+}
 var BIN_NODE_RE = /^"?(?:[A-Za-z]:)?[\\/](?:.*[\\/])?bin[\\/]node"?$/;
 var LEADING_BIN_NODE_RE = /^"?(?:[A-Za-z]:)?[\\/](?:[^"\s]*[\\/])?bin[\\/]node"?(?=\s)/;
 function normalizeNodePathsDeep(value) {
@@ -1614,14 +1622,16 @@ function regenerateSettings(ts, opts = {}) {
       const existing = readJson(settingsPath);
       const drift = classifySettingsDrift(merged, existing);
       if (drift.behind.length > 0) {
+        const { phrase, pronoun } = describeSettings(drift.behind);
         warn(
-          `existing settings.json is missing merged keys ${JSON.stringify(drift.behind)}. Run 'nomad pull' to restore them.`
+          `your settings.json is missing ${phrase} that the synced copy has; run 'nomad pull' to restore ${pronoun}.`
         );
       }
       const { promotable } = partitionByCaptureExclusion(drift.ahead);
       if (promotable.length > 0) {
+        const { phrase, pronoun, verb } = describeSettings(promotable);
         warn(
-          `existing settings.json has local-only keys ${JSON.stringify(promotable)}. Run 'nomad capture-settings' to promote them into the repo before they are overwritten.`
+          `your settings.json has ${phrase} that ${verb} not yet synced; run 'nomad capture-settings' to save ${pronoun} to the repo before the next pull overwrites ${pronoun}.`
         );
       }
     } catch {
@@ -2063,13 +2073,13 @@ function cmdEject(opts = {}, roots = defaultEjectRoots()) {
 }
 // src/commands.doctor.ts
-import { existsSync as existsSync29 } from "node:fs";
-import { join as join35 } from "node:path";
+import { existsSync as existsSync30 } from "node:fs";
+import { join as join36 } from "node:path";
 // src/commands.doctor.checks.repo.ts
 init_color();
 init_config();
-import { existsSync as existsSync9, lstatSync as lstatSync6, statSync as statSync3 } from "node:fs";
+import { existsSync as existsSync9, lstatSync as lstatSync6, readdirSync as readdirSync2, statSync as statSync3 } from "node:fs";
 import { join as join11 } from "node:path";
 // src/commands.doctor.format.ts
@@ -2189,6 +2199,7 @@ function reasonForPartial(repoHome2, host) {
 }
 // src/commands.doctor.checks.repo.ts
+init_utils_json();
 function isOverrideActive() {
   return Boolean(process.env.NOMAD_REPO);
 }
@@ -2206,6 +2217,46 @@ function reportHostAndPaths(section2) {
     `${existsSync9(claude) ? green(okGlyph) : yellow(warnGlyph)} claude home: ${blue(claude)}`
   );
 }
+function pathMapHostKeys() {
+  const mapPath = join11(repoHome(), "path-map.json");
+  if (!existsSync9(mapPath)) return /* @__PURE__ */ new Set();
+  let raw;
+  try {
+    raw = readJson(mapPath);
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+  if (validatePathMapShape(raw) !== null) return /* @__PURE__ */ new Set();
+  const keys = /* @__PURE__ */ new Set();
+  for (const hosts of Object.values(raw.projects)) {
+    for (const key of Object.keys(hosts)) keys.add(key);
+  }
+  return keys;
+}
+function hostOverrideLabels() {
+  let entries;
+  try {
+    entries = readdirSync2(join11(repoHome(), "hosts"));
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+  const labels = /* @__PURE__ */ new Set();
+  for (const entry of entries) {
+    if (entry.endsWith(".json")) labels.add(entry.slice(0, -".json".length));
+  }
+  return labels;
+}
+function reportHostKeyAlignment(section2) {
+  if (process.env.NOMAD_HOST) return;
+  const overrideLabels = hostOverrideLabels();
+  const mapKeys = pathMapHostKeys();
+  if (overrideLabels.has(HOST) || mapKeys.has(HOST)) return;
+  if (overrideLabels.size === 0 && mapKeys.size === 0) return;
+  addItem(
+    section2,
+    `${yellow(warnGlyph)} NOMAD_HOST unset: this repo configures other hosts, but the hostname key ${cyan(HOST)} matches no hosts/${HOST}.json or path-map entry; set NOMAD_HOST to the label this host should use so per-host settings and session sync line up`
+  );
+}
 function reportRepoState(section2) {
   const repo = repoHome();
   const state = classifyRepoState(repo, HOST);
@@ -2301,7 +2352,7 @@ function reportDroppedNamesMigration(section2) {
 // src/commands.doctor.checks.settings.ts
 init_color();
 init_config();
-import { existsSync as existsSync10, readdirSync as readdirSync2 } from "node:fs";
+import { existsSync as existsSync10, readdirSync as readdirSync3 } from "node:fs";
 import { join as join12 } from "node:path";
 function loadBaseSettings(section2) {
   const basePath = join12(repoHome(), "shared", "settings.base.json");
@@ -2347,7 +2398,7 @@ function reportHostOverrides(section2, base, settings) {
     );
     const hostsDir = join12(repo, "hosts");
     if (existsSync10(hostsDir)) {
-      const cands = readdirSync2(hostsDir).filter((f) => f.endsWith(".json"));
+      const cands = readdirSync3(hostsDir).filter((f) => f.endsWith(".json"));
       if (cands.length > 0) addItem(section2, `${dim(infoGlyph)} candidates: ${cands.join(", ")}`);
     }
     process.exitCode = 1;
@@ -2362,7 +2413,7 @@ function reportHostOverrides(section2, base, settings) {
 // src/commands.doctor.checks.pathmap.ts
 init_color();
 init_config();
-import { existsSync as existsSync11, readdirSync as readdirSync3 } from "node:fs";
+import { existsSync as existsSync11, readdirSync as readdirSync4 } from "node:fs";
 import { join as join13 } from "node:path";
 init_utils_json();
 function reportMappedProjects(section2, map) {
@@ -2377,7 +2428,7 @@ function reportUnmappedProjects(section2, map) {
   if (!existsSync11(localProjects)) return;
   let localDirs;
   try {
-    localDirs = readdirSync3(localProjects);
+    localDirs = readdirSync4(localProjects);
   } catch {
     return;
   }
@@ -2391,6 +2442,18 @@ function reportUnmappedProjects(section2, map) {
     addChildItem(section2, dim(dir));
   }
 }
+function reportCurrentHostPathsMissing(section2, map) {
+  for (const [name, hosts] of Object.entries(map.projects)) {
+    const abspath = hosts[HOST];
+    if (!abspath || abspath === "TBD") continue;
+    if (!existsSync11(abspath)) {
+      addItem(
+        section2,
+        `${yellow(warnGlyph)} path-map: ${name} local path missing on ${HOST}: ${blue(abspath)}`
+      );
+    }
+  }
+}
 function reportPathCollisions(section2, map) {
   const seen = /* @__PURE__ */ new Map();
   let collisionCount = 0;
@@ -2429,6 +2492,7 @@ function reportPathMap(section2) {
     return;
   }
   reportMappedProjects(section2, map);
+  reportCurrentHostPathsMissing(section2, map);
   reportUnmappedProjects(section2, map);
   reportPathCollisions(section2, map);
 }
@@ -2441,18 +2505,103 @@ function reportNeverSync(section2) {
   );
 }
+// src/commands.doctor.checks.skills.ts
+init_color();
+import { existsSync as existsSync12 } from "node:fs";
+import { join as join14 } from "node:path";
+init_config();
+// src/extras-sync.diff.ts
+init_utils();
+import { execFileSync as execFileSync2 } from "node:child_process";
+function labelDiffLine(line) {
+  const tab = line.indexOf("	");
+  if (tab === -1) return line;
+  const status = line.slice(0, tab);
+  const path = line.slice(tab + 1);
+  if (status === "D") return `${path} (local only)`;
+  if (status === "A") return `${path} (repo only)`;
+  return path;
+}
+function parseDiffOutput(stdout) {
+  return stdout.split("\n").filter((line) => line.length > 0).map(labelDiffLine);
+}
+function listDivergingFiles(a, b) {
+  try {
+    const stdout = execFileSync2("git", ["diff", "--no-index", "--name-status", a, b], {
+      stdio: ["ignore", "pipe", "pipe"]
+    }).toString();
+    return parseDiffOutput(stdout);
+  } catch (err) {
+    const e = err;
+    if (e.status === 1 && e.stdout !== void 0) {
+      return parseDiffOutput(e.stdout.toString());
+    }
+    if (e.code === "ENOENT") {
+      warn(`git not on PATH; divergence check skipped for ${a}`);
+      return [];
+    }
+    warn(`divergence check failed for ${a}: ${e.message ?? String(err)}`);
+    return [];
+  }
+}
+// src/commands.doctor.checks.skills.ts
+function stripSideIndicator(line) {
+  if (line.endsWith(" (local only)")) return line.slice(0, -" (local only)".length);
+  if (line.endsWith(" (repo only)")) return line.slice(0, -" (repo only)".length);
+  return line;
+}
+function isGsdDiffLine(line, localBase, sharedBase) {
+  const bare = stripSideIndicator(line);
+  let relative6;
+  if (bare.startsWith(localBase + "/")) {
+    relative6 = bare.slice(localBase.length + 1);
+  } else if (bare.startsWith(sharedBase + "/")) {
+    relative6 = bare.slice(sharedBase.length + 1);
+  } else {
+    relative6 = bare;
+  }
+  return relative6.split("/")[0].startsWith(GSD_PREFIX);
+}
+function reportSkillsDivergence(section2) {
+  const sharedSkills = join14(repoHome(), "shared", "skills");
+  const localSkills = join14(claudeHome(), "skills");
+  if (!existsSync12(sharedSkills)) {
+    addItem(section2, `${dim(infoGlyph)} skills: no shared/skills/ to compare`);
+    return;
+  }
+  if (!existsSync12(localSkills)) {
+    addItem(section2, `${dim(infoGlyph)} skills: no local skills/ to compare`);
+    return;
+  }
+  const diff = listDivergingFiles(localSkills, sharedSkills);
+  const relevant = diff.filter((line) => !isGsdDiffLine(line, localSkills, sharedSkills));
+  if (relevant.length === 0) {
+    addItem(section2, `${green(okGlyph)} skills: in sync with shared/skills/`);
+    return;
+  }
+  addItem(
+    section2,
+    `${yellow(warnGlyph)} skills: ${relevant.length} file(s) diverge from shared/skills/`
+  );
+  for (const f of relevant) {
+    addChildItem(section2, f);
+  }
+}
 // src/commands.doctor.checks.git-state.ts
 init_color();
 init_config();
-import { execFileSync as execFileSync4 } from "node:child_process";
-import { existsSync as existsSync14 } from "node:fs";
-import { join as join17, relative as relative2 } from "node:path";
+import { execFileSync as execFileSync5 } from "node:child_process";
+import { existsSync as existsSync15 } from "node:fs";
+import { join as join18, relative as relative2 } from "node:path";
 init_commands_pull_wedge();
 init_push_checks();
 init_utils();
 function reportGitleaksProbe(section2) {
   try {
-    execFileSync4("gitleaks", ["version"], { stdio: ["ignore", "pipe", "pipe"] });
+    execFileSync5("gitleaks", ["version"], { stdio: ["ignore", "pipe", "pipe"] });
     return true;
   } catch (err) {
     if (err.code === "ENOENT") {
@@ -2469,8 +2618,8 @@ function reportGitleaksProbe(section2) {
 }
 function reportGitlinks(section2) {
   const repo = repoHome();
-  const sharedDir = join17(repo, "shared");
-  if (existsSync14(sharedDir)) {
+  const sharedDir = join18(repo, "shared");
+  if (existsSync15(sharedDir)) {
     const gitlinks = findGitlinks(sharedDir);
     for (const p of gitlinks) {
       const rel = relative2(repo, p);
@@ -2488,7 +2637,7 @@ function reportGitlinks(section2) {
 }
 function reportRemote(section2) {
   try {
-    const url = execFileSync4("git", ["remote", "get-url", "origin"], {
+    const url = execFileSync5("git", ["remote", "get-url", "origin"], {
       cwd: repoHome(),
       stdio: ["ignore", "pipe", "pipe"]
     }).toString().trim();
@@ -2540,16 +2689,41 @@ function reportOrphanedAutostash(sec) {
   } catch {
   }
 }
+function reportGitIdentity(section2) {
+  const repo = repoHome();
+  const missing = [];
+  for (const field of ["user.name", "user.email"]) {
+    try {
+      const val = execFileSync5("git", ["config", field], {
+        cwd: repo,
+        stdio: ["ignore", "pipe", "pipe"]
+      }).toString().trim();
+      if (!val) missing.push(field);
+    } catch (err) {
+      if (err.status === 1) missing.push(field);
+      else return;
+    }
+  }
+  if (missing.length > 0) {
+    const hint = missing.map((f) => `git config ${f} "..."`).join(" / ");
+    addItem(
+      section2,
+      `${yellow(warnGlyph)} git identity: ${missing.join(", ")} not set (run: ${hint})`
+    );
+  } else {
+    addItem(section2, `${green(okGlyph)} git identity: user.name and user.email configured`);
+  }
+}
 // src/commands.doctor.checks.backups.ts
 init_color();
-import { existsSync as existsSync15, lstatSync as lstatSync7, readdirSync as readdirSync5 } from "node:fs";
-import { join as join18 } from "node:path";
+import { existsSync as existsSync16, lstatSync as lstatSync7, readdirSync as readdirSync6 } from "node:fs";
+import { join as join19 } from "node:path";
 init_config();
 var TS_SHAPE2 = /^\d{8}-\d{6}(-\d+)?$/;
 function safeReaddir(dir) {
   try {
-    return readdirSync5(dir);
+    return readdirSync6(dir);
   } catch {
     return [];
   }
@@ -2560,7 +2734,7 @@ var BYTES_PER_MB = 1024 * 1024;
 function dirSizeBytes(dir) {
   let bytes = 0;
   for (const entry of safeReaddir(dir)) {
-    const full = join18(dir, entry);
+    const full = join19(dir, entry);
     const st = lstatSync7(full, { throwIfNoEntry: false });
     if (!st) continue;
     if (st.isSymbolicLink()) continue;
@@ -2571,11 +2745,11 @@ function dirSizeBytes(dir) {
 }
 function totalSizeMb(backupBase2, dirs) {
   let bytes = 0;
-  for (const name of dirs) bytes += dirSizeBytes(join18(backupBase2, name));
+  for (const name of dirs) bytes += dirSizeBytes(join19(backupBase2, name));
   return bytes / BYTES_PER_MB;
 }
 function reportBackupsCheck(section2, backupBase2 = backupBase()) {
-  if (!existsSync15(backupBase2)) return;
+  if (!existsSync16(backupBase2)) return;
   const dirs = safeReaddir(backupBase2).filter((n) => TS_SHAPE2.test(n));
   const count = dirs.length;
   const sizeMb = totalSizeMb(backupBase2, dirs);
@@ -2587,16 +2761,83 @@ function reportBackupsCheck(section2, backupBase2 = backupBase()) {
   }
 }
+// src/commands.doctor.check-remote.ts
+init_color();
+import { execFileSync as execFileSync6 } from "node:child_process";
+init_config();
+init_utils_json();
+var GIT_REMOTE_TIMEOUT_MS = 3e3;
+function readRemotePathMap(sec, repo) {
+  let rawJson;
+  try {
+    rawJson = execFileSync6("git", ["show", "origin/main:path-map.json"], {
+      cwd: repo,
+      stdio: ["ignore", "pipe", "pipe"],
+      timeout: GIT_REMOTE_TIMEOUT_MS
+    }).toString();
+  } catch {
+    addItem(
+      sec,
+      `${yellow(warnGlyph)} remote check skipped (could not read path-map.json from origin/main)`
+    );
+    return false;
+  }
+  let map;
+  try {
+    map = JSON.parse(rawJson);
+  } catch {
+    addItem(sec, `${yellow(warnGlyph)} remote: path-map.json at origin/main is malformed JSON`);
+    return false;
+  }
+  const shapeError = validatePathMapShape(map);
+  if (shapeError !== null) {
+    addItem(
+      sec,
+      `${yellow(warnGlyph)} remote: path-map.json at origin/main has invalid shape: ${shapeError}`
+    );
+    return false;
+  }
+  return true;
+}
+function reportCheckRemote(section2) {
+  const repo = repoHome();
+  let names;
+  try {
+    const out = execFileSync6("git", ["ls-tree", "--name-only", "origin/main"], {
+      cwd: repo,
+      stdio: ["ignore", "pipe", "pipe"],
+      timeout: GIT_REMOTE_TIMEOUT_MS
+    }).toString().trim();
+    names = out.split("\n").filter(Boolean);
+  } catch {
+    addItem(
+      section2,
+      `${yellow(warnGlyph)} remote check skipped (origin/main unavailable or git error)`
+    );
+    return;
+  }
+  if (!names.includes("shared")) {
+    addItem(section2, `${yellow(warnGlyph)} remote: shared/ not found in origin/main`);
+    return;
+  }
+  if (!names.includes("path-map.json")) {
+    addItem(section2, `${yellow(warnGlyph)} remote: path-map.json not found in origin/main`);
+    return;
+  }
+  if (!readRemotePathMap(section2, repo)) return;
+  addItem(section2, `${green(okGlyph)} remote: origin/main has shared/ and a valid path-map.json`);
+}
 // src/commands.doctor.check-schema.ts
 init_color();
-import { existsSync as existsSync16 } from "node:fs";
-import { join as join19 } from "node:path";
+import { existsSync as existsSync17 } from "node:fs";
+import { join as join20 } from "node:path";
 init_config();
 // src/http-fetch.ts
-import { execFileSync as execFileSync5 } from "node:child_process";
+import { execFileSync as execFileSync7 } from "node:child_process";
 var FETCH_TIMEOUT_MS = 3e3;
-function fetchUrl(url, run = execFileSync5) {
+function fetchUrl(url, run = execFileSync7) {
   try {
     return run("curl", ["-fsSL", "-m", "3", url], {
       stdio: ["ignore", "pipe", "pipe"],
@@ -2627,8 +2868,8 @@ function fetchSchemaKeys() {
   }
 }
 function reportCheckSchema(section2) {
-  const settingsPath = join19(claudeHome(), "settings.json");
-  if (!existsSync16(settingsPath)) {
+  const settingsPath = join20(claudeHome(), "settings.json");
+  if (!existsSync17(settingsPath)) {
     addItem(section2, `${dim(infoGlyph)} no ~/.claude/settings.json to check`);
     return;
   }
@@ -2657,19 +2898,19 @@ function reportCheckSchema(section2) {
 // src/commands.doctor.check-shared.ts
 init_color();
 import { randomBytes } from "node:crypto";
-import { execFileSync as execFileSync7 } from "node:child_process";
-import { existsSync as existsSync18, mkdirSync as mkdirSync5, readdirSync as readdirSync7, rmSync as rmSync8 } from "node:fs";
+import { execFileSync as execFileSync9 } from "node:child_process";
+import { existsSync as existsSync19, mkdirSync as mkdirSync5, readdirSync as readdirSync8, rmSync as rmSync8 } from "node:fs";
 import { homedir as homedir4 } from "node:os";
-import { join as join23 } from "node:path";
+import { join as join24 } from "node:path";
 // src/commands.doctor.check-shared.scan.ts
 init_color();
-import { join as join21 } from "node:path";
+import { join as join22 } from "node:path";
 init_config();
 init_push_gitleaks();
 function scrubPath(logical, sid, logicalToEncoded) {
   const encoded = logicalToEncoded.get(logical) ?? logical;
-  return join21(claudeHome(), "projects", encoded, `${sid}.jsonl`);
+  return join22(claudeHome(), "projects", encoded, `${sid}.jsonl`);
 }
 function reportSessionFindings(section2, bySession) {
   for (const [sid, counts] of bySession) {
@@ -2757,8 +2998,8 @@ init_config();
 // src/remap.ts
 init_config_sharedDirs_guard();
-import { cpSync as cpSync4, existsSync as existsSync17, mkdirSync as mkdirSync4, readdirSync as readdirSync6, renameSync as renameSync3, rmSync as rmSync7, statSync as statSync4 } from "node:fs";
-import { join as join22, relative as relative3, sep as sep3 } from "node:path";
+import { cpSync as cpSync4, existsSync as existsSync18, mkdirSync as mkdirSync4, readdirSync as readdirSync7, renameSync as renameSync3, rmSync as rmSync7, statSync as statSync4 } from "node:fs";
+import { join as join23, relative as relative3, sep as sep3 } from "node:path";
 // src/extras-sync.guards.ts
 init_utils();
@@ -2819,15 +3060,15 @@ function remapPull(ts, opts = {}) {
   const wouldPull = [];
   const repo = repoHome();
   const claude = claudeHome();
-  const mapPath = join22(repo, "path-map.json");
-  const repoProjects = join22(repo, "shared", "projects");
-  if (!existsSync17(mapPath) || !existsSync17(repoProjects)) {
+  const mapPath = join23(repo, "path-map.json");
+  const repoProjects = join23(repo, "shared", "projects");
+  if (!existsSync18(mapPath) || !existsSync18(repoProjects)) {
     const text = "no path-map or repo projects dir; skipping session remap";
     emitPreview(opts.onPreview, { kind: "note", text }, text);
     return { unmapped: 0, pulled, wouldPull };
   }
   const map = readPathMap(mapPath);
-  const localProjects = join22(claude, "projects");
+  const localProjects = join23(claude, "projects");
   if (!dryRun) mkdirSync4(localProjects, { recursive: true });
   for (const [logical, hosts] of Object.entries(map.projects)) {
     assertSafeLogical(logical);
@@ -2837,9 +3078,9 @@ function remapPull(ts, opts = {}) {
       continue;
     }
     assertSafeLocalRoot(localPath, logical);
-    const src = join22(repoProjects, logical);
-    if (!existsSync17(src)) continue;
-    const dst = join22(localProjects, encodePath(localPath));
+    const src = join23(repoProjects, logical);
+    if (!existsSync18(src)) continue;
+    const dst = join23(localProjects, encodePath(localPath));
     if (dryRun) {
       wouldPull.push(logical);
       emitPreview(
@@ -2886,31 +3127,31 @@ function remapPush(ts, opts = {}) {
   const wouldPush = [];
   const repo = repoHome();
   const claude = claudeHome();
-  const mapPath = join22(repo, "path-map.json");
-  if (!existsSync17(mapPath)) {
+  const mapPath = join23(repo, "path-map.json");
+  if (!existsSync18(mapPath)) {
     log("no path-map.json; skipping session export");
     return { unmapped: 0, collisions: 0, pushed, wouldPush };
   }
   const map = readPathMap(mapPath);
-  const localProjects = join22(claude, "projects");
-  const repoProjects = join22(repo, "shared", "projects");
+  const localProjects = join23(claude, "projects");
+  const repoProjects = join23(repo, "shared", "projects");
   const reverse = buildReverseMap(map);
-  if (!existsSync17(localProjects)) return { unmapped, collisions: 0, pushed, wouldPush };
+  if (!existsSync18(localProjects)) return { unmapped, collisions: 0, pushed, wouldPush };
   if (!dryRun) mkdirSync4(repoProjects, { recursive: true });
-  for (const dir of readdirSync6(localProjects)) {
+  for (const dir of readdirSync7(localProjects)) {
     if (dir.endsWith(TMP_SUFFIX)) continue;
     const logical = reverse.get(dir);
     if (!logical) {
       unmapped++;
       continue;
     }
-    const repoDst = join22(repoProjects, logical);
+    const repoDst = join23(repoProjects, logical);
     if (dryRun) {
       wouldPush.push(logical);
       continue;
     }
     backupRepoWrite(repoDst, ts, repo);
-    copyDirJsonlOnly(join22(localProjects, dir), repoDst);
+    copyDirJsonlOnly(join23(localProjects, dir), repoDst);
     pushed.push(logical);
   }
   return { unmapped, collisions: 0, pushed, wouldPush };
@@ -2923,8 +3164,8 @@ function buildScanTree(tmpRoot) {
   const logicalToEncoded = /* @__PURE__ */ new Map();
   let staged = 0;
   const repo = repoHome();
-  const mapPath = join23(repo, "path-map.json");
-  if (!existsSync18(mapPath)) return { logicalToEncoded, staged, malformed: false };
+  const mapPath = join24(repo, "path-map.json");
+  if (!existsSync19(mapPath)) return { logicalToEncoded, staged, malformed: false };
   let map;
   try {
     map = readJson(mapPath);
@@ -2941,12 +3182,12 @@ function buildScanTree(tmpRoot) {
     if (!p || p === "TBD") continue;
     reverse.set(encodePath(p), logical);
   }
-  const localProjects = join23(claudeHome(), "projects");
-  if (!existsSync18(localProjects)) return { logicalToEncoded, staged, malformed: false };
-  for (const dir of readdirSync7(localProjects)) {
+  const localProjects = join24(claudeHome(), "projects");
+  if (!existsSync19(localProjects)) return { logicalToEncoded, staged, malformed: false };
+  for (const dir of readdirSync8(localProjects)) {
     const logical = reverse.get(dir);
     if (!logical) continue;
-    copyDirJsonlOnly(join23(localProjects, dir), join23(tmpRoot, "shared", "projects", logical));
+    copyDirJsonlOnly(join24(localProjects, dir), join24(tmpRoot, "shared", "projects", logical));
     logicalToEncoded.set(logical, dir);
     staged++;
   }
@@ -2954,7 +3195,7 @@ function buildScanTree(tmpRoot) {
 }
 function probeGitleaksForScan() {
   try {
-    execFileSync7("gitleaks", ["version"], { stdio: ["ignore", "pipe", "pipe"] });
+    execFileSync9("gitleaks", ["version"], { stdio: ["ignore", "pipe", "pipe"] });
     return "ok";
   } catch (err) {
     if (err.code === "ENOENT") return "missing";
@@ -2977,11 +3218,11 @@ function ensureGitleaksReady(section2, gitleaksReady) {
 }
 function reportCheckShared(section2, gitleaksReady) {
   if (!ensureGitleaksReady(section2, gitleaksReady)) return;
-  const cacheDir = join23(homedir4(), ".cache", "claude-nomad");
+  const cacheDir = join24(homedir4(), ".cache", "claude-nomad");
   mkdirSync5(cacheDir, { recursive: true });
   const stamp = `${nowTimestamp()}-${process.pid}-${randomBytes(4).toString("hex")}`;
-  const reportPath = join23(cacheDir, `check-shared-${stamp}.json`);
-  const tmpRoot = join23(cacheDir, `check-shared-tree-${stamp}`);
+  const reportPath = join24(cacheDir, `check-shared-${stamp}.json`);
+  const tmpRoot = join24(cacheDir, `check-shared-tree-${stamp}`);
   try {
     const { logicalToEncoded, staged, malformed } = buildScanTree(tmpRoot);
     if (malformed) {
@@ -3002,8 +3243,8 @@ function reportCheckShared(section2, gitleaksReady) {
 // src/commands.doctor.checks.hooks.scope.ts
 init_color();
-import { existsSync as existsSync19, readFileSync as readFileSync6, readdirSync as readdirSync8, realpathSync as realpathSync2 } from "node:fs";
-import { dirname as dirname3, extname, join as join24 } from "node:path";
+import { existsSync as existsSync20, readFileSync as readFileSync6, readdirSync as readdirSync9, realpathSync as realpathSync2 } from "node:fs";
+import { dirname as dirname3, extname, join as join25 } from "node:path";
 init_config();
 function typeFromPackageJson(pkgPath) {
   try {
@@ -3025,8 +3266,8 @@ function effectiveType(hookPath) {
   }
   let dir = dirname3(real);
   for (; ; ) {
-    const pkg = join24(dir, "package.json");
-    if (existsSync19(pkg)) return typeFromPackageJson(pkg);
+    const pkg = join25(dir, "package.json");
+    if (existsSync20(pkg)) return typeFromPackageJson(pkg);
     const parent = dirname3(dir);
     if (parent === dir) return "cjs";
     dir = parent;
@@ -3055,7 +3296,7 @@ function remedy(family) {
 }
 function safeReaddir2(dir) {
   try {
-    return readdirSync8(dir);
+    return readdirSync9(dir);
   } catch {
     return [];
   }
@@ -3068,15 +3309,15 @@ function safeRead(path) {
   }
 }
 function reportHookScopeCheck(section2) {
-  const hooksDir = join24(claudeHome(), "hooks");
-  if (!existsSync19(hooksDir)) {
+  const hooksDir = join25(claudeHome(), "hooks");
+  if (!existsSync20(hooksDir)) {
     addItem(section2, `${dim(infoGlyph)} no ~/.claude/hooks; skipping module-scope check`);
     return;
   }
   let anyWarn = false;
   for (const name of safeReaddir2(hooksDir)) {
     if (extname(name) !== ".js") continue;
-    const abs = join24(hooksDir, name);
+    const abs = join25(hooksDir, name);
     const eff = effectiveType(abs);
     if (eff === null) continue;
     const src = safeRead(abs);
@@ -3096,8 +3337,8 @@ function reportHookScopeCheck(section2) {
 // src/commands.doctor.checks.hooks.ts
 init_color();
-import { existsSync as existsSync20 } from "node:fs";
-import { join as join25 } from "node:path";
+import { existsSync as existsSync21 } from "node:fs";
+import { join as join26 } from "node:path";
 init_config();
 function expandHome(token) {
   const h2 = home();
@@ -3136,7 +3377,7 @@ function checkEventGroups(section2, event, groups) {
   for (const group of groups) {
     for (const cmd of commandsFromGroup(group)) {
       for (const resolved of claudePathsIn(cmd)) {
-        if (existsSync20(resolved)) continue;
+        if (existsSync21(resolved)) continue;
         addItem(
           section2,
           `${red(failGlyph)} hooks/${event}: command target missing: ${resolved} (run nomad pull)`
@@ -3149,8 +3390,8 @@ function checkEventGroups(section2, event, groups) {
   return anyFail;
 }
 function reportHooksTargetCheck(section2) {
-  const settingsPath = join25(claudeHome(), "settings.json");
-  if (!existsSync20(settingsPath)) {
+  const settingsPath = join26(claudeHome(), "settings.json");
+  if (!existsSync21(settingsPath)) {
     addItem(section2, `${dim(infoGlyph)} no ~/.claude/settings.json; skipping hook target check`);
     return;
   }
@@ -3173,12 +3414,12 @@ function reportHooksTargetCheck(section2) {
 // src/commands.doctor.checks.hooks.preserve-symlinks.ts
 init_color();
-import { existsSync as existsSync22, readFileSync as readFileSync7 } from "node:fs";
-import { join as join27 } from "node:path";
+import { existsSync as existsSync23, readFileSync as readFileSync7 } from "node:fs";
+import { join as join28 } from "node:path";
 // src/commands.doctor.checks.hooks.preserve-symlinks.probe.ts
-import { closeSync as closeSync3, existsSync as existsSync21, openSync as openSync3, readSync, realpathSync as realpathSync3 } from "node:fs";
-import { dirname as dirname4, join as join26, resolve as resolve2 } from "node:path";
+import { closeSync as closeSync3, existsSync as existsSync22, openSync as openSync3, readSync, realpathSync as realpathSync3 } from "node:fs";
+import { dirname as dirname4, join as join27, resolve as resolve2 } from "node:path";
 function suppressedRanges(src) {
   const ranges = [];
   const re = /\/\*[\s\S]*?\*\/|\/\/[^\n]*|'[^']*'|"[^"]*"|`[^`]*`/g;
@@ -3210,12 +3451,12 @@ function topRelativeSpecifiers(src) {
 }
 function specifierIsMissing(specifier, baseDir) {
   const base = resolve2(baseDir, specifier);
-  if (existsSync21(base)) return false;
+  if (existsSync22(base)) return false;
   for (const ext of [".js", ".cjs", ".mjs"]) {
-    if (existsSync21(base + ext)) return false;
+    if (existsSync22(base + ext)) return false;
   }
   for (const idx of ["index.js", "index.cjs", "index.mjs"]) {
-    if (existsSync21(join26(base, idx))) return false;
+    if (existsSync22(join27(base, idx))) return false;
   }
   return true;
 }
@@ -3270,8 +3511,8 @@ function commandTokens(command) {
   return tokens;
 }
 function readPathMapSafe() {
-  const mapPath = join27(repoHome(), "path-map.json");
-  if (!existsSync22(mapPath)) return { projects: {} };
+  const mapPath = join28(repoHome(), "path-map.json");
+  if (!existsSync23(mapPath)) return { projects: {} };
   try {
     return JSON.parse(readFileSync7(mapPath, "utf8"));
   } catch {
@@ -3344,8 +3585,8 @@ function checkEventForPreserveSymlinks(section2, event, groups, sharedLinkNames)
   return anyWarn;
 }
 function reportPreserveSymlinksCheck(section2) {
-  const settingsPath = join27(claudeHome(), "settings.json");
-  if (!existsSync22(settingsPath)) {
+  const settingsPath = join28(claudeHome(), "settings.json");
+  if (!existsSync23(settingsPath)) {
     addItem(
       section2,
       `${dim(infoGlyph)} no ~/.claude/settings.json; skipping preserve-symlinks-main check`
@@ -3378,8 +3619,8 @@ function reportPreserveSymlinksCheck(section2) {
 // src/commands.doctor.checks.settings-drift.ts
 init_color();
-import { existsSync as existsSync23, readFileSync as readFileSync8 } from "node:fs";
-import { join as join28 } from "node:path";
+import { existsSync as existsSync24, readFileSync as readFileSync8 } from "node:fs";
+import { join as join29 } from "node:path";
 init_config();
 init_utils_json();
 function diffMergedSettings(merged, settings) {
@@ -3397,7 +3638,7 @@ function tryReadJson(filePath) {
   }
 }
 function reportHooksBaseSelfCleanNote(section2) {
-  const basePath = join28(repoHome(), "shared", "settings.base.json");
+  const basePath = join29(repoHome(), "shared", "settings.base.json");
   const base = tryReadJson(basePath);
   if (base === null) return;
   if (!baseHasGsdHookEntries(base)) return;
@@ -3410,14 +3651,14 @@ function reportSettingsDriftCheck(section2) {
   const claude = claudeHome();
   const repo = repoHome();
   const host = HOST;
-  const settingsPath = join28(claude, "settings.json");
-  const basePath = join28(repo, "shared", "settings.base.json");
-  const hostPath = join28(repo, "hosts", `${host}.json`);
-  if (!existsSync23(settingsPath)) {
+  const settingsPath = join29(claude, "settings.json");
+  const basePath = join29(repo, "shared", "settings.base.json");
+  const hostPath = join29(repo, "hosts", `${host}.json`);
+  if (!existsSync24(settingsPath)) {
     addItem(section2, `${dim(infoGlyph)} no ~/.claude/settings.json; skipping merge-drift check`);
     return;
   }
-  if (!existsSync23(basePath)) {
+  if (!existsSync24(basePath)) {
     addItem(
       section2,
       `${dim(infoGlyph)} shared/settings.base.json missing; skipping merge-drift check`
@@ -3436,7 +3677,7 @@ function reportSettingsDriftCheck(section2) {
   if (settings === null) {
     return;
   }
-  const hostExists = existsSync23(hostPath);
+  const hostExists = existsSync24(hostPath);
   const hostObj = hostExists ? tryReadJson(hostPath) : null;
   if (hostExists && hostObj === null) {
     addItem(
@@ -3594,14 +3835,14 @@ function reportNodeEngineCheck(section2) {
 // src/spinner.ts
 init_color();
-import { existsSync as existsSync27 } from "node:fs";
+import { existsSync as existsSync28 } from "node:fs";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 import { Worker } from "node:worker_threads";
 // src/commands.push.recovery.ts
 init_config();
 import { readFileSync as readFileSync13, rmSync as rmSync10, writeFileSync as writeFileSync5 } from "node:fs";
-import { join as join33 } from "node:path";
+import { join as join34 } from "node:path";
 import { createInterface as createInterface2 } from "node:readline/promises";
 // src/commands.push.recovery.actions.ts
@@ -3612,25 +3853,25 @@ import { isAbsolute as isAbsolute2, resolve as resolve3, sep as sep5 } from "nod
 // src/commands.push.recovery.redact.ts
 init_config();
 init_config_sharedDirs_guard();
-import { cpSync as cpSync5, existsSync as existsSync26, mkdirSync as mkdirSync6, statSync as statSync7 } from "node:fs";
-import { dirname as dirname6, join as join31, sep as sep4 } from "node:path";
+import { cpSync as cpSync5, existsSync as existsSync27, mkdirSync as mkdirSync6, statSync as statSync7 } from "node:fs";
+import { dirname as dirname6, join as join32, sep as sep4 } from "node:path";
 // src/commands.redact.ts
 init_config();
-import { existsSync as existsSync25, statSync as statSync6 } from "node:fs";
-import { dirname as dirname5, join as join30 } from "node:path";
+import { existsSync as existsSync26, statSync as statSync6 } from "node:fs";
+import { dirname as dirname5, join as join31 } from "node:path";
 // src/commands.redact.subtree.ts
-import { existsSync as existsSync24, lstatSync as lstatSync8, readFileSync as readFileSync11, readdirSync as readdirSync9, statSync as statSync5, writeFileSync as writeFileSync4 } from "node:fs";
-import { join as join29 } from "node:path";
+import { existsSync as existsSync25, lstatSync as lstatSync8, readFileSync as readFileSync11, readdirSync as readdirSync10, statSync as statSync5, writeFileSync as writeFileSync4 } from "node:fs";
+import { join as join30 } from "node:path";
 init_utils_fs();
 init_utils();
 function collectFiles(dir, out) {
-  if (!existsSync24(dir)) return;
+  if (!existsSync25(dir)) return;
   const st = lstatSync8(dir);
   if (!st.isDirectory()) return;
-  for (const entry of readdirSync9(dir)) {
-    const abs = join29(dir, entry);
+  for (const entry of readdirSync10(dir)) {
+    const abs = join30(dir, entry);
     const lst = lstatSync8(abs);
     if (lst.isSymbolicLink()) continue;
     if (lst.isDirectory()) {
@@ -3682,10 +3923,10 @@ function applySubtreeRedactions(mainPath, mainFindings, subtreeFiles, rule, ts,
 // src/commands.pushed-history.ts
 init_utils();
-import { execFileSync as execFileSync8 } from "node:child_process";
+import { execFileSync as execFileSync10 } from "node:child_process";
 function pushedRef(repo) {
   try {
-    const ref = execFileSync8("git", ["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}"], {
+    const ref = execFileSync10("git", ["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}"], {
       cwd: repo,
       stdio: ["ignore", "pipe", "ignore"]
     }).toString().trim();
@@ -3698,7 +3939,7 @@ function sessionInPushedHistory(id, repo) {
   const ref = pushedRef(repo);
   if (ref === null) return false;
   try {
-    const out = execFileSync8(
+    const out = execFileSync10(
       "git",
       [
         "log",
@@ -3735,15 +3976,15 @@ init_utils_json();
 init_utils();
 function resolveLiveTranscript(id) {
   try {
-    const mapPath = join30(repoHome(), "path-map.json");
-    if (!existsSync25(mapPath)) return null;
+    const mapPath = join31(repoHome(), "path-map.json");
+    if (!existsSync26(mapPath)) return null;
     const projects = readJson(mapPath).projects;
     const claude = claudeHome();
     for (const hostMap of Object.values(projects)) {
       const abs = hostMap[HOST];
       if (abs === void 0) continue;
-      const live = join30(claude, "projects", encodePath(abs), `${id}.jsonl`);
-      if (existsSync25(live)) return live;
+      const live = join31(claude, "projects", encodePath(abs), `${id}.jsonl`);
+      if (existsSync26(live)) return live;
     }
     return null;
   } catch {
@@ -3763,17 +4004,17 @@ function cmdRedact(opts, nowMs = Date.now, scan = scanFile) {
   }
   const repo = repoHome();
   const backup = backupBase();
-  if (!existsSync25(repo)) die(`repo not cloned at ${repo}`);
+  if (!existsSync26(repo)) die(`repo not cloned at ${repo}`);
   const handle = acquireLock("redact");
   if (handle === null) process.exit(0);
   try {
     const localPath = resolveLiveTranscript(id);
-    if (localPath === null || !existsSync25(localPath)) {
+    if (localPath === null || !existsSync26(localPath)) {
       fail(`could not resolve local transcript for session ${id} on this host`);
       process.exitCode = 1;
       return;
     }
-    const sessionDir = join30(dirname5(localPath), id);
+    const sessionDir = join31(dirname5(localPath), id);
     const subtreeFiles = listSubtreeFiles(sessionDir);
     const subtreeMtime = newestSubtreeMtimeMs(localPath, subtreeFiles, (p) => statSync6(p).mtimeMs);
     if (isRecentlyModified(subtreeMtime, nowMs())) {
@@ -3889,8 +4130,8 @@ function resolveStagedDir(localPath, map, claude, repo) {
     assertSafeLogical(logical);
     const abs = hostMap[HOST];
     if (abs === void 0) continue;
-    if (localPath.startsWith(join31(claude, "projects", encodePath(abs)) + sep4)) {
-      return join31(repo, "shared", "projects", logical);
+    if (localPath.startsWith(join32(claude, "projects", encodePath(abs)) + sep4)) {
+      return join32(repo, "shared", "projects", logical);
     }
   }
   return null;
@@ -3900,7 +4141,7 @@ function preflightRedactable(f, map, nowMs) {
   if (sid === null) return "a finding has no resolvable session id (not a session transcript)";
   const localPath = resolveLiveTranscript(sid);
   if (localPath === null) return `session ${sid}: local transcript not found`;
-  const sessionDir = join31(dirname6(localPath), sid);
+  const sessionDir = join32(dirname6(localPath), sid);
   const subtreeFiles = listSubtreeFiles(sessionDir);
   const subtreeMtime = newestSubtreeMtimeMs(localPath, subtreeFiles, (p) => statSync7(p).mtimeMs);
   if (isRecentlyModified(subtreeMtime, nowMs())) {
@@ -3930,7 +4171,7 @@ function applyRedact(f, ts, map, nowMs, scan = scanFile) {
       `could not locate the local transcript for session ${sid}; choose Skip or Drop session.`
     );
   }
-  const sessionDir = join31(dirname6(localPath), sid);
+  const sessionDir = join32(dirname6(localPath), sid);
   const subtreeFiles = listSubtreeFiles(sessionDir);
   const subtreeMtime = newestSubtreeMtimeMs(localPath, subtreeFiles, (p) => statSync7(p).mtimeMs);
   if (isRecentlyModified(subtreeMtime, nowMs())) {
@@ -3964,9 +4205,9 @@ function applyRedact(f, ts, map, nowMs, scan = scanFile) {
     );
   }
   mkdirSync6(stagedProjectDir, { recursive: true });
-  cpSync5(localPath, join31(stagedProjectDir, `${sid}.jsonl`), { force: true });
-  if (existsSync26(sessionDir)) {
-    cpSync5(sessionDir, join31(stagedProjectDir, sid), { force: true, recursive: true });
+  cpSync5(localPath, join32(stagedProjectDir, `${sid}.jsonl`), { force: true });
+  if (existsSync27(sessionDir)) {
+    cpSync5(sessionDir, join32(stagedProjectDir, sid), { force: true, recursive: true });
   }
   return true;
 }
@@ -3974,14 +4215,14 @@ function applyRedact(f, ts, map, nowMs, scan = scanFile) {
 // src/commands.push.recovery.drop.ts
 init_config();
 import { rmSync as rmSync9 } from "node:fs";
-import { join as join32 } from "node:path";
+import { join as join33 } from "node:path";
 function dropSessionFromStaged(sid, map) {
   const logicals = Object.keys(map.projects);
   if (logicals.length === 0) return false;
   const repo = repoHome();
   for (const logical of logicals) {
-    const jsonl = join32(repo, "shared", "projects", logical, `${sid}.jsonl`);
-    const dir = join32(repo, "shared", "projects", logical, sid);
+    const jsonl = join33(repo, "shared", "projects", logical, `${sid}.jsonl`);
+    const dir = join33(repo, "shared", "projects", logical, sid);
     rmSync9(jsonl, { force: true });
     rmSync9(dir, { recursive: true, force: true });
   }
@@ -4138,7 +4379,7 @@ function applyThenRescan(scanVerdict, repoHome2) {
   return next;
 }
 function allowThenRescan(append, scanVerdict, repoHome2) {
-  const ignPath = join33(repoHome2, ".gitleaksignore");
+  const ignPath = join34(repoHome2, ".gitleaksignore");
   let before;
   try {
     before = readFileSync13(ignPath, "utf8");
@@ -4237,7 +4478,7 @@ function writeAnimatedDone(out, label, ms, useTTY) {
 `);
 }
 function resolveWorkerPath(deps = {}) {
-  const check = deps.existsSyncFn ?? existsSync27;
+  const check = deps.existsSyncFn ?? existsSync28;
   const base = deps.baseUrl ?? import.meta.url;
   const mjs = fileURLToPath4(new URL("./nomad.worker.mjs", base));
   if (check(mjs)) return mjs;
@@ -4303,9 +4544,9 @@ function withSpinner(label, fn, deps) {
 // src/commands.doctor.gitleaks-version.ts
 init_color();
-import { execFileSync as execFileSync9 } from "node:child_process";
-import { existsSync as existsSync28 } from "node:fs";
-import { join as join34 } from "node:path";
+import { execFileSync as execFileSync11 } from "node:child_process";
+import { existsSync as existsSync29 } from "node:fs";
+import { join as join35 } from "node:path";
 init_config();
 var SEMVER_MAJOR_MINOR = /^(\d+)\.(\d+)\.\d+$/;
 var GITLEAKS_TIMEOUT_MS = 5e3;
@@ -4314,7 +4555,7 @@ function majorMinorOf(value) {
   return m === null ? null : [m[1], m[2]];
 }
 function readGitleaksVersion(run, tomlExists) {
-  const tomlPath = join34(repoHome(), ".gitleaks.toml");
+  const tomlPath = join35(repoHome(), ".gitleaks.toml");
   const args = ["version"];
   if (tomlExists(tomlPath)) args.push("--config", tomlPath);
   try {
@@ -4326,7 +4567,7 @@ function readGitleaksVersion(run, tomlExists) {
     return null;
   }
 }
-function reportGitleaksVersionCheck(section2, run = execFileSync9, tomlExists = existsSync28) {
+function reportGitleaksVersionCheck(section2, run = execFileSync11, tomlExists = existsSync29) {
   const raw = readGitleaksVersion(run, tomlExists);
   if (raw === null) return;
   const local = majorMinorOf(raw);
@@ -4346,7 +4587,7 @@ function reportGitleaksVersionCheck(section2, run = execFileSync9, tomlExists =
 // src/commands.doctor.checks.deps.ts
 init_color();
-import { execFileSync as execFileSync10 } from "node:child_process";
+import { execFileSync as execFileSync12 } from "node:child_process";
 var VERSION_TOKEN = /(\d{1,9}\.\d{1,9}\.\d{1,9})/;
 var PROBE_TIMEOUT_MS = 3e3;
 var FETCHER_BASE = "HTTP fetcher";
@@ -4383,14 +4624,14 @@ function reportFetcherRow(section2, run) {
     );
   }
 }
-function reportOptionalDeps(section2, run = execFileSync10) {
+function reportOptionalDeps(section2, run = execFileSync12) {
   const gh = probeOptionalDep("gh", run);
   if (gh.status === "present") {
     addItem(section2, `${green(okGlyph)} gh: ${gh.version ?? "present"}`);
   } else {
     addItem(
       section2,
-      `${yellow(warnGlyph)} gh: not installed (optional; needed for nomad init Actions auto-disable + the Actions-drift check)`
+      `${yellow(warnGlyph)} gh: not installed (optional; nomad init needs it to create the sync repo and auto-disable Actions, and the Actions-drift check uses it)`
     );
   }
   reportFetcherRow(section2, run);
@@ -4398,11 +4639,11 @@ function reportOptionalDeps(section2, run = execFileSync10) {
 // src/commands.doctor.actions-drift.ts
 init_color();
-import { execFileSync as execFileSync12 } from "node:child_process";
+import { execFileSync as execFileSync14 } from "node:child_process";
 init_config();
 // src/gh-actions.ts
-import { execFileSync as execFileSync11 } from "node:child_process";
+import { execFileSync as execFileSync13 } from "node:child_process";
 var GH_TIMEOUT_MS = 5e3;
 function parseGitHubRemote(remoteUrl) {
   const normalized = remoteUrl.trim().replace(/\/$/, "");
@@ -4410,7 +4651,7 @@ function parseGitHubRemote(remoteUrl) {
   if (m === null) return null;
   return { owner: m[1], repo: m[2] };
 }
-function ghAuthStatus(run = execFileSync11) {
+function ghAuthStatus(run = execFileSync13) {
   try {
     run("gh", ["auth", "status"], {
       stdio: ["ignore", "ignore", "ignore"],
@@ -4424,7 +4665,7 @@ function ghAuthStatus(run = execFileSync11) {
     return "gh-probe-error";
   }
 }
-function isRepoPrivate(ref, run = execFileSync11) {
+function isRepoPrivate(ref, run = execFileSync13) {
   const out = run("gh", ["repo", "view", `${ref.owner}/${ref.repo}`, "--json", "isPrivate"], {
     stdio: ["ignore", "pipe", "ignore"],
     timeout: GH_TIMEOUT_MS
@@ -4432,7 +4673,7 @@ function isRepoPrivate(ref, run = execFileSync11) {
   const parsed = JSON.parse(out);
   return parsed.isPrivate === true;
 }
-function isActionsEnabled(ref, run = execFileSync11) {
+function isActionsEnabled(ref, run = execFileSync13) {
   const out = run(
     "gh",
     ["api", `repos/${ref.owner}/${ref.repo}/actions/permissions`, "--jq", ".enabled"],
@@ -4440,7 +4681,7 @@ function isActionsEnabled(ref, run = execFileSync11) {
   ).toString().trim();
   return out === "true";
 }
-function disableActions(ref, run = execFileSync11) {
+function disableActions(ref, run = execFileSync13) {
   run(
     "gh",
     [
@@ -4454,7 +4695,7 @@ function disableActions(ref, run = execFileSync11) {
     { stdio: ["ignore", "ignore", "pipe"], timeout: GH_TIMEOUT_MS }
   );
 }
-function readOriginRemote(cwd, run = execFileSync11) {
+function readOriginRemote(cwd, run = execFileSync13) {
   return run("git", ["remote", "get-url", "origin"], {
     cwd,
     stdio: ["ignore", "pipe", "ignore"]
@@ -4462,7 +4703,7 @@ function readOriginRemote(cwd, run = execFileSync11) {
 }
 // src/commands.doctor.actions-drift.ts
-function reportActionsDrift(section2, run = execFileSync12) {
+function reportActionsDrift(section2, run = execFileSync14) {
   let remote;
   try {
     remote = readOriginRemote(repoHome(), run);
@@ -4519,7 +4760,13 @@ function buildVerdictSection(sections) {
 // src/commands.doctor.compact.ts
 init_color();
-var ALWAYS_FULL = /* @__PURE__ */ new Set(["Nomad Version", "Summary", "Shared scan", "Schema scan"]);
+var ALWAYS_FULL = /* @__PURE__ */ new Set([
+  "Nomad Version",
+  "Summary",
+  "Shared scan",
+  "Schema scan",
+  "Remote check"
+]);
 function isProblem(item2) {
   return item2.includes(failGlyph) || item2.includes(warnGlyph);
 }
@@ -4540,10 +4787,11 @@ function compactSections(sections) {
 function gatherDoctorSections(opts) {
   const host = section("Environment");
   reportHostAndPaths(host);
+  reportHostKeyAlignment(host);
   reportRepoState(host);
   const links = section("Shared links");
-  const mapPath = join35(repoHome(), "path-map.json");
-  const rawMap = existsSync29(mapPath) ? readJsonSafe(mapPath, mapPath, links) : null;
+  const mapPath = join36(repoHome(), "path-map.json");
+  const rawMap = existsSync30(mapPath) ? readJsonSafe(mapPath, mapPath, links) : null;
   const map = rawMap ?? { projects: {} };
   reportSharedLinks(links, map);
   reportDroppedNamesMigration(links);
@@ -4561,10 +4809,13 @@ function gatherDoctorSections(opts) {
   reportPathMap(pathMap);
   const neverSync = section("Never-sync");
   reportNeverSync(neverSync);
+  const skills = section("Skills");
+  reportSkillsDivergence(skills);
   const repository = section("Repository");
   const gitleaksReady = reportGitleaksProbe(repository);
   reportGitlinks(repository);
   reportRemote(repository);
+  reportGitIdentity(repository);
   reportRebaseClean(repository);
   reportRebaseState(repository);
   reportOrphanedAutostash(repository);
@@ -4581,6 +4832,8 @@ function gatherDoctorSections(opts) {
   if (opts.checkShared === true) reportCheckShared(sharedScan, gitleaksReady);
   const schemaScan = section("Schema scan");
   if (opts.checkSchema === true) reportCheckSchema(schemaScan);
+  const remoteCheck = section("Remote check");
+  if (opts.checkRemote === true) reportCheckRemote(remoteCheck);
   const body = [
     nomadVersion,
     depVersions,
@@ -4590,10 +4843,12 @@ function gatherDoctorSections(opts) {
     settings,
     pathMap,
     neverSync,
+    skills,
     repository,
     housekeeping,
     sharedScan,
-    schemaScan
+    schemaScan,
+    remoteCheck
   ];
   return [...body, buildVerdictSection(body)];
 }
@@ -4618,27 +4873,29 @@ function parseDoctorArgs(args) {
   }
   let checkShared = false;
   let checkSchema = false;
+  let checkRemote = false;
   let verbose = false;
   for (const arg of args) {
     if (arg === "--check-shared") checkShared = true;
     else if (arg === "--check-schema") checkSchema = true;
+    else if (arg === "--check-remote") checkRemote = true;
     else if (arg === "--verbose" || arg === "--all" || arg === "-v") verbose = true;
     else return { kind: "error" };
   }
-  return { kind: "run", checkShared, checkSchema, verbose };
+  return { kind: "run", checkShared, checkSchema, checkRemote, verbose };
 }
 // src/commands.drop-session.ts
 init_config();
-import { execFileSync as execFileSync14 } from "node:child_process";
-import { existsSync as existsSync31, readdirSync as readdirSync10, statSync as statSync8 } from "node:fs";
-import { join as join37, relative as relative4 } from "node:path";
+import { execFileSync as execFileSync16 } from "node:child_process";
+import { existsSync as existsSync32, readdirSync as readdirSync11, statSync as statSync8 } from "node:fs";
+import { join as join38, relative as relative4 } from "node:path";
 // src/commands.drop-session.git.ts
-import { execFileSync as execFileSync13 } from "node:child_process";
+import { execFileSync as execFileSync15 } from "node:child_process";
 function expandStagedDir(dirRel, repo) {
   try {
-    const out = execFileSync13("git", ["ls-files", "-z", "--", dirRel], {
+    const out = execFileSync15("git", ["ls-files", "-z", "--", dirRel], {
       cwd: repo,
       stdio: ["ignore", "pipe", "pipe"]
     });
@@ -4649,7 +4906,7 @@ function expandStagedDir(dirRel, repo) {
 }
 function isTrackedInHead(rel, repo) {
   try {
-    execFileSync13("git", ["cat-file", "-e", `HEAD:${rel}`], {
+    execFileSync15("git", ["cat-file", "-e", `HEAD:${rel}`], {
       cwd: repo,
       stdio: ["ignore", "pipe", "pipe"]
     });
@@ -4660,7 +4917,7 @@ function isTrackedInHead(rel, repo) {
 }
 function isInIndex(rel, repo) {
   try {
-    const out = execFileSync13("git", ["ls-files", "--", rel], {
+    const out = execFileSync15("git", ["ls-files", "--", rel], {
       cwd: repo,
       stdio: ["ignore", "pipe", "pipe"]
     });
@@ -4674,8 +4931,8 @@ function isInIndex(rel, repo) {
 init_config();
 init_utils();
 init_utils_json();
-import { existsSync as existsSync30 } from "node:fs";
-import { join as join36 } from "node:path";
+import { existsSync as existsSync31 } from "node:fs";
+import { join as join37 } from "node:path";
 var SHARED_PROJECT_LOGICAL = /^shared\/projects\/([^/]+)\//;
 function reportScrubHint(id, matches) {
   const live = resolveLiveTranscript2(id, matches);
@@ -4691,8 +4948,8 @@ function reportScrubHint(id, matches) {
 }
 function resolveLiveTranscript2(id, matches) {
   try {
-    const mapPath = join36(repoHome(), "path-map.json");
-    if (!existsSync30(mapPath)) return null;
+    const mapPath = join37(repoHome(), "path-map.json");
+    if (!existsSync31(mapPath)) return null;
     const projects = readJson(mapPath).projects;
     const claude = claudeHome();
     for (const rel of matches) {
@@ -4700,8 +4957,8 @@ function resolveLiveTranscript2(id, matches) {
       if (logical === void 0) continue;
       const abs = projects[logical]?.[HOST];
       if (abs === void 0) continue;
-      const live = join36(claude, "projects", encodePath(abs), `${id}.jsonl`);
-      if (existsSync30(live)) return live;
+      const live = join37(claude, "projects", encodePath(abs), `${id}.jsonl`);
+      if (existsSync31(live)) return live;
     }
     return null;
   } catch {
@@ -4717,12 +4974,12 @@ function cmdDropSession(id) {
     process.exit(1);
   }
   const repo = repoHome();
-  if (!existsSync31(repo)) die(`repo not cloned at ${repo}`);
+  if (!existsSync32(repo)) die(`repo not cloned at ${repo}`);
   const handle = acquireLock("drop-session");
   if (handle === null) process.exit(0);
   try {
-    const repoProjects = join37(repo, "shared", "projects");
-    if (!existsSync31(repoProjects)) {
+    const repoProjects = join38(repo, "shared", "projects");
+    if (!existsSync32(repoProjects)) {
       throw new NomadFatal(`no staged session matches ${id}`);
     }
     const matches = collectMatches(repoProjects, id, repo);
@@ -4744,13 +5001,13 @@ function cmdDropSession(id) {
 }
 function collectMatches(repoProjects, id, repo) {
   const matches = [];
-  for (const logical of readdirSync10(repoProjects)) {
-    const candidate = join37(repoProjects, logical, `${id}.jsonl`);
-    if (existsSync31(candidate)) {
+  for (const logical of readdirSync11(repoProjects)) {
+    const candidate = join38(repoProjects, logical, `${id}.jsonl`);
+    if (existsSync32(candidate)) {
       matches.push(relative4(repo, candidate));
     }
-    const dir = join37(repoProjects, logical, id);
-    if (existsSync31(dir) && statSync8(dir).isDirectory()) {
+    const dir = join38(repoProjects, logical, id);
+    if (existsSync32(dir) && statSync8(dir).isDirectory()) {
       const dirRel = relative4(repo, dir);
       const staged = expandStagedDir(dirRel, repo);
       if (staged.length > 0) matches.push(...staged);
@@ -4766,12 +5023,12 @@ function unstageOne(rel, repo) {
   }
   try {
     if (isTrackedInHead(rel, repo)) {
-      execFileSync14("git", ["restore", "--staged", "--worktree", "--", rel], {
+      execFileSync16("git", ["restore", "--staged", "--worktree", "--", rel], {
         cwd: repo,
         stdio: ["ignore", "pipe", "pipe"]
       });
     } else {
-      execFileSync14("git", ["rm", "--cached", "-f", "--", rel], {
+      execFileSync16("git", ["rm", "--cached", "-f", "--", rel], {
         cwd: repo,
         stdio: ["ignore", "pipe", "pipe"]
       });
@@ -4785,8 +5042,8 @@ function unstageOne(rel, repo) {
 }
 // src/commands.pull.ts
-import { existsSync as existsSync37, mkdirSync as mkdirSync9 } from "node:fs";
-import { join as join44 } from "node:path";
+import { existsSync as existsSync38, mkdirSync as mkdirSync9 } from "node:fs";
+import { join as join45 } from "node:path";
 // src/commands.push.sections.ts
 init_color();
@@ -4881,55 +5138,20 @@ init_config();
 // src/extras-sync.ts
 init_config();
-import { existsSync as existsSync34 } from "node:fs";
-import { join as join41 } from "node:path";
-// src/extras-sync.diff.ts
-init_utils();
-import { execFileSync as execFileSync15 } from "node:child_process";
-function labelDiffLine(line) {
-  const tab = line.indexOf("	");
-  if (tab === -1) return line;
-  const status = line.slice(0, tab);
-  const path = line.slice(tab + 1);
-  if (status === "D") return `${path} (local only)`;
-  if (status === "A") return `${path} (repo only)`;
-  return path;
-}
-function parseDiffOutput(stdout) {
-  return stdout.split("\n").filter((line) => line.length > 0).map(labelDiffLine);
-}
-function listDivergingFiles(a, b) {
-  try {
-    const stdout = execFileSync15("git", ["diff", "--no-index", "--name-status", a, b], {
-      stdio: ["ignore", "pipe", "pipe"]
-    }).toString();
-    return parseDiffOutput(stdout);
-  } catch (err) {
-    const e = err;
-    if (e.status === 1 && e.stdout !== void 0) {
-      return parseDiffOutput(e.stdout.toString());
-    }
-    if (e.code === "ENOENT") {
-      warn(`git not on PATH; divergence check skipped for ${a}`);
-      return [];
-    }
-    warn(`divergence check failed for ${a}: ${e.message ?? String(err)}`);
-    return [];
-  }
-}
+import { existsSync as existsSync35, statSync as statSync9 } from "node:fs";
+import { join as join42 } from "node:path";
 // src/extras-sync.core.ts
 init_config();
-import { cpSync as cpSync6, existsSync as existsSync32, lstatSync as lstatSync9, readdirSync as readdirSync11, rmSync as rmSync11 } from "node:fs";
-import { basename, join as join38 } from "node:path";
+import { cpSync as cpSync6, existsSync as existsSync33, lstatSync as lstatSync9, readdirSync as readdirSync12, rmSync as rmSync11 } from "node:fs";
+import { basename, join as join39 } from "node:path";
 init_utils();
 init_utils_json();
 function loadValidatedExtras(opts) {
   const repo = repoHome();
-  const mapPath = join38(repo, "path-map.json");
-  const repoExtras = join38(repo, "shared", "extras");
-  if (!existsSync32(mapPath) || opts.requireRepoExtras === true && !existsSync32(repoExtras)) {
+  const mapPath = join39(repo, "path-map.json");
+  const repoExtras = join39(repo, "shared", "extras");
+  if (!existsSync33(mapPath) || opts.requireRepoExtras === true && !existsSync33(repoExtras)) {
     if (opts.missingMsg !== void 0) log(opts.missingMsg);
     return null;
   }
@@ -4961,16 +5183,16 @@ function* eachExtrasTarget(v, counts) {
   }
 }
 function stripCollidingDstSymlinks(src, dst, isExcluded) {
-  if (!existsSync32(dst)) return;
-  for (const name of readdirSync11(src)) {
+  if (!existsSync33(dst)) return;
+  for (const name of readdirSync12(src)) {
     if (isExcluded(name)) continue;
-    const dstPath = join38(dst, name);
+    const dstPath = join39(dst, name);
     const dstStat = lstatSync9(dstPath, { throwIfNoEntry: false });
     if (dstStat === void 0) continue;
     if (dstStat.isSymbolicLink()) {
       rmSync11(dstPath, { recursive: true, force: true });
-    } else if (dstStat.isDirectory() && lstatSync9(join38(src, name)).isDirectory()) {
-      stripCollidingDstSymlinks(join38(src, name), dstPath, isExcluded);
+    } else if (dstStat.isDirectory() && lstatSync9(join39(src, name)).isDirectory()) {
+      stripCollidingDstSymlinks(join39(src, name), dstPath, isExcluded);
     }
   }
 }
@@ -5010,17 +5232,17 @@ function copyExtrasFiltered(src, dst, blockSet) {
   });
 }
 function prunePreservingDenied(src, dst, blockSet) {
-  for (const name of readdirSync11(dst)) {
+  for (const name of readdirSync12(dst)) {
     if (isDeniedName(blockSet, name)) continue;
-    const dstPath = join38(dst, name);
-    const srcStat = lstatSync9(join38(src, name), { throwIfNoEntry: false });
+    const dstPath = join39(dst, name);
+    const srcStat = lstatSync9(join39(src, name), { throwIfNoEntry: false });
     if (srcStat === void 0) {
       rmSync11(dstPath, { recursive: true, force: true });
       continue;
     }
     const dstStat = lstatSync9(dstPath);
     if (srcStat.isDirectory() && dstStat.isDirectory()) {
-      prunePreservingDenied(join38(src, name), dstPath, blockSet);
+      prunePreservingDenied(join39(src, name), dstPath, blockSet);
     } else if (srcStat.isDirectory() !== dstStat.isDirectory()) {
       rmSync11(dstPath, { recursive: true, force: true });
     }
@@ -5041,17 +5263,17 @@ function copyExtrasFilteredPreserving(src, dst, blockSet) {
   });
 }
 function prunePreservingBy(src, dst, isPreserved) {
-  for (const name of readdirSync11(dst)) {
+  for (const name of readdirSync12(dst)) {
     if (isPreserved(name)) continue;
-    const dstPath = join38(dst, name);
-    const srcStat = lstatSync9(join38(src, name), { throwIfNoEntry: false });
+    const dstPath = join39(dst, name);
+    const srcStat = lstatSync9(join39(src, name), { throwIfNoEntry: false });
     if (srcStat === void 0) {
       rmSync11(dstPath, { recursive: true, force: true });
       continue;
     }
     const dstStat = lstatSync9(dstPath);
     if (srcStat.isDirectory() && dstStat.isDirectory()) {
-      prunePreservingBy(join38(src, name), dstPath, isPreserved);
+      prunePreservingBy(join39(src, name), dstPath, isPreserved);
     } else if (srcStat.isDirectory() !== dstStat.isDirectory()) {
       rmSync11(dstPath, { recursive: true, force: true });
     }
@@ -5078,11 +5300,11 @@ init_utils_json();
 // src/extras-sync.remap.ts
 init_config();
-import { existsSync as existsSync33, mkdirSync as mkdirSync7, readdirSync as readdirSync12, realpathSync as realpathSync4, rmSync as rmSync12 } from "node:fs";
-import { dirname as dirname7, join as join40, sep as sep7 } from "node:path";
+import { existsSync as existsSync34, mkdirSync as mkdirSync7, readdirSync as readdirSync13, realpathSync as realpathSync4, rmSync as rmSync12 } from "node:fs";
+import { dirname as dirname7, join as join41, sep as sep7 } from "node:path";
 // src/extras-sync.planning-diff.ts
-import { join as join39, normalize as normalize2, sep as sep6 } from "node:path";
+import { join as join40, normalize as normalize2, sep as sep6 } from "node:path";
 init_utils();
 function processRecord(fields, i, changed, deleted) {
   const status = fields[i];
@@ -5134,7 +5356,7 @@ function planningDeleteTargets(opts) {
   const { deleted } = parsePlanningDiff(raw);
   const logicalPrefix = "shared/extras/" + logical + "/";
   const prefix = logicalPrefix + ".planning/";
-  const planningRoot = join39(localRoot, ".planning");
+  const planningRoot = join40(localRoot, ".planning");
   const planningRootBoundary = planningRoot + sep6;
   const targets = [];
   for (const repoPath of deleted) {
@@ -5142,7 +5364,7 @@ function planningDeleteTargets(opts) {
       continue;
     }
     const remainder = repoPath.slice(logicalPrefix.length);
-    const candidate = join39(localRoot, remainder);
+    const candidate = join40(localRoot, remainder);
     const resolved = normalize2(candidate);
     if (!resolved.startsWith(planningRootBoundary)) {
       throw new NomadFatal(
@@ -5163,7 +5385,7 @@ function runExtrasOp(v, dryRun, paths, backup, copy) {
   const would = [];
   for (const t of eachExtrasTarget(v, counts)) {
     const { src, dst } = paths(t);
-    if (!existsSync33(src)) continue;
+    if (!existsSync34(src)) continue;
     const item2 = `${t.logical}/${t.dirname}`;
     if (dryRun) {
       would.push(item2);
@@ -5179,7 +5401,7 @@ function pruneEmptyAncestors(target, planningRoot) {
   let dir = dirname7(target);
   while (dir !== planningRoot && dir.startsWith(planningRoot + sep7)) {
     try {
-      if (readdirSync12(dir).length > 0) break;
+      if (readdirSync13(dir).length > 0) break;
       rmSync12(dir, { recursive: true, force: true });
     } catch {
       break;
@@ -5198,7 +5420,7 @@ function isInsidePlanningRoot(parentReal, rootReal) {
   return parentReal === rootReal || parentReal.startsWith(rootReal + sep7);
 }
 function deletePlanningTarget(target, planningRoot, repoCounterpart) {
-  if (existsSync33(repoCounterpart)) return;
+  if (existsSync34(repoCounterpart)) return;
   const parentReal = tryRealpath(dirname7(target));
   if (parentReal === void 0) return;
   const rootReal = tryRealpath(planningRoot);
@@ -5208,7 +5430,7 @@ function deletePlanningTarget(target, planningRoot, repoCounterpart) {
   pruneEmptyAncestors(target, planningRoot);
 }
 function propagatePlanningDeletes(v, ts, prePostHeads, repo) {
-  const repoExtras = join40(repo, "shared", "extras");
+  const repoExtras = join41(repo, "shared", "extras");
   for (const t of eachExtrasTarget(v, { unmapped: 0, skipped: 0 })) {
     if (t.dirname !== ".planning") continue;
     let raw;
@@ -5234,11 +5456,11 @@ function propagatePlanningDeletes(v, ts, prePostHeads, repo) {
     }
     const targets = planningDeleteTargets({ raw, logical: t.logical, localRoot: t.localRoot });
     if (targets.length === 0) continue;
-    backupExtrasWrite(join40(t.localRoot, t.dirname), ts, t.localRoot);
-    const planningRoot = join40(t.localRoot, ".planning");
+    backupExtrasWrite(join41(t.localRoot, t.dirname), ts, t.localRoot);
+    const planningRoot = join41(t.localRoot, ".planning");
     for (const target of targets) {
       const relToLocal = target.slice(t.localRoot.length + sep7.length);
-      deletePlanningTarget(target, planningRoot, join40(repoExtras, t.logical, relToLocal));
+      deletePlanningTarget(target, planningRoot, join41(repoExtras, t.logical, relToLocal));
     }
   }
 }
@@ -5247,14 +5469,14 @@ function remapExtrasPush(ts, opts = {}) {
   const v = loadValidatedExtras({ missingMsg: "no path-map.json; skipping extras push" });
   if (v === null) return { unmapped: 0, skipped: 0, pushed: [], wouldPush: [] };
   const repo = repoHome();
-  const repoExtras = join40(repo, "shared", "extras");
+  const repoExtras = join41(repo, "shared", "extras");
   if (!dryRun) mkdirSync7(repoExtras, { recursive: true });
   const { unmapped, skipped, done, would } = runExtrasOp(
     v,
     dryRun,
     ({ localRoot, logical, dirname: dirname8 }) => ({
-      src: join40(localRoot, dirname8),
-      dst: join40(repoExtras, logical, dirname8)
+      src: join41(localRoot, dirname8),
+      dst: join41(repoExtras, logical, dirname8)
     }),
     (dst) => backupRepoWrite(dst, ts, repo),
     // Push copy routing per extra type:
@@ -5283,8 +5505,8 @@ function remapExtrasPull(ts, opts = {}) {
     v,
     dryRun,
     ({ localRoot, logical, dirname: dirname8 }) => ({
-      src: join40(repo, "shared", "extras", logical, dirname8),
-      dst: join40(localRoot, dirname8)
+      src: join41(repo, "shared", "extras", logical, dirname8),
+      dst: join41(localRoot, dirname8)
     }),
     // Snapshot the host-side dst BEFORE copyExtras clobbers it. Anchor on
     // localRoot so the backup tree mirrors the project layout.
@@ -5312,21 +5534,36 @@ function remapExtrasPull(ts, opts = {}) {
 }
 // src/extras-sync.ts
+function divergenceWarnLine(o) {
+  const kind = o.isDir ? "folder" : "file";
+  const name = o.isDir ? `${o.dirname}/` : o.dirname;
+  const one = o.count === 1;
+  const fileCount = one ? "1 file" : `${o.count} files`;
+  const them = one ? "it" : "them";
+  const yours = one ? "your current file is" : "your current files are";
+  return `local ${kind} ${name} in repo ${o.logical} differs from the synced copy in ${fileCount}; the next pull step will overwrite ${them} with the synced version (${yours} backed up to ${o.projectBackupRoot}/)`;
+}
 function divergenceCheckExtras(ts) {
   const v = loadValidatedExtras({});
   if (v === null) return;
   const counts = { unmapped: 0, skipped: 0 };
-  const backupRoot = join41(backupBase(), ts, "extras");
+  const backupRoot = join42(backupBase(), ts, "extras");
   const repo = repoHome();
   for (const { logical, localRoot, dirname: dirname8 } of eachExtrasTarget(v, counts)) {
-    const local = join41(localRoot, dirname8);
-    const repoEntry = join41(repo, "shared", "extras", logical, dirname8);
-    if (!existsSync34(local) || !existsSync34(repoEntry)) continue;
+    const local = join42(localRoot, dirname8);
+    const repoEntry = join42(repo, "shared", "extras", logical, dirname8);
+    if (!existsSync35(local) || !existsSync35(repoEntry)) continue;
     const diff = listDivergingFiles(local, repoEntry);
     if (diff.length === 0) continue;
-    const projectBackupRoot = join41(backupRoot, encodePath(localRoot));
+    const projectBackupRoot = join42(backupRoot, encodePath(localRoot));
     warn(
-      `local ${dirname8} for ${logical} diverges from origin in ${diff.length} file(s); next remapExtrasPull will merge changes (.planning overlays, .claude/.CLAUDE.md mirror; backups at ${projectBackupRoot}/)`
+      divergenceWarnLine({
+        dirname: dirname8,
+        logical,
+        isDir: statSync9(local).isDirectory(),
+        count: diff.length,
+        projectBackupRoot
+      })
     );
     for (const f of diff) warn(`  ${f}`);
   }
@@ -5334,8 +5571,8 @@ function divergenceCheckExtras(ts) {
 // src/skills-sync.ts
 init_config();
-import { existsSync as existsSync35, lstatSync as lstatSync10, mkdirSync as mkdirSync8, readdirSync as readdirSync13, rmSync as rmSync13 } from "node:fs";
-import { join as join42 } from "node:path";
+import { existsSync as existsSync36, lstatSync as lstatSync10, mkdirSync as mkdirSync8, readdirSync as readdirSync14, rmSync as rmSync13 } from "node:fs";
+import { join as join43 } from "node:path";
 init_utils_fs();
 function isGsdOwned(name) {
   return name.startsWith(GSD_PREFIX);
@@ -5344,7 +5581,7 @@ function isSkillExcluded(name) {
   return isGsdOwned(name) || isDeniedName(ALWAYS_NEVER_SYNC, name);
 }
 function copySkillsPush(src, dst) {
-  const srcNames = readdirSync13(src, { encoding: "utf8" });
+  const srcNames = readdirSync14(src, { encoding: "utf8" });
   const blockSet = /* @__PURE__ */ new Set([
     ...srcNames.filter((n) => isGsdOwned(n)),
     ...ALWAYS_NEVER_SYNC
@@ -5355,9 +5592,9 @@ function copySkillsPull(src, dst) {
   copyExtrasFilteredPreservingBy(src, dst, isSkillExcluded);
 }
 function syncSkillsPull(ts) {
-  const sharedSkills = join42(repoHome(), "shared", "skills");
-  if (!existsSync35(sharedSkills)) return;
-  const localSkills = join42(claudeHome(), "skills");
+  const sharedSkills = join43(repoHome(), "shared", "skills");
+  if (!existsSync36(sharedSkills)) return;
+  const localSkills = join43(claudeHome(), "skills");
   const dstStat = lstatSync10(localSkills, { throwIfNoEntry: false });
   if (dstStat?.isSymbolicLink() === true) {
     backupBeforeWrite(localSkills, ts);
@@ -5367,18 +5604,18 @@ function syncSkillsPull(ts) {
   copySkillsPull(sharedSkills, localSkills);
 }
 function syncSkillsPush() {
-  const localSkills = join42(claudeHome(), "skills");
+  const localSkills = join43(claudeHome(), "skills");
   const stat = lstatSync10(localSkills, { throwIfNoEntry: false });
   if (stat === void 0) return;
   if (stat.isSymbolicLink()) return;
-  const sharedSkills = join42(repoHome(), "shared", "skills");
+  const sharedSkills = join43(repoHome(), "shared", "skills");
   copySkillsPush(localSkills, sharedSkills);
 }
 // src/preview.ts
 init_config();
-import { existsSync as existsSync36 } from "node:fs";
-import { join as join43 } from "node:path";
+import { existsSync as existsSync37 } from "node:fs";
+import { join as join44 } from "node:path";
 // node_modules/diff/libesm/diff/base.js
 var Diff = class {
@@ -5664,7 +5901,7 @@ function diffJsonStrings(currentJsonText, newJsonText) {
   return lines.join("\n");
 }
 function readJsonOrNull(path) {
-  if (!existsSync36(path)) return null;
+  if (!existsSync37(path)) return null;
   try {
     return readJson(path);
   } catch {
@@ -5678,12 +5915,12 @@ function previewSettings(basePath, hostPath, settingsPath) {
   }
   const notes = [];
   const hostOverrides = readJsonOrNull(hostPath);
-  if (hostOverrides === null && existsSync36(hostPath)) {
+  if (hostOverrides === null && existsSync37(hostPath)) {
     notes.push(`malformed hosts/${HOST}.json; ignoring overrides`);
   }
   const merged = stripGsdHookEntries(deepMerge(base, hostOverrides ?? {}));
   const current = readJsonOrNull(settingsPath);
-  if (current === null && existsSync36(settingsPath)) {
+  if (current === null && existsSync37(settingsPath)) {
     return { diff: "", notes: [...notes, "malformed; skipping diff"] };
   }
   const strippedCurrent = stripGsdHookEntries(current ?? {});
@@ -5724,9 +5961,9 @@ function computePreview(ts, map, verb = "pull") {
     onPreview: (e) => addItem(links, formatLinkRow(e))
   });
   const settingsResult = previewSettings(
-    join43(repo, "shared", "settings.base.json"),
-    join43(repo, "hosts", `${HOST}.json`),
-    join43(claude, "settings.json")
+    join44(repo, "shared", "settings.base.json"),
+    join44(repo, "hosts", `${HOST}.json`),
+    join44(claude, "settings.json")
   );
   const settingsSection = buildSettingsSectionForPreview(settingsResult);
   const sessions = section("Sessions");
@@ -5748,9 +5985,9 @@ init_config();
 init_commands_pull_wedge();
 init_utils();
 init_utils_fs();
-import { execFileSync as execFileSync16 } from "node:child_process";
+import { execFileSync as execFileSync17 } from "node:child_process";
 function gitCapture(args, cwd) {
-  return execFileSync16("git", args, {
+  return execFileSync17("git", args, {
     cwd,
     stdio: ["ignore", "pipe", "pipe"],
     maxBuffer: 64 * 1024 * 1024
@@ -5927,8 +6164,8 @@ function cmdPull(opts = {}) {
   const forceRemote = opts.forceRemote === true;
   const repo = repoHome();
   const backup = backupBase();
-  if (!existsSync37(repo)) die(`repo not cloned at ${repo}`);
-  if (!existsSync37(join44(repo, "shared", "settings.base.json"))) {
+  if (!existsSync38(repo)) die(`repo not cloned at ${repo}`);
+  if (!existsSync38(join45(repo, "shared", "settings.base.json"))) {
     die("repo not initialized; run 'nomad init' to scaffold");
   }
   const handle = acquireLock("pull");
@@ -5937,7 +6174,7 @@ function cmdPull(opts = {}) {
     const ts = freshBackupTs(backup);
     handleWedge(repo, forceRemote);
     if (!dryRun) {
-      const backupRoot = join44(backup, ts);
+      const backupRoot = join45(backup, ts);
       try {
         mkdirSync9(backupRoot, { recursive: true });
       } catch (err) {
@@ -5950,8 +6187,8 @@ function cmdPull(opts = {}) {
     const prePostHeads = capturePrePostHeads(repo, () => {
       gitOrFatal(["pull", "--rebase", "--autostash"], "git pull --rebase", repo);
     });
-    const mapPath = join44(repo, "path-map.json");
-    const map = existsSync37(mapPath) ? readPathMap(mapPath) : { projects: {} };
+    const mapPath = join45(repo, "path-map.json");
+    const map = existsSync38(mapPath) ? readPathMap(mapPath) : { projects: {} };
     divergenceCheckExtras(ts);
     if (dryRun) {
       computePreview(ts, map, "pull");
@@ -5973,8 +6210,8 @@ function cmdPull(opts = {}) {
 // src/commands.push.ts
 init_config();
-import { existsSync as existsSync39 } from "node:fs";
-import { join as join46, relative as relative5 } from "node:path";
+import { existsSync as existsSync40 } from "node:fs";
+import { join as join47, relative as relative5 } from "node:path";
 // src/commands.push.allowlist.ts
 init_config();
@@ -6067,7 +6304,7 @@ function enforceAllowList(statusPorcelain, map) {
 // src/push-global-config.ts
 init_config();
-import { execFileSync as execFileSync17 } from "node:child_process";
+import { execFileSync as execFileSync18 } from "node:child_process";
 var STATUS_LABELS = {
   A: "add",
   M: "modify",
@@ -6107,7 +6344,7 @@ function isInScope(filePath, exactPrefixes, dirPrefixes) {
 }
 function collectGlobalConfigChanges(repoHome2, hostname2, opts) {
   const args = opts.staged ? ["diff", "--cached", "--name-status", "-z"] : ["diff", "HEAD", "--name-status", "-z"];
-  const raw = execFileSync17("git", args, {
+  const raw = execFileSync18("git", args, {
     cwd: repoHome2,
     stdio: ["ignore", "pipe", "pipe"]
   }).toString();
@@ -6146,9 +6383,9 @@ init_color();
 init_config();
 init_config_sharedDirs_guard();
 import { randomBytes as randomBytes2 } from "node:crypto";
-import { copyFileSync, existsSync as existsSync38, mkdirSync as mkdirSync10, readdirSync as readdirSync14, rmSync as rmSync14 } from "node:fs";
+import { copyFileSync, existsSync as existsSync39, mkdirSync as mkdirSync10, readdirSync as readdirSync15, rmSync as rmSync14 } from "node:fs";
 import { homedir as homedir5 } from "node:os";
-import { join as join45 } from "node:path";
+import { join as join46 } from "node:path";
 init_push_leak_verdict();
 init_push_gitleaks();
 init_utils_fs();
@@ -6163,13 +6400,13 @@ function stageSessions(tmpRoot, map) {
     if (!p || p === "TBD") continue;
     reverse.set(encodePath(p), logical);
   }
-  const localProjects = join45(claudeHome(), "projects");
-  if (!existsSync38(localProjects)) return 0;
+  const localProjects = join46(claudeHome(), "projects");
+  if (!existsSync39(localProjects)) return 0;
   let staged = 0;
-  for (const dir of readdirSync14(localProjects)) {
+  for (const dir of readdirSync15(localProjects)) {
     const logical = reverse.get(dir);
     if (!logical) continue;
-    copyDirJsonlOnly(join45(localProjects, dir), join45(tmpRoot, "shared", "projects", logical));
+    copyDirJsonlOnly(join46(localProjects, dir), join46(tmpRoot, "shared", "projects", logical));
     staged++;
   }
   return staged;
@@ -6185,9 +6422,9 @@ function stageExtras(tmpRoot, map) {
     if (!localRoot || localRoot === "TBD") continue;
     for (const dirname8 of dirnames) {
       if (!whitelist.includes(dirname8)) continue;
-      const src = join45(localRoot, dirname8);
-      if (!existsSync38(src)) continue;
-      const dst = join45(tmpRoot, "shared", "extras", logical, dirname8);
+      const src = join46(localRoot, dirname8);
+      if (!existsSync39(src)) continue;
+      const dst = join46(tmpRoot, "shared", "extras", logical, dirname8);
       copyExtras(src, dst);
       staged++;
     }
@@ -6195,19 +6432,19 @@ function stageExtras(tmpRoot, map) {
   return staged;
 }
 function previewPushLeaks(map) {
-  const cacheDir = join45(homedir5(), ".cache", "claude-nomad");
+  const cacheDir = join46(homedir5(), ".cache", "claude-nomad");
   mkdirSync10(cacheDir, { recursive: true });
   const stamp = `${nowTimestamp()}-${process.pid}-${randomBytes2(4).toString("hex")}`;
-  const tmpRoot = join45(cacheDir, `push-preview-tree-${stamp}`);
+  const tmpRoot = join46(cacheDir, `push-preview-tree-${stamp}`);
   try {
     const sessionCount = stageSessions(tmpRoot, map);
     const extrasCount = stageExtras(tmpRoot, map);
     if (sessionCount + extrasCount === 0) {
       return { leak: false, verdictRow: NOTHING_TO_SCAN_ROW, recovery: null, findings: [] };
     }
-    const ignoreFile = join45(repoHome(), ".gitleaksignore");
-    if (existsSync38(ignoreFile)) {
-      copyFileSync(ignoreFile, join45(tmpRoot, ".gitleaksignore"));
+    const ignoreFile = join46(repoHome(), ".gitleaksignore");
+    if (existsSync39(ignoreFile)) {
+      copyFileSync(ignoreFile, join46(tmpRoot, ".gitleaksignore"));
     }
     let findings;
     try {
@@ -6229,8 +6466,8 @@ init_utils();
 init_utils_fs();
 init_utils_json();
 function stripGsdHooksFromBase(repo, backup) {
-  const basePath = join46(repo, "shared", "settings.base.json");
-  if (!existsSync39(basePath)) return;
+  const basePath = join47(repo, "shared", "settings.base.json");
+  if (!existsSync40(basePath)) return;
   let base;
   try {
     base = readJson(basePath);
@@ -6244,28 +6481,28 @@ function stripGsdHooksFromBase(repo, backup) {
   writeJsonAtomic(basePath, stripped);
 }
 function reportSettingsAheadDrift(repo) {
-  const basePath = join46(repo, "shared", "settings.base.json");
-  if (!existsSync39(basePath)) return;
-  const settingsPath = join46(claudeHome(), "settings.json");
-  if (!existsSync39(settingsPath)) return;
+  const basePath = join47(repo, "shared", "settings.base.json");
+  if (!existsSync40(basePath)) return;
+  const settingsPath = join47(claudeHome(), "settings.json");
+  if (!existsSync40(settingsPath)) return;
   try {
     const base = readJson(basePath);
-    const hostPath = join46(repo, "hosts", `${HOST}.json`);
-    const overrides = existsSync39(hostPath) ? readJson(hostPath) : {};
+    const hostPath = join47(repo, "hosts", `${HOST}.json`);
+    const overrides = existsSync40(hostPath) ? readJson(hostPath) : {};
     const merged = deepMerge(base, overrides);
     const settings = readJson(settingsPath);
     const { ahead } = classifySettingsDrift(merged, settings);
     const { promotable } = partitionByCaptureExclusion(ahead);
     if (promotable.length === 0) return;
-    const keys = JSON.stringify(promotable);
+    const { phrase, pronoun, verb } = describeSettings(promotable);
     warn(
-      `settings.json has local-only keys ${keys} not in the repo. Run 'nomad capture-settings' to promote them (or 'nomad capture-settings --host' for host-specific values).`
+      `your settings.json has ${phrase} that ${verb} not yet in the repo; run 'nomad capture-settings' to save ${pronoun} (or 'nomad capture-settings --host' for host-specific values).`
     );
   } catch {
   }
 }
 function guardGitlinks(repo) {
-  const gitlinks = findGitlinks(join46(repo, "shared"));
+  const gitlinks = findGitlinks(join47(repo, "shared"));
   if (gitlinks.length === 0) return;
   for (const p of gitlinks) {
     const rel = relative5(repo, p);
@@ -6331,7 +6568,7 @@ async function cmdPush(opts = {}) {
   guardResolutionModeConflicts(dryRun, redactAll, allowAll, allowRule);
   const repo = repoHome();
   const backup = backupBase();
-  if (!existsSync39(repo)) die(`repo not cloned at ${repo}`);
+  if (!existsSync40(repo)) die(`repo not cloned at ${repo}`);
   const handle = acquireLock("push");
   if (handle === null) process.exit(0);
   try {
@@ -6354,8 +6591,8 @@ async function cmdPush(opts = {}) {
       renderNoScanTree(st);
       return;
     }
-    const mapPath = join46(repo, "path-map.json");
-    if (!existsSync39(mapPath)) {
+    const mapPath = join47(repo, "path-map.json");
+    if (!existsSync40(mapPath)) {
       if (dryRun) return runDryRunPreview(st, null, repo);
       die("path-map.json missing, cannot enforce push allow-list");
     }
@@ -6376,25 +6613,35 @@ async function cmdPush(opts = {}) {
 }
 // src/commands.update.ts
-import { execFileSync as execFileSync18 } from "node:child_process";
+import { execFileSync as execFileSync19 } from "node:child_process";
 init_utils();
-function readInstalledVersion(run = execFileSync18) {
+function readInstalledVersion(run = execFileSync19) {
   try {
     return run("nomad", ["--version"], { encoding: "utf8" }).toString().trim() || null;
   } catch {
     return null;
   }
 }
-function cmdUpdate(run = execFileSync18) {
-  console.log("Updating claude-nomad CLI via npm...");
+function cmdUpdate(currentVersion, run = execFileSync19) {
+  console.log(`Updating claude-nomad v${currentVersion}...`);
   try {
-    run("npm", ["update", "-g", "claude-nomad"], { stdio: "inherit" });
+    run("npm", ["update", "-g", "claude-nomad"], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"],
+      // Now that output is captured rather than inherited, execFileSync buffers
+      // it; lift the default 1 MiB ceiling so a noisy-but-successful npm run
+      // (deprecation/funding spam) cannot throw ENOBUFS.
+      maxBuffer: 64 * 1024 * 1024
+    });
   } catch (err) {
     const e = err;
     if (e.code === "ENOENT") {
       throw new NomadFatal("npm not found on PATH; install Node.js/npm and retry.");
     }
-    throw new NomadFatal(`npm update -g claude-nomad failed: ${e.message}`);
+    const detail = String(e.stderr ?? "").trim();
+    const suffix = detail ? `
+${detail}` : "";
+    throw new NomadFatal(`npm update -g claude-nomad failed: ${e.message}${suffix}`);
   }
   const version = readInstalledVersion(run);
   if (version) {
@@ -6409,18 +6656,18 @@ init_config();
 // src/diff.ts
 init_config();
-import { existsSync as existsSync40 } from "node:fs";
-import { join as join47 } from "node:path";
+import { existsSync as existsSync41 } from "node:fs";
+import { join as join48 } from "node:path";
 init_utils();
 init_utils_fs();
 init_utils_json();
 function cmdDiff() {
   try {
     const repo = repoHome();
-    if (!existsSync40(repo)) die(`repo not cloned at ${repo}`);
+    if (!existsSync41(repo)) die(`repo not cloned at ${repo}`);
     const ts = freshBackupTs(backupBase());
-    const mapPath = join47(repo, "path-map.json");
-    const map = existsSync40(mapPath) ? readPathMap(mapPath) : { projects: {} };
+    const mapPath = join48(repo, "path-map.json");
+    const map = existsSync41(mapPath) ? readPathMap(mapPath) : { projects: {} };
     computePreview(ts, map, "diff");
   } catch (err) {
     if (err instanceof NomadFatal) {
@@ -6434,19 +6681,19 @@ function cmdDiff() {
 // src/init.ts
 init_config();
-import { existsSync as existsSync42, mkdirSync as mkdirSync11, writeFileSync as writeFileSync6 } from "node:fs";
-import { join as join49 } from "node:path";
+import { existsSync as existsSync43, mkdirSync as mkdirSync11, writeFileSync as writeFileSync6 } from "node:fs";
+import { join as join50 } from "node:path";
 // src/init.gh-onboard.ts
 init_config();
-import { execFileSync as execFileSync19 } from "node:child_process";
+import { execFileSync as execFileSync20 } from "node:child_process";
 init_utils();
 var DEFAULT_REPO_NAME = "claude-nomad-config";
 function isValidRepoName(name) {
   return /^[A-Za-z0-9._-]{1,100}$/.test(name);
 }
 var GH_NETWORK_TIMEOUT_MS = 3e4;
-function ensureOriginRepo(repoName, run = execFileSync19) {
+function ensureOriginRepo(repoName, run = execFileSync20) {
   if (!isValidRepoName(repoName)) {
     die(
       `invalid repo name: ${JSON.stringify(repoName)}. Use only letters, digits, hyphens, underscores, and dots (1-100 chars).`
@@ -6517,33 +6764,33 @@ init_config();
 init_utils();
 init_utils_fs();
 init_utils_json();
-import { copyFileSync as copyFileSync2, cpSync as cpSync7, existsSync as existsSync41, rmSync as rmSync15, statSync as statSync9 } from "node:fs";
-import { join as join48 } from "node:path";
+import { copyFileSync as copyFileSync2, cpSync as cpSync7, existsSync as existsSync42, rmSync as rmSync15, statSync as statSync10 } from "node:fs";
+import { join as join49 } from "node:path";
 function snapshotIntoShared(map) {
   const repo = repoHome();
   const claude = claudeHome();
   for (const name of allSharedLinks(map)) {
-    const src = join48(claude, name);
-    if (!existsSync41(src)) continue;
-    const dst = join48(repo, "shared", name);
-    if (statSync9(src).isDirectory()) {
-      const gk = join48(dst, ".gitkeep");
-      if (existsSync41(gk)) rmSync15(gk);
+    const src = join49(claude, name);
+    if (!existsSync42(src)) continue;
+    const dst = join49(repo, "shared", name);
+    if (statSync10(src).isDirectory()) {
+      const gk = join49(dst, ".gitkeep");
+      if (existsSync42(gk)) rmSync15(gk);
       cpSync7(src, dst, { recursive: true, force: false, errorOnExist: true });
     } else {
       copyFileSync2(src, dst);
     }
     log(`snapshotted shared/${name} from ${src}`);
   }
-  const userSettings = join48(claude, "settings.json");
-  if (existsSync41(userSettings)) {
+  const userSettings = join49(claude, "settings.json");
+  if (existsSync42(userSettings)) {
     let parsed;
     try {
       parsed = readJson(userSettings);
     } catch (err) {
       return die(`malformed ${userSettings}: ${err.message}`);
     }
-    const hostFile = join48(repo, "hosts", `${HOST}.json`);
+    const hostFile = join49(repo, "hosts", `${HOST}.json`);
     writeJsonAtomic(hostFile, parsed);
     log(`snapshotted hosts/${HOST}.json from ${userSettings}`);
   }
@@ -6556,17 +6803,20 @@ var SHARED_CLAUDE_MD = "<!-- claude-nomad shared CLAUDE.md; symlinked into ~/.cl
 var SHARED_KEEP_DIRS = ["agents", "skills", "commands", "rules", "hooks"];
 function preflightConflict(repoHome2) {
   const candidates = [
-    join49(repoHome2, "shared", "settings.base.json"),
-    join49(repoHome2, "shared", "CLAUDE.md"),
-    join49(repoHome2, "path-map.json"),
-    join49(repoHome2, "hosts"),
-    join49(repoHome2, "shared")
+    join50(repoHome2, "shared", "settings.base.json"),
+    join50(repoHome2, "shared", "CLAUDE.md"),
+    join50(repoHome2, "path-map.json"),
+    join50(repoHome2, "hosts"),
+    join50(repoHome2, "shared")
   ];
   for (const c of candidates) {
-    if (existsSync42(c)) return c;
+    if (existsSync43(c)) return c;
   }
   return null;
 }
+function isAlreadyInitialized(repoHome2) {
+  return preflightConflict(repoHome2) !== null;
+}
 function cmdInit(opts = {}) {
   const snapshot = opts.snapshot === true;
   const keepActions = opts.keepActions === true;
@@ -6578,25 +6828,25 @@ function cmdInit(opts = {}) {
     die(`already initialized; refusing to clobber ${conflict}`);
   }
   ensureOriginRepo(opts.repoName ?? DEFAULT_REPO_NAME, opts.run);
-  mkdirSync11(join49(repo, "shared"), { recursive: true });
-  mkdirSync11(join49(repo, "hosts"), { recursive: true });
+  mkdirSync11(join50(repo, "shared"), { recursive: true });
+  mkdirSync11(join50(repo, "hosts"), { recursive: true });
   for (const name of SHARED_KEEP_DIRS) {
-    mkdirSync11(join49(repo, "shared", name), { recursive: true });
+    mkdirSync11(join50(repo, "shared", name), { recursive: true });
   }
-  const userClaudeMd = join49(claude, "CLAUDE.md");
-  if (!snapshot || !existsSync42(userClaudeMd)) {
-    writeFileSync6(join49(repo, "shared", "CLAUDE.md"), SHARED_CLAUDE_MD);
+  const userClaudeMd = join50(claude, "CLAUDE.md");
+  if (!snapshot || !existsSync43(userClaudeMd)) {
+    writeFileSync6(join50(repo, "shared", "CLAUDE.md"), SHARED_CLAUDE_MD);
     item("created shared/CLAUDE.md");
   }
   for (const name of SHARED_KEEP_DIRS) {
-    writeFileSync6(join49(repo, "shared", name, ".gitkeep"), "");
+    writeFileSync6(join50(repo, "shared", name, ".gitkeep"), "");
     item(`created shared/${name}/.gitkeep`);
   }
-  writeFileSync6(join49(repo, "hosts", ".gitkeep"), "");
+  writeFileSync6(join50(repo, "hosts", ".gitkeep"), "");
   item("created hosts/.gitkeep");
-  writeJsonAtomic(join49(repo, "shared", "settings.base.json"), {});
+  writeJsonAtomic(join50(repo, "shared", "settings.base.json"), {});
   item("created shared/settings.base.json");
-  writeJsonAtomic(join49(repo, "path-map.json"), { projects: {} });
+  writeJsonAtomic(join50(repo, "path-map.json"), { projects: {} });
   item("created path-map.json");
   if (snapshot) {
     snapshotIntoShared({ projects: {} });
@@ -6659,6 +6909,47 @@ function maybeDisableRepoActions(repoHome2, run) {
   }
 }
+// src/init.prompt.ts
+init_config();
+init_utils();
+import { existsSync as existsSync44, readdirSync as readdirSync16, statSync as statSync11 } from "node:fs";
+import { join as join51 } from "node:path";
+import { createInterface as createInterface3 } from "node:readline/promises";
+function nonEmptyExists(path) {
+  if (!existsSync44(path)) return false;
+  try {
+    if (statSync11(path).isDirectory()) return readdirSync16(path).length > 0;
+    return true;
+  } catch {
+    return false;
+  }
+}
+function hasExistingClaudeConfig(claudeHome2) {
+  if (existsSync44(join51(claudeHome2, "settings.json"))) return true;
+  return SHARED_LINKS.some((name) => nonEmptyExists(join51(claudeHome2, name)));
+}
+async function confirmSnapshotDefault(claudeHome2) {
+  if (process.stdin.isTTY !== true || process.stdout.isTTY !== true) {
+    log(
+      `tip: ${claudeHome2} already has config; re-run 'nomad init --snapshot' to seed the repo from it.`
+    );
+    return false;
+  }
+  log(`Found existing config in ${claudeHome2}.`);
+  const rl = createInterface3({ input: process.stdin, output: process.stdout });
+  try {
+    const answer = await rl.question("Seed the new repo from it? [Y/n] ");
+    return !/^n(o)?$/i.test(answer.trim());
+  } finally {
+    rl.close();
+  }
+}
+async function resolveSnapshotChoice(flagSnapshot, claudeHome2, confirm = confirmSnapshotDefault) {
+  if (flagSnapshot) return true;
+  if (!hasExistingClaudeConfig(claudeHome2)) return false;
+  return confirm(claudeHome2);
+}
 // src/nomad.dispatch.helpers.ts
 var REJECT = { ok: false, advance: 0 };
 function applyBool(seen, set) {
@@ -6918,7 +7209,7 @@ function parsePushArgs(argv) {
 // package.json
 var package_default = {
   name: "claude-nomad",
-  version: "0.53.3",
+  version: "0.55.0",
   type: "module",
   description: "Sync Claude Code config (~/.claude/) across machines via a private Git repo, with path remapping and per-host settings overrides.",
   keywords: [
@@ -7050,7 +7341,8 @@ var DEFAULT_HELP = [
     "  init",
     "Create a private GitHub repo via gh (if none exists), scaffold shared/, hosts/, path-map."
   ),
-  row("       --snapshot", "Overlay the current ~/.claude/ into shared/ as the initial seed."),
+  row("       --snapshot", "Seed shared/ from the current ~/.claude/. Without this flag, init"),
+  cont("offers the same seed interactively when it detects existing config."),
   row("       --keep-actions", "Skip auto-disabling GitHub Actions on the private repo."),
   row(
     "       --repo <name>",
@@ -7064,6 +7356,8 @@ var DEFAULT_HELP = [
   cont("`nomad push` would stage (a temp copy, never the live dir)."),
   row("       --check-schema", "Flag settings.json keys absent from the live published"),
   cont("Claude Code settings schema (needs network; degrades offline)."),
+  row("       --check-remote", "Verify origin/main has shared/ and a valid path-map.json"),
+  cont("(reads locally-cached remote ref; skips with a warning if unavailable)."),
   row("       --resume-cmd <id>", "Print `cd <abspath> && claude --resume <id>` for a session id"),
   cont("from ~/.claude/projects/."),
   "",
@@ -7126,7 +7420,8 @@ var DEFAULT_HELP = [
   "",
   row("  --version", "Print the installed CLI version as bare semver to stdout; exits 0."),
   "",
-  "Run `nomad doctor` to validate your setup. Edit shared/ or hosts/<HOST>.json",
+  "You edit the sync repo (~/claude-nomad/); nomad regenerates ~/.claude/ on every",
+  "pull. Run `nomad doctor` to validate your setup. Edit shared/ or hosts/<HOST>.json",
   "in the repo, never ~/.claude/settings.json directly (it is regenerated on",
   "every pull)."
 ].join("\n");
@@ -7135,15 +7430,15 @@ var DEFAULT_HELP = [
 init_config();
 init_utils();
 init_utils_json();
-import { existsSync as existsSync43, readFileSync as readFileSync14, readdirSync as readdirSync15 } from "node:fs";
-import { join as join50 } from "node:path";
+import { existsSync as existsSync45, readFileSync as readFileSync14, readdirSync as readdirSync17 } from "node:fs";
+import { join as join52 } from "node:path";
 function resumeCmd(sessionId) {
   if (!/^[A-Za-z0-9_-]+$/.test(sessionId) || sessionId.length > 128) {
     fail(`invalid session id: ${sessionId}`);
     process.exit(1);
   }
-  const projectsRoot = join50(claudeHome(), "projects");
-  if (!existsSync43(projectsRoot)) {
+  const projectsRoot = join52(claudeHome(), "projects");
+  if (!existsSync45(projectsRoot)) {
     fail(`${projectsRoot} does not exist`);
     process.exit(1);
   }
@@ -7157,8 +7452,8 @@ function resumeCmd(sessionId) {
     fail(`no cwd field found in ${jsonlPath}`);
     process.exit(1);
   }
-  const mapPath = join50(repoHome(), "path-map.json");
-  if (!existsSync43(mapPath)) {
+  const mapPath = join52(repoHome(), "path-map.json");
+  if (!existsSync45(mapPath)) {
     fail("path-map.json missing");
     process.exit(1);
   }
@@ -7180,9 +7475,9 @@ function resumeCmd(sessionId) {
   console.log(`cd ${shQuote(hit.localPath)} && claude --resume ${shQuote(sessionId)}`);
 }
 function findTranscriptPath(projectsRoot, sessionId) {
-  for (const dir of readdirSync15(projectsRoot)) {
-    const candidate = join50(projectsRoot, dir, `${sessionId}.jsonl`);
-    if (existsSync43(candidate)) return candidate;
+  for (const dir of readdirSync17(projectsRoot)) {
+    const candidate = join52(projectsRoot, dir, `${sessionId}.jsonl`);
+    if (existsSync45(candidate)) return candidate;
   }
   return null;
 }
@@ -7265,8 +7560,9 @@ try {
         console.error("usage: nomad init [--snapshot] [--keep-actions] [--repo <name>]");
         process.exit(1);
       }
+      const snapshot = isAlreadyInitialized(repoHome()) ? initArgs.snapshot : await resolveSnapshotChoice(initArgs.snapshot, claudeHome());
       cmdInit({
-        snapshot: initArgs.snapshot,
+        snapshot,
         keepActions: initArgs.keepActions,
         repoName: initArgs.repoName
       });
@@ -7284,7 +7580,7 @@ try {
         console.error("usage: nomad update");
         process.exit(1);
       }
-      cmdUpdate();
+      cmdUpdate(package_default.version);
       break;
     }
     case "adopt": {
@@ -7323,7 +7619,7 @@ try {
       const parsed = parseDoctorArgs(process.argv.slice(3));
       if (parsed.kind === "error") {
         console.error(
-          "usage: nomad doctor [--check-shared] [--check-schema] [--verbose|--all|-v] | --resume-cmd <session-id>"
+          "usage: nomad doctor [--check-shared] [--check-schema] [--check-remote] [--verbose|--all|-v] | --resume-cmd <session-id>"
         );
         process.exit(1);
       } else if (parsed.kind === "resume") {
@@ -7332,6 +7628,7 @@ try {
         cmdDoctor({
           checkShared: parsed.checkShared,
           checkSchema: parsed.checkSchema,
+          checkRemote: parsed.checkRemote,
           verbose: parsed.verbose
         });
       }