@@ -237,3 +237,36 @@ re-pin list and burst budget before any code.**
 - The columnar verdict cache (re-judged only AFTER this arc's landscape
   change, with the #509 keystroke instrument).
 - Scheduler/budget tuning, react/renderer changes, any public API.
+
+## M2 amendment (2026-08-29, approved): chunked identity sweep
+
+Trigger: the fit-estimate after M1 sits ~124–135 ms (loaded rounds 133.3
+post-#518 / 141.6 pre, controls 1.7× out of band all day; pretable-side
+inflation markers ~1.07×) — above the 120 primary bar. #518 (parallel
+#500 arc) already amortized the slice clock to a 32-unit stride, worth
+~8 ms here; the remaining lever is per-row unit granularity.
+
+Scope — the IDENTITY LANE's build sweep only:
+
+- The unit becomes ONE SLOT-VECTOR CHUNK (1024 slots, aligned to
+  `SLOT_VECTOR_CHUNK`, cursor = chunk index): per `step()`, verdict every
+  populated slot in the chunk, insert survivors into the transient tree,
+  set bits. `completedRows` advances by the populated slots processed
+  (rows, not units — the status contract stays row-denominated);
+  `totalRows` unchanged. Holes skip for free.
+- Budget semantics under #518's runner: the first-unit clock check ends
+  the slice after one ~1 ms chunk, so slices carry 1–2 chunks and the 50k
+  sweep drops from ~196 scheduler hops to ~50. `maxUnitsPerSlice` becomes
+  a non-binding backstop for this lane.
+- Replay units, the evaluate lane, grouped lanes, and the shared runner
+  are UNTOUCHED.
+- Deliberate re-pins (the design priced these in): the transitions-test
+  progress pins that assume one row per unit on a flat set-query
+  (first-slice `completedRows`, stalled-clock unit bounds) are re-pinned
+  to the chunk denomination WITH comments naming this amendment; every
+  other contract pin (budget yield, cancellation, supersede, replay,
+  retention) must stay green unmodified.
+- Bar: paired A/B vs current main; the arc closes if the fit-estimate
+  reaches ≤120 (or the measured loaded number drops commensurately,
+  ~≤112 under today's regime); a flat result reverts the chunk per the
+  house rule.
@@ -101,3 +101,40 @@ Paired interleaved design + zero-long-task invariance + load-independent
 work counters carry the conclusion; absolute bars that need a fit regime
 are explicitly deferred, not claimed. No lever measured flat; nothing to
 revert.
+
+## M2 addendum (2026-08-29): chunked identity sweep — measured, bar met by estimate
+
+Implemented per the M2 amendment (commits `17385023`/`28fa68f5`/`04fe0a2a`):
+the identity lane's build unit is one slot-vector chunk; `completedRows`
+stays row-denominated; one transitions pin deliberately re-denominated;
+the mid-flight M1 pins were tightened with in-test rebuilding guards
+(they had gone green-but-vacuous under chunk units), and a review
+mutation added the absent-chunk-costs-no-unit pin.
+
+Context shift mid-arc: the parallel #500 arc's #518 amortized the shared
+slice clock to a 32-unit stride — main's own 50k filter dropped
+~141.6 → ~133 in the same regime before M2 ran.
+
+**Clean guarded paired A/B** (per-run port guard after a 4173 collision
+poisoned one window; 3 pairs, alternating sides, all 12 runs green, zero
+long tasks, medians of 3, load ~11–13, no same-run comparator):
+
+| Metric (pretable, 50k) | main (#518)               | M2 branch                     | Δ     |
+| ---------------------- | ------------------------- | ----------------------------- | ----- |
+| filter-metadata total  | 132.7 (123.7/132.7/133.4) | **124.1** (124.0/124.1/125.2) | −6.5% |
+| keystroke warm p50     | 59.1                      | **51.2**                      | −13%  |
+| keystroke cold total   | 149.3                     | 149.6                         | flat  |
+
+Branch-side spread ±0.6 ms. Consistent direction on two metrics — not a
+flat result; the chunk stays.
+
+**Bar verdict:** loaded 124.1 × the pretable-side inflation marker
+(~1.07× today) → fit-estimate **~116 ms ≤ 120**. The primary bar is met
+BY ESTIMATE; no controls-in-band round existed at any point today, so
+this is closed as estimate-met with the regime disclosed, and the arc's
+cumulative record stands at: pre-arc ~210 (fit) → M1+#518+M2
+~124 loaded / ~116 fit-estimate, zero blocking throughout.
+
+**Arc closed.** Remaining traced levers (snapshot HAMT reads ~10%,
+sort-key carry fill ~8%, residual runner overhead) stay on record for a
+future cycle; none is claimed.
@@ -302,20 +302,28 @@ describe("flat cooperative candidate — identity-carry and evaluate lanes", ()
     expect(scheduler.entries.length).toBeGreaterThan(0);
     const candidate = activeCandidateOf(model);
 
-    // Partial build: three one-unit slices, then a delta that touches all
-    // three change classes — an update that flips a survivor across the new
-    // filter (e: 60 -> 100 leaves lte 60), a removal, and an insert that
+    // The M2 chunk unit completes this 8-row build sweep in the SYNCHRONOUS
+    // first slice, so the delta lands right here — before any flush, while
+    // the transition is still in flight (terminal unit pending) — touching
+    // all three change classes: an update that flips a survivor across the
+    // new filter (e: 60 -> 100 leaves lte 60), a removal, and an insert that
     // lands inside the new filter.
-    scheduler.flushOne();
-    scheduler.flushOne();
-    scheduler.flushOne();
+    //
+    // Non-vacuity guard: the transition must NOT have settled when the
+    // transaction lands, or `append` never runs and this pin proves nothing
+    // about the upgrade path. A future unit-granularity change that settles
+    // this fixture synchronously fails HERE instead of re-vacuating the pin.
+    expect(model.getState().status).toMatchObject({ kind: "rebuilding" });
     expect(
       model.applyTransaction({
         update: [{ id: "e", changes: { score: 100 } }],
         remove: ["c"],
         add: [{ id: "i", team: "Z", score: 55, note: "g", rank: 0 }],
       }),
     ).toMatchObject({ updated: 1, removed: 1, added: 1 });
+    // The delta was queued into the LIVE candidate: its replay units are now
+    // outstanding (8 swept rows against 8 + 2*3 + 1 total units).
+    expect(candidate.completedRows).toBeLessThan(candidate.totalRows);
     scheduler.flushAll();
     await transition.finished;
 
@@ -352,8 +360,14 @@ describe("flat cooperative candidate — identity-carry and evaluate lanes", ()
     const transition = model.setQuery(COMBINED_QUERY);
     expect(scheduler.entries.length).toBeGreaterThan(0);
 
-    scheduler.flushOne();
-    scheduler.flushOne();
+    // The M2 chunk unit finishes this 8-row build sweep in the SYNCHRONOUS
+    // first slice, so the grown-slot delta lands before any flush — while
+    // the transition is still in flight (terminal unit pending), which is
+    // when `append`'s widening must run. Non-vacuity guard: a settled
+    // transition would never call `append`, so a future granularity change
+    // that settles this fixture synchronously fails HERE instead of
+    // re-vacuating the pin.
+    expect(model.getState().status).toMatchObject({ kind: "rebuilding" });
     const inserted: Row[] = Array.from({ length: 30 }, (_, index) => ({
       id: `j${index}`,
       team: "Z",
@@ -487,6 +501,208 @@ describe("flat cooperative candidate — identity-carry and evaluate lanes", ()
     model.dispose();
   });
 
+  test("the identity sweep processes one whole slot chunk per unit (M2 amendment)", async () => {
+    // M2 amendment (#490): the identity lane's build unit is ONE slot-vector
+    // chunk, not one row. The fixture's 8 rows share chunk 0, and the ticking
+    // 1ms-budget clock ends every slice after its first unit — so the
+    // SYNCHRONOUS first slice alone must complete all 8 rows, while the
+    // terminal unit is still pending (one-row units would show 1 here).
+    const { model, scheduler } = createFixture();
+    const transition = model.setQuery(COMBINED_QUERY);
+    expect(scheduler.entries.length).toBeGreaterThan(0);
+    const candidate = activeCandidateOf(model);
+    expect(candidate.completedRows).toBe(FIXTURE_ROWS.length);
+    expect(model.getState().status).toMatchObject({ kind: "rebuilding" });
+
+    // The next unit is the terminal one: the sweep is exhausted, the delta
+    // queue is empty, so this single flush settles the transition.
+    scheduler.flushOne();
+    expect(model.getState().status).toEqual({ kind: "ready" });
+    await transition.finished;
+    expectSettledEqualsCold(model, FIXTURE_ROWS, COMBINED_QUERY);
+    model.dispose();
+  });
+
+  test("a >1-chunk identity sweep takes one build unit per chunk and settles equal to cold (M2 amendment)", async () => {
+    // 1_100 rows span two slot-vector chunks (1_024 + 76), so the build takes
+    // exactly TWO chunk units: the synchronous first slice completes chunk 0,
+    // the next slice completes the 76-row partial chunk — a sweep that
+    // skipped the last partial chunk, or advanced by chunks instead of
+    // populated slots, cannot pass both progress pins AND the cold oracle.
+    const rows: Row[] = Array.from({ length: 1_100 }, (_, index) => ({
+      id: `r${String(index).padStart(4, "0")}`,
+      team: index % 2 === 0 ? "X" : "Y",
+      score: index % 100,
+      note: `n${String(index).padStart(4, "0")}`,
+      rank: 2_000 - index,
+    }));
+    const { model, scheduler } = createFixture({ rows });
+    const transition = model.setQuery(COMBINED_QUERY);
+    expect(scheduler.entries.length).toBeGreaterThan(0);
+    const candidate = activeCandidateOf(model);
+    expect(candidate.totalRows).toBe(1_100);
+    expect(candidate.completedRows).toBe(1_024);
+
+    scheduler.flushOne();
+    expect(candidate.completedRows).toBe(1_100);
+    expect(model.getState().status).toMatchObject({ kind: "rebuilding" });
+
+    scheduler.flushAll();
+    await transition.finished;
+    expect(candidate.completedRows).toBe(candidate.totalRows);
+    expectSettledEqualsCold(model, rows, COMBINED_QUERY);
+    model.dispose();
+  });
+
+  test("an absent slot-vector chunk costs no build unit (M2 amendment)", async () => {
+    // The M2 amendment's "skipped without spending the unit" claim: an ABSENT
+    // chunk (undefined in the captured vector's table — all holes) must not
+    // consume a build unit. The fixture engineers a genuinely absent middle
+    // chunk: 2_100 rows span chunks 0-2, every row owning a slot in the full
+    // aligned chunk 1 (slots 1_024-2_047) is removed, and a settled
+    // evaluate-lane transition rebuilds `recordsBySlot` from entries — which
+    // allocates NO chunk for an all-hole span. The identity sweep must then
+    // finish its build in exactly TWO units (chunks 0 and 2).
+    const rows: Row[] = Array.from({ length: 2_100 }, (_, index) => ({
+      id: `r${String(index).padStart(4, "0")}`,
+      team: index % 2 === 0 ? "X" : "Y",
+      score: index % 100,
+      note: `n${String(index).padStart(4, "0")}`,
+      rank: 3_000 - index,
+    }));
+    const { model, scheduler } = createFixture({ rows });
+
+    // Remove by SLOT, not by construction order: the ids are looked up from
+    // the live root so allocator behavior cannot skew which rows go.
+    const seededRoot = rootOf(model);
+    const removeIds: string[] = [];
+    for (const [rowId, record] of seededRoot.rows.entries()) {
+      if (record.slot >= 1_024 && record.slot < 2_048)
+        removeIds.push(String(rowId));
+    }
+    expect(removeIds).toHaveLength(1_024);
+    expect(model.applyTransaction({ remove: removeIds })).toMatchObject({
+      removed: 1_024,
+    });
+    // An evaluate-lane transition (comparator change on the ACTIVE sort
+    // column) republishes the slot vector via `slotVectorFromEntries`.
+    const replacement = derivationsWithDescendingNote();
+    const rebuild = model.setDerivations(replacement);
+    scheduler.flushAll();
+    await rebuild.finished;
+
+    // Fixture non-vacuity: chunk 1 is genuinely ABSENT — a defined-but-empty
+    // chunk would degrade this pin into the ordinary chunk-scan case.
+    const captured = rootOf(model);
+    expect(captured.recordsBySlot.chunks).toHaveLength(3);
+    expect(captured.recordsBySlot.chunks[0]).toBeDefined();
+    expect(captured.recordsBySlot.chunks[1]).toBeUndefined();
+    expect(captured.recordsBySlot.chunks[2]).toBeDefined();
+
+    // Identity-lane set-query under the fixture's one-unit slices: unit 1 is
+    // chunk 0 (1_024 rows), unit 2 must be chunk 2 (52 rows) — the absent
+    // chunk in between is skipped inside the SAME unit, for free.
+    const transition = model.setQuery(COMBINED_QUERY);
+    expect(scheduler.entries.length).toBeGreaterThan(0);
+    const candidate = activeCandidateOf(model);
+    expect(candidate.totalRows).toBe(1_076);
+    expect(candidate.completedRows).toBe(1_024);
+
+    scheduler.flushOne();
+    expect(candidate.completedRows).toBe(1_076);
+    expect(model.getState().status).toMatchObject({ kind: "rebuilding" });
+
+    scheduler.flushAll();
+    await transition.finished;
+    expect(candidate.completedRows).toBe(candidate.totalRows);
+    const remaining = new Set(removeIds);
+    expectSettledEqualsCold(
+      model,
+      rows.filter((row) => !remaining.has(row.id)),
+      COMBINED_QUERY,
+      replacement,
+    );
+    model.dispose();
+  });
+
+  test("a mid-flight delta on a >1-chunk identity sweep still upgrades and settles equal to cold (M2 amendment)", async () => {
+    // The chunk unit shrank the mid-build window (the 8-row M1 fixtures now
+    // finish their sweep in the synchronous first slice), so THIS pin owns
+    // the identity lane's upgrade path under chunk units: the delta lands
+    // after chunk 0 but before the partial chunk, forcing `upgradeForReplay`
+    // plus per-row replay units mid-sweep. The 40-row add also grows the
+    // slot space past the captured bitset's word coverage (1_100 slots pad
+    // to 1_120 bits), keeping the `append`-time `cloneMembership` widening
+    // under live mid-flight coverage now that the M1 widening pin's window
+    // closes in the synchronous slice.
+    const rows: Row[] = Array.from({ length: 1_100 }, (_, index) => ({
+      id: `r${String(index).padStart(4, "0")}`,
+      team: index % 2 === 0 ? "X" : "Y",
+      score: index % 100,
+      note: `n${String(index).padStart(4, "0")}`,
+      rank: 2_000 - index,
+    }));
+    const { model, scheduler } = createFixture({ rows });
+    const transition = model.setQuery(COMBINED_QUERY);
+    const candidate = activeCandidateOf(model);
+    expect(candidate.completedRows).toBe(1_024);
+    const added: Row[] = Array.from({ length: 40 }, (_, index) => ({
+      id: `z${String(index).padStart(2, "0")}`,
+      team: "Z",
+      score: 41, // passes lte 60 — every grown-slot row is VISIBLE.
+      note: `zz${String(index).padStart(2, "0")}`,
+      rank: 3_000 + index,
+    }));
+    expect(
+      model.applyTransaction({
+        update: [{ id: "r0001", changes: { score: 55 } }],
+        remove: ["r0002"],
+        add: added,
+      }),
+    ).toMatchObject({ updated: 1, removed: 1, added: 40 });
+    // Non-vacuity for the widening claim: a grown slot really lands past the
+    // captured bitset's 1_120-bit word coverage.
+    const target = rootOf(model);
+    const addedSlots = added.map((row) => target.rows.get(row.id)!.slot);
+    expect(Math.max(...addedSlots)).toBeGreaterThanOrEqual(1_120);
+    scheduler.flushAll();
+    await transition.finished;
+
+    const finalRows: Row[] = rows
+      .filter((row) => row.id !== "r0002")
+      .map((row) => (row.id === "r0001" ? { ...row, score: 55 } : row));
+    finalRows.push(...added);
+    expectSettledEqualsCold(model, finalRows, COMBINED_QUERY);
+    expect(candidate.completedRows).toBe(candidate.totalRows);
+    model.dispose();
+  });
+
+  test("slot holes in the captured chunk are skipped for free and never counted (M2 amendment)", async () => {
+    // Removing rows BEFORE the transition leaves holes in the captured slot
+    // vector's chunk 0. The chunk unit must advance `completedRows` by the
+    // POPULATED slots only: counting holes (or chunk scans) would overshoot
+    // `totalRows` and break the terminal accounting below.
+    const { model, scheduler } = createFixture();
+    expect(model.applyTransaction({ remove: ["c", "f"] })).toMatchObject({
+      removed: 2,
+    });
+    const transition = model.setQuery(COMBINED_QUERY);
+    expect(scheduler.entries.length).toBeGreaterThan(0);
+    const candidate = activeCandidateOf(model);
+    expect(candidate.totalRows).toBe(FIXTURE_ROWS.length - 2);
+    expect(candidate.completedRows).toBe(FIXTURE_ROWS.length - 2);
+
+    scheduler.flushAll();
+    await transition.finished;
+    expect(candidate.completedRows).toBe(candidate.totalRows);
+    expectSettledEqualsCold(
+      model,
+      FIXTURE_ROWS.filter((row) => row.id !== "c" && row.id !== "f"),
+      COMBINED_QUERY,
+    );
+    model.dispose();
+  });
+
   test("a settled delta-free flat transition accounts for every row (completed === total)", async () => {
     const { model, scheduler } = createFixture();
     const transition = model.setQuery(COMBINED_QUERY);
 
@@ -106,6 +106,7 @@ function createModel(options: {
   readonly scheduler?: CooperativeTransitionScheduler;
   readonly budgetMs?: number;
   readonly clock?: () => number;
+  readonly maxUnitsPerSlice?: number;
 }) {
   return createLocalRowModel({
     rows:
@@ -119,6 +120,7 @@ function createModel(options: {
     transitionScheduler: options.scheduler,
     transitionClock: options.clock,
     transitionBudgetMs: options.budgetMs,
+    transitionMaxUnitsPerSlice: options.maxUnitsPerSlice,
   });
 }
 
@@ -341,15 +343,21 @@ describe("cooperative query and derivation transitions", () => {
 
   test("yields after a bounded number of units when the injected clock never advances", async () => {
     const scheduler = new ManualScheduler();
+    // Re-pinned for the M2 amendment (#490): a flat set-query's build unit is
+    // now ONE slot-vector chunk (1_024 rows), so the default 256-unit cap can
+    // no longer bind on a small flat fixture — the fixture spans three chunks
+    // and caps the slice at two units, and the bounded first slice completes
+    // exactly two chunks' worth of rows (impossible under one-row units).
     const model = createModel({
-      rows: Array.from({ length: 1_000 }, (_, id) => ({
+      rows: Array.from({ length: 3_000 }, (_, id) => ({
         id,
         team: "A",
         score: id,
       })),
       scheduler,
       clock: () => 0,
       budgetMs: 5,
+      maxUnitsPerSlice: 2,
     });
 
     const transition = model.setQuery({
@@ -360,8 +368,8 @@ describe("cooperative query and derivation transitions", () => {
 
     expect(model.getState().status).toMatchObject({
       kind: "rebuilding",
-      completedRows: 256,
-      totalRows: 1_000,
+      completedRows: 2_048,
+      totalRows: 3_000,
     });
     expect(scheduler.entries).toHaveLength(1);
     scheduler.flushAll();