claude-nomad 0.48.0 → 0.50.0

package/dist/nomad.mjs

@@ -162,6 +162,13 @@ var init_color = __esm({
 
 // src/utils.ts
 import { execFileSync } from "node:child_process";
+function gitCaptureRaw(args, cwd) {
+  return execFileSync("git", args, {
+    cwd,
+    stdio: ["ignore", "pipe", "pipe"],
+    maxBuffer: 64 * 1024 * 1024
+  }).toString();
+}
 function gitOrFatal(args, context, cwd) {
   try {
     execFileSync("git", args, { cwd, stdio: ["ignore", "pipe", "pipe"] });
@@ -387,7 +394,7 @@ function allSharedLinks(map) {
   }
   return [...SHARED_LINKS, ...extras];
 }
-var SETTINGS_SCHEMA_URL, NPM_REGISTRY_LATEST_URL, GITLEAKS_PINNED_VERSION, HOST, SHARED_LINKS, SUPPORTED_EXTRAS, ALWAYS_NEVER_SYNC, PUSH_ALLOWED_STATIC;
+var SETTINGS_SCHEMA_URL, NPM_REGISTRY_LATEST_URL, GITLEAKS_PINNED_VERSION, HOST, SHARED_LINKS, GSD_PREFIX, GSD_DROPPED_NAMES, SUPPORTED_EXTRAS, ALWAYS_NEVER_SYNC, PUSH_ALLOWED_STATIC;
 var init_config = __esm({
   "src/config.ts"() {
     "use strict";
@@ -399,15 +406,9 @@ var init_config = __esm({
     NPM_REGISTRY_LATEST_URL = "https://registry.npmjs.org/claude-nomad/latest";
     GITLEAKS_PINNED_VERSION = "8.30.1";
     HOST = (process.env.NOMAD_HOST || hostname()).toLowerCase();
-    SHARED_LINKS = [
-      "CLAUDE.md",
-      "agents",
-      "skills",
-      "commands",
-      "rules",
-      "my-statusline.cjs",
-      "hooks"
-    ];
+    SHARED_LINKS = ["CLAUDE.md", "commands", "rules", "my-statusline.cjs"];
+    GSD_PREFIX = "gsd-";
+    GSD_DROPPED_NAMES = ["hooks", "agents"];
     SUPPORTED_EXTRAS = [".planning", "CLAUDE.md", ".claude"];
     ALWAYS_NEVER_SYNC = /* @__PURE__ */ new Set([
       ".claude.json",
@@ -420,12 +421,10 @@ var init_config = __esm({
       "shared/CLAUDE.md",
       "shared/my-statusline.cjs",
       "shared/settings.base.json",
-      "shared/agents/",
       "shared/skills/",
       "shared/commands/",
       "shared/rules/",
       "shared/.gitignore",
-      "shared/hooks/",
       "hosts/",
       "path-map.json",
       ".gitleaksignore",
@@ -571,6 +570,69 @@ var init_utils_fs = __esm({
   }
 });
 
+// src/commands.pull.wedge.ts
+import { execFileSync as execFileSync2 } from "node:child_process";
+import { existsSync as existsSync10 } from "node:fs";
+import { join as join11 } from "node:path";
+function detectWedge(repo) {
+  const g = join11(repo, ".git");
+  if (existsSync10(join11(g, "rebase-merge")) || existsSync10(join11(g, "rebase-apply"))) return "rebase";
+  if (existsSync10(join11(g, "MERGE_HEAD"))) return "merge";
+  return null;
+}
+function unmergedIndexPresent(repo) {
+  let raw;
+  try {
+    raw = execFileSync2("git", ["diff", "--diff-filter=U", "--name-only", "-z"], {
+      cwd: repo,
+      stdio: ["ignore", "pipe", "pipe"],
+      maxBuffer: 64 * 1024 * 1024
+    }).toString();
+  } catch {
+    return false;
+  }
+  return raw.split("\0").some(Boolean);
+}
+function classifyWedge(repo) {
+  const mode = detectWedge(repo);
+  if (mode !== null) return mode;
+  return unmergedIndexPresent(repo) ? "unmerged-index" : null;
+}
+function unmergedIndexRunbookText(resumeCmd2) {
+  return `repo has an unmerged index with no active rebase or merge in progress (torn-down rebase left stage-2/3 entries behind).
+
+Manual recovery:
+  1. git reset --mixed HEAD   (clears the stuck index; preserves working-tree files)
+  2. git stash list           (look for an orphaned autostash entry)
+     git stash pop            (restore the autostash) or
+     git stash drop           (discard it)
+  3. ${resumeCmd2}
+
+Auto-recover: run 'nomad pull --force-remote' to apply step 1 automatically
+(see FAQ: "Every pull fails with unmerged files")`;
+}
+function wedgeMarkerRunbookText(state) {
+  return `repo is ${state} from a previous failed pull; run 'nomad pull --force-remote' to auto-recover, or resolve manually (see FAQ: "Every pull fails with unmerged files")`;
+}
+function orphanedAutostashPresent(repo) {
+  let raw;
+  try {
+    raw = execFileSync2("git", ["stash", "list"], {
+      cwd: repo,
+      stdio: ["ignore", "pipe", "pipe"],
+      maxBuffer: 64 * 1024 * 1024
+    }).toString();
+  } catch {
+    return false;
+  }
+  return raw.split("\n").some((line) => /:\s*autostash$/.test(line));
+}
+var init_commands_pull_wedge = __esm({
+  "src/commands.pull.wedge.ts"() {
+    "use strict";
+  }
+});
+
 // src/push-gitleaks.config.ts
 import { existsSync as existsSync11, mkdtempSync, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "node:fs";
 import { tmpdir } from "node:os";
@@ -637,7 +699,7 @@ var init_push_gitleaks_config = __esm({
 });
 
 // src/push-checks.ts
-import { execFileSync as execFileSync2 } from "node:child_process";
+import { execFileSync as execFileSync3 } from "node:child_process";
 import { readdirSync as readdirSync4, rmSync as rmSync4 } from "node:fs";
 import { homedir as homedir2, platform } from "node:os";
 import { join as join13 } from "node:path";
@@ -699,7 +761,7 @@ function probeGitleaks() {
   const args = ["version"];
   if (toml !== null) args.push("--config", toml);
   try {
-    return execFileSync2("gitleaks", args, { stdio: ["ignore", "pipe", "pipe"] }).toString().trim();
+    return execFileSync3("gitleaks", args, { stdio: ["ignore", "pipe", "pipe"] }).toString().trim();
   } catch (err) {
     const e = err;
     if (e.code === "ENOENT") throw new NomadFatal(gitleaksInstallHint());
@@ -708,9 +770,18 @@ function probeGitleaks() {
     if (tempPath !== null) rmSync4(tempPath, { recursive: true, force: true });
   }
 }
+function wedgePreflight(wedge) {
+  if (wedge === "unmerged-index") {
+    return unmergedIndexRunbookText("nomad push");
+  }
+  const state = wedge === "rebase" ? "mid-rebase" : "mid-merge";
+  return wedgeMarkerRunbookText(state);
+}
 function rebaseBeforePush(repo) {
+  const wedge = classifyWedge(repo);
+  if (wedge !== null) throw new NomadFatal(wedgePreflight(wedge));
   try {
-    execFileSync2("git", ["pull", "--rebase", "--autostash"], {
+    execFileSync3("git", ["pull", "--rebase", "--autostash"], {
       cwd: repo,
       stdio: ["ignore", "pipe", "pipe"]
     });
@@ -726,12 +797,13 @@ var init_push_checks = __esm({
   "src/push-checks.ts"() {
     "use strict";
     init_push_gitleaks_config();
+    init_commands_pull_wedge();
     init_utils();
   }
 });
 
 // src/push-gitleaks.scan.ts
-import { execFileSync as execFileSync5 } from "node:child_process";
+import { execFileSync as execFileSync6 } from "node:child_process";
 import { mkdirSync as mkdirSync2, readFileSync as readFileSync4, rmSync as rmSync5 } from "node:fs";
 import { homedir as homedir3 } from "node:os";
 import { join as join17 } from "node:path";
@@ -761,9 +833,9 @@ function scanStagedTree(repoDir, forwardStreams = false) {
   if (toml !== null) args.push("--config", toml);
   const opts = { cwd: repoDir, stdio: ["ignore", "pipe", "pipe"] };
   try {
-    execFileSync5("git", ["init", "-q"], opts);
-    execFileSync5("git", ["add", "-A"], opts);
-    execFileSync5("gitleaks", args, opts);
+    execFileSync6("git", ["init", "-q"], opts);
+    execFileSync6("git", ["add", "-A"], opts);
+    execFileSync6("gitleaks", args, opts);
     return [];
   } catch (err) {
     const e = err;
@@ -795,7 +867,7 @@ function scanFile(filePath, forwardStreams = false) {
   if (toml !== null) args.push("--config", toml);
   const opts = { stdio: ["ignore", "pipe", "pipe"] };
   try {
-    execFileSync5("gitleaks", args, opts);
+    execFileSync6("gitleaks", args, opts);
     return [];
   } catch (err) {
     const e = err;
@@ -1618,6 +1690,23 @@ function reportSharedLinks(section2, map) {
     if (fail2) process.exitCode = 1;
   }
 }
+function reportDroppedNamesMigration(section2) {
+  const claude = claudeHome();
+  for (const name of GSD_DROPPED_NAMES) {
+    const p = join8(claude, name);
+    let stat;
+    try {
+      stat = lstatSync5(p);
+    } catch {
+      continue;
+    }
+    if (!stat.isSymbolicLink()) continue;
+    addItem(
+      section2,
+      `${yellow(warnGlyph)} ${name}: gsd now owns this dir per-host (was a nomad symlink); run \`rm ~/.claude/${name}\` and let gsd reinstall a real dir`
+    );
+  }
+}
 
 // src/commands.doctor.checks.settings.ts
 init_color();
@@ -1788,26 +1877,15 @@ function reportNeverSync(section2) {
 // src/commands.doctor.checks.repository.ts
 init_color();
 init_config();
-import { execFileSync as execFileSync3 } from "node:child_process";
+import { execFileSync as execFileSync4 } from "node:child_process";
 import { existsSync as existsSync12 } from "node:fs";
 import { join as join14, relative as relative2 } from "node:path";
-
-// src/commands.pull.wedge.ts
-import { existsSync as existsSync10 } from "node:fs";
-import { join as join11 } from "node:path";
-function detectWedge(repo) {
-  const g = join11(repo, ".git");
-  if (existsSync10(join11(g, "rebase-merge")) || existsSync10(join11(g, "rebase-apply"))) return "rebase";
-  if (existsSync10(join11(g, "MERGE_HEAD"))) return "merge";
-  return null;
-}
-
-// src/commands.doctor.checks.repository.ts
+init_commands_pull_wedge();
 init_push_checks();
 init_utils();
 function reportGitleaksProbe(section2) {
   try {
-    execFileSync3("gitleaks", ["version"], { stdio: ["ignore", "pipe", "pipe"] });
+    execFileSync4("gitleaks", ["version"], { stdio: ["ignore", "pipe", "pipe"] });
     return true;
   } catch (err) {
     if (err.code === "ENOENT") {
@@ -1843,7 +1921,7 @@ function reportGitlinks(section2) {
 }
 function reportRemote(section2) {
   try {
-    const url = execFileSync3("git", ["remote", "get-url", "origin"], {
+    const url = execFileSync4("git", ["remote", "get-url", "origin"], {
       cwd: repoHome(),
       stdio: ["ignore", "pipe", "pipe"]
     }).toString().trim();
@@ -1866,14 +1944,31 @@ function reportRebaseClean(section2) {
 }
 function reportRebaseState(section2) {
   try {
-    const wedge = detectWedge(repoHome());
-    if (wedge !== null) {
+    const wedge = classifyWedge(repoHome());
+    if (wedge === null) return;
+    if (wedge === "unmerged-index") {
+      addItem(
+        section2,
+        `${red(failGlyph)} repo has an unmerged index with no active rebase: run 'nomad pull --force-remote' to auto-recover`
+      );
+    } else {
       const state = wedge === "rebase" ? "mid-rebase" : "mid-merge";
       addItem(
         section2,
         `${red(failGlyph)} repo is ${state}: run 'nomad pull --force-remote' to auto-recover`
       );
-      process.exitCode = 1;
+    }
+    process.exitCode = 1;
+  } catch {
+  }
+}
+function reportOrphanedAutostash(sec) {
+  try {
+    if (orphanedAutostashPresent(repoHome())) {
+      addItem(
+        sec,
+        `${yellow(warnGlyph)} repo has an orphaned autostash entry: run 'git stash pop' to restore or 'git stash drop' to discard`
+      );
     }
   } catch {
   }
@@ -1920,7 +2015,7 @@ function reportBackupsCheck(section2, backupBase2 = backupBase()) {
   if (count > DOCTOR_BACKUP_COUNT_WARN || sizeMb > DOCTOR_BACKUP_SIZE_WARN_MB) {
     addItem(
       section2,
-      `${yellow(warnGlyph)} backups: ${count} dirs / ${sizeMb.toFixed(1)} MB (run 'nomad clean --backups')`
+      `${yellow(warnGlyph)} backups: ${count} dirs / ${sizeMb.toFixed(1)} MB (run 'nomad clean --backups --keep <N>'; bare --backups only prunes dirs older than 14d)`
     );
   }
 }
@@ -1932,9 +2027,9 @@ import { join as join16 } from "node:path";
 init_config();
 
 // src/http-fetch.ts
-import { execFileSync as execFileSync4 } from "node:child_process";
+import { execFileSync as execFileSync5 } from "node:child_process";
 var FETCH_TIMEOUT_MS = 3e3;
-function fetchUrl(url, run = execFileSync4) {
+function fetchUrl(url, run = execFileSync5) {
   try {
     return run("curl", ["-fsSL", "-m", "3", url], {
       stdio: ["ignore", "pipe", "pipe"],
@@ -1995,7 +2090,7 @@ function reportCheckSchema(section2) {
 // src/commands.doctor.check-shared.ts
 init_color();
 import { randomBytes } from "node:crypto";
-import { execFileSync as execFileSync6 } from "node:child_process";
+import { execFileSync as execFileSync7 } from "node:child_process";
 import { existsSync as existsSync16, mkdirSync as mkdirSync4, readdirSync as readdirSync7, rmSync as rmSync7 } from "node:fs";
 import { homedir as homedir4 } from "node:os";
 import { join as join20 } from "node:path";
@@ -2265,7 +2360,7 @@ function buildScanTree(tmpRoot) {
 }
 function probeGitleaksForScan() {
   try {
-    execFileSync6("gitleaks", ["version"], { stdio: ["ignore", "pipe", "pipe"] });
+    execFileSync7("gitleaks", ["version"], { stdio: ["ignore", "pipe", "pipe"] });
     return "ok";
   } catch (err) {
     if (err.code === "ENOENT") return "missing";
@@ -3669,7 +3764,7 @@ function withSpinner(label, fn, deps) {
 
 // src/commands.doctor.gitleaks-version.ts
 init_color();
-import { execFileSync as execFileSync7 } from "node:child_process";
+import { execFileSync as execFileSync8 } from "node:child_process";
 import { existsSync as existsSync26 } from "node:fs";
 import { join as join32 } from "node:path";
 init_config();
@@ -3692,7 +3787,7 @@ function readGitleaksVersion(run, tomlExists) {
     return null;
   }
 }
-function reportGitleaksVersionCheck(section2, run = execFileSync7, tomlExists = existsSync26) {
+function reportGitleaksVersionCheck(section2, run = execFileSync8, tomlExists = existsSync26) {
   const raw = readGitleaksVersion(run, tomlExists);
   if (raw === null) return;
   const local = majorMinorOf(raw);
@@ -3712,7 +3807,7 @@ function reportGitleaksVersionCheck(section2, run = execFileSync7, tomlExists =
 
 // src/commands.doctor.checks.deps.ts
 init_color();
-import { execFileSync as execFileSync8 } from "node:child_process";
+import { execFileSync as execFileSync9 } 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";
@@ -3749,7 +3844,7 @@ function reportFetcherRow(section2, run) {
     );
   }
 }
-function reportOptionalDeps(section2, run = execFileSync8) {
+function reportOptionalDeps(section2, run = execFileSync9) {
   const gh = probeOptionalDep("gh", run);
   if (gh.status === "present") {
     addItem(section2, `${green(okGlyph)} gh: ${gh.version ?? "present"}`);
@@ -3764,11 +3859,11 @@ function reportOptionalDeps(section2, run = execFileSync8) {
 
 // src/commands.doctor.actions-drift.ts
 init_color();
-import { execFileSync as execFileSync10 } from "node:child_process";
+import { execFileSync as execFileSync11 } from "node:child_process";
 init_config();
 
 // src/gh-actions.ts
-import { execFileSync as execFileSync9 } from "node:child_process";
+import { execFileSync as execFileSync10 } from "node:child_process";
 var GH_TIMEOUT_MS = 5e3;
 function parseGitHubRemote(remoteUrl) {
   const normalized = remoteUrl.trim().replace(/\/$/, "");
@@ -3776,7 +3871,7 @@ function parseGitHubRemote(remoteUrl) {
   if (m === null) return null;
   return { owner: m[1], repo: m[2] };
 }
-function ghAuthStatus(run = execFileSync9) {
+function ghAuthStatus(run = execFileSync10) {
   try {
     run("gh", ["auth", "status"], {
       stdio: ["ignore", "ignore", "ignore"],
@@ -3790,7 +3885,7 @@ function ghAuthStatus(run = execFileSync9) {
     return "gh-probe-error";
   }
 }
-function isRepoPrivate(ref, run = execFileSync9) {
+function isRepoPrivate(ref, run = execFileSync10) {
   const out = run("gh", ["repo", "view", `${ref.owner}/${ref.repo}`, "--json", "isPrivate"], {
     stdio: ["ignore", "pipe", "ignore"],
     timeout: GH_TIMEOUT_MS
@@ -3798,7 +3893,7 @@ function isRepoPrivate(ref, run = execFileSync9) {
   const parsed = JSON.parse(out);
   return parsed.isPrivate === true;
 }
-function isActionsEnabled(ref, run = execFileSync9) {
+function isActionsEnabled(ref, run = execFileSync10) {
   const out = run(
     "gh",
     ["api", `repos/${ref.owner}/${ref.repo}/actions/permissions`, "--jq", ".enabled"],
@@ -3806,7 +3901,7 @@ function isActionsEnabled(ref, run = execFileSync9) {
   ).toString().trim();
   return out === "true";
 }
-function disableActions(ref, run = execFileSync9) {
+function disableActions(ref, run = execFileSync10) {
   run(
     "gh",
     [
@@ -3820,7 +3915,7 @@ function disableActions(ref, run = execFileSync9) {
     { stdio: ["ignore", "ignore", "pipe"], timeout: GH_TIMEOUT_MS }
   );
 }
-function readOriginRemote(cwd, run = execFileSync9) {
+function readOriginRemote(cwd, run = execFileSync10) {
   return run("git", ["remote", "get-url", "origin"], {
     cwd,
     stdio: ["ignore", "pipe", "ignore"]
@@ -3828,7 +3923,7 @@ function readOriginRemote(cwd, run = execFileSync9) {
 }
 
 // src/commands.doctor.actions-drift.ts
-function reportActionsDrift(section2, run = execFileSync10) {
+function reportActionsDrift(section2, run = execFileSync11) {
   let remote;
   try {
     remote = readOriginRemote(repoHome(), run);
@@ -3896,6 +3991,7 @@ function gatherDoctorSections(opts) {
   const rawMap = existsSync27(mapPath) ? readJsonSafe(mapPath, mapPath, links) : null;
   const map = rawMap ?? { projects: {} };
   reportSharedLinks(links, map);
+  reportDroppedNamesMigration(links);
   const hooksScan = section("Hook targets");
   reportHooksTargetCheck(hooksScan);
   reportHookScopeCheck(hooksScan);
@@ -3915,6 +4011,7 @@ function gatherDoctorSections(opts) {
   reportRemote(repository);
   reportRebaseClean(repository);
   reportRebaseState(repository);
+  reportOrphanedAutostash(repository);
   reportActionsDrift(repository);
   const nomadVersion = section("Nomad Version");
   reportVersionCheck(nomadVersion);
@@ -3958,15 +4055,15 @@ function cmdDoctor(opts = {}) {
 
 // src/commands.drop-session.ts
 init_config();
-import { execFileSync as execFileSync12 } from "node:child_process";
+import { execFileSync as execFileSync13 } from "node:child_process";
 import { existsSync as existsSync29, readdirSync as readdirSync10, statSync as statSync8 } from "node:fs";
 import { join as join35, relative as relative4 } from "node:path";
 
 // src/commands.drop-session.git.ts
-import { execFileSync as execFileSync11 } from "node:child_process";
+import { execFileSync as execFileSync12 } from "node:child_process";
 function expandStagedDir(dirRel, repo) {
   try {
-    const out = execFileSync11("git", ["ls-files", "-z", "--", dirRel], {
+    const out = execFileSync12("git", ["ls-files", "-z", "--", dirRel], {
       cwd: repo,
       stdio: ["ignore", "pipe", "pipe"]
     });
@@ -3977,7 +4074,7 @@ function expandStagedDir(dirRel, repo) {
 }
 function isTrackedInHead(rel, repo) {
   try {
-    execFileSync11("git", ["cat-file", "-e", `HEAD:${rel}`], {
+    execFileSync12("git", ["cat-file", "-e", `HEAD:${rel}`], {
       cwd: repo,
       stdio: ["ignore", "pipe", "pipe"]
     });
@@ -3988,7 +4085,7 @@ function isTrackedInHead(rel, repo) {
 }
 function isInIndex(rel, repo) {
   try {
-    const out = execFileSync11("git", ["ls-files", "--", rel], {
+    const out = execFileSync12("git", ["ls-files", "--", rel], {
       cwd: repo,
       stdio: ["ignore", "pipe", "pipe"]
     });
@@ -4093,12 +4190,12 @@ function unstageOne(rel, repo) {
   }
   try {
     if (isTrackedInHead(rel, repo)) {
-      execFileSync12("git", ["restore", "--staged", "--worktree", "--", rel], {
+      execFileSync13("git", ["restore", "--staged", "--worktree", "--", rel], {
         cwd: repo,
         stdio: ["ignore", "pipe", "pipe"]
       });
     } else {
-      execFileSync12("git", ["rm", "--cached", "-f", "--", rel], {
+      execFileSync13("git", ["rm", "--cached", "-f", "--", rel], {
         cwd: repo,
         stdio: ["ignore", "pipe", "pipe"]
       });
@@ -4112,8 +4209,8 @@ function unstageOne(rel, repo) {
 }
 
 // src/commands.pull.ts
-import { existsSync as existsSync35, mkdirSync as mkdirSync8 } from "node:fs";
-import { join as join41 } from "node:path";
+import { existsSync as existsSync36, mkdirSync as mkdirSync9 } from "node:fs";
+import { join as join43 } from "node:path";
 
 // src/commands.push.sections.ts
 init_color();
@@ -4209,11 +4306,11 @@ init_config();
 // src/extras-sync.ts
 init_config();
 import { existsSync as existsSync32 } from "node:fs";
-import { join as join38 } from "node:path";
+import { join as join39 } from "node:path";
 
 // src/extras-sync.diff.ts
 init_utils();
-import { execFileSync as execFileSync13 } from "node:child_process";
+import { execFileSync as execFileSync14 } from "node:child_process";
 function labelDiffLine(line) {
   const tab = line.indexOf("	");
   if (tab === -1) return line;
@@ -4228,7 +4325,7 @@ function parseDiffOutput(stdout) {
 }
 function listDivergingFiles(a, b) {
   try {
-    const stdout = execFileSync13("git", ["diff", "--no-index", "--name-status", a, b], {
+    const stdout = execFileSync14("git", ["diff", "--no-index", "--name-status", a, b], {
       stdio: ["ignore", "pipe", "pipe"]
     }).toString();
     return parseDiffOutput(stdout);
@@ -4297,21 +4394,39 @@ function* eachExtrasTarget(v, counts) {
       counts.unmapped++;
       continue;
     }
-    for (const dirname7 of dirnames) {
-      if (!whitelist.includes(dirname7)) {
+    for (const dirname8 of dirnames) {
+      if (!whitelist.includes(dirname8)) {
         counts.skipped++;
         continue;
       }
-      yield { logical, localRoot, dirname: dirname7 };
+      yield { logical, localRoot, dirname: dirname8 };
     }
   }
 }
+function copyExtrasOverlayFiltered(src, dst, blockSet) {
+  try {
+    cpSync6(src, dst, {
+      recursive: true,
+      force: true,
+      verbatimSymlinks: true,
+      filter: (srcEntry) => srcEntry === src || !blockSet.has(basename(srcEntry))
+    });
+  } catch (err) {
+    const e = err;
+    if (e.code === "EINVAL" || e.code === "ENOTEMPTY" || e.code === "ERR_FS_CP_NON_DIR_TO_DIR" || e.code === "ERR_FS_CP_DIR_TO_NON_DIR") {
+      throw new NomadFatal(
+        `copyExtrasOverlayFiltered: type collision copying ${JSON.stringify(src)} -> ${JSON.stringify(dst)} (${e.path ?? "unknown path"}): a file/directory type changed upstream; run nomad pull --force-remote to recover`
+      );
+    }
+    throw err;
+  }
+}
 function copyExtras(src, dst) {
   rmSync10(dst, { recursive: true, force: true });
   cpSync6(src, dst, { recursive: true, force: true, verbatimSymlinks: true });
 }
-function extrasDenySet(dirname7) {
-  return dirname7 === ".claude" ? CLAUDE_EXTRA_NEVER_SYNC : ALWAYS_NEVER_SYNC;
+function extrasDenySet(dirname8) {
+  return dirname8 === ".claude" ? CLAUDE_EXTRA_NEVER_SYNC : ALWAYS_NEVER_SYNC;
 }
 function copyExtrasFiltered(src, dst, blockSet) {
   rmSync10(dst, { recursive: true, force: true });
@@ -4352,6 +4467,36 @@ function copyExtrasFilteredPreserving(src, dst, blockSet) {
     filter: (srcEntry) => srcEntry === src || !blockSet.has(basename(srcEntry))
   });
 }
+function prunePreservingBy(src, dst, isPreserved) {
+  for (const name of readdirSync11(dst)) {
+    if (isPreserved(name)) continue;
+    const dstPath = join36(dst, name);
+    const srcStat = lstatSync8(join36(src, name), { throwIfNoEntry: false });
+    if (srcStat === void 0) {
+      rmSync10(dstPath, { recursive: true, force: true });
+      continue;
+    }
+    const dstStat = lstatSync8(dstPath);
+    if (srcStat.isDirectory() && dstStat.isDirectory()) {
+      prunePreservingBy(join36(src, name), dstPath, isPreserved);
+    } else if (srcStat.isDirectory() !== dstStat.isDirectory()) {
+      rmSync10(dstPath, { recursive: true, force: true });
+    }
+  }
+}
+function copyExtrasFilteredPreservingBy(src, dst, isPreserved) {
+  const dstStat = lstatSync8(dst, { throwIfNoEntry: false });
+  if (dstStat !== void 0) {
+    if (dstStat.isDirectory()) prunePreservingBy(src, dst, isPreserved);
+    else rmSync10(dst, { recursive: true, force: true });
+  }
+  cpSync6(src, dst, {
+    recursive: true,
+    force: true,
+    verbatimSymlinks: true,
+    filter: (srcEntry) => srcEntry === src || !isPreserved(basename(srcEntry))
+  });
+}
 
 // src/extras-sync.ts
 init_utils();
@@ -4359,9 +4504,85 @@ init_utils_json();
 
 // src/extras-sync.remap.ts
 init_config();
-import { existsSync as existsSync31, mkdirSync as mkdirSync7 } from "node:fs";
-import { join as join37 } from "node:path";
+import { existsSync as existsSync31, mkdirSync as mkdirSync7, readdirSync as readdirSync12, realpathSync as realpathSync4, rmSync as rmSync11 } from "node:fs";
+import { dirname as dirname7, join as join38, sep as sep6 } from "node:path";
+
+// src/extras-sync.planning-diff.ts
+import { join as join37, normalize as normalize2, sep as sep5 } from "node:path";
+init_utils();
+function processRecord(fields, i, changed, deleted) {
+  const status = fields[i];
+  const next = i + 1;
+  if (status.startsWith("R")) {
+    const oldPath = fields[next];
+    const newPath = fields[next + 1];
+    if (oldPath) deleted.push(oldPath);
+    if (newPath) changed.push(newPath);
+    return next + 2;
+  }
+  if (status.startsWith("C")) {
+    const dstPath = fields[next + 1];
+    if (dstPath) changed.push(dstPath);
+    return next + 2;
+  }
+  const path = fields[next];
+  if (path) {
+    if (status === "D") {
+      deleted.push(path);
+    } else {
+      changed.push(path);
+    }
+  }
+  return next + 1;
+}
+function parsePlanningDiff(raw) {
+  const changed = [];
+  const deleted = [];
+  if (raw === "") {
+    return { changed, deleted };
+  }
+  const fields = raw.split("\0");
+  let i = 0;
+  while (i < fields.length) {
+    const status = fields[i];
+    if (!status) {
+      i++;
+      continue;
+    }
+    i = processRecord(fields, i, changed, deleted);
+  }
+  return { changed, deleted };
+}
+function planningDeleteTargets(opts) {
+  const { raw, logical, localRoot } = opts;
+  assertSafeLogical(logical);
+  assertSafeLocalRoot(localRoot, logical);
+  const { deleted } = parsePlanningDiff(raw);
+  const logicalPrefix = "shared/extras/" + logical + "/";
+  const prefix = logicalPrefix + ".planning/";
+  const planningRoot = join37(localRoot, ".planning");
+  const planningRootBoundary = planningRoot + sep5;
+  const targets = [];
+  for (const repoPath of deleted) {
+    if (!repoPath.startsWith(prefix)) {
+      continue;
+    }
+    const remainder = repoPath.slice(logicalPrefix.length);
+    const candidate = join37(localRoot, remainder);
+    const resolved = normalize2(candidate);
+    if (!resolved.startsWith(planningRootBoundary)) {
+      throw new NomadFatal(
+        `planningDeleteTargets: resolved path ${JSON.stringify(resolved)} escapes localRoot/.planning for logical ${JSON.stringify(logical)} -- refusing delete`
+      );
+    }
+    targets.push(resolved);
+  }
+  return targets;
+}
+
+// src/extras-sync.remap.ts
 init_utils_fs();
+init_utils();
 function runExtrasOp(v, dryRun, paths, backup, copy) {
   const counts = { unmapped: 0, skipped: 0 };
   const done = [];
@@ -4380,56 +4601,139 @@ function runExtrasOp(v, dryRun, paths, backup, copy) {
   }
   return { ...counts, done, would };
 }
+function pruneEmptyAncestors(target, planningRoot) {
+  let dir = dirname7(target);
+  while (dir !== planningRoot && dir.startsWith(planningRoot + sep6)) {
+    try {
+      if (readdirSync12(dir).length > 0) break;
+      rmSync11(dir, { recursive: true, force: true });
+    } catch {
+      break;
+    }
+    dir = dirname7(dir);
+  }
+}
+function tryRealpath(dir) {
+  try {
+    return realpathSync4(dir);
+  } catch {
+    return void 0;
+  }
+}
+function isInsidePlanningRoot(parentReal, rootReal) {
+  return parentReal === rootReal || parentReal.startsWith(rootReal + sep6);
+}
+function deletePlanningTarget(target, planningRoot, repoCounterpart) {
+  if (existsSync31(repoCounterpart)) return;
+  const parentReal = tryRealpath(dirname7(target));
+  if (parentReal === void 0) return;
+  const rootReal = tryRealpath(planningRoot);
+  if (rootReal === void 0) return;
+  if (!isInsidePlanningRoot(parentReal, rootReal)) return;
+  rmSync11(target, { recursive: true, force: true });
+  pruneEmptyAncestors(target, planningRoot);
+}
+function propagatePlanningDeletes(v, ts, prePostHeads, repo) {
+  const repoExtras = join38(repo, "shared", "extras");
+  for (const t of eachExtrasTarget(v, { unmapped: 0, skipped: 0 })) {
+    if (t.dirname !== ".planning") continue;
+    let raw;
+    try {
+      raw = gitCaptureRaw(
+        [
+          "diff",
+          "--name-status",
+          "-z",
+          prePostHeads.pre,
+          prePostHeads.post,
+          "--",
+          `shared/extras/${t.logical}/.planning/`
+        ],
+        repo
+      );
+    } catch (err) {
+      const e = err;
+      if (e.stderr) process.stderr.write(e.stderr);
+      throw new NomadFatal(
+        `git diff failed while propagating .planning deletes for ${t.logical}; run nomad pull --force-remote to recover`
+      );
+    }
+    const targets = planningDeleteTargets({ raw, logical: t.logical, localRoot: t.localRoot });
+    if (targets.length === 0) continue;
+    backupExtrasWrite(join38(t.localRoot, t.dirname), ts, t.localRoot);
+    const planningRoot = join38(t.localRoot, ".planning");
+    for (const target of targets) {
+      const relToLocal = target.slice(t.localRoot.length + sep6.length);
+      deletePlanningTarget(target, planningRoot, join38(repoExtras, t.logical, relToLocal));
+    }
+  }
+}
 function remapExtrasPush(ts, opts = {}) {
   const dryRun = opts.dryRun === true;
   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 = join37(repo, "shared", "extras");
+  const repoExtras = join38(repo, "shared", "extras");
   if (!dryRun) mkdirSync7(repoExtras, { recursive: true });
   const { unmapped, skipped, done, would } = runExtrasOp(
     v,
     dryRun,
-    ({ localRoot, logical, dirname: dirname7 }) => ({
-      src: join37(localRoot, dirname7),
-      dst: join37(repoExtras, logical, dirname7)
+    ({ localRoot, logical, dirname: dirname8 }) => ({
+      src: join38(localRoot, dirname8),
+      dst: join38(repoExtras, logical, dirname8)
     }),
     (dst) => backupRepoWrite(dst, ts, repo),
-    // Push filters every extra by its per-name denylist: `.claude` gets the
-    // full NEVER_SYNC boundary, `.planning` keeps the narrow ALWAYS_NEVER_SYNC.
-    (src, dst, dirname7) => copyExtrasFiltered(src, dst, extrasDenySet(dirname7))
+    // Push copy routing per extra type:
+    //   `.planning`: copyExtrasOverlayFiltered (no rmSync; deny-set filtered).
+    //     Repo-only files survive; local edits propagate (overlay overwrites).
+    //     The filter prevents ALWAYS_NEVER_SYNC files from landing in the repo
+    //     working tree before the allow-list gate fires, eliminating the
+    //     "residue wedges repeat push" regression (WR-02). The allow-list gate
+    //     (enforceAllowList / blockSetFor in commands.push.allowlist.ts)
+    //     remains the hard security boundary.
+    //   All others: copyExtrasFiltered with per-extra denylist.
+    (src, dst, dirname8) => dirname8 === ".planning" ? copyExtrasOverlayFiltered(src, dst, extrasDenySet(dirname8)) : copyExtrasFiltered(src, dst, extrasDenySet(dirname8))
   );
   return { unmapped, skipped, pushed: done, wouldPush: would };
 }
 function remapExtrasPull(ts, opts = {}) {
   const dryRun = opts.dryRun === true;
+  const { prePostHeads } = opts;
   const v = loadValidatedExtras({
     requireRepoExtras: true,
     missingMsg: "no path-map or repo extras dir; skipping extras remap"
   });
   if (v === null) return { unmapped: 0, skipped: 0, pulled: [], wouldPull: [] };
-  const repoExtras = join37(repoHome(), "shared", "extras");
+  const repo = repoHome();
   const { unmapped, skipped, done, would } = runExtrasOp(
     v,
     dryRun,
-    ({ localRoot, logical, dirname: dirname7 }) => ({
-      src: join37(repoExtras, logical, dirname7),
-      dst: join37(localRoot, dirname7)
+    ({ localRoot, logical, dirname: dirname8 }) => ({
+      src: join38(repo, "shared", "extras", logical, dirname8),
+      dst: join38(localRoot, dirname8)
     }),
     // Snapshot the host-side dst BEFORE copyExtras clobbers it. Anchor on
     // localRoot so the backup tree mirrors the project layout.
     (dst, localRoot) => backupExtrasWrite(dst, ts, localRoot),
-    // Pull routes `.claude` through copyExtrasFilteredPreserving so host-local
-    // deny-set files already on disk (e.g. settings.local.json) are preserved
-    // instead of being wiped by a blanket rmSync. The same deny-set filter still
-    // strips blocked basenames from the src copy (defense-in-depth: a repo
-    // poisoned out-of-band cannot restore a blocked per-host file). Synced
-    // non-deny files that are absent from src are still mirror-pruned. This
-    // preservation is `.claude`-only; `.planning` and `CLAUDE.md` use the
-    // exact-mirror copyExtras (documented restore semantics; they rarely carry
-    // host-local files, so the exact mirror is the correct default).
-    (src, dst, dirname7) => dirname7 === ".claude" ? copyExtrasFilteredPreserving(src, dst, extrasDenySet(dirname7)) : copyExtras(src, dst)
+    // Pull routing per extra type:
+    //   `.claude`: copyExtrasFilteredPreserving preserves host-local deny-set
+    //     files (e.g. settings.local.json) while mirror-pruning synced entries.
+    //   `.planning`: copyExtrasOverlayFiltered (no rmSync; deny-set filtered)
+    //     keeps local-only files; the delete pass below propagates upstream
+    //     removals via the git-diff D set. The filter is defense-in-depth
+    //     against a repo poisoned out-of-band.
+    //   All others: copyExtras (exact mirror; rarely carry host-local files).
+    (src, dst, dirname8) => {
+      if (dirname8 === ".claude")
+        return copyExtrasFilteredPreserving(src, dst, extrasDenySet(dirname8));
+      if (dirname8 === ".planning")
+        return copyExtrasOverlayFiltered(src, dst, extrasDenySet(dirname8));
+      return copyExtras(src, dst);
+    }
   );
+  if (!dryRun && prePostHeads !== void 0) {
+    propagatePlanningDeletes(v, ts, prePostHeads, repo);
+  }
   return { unmapped, skipped, pulled: done, wouldPull: would };
 }
 
@@ -4438,17 +4742,17 @@ function divergenceCheckExtras(ts) {
   const v = loadValidatedExtras({});
   if (v === null) return;
   const counts = { unmapped: 0, skipped: 0 };
-  const backupRoot = join38(backupBase(), ts, "extras");
+  const backupRoot = join39(backupBase(), ts, "extras");
   const repo = repoHome();
-  for (const { logical, localRoot, dirname: dirname7 } of eachExtrasTarget(v, counts)) {
-    const local = join38(localRoot, dirname7);
-    const repoEntry = join38(repo, "shared", "extras", logical, dirname7);
+  for (const { logical, localRoot, dirname: dirname8 } of eachExtrasTarget(v, counts)) {
+    const local = join39(localRoot, dirname8);
+    const repoEntry = join39(repo, "shared", "extras", logical, dirname8);
     if (!existsSync32(local) || !existsSync32(repoEntry)) continue;
     const diff = listDivergingFiles(local, repoEntry);
     if (diff.length === 0) continue;
-    const projectBackupRoot = join38(backupRoot, encodePath(localRoot));
+    const projectBackupRoot = join39(backupRoot, encodePath(localRoot));
     warn(
-      `local ${dirname7} for ${logical} diverges from origin in ${diff.length} file(s); next remapExtrasPull will overwrite them (backups at ${projectBackupRoot}/)`
+      `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}/)`
     );
     for (const f of diff) warn(`  ${f}`);
   }
@@ -4459,8 +4763,8 @@ init_config();
 init_utils();
 init_utils_fs();
 init_utils_json();
-import { existsSync as existsSync33, lstatSync as lstatSync9, rmSync as rmSync11 } from "node:fs";
-import { join as join39 } from "node:path";
+import { existsSync as existsSync33, lstatSync as lstatSync9, rmSync as rmSync12 } from "node:fs";
+import { join as join40 } from "node:path";
 function emitAutoMove(onPreview, linkPath, ts, name) {
   if (onPreview) {
     onPreview({ kind: "auto-move", from: linkPath, to: `backup/${ts}/${name}` });
@@ -4480,8 +4784,8 @@ function isAlreadySymlink(linkPath) {
 }
 function runAutoMovePasses(linkNames, claude, repo, ts, dryRun, onPreview) {
   for (const name of linkNames) {
-    const linkPath = join39(claude, name);
-    const target = join39(repo, "shared", name);
+    const linkPath = join40(claude, name);
+    const target = join40(repo, "shared", name);
     if (!existsSync33(linkPath)) continue;
     if (lstatSync9(linkPath).isSymbolicLink()) continue;
     if (!existsSync33(target)) continue;
@@ -4490,7 +4794,7 @@ function runAutoMovePasses(linkNames, claude, repo, ts, dryRun, onPreview) {
       continue;
     }
     backupBeforeWrite(linkPath, ts);
-    rmSync11(linkPath, { recursive: true, force: true });
+    rmSync12(linkPath, { recursive: true, force: true });
   }
 }
 function applySharedLinks(ts, map, opts = {}) {
@@ -4500,9 +4804,9 @@ function applySharedLinks(ts, map, opts = {}) {
   const linkNames = allSharedLinks(map);
   runAutoMovePasses(linkNames, claude, repo, ts, dryRun, opts.onPreview);
   for (const name of linkNames) {
-    const target = join39(repo, "shared", name);
+    const target = join40(repo, "shared", name);
     if (!existsSync33(target)) continue;
-    const linkPath = join39(claude, name);
+    const linkPath = join40(claude, name);
     if (isAlreadySymlink(linkPath)) continue;
     if (dryRun) {
       emitCreate(opts.onPreview, linkPath, target);
@@ -4515,8 +4819,8 @@ function regenerateSettings(ts, opts = {}) {
   const dryRun = opts.dryRun === true;
   const repo = repoHome();
   const claude = claudeHome();
-  const basePath = join39(repo, "shared", "settings.base.json");
-  const hostPath = join39(repo, "hosts", `${HOST}.json`);
+  const basePath = join40(repo, "shared", "settings.base.json");
+  const hostPath = join40(repo, "hosts", `${HOST}.json`);
   if (!existsSync33(basePath)) {
     die("repo not initialized; run 'nomad init' to scaffold");
   }
@@ -4524,7 +4828,7 @@ function regenerateSettings(ts, opts = {}) {
   const hasOverrides = existsSync33(hostPath);
   const overrides = hasOverrides ? readJson(hostPath) : {};
   const merged = deepMerge(base, overrides);
-  const settingsPath = join39(claude, "settings.json");
+  const settingsPath = join40(claude, "settings.json");
   if (!hasOverrides && existsSync33(settingsPath)) {
     try {
       const existing = readJson(settingsPath);
@@ -4549,10 +4853,53 @@ function regenerateSettings(ts, opts = {}) {
   return { label: overrideLabel };
 }
 
+// src/skills-sync.ts
+init_config();
+import { existsSync as existsSync34, lstatSync as lstatSync10, mkdirSync as mkdirSync8, readdirSync as readdirSync13, rmSync as rmSync13 } from "node:fs";
+import { join as join41 } from "node:path";
+init_utils_fs();
+function isGsdOwned(name) {
+  return name.startsWith(GSD_PREFIX);
+}
+function isSkillExcluded(name) {
+  return isGsdOwned(name) || ALWAYS_NEVER_SYNC.has(name);
+}
+function copySkillsPush(src, dst) {
+  const srcNames = readdirSync13(src, { encoding: "utf8" });
+  const blockSet = /* @__PURE__ */ new Set([
+    ...srcNames.filter((n) => isGsdOwned(n)),
+    ...ALWAYS_NEVER_SYNC
+  ]);
+  copyExtrasFiltered(src, dst, blockSet);
+}
+function copySkillsPull(src, dst) {
+  copyExtrasFilteredPreservingBy(src, dst, isSkillExcluded);
+}
+function syncSkillsPull(ts) {
+  const sharedSkills = join41(repoHome(), "shared", "skills");
+  if (!existsSync34(sharedSkills)) return;
+  const localSkills = join41(claudeHome(), "skills");
+  const dstStat = lstatSync10(localSkills, { throwIfNoEntry: false });
+  if (dstStat?.isSymbolicLink() === true) {
+    backupBeforeWrite(localSkills, ts);
+    rmSync13(localSkills, { recursive: true, force: true });
+    mkdirSync8(localSkills, { recursive: true });
+  }
+  copySkillsPull(sharedSkills, localSkills);
+}
+function syncSkillsPush() {
+  const localSkills = join41(claudeHome(), "skills");
+  const stat = lstatSync10(localSkills, { throwIfNoEntry: false });
+  if (stat === void 0) return;
+  if (stat.isSymbolicLink()) return;
+  const sharedSkills = join41(repoHome(), "shared", "skills");
+  copySkillsPush(localSkills, sharedSkills);
+}
+
 // src/preview.ts
 init_config();
-import { existsSync as existsSync34 } from "node:fs";
-import { join as join40 } from "node:path";
+import { existsSync as existsSync35 } from "node:fs";
+import { join as join42 } from "node:path";
 
 // node_modules/diff/libesm/diff/base.js
 var Diff = class {
@@ -4838,7 +5185,7 @@ function diffJsonStrings(currentJsonText, newJsonText) {
   return lines.join("\n");
 }
 function readJsonOrNull(path) {
-  if (!existsSync34(path)) return null;
+  if (!existsSync35(path)) return null;
   try {
     return readJson(path);
   } catch {
@@ -4852,12 +5199,12 @@ function previewSettings(basePath, hostPath, settingsPath) {
   }
   const notes = [];
   const hostOverrides = readJsonOrNull(hostPath);
-  if (hostOverrides === null && existsSync34(hostPath)) {
+  if (hostOverrides === null && existsSync35(hostPath)) {
     notes.push(`malformed hosts/${HOST}.json; ignoring overrides`);
   }
   const merged = deepMerge(base, hostOverrides ?? {});
   const current = readJsonOrNull(settingsPath);
-  if (current === null && existsSync34(settingsPath)) {
+  if (current === null && existsSync35(settingsPath)) {
     return { diff: "", notes: [...notes, "malformed; skipping diff"] };
   }
   const rawEqual = JSON.stringify(current ?? {}, null, 2) === JSON.stringify(merged, null, 2);
@@ -4897,9 +5244,9 @@ function computePreview(ts, map, verb = "pull") {
     onPreview: (e) => addItem(links, formatLinkRow(e))
   });
   const settingsResult = previewSettings(
-    join40(repo, "shared", "settings.base.json"),
-    join40(repo, "hosts", `${HOST}.json`),
-    join40(claude, "settings.json")
+    join42(repo, "shared", "settings.base.json"),
+    join42(repo, "hosts", `${HOST}.json`),
+    join42(claude, "settings.json")
   );
   const settingsSection = buildSettingsSectionForPreview(settingsResult);
   const sessions = section("Sessions");
@@ -4913,13 +5260,21 @@ function computePreview(ts, map, verb = "pull") {
   return { unmapped: remapResult.unmapped, collisions: 0 };
 }
 
+// src/commands.pull.ts
+init_commands_pull_wedge();
+
 // src/commands.pull.recovery.ts
 init_config();
-import { execFileSync as execFileSync14 } from "node:child_process";
+init_commands_pull_wedge();
 init_utils();
 init_utils_fs();
+import { execFileSync as execFileSync15 } from "node:child_process";
 function gitCapture(args, cwd) {
-  return execFileSync14("git", args, { cwd, stdio: ["ignore", "pipe", "pipe"] }).toString().trim();
+  return execFileSync15("git", args, {
+    cwd,
+    stdio: ["ignore", "pipe", "pipe"],
+    maxBuffer: 64 * 1024 * 1024
+  }).toString().trim();
 }
 function isSyncedConfig(path) {
   return PUSH_ALLOWED_STATIC.some(
@@ -4990,6 +5345,20 @@ function freshStrandedBranch(repo) {
   while (exists(`${base}-${n}`)) n++;
   return `${base}-${n}`;
 }
+function recoverUnmergedIndex(repo) {
+  gitOrFatal(["reset", "--mixed", "HEAD"], "git reset --mixed HEAD", repo);
+  const dirty = gitCapture(["diff", "--name-only", "-z"], repo).split("\0").filter(Boolean);
+  if (dirty.length > 0) {
+    log(
+      "index cleared, but these files still carry conflict content from the torn-down rebase; review and resolve before the next pull:\n" + dirty.map((p) => `  ${p}`).join("\n")
+    );
+  }
+  if (orphanedAutostashPresent(repo)) {
+    log(
+      'orphaned autostash preserved in the stash list; run "git stash pop" to restore or "git stash drop" to discard it, then re-run "nomad pull"'
+    );
+  }
+}
 function recoverForceRemote(mode, repo) {
   if (mode === "merge") {
     gitOrFatal(["merge", "--abort"], "git merge --abort", repo);
@@ -5023,11 +5392,26 @@ function recoverForceRemote(mode, repo) {
 init_utils();
 init_utils_fs();
 init_utils_json();
-function applyWetPull(ts, map) {
+function captureHead(repo) {
+  try {
+    return gitCaptureRaw(["rev-parse", "HEAD"], repo).trim();
+  } catch {
+    return void 0;
+  }
+}
+function capturePrePostHeads(repo, rebase) {
+  const pre = captureHead(repo);
+  rebase();
+  const post = captureHead(repo);
+  if (pre === void 0 || post === void 0) return void 0;
+  return { pre, post };
+}
+function applyWetPull(ts, map, prePostHeads) {
   applySharedLinks(ts, map);
   const { label } = regenerateSettings(ts);
+  syncSkillsPull(ts);
   const remapResult = withSpinner("Syncing sessions", () => remapPull(ts));
-  const extrasResult = remapExtrasPull(ts);
+  const extrasResult = remapExtrasPull(ts, { prePostHeads });
   const summary = section("Summary");
   addItem(
     summary,
@@ -5041,24 +5425,30 @@ function applyWetPull(ts, map) {
   ]);
 }
 function handleWedge(repo, forceRemote) {
-  const wedge = detectWedge(repo);
+  const wedge = classifyWedge(repo);
   if (wedge === null) return;
+  if (wedge === "unmerged-index") {
+    if (forceRemote) {
+      recoverUnmergedIndex(repo);
+    } else {
+      die(unmergedIndexRunbookText("nomad pull"));
+    }
+    return;
+  }
   if (forceRemote) {
     recoverForceRemote(wedge, repo);
     return;
   }
   const state = wedge === "rebase" ? "mid-rebase" : "mid-merge";
-  die(
-    `repo is ${state} from a previous failed pull; run 'nomad pull --force-remote' to auto-recover, or resolve manually (see FAQ: "Every pull fails with unmerged files")`
-  );
+  die(wedgeMarkerRunbookText(state));
 }
 function cmdPull(opts = {}) {
   const dryRun = opts.dryRun === true;
   const forceRemote = opts.forceRemote === true;
   const repo = repoHome();
   const backup = backupBase();
-  if (!existsSync35(repo)) die(`repo not cloned at ${repo}`);
-  if (!existsSync35(join41(repo, "shared", "settings.base.json"))) {
+  if (!existsSync36(repo)) die(`repo not cloned at ${repo}`);
+  if (!existsSync36(join43(repo, "shared", "settings.base.json"))) {
     die("repo not initialized; run 'nomad init' to scaffold");
   }
   const handle = acquireLock("pull");
@@ -5067,9 +5457,9 @@ function cmdPull(opts = {}) {
     const ts = freshBackupTs(backup);
     handleWedge(repo, forceRemote);
     if (!dryRun) {
-      const backupRoot = join41(backup, ts);
+      const backupRoot = join43(backup, ts);
       try {
-        mkdirSync8(backupRoot, { recursive: true });
+        mkdirSync9(backupRoot, { recursive: true });
       } catch (err) {
         die(`could not create backup dir: ${err.message}`);
       }
@@ -5077,15 +5467,17 @@ function cmdPull(opts = {}) {
     log(
       dryRun ? `pulling on host=${HOST} (backup=${ts}; dry-run)` : `pull on host=${HOST} (backup=${ts})`
     );
-    gitOrFatal(["pull", "--rebase", "--autostash"], "git pull --rebase", repo);
-    const mapPath = join41(repo, "path-map.json");
-    const map = existsSync35(mapPath) ? readPathMap(mapPath) : { projects: {} };
+    const prePostHeads = capturePrePostHeads(repo, () => {
+      gitOrFatal(["pull", "--rebase", "--autostash"], "git pull --rebase", repo);
+    });
+    const mapPath = join43(repo, "path-map.json");
+    const map = existsSync36(mapPath) ? readPathMap(mapPath) : { projects: {} };
     divergenceCheckExtras(ts);
     if (dryRun) {
       computePreview(ts, map, "pull");
       log("dry-run complete; no mutation");
     } else {
-      applyWetPull(ts, map);
+      applyWetPull(ts, map, prePostHeads);
     }
   } catch (err) {
     if (err instanceof NomadFatal) {
@@ -5101,8 +5493,8 @@ function cmdPull(opts = {}) {
 
 // src/commands.push.ts
 init_config();
-import { existsSync as existsSync37 } from "node:fs";
-import { join as join43, relative as relative5 } from "node:path";
+import { existsSync as existsSync38 } from "node:fs";
+import { join as join45, relative as relative5 } from "node:path";
 
 // src/commands.push.allowlist.ts
 init_config();
@@ -5181,7 +5573,7 @@ function enforceAllowList(statusPorcelain, map) {
 
 // src/push-global-config.ts
 init_config();
-import { execFileSync as execFileSync15 } from "node:child_process";
+import { execFileSync as execFileSync16 } from "node:child_process";
 var STATUS_LABELS = {
   A: "add",
   M: "modify",
@@ -5208,6 +5600,7 @@ function buildPrefixSets(hostname2) {
     }
   }
   exactPrefixes.add("shared/settings.base.json");
+  dirPrefixes.push("shared/skills");
   exactPrefixes.add(`hosts/${hostname2}.json`);
   return { exactPrefixes, dirPrefixes };
 }
@@ -5220,7 +5613,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 = execFileSync15("git", args, {
+  const raw = execFileSync16("git", args, {
     cwd: repoHome2,
     stdio: ["ignore", "pipe", "pipe"]
   }).toString();
@@ -5259,9 +5652,9 @@ init_color();
 init_config();
 init_config_sharedDirs_guard();
 import { randomBytes as randomBytes2 } from "node:crypto";
-import { copyFileSync, existsSync as existsSync36, mkdirSync as mkdirSync9, readdirSync as readdirSync12, rmSync as rmSync12 } from "node:fs";
+import { copyFileSync, existsSync as existsSync37, mkdirSync as mkdirSync10, readdirSync as readdirSync14, rmSync as rmSync14 } from "node:fs";
 import { homedir as homedir5 } from "node:os";
-import { join as join42 } from "node:path";
+import { join as join44 } from "node:path";
 init_push_leak_verdict();
 init_push_gitleaks();
 init_utils_fs();
@@ -5276,13 +5669,13 @@ function stageSessions(tmpRoot, map) {
     if (!p || p === "TBD") continue;
     reverse.set(encodePath(p), logical);
   }
-  const localProjects = join42(claudeHome(), "projects");
-  if (!existsSync36(localProjects)) return 0;
+  const localProjects = join44(claudeHome(), "projects");
+  if (!existsSync37(localProjects)) return 0;
   let staged = 0;
-  for (const dir of readdirSync12(localProjects)) {
+  for (const dir of readdirSync14(localProjects)) {
     const logical = reverse.get(dir);
     if (!logical) continue;
-    copyDirJsonlOnly(join42(localProjects, dir), join42(tmpRoot, "shared", "projects", logical));
+    copyDirJsonlOnly(join44(localProjects, dir), join44(tmpRoot, "shared", "projects", logical));
     staged++;
   }
   return staged;
@@ -5296,11 +5689,11 @@ function stageExtras(tmpRoot, map) {
     assertSafeLogical(logical);
     const localRoot = map.projects[logical]?.[HOST];
     if (!localRoot || localRoot === "TBD") continue;
-    for (const dirname7 of dirnames) {
-      if (!whitelist.includes(dirname7)) continue;
-      const src = join42(localRoot, dirname7);
-      if (!existsSync36(src)) continue;
-      const dst = join42(tmpRoot, "shared", "extras", logical, dirname7);
+    for (const dirname8 of dirnames) {
+      if (!whitelist.includes(dirname8)) continue;
+      const src = join44(localRoot, dirname8);
+      if (!existsSync37(src)) continue;
+      const dst = join44(tmpRoot, "shared", "extras", logical, dirname8);
       copyExtras(src, dst);
       staged++;
     }
@@ -5308,19 +5701,19 @@ function stageExtras(tmpRoot, map) {
   return staged;
 }
 function previewPushLeaks(map) {
-  const cacheDir = join42(homedir5(), ".cache", "claude-nomad");
-  mkdirSync9(cacheDir, { recursive: true });
+  const cacheDir = join44(homedir5(), ".cache", "claude-nomad");
+  mkdirSync10(cacheDir, { recursive: true });
   const stamp = `${nowTimestamp()}-${process.pid}-${randomBytes2(4).toString("hex")}`;
-  const tmpRoot = join42(cacheDir, `push-preview-tree-${stamp}`);
+  const tmpRoot = join44(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 = join42(repoHome(), ".gitleaksignore");
-    if (existsSync36(ignoreFile)) {
-      copyFileSync(ignoreFile, join42(tmpRoot, ".gitleaksignore"));
+    const ignoreFile = join44(repoHome(), ".gitleaksignore");
+    if (existsSync37(ignoreFile)) {
+      copyFileSync(ignoreFile, join44(tmpRoot, ".gitleaksignore"));
     }
     let findings;
     try {
@@ -5333,7 +5726,7 @@ function previewPushLeaks(map) {
     }
     return verdictFromFindings(findings);
   } finally {
-    rmSync12(tmpRoot, { recursive: true, force: true });
+    rmSync14(tmpRoot, { recursive: true, force: true });
   }
 }
 
@@ -5342,7 +5735,7 @@ init_utils();
 init_utils_fs();
 init_utils_json();
 function guardGitlinks(repo) {
-  const gitlinks = findGitlinks(join43(repo, "shared"));
+  const gitlinks = findGitlinks(join45(repo, "shared"));
   if (gitlinks.length === 0) return;
   for (const p of gitlinks) {
     const rel = relative5(repo, p);
@@ -5398,7 +5791,7 @@ async function cmdPush(opts = {}) {
   guardResolutionModeConflicts(dryRun, redactAll, allowAll, allowRule);
   const repo = repoHome();
   const backup = backupBase();
-  if (!existsSync37(repo)) die(`repo not cloned at ${repo}`);
+  if (!existsSync38(repo)) die(`repo not cloned at ${repo}`);
   const handle = acquireLock("push");
   if (handle === null) process.exit(0);
   try {
@@ -5408,6 +5801,7 @@ async function cmdPush(opts = {}) {
     const ts = freshBackupTs(backup);
     const remap = withSpinner("Syncing sessions", () => remapPush(ts, { dryRun }));
     const extras = withSpinner("Syncing extras", () => remapExtrasPush(ts, { dryRun }));
+    if (!dryRun) syncSkillsPush();
     const st = { dryRun, remap, extras, globalConfig: [] };
     guardGitlinks(repo);
     const status = gitStatusPorcelainZ(repo, { untrackedAll: true });
@@ -5416,8 +5810,8 @@ async function cmdPush(opts = {}) {
       renderNoScanTree(st);
       return;
     }
-    const mapPath = join43(repo, "path-map.json");
-    if (!existsSync37(mapPath)) {
+    const mapPath = join45(repo, "path-map.json");
+    if (!existsSync38(mapPath)) {
       if (dryRun) return runDryRunPreview(st, null, repo);
       die("path-map.json missing, cannot enforce push allow-list");
     }
@@ -5438,16 +5832,16 @@ async function cmdPush(opts = {}) {
 }
 
 // src/commands.update.ts
-import { execFileSync as execFileSync16 } from "node:child_process";
+import { execFileSync as execFileSync17 } from "node:child_process";
 init_utils();
-function readInstalledVersion(run = execFileSync16) {
+function readInstalledVersion(run = execFileSync17) {
   try {
     return run("nomad", ["--version"], { encoding: "utf8" }).toString().trim() || null;
   } catch {
     return null;
   }
 }
-function cmdUpdate(run = execFileSync16) {
+function cmdUpdate(run = execFileSync17) {
   console.log("Updating claude-nomad CLI via npm...");
   try {
     run("npm", ["update", "-g", "claude-nomad"], { stdio: "inherit" });
@@ -5471,18 +5865,18 @@ init_config();
 
 // src/diff.ts
 init_config();
-import { existsSync as existsSync38 } from "node:fs";
-import { join as join44 } from "node:path";
+import { existsSync as existsSync39 } from "node:fs";
+import { join as join46 } from "node:path";
 init_utils();
 init_utils_fs();
 init_utils_json();
 function cmdDiff() {
   try {
     const repo = repoHome();
-    if (!existsSync38(repo)) die(`repo not cloned at ${repo}`);
+    if (!existsSync39(repo)) die(`repo not cloned at ${repo}`);
     const ts = freshBackupTs(backupBase());
-    const mapPath = join44(repo, "path-map.json");
-    const map = existsSync38(mapPath) ? readPathMap(mapPath) : { projects: {} };
+    const mapPath = join46(repo, "path-map.json");
+    const map = existsSync39(mapPath) ? readPathMap(mapPath) : { projects: {} };
     computePreview(ts, map, "diff");
   } catch (err) {
     if (err instanceof NomadFatal) {
@@ -5496,19 +5890,19 @@ function cmdDiff() {
 
 // src/init.ts
 init_config();
-import { existsSync as existsSync40, mkdirSync as mkdirSync10, writeFileSync as writeFileSync6 } from "node:fs";
-import { join as join46 } from "node:path";
+import { existsSync as existsSync41, mkdirSync as mkdirSync11, writeFileSync as writeFileSync6 } from "node:fs";
+import { join as join48 } from "node:path";
 
 // src/init.gh-onboard.ts
 init_config();
-import { execFileSync as execFileSync17 } from "node:child_process";
+import { execFileSync as execFileSync18 } 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 = execFileSync17) {
+function ensureOriginRepo(repoName, run = execFileSync18) {
   if (!isValidRepoName(repoName)) {
     die(
       `invalid repo name: ${JSON.stringify(repoName)}. Use only letters, digits, hyphens, underscores, and dots (1-100 chars).`
@@ -5579,33 +5973,33 @@ init_config();
 init_utils();
 init_utils_fs();
 init_utils_json();
-import { copyFileSync as copyFileSync2, cpSync as cpSync7, existsSync as existsSync39, rmSync as rmSync13, statSync as statSync9 } from "node:fs";
-import { join as join45 } from "node:path";
+import { copyFileSync as copyFileSync2, cpSync as cpSync7, existsSync as existsSync40, rmSync as rmSync15, statSync as statSync9 } from "node:fs";
+import { join as join47 } from "node:path";
 function snapshotIntoShared(map) {
   const repo = repoHome();
   const claude = claudeHome();
   for (const name of allSharedLinks(map)) {
-    const src = join45(claude, name);
-    if (!existsSync39(src)) continue;
-    const dst = join45(repo, "shared", name);
+    const src = join47(claude, name);
+    if (!existsSync40(src)) continue;
+    const dst = join47(repo, "shared", name);
     if (statSync9(src).isDirectory()) {
-      const gk = join45(dst, ".gitkeep");
-      if (existsSync39(gk)) rmSync13(gk);
+      const gk = join47(dst, ".gitkeep");
+      if (existsSync40(gk)) rmSync15(gk);
       cpSync7(src, dst, { recursive: true, force: false, errorOnExist: true });
     } else {
       copyFileSync2(src, dst);
     }
     log(`snapshotted shared/${name} from ${src}`);
   }
-  const userSettings = join45(claude, "settings.json");
-  if (existsSync39(userSettings)) {
+  const userSettings = join47(claude, "settings.json");
+  if (existsSync40(userSettings)) {
     let parsed;
     try {
       parsed = readJson(userSettings);
     } catch (err) {
       return die(`malformed ${userSettings}: ${err.message}`);
     }
-    const hostFile = join45(repo, "hosts", `${HOST}.json`);
+    const hostFile = join47(repo, "hosts", `${HOST}.json`);
     writeJsonAtomic(hostFile, parsed);
     log(`snapshotted hosts/${HOST}.json from ${userSettings}`);
   }
@@ -5618,14 +6012,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 = [
-    join46(repoHome2, "shared", "settings.base.json"),
-    join46(repoHome2, "shared", "CLAUDE.md"),
-    join46(repoHome2, "path-map.json"),
-    join46(repoHome2, "hosts"),
-    join46(repoHome2, "shared")
+    join48(repoHome2, "shared", "settings.base.json"),
+    join48(repoHome2, "shared", "CLAUDE.md"),
+    join48(repoHome2, "path-map.json"),
+    join48(repoHome2, "hosts"),
+    join48(repoHome2, "shared")
   ];
   for (const c of candidates) {
-    if (existsSync40(c)) return c;
+    if (existsSync41(c)) return c;
   }
   return null;
 }
@@ -5634,31 +6028,31 @@ function cmdInit(opts = {}) {
   const keepActions = opts.keepActions === true;
   const repo = repoHome();
   const claude = claudeHome();
-  mkdirSync10(repo, { recursive: true });
+  mkdirSync11(repo, { recursive: true });
   const conflict = preflightConflict(repo);
   if (conflict !== null) {
     die(`already initialized; refusing to clobber ${conflict}`);
   }
   ensureOriginRepo(opts.repoName ?? DEFAULT_REPO_NAME, opts.run);
-  mkdirSync10(join46(repo, "shared"), { recursive: true });
-  mkdirSync10(join46(repo, "hosts"), { recursive: true });
+  mkdirSync11(join48(repo, "shared"), { recursive: true });
+  mkdirSync11(join48(repo, "hosts"), { recursive: true });
   for (const name of SHARED_KEEP_DIRS) {
-    mkdirSync10(join46(repo, "shared", name), { recursive: true });
+    mkdirSync11(join48(repo, "shared", name), { recursive: true });
   }
-  const userClaudeMd = join46(claude, "CLAUDE.md");
-  if (!snapshot || !existsSync40(userClaudeMd)) {
-    writeFileSync6(join46(repo, "shared", "CLAUDE.md"), SHARED_CLAUDE_MD);
+  const userClaudeMd = join48(claude, "CLAUDE.md");
+  if (!snapshot || !existsSync41(userClaudeMd)) {
+    writeFileSync6(join48(repo, "shared", "CLAUDE.md"), SHARED_CLAUDE_MD);
     item("created shared/CLAUDE.md");
   }
   for (const name of SHARED_KEEP_DIRS) {
-    writeFileSync6(join46(repo, "shared", name, ".gitkeep"), "");
+    writeFileSync6(join48(repo, "shared", name, ".gitkeep"), "");
     item(`created shared/${name}/.gitkeep`);
   }
-  writeFileSync6(join46(repo, "hosts", ".gitkeep"), "");
+  writeFileSync6(join48(repo, "hosts", ".gitkeep"), "");
   item("created hosts/.gitkeep");
-  writeJsonAtomic(join46(repo, "shared", "settings.base.json"), {});
+  writeJsonAtomic(join48(repo, "shared", "settings.base.json"), {});
   item("created shared/settings.base.json");
-  writeJsonAtomic(join46(repo, "path-map.json"), { projects: {} });
+  writeJsonAtomic(join48(repo, "path-map.json"), { projects: {} });
   item("created path-map.json");
   if (snapshot) {
     snapshotIntoShared({ projects: {} });
@@ -5959,7 +6353,7 @@ function parsePushArgs(argv) {
 // package.json
 var package_default = {
   name: "claude-nomad",
-  version: "0.48.0",
+  version: "0.50.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: [
@@ -6160,15 +6554,15 @@ var DEFAULT_HELP = [
 init_config();
 init_utils();
 init_utils_json();
-import { existsSync as existsSync41, readFileSync as readFileSync14, readdirSync as readdirSync13 } from "node:fs";
-import { join as join47 } from "node:path";
+import { existsSync as existsSync42, readFileSync as readFileSync14, readdirSync as readdirSync15 } from "node:fs";
+import { join as join49 } 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 = join47(claudeHome(), "projects");
-  if (!existsSync41(projectsRoot)) {
+  const projectsRoot = join49(claudeHome(), "projects");
+  if (!existsSync42(projectsRoot)) {
     fail(`${projectsRoot} does not exist`);
     process.exit(1);
   }
@@ -6182,8 +6576,8 @@ function resumeCmd(sessionId) {
     fail(`no cwd field found in ${jsonlPath}`);
     process.exit(1);
   }
-  const mapPath = join47(repoHome(), "path-map.json");
-  if (!existsSync41(mapPath)) {
+  const mapPath = join49(repoHome(), "path-map.json");
+  if (!existsSync42(mapPath)) {
     fail("path-map.json missing");
     process.exit(1);
   }
@@ -6205,9 +6599,9 @@ function resumeCmd(sessionId) {
   console.log(`cd ${shQuote(hit.localPath)} && claude --resume ${shQuote(sessionId)}`);
 }
 function findTranscriptPath(projectsRoot, sessionId) {
-  for (const dir of readdirSync13(projectsRoot)) {
-    const candidate = join47(projectsRoot, dir, `${sessionId}.jsonl`);
-    if (existsSync41(candidate)) return candidate;
+  for (const dir of readdirSync15(projectsRoot)) {
+    const candidate = join49(projectsRoot, dir, `${sessionId}.jsonl`);
+    if (existsSync42(candidate)) return candidate;
   }
   return null;
 }