queen-mq 1.3.0 → 2.0.0

package/test-v2/timers.js

@@ -1,8 +1,9 @@
 /**
  * Timer integration suite (PLAN_KV_TIMERS.md §4, §9.6, §20.2).
  *
- * Repeatable only because run.js purges `queen.log_timers` for the `test-%`
- * queues before the run: a pending timer left behind by a previous run fires
+ * Repeatable only because every run starts on a fresh broker (test/run.sh
+ * creates the lane's data volume empty and destroys it with `down -v`): on a
+ * broker that kept it, a pending timer left behind by a previous run fires
  * into the queue of the next one and shows up as a phantom message in an
  * unrelated test.
  *
@@ -21,7 +22,7 @@ export async function timerSchedulesAndFires(client) {
   // A per-run marker, so a message left in this queue by an earlier run can
   // never be mistaken for this run's delivery. It is the one place in these
   // suites where per-run uniqueness is right: the assertion is about THIS
-  // timer's identity, and the purge cannot be relied on to prove identity.
+  // timer's identity, and a clean start cannot be relied on to prove identity.
   const run = `fire-${Date.now()}`
   const res = await client.timer(queueName)
     .key('fire-1')
@@ -34,8 +35,8 @@ export async function timerSchedulesAndFires(client) {
   }
 
   // deliverAt is "not before", never "exactly at", and the visibility of a
-  // fired timer to a consumer is bounded by the hot-list reseed, not by the
-  // delay -- see popUntil, which measured it. The assertion is arrival.
+  // fired timer to a consumer is bounded by the broker's fire step, not by the
+  // delay -- see popUntil. The assertion is arrival.
   const mine = await popUntil(client, queueName, m => m.data && m.data.run === run)
 
   if (mine.length !== 1) {

package/test-v2/transaction.js

@@ -1,3 +1,5 @@
+import { TEST_CONFIG } from './run.js'
+
 export async function transactionBasicPushAck(client) {
     const queueA = await client.queue('test-queue-v2-txn-basic-a').create()
     const queueB = await client.queue('test-queue-v2-txn-basic-b').create()
@@ -572,3 +574,170 @@ export async function transactionAckWithConsumerGroup(client) {
     }
 }
 
+
+// An ack takes the consumer group the message was popped under (2026-10-02,
+// 2.0.0-beta.6). Without an explicit { consumerGroup } the op was judged in
+// queue mode and the bundle rolled back with rejected_ack; queen.ack() came
+// back "invalid or expired lease" the same way.
+export async function transactionAckTakesGroupFromMessage(client) {
+    const source = 'test-queue-v2-txn-group-from-msg'
+    const sink = 'test-queue-v2-txn-group-from-msg-out'
+    const group = 'test-txn-group-from-msg'
+    const qa = await client.queue(source).create()
+    const qb = await client.queue(sink).create()
+    if (!qa.configured || !qb.configured) {
+        return { success: false, message: 'Queues not created' }
+    }
+    await client.queue(source).push([{ data: { value: 1 } }, { data: { value: 2 } }])
+
+    const messages = await client.queue(source).group(group).subscriptionMode('all').batch(2).wait(false).pop()
+    if (messages.length !== 2) {
+        return { success: false, message: `Expected 2 messages, got ${messages.length}` }
+    }
+    if (messages[0].consumerGroup !== group) {
+        return { success: false, message: `pop answered consumerGroup=${messages[0].consumerGroup}, expected ${group}` }
+    }
+
+    let committed
+    try {
+        committed = await client.transaction()
+            .ack(messages[0])
+            .queue(sink).push([{ data: { from: messages[0].data.value } }])
+            .commit()
+    } catch (error) {
+        return { success: false, message: `commit threw (${error.reason}): ${error.message}` }
+    }
+    const direct = await client.ack(messages[1], true)
+    const after = await client.queue(source).group(group).batch(2).wait(false).pop()
+    const forwarded = await client.queue(sink).batch(1).wait(false).pop()
+
+    const success = committed.success === true && direct.success === true && after.length === 0 && forwarded.length === 1
+    return {
+        success,
+        message: success
+            ? 'transaction().ack and queen.ack took the group from the message'
+            : `txn=${committed.success} direct=${direct.success} (${direct.error}) after=${after.length} forwarded=${forwarded.length}`
+    }
+}
+
+// ============================================================================
+// A bundle that acks messages of two leases (2026-10-03, 2.0.0-beta.6)
+// ============================================================================
+//
+// A Queen 2 broker fences each ack with the leaseId the operation carries, and
+// lends requiredLeases to an ack without one only when the bundle names a
+// single lease. An ack that left its lease in requiredLeases alone was applied
+// in a bundle of two leases even after its lease expired and another consumer
+// took the message. The builder has no per-pop lease knob, so these pops go
+// through fetch, as in semantics.js.
+
+const sleep = ms => new Promise(resolve => setTimeout(resolve, ms))
+const fenceQueue = name => `test-queue-v2-txn-fence-${name}-${Date.now()}`
+
+/** One message of a queue-mode pop leased for `leaseSeconds`, or null. */
+async function popLeased(queue, leaseSeconds, tries = 20) {
+    const qs = new URLSearchParams({
+        batch: '1',
+        wait: 'false',
+        leaseSeconds: String(leaseSeconds),
+        subscriptionMode: 'all'
+    })
+    // Lazy: run.js imports this module before TEST_CONFIG is initialized.
+    const url = `${TEST_CONFIG.baseUrls[0]}/api/v1/pop/queue/${queue}?${qs}`
+    for (let i = 0; i < tries; i++) {
+        const res = await fetch(url)
+        if (res.status !== 204) {
+            if (!res.ok) throw new Error(`pop ${queue}: HTTP ${res.status}`)
+            const body = await res.json()
+            if (body.messages && body.messages.length > 0) return body.messages[0]
+        }
+        await sleep(150)
+    }
+    return null
+}
+
+/** The outcome of a commit, whether the client threw the refusal or returned it. */
+async function commitOutcome(transaction) {
+    try {
+        const result = await transaction.commit()
+        return { committed: result.success === true, error: result.error || null }
+    } catch (error) {
+        return { committed: false, error: error.message }
+    }
+}
+
+export async function transactionTwoLeaseBundleExpiredLeaseRefused(client) {
+    const queueA = fenceQueue('stale-a')
+    const queueB = fenceQueue('stale-b')
+    const qa = await client.queue(queueA).create()
+    const qb = await client.queue(queueB).create()
+    if (!qa.configured || !qb.configured) {
+        return { success: false, message: 'Queues not created' }
+    }
+    await client.queue(queueA).push([{ data: { name: 'a' } }])
+    await client.queue(queueB).push([{ data: { name: 'b' } }])
+
+    const a = await popLeased(queueA, 1)
+    const b = await popLeased(queueB, 60)
+    if (!a?.leaseId || !b?.leaseId || a.leaseId === b.leaseId) {
+        return { success: false, message: `Expected two messages under two leases, got a=${a?.leaseId} b=${b?.leaseId}` }
+    }
+
+    // Lease A expires, and another consumer takes the message.
+    const taken = await popLeased(queueA, 60, 100)
+    if (!taken || taken.transactionId !== a.transactionId || taken.leaseId === a.leaseId) {
+        return { success: false, message: 'The message of the expired lease was not delivered again under a new lease' }
+    }
+
+    const stale = await commitOutcome(client.transaction().ack(a).ack(b))
+    if (stale.committed) {
+        return { success: false, message: 'The bundle committed: the ack under the expired lease was applied unfenced' }
+    }
+    if (!/rolled back/.test(stale.error || '')) {
+        return { success: false, message: `The bundle was refused, but not as a rollback: ${stale.error}` }
+    }
+
+    // Nothing of the bundle happened: each holder still settles its own message.
+    const takenAck = await commitOutcome(client.transaction().ack(taken))
+    const bAck = await commitOutcome(client.transaction().ack(b))
+    const leftA = await client.queue(queueA).batch(10).wait(false).pop()
+    const leftB = await client.queue(queueB).batch(10).wait(false).pop()
+
+    const success = takenAck.committed && bAck.committed && leftA.length === 0 && leftB.length === 0
+    return {
+        success,
+        message: success
+            ? 'A bundle with an ack under an expired lease was refused whole; each holder then settled its own message'
+            : `new holder ack=${takenAck.committed} (${takenAck.error}), B ack=${bAck.committed} (${bAck.error}), left A=${leftA.length} B=${leftB.length}`
+    }
+}
+
+export async function transactionTwoLeaseBundleLiveLeasesCommit(client) {
+    const queueA = fenceQueue('live-a')
+    const queueB = fenceQueue('live-b')
+    const qa = await client.queue(queueA).create()
+    const qb = await client.queue(queueB).create()
+    if (!qa.configured || !qb.configured) {
+        return { success: false, message: 'Queues not created' }
+    }
+    await client.queue(queueA).push([{ data: { name: 'a' } }])
+    await client.queue(queueB).push([{ data: { name: 'b' } }])
+
+    const a = await popLeased(queueA, 60)
+    const b = await popLeased(queueB, 60)
+    if (!a?.leaseId || !b?.leaseId || a.leaseId === b.leaseId) {
+        return { success: false, message: `Expected two messages under two leases, got a=${a?.leaseId} b=${b?.leaseId}` }
+    }
+
+    const outcome = await commitOutcome(client.transaction().ack(a).ack(b))
+    const leftA = await client.queue(queueA).batch(10).wait(false).pop()
+    const leftB = await client.queue(queueB).batch(10).wait(false).pop()
+
+    const success = outcome.committed && leftA.length === 0 && leftB.length === 0
+    return {
+        success,
+        message: success
+            ? 'A bundle of two live leases completed both messages'
+            : `commit=${outcome.committed} (${outcome.error}), left A=${leftA.length} B=${leftB.length}`
+    }
+}

package/test-v2/watermark.js

@@ -1,90 +1,36 @@
 /**
- * Seek / delete re-consumption tests (behaviour, not bookkeeping)
+ * Seek / delete re-consumption tests.
  *
- * These tests verify the BEHAVIOUR a user cares about:
+ * These pin the BEHAVIOUR a user cares about, and nothing else:
  *   1. Seeking a consumer group backwards re-exposes the old messages, and the
  *      group re-consumes them from the start within a short bound.
  *   2. Deleting a consumer group (all queues, or for one queue) lets a group of
  *      the same name consume every message again from the start.
  *
- * WHY THIS WAS REWRITTEN (2026-07-24)
- * -----------------------------------
- * The consumer_watermarks table is a LEGACY-path optimisation: it records when a
- * consumer last found a queue empty so an indexed empty-scan can be skipped. The
- * original tests asserted the *row* was created after an empty poll and then aged
- * it to exercise the 2-minute buffer:
- *     pl.updated_at >= (v_watermark - interval '2 minutes')
- *
- * With the wildcard hot-list ON (QUEEN_HOTLIST=1, the default) empty polls are
- * answered from the in-memory candidate ring and that bookkeeping row is NEVER
- * written — by design, not a bug: the ring, not the watermark, is the discovery
- * source. So asserting the row exists fails on the hot-list path even though
- * re-consumption works perfectly.
- *
- * The behaviour is identical on both engines, so these tests now assert the
- * behaviour directly and only exercise the watermark-age scenario on the LEGACY
- * path — detected at runtime by whether the empty poll actually wrote the row
- * (no env flag needed). On the hot-list path the broker's seek/delete handlers
- * re-seed / invalidate the ring so the reconsume is immediate; the idle-bounded
- * consume below (idleMillis 3000) is what proves "within a short bound".
+ * Each test first drains the queue and polls it empty, so the group has seen
+ * "nothing to deliver" before the seek or the delete. "Within a short bound"
+ * is the idle-bounded consume (idleMillis 3000) that follows: a seek or a
+ * delete that left stale per-group state behind makes that consume go idle
+ * before every message came back, and the count comes up short.
  *
  * Run: node run.js seekBackwardsAllowsReconsume
  *      node run.js deleteConsumerGroupAllowsReconsume
  *      node run.js deleteConsumerGroupForQueueAllowsReconsume
  */
 
-import { dbPool } from './run.js'
-
 const QUEUE_NAME_SEEK = 'test-queue-v2-watermark-seek'
 const QUEUE_NAME_DELETE = 'test-queue-v2-watermark-delete'
 
-/**
- * Helper: Move the watermark FORWARD in time to simulate that partitions
- * are "old" relative to the watermark.
- *
- * The filter is: pl.updated_at >= (v_watermark - interval '2 minutes')
- *
- * If watermark = NOW + 10 minutes, then:
- *   filter = pl.updated_at >= (NOW + 10 - 2) = pl.updated_at >= NOW + 8
- *
- * Partitions updated at NOW will fail this filter (NOW < NOW + 8)
- */
-async function advanceWatermark(queueName, consumerGroup, minutesForward = 10) {
-    const result = await dbPool.query(`
-        UPDATE queen.consumer_watermarks w
-        SET last_empty_scan_at = NOW() + interval '${minutesForward} minutes',
-            updated_at = NOW() + interval '${minutesForward} minutes'
-        FROM queen.queues q
-        WHERE w.queue_id = q.id AND q.name = $1 AND w.consumer_group = $2
-        RETURNING w.*
-    `, [queueName, consumerGroup])
-    return result.rows[0]
-}
-
-/**
- * Helper: Check if watermark exists for a queue/consumer_group
- */
-async function getWatermark(queueName, consumerGroup) {
-    const result = await dbPool.query(`
-        SELECT w.* FROM queen.consumer_watermarks w
-        JOIN queen.queues q ON q.id = w.queue_id
-        WHERE q.name = $1 AND w.consumer_group = $2
-    `, [queueName, consumerGroup])
-    return result.rows[0]
-}
-
 /**
  * Test: Seeking backwards should allow re-consumption of messages
  *
  * Steps:
  * 1. Push messages to queue
- * 2. Consume all messages with a consumer group (watermark advances)
- * 3. Artificially age the watermark (simulate 10 minutes passing)
- * 4. Seek the consumer group backwards to before the messages
- * 5. Try to consume again - should get all messages
+ * 2. Consume all messages with a consumer group, then poll it empty
+ * 3. Seek the consumer group backwards to before the messages
+ * 4. Try to consume again - should get all messages
  *
- * Expected: All messages are re-consumed after seek
- * Actual (bug): Watermark blocks re-consumption, 0 messages returned
+ * Expected: All messages are re-consumed after seek, within the idle window
  */
 export async function seekBackwardsAllowsReconsume(client) {
     const consumerGroup = 'watermark-seek-test-cg'
@@ -92,11 +38,6 @@ export async function seekBackwardsAllowsReconsume(client) {
     // Cleanup
     try {
         await client.deleteConsumerGroup(consumerGroup, true)
-        // Also clean up any orphaned watermark from previous runs
-        await dbPool.query(
-            'DELETE FROM queen.consumer_watermarks WHERE consumer_group = $1',
-            [consumerGroup]
-        )
     } catch (e) {
         // Ignore
     }
@@ -147,7 +88,7 @@ export async function seekBackwardsAllowsReconsume(client) {
         }
     }
 
-    // 5. Verify queue is empty for this consumer (triggers watermark advancement)
+    // 5. Verify queue is empty for this consumer (the group has now polled empty)
     const emptyCheck = await client
         .queue(QUEUE_NAME_SEEK)
         .group(consumerGroup)
@@ -162,24 +103,9 @@ export async function seekBackwardsAllowsReconsume(client) {
         }
     }
 
-    console.log(`  Verified queue is empty (watermark should be set)`)
-
-    // 6. Detect which discovery path we are on. On the LEGACY path the empty poll
-    //    wrote a consumer_watermarks row; on the hot-list path it did not (empty
-    //    polls are served from the ring — by design). We do NOT assert the row: it
-    //    is a path-specific bookkeeping detail, not the behaviour under test.
-    const watermarkBefore = await getWatermark(QUEUE_NAME_SEEK, consumerGroup)
-    if (watermarkBefore) {
-        // Legacy path: age the watermark 10 minutes into the future so the old
-        // partitions fall outside the 2-minute buffer — the original repro that
-        // proves seek must reset the watermark.
-        const advancedWatermark = await advanceWatermark(QUEUE_NAME_SEEK, consumerGroup, 10)
-        console.log(`  [legacy] Watermark row exists; advanced to ${advancedWatermark.last_empty_scan_at} (10m future)`)
-    } else {
-        console.log(`  [hotlist] No watermark row (empty polls served from the ring) — skipping the watermark-age step`)
-    }
+    console.log(`  Verified queue is empty`)
 
-    // 8. Seek backwards to BEFORE the messages were pushed
+    // 6. Seek backwards to BEFORE the messages were pushed
     console.log(`  Seeking to timestamp: ${timestampBeforeMessages}`)
 
     const seekResult = await client.admin.seekConsumerGroup(
@@ -190,18 +116,10 @@ export async function seekBackwardsAllowsReconsume(client) {
 
     console.log(`  Seek result: ${JSON.stringify(seekResult)}`)
 
-    // 9. Check if watermark was reset (it should be, but currently isn't - that's the bug)
-    const watermarkAfterSeek = await getWatermark(QUEUE_NAME_SEEK, consumerGroup)
-    if (watermarkAfterSeek) {
-        console.log(`  WARNING: Watermark still exists after seek: ${watermarkAfterSeek.last_empty_scan_at}`)
-    } else {
-        console.log(`  Watermark was properly deleted after seek`)
-    }
-
     // Small delay after seek
     await new Promise(resolve => setTimeout(resolve, 500))
 
-    // 10. Try to consume again - should get all messages back
+    // 7. Try to consume again - should get all messages back
     let secondConsumeCount = 0
     await client
         .queue(QUEUE_NAME_SEEK)
@@ -216,17 +134,13 @@ export async function seekBackwardsAllowsReconsume(client) {
 
     console.log(`  Second consume (after seek): ${secondConsumeCount} messages`)
 
-    // 11. Verify we got all messages back within the idle-bounded consume above.
-    //     A shortfall means the backward seek did not re-expose the messages
-    //     promptly: on the legacy path the consumer_watermarks row was not reset
-    //     (still at ${watermarkAfterSeek?.last_empty_scan_at}); on the hot-list path
-    //     the ring was not re-seeded, so reconsume would only resume at the ≤30s
-    //     periodic floor instead of immediately.
+    // 8. Verify we got all messages back within the idle-bounded consume above.
+    //    A shortfall means the backward seek did not re-expose the messages
+    //    promptly.
     if (secondConsumeCount !== messageCount) {
         return {
             success: false,
-            message: `After seek backwards, should re-consume ${messageCount} messages within the idle window, but got ${secondConsumeCount}. ` +
-                     `(legacy watermark after seek: ${watermarkAfterSeek?.last_empty_scan_at})`
+            message: `After seek backwards, should re-consume ${messageCount} messages within the idle window, but got ${secondConsumeCount}`
         }
     }
 
@@ -241,14 +155,12 @@ export async function seekBackwardsAllowsReconsume(client) {
  *
  * Steps:
  * 1. Push messages to queue
- * 2. Consume all messages with a consumer group (watermark advances)
- * 3. Artificially age the watermark (simulate 10 minutes passing)
- * 4. Delete the consumer group
- * 5. Create a new consumer group with the SAME name
- * 6. Try to consume - should get all messages
+ * 2. Consume all messages with a consumer group, then poll it empty
+ * 3. Delete the consumer group
+ * 4. Create a new consumer group with the SAME name
+ * 5. Try to consume - should get all messages
  *
  * Expected: All messages are consumed by the "new" consumer group
- * Actual (bug): Orphaned watermark blocks consumption, 0 messages returned
  */
 export async function deleteConsumerGroupAllowsReconsume(client) {
     const consumerGroup = 'watermark-delete-test-cg'
@@ -256,11 +168,6 @@ export async function deleteConsumerGroupAllowsReconsume(client) {
     // Cleanup
     try {
         await client.deleteConsumerGroup(consumerGroup, true)
-        // Also clean up any orphaned watermark from previous runs
-        await dbPool.query(
-            'DELETE FROM queen.consumer_watermarks WHERE consumer_group = $1',
-            [consumerGroup]
-        )
     } catch (e) {
         // Ignore
     }
@@ -305,7 +212,7 @@ export async function deleteConsumerGroupAllowsReconsume(client) {
         }
     }
 
-    // 4. Verify queue is empty for this consumer (triggers watermark advancement)
+    // 4. Verify queue is empty for this consumer (the group has now polled empty)
     const emptyCheck = await client
         .queue(QUEUE_NAME_DELETE)
         .group(consumerGroup)
@@ -320,40 +227,20 @@ export async function deleteConsumerGroupAllowsReconsume(client) {
         }
     }
 
-    console.log(`  Verified queue is empty (watermark should be set)`)
-
-    // 5. Detect the discovery path (see seekBackwardsAllowsReconsume). The
-    //    watermark row is a legacy-path artefact, not the behaviour under test, so
-    //    we do not assert it — we only exercise the watermark-age scenario when the
-    //    row was actually written (legacy path).
-    const watermarkBefore = await getWatermark(QUEUE_NAME_DELETE, consumerGroup)
-    if (watermarkBefore) {
-        const advancedWatermark = await advanceWatermark(QUEUE_NAME_DELETE, consumerGroup, 10)
-        console.log(`  [legacy] Watermark row exists; advanced to ${advancedWatermark.last_empty_scan_at} (10m future)`)
-    } else {
-        console.log(`  [hotlist] No watermark row (empty polls served from the ring) — skipping the watermark-age step`)
-    }
+    console.log(`  Verified queue is empty`)
 
-    // 7. Delete the consumer group
+    // 5. Delete the consumer group
     console.log(`  Deleting consumer group: ${consumerGroup}`)
 
     const deleteResult = await client.deleteConsumerGroup(consumerGroup, true)
     console.log(`  Delete result: ${JSON.stringify(deleteResult)}`)
 
-    // 8. Check if watermark was deleted (it should be, but currently isn't - that's the bug)
-    const watermarkAfterDelete = await getWatermark(QUEUE_NAME_DELETE, consumerGroup)
-    if (watermarkAfterDelete) {
-        console.log(`  WARNING: Orphaned watermark still exists: ${watermarkAfterDelete.last_empty_scan_at}`)
-    } else {
-        console.log(`  Watermark was properly deleted`)
-    }
-
     // Small delay after delete
     await new Promise(resolve => setTimeout(resolve, 500))
 
-    // 9. Create a "new" consumer group with the same name and try to consume
-    //    Since partition_consumers was deleted, this should start fresh
-    //    But if consumer_watermarks wasn't deleted, it will skip all messages
+    // 6. Create a "new" consumer group with the same name and try to consume.
+    //    The delete removed the group's cursors and metadata, so it must start
+    //    fresh; any per-group state that survived would skip the messages.
     let secondConsumeCount = 0
     await client
         .queue(QUEUE_NAME_DELETE)
@@ -369,16 +256,14 @@ export async function deleteConsumerGroupAllowsReconsume(client) {
 
     console.log(`  Second consume (after delete + recreate): ${secondConsumeCount} messages`)
 
-    // 10. Verify we got all messages within the idle-bounded consume above. A
-    //     shortfall means the delete left stale discovery state: a legacy orphaned
-    //     watermark (at ${watermarkAfterDelete?.last_empty_scan_at}), or, on the
-    //     hot-list path, a surviving group ring / stale seeded-groups cache that
-    //     suppressed the from-the-start reconsume.
+    // 7. Verify we got all messages within the idle-bounded consume above. A
+    //    shortfall means the delete left stale per-group state behind that
+    //    suppressed the from-the-start reconsume.
     if (secondConsumeCount !== messageCount) {
         return {
             success: false,
             message: `After deleting CG, new CG with same name should consume ${messageCount} messages within the idle window, ` +
-                     `but got ${secondConsumeCount}. (legacy watermark after delete: ${watermarkAfterDelete?.last_empty_scan_at})`
+                     `but got ${secondConsumeCount}`
         }
     }
 
@@ -400,11 +285,6 @@ export async function deleteConsumerGroupForQueueAllowsReconsume(client) {
     // Cleanup
     try {
         await client.admin.deleteConsumerGroupForQueue(consumerGroup, queueName, true)
-        // Also clean up any orphaned watermark from previous runs
-        await dbPool.query(
-            'DELETE FROM queen.consumer_watermarks w USING queen.queues q WHERE w.queue_id = q.id AND q.name = $1 AND w.consumer_group = $2',
-            [queueName, consumerGroup]
-        )
     } catch (e) {
         // Ignore
     }
@@ -449,7 +329,7 @@ export async function deleteConsumerGroupForQueueAllowsReconsume(client) {
         }
     }
 
-    // 4. Verify queue is empty (triggers watermark)
+    // 4. Verify queue is empty (the group has now polled empty)
     const emptyCheck = await client
         .queue(queueName)
         .group(consumerGroup)
@@ -464,35 +344,17 @@ export async function deleteConsumerGroupForQueueAllowsReconsume(client) {
         }
     }
 
-    console.log(`  Verified queue is empty (watermark should be set)`)
-
-    // 5. Detect the discovery path (see seekBackwardsAllowsReconsume). The
-    //    watermark row is a legacy-path artefact, not the behaviour under test.
-    const watermarkBefore = await getWatermark(queueName, consumerGroup)
-    if (watermarkBefore) {
-        const advancedWatermark = await advanceWatermark(queueName, consumerGroup, 10)
-        console.log(`  [legacy] Watermark row exists; advanced to ${advancedWatermark.last_empty_scan_at} (10m future)`)
-    } else {
-        console.log(`  [hotlist] No watermark row (empty polls served from the ring) — skipping the watermark-age step`)
-    }
+    console.log(`  Verified queue is empty`)
 
-    // 7. Delete consumer group for this specific queue
+    // 5. Delete consumer group for this specific queue
     console.log(`  Deleting consumer group for queue: ${consumerGroup} / ${queueName}`)
 
     const deleteResult = await client.admin.deleteConsumerGroupForQueue(consumerGroup, queueName, true)
     console.log(`  Delete result: ${JSON.stringify(deleteResult)}`)
 
-    // 8. Check if watermark was deleted
-    const watermarkAfterDelete = await getWatermark(queueName, consumerGroup)
-    if (watermarkAfterDelete) {
-        console.log(`  WARNING: Orphaned watermark still exists: ${watermarkAfterDelete.last_empty_scan_at}`)
-    } else {
-        console.log(`  Watermark was properly deleted`)
-    }
-
     await new Promise(resolve => setTimeout(resolve, 500))
 
-    // 9. Try to consume again
+    // 6. Try to consume again
     let secondConsumeCount = 0
     await client
         .queue(queueName)
@@ -512,7 +374,7 @@ export async function deleteConsumerGroupForQueueAllowsReconsume(client) {
         return {
             success: false,
             message: `After deleting CG for queue, should consume ${messageCount} messages within the idle window, ` +
-                     `but got ${secondConsumeCount}. (legacy watermark after delete: ${watermarkAfterDelete?.last_empty_scan_at})`
+                     `but got ${secondConsumeCount}`
         }
     }