baldart 5.1.0 → 5.2.1

package/src/utils/git.js

@@ -209,10 +209,13 @@ class GitUtils {
   //   - subtree-merge:  `git subtree pull --squash` merge commits
   //   - subtree-squash: the squash payload commits themselves
   //   - chore-wrapper:  CLI-generated [CHORE]/chore(baldart): commits
-  //   - absorbed:       a would-be custom commit whose touched .framework/ files
-  //                     are now byte-identical to upstream (FETCH_HEAD) — the edit
-  //                     has been absorbed into upstream (or reset away), so a
-  //                     re-sync loses nothing. Pure history, not live drift → noise.
+  //   - absorbed:       a would-be custom commit whose touched .framework/ PAYLOAD
+  //                     files are now byte-identical to upstream (FETCH_HEAD) — the
+  //                     edit has been absorbed into upstream (or reset away), so a
+  //                     re-sync loses nothing. Consumer files (outside .framework/)
+  //                     and subtree bookkeeping (VERSION/CHANGELOG/README) are not
+  //                     counted (see absorbablePayloadSubset). Pure history, not
+  //                     live drift → noise.
   //   - custom-overlay-able: user edited a framework agent/skill/command
   //                          → should migrate to .baldart/overlays/
   //   - custom-other:   anything else (src/, CHANGELOG, ad-hoc fixes)
@@ -297,18 +300,51 @@ class GitUtils {
     });
   }
 
-  // True when EVERY touched `.framework/` file's content at HEAD is already
+  // The subset of a commit's touched paths whose byte-content must match
+  // upstream for the commit to count as "absorbed". Two classes of path are
+  // EXCLUDED because they can never conflict in a `.framework/` subtree sync:
+  //   1. Anything outside `.framework/` — the consumer's OWN files. A mixed
+  //      commit that edits both a framework doc and app code (e.g. a FEAT that
+  //      also tweaks a protocol module) is common; the subtree merge never
+  //      touches the app files, so they are irrelevant to whether the commit's
+  //      framework portion is absorbed. (Pre-v5.1.1 the check bailed to
+  //      not-absorbed on the FIRST such path → mixed commits falsely blocked
+  //      the update even when their `.framework/` payload matched upstream.)
+  //   2. Subtree bookkeeping (`.framework/{VERSION,CHANGELOG.md,README.md}`) —
+  //      framework-owned metadata the merge reconciles wholesale, which ALWAYS
+  //      differs across versions (VERSION bumps, CHANGELOG grows). Counting it
+  //      meant any commit touching it (e.g. an add-then-revert pair) could
+  //      never be absorbed. It is never consumer content, so dropping it is
+  //      safe: a hand-edit to it SHOULD be overwritten by upstream anyway.
+  // Pure (no fs / no git) so it stays unit-testable.
+  static absorbablePayloadSubset(touched) {
+    const prefix = `${FRAMEWORK_DIR}/`;
+    const META = new Set([
+      `${prefix}VERSION`,
+      `${prefix}CHANGELOG.md`,
+      `${prefix}README.md`,
+    ]);
+    return (touched || []).filter((p) => p.startsWith(prefix) && !META.has(p));
+  }
+
+  // True when EVERY `.framework/` PAYLOAD file touched by the commit is already
   // byte-identical to the upstream (FETCH_HEAD) blob — i.e. the commit's edit
   // has been fully absorbed into upstream (or reset away) and a re-sync would
   // lose nothing. Compares blob SHAs (cheap, exact). The subtree prefix
   // `.framework/` is stripped to reach the upstream path (FETCH_HEAD has no
-  // `.framework/` prefix). Conservative: any file outside `.framework/`, missing
-  // upstream, or whose SHA differs → not absorbed (real drift, keep flagging).
+  // `.framework/` prefix). The comparison runs over `absorbablePayloadSubset`
+  // ONLY (consumer files + subtree bookkeeping excluded — see there). A commit
+  // whose payload subset is EMPTY (it touched `.framework/` only via bookkeeping
+  // and/or only touched consumer files) carries no subtree drift → absorbed.
+  // Conservative on the payload itself: a file missing at HEAD (deleted) or
+  // missing upstream (net-new), or whose SHA differs → not absorbed (real
+  // drift, keep flagging).
   async isAbsorbedAgainstUpstream(touched) {
     if (!touched || !touched.length) return false;
     const prefix = `${FRAMEWORK_DIR}/`;
-    for (const p of touched) {
-      if (!p.startsWith(prefix)) return false;
+    const payload = GitUtils.absorbablePayloadSubset(touched);
+    if (!payload.length) return true;
+    for (const p of payload) {
       const upstreamPath = p.slice(prefix.length);
       let headSha;
       let upSha;