claude-nomad 0.59.0 → 0.60.0

package/CHANGELOG.md

@@ -1,5 +1,27 @@
 # Changelog
 
+## [0.60.0](https://github.com/funkadelic/claude-nomad/compare/v0.59.0...v0.60.0) (2026-07-15)
+
+
+### Added
+
+* **links:** preserve live gsd hook entries across regenerateSettings ([#421](https://github.com/funkadelic/claude-nomad/issues/421)) ([10a18ca](https://github.com/funkadelic/claude-nomad/commit/10a18ca7ed6c1851cdc43e46ad616527d41a1f92))
+* **sync:** compact output with merged tree and no-op collapse ([#415](https://github.com/funkadelic/claude-nomad/issues/415)) ([9bb9cdd](https://github.com/funkadelic/claude-nomad/commit/9bb9cdd7e901ea463d5c1fb5b66ffc39b2864f8a))
+* **sync:** compact summary-only output by default, add --verbose ([#420](https://github.com/funkadelic/claude-nomad/issues/420)) ([b5b95b3](https://github.com/funkadelic/claude-nomad/commit/b5b95b372634a0b372023b399e7f16bb0063ff74))
+
+
+### Changed
+
+* **lint:** enable sonarjs recommended ruleset with triaged exclusions ([#422](https://github.com/funkadelic/claude-nomad/issues/422)) ([f92fce8](https://github.com/funkadelic/claude-nomad/commit/f92fce8533e06814d5e3f58c1f120adf3e00ded7))
+* **tests:** make Defender exclusion step non-fatal ([#419](https://github.com/funkadelic/claude-nomad/issues/419)) ([413a906](https://github.com/funkadelic/claude-nomad/commit/413a9065ef152dfaedd76b325de749070e2165ab))
+
+
+### Testing
+
+* **integration:** cover extras deny-set, host overrides, and skills sync in round-trip ([#418](https://github.com/funkadelic/claude-nomad/issues/418)) ([70074b5](https://github.com/funkadelic/claude-nomad/commit/70074b5c5a8831a93726576e346e7e89ac511ffa))
+* **pull:** fix flaky incomingChanges tests via shared mock instance ([#417](https://github.com/funkadelic/claude-nomad/issues/417)) ([6589887](https://github.com/funkadelic/claude-nomad/commit/6589887d0ac1c77f7696b89a1a518e469e913dae))
+* **vitest:** raise subprocess project maxWorkers to 2 ([#423](https://github.com/funkadelic/claude-nomad/issues/423)) ([8fa28b5](https://github.com/funkadelic/claude-nomad/commit/8fa28b5a2ef4cae4816f5b6ad23bf90189a611d1))
+
 ## [0.59.0](https://github.com/funkadelic/claude-nomad/compare/v0.58.1...v0.59.0) (2026-07-14)
 
 

package/README.md

@@ -174,12 +174,13 @@ $ nomad sync     # pull config, then publish local changes, in one step
 
 `nomad sync` is the command to reach for day to day: it always pulls first (so changes from your
 other machines land before anything is pushed, and work that exists only on this machine is kept,
-not deleted) and then pushes, under one lock, so there is no ordering to remember. `nomad pull` and
-`nomad push` are still available as lower-level commands for cases `sync` does not cover: recovering
-a wedged repo with `nomad pull --force-remote`, or resolving a detected secret without the
-interactive menu via `nomad push --redact-all` / `--allow` / `--allow-all` (see
-[Changing settings](#changing-settings) and
-[Recovery flows](https://funkadelic.github.io/claude-nomad/recovery/)). The
+not deleted) and then pushes, under one lock, so there is no ordering to remember. Output is compact
+by default: a run prints only a short Sync summary, not the full status tree; pass
+`nomad sync --verbose` (or `--all` / `-v`) to see the full tree. `nomad pull` and `nomad push` are
+still available as lower-level commands for cases `sync` does not cover: recovering a wedged repo
+with `nomad pull --force-remote`, or resolving a detected secret without the interactive menu via
+`nomad push --redact-all` / `--allow` / `--allow-all` (see [Changing settings](#changing-settings)
+and [Recovery flows](https://funkadelic.github.io/claude-nomad/recovery/)). The
 [FAQ](https://funkadelic.github.io/claude-nomad/faq/) covers what `sync` does under the hood and the
 push/pull order it enforces.
 

package/dist/nomad.mjs

@@ -1353,6 +1353,75 @@ function stripGsdHookEntries(settings) {
   }
   return out;
 }
+function keepMatcherEntry(entry) {
+  if (entry === null || typeof entry !== "object" || Array.isArray(entry)) return null;
+  const entryObj = entry;
+  if (!Array.isArray(entryObj.hooks)) return null;
+  const innerHooks = entryObj.hooks;
+  const kept = innerHooks.filter((h2) => {
+    if (h2 === null || typeof h2 !== "object" || Array.isArray(h2)) return false;
+    const hookObj = h2;
+    const cmd = hookObj.command;
+    return isGsdHookEntry(typeof cmd === "string" ? cmd : "");
+  });
+  if (kept.length === 0) return null;
+  return { ...entryObj, hooks: kept };
+}
+function keepEventMatchers(matchers) {
+  if (!Array.isArray(matchers)) return null;
+  const kept = [];
+  for (const entry of matchers) {
+    const result = keepMatcherEntry(entry);
+    if (result !== null) kept.push(result);
+  }
+  return kept.length === 0 ? null : kept;
+}
+function keepGsdHookEntries(settings) {
+  const hooksVal = settings.hooks;
+  if (hooksVal === null || typeof hooksVal !== "object" || Array.isArray(hooksVal)) return {};
+  const hooksObj = hooksVal;
+  const keptHooks = {};
+  for (const [event, matchers] of Object.entries(hooksObj)) {
+    const kept = keepEventMatchers(matchers);
+    if (kept !== null) keptHooks[event] = kept;
+  }
+  return Object.keys(keptHooks).length === 0 ? {} : { hooks: keptHooks };
+}
+function asPlainObject(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return null;
+  return value;
+}
+function canonicalMatcherKey(m) {
+  const obj = asPlainObject(m);
+  if (obj === null) return JSON.stringify(m);
+  return JSON.stringify(
+    Object.keys(obj).sort((a, b) => a.localeCompare(b)).map((k) => [k, obj[k]])
+  );
+}
+function unionMatcherArrays(baseMatchers, gsdMatchers) {
+  const seen = new Set(baseMatchers.map(canonicalMatcherKey));
+  const merged = [...baseMatchers];
+  for (const m of gsdMatchers) {
+    const key = canonicalMatcherKey(m);
+    if (!seen.has(key)) {
+      merged.push(m);
+      seen.add(key);
+    }
+  }
+  return merged;
+}
+function graftGsdHookEntries(base, gsdOnly) {
+  const gsdHooks = asPlainObject(gsdOnly.hooks);
+  if (gsdHooks === null || Object.keys(gsdHooks).length === 0) return base;
+  const baseHooks = asPlainObject(base.hooks);
+  const mergedHooks = baseHooks ? { ...baseHooks } : {};
+  for (const [event, gsdMatchers] of Object.entries(gsdHooks)) {
+    if (!Array.isArray(gsdMatchers)) continue;
+    const baseMatchers = mergedHooks[event];
+    mergedHooks[event] = Array.isArray(baseMatchers) ? unionMatcherArrays(baseMatchers, gsdMatchers) : gsdMatchers;
+  }
+  return { ...base, hooks: mergedHooks };
+}
 function matcherHasGsdEntry(entry) {
   if (entry === null || typeof entry !== "object" || Array.isArray(entry)) return false;
   const entryObj = entry;
@@ -1804,6 +1873,34 @@ function syncSharedLinksPush(map) {
     copyExtrasFiltered(localPath, join5(repo, "shared", name), ALWAYS_NEVER_SYNC);
   }
 }
+function readExistingSettings(settingsPath) {
+  if (!existsSync4(settingsPath)) return { existing: {}, present: false, malformed: false };
+  try {
+    const parsed = readJson(settingsPath);
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return { existing: {}, present: true, malformed: true };
+    }
+    return { existing: parsed, present: true, malformed: false };
+  } catch {
+    return { existing: {}, present: true, malformed: true };
+  }
+}
+function emitDriftWarnings(merged, existing) {
+  const drift = classifySettingsDrift(merged, existing);
+  if (drift.behind.length > 0) {
+    const { phrase, pronoun } = describeSettings(drift.behind);
+    warn(
+      `your settings.json is missing ${phrase} that the synced copy has; run 'nomad pull' to restore ${pronoun}.`
+    );
+  }
+  const { promotable } = partitionByCaptureExclusion(drift.ahead);
+  if (promotable.length > 0) {
+    const { phrase, pronoun, verb } = describeSettings(promotable);
+    warn(
+      `your settings.json has ${phrase} that ${verb} not yet synced; run 'nomad capture-settings' to save ${pronoun} to the repo before the next pull overwrites ${pronoun}.`
+    );
+  }
+}
 function regenerateSettings(ts, opts = {}) {
   const dryRun = opts.dryRun === true;
   const suppressDriftWarn = opts.suppressDriftWarn === true;
@@ -1819,25 +1916,12 @@ function regenerateSettings(ts, opts = {}) {
   const overrides = hasOverrides ? readJson(hostPath) : {};
   const merged = deepMerge(base, overrides);
   const settingsPath = join5(claude, "settings.json");
-  if (!suppressDriftWarn && existsSync4(settingsPath)) {
-    try {
-      const existing = readJson(settingsPath);
-      const drift = classifySettingsDrift(merged, existing);
-      if (drift.behind.length > 0) {
-        const { phrase, pronoun } = describeSettings(drift.behind);
-        warn(
-          `your settings.json is missing ${phrase} that the synced copy has; run 'nomad pull' to restore ${pronoun}.`
-        );
-      }
-      const { promotable } = partitionByCaptureExclusion(drift.ahead);
-      if (promotable.length > 0) {
-        const { phrase, pronoun, verb } = describeSettings(promotable);
-        warn(
-          `your settings.json has ${phrase} that ${verb} not yet synced; run 'nomad capture-settings' to save ${pronoun} to the repo before the next pull overwrites ${pronoun}.`
-        );
-      }
-    } catch {
+  const { existing, present, malformed } = readExistingSettings(settingsPath);
+  if (!suppressDriftWarn && present) {
+    if (malformed) {
       warn("existing settings.json is malformed; skipping drift-check and regenerating.");
+    } else {
+      emitDriftWarnings(merged, existing);
     }
   }
   const overrideLabel = hasOverrides ? `${HOST}.json` : "no host overrides";
@@ -1846,7 +1930,10 @@ function regenerateSettings(ts, opts = {}) {
     return { label: overrideLabel };
   }
   backupBeforeWrite(settingsPath, ts);
-  writeJsonAtomic(settingsPath, stripGsdHookEntries(merged));
+  writeJsonAtomic(
+    settingsPath,
+    graftGsdHookEntries(stripGsdHookEntries(merged), keepGsdHookEntries(existing))
+  );
   return { label: overrideLabel };
 }
 
@@ -5818,19 +5905,25 @@ function summarySection(st) {
   addItem(s, summaryRow("push", unmapped, st.remap.collisions, st.extras.skipped));
   return s;
 }
-function renderPushTree(st, verdict) {
+function buildPushTreeSections(st, verdict) {
   const leakScan = section("Leak scan");
   addItem(leakScan, verdict.verdictRow);
-  renderTree([...syncedSections(st), leakScan, summarySection(st)]);
+  return [...syncedSections(st), leakScan, summarySection(st)];
 }
-function renderNoScanTree(st, opts = {}) {
+function renderPushTree(st, verdict) {
+  renderTree(buildPushTreeSections(st, verdict));
+}
+function buildNoScanSections(st, opts = {}) {
   const sections = [];
   if (opts.noMapHint === true) {
     const pathMap = section("Path map");
     addItem(pathMap, `${dim(infoGlyph)} no path-map.json (nothing to preview)`);
     sections.push(pathMap);
   }
-  renderTree([...sections, ...syncedSections(st), summarySection(st)]);
+  return [...sections, ...syncedSections(st), summarySection(st)];
+}
+function renderNoScanTree(st, opts = {}) {
+  renderTree(buildNoScanSections(st, opts));
 }
 
 // src/commands.pull.ts
@@ -6746,17 +6839,9 @@ function buildWetPullSections(ts, map, prePostHeads) {
   const remapResult = withSpinner("Syncing sessions", () => remapPull(ts));
   const extrasResult = remapExtrasPull(ts, { prePostHeads });
   const localOnly = scanLocalOnly();
+  const unmapped = remapResult.unmapped + extrasResult.unmapped;
   const summary = section(PULL_SUMMARY_HEADER);
-  addItem(
-    summary,
-    summaryRow(
-      "pull",
-      remapResult.unmapped + extrasResult.unmapped,
-      0,
-      extrasResult.skipped,
-      localOnly
-    )
-  );
+  addItem(summary, summaryRow("pull", unmapped, 0, extrasResult.skipped, localOnly));
   return {
     sections: [
       buildSettingsSection(label),
@@ -6764,7 +6849,10 @@ function buildWetPullSections(ts, map, prePostHeads) {
       buildExtrasSection(extrasResult.pulled, extrasResult.skipped),
       summary
     ],
-    localOnly
+    localOnly,
+    settingsLabel: label,
+    unmapped,
+    extrasSkipped: extrasResult.skipped
   };
 }
 function handleWedge(repo, forceRemote) {
@@ -6788,6 +6876,7 @@ function handleWedge(repo, forceRemote) {
 function runPullCore(opts = {}) {
   const dryRun = opts.dryRun === true;
   const forceRemote = opts.forceRemote === true;
+  const compose = opts.compose === true;
   const repo = repoHome();
   const backup = backupBase();
   const ts = freshBackupTs(backup);
@@ -6800,9 +6889,11 @@ function runPullCore(opts = {}) {
       die(`could not create backup dir: ${err.message}`);
     }
   }
-  log(
-    dryRun ? `pulling on host=${HOST} (backup=${ts}; dry-run)` : `pull on host=${HOST} (backup=${ts})`
-  );
+  if (!compose) {
+    log(
+      dryRun ? `pulling on host=${HOST} (backup=${ts}; dry-run)` : `pull on host=${HOST} (backup=${ts})`
+    );
+  }
   const prePostHeads = capturePrePostHeads(repo, () => {
     gitOrFatal(["pull", "--rebase", "--autostash"], "git pull --rebase", repo);
   });
@@ -6814,8 +6905,22 @@ function runPullCore(opts = {}) {
     log("dry-run complete; no mutation");
     return { tag: "dry" };
   }
-  const { sections, localOnly } = buildWetPullSections(ts, map, prePostHeads);
-  return { tag: "wet", sections, localOnly, divergedKeptLocal };
+  const { sections, localOnly, settingsLabel, unmapped, extrasSkipped } = buildWetPullSections(
+    ts,
+    map,
+    prePostHeads
+  );
+  const incomingChanges = prePostHeads === void 0 ? true : prePostHeads.pre !== prePostHeads.post;
+  return {
+    tag: "wet",
+    sections,
+    localOnly,
+    divergedKeptLocal,
+    incomingChanges,
+    settingsLabel,
+    unmapped,
+    extrasSkipped
+  };
 }
 function cmdPull(opts = {}) {
   const repo = repoHome();
@@ -7242,7 +7347,7 @@ function previewPushLeaks(map, opts = {}) {
 
 // src/commands.push.steps.ts
 init_utils();
-async function commitAndPush(st, ts, map, resolution, repo, newManifest) {
+async function commitAndPush(st, ts, map, resolution, repo, newManifest, render) {
   gitOrFatal(["add", "-A"], "git add", repo);
   const staged = parsePorcelainZ2(gitStatusPorcelainZ(repo));
   const toDrop = staged.filter((p) => isGsdDropped(p));
@@ -7250,13 +7355,18 @@ async function commitAndPush(st, ts, map, resolution, repo, newManifest) {
     gitOrFatal(["restore", "--staged", "--", ...toDrop], "git restore --staged", repo);
   }
   if (staged.length === toDrop.length) {
-    log("nothing to commit");
-    renderNoScanTree(st);
-    return "nothing";
+    const sections2 = buildNoScanSections(st);
+    if (render) {
+      log("nothing to commit");
+      renderTree(sections2);
+    }
+    return { outcome: "nothing", sections: sections2 };
   }
   st.globalConfig = collectGlobalConfigChanges(repo, HOST, { staged: true });
   let verdict = withSpinner("Scanning for secrets", () => scanPushVerdict(repo));
+  const hadLeak = verdict.leak;
   if (verdict.leak) {
+    if (!render) log("push (leak recovery)");
     renderPushTree(st, verdict);
     verdict = await resolveLeakFindings(verdict, ts, map, resolution);
   }
@@ -7267,8 +7377,13 @@ async function commitAndPush(st, ts, map, resolution, repo, newManifest) {
   } catch (err) {
     warn(`could not write push manifest (next push will full-rescan): ${String(err)}`);
   }
-  renderPushTree(st, verdict);
-  return "pushed";
+  if (hadLeak) {
+    renderPushTree(st, verdict);
+    return { outcome: "pushed", sections: [] };
+  }
+  const sections = buildPushTreeSections(st, verdict);
+  if (render) renderTree(sections);
+  return { outcome: "pushed", sections };
 }
 function runDryRunPreview(st, map, repo, selection) {
   st.globalConfig = collectGlobalConfigChanges(repo, HOST, { staged: false });
@@ -7285,15 +7400,56 @@ function runDryRunPreview(st, map, repo, selection) {
 init_push_checks();
 init_utils();
 init_utils_fs();
+function aheadOfUpstream(repo) {
+  try {
+    const raw = gitCaptureRaw(["rev-list", "--count", "@{u}..HEAD"], repo);
+    return Number.parseInt(raw.trim(), 10) > 0;
+  } catch {
+    return false;
+  }
+}
+function emptyStatusResult(st, compose, repo) {
+  if (compose) {
+    return {
+      tag: "nothing",
+      sections: buildNoScanSections(st),
+      aheadOfOrigin: aheadOfUpstream(repo),
+      globalConfigCount: st.globalConfig.length,
+      collisions: st.remap.collisions
+    };
+  }
+  log("nothing to commit");
+  renderNoScanTree(st);
+  return { tag: "nothing" };
+}
+function toPushCoreResult(outcome, sections, compose, repo, st) {
+  if (!compose) return { tag: outcome };
+  const globalConfigCount = st.globalConfig.length;
+  const collisions = st.remap.collisions;
+  if (outcome === "nothing") {
+    return {
+      tag: "nothing",
+      sections,
+      aheadOfOrigin: aheadOfUpstream(repo),
+      globalConfigCount,
+      collisions
+    };
+  }
+  return { tag: "pushed", sections, globalConfigCount, collisions };
+}
 async function runPushCore(opts = {}) {
   const dryRun = opts.dryRun === true;
   const redactAll = opts.redactAll === true;
   const allowAll = opts.allowAll === true;
   const allowRule = opts.allowRule;
   const fullScan = opts.fullScan === true;
+  const compose = opts.compose === true;
+  const render = !compose;
   const repo = repoHome();
   const backup = backupBase();
-  console.log(dryRun ? `push on host=${HOST} (dry-run)` : `push on host=${HOST}`);
+  if (!compose) {
+    console.log(dryRun ? `push on host=${HOST} (dry-run)` : `push on host=${HOST}`);
+  }
   reportSettingsAheadDrift(repo);
   const scannerVersion = probeGitleaks();
   const configHash = computeConfigHash();
@@ -7318,11 +7474,7 @@ async function runPushCore(opts = {}) {
   const st = { dryRun, remap, extras, globalConfig: [] };
   guardGitlinks(repo);
   const status = gitStatusPorcelainZ(repo, { untrackedAll: true });
-  if (!dryRun && !status) {
-    log("nothing to commit");
-    renderNoScanTree(st);
-    return { tag: "nothing" };
-  }
+  if (!dryRun && !status) return emptyStatusResult(st, compose, repo);
   if (map === null) {
     if (dryRun) {
       runDryRunPreview(st, null, repo, selection);
@@ -7335,15 +7487,16 @@ async function runPushCore(opts = {}) {
     runDryRunPreview(st, map, repo, selection);
     return { tag: "dry" };
   }
-  const outcome = await commitAndPush(
+  const { outcome, sections } = await commitAndPush(
     st,
     ts,
     map,
     { redactAll, allowAll, allowRule },
     repo,
-    newManifest
+    newManifest,
+    render
   );
-  return outcome === "nothing" ? { tag: "nothing" } : { tag: "pushed" };
+  return toPushCoreResult(outcome, sections, compose, repo, st);
 }
 async function cmdPush(opts = {}) {
   const dryRun = opts.dryRun === true;
@@ -7373,33 +7526,56 @@ async function cmdPush(opts = {}) {
 import { existsSync as existsSync46 } from "node:fs";
 import { join as join54 } from "node:path";
 init_config();
+init_color();
 init_utils();
 init_utils_fs();
 init_utils_json();
-function pullHasNoSyncedItems(sections) {
-  return sections.every(
-    (s) => s.header === "Settings" || s.header === PULL_SUMMARY_HEADER || s.items.length === 0
-  );
-}
 function isNoopSync(pull, pushOutcome) {
   if (!pushOutcome.ok) return false;
   if (pull.localOnly !== 0 || pull.divergedKeptLocal !== 0) return false;
   if (pushOutcome.result.tag !== "nothing") return false;
-  return pullHasNoSyncedItems(pull.sections);
+  if (pushOutcome.result.aheadOfOrigin === true) return false;
+  return !pull.incomingChanges;
 }
-function pullPhrase(pull) {
-  const summary = pull.sections.find((s) => s.header === PULL_SUMMARY_HEADER);
-  return summary?.items[0] ?? "applied";
+function buildPullSummaryRow(pull) {
+  const applied = pull.incomingChanges ? "upstream changes applied" : "no upstream changes";
+  return `pull: ${applied}; settings regenerated (base + ${pull.settingsLabel})`;
 }
-function reconciledNotes(pull) {
-  const notes = [];
+function countNoun(n, singular, plural) {
+  return `${n} ${n === 1 ? singular : plural}`;
+}
+function pushedParenParts(pull, globalConfigCount) {
+  const parts = [];
+  if (pull.localOnly > 0) {
+    parts.push(countNoun(pull.localOnly, "local-only session", "local-only sessions"));
+  }
   if (pull.divergedKeptLocal > 0) {
-    notes.push(`${pull.divergedKeptLocal} diverged files kept local and pushed`);
+    parts.push(countNoun(pull.divergedKeptLocal, "diverged extras file", "diverged extras files"));
   }
-  if (pull.localOnly > 0) {
-    notes.push(`${pull.localOnly} local-only sessions pushed`);
+  if (globalConfigCount > 0) {
+    parts.push(countNoun(globalConfigCount, "config file", "config files"));
+  }
+  return parts;
+}
+function buildPushSummaryRow(pull, result) {
+  if (result.tag !== "pushed") return "push: nothing to push";
+  const parts = pushedParenParts(pull, result.globalConfigCount ?? 0);
+  return parts.length > 0 ? `push: pushed (${parts.join(", ")})` : "push: pushed";
+}
+function buildSkipAndCollisionRows(pull, result) {
+  const rows = [];
+  if (pull.unmapped > 0) {
+    rows.push(`${dim(infoGlyph)} ${pull.unmapped} not in path-map (run nomad doctor to list)`);
+  }
+  if (pull.extrasSkipped > 0) {
+    rows.push(`${dim(infoGlyph)} ${pull.extrasSkipped} extras skipped`);
+  }
+  const collisions = result.tag === "dry" ? void 0 : result.collisions;
+  if (collisions !== void 0 && collisions > 0) {
+    const phrase = countNoun(collisions, "collision", "collisions");
+    rows.push(`${yellow(warnGlyph)} ${phrase} (run nomad doctor to list)`);
   }
-  return notes;
+  return rows;
 }
 function buildSyncSummarySection(pull, pushOutcome) {
   const s = section("Sync summary");
@@ -7407,22 +7583,59 @@ function buildSyncSummarySection(pull, pushOutcome) {
     addItem(s, `pull: applied, push: failed (${pushOutcome.message})`);
     return s;
   }
-  addItem(s, `pull: ${pullPhrase(pull)}`);
-  addItem(s, `push: ${pushOutcome.result.tag === "pushed" ? "pushed" : "nothing to push"}`);
-  for (const note of reconciledNotes(pull)) addItem(s, note);
+  const { result } = pushOutcome;
+  addItem(s, buildPullSummaryRow(pull));
+  addItem(s, buildPushSummaryRow(pull, result));
+  if (result.tag === "nothing" && result.aheadOfOrigin === true) {
+    addItem(s, "sync repo has unpushed commits");
+  }
+  for (const row2 of buildSkipAndCollisionRows(pull, result)) addItem(s, row2);
   return s;
 }
-function renderWetSync(pull, pushOutcome) {
+var SYNC_SECTION_ORDER = ["Settings", "Global config", "Sessions", "Extras", "Leak scan"];
+function isDroppedSummaryHeader(header) {
+  return header === PULL_SUMMARY_HEADER || header === "Push summary";
+}
+function mergeSyncSections(pullSections, pushSections) {
+  const byHeader = new Map(
+    SYNC_SECTION_ORDER.map((header) => [header, section(header)])
+  );
+  for (const s of [...pullSections, ...pushSections]) {
+    if (isDroppedSummaryHeader(s.header)) continue;
+    let target = byHeader.get(s.header);
+    if (target === void 0) {
+      target = section(s.header);
+      byHeader.set(s.header, target);
+    }
+    for (const item2 of s.items) {
+      if (!target.items.includes(item2)) addItem(target, item2);
+    }
+  }
+  return [...byHeader.values()].filter((s) => s.items.length > 0);
+}
+function pushSectionsOf(pushOutcome) {
+  if (!pushOutcome.ok) return [];
+  const result = pushOutcome.result;
+  if (result.tag === "dry") return [];
+  return result.sections ?? [];
+}
+function renderWetSync(pull, pushOutcome, verbose) {
   if (isNoopSync(pull, pushOutcome)) {
     ok("already in sync");
     return;
   }
-  renderTree(pull.sections);
-  renderTree([buildSyncSummarySection(pull, pushOutcome)]);
+  log(`sync on host=${HOST}`);
+  const summary = buildSyncSummarySection(pull, pushOutcome);
+  if (!verbose) {
+    renderTree([summary]);
+    return;
+  }
+  const merged = mergeSyncSections(pull.sections, pushSectionsOf(pushOutcome));
+  renderTree([...merged, summary]);
 }
 async function runSyncPushHalf() {
   try {
-    const result = await runPushCore();
+    const result = await runPushCore({ compose: true });
     return { ok: true, result };
   } catch (err) {
     if (err instanceof NomadFatal) {
@@ -7432,10 +7645,10 @@ async function runSyncPushHalf() {
     throw err;
   }
 }
-async function runSyncWet() {
-  const pull = runPullCore();
+async function runSyncWet(verbose) {
+  const pull = runPullCore({ compose: true });
   const pushOutcome = await runSyncPushHalf();
-  renderWetSync(pull, pushOutcome);
+  renderWetSync(pull, pushOutcome, verbose);
 }
 async function runSyncDryRun(repo, backup) {
   const ts = freshBackupTs(backup);
@@ -7447,6 +7660,7 @@ async function runSyncDryRun(repo, backup) {
 }
 async function cmdSync(opts = {}) {
   const dryRun = opts.dryRun === true;
+  const verbose = opts.verbose === true;
   const repo = repoHome();
   const backup = backupBase();
   if (!existsSync46(repo)) die(`repo not cloned at ${repo}`);
@@ -7459,7 +7673,7 @@ async function cmdSync(opts = {}) {
     if (dryRun) {
       await runSyncDryRun(repo, backup);
     } else {
-      await runSyncWet();
+      await runSyncWet(verbose);
     }
   } catch (err) {
     if (err instanceof NomadFatal) {
@@ -8084,24 +8298,27 @@ function parsePushArgs(argv) {
 // src/nomad.dispatch.sync.ts
 function parseSyncArgs(argv) {
   let dryRun = false;
+  let verbose = false;
   let i = 3;
   while (i < argv.length) {
     const token = argv[i];
     if (token === "--dry-run") {
       if (dryRun) return null;
       dryRun = true;
+    } else if (token === "--verbose" || token === "--all" || token === "-v") {
+      verbose = true;
     } else {
       return null;
     }
     i++;
   }
-  return { dryRun };
+  return { dryRun, verbose };
 }
 
 // package.json
 var package_default = {
   name: "claude-nomad",
-  version: "0.59.0",
+  version: "0.60.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: [
@@ -8236,10 +8453,15 @@ var DEFAULT_HELP = [
   cont("Mutually exclusive with --redact-all/--allow. Cannot combine with --dry-run."),
   "",
   row("  sync", "Pull (retain-merge), then push, under one lock. One-shot; hides ordering."),
+  cont("Compact by default: prints only the Sync summary."),
   row("       --dry-run", "Stack the pull preview then the push preview; mutates nothing."),
   cont("Fails fast on a pull-half error; a wedged repo hints at nomad pull --force-remote"),
   cont("(sync itself takes no --force-remote). Mid-push leak recovery behaves exactly"),
   cont("like nomad push."),
+  row(
+    "       --verbose, --all, -v",
+    "Show the full merged tree; default output is the Sync summary only."
+  ),
   "",
   row("  diff", "Offline preview of what `pull` would change against local repo state."),
   cont("No git pull, no lock acquired."),
@@ -8465,10 +8687,10 @@ try {
     case "sync": {
       const syncArgs = parseSyncArgs(process.argv);
       if (syncArgs === null) {
-        console.error("usage: nomad sync [--dry-run]");
+        console.error("usage: nomad sync [--dry-run] [--verbose|--all|-v]");
         process.exit(1);
       }
-      await cmdSync({ dryRun: syncArgs.dryRun });
+      await cmdSync({ dryRun: syncArgs.dryRun, verbose: syncArgs.verbose });
       break;
     }
     case "init": {

package/package.json

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