claude-nomad 0.51.0 → 0.52.0

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [0.52.0](https://github.com/funkadelic/claude-nomad/compare/v0.51.1...v0.52.0) (2026-06-19)
+
+
+### Added
+
+* stop syncing gsd-owned hook entries from settings.base.json ([#317](https://github.com/funkadelic/claude-nomad/issues/317)) ([31f5f79](https://github.com/funkadelic/claude-nomad/commit/31f5f79b16245dd792a12a7fc315661c34bae610))
+
+## [0.51.1](https://github.com/funkadelic/claude-nomad/compare/v0.51.0...v0.51.1) (2026-06-18)
+
+
+### Fixed
+
+* **doctor:** handle diverged settings keys honestly instead of advising blind pull ([#315](https://github.com/funkadelic/claude-nomad/issues/315)) ([39f8148](https://github.com/funkadelic/claude-nomad/commit/39f81480285693e08575f5ab4ecbb8b182eeb233))
+
 ## [0.51.0](https://github.com/funkadelic/claude-nomad/compare/v0.50.3...v0.51.0) (2026-06-18)
 
 

package/README.md

@@ -33,6 +33,10 @@ survives different file paths and your secrets never ride along.
   churn). Skills sync as a filtered copy: your own skills travel, `gsd-*` skills are excluded (see
   `SHARED_LINKS` and `src/skills-sync.ts` in `src/config.ts`). Settings merge a shared base with a
   per-host override, so one machine can run a different model or MCP URL without forking the rest.
+  GSD-owned hook entries (scripts whose basename starts with `gsd-`) are filtered out of the
+  generated `~/.claude/settings.json` during pull and stripped from `shared/settings.base.json` on
+  the next push; GSD reinstalls the correct per-host hook set itself. A non-gsd hook you add to your
+  live settings syncs normally via `nomad capture-settings`.
 - **Every push is secret-scanned.** Only an explicit allow-list of paths ever leaves the machine,
   credentials never sync, and gitleaks scans the exact files about to be published. The push aborts
   on any hit, with an interactive menu to redact, allow, or drop the finding.

package/dist/nomad.mjs

@@ -1270,6 +1270,102 @@ import { existsSync as existsSync5 } from "node:fs";
 import { join as join7 } from "node:path";
 import { createInterface } from "node:readline/promises";
 
+// src/hooks-filter.ts
+init_config();
+var KNOWN_LAUNCHER_BASENAMES = /* @__PURE__ */ new Set(["node", "bash", "sh"]);
+function scriptBasename(token) {
+  const lastSlash = Math.max(token.lastIndexOf("/"), token.lastIndexOf("\\"));
+  return lastSlash >= 0 ? token.slice(lastSlash + 1) : token;
+}
+function isGsdHookEntry(command) {
+  const tokens = command.trim().split(/\s+/);
+  if (tokens.length === 0 || tokens[0] === "") return false;
+  const envAssign = /^[A-Za-z_]\w*=/;
+  let i = 0;
+  while (i < tokens.length && envAssign.test(tokens[i])) {
+    i++;
+  }
+  const first = tokens[i] ?? "";
+  const firstBase = scriptBasename(first);
+  const firstHasPath = first.includes("/") || first.includes("\\");
+  if (firstHasPath && !KNOWN_LAUNCHER_BASENAMES.has(firstBase) || first.startsWith(GSD_PREFIX)) {
+    return firstBase.startsWith(GSD_PREFIX);
+  }
+  for (let j = i + 1; j < tokens.length; j++) {
+    if (tokens[j].startsWith("-")) continue;
+    return scriptBasename(tokens[j]).startsWith(GSD_PREFIX);
+  }
+  return false;
+}
+function filterMatcherEntry(entry) {
+  if (entry === null || typeof entry !== "object" || Array.isArray(entry)) return entry;
+  const entryObj = entry;
+  if (!Array.isArray(entryObj.hooks)) return entryObj;
+  const innerHooks = entryObj.hooks;
+  const kept = innerHooks.filter((h2) => {
+    if (h2 === null || typeof h2 !== "object" || Array.isArray(h2)) return true;
+    const hookObj = h2;
+    const cmd = hookObj.command;
+    return !isGsdHookEntry(typeof cmd === "string" ? cmd : "");
+  });
+  if (kept.length === 0) return null;
+  return { ...entryObj, hooks: kept };
+}
+function filterEventMatchers(matchers) {
+  if (!Array.isArray(matchers)) return matchers;
+  const kept = [];
+  for (const entry of matchers) {
+    const result = filterMatcherEntry(entry);
+    if (result != null) kept.push(result);
+  }
+  return kept.length === 0 ? null : kept;
+}
+function stripGsdHookEntries(settings) {
+  const out = {};
+  for (const [key, value] of Object.entries(settings)) {
+    if (key !== "hooks") {
+      out[key] = value;
+      continue;
+    }
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+      out[key] = value;
+      continue;
+    }
+    const hooksObj = value;
+    const filteredHooks = {};
+    for (const [event, matchers] of Object.entries(hooksObj)) {
+      const filtered = filterEventMatchers(matchers);
+      if (filtered !== null) filteredHooks[event] = filtered;
+    }
+    if (Object.keys(filteredHooks).length > 0) out[key] = filteredHooks;
+  }
+  return out;
+}
+function matcherHasGsdEntry(entry) {
+  if (entry === null || typeof entry !== "object" || Array.isArray(entry)) return false;
+  const entryObj = entry;
+  if (!Array.isArray(entryObj.hooks)) return false;
+  for (const h2 of entryObj.hooks) {
+    if (h2 === null || typeof h2 !== "object" || Array.isArray(h2)) continue;
+    const hookObj = h2;
+    const cmd = hookObj.command;
+    if (isGsdHookEntry(typeof cmd === "string" ? cmd : "")) return true;
+  }
+  return false;
+}
+function baseHasGsdHookEntries(settings) {
+  const hooksVal = settings.hooks;
+  if (hooksVal === null || typeof hooksVal !== "object" || Array.isArray(hooksVal)) return false;
+  const hooksObj = hooksVal;
+  for (const matchers of Object.values(hooksObj)) {
+    if (!Array.isArray(matchers)) continue;
+    for (const entry of matchers) {
+      if (matcherHasGsdEntry(entry)) return true;
+    }
+  }
+  return false;
+}
+
 // src/commands.capture-settings.core.ts
 function arraysEqual(a, b) {
   if (a.length !== b.length) return false;
@@ -1299,19 +1395,24 @@ function deepEqual(a, b) {
   return false;
 }
 function classifySettingsDrift(merged, settings) {
+  const filteredMerged = stripGsdHookEntries(merged);
+  const filteredSettings = stripGsdHookEntries(settings);
   const behind = [];
   const ahead = [];
   const changed = [];
-  const settingsKeys = new Set(Object.keys(settings));
-  for (const key of Object.keys(merged)) {
+  const settingsKeys = new Set(Object.keys(filteredSettings));
+  for (const key of Object.keys(filteredMerged)) {
     if (!settingsKeys.has(key)) {
       behind.push(key);
-    } else if (!deepEqual(merged[key], settings[key])) {
+    } else if (!deepEqual(
+      normalizeNodePathsDeep(filteredMerged[key]),
+      normalizeNodePathsDeep(filteredSettings[key])
+    )) {
       changed.push(key);
     }
   }
-  const mergedKeys = new Set(Object.keys(merged));
-  for (const key of Object.keys(settings)) {
+  const mergedKeys = new Set(Object.keys(filteredMerged));
+  for (const key of Object.keys(filteredSettings)) {
     if (!mergedKeys.has(key)) ahead.push(key);
   }
   const collator = (a, b) => a.localeCompare(b, "en");
@@ -1337,10 +1438,13 @@ function partitionByCaptureExclusion(keys) {
   }
   return { promotable, excluded };
 }
-var BIN_NODE_RE = /^(?:[A-Za-z]:)?[\\/](?:.*[\\/])?bin[\\/]node$/;
+var BIN_NODE_RE = /^"?(?:[A-Za-z]:)?[\\/](?:.*[\\/])?bin[\\/]node"?$/;
+var LEADING_BIN_NODE_RE = /^"?(?:[A-Za-z]:)?[\\/](?:[^"\s]*[\\/])?bin[\\/]node"?(?=\s)/;
 function normalizeNodePathsDeep(value) {
   if (typeof value === "string") {
-    return BIN_NODE_RE.test(value) ? "node" : value;
+    if (BIN_NODE_RE.test(value)) return "node";
+    const lead = LEADING_BIN_NODE_RE.exec(value);
+    return lead ? "node" + value.slice(lead[0].length) : value;
   }
   if (Array.isArray(value)) {
     return value.map(normalizeNodePathsDeep);
@@ -1355,11 +1459,12 @@ function normalizeNodePathsDeep(value) {
   return value;
 }
 function buildCaptureSubset(merged, settings, opts) {
+  const filtered = stripGsdHookEntries(settings);
   const { ahead } = classifySettingsDrift(merged, settings);
   const out = {};
   for (const key of ahead) {
     if (CAPTURE_EXCLUDED_KEYS.has(key)) continue;
-    const raw = settings[key];
+    const raw = filtered[key];
     out[key] = opts.normalizeNodePath ? normalizeNodePathsDeep(raw) : raw;
   }
   return out;
@@ -1462,7 +1567,7 @@ function regenerateSettings(ts, opts = {}) {
     return { label: overrideLabel };
   }
   backupBeforeWrite(settingsPath, ts);
-  writeJsonAtomic(settingsPath, merged);
+  writeJsonAtomic(settingsPath, stripGsdHookEntries(merged));
   return { label: overrideLabel };
 }
 
@@ -3204,6 +3309,16 @@ function tryReadJson(filePath) {
     return null;
   }
 }
+function reportHooksBaseSelfCleanNote(section2) {
+  const basePath = join28(repoHome(), "shared", "settings.base.json");
+  const base = tryReadJson(basePath);
+  if (base === null) return;
+  if (!baseHasGsdHookEntries(base)) return;
+  addItem(
+    section2,
+    `${dim(infoGlyph)} gsd now owns hook entries per-host; shared/settings.base.json self-cleans on your next 'nomad push'`
+  );
+}
 function reportSettingsDriftCheck(section2) {
   const claude = claudeHome();
   const repo = repoHome();
@@ -3258,7 +3373,7 @@ function emitDriftRows(section2, missing, changed, promotable, excluded, hostFil
   if (changed.length > 0) {
     addItem(
       section2,
-      `${yellow(warnGlyph)} settings.json drift: merged keys with changed values: ${changed.join(", ")} (run 'nomad pull')`
+      `${yellow(warnGlyph)} settings.json drift: ${changed.join(", ")} diverged from the base+host merge (run 'nomad diff' to inspect; 'nomad pull' overwrites local with the repo, or edit the base/host file to keep local)`
     );
   }
   if (promotable.length > 0 && hostFileExists) {
@@ -4335,6 +4450,7 @@ function gatherDoctorSections(opts) {
   const parsedSettings = loadAndReportSettings(settings);
   reportHostOverrides(settings, base, parsedSettings);
   reportSettingsDriftCheck(settings);
+  reportHooksBaseSelfCleanNote(settings);
   const pathMap = section("Path map");
   reportPathMap(pathMap);
   const neverSync = section("Never-sync");
@@ -5988,6 +6104,21 @@ function previewPushLeaks(map) {
 init_utils();
 init_utils_fs();
 init_utils_json();
+function stripGsdHooksFromBase(repo, backup) {
+  const basePath = join46(repo, "shared", "settings.base.json");
+  if (!existsSync39(basePath)) return;
+  let base;
+  try {
+    base = readJson(basePath);
+  } catch {
+    return;
+  }
+  if (!baseHasGsdHookEntries(base)) return;
+  const stripped = stripGsdHookEntries(base);
+  const ts = freshBackupTs(backup);
+  backupRepoWrite(basePath, ts, repo);
+  writeJsonAtomic(basePath, stripped);
+}
 function reportSettingsAheadDrift(repo) {
   const basePath = join46(repo, "shared", "settings.base.json");
   if (!existsSync39(basePath)) return;
@@ -6087,7 +6218,10 @@ async function cmdPush(opts = {}) {
     const ts = freshBackupTs(backup);
     const remap = withSpinner("Syncing sessions", () => remapPush(ts, { dryRun }));
     const extras = withSpinner("Syncing extras", () => remapExtrasPush(ts, { dryRun }));
-    if (!dryRun) syncSkillsPush();
+    if (!dryRun) {
+      syncSkillsPush();
+      stripGsdHooksFromBase(repo, backup);
+    }
     const st = { dryRun, remap, extras, globalConfig: [] };
     guardGitlinks(repo);
     const status = gitStatusPorcelainZ(repo, { untrackedAll: true });
@@ -6660,7 +6794,7 @@ function parsePushArgs(argv) {
 // package.json
 var package_default = {
   name: "claude-nomad",
-  version: "0.51.0",
+  version: "0.52.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: [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-nomad",
-  "version": "0.51.0",
+  "version": "0.52.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": [