chore: merge public-next into next (raw, conflict markers) [PR 1/2]

Author: AztecBot

.claude/skills/merge-train-infra/SKILL.md

@@ -21,7 +21,7 @@ The merge-train system is fully automated via GitHub Actions in `.github/workflo
 
 5. **Recreation & Wakeup** (`merge-train-recreate.yml`): Triggered when a PR is closed (merged). If the merged PR's head branch starts with `merge-train/`, recreates the branch from the base branch (usually `next`). Then runs `scripts/merge-train/wakeup-prs.sh` to add the `ci-wakeup-pr-after-merge` label to all open PRs targeting the branch that have passed CI and have automerge enabled. This triggers a CI re-run (typically a no-op via tree-hash cache) so those PRs can proceed through the merge queue. The label is immediately removed by a step in `ci3.yml` so it can be re-applied on subsequent merges.
 
-6. **Failure Notification** (`merge-queue-dequeue-notify.yml`): Triggered when a PR is dequeued from the merge queue. If the PR's head branch starts with `merge-train/` and the PR was NOT merged, sends a Slack notification via `ci3/merge_train_failure_slack_notify`.
+6. **Failure Notification** (`merge-queue-dequeue-notify.yml`): Triggered when a PR is dequeued from the merge queue. If the PR's head branch starts with `merge-train/` and the PR was NOT merged, sends a Slack notification via `ci3/merge_train_failure_slack_notify`. That script also kicks off a ClaudeBox session to investigate/fix the dequeued PR (`ci3/slack_notify_with_claudebox_kickoff`), passing `--repo "$GITHUB_REPOSITORY"` so the session runs in the mode matching the repo the train lives on. When the train is on a private mirror (`…-private`), `claudebox.yml` selects private mode; otherwise it stays public. Without that repo hint a private-train fix session lands in public mode and cannot read the PR or open the fix.
 
 ## CI Integration Details
 

.github/workflows/ci3.yml

@@ -16,8 +16,11 @@ on:
   merge_group: {}
 
 concurrency:
-  # Allow full concurrency for merge-train PRs, one-run-per-branch for everything else.
-  group: ci3-${{ (startsWith(github.event.pull_request.head.ref, 'merge-train/') && github.run_id) || github.event.merge_group.head_ref || github.ref_name }}
+  # merge-train PRs: one run per commit — distinct commits run concurrently (each is a real
+  # train state to test), but duplicate events for the same commit (synchronize + the bot's
+  # label re-applies) collapse. Keying on head.sha instead of run_id is what collapses them;
+  # run_id is unique per run and never collapsed anything. Everything else: one run per branch.
+  group: ci3-${{ (startsWith(github.event.pull_request.head.ref, 'merge-train/') && github.event.pull_request.head.sha) || github.event.merge_group.head_ref || github.ref_name }}
   cancel-in-progress: true
 
 jobs:

.github/workflows/claudebox.yml

@@ -19,6 +19,14 @@ on:
         description: 'Git ref the session should work against (e.g., origin/merge-train/barretenberg)'
         required: false
         type: string
+      repo:
+        description: 'Repo the work targets (owner/repo). Defaults to this repo. A private target (…-private) makes the session run in private mode.'
+        required: false
+        type: string
+      mode:
+        description: 'ClaudeBox repo-access mode (public|private). Leave empty to infer from the target repo.'
+        required: false
+        type: string
       slack_channel:
         description: 'Slack channel ID to thread status into (set by the kickoff script)'
         required: false
@@ -124,15 +132,19 @@ jobs:
           CLAUDEBOX_LINK: ${{ steps.parse.outputs.link }}
           COMMENT_ID: ${{ github.event.comment.id || '' }}
           RUN_COMMENT_ID: ${{ steps.status_comment.outputs.run_comment_id || '' }}
-          REPO: ${{ github.repository }}
+          REPO: ${{ inputs.repo || github.repository }}
           RUN_URL: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
           AUTHOR: ${{ github.event.comment.user.login || github.actor }}
           SLACK_CHANNEL: ${{ inputs.slack_channel || '' }}
           SLACK_THREAD_TS: ${{ inputs.slack_thread_ts || '' }}
-          # Public mode grants the session read-write access to public repos
-          # (aztec-packages). Without it the session only gets the group's
-          # unscoped repos and cannot open PRs against aztec-packages.
-          CLAUDEBOX_MODE: ${{ vars.CLAUDEBOX_MODE || 'public' }}
+          # Mode selection, in priority order:
+          #   1. an explicit `mode` input (caller knows best);
+          #   2. private, when the target repo is a private mirror (…-private) —
+          #      e.g. a merge-train dequeue on aztec-packages-private, which a
+          #      public-mode session cannot read or open a fix PR against;
+          #   3. the repo/org default (public) for ordinary /claudebox work on
+          #      aztec-packages.
+          CLAUDEBOX_MODE: ${{ inputs.mode || (endsWith(inputs.repo || github.repository, '-private') && 'private' || vars.CLAUDEBOX_MODE || 'public') }}
         run: |
           if [ -z "${CLAUDEBOX_API_SECRET:-}" ]; then
             echo "ERROR: CLAUDEBOX_API_SECRET is not set; cannot dispatch ClaudeBox v2"

.github/workflows/merge-train-create-pr.yml

@@ -24,11 +24,11 @@ jobs:
             branch="${{ github.ref_name }}"
 
             # Determine base branch. Most trains target next; trains suffixed
-            # with -v5 (e.g. spartan-v5, fairies-v5) target the v5 release line
-            # (v5-next) instead.
+            # with -v<N> (e.g. spartan-v5, fairies-v5, spartan-v6) target the
+            # matching release line (v5-next, v6-next) instead.
             base_branch="next"
-            if [[ "$branch" == *-v5 ]]; then
-              base_branch="v5-next"
+            if [[ "$branch" =~ -v([0-9]+)$ ]]; then
+              base_branch="v${BASH_REMATCH[1]}-next"
             fi
 
             # Skip if this is a merge commit (multiple parents) -- unless its
@@ -55,7 +55,7 @@ jobs:
 
               # Create PR with ci-no-squash label
               labels="ci-no-squash"
-              if [[ "$branch" == "merge-train/spartan" || "$branch" == "merge-train/spartan-v5" || "$branch" == "merge-train/ci" ]]; then
+              if [[ "$branch" == "merge-train/spartan" || "$branch" == "merge-train/spartan-v5" || "$branch" == "merge-train/spartan-v6" || "$branch" == "merge-train/ci" ]]; then
                 labels="$labels,ci-full-no-test-cache"
               fi
               # Trains targeting the v5 release line are ports into v5-next.

.github/workflows/merge-train-next-to-branches.yml

@@ -5,6 +5,7 @@ on:
     branches:
       - next
       - v5-next
+      - v6-next
 
 jobs:
   merge-to-trains:
@@ -27,13 +28,17 @@ jobs:
           GH_TOKEN: ${{ secrets.AZTEC_BOT_GITHUB_TOKEN }}
           COMMIT_SHA: ${{ github.sha }}
         run: |
-          # The -v5 trains track the v5 release line (v5-next); every other
-          # train tracks next. Sync only the trains fed by the branch that was
-          # just pushed.
+          # The -v<N> trains track the matching release line (v5-next, v6-next);
+          # every other train tracks next. Sync only the trains fed by the
+          # branch that was just pushed.
           if [[ "${{ github.ref_name }}" == "v5-next" ]]; then
             for branch in merge-train/spartan-v5 merge-train/fairies-v5; do
               ./scripts/merge-train/merge-next.sh "$branch" v5-next || true
             done
+          elif [[ "${{ github.ref_name }}" == "v6-next" ]]; then
+            for branch in merge-train/spartan-v6; do
+              ./scripts/merge-train/merge-next.sh "$branch" v6-next || true
+            done
           else
             for branch in merge-train/avm merge-train/barretenberg merge-train/ci merge-train/docs merge-train/fairies merge-train/spartan; do
               ./scripts/merge-train/merge-next.sh "$branch" || true

.github/workflows/merge-train-stale-check.yml

@@ -38,6 +38,22 @@ jobs:
           BASE_BRANCH: v5-next
         run: ./ci3/merge_train_stale_check merge-train/spartan-v5 '#team-alpha'
 
+  spartan-v6:
+    name: Check merge-train/spartan-v6
+    if: ${{ github.event_name != 'schedule' || github.repository == 'AztecProtocol/aztec-packages' }}
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      pull-requests: read
+    steps:
+      - uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1
+      - name: Run stale check
+        env:
+          GH_TOKEN: ${{ secrets.AZTEC_BOT_GITHUB_TOKEN }}
+          SLACK_BOT_TOKEN: ${{ secrets.SLACK_BOT_TOKEN }}
+          BASE_BRANCH: v6-next
+        run: ./ci3/merge_train_stale_check merge-train/spartan-v6 '#team-alpha'
+
   fairies-v5:
     name: Check merge-train/fairies-v5
     runs-on: ubuntu-latest

.github/workflows/metrics-deploy.yml

@@ -41,7 +41,7 @@ on:
         description: Optional Terraform list of Slack user IDs to mention on Grafana alert notifications
         required: false
         type: string
-        default: '["U0AHB6VR8N5"]'
+        default: '["U0AQPRA1FSL"]'
     secrets:
       GCP_SA_KEY:
         required: true
@@ -78,7 +78,7 @@ on:
       slack_alert_mention_user_ids:
         description: Optional Terraform list of Slack user IDs to mention on Grafana alert notifications
         required: false
-        default: '["U0AHB6VR8N5"]'
+        default: '["U0AQPRA1FSL"]'
 
 jobs:
   metrics_deployment:

barretenberg/cpp/src/barretenberg/vm2/tracegen/lib/lookup_builder.hpp

@@ -50,10 +50,10 @@ template <typename LookupSettings_> class IndexedLookupTraceBuilder : public Int
             }
 
             trace.set(LookupSettings::COUNTS, dst_row, trace.get(LookupSettings::COUNTS, dst_row) + 1);
-            // Set the fine grained inner selector if it's not already one.
-            if (LookupSettings::DST_SELECTOR != this->outer_dst_selector &&
-                trace.get(LookupSettings::DST_SELECTOR, dst_row) != 1) {
-                trace.set(LookupSettings::DST_SELECTOR, dst_row, 1);
+            if (LookupSettings::DST_SELECTOR != this->outer_dst_selector) {
+                // This step might write to the same cell from multiple threads, so we use atomic limbs to avoid UB.
+                // Since we are always writing a 1, the end result will be 1 even under concurrency.
+                trace.set(LookupSettings::DST_SELECTOR, dst_row, 1, /*use_atomic_limbs=*/true);
             }
         });
     }
@@ -198,10 +198,10 @@ template <typename LookupSettings> class LookupIntoDynamicTableSequential : publ
                 if (dst_selector == 1 && src_values == trace.get_multiple(LookupSettings::DST_COLUMNS, dst_row)) {
                     trace.set(LookupSettings::COUNTS, dst_row, trace.get(LookupSettings::COUNTS, dst_row) + 1);
 
-                    // Set the fine grained inner selector if it's not already one.
-                    if (LookupSettings::DST_SELECTOR != this->outer_dst_selector &&
-                        trace.get(LookupSettings::DST_SELECTOR, dst_row) != 1) {
-                        trace.set(LookupSettings::DST_SELECTOR, dst_row, 1);
+                    if (LookupSettings::DST_SELECTOR != this->outer_dst_selector) {
+                        // This step might write to the same cell from multiple threads, so we use atomic limbs to avoid
+                        // UB. Since we are always writing a 1, the end result will be 1 even under concurrency.
+                        trace.set(LookupSettings::DST_SELECTOR, dst_row, 1, /*use_atomic_limbs=*/true);
                     }
 
                     found = true;

barretenberg/cpp/src/barretenberg/vm2/tracegen/trace_container.cpp

@@ -3,6 +3,11 @@
 #include <algorithm>
 
 #include "barretenberg/common/assert.hpp"
+<<<<<<< HEAD
+=======
+#include "barretenberg/common/compiler_hints.hpp"
+#include "barretenberg/common/log.hpp"
+>>>>>>> origin/public-next
 #include "barretenberg/common/ref_vector.hpp"
 #include "barretenberg/vm2/tracegen/lib/trace_conversion.hpp"
 
@@ -11,6 +16,21 @@ namespace {
 
 // We need a zero value to return (a reference to) when a value is not found.
 const FF zero = FF::zero();
+<<<<<<< HEAD
+=======
+
+// Writes each 64-bit limb of the field with a relaxed atomic store. Each limb is naturally aligned (FF is
+// alignas(32), 4x uint64_t), so this lowers to 4 plain `movq` stores on x86-64 — no lock, no libatomic call
+// (unlike a whole-field std::atomic_ref<FF>, whose 32 bytes exceed the lock-free width). Lets set() make a
+// same-cell concurrent write data-race-free when every writer stores the same value.
+inline void store_per_limb(FF& cell, const FF& value)
+{
+    static_assert(sizeof(FF) == 4 * sizeof(uint64_t));
+    for (size_t i = 0; i < 4; ++i) {
+        std::atomic_ref<uint64_t>(cell.data[i]).store(value.data[i], std::memory_order_relaxed);
+    }
+}
+>>>>>>> origin/public-next
 
 } // namespace
 
@@ -59,7 +79,7 @@ TraceContainer::ColumnInterval& TraceContainer::get_or_create_shard(SparseColumn
     return *expected; // CAS failure loaded the winning pointer into `expected` (acquire).
 }
 
-void TraceContainer::set(Column col, uint32_t row, const FF& value)
+void TraceContainer::set(Column col, uint32_t row, const FF& value, bool use_atomic_limbs)
 {
     auto& column_data = (*trace)[static_cast<size_t>(col)];
     const size_t shard_idx = row / INTERVAL_SIZE;
@@ -70,12 +90,26 @@ void TraceContainer::set(Column col, uint32_t row, const FF& value)
         // Lock-free: a single atomic load finds the shard (created on first write), then we write our
         // own dense cell directly. Different rows are distinct array elements, so concurrent writers of
         // this column (or even of the same shard, at a chunk boundary) never race and never serialize.
-        get_or_create_shard(column_data, shard_idx).rows[offset] = value;
+        auto& cell = get_or_create_shard(column_data, shard_idx).rows[offset];
+        if (BB_UNLIKELY(use_atomic_limbs)) {
+            store_per_limb(cell, value);
+        } else {
+            cell = value;
+        }
     } else {
-        // Zero value: clear if present. We never create a shard (clearing an absent row is a no-op).
+        // Zero value: clear if present. We never create a shard, so sparse (mostly-zero) columns are not
+        // materialized (an unset cell already reads as zero).
         ColumnInterval* shard = column_data.slots[shard_idx].load(std::memory_order_acquire);
         if (shard != nullptr) {
+<<<<<<< HEAD
             shard->rows[offset] = zero;
+=======
+            if (BB_UNLIKELY(use_atomic_limbs)) {
+                store_per_limb(shard->rows[offset], zero);
+            } else {
+                shard->rows[offset] = FF::zero();
+            }
+>>>>>>> origin/public-next
         }
     }
 }

barretenberg/cpp/src/barretenberg/vm2/tracegen/trace_container.hpp

@@ -72,7 +72,11 @@ class TraceContainer {
     // Extended version of get that works with shifted columns. More expensive.
     const FF& get_column_or_shift(ColumnAndShifts col, uint32_t row) const;
 
-    void set(Column col, uint32_t row, const FF& value);
+    // Sets the value of a cell. Thread-safe if the same cell is not written to from multiple threads.
+    // If writing to the same cell from multiple threads, use_atomic_limbs=true to use atomic limbs.
+    // This makes the write slower, but it will not be UB. However, it is also not thread-safe.
+    // Use only if you know what you are doing.
+    void set(Column col, uint32_t row, const FF& value, bool use_atomic_limbs = false);
     // Bulk setting for a given row.
     void set(uint32_t row, std::span<const std::pair<Column, FF>> values);
     // Reserve column size. Useful for precomputed columns.