claude-nomad 0.60.0 → 0.62.0

package/dist/nomad.mjs

@@ -189,8 +189,36 @@ var init_color = __esm({
   }
 });
 
+// src/exit-codes.ts
+var EXIT;
+var init_exit_codes = __esm({
+  "src/exit-codes.ts"() {
+    "use strict";
+    EXIT = {
+      /** Completed successfully. Also returned when a held lock causes a no-op skip. */
+      SUCCESS: 0,
+      /** Unclassified failure; the default for any error not mapped to a more specific code. */
+      GENERIC_FAILURE: 1,
+      /** Bad argv: unknown subcommand, unknown flag, or malformed flag value. */
+      USAGE: 2,
+      /** A wedged repo state (e.g. an unresolved rebase) needing manual git resolution. */
+      CONFLICT: 4,
+      /** gitleaks confirmed a secret in the staged tree and the push was aborted. */
+      LEAK_BLOCKED: 5
+    };
+  }
+});
+
 // src/utils.ts
 import { execFileSync } from "node:child_process";
+function isProcessExit(err) {
+  if (typeof err !== "object" || err === null) return false;
+  try {
+    return err[PROCESS_EXIT_BRAND] === true;
+  } catch {
+    return false;
+  }
+}
 function gitCaptureRaw(args, cwd) {
   return execFileSync("git", args, {
     cwd,
@@ -214,11 +242,12 @@ function gitOrFatal(args, context, cwd) {
     throw new NomadFatal(`${context} failed`);
   }
 }
-var log, ok, warn, fail, item, NomadFatal, die, gitStatusPorcelainZ;
+var log, ok, warn, fail, item, NomadFatal, PROCESS_EXIT_BRAND, ProcessExit, die, gitStatusPorcelainZ;
 var init_utils = __esm({
   "src/utils.ts"() {
     "use strict";
     init_color();
+    init_exit_codes();
     log = (msg) => console.log(`${dim(infoGlyph)} ${msg}`);
     ok = (msg) => console.log(`${green(okGlyph)} ${msg}`);
     warn = (msg) => {
@@ -229,13 +258,25 @@ var init_utils = __esm({
     };
     item = (msg) => console.log(dim(`  ${msg}`));
     NomadFatal = class extends Error {
-      constructor(message) {
+      code;
+      constructor(message, opts = {}) {
         super(message);
         this.name = "NomadFatal";
+        this.code = opts.code ?? EXIT.GENERIC_FAILURE;
       }
     };
-    die = (msg) => {
-      throw new NomadFatal(msg);
+    PROCESS_EXIT_BRAND = /* @__PURE__ */ Symbol.for("claude-nomad.ProcessExit");
+    ProcessExit = class extends Error {
+      code;
+      [PROCESS_EXIT_BRAND] = true;
+      constructor(code) {
+        super(`exit:${String(code)}`);
+        this.name = "ProcessExit";
+        this.code = code;
+      }
+    };
+    die = (msg, opts = {}) => {
+      throw new NomadFatal(msg, opts);
     };
     gitStatusPorcelainZ = (cwd, opts = {}) => {
       const args = ["status", "--porcelain=v1", "-z"];
@@ -459,6 +500,9 @@ function repoHome() {
 function backupBase() {
   return join(home(), ".cache", "claude-nomad", "backup");
 }
+function crashDir() {
+  return join(home(), ".cache", "claude-nomad", "crash");
+}
 function manifestPath() {
   return join(home(), ".cache", "claude-nomad", `push-manifest-${encodeURIComponent(HOST)}.json`);
 }
@@ -957,7 +1001,7 @@ function wedgePreflight(wedge) {
 }
 function rebaseBeforePush(repo) {
   const wedge = classifyWedge(repo);
-  if (wedge !== null) throw new NomadFatal(wedgePreflight(wedge));
+  if (wedge !== null) throw new NomadFatal(wedgePreflight(wedge), { code: EXIT.CONFLICT });
   try {
     execFileSync4("git", ["pull", "--rebase", "--autostash"], {
       cwd: repo,
@@ -976,6 +1020,7 @@ var init_push_checks = __esm({
     "use strict";
     init_push_gitleaks_config();
     init_commands_pull_wedge();
+    init_exit_codes();
     init_utils();
   }
 });
@@ -1030,7 +1075,7 @@ function scanStagedTree(repoDir, forwardStreams = false) {
     rmSync8(reportPath, { force: true });
   }
 }
-function scanFile(filePath, forwardStreams = false) {
+function scanFile(filePath, forwardStreams = false, timeoutMs = GITLEAKS_SCAN_TIMEOUT_MS) {
   const cacheDir = join23(homedir3(), ".cache", "claude-nomad");
   mkdirSync3(cacheDir, { recursive: true });
   const reportPath = join23(cacheDir, `gitleaks-file-${nowTimestamp()}-${process.pid}.json`);
@@ -1046,7 +1091,7 @@ function scanFile(filePath, forwardStreams = false) {
   if (toml !== null) args.push("--config", toml);
   const opts = {
     stdio: ["ignore", "pipe", "pipe"],
-    timeout: GITLEAKS_SCAN_TIMEOUT_MS
+    timeout: timeoutMs
   };
   try {
     execFileSync8("gitleaks", args, opts);
@@ -1166,6 +1211,7 @@ var init_push_gitleaks = __esm({
   "src/push-gitleaks.ts"() {
     "use strict";
     init_config();
+    init_exit_codes();
     init_push_checks();
     init_push_gitleaks_scan();
     init_utils();
@@ -1686,12 +1732,12 @@ function* eachExtrasTarget(v, counts) {
       counts.unmapped++;
       continue;
     }
-    for (const dirname10 of dirnames) {
-      if (!whitelist.includes(dirname10)) {
+    for (const dirname13 of dirnames) {
+      if (!whitelist.includes(dirname13)) {
         counts.skipped++;
         continue;
       }
-      yield { logical, localRoot, dirname: dirname10 };
+      yield { logical, localRoot, dirname: dirname13 };
     }
   }
 }
@@ -1729,8 +1775,8 @@ function copyExtrasFileSkipDiverged(src, dst) {
   }
   copyExtras(src, dst);
 }
-function extrasDenySet(dirname10) {
-  return dirname10 === ".claude" ? CLAUDE_EXTRA_NEVER_SYNC : ALWAYS_NEVER_SYNC;
+function extrasDenySet(dirname13) {
+  return dirname13 === ".claude" ? CLAUDE_EXTRA_NEVER_SYNC : ALWAYS_NEVER_SYNC;
 }
 function copyExtrasFiltered(src, dst, blockSet) {
   rmSync2(dst, { recursive: true, force: true });
@@ -2024,7 +2070,7 @@ function cmdAdopt(name, opts = {}) {
   } catch (err) {
     if (!(err instanceof NomadFatal)) throw err;
     fail(err.message);
-    process.exitCode = 1;
+    process.exitCode = err.code;
   }
 }
 
@@ -2107,6 +2153,7 @@ function appendGitleaksIgnore(fingerprint, repo) {
 }
 
 // src/commands.allow.ts
+init_exit_codes();
 init_utils();
 function cmdAllow(fingerprints) {
   const repo = repoHome();
@@ -2115,7 +2162,7 @@ function cmdAllow(fingerprints) {
     if (!isValidFingerprint(fp)) {
       const shown = fp.replaceAll("\r", String.raw`\r`).replaceAll("\n", String.raw`\n`);
       fail(`invalid fingerprint: ${shown}`);
-      process.exit(1);
+      process.exit(EXIT.USAGE);
     }
   }
   for (const fp of fingerprints) {
@@ -2324,6 +2371,7 @@ async function cmdCaptureSettings(opts) {
 
 // src/commands.clean.ts
 init_config();
+init_exit_codes();
 init_utils();
 import { existsSync as existsSync8, lstatSync as lstatSync6, readdirSync as readdirSync3, rmSync as rmSync5, statSync as statSync2 } from "node:fs";
 import { join as join10 } from "node:path";
@@ -2364,14 +2412,14 @@ function cmdClean(opts, backupBase2 = backupBase()) {
   const { dryRun, olderThan, keep } = opts;
   if (olderThan !== void 0 && keep !== void 0) {
     fail("--older-than and --keep are mutually exclusive");
-    process.exit(1);
+    process.exit(EXIT.USAGE);
   }
   let olderThanMs = CLEAN_DEFAULT_OLDER_THAN_MS;
   if (olderThan !== void 0) {
     const parsed = parseDuration(olderThan);
     if (parsed === null) {
       fail(`invalid --older-than duration: ${olderThan} (expected e.g. 14d, 24h, 30m)`);
-      process.exit(1);
+      process.exit(EXIT.USAGE);
     }
     olderThanMs = parsed;
   }
@@ -2558,8 +2606,8 @@ function cmdEject(opts = {}, roots = defaultEjectRoots()) {
 }
 
 // src/commands.doctor.ts
-import { existsSync as existsSync34 } from "node:fs";
-import { join as join40 } from "node:path";
+import { existsSync as existsSync36 } from "node:fs";
+import { join as join45 } from "node:path";
 
 // src/commands.doctor.checks.repo.ts
 init_color();
@@ -3406,20 +3454,117 @@ function reportCheckSchema(section2) {
 
 // src/commands.doctor.check-shared.ts
 init_color();
-import { randomBytes } from "node:crypto";
+import { randomBytes as randomBytes3 } from "node:crypto";
+import { execFileSync as execFileSync11 } from "node:child_process";
+import { existsSync as existsSync22, mkdirSync as mkdirSync8, readdirSync as readdirSync11, rmSync as rmSync12 } from "node:fs";
+import { homedir as homedir6 } from "node:os";
+import { join as join29 } from "node:path";
+
+// src/commands.doctor.check-shared.memory.ts
+init_color();
 import { execFileSync as execFileSync9 } from "node:child_process";
-import { existsSync as existsSync22, mkdirSync as mkdirSync6, readdirSync as readdirSync11, rmSync as rmSync10 } from "node:fs";
+import { randomBytes } from "node:crypto";
+import { mkdirSync as mkdirSync4, rmSync as rmSync9, writeFileSync as writeFileSync4 } from "node:fs";
 import { homedir as homedir4 } from "node:os";
-import { join as join27 } from "node:path";
+import { dirname as dirname3, join as join24 } from "node:path";
+init_config();
+init_push_gitleaks();
+init_utils_fs();
+var MEMORY_MD_PATH = /^shared\/projects\/([^/]+)\/memory\/[^/]+\.md$/;
+function buildMemoryScanTree(tmpRoot) {
+  let paths;
+  try {
+    const out = execFileSync9(
+      "git",
+      ["-C", repoHome(), "ls-tree", "-r", "-z", "--name-only", "HEAD", "--", "shared/projects"],
+      { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 1e4 }
+    );
+    paths = out.split("\0").filter((p) => p.length > 0);
+  } catch {
+    return 0;
+  }
+  const logicals = /* @__PURE__ */ new Set();
+  for (const rel of paths) {
+    const m = MEMORY_MD_PATH.exec(rel);
+    if (m?.[1] === void 0) continue;
+    let blob;
+    try {
+      blob = execFileSync9("git", ["-C", repoHome(), "cat-file", "blob", `HEAD:${rel}`], {
+        stdio: ["ignore", "pipe", "ignore"],
+        maxBuffer: 67108864,
+        timeout: 1e4
+      });
+    } catch {
+      continue;
+    }
+    const dest = join24(tmpRoot, rel);
+    mkdirSync4(dirname3(dest), { recursive: true });
+    writeFileSync4(dest, blob);
+    logicals.add(m[1]);
+  }
+  return logicals.size;
+}
+function reportMemoryFindings(section2, findings) {
+  for (const f of findings) {
+    addItem(section2, `${yellow(warnGlyph)} ${f.RuleID} in ${f.File}`);
+  }
+  addItem(
+    section2,
+    `  ${dim("run `nomad push` and choose Redact in the recovery menu to scrub these")}`
+  );
+}
+function reportCommittedMemory(section2) {
+  let tmpRoot;
+  try {
+    const cacheDir = join24(homedir4(), ".cache", "claude-nomad");
+    mkdirSync4(cacheDir, { recursive: true });
+    const stamp = `${nowTimestamp()}-${process.pid}-${randomBytes(4).toString("hex")}`;
+    tmpRoot = join24(cacheDir, `check-shared-memory-tree-${stamp}`);
+    mkdirSync4(tmpRoot, { recursive: true, mode: 448 });
+    const staged = buildMemoryScanTree(tmpRoot);
+    if (staged === 0) return;
+    let findings;
+    try {
+      findings = scanStagedTree(tmpRoot);
+    } catch (err) {
+      addItem(
+        section2,
+        `${yellow(warnGlyph)} committed-memory scan skipped: ${err.message}`
+      );
+      return;
+    }
+    if (findings === null) {
+      addItem(
+        section2,
+        `${yellow(warnGlyph)} committed-memory scan skipped: no parseable gitleaks report`
+      );
+      return;
+    }
+    if (findings.length === 0) return;
+    reportMemoryFindings(section2, findings);
+  } catch (err) {
+    addItem(
+      section2,
+      `${yellow(warnGlyph)} committed-memory scan skipped: ${err.message}`
+    );
+  } finally {
+    if (tmpRoot !== void 0) {
+      try {
+        rmSync9(tmpRoot, { recursive: true, force: true });
+      } catch {
+      }
+    }
+  }
+}
 
 // src/commands.doctor.check-shared.scan.ts
 init_color();
-import { join as join24 } from "node:path";
+import { join as join25 } from "node:path";
 init_config();
 init_push_gitleaks();
 function scrubPath(logical, sid, logicalToEncoded) {
   const encoded = logicalToEncoded.get(logical) ?? logical;
-  return join24(claudeHome(), "projects", encoded, `${sid}.jsonl`);
+  return join25(claudeHome(), "projects", encoded, `${sid}.jsonl`);
 }
 function reportSessionFindings(section2, bySession) {
   for (const [sid, counts] of bySession) {
@@ -3502,13 +3647,123 @@ function scanAndReport(section2, tmpRoot, staged, logicalToEncoded) {
   emitDescriptionLegend(section2, findings);
 }
 
+// src/commands.doctor.check-shared.skills.ts
+init_color();
+import { execFileSync as execFileSync10 } from "node:child_process";
+import { randomBytes as randomBytes2 } from "node:crypto";
+import { mkdirSync as mkdirSync5, rmSync as rmSync10, writeFileSync as writeFileSync5 } from "node:fs";
+import { homedir as homedir5 } from "node:os";
+import { dirname as dirname4, join as join26 } from "node:path";
+init_config();
+init_push_gitleaks();
+init_utils_fs();
+var SKILL_PATH = /^shared\/skills\/([^/]+)\/(.+)$/;
+function buildSkillScanTree(tmpRoot) {
+  let paths;
+  try {
+    const out = execFileSync10(
+      "git",
+      ["-C", repoHome(), "ls-tree", "-r", "-z", "--name-only", "HEAD", "--", "shared/skills"],
+      { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 1e4 }
+    );
+    paths = out.split("\0").filter((p) => p.length > 0);
+  } catch {
+    return { staged: 0, incomplete: false };
+  }
+  const names = /* @__PURE__ */ new Set();
+  let incomplete = false;
+  for (const rel of paths) {
+    const m = SKILL_PATH.exec(rel);
+    if (m?.[1] === void 0) continue;
+    let blob;
+    try {
+      blob = execFileSync10("git", ["-C", repoHome(), "cat-file", "blob", `HEAD:${rel}`], {
+        stdio: ["ignore", "pipe", "ignore"],
+        maxBuffer: 67108864,
+        timeout: 1e4
+      });
+    } catch {
+      incomplete = true;
+      continue;
+    }
+    const dest = join26(tmpRoot, rel);
+    mkdirSync5(dirname4(dest), { recursive: true });
+    writeFileSync5(dest, blob);
+    names.add(m[1]);
+  }
+  return { staged: names.size, incomplete };
+}
+function reportSkillFindings(section2, findings) {
+  for (const f of findings) {
+    addItem(section2, `${yellow(warnGlyph)} ${f.RuleID} in ${f.File}`);
+  }
+  addItem(
+    section2,
+    `  ${dim("run `nomad push` and choose Redact in the recovery menu to scrub these")}`
+  );
+  addItem(
+    section2,
+    `  ${dim("a gsd-* skill is not auto-redactable; remove the secret from it by hand")}`
+  );
+}
+function reportCommittedSkills(section2) {
+  let tmpRoot;
+  try {
+    const cacheDir = join26(homedir5(), ".cache", "claude-nomad");
+    mkdirSync5(cacheDir, { recursive: true });
+    const stamp = `${nowTimestamp()}-${process.pid}-${randomBytes2(4).toString("hex")}`;
+    tmpRoot = join26(cacheDir, `check-shared-skills-tree-${stamp}`);
+    mkdirSync5(tmpRoot, { recursive: true, mode: 448 });
+    const { staged, incomplete } = buildSkillScanTree(tmpRoot);
+    if (incomplete) {
+      addItem(
+        section2,
+        `${yellow(warnGlyph)} committed-skills scan skipped: could not read every committed skill blob`
+      );
+      return;
+    }
+    if (staged === 0) return;
+    let findings;
+    try {
+      findings = scanStagedTree(tmpRoot);
+    } catch (err) {
+      addItem(
+        section2,
+        `${yellow(warnGlyph)} committed-skills scan skipped: ${err.message}`
+      );
+      return;
+    }
+    if (findings === null) {
+      addItem(
+        section2,
+        `${yellow(warnGlyph)} committed-skills scan skipped: no parseable gitleaks report`
+      );
+      return;
+    }
+    if (findings.length === 0) return;
+    reportSkillFindings(section2, findings);
+  } catch (err) {
+    addItem(
+      section2,
+      `${yellow(warnGlyph)} committed-skills scan skipped: ${err.message}`
+    );
+  } finally {
+    if (tmpRoot !== void 0) {
+      try {
+        rmSync10(tmpRoot, { recursive: true, force: true });
+      } catch {
+      }
+    }
+  }
+}
+
 // src/commands.doctor.check-shared.ts
 init_config();
 
 // src/remap.ts
 init_config_sharedDirs_guard();
-import { cpSync as cpSync6, existsSync as existsSync21, lstatSync as lstatSync10, mkdirSync as mkdirSync5, readdirSync as readdirSync10, rmSync as rmSync9, statSync as statSync5 } from "node:fs";
-import { dirname as dirname4, join as join26, relative as relative5, sep as sep4 } from "node:path";
+import { cpSync as cpSync6, existsSync as existsSync21, lstatSync as lstatSync10, mkdirSync as mkdirSync7, readdirSync as readdirSync10, rmSync as rmSync11, statSync as statSync5 } from "node:fs";
+import { dirname as dirname6, join as join28, relative as relative5, sep as sep4 } from "node:path";
 init_config();
 
 // src/push-manifest.ts
@@ -3516,8 +3771,8 @@ init_config();
 init_push_gitleaks_config();
 init_utils_fs();
 import { createHash } from "node:crypto";
-import { existsSync as existsSync20, mkdirSync as mkdirSync4, readdirSync as readdirSync9, readFileSync as readFileSync7, statSync as statSync4 } from "node:fs";
-import { dirname as dirname3, join as join25 } from "node:path";
+import { existsSync as existsSync20, mkdirSync as mkdirSync6, readdirSync as readdirSync9, readFileSync as readFileSync7, statSync as statSync4 } from "node:fs";
+import { dirname as dirname5, join as join27 } from "node:path";
 function isChanged(prev, cur, hash) {
   if (prev === void 0) return true;
   if (prev.size !== cur.size) return true;
@@ -3558,7 +3813,7 @@ function hashFile(absPath) {
 }
 function enumerateDir(dir, results) {
   for (const entry of readdirSync9(dir)) {
-    const fullPath = join25(dir, entry);
+    const fullPath = join27(dir, entry);
     const st = statSync4(fullPath);
     if (st.isDirectory()) {
       enumerateDir(fullPath, results);
@@ -3570,7 +3825,7 @@ function enumerateDir(dir, results) {
 function enumerateSourceFiles(projectDir) {
   const results = [];
   for (const entry of readdirSync9(projectDir)) {
-    const fullPath = join25(projectDir, entry);
+    const fullPath = join27(projectDir, entry);
     const st = statSync4(fullPath);
     if (st.isDirectory()) {
       enumerateDir(fullPath, results);
@@ -3589,8 +3844,8 @@ function computeConfigHash() {
   const repo = repoHome();
   const parts = [
     fileIdentity(resolveTomlPath(repo)),
-    fileIdentity(join25(repo, ".gitleaks.overlay.toml")),
-    fileIdentity(join25(repo, ".gitleaksignore"))
+    fileIdentity(join27(repo, ".gitleaks.overlay.toml")),
+    fileIdentity(join27(repo, ".gitleaksignore"))
   ];
   return createHash("sha256").update(parts.join("\n")).digest("hex");
 }
@@ -3610,7 +3865,7 @@ function readManifest(path) {
   }
 }
 function writeManifest(path, manifest) {
-  mkdirSync4(dirname3(path), { recursive: true });
+  mkdirSync6(dirname5(path), { recursive: true });
   writeJsonAtomic(path, manifest);
 }
 function buildManifest(files, scannerVersion, configHash) {
@@ -3624,9 +3879,9 @@ init_utils_json();
 var TMP_SUFFIX = ".nomad-tmp";
 function atomicMirror(src, dst, options) {
   const tmp = `${dst}${TMP_SUFFIX}`;
-  rmSync9(tmp, { recursive: true, force: true });
+  rmSync11(tmp, { recursive: true, force: true });
   cpSync6(src, tmp, options);
-  rmSync9(dst, { recursive: true, force: true });
+  rmSync11(dst, { recursive: true, force: true });
   renameAtomicRetry(tmp, dst);
 }
 function overlaySessionDir(src, dst) {
@@ -3634,7 +3889,7 @@ function overlaySessionDir(src, dst) {
   cpSyncGuarded(src, dst, void 0, "overlaySessionDir");
 }
 function copyFileAtomic(src, dst) {
-  mkdirSync5(dirname4(dst), { recursive: true });
+  mkdirSync7(dirname6(dst), { recursive: true });
   const tmp = `${dst}.tmp.${process.pid}`;
   cpSync6(src, tmp, { force: true, preserveTimestamps: true });
   renameAtomicRetry(tmp, dst);
@@ -3652,12 +3907,12 @@ function applySelective(sel, localDir, repoDst) {
   const prefix = `${localDir}${sep4}`;
   for (const src of sel.changed) {
     if (!src.startsWith(prefix)) continue;
-    copyFileAtomic(src, join26(repoDst, relative5(localDir, src)));
+    copyFileAtomic(src, join28(repoDst, relative5(localDir, src)));
   }
   for (const src of sel.deleted) {
     if (!src.startsWith(prefix)) continue;
-    const dst = join26(repoDst, relative5(localDir, src));
-    if (existsSync21(dst)) rmSync9(dst);
+    const dst = join28(repoDst, relative5(localDir, src));
+    if (existsSync21(dst)) rmSync11(dst);
   }
 }
 function copyDirJsonlOnly(src, dst) {
@@ -3686,16 +3941,16 @@ function remapPull(ts, opts = {}) {
   const wouldPull = [];
   const repo = repoHome();
   const claude = claudeHome();
-  const mapPath = join26(repo, "path-map.json");
-  const repoProjects = join26(repo, "shared", "projects");
+  const mapPath = join28(repo, "path-map.json");
+  const repoProjects = join28(repo, "shared", "projects");
   if (!existsSync21(mapPath) || !existsSync21(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 = join26(claude, "projects");
-  if (!dryRun) mkdirSync5(localProjects, { recursive: true });
+  const localProjects = join28(claude, "projects");
+  if (!dryRun) mkdirSync7(localProjects, { recursive: true });
   for (const [logical, hosts] of Object.entries(map.projects)) {
     assertSafeLogical(logical);
     const localPath = hosts[HOST];
@@ -3704,9 +3959,9 @@ function remapPull(ts, opts = {}) {
       continue;
     }
     assertSafeLocalRoot(localPath, logical);
-    const src = join26(repoProjects, logical);
+    const src = join28(repoProjects, logical);
     if (!existsSync21(src)) continue;
-    const dst = join26(localProjects, encodePath(localPath));
+    const dst = join28(localProjects, encodePath(localPath));
     if (dryRun) {
       wouldPull.push(logical);
       emitPreview(
@@ -3725,8 +3980,8 @@ function remapPull(ts, opts = {}) {
 function countLocalOnly(src, dst) {
   let count = 0;
   for (const name of readdirSync10(dst)) {
-    const dstPath = join26(dst, name);
-    const srcPath = join26(src, name);
+    const dstPath = join28(dst, name);
+    const srcPath = join28(src, name);
     if (lstatSync10(dstPath).isDirectory()) {
       count += countLocalOnly(srcPath, dstPath);
     } else if (lstatSync10(srcPath, { throwIfNoEntry: false }) === void 0) {
@@ -3738,20 +3993,20 @@ function countLocalOnly(src, dst) {
 function scanLocalOnly() {
   const repo = repoHome();
   const claude = claudeHome();
-  const mapPath = join26(repo, "path-map.json");
-  const repoProjects = join26(repo, "shared", "projects");
+  const mapPath = join28(repo, "path-map.json");
+  const repoProjects = join28(repo, "shared", "projects");
   if (!existsSync21(mapPath) || !existsSync21(repoProjects)) return 0;
   const map = readPathMap(mapPath);
-  const localProjects = join26(claude, "projects");
+  const localProjects = join28(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 = join26(localProjects, encodePath(localPath));
+    const dst = join28(localProjects, encodePath(localPath));
     if (!existsSync21(dst)) continue;
-    count += countLocalOnly(join26(repoProjects, logical), dst);
+    count += countLocalOnly(join28(repoProjects, logical), dst);
   }
   return count;
 }
@@ -3786,17 +4041,17 @@ function remapPush(ts, opts = {}) {
   const wouldPush = [];
   const repo = repoHome();
   const claude = claudeHome();
-  const mapPath = join26(repo, "path-map.json");
+  const mapPath = join28(repo, "path-map.json");
   if (!existsSync21(mapPath)) {
     log("no path-map.json; skipping session export");
     return { unmapped: 0, collisions: 0, pushed, wouldPush };
   }
   const map = readPathMap(mapPath);
-  const localProjects = join26(claude, "projects");
-  const repoProjects = join26(repo, "shared", "projects");
+  const localProjects = join28(claude, "projects");
+  const repoProjects = join28(repo, "shared", "projects");
   const reverse = buildReverseMap(map);
   if (!existsSync21(localProjects)) return { unmapped, collisions: 0, pushed, wouldPush };
-  if (!dryRun) mkdirSync5(repoProjects, { recursive: true });
+  if (!dryRun) mkdirSync7(repoProjects, { recursive: true });
   for (const dir of readdirSync10(localProjects)) {
     if (dir.endsWith(TMP_SUFFIX)) continue;
     const logical = reverse.get(dir);
@@ -3804,8 +4059,8 @@ function remapPush(ts, opts = {}) {
       unmapped++;
       continue;
     }
-    const localDir = join26(localProjects, dir);
-    const repoDst = join26(repoProjects, logical);
+    const localDir = join28(localProjects, dir);
+    const repoDst = join28(repoProjects, logical);
     if (skipForSelection(opts.selection, localDir)) continue;
     if (dryRun) {
       wouldPush.push(logical);
@@ -3829,7 +4084,7 @@ function buildScanTree(tmpRoot) {
   const logicalToEncoded = /* @__PURE__ */ new Map();
   let staged = 0;
   const repo = repoHome();
-  const mapPath = join27(repo, "path-map.json");
+  const mapPath = join29(repo, "path-map.json");
   if (!existsSync22(mapPath)) return { logicalToEncoded, staged, malformed: false };
   let map;
   try {
@@ -3847,12 +4102,12 @@ function buildScanTree(tmpRoot) {
     if (!p || p === "TBD") continue;
     reverse.set(encodePath(p), logical);
   }
-  const localProjects = join27(claudeHome(), "projects");
+  const localProjects = join29(claudeHome(), "projects");
   if (!existsSync22(localProjects)) return { logicalToEncoded, staged, malformed: false };
   for (const dir of readdirSync11(localProjects)) {
     const logical = reverse.get(dir);
     if (!logical) continue;
-    copyDirJsonlOnly(join27(localProjects, dir), join27(tmpRoot, "shared", "projects", logical));
+    copyDirJsonlOnly(join29(localProjects, dir), join29(tmpRoot, "shared", "projects", logical));
     logicalToEncoded.set(logical, dir);
     staged++;
   }
@@ -3860,7 +4115,7 @@ function buildScanTree(tmpRoot) {
 }
 function probeGitleaksForScan() {
   try {
-    execFileSync9("gitleaks", ["version"], { stdio: ["ignore", "pipe", "pipe"] });
+    execFileSync11("gitleaks", ["version"], { stdio: ["ignore", "pipe", "pipe"] });
     return "ok";
   } catch (err) {
     if (err.code === "ENOENT") return "missing";
@@ -3881,13 +4136,12 @@ function ensureGitleaksReady(section2, gitleaksReady) {
   }
   return true;
 }
-function reportCheckShared(section2, gitleaksReady) {
-  if (!ensureGitleaksReady(section2, gitleaksReady)) return;
-  const cacheDir = join27(homedir4(), ".cache", "claude-nomad");
-  mkdirSync6(cacheDir, { recursive: true });
-  const stamp = `${nowTimestamp()}-${process.pid}-${randomBytes(4).toString("hex")}`;
-  const reportPath = join27(cacheDir, `check-shared-${stamp}.json`);
-  const tmpRoot = join27(cacheDir, `check-shared-tree-${stamp}`);
+function runLocalPreviewScan(section2) {
+  const cacheDir = join29(homedir6(), ".cache", "claude-nomad");
+  mkdirSync8(cacheDir, { recursive: true });
+  const stamp = `${nowTimestamp()}-${process.pid}-${randomBytes3(4).toString("hex")}`;
+  const reportPath = join29(cacheDir, `check-shared-${stamp}.json`);
+  const tmpRoot = join29(cacheDir, `check-shared-tree-${stamp}`);
   try {
     const { logicalToEncoded, staged, malformed } = buildScanTree(tmpRoot);
     if (malformed) {
@@ -3901,15 +4155,27 @@ function reportCheckShared(section2, gitleaksReady) {
     }
     scanAndReport(section2, tmpRoot, staged, logicalToEncoded);
   } finally {
-    rmSync10(reportPath, { force: true });
-    rmSync10(tmpRoot, { recursive: true, force: true });
+    rmSync12(reportPath, { force: true });
+    rmSync12(tmpRoot, { recursive: true, force: true });
+  }
+}
+function reportCheckShared(section2, gitleaksReady) {
+  if (!ensureGitleaksReady(section2, gitleaksReady)) return;
+  try {
+    runLocalPreviewScan(section2);
+  } catch (err) {
+    addItem(section2, `${red(failGlyph)} shared scan failed: ${err.message}`);
+    process.exitCode = 1;
+  } finally {
+    reportCommittedMemory(section2);
+    reportCommittedSkills(section2);
   }
 }
 
 // src/commands.doctor.checks.hooks.scope.ts
 init_color();
 import { existsSync as existsSync23, readFileSync as readFileSync8, readdirSync as readdirSync12, realpathSync as realpathSync2 } from "node:fs";
-import { dirname as dirname5, extname, join as join28 } from "node:path";
+import { dirname as dirname7, extname, join as join30 } from "node:path";
 init_config();
 function typeFromPackageJson(pkgPath) {
   try {
@@ -3929,11 +4195,11 @@ function effectiveType(hookPath) {
   } catch {
     return null;
   }
-  let dir = dirname5(real);
+  let dir = dirname7(real);
   for (; ; ) {
-    const pkg = join28(dir, "package.json");
+    const pkg = join30(dir, "package.json");
     if (existsSync23(pkg)) return typeFromPackageJson(pkg);
-    const parent = dirname5(dir);
+    const parent = dirname7(dir);
     if (parent === dir) return "cjs";
     dir = parent;
   }
@@ -3974,7 +4240,7 @@ function safeRead(path) {
   }
 }
 function reportHookScopeCheck(section2) {
-  const hooksDir = join28(claudeHome(), "hooks");
+  const hooksDir = join30(claudeHome(), "hooks");
   if (!existsSync23(hooksDir)) {
     addItem(section2, `${dim(infoGlyph)} no ~/.claude/hooks; skipping module-scope check`);
     return;
@@ -3982,7 +4248,7 @@ function reportHookScopeCheck(section2) {
   let anyWarn = false;
   for (const name of safeReaddir2(hooksDir)) {
     if (extname(name) !== ".js") continue;
-    const abs = join28(hooksDir, name);
+    const abs = join30(hooksDir, name);
     const eff = effectiveType(abs);
     if (eff === null) continue;
     const src = safeRead(abs);
@@ -4003,7 +4269,7 @@ function reportHookScopeCheck(section2) {
 // src/commands.doctor.checks.hooks.ts
 init_color();
 import { existsSync as existsSync24 } from "node:fs";
-import { join as join29 } from "node:path";
+import { join as join31 } from "node:path";
 init_config();
 function expandHome(token) {
   const h2 = home();
@@ -4059,7 +4325,7 @@ function checkEventGroups(section2, event, groups) {
   return anyFail;
 }
 function reportHooksTargetCheck(section2) {
-  const settingsPath = join29(claudeHome(), "settings.json");
+  const settingsPath = join31(claudeHome(), "settings.json");
   if (!existsSync24(settingsPath)) {
     addItem(section2, `${dim(infoGlyph)} no ~/.claude/settings.json; skipping hook target check`);
     return;
@@ -4084,11 +4350,11 @@ function reportHooksTargetCheck(section2) {
 // src/commands.doctor.checks.hooks.preserve-symlinks.ts
 init_color();
 import { existsSync as existsSync26, readFileSync as readFileSync9 } from "node:fs";
-import { join as join31 } from "node:path";
+import { join as join33 } from "node:path";
 
 // src/commands.doctor.checks.hooks.preserve-symlinks.probe.ts
 import { closeSync as closeSync3, existsSync as existsSync25, openSync as openSync3, readSync, realpathSync as realpathSync3 } from "node:fs";
-import { dirname as dirname6, join as join30, resolve as resolve2 } from "node:path";
+import { dirname as dirname8, join as join32, resolve as resolve2 } from "node:path";
 function suppressedRanges(src) {
   const ranges = [];
   const re = /\/\*[\s\S]*?\*\/|\/\/[^\n]*|'[^']*'|"[^"]*"|`[^`]*`/g;
@@ -4125,7 +4391,7 @@ function specifierIsMissing(specifier, baseDir) {
     if (existsSync25(base + ext)) return false;
   }
   for (const idx of ["index.js", "index.cjs", "index.mjs"]) {
-    if (existsSync25(join30(base, idx))) return false;
+    if (existsSync25(join32(base, idx))) return false;
   }
   return true;
 }
@@ -4151,7 +4417,7 @@ function relativeRequireTargetsBroken(scriptPath) {
   }
   const specifiers = topRelativeSpecifiers(raw);
   if (specifiers.length === 0) return false;
-  const baseDir = dirname6(realPath);
+  const baseDir = dirname8(realPath);
   for (const spec of specifiers) {
     if (specifierIsMissing(spec, baseDir)) return true;
   }
@@ -4180,7 +4446,7 @@ function commandTokens(command) {
   return tokens;
 }
 function readPathMapSafe() {
-  const mapPath = join31(repoHome(), "path-map.json");
+  const mapPath = join33(repoHome(), "path-map.json");
   if (!existsSync26(mapPath)) return { projects: {} };
   try {
     return JSON.parse(readFileSync9(mapPath, "utf8"));
@@ -4255,7 +4521,7 @@ function checkEventForPreserveSymlinks(section2, event, groups, sharedLinkNames)
   return anyWarn;
 }
 function reportPreserveSymlinksCheck(section2) {
-  const settingsPath = join31(claudeHome(), "settings.json");
+  const settingsPath = join33(claudeHome(), "settings.json");
   if (!existsSync26(settingsPath)) {
     addItem(
       section2,
@@ -4290,7 +4556,7 @@ function reportPreserveSymlinksCheck(section2) {
 // src/commands.doctor.checks.settings-drift.ts
 init_color();
 import { existsSync as existsSync27, readFileSync as readFileSync10 } from "node:fs";
-import { join as join32 } from "node:path";
+import { join as join34 } from "node:path";
 init_config();
 init_utils_json();
 function diffMergedSettings(merged, settings) {
@@ -4308,7 +4574,7 @@ function tryReadJson(filePath) {
   }
 }
 function reportHooksBaseSelfCleanNote(section2) {
-  const basePath = join32(repoHome(), "shared", "settings.base.json");
+  const basePath = join34(repoHome(), "shared", "settings.base.json");
   const base = tryReadJson(basePath);
   if (base === null) return;
   if (!baseHasGsdHookEntries(base)) return;
@@ -4321,9 +4587,9 @@ function reportSettingsDriftCheck(section2) {
   const claude = claudeHome();
   const repo = repoHome();
   const host = HOST;
-  const settingsPath = join32(claude, "settings.json");
-  const basePath = join32(repo, "shared", "settings.base.json");
-  const hostPath = join32(repo, "hosts", `${host}.json`);
+  const settingsPath = join34(claude, "settings.json");
+  const basePath = join34(repo, "shared", "settings.base.json");
+  const hostPath = join34(repo, "hosts", `${host}.json`);
   if (!existsSync27(settingsPath)) {
     addItem(section2, `${dim(infoGlyph)} no ~/.claude/settings.json; skipping merge-drift check`);
     return;
@@ -4505,7 +4771,7 @@ function reportNodeEngineCheck(section2) {
 
 // src/commands.doctor.checks.longpaths.ts
 init_color();
-import { execFileSync as execFileSync10 } from "node:child_process";
+import { execFileSync as execFileSync12 } from "node:child_process";
 init_config();
 var PROBE_TIMEOUT_MS = 3e3;
 var LONGPATHS_REG_KEY = String.raw`HKLM\SYSTEM\CurrentControlSet\Control\FileSystem`;
@@ -4539,7 +4805,7 @@ function addLongpathsRow(section2, label, enabled2, remediation) {
   }
   addItem(section2, `${yellow(warnGlyph)} ${label}: not enabled (${remediation})`);
 }
-function reportLongPathsCheck(section2, run = execFileSync10) {
+function reportLongPathsCheck(section2, run = execFileSync12) {
   if (process.platform !== "win32") return;
   addLongpathsRow(
     section2,
@@ -4561,15 +4827,15 @@ function reportSyncModality(section2) {
 
 // src/commands.doctor.checks.crlf.ts
 init_color();
-import { execFileSync as execFileSync11 } from "node:child_process";
+import { execFileSync as execFileSync13 } from "node:child_process";
 import { existsSync as existsSync28, readFileSync as readFileSync13 } from "node:fs";
-import { join as join33 } from "node:path";
+import { join as join35 } from "node:path";
 init_config();
 var PROBE_TIMEOUT_MS2 = 3e3;
 var GUARD_LINE = /^\*\s+-text\b/;
 function hasGitattributesGuard(repo) {
   try {
-    const path = join33(repo, ".gitattributes");
+    const path = join35(repo, ".gitattributes");
     if (!existsSync28(path)) return false;
     const content = readFileSync13(path, "utf8");
     return content.split("\n").map((line) => line.trim()).some((line) => line !== "" && !line.startsWith("#") && GUARD_LINE.test(line));
@@ -4600,7 +4866,7 @@ function addExposedRow(section2, repo, verdict) {
   const remediation = `add a .gitattributes with a \`* -text\` line, or run \`git config core.autocrlf false\`, in ${repo}`;
   addItem(section2, `${yellow(warnGlyph)} CRLF guard: ${risk}; ${remediation}`);
 }
-function reportCrlfGuardCheck(section2, run = execFileSync11) {
+function reportCrlfGuardCheck(section2, run = execFileSync13) {
   const repo = repoHome();
   if (hasGitattributesGuard(repo)) {
     addItem(section2, `${green(okGlyph)} CRLF guard: .gitattributes (* -text) present`);
@@ -4611,35 +4877,35 @@ function reportCrlfGuardCheck(section2, run = execFileSync11) {
 
 // src/spinner.ts
 init_color();
-import { existsSync as existsSync32 } from "node:fs";
+import { existsSync as existsSync34 } from "node:fs";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 import { Worker } from "node:worker_threads";
 
 // src/commands.push.recovery.ts
 init_config();
-import { readFileSync as readFileSync16, rmSync as rmSync12, writeFileSync as writeFileSync5 } from "node:fs";
-import { join as join38 } from "node:path";
+import { readFileSync as readFileSync18, rmSync as rmSync15, writeFileSync as writeFileSync9 } from "node:fs";
+import { join as join43 } from "node:path";
 import { createInterface as createInterface2 } from "node:readline/promises";
 
 // src/commands.push.recovery.actions.ts
 init_config();
-import { readFileSync as readFileSync15 } from "node:fs";
-import { isAbsolute as isAbsolute2, resolve as resolve3, sep as sep6 } from "node:path";
+import { readFileSync as readFileSync17 } from "node:fs";
+import { isAbsolute as isAbsolute2, resolve as resolve3, sep as sep7 } from "node:path";
 
 // src/commands.push.recovery.redact.ts
 init_config();
 init_config_sharedDirs_guard();
-import { cpSync as cpSync7, existsSync as existsSync31, mkdirSync as mkdirSync7, statSync as statSync8 } from "node:fs";
-import { dirname as dirname8, join as join36, sep as sep5 } from "node:path";
+import { cpSync as cpSync8, existsSync as existsSync32, mkdirSync as mkdirSync10, statSync as statSync8 } from "node:fs";
+import { dirname as dirname10, join as join39, sep as sep5 } from "node:path";
 
 // src/commands.redact.ts
 init_config();
 import { existsSync as existsSync30, statSync as statSync7 } from "node:fs";
-import { dirname as dirname7, join as join35 } from "node:path";
+import { dirname as dirname9, join as join37 } from "node:path";
 
 // src/commands.redact.subtree.ts
-import { existsSync as existsSync29, lstatSync as lstatSync11, readFileSync as readFileSync14, readdirSync as readdirSync13, statSync as statSync6, writeFileSync as writeFileSync4 } from "node:fs";
-import { join as join34 } from "node:path";
+import { existsSync as existsSync29, lstatSync as lstatSync11, readFileSync as readFileSync14, readdirSync as readdirSync13, statSync as statSync6, writeFileSync as writeFileSync6 } from "node:fs";
+import { join as join36 } from "node:path";
 init_utils_fs();
 init_utils();
 function collectFiles(dir, out) {
@@ -4647,7 +4913,7 @@ function collectFiles(dir, out) {
   const st = lstatSync11(dir);
   if (!st.isDirectory()) return;
   for (const entry of readdirSync13(dir)) {
-    const abs = join34(dir, entry);
+    const abs = join36(dir, entry);
     const lst = lstatSync11(abs);
     if (lst.isSymbolicLink()) continue;
     if (lst.isDirectory()) {
@@ -4691,7 +4957,7 @@ function applySubtreeRedactions(mainPath, mainFindings, subtreeFiles, rule, ts,
           `warning: no redaction applied to ${filePath}: finding match values were not located in the file. Inspect it manually; the push re-scan still blocks a real leak.`
         );
       }
-      writeFileSync4(filePath, after, "utf8");
+      writeFileSync6(filePath, after, "utf8");
     }
   }
   return { total, dirty };
@@ -4699,10 +4965,10 @@ function applySubtreeRedactions(mainPath, mainFindings, subtreeFiles, rule, ts,
 
 // src/commands.pushed-history.ts
 init_utils();
-import { execFileSync as execFileSync12 } from "node:child_process";
+import { execFileSync as execFileSync14 } from "node:child_process";
 function pushedRef(repo) {
   try {
-    const ref = execFileSync12("git", ["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}"], {
+    const ref = execFileSync14("git", ["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}"], {
       cwd: repo,
       stdio: ["ignore", "pipe", "ignore"]
     }).toString().trim();
@@ -4715,7 +4981,7 @@ function sessionInPushedHistory(id, repo) {
   const ref = pushedRef(repo);
   if (ref === null) return false;
   try {
-    const out = execFileSync12(
+    const out = execFileSync14(
       "git",
       [
         "log",
@@ -4747,19 +5013,20 @@ function warnIfSessionPushed(id, repo) {
 
 // src/commands.redact.ts
 init_push_gitleaks_scan();
+init_exit_codes();
 init_utils_fs();
 init_utils_json();
 init_utils();
 function resolveLiveTranscript(id) {
   try {
-    const mapPath = join35(repoHome(), "path-map.json");
+    const mapPath = join37(repoHome(), "path-map.json");
     if (!existsSync30(mapPath)) return null;
     const projects = readJson(mapPath).projects;
     const claude = claudeHome();
     for (const hostMap of Object.values(projects)) {
       const abs = hostMap[HOST];
       if (abs === void 0) continue;
-      const live = join35(claude, "projects", encodePath(abs), `${id}.jsonl`);
+      const live = join37(claude, "projects", encodePath(abs), `${id}.jsonl`);
       if (existsSync30(live)) return live;
     }
     return null;
@@ -4776,7 +5043,7 @@ function cmdRedact(opts, nowMs = Date.now, scan = scanFile) {
   const { id, rule, dryRun = false, findings: rawFindings } = opts;
   if (id.length === 0 || id.length > 128 || !/^[A-Za-z0-9_-]+$/.test(id)) {
     fail(`invalid session id: ${id}`);
-    process.exit(1);
+    process.exit(EXIT.USAGE);
   }
   const repo = repoHome();
   const backup = backupBase();
@@ -4790,7 +5057,7 @@ function cmdRedact(opts, nowMs = Date.now, scan = scanFile) {
       process.exitCode = 1;
       return;
     }
-    const sessionDir = join35(dirname7(localPath), id);
+    const sessionDir = join37(dirname9(localPath), id);
     const subtreeFiles = listSubtreeFiles(sessionDir);
     const subtreeMtime = newestSubtreeMtimeMs(localPath, subtreeFiles, (p) => statSync7(p).mtimeMs);
     if (isRecentlyModified(subtreeMtime, nowMs())) {
@@ -4850,6 +5117,78 @@ init_utils();
 
 // src/commands.push.recovery.seams.ts
 init_push_gitleaks();
+
+// src/commands.push.recovery.memory.ts
+init_config();
+init_config_sharedDirs_guard();
+import { cpSync as cpSync7, existsSync as existsSync31, mkdirSync as mkdirSync9, readFileSync as readFileSync15, writeFileSync as writeFileSync7 } from "node:fs";
+import { join as join38 } from "node:path";
+init_push_gitleaks_scan();
+init_utils_fs();
+init_utils_json();
+init_utils();
+var MEMORY_FINDING_PATH = /^shared\/projects\/([^/]+)\/memory\/([^/]+\.md)$/;
+var SAFE_MEMORY_FILENAME = /^[^/\\]+\.md$/;
+var MEMORY_DIR_PATH = /^shared\/projects\/[^/]+\/memory\//;
+function memoryFileFromFinding(f) {
+  const m = MEMORY_FINDING_PATH.exec(f.File);
+  if (m?.[1] === void 0 || m[2] === void 0) return null;
+  return { logical: m[1], filename: m[2] };
+}
+function isMemoryFindingPath(f) {
+  return MEMORY_DIR_PATH.test(f.File);
+}
+function resolveMemoryLocalPath(logical, filename, map) {
+  assertSafeLogical(logical);
+  if (!SAFE_MEMORY_FILENAME.test(filename) || filename.includes("..")) return null;
+  const abs = map.projects[logical]?.[HOST];
+  if (abs === void 0) return null;
+  const localPath = join38(claudeHome(), "projects", encodePath(abs), "memory", filename);
+  return existsSync31(localPath) ? localPath : null;
+}
+function preflightMemoryRedactable(f, map) {
+  const parsed = memoryFileFromFinding(f);
+  if (parsed === null) return "a finding is not a project-level memory file";
+  const localPath = resolveMemoryLocalPath(parsed.logical, parsed.filename, map);
+  if (localPath === null) {
+    return `memory file ${parsed.logical}/memory/${parsed.filename}: local file not found or unmapped`;
+  }
+  return null;
+}
+function applyMemoryRedact(f, ts, map, scan = scanFile) {
+  const refuse = (msg) => {
+    log(msg);
+    return false;
+  };
+  const parsed = memoryFileFromFinding(f);
+  if (parsed === null) {
+    return refuse("could not parse this finding as a project-level memory file; choose Skip.");
+  }
+  const { logical, filename } = parsed;
+  const localPath = resolveMemoryLocalPath(logical, filename, map);
+  if (localPath === null) {
+    return refuse(
+      `could not locate the local memory file for ${logical}/memory/${filename}; choose Skip.`
+    );
+  }
+  const findings = scan(localPath);
+  if (findings === null) {
+    return refuse(`re-scan of ${logical}/memory/${filename} failed; choose Skip.`);
+  }
+  if (findings.length === 0) {
+    return refuse(`nothing to redact in ${logical}/memory/${filename}; choose Skip.`);
+  }
+  backupBeforeWrite(localPath, ts);
+  const before = readFileSync15(localPath, "utf8");
+  const after = applyRedactions(before, findings);
+  writeFileSync7(localPath, after, "utf8");
+  const stagedMemoryDir = join38(repoHome(), "shared", "projects", logical, "memory");
+  mkdirSync9(stagedMemoryDir, { recursive: true });
+  cpSync7(localPath, join38(stagedMemoryDir, filename), { force: true });
+  return true;
+}
+
+// src/commands.push.recovery.seams.ts
 var MASK_LEAD = 4;
 var MASK_BODY = "************";
 var CONTEXT_WINDOW = 40;
@@ -4858,8 +5197,10 @@ function findingKey(f) {
   return `${f.File}:${f.StartLine}:${f.StartColumn}:${f.RuleID}`;
 }
 var VALID_SID = /^[A-Za-z0-9_-]+$/;
+var SUBTREE_PATH = /^shared\/projects\/[^/]+\/([^/]+)\/.+$/;
 function sessionIdFromFinding(f) {
-  const m = SESSION_PATH.exec(f.File) ?? /^shared\/projects\/[^/]+\/([^/]+)\//.exec(f.File);
+  if (isMemoryFindingPath(f)) return null;
+  const m = SESSION_PATH.exec(f.File) ?? SUBTREE_PATH.exec(f.File);
   if (m === null) return null;
   const sid = m[1];
   return VALID_SID.test(sid) ? sid : null;
@@ -4906,8 +5247,8 @@ function resolveStagedDir(localPath, map, claude, repo) {
     assertSafeLogical(logical);
     const abs = hostMap[HOST];
     if (abs === void 0) continue;
-    if (localPath.startsWith(join36(claude, "projects", encodePath(abs)) + sep5)) {
-      return join36(repo, "shared", "projects", logical);
+    if (localPath.startsWith(join39(claude, "projects", encodePath(abs)) + sep5)) {
+      return join39(repo, "shared", "projects", logical);
     }
   }
   return null;
@@ -4917,7 +5258,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 = join36(dirname8(localPath), sid);
+  const sessionDir = join39(dirname10(localPath), sid);
   const subtreeFiles = listSubtreeFiles(sessionDir);
   const subtreeMtime = newestSubtreeMtimeMs(localPath, subtreeFiles, (p) => statSync8(p).mtimeMs);
   if (isRecentlyModified(subtreeMtime, nowMs())) {
@@ -4947,7 +5288,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 = join36(dirname8(localPath), sid);
+  const sessionDir = join39(dirname10(localPath), sid);
   const subtreeFiles = listSubtreeFiles(sessionDir);
   const subtreeMtime = newestSubtreeMtimeMs(localPath, subtreeFiles, (p) => statSync8(p).mtimeMs);
   if (isRecentlyModified(subtreeMtime, nowMs())) {
@@ -4980,28 +5321,163 @@ function applyRedact(f, ts, map, nowMs, scan = scanFile) {
       `nothing to redact in the local transcript for session ${sid}; choose Skip or Drop session.`
     );
   }
-  mkdirSync7(stagedProjectDir, { recursive: true });
-  cpSync7(localPath, join36(stagedProjectDir, `${sid}.jsonl`), { force: true });
-  if (existsSync31(sessionDir)) {
-    cpSync7(sessionDir, join36(stagedProjectDir, sid), { force: true, recursive: true });
+  mkdirSync10(stagedProjectDir, { recursive: true });
+  cpSync8(localPath, join39(stagedProjectDir, `${sid}.jsonl`), { force: true });
+  if (existsSync32(sessionDir)) {
+    cpSync8(sessionDir, join39(stagedProjectDir, sid), { force: true, recursive: true });
   }
   return true;
 }
 
 // src/commands.push.recovery.drop.ts
 init_config();
-import { rmSync as rmSync11 } from "node:fs";
-import { join as join37 } from "node:path";
+import { rmSync as rmSync13 } from "node:fs";
+import { join as join40 } from "node:path";
 function dropSessionFromStaged(sid, map) {
   const logicals = Object.keys(map.projects);
   if (logicals.length === 0) return false;
   const repo = repoHome();
   for (const logical of logicals) {
-    const jsonl = join37(repo, "shared", "projects", logical, `${sid}.jsonl`);
-    const dir = join37(repo, "shared", "projects", logical, sid);
-    rmSync11(jsonl, { force: true });
-    rmSync11(dir, { recursive: true, force: true });
+    const jsonl = join40(repo, "shared", "projects", logical, `${sid}.jsonl`);
+    const dir = join40(repo, "shared", "projects", logical, sid);
+    rmSync13(jsonl, { force: true });
+    rmSync13(dir, { recursive: true, force: true });
+  }
+  return true;
+}
+
+// src/commands.push.recovery.skills.ts
+init_config();
+import {
+  cpSync as cpSync9,
+  lstatSync as lstatSync13,
+  mkdirSync as mkdirSync12,
+  readFileSync as readFileSync16,
+  realpathSync as realpathSync4,
+  statSync as statSync9,
+  writeFileSync as writeFileSync8
+} from "node:fs";
+import { dirname as dirname11, join as join42, sep as sep6 } from "node:path";
+
+// src/skills-sync.ts
+init_config();
+import { existsSync as existsSync33, lstatSync as lstatSync12, mkdirSync as mkdirSync11, readdirSync as readdirSync14, rmSync as rmSync14 } 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) || isDeniedName(ALWAYS_NEVER_SYNC, name);
+}
+function copySkillsPush(src, dst) {
+  const srcNames = readdirSync14(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 (!existsSync33(sharedSkills)) return;
+  const localSkills = join41(claudeHome(), "skills");
+  const dstStat = lstatSync12(localSkills, { throwIfNoEntry: false });
+  if (dstStat?.isSymbolicLink() === true) {
+    backupBeforeWrite(localSkills, ts);
+    rmSync14(localSkills, { recursive: true, force: true });
+    mkdirSync11(localSkills, { recursive: true });
+  }
+  copySkillsPull(sharedSkills, localSkills);
+}
+function syncSkillsPush() {
+  const localSkills = join41(claudeHome(), "skills");
+  const stat = lstatSync12(localSkills, { throwIfNoEntry: false });
+  if (stat === void 0) return;
+  if (stat.isSymbolicLink()) return;
+  const sharedSkills = join41(repoHome(), "shared", "skills");
+  copySkillsPush(localSkills, sharedSkills);
+}
+
+// src/commands.push.recovery.skills.ts
+init_push_gitleaks_scan();
+init_utils_fs();
+init_utils();
+var SKILL_FINDING_PATH = /^shared\/skills\/([^/]+)\/(.+)$/;
+var SAFE_SKILL_NAME = /^[A-Za-z0-9._-]+$/;
+var SKILL_DIR_PATH = /^shared\/skills\/[^/]+\//;
+function skillFileFromFinding(f) {
+  const m = SKILL_FINDING_PATH.exec(f.File);
+  if (m?.[1] === void 0 || m[2] === void 0) return null;
+  return { name: m[1], relPath: m[2] };
+}
+function isSkillFindingPath(f) {
+  return SKILL_DIR_PATH.test(f.File);
+}
+function isSafeRelPath(relPath) {
+  if (relPath.length === 0 || relPath.startsWith("/") || relPath.includes("\\")) return false;
+  const segments = relPath.split("/");
+  return segments.every((s) => s.length > 0 && s !== "." && s !== "..");
+}
+function resolveSkillLocalPath(name, relPath) {
+  if (!SAFE_SKILL_NAME.test(name) || name === "." || name === "..") return null;
+  if (isGsdOwned(name)) return null;
+  if (!isSafeRelPath(relPath)) return null;
+  const skillsRoot = join42(claudeHome(), "skills");
+  const skillRoot = join42(skillsRoot, name);
+  const localPath = join42(skillRoot, ...relPath.split("/"));
+  if (localPath !== skillRoot && !localPath.startsWith(skillRoot + sep6)) return null;
+  try {
+    if (lstatSync13(localPath).isSymbolicLink()) return null;
+    const realLocal = realpathSync4(localPath);
+    const realRoot = realpathSync4(skillsRoot);
+    if (!realLocal.startsWith(realRoot + sep6)) return null;
+    if (!statSync9(realLocal).isFile()) return null;
+  } catch {
+    return null;
+  }
+  return localPath;
+}
+function preflightSkillRedactable(f) {
+  const parsed = skillFileFromFinding(f);
+  if (parsed === null) return "a finding is not a skill file";
+  const localPath = resolveSkillLocalPath(parsed.name, parsed.relPath);
+  if (localPath === null) {
+    return `skill file ${parsed.name}/${parsed.relPath}: local file not found or unresolvable`;
   }
+  return null;
+}
+function applySkillRedact(f, ts, scan = scanFile) {
+  const refuse = (msg) => {
+    log(msg);
+    return false;
+  };
+  const parsed = skillFileFromFinding(f);
+  if (parsed === null) {
+    return refuse("could not parse this finding as a skill file; choose Skip.");
+  }
+  const { name, relPath } = parsed;
+  const localPath = resolveSkillLocalPath(name, relPath);
+  if (localPath === null) {
+    return refuse(`could not locate the local skill file for ${name}/${relPath}; choose Skip.`);
+  }
+  const findings = scan(localPath);
+  if (findings === null) {
+    return refuse(`re-scan of ${name}/${relPath} failed; choose Skip.`);
+  }
+  if (findings.length === 0) {
+    return refuse(`nothing to redact in ${name}/${relPath}; choose Skip.`);
+  }
+  backupBeforeWrite(localPath, ts);
+  const before = readFileSync16(localPath, "utf8");
+  const after = applyRedactions(before, findings);
+  writeFileSync8(localPath, after, "utf8");
+  const dest = join42(repoHome(), "shared", "skills", name, ...relPath.split("/"));
+  mkdirSync12(dirname11(dest), { recursive: true });
+  cpSync9(localPath, dest, { force: true });
   return true;
 }
 
@@ -5031,10 +5507,10 @@ function makeDefaultReadLine(repo) {
     try {
       const repoRoot = resolve3(repo);
       const target = resolve3(repoRoot, file);
-      if (isAbsolute2(file) || target !== repoRoot && !target.startsWith(repoRoot + sep6)) {
+      if (isAbsolute2(file) || target !== repoRoot && !target.startsWith(repoRoot + sep7)) {
         return null;
       }
-      const content = readFileSync15(target, "utf8");
+      const content = readFileSync17(target, "utf8");
       const lines = content.split(/\r?\n/);
       const idx = line - 1;
       if (idx < 0 || idx >= lines.length) return null;
@@ -5057,6 +5533,40 @@ Finding: ${f.RuleID} in ${f.File} line ${f.StartLine}` + (sid === null ? "" : `
   }
   return actions;
 }
+function dispatchMemory(f, action, ctx) {
+  const parsed = memoryFileFromFinding(f);
+  if (parsed === null) {
+    log(`memory path not auto-redactable: ${f.File}; scrub it by hand or choose Skip`);
+    return;
+  }
+  if (action === "drop") {
+    log("memory files cannot be dropped; use Redact or Skip");
+    return;
+  }
+  const memKey = `${parsed.logical}/${parsed.filename}`;
+  if (ctx.redactedMemory.has(memKey)) return;
+  if (applyMemoryRedact(f, ctx.ts, ctx.map, ctx.scan)) ctx.redactedMemory.add(memKey);
+}
+function dispatchSkill(f, action, ctx) {
+  const parsed = skillFileFromFinding(f);
+  if (parsed === null) return;
+  if (action === "drop") {
+    log("skill files cannot be dropped; use Redact or Skip");
+    return;
+  }
+  const skillKey = `${parsed.name}/${parsed.relPath}`;
+  if (ctx.redactedSkills.has(skillKey)) return;
+  if (applySkillRedact(f, ctx.ts, ctx.scan)) ctx.redactedSkills.add(skillKey);
+}
+function dispatchNonSession(f, action, ctx) {
+  if (isMemoryFindingPath(f)) {
+    dispatchMemory(f, action, ctx);
+    return;
+  }
+  if (isSkillFindingPath(f)) {
+    dispatchSkill(f, action, ctx);
+  }
+}
 function dispatchOne(f, ctx) {
   const action = ctx.actions.get(findingKey(f)) ?? "skip";
   if (action === "skip") return;
@@ -5066,7 +5576,10 @@ function dispatchOne(f, ctx) {
     applyAllow(f, ctx.repo);
     return;
   }
-  if (sid === null) return;
+  if (sid === null) {
+    dispatchNonSession(f, action, ctx);
+    return;
+  }
   if (action === "drop") {
     ctx.droppedSids.add(sid);
     if (ctx.drop(sid, ctx.map)) {
@@ -5091,20 +5604,58 @@ function dispatchActions(findings, actions, opts) {
     scan,
     drop,
     redactedSids: /* @__PURE__ */ new Set(),
-    droppedSids: /* @__PURE__ */ new Set()
+    droppedSids: /* @__PURE__ */ new Set(),
+    redactedMemory: /* @__PURE__ */ new Set(),
+    redactedSkills: /* @__PURE__ */ new Set()
   };
   for (const f of findings) {
     dispatchOne(f, ctx);
   }
 }
+function redactAllDedupeKey(f) {
+  const sid = sessionIdFromFinding(f);
+  if (sid !== null) return sid;
+  const memParsed = memoryFileFromFinding(f);
+  if (memParsed !== null) return `${memParsed.logical}/${memParsed.filename}`;
+  const skillParsed = skillFileFromFinding(f);
+  if (skillParsed !== null) return `skill:${skillParsed.name}/${skillParsed.relPath}`;
+  return findingKey(f);
+}
+function redactAllPreflightOne(f, map, nowMs) {
+  if (sessionIdFromFinding(f) === null) {
+    if (memoryFileFromFinding(f) !== null) return preflightMemoryRedactable(f, map);
+    if (skillFileFromFinding(f) !== null) return preflightSkillRedactable(f);
+  }
+  return preflightRedactable(f, map, nowMs);
+}
+function redactAllOne(f, ts, map, nowMs, scan, dedupe) {
+  const sid = sessionIdFromFinding(f);
+  if (sid !== null) {
+    if (dedupe.redactedSids.has(sid)) return;
+    if (applyRedact(f, ts, map, nowMs, scan)) dedupe.redactedSids.add(sid);
+    return;
+  }
+  const memParsed = memoryFileFromFinding(f);
+  if (memParsed !== null) {
+    const memKey = `${memParsed.logical}/${memParsed.filename}`;
+    if (dedupe.redactedMemory.has(memKey)) return;
+    if (applyMemoryRedact(f, ts, map, scan)) dedupe.redactedMemory.add(memKey);
+    return;
+  }
+  const skillParsed = skillFileFromFinding(f);
+  if (skillParsed === null) return;
+  const skillKey = `${skillParsed.name}/${skillParsed.relPath}`;
+  if (dedupe.redactedSkills.has(skillKey)) return;
+  if (applySkillRedact(f, ts, scan)) dedupe.redactedSkills.add(skillKey);
+}
 function redactAllFindings(findings, ts, map, nowMs, scan = scanFile) {
   const refusals = [];
   const preflighted = /* @__PURE__ */ new Set();
   for (const f of findings) {
-    const dedupeKey = sessionIdFromFinding(f) ?? findingKey(f);
+    const dedupeKey = redactAllDedupeKey(f);
     if (preflighted.has(dedupeKey)) continue;
     preflighted.add(dedupeKey);
-    const reason = preflightRedactable(f, map, nowMs);
+    const reason = redactAllPreflightOne(f, map, nowMs);
     if (reason !== null) refusals.push(reason);
   }
   if (refusals.length > 0) {
@@ -5114,15 +5665,18 @@ function redactAllFindings(findings, ts, map, nowMs, scan = scanFile) {
   Re-run without --redact-all to triage these interactively (Drop session / Skip), or end any active session and retry.`
     );
   }
-  const redactedSids = /* @__PURE__ */ new Set();
+  const dedupe = {
+    redactedSids: /* @__PURE__ */ new Set(),
+    redactedMemory: /* @__PURE__ */ new Set(),
+    redactedSkills: /* @__PURE__ */ new Set()
+  };
   for (const f of findings) {
-    const sid = sessionIdFromFinding(f);
-    if (sid === null || redactedSids.has(sid)) continue;
-    if (applyRedact(f, ts, map, nowMs, scan)) redactedSids.add(sid);
+    redactAllOne(f, ts, map, nowMs, scan, dedupe);
   }
 }
 
 // src/commands.push.recovery.ts
+init_exit_codes();
 init_push_gitleaks_scan();
 init_push_gitleaks();
 init_utils();
@@ -5150,15 +5704,15 @@ function applyThenRescan(scanVerdict, repoHome2) {
   const next = scanVerdict(repoHome2);
   if (next.leak) {
     const { bySession, other } = partitionFindings(next.findings);
-    throw new NomadFatal(buildSessionAwareFatal(bySession, other));
+    throw new NomadFatal(buildSessionAwareFatal(bySession, other), { code: EXIT.LEAK_BLOCKED });
   }
   return next;
 }
 function allowThenRescan(append, scanVerdict, repoHome2) {
-  const ignPath = join38(repoHome2, ".gitleaksignore");
+  const ignPath = join43(repoHome2, ".gitleaksignore");
   let before;
   try {
-    before = readFileSync16(ignPath, "utf8");
+    before = readFileSync18(ignPath, "utf8");
   } catch {
     before = null;
   }
@@ -5166,8 +5720,8 @@ function allowThenRescan(append, scanVerdict, repoHome2) {
   try {
     return applyThenRescan(scanVerdict, repoHome2);
   } catch (err) {
-    if (before === null) rmSync12(ignPath, { force: true });
-    else writeFileSync5(ignPath, before, "utf8");
+    if (before === null) rmSync15(ignPath, { force: true });
+    else writeFileSync9(ignPath, before, "utf8");
     throw err;
   }
 }
@@ -5217,7 +5771,9 @@ async function resolveLeakFindings(verdict, ts, map, deps = {}) {
     );
   }
   if (!isTTYCheck()) {
-    throw new NomadFatal(current.recovery ?? "gitleaks detected secrets");
+    throw new NomadFatal(current.recovery ?? "gitleaks detected secrets", {
+      code: EXIT.LEAK_BLOCKED
+    });
   }
   const prompt = makePromptFn();
   printLegend();
@@ -5226,7 +5782,7 @@ async function resolveLeakFindings(verdict, ts, map, deps = {}) {
     if (hasUnresolved(actions)) {
       const unresolved = current.findings.filter((f) => actions.get(findingKey(f)) === "skip");
       const { bySession, other } = partitionFindings(unresolved);
-      throw new NomadFatal(buildSessionAwareFatal(bySession, other));
+      throw new NomadFatal(buildSessionAwareFatal(bySession, other), { code: EXIT.LEAK_BLOCKED });
     }
     dispatchActions(current.findings, actions, { ts, map, nowMs, repo, scan });
     gitOrFatal(["add", "-A"], "git add", repo);
@@ -5254,7 +5810,7 @@ function writeAnimatedDone(out, label, ms, useTTY) {
 `);
 }
 function resolveWorkerPath(deps = {}) {
-  const check = deps.existsSyncFn ?? existsSync32;
+  const check = deps.existsSyncFn ?? existsSync34;
   const base = deps.baseUrl ?? import.meta.url;
   const mjs = fileURLToPath4(new URL("./nomad.worker.mjs", base));
   if (check(mjs)) return mjs;
@@ -5320,9 +5876,9 @@ function withSpinner(label, fn, deps) {
 
 // src/commands.doctor.gitleaks-version.ts
 init_color();
-import { execFileSync as execFileSync13 } from "node:child_process";
-import { existsSync as existsSync33 } from "node:fs";
-import { join as join39 } from "node:path";
+import { execFileSync as execFileSync15 } from "node:child_process";
+import { existsSync as existsSync35 } from "node:fs";
+import { join as join44 } from "node:path";
 init_config();
 var SEMVER_MAJOR_MINOR = /^(\d+)\.(\d+)\.\d+$/;
 var GITLEAKS_TIMEOUT_MS = 5e3;
@@ -5331,7 +5887,7 @@ function majorMinorOf(value) {
   return m === null ? null : [m[1], m[2]];
 }
 function readGitleaksVersion(run, tomlExists) {
-  const tomlPath = join39(repoHome(), ".gitleaks.toml");
+  const tomlPath = join44(repoHome(), ".gitleaks.toml");
   const args = ["version"];
   if (tomlExists(tomlPath)) args.push("--config", tomlPath);
   try {
@@ -5343,7 +5899,7 @@ function readGitleaksVersion(run, tomlExists) {
     return null;
   }
 }
-function reportGitleaksVersionCheck(section2, run = execFileSync13, tomlExists = existsSync33) {
+function reportGitleaksVersionCheck(section2, run = execFileSync15, tomlExists = existsSync35) {
   const raw = readGitleaksVersion(run, tomlExists);
   if (raw === null) return;
   const local = majorMinorOf(raw);
@@ -5363,7 +5919,7 @@ function reportGitleaksVersionCheck(section2, run = execFileSync13, tomlExists =
 
 // src/commands.doctor.checks.deps.ts
 init_color();
-import { execFileSync as execFileSync14 } from "node:child_process";
+import { execFileSync as execFileSync16 } from "node:child_process";
 var VERSION_TOKEN = /(\d{1,9}\.\d{1,9}\.\d{1,9})/;
 var PROBE_TIMEOUT_MS3 = 3e3;
 var FETCHER_BASE = "HTTP fetcher";
@@ -5400,7 +5956,7 @@ function reportFetcherRow(section2, run) {
     );
   }
 }
-function reportOptionalDeps(section2, run = execFileSync14) {
+function reportOptionalDeps(section2, run = execFileSync16) {
   const gh = probeOptionalDep("gh", run);
   if (gh.status === "present") {
     addItem(section2, `${green(okGlyph)} gh: ${gh.version ?? "present"}`);
@@ -5415,11 +5971,11 @@ function reportOptionalDeps(section2, run = execFileSync14) {
 
 // src/commands.doctor.actions-drift.ts
 init_color();
-import { execFileSync as execFileSync16 } from "node:child_process";
+import { execFileSync as execFileSync18 } from "node:child_process";
 init_config();
 
 // src/gh-actions.ts
-import { execFileSync as execFileSync15 } from "node:child_process";
+import { execFileSync as execFileSync17 } from "node:child_process";
 var GH_TIMEOUT_MS = 5e3;
 function parseGitHubRemote(remoteUrl) {
   const normalized = remoteUrl.trim().replace(/\/$/, "");
@@ -5427,7 +5983,7 @@ function parseGitHubRemote(remoteUrl) {
   if (m === null) return null;
   return { owner: m[1], repo: m[2] };
 }
-function ghAuthStatus(run = execFileSync15) {
+function ghAuthStatus(run = execFileSync17) {
   try {
     run("gh", ["auth", "status"], {
       stdio: ["ignore", "ignore", "ignore"],
@@ -5441,7 +5997,7 @@ function ghAuthStatus(run = execFileSync15) {
     return "gh-probe-error";
   }
 }
-function isRepoPrivate(ref, run = execFileSync15) {
+function isRepoPrivate(ref, run = execFileSync17) {
   const out = run("gh", ["repo", "view", `${ref.owner}/${ref.repo}`, "--json", "isPrivate"], {
     stdio: ["ignore", "pipe", "ignore"],
     timeout: GH_TIMEOUT_MS
@@ -5449,7 +6005,7 @@ function isRepoPrivate(ref, run = execFileSync15) {
   const parsed = JSON.parse(out);
   return parsed.isPrivate === true;
 }
-function isActionsEnabled(ref, run = execFileSync15) {
+function isActionsEnabled(ref, run = execFileSync17) {
   const out = run(
     "gh",
     ["api", `repos/${ref.owner}/${ref.repo}/actions/permissions`, "--jq", ".enabled"],
@@ -5457,7 +6013,7 @@ function isActionsEnabled(ref, run = execFileSync15) {
   ).toString().trim();
   return out === "true";
 }
-function disableActions(ref, run = execFileSync15) {
+function disableActions(ref, run = execFileSync17) {
   run(
     "gh",
     [
@@ -5471,7 +6027,7 @@ function disableActions(ref, run = execFileSync15) {
     { stdio: ["ignore", "ignore", "pipe"], timeout: GH_TIMEOUT_MS }
   );
 }
-function readOriginRemote(cwd, run = execFileSync15) {
+function readOriginRemote(cwd, run = execFileSync17) {
   return run("git", ["remote", "get-url", "origin"], {
     cwd,
     stdio: ["ignore", "pipe", "ignore"]
@@ -5479,7 +6035,7 @@ function readOriginRemote(cwd, run = execFileSync15) {
 }
 
 // src/commands.doctor.actions-drift.ts
-function reportActionsDrift(section2, run = execFileSync16) {
+function reportActionsDrift(section2, run = execFileSync18) {
   let remote;
   try {
     remote = readOriginRemote(repoHome(), run);
@@ -5569,8 +6125,8 @@ function gatherDoctorSections(opts) {
   reportLongPathsCheck(host);
   reportCrlfGuardCheck(host);
   const links = section("Shared links");
-  const mapPath = join40(repoHome(), "path-map.json");
-  const rawMap = existsSync34(mapPath) ? readJsonSafe(mapPath, mapPath, links) : null;
+  const mapPath = join45(repoHome(), "path-map.json");
+  const rawMap = existsSync36(mapPath) ? readJsonSafe(mapPath, mapPath, links) : null;
   const map = rawMap ?? { projects: {} };
   reportSharedLinks(links, map);
   reportDroppedNamesMigration(links);
@@ -5666,15 +6222,15 @@ function parseDoctorArgs(args) {
 
 // src/commands.drop-session.ts
 init_config();
-import { execFileSync as execFileSync18 } from "node:child_process";
-import { existsSync as existsSync36, readdirSync as readdirSync14, statSync as statSync9 } from "node:fs";
-import { join as join42, relative as relative6 } from "node:path";
+import { execFileSync as execFileSync20 } from "node:child_process";
+import { existsSync as existsSync38, readdirSync as readdirSync15, statSync as statSync10 } from "node:fs";
+import { join as join47, relative as relative6 } from "node:path";
 
 // src/commands.drop-session.git.ts
-import { execFileSync as execFileSync17 } from "node:child_process";
+import { execFileSync as execFileSync19 } from "node:child_process";
 function expandStagedDir(dirRel, repo) {
   try {
-    const out = execFileSync17("git", ["ls-files", "-z", "--", dirRel], {
+    const out = execFileSync19("git", ["ls-files", "-z", "--", dirRel], {
       cwd: repo,
       stdio: ["ignore", "pipe", "pipe"]
     });
@@ -5686,7 +6242,7 @@ function expandStagedDir(dirRel, repo) {
 function isTrackedInHead(rel, repo) {
   try {
     const treePath = process.platform === "win32" ? rel.replaceAll("\\", "/") : rel;
-    execFileSync17("git", ["cat-file", "-e", `HEAD:${treePath}`], {
+    execFileSync19("git", ["cat-file", "-e", `HEAD:${treePath}`], {
       cwd: repo,
       stdio: ["ignore", "pipe", "pipe"]
     });
@@ -5697,7 +6253,7 @@ function isTrackedInHead(rel, repo) {
 }
 function isInIndex(rel, repo) {
   try {
-    const out = execFileSync17("git", ["ls-files", "--", rel], {
+    const out = execFileSync19("git", ["ls-files", "--", rel], {
       cwd: repo,
       stdio: ["ignore", "pipe", "pipe"]
     });
@@ -5711,8 +6267,8 @@ function isInIndex(rel, repo) {
 init_config();
 init_utils();
 init_utils_json();
-import { existsSync as existsSync35 } from "node:fs";
-import { join as join41 } from "node:path";
+import { existsSync as existsSync37 } from "node:fs";
+import { join as join46 } from "node:path";
 var SHARED_PROJECT_LOGICAL = /^shared\/projects\/([^/]+)\//;
 function reportScrubHint(id, matches) {
   const live = resolveLiveTranscript2(id, matches);
@@ -5728,8 +6284,8 @@ function reportScrubHint(id, matches) {
 }
 function resolveLiveTranscript2(id, matches) {
   try {
-    const mapPath = join41(repoHome(), "path-map.json");
-    if (!existsSync35(mapPath)) return null;
+    const mapPath = join46(repoHome(), "path-map.json");
+    if (!existsSync37(mapPath)) return null;
     const projects = readJson(mapPath).projects;
     const claude = claudeHome();
     for (const rel of matches) {
@@ -5737,8 +6293,8 @@ function resolveLiveTranscript2(id, matches) {
       if (logical === void 0) continue;
       const abs = projects[logical]?.[HOST];
       if (abs === void 0) continue;
-      const live = join41(claude, "projects", encodePath(abs), `${id}.jsonl`);
-      if (existsSync35(live)) return live;
+      const live = join46(claude, "projects", encodePath(abs), `${id}.jsonl`);
+      if (existsSync37(live)) return live;
     }
     return null;
   } catch {
@@ -5754,12 +6310,12 @@ function cmdDropSession(id) {
     process.exit(1);
   }
   const repo = repoHome();
-  if (!existsSync36(repo)) die(`repo not cloned at ${repo}`);
+  if (!existsSync38(repo)) die(`repo not cloned at ${repo}`);
   const handle = acquireLock("drop-session");
   if (handle === null) process.exit(0);
   try {
-    const repoProjects = join42(repo, "shared", "projects");
-    if (!existsSync36(repoProjects)) {
+    const repoProjects = join47(repo, "shared", "projects");
+    if (!existsSync38(repoProjects)) {
       throw new NomadFatal(`no staged session matches ${id}`);
     }
     const matches = collectMatches(repoProjects, id, repo);
@@ -5774,20 +6330,20 @@ function cmdDropSession(id) {
       throw err;
     }
     fail(err.message);
-    process.exitCode = 1;
+    process.exitCode = err.code;
   } finally {
     releaseLock(handle);
   }
 }
 function collectMatches(repoProjects, id, repo) {
   const matches = [];
-  for (const logical of readdirSync14(repoProjects)) {
-    const candidate = join42(repoProjects, logical, `${id}.jsonl`);
-    if (existsSync36(candidate)) {
+  for (const logical of readdirSync15(repoProjects)) {
+    const candidate = join47(repoProjects, logical, `${id}.jsonl`);
+    if (existsSync38(candidate)) {
       matches.push(relative6(repo, candidate));
     }
-    const dir = join42(repoProjects, logical, id);
-    if (existsSync36(dir) && statSync9(dir).isDirectory()) {
+    const dir = join47(repoProjects, logical, id);
+    if (existsSync38(dir) && statSync10(dir).isDirectory()) {
       const dirRel = relative6(repo, dir);
       const staged = expandStagedDir(dirRel, repo);
       if (staged.length > 0) matches.push(...staged);
@@ -5803,12 +6359,12 @@ function unstageOne(rel, repo) {
   }
   try {
     if (isTrackedInHead(rel, repo)) {
-      execFileSync18("git", ["restore", "--staged", "--worktree", "--", rel], {
+      execFileSync20("git", ["restore", "--staged", "--worktree", "--", rel], {
         cwd: repo,
         stdio: ["ignore", "pipe", "pipe"]
       });
     } else {
-      execFileSync18("git", ["rm", "--cached", "-f", "--", rel], {
+      execFileSync20("git", ["rm", "--cached", "-f", "--", rel], {
         cwd: repo,
         stdio: ["ignore", "pipe", "pipe"]
       });
@@ -5822,8 +6378,8 @@ function unstageOne(rel, repo) {
 }
 
 // src/commands.pull.ts
-import { existsSync as existsSync41, mkdirSync as mkdirSync10 } from "node:fs";
-import { join as join48 } from "node:path";
+import { existsSync as existsSync42, mkdirSync as mkdirSync14 } from "node:fs";
+import { join as join52 } from "node:path";
 
 // src/commands.push.sections.ts
 init_color();
@@ -5931,18 +6487,18 @@ init_config();
 
 // src/extras-sync.ts
 init_config();
-import { existsSync as existsSync38, statSync as statSync10 } from "node:fs";
-import { join as join45 } from "node:path";
+import { existsSync as existsSync40, statSync as statSync11 } from "node:fs";
+import { join as join50 } from "node:path";
 init_utils();
 init_utils_json();
 
 // src/extras-sync.remap.ts
 init_config();
-import { existsSync as existsSync37, mkdirSync as mkdirSync8, readdirSync as readdirSync15, readFileSync as readFileSync17, realpathSync as realpathSync4, rmSync as rmSync13 } from "node:fs";
-import { dirname as dirname9, join as join44, sep as sep8 } from "node:path";
+import { existsSync as existsSync39, mkdirSync as mkdirSync13, readdirSync as readdirSync16, readFileSync as readFileSync19, realpathSync as realpathSync5, rmSync as rmSync16 } from "node:fs";
+import { dirname as dirname12, join as join49, sep as sep9 } from "node:path";
 
 // src/extras-sync.planning-diff.ts
-import { join as join43, normalize as normalize2, sep as sep7 } from "node:path";
+import { join as join48, normalize as normalize2, sep as sep8 } from "node:path";
 init_utils();
 function processRecord(fields, i, changed, deleted) {
   const status = fields[i];
@@ -5994,15 +6550,15 @@ function planningDeleteTargets(opts) {
   const { deleted } = parsePlanningDiff(raw);
   const logicalPrefix = "shared/extras/" + logical + "/";
   const prefix = logicalPrefix + ".planning/";
-  const planningRoot = join43(localRoot, ".planning");
-  const planningRootBoundary = planningRoot + sep7;
+  const planningRoot = join48(localRoot, ".planning");
+  const planningRootBoundary = planningRoot + sep8;
   const targets = [];
   for (const repoPath of deleted) {
     if (!repoPath.startsWith(prefix)) {
       continue;
     }
     const remainder = repoPath.slice(logicalPrefix.length);
-    const candidate = join43(localRoot, remainder);
+    const candidate = join48(localRoot, remainder);
     const resolved = normalize2(candidate);
     if (!resolved.startsWith(planningRootBoundary)) {
       throw new NomadFatal(
@@ -6023,7 +6579,7 @@ function runExtrasOp(v, dryRun, paths, backup, copy) {
   const would = [];
   for (const t of eachExtrasTarget(v, counts)) {
     const { src, dst } = paths(t);
-    if (!existsSync37(src)) continue;
+    if (!existsSync39(src)) continue;
     const item2 = `${t.logical}/${t.dirname}`;
     if (dryRun) {
       would.push(item2);
@@ -6036,42 +6592,42 @@ function runExtrasOp(v, dryRun, paths, backup, copy) {
   return { ...counts, done, would };
 }
 function pruneEmptyAncestors(target, planningRoot) {
-  let dir = dirname9(target);
-  while (dir !== planningRoot && dir.startsWith(planningRoot + sep8)) {
+  let dir = dirname12(target);
+  while (dir !== planningRoot && dir.startsWith(planningRoot + sep9)) {
     try {
-      if (readdirSync15(dir).length > 0) break;
-      rmSync13(dir, { recursive: true, force: true });
+      if (readdirSync16(dir).length > 0) break;
+      rmSync16(dir, { recursive: true, force: true });
     } catch {
       break;
     }
-    dir = dirname9(dir);
+    dir = dirname12(dir);
   }
 }
 function tryRealpath(dir) {
   try {
-    return realpathSync4(dir);
+    return realpathSync5(dir);
   } catch {
     return void 0;
   }
 }
 function isInsidePlanningRoot(parentReal, rootReal) {
-  return parentReal === rootReal || parentReal.startsWith(rootReal + sep8);
+  return parentReal === rootReal || parentReal.startsWith(rootReal + sep9);
 }
 function deletePlanningTarget(target, planningRoot, repoCounterpart) {
-  if (existsSync37(repoCounterpart)) return;
-  const parentReal = tryRealpath(dirname9(target));
+  if (existsSync39(repoCounterpart)) return;
+  const parentReal = tryRealpath(dirname12(target));
   if (parentReal === void 0) return;
   const rootReal = tryRealpath(planningRoot);
   if (rootReal === void 0) return;
   if (!isInsidePlanningRoot(parentReal, rootReal)) return;
-  rmSync13(target, { recursive: true, force: true });
+  rmSync16(target, { recursive: true, force: true });
   pruneEmptyAncestors(target, planningRoot);
 }
 function localDivergesFromPreDelete(target, pre, repoRel, repo) {
-  if (!existsSync37(target)) return false;
+  if (!existsSync39(target)) return false;
   try {
     const preBlob = gitCaptureBuffer(["show", `${pre}:${repoRel}`], repo);
-    return !readFileSync17(target).equals(preBlob);
+    return !readFileSync19(target).equals(preBlob);
   } catch {
     return true;
   }
@@ -6082,11 +6638,11 @@ function planningDiffArgs(pre, post, logical) {
 function deletePairsFor(t, raw) {
   return planningDeleteTargets({ raw, logical: t.logical, localRoot: t.localRoot }).map(
     (target) => {
-      const relToLocal = target.slice(t.localRoot.length + sep8.length);
+      const relToLocal = target.slice(t.localRoot.length + sep9.length);
       return {
         target,
         relToLocal,
-        repoRel: `shared/extras/${t.logical}/${relToLocal.split(sep8).join("/")}`
+        repoRel: `shared/extras/${t.logical}/${relToLocal.split(sep9).join("/")}`
       };
     }
   );
@@ -6113,7 +6669,7 @@ function keptDeletePreview(v, prePostHeads, repo) {
   return kept;
 }
 function propagatePlanningDeletes(v, ts, prePostHeads, repo) {
-  const repoExtras = join44(repo, "shared", "extras");
+  const repoExtras = join49(repo, "shared", "extras");
   for (const t of eachExtrasTarget(v, { unmapped: 0, skipped: 0 })) {
     if (t.dirname !== ".planning") continue;
     let raw;
@@ -6128,14 +6684,14 @@ function propagatePlanningDeletes(v, ts, prePostHeads, repo) {
     }
     const pairs = deletePairsFor(t, raw);
     if (pairs.length === 0) continue;
-    backupExtrasWrite(join44(t.localRoot, t.dirname), ts, t.localRoot);
-    const planningRoot = join44(t.localRoot, ".planning");
+    backupExtrasWrite(join49(t.localRoot, t.dirname), ts, t.localRoot);
+    const planningRoot = join49(t.localRoot, ".planning");
     for (const { target, relToLocal, repoRel } of pairs) {
       if (localDivergesFromPreDelete(target, prePostHeads.pre, repoRel, repo)) {
         warn(keptDeleteWarnLine(t.logical, relToLocal));
         continue;
       }
-      deletePlanningTarget(target, planningRoot, join44(repoExtras, t.logical, relToLocal));
+      deletePlanningTarget(target, planningRoot, join49(repoExtras, t.logical, relToLocal));
     }
   }
 }
@@ -6144,14 +6700,14 @@ function remapExtrasPush(ts, opts = {}) {
   const v = loadValidatedExtras({ missingMsg: "no path-map.json; skipping extras push" });
   if (v === null) return { unmapped: 0, skipped: 0, pushed: [], wouldPush: [] };
   const repo = repoHome();
-  const repoExtras = join44(repo, "shared", "extras");
-  if (!dryRun) mkdirSync8(repoExtras, { recursive: true });
+  const repoExtras = join49(repo, "shared", "extras");
+  if (!dryRun) mkdirSync13(repoExtras, { recursive: true });
   const { unmapped, skipped, done, would } = runExtrasOp(
     v,
     dryRun,
-    ({ localRoot, logical, dirname: dirname10 }) => ({
-      src: join44(localRoot, dirname10),
-      dst: join44(repoExtras, logical, dirname10)
+    ({ localRoot, logical, dirname: dirname13 }) => ({
+      src: join49(localRoot, dirname13),
+      dst: join49(repoExtras, logical, dirname13)
     }),
     (dst) => backupRepoWrite(dst, ts, repo),
     // Push copy routing per extra type:
@@ -6163,7 +6719,7 @@ function remapExtrasPush(ts, opts = {}) {
     //     (enforceAllowList / blockSetFor in commands.push.allowlist.ts)
     //     remains the hard security boundary.
     //   All others: copyExtrasFiltered with per-extra denylist.
-    (src, dst, dirname10) => dirname10 === ".planning" ? copyExtrasOverlayFiltered(src, dst, extrasDenySet(dirname10)) : copyExtrasFiltered(src, dst, extrasDenySet(dirname10))
+    (src, dst, dirname13) => dirname13 === ".planning" ? copyExtrasOverlayFiltered(src, dst, extrasDenySet(dirname13)) : copyExtrasFiltered(src, dst, extrasDenySet(dirname13))
   );
   return { unmapped, skipped, pushed: done, wouldPush: would };
 }
@@ -6179,9 +6735,9 @@ function remapExtrasPull(ts, opts = {}) {
   const { unmapped, skipped, done, would } = runExtrasOp(
     v,
     dryRun,
-    ({ localRoot, logical, dirname: dirname10 }) => ({
-      src: join44(repo, "shared", "extras", logical, dirname10),
-      dst: join44(localRoot, dirname10)
+    ({ localRoot, logical, dirname: dirname13 }) => ({
+      src: join49(repo, "shared", "extras", logical, dirname13),
+      dst: join49(localRoot, dirname13)
     }),
     // Snapshot the host-side dst BEFORE the copy step touches it. Anchor on
     // localRoot so the backup tree mirrors the project layout.
@@ -6199,12 +6755,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, dirname10) => {
-      if (dirname10 === ".claude")
-        return copyExtrasFilteredPreserving(src, dst, extrasDenySet(dirname10));
-      if (dirname10 === ".planning") {
+    (src, dst, dirname13) => {
+      if (dirname13 === ".claude")
+        return copyExtrasFilteredPreserving(src, dst, extrasDenySet(dirname13));
+      if (dirname13 === ".planning") {
         const divergedSet = new Set(listDivergingModified(dst, src));
-        return copyExtrasOverlaySkipDiverged(src, dst, extrasDenySet(dirname10), divergedSet);
+        return copyExtrasOverlaySkipDiverged(src, dst, extrasDenySet(dirname13), divergedSet);
       }
       return copyExtrasFileSkipDiverged(src, dst);
     }
@@ -6228,22 +6784,22 @@ function divergenceCheckExtras(ts, prePostHeads) {
   const v = loadValidatedExtras({});
   if (v === null) return 0;
   const counts = { unmapped: 0, skipped: 0 };
-  const backupRoot = join45(backupBase(), ts, "extras");
+  const backupRoot = join50(backupBase(), ts, "extras");
   const repo = repoHome();
   let divergedCount = 0;
-  for (const { logical, localRoot, dirname: dirname10 } of eachExtrasTarget(v, counts)) {
-    const local = join45(localRoot, dirname10);
-    const repoEntry = join45(repo, "shared", "extras", logical, dirname10);
-    if (!existsSync38(local) || !existsSync38(repoEntry)) continue;
+  for (const { logical, localRoot, dirname: dirname13 } of eachExtrasTarget(v, counts)) {
+    const local = join50(localRoot, dirname13);
+    const repoEntry = join50(repo, "shared", "extras", logical, dirname13);
+    if (!existsSync40(local) || !existsSync40(repoEntry)) continue;
     const modified = listDivergingModified(local, repoEntry);
     if (modified.length === 0) continue;
     divergedCount += modified.length;
-    const projectBackupRoot = join45(backupRoot, encodePath(localRoot));
+    const projectBackupRoot = join50(backupRoot, encodePath(localRoot));
     warn(
       divergenceWarnLine({
-        dirname: dirname10,
+        dirname: dirname13,
         logical,
-        isDir: statSync10(local).isDirectory(),
+        isDir: statSync11(local).isDirectory(),
         count: modified.length,
         projectBackupRoot
       })
@@ -6258,53 +6814,10 @@ function divergenceCheckExtras(ts, prePostHeads) {
   return divergedCount;
 }
 
-// src/skills-sync.ts
-init_config();
-import { existsSync as existsSync39, lstatSync as lstatSync12, mkdirSync as mkdirSync9, readdirSync as readdirSync16, rmSync as rmSync14 } from "node:fs";
-import { join as join46 } from "node:path";
-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 = readdirSync16(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 = join46(repoHome(), "shared", "skills");
-  if (!existsSync39(sharedSkills)) return;
-  const localSkills = join46(claudeHome(), "skills");
-  const dstStat = lstatSync12(localSkills, { throwIfNoEntry: false });
-  if (dstStat?.isSymbolicLink() === true) {
-    backupBeforeWrite(localSkills, ts);
-    rmSync14(localSkills, { recursive: true, force: true });
-    mkdirSync9(localSkills, { recursive: true });
-  }
-  copySkillsPull(sharedSkills, localSkills);
-}
-function syncSkillsPush() {
-  const localSkills = join46(claudeHome(), "skills");
-  const stat = lstatSync12(localSkills, { throwIfNoEntry: false });
-  if (stat === void 0) return;
-  if (stat.isSymbolicLink()) return;
-  const sharedSkills = join46(repoHome(), "shared", "skills");
-  copySkillsPush(localSkills, sharedSkills);
-}
-
 // src/preview.ts
 init_config();
-import { existsSync as existsSync40 } from "node:fs";
-import { join as join47 } from "node:path";
+import { existsSync as existsSync41 } from "node:fs";
+import { join as join51 } from "node:path";
 
 // node_modules/diff/libesm/diff/base.js
 var Diff = class {
@@ -6590,7 +7103,7 @@ function diffJsonStrings(currentJsonText, newJsonText) {
   return lines.join("\n");
 }
 function readJsonOrNull(path) {
-  if (!existsSync40(path)) return null;
+  if (!existsSync41(path)) return null;
   try {
     return readJson(path);
   } catch {
@@ -6604,12 +7117,12 @@ function previewSettings(basePath, hostPath, settingsPath) {
   }
   const notes = [];
   const hostOverrides = readJsonOrNull(hostPath);
-  if (hostOverrides === null && existsSync40(hostPath)) {
+  if (hostOverrides === null && existsSync41(hostPath)) {
     notes.push(`malformed hosts/${HOST}.json; ignoring overrides`);
   }
   const merged = stripGsdHookEntries(deepMerge(base, hostOverrides ?? {}));
   const current = readJsonOrNull(settingsPath);
-  if (current === null && existsSync40(settingsPath)) {
+  if (current === null && existsSync41(settingsPath)) {
     return { diff: "", notes: [...notes, "malformed; skipping diff"] };
   }
   const strippedCurrent = stripGsdHookEntries(current ?? {});
@@ -6651,9 +7164,9 @@ function computePreview(ts, map, verb = "pull") {
     onPreview: (e) => addItem(links, formatLinkRow(e))
   });
   const settingsResult = previewSettings(
-    join47(repo, "shared", "settings.base.json"),
-    join47(repo, "hosts", `${HOST}.json`),
-    join47(claude, "settings.json")
+    join51(repo, "shared", "settings.base.json"),
+    join51(repo, "hosts", `${HOST}.json`),
+    join51(claude, "settings.json")
   );
   const settingsSection = buildSettingsSectionForPreview(settingsResult);
   const sessions = section("Sessions");
@@ -6668,7 +7181,7 @@ function computePreview(ts, map, verb = "pull") {
   const extras = section("Extras");
   let extrasSkipped = 0;
   let extrasUnmapped = 0;
-  if (existsSync40(join47(repo, "path-map.json")) && existsSync40(join47(repo, "shared", "extras"))) {
+  if (existsSync41(join51(repo, "path-map.json")) && existsSync41(join51(repo, "shared", "extras"))) {
     const extrasResult = remapExtrasPull(ts, { dryRun: true });
     for (const entry of extrasResult.wouldPull) {
       addItem(extras, entry);
@@ -6693,9 +7206,9 @@ init_config();
 init_commands_pull_wedge();
 init_utils();
 init_utils_fs();
-import { execFileSync as execFileSync19 } from "node:child_process";
+import { execFileSync as execFileSync21 } from "node:child_process";
 function gitCapture(args, cwd) {
-  return execFileSync19("git", args, {
+  return execFileSync21("git", args, {
     cwd,
     stdio: ["ignore", "pipe", "pipe"],
     maxBuffer: 64 * 1024 * 1024
@@ -6814,6 +7327,7 @@ function recoverForceRemote(mode, repo) {
 }
 
 // src/commands.pull.ts
+init_exit_codes();
 init_utils();
 init_utils_fs();
 init_utils_json();
@@ -6862,7 +7376,7 @@ function handleWedge(repo, forceRemote) {
     if (forceRemote) {
       recoverUnmergedIndex(repo);
     } else {
-      die(unmergedIndexRunbookText("nomad pull"));
+      die(unmergedIndexRunbookText("nomad pull"), { code: EXIT.CONFLICT });
     }
     return;
   }
@@ -6871,7 +7385,7 @@ function handleWedge(repo, forceRemote) {
     return;
   }
   const state = wedge === "rebase" ? "mid-rebase" : "mid-merge";
-  die(wedgeMarkerRunbookText(state));
+  die(wedgeMarkerRunbookText(state), { code: EXIT.CONFLICT });
 }
 function runPullCore(opts = {}) {
   const dryRun = opts.dryRun === true;
@@ -6882,9 +7396,9 @@ function runPullCore(opts = {}) {
   const ts = freshBackupTs(backup);
   handleWedge(repo, forceRemote);
   if (!dryRun) {
-    const backupRoot = join48(backup, ts);
+    const backupRoot = join52(backup, ts);
     try {
-      mkdirSync10(backupRoot, { recursive: true });
+      mkdirSync14(backupRoot, { recursive: true });
     } catch (err) {
       die(`could not create backup dir: ${err.message}`);
     }
@@ -6897,8 +7411,8 @@ function runPullCore(opts = {}) {
   const prePostHeads = capturePrePostHeads(repo, () => {
     gitOrFatal(["pull", "--rebase", "--autostash"], "git pull --rebase", repo);
   });
-  const mapPath = join48(repo, "path-map.json");
-  const map = existsSync41(mapPath) ? readPathMap(mapPath) : { projects: {} };
+  const mapPath = join52(repo, "path-map.json");
+  const map = existsSync42(mapPath) ? readPathMap(mapPath) : { projects: {} };
   const divergedKeptLocal = divergenceCheckExtras(ts, dryRun ? prePostHeads : void 0);
   if (dryRun) {
     computePreview(ts, map, "pull");
@@ -6924,8 +7438,8 @@ function runPullCore(opts = {}) {
 }
 function cmdPull(opts = {}) {
   const repo = repoHome();
-  if (!existsSync41(repo)) die(`repo not cloned at ${repo}`);
-  if (!existsSync41(join48(repo, "shared", "settings.base.json"))) {
+  if (!existsSync42(repo)) die(`repo not cloned at ${repo}`);
+  if (!existsSync42(join52(repo, "shared", "settings.base.json"))) {
     die("repo not initialized; run 'nomad init' to scaffold");
   }
   const handle = acquireLock("pull");
@@ -6936,7 +7450,7 @@ function cmdPull(opts = {}) {
   } catch (err) {
     if (err instanceof NomadFatal) {
       fail(err.message);
-      process.exitCode = 1;
+      process.exitCode = err.code;
     } else {
       throw err;
     }
@@ -6947,13 +7461,13 @@ function cmdPull(opts = {}) {
 
 // src/commands.push.ts
 init_config();
-import { existsSync as existsSync45 } from "node:fs";
-import { join as join53 } from "node:path";
+import { existsSync as existsSync46 } from "node:fs";
+import { join as join57 } from "node:path";
 
 // src/commands.push.selection.ts
 init_config();
-import { existsSync as existsSync42, statSync as statSync11 } from "node:fs";
-import { join as join49 } from "node:path";
+import { existsSync as existsSync43, statSync as statSync12 } from "node:fs";
+import { join as join53 } from "node:path";
 init_utils_json();
 function buildCurrentMap(map) {
   const current = {};
@@ -6962,10 +7476,10 @@ function buildCurrentMap(map) {
   for (const [, hostMap] of Object.entries(map.projects)) {
     const localPath = hostMap[HOST];
     if (!localPath) continue;
-    const localDir = join49(claude, "projects", encodePath(localPath));
-    if (!existsSync42(localDir)) continue;
+    const localDir = join53(claude, "projects", encodePath(localPath));
+    if (!existsSync43(localDir)) continue;
     for (const f of enumerateSourceFiles(localDir)) {
-      const st = statSync11(f);
+      const st = statSync12(f);
       current[f] = { size: st.size, mtime: st.mtimeMs };
     }
   }
@@ -6994,7 +7508,7 @@ function computePushSelection(map, old, scannerVersion, configHash, fullScan) {
   };
 }
 function loadSelectionForPush(mapPath, old, scannerVersion, configHash, fullScan) {
-  const map = existsSync42(mapPath) ? readPathMap(mapPath) : null;
+  const map = existsSync43(mapPath) ? readPathMap(mapPath) : null;
   const { selection, newManifest } = computePushSelection(
     map,
     old,
@@ -7096,14 +7610,14 @@ function enforceAllowList(statusPorcelain, map) {
 
 // src/commands.push.settings.ts
 init_config();
-import { existsSync as existsSync43 } from "node:fs";
-import { join as join50 } from "node:path";
+import { existsSync as existsSync44 } from "node:fs";
+import { join as join54 } from "node:path";
 init_utils();
 init_utils_fs();
 init_utils_json();
 function stripGsdHooksFromBase(repo, backup) {
-  const basePath = join50(repo, "shared", "settings.base.json");
-  if (!existsSync43(basePath)) return;
+  const basePath = join54(repo, "shared", "settings.base.json");
+  if (!existsSync44(basePath)) return;
   let base;
   try {
     base = readJson(basePath);
@@ -7117,14 +7631,14 @@ function stripGsdHooksFromBase(repo, backup) {
   writeJsonAtomic(basePath, stripped);
 }
 function reportSettingsAheadDrift(repo) {
-  const basePath = join50(repo, "shared", "settings.base.json");
-  if (!existsSync43(basePath)) return;
-  const settingsPath = join50(claudeHome(), "settings.json");
-  if (!existsSync43(settingsPath)) return;
+  const basePath = join54(repo, "shared", "settings.base.json");
+  if (!existsSync44(basePath)) return;
+  const settingsPath = join54(claudeHome(), "settings.json");
+  if (!existsSync44(settingsPath)) return;
   try {
     const base = readJson(basePath);
-    const hostPath = join50(repo, "hosts", `${HOST}.json`);
-    const overrides = existsSync43(hostPath) ? readJson(hostPath) : {};
+    const hostPath = join54(repo, "hosts", `${HOST}.json`);
+    const overrides = existsSync44(hostPath) ? readJson(hostPath) : {};
     const merged = deepMerge(base, overrides);
     const settings = readJson(settingsPath);
     const { ahead } = classifySettingsDrift(merged, settings);
@@ -7141,9 +7655,9 @@ function reportSettingsAheadDrift(repo) {
 // src/commands.push.guards.ts
 init_push_checks();
 init_utils();
-import { join as join51, relative as relative7 } from "node:path";
+import { join as join55, relative as relative7 } from "node:path";
 function guardGitlinks(repo) {
-  const gitlinks = findGitlinks(join51(repo, "shared"));
+  const gitlinks = findGitlinks(join55(repo, "shared"));
   if (gitlinks.length === 0) return;
   for (const p of gitlinks) {
     const rel = relative7(repo, p).replaceAll("\\", "/");
@@ -7175,7 +7689,7 @@ init_config();
 
 // src/push-global-config.ts
 init_config();
-import { execFileSync as execFileSync20 } from "node:child_process";
+import { execFileSync as execFileSync22 } from "node:child_process";
 var STATUS_LABELS = {
   A: "add",
   M: "modify",
@@ -7215,7 +7729,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 = execFileSync20("git", args, {
+  const raw = execFileSync22("git", args, {
     cwd: repoHome2,
     stdio: ["ignore", "pipe", "pipe"]
   }).toString();
@@ -7252,10 +7766,10 @@ init_push_leak_verdict();
 init_color();
 init_config();
 init_config_sharedDirs_guard();
-import { randomBytes as randomBytes2 } from "node:crypto";
-import { copyFileSync, existsSync as existsSync44, mkdirSync as mkdirSync11, readdirSync as readdirSync17, rmSync as rmSync15 } from "node:fs";
-import { homedir as homedir5 } from "node:os";
-import { join as join52, relative as relative8, sep as sep9 } from "node:path";
+import { randomBytes as randomBytes4 } from "node:crypto";
+import { copyFileSync, existsSync as existsSync45, mkdirSync as mkdirSync15, readdirSync as readdirSync17, rmSync as rmSync17 } from "node:fs";
+import { homedir as homedir7 } from "node:os";
+import { join as join56, relative as relative8, sep as sep10 } from "node:path";
 init_push_leak_verdict();
 init_push_gitleaks();
 init_utils_fs();
@@ -7263,11 +7777,11 @@ init_utils_json();
 var NOTHING_TO_SCAN_ROW = `${dim(infoGlyph)} nothing to scan, no leaks`;
 function stageSessionDir(localDir, dstDir, changed) {
   if (changed !== void 0) {
-    const prefix = `${localDir}${sep9}`;
+    const prefix = `${localDir}${sep10}`;
     const matching = [...changed].filter((p) => p.startsWith(prefix));
     if (matching.length === 0) return false;
     for (const src of matching) {
-      copyFileAtomic(src, join52(dstDir, relative8(localDir, src)));
+      copyFileAtomic(src, join56(dstDir, relative8(localDir, src)));
     }
     return true;
   }
@@ -7283,14 +7797,14 @@ function stageSessions(tmpRoot, map, changed) {
     if (!p || p === "TBD") continue;
     reverse.set(encodePath(p), logical);
   }
-  const localProjects = join52(claudeHome(), "projects");
-  if (!existsSync44(localProjects)) return 0;
+  const localProjects = join56(claudeHome(), "projects");
+  if (!existsSync45(localProjects)) return 0;
   let staged = 0;
   for (const dir of readdirSync17(localProjects)) {
     const logical = reverse.get(dir);
     if (!logical) continue;
-    const localDir = join52(localProjects, dir);
-    const dstDir = join52(tmpRoot, "shared", "projects", logical);
+    const localDir = join56(localProjects, dir);
+    const dstDir = join56(tmpRoot, "shared", "projects", logical);
     if (stageSessionDir(localDir, dstDir, changed)) staged++;
   }
   return staged;
@@ -7304,11 +7818,11 @@ function stageExtras(tmpRoot, map) {
     assertSafeLogical(logical);
     const localRoot = map.projects[logical]?.[HOST];
     if (!localRoot || localRoot === "TBD") continue;
-    for (const dirname10 of dirnames) {
-      if (!whitelist.includes(dirname10)) continue;
-      const src = join52(localRoot, dirname10);
-      if (!existsSync44(src)) continue;
-      const dst = join52(tmpRoot, "shared", "extras", logical, dirname10);
+    for (const dirname13 of dirnames) {
+      if (!whitelist.includes(dirname13)) continue;
+      const src = join56(localRoot, dirname13);
+      if (!existsSync45(src)) continue;
+      const dst = join56(tmpRoot, "shared", "extras", logical, dirname13);
       copyExtras(src, dst);
       staged++;
     }
@@ -7316,19 +7830,19 @@ function stageExtras(tmpRoot, map) {
   return staged;
 }
 function previewPushLeaks(map, opts = {}) {
-  const cacheDir = join52(homedir5(), ".cache", "claude-nomad");
-  mkdirSync11(cacheDir, { recursive: true });
-  const stamp = `${nowTimestamp()}-${process.pid}-${randomBytes2(4).toString("hex")}`;
-  const tmpRoot = join52(cacheDir, `push-preview-tree-${stamp}`);
+  const cacheDir = join56(homedir7(), ".cache", "claude-nomad");
+  mkdirSync15(cacheDir, { recursive: true });
+  const stamp = `${nowTimestamp()}-${process.pid}-${randomBytes4(4).toString("hex")}`;
+  const tmpRoot = join56(cacheDir, `push-preview-tree-${stamp}`);
   try {
     const sessionCount = stageSessions(tmpRoot, map, opts.selection?.changed);
     const extrasCount = stageExtras(tmpRoot, map);
     if (sessionCount + extrasCount === 0) {
       return { leak: false, verdictRow: NOTHING_TO_SCAN_ROW, recovery: null, findings: [] };
     }
-    const ignoreFile = join52(repoHome(), ".gitleaksignore");
-    if (existsSync44(ignoreFile)) {
-      copyFileSync(ignoreFile, join52(tmpRoot, ".gitleaksignore"));
+    const ignoreFile = join56(repoHome(), ".gitleaksignore");
+    if (existsSync45(ignoreFile)) {
+      copyFileSync(ignoreFile, join56(tmpRoot, ".gitleaksignore"));
     }
     let findings;
     try {
@@ -7341,7 +7855,7 @@ function previewPushLeaks(map, opts = {}) {
     }
     return verdictFromFindings(findings);
   } finally {
-    rmSync15(tmpRoot, { recursive: true, force: true });
+    rmSync17(tmpRoot, { recursive: true, force: true });
   }
 }
 
@@ -7454,7 +7968,7 @@ async function runPushCore(opts = {}) {
   const scannerVersion = probeGitleaks();
   const configHash = computeConfigHash();
   const old = readManifest(manifestPath());
-  const mapPath = join53(repo, "path-map.json");
+  const mapPath = join57(repo, "path-map.json");
   const { map, selection, newManifest } = loadSelectionForPush(
     mapPath,
     old,
@@ -7505,7 +8019,7 @@ async function cmdPush(opts = {}) {
   const allowRule = opts.allowRule;
   guardResolutionModeConflicts(dryRun, redactAll, allowAll, allowRule);
   const repo = repoHome();
-  if (!existsSync45(repo)) die(`repo not cloned at ${repo}`);
+  if (!existsSync46(repo)) die(`repo not cloned at ${repo}`);
   const handle = acquireLock("push");
   if (handle === null) process.exit(0);
   try {
@@ -7513,7 +8027,7 @@ async function cmdPush(opts = {}) {
   } catch (err) {
     if (err instanceof NomadFatal) {
       fail(err.message);
-      process.exitCode = 1;
+      process.exitCode = err.code;
     } else {
       throw err;
     }
@@ -7523,8 +8037,8 @@ async function cmdPush(opts = {}) {
 }
 
 // src/commands.sync.ts
-import { existsSync as existsSync46 } from "node:fs";
-import { join as join54 } from "node:path";
+import { existsSync as existsSync47 } from "node:fs";
+import { join as join58 } from "node:path";
 init_config();
 init_color();
 init_utils();
@@ -7639,7 +8153,7 @@ async function runSyncPushHalf() {
     return { ok: true, result };
   } catch (err) {
     if (err instanceof NomadFatal) {
-      process.exitCode = 1;
+      process.exitCode = err.code;
       return { ok: false, message: err.message };
     }
     throw err;
@@ -7652,8 +8166,8 @@ async function runSyncWet(verbose) {
 }
 async function runSyncDryRun(repo, backup) {
   const ts = freshBackupTs(backup);
-  const mapPath = join54(repo, "path-map.json");
-  const map = existsSync46(mapPath) ? readPathMap(mapPath) : { projects: {} };
+  const mapPath = join58(repo, "path-map.json");
+  const map = existsSync47(mapPath) ? readPathMap(mapPath) : { projects: {} };
   computePreview(ts, map, "pull");
   log("push preview below is computed against pre-pull state (a real sync pushes after pull)");
   await runPushCore({ dryRun: true });
@@ -7663,8 +8177,8 @@ async function cmdSync(opts = {}) {
   const verbose = opts.verbose === true;
   const repo = repoHome();
   const backup = backupBase();
-  if (!existsSync46(repo)) die(`repo not cloned at ${repo}`);
-  if (!existsSync46(join54(repo, "shared", "settings.base.json"))) {
+  if (!existsSync47(repo)) die(`repo not cloned at ${repo}`);
+  if (!existsSync47(join58(repo, "shared", "settings.base.json"))) {
     die("repo not initialized; run 'nomad init' to scaffold");
   }
   const handle = acquireLock("sync");
@@ -7678,7 +8192,7 @@ async function cmdSync(opts = {}) {
   } catch (err) {
     if (err instanceof NomadFatal) {
       fail(err.message);
-      process.exitCode = 1;
+      process.exitCode = err.code;
     } else {
       throw err;
     }
@@ -7688,9 +8202,9 @@ async function cmdSync(opts = {}) {
 }
 
 // src/commands.update.ts
-import { execFileSync as execFileSync21 } from "node:child_process";
+import { execFileSync as execFileSync23 } from "node:child_process";
 init_utils();
-function readInstalledVersion(run = execFileSync21) {
+function readInstalledVersion(run = execFileSync23) {
   const isWin = process.platform === "win32";
   try {
     return run(isWin ? "nomad.cmd" : "nomad", ["--version"], {
@@ -7701,7 +8215,7 @@ function readInstalledVersion(run = execFileSync21) {
     return null;
   }
 }
-function cmdUpdate(currentVersion, run = execFileSync21) {
+function cmdUpdate(currentVersion, run = execFileSync23) {
   console.log(`Updating claude-nomad v${currentVersion}...`);
   const isWin = process.platform === "win32";
   try {
@@ -7735,26 +8249,191 @@ ${detail}` : "";
 // src/nomad.ts
 init_config();
 
+// src/crash-report.write.ts
+init_config();
+import { mkdirSync as mkdirSync16, readdirSync as readdirSync18, statSync as statSync13, unlinkSync as unlinkSync2, writeFileSync as writeFileSync11 } from "node:fs";
+import { join as join60 } from "node:path";
+
+// src/crash-report.ts
+var CRASH_MAX_STACK_LINES = 50;
+var CRASH_MAX_ARGV = 32;
+var CRASH_MAX_ARGV_TOKEN_LENGTH = 200;
+var CRASH_MAX_REPORT_BYTES = 16384;
+var TRUNCATION_MARKER = "\n[... truncated ...]\n";
+function safeStringify(value) {
+  try {
+    const json = JSON.stringify(value);
+    if (json !== void 0) return json;
+  } catch {
+  }
+  try {
+    return String(value);
+  } catch {
+    return "(unstringifiable thrown value)";
+  }
+}
+function normalizeError(err) {
+  try {
+    if (err instanceof Error) {
+      return { name: err.name, message: err.message, stack: err.stack };
+    }
+  } catch {
+    return { name: "Error", message: "(unreadable Error)", stack: void 0 };
+  }
+  if (typeof err === "string") {
+    return { name: "NonErrorThrow", message: err, stack: void 0 };
+  }
+  return { name: "NonErrorThrow", message: safeStringify(err), stack: void 0 };
+}
+function boundedStack(stack) {
+  if (stack === void 0) return "(no stack available)";
+  return stack.split("\n").slice(0, CRASH_MAX_STACK_LINES).join("\n");
+}
+function clampArgv(argv) {
+  return argv.slice(0, CRASH_MAX_ARGV).map((tok) => {
+    if (tok.length <= CRASH_MAX_ARGV_TOKEN_LENGTH) return tok;
+    return tok.slice(0, CRASH_MAX_ARGV_TOKEN_LENGTH) + "...";
+  });
+}
+function truncateToBytes(text, maxBytes) {
+  if (Buffer.byteLength(text, "utf8") <= maxBytes) return text;
+  const budget = Math.max(0, maxBytes - Buffer.byteLength(TRUNCATION_MARKER, "utf8"));
+  let sliced = text.slice(0, budget);
+  while (Buffer.byteLength(sliced, "utf8") > budget) {
+    sliced = sliced.slice(0, -1);
+  }
+  return sliced + TRUNCATION_MARKER;
+}
+function scrubStructural(text, homeDir, hostLabel) {
+  let out = homeDir.length > 0 ? text.split(homeDir).join("~") : text;
+  if (hostLabel.length > 0) out = out.split(hostLabel).join("<host>");
+  return out;
+}
+function buildCrashReport(input) {
+  const { err, argv, version, platform: platform2, timestamp, homeDir, hostLabel } = input;
+  const normalized = normalizeError(err);
+  const command = clampArgv(argv).join(" ");
+  const stack = boundedStack(normalized.stack);
+  const composed = [
+    "nomad crash report",
+    `version: ${version}`,
+    `command: ${command}`,
+    `error: ${normalized.name}: ${normalized.message}`,
+    "stack:",
+    stack,
+    `platform: ${platform2} (node ${process.version})`,
+    `timestamp: ${timestamp}`
+  ].join("\n");
+  const scrubbed = scrubStructural(composed, homeDir, hostLabel);
+  return truncateToBytes(scrubbed, CRASH_MAX_REPORT_BYTES);
+}
+
+// src/crash-report.redact.ts
+import { mkdtempSync as mkdtempSync2, rmSync as rmSync18, writeFileSync as writeFileSync10 } from "node:fs";
+import { tmpdir as tmpdir2 } from "node:os";
+import { join as join59 } from "node:path";
+init_push_gitleaks_scan();
+var CRASH_SCAN_TIMEOUT_MS = 3e3;
+var SCAN_UNAVAILABLE_ADVISORY = "\n\n[gitleaks value-based scan unavailable; only structural redaction applied. Review before sharing this file publicly.]\n";
+function redactWithGitleaks(text, scan = scanFile) {
+  let dir;
+  try {
+    dir = mkdtempSync2(join59(tmpdir2(), "nomad-crash-scan-"));
+    const tmp = join59(dir, "crash.txt");
+    writeFileSync10(tmp, text, { mode: 384 });
+    const findings = scan(tmp, false, CRASH_SCAN_TIMEOUT_MS);
+    if (findings === null) return text + SCAN_UNAVAILABLE_ADVISORY;
+    return applyRedactions(text, findings);
+  } catch {
+    return text + SCAN_UNAVAILABLE_ADVISORY;
+  } finally {
+    if (dir !== void 0) {
+      try {
+        rmSync18(dir, { recursive: true, force: true });
+      } catch {
+      }
+    }
+  }
+}
+
+// src/crash-report.write.ts
+init_utils_fs();
+init_utils();
+var CRASH_RETENTION_KEEP = 20;
+function listCrashFiles(dir = crashDir()) {
+  try {
+    return readdirSync18(dir).flatMap((name) => {
+      try {
+        return [{ name, mtimeMs: statSync13(join60(dir, name)).mtimeMs }];
+      } catch {
+        return [];
+      }
+    }).sort((a, b) => b.mtimeMs - a.mtimeMs);
+  } catch {
+    return [];
+  }
+}
+function pruneCrashDir(dir, keep = CRASH_RETENTION_KEEP) {
+  const files = listCrashFiles(dir);
+  const targets = prunableByCount(files, keep);
+  for (const name of targets) {
+    try {
+      unlinkSync2(join60(dir, name));
+    } catch {
+    }
+  }
+}
+function writeCrashReport(text, dir = crashDir()) {
+  mkdirSync16(dir, { recursive: true, mode: 448 });
+  const path = join60(dir, `crash-${nowTimestamp()}-${process.pid}.txt`);
+  writeFileSync11(path, text, { mode: 384 });
+  pruneCrashDir(dir);
+  return path;
+}
+function handleCrash(err, argv, opts) {
+  const redact = opts.redact ?? redactWithGitleaks;
+  const write = opts.write ?? writeCrashReport;
+  const now = opts.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
+  try {
+    const report = buildCrashReport({
+      err,
+      argv,
+      version: opts.version,
+      platform: opts.platform,
+      timestamp: now(),
+      homeDir: home(),
+      hostLabel: HOST
+    });
+    const redacted = redact(report);
+    const path = write(redacted);
+    fail("nomad hit an unexpected error. This looks like a bug, not something you did wrong.");
+    item(`Crash report written to: ${path}`);
+    item(`Please consider reporting it at: ${opts.issuesUrl}`);
+  } catch {
+    fail("nomad hit an unexpected error and could not write a crash report.");
+  }
+}
+
 // src/diff.ts
 init_config();
-import { existsSync as existsSync47 } from "node:fs";
-import { join as join55 } from "node:path";
+import { existsSync as existsSync48 } from "node:fs";
+import { join as join61 } from "node:path";
 init_utils();
 init_utils_fs();
 init_utils_json();
 function cmdDiff() {
   try {
     const repo = repoHome();
-    if (!existsSync47(repo)) die(`repo not cloned at ${repo}`);
+    if (!existsSync48(repo)) die(`repo not cloned at ${repo}`);
     const ts = freshBackupTs(backupBase());
-    const mapPath = join55(repo, "path-map.json");
-    const map = existsSync47(mapPath) ? readPathMap(mapPath) : { projects: {} };
+    const mapPath = join61(repo, "path-map.json");
+    const map = existsSync48(mapPath) ? readPathMap(mapPath) : { projects: {} };
     divergenceCheckExtras(ts);
     computePreview(ts, map, "diff");
   } catch (err) {
     if (err instanceof NomadFatal) {
       fail(err.message);
-      process.exitCode = 1;
+      process.exitCode = err.code;
       return;
     }
     throw err;
@@ -7763,19 +8442,19 @@ function cmdDiff() {
 
 // src/init.ts
 init_config();
-import { existsSync as existsSync49, mkdirSync as mkdirSync12, writeFileSync as writeFileSync6 } from "node:fs";
-import { join as join57 } from "node:path";
+import { existsSync as existsSync50, mkdirSync as mkdirSync17, writeFileSync as writeFileSync12 } from "node:fs";
+import { join as join63 } from "node:path";
 
 // src/init.gh-onboard.ts
 init_config();
-import { execFileSync as execFileSync22 } from "node:child_process";
+import { execFileSync as execFileSync24 } 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 = execFileSync22) {
+function ensureOriginRepo(repoName, run = execFileSync24) {
   if (!isValidRepoName(repoName)) {
     die(
       `invalid repo name: ${JSON.stringify(repoName)}. Use only letters, digits, hyphens, underscores, and dots (1-100 chars).`
@@ -7846,33 +8525,33 @@ init_config();
 init_utils();
 init_utils_fs();
 init_utils_json();
-import { copyFileSync as copyFileSync2, cpSync as cpSync8, existsSync as existsSync48, rmSync as rmSync16, statSync as statSync12 } from "node:fs";
-import { join as join56 } from "node:path";
+import { copyFileSync as copyFileSync2, cpSync as cpSync10, existsSync as existsSync49, rmSync as rmSync19, statSync as statSync14 } from "node:fs";
+import { join as join62 } from "node:path";
 function snapshotIntoShared(map) {
   const repo = repoHome();
   const claude = claudeHome();
   for (const name of allSharedLinks(map)) {
-    const src = join56(claude, name);
-    if (!existsSync48(src)) continue;
-    const dst = join56(repo, "shared", name);
-    if (statSync12(src).isDirectory()) {
-      const gk = join56(dst, ".gitkeep");
-      if (existsSync48(gk)) rmSync16(gk);
-      cpSync8(src, dst, { recursive: true, force: false, errorOnExist: true });
+    const src = join62(claude, name);
+    if (!existsSync49(src)) continue;
+    const dst = join62(repo, "shared", name);
+    if (statSync14(src).isDirectory()) {
+      const gk = join62(dst, ".gitkeep");
+      if (existsSync49(gk)) rmSync19(gk);
+      cpSync10(src, dst, { recursive: true, force: false, errorOnExist: true });
     } else {
       copyFileSync2(src, dst);
     }
     log(`snapshotted shared/${name} from ${src}`);
   }
-  const userSettings = join56(claude, "settings.json");
-  if (existsSync48(userSettings)) {
+  const userSettings = join62(claude, "settings.json");
+  if (existsSync49(userSettings)) {
     let parsed;
     try {
       parsed = readJson(userSettings);
     } catch (err) {
       return die(`malformed ${userSettings}: ${err.message}`);
     }
-    const hostFile = join56(repo, "hosts", `${HOST}.json`);
+    const hostFile = join62(repo, "hosts", `${HOST}.json`);
     writeJsonAtomic(hostFile, parsed);
     log(`snapshotted hosts/${HOST}.json from ${userSettings}`);
   }
@@ -7886,14 +8565,14 @@ var GITATTRIBUTES = "# nomad: sync content is byte-managed, disable all line-end
 var SHARED_KEEP_DIRS = ["agents", "skills", "commands", "rules", "hooks"];
 function preflightConflict(repoHome2) {
   const candidates = [
-    join57(repoHome2, "shared", "settings.base.json"),
-    join57(repoHome2, "shared", "CLAUDE.md"),
-    join57(repoHome2, "path-map.json"),
-    join57(repoHome2, "hosts"),
-    join57(repoHome2, "shared")
+    join63(repoHome2, "shared", "settings.base.json"),
+    join63(repoHome2, "shared", "CLAUDE.md"),
+    join63(repoHome2, "path-map.json"),
+    join63(repoHome2, "hosts"),
+    join63(repoHome2, "shared")
   ];
   for (const c of candidates) {
-    if (existsSync49(c)) return c;
+    if (existsSync50(c)) return c;
   }
   return null;
 }
@@ -7905,33 +8584,33 @@ function cmdInit(opts = {}) {
   const keepActions = opts.keepActions === true;
   const repo = repoHome();
   const claude = claudeHome();
-  mkdirSync12(repo, { recursive: true });
+  mkdirSync17(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);
-  mkdirSync12(join57(repo, "shared"), { recursive: true });
-  mkdirSync12(join57(repo, "hosts"), { recursive: true });
+  mkdirSync17(join63(repo, "shared"), { recursive: true });
+  mkdirSync17(join63(repo, "hosts"), { recursive: true });
   for (const name of SHARED_KEEP_DIRS) {
-    mkdirSync12(join57(repo, "shared", name), { recursive: true });
+    mkdirSync17(join63(repo, "shared", name), { recursive: true });
   }
-  const userClaudeMd = join57(claude, "CLAUDE.md");
-  if (!snapshot || !existsSync49(userClaudeMd)) {
-    writeFileSync6(join57(repo, "shared", "CLAUDE.md"), SHARED_CLAUDE_MD);
+  const userClaudeMd = join63(claude, "CLAUDE.md");
+  if (!snapshot || !existsSync50(userClaudeMd)) {
+    writeFileSync12(join63(repo, "shared", "CLAUDE.md"), SHARED_CLAUDE_MD);
     item("created shared/CLAUDE.md");
   }
   for (const name of SHARED_KEEP_DIRS) {
-    writeFileSync6(join57(repo, "shared", name, ".gitkeep"), "");
+    writeFileSync12(join63(repo, "shared", name, ".gitkeep"), "");
     item(`created shared/${name}/.gitkeep`);
   }
-  writeFileSync6(join57(repo, "hosts", ".gitkeep"), "");
+  writeFileSync12(join63(repo, "hosts", ".gitkeep"), "");
   item("created hosts/.gitkeep");
-  writeJsonAtomic(join57(repo, "shared", "settings.base.json"), {});
+  writeJsonAtomic(join63(repo, "shared", "settings.base.json"), {});
   item("created shared/settings.base.json");
-  writeJsonAtomic(join57(repo, "path-map.json"), { projects: {} });
+  writeJsonAtomic(join63(repo, "path-map.json"), { projects: {} });
   item("created path-map.json");
-  writeFileSync6(join57(repo, ".gitattributes"), GITATTRIBUTES);
+  writeFileSync12(join63(repo, ".gitattributes"), GITATTRIBUTES);
   item("created .gitattributes");
   if (snapshot) {
     snapshotIntoShared({ projects: {} });
@@ -7997,21 +8676,21 @@ function maybeDisableRepoActions(repoHome2, run) {
 // src/init.prompt.ts
 init_config();
 init_utils();
-import { existsSync as existsSync50, readdirSync as readdirSync18, statSync as statSync13 } from "node:fs";
-import { join as join58 } from "node:path";
+import { existsSync as existsSync51, readdirSync as readdirSync19, statSync as statSync15 } from "node:fs";
+import { join as join64 } from "node:path";
 import { createInterface as createInterface3 } from "node:readline/promises";
 function nonEmptyExists(path) {
-  if (!existsSync50(path)) return false;
+  if (!existsSync51(path)) return false;
   try {
-    if (statSync13(path).isDirectory()) return readdirSync18(path).length > 0;
+    if (statSync15(path).isDirectory()) return readdirSync19(path).length > 0;
     return true;
   } catch {
     return false;
   }
 }
 function hasExistingClaudeConfig(claudeHome2) {
-  if (existsSync50(join58(claudeHome2, "settings.json"))) return true;
-  return SHARED_LINKS.some((name) => nonEmptyExists(join58(claudeHome2, name)));
+  if (existsSync51(join64(claudeHome2, "settings.json"))) return true;
+  return SHARED_LINKS.some((name) => nonEmptyExists(join64(claudeHome2, name)));
 }
 async function confirmSnapshotDefault(claudeHome2) {
   if (process.stdin.isTTY !== true || process.stdout.isTTY !== true) {
@@ -8318,7 +8997,7 @@ function parseSyncArgs(argv) {
 // package.json
 var package_default = {
   name: "claude-nomad",
-  version: "0.60.0",
+  version: "0.62.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: [
@@ -8401,7 +9080,7 @@ var package_default = {
     globals: "^17.6.0",
     husky: "^9.1.7",
     "lint-staged": "^17.0.5",
-    "markdownlint-cli2": "^0.23.0",
+    "markdownlint-cli2": "^0.23.1",
     picocolors: "^1.1.1",
     prettier: "^3.8.3",
     typescript: "^6.0.3",
@@ -8559,15 +9238,15 @@ var DEFAULT_HELP = [
 init_config();
 init_utils();
 init_utils_json();
-import { existsSync as existsSync51, readFileSync as readFileSync18, readdirSync as readdirSync19 } from "node:fs";
-import { join as join59 } from "node:path";
+import { existsSync as existsSync52, readFileSync as readFileSync20, readdirSync as readdirSync20 } from "node:fs";
+import { join as join65 } 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 = join59(claudeHome(), "projects");
-  if (!existsSync51(projectsRoot)) {
+  const projectsRoot = join65(claudeHome(), "projects");
+  if (!existsSync52(projectsRoot)) {
     fail(`${projectsRoot} does not exist`);
     process.exit(1);
   }
@@ -8581,8 +9260,8 @@ function resumeCmd(sessionId) {
     fail(`no cwd field found in ${jsonlPath}`);
     process.exit(1);
   }
-  const mapPath = join59(repoHome(), "path-map.json");
-  if (!existsSync51(mapPath)) {
+  const mapPath = join65(repoHome(), "path-map.json");
+  if (!existsSync52(mapPath)) {
     fail("path-map.json missing");
     process.exit(1);
   }
@@ -8604,14 +9283,14 @@ function resumeCmd(sessionId) {
   console.log(`cd ${shQuote(hit.localPath)} && claude --resume ${shQuote(sessionId)}`);
 }
 function findTranscriptPath(projectsRoot, sessionId) {
-  for (const dir of readdirSync19(projectsRoot)) {
-    const candidate = join59(projectsRoot, dir, `${sessionId}.jsonl`);
-    if (existsSync51(candidate)) return candidate;
+  for (const dir of readdirSync20(projectsRoot)) {
+    const candidate = join65(projectsRoot, dir, `${sessionId}.jsonl`);
+    if (existsSync52(candidate)) return candidate;
   }
   return null;
 }
 function extractRecordedCwd(jsonlPath) {
-  for (const line of readFileSync18(jsonlPath, "utf8").split("\n")) {
+  for (const line of readFileSync20(jsonlPath, "utf8").split("\n")) {
     if (!line.trim()) continue;
     try {
       const obj = JSON.parse(line);
@@ -8641,20 +9320,45 @@ function shQuote(s) {
 
 // src/nomad.ts
 init_utils();
+init_exit_codes();
+function handleTopLevelError(err) {
+  if (isProcessExit(err)) throw err;
+  if (err instanceof NomadFatal) {
+    fail(err.message);
+    process.exit(err.code);
+  }
+  const issuesUrl = package_default.bugs?.url ?? "https://github.com/funkadelic/claude-nomad/issues";
+  handleCrash(err, process.argv, {
+    version: package_default.version,
+    platform: process.platform,
+    issuesUrl
+  });
+  process.exit(EXIT.GENERIC_FAILURE);
+}
+process.on("uncaughtException", handleTopLevelError);
+process.on("unhandledRejection", handleTopLevelError);
 var h = home();
 if (!h) {
   fail(
     "could not determine home directory (HOME env unset and no uid mapping). Set HOME and retry."
   );
-  process.exit(1);
+  process.exit(EXIT.GENERIC_FAILURE);
 }
 try {
+  if (process.env.NOMAD_TEST_FORCE_CRASH) {
+    throw new Error("forced test crash (NOMAD_TEST_FORCE_CRASH)");
+  }
+  if (process.env.NOMAD_TEST_FORCE_ASYNC_CRASH) {
+    setImmediate(() => {
+      void Promise.reject(new Error("forced test async crash (NOMAD_TEST_FORCE_ASYNC_CRASH)"));
+    });
+  }
   const cmd = process.argv[2];
   switch (cmd) {
     case "--version":
       if (process.argv.length !== 3) {
         console.error("usage: nomad --version (no extra arguments)");
-        process.exit(1);
+        process.exit(EXIT.USAGE);
       }
       console.log(package_default.version);
       break;
@@ -8662,7 +9366,7 @@ try {
       const pullArgs = parsePullArgs(process.argv);
       if (pullArgs === null) {
         console.error("usage: nomad pull [--dry-run] [--force-remote]");
-        process.exit(1);
+        process.exit(EXIT.USAGE);
       }
       cmdPull({ dryRun: pullArgs.dryRun, forceRemote: pullArgs.forceRemote });
       break;
@@ -8673,7 +9377,7 @@ try {
         console.error(
           "usage: nomad push [--dry-run] [--full-scan] [--redact-all] [--allow <rule>] [--allow-all]"
         );
-        process.exit(1);
+        process.exit(EXIT.USAGE);
       }
       await cmdPush({
         dryRun: pushArgs.dryRun,
@@ -8688,7 +9392,7 @@ try {
       const syncArgs = parseSyncArgs(process.argv);
       if (syncArgs === null) {
         console.error("usage: nomad sync [--dry-run] [--verbose|--all|-v]");
-        process.exit(1);
+        process.exit(EXIT.USAGE);
       }
       await cmdSync({ dryRun: syncArgs.dryRun, verbose: syncArgs.verbose });
       break;
@@ -8697,7 +9401,7 @@ try {
       const initArgs = parseInitArgs(process.argv);
       if (initArgs === null) {
         console.error("usage: nomad init [--snapshot] [--keep-actions] [--repo <name>]");
-        process.exit(1);
+        process.exit(EXIT.USAGE);
       }
       const snapshot = isAlreadyInitialized(repoHome()) ? initArgs.snapshot : await resolveSnapshotChoice(initArgs.snapshot, claudeHome());
       cmdInit({
@@ -8710,14 +9414,14 @@ try {
     case "diff":
       if (process.argv.length > 3) {
         console.error("usage: nomad diff");
-        process.exit(1);
+        process.exit(EXIT.USAGE);
       }
       cmdDiff();
       break;
     case "update": {
       if (process.argv.length !== 3) {
         console.error("usage: nomad update");
-        process.exit(1);
+        process.exit(EXIT.USAGE);
       }
       cmdUpdate(package_default.version);
       break;
@@ -8727,7 +9431,7 @@ try {
       const sub = process.argv[4];
       if (typeof name !== "string" || name.length === 0 || name.startsWith("-") || sub !== void 0 && (sub !== "--dry-run" || process.argv.length !== 5)) {
         console.error("usage: nomad adopt <name> [--dry-run]");
-        process.exit(1);
+        process.exit(EXIT.USAGE);
       }
       cmdAdopt(name, { dryRun: sub === "--dry-run" });
       break;
@@ -8736,7 +9440,7 @@ try {
       const ejectArgs = parseEjectArgs(process.argv);
       if (ejectArgs === null) {
         console.error("usage: nomad eject [--dry-run]");
-        process.exit(1);
+        process.exit(EXIT.USAGE);
       }
       cmdEject({ dryRun: ejectArgs.dryRun });
       break;
@@ -8745,7 +9449,7 @@ try {
       const captureArgs = parseCaptureSettingsArgs(process.argv);
       if (captureArgs === null) {
         console.error("usage: nomad capture-settings [--host] [--dry-run] [--yes]");
-        process.exit(1);
+        process.exit(EXIT.USAGE);
       }
       await cmdCaptureSettings({
         host: captureArgs.host,
@@ -8760,7 +9464,7 @@ try {
         console.error(
           "usage: nomad doctor [--check-shared] [--check-schema] [--check-remote] [--verbose|--all|-v] | --resume-cmd <session-id>"
         );
-        process.exit(1);
+        process.exit(EXIT.USAGE);
       } else if (parsed.kind === "resume") {
         resumeCmd(parsed.id);
       } else {
@@ -8777,7 +9481,7 @@ try {
       const id = process.argv[3];
       if (process.argv.length !== 4 || typeof id !== "string" || !/^\w[\w-]{0,127}$/.test(id)) {
         console.error("usage: nomad drop-session <id>");
-        process.exit(1);
+        process.exit(EXIT.USAGE);
       }
       cmdDropSession(id);
       break;
@@ -8786,7 +9490,7 @@ try {
       const redactArgs = parseRedactArgs(process.argv);
       if (redactArgs === null) {
         console.error("usage: nomad redact <session-id> [--rule <rule-id>] [--dry-run]");
-        process.exit(1);
+        process.exit(EXIT.USAGE);
       }
       cmdRedact(redactArgs);
       break;
@@ -8795,7 +9499,7 @@ try {
       const allowArgs = parseAllowArgs(process.argv);
       if (allowArgs === null) {
         console.error("usage: nomad allow <fingerprint> [<fingerprint>...]");
-        process.exit(1);
+        process.exit(EXIT.USAGE);
       }
       cmdAllow(allowArgs);
       break;
@@ -8804,19 +9508,15 @@ try {
       const cleanArgs = parseCleanArgs(process.argv);
       if (cleanArgs === null) {
         console.error("usage: nomad clean --backups [--dry-run] [--older-than <dur> | --keep <N>]");
-        process.exit(1);
+        process.exit(EXIT.USAGE);
       }
       cmdClean(cleanArgs);
       break;
     }
     default:
       console.error(DEFAULT_HELP);
-      process.exit(1);
+      process.exit(EXIT.USAGE);
   }
 } catch (err) {
-  if (err instanceof NomadFatal) {
-    fail(err.message);
-    process.exit(1);
-  }
-  throw err;
+  handleTopLevelError(err);
 }