@@ -22,6 +22,10 @@ inputs:
     description: Actual number of synchronized branches.
     type: string
     required: true
+  created:
+    description: Actual number of created branches.
+    type: string
+    required: true
   skipped:
     description: Actual number of skipped entries.
     type: string
@@ -34,6 +38,10 @@ inputs:
     description: Expected number of synchronized branches.
     type: string
     required: true
+  expected-created:
+    description: Expected number of created branches.
+    type: string
+    required: true
   expected-skipped:
     description: Expected number of skipped entries.
     type: string
@@ -50,9 +58,11 @@ runs:
       shell: bash
       env:
         SYNCHRONIZED:          ${{ inputs.synchronized }}
+        CREATED:               ${{ inputs.created }}
         SKIPPED:               ${{ inputs.skipped }}
         ERRORS:                ${{ inputs.errors }}
         EXPECTED_SYNCHRONIZED: ${{ inputs.expected-synchronized }}
+        EXPECTED_CREATED:      ${{ inputs.expected-created }}
         EXPECTED_SKIPPED:      ${{ inputs.expected-skipped }}
         EXPECTED_ERRORS:       ${{ inputs.expected-errors }}
       run: |
@@ -78,6 +88,7 @@ runs:
         }
 
         checkOutput "synchronized" "${SYNCHRONIZED}" "${EXPECTED_SYNCHRONIZED}"
+        checkOutput "created"      "${CREATED}"      "${EXPECTED_CREATED}"
         checkOutput "skipped"      "${SKIPPED}"      "${EXPECTED_SKIPPED}"
         checkOutput "errors"       "${ERRORS}"       "${EXPECTED_ERRORS}"
 
 
@@ -43,11 +43,14 @@ jobs:
         uses: ./.github/actions/check-outputs
         with:
           synchronized:          ${{ steps.synchronize.outputs.synchronized }}
+          created:               ${{ steps.synchronize.outputs.created }}
           skipped:               ${{ steps.synchronize.outputs.skipped }}
           errors:                ${{ steps.synchronize.outputs.errors }}
           # 1 branch of 'ghdl' + 1 branch of 'progit2' + 2 branches of 'itertree'
           expected-synchronized: 4
           # 1 commented out organisation + 1 commented out repository
+          # Dry-run reads no repository, so no branch is created.
+          expected-created:      0
           expected-skipped:      2
           expected-errors:       0
 
@@ -73,9 +76,11 @@ jobs:
         uses: ./.github/actions/check-outputs
         with:
           synchronized:          ${{ steps.synchronize.outputs.synchronized }}
+          created:               ${{ steps.synchronize.outputs.created }}
           skipped:               ${{ steps.synchronize.outputs.skipped }}
           errors:                ${{ steps.synchronize.outputs.errors }}
           expected-synchronized: 1
+          expected-created:      0
           expected-skipped:      0
           # 1 missing 'Missing.repos' + 4 malformed lines in 'ghdl.repos'
           expected-errors:       5
 
@@ -120,17 +120,20 @@ Every organisation becomes a collapsible group, and each fork reports the branch
     ✅ gh repo sync PLC2/OSVVM --branch main
     ✅ gh repo sync PLC2/OSVVM --branch dev
   📂 OSVVM/AXI4 ⇒ PLC2/OSVVM-AXI4
-    ❌ gh repo sync PLC2/OSVVM-AXI4 --branch dev
+    🌱 dev — created from OSVVM/AXI4@a1b2c3d
+  📂 OSVVM/Ethernet ⇒ PLC2/OSVVM-Ethernet
+    ❌ gh repo sync PLC2/OSVVM-Ethernet --branch main
     ↪ failed to sync: HTTP 404: Not Found
   🚫 #OSVVM/AvalonST=OSVVM-AvalonST:main
 
 Summary:
   Synchronized branches:  2
+  Created branches:       1
   Skipped entries:        1
   Errors:                 1
 
 Not synchronized:
-  ❌ OSVVM/AXI4 ⇒ PLC2/OSVVM-AXI4:dev
+  ❌ OSVVM/Ethernet ⇒ PLC2/OSVVM-Ethernet:main
 ```
 
 ### Input Parameters
@@ -142,6 +145,7 @@ Not synchronized:
 | `directory`           |    no    | `'.'`                            | Directory containing the configuration files.                                                                        |
 | `index-file`          |    no    | `'.ALL.repos'`                   | Name of the index file listing the organisations to be synchronized.                                                 |
 | `force`               |    no    | `false`                          | Hard reset the fork's branch to the upstream branch, discarding commits that aren't in the upstream repository.       |
+| `create-missing-branches` | no   | `false`                          | Create a listed branch that doesn't exist in the fork yet from the upstream repository's branch head.                |
 | `dry-run`             |    no    | `false`                          | Print the synchronization commands instead of running them.                                                          |
 | `fail-on-error`       |    no    | `true`                           | Let the action fail if at least one error was counted.                                                               |
 
@@ -150,10 +154,35 @@ Not synchronized:
 | Parameter      | Description                                                             |
 |----------------|---------------------------------------------------------------------------|
 | `synchronized` | Number of successfully synchronized branches.                           |
+| `created`      | Number of branches created in a fork.                                   |
 | `skipped`      | Number of skipped organisations and repositories (commented out lines). |
 | `errors`       | Number of counted errors.                                               |
 
-In dry-run mode, `synchronized` counts the branches that *would* have been synchronized.
+In dry-run mode, `synchronized` counts the branches that *would* have been synchronized. Dry-run reads no repository,
+so a missing branch isn't detected and `created` stays `0`.
+
+## Missing Branches
+
+`gh repo sync` updates a branch; it can't create one. A branch listed in an `<organisation>.repos` file that the fork
+doesn't have yet — a branch added upstream after the fork was created, or a fork made with *Copy the default branch
+only* — therefore can't be synchronized at all.
+
+With `create-missing-branches: true`, the action creates it from the upstream repository's branch head, and the next
+run synchronizes it like any other branch:
+
+```
+  📂 OSVVM/AXI4 ⇒ PLC2/OSVVM-AXI4
+    🌱 dev — created from OSVVM/AXI4@a1b2c3d
+```
+
+**It's off by default**, because this is where `<upstream>` stops being decoration: it's the repository the new
+branch's head is read from, and a stale or copy-pasted upstream would create the branch from the wrong repository.
+Check that field, then enable it per repository. While it's disabled, a missing branch is a counted error naming the
+parameter.
+
+No clone, fetch or push is involved. GitHub keeps a fork and its upstream in one object network, so the upstream's
+commit is addressable through the fork and the branch is created with a single API call. If the branch exists in
+neither repository — usually a typo in the configuration file — it's a counted error.
 
 ## Error Handling
 
@@ -164,7 +193,9 @@ Each of these is counted, reported as a GitHub Actions error annotation, and let
 * an `<organisation>.repos` file listed in the index file doesn't exist,
 * a repository line is malformed — no `=`, no `:`, or an empty `<upstream>`, `<fork>` or branch list,
 * `gh repo sync` fails for a fork's branch. Its output is quoted below the failed command, and the annotation names the
-  upstream repository, the fork and the branch.
+  upstream repository, the fork and the branch,
+* a branch exists neither in the fork nor in the upstream repository, or creating it fails,
+* a branch is missing from the fork while `create-missing-branches` is disabled.
 
 A failing fork doesn't stop the run: every other fork is still synchronized, and the summary lists what wasn't.
 
 
@@ -55,10 +55,20 @@ inputs:
     type: boolean
     required: false
     default: false
+  create-missing-branches:
+    description: |
+      Create a branch that is listed in an '<organisation>.repos' file, but doesn't exist in the fork yet, from the
+      upstream repository's branch head. 'gh repo sync' can only update an existing branch.
+      The branch head is read from '<upstream>', so this is disabled by default: a stale or copy-pasted upstream in a
+      configuration file would create the branch from the wrong repository.
+    type: boolean
+    required: false
+    default: false
   dry-run:
     description: |
       Print the synchronization commands instead of running them.
-      Branches that would have been synchronized are counted in the 'synchronized' output parameter.
+      Branches that would have been synchronized are counted in the 'synchronized' output parameter. No repository is
+      read or written, so a missing branch isn't detected in this mode.
     type: boolean
     required: false
     default: false
@@ -74,6 +84,10 @@ outputs:
     description: |
       Number of successfully synchronized branches.
     value: ${{ steps.synchronize.outputs.synchronized }}
+  created:
+    description: |
+      Number of branches created in a fork.
+    value: ${{ steps.synchronize.outputs.created }}
   skipped:
     description: |
       Number of skipped organisations and repositories (commented out lines).
@@ -114,6 +128,7 @@ runs:
         TARGET_ORGANISATION: ${{ inputs.target-organisation }}
         INDEX_FILE:          ${{ inputs.index-file }}
         FORCE:               ${{ inputs.force }}
+        CREATE_BRANCHES:     ${{ inputs.create-missing-branches }}
         DRY_RUN:             ${{ inputs.dry-run }}
         FAIL_ON_ERROR:       ${{ inputs.fail-on-error }}
       run: |
@@ -137,10 +152,38 @@ runs:
         printf "%s\n" ""
 
         synchronized=0
+        created=0
         skipped=0
         errors=0
         failures=()
 
+        # Create a branch in the fork, pointing at the upstream repository's branch head. GitHub keeps a fork and its
+        # upstream in one object network, so the upstream's commit is addressable through the fork and no clone,
+        # fetch or push is involved. 'gh repo sync' can only fast-forward a branch that already exists.
+        createBranch() {
+          local upstream="${1}" fork="${2}" branch="${3}"
+          local sha messages
+
+          sha="$(gh api "repos/${upstream}/git/ref/heads/${branch}" --jq '.object.sha' 2>&1)"
+          if [[ $? -ne 0 ]]; then
+            printf "    ❌ %s\n" "${ANSI_LIGHT_RED}${branch} — exists neither in the fork nor in '${upstream}'${ANSI_NOCOLOR}"
+            printf "::error title=%s::%s\n" "Create ${fork}:${branch}" "Branch '${branch}' exists neither in the fork '${fork}' nor in the upstream repository '${upstream}'."
+            return 1
+          fi
+
+          messages="$(gh api --method POST "repos/${fork}/git/refs" --field "ref=refs/heads/${branch}" --field "sha=${sha}" 2>&1)"
+          if [[ $? -ne 0 ]]; then
+            printf "    ❌ %s\n" "${ANSI_LIGHT_RED}${branch} — couldn't be created from ${upstream}@${sha:0:7}${ANSI_NOCOLOR}"
+            printf "%s\n" "$(sed 's/^/    ↪ /g' <<< "${messages}")"
+            printf "::error title=%s::%s\n" "Create ${fork}:${branch}" "${messages//$'\n'/%0A}"
+            return 1
+          fi
+
+          printf "    🌱 %s\n" "${ANSI_LIGHT_GREEN}${branch} — created from ${upstream}@${sha:0:7}${ANSI_NOCOLOR}"
+          created=$((created + 1))
+          return 0
+        }
+
         if [[ ! -f "${INDEX_FILE}" ]]; then
           printf "%s\n" "${ANSI_LIGHT_RED}Index file '${INDEX_FILE}' not found in '$(pwd)'.${ANSI_NOCOLOR}"
           printf "::error title=%s::%s\n" "pyTooling/SynchronizeForks" "Index file '${INDEX_FILE}' not found in '$(pwd)'."
@@ -215,6 +258,25 @@ runs:
                   continue
                 fi
 
+                # A branch that doesn't exist in the fork can't be synchronized — 'gh repo sync' updates a branch, it
+                # doesn't create one. Create it here, so the next run synchronizes it like any other branch.
+                if ! gh api "repos/${TARGET_ORGANISATION}/${repository}/git/ref/heads/${branch}" > /dev/null 2>&1; then
+                  if [[ "${CREATE_BRANCHES}" == "true" ]]; then
+                    createBranch "${upstream}" "${TARGET_ORGANISATION}/${repository}" "${branch}"
+                    if [[ $? -ne 0 ]]; then
+                      failures+=("${upstream} ⇒ ${TARGET_ORGANISATION}/${repository}:${branch}")
+                      errors=$((errors + 1))
+                    fi
+                  else
+                    printf "    ❌ %s\n" "${ANSI_LIGHT_RED}${branch} — doesn't exist in the fork${ANSI_NOCOLOR}"
+                    printf "    ↪ %s\n" "${ANSI_LIGHT_RED}enable 'create-missing-branches' to create it${ANSI_NOCOLOR}"
+                    printf "::error title=%s::%s\n" "Synchronize ${upstream} ⇒ ${TARGET_ORGANISATION}/${repository}:${branch}" "Branch '${branch}' doesn't exist in the fork. Enable 'create-missing-branches' to create it from '${upstream}'."
+                    failures+=("${upstream} ⇒ ${TARGET_ORGANISATION}/${repository}:${branch}")
+                    errors=$((errors + 1))
+                  fi
+                  continue
+                fi
+
                 messages="$("${syncCommand[@]}" 2>&1)"
                 if [[ $? -eq 0 ]]; then
                   printf "    ✅ %s\n" "${syncCommand[*]}"
@@ -237,6 +299,7 @@ runs:
         printf "%s\n" ""
         printf "%s\n"        "${ANSI_CYAN}Summary:${ANSI_NOCOLOR}"
         printf "  %-24s%s\n" "Synchronized branches:" "${synchronized}"
+        printf "  %-24s%s\n" "Created branches:"      "${created}"
         printf "  %-24s%s\n" "Skipped entries:"       "${skipped}"
         printf "  %-24s%s\n" "Errors:"                "${errors}"
 
@@ -247,6 +310,7 @@ runs:
         fi
 
         printf "synchronized=%s\n" "${synchronized}" >> "${GITHUB_OUTPUT}"
+        printf "created=%s\n"      "${created}"      >> "${GITHUB_OUTPUT}"
         printf "skipped=%s\n"      "${skipped}"      >> "${GITHUB_OUTPUT}"
         printf "errors=%s\n"       "${errors}"       >> "${GITHUB_OUTPUT}"