claude-nomad 0.53.2 → 0.54.0

package/dist/nomad.mjs

@@ -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 { execFileSync as execFileSync4 } from "node:child_process";
 import { readdirSync as readdirSync4, 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();
@@ -825,7 +825,7 @@ function findGitlinks(dir) {
       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;
@@ -2063,8 +2063,8 @@ 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();
@@ -2391,6 +2391,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 +2441,7 @@ function reportPathMap(section2) {
     return;
   }
   reportMappedProjects(section2, map);
+  reportCurrentHostPathsMissing(section2, map);
   reportUnmappedProjects(section2, map);
   reportPathCollisions(section2, map);
 }
@@ -2441,18 +2454,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 +2567,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 +2586,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,11 +2638,36 @@ 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 readdirSync5 } from "node:fs";
+import { join as join19 } from "node:path";
 init_config();
 var TS_SHAPE2 = /^\d{8}-\d{6}(-\d+)?$/;
 function safeReaddir(dir) {
@@ -2560,7 +2683,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 +2694,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 +2710,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 +2817,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 +2847,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 readdirSync7, 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 +2947,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 readdirSync6, 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 +3009,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 +3027,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,16 +3076,16 @@ 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)) {
     if (dir.endsWith(TMP_SUFFIX)) continue;
@@ -2904,13 +3094,13 @@ function remapPush(ts, opts = {}) {
       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 +3113,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 +3131,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 };
+  const localProjects = join24(claudeHome(), "projects");
+  if (!existsSync19(localProjects)) return { logicalToEncoded, staged, malformed: false };
   for (const dir of readdirSync7(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 +3144,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 +3167,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 +3192,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 readdirSync8, 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 +3215,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;
@@ -3068,15 +3258,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 +3286,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 +3326,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 +3339,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 +3363,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 +3400,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 +3460,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 +3534,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 +3568,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 +3587,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 +3600,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 +3626,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 +3784,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 +3802,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 readdirSync9, 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);
+    const abs = join30(dir, entry);
     const lst = lstatSync8(abs);
     if (lst.isSymbolicLink()) continue;
     if (lst.isDirectory()) {
@@ -3682,10 +3872,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 +3888,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 +3925,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 +3953,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 +4079,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 +4090,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 +4120,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 +4154,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 +4164,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 +4328,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 +4427,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 +4493,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 +4504,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 +4516,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 +4536,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,7 +4573,7 @@ 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"}`);
@@ -4398,11 +4588,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 +4600,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 +4614,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 +4622,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 +4630,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 +4644,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 +4652,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 +4709,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);
 }
@@ -4542,8 +4738,8 @@ function gatherDoctorSections(opts) {
   reportHostAndPaths(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 +4757,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 +4780,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 +4791,12 @@ function gatherDoctorSections(opts) {
     settings,
     pathMap,
     neverSync,
+    skills,
     repository,
     housekeeping,
     sharedScan,
-    schemaScan
+    schemaScan,
+    remoteCheck
   ];
   return [...body, buildVerdictSection(body)];
 }
@@ -4618,27 +4821,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 readdirSync10, 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 +4854,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 +4865,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 +4879,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 +4896,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 +4905,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 +4922,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);
@@ -4745,12 +4950,12 @@ 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)) {
+    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 +4971,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 +4990,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 +5086,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 } 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 readdirSync11, 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 +5131,16 @@ function* eachExtrasTarget(v, counts) {
   }
 }
 function stripCollidingDstSymlinks(src, dst, isExcluded) {
-  if (!existsSync32(dst)) return;
+  if (!existsSync33(dst)) return;
   for (const name of readdirSync11(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);
     }
   }
 }
@@ -5012,15 +5182,15 @@ function copyExtrasFiltered(src, dst, blockSet) {
 function prunePreservingDenied(src, dst, blockSet) {
   for (const name of readdirSync11(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 });
     }
@@ -5043,15 +5213,15 @@ function copyExtrasFilteredPreserving(src, dst, blockSet) {
 function prunePreservingBy(src, dst, isPreserved) {
   for (const name of readdirSync11(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 +5248,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 readdirSync12, 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 +5304,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 +5312,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 +5333,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);
@@ -5198,7 +5368,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 +5378,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 +5404,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 +5417,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 +5453,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.
@@ -5316,15 +5486,15 @@ 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}/)`
     );
@@ -5334,8 +5504,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 readdirSync13, rmSync as rmSync13 } from "node:fs";
+import { join as join43 } from "node:path";
 init_utils_fs();
 function isGsdOwned(name) {
   return name.startsWith(GSD_PREFIX);
@@ -5355,9 +5525,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 +5537,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 +5834,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 +5848,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 +5894,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 +5918,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 +6097,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 +6107,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 +6120,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 +6143,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 +6237,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 +6277,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 +6316,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 readdirSync14, 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 +6333,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)) {
     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 +6355,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 +6365,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 +6399,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,14 +6414,14 @@ 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);
@@ -6265,7 +6435,7 @@ function reportSettingsAheadDrift(repo) {
   }
 }
 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 +6501,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 +6524,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 +6546,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 +6589,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 +6614,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 +6697,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 statSync9 } 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);
+    const src = join49(claude, name);
+    if (!existsSync42(src)) continue;
+    const dst = join49(repo, "shared", name);
     if (statSync9(src).isDirectory()) {
-      const gk = join48(dst, ".gitkeep");
-      if (existsSync41(gk)) rmSync15(gk);
+      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,14 +6736,14 @@ 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;
 }
@@ -6578,25 +6758,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: {} });
@@ -6918,7 +7098,7 @@ function parsePushArgs(argv) {
 // package.json
 var package_default = {
   name: "claude-nomad",
-  version: "0.53.2",
+  version: "0.54.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: [
@@ -7064,6 +7244,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/."),
   "",
@@ -7135,15 +7317,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 existsSync44, readFileSync as readFileSync14, readdirSync as readdirSync15 } from "node:fs";
+import { join as join51 } 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 = join51(claudeHome(), "projects");
+  if (!existsSync44(projectsRoot)) {
     fail(`${projectsRoot} does not exist`);
     process.exit(1);
   }
@@ -7157,8 +7339,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 = join51(repoHome(), "path-map.json");
+  if (!existsSync44(mapPath)) {
     fail("path-map.json missing");
     process.exit(1);
   }
@@ -7181,8 +7363,8 @@ function resumeCmd(sessionId) {
 }
 function findTranscriptPath(projectsRoot, sessionId) {
   for (const dir of readdirSync15(projectsRoot)) {
-    const candidate = join50(projectsRoot, dir, `${sessionId}.jsonl`);
-    if (existsSync43(candidate)) return candidate;
+    const candidate = join51(projectsRoot, dir, `${sessionId}.jsonl`);
+    if (existsSync44(candidate)) return candidate;
   }
   return null;
 }
@@ -7284,7 +7466,7 @@ try {
         console.error("usage: nomad update");
         process.exit(1);
       }
-      cmdUpdate();
+      cmdUpdate(package_default.version);
       break;
     }
     case "adopt": {
@@ -7323,7 +7505,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 +7514,7 @@ try {
         cmdDoctor({
           checkShared: parsed.checkShared,
           checkSchema: parsed.checkSchema,
+          checkRemote: parsed.checkRemote,
           verbose: parsed.verbose
         });
       }