claude-nomad 0.69.2 → 0.69.3

package/dist/nomad.mjs

@@ -848,7 +848,7 @@ import {
   symlinkSync,
   writeFileSync
 } from "node:fs";
-import { dirname, join as join5, relative as relative3, sep as sep2 } from "node:path";
+import { dirname as dirname2, join as join5, relative as relative3, sep as sep2 } from "node:path";
 function isRetryableRenameCode(code) {
   return code === "EPERM" || code === "EBUSY";
 }
@@ -883,7 +883,7 @@ function writeJsonAtomic(path, data) {
     closeSync(fd);
   }
   renameAtomicRetry(tmp, path);
-  const dirFd = openSync(dirname(path), "r");
+  const dirFd = openSync(dirname2(path), "r");
   try {
     fsyncSync(dirFd);
   } catch (e) {
@@ -921,7 +921,7 @@ function ensureSymlink(linkPath, target) {
     if (lstatSync5(linkPath).isSymbolicLink()) return;
     die(`${linkPath} exists and is not a symlink. Move it aside first.`);
   }
-  mkdirSync(dirname(linkPath), { recursive: true });
+  mkdirSync(dirname2(linkPath), { recursive: true });
   symlinkSync(target, linkPath);
   log(`linked ${linkPath} -> ${target}`);
 }
@@ -931,7 +931,7 @@ function backupUnder(absPath, anchor, destRoot, hint) {
   if (rel === "" || rel === ".." || rel.startsWith(`..${sep2}`)) return false;
   const dst = join5(destRoot, rel);
   try {
-    mkdirSync(dirname(dst), { recursive: true });
+    mkdirSync(dirname2(dst), { recursive: true });
     cpSync3(absPath, dst, { recursive: true, force: false, preserveTimestamps: true });
   } catch (err) {
     const fragment = `could not back up ${absPath} into ${dst} (${errorText(err)}); a partial copy may be left there`;
@@ -963,12 +963,12 @@ var init_utils_fs = __esm({
 
 // src/commands/pull/wedge.ts
 import { execFileSync as execFileSync4 } from "node:child_process";
-import { existsSync as existsSync17 } from "node:fs";
-import { join as join23 } from "node:path";
+import { existsSync as existsSync18 } from "node:fs";
+import { join as join24 } from "node:path";
 function detectWedge(repo) {
-  const g = join23(repo, ".git");
-  if (existsSync17(join23(g, "rebase-merge")) || existsSync17(join23(g, "rebase-apply"))) return "rebase";
-  if (existsSync17(join23(g, "MERGE_HEAD"))) return "merge";
+  const g = join24(repo, ".git");
+  if (existsSync18(join24(g, "rebase-merge")) || existsSync18(join24(g, "rebase-apply"))) return "rebase";
+  if (existsSync18(join24(g, "MERGE_HEAD"))) return "merge";
   return null;
 }
 function probeUnmergedIndex(repo) {
@@ -1038,17 +1038,17 @@ var init_wedge = __esm({
 });
 
 // src/core/package-root.ts
-import { existsSync as existsSync18 } from "node:fs";
-import { basename as basename4, dirname as dirname6, join as join24 } from "node:path";
+import { existsSync as existsSync19 } from "node:fs";
+import { basename as basename5, dirname as dirname7, join as join25 } from "node:path";
 import { fileURLToPath } from "node:url";
 function packageRoot(from = HERE) {
   let dir = from;
   for (; ; ) {
-    if (existsSync18(join24(dir, "package.json"))) return dir;
-    if (basename4(dir) === "node_modules") {
+    if (existsSync19(join25(dir, "package.json"))) return dir;
+    if (basename5(dir) === "node_modules") {
       throw new Error(`no package.json above ${from} within its own package`);
     }
-    const parent = dirname6(dir);
+    const parent = dirname7(dir);
     if (parent === dir) throw new Error(`no package.json above ${from}`);
     dir = parent;
   }
@@ -1057,17 +1057,17 @@ var HERE;
 var init_package_root = __esm({
   "src/core/package-root.ts"() {
     "use strict";
-    HERE = dirname6(fileURLToPath(import.meta.url));
+    HERE = dirname7(fileURLToPath(import.meta.url));
   }
 });
 
 // src/commands/push/gitleaks.config.ts
-import { existsSync as existsSync19, mkdtempSync, readFileSync as readFileSync6, writeFileSync as writeFileSync3 } from "node:fs";
+import { existsSync as existsSync20, mkdtempSync, readFileSync as readFileSync6, writeFileSync as writeFileSync3 } from "node:fs";
 import { tmpdir } from "node:os";
-import { join as join25 } from "node:path";
+import { join as join26 } from "node:path";
 function resolveTomlPath(repo = repoHome()) {
-  const repoToml = join25(repo, ".gitleaks.toml");
-  if (existsSync19(repoToml)) return repoToml;
+  const repoToml = join26(repo, ".gitleaks.toml");
+  if (existsSync20(repoToml)) return repoToml;
   let root;
   try {
     root = packageRoot();
@@ -1076,8 +1076,8 @@ function resolveTomlPath(repo = repoHome()) {
       "claude-nomad install looks incomplete (no package.json above the CLI); reinstall with `npm i -g claude-nomad`"
     );
   }
-  const bundled = join25(root, ".gitleaks.toml");
-  return existsSync19(bundled) ? bundled : null;
+  const bundled = join26(root, ".gitleaks.toml");
+  return existsSync20(bundled) ? bundled : null;
 }
 function assertOverlayAllowlistsScoped(overlayBody) {
   if (OVERLAY_INLINE_ALLOWLIST_RE.test(overlayBody)) {
@@ -1115,17 +1115,17 @@ function buildOverlayTempConfig(overlayBody, bundled) {
 path = ${JSON.stringify(bundled)}
 
 ${overlayBody}`;
-  const tempPath = mkdtempSync(join25(tmpdir(), "nomad-gitleaks-cfg-"));
-  const configPath = join25(tempPath, "config.toml");
+  const tempPath = mkdtempSync(join26(tmpdir(), "nomad-gitleaks-cfg-"));
+  const configPath = join26(tempPath, "config.toml");
   writeFileSync3(configPath, tempBody, { mode: 384, flag: "wx" });
   return { configPath, tempPath };
 }
 function resolveTomlConfig() {
   const repo = repoHome();
-  const overlayPath = join25(repo, ".gitleaks.overlay.toml");
-  const repoToml = join25(repo, ".gitleaks.toml");
+  const overlayPath = join26(repo, ".gitleaks.overlay.toml");
+  const repoToml = join26(repo, ".gitleaks.toml");
   const bundled = resolveTomlPath(repo);
-  if (!existsSync19(overlayPath)) {
+  if (!existsSync20(overlayPath)) {
     return { path: bundled, tempPath: null };
   }
   if (bundled === repoToml) {
@@ -1212,9 +1212,9 @@ var init_autostash_guard = __esm({
 
 // src/commands/push/checks.ts
 import { execFileSync as execFileSync5 } from "node:child_process";
-import { readdirSync as readdirSync8, rmSync as rmSync10 } from "node:fs";
+import { readdirSync as readdirSync9, rmSync as rmSync11 } from "node:fs";
 import { homedir as homedir2, platform } from "node:os";
-import { delimiter, join as join26 } from "node:path";
+import { delimiter, join as join27 } from "node:path";
 function gitleaksInstallHint() {
   const head = "gitleaks not on PATH (required for nomad push). Install:";
   const plat = platform();
@@ -1257,12 +1257,12 @@ function findGitlinks(dir) {
   function walk2(current) {
     let entries;
     try {
-      entries = readdirSync8(current, { withFileTypes: true });
+      entries = readdirSync9(current, { withFileTypes: true });
     } catch {
       return;
     }
     for (const e of entries) {
-      const p = join26(current, e.name);
+      const p = join27(current, e.name);
       if (e.name === ".git") {
         hits.push(p);
         continue;
@@ -1284,7 +1284,7 @@ function probeGitleaks() {
     if (e.code === "ENOENT") throw new NomadFatal(gitleaksInstallHint());
     throw new NomadFatal(`gitleaks --version failed: ${e.message}`);
   } finally {
-    if (tempPath !== null) rmSync10(tempPath, { recursive: true, force: true });
+    if (tempPath !== null) rmSync11(tempPath, { recursive: true, force: true });
   }
 }
 function wedgePreflight(wedge) {
@@ -1324,9 +1324,9 @@ var init_checks = __esm({
 
 // src/commands/push/gitleaks.scan.ts
 import { execFileSync as execFileSync9 } from "node:child_process";
-import { mkdirSync as mkdirSync4, mkdtempSync as mkdtempSync2, readFileSync as readFileSync7, rmSync as rmSync11 } from "node:fs";
+import { mkdirSync as mkdirSync5, mkdtempSync as mkdtempSync2, readFileSync as readFileSync7, rmSync as rmSync12 } from "node:fs";
 import { homedir as homedir3 } from "node:os";
-import { join as join30 } from "node:path";
+import { join as join31 } from "node:path";
 function toFinding(entry) {
   if (typeof entry !== "object" || entry === null) return null;
   const e = entry;
@@ -1374,9 +1374,9 @@ function resolveScanFailure(reportPath, e, forwardStreams) {
   return report;
 }
 function scanStagedTree(repoDir, forwardStreams = false) {
-  const cacheDir = join30(homedir3(), ".cache", "claude-nomad");
-  mkdirSync4(cacheDir, { recursive: true });
-  const reportPath = join30(cacheDir, `gitleaks-${nowTimestamp()}-${process.pid}.json`);
+  const cacheDir = join31(homedir3(), ".cache", "claude-nomad");
+  mkdirSync5(cacheDir, { recursive: true });
+  const reportPath = join31(cacheDir, `gitleaks-${nowTimestamp()}-${process.pid}.json`);
   const { path: toml, tempPath } = resolveTomlConfig();
   const args = [
     "protect",
@@ -1399,19 +1399,19 @@ function scanStagedTree(repoDir, forwardStreams = false) {
     if (e.code === "ENOENT") throw err;
     return resolveScanFailure(reportPath, e, forwardStreams);
   } finally {
-    if (tempPath !== null) rmSync11(tempPath, { recursive: true, force: true });
-    rmSync11(reportPath, { force: true });
+    if (tempPath !== null) rmSync12(tempPath, { recursive: true, force: true });
+    rmSync12(reportPath, { force: true });
   }
 }
 function scanFile(filePath, forwardStreams = false, timeoutMs = GITLEAKS_SCAN_TIMEOUT_MS) {
-  const cacheDir = join30(homedir3(), ".cache", "claude-nomad");
-  mkdirSync4(cacheDir, { recursive: true });
+  const cacheDir = join31(homedir3(), ".cache", "claude-nomad");
+  mkdirSync5(cacheDir, { recursive: true });
   const { path: toml, tempPath } = resolveTomlConfig();
   let reportDir;
   let reportPath;
   try {
-    reportDir = mkdtempSync2(join30(cacheDir, `gitleaks-file-${nowTimestamp()}-${process.pid}-`));
-    reportPath = join30(reportDir, "report.json");
+    reportDir = mkdtempSync2(join31(cacheDir, `gitleaks-file-${nowTimestamp()}-${process.pid}-`));
+    reportPath = join31(reportDir, "report.json");
     const args = [
       "detect",
       "--no-git",
@@ -1432,8 +1432,8 @@ function scanFile(filePath, forwardStreams = false, timeoutMs = GITLEAKS_SCAN_TI
     if (e.code === "ENOENT") return null;
     return resolveScanFailure(reportPath, e, forwardStreams);
   } finally {
-    if (tempPath !== null) rmSync11(tempPath, { recursive: true, force: true });
-    if (reportDir !== void 0) rmSync11(reportDir, { recursive: true, force: true });
+    if (tempPath !== null) rmSync12(tempPath, { recursive: true, force: true });
+    if (reportDir !== void 0) rmSync12(reportDir, { recursive: true, force: true });
   }
 }
 var init_gitleaks_scan = __esm({
@@ -1640,7 +1640,7 @@ import { join as join10 } from "node:path";
 
 // src/commands/adopt.recover.ts
 import { rmSync as rmSync6 } from "node:fs";
-import { dirname as dirname3, join as join8, resolve as resolve2 } from "node:path";
+import { dirname as dirname4, join as join8, resolve as resolve2 } from "node:path";
 
 // src/commands/adopt.scan.ts
 init_config();
@@ -1734,14 +1734,17 @@ import { basename as basename2, join as join4, relative as relative2 } from "nod
 // src/sync/extras/collision.ts
 init_utils();
 import { cpSync, existsSync, lstatSync as lstatSync2, readdirSync as readdirSync2, rmSync } from "node:fs";
-import { basename, join as join3 } from "node:path";
+import { basename, dirname, join as join3 } from "node:path";
 function quoted(p) {
   return `"${p}"`;
 }
-function stripCollidingDstSymlinks(src, dst, isExcluded) {
+function isRootExcludedEntry(src, entry, isRootExcluded) {
+  return dirname(entry) === src && isRootExcluded?.(basename(entry)) === true;
+}
+function stripCollidingDstSymlinks(src, dst, isExcluded, isRootExcluded) {
   if (!existsSync(dst)) return;
   for (const name of readdirSync2(src)) {
-    if (isExcluded(name)) continue;
+    if (isExcluded(name) || isRootExcluded?.(name) === true) continue;
     const dstPath = join3(dst, name);
     const dstStat = lstatSync2(dstPath, { throwIfNoEntry: false });
     if (dstStat === void 0) continue;
@@ -1782,7 +1785,7 @@ function prunePreservingBy(src, dst, isPreserved, isRootPreserved) {
     }
   }
 }
-function copyExtrasFilteredPreservingBy(src, dst, isPreserved, isRootPreserved) {
+function copyExtrasFilteredPreservingBy(src, dst, isPreserved, isRootPreserved, isRootExcluded) {
   const dstStat = lstatSync2(dst, { throwIfNoEntry: false });
   if (dstStat !== void 0) {
     if (dstStat.isDirectory()) {
@@ -1792,17 +1795,22 @@ function copyExtrasFilteredPreservingBy(src, dst, isPreserved, isRootPreserved)
           `copyExtrasFilteredPreservingBy: type mismatch copying ${quoted(src)} -> ${quoted(dst)}: the repo entry is a file but the local entry is a directory; run nomad pull --force-remote to recover`
         );
       }
-      prunePreservingBy(src, dst, isPreserved, isRootPreserved);
+      prunePreservingBy(
+        src,
+        dst,
+        isPreserved,
+        (name) => isRootExcluded?.(name) === true || isRootPreserved?.(name) === true
+      );
     } else {
       rmSync(dst, { recursive: true, force: true });
     }
   }
-  stripCollidingDstSymlinks(src, dst, isPreserved);
+  stripCollidingDstSymlinks(src, dst, isPreserved, isRootExcluded);
   cpSync(src, dst, {
     recursive: true,
     force: true,
     verbatimSymlinks: true,
-    filter: (srcEntry) => srcEntry === src || !isPreserved(basename(srcEntry))
+    filter: (srcEntry) => srcEntry === src || !isPreserved(basename(srcEntry)) && !isRootExcludedEntry(src, srcEntry, isRootExcluded)
   });
 }
 
@@ -1853,12 +1861,12 @@ function* eachExtrasTarget(v, counts) {
       counts.unmapped++;
       continue;
     }
-    for (const dirname18 of dirnames) {
-      if (!whitelist.includes(dirname18)) {
+    for (const dirname19 of dirnames) {
+      if (!whitelist.includes(dirname19)) {
         counts.skipped++;
         continue;
       }
-      yield { logical, localRoot, dirname: dirname18 };
+      yield { logical, localRoot, dirname: dirname19 };
     }
   }
 }
@@ -1900,16 +1908,16 @@ function copyExtrasFileSkipDiverged(src, dst) {
   }
   copyExtras(src, dst);
 }
-function extrasDenySet(dirname18) {
-  return isClaudeExtraName(dirname18) ? CLAUDE_EXTRA_NEVER_SYNC : ALWAYS_NEVER_SYNC;
+function extrasDenySet(dirname19) {
+  return isClaudeExtraName(dirname19) ? CLAUDE_EXTRA_NEVER_SYNC : ALWAYS_NEVER_SYNC;
 }
-function copyExtrasFiltered(src, dst, blockSet) {
+function copyExtrasFiltered(src, dst, blockSet, isRootExcluded) {
   rmSync2(dst, { recursive: true, force: true });
   cpSync2(src, dst, {
     recursive: true,
     force: true,
     verbatimSymlinks: true,
-    filter: (srcEntry) => srcEntry === src || !isDeniedName(blockSet, basename2(srcEntry))
+    filter: (srcEntry) => srcEntry === src || !isDeniedName(blockSet, basename2(srcEntry)) && !isRootExcludedEntry(src, srcEntry, isRootExcluded)
   });
 }
 function prunePreservingDenied(src, dst, blockSet) {
@@ -2490,7 +2498,7 @@ init_config();
 init_utils_fs();
 init_utils();
 import { mkdirSync as mkdirSync2, readFileSync as readFileSync3, rmSync as rmSync3 } from "node:fs";
-import { dirname as dirname2 } from "node:path";
+import { dirname as dirname3 } from "node:path";
 var SETTINGS_WRITTEN_KIND = "settings-written/2";
 function isObject(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
@@ -2510,7 +2518,7 @@ function readWrittenSettingsKeys() {
 function recordWrittenSettingsKeys(written) {
   try {
     const path = settingsWrittenPath();
-    mkdirSync2(dirname2(path), { recursive: true });
+    mkdirSync2(dirname3(path), { recursive: true });
     rmSync3(path, { force: true });
     const keys = Object.fromEntries(
       Object.entries(stripGsdHookEntries(written)).map(([k, v]) => [k, settingValueHash(v)])
@@ -2729,7 +2737,7 @@ function regenerateSettings(ts, opts = {}) {
 // src/commands/adopt.recover.ts
 init_utils();
 function isDirectChildOf(root, abs) {
-  return dirname3(resolve2(abs)) === resolve2(root);
+  return dirname4(resolve2(abs)) === resolve2(root);
 }
 function clearPartialCopy(linkPath) {
   return clearIfDirectChild(claudeHome(), linkPath);
@@ -2849,13 +2857,13 @@ init_utils_fs();
 init_config();
 init_utils();
 import { closeSync as closeSync2, mkdirSync as mkdirSync3, openSync as openSync2, readFileSync as readFileSync4, unlinkSync, writeFileSync as writeFileSync2 } from "node:fs";
-import { dirname as dirname4, join as join9 } from "node:path";
+import { dirname as dirname5, join as join9 } from "node:path";
 function lockFilePath() {
   return join9(home(), ".cache", "claude-nomad", "nomad.lock");
 }
 function acquireLock(verb) {
   const lp = lockFilePath();
-  mkdirSync3(dirname4(lp), { recursive: true });
+  mkdirSync3(dirname5(lp), { recursive: true });
   try {
     const fd = openSync2(lp, "wx");
     try {
@@ -3406,7 +3414,7 @@ init_config_sharedDirs_guard();
 init_utils();
 init_utils_json();
 import { existsSync as existsSync11, realpathSync as realpathSync2, rmSync as rmSync9 } from "node:fs";
-import { basename as basename3, dirname as dirname5, join as join15 } from "node:path";
+import { basename as basename3, dirname as dirname6, join as join15 } from "node:path";
 
 // src/commands/eject.materialize.ts
 init_config();
@@ -3498,7 +3506,7 @@ function ejectChecklist() {
     `  3. Optionally delete the local sync checkout: rm -rf ${shellPath(repoHome())}`,
     `  4. Optionally delete the private sync repo on GitHub`,
     `  5. Optionally delete nomad's cache folder, which holds backups and crash reports, once you`,
-    `     no longer need the backups in it: rm -rf ${shellPath(dirname5(backupBase()))}`
+    `     no longer need the backups in it: rm -rf ${shellPath(dirname6(backupBase()))}`
   ].join("\n");
 }
 function forgetHostRecords(cacheDir, dryRun) {
@@ -3587,7 +3595,7 @@ function ejectNames(map) {
   return [.../* @__PURE__ */ new Set([...allSharedLinks(map), ...alreadyMaterialized])];
 }
 function defaultEjectRoots() {
-  return { claudeHome: claudeHome(), repoHome: repoHome(), cacheDir: dirname5(backupBase()) };
+  return { claudeHome: claudeHome(), repoHome: repoHome(), cacheDir: dirname6(backupBase()) };
 }
 function cmdEject(opts = {}, roots = defaultEjectRoots()) {
   const dryRun = opts.dryRun === true;
@@ -4336,15 +4344,80 @@ function reportNeverSync(section2) {
 
 // src/commands/doctor/checks/skills.ts
 init_color();
-import { existsSync as existsSync16 } from "node:fs";
-import { join as join22 } from "node:path";
+import { existsSync as existsSync17 } from "node:fs";
+import { join as join23 } from "node:path";
+init_config();
+
+// src/sync/skills-sync.ts
 init_config();
+import { existsSync as existsSync16, lstatSync as lstatSync13, mkdirSync as mkdirSync4, readdirSync as readdirSync8, rmSync as rmSync10 } from "node:fs";
+import { join as join22 } from "node:path";
+
+// src/sync/skills-sync.tracked.ts
+init_utils();
+import { basename as basename4 } from "node:path";
+function trackedRootSkillsAt(ref, repo) {
+  try {
+    const raw = gitCaptureRaw(["ls-tree", "--name-only", "-z", ref, "--", "shared/skills/"], repo);
+    const entries = raw.split("\0").filter((entry) => entry !== "");
+    return new Set(entries.map((entry) => basename4(entry)));
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+}
+
+// src/sync/skills-sync.ts
+init_utils_fs();
+function isGsdOwned(name) {
+  return name.startsWith(GSD_PREFIX);
+}
+function isSkillExcluded(name) {
+  return isGsdOwned(name) || isDeniedName(ALWAYS_NEVER_SYNC, name);
+}
+var ROOT_EXCLUDED_SKILLS_DIRS = /* @__PURE__ */ new Set(["synced", ".trash", ".staging"]);
+function isRootSkillExcluded(name) {
+  return isSkillExcluded(name) || ROOT_EXCLUDED_SKILLS_DIRS.has(name.toLowerCase());
+}
+function copySkillsPush(src, dst) {
+  const srcNames = readdirSync8(src, { encoding: "utf8" });
+  const blockSet = /* @__PURE__ */ new Set([
+    ...srcNames.filter((n) => isGsdOwned(n)),
+    ...ALWAYS_NEVER_SYNC
+  ]);
+  copyExtrasFiltered(src, dst, blockSet, isRootSkillExcluded);
+}
+function copySkillsPull(src, dst, isRootPreserved) {
+  copyExtrasFilteredPreservingBy(src, dst, isSkillExcluded, isRootPreserved, isRootSkillExcluded);
+}
+function syncSkillsPull(ts, prePostHeads) {
+  const sharedSkills = join22(repoHome(), "shared", "skills");
+  if (!existsSync16(sharedSkills)) return;
+  const localSkills = join22(claudeHome(), "skills");
+  backupBeforeWrite(localSkills, ts);
+  const dstStat = lstatSync13(localSkills, { throwIfNoEntry: false });
+  if (dstStat?.isSymbolicLink() === true) {
+    rmSync10(localSkills, { recursive: true, force: true });
+    mkdirSync4(localSkills, { recursive: true });
+  }
+  const tracked = prePostHeads === void 0 ? /* @__PURE__ */ new Set() : trackedRootSkillsAt(prePostHeads.pre, repoHome());
+  copySkillsPull(sharedSkills, localSkills, (name) => !tracked.has(name));
+}
+function syncSkillsPush() {
+  const localSkills = join22(claudeHome(), "skills");
+  const stat = lstatSync13(localSkills, { throwIfNoEntry: false });
+  if (stat === void 0) return;
+  if (stat.isSymbolicLink()) return;
+  const sharedSkills = join22(repoHome(), "shared", "skills");
+  copySkillsPush(localSkills, sharedSkills);
+}
+
+// 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) {
+function isExcludedDiffLine(line, localBase, sharedBase) {
   const bare = stripSideIndicator(line);
   let relative12;
   if (bare.startsWith(localBase + "/")) {
@@ -4354,21 +4427,21 @@ function isGsdDiffLine(line, localBase, sharedBase) {
   } else {
     relative12 = bare;
   }
-  return relative12.split("/")[0].startsWith(GSD_PREFIX);
+  return isRootSkillExcluded(relative12.split("/")[0]);
 }
 function reportSkillsDivergence(section2) {
-  const sharedSkills = join22(repoHome(), "shared", "skills");
-  const localSkills = join22(claudeHome(), "skills");
-  if (!existsSync16(sharedSkills)) {
+  const sharedSkills = join23(repoHome(), "shared", "skills");
+  const localSkills = join23(claudeHome(), "skills");
+  if (!existsSync17(sharedSkills)) {
     addItem(section2, `${dim(infoGlyph)} skills: no shared/skills/ to compare`);
     return;
   }
-  if (!existsSync16(localSkills)) {
+  if (!existsSync17(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));
+  const relevant = diff.filter((line) => !isExcludedDiffLine(line, localSkills, sharedSkills));
   if (relevant.length === 0) {
     addItem(section2, `${green(okGlyph)} skills: in sync with shared/skills/`);
     return;
@@ -4386,8 +4459,8 @@ function reportSkillsDivergence(section2) {
 init_color();
 init_config();
 import { execFileSync as execFileSync6 } from "node:child_process";
-import { existsSync as existsSync20 } from "node:fs";
-import { join as join27, relative as relative5 } from "node:path";
+import { existsSync as existsSync21 } from "node:fs";
+import { join as join28, relative as relative5 } from "node:path";
 init_wedge();
 init_checks();
 init_utils();
@@ -4410,8 +4483,8 @@ function reportGitleaksProbe(section2) {
 }
 function reportGitlinks(section2) {
   const repo = repoHome();
-  const sharedDir = join27(repo, "shared");
-  if (existsSync20(sharedDir)) {
+  const sharedDir = join28(repo, "shared");
+  if (existsSync21(sharedDir)) {
     const gitlinks = findGitlinks(sharedDir);
     for (const p of gitlinks) {
       const rel = relative5(repo, p).replaceAll("\\", "/");
@@ -4548,13 +4621,13 @@ function reportTrackedDeniedShared(section2) {
 
 // src/commands/doctor/checks/backups.ts
 init_color();
-import { existsSync as existsSync21, lstatSync as lstatSync13, readdirSync as readdirSync9 } from "node:fs";
-import { join as join28 } from "node:path";
+import { existsSync as existsSync22, lstatSync as lstatSync14, readdirSync as readdirSync10 } from "node:fs";
+import { join as join29 } from "node:path";
 init_config();
 var TS_SHAPE2 = /^\d{8}-\d{6}(-\d+)?$/;
 function safeReaddir(dir) {
   try {
-    return readdirSync9(dir);
+    return readdirSync10(dir);
   } catch {
     return [];
   }
@@ -4565,8 +4638,8 @@ var BYTES_PER_MB = 1024 * 1024;
 function dirSizeBytes(dir) {
   let bytes = 0;
   for (const entry of safeReaddir(dir)) {
-    const full = join28(dir, entry);
-    const st = lstatSync13(full, { throwIfNoEntry: false });
+    const full = join29(dir, entry);
+    const st = lstatSync14(full, { throwIfNoEntry: false });
     if (!st) continue;
     if (st.isSymbolicLink()) continue;
     if (st.isDirectory()) bytes += dirSizeBytes(full);
@@ -4576,11 +4649,11 @@ function dirSizeBytes(dir) {
 }
 function totalSizeMb(backupBase2, dirs) {
   let bytes = 0;
-  for (const name of dirs) bytes += dirSizeBytes(join28(backupBase2, name));
+  for (const name of dirs) bytes += dirSizeBytes(join29(backupBase2, name));
   return bytes / BYTES_PER_MB;
 }
 function reportBackupsCheck(section2, backupBase2 = backupBase()) {
-  if (!existsSync21(backupBase2)) return;
+  if (!existsSync22(backupBase2)) return;
   const dirs = safeReaddir(backupBase2).filter((n) => TS_SHAPE2.test(n));
   const count = dirs.length;
   const sizeMb = totalSizeMb(backupBase2, dirs);
@@ -4661,8 +4734,8 @@ function reportCheckRemote(section2) {
 
 // src/commands/doctor/checks/schema.ts
 init_color();
-import { existsSync as existsSync22 } from "node:fs";
-import { join as join29 } from "node:path";
+import { existsSync as existsSync23 } from "node:fs";
+import { join as join30 } from "node:path";
 init_config();
 
 // src/core/http-fetch.ts
@@ -4699,8 +4772,8 @@ function fetchSchemaKeys() {
   }
 }
 function reportCheckSchema(section2) {
-  const settingsPath = join29(claudeHome(), "settings.json");
-  if (!existsSync22(settingsPath)) {
+  const settingsPath = join30(claudeHome(), "settings.json");
+  if (!existsSync23(settingsPath)) {
     addItem(section2, `${dim(infoGlyph)} no ~/.claude/settings.json to check`);
     return;
   }
@@ -4730,17 +4803,17 @@ function reportCheckSchema(section2) {
 init_color();
 import { randomBytes as randomBytes3 } from "node:crypto";
 import { execFileSync as execFileSync12 } from "node:child_process";
-import { existsSync as existsSync26, mkdirSync as mkdirSync9, readdirSync as readdirSync13, rmSync as rmSync15 } from "node:fs";
+import { existsSync as existsSync27, mkdirSync as mkdirSync10, readdirSync as readdirSync14, rmSync as rmSync16 } from "node:fs";
 import { homedir as homedir6 } from "node:os";
-import { join as join37 } from "node:path";
+import { join as join38 } from "node:path";
 
 // src/commands/doctor/checks/shared.memory.ts
 init_color();
 import { execFileSync as execFileSync10 } from "node:child_process";
 import { randomBytes } from "node:crypto";
-import { mkdirSync as mkdirSync5, rmSync as rmSync12, writeFileSync as writeFileSync4 } from "node:fs";
+import { mkdirSync as mkdirSync6, rmSync as rmSync13, writeFileSync as writeFileSync4 } from "node:fs";
 import { homedir as homedir4 } from "node:os";
-import { dirname as dirname7, join as join31 } from "node:path";
+import { dirname as dirname8, join as join32 } from "node:path";
 init_config();
 init_gitleaks();
 init_utils_fs();
@@ -4773,8 +4846,8 @@ function buildMemoryScanTree(tmpRoot) {
       incomplete = true;
       continue;
     }
-    const dest = join31(tmpRoot, rel);
-    mkdirSync5(dirname7(dest), { recursive: true });
+    const dest = join32(tmpRoot, rel);
+    mkdirSync6(dirname8(dest), { recursive: true });
     writeFileSync4(dest, blob);
     logicals.add(m[1]);
   }
@@ -4792,11 +4865,11 @@ function reportMemoryFindings(section2, findings) {
 function reportCommittedMemory(section2) {
   let tmpRoot;
   try {
-    const cacheDir = join31(homedir4(), ".cache", "claude-nomad");
-    mkdirSync5(cacheDir, { recursive: true });
+    const cacheDir = join32(homedir4(), ".cache", "claude-nomad");
+    mkdirSync6(cacheDir, { recursive: true });
     const stamp = `${nowTimestamp()}-${process.pid}-${randomBytes(4).toString("hex")}`;
-    tmpRoot = join31(cacheDir, `check-shared-memory-tree-${stamp}`);
-    mkdirSync5(tmpRoot, { recursive: true, mode: 448 });
+    tmpRoot = join32(cacheDir, `check-shared-memory-tree-${stamp}`);
+    mkdirSync6(tmpRoot, { recursive: true, mode: 448 });
     const { staged, incomplete } = buildMemoryScanTree(tmpRoot);
     if (incomplete) {
       addItem(
@@ -4833,7 +4906,7 @@ function reportCommittedMemory(section2) {
   } finally {
     if (tmpRoot !== void 0) {
       try {
-        rmSync12(tmpRoot, { recursive: true, force: true });
+        rmSync13(tmpRoot, { recursive: true, force: true });
       } catch {
       }
     }
@@ -4842,12 +4915,12 @@ function reportCommittedMemory(section2) {
 
 // src/commands/doctor/checks/shared.scan.ts
 init_color();
-import { join as join32 } from "node:path";
+import { join as join33 } from "node:path";
 init_config();
 init_gitleaks();
 function scrubPath(logical, sid, logicalToEncoded) {
   const encoded = logicalToEncoded.get(logical) ?? logical;
-  return join32(claudeHome(), "projects", encoded, `${sid}.jsonl`);
+  return join33(claudeHome(), "projects", encoded, `${sid}.jsonl`);
 }
 function reportSessionFindings(section2, bySession) {
   for (const [sid, counts] of bySession) {
@@ -4934,9 +5007,9 @@ function scanAndReport(section2, tmpRoot, staged, logicalToEncoded) {
 init_color();
 import { execFileSync as execFileSync11 } from "node:child_process";
 import { randomBytes as randomBytes2 } from "node:crypto";
-import { mkdirSync as mkdirSync6, rmSync as rmSync13, writeFileSync as writeFileSync5 } from "node:fs";
+import { mkdirSync as mkdirSync7, rmSync as rmSync14, writeFileSync as writeFileSync5 } from "node:fs";
 import { homedir as homedir5 } from "node:os";
-import { dirname as dirname8, join as join33 } from "node:path";
+import { dirname as dirname9, join as join34 } from "node:path";
 init_config();
 init_gitleaks();
 init_utils_fs();
@@ -4969,8 +5042,8 @@ function buildSkillScanTree(tmpRoot) {
       incomplete = true;
       continue;
     }
-    const dest = join33(tmpRoot, rel);
-    mkdirSync6(dirname8(dest), { recursive: true });
+    const dest = join34(tmpRoot, rel);
+    mkdirSync7(dirname9(dest), { recursive: true });
     writeFileSync5(dest, blob);
     names.add(m[1]);
   }
@@ -4992,11 +5065,11 @@ function reportSkillFindings(section2, findings) {
 function reportCommittedSkills(section2) {
   let tmpRoot;
   try {
-    const cacheDir = join33(homedir5(), ".cache", "claude-nomad");
-    mkdirSync6(cacheDir, { recursive: true });
+    const cacheDir = join34(homedir5(), ".cache", "claude-nomad");
+    mkdirSync7(cacheDir, { recursive: true });
     const stamp = `${nowTimestamp()}-${process.pid}-${randomBytes2(4).toString("hex")}`;
-    tmpRoot = join33(cacheDir, `check-shared-skills-tree-${stamp}`);
-    mkdirSync6(tmpRoot, { recursive: true, mode: 448 });
+    tmpRoot = join34(cacheDir, `check-shared-skills-tree-${stamp}`);
+    mkdirSync7(tmpRoot, { recursive: true, mode: 448 });
     const { staged, incomplete } = buildSkillScanTree(tmpRoot);
     if (incomplete) {
       addItem(
@@ -5033,7 +5106,7 @@ function reportCommittedSkills(section2) {
   } finally {
     if (tmpRoot !== void 0) {
       try {
-        rmSync13(tmpRoot, { recursive: true, force: true });
+        rmSync14(tmpRoot, { recursive: true, force: true });
       } catch {
       }
     }
@@ -5045,8 +5118,8 @@ init_config();
 
 // src/sync/remap.ts
 init_config_sharedDirs_guard();
-import { cpSync as cpSync5, existsSync as existsSync25, mkdirSync as mkdirSync8, readdirSync as readdirSync12, rmSync as rmSync14, statSync as statSync6 } from "node:fs";
-import { dirname as dirname10, join as join36, relative as relative6, sep as sep5 } from "node:path";
+import { cpSync as cpSync5, existsSync as existsSync26, mkdirSync as mkdirSync9, readdirSync as readdirSync13, rmSync as rmSync15, statSync as statSync6 } from "node:fs";
+import { dirname as dirname11, join as join37, relative as relative6, sep as sep5 } from "node:path";
 init_config();
 
 // src/commands/push/manifest.ts
@@ -5054,8 +5127,8 @@ init_config();
 init_gitleaks_config();
 init_utils_fs();
 import { createHash as createHash2 } from "node:crypto";
-import { existsSync as existsSync23, mkdirSync as mkdirSync7, readdirSync as readdirSync10, readFileSync as readFileSync8, statSync as statSync5 } from "node:fs";
-import { dirname as dirname9, join as join34 } from "node:path";
+import { existsSync as existsSync24, mkdirSync as mkdirSync8, readdirSync as readdirSync11, readFileSync as readFileSync8, statSync as statSync5 } from "node:fs";
+import { dirname as dirname10, join as join35 } from "node:path";
 function isChanged(prev, cur, hash) {
   if (prev === void 0) return true;
   if (prev.size !== cur.size) return true;
@@ -5095,8 +5168,8 @@ function hashFile(absPath) {
   return createHash2("sha256").update(readFileSync8(absPath)).digest("hex");
 }
 function enumerateDir(dir, results) {
-  for (const entry of readdirSync10(dir)) {
-    const fullPath = join34(dir, entry);
+  for (const entry of readdirSync11(dir)) {
+    const fullPath = join35(dir, entry);
     const st = statSync5(fullPath);
     if (st.isDirectory()) {
       enumerateDir(fullPath, results);
@@ -5107,8 +5180,8 @@ function enumerateDir(dir, results) {
 }
 function enumerateSourceFiles(projectDir) {
   const results = [];
-  for (const entry of readdirSync10(projectDir)) {
-    const fullPath = join34(projectDir, entry);
+  for (const entry of readdirSync11(projectDir)) {
+    const fullPath = join35(projectDir, entry);
     const st = statSync5(fullPath);
     if (st.isDirectory()) {
       enumerateDir(fullPath, results);
@@ -5120,15 +5193,15 @@ function enumerateSourceFiles(projectDir) {
 }
 function fileIdentity(p) {
   if (p === null) return "none::absent";
-  if (!existsSync23(p)) return `${p}::absent`;
+  if (!existsSync24(p)) return `${p}::absent`;
   return `${p}::${createHash2("sha256").update(readFileSync8(p)).digest("hex")}`;
 }
 function computeConfigHash() {
   const repo = repoHome();
   const parts = [
     fileIdentity(resolveTomlPath(repo)),
-    fileIdentity(join34(repo, ".gitleaks.overlay.toml")),
-    fileIdentity(join34(repo, ".gitleaksignore"))
+    fileIdentity(join35(repo, ".gitleaks.overlay.toml")),
+    fileIdentity(join35(repo, ".gitleaksignore"))
   ];
   return createHash2("sha256").update(parts.join("\n")).digest("hex");
 }
@@ -5148,7 +5221,7 @@ function readManifest(path) {
   }
 }
 function writeManifest(path, manifest) {
-  mkdirSync7(dirname9(path), { recursive: true });
+  mkdirSync8(dirname10(path), { recursive: true });
   writeJsonAtomic(path, manifest);
 }
 function buildManifest(files, scannerVersion, configHash) {
@@ -5162,18 +5235,18 @@ init_utils_json();
 
 // src/sync/remap.scan.ts
 init_config_sharedDirs_guard();
-import { existsSync as existsSync24, lstatSync as lstatSync14, readdirSync as readdirSync11 } from "node:fs";
-import { join as join35 } from "node:path";
+import { existsSync as existsSync25, lstatSync as lstatSync15, readdirSync as readdirSync12 } from "node:fs";
+import { join as join36 } from "node:path";
 init_config();
 init_utils_json();
 function countLocalOnly(src, dst) {
   let count = 0;
-  for (const name of readdirSync11(dst)) {
-    const dstPath = join35(dst, name);
-    const srcPath = join35(src, name);
-    if (lstatSync14(dstPath).isDirectory()) {
+  for (const name of readdirSync12(dst)) {
+    const dstPath = join36(dst, name);
+    const srcPath = join36(src, name);
+    if (lstatSync15(dstPath).isDirectory()) {
       count += countLocalOnly(srcPath, dstPath);
-    } else if (lstatSync14(srcPath, { throwIfNoEntry: false }) === void 0) {
+    } else if (lstatSync15(srcPath, { throwIfNoEntry: false }) === void 0) {
       count++;
     }
   }
@@ -5182,20 +5255,20 @@ function countLocalOnly(src, dst) {
 function scanLocalOnly() {
   const repo = repoHome();
   const claude = claudeHome();
-  const mapPath = join35(repo, "path-map.json");
-  const repoProjects = join35(repo, "shared", "projects");
-  if (!existsSync24(mapPath) || !existsSync24(repoProjects)) return 0;
+  const mapPath = join36(repo, "path-map.json");
+  const repoProjects = join36(repo, "shared", "projects");
+  if (!existsSync25(mapPath) || !existsSync25(repoProjects)) return 0;
   const map = readPathMap(mapPath);
-  const localProjects = join35(claude, "projects");
+  const localProjects = join36(claude, "projects");
   let count = 0;
   for (const [logical, hosts] of Object.entries(map.projects)) {
     assertSafeLogical(logical);
     const localPath = hosts[HOST];
     if (!localPath || localPath === "TBD") continue;
     assertSafeLocalRoot(localPath, logical);
-    const dst = join35(localProjects, encodePath(localPath));
-    if (!existsSync24(dst)) continue;
-    count += countLocalOnly(join35(repoProjects, logical), dst);
+    const dst = join36(localProjects, encodePath(localPath));
+    if (!existsSync25(dst)) continue;
+    count += countLocalOnly(join36(repoProjects, logical), dst);
   }
   return count;
 }
@@ -5204,9 +5277,9 @@ function scanLocalOnly() {
 var TMP_SUFFIX = ".nomad-tmp";
 function atomicMirror(src, dst, options) {
   const tmp = `${dst}${TMP_SUFFIX}`;
-  rmSync14(tmp, { recursive: true, force: true });
+  rmSync15(tmp, { recursive: true, force: true });
   cpSync5(src, tmp, options);
-  rmSync14(dst, { recursive: true, force: true });
+  rmSync15(dst, { recursive: true, force: true });
   renameAtomicRetry(tmp, dst);
 }
 function overlaySessionDir(src, dst) {
@@ -5214,7 +5287,7 @@ function overlaySessionDir(src, dst) {
   cpSyncGuarded(src, dst, void 0, "overlaySessionDir");
 }
 function copyFileAtomic(src, dst) {
-  mkdirSync8(dirname10(dst), { recursive: true });
+  mkdirSync9(dirname11(dst), { recursive: true });
   const tmp = `${dst}.tmp.${process.pid}`;
   cpSync5(src, tmp, { force: true, preserveTimestamps: true });
   renameAtomicRetry(tmp, dst);
@@ -5231,12 +5304,12 @@ function applySelective(sel, localDir, repoDst) {
   const prefix = `${localDir}${sep5}`;
   for (const src of sel.changed) {
     if (!src.startsWith(prefix)) continue;
-    copyFileAtomic(src, join36(repoDst, relative6(localDir, src)));
+    copyFileAtomic(src, join37(repoDst, relative6(localDir, src)));
   }
   for (const src of sel.deleted) {
     if (!src.startsWith(prefix)) continue;
-    const dst = join36(repoDst, relative6(localDir, src));
-    if (existsSync25(dst)) rmSync14(dst);
+    const dst = join37(repoDst, relative6(localDir, src));
+    if (existsSync26(dst)) rmSync15(dst);
   }
 }
 function copyDirJsonlOnly(src, dst) {
@@ -5265,16 +5338,16 @@ function remapPull(ts, opts = {}) {
   const wouldPull = [];
   const repo = repoHome();
   const claude = claudeHome();
-  const mapPath = join36(repo, "path-map.json");
-  const repoProjects = join36(repo, "shared", "projects");
-  if (!existsSync25(mapPath) || !existsSync25(repoProjects)) {
+  const mapPath = join37(repo, "path-map.json");
+  const repoProjects = join37(repo, "shared", "projects");
+  if (!existsSync26(mapPath) || !existsSync26(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 = join36(claude, "projects");
-  if (!dryRun) mkdirSync8(localProjects, { recursive: true });
+  const localProjects = join37(claude, "projects");
+  if (!dryRun) mkdirSync9(localProjects, { recursive: true });
   for (const [logical, hosts] of Object.entries(map.projects)) {
     assertSafeLogical(logical);
     const localPath = hosts[HOST];
@@ -5283,9 +5356,9 @@ function remapPull(ts, opts = {}) {
       continue;
     }
     assertSafeLocalRoot(localPath, logical);
-    const src = join36(repoProjects, logical);
-    if (!existsSync25(src)) continue;
-    const dst = join36(localProjects, encodePath(localPath));
+    const src = join37(repoProjects, logical);
+    if (!existsSync26(src)) continue;
+    const dst = join37(localProjects, encodePath(localPath));
     if (dryRun) {
       wouldPull.push(logical);
       emitPreview(
@@ -5332,26 +5405,26 @@ function remapPush(ts, opts = {}) {
   const wouldPush = [];
   const repo = repoHome();
   const claude = claudeHome();
-  const mapPath = join36(repo, "path-map.json");
-  if (!existsSync25(mapPath)) {
+  const mapPath = join37(repo, "path-map.json");
+  if (!existsSync26(mapPath)) {
     log("no path-map.json; skipping session export");
     return { unmapped: 0, collisions: 0, pushed, wouldPush };
   }
   const map = readPathMap(mapPath);
-  const localProjects = join36(claude, "projects");
-  const repoProjects = join36(repo, "shared", "projects");
+  const localProjects = join37(claude, "projects");
+  const repoProjects = join37(repo, "shared", "projects");
   const reverse = buildReverseMap(map);
-  if (!existsSync25(localProjects)) return { unmapped, collisions: 0, pushed, wouldPush };
-  if (!dryRun) mkdirSync8(repoProjects, { recursive: true });
-  for (const dir of readdirSync12(localProjects)) {
+  if (!existsSync26(localProjects)) return { unmapped, collisions: 0, pushed, wouldPush };
+  if (!dryRun) mkdirSync9(repoProjects, { recursive: true });
+  for (const dir of readdirSync13(localProjects)) {
     if (dir.endsWith(TMP_SUFFIX)) continue;
     const logical = reverse.get(dir);
     if (!logical) {
       unmapped++;
       continue;
     }
-    const localDir = join36(localProjects, dir);
-    const repoDst = join36(repoProjects, logical);
+    const localDir = join37(localProjects, dir);
+    const repoDst = join37(repoProjects, logical);
     if (skipForSelection(opts.selection, localDir)) continue;
     if (dryRun) {
       wouldPush.push(logical);
@@ -5375,8 +5448,8 @@ function buildScanTree(tmpRoot) {
   const logicalToEncoded = /* @__PURE__ */ new Map();
   let staged = 0;
   const repo = repoHome();
-  const mapPath = join37(repo, "path-map.json");
-  if (!existsSync26(mapPath)) return { logicalToEncoded, staged, malformed: false };
+  const mapPath = join38(repo, "path-map.json");
+  if (!existsSync27(mapPath)) return { logicalToEncoded, staged, malformed: false };
   let map;
   try {
     map = readJson(mapPath);
@@ -5393,12 +5466,12 @@ function buildScanTree(tmpRoot) {
     if (!p || p === "TBD") continue;
     reverse.set(encodePath(p), logical);
   }
-  const localProjects = join37(claudeHome(), "projects");
-  if (!existsSync26(localProjects)) return { logicalToEncoded, staged, malformed: false };
-  for (const dir of readdirSync13(localProjects)) {
+  const localProjects = join38(claudeHome(), "projects");
+  if (!existsSync27(localProjects)) return { logicalToEncoded, staged, malformed: false };
+  for (const dir of readdirSync14(localProjects)) {
     const logical = reverse.get(dir);
     if (!logical) continue;
-    copyDirJsonlOnly(join37(localProjects, dir), join37(tmpRoot, "shared", "projects", logical));
+    copyDirJsonlOnly(join38(localProjects, dir), join38(tmpRoot, "shared", "projects", logical));
     logicalToEncoded.set(logical, dir);
     staged++;
   }
@@ -5428,11 +5501,11 @@ function ensureGitleaksReady(section2, gitleaksReady) {
   return true;
 }
 function runLocalPreviewScan(section2) {
-  const cacheDir = join37(homedir6(), ".cache", "claude-nomad");
-  mkdirSync9(cacheDir, { recursive: true });
+  const cacheDir = join38(homedir6(), ".cache", "claude-nomad");
+  mkdirSync10(cacheDir, { recursive: true });
   const stamp = `${nowTimestamp()}-${process.pid}-${randomBytes3(4).toString("hex")}`;
-  const reportPath = join37(cacheDir, `check-shared-${stamp}.json`);
-  const tmpRoot = join37(cacheDir, `check-shared-tree-${stamp}`);
+  const reportPath = join38(cacheDir, `check-shared-${stamp}.json`);
+  const tmpRoot = join38(cacheDir, `check-shared-tree-${stamp}`);
   try {
     const { logicalToEncoded, staged, malformed } = buildScanTree(tmpRoot);
     if (malformed) {
@@ -5446,8 +5519,8 @@ function runLocalPreviewScan(section2) {
     }
     scanAndReport(section2, tmpRoot, staged, logicalToEncoded);
   } finally {
-    rmSync15(reportPath, { force: true });
-    rmSync15(tmpRoot, { recursive: true, force: true });
+    rmSync16(reportPath, { force: true });
+    rmSync16(tmpRoot, { recursive: true, force: true });
   }
 }
 function reportCheckShared(section2, gitleaksReady) {
@@ -5465,8 +5538,8 @@ function reportCheckShared(section2, gitleaksReady) {
 
 // src/commands/doctor/checks/hooks.scope.ts
 init_color();
-import { existsSync as existsSync27, readFileSync as readFileSync9, readdirSync as readdirSync14, realpathSync as realpathSync4 } from "node:fs";
-import { dirname as dirname11, extname, join as join38 } from "node:path";
+import { existsSync as existsSync28, readFileSync as readFileSync9, readdirSync as readdirSync15, realpathSync as realpathSync4 } from "node:fs";
+import { dirname as dirname12, extname, join as join39 } from "node:path";
 init_config();
 function typeFromPackageJson(pkgPath) {
   try {
@@ -5486,11 +5559,11 @@ function effectiveType(hookPath) {
   } catch {
     return null;
   }
-  let dir = dirname11(real);
+  let dir = dirname12(real);
   for (; ; ) {
-    const pkg = join38(dir, "package.json");
-    if (existsSync27(pkg)) return typeFromPackageJson(pkg);
-    const parent = dirname11(dir);
+    const pkg = join39(dir, "package.json");
+    if (existsSync28(pkg)) return typeFromPackageJson(pkg);
+    const parent = dirname12(dir);
     if (parent === dir) return "cjs";
     dir = parent;
   }
@@ -5518,7 +5591,7 @@ function remedy(family) {
 }
 function safeReaddir2(dir) {
   try {
-    return readdirSync14(dir);
+    return readdirSync15(dir);
   } catch {
     return [];
   }
@@ -5531,15 +5604,15 @@ function safeRead(path) {
   }
 }
 function reportHookScopeCheck(section2) {
-  const hooksDir = join38(claudeHome(), "hooks");
-  if (!existsSync27(hooksDir)) {
+  const hooksDir = join39(claudeHome(), "hooks");
+  if (!existsSync28(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 = join38(hooksDir, name);
+    const abs = join39(hooksDir, name);
     const eff = effectiveType(abs);
     if (eff === null) continue;
     const src = safeRead(abs);
@@ -5559,8 +5632,8 @@ function reportHookScopeCheck(section2) {
 
 // src/commands/doctor/checks/hooks.ts
 init_color();
-import { existsSync as existsSync28 } from "node:fs";
-import { join as join39 } from "node:path";
+import { existsSync as existsSync29 } from "node:fs";
+import { join as join40 } from "node:path";
 init_config();
 function expandHome(token) {
   const h = home();
@@ -5603,7 +5676,7 @@ function checkEventGroups(section2, event, groups) {
   for (const group of groups) {
     for (const cmd of commandsFromGroup(group)) {
       for (const resolved of claudePathsIn(cmd)) {
-        if (existsSync28(resolved)) continue;
+        if (existsSync29(resolved)) continue;
         addItem(
           section2,
           `${red(failGlyph)} hooks/${event}: command target missing: ${resolved} (run nomad pull)`
@@ -5616,8 +5689,8 @@ function checkEventGroups(section2, event, groups) {
   return anyFail;
 }
 function reportHooksTargetCheck(section2) {
-  const settingsPath = join39(claudeHome(), "settings.json");
-  if (!existsSync28(settingsPath)) {
+  const settingsPath = join40(claudeHome(), "settings.json");
+  if (!existsSync29(settingsPath)) {
     addItem(section2, `${dim(infoGlyph)} no ~/.claude/settings.json; skipping hook target check`);
     return;
   }
@@ -5640,12 +5713,12 @@ function reportHooksTargetCheck(section2) {
 
 // src/commands/doctor/checks/hooks.preserve-symlinks.ts
 init_color();
-import { existsSync as existsSync30, readFileSync as readFileSync10 } from "node:fs";
-import { join as join41 } from "node:path";
+import { existsSync as existsSync31, readFileSync as readFileSync10 } from "node:fs";
+import { join as join42 } from "node:path";
 
 // src/commands/doctor/checks/hooks.preserve-symlinks.probe.ts
-import { closeSync as closeSync3, existsSync as existsSync29, openSync as openSync3, readSync, realpathSync as realpathSync5 } from "node:fs";
-import { dirname as dirname12, join as join40, resolve as resolve3 } from "node:path";
+import { closeSync as closeSync3, existsSync as existsSync30, openSync as openSync3, readSync, realpathSync as realpathSync5 } from "node:fs";
+import { dirname as dirname13, join as join41, resolve as resolve3 } from "node:path";
 function suppressedRanges(src) {
   const ranges = [];
   const re = /\/\*[^]*?\*\/|\/\/[^\n]*|(['"`])(?:\\[^]|[^\\])*?\1/g;
@@ -5677,12 +5750,12 @@ function relativeSpecifiers(src) {
 }
 function specifierIsMissing(specifier, baseDir) {
   const base = resolve3(baseDir, specifier);
-  if (existsSync29(base)) return false;
+  if (existsSync30(base)) return false;
   for (const ext of [".js", ".cjs", ".mjs"]) {
-    if (existsSync29(base + ext)) return false;
+    if (existsSync30(base + ext)) return false;
   }
   for (const idx of ["index.js", "index.cjs", "index.mjs"]) {
-    if (existsSync29(join40(base, idx))) return false;
+    if (existsSync30(join41(base, idx))) return false;
   }
   return true;
 }
@@ -5708,7 +5781,7 @@ function relativeRequireTargetsBroken(scriptPath) {
   }
   const specifiers = relativeSpecifiers(raw);
   if (specifiers.length === 0) return false;
-  const baseDir = dirname12(realPath);
+  const baseDir = dirname13(realPath);
   for (const spec of specifiers) {
     if (specifierIsMissing(spec, baseDir)) return true;
   }
@@ -5737,8 +5810,8 @@ function commandTokens(command) {
   return tokens;
 }
 function readPathMapSafe() {
-  const mapPath = join41(repoHome(), "path-map.json");
-  if (!existsSync30(mapPath)) return { projects: {} };
+  const mapPath = join42(repoHome(), "path-map.json");
+  if (!existsSync31(mapPath)) return { projects: {} };
   try {
     return JSON.parse(readFileSync10(mapPath, "utf8"));
   } catch {
@@ -5812,8 +5885,8 @@ function checkEventForPreserveSymlinks(section2, event, groups, sharedLinkNames)
   return anyWarn;
 }
 function reportPreserveSymlinksCheck(section2) {
-  const settingsPath = join41(claudeHome(), "settings.json");
-  if (!existsSync30(settingsPath)) {
+  const settingsPath = join42(claudeHome(), "settings.json");
+  if (!existsSync31(settingsPath)) {
     addItem(
       section2,
       `${dim(infoGlyph)} no ~/.claude/settings.json; skipping preserve-symlinks-main check`
@@ -5846,8 +5919,8 @@ function reportPreserveSymlinksCheck(section2) {
 
 // src/commands/doctor/checks/settings-drift.ts
 init_color();
-import { existsSync as existsSync31, readFileSync as readFileSync11 } from "node:fs";
-import { join as join42 } from "node:path";
+import { existsSync as existsSync32, readFileSync as readFileSync11 } from "node:fs";
+import { join as join43 } from "node:path";
 init_config();
 init_utils_json();
 function diffMergedSettings(merged, settings) {
@@ -5865,7 +5938,7 @@ function tryReadJson(filePath) {
   }
 }
 function reportHooksBaseSelfCleanNote(section2) {
-  const basePath = join42(repoHome(), "shared", "settings.base.json");
+  const basePath = join43(repoHome(), "shared", "settings.base.json");
   const base = tryReadJson(basePath);
   if (base === null) return;
   if (!baseHasGsdHookEntries(base)) return;
@@ -5878,14 +5951,14 @@ function reportSettingsDriftCheck(section2) {
   const claude = claudeHome();
   const repo = repoHome();
   const host = HOST;
-  const settingsPath = join42(claude, "settings.json");
-  const basePath = join42(repo, "shared", "settings.base.json");
-  const hostPath = join42(repo, "hosts", `${host}.json`);
-  if (!existsSync31(settingsPath)) {
+  const settingsPath = join43(claude, "settings.json");
+  const basePath = join43(repo, "shared", "settings.base.json");
+  const hostPath = join43(repo, "hosts", `${host}.json`);
+  if (!existsSync32(settingsPath)) {
     addItem(section2, `${dim(infoGlyph)} no ~/.claude/settings.json; skipping merge-drift check`);
     return;
   }
-  if (!existsSync31(basePath)) {
+  if (!existsSync32(basePath)) {
     addItem(
       section2,
       `${dim(infoGlyph)} shared/settings.base.json missing; skipping merge-drift check`
@@ -5904,7 +5977,7 @@ function reportSettingsDriftCheck(section2) {
   if (settings === null) {
     return;
   }
-  const hostExists = existsSync31(hostPath);
+  const hostExists = existsSync32(hostPath);
   const hostObj = hostExists ? tryReadJson(hostPath) : null;
   if (hostExists && hostObj === null) {
     addItem(
@@ -5965,12 +6038,12 @@ init_config();
 // src/commands/doctor/engine.ts
 init_color();
 import { readFileSync as readFileSync13 } from "node:fs";
-import { join as join44 } from "node:path";
+import { join as join45 } from "node:path";
 
 // src/commands/doctor/version.ts
 init_color();
 import { readFileSync as readFileSync12 } from "node:fs";
-import { join as join43 } from "node:path";
+import { join as join44 } from "node:path";
 init_config();
 init_package_root();
 var STRICT_SEMVER = /^\d+\.\d+\.\d+$/;
@@ -5986,7 +6059,7 @@ function compareSemver(a, b) {
 }
 function readLocalVersion() {
   try {
-    const pkgPath = join43(packageRoot(), "package.json");
+    const pkgPath = join44(packageRoot(), "package.json");
     const parsed = JSON.parse(readFileSync12(pkgPath, "utf8"));
     if (typeof parsed.version === "string" && parsed.version.length > 0) {
       return parsed.version;
@@ -6046,7 +6119,7 @@ function parseMinVersion(spec) {
 }
 function readEnginesNode() {
   try {
-    const pkgPath = join44(packageRoot(), "package.json");
+    const pkgPath = join45(packageRoot(), "package.json");
     const parsed = JSON.parse(readFileSync13(pkgPath, "utf8"));
     const node = parsed.engines?.node;
     if (typeof node === "string" && node.length > 0) return node;
@@ -6134,15 +6207,15 @@ function reportSyncModality(section2) {
 // src/commands/doctor/checks/crlf.ts
 init_color();
 import { execFileSync as execFileSync14 } from "node:child_process";
-import { existsSync as existsSync32, readFileSync as readFileSync14 } from "node:fs";
-import { join as join45 } from "node:path";
+import { existsSync as existsSync33, readFileSync as readFileSync14 } from "node:fs";
+import { join as join46 } from "node:path";
 init_config();
 var PROBE_TIMEOUT_MS3 = 3e3;
 var GUARD_LINE = /^\*\s+-text\b/;
 function hasGitattributesGuard(repo) {
   try {
-    const path = join45(repo, ".gitattributes");
-    if (!existsSync32(path)) return false;
+    const path = join46(repo, ".gitattributes");
+    if (!existsSync33(path)) return false;
     const content = readFileSync14(path, "utf8");
     return content.split("\n").map((line) => line.trim()).some((line) => line !== "" && !line.startsWith("#") && GUARD_LINE.test(line));
   } catch {
@@ -6203,14 +6276,14 @@ init_config();
 init_config_sharedDirs_guard();
 import {
   cpSync as cpSync6,
-  lstatSync as lstatSync15,
-  mkdirSync as mkdirSync10,
+  lstatSync as lstatSync16,
+  mkdirSync as mkdirSync11,
   readFileSync as readFileSync15,
   realpathSync as realpathSync6,
   statSync as statSync7,
   writeFileSync as writeFileSync6
 } from "node:fs";
-import { dirname as dirname13, join as join46, sep as sep6 } from "node:path";
+import { dirname as dirname14, join as join47, sep as sep6 } from "node:path";
 init_gitleaks_scan();
 
 // src/core/rel-path-guard.ts
@@ -6239,11 +6312,11 @@ function resolveMemoryLocalPath(logical, relPath, map) {
   if (!isSafeRelPath(relPath)) return null;
   const abs = map.projects[logical]?.[HOST];
   if (abs === void 0) return null;
-  const memoryRoot = join46(claudeHome(), "projects", encodePath(abs), "memory");
-  const localPath = join46(memoryRoot, ...relPath.split("/"));
+  const memoryRoot = join47(claudeHome(), "projects", encodePath(abs), "memory");
+  const localPath = join47(memoryRoot, ...relPath.split("/"));
   if (localPath !== memoryRoot && !localPath.startsWith(memoryRoot + sep6)) return null;
   try {
-    if (lstatSync15(localPath).isSymbolicLink()) return null;
+    if (lstatSync16(localPath).isSymbolicLink()) return null;
     const realLocal = realpathSync6(localPath);
     const realRoot = realpathSync6(memoryRoot);
     if (!realLocal.startsWith(realRoot + sep6)) return null;
@@ -6294,8 +6367,8 @@ function applyMemoryRedact(f, ts, map, scan = scanFile) {
     );
   }
   writeFileSync6(localPath, after, "utf8");
-  const dest = join46(repoHome(), "shared", "projects", logical, "memory", ...relPath.split("/"));
-  mkdirSync10(dirname13(dest), { recursive: true });
+  const dest = join47(repoHome(), "shared", "projects", logical, "memory", ...relPath.split("/"));
+  mkdirSync11(dirname14(dest), { recursive: true });
   cpSync6(localPath, dest, { force: true });
   return true;
 }
@@ -6311,68 +6384,7 @@ import {
   statSync as statSync8,
   writeFileSync as writeFileSync7
 } from "node:fs";
-import { dirname as dirname14, join as join48, sep as sep7 } from "node:path";
-
-// src/sync/skills-sync.ts
-init_config();
-import { existsSync as existsSync33, lstatSync as lstatSync16, mkdirSync as mkdirSync11, readdirSync as readdirSync15, rmSync as rmSync16 } from "node:fs";
-import { join as join47 } from "node:path";
-
-// src/sync/skills-sync.tracked.ts
-init_utils();
-import { basename as basename5 } from "node:path";
-function trackedRootSkillsAt(ref, repo) {
-  try {
-    const raw = gitCaptureRaw(["ls-tree", "--name-only", "-z", ref, "--", "shared/skills/"], repo);
-    const entries = raw.split("\0").filter((entry) => entry !== "");
-    return new Set(entries.map((entry) => basename5(entry)));
-  } catch {
-    return /* @__PURE__ */ new Set();
-  }
-}
-
-// src/sync/skills-sync.ts
-init_utils_fs();
-function isGsdOwned(name) {
-  return name.startsWith(GSD_PREFIX);
-}
-function isSkillExcluded(name) {
-  return isGsdOwned(name) || isDeniedName(ALWAYS_NEVER_SYNC, name);
-}
-function copySkillsPush(src, dst) {
-  const srcNames = readdirSync15(src, { encoding: "utf8" });
-  const blockSet = /* @__PURE__ */ new Set([
-    ...srcNames.filter((n) => isGsdOwned(n)),
-    ...ALWAYS_NEVER_SYNC
-  ]);
-  copyExtrasFiltered(src, dst, blockSet);
-}
-function copySkillsPull(src, dst, isRootPreserved) {
-  copyExtrasFilteredPreservingBy(src, dst, isSkillExcluded, isRootPreserved);
-}
-function syncSkillsPull(ts, prePostHeads) {
-  const sharedSkills = join47(repoHome(), "shared", "skills");
-  if (!existsSync33(sharedSkills)) return;
-  const localSkills = join47(claudeHome(), "skills");
-  backupBeforeWrite(localSkills, ts);
-  const dstStat = lstatSync16(localSkills, { throwIfNoEntry: false });
-  if (dstStat?.isSymbolicLink() === true) {
-    rmSync16(localSkills, { recursive: true, force: true });
-    mkdirSync11(localSkills, { recursive: true });
-  }
-  const tracked = prePostHeads === void 0 ? /* @__PURE__ */ new Set() : trackedRootSkillsAt(prePostHeads.pre, repoHome());
-  copySkillsPull(sharedSkills, localSkills, (name) => !tracked.has(name));
-}
-function syncSkillsPush() {
-  const localSkills = join47(claudeHome(), "skills");
-  const stat = lstatSync16(localSkills, { throwIfNoEntry: false });
-  if (stat === void 0) return;
-  if (stat.isSymbolicLink()) return;
-  const sharedSkills = join47(repoHome(), "shared", "skills");
-  copySkillsPush(localSkills, sharedSkills);
-}
-
-// src/commands/push/recovery/skills.ts
+import { dirname as dirname15, join as join48, sep as sep7 } from "node:path";
 init_gitleaks_scan();
 init_utils_fs();
 init_utils();
@@ -6446,7 +6458,7 @@ function applySkillRedact(f, ts, scan = scanFile) {
   }
   writeFileSync7(localPath, after, "utf8");
   const dest = join48(repoHome(), "shared", "skills", name, ...relPath.split("/"));
-  mkdirSync12(dirname14(dest), { recursive: true });
+  mkdirSync12(dirname15(dest), { recursive: true });
   cpSync7(localPath, dest, { force: true });
   return true;
 }
@@ -6524,12 +6536,12 @@ function applyDeferredAllows(findings, state, repo) {
 init_config();
 init_config_sharedDirs_guard();
 import { cpSync as cpSync8, existsSync as existsSync36, mkdirSync as mkdirSync13 } from "node:fs";
-import { dirname as dirname16, join as join51, sep as sep8 } from "node:path";
+import { dirname as dirname17, join as join51, sep as sep8 } from "node:path";
 
 // src/commands/redact/redact.ts
 init_config();
 import { existsSync as existsSync35 } from "node:fs";
-import { dirname as dirname15, join as join50 } from "node:path";
+import { dirname as dirname16, join as join50 } from "node:path";
 
 // src/commands/redact/subtree.ts
 import { existsSync as existsSync34, lstatSync as lstatSync18, readFileSync as readFileSync17, readdirSync as readdirSync16, statSync as statSync9, writeFileSync as writeFileSync8 } from "node:fs";
@@ -6689,7 +6701,7 @@ function cmdRedact(opts, nowMs = Date.now, scan = scanFile) {
       process.exitCode = 1;
       return;
     }
-    const sessionDir = join50(dirname15(localPath), id);
+    const sessionDir = join50(dirname16(localPath), id);
     const subtreeFiles = listSubtreeFiles(sessionDir);
     if (isSubtreeActive(localPath, subtreeFiles, nowMs())) {
       log(
@@ -6761,7 +6773,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 = join51(dirname16(localPath), sid);
+  const sessionDir = join51(dirname17(localPath), sid);
   const subtreeFiles = listSubtreeFiles(sessionDir);
   if (isSubtreeActive(localPath, subtreeFiles, nowMs())) {
     return `session ${sid}: looks active (modified within the last 5 minutes)`;
@@ -6790,7 +6802,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 = join51(dirname16(localPath), sid);
+  const sessionDir = join51(dirname17(localPath), sid);
   const subtreeFiles = listSubtreeFiles(sessionDir);
   if (isSubtreeActive(localPath, subtreeFiles, nowMs())) {
     return refuse(
@@ -8051,7 +8063,7 @@ import { join as join60 } from "node:path";
 
 // src/sync/extras/planning-deletes.ts
 import { existsSync as existsSync42, readdirSync as readdirSync18, readFileSync as readFileSync20, realpathSync as realpathSync8, rmSync as rmSync19 } from "node:fs";
-import { dirname as dirname17, join as join59, sep as sep11 } from "node:path";
+import { dirname as dirname18, join as join59, sep as sep11 } from "node:path";
 
 // src/sync/extras/planning-diff.ts
 import { join as join58, normalize as normalize2, sep as sep10 } from "node:path";
@@ -8130,7 +8142,7 @@ function planningDeleteTargets(opts) {
 init_utils_fs();
 init_utils();
 function pruneEmptyAncestors(target, planningRoot) {
-  let dir = dirname17(target);
+  let dir = dirname18(target);
   while (dir !== planningRoot && dir.startsWith(planningRoot + sep11)) {
     try {
       if (readdirSync18(dir).length > 0) break;
@@ -8138,7 +8150,7 @@ function pruneEmptyAncestors(target, planningRoot) {
     } catch {
       break;
     }
-    dir = dirname17(dir);
+    dir = dirname18(dir);
   }
 }
 function tryRealpath(dir) {
@@ -8153,7 +8165,7 @@ function isInsidePlanningRoot(parentReal, rootReal) {
 }
 function deletePlanningTarget(target, planningRoot, repoCounterpart) {
   if (existsSync42(repoCounterpart)) return;
-  const parentReal = tryRealpath(dirname17(target));
+  const parentReal = tryRealpath(dirname18(target));
   if (parentReal === void 0) return;
   const rootReal = tryRealpath(planningRoot);
   if (rootReal === void 0) return;
@@ -8264,9 +8276,9 @@ function remapExtrasPush(ts, opts = {}) {
   const { unmapped, skipped, done, would } = runExtrasOp(
     v,
     dryRun,
-    ({ localRoot, logical, dirname: dirname18 }) => ({
-      src: join60(localRoot, dirname18),
-      dst: join60(repoExtras, logical, dirname18)
+    ({ localRoot, logical, dirname: dirname19 }) => ({
+      src: join60(localRoot, dirname19),
+      dst: join60(repoExtras, logical, dirname19)
     }),
     (dst) => backupRepoWrite(dst, ts, repo),
     // Push copy routing per extra type:
@@ -8279,7 +8291,7 @@ function remapExtrasPush(ts, opts = {}) {
     //     config.never-sync.ts)
     //     remains the hard security boundary.
     //   All others: copyExtrasFiltered with per-extra denylist.
-    (src, dst, dirname18) => dirname18 === ".planning" ? copyExtrasOverlayFiltered(src, dst, extrasDenySet(dirname18)) : copyExtrasFiltered(src, dst, extrasDenySet(dirname18))
+    (src, dst, dirname19) => dirname19 === ".planning" ? copyExtrasOverlayFiltered(src, dst, extrasDenySet(dirname19)) : copyExtrasFiltered(src, dst, extrasDenySet(dirname19))
   );
   return { unmapped, skipped, pushed: done, wouldPush: would };
 }
@@ -8295,9 +8307,9 @@ function remapExtrasPull(ts, opts = {}) {
   const { unmapped, skipped, done, would } = runExtrasOp(
     v,
     dryRun,
-    ({ localRoot, logical, dirname: dirname18 }) => ({
-      src: join60(repo, "shared", "extras", logical, dirname18),
-      dst: join60(localRoot, dirname18)
+    ({ localRoot, logical, dirname: dirname19 }) => ({
+      src: join60(repo, "shared", "extras", logical, dirname19),
+      dst: join60(localRoot, dirname19)
     }),
     // Snapshot the host-side dst BEFORE the copy step touches it. Anchor on
     // localRoot so the backup tree mirrors the project layout.
@@ -8315,12 +8327,12 @@ function remapExtrasPull(ts, opts = {}) {
     //     copyExtrasFileSkipDiverged keeps a locally-edited file rather than
     //     clobbering it, so the divergence WARN's keep-local promise holds for
     //     every extra, not just `.planning`.
-    (src, dst, dirname18) => {
-      if (dirname18 === ".claude")
-        return copyExtrasFilteredPreserving(src, dst, extrasDenySet(dirname18));
-      if (dirname18 === ".planning") {
+    (src, dst, dirname19) => {
+      if (dirname19 === ".claude")
+        return copyExtrasFilteredPreserving(src, dst, extrasDenySet(dirname19));
+      if (dirname19 === ".planning") {
         const divergedSet = new Set(listDivergingModified(dst, src));
-        return copyExtrasOverlaySkipDiverged(src, dst, extrasDenySet(dirname18), divergedSet);
+        return copyExtrasOverlaySkipDiverged(src, dst, extrasDenySet(dirname19), divergedSet);
       }
       return copyExtrasFileSkipDiverged(src, dst);
     }
@@ -8347,9 +8359,9 @@ function divergenceCheckExtras(ts, prePostHeads) {
   const backupRoot = join61(backupBase(), ts, "extras");
   const repo = repoHome();
   let divergedCount = 0;
-  for (const { logical, localRoot, dirname: dirname18 } of eachExtrasTarget(v, counts)) {
-    const local = join61(localRoot, dirname18);
-    const repoEntry = join61(repo, "shared", "extras", logical, dirname18);
+  for (const { logical, localRoot, dirname: dirname19 } of eachExtrasTarget(v, counts)) {
+    const local = join61(localRoot, dirname19);
+    const repoEntry = join61(repo, "shared", "extras", logical, dirname19);
     if (!existsSync44(local) || !existsSync44(repoEntry)) continue;
     const modified = listDivergingModified(local, repoEntry);
     if (modified.length === 0) continue;
@@ -8357,7 +8369,7 @@ function divergenceCheckExtras(ts, prePostHeads) {
     const projectBackupRoot = join61(backupRoot, encodePath(localRoot));
     warn(
       divergenceWarnLine({
-        dirname: dirname18,
+        dirname: dirname19,
         logical,
         isDir: statSync11(local).isDirectory(),
         count: modified.length,
@@ -9062,11 +9074,11 @@ function buildSkillsPreviewSection() {
   const s = section("Skills");
   const sharedSkills = join66(repoHome(), "shared", "skills");
   if (!existsSync48(sharedSkills)) return s;
-  const sharedNames = readdirSync20(sharedSkills, { encoding: "utf8" }).filter((name) => !isSkillExcluded(name)).sort((a, b) => a.localeCompare(b, "en"));
+  const sharedNames = readdirSync20(sharedSkills, { encoding: "utf8" }).filter((name) => !isRootSkillExcluded(name)).sort((a, b) => a.localeCompare(b, "en"));
   for (const name of sharedNames) addItem(s, name);
   const localSkills = join66(claudeHome(), "skills");
   const localOnly = existsSync48(localSkills) ? readdirSync20(localSkills, { encoding: "utf8" }).filter(
-    (name) => !isSkillExcluded(name) && !sharedNames.includes(name)
+    (name) => !isRootSkillExcluded(name) && !sharedNames.includes(name)
   ).length : 0;
   if (localOnly > 0) {
     addItem(s, `${localOnly} local-only present, not in repo (push to reconcile)`);
@@ -10178,11 +10190,11 @@ function stageExtras(tmpRoot, map) {
     assertSafeLogical(logical);
     const localRoot = map.projects[logical]?.[HOST];
     if (!localRoot || localRoot === "TBD") continue;
-    for (const dirname18 of dirnames) {
-      if (!whitelist.includes(dirname18)) continue;
-      const src = join74(localRoot, dirname18);
+    for (const dirname19 of dirnames) {
+      if (!whitelist.includes(dirname19)) continue;
+      const src = join74(localRoot, dirname19);
       if (!existsSync55(src)) continue;
-      const dst = join74(tmpRoot, "shared", "extras", logical, dirname18);
+      const dst = join74(tmpRoot, "shared", "extras", logical, dirname19);
       copyExtras(src, dst);
       staged++;
     }
@@ -10193,7 +10205,9 @@ function stageSkills(tmpRoot) {
   const localSkills = join74(claudeHome(), "skills");
   const stat = lstatSync24(localSkills, { throwIfNoEntry: false });
   if (stat === void 0 || stat.isSymbolicLink()) return 0;
-  const names = readdirSync21(localSkills, { encoding: "utf8" }).filter((n) => !isSkillExcluded(n));
+  const names = readdirSync21(localSkills, { encoding: "utf8" }).filter(
+    (n) => !isRootSkillExcluded(n)
+  );
   if (names.length === 0) return 0;
   copySkillsPush(localSkills, join74(tmpRoot, "shared", "skills"));
   return names.length;
@@ -11219,7 +11233,7 @@ function parseSyncArgs(argv) {
 // package.json
 var package_default = {
   name: "claude-nomad",
-  version: "0.69.2",
+  version: "0.69.3",
   type: "module",
   description: "Sync Claude Code config (~/.claude/) across machines via a private Git repo, with path remapping and per-host settings overrides.",
   keywords: [