@a9n-shoji/rvw 0.2.1 → 0.2.3

package/skills/rvw-watch-comments/scripts/watch-driver.mjs

@@ -1,6 +1,16 @@
 #!/usr/bin/env node
 
+import { randomUUID } from "node:crypto";
 import { spawn } from "node:child_process";
+import {
+  chmodSync,
+  linkSync,
+  lstatSync,
+  readFileSync,
+  realpathSync,
+  unlinkSync,
+  writeFileSync,
+} from "node:fs";
 import path from "node:path";
 import { StringDecoder } from "node:string_decoder";
 import { fileURLToPath } from "node:url";
@@ -10,9 +20,13 @@ const EXIT_WATCH = 20;
 const EXIT_SEQUENCE = 21;
 const EXIT_INGEST = 22;
 const EXIT_AUTO_ACK = 23;
+const EXIT_ALREADY_RUNNING = 24;
+const DEFAULT_MAX_IN_FLIGHT = 1;
+const DEFAULT_AUTO_ACK_POLL_MS = 250;
 const scriptDirectory = path.dirname(fileURLToPath(import.meta.url));
 const stateScript = path.join(scriptDirectory, "watch-state.mjs");
 const autoAckScript = path.join(scriptDirectory, "auto-ack.mjs");
+const DRIVER_LOCK_SUFFIX = ".watch-driver.lock";
 
 class DriverError extends Error {
   constructor(message, exitCode, details = null) {
@@ -25,12 +39,27 @@ class DriverError extends Error {
 function parseArguments(values) {
   let state = null;
   let autoAck = false;
+  let maxInFlight = DEFAULT_MAX_IN_FLIGHT;
+  let maxInFlightProvided = false;
   for (let index = 0; index < values.length; index += 1) {
     const value = values[index];
     if (value === "--auto-ack") {
       autoAck = true;
       continue;
     }
+    if (value === "--max-in-flight") {
+      const next = values[index + 1];
+      if (!next || next.startsWith("--")) {
+        throw new DriverError("--max-in-flight requires an integer", EXIT_WATCH);
+      }
+      maxInFlight = Number(next);
+      maxInFlightProvided = true;
+      if (!Number.isSafeInteger(maxInFlight) || maxInFlight < 1 || maxInFlight > 64) {
+        throw new DriverError("--max-in-flight must be an integer from 1 through 64", EXIT_WATCH);
+      }
+      index += 1;
+      continue;
+    }
     if (value === "--state") {
       const next = values[index + 1];
       if (!next || next.startsWith("--")) {
@@ -47,7 +76,10 @@ function parseArguments(values) {
     throw new DriverError(`Unexpected argument: ${value}`, EXIT_WATCH);
   }
   if (!state) throw new DriverError("Pass the task state database path", EXIT_WATCH);
-  return { state: path.resolve(state), autoAck };
+  if (!autoAck && maxInFlightProvided) {
+    throw new DriverError("--max-in-flight requires --auto-ack", EXIT_WATCH);
+  }
+  return { state: path.resolve(state), autoAck, maxInFlight };
 }
 
 async function runNodeScript(script, args, input) {
@@ -86,12 +118,108 @@ function write(value) {
   process.stdout.write(`${JSON.stringify(value)}\n`);
 }
 
-async function dispatchAutoAck(state, pullRequest) {
-  const pending = await stateCommand(state, "list");
-  if (!pending.pending.some((batch) => batch.pullRequest === pullRequest)) {
-    write({ ok: true, type: "queued", pullRequest, reason: "batch-not-yet-eligible" });
-    return;
+function fileIdentity(filePath) {
+  try {
+    const stat = lstatSync(filePath);
+    return { dev: stat.dev, ino: stat.ino };
+  } catch {
+    return null;
+  }
+}
+
+function unlinkIfOwned(filePath, identity) {
+  const current = fileIdentity(filePath);
+  if (!identity || !current || current.dev !== identity.dev || current.ino !== identity.ino) return;
+  try {
+    unlinkSync(filePath);
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+}
+
+function processIsAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code !== "ESRCH";
+  }
+}
+
+function lockOwner(lockPath) {
+  try {
+    const value = JSON.parse(readFileSync(lockPath, "utf8"));
+    return Number.isInteger(value?.pid) && value.pid > 0 ? value : null;
+  } catch {
+    return null;
+  }
+}
+
+function acquireDriverLock(state) {
+  const canonicalState = realpathSync(state);
+  const lockPath = `${canonicalState}${DRIVER_LOCK_SUFFIX}`;
+  for (let attempt = 0; attempt < 2; attempt += 1) {
+    const stagingPath = `${lockPath}.${process.pid}.${randomUUID()}.tmp`;
+    try {
+      writeFileSync(
+        stagingPath,
+        `${JSON.stringify({ pid: process.pid, state: canonicalState, startedAt: new Date().toISOString() })}\n`,
+        { flag: "wx", mode: 0o600 },
+      );
+      chmodSync(stagingPath, 0o600);
+      linkSync(stagingPath, lockPath);
+    } catch (error) {
+      try {
+        unlinkSync(stagingPath);
+      } catch (unlinkError) {
+        if (unlinkError.code !== "ENOENT") throw unlinkError;
+      }
+      if (error.code !== "EEXIST") throw error;
+      const observedIdentity = fileIdentity(lockPath);
+      const owner = lockOwner(lockPath);
+      // Preserve unreadable locks rather than risking two live drivers.
+      if (!owner || processIsAlive(owner.pid)) {
+        throw new DriverError(
+          "Another watch-driver process already owns this task state",
+          EXIT_ALREADY_RUNNING,
+          {
+            state: canonicalState,
+            lockPath,
+            ownerPid: owner?.pid ?? null,
+          },
+        );
+      }
+      unlinkIfOwned(lockPath, observedIdentity);
+      continue;
+    }
+    try {
+      const identity = fileIdentity(lockPath);
+      if (!identity) throw new Error("Could not verify the watch-driver owner lock");
+      unlinkSync(stagingPath);
+      return { identity, path: lockPath };
+    } catch (error) {
+      const stagingIdentity = fileIdentity(stagingPath);
+      unlinkIfOwned(lockPath, stagingIdentity);
+      try {
+        unlinkSync(stagingPath);
+      } catch (unlinkError) {
+        if (unlinkError.code !== "ENOENT") throw unlinkError;
+      }
+      throw error;
+    }
   }
+  throw new DriverError("Could not acquire the watch-driver owner lock", EXIT_ALREADY_RUNNING, {
+    state: canonicalState,
+    lockPath,
+  });
+}
+
+function releaseDriverLock(lock) {
+  unlinkIfOwned(lock.path, lock.identity);
+}
+
+async function dispatchAutoAck(state, pullRequest) {
   const result = await runNodeScript(autoAckScript, [
     "--state",
     state,
@@ -104,14 +232,21 @@ async function dispatchAutoAck(state, pullRequest) {
   write({ ...result.json, type: "batch-acknowledged" });
 }
 
-async function dispatchPendingAutoAcks(state) {
-  const pending = await stateCommand(state, "list");
-  for (const batch of pending.pending) {
+async function dispatchPendingAutoAcks(state, maxInFlight) {
+  const work = await stateCommand(state, "list");
+  const inFlight = Number(work.inFlight);
+  if (!Number.isSafeInteger(inFlight) || inFlight < 0 || !Array.isArray(work.pending)) {
+    throw new DriverError("watch-state list returned invalid work capacity", EXIT_INGEST, work);
+  }
+  let available = Math.max(0, maxInFlight - inFlight);
+  for (const batch of work.pending) {
+    if (available === 0) break;
     await dispatchAutoAck(state, batch.pullRequest);
+    available -= 1;
   }
 }
 
-async function processFrame(state, frame, autoAck, pullRequests) {
+async function processFrame(state, frame, autoAck, maxInFlight) {
   if (!frame || typeof frame !== "object" || typeof frame.type !== "string") {
     throw new DriverError("Invalid RFC 7464 frame", EXIT_SEQUENCE, frame);
   }
@@ -127,10 +262,10 @@ async function processFrame(state, frame, autoAck, pullRequests) {
       databaseId: frame.databaseId,
       anchoredAtCurrent: frame.anchoredAtCurrent,
       autoAck,
+      maxInFlight: autoAck ? maxInFlight : null,
     });
   } else if (frame.type === "comment-posted" && ingested.status === "queued") {
-    if (autoAck) pullRequests.add(frame.event.pullRequestUrl);
-    else {
+    if (!autoAck) {
       write({
         ok: true,
         type: "pending",
@@ -142,7 +277,16 @@ async function processFrame(state, frame, autoAck, pullRequests) {
   }
 }
 
-async function runWatchOnce(state, autoAck, stopping) {
+function autoAckPollMilliseconds() {
+  const configured = Number(
+    process.env.RVW_WATCH_AUTO_ACK_POLL_MS ?? String(DEFAULT_AUTO_ACK_POLL_MS),
+  );
+  return Number.isSafeInteger(configured) && configured >= 10 && configured <= 60_000
+    ? configured
+    : DEFAULT_AUTO_ACK_POLL_MS;
+}
+
+async function runWatchOnce(state, autoAck, maxInFlight, stopping) {
   const current = await stateCommand(state, "status");
   const args = ["comment", "watch"];
   if (current.cursor) args.push("--after", current.cursor);
@@ -160,6 +304,25 @@ async function runWatchOnce(state, autoAck, stopping) {
     child.once("close", (code, signal) => resolve({ code, signal }));
   });
   child.stdin.end();
+  let autoAckPump = null;
+  let autoAckError = null;
+  const pumpAutoAcks = async () => {
+    if (!autoAck || stopping.requested) return;
+    if (autoAckPump) return autoAckPump;
+    autoAckPump = dispatchPendingAutoAcks(state, maxInFlight);
+    try {
+      await autoAckPump;
+    } catch (error) {
+      autoAckError ??= error;
+      child.kill("SIGTERM");
+      throw error;
+    } finally {
+      autoAckPump = null;
+    }
+  };
+  const autoAckTimer = autoAck
+    ? setInterval(() => void pumpAutoAcks().catch(() => undefined), autoAckPollMilliseconds())
+    : null;
   const decoder = new StringDecoder("utf8");
   let buffered = "";
   let readySeen = false;
@@ -169,7 +332,6 @@ async function runWatchOnce(state, autoAck, stopping) {
       buffered += decoder.write(chunk);
       const lines = buffered.split("\n");
       buffered = lines.pop() ?? "";
-      const pullRequests = new Set();
       for (const rawLine of lines) {
         if (!rawLine) continue;
         if (!rawLine.startsWith("\u001e")) {
@@ -183,9 +345,9 @@ async function runWatchOnce(state, autoAck, stopping) {
         }
         readySeen ||= frame.type === "ready";
         stoppedSeen ||= frame.type === "stopped";
-        await processFrame(state, frame, autoAck, pullRequests);
+        await processFrame(state, frame, autoAck, maxInFlight);
       }
-      for (const pullRequest of pullRequests) await dispatchAutoAck(state, pullRequest);
+      await pumpAutoAcks();
     }
     buffered += decoder.end();
     if (buffered.trim()) {
@@ -196,6 +358,8 @@ async function runWatchOnce(state, autoAck, stopping) {
       );
     }
     const status = await statusPromise;
+    if (autoAckPump) await autoAckPump.catch(() => undefined);
+    if (autoAckError) throw autoAckError;
     stopping.child = null;
     return { ...status, stderr, readySeen, stoppedSeen };
   } catch (error) {
@@ -203,6 +367,8 @@ async function runWatchOnce(state, autoAck, stopping) {
     await statusPromise.catch(() => undefined);
     stopping.child = null;
     throw error;
+  } finally {
+    if (autoAckTimer) clearInterval(autoAckTimer);
   }
 }
 
@@ -217,42 +383,51 @@ function delay(milliseconds) {
 }
 
 async function main() {
-  const { state, autoAck } = parseArguments(process.argv.slice(2));
-  const stopping = { requested: false, child: null };
-  const stop = () => {
-    stopping.requested = true;
-    stopping.child?.kill("SIGTERM");
-  };
-  process.once("SIGINT", stop);
-  process.once("SIGTERM", stop);
-  const maxRestarts = Number(process.env.RVW_WATCH_DRIVER_MAX_RESTARTS ?? "5");
-  let restarts = 0;
+  const { state, autoAck, maxInFlight } = parseArguments(process.argv.slice(2));
+  const driverLock = acquireDriverLock(state);
   try {
-    while (!stopping.requested) {
-      const startedAt = Date.now();
-      if (autoAck) await dispatchPendingAutoAcks(state);
-      const result = await runWatchOnce(state, autoAck, stopping);
-      if (stopping.requested) return;
-      if (Date.now() - startedAt >= 30_000) restarts = 0;
-      restarts += 1;
-      if (restarts > maxRestarts) {
-        throw new DriverError("rvw comment watch exceeded its reconnect limit", EXIT_WATCH, result);
+    const stopping = { requested: false, child: null };
+    const stop = () => {
+      stopping.requested = true;
+      stopping.child?.kill("SIGTERM");
+    };
+    process.once("SIGINT", stop);
+    process.once("SIGTERM", stop);
+    const maxRestarts = Number(process.env.RVW_WATCH_DRIVER_MAX_RESTARTS ?? "5");
+    let restarts = 0;
+    try {
+      while (!stopping.requested) {
+        const startedAt = Date.now();
+        if (autoAck) await dispatchPendingAutoAcks(state, maxInFlight);
+        const result = await runWatchOnce(state, autoAck, maxInFlight, stopping);
+        if (stopping.requested) return;
+        if (Date.now() - startedAt >= 30_000) restarts = 0;
+        restarts += 1;
+        if (restarts > maxRestarts) {
+          throw new DriverError(
+            "rvw comment watch exceeded its reconnect limit",
+            EXIT_WATCH,
+            result,
+          );
+        }
+        const delayMs = retryDelay(restarts);
+        write({
+          ok: true,
+          type: "reconnecting",
+          attempt: restarts,
+          delayMs,
+          lastExitCode: result.code,
+          lastSignal: result.signal,
+          readySeen: result.readySeen,
+        });
+        await delay(delayMs);
       }
-      const delayMs = retryDelay(restarts);
-      write({
-        ok: true,
-        type: "reconnecting",
-        attempt: restarts,
-        delayMs,
-        lastExitCode: result.code,
-        lastSignal: result.signal,
-        readySeen: result.readySeen,
-      });
-      await delay(delayMs);
+    } finally {
+      process.off("SIGINT", stop);
+      process.off("SIGTERM", stop);
     }
   } finally {
-    process.off("SIGINT", stop);
-    process.off("SIGTERM", stop);
+    releaseDriverLock(driverLock);
   }
 }
 

package/skills/rvw-watch-comments/scripts/watch-state.mjs

@@ -68,7 +68,8 @@ function openState(statePath, create) {
     fail(`State database does not exist: ${absolute}`);
   }
   const database = new DatabaseSync(absolute);
-  database.exec("PRAGMA journal_mode = WAL; PRAGMA busy_timeout = 5000;");
+  database.exec("PRAGMA busy_timeout = 5000;");
+  database.exec("PRAGMA journal_mode = WAL;");
   database.exec(`
     CREATE TABLE IF NOT EXISTS meta (
       key TEXT PRIMARY KEY,
@@ -98,17 +99,11 @@ function openState(statePath, create) {
       created_at TEXT NOT NULL,
       updated_at TEXT NOT NULL
     );
-    CREATE TABLE IF NOT EXISTS comment_statuses (
-      comment_ref TEXT PRIMARY KEY,
-      idempotency_key TEXT NOT NULL UNIQUE,
-      post_id TEXT UNIQUE,
-      created_at TEXT NOT NULL,
-      updated_at TEXT NOT NULL
-    );
     CREATE TABLE IF NOT EXISTS operations (
       batch_id TEXT NOT NULL,
       comment_ref TEXT NOT NULL,
       idempotency_key TEXT NOT NULL UNIQUE,
+      post_id TEXT,
       PRIMARY KEY(batch_id, comment_ref)
     );
     CREATE TABLE IF NOT EXISTS suppressed_posts (
@@ -123,6 +118,7 @@ function openState(statePath, create) {
     CREATE INDEX IF NOT EXISTS batches_pending_pr
       ON batches(status, pull_request_url, next_attempt_at, created_at);
   `);
+  migrateStateSchema(database);
   if (create) chmodSync(absolute, 0o600);
   return { database, absolute };
 }
@@ -156,39 +152,102 @@ function setMeta(database, key, value) {
     .run(key, value);
 }
 
-function ensureCommentStatus(database, commentRef, now) {
-  const existing = database
-    .prepare("SELECT * FROM comment_statuses WHERE comment_ref = ?")
-    .get(commentRef);
-  if (existing) return existing;
-  const legacyOperation = database
-    .prepare(
-      `SELECT o.idempotency_key
-      FROM operations o
-      JOIN batches b ON b.id = o.batch_id
-      WHERE o.comment_ref = ? AND b.status IN ('pending', 'in_flight')
-      ORDER BY b.created_at DESC LIMIT 1`,
-    )
-    .get(commentRef);
-  const idempotencyKey =
-    legacyOperation?.idempotency_key ?? `${getMeta(database, "task_id")}:status:${randomUUID()}`;
-  database
-    .prepare(
-      `INSERT INTO comment_statuses(
-        comment_ref, idempotency_key, post_id, created_at, updated_at
-      ) VALUES (?, ?, NULL, ?, ?)`,
-    )
-    .run(commentRef, idempotencyKey, now, now);
-  return database.prepare("SELECT * FROM comment_statuses WHERE comment_ref = ?").get(commentRef);
+function tableExists(database, tableName) {
+  return Boolean(
+    database
+      .prepare("SELECT 1 AS present FROM sqlite_master WHERE type = 'table' AND name = ?")
+      .get(tableName),
+  );
+}
+
+function migrateStateSchema(database) {
+  const operationColumns = database.prepare("PRAGMA table_info(operations)").all();
+  if (
+    operationColumns.some((column) => column.name === "post_id") &&
+    getMeta(database, "batch_scoped_status_posts") === "1"
+  ) {
+    return;
+  }
+  transaction(database, () => {
+    const currentOperationColumns = database.prepare("PRAGMA table_info(operations)").all();
+    if (!currentOperationColumns.some((column) => column.name === "post_id")) {
+      database.exec("ALTER TABLE operations ADD COLUMN post_id TEXT;");
+    }
+    if (getMeta(database, "batch_scoped_status_posts") === "1") return;
+    if (tableExists(database, "comment_statuses")) {
+      const rows = database
+        .prepare(
+          `SELECT b.id AS batch_id, e.comment_ref,
+            b.created_at AS batch_created_at,
+            o.idempotency_key AS operation_key, o.post_id AS operation_post_id,
+            s.idempotency_key AS legacy_key, s.post_id AS legacy_post_id,
+            s.updated_at AS legacy_updated_at
+          FROM batches b
+          JOIN (
+            SELECT DISTINCT batch_id, comment_ref FROM events WHERE batch_id IS NOT NULL
+          ) e ON e.batch_id = b.id
+          LEFT JOIN operations o ON o.batch_id = b.id AND o.comment_ref = e.comment_ref
+          LEFT JOIN comment_statuses s ON s.comment_ref = e.comment_ref
+          WHERE b.status != 'completed' AND b.attempts > 0
+          ORDER BY e.comment_ref,
+            CASE b.status WHEN 'in_flight' THEN 0 WHEN 'pending' THEN 1 ELSE 2 END,
+            b.created_at DESC`,
+        )
+        .all();
+      const migratedCommentRefs = new Set();
+      for (const row of rows) {
+        const useLegacyStatus =
+          !migratedCommentRefs.has(row.comment_ref) &&
+          row.legacy_key &&
+          row.legacy_updated_at >= row.batch_created_at;
+        if (useLegacyStatus) migratedCommentRefs.add(row.comment_ref);
+        if (row.operation_key) {
+          if (useLegacyStatus && row.operation_post_id === null && row.legacy_post_id !== null) {
+            database
+              .prepare("UPDATE operations SET post_id = ? WHERE batch_id = ? AND comment_ref = ?")
+              .run(row.legacy_post_id, row.batch_id, row.comment_ref);
+          }
+          continue;
+        }
+        database
+          .prepare(
+            `INSERT INTO operations(batch_id, comment_ref, idempotency_key, post_id)
+            VALUES (?, ?, ?, ?)`,
+          )
+          .run(
+            row.batch_id,
+            row.comment_ref,
+            useLegacyStatus
+              ? row.legacy_key
+              : `${getMeta(database, "task_id") ?? "task"}:${row.batch_id}:${randomUUID()}`,
+            useLegacyStatus ? row.legacy_post_id : null,
+          );
+      }
+    }
+    setMeta(database, "batch_scoped_status_posts", "1");
+  });
+}
+
+function ensureBatchOperations(database, batchId) {
+  const commentRefs = database
+    .prepare("SELECT DISTINCT comment_ref FROM events WHERE batch_id = ? ORDER BY comment_ref")
+    .all(batchId)
+    .map((operation) => operation.comment_ref);
+  for (let index = 0; index < commentRefs.length; index += 1) {
+    database
+      .prepare(
+        `INSERT OR IGNORE INTO operations(batch_id, comment_ref, idempotency_key, post_id)
+        VALUES (?, ?, ?, NULL)`,
+      )
+      .run(batchId, commentRefs[index], `${getMeta(database, "task_id")}:${batchId}:${index + 1}`);
+  }
 }
 
 function batchStatusOperations(database, batchId) {
   return database
     .prepare(
-      `SELECT DISTINCT e.comment_ref, s.post_id
-      FROM events e
-      LEFT JOIN comment_statuses s ON s.comment_ref = e.comment_ref
-      WHERE e.batch_id = ? ORDER BY e.comment_ref`,
+      `SELECT comment_ref, post_id FROM operations
+      WHERE batch_id = ? ORDER BY comment_ref`,
     )
     .all(batchId)
     .map((operation) => ({
@@ -311,19 +370,19 @@ function ingestEvent(database, frame) {
         now,
       );
     if (event.deleted) {
-      const commentStatus = database
-        .prepare("SELECT comment_ref FROM comment_statuses WHERE post_id = ?")
-        .get(event.postId);
-      if (commentStatus) {
+      const operations = database
+        .prepare("SELECT batch_id, comment_ref FROM operations WHERE post_id = ?")
+        .all(event.postId);
+      for (const operation of operations) {
         database
           .prepare(
-            `UPDATE comment_statuses SET post_id = NULL, idempotency_key = ?, updated_at = ?
-            WHERE comment_ref = ?`,
+            `UPDATE operations SET post_id = NULL, idempotency_key = ?
+            WHERE batch_id = ? AND comment_ref = ?`,
           )
           .run(
-            `${getMeta(database, "task_id")}:status:${randomUUID()}`,
-            now,
-            commentStatus.comment_ref,
+            `${getMeta(database, "task_id")}:${operation.batch_id}:${randomUUID()}`,
+            operation.batch_id,
+            operation.comment_ref,
           );
       }
     }
@@ -397,6 +456,16 @@ function listPending(database) {
     });
 }
 
+function listWork(database) {
+  const inFlight = database
+    .prepare("SELECT count(*) AS count FROM batches WHERE status = 'in_flight'")
+    .get();
+  return {
+    inFlight: Number(inFlight.count),
+    pending: listPending(database),
+  };
+}
+
 async function waitForPending(database, options) {
   const intervalMs = positiveIntegerOption(options, "interval-ms", 250);
   const follow = options.follow === true;
@@ -448,8 +517,7 @@ function createBatch(database, pullRequestUrl, now) {
       "UPDATE events SET batch_id = ?, updated_at = ? WHERE pull_request_url = ? AND status = 'pending' AND batch_id IS NULL",
     )
     .run(batchId, now, pullRequestUrl);
-  const commentRefs = [...new Set(events.map((event) => event.comment_ref))];
-  for (const commentRef of commentRefs) ensureCommentStatus(database, commentRef, now);
+  ensureBatchOperations(database, batchId);
   return batchId;
 }
 
@@ -497,17 +565,11 @@ function claim(database, pullRequestUrl, writeKey) {
         commentRef: event.comment_ref,
         pullRequestUrl: event.pull_request_url,
       }));
-    const commentRefs = database
-      .prepare("SELECT DISTINCT comment_ref FROM events WHERE batch_id = ? ORDER BY comment_ref")
-      .all(batchId)
-      .map((operation) => operation.comment_ref);
-    for (const commentRef of commentRefs) ensureCommentStatus(database, commentRef, now);
+    ensureBatchOperations(database, batchId);
     const operations = database
       .prepare(
-        `SELECT DISTINCT e.comment_ref, s.idempotency_key, s.post_id
-        FROM events e
-        JOIN comment_statuses s ON s.comment_ref = e.comment_ref
-        WHERE e.batch_id = ? ORDER BY e.comment_ref`,
+        `SELECT comment_ref, idempotency_key, post_id FROM operations
+        WHERE batch_id = ? ORDER BY comment_ref`,
       )
       .all(batchId)
       .map((operation) => ({
@@ -568,17 +630,16 @@ function acknowledge(database, leaseId, input) {
       .get(leaseId);
     if (!batch) fail("Active lease was not found");
     const operation = database
-      .prepare("SELECT 1 AS present FROM events WHERE batch_id = ? AND comment_ref = ? LIMIT 1")
+      .prepare("SELECT post_id FROM operations WHERE batch_id = ? AND comment_ref = ?")
       .get(batch.id, input.commentRef);
     if (!operation) fail("Comment is not part of the active lease");
     const now = new Date().toISOString();
-    const status = ensureCommentStatus(database, input.commentRef, now);
-    if (status.post_id !== null && status.post_id !== input.postId) {
-      fail("Comment already has another status post");
+    if (operation.post_id !== null && operation.post_id !== input.postId) {
+      fail("Batch operation already has another status post");
     }
     database
-      .prepare("UPDATE comment_statuses SET post_id = ?, updated_at = ? WHERE comment_ref = ?")
-      .run(input.postId, now, input.commentRef);
+      .prepare("UPDATE operations SET post_id = ? WHERE batch_id = ? AND comment_ref = ?")
+      .run(input.postId, batch.id, input.commentRef);
     database
       .prepare("INSERT OR IGNORE INTO suppressed_posts(post_id, created_at) VALUES (?, ?)")
       .run(input.postId, now);
@@ -591,7 +652,7 @@ function acknowledge(database, leaseId, input) {
       batchId: batch.id,
       commentRef: input.commentRef,
       statusPostId: input.postId,
-      status: status.post_id === null ? "recorded" : "existing",
+      status: operation.post_id === null ? "recorded" : "existing",
     };
   });
 }
@@ -772,7 +833,7 @@ async function main() {
       return;
     }
     if (command === "list") {
-      write({ ok: true, pending: listPending(database) });
+      write({ ok: true, ...listWork(database) });
       return;
     }
     if (command === "wait") {