climaybe 1.5.2 → 1.6.1

package/src/workflows/multi/main-to-staging-stores.yml

@@ -1,7 +1,10 @@
 # climaybe — Main to Staging <store> (Multi-store)
-# When a PR is merged into main (from staging), this workflow
-# opens and auto-merges PRs from main to each staging-<alias> branch.
-# Skips [hotfix-backport] and version-bump commits so multistore-hotfix-to-main syncs are not re-pushed to stores.
+# When main is pushed (e.g. after staging→main merge), syncs main to each staging-<alias>.
+# Root JSON files (config/settings_data.json, templates/*.json, sections/*.json) are ignored:
+# merge brings main in but we immediately restore root from stores/<alias>/ so store-specific data is kept.
+# Runs on every push to main except pure store-sync commits ([stores-to-root], [root-to-stores]), so that:
+# - Version-bump commits: staging-<alias> get the new version.
+# - Hotfix backports (live or staging-<alias> → main): other staging-<alias> get those changes; the store that sent the hotfix is skipped (no need to merge back to the same branch).
 
 name: Main to Staging Stores
 
@@ -15,30 +18,38 @@ concurrency:
   cancel-in-progress: false
 
 jobs:
-  # Gate: skip hotfix backports and version bump commits
+  # Gate: skip only pure store-sync commits. When hotfix-backport, extract source branch alias so we skip merging back into that same store.
   gate:
     runs-on: ubuntu-latest
     outputs:
       should_run: ${{ steps.check.outputs.should_run }}
+      hotfix_source_alias: ${{ steps.check.outputs.hotfix_source_alias }}
     steps:
-      - name: Check commit message
+      - name: Check commit message and hotfix source
         id: check
         run: |
           COMMIT_MSG="${{ github.event.head_commit.message }}"
 
-          if echo "$COMMIT_MSG" | grep -q "\[hotfix-backport\]"; then
-            echo "Skipping — hotfix backport commit"
-            echo "should_run=false" >> $GITHUB_OUTPUT
-          elif echo "$COMMIT_MSG" | grep -q "chore(release): bump version"; then
-            echo "Skipping — version bump commit"
+          if echo "$COMMIT_MSG" | grep -qE "\[skip-store-sync\]|\[stores-to-root\]|\[root-to-stores\]"; then
+            echo "Skipping — store sync commit (avoid loop)"
             echo "should_run=false" >> $GITHUB_OUTPUT
-          elif echo "$COMMIT_MSG" | grep -q "\[skip-store-sync\]"; then
-            echo "Skipping — store sync commit"
-            echo "should_run=false" >> $GITHUB_OUTPUT
-          else
-            echo "should_run=true" >> $GITHUB_OUTPUT
+            echo "hotfix_source_alias=" >> $GITHUB_OUTPUT
+            exit 0
           fi
 
+          echo "should_run=true" >> $GITHUB_OUTPUT
+
+          # If hotfix-backport, extract source branch alias (e.g. staging-norway or live-norway → norway) so we skip that store in sync
+          HOTFIX_SOURCE_ALIAS=""
+          if echo "$COMMIT_MSG" | grep -q "\[hotfix-backport\]"; then
+            SOURCE_BRANCH=$(echo "$COMMIT_MSG" | sed -n 's/.*Merge \([^ ]*\) into main.*/\1/p' | head -1)
+            if [ -n "$SOURCE_BRANCH" ]; then
+              HOTFIX_SOURCE_ALIAS="${SOURCE_BRANCH#staging-}"
+              HOTFIX_SOURCE_ALIAS="${HOTFIX_SOURCE_ALIAS#live-}"
+            fi
+          fi
+          echo "hotfix_source_alias=$HOTFIX_SOURCE_ALIAS" >> $GITHUB_OUTPUT
+
   # Read store list from package.json
   config:
     needs: gate
@@ -60,7 +71,7 @@ jobs:
           echo "stores=$STORES" >> $GITHUB_OUTPUT
           echo "Store aliases: $STORES"
 
-  # Create PRs to each staging-<alias> branch
+  # Merge main into each staging-<alias>; root JSONs ignored (restored from stores/<alias>/). Skip the store that sent the hotfix (no need to merge back).
   sync:
     needs: [gate, config]
     if: needs.gate.outputs.should_run == 'true'
@@ -75,85 +86,61 @@ jobs:
       actions: write
     env:
       GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      HOTFIX_SOURCE_ALIAS: ${{ needs.gate.outputs.hotfix_source_alias }}
     steps:
       - uses: actions/checkout@v4
         with:
           fetch-depth: 0
 
-      - name: Sync main to staging-${{ matrix.store }}
+      - name: Sync main to staging-${{ matrix.store }} (root JSONs ignored)
         run: |
           BRANCH="staging-${{ matrix.store }}"
+          ALIAS="${{ matrix.store }}"
+          STORE_DIR="stores/${ALIAS}"
+
+          if [ -n "$HOTFIX_SOURCE_ALIAS" ] && [ "$HOTFIX_SOURCE_ALIAS" = "$ALIAS" ]; then
+            echo "Hotfix came from staging-$ALIAS or live-$ALIAS, skipping (no need to merge back to same store)."
+            exit 0
+          fi
 
-          # Check if branch exists
           if ! git ls-remote --heads origin "$BRANCH" | grep -q "$BRANCH"; then
             echo "Branch $BRANCH does not exist on remote, skipping."
             exit 0
           fi
 
-          # Check for existing open PR
-          EXISTING_PR=$(gh pr list --base "$BRANCH" --head main --state open --json number --jq '.[0].number' 2>/dev/null || echo "")
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
 
-          if [ -n "$EXISTING_PR" ]; then
-            echo "PR #$EXISTING_PR already exists for main → $BRANCH"
-            # Update the existing PR by force
-            gh pr close "$EXISTING_PR" --delete-branch=false 2>/dev/null || true
+          git fetch origin "$BRANCH"
+          git checkout "$BRANCH"
+          git merge origin/main --no-ff -m "Sync main → $BRANCH" || true
+          if [ $? -ne 0 ]; then
+            echo "Merge had conflicts; aborting. Manual resolution may be needed."
+            git merge --abort 2>/dev/null || true
+            exit 1
           fi
 
-          # Create PR
-          PR_URL=$(gh pr create \
-            --base "$BRANCH" \
-            --head main \
-            --title "Sync main → $BRANCH" \
-            --body "Automated sync from main to $BRANCH after staging merge.
-
-          *Generated by climaybe*" 2>/dev/null || echo "")
-
-          if [ -n "$PR_URL" ]; then
-            echo "Created PR: $PR_URL"
-
-            # Auto-merge
-            PR_NUM=$(echo "$PR_URL" | grep -oP '\d+$')
-            if gh pr merge "$PR_NUM" --merge --admin 2>/dev/null; then
-              echo "Auto-merge succeeded for $BRANCH"
-
-              # Explicitly trigger Stores to Root to avoid missing downstream runs
-              # when merges are performed by GITHUB_TOKEN-based automation.
-              gh workflow run "Stores to Root" --ref "$BRANCH" 2>/dev/null || \
-                echo "Failed to trigger Stores to Root for $BRANCH"
-
-              # Wait for the latest Stores to Root run on this branch to complete,
-              # then trigger PR to Live to keep ordering deterministic.
-              for i in $(seq 1 30); do
-                RUN_STATUS=$(gh run list \
-                  --workflow "Stores to Root" \
-                  --branch "$BRANCH" \
-                  --limit 1 \
-                  --json status,conclusion \
-                  --jq '.[0].status + "|" + (.[0].conclusion // "")' 2>/dev/null || echo "")
-
-                if [ -z "$RUN_STATUS" ]; then
-                  sleep 5
-                  continue
-                fi
-
-                STATUS="${RUN_STATUS%%|*}"
-                CONCLUSION="${RUN_STATUS##*|}"
-
-                if [ "$STATUS" = "completed" ]; then
-                  if [ "$CONCLUSION" = "success" ]; then
-                    gh workflow run "PR to Live" --ref "$BRANCH" 2>/dev/null || \
-                      echo "Failed to trigger PR to Live for $BRANCH"
-                  else
-                    echo "Stores to Root did not succeed for $BRANCH (conclusion: $CONCLUSION)"
+          # Ignore root JSONs: restore from stores/<alias>/ so main's versions are not kept
+          if [ -d "$STORE_DIR" ]; then
+            for DIR in config templates sections; do
+              SRC="${STORE_DIR}/${DIR}"
+              if [ -d "$SRC" ]; then
+                find "$SRC" -name "*.json" | while read -r FILE; do
+                  REL_PATH="${FILE#$STORE_DIR/}"
+                  if [ "$REL_PATH" = "config/settings_schema.json" ]; then
+                    continue
                   fi
-                  break
-                fi
-
-                sleep 5
-              done
-            else
-              echo "Auto-merge failed — manual review may be needed."
+                  mkdir -p "$(dirname "$REL_PATH")"
+                  cp "$FILE" "$REL_PATH"
+                done
+              fi
+            done
+            git add config templates sections 2>/dev/null || true
+            if ! git diff --cached --quiet; then
+              git commit -m "chore: keep store root JSONs from stores/$ALIAS/ [stores-to-root]"
             fi
-          else
-            echo "No changes to sync for $BRANCH"
           fi
+
+          git push origin "$BRANCH" && echo "Pushed $BRANCH" || { echo "Push failed."; exit 1; }
+
+          gh workflow run "PR to Live" --ref "$BRANCH" 2>/dev/null || echo "Failed to trigger PR to Live for $BRANCH"

package/src/workflows/multi/multistore-hotfix-to-main.yml

@@ -1,8 +1,7 @@
 # climaybe — Multistore Hotfix to Main
-# Automatically syncs direct hotfixes from staging-<store> or live-<store> back to main.
+# Syncs hotfixes from staging-<store> or live-<store> back to main.
+# Only when the push is NOT from main (main→staging merge would create a loop).
 # Triggers: push to staging-* or live-*; also after Root to Stores completes (live-*).
-# Merges the store branch into main with [hotfix-backport] so post-merge-tag runs patch bump.
-# main-to-staging-stores skips [hotfix-backport] commits so hotfixes are not re-pushed to stores.
 
 name: Multistore Hotfix to Main
 
@@ -49,8 +48,20 @@ jobs:
         run: |
           SOURCE="${{ steps.ref.outputs.branch }}"
 
-          MERGE_BASE=$(git merge-base origin/main origin/$SOURCE 2>/dev/null || echo "")
+          # Do not backport when this push was a merge FROM main (staging-* or live-*; would loop)
+          if [[ "$SOURCE" == staging-* || "$SOURCE" == live-* ]]; then
+            MAIN_SHA=$(git rev-parse origin/main 2>/dev/null || echo "")
+            if [ -n "$MAIN_SHA" ]; then
+              SECOND_PARENT=$(git rev-parse origin/$SOURCE^2 2>/dev/null || echo "")
+              if [ "$SECOND_PARENT" = "$MAIN_SHA" ]; then
+                echo "needs_backport=false" >> $GITHUB_OUTPUT
+                echo "Push is merge from main into $SOURCE; skipping to avoid loop."
+                exit 0
+              fi
+            fi
+          fi
 
+          MERGE_BASE=$(git merge-base origin/main origin/$SOURCE 2>/dev/null || echo "")
           if [ -z "$MERGE_BASE" ]; then
             echo "needs_backport=false" >> $GITHUB_OUTPUT
             exit 0

package/src/workflows/multi/root-to-stores.yml

@@ -1,7 +1,7 @@
-# climaybe — Root to Stores (Multi-store)
-# When direct commits (hotfixes) land on live-* branches,
-# syncs root JSON files back to stores/<alias>/ directory.
-# This prepares the data for backporting to main.
+# climaybe — Root to Stores / Stores to Root (Multi-store, live-*)
+# Same logic as stores-to-root on staging-*: direction depends on source.
+# Push to live-* from MAIN (merge): copy stores/<alias>/ → root.
+# Push to live-* from ELSEWHERE (direct, Shopify, etc.): copy root → stores/<alias>/.
 
 name: Root to Stores
 
@@ -24,16 +24,30 @@ jobs:
       - uses: actions/checkout@v4
         with:
           token: ${{ secrets.GITHUB_TOKEN }}
+          fetch-depth: 0
 
-      - name: Skip workflow commits
+      - name: Skip if our own sync commit; detect if push from main
         id: gate
         run: |
           COMMIT_MSG="${{ github.event.head_commit.message }}"
           if echo "$COMMIT_MSG" | grep -qE "\[root-to-stores\]|\[stores-to-root\]|\[hotfix-backport\]|chore\(release\)"; then
             echo "skip=true" >> $GITHUB_OUTPUT
+            echo "from_main=false" >> $GITHUB_OUTPUT
+            exit 0
+          fi
+          # Detect: is this push a merge FROM main? (second parent = main)
+          MAIN_SHA=$(git rev-parse origin/main 2>/dev/null || echo "")
+          if [ -z "$MAIN_SHA" ]; then
+            echo "from_main=false" >> $GITHUB_OUTPUT
           else
-            echo "skip=false" >> $GITHUB_OUTPUT
+            SECOND_PARENT=$(git rev-parse HEAD^2 2>/dev/null || echo "")
+            if [ "$SECOND_PARENT" = "$MAIN_SHA" ]; then
+              echo "from_main=true" >> $GITHUB_OUTPUT
+            else
+              echo "from_main=false" >> $GITHUB_OUTPUT
+            fi
           fi
+          echo "skip=false" >> $GITHUB_OUTPUT
 
       - name: Extract store alias
         if: steps.gate.outputs.skip != 'true'
@@ -42,25 +56,59 @@ jobs:
           BRANCH="${{ github.ref_name }}"
           ALIAS="${BRANCH#live-}"
           echo "alias=$ALIAS" >> $GITHUB_OUTPUT
+          echo "Store alias: $ALIAS (from_main=${{ steps.gate.outputs.from_main }})"
 
-      - name: Sync root to stores/<alias>/
-        if: steps.gate.outputs.skip != 'true'
+      # --- When push is FROM MAIN: stores → root ---
+      - name: Sync stores/<alias>/ to root (main merged in)
+        if: steps.gate.outputs.skip != 'true' && steps.gate.outputs.from_main == 'true'
         run: |
           ALIAS="${{ steps.alias.outputs.alias }}"
           STORE_DIR="stores/${ALIAS}"
+          if [ ! -d "$STORE_DIR" ]; then
+            echo "Store directory $STORE_DIR does not exist, skipping."
+            exit 0
+          fi
+          for DIR in config templates sections; do
+            SRC="${STORE_DIR}/${DIR}"
+            if [ -d "$SRC" ]; then
+              find "$SRC" -name "*.json" | while read -r FILE; do
+                REL_PATH="${FILE#$STORE_DIR/}"
+                if [ "$REL_PATH" = "config/settings_schema.json" ]; then
+                  continue
+                fi
+                mkdir -p "$(dirname "$REL_PATH")"
+                cp "$FILE" "$REL_PATH"
+                echo "  Copied: $REL_PATH"
+              done
+            fi
+          done
 
-          # Ensure store directory exists
-          mkdir -p "${STORE_DIR}/config" "${STORE_DIR}/templates" "${STORE_DIR}/sections"
+      - name: Commit stores→root
+        if: steps.gate.outputs.skip != 'true' && steps.gate.outputs.from_main == 'true'
+        run: |
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          git add -A
+          if ! git diff --cached --quiet; then
+            git commit -m "chore: sync stores/${{ steps.alias.outputs.alias }}/ to root [stores-to-root]"
+            git push
+          else
+            echo "No changes to commit."
+          fi
 
-          # Sync directories: config, templates, sections
+      # --- When push is NOT from main: root → stores/<alias>/ ---
+      - name: Sync root to stores/<alias>/ (external push)
+        if: steps.gate.outputs.skip != 'true' && steps.gate.outputs.from_main == 'false'
+        run: |
+          ALIAS="${{ steps.alias.outputs.alias }}"
+          STORE_DIR="stores/${ALIAS}"
+          mkdir -p "${STORE_DIR}/config" "${STORE_DIR}/templates" "${STORE_DIR}/sections"
           for DIR in config templates sections; do
             if [ -d "$DIR" ]; then
               find "$DIR" -name "*.json" | while read -r FILE; do
-                # Skip excluded files
                 if [ "$FILE" = "config/settings_schema.json" ]; then
                   continue
                 fi
-
                 DEST="${STORE_DIR}/${FILE}"
                 mkdir -p "$(dirname "$DEST")"
                 cp "$FILE" "$DEST"
@@ -69,12 +117,11 @@ jobs:
             fi
           done
 
-      - name: Commit changes
-        if: steps.gate.outputs.skip != 'true'
+      - name: Commit root→stores
+        if: steps.gate.outputs.skip != 'true' && steps.gate.outputs.from_main == 'false'
         run: |
           git config user.name "github-actions[bot]"
           git config user.email "github-actions[bot]@users.noreply.github.com"
-
           git add -A
           if ! git diff --cached --quiet; then
             git commit -m "chore: sync root to stores/${{ steps.alias.outputs.alias }}/ [root-to-stores]"

package/src/workflows/multi/stores-to-root.yml

@@ -1,6 +1,7 @@
-# climaybe — Stores to Root (Multi-store)
-# When a push happens on staging-* branches (e.g., after main sync),
-# copies JSON files from stores/<alias>/ to the repo root.
+# climaybe — Stores to Root / Root to Stores (Multi-store, staging-*)
+# Push to staging-* from MAIN (merge): copy stores/<alias>/ → root (store-specific on top of main).
+# Push to staging-* from ELSEWHERE (Shopify, direct, feature branch): copy root → stores/<alias>/
+# so store-specific JSON changes are persisted, then hotfix-to-main can backport.
 
 name: Stores to Root
 
@@ -24,80 +25,80 @@ jobs:
       - uses: actions/checkout@v4
         with:
           token: ${{ secrets.GITHUB_TOKEN }}
-          fetch-depth: 2
+          fetch-depth: 0
 
-      - name: Skip if this is a sync commit
+      - name: Skip if this is our own sync commit
         id: gate
         run: |
-          if [ "${{ github.event_name }}" = "push" ]; then
-            COMMIT_MSG="${{ github.event.head_commit.message }}"
-            if echo "$COMMIT_MSG" | grep -q "\[stores-to-root\]"; then
-              echo "skip=true" >> $GITHUB_OUTPUT
+          if [ "${{ github.event_name }}" = "workflow_dispatch" ]; then
+            echo "skip=false" >> $GITHUB_OUTPUT
+            echo "from_main=false" >> $GITHUB_OUTPUT
+            exit 0
+          fi
+          COMMIT_MSG="${{ github.event.head_commit.message }}"
+          if echo "$COMMIT_MSG" | grep -qE "\[stores-to-root\]|\[root-to-stores\]"; then
+            echo "skip=true" >> $GITHUB_OUTPUT
+            echo "from_main=false" >> $GITHUB_OUTPUT
+            exit 0
+          fi
+          # Detect: is this push a merge FROM main? (merge commit with second parent = main)
+          MAIN_SHA=$(git rev-parse origin/main 2>/dev/null || echo "")
+          if [ -z "$MAIN_SHA" ]; then
+            echo "from_main=false" >> $GITHUB_OUTPUT
+          else
+            SECOND_PARENT=$(git rev-parse HEAD^2 2>/dev/null || echo "")
+            if [ "$SECOND_PARENT" = "$MAIN_SHA" ]; then
+              echo "from_main=true" >> $GITHUB_OUTPUT
             else
-              echo "skip=false" >> $GITHUB_OUTPUT
+              echo "from_main=false" >> $GITHUB_OUTPUT
             fi
-          else
-            # Manual/API dispatch should always run for the selected branch ref.
-            echo "workflow_dispatch detected, bypassing sync-commit gate."
-            echo "skip=false" >> $GITHUB_OUTPUT
           fi
+          echo "skip=false" >> $GITHUB_OUTPUT
 
-      - name: Keep store-specific paths (e.g. locales) after main sync
+      - name: Extract store alias from branch name
         if: steps.gate.outputs.skip != 'true'
+        id: alias
+        run: |
+          BRANCH="${{ github.ref_name }}"
+          ALIAS="${BRANCH#staging-}"
+          echo "alias=$ALIAS" >> $GITHUB_OUTPUT
+          echo "Store alias: $ALIAS (from_main=${{ steps.gate.outputs.from_main }})"
+
+      # --- When push is FROM MAIN: stores → root, and restore store-specific locales ---
+      - name: Keep store-specific paths (e.g. locales) after main sync
+        if: steps.gate.outputs.skip != 'true' && steps.gate.outputs.from_main == 'true'
         run: |
-          # After a main→staging merge, restore store-specific paths from the pre-merge commit
-          # so they are not overwritten by main. Only run when paths exist (no pathspec error).
           if [ ! -d "locales" ]; then
-            echo "No locales/ directory, skipping."
             exit 0
           fi
           PARENT=$(git rev-parse HEAD^1 2>/dev/null || echo "")
           if [ -z "$PARENT" ]; then
-            echo "Not a merge commit or shallow clone, skipping."
             exit 0
           fi
           find locales -name "*.json" 2>/dev/null | while read -r f; do
             git checkout "$PARENT" -- "$f" 2>/dev/null || true
           done
-          if git diff --quiet; then
-            echo "No store-specific locale changes to restore."
-          else
+          if ! git diff --quiet; then
             echo "Restored store-specific locale files from pre-merge commit."
           fi
 
-      - name: Extract store alias from branch name
-        if: steps.gate.outputs.skip != 'true'
-        id: alias
-        run: |
-          BRANCH="${{ github.ref_name }}"
-          ALIAS="${BRANCH#staging-}"
-          echo "alias=$ALIAS" >> $GITHUB_OUTPUT
-          echo "Store alias: $ALIAS"
-
-      - name: Sync stores/<alias>/ to root
-        if: steps.gate.outputs.skip != 'true'
+      - name: Sync stores/<alias>/ to root (main merged in)
+        if: steps.gate.outputs.skip != 'true' && steps.gate.outputs.from_main == 'true'
         run: |
           ALIAS="${{ steps.alias.outputs.alias }}"
           STORE_DIR="stores/${ALIAS}"
-
           if [ ! -d "$STORE_DIR" ]; then
             echo "Store directory $STORE_DIR does not exist, skipping."
             exit 0
           fi
-
-          # Sync directories: config, templates, sections
           for DIR in config templates sections; do
             SRC="${STORE_DIR}/${DIR}"
             if [ -d "$SRC" ]; then
-              # Copy JSON files only, preserving directory structure
               find "$SRC" -name "*.json" | while read -r FILE; do
                 REL_PATH="${FILE#$STORE_DIR/}"
-
-                # Skip excluded files
                 if [ "$REL_PATH" = "config/settings_schema.json" ]; then
                   continue
                 fi
-
                 mkdir -p "$(dirname "$REL_PATH")"
                 cp "$FILE" "$REL_PATH"
                 echo "  Copied: $REL_PATH"
@@ -105,12 +106,11 @@ jobs:
             fi
           done
 
-      - name: Commit changes
-        if: steps.gate.outputs.skip != 'true'
+      - name: Commit stores→root
+        if: steps.gate.outputs.skip != 'true' && steps.gate.outputs.from_main == 'true'
         run: |
           git config user.name "github-actions[bot]"
           git config user.email "github-actions[bot]@users.noreply.github.com"
-
           git add -A
           if ! git diff --cached --quiet; then
             git commit -m "chore: sync stores/${{ steps.alias.outputs.alias }}/ to root [stores-to-root]"
@@ -118,3 +118,37 @@ jobs:
           else
             echo "No changes to commit."
           fi
+
+      # --- When push is NOT from main: root → stores/<alias>/ (persist store JSONs) ---
+      - name: Sync root to stores/<alias>/ (external push, e.g. Shopify)
+        if: steps.gate.outputs.skip != 'true' && steps.gate.outputs.from_main == 'false'
+        run: |
+          ALIAS="${{ steps.alias.outputs.alias }}"
+          STORE_DIR="stores/${ALIAS}"
+          mkdir -p "${STORE_DIR}/config" "${STORE_DIR}/templates" "${STORE_DIR}/sections"
+          for DIR in config templates sections; do
+            if [ -d "$DIR" ]; then
+              find "$DIR" -name "*.json" | while read -r FILE; do
+                if [ "$FILE" = "config/settings_schema.json" ]; then
+                  continue
+                fi
+                DEST="${STORE_DIR}/${FILE}"
+                mkdir -p "$(dirname "$DEST")"
+                cp "$FILE" "$DEST"
+                echo "  Synced: $FILE → $DEST"
+              done
+            fi
+          done
+
+      - name: Commit root→stores
+        if: steps.gate.outputs.skip != 'true' && steps.gate.outputs.from_main == 'false'
+        run: |
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          git add -A
+          if ! git diff --cached --quiet; then
+            git commit -m "chore: sync root to stores/${{ steps.alias.outputs.alias }}/ [root-to-stores]"
+            git push
+          else
+            echo "No changes to commit."
+          fi

package/src/workflows/shared/version-bump.yml

@@ -1,5 +1,6 @@
 # climaybe — Version Bump (Reusable Workflow)
-# Bumps version in settings_schema.json, creates a git tag, and pushes.
+# Bumps version in settings_schema.json and package.json (if present), creates a git tag, and pushes.
+# Only runs on main (called from post-merge-tag and nightly-hotfix). staging / staging-* / live-* do not run version bump.
 
 name: Version Bump
 
@@ -60,8 +61,25 @@ jobs:
             fi
             NEW_VERSION="v${NEW_VERSION}"
           else
-            # Get latest tag
-            LATEST_TAG=$(git describe --tags --abbrev=0 2>/dev/null || echo "v0.0.0")
+            # Get latest tag (or theme_version from settings_schema.json when no tags)
+            LATEST_TAG=$(git describe --tags --abbrev=0 2>/dev/null || true)
+            if [ -z "$LATEST_TAG" ]; then
+              SCHEMA="config/settings_schema.json"
+              if [ -f "$SCHEMA" ]; then
+                LATEST_TAG=$(node -e "
+                  const fs = require('fs');
+                  const arr = JSON.parse(fs.readFileSync('$SCHEMA', 'utf-8'));
+                  const info = arr.find(x => x.name === 'theme_info');
+                  const v = (info && info.theme_version) ? String(info.theme_version).trim() : '';
+                  if (!v) process.exit(1);
+                  let parts = v.replace(/^v/i, '').split('.');
+                  if (parts.length === 2) parts.push('0');
+                  if (parts.length < 3) parts = parts.concat(Array(3 - parts.length).fill('0')).slice(0, 3);
+                  console.log('v' + parts.slice(0, 3).join('.'));
+                " 2>/dev/null || true)
+              fi
+              [ -z "$LATEST_TAG" ] && LATEST_TAG="v0.0.0"
+            fi
             LATEST_TAG="${LATEST_TAG#v}"
 
             IFS='.' read -r MAJOR MINOR PATCH <<< "$LATEST_TAG"
@@ -82,20 +100,20 @@ jobs:
           echo "new_version=$NEW_VERSION" >> $GITHUB_OUTPUT
           echo "New version: $NEW_VERSION"
 
-      - name: Update settings_schema.json
+      - name: Update settings_schema.json and package.json
+        env:
+          NEW_VERSION: ${{ steps.bump.outputs.new_version }}
         run: |
-          NEW_VERSION="${{ steps.bump.outputs.new_version }}"
+          export VERSION_PLAIN="${NEW_VERSION#v}"
           SCHEMA_FILE="config/settings_schema.json"
 
           if [ -f "$SCHEMA_FILE" ]; then
-            # Update the theme_info version in settings_schema.json
             node -e "
               const fs = require('fs');
+              const v = process.env.VERSION_PLAIN;
               const schema = JSON.parse(fs.readFileSync('$SCHEMA_FILE', 'utf-8'));
               const themeInfo = schema.find(s => s.name === 'theme_info');
-              if (themeInfo) {
-                themeInfo.theme_version = '${NEW_VERSION#v}';
-              }
+              if (themeInfo) themeInfo.theme_version = v;
               fs.writeFileSync('$SCHEMA_FILE', JSON.stringify(schema, null, 2) + '\n');
             "
             echo "Updated $SCHEMA_FILE to ${NEW_VERSION}"
@@ -103,6 +121,18 @@ jobs:
             echo "No $SCHEMA_FILE found, skipping schema update."
           fi
 
+          if [ -f "package.json" ]; then
+            node -e "
+              const fs = require('fs');
+              const pkg = JSON.parse(fs.readFileSync('package.json', 'utf-8'));
+              pkg.version = process.env.VERSION_PLAIN;
+              fs.writeFileSync('package.json', JSON.stringify(pkg, null, 2) + '\n');
+            "
+            echo "Updated package.json version to ${VERSION_PLAIN}"
+          else
+            echo "No package.json found, skipping."
+          fi
+
       - name: Commit and tag
         run: |
           NEW_VERSION="${{ steps.bump.outputs.new_version }}"