queen-mq 0.16.0 → 1.0.0

package/test-v2/http-unit/retry429.test.js

@@ -0,0 +1,314 @@
+/**
+ * Client-side 429/403 handling tests (PLAN_QUEEN_PROXY_CLOUD.md §4/§9,
+ * blocker B4 -- "client 429/backoff work ... mandatory pre-enforcement").
+ *
+ * The proxy error contract under test:
+ *   429  Retry-After: <seconds>  { "error": "...", "code": "rate_limited" | "quota_exceeded" }
+ *   403                          { "error": "...", "code": "cluster_suspended" | "storage_quota_exceeded"
+ *                                                          | "feature_gated" | "forbidden" }
+ *
+ * These tests run against a real local HTTP server (no broker) that plays
+ * back a canned response script, mirroring the style of ack.test.js
+ * (withAckServer) and streams-unit/fakeServer.js -- no mocking framework,
+ * just node:http.
+ */
+
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+import { createServer } from 'node:http'
+
+import { Queen } from '../../client-v2/index.js'
+import { HttpClient } from '../../client-v2/http/HttpClient.js'
+
+/**
+ * Spin up a real HTTP server driven by a canned response `plan` (array of
+ * {status, body, retryAfter, headers}, consumed in request order; any
+ * request beyond the plan gets `defaultResponse`). Records each hit's
+ * arrival time so tests can sanity-check backoff pacing.
+ */
+function withPlanServer(plan, defaultResponse, run) {
+  const hits = []
+  const start = Date.now()
+  let index = 0
+
+  const server = createServer((req, res) => {
+    let raw = ''
+    req.on('data', chunk => { raw += chunk })
+    req.on('end', () => {
+      hits.push({ method: req.method, url: req.url, atMs: Date.now() - start })
+
+      const descriptor = index < plan.length ? plan[index] : defaultResponse
+      index++
+
+      const status = descriptor.status ?? 200
+      const headers = { 'Content-Type': 'application/json', ...(descriptor.headers || {}) }
+      if (descriptor.retryAfter != null) headers['Retry-After'] = String(descriptor.retryAfter)
+
+      res.writeHead(status, headers)
+      res.end(JSON.stringify(descriptor.body ?? { ok: true }))
+    })
+  })
+
+  return new Promise((resolve, reject) => {
+    server.listen(0, '127.0.0.1', () => {
+      const { port } = server.address()
+      const teardown = () => new Promise(r => server.close(r))
+      Promise.resolve()
+        .then(() => run(`http://127.0.0.1:${port}`, hits))
+        .then(
+          async (value) => { await teardown(); resolve(value) },
+          async (err) => { await teardown(); reject(err) }
+        )
+    })
+  })
+}
+
+function rateLimited(retryAfter) {
+  const descriptor = { status: 429, body: { error: 'slow down', code: 'rate_limited' } }
+  if (retryAfter != null) descriptor.retryAfter = retryAfter
+  return descriptor
+}
+
+function repeat(descriptor, n) {
+  return Array.from({ length: n }, () => ({ ...descriptor }))
+}
+
+// ---------------------------------------------------------------------------
+// HttpClient (direct) -- the centralized retry429 mechanism itself.
+// ---------------------------------------------------------------------------
+
+describe('HttpClient — 429 retry policy', () => {
+  it('honors Retry-After (seconds) and succeeds once the header-specified wait elapses', async () => {
+    const plan = [rateLimited('0')]
+    await withPlanServer(plan, { status: 200, body: { ok: true } }, async (url, hits) => {
+      const client = new HttpClient({ baseUrl: url, retry429: { baseMs: 5, capMs: 50 } })
+      try {
+        const result = await client.get('/x')
+        assert.deepEqual(result, { ok: true })
+        assert.equal(hits.length, 2, 'one 429 then one success')
+      } finally {
+        await client.destroy()
+      }
+    })
+  })
+
+  it('falls back to exponential backoff when Retry-After is absent, and the gap grows', async () => {
+    const plan = repeat(rateLimited(), 2)
+    await withPlanServer(plan, { status: 200, body: { ok: true } }, async (url, hits) => {
+      const client = new HttpClient({ baseUrl: url, retry429: { baseMs: 20, capMs: 2000 } })
+      try {
+        const result = await client.get('/x')
+        assert.deepEqual(result, { ok: true })
+        assert.equal(hits.length, 3)
+        const gap1 = hits[1].atMs - hits[0].atMs
+        const gap2 = hits[2].atMs - hits[1].atMs
+        // Exponential (base=20ms -> ~20ms then ~40ms), jittered +-20%: allow
+        // generous slack for CI timer jitter while still proving growth.
+        assert.ok(gap2 > gap1 * 1.2, `expected gap2 (${gap2}ms) to exceed gap1 (${gap1}ms) by backoff growth`)
+      } finally {
+        await client.destroy()
+      }
+    })
+  })
+
+  it('gives up after retry429.maxAttempts on a default (push-like) call and throws rate_limited', async () => {
+    await withPlanServer([], rateLimited(), async (url, hits) => {
+      const client = new HttpClient({ baseUrl: url, retry429: { maxAttempts: 3, baseMs: 1, capMs: 5 } })
+      try {
+        await assert.rejects(
+          client.post('/api/v1/push', { items: [] }),
+          (err) => {
+            assert.equal(err.status, 429)
+            assert.equal(err.code, 'rate_limited')
+            return true
+          }
+        )
+        assert.equal(hits.length, 3, 'exactly maxAttempts tries, no more')
+      } finally {
+        await client.destroy()
+      }
+    })
+  })
+
+  it('defaults to 10 attempts for a default (non-pop) call when retry429 is not configured', async () => {
+    await withPlanServer([], rateLimited(), async (url, hits) => {
+      const client = new HttpClient({ baseUrl: url, retry429: { baseMs: 1, capMs: 2 } })
+      try {
+        await assert.rejects(client.post('/api/v1/push', { items: [] }))
+        assert.equal(hits.length, 10)
+      } finally {
+        await client.destroy()
+      }
+    })
+  })
+
+  it('retries a long-poll pop (retryKind "pop") past the push default of 10 attempts', async () => {
+    const plan = repeat(rateLimited('0'), 14)
+    await withPlanServer(plan, { status: 200, body: { messages: [{ id: 'm1' }] } }, async (url, hits) => {
+      const client = new HttpClient({ baseUrl: url, retry429: { baseMs: 1, capMs: 5 } })
+      try {
+        const result = await client.get('/api/v1/pop', null, null, 'pop')
+        assert.deepEqual(result, { messages: [{ id: 'm1' }] })
+        assert.equal(hits.length, 15, 'pop must not give up at the push default of 10 attempts')
+      } finally {
+        await client.destroy()
+      }
+    })
+  })
+
+  it('an explicit maxAttempts override applies to pop too (not just push)', async () => {
+    await withPlanServer([], rateLimited(), async (url, hits) => {
+      const client = new HttpClient({ baseUrl: url, retry429: { maxAttempts: 2, baseMs: 1, capMs: 5 } })
+      try {
+        await assert.rejects(client.get('/api/v1/pop', null, null, 'pop'))
+        assert.equal(hits.length, 2, 'explicit maxAttempts bounds pop as well as push')
+      } finally {
+        await client.destroy()
+      }
+    })
+  })
+
+  it('never retries a 403 and preserves its code (terminal)', async () => {
+    await withPlanServer([], { status: 403, body: { error: 'cluster suspended', code: 'cluster_suspended' } }, async (url, hits) => {
+      const client = new HttpClient({ baseUrl: url })
+      try {
+        await assert.rejects(
+          client.post('/api/v1/push', { items: [] }),
+          (err) => {
+            assert.equal(err.status, 403)
+            assert.equal(err.code, 'cluster_suspended')
+            return true
+          }
+        )
+        assert.equal(hits.length, 1, '403 must not be retried')
+      } finally {
+        await client.destroy()
+      }
+    })
+  })
+
+  it('still does not retry an ordinary 4xx like 400 (unaffected by the 429 changes)', async () => {
+    await withPlanServer([], { status: 400, body: { error: 'bad request' } }, async (url, hits) => {
+      const client = new HttpClient({ baseUrl: url })
+      try {
+        await assert.rejects(client.get('/x'), (err) => {
+          assert.equal(err.status, 400)
+          return true
+        })
+        assert.equal(hits.length, 1)
+      } finally {
+        await client.destroy()
+      }
+    })
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Queen public API wiring: config plumbing (retry429) + call-site marking
+// (push vs. wait=true pop) actually reach HttpClient.
+// ---------------------------------------------------------------------------
+
+describe('Queen — push()/pop() wired to retry429', () => {
+  it('push() retries a 429 (Retry-After) then succeeds', async () => {
+    const plan = [rateLimited('0')]
+    await withPlanServer(plan, { status: 200, body: [{ status: 'queued', transactionId: 'tx-1' }] }, async (url, hits) => {
+      const queen = new Queen({ url, handleSignals: false, retry429: { baseMs: 5, capMs: 50 } })
+      try {
+        const result = await queen.queue('q1').push({ hello: 'world' })
+        assert.equal(hits.length, 2)
+        assert.equal(result[0].status, 'queued')
+      } finally {
+        await queen.close()
+      }
+    })
+  })
+
+  it('push() surfaces a terminal 403 without retrying', async () => {
+    await withPlanServer([], { status: 403, body: { error: 'over quota', code: 'storage_quota_exceeded' } }, async (url, hits) => {
+      const queen = new Queen({ url, handleSignals: false })
+      try {
+        await assert.rejects(
+          async () => { await queen.queue('q1').push({ hello: 'world' }) },
+          (err) => { assert.equal(err.code, 'storage_quota_exceeded'); return true }
+        )
+        assert.equal(hits.length, 1)
+      } finally {
+        await queen.close()
+      }
+    })
+  })
+
+  it('a long-poll pop() rides out more 429s than the push default before returning', async () => {
+    const plan = repeat(rateLimited('0'), 12)
+    await withPlanServer(plan, { status: 200, body: { messages: [{ transactionId: 'tx-1', data: { x: 1 } }] } }, async (url, hits) => {
+      const queen = new Queen({ url, handleSignals: false, retry429: { baseMs: 1, capMs: 5 } })
+      try {
+        const messages = await queen.queue('q1').wait(true).pop()
+        assert.equal(messages.length, 1)
+        assert.equal(hits.length, 13)
+      } finally {
+        await queen.close()
+      }
+    })
+  })
+
+  it('a non-waiting pop() uses the bounded default and swallows an exhausted 429 to []', async () => {
+    await withPlanServer([], rateLimited(), async (url, hits) => {
+      const queen = new Queen({ url, handleSignals: false, retry429: { maxAttempts: 2, baseMs: 1, capMs: 5 } })
+      try {
+        const messages = await queen.queue('q1').wait(false).pop()
+        assert.deepEqual(messages, [], 'pop() keeps its swallow-errors-to-[] contract')
+        assert.equal(hits.length, 2)
+      } finally {
+        await queen.close()
+      }
+    })
+  })
+})
+
+// ---------------------------------------------------------------------------
+// ConsumerManager worker loop: the actual hot-loop/die bug (B4) this task
+// fixes -- consume() must back off through 429s and stop cleanly on a
+// terminal 403 instead of spinning or crashing uncontrolled.
+// ---------------------------------------------------------------------------
+
+describe('Queen — consume() loop backs off on 429 and stops on terminal 403', () => {
+  it('backs off through repeated 429s and still delivers the message', async () => {
+    const plan = repeat(rateLimited('0'), 3)
+    await withPlanServer(
+      plan,
+      { status: 200, body: { messages: [{ transactionId: 'tx-1', partitionId: 'p-1', data: { x: 1 } }] } },
+      async (url, hits) => {
+        const queen = new Queen({ url, handleSignals: false, retry429: { baseMs: 1, capMs: 5 } })
+        try {
+          const received = []
+          // .each() delivers one message per handler call (default batches
+          // the whole array) -- simplest shape to assert on here.
+          await queen.queue('q1').wait(true).limit(1).autoAck(false).each().consume(async (msg) => {
+            received.push(msg)
+          })
+          assert.equal(received.length, 1)
+          assert.equal(received[0].transactionId, 'tx-1')
+          assert.ok(hits.length >= 4, 'the 3 rate-limited attempts plus the final success must all have hit the server')
+        } finally {
+          await queen.close()
+        }
+      }
+    )
+  })
+
+  it('stops the worker on a terminal 403 (cluster_suspended) instead of hot-looping or hanging', async () => {
+    await withPlanServer([], { status: 403, body: { error: 'cluster suspended', code: 'cluster_suspended' } }, async (url, hits) => {
+      const queen = new Queen({ url, handleSignals: false })
+      try {
+        await assert.rejects(
+          async () => { await queen.queue('q1').wait(true).consume(async () => {}) },
+          (err) => { assert.equal(err.code, 'cluster_suspended'); return true }
+        )
+        assert.equal(hits.length, 1, 'must stop after the first 403, not hot-loop')
+      } finally {
+        await queen.close()
+      }
+    })
+  })
+})

package/test-v2/load.js

@@ -1,3 +1,22 @@
+// Ordering assertion that tolerates REDELIVERY (at-least-once is the broker's
+// contract: a lease expiry / ack timeout on a slow machine legally replays a
+// batch). What it still catches is the real bug class — SKIPPED messages: the
+// stream must never jump PAST an id it hasn't delivered yet. Throwing on a
+// redelivered (already-seen) id instead would nack the batch, and four nacks
+// dead-letter the head (v0.16.0 retry semantics) — turning one benign
+// redelivery into message loss and a failed test.
+function makeOrderingTracker() {
+    let maxId = -1
+    return {
+        observe(id) {
+            if (id > maxId + 1) {
+                throw new Error(`Message ordering violation: jumped from ${maxId} to ${id} (skipped ${id - maxId - 1})`)
+            }
+            if (id > maxId) maxId = id
+        }
+    }
+}
+
 export async function testLoad(client) { 
     const queue = await client
     .queue('test-queue-v2-load')
@@ -19,24 +38,22 @@ export async function testLoad(client) {
     await client.queue('test-queue-v2-load').push(messages)    
 
     let uniqueIds = new Set();
-    let lastId = null;
+    const order = makeOrderingTracker();
 
+    // idleMillis instead of limit(10000): a hard per-worker delivery budget
+    // counts redeliveries too, so one replayed batch makes workers return
+    // "complete" with messages still queued (or spin forever waiting to hit an
+    // exact share). Draining until idle is redelivery-proof — same pattern as
+    // the bootstrap tests.
     await client
     .queue('test-queue-v2-load')
     .concurrency(10)
     .batch(100)
     .wait(false)
-    .limit(10000)
+    .idleMillis(5000)
     .consume(async msgs => {
         for (const msg of msgs) {
-            if (lastId === null) {
-                lastId = msg.data.id
-            } else {
-                if (msg.data.id !== lastId + 1) {
-                    throw new Error('Message ordering violation')
-                }
-                lastId = msg.data.id
-            }
+            order.observe(msg.data.id)
             uniqueIds.add(msg.data.id)
         }
     })
@@ -76,24 +93,16 @@ export async function testLoadPartition(client) {
     
     
     for (let i = 0; i < 10; i++) {
-        let lastId = null;
+        const order = makeOrderingTracker();
     await client
     .queue('test-queue-v2-load-partition')
     .partition(i.toString())
     .batch(100)
     .wait(false)
-    .limit(10000)
+    .idleMillis(5000)
     .consume(async msgs => {
         for (const msg of msgs) {
-            if (lastId === null) {
-                lastId = msg.data.id
-            } else {
-                if (msg.data.id !== lastId + 1) {
-                    console.log(`Message ordering violation: ${msg.data.id} !== ${lastId + 1}`)
-                    throw new Error('Message ordering violation')
-                }
-                lastId = msg.data.id
-            }
+            order.observe(msg.data.id)
             uniqueIds.add(msg.data.id)
         }
     })
@@ -126,7 +135,7 @@ export async function testLoadConsumerGroup(client) {
     await client.queue('test-queue-v2-load-consumer-group').push(messages)    
 
     let uniqueIdsA = new Set();
-    let lastIdA = null;
+    const orderA = makeOrderingTracker();
 
     await client
     .queue('test-queue-v2-load-consumer-group')
@@ -135,23 +144,16 @@ export async function testLoadConsumerGroup(client) {
     .concurrency(10)
     .batch(100)
     .wait(false)
-    .limit(10000)
+    .idleMillis(5000)
     .consume(async msgs => {
         for (const msg of msgs) {
-            if (lastIdA === null) {
-                lastIdA = msg.data.id
-            } else {
-                if (msg.data.id !== lastIdA + 1) {
-                    throw new Error('Message ordering violation')
-                }
-                lastIdA = msg.data.id
-            }
+            orderA.observe(msg.data.id)
             uniqueIdsA.add(msg.data.id)
         }
     })
     
     let uniqueIdsB = new Set();
-    let lastIdB = null;
+    const orderB = makeOrderingTracker();
 
     await client
     .queue('test-queue-v2-load-consumer-group')
@@ -160,22 +162,16 @@ export async function testLoadConsumerGroup(client) {
     .concurrency(10)
     .batch(100)
     .wait(false)
-    .limit(10000)
+    .idleMillis(5000)
     .consume(async msgs => {
         for (const msg of msgs) {
-            if (lastIdB === null) {
-                lastIdB = msg.data.id
-            } else {
-                if (msg.data.id !== lastIdB + 1) {
-                    throw new Error('Message ordering violation')
-                }
-                lastIdB = msg.data.id
-            }
+            orderB.observe(msg.data.id)
             uniqueIdsB.add(msg.data.id)
         }
     })    
 
     const uniqueIdsCountA = uniqueIdsA.size;
     const uniqueIdsCountB = uniqueIdsB.size;
+    console.log(`Unique IDs: groupA=${uniqueIdsCountA} groupB=${uniqueIdsCountB}`)
     return { success: uniqueIdsCountA === messagesToPush && uniqueIdsCountB === messagesToPush, message: 'Load test completed successfully' }
 }

package/test-v2/maintenance.js

@@ -6,8 +6,8 @@ export async function test_maintenance_mode(client = null) {
   
   const queen = client
   
-  // Use port 6632 (default Queen port) for API calls
-  const API_URL = 'http://localhost:6632';
+  // Default Queen port; override with QUEEN_SERVER_URL (same as run.js).
+  const API_URL = process.env.QUEEN_SERVER_URL || 'http://localhost:6632';
   const QUEUE_NAME = 'test-maintenance-queue';
   const MESSAGES_PER_SECOND = 10;
   const MAINTENANCE_DURATION_SECONDS = 10;

package/test-v2/pop.js

@@ -25,11 +25,13 @@ export async function popNonEmptyQueue(client) {
     // wait(false) wildcard pop can race past the not-yet-committed lookup
     // row. Long-poll re-runs the candidate scan and picks up the row
     // once it commits (typically within ms).
+    // docs:start(js-pop)
     const res = await client
     .queue('test-queue-v2-pop-non-empty')
     .batch(1)
     .wait(true)
     .pop()
+    // docs:end
     return { success: res.length === 1 }
 }
 

package/test-v2/push.js

@@ -5,9 +5,11 @@ export async function pushMessage(client) {
     if (!queue.configured) {
         return { success: false, message: 'Queue not created' }
     }
+    // docs:start(js-push)
     const res = await client
     .queue('test-queue-v2')
     .push([{ data: { message: 'Hello, world!' } }])
+    // docs:end
 
     return { success: res[0].status === 'queued' }
 }
@@ -17,14 +19,17 @@ export async function pushDuplicateMessage(client) {
     if (!queue.configured) {
         return { success: false, message: 'Queue not created' }
     }
+    // docs:start(js-push-dedup)
     const res1 = await client
     .queue('test-queue-v2')
     .push([{ transactionId: 'test-transaction-id', data: { message: 'Hello, world!' } }])
-    
+
     const res2 = await client
     .queue('test-queue-v2')
     .push([{ transactionId: 'test-transaction-id', data: { message: 'Hello, world!' } }])
-    
+    // res1[0].status === 'queued', res2[0].status === 'duplicate'
+    // docs:end
+
     return { success: res1[0].status === 'queued' && res2[0].status === 'duplicate' }
 }
 
@@ -518,48 +523,37 @@ export async function testPushMalformedTraceId(client) {
 
 export async function testPushProducerSubEmptyStringBecomesNull(client) {
     // We can't set producerSub from the client (server-stamped field). The
-    // invariant we need to preserve is that when the server writes an empty
-    // producer_sub into the JSON, the SP stores SQL NULL. We verify it by
-    // pushing without auth (server will stamp producerSub as empty / NULL)
-    // and then checking via a short-lived pg client. NOTE: we intentionally
-    // do NOT dynamically import ./run.js here — that module executes
-    // top-level `await main()` and re-importing it while it's running
-    // deadlocks the ESM module graph.
+    // invariant we need to preserve is that a message pushed without auth has a
+    // producerSub of null (never a literal empty string). Black-box port: the
+    // segments engine stores messages in queen.seg_segments and never populates
+    // queen.messages, so we observe the field via the pop API — the seg-native
+    // ground truth — instead of a direct SQL read of queen.messages.
     const queueName = 'test-v3-producer-sub-null'
     const queue = await client.queue(queueName).create()
     if (!queue.configured) {
         return { success: false, message: 'Queue not created' }
     }
-    const res = await client.queue(queueName).push([{ data: { x: 1 } }])
+    const tx = 'tx-psn-' + crypto.randomBytes(4).toString('hex')
+    const res = await client.queue(queueName).push([{ transactionId: tx, data: { x: 1 } }])
     if (res[0].status !== 'queued') {
         return { success: false, message: 'Push failed' }
     }
-    const messageId = res[0].message_id
-
-    const { default: pg } = await import('pg')
-    const pool = new pg.Pool({
-        host: process.env.PG_HOST || 'localhost',
-        port: process.env.PG_PORT || 5432,
-        database: process.env.PG_DB || 'postgres',
-        user: process.env.PG_USER || 'postgres',
-        password: process.env.PG_PASSWORD || 'postgres',
-        max: 1
-    })
-    try {
-        const r = await pool.query(
-            'SELECT producer_sub FROM queen.messages WHERE id = $1',
-            [messageId]
-        )
-        if (r.rows.length !== 1) {
-            return { success: false, message: `Message ${messageId} not found` }
-        }
-        if (r.rows[0].producer_sub !== null) {
-            return { success: false, message: `Expected producer_sub NULL, got ${JSON.stringify(r.rows[0].producer_sub)}` }
-        }
-        return { success: true }
-    } finally {
-        await pool.end()
+
+    // wait(true): ride out any push→visibility race (see pushLargePayload).
+    const deadline = Date.now() + 6000
+    let hit = null
+    while (Date.now() < deadline && !hit) {
+        const msgs = await client.queue(queueName).batch(20).wait(true).pop()
+        hit = (msgs || []).find(m => m && m.transactionId === tx)
+        if (!hit) await new Promise(r => setTimeout(r, 150))
     }
+    if (!hit) {
+        return { success: false, message: `Pushed message ${tx} not observed via pop` }
+    }
+    if (hit.producerSub != null) {
+        return { success: false, message: `Expected producerSub null, got ${JSON.stringify(hit.producerSub)}` }
+    }
+    return { success: true }
 }
 
 export async function pushEncryptedPayload(client) {

package/test-v2/run.js

@@ -15,6 +15,8 @@ import * as bootstrapTests from './bootstrap.js'
 import * as loggerTests from './logger.js'
 import * as watermarkTests from './watermark.js'
 import * as authTests from './auth.js'
+import * as semanticsTests from './semantics.js'
+import * as ackWindowTests from './ackwindow.js'
 import * as streamTests from './stream/index.js'
 import { LoadBalancer } from '../client-v2/http/LoadBalancer.js';
 
@@ -22,7 +24,7 @@ import { LoadBalancer } from '../client-v2/http/LoadBalancer.js';
 // Test configuration
 
 export const TEST_CONFIG_SINGLE = {
-    baseUrls: ['http://localhost:6632'],
+    baseUrls: [process.env.QUEEN_SERVER_URL || 'http://localhost:6632'],
     loadBalancingStrategy: 'affinity',
     dbConfig: {
       host: process.env.PG_HOST || 'localhost',
@@ -88,6 +90,8 @@ function printResults() {
 }
 
 export const cleanupTestData = async () => {
+    // All the LIKE patterns test queues use.
+    const patterns = ['test-%', 'edge-%', 'pattern-%', 'workflow-%'];
     try {
       // Drop streaming queries first (CASCADE removes their state rows).
       // Safe even when queen_streams isn't installed yet — we swallow the
@@ -98,11 +102,32 @@ export const cleanupTestData = async () => {
         // queen_streams schema not installed — ignore.
       }
 
-      await dbPool.query(`DELETE FROM queen.queues WHERE name LIKE 'test-%' OR name LIKE 'edge-%' OR name LIKE 'pattern-%' OR name LIKE 'workflow-%'`);
+      // Queue identity is now the queen.queues id (log_queues was merged
+      // away): log_partitions, consumer_watermarks, consumer_groups_metadata
+      // and queue_lag_metrics all cascade from the queues row. Only log_txns
+      // and log_dlq have NO foreign key by design, so they get an explicit
+      // purge keyed via log_partitions first. Without it, every suite run
+      // inherits the previous run's messages and dedup window entries —
+      // fixed-transactionId tests report 'duplicate' on their FIRST push.
+      try {
+        await dbPool.query(`
+          WITH parts AS (
+            SELECT lp.id FROM queen.log_partitions lp
+            JOIN queen.queues q ON q.id = lp.queue_id
+            WHERE q.name LIKE ANY($1::text[])
+          ),
+          d1 AS (DELETE FROM queen.log_txns WHERE partition_id IN (SELECT id FROM parts)),
+          d2 AS (DELETE FROM queen.log_dlq  WHERE partition_id IN (SELECT id FROM parts))
+          SELECT 1`, [patterns]);
+      } catch (e) {
+        // Log-engine schema not installed (rows-only server) — ignore.
+      }
+
+      await dbPool.query(`DELETE FROM queen.queues WHERE name LIKE ANY($1::text[])`, [patterns]);
 
-      log('Test data cleaned up');
+      log(true, 'Test data cleaned up (rows + segments)');
     } catch (error) {
-      log(`Cleanup error: ${error.message}`, 'warning');
+      log(false, `Cleanup error: ${error.message}`);
     }
   };
 
@@ -129,7 +154,9 @@ async function main() {
         bootstrapTests,
         loggerTests,
         watermarkTests,
-        authTests
+        authTests,
+        semanticsTests,
+        ackWindowTests
     ]
     
     const aiTests = [
@@ -224,6 +251,11 @@ async function main() {
     
     //await cleanupTestData()
     await closeDb()
+    // Queen.close() destroys the per-client HTTP agent, releasing keep-alive
+    // sockets so the loop can drain; the explicit exit code is for CI.
+    await client.close()
+    const failedCount = testResults.filter(x => !x.success).length
+    process.exit(failedCount > 0 ? 1 : 0)
 }
 
 try {