@rei-standard/amsg-server 2.6.0-next.4 → 2.6.0-next.6

package/dist/{neon-CJl66EGy.d.cts → neon-PqNFJIz2.d.ts}

@@ -1,5 +1,5 @@
 import { neon } from '@neondatabase/serverless';
-import { T as TABLE_SQL, I as INDEXES, V as VERIFY_TABLE_SQL, C as COLUMNS_SQL } from './schema-C8OnYk6j.cjs';
+import { T as TABLE_SQL, M as MIGRATIONS, I as INDEXES, V as VERIFY_TABLE_SQL, C as COLUMNS_SQL } from './schema-BHuyH_6Z.js';
 
 /**
  * Neon Serverless Database Adapter
@@ -30,6 +30,9 @@ class NeonAdapter {
     const sql = this._getSql();
 
     await sql.query(TABLE_SQL);
+    for (const migration of MIGRATIONS) {
+      await sql.query(migration.sql);
+    }
     const indexResults = [];
     for (const index of INDEXES) {
       try {
@@ -184,12 +187,53 @@ class NeonAdapter {
       `SELECT id, user_id, uuid, encrypted_payload, message_type, next_send_at, status, retry_count
        FROM scheduled_messages
        WHERE status = 'pending' AND next_send_at <= NOW()
+         AND (lease_until IS NULL OR lease_until <= NOW())
        ORDER BY next_send_at ASC
        LIMIT $1`,
       [limit]
     );
   }
 
+  /**
+   * 领取一条到点的任务：在 lease_until 上写下「这条归我管到什么时候」，
+   * 本次投递期间别的 tick 领不走它。
+   *
+   * 租约写在自己的列上，next_send_at 全程不动——那一列是用户设的触发时刻，
+   * 任务列表要读它、循环任务推进下一次也要拿它当基准。
+   *
+   * 两个 tick 抢同一行时只有一个改得动，另一个拿不到 RETURNING 行，据此跳
+   * 过。WHERE 里的两个条件各管一件事：
+   *   - lease_until 为空或已过期：没人正在跑这条。领了任务的 tick 中途没了
+   *     也不会把行焊死，租约到期后自然可以被接手。
+   *   - next_send_at 等于读这行时看到的值：读出来之后用户又改了排期的话，
+   *     这一跳就不该再按旧时刻发。
+   *
+   * 不加一个 'sending' 状态来表达「正在跑」：status 上有 CHECK 约束，加值
+   * 要改表。
+   *
+   * 比 next_send_at 时两边都截到毫秒：列是 timestamptz（微秒精度），驱动读
+   * 出来是 JS Date（毫秒精度），原值送回去可能因为亚毫秒差对不上。
+   *
+   * @param {number} taskId
+   * @param {string|Date} expectedNextSendAt - 读这行时拿到的 next_send_at 原值
+   * @param {string|Date} leaseUntil - 租期末尾
+   * @returns {Promise<boolean>} true = 领到了；false = 别人正拿着租约、排期被改过、或行已不是 pending
+   */
+  async claimTask(taskId, expectedNextSendAt, leaseUntil) {
+    const sql = this._getSql();
+    const rows = await sql.query(
+      `UPDATE scheduled_messages
+          SET lease_until = $1, updated_at = NOW()
+        WHERE id = $2 AND status = 'pending'
+          AND date_trunc('milliseconds', next_send_at)
+            = date_trunc('milliseconds', $3::timestamptz)
+          AND (lease_until IS NULL OR lease_until <= NOW())
+       RETURNING id`,
+      [leaseUntil, taskId, expectedNextSendAt]
+    );
+    return rows.length > 0;
+  }
+
   async listTasks(userId, opts = {}) {
     const sql = this._getSql();
     const { status = 'all', limit = 20, offset = 0 } = opts;

package/dist/{neon-CU5N3CSW.mjs → neon-QJ7KYHEX.mjs}

@@ -1,9 +1,10 @@
 import {
   COLUMNS_SQL,
   INDEXES,
+  MIGRATIONS,
   TABLE_SQL,
   VERIFY_TABLE_SQL
-} from "./chunk-5ENJGVZX.mjs";
+} from "./chunk-GOBCWCJP.mjs";
 
 // src/server/adapters/neon.js
 import { neon } from "@neondatabase/serverless";
@@ -23,6 +24,9 @@ var NeonAdapter = class {
   async initSchema() {
     const sql = this._getSql();
     await sql.query(TABLE_SQL);
+    for (const migration of MIGRATIONS) {
+      await sql.query(migration.sql);
+    }
     const indexResults = [];
     for (const index of INDEXES) {
       try {
@@ -160,11 +164,51 @@ var NeonAdapter = class {
       `SELECT id, user_id, uuid, encrypted_payload, message_type, next_send_at, status, retry_count
        FROM scheduled_messages
        WHERE status = 'pending' AND next_send_at <= NOW()
+         AND (lease_until IS NULL OR lease_until <= NOW())
        ORDER BY next_send_at ASC
        LIMIT $1`,
       [limit]
     );
   }
+  /**
+   * 领取一条到点的任务：在 lease_until 上写下「这条归我管到什么时候」，
+   * 本次投递期间别的 tick 领不走它。
+   *
+   * 租约写在自己的列上，next_send_at 全程不动——那一列是用户设的触发时刻，
+   * 任务列表要读它、循环任务推进下一次也要拿它当基准。
+   *
+   * 两个 tick 抢同一行时只有一个改得动，另一个拿不到 RETURNING 行，据此跳
+   * 过。WHERE 里的两个条件各管一件事：
+   *   - lease_until 为空或已过期：没人正在跑这条。领了任务的 tick 中途没了
+   *     也不会把行焊死，租约到期后自然可以被接手。
+   *   - next_send_at 等于读这行时看到的值：读出来之后用户又改了排期的话，
+   *     这一跳就不该再按旧时刻发。
+   *
+   * 不加一个 'sending' 状态来表达「正在跑」：status 上有 CHECK 约束，加值
+   * 要改表。
+   *
+   * 比 next_send_at 时两边都截到毫秒：列是 timestamptz（微秒精度），驱动读
+   * 出来是 JS Date（毫秒精度），原值送回去可能因为亚毫秒差对不上。
+   *
+   * @param {number} taskId
+   * @param {string|Date} expectedNextSendAt - 读这行时拿到的 next_send_at 原值
+   * @param {string|Date} leaseUntil - 租期末尾
+   * @returns {Promise<boolean>} true = 领到了；false = 别人正拿着租约、排期被改过、或行已不是 pending
+   */
+  async claimTask(taskId, expectedNextSendAt, leaseUntil) {
+    const sql = this._getSql();
+    const rows = await sql.query(
+      `UPDATE scheduled_messages
+          SET lease_until = $1, updated_at = NOW()
+        WHERE id = $2 AND status = 'pending'
+          AND date_trunc('milliseconds', next_send_at)
+            = date_trunc('milliseconds', $3::timestamptz)
+          AND (lease_until IS NULL OR lease_until <= NOW())
+       RETURNING id`,
+      [leaseUntil, taskId, expectedNextSendAt]
+    );
+    return rows.length > 0;
+  }
   async listTasks(userId, opts = {}) {
     const sql = this._getSql();
     const { status = "all", limit = 20, offset = 0 } = opts;

package/dist/{neon-BFUS25UX.cjs → neon-V4VOH55N.cjs}

@@ -3,7 +3,8 @@
 
 
 
-var _chunkRGECD4OHcjs = require('./chunk-RGECD4OH.cjs');
+
+var _chunkDCKCAGFVcjs = require('./chunk-DCKCAGFV.cjs');
 
 // src/server/adapters/neon.js
 var _serverless = require('@neondatabase/serverless');
@@ -22,9 +23,12 @@ var NeonAdapter = class {
   }
   async initSchema() {
     const sql = this._getSql();
-    await sql.query(_chunkRGECD4OHcjs.TABLE_SQL);
+    await sql.query(_chunkDCKCAGFVcjs.TABLE_SQL);
+    for (const migration of _chunkDCKCAGFVcjs.MIGRATIONS) {
+      await sql.query(migration.sql);
+    }
     const indexResults = [];
-    for (const index of _chunkRGECD4OHcjs.INDEXES) {
+    for (const index of _chunkDCKCAGFVcjs.INDEXES) {
       try {
         await sql.query(index.sql);
         indexResults.push({
@@ -50,11 +54,11 @@ var NeonAdapter = class {
         `Critical index creation failed (${failedNames}). Please remove duplicate UUID rows and run initSchema again.`
       );
     }
-    const tableCheck = await sql.query(_chunkRGECD4OHcjs.VERIFY_TABLE_SQL);
+    const tableCheck = await sql.query(_chunkDCKCAGFVcjs.VERIFY_TABLE_SQL);
     if (tableCheck.length === 0) {
       throw new Error("Table creation verification failed");
     }
-    const columns = await sql.query(_chunkRGECD4OHcjs.COLUMNS_SQL);
+    const columns = await sql.query(_chunkDCKCAGFVcjs.COLUMNS_SQL);
     return {
       columnsCreated: columns.length,
       indexesCreated: indexResults.filter((r) => r.status === "success").length,
@@ -160,11 +164,51 @@ var NeonAdapter = class {
       `SELECT id, user_id, uuid, encrypted_payload, message_type, next_send_at, status, retry_count
        FROM scheduled_messages
        WHERE status = 'pending' AND next_send_at <= NOW()
+         AND (lease_until IS NULL OR lease_until <= NOW())
        ORDER BY next_send_at ASC
        LIMIT $1`,
       [limit]
     );
   }
+  /**
+   * 领取一条到点的任务：在 lease_until 上写下「这条归我管到什么时候」，
+   * 本次投递期间别的 tick 领不走它。
+   *
+   * 租约写在自己的列上，next_send_at 全程不动——那一列是用户设的触发时刻，
+   * 任务列表要读它、循环任务推进下一次也要拿它当基准。
+   *
+   * 两个 tick 抢同一行时只有一个改得动，另一个拿不到 RETURNING 行，据此跳
+   * 过。WHERE 里的两个条件各管一件事：
+   *   - lease_until 为空或已过期：没人正在跑这条。领了任务的 tick 中途没了
+   *     也不会把行焊死，租约到期后自然可以被接手。
+   *   - next_send_at 等于读这行时看到的值：读出来之后用户又改了排期的话，
+   *     这一跳就不该再按旧时刻发。
+   *
+   * 不加一个 'sending' 状态来表达「正在跑」：status 上有 CHECK 约束，加值
+   * 要改表。
+   *
+   * 比 next_send_at 时两边都截到毫秒：列是 timestamptz（微秒精度），驱动读
+   * 出来是 JS Date（毫秒精度），原值送回去可能因为亚毫秒差对不上。
+   *
+   * @param {number} taskId
+   * @param {string|Date} expectedNextSendAt - 读这行时拿到的 next_send_at 原值
+   * @param {string|Date} leaseUntil - 租期末尾
+   * @returns {Promise<boolean>} true = 领到了；false = 别人正拿着租约、排期被改过、或行已不是 pending
+   */
+  async claimTask(taskId, expectedNextSendAt, leaseUntil) {
+    const sql = this._getSql();
+    const rows = await sql.query(
+      `UPDATE scheduled_messages
+          SET lease_until = $1, updated_at = NOW()
+        WHERE id = $2 AND status = 'pending'
+          AND date_trunc('milliseconds', next_send_at)
+            = date_trunc('milliseconds', $3::timestamptz)
+          AND (lease_until IS NULL OR lease_until <= NOW())
+       RETURNING id`,
+      [leaseUntil, taskId, expectedNextSendAt]
+    );
+    return rows.length > 0;
+  }
   async listTasks(userId, opts = {}) {
     const sql = this._getSql();
     const { status = "all", limit = 20, offset = 0 } = opts;

package/dist/{pg-IIH3M4OM.cjs → pg-6X74HKMX.cjs}

@@ -3,7 +3,8 @@
 
 
 
-var _chunkRGECD4OHcjs = require('./chunk-RGECD4OH.cjs');
+
+var _chunkDCKCAGFVcjs = require('./chunk-DCKCAGFV.cjs');
 
 // src/server/adapters/pg.js
 var _pg = require('pg');
@@ -27,9 +28,12 @@ var PgAdapter = class {
     return result.rows;
   }
   async initSchema() {
-    await this._query(_chunkRGECD4OHcjs.TABLE_SQL);
+    await this._query(_chunkDCKCAGFVcjs.TABLE_SQL);
+    for (const migration of _chunkDCKCAGFVcjs.MIGRATIONS) {
+      await this._query(migration.sql);
+    }
     const indexResults = [];
-    for (const index of _chunkRGECD4OHcjs.INDEXES) {
+    for (const index of _chunkDCKCAGFVcjs.INDEXES) {
       try {
         await this._query(index.sql);
         indexResults.push({
@@ -55,11 +59,11 @@ var PgAdapter = class {
         `Critical index creation failed (${failedNames}). Please remove duplicate UUID rows and run initSchema again.`
       );
     }
-    const tableCheck = await this._query(_chunkRGECD4OHcjs.VERIFY_TABLE_SQL);
+    const tableCheck = await this._query(_chunkDCKCAGFVcjs.VERIFY_TABLE_SQL);
     if (tableCheck.length === 0) {
       throw new Error("Table creation verification failed");
     }
-    const columns = await this._query(_chunkRGECD4OHcjs.COLUMNS_SQL);
+    const columns = await this._query(_chunkDCKCAGFVcjs.COLUMNS_SQL);
     return {
       columnsCreated: columns.length,
       indexesCreated: indexResults.filter((r) => r.status === "success").length,
@@ -156,11 +160,50 @@ var PgAdapter = class {
       `SELECT id, user_id, uuid, encrypted_payload, message_type, next_send_at, status, retry_count
        FROM scheduled_messages
        WHERE status = 'pending' AND next_send_at <= NOW()
+         AND (lease_until IS NULL OR lease_until <= NOW())
        ORDER BY next_send_at ASC
        LIMIT $1`,
       [limit]
     );
   }
+  /**
+   * 领取一条到点的任务：在 lease_until 上写下「这条归我管到什么时候」，
+   * 本次投递期间别的 tick 领不走它。
+   *
+   * 租约写在自己的列上，next_send_at 全程不动——那一列是用户设的触发时刻，
+   * 任务列表要读它、循环任务推进下一次也要拿它当基准。
+   *
+   * 两个 tick 抢同一行时只有一个改得动，另一个拿不到 RETURNING 行，据此跳
+   * 过。WHERE 里的两个条件各管一件事：
+   *   - lease_until 为空或已过期：没人正在跑这条。领了任务的 tick 中途没了
+   *     也不会把行焊死，租约到期后自然可以被接手。
+   *   - next_send_at 等于读这行时看到的值：读出来之后用户又改了排期的话，
+   *     这一跳就不该再按旧时刻发。
+   *
+   * 不加一个 'sending' 状态来表达「正在跑」：status 上有 CHECK 约束，加值
+   * 要改表。
+   *
+   * 比 next_send_at 时两边都截到毫秒：列是 timestamptz（微秒精度），驱动读
+   * 出来是 JS Date（毫秒精度），原值送回去可能因为亚毫秒差对不上。
+   *
+   * @param {number} taskId
+   * @param {string|Date} expectedNextSendAt - 读这行时拿到的 next_send_at 原值
+   * @param {string|Date} leaseUntil - 租期末尾
+   * @returns {Promise<boolean>} true = 领到了；false = 已被别人领走或行已不是 pending
+   */
+  async claimTask(taskId, expectedNextSendAt, leaseUntil) {
+    const rows = await this._query(
+      `UPDATE scheduled_messages
+          SET lease_until = $1, updated_at = NOW()
+        WHERE id = $2 AND status = 'pending'
+          AND date_trunc('milliseconds', next_send_at)
+            = date_trunc('milliseconds', $3::timestamptz)
+          AND (lease_until IS NULL OR lease_until <= NOW())
+       RETURNING id`,
+      [leaseUntil, taskId, expectedNextSendAt]
+    );
+    return rows.length > 0;
+  }
   async listTasks(userId, opts = {}) {
     const { status = "all", limit = 20, offset = 0 } = opts;
     const conditions = ["user_id = $1"];

package/dist/{pg-Du-pN_UT.d.ts → pg-C48FwCWW.d.cts}

@@ -1,5 +1,5 @@
 import { Pool } from 'pg';
-import { T as TABLE_SQL, I as INDEXES, V as VERIFY_TABLE_SQL, C as COLUMNS_SQL } from './schema-C8OnYk6j.js';
+import { T as TABLE_SQL, M as MIGRATIONS, I as INDEXES, V as VERIFY_TABLE_SQL, C as COLUMNS_SQL } from './schema-BHuyH_6Z.cjs';
 
 /**
  * PostgreSQL (pg) Database Adapter
@@ -37,6 +37,9 @@ class PgAdapter {
 
   async initSchema() {
     await this._query(TABLE_SQL);
+    for (const migration of MIGRATIONS) {
+      await this._query(migration.sql);
+    }
     const indexResults = [];
     for (const index of INDEXES) {
       try {
@@ -182,12 +185,52 @@ class PgAdapter {
       `SELECT id, user_id, uuid, encrypted_payload, message_type, next_send_at, status, retry_count
        FROM scheduled_messages
        WHERE status = 'pending' AND next_send_at <= NOW()
+         AND (lease_until IS NULL OR lease_until <= NOW())
        ORDER BY next_send_at ASC
        LIMIT $1`,
       [limit]
     );
   }
 
+  /**
+   * 领取一条到点的任务：在 lease_until 上写下「这条归我管到什么时候」，
+   * 本次投递期间别的 tick 领不走它。
+   *
+   * 租约写在自己的列上，next_send_at 全程不动——那一列是用户设的触发时刻，
+   * 任务列表要读它、循环任务推进下一次也要拿它当基准。
+   *
+   * 两个 tick 抢同一行时只有一个改得动，另一个拿不到 RETURNING 行，据此跳
+   * 过。WHERE 里的两个条件各管一件事：
+   *   - lease_until 为空或已过期：没人正在跑这条。领了任务的 tick 中途没了
+   *     也不会把行焊死，租约到期后自然可以被接手。
+   *   - next_send_at 等于读这行时看到的值：读出来之后用户又改了排期的话，
+   *     这一跳就不该再按旧时刻发。
+   *
+   * 不加一个 'sending' 状态来表达「正在跑」：status 上有 CHECK 约束，加值
+   * 要改表。
+   *
+   * 比 next_send_at 时两边都截到毫秒：列是 timestamptz（微秒精度），驱动读
+   * 出来是 JS Date（毫秒精度），原值送回去可能因为亚毫秒差对不上。
+   *
+   * @param {number} taskId
+   * @param {string|Date} expectedNextSendAt - 读这行时拿到的 next_send_at 原值
+   * @param {string|Date} leaseUntil - 租期末尾
+   * @returns {Promise<boolean>} true = 领到了；false = 已被别人领走或行已不是 pending
+   */
+  async claimTask(taskId, expectedNextSendAt, leaseUntil) {
+    const rows = await this._query(
+      `UPDATE scheduled_messages
+          SET lease_until = $1, updated_at = NOW()
+        WHERE id = $2 AND status = 'pending'
+          AND date_trunc('milliseconds', next_send_at)
+            = date_trunc('milliseconds', $3::timestamptz)
+          AND (lease_until IS NULL OR lease_until <= NOW())
+       RETURNING id`,
+      [leaseUntil, taskId, expectedNextSendAt]
+    );
+    return rows.length > 0;
+  }
+
   async listTasks(userId, opts = {}) {
     const { status = 'all', limit = 20, offset = 0 } = opts;
 

package/dist/{pg-07S-u_H4.d.cts → pg-C5gtWUfU.d.ts}

@@ -1,5 +1,5 @@
 import { Pool } from 'pg';
-import { T as TABLE_SQL, I as INDEXES, V as VERIFY_TABLE_SQL, C as COLUMNS_SQL } from './schema-C8OnYk6j.cjs';
+import { T as TABLE_SQL, M as MIGRATIONS, I as INDEXES, V as VERIFY_TABLE_SQL, C as COLUMNS_SQL } from './schema-BHuyH_6Z.js';
 
 /**
  * PostgreSQL (pg) Database Adapter
@@ -37,6 +37,9 @@ class PgAdapter {
 
   async initSchema() {
     await this._query(TABLE_SQL);
+    for (const migration of MIGRATIONS) {
+      await this._query(migration.sql);
+    }
     const indexResults = [];
     for (const index of INDEXES) {
       try {
@@ -182,12 +185,52 @@ class PgAdapter {
       `SELECT id, user_id, uuid, encrypted_payload, message_type, next_send_at, status, retry_count
        FROM scheduled_messages
        WHERE status = 'pending' AND next_send_at <= NOW()
+         AND (lease_until IS NULL OR lease_until <= NOW())
        ORDER BY next_send_at ASC
        LIMIT $1`,
       [limit]
     );
   }
 
+  /**
+   * 领取一条到点的任务：在 lease_until 上写下「这条归我管到什么时候」，
+   * 本次投递期间别的 tick 领不走它。
+   *
+   * 租约写在自己的列上，next_send_at 全程不动——那一列是用户设的触发时刻，
+   * 任务列表要读它、循环任务推进下一次也要拿它当基准。
+   *
+   * 两个 tick 抢同一行时只有一个改得动，另一个拿不到 RETURNING 行，据此跳
+   * 过。WHERE 里的两个条件各管一件事：
+   *   - lease_until 为空或已过期：没人正在跑这条。领了任务的 tick 中途没了
+   *     也不会把行焊死，租约到期后自然可以被接手。
+   *   - next_send_at 等于读这行时看到的值：读出来之后用户又改了排期的话，
+   *     这一跳就不该再按旧时刻发。
+   *
+   * 不加一个 'sending' 状态来表达「正在跑」：status 上有 CHECK 约束，加值
+   * 要改表。
+   *
+   * 比 next_send_at 时两边都截到毫秒：列是 timestamptz（微秒精度），驱动读
+   * 出来是 JS Date（毫秒精度），原值送回去可能因为亚毫秒差对不上。
+   *
+   * @param {number} taskId
+   * @param {string|Date} expectedNextSendAt - 读这行时拿到的 next_send_at 原值
+   * @param {string|Date} leaseUntil - 租期末尾
+   * @returns {Promise<boolean>} true = 领到了；false = 已被别人领走或行已不是 pending
+   */
+  async claimTask(taskId, expectedNextSendAt, leaseUntil) {
+    const rows = await this._query(
+      `UPDATE scheduled_messages
+          SET lease_until = $1, updated_at = NOW()
+        WHERE id = $2 AND status = 'pending'
+          AND date_trunc('milliseconds', next_send_at)
+            = date_trunc('milliseconds', $3::timestamptz)
+          AND (lease_until IS NULL OR lease_until <= NOW())
+       RETURNING id`,
+      [leaseUntil, taskId, expectedNextSendAt]
+    );
+    return rows.length > 0;
+  }
+
   async listTasks(userId, opts = {}) {
     const { status = 'all', limit = 20, offset = 0 } = opts;
 

package/dist/{pg-QO6NKTGL.mjs → pg-DFJSFOJQ.mjs}

@@ -1,9 +1,10 @@
 import {
   COLUMNS_SQL,
   INDEXES,
+  MIGRATIONS,
   TABLE_SQL,
   VERIFY_TABLE_SQL
-} from "./chunk-5ENJGVZX.mjs";
+} from "./chunk-GOBCWCJP.mjs";
 
 // src/server/adapters/pg.js
 import { Pool } from "pg";
@@ -28,6 +29,9 @@ var PgAdapter = class {
   }
   async initSchema() {
     await this._query(TABLE_SQL);
+    for (const migration of MIGRATIONS) {
+      await this._query(migration.sql);
+    }
     const indexResults = [];
     for (const index of INDEXES) {
       try {
@@ -156,11 +160,50 @@ var PgAdapter = class {
       `SELECT id, user_id, uuid, encrypted_payload, message_type, next_send_at, status, retry_count
        FROM scheduled_messages
        WHERE status = 'pending' AND next_send_at <= NOW()
+         AND (lease_until IS NULL OR lease_until <= NOW())
        ORDER BY next_send_at ASC
        LIMIT $1`,
       [limit]
     );
   }
+  /**
+   * 领取一条到点的任务：在 lease_until 上写下「这条归我管到什么时候」，
+   * 本次投递期间别的 tick 领不走它。
+   *
+   * 租约写在自己的列上，next_send_at 全程不动——那一列是用户设的触发时刻，
+   * 任务列表要读它、循环任务推进下一次也要拿它当基准。
+   *
+   * 两个 tick 抢同一行时只有一个改得动，另一个拿不到 RETURNING 行，据此跳
+   * 过。WHERE 里的两个条件各管一件事：
+   *   - lease_until 为空或已过期：没人正在跑这条。领了任务的 tick 中途没了
+   *     也不会把行焊死，租约到期后自然可以被接手。
+   *   - next_send_at 等于读这行时看到的值：读出来之后用户又改了排期的话，
+   *     这一跳就不该再按旧时刻发。
+   *
+   * 不加一个 'sending' 状态来表达「正在跑」：status 上有 CHECK 约束，加值
+   * 要改表。
+   *
+   * 比 next_send_at 时两边都截到毫秒：列是 timestamptz（微秒精度），驱动读
+   * 出来是 JS Date（毫秒精度），原值送回去可能因为亚毫秒差对不上。
+   *
+   * @param {number} taskId
+   * @param {string|Date} expectedNextSendAt - 读这行时拿到的 next_send_at 原值
+   * @param {string|Date} leaseUntil - 租期末尾
+   * @returns {Promise<boolean>} true = 领到了；false = 已被别人领走或行已不是 pending
+   */
+  async claimTask(taskId, expectedNextSendAt, leaseUntil) {
+    const rows = await this._query(
+      `UPDATE scheduled_messages
+          SET lease_until = $1, updated_at = NOW()
+        WHERE id = $2 AND status = 'pending'
+          AND date_trunc('milliseconds', next_send_at)
+            = date_trunc('milliseconds', $3::timestamptz)
+          AND (lease_until IS NULL OR lease_until <= NOW())
+       RETURNING id`,
+      [leaseUntil, taskId, expectedNextSendAt]
+    );
+    return rows.length > 0;
+  }
   async listTasks(userId, opts = {}) {
     const { status = "all", limit = 20, offset = 0 } = opts;
     const conditions = ["user_id = $1"];

package/dist/{schema-C8OnYk6j.d.cts → schema-BHuyH_6Z.d.cts}

@@ -11,6 +11,7 @@ const TABLE_SQL = `
     encrypted_payload TEXT NOT NULL,
     message_type VARCHAR(50) NOT NULL CHECK (message_type IN ('fixed', 'prompted', 'auto', 'instant')),
     next_send_at TIMESTAMP WITH TIME ZONE NOT NULL,
+    lease_until TIMESTAMP WITH TIME ZONE,
     status VARCHAR(50) NOT NULL DEFAULT 'pending' CHECK (status IN ('pending', 'sent', 'failed')),
     retry_count INTEGER DEFAULT 0,
     created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
@@ -18,6 +19,19 @@ const TABLE_SQL = `
   )
 `;
 
+/**
+ * 建表语句用的是 CREATE TABLE IF NOT EXISTS，已经存在的表不会被改动，所以
+ * 后加的列要单独补。initSchema 每次都会跑一遍，Postgres 的 IF NOT EXISTS
+ * 让重复执行也没事。
+ */
+const MIGRATIONS = [
+  {
+    name: 'add_lease_until',
+    sql: 'ALTER TABLE scheduled_messages ADD COLUMN IF NOT EXISTS lease_until TIMESTAMP WITH TIME ZONE',
+    description: 'Task claim lease (2.6.0)'
+  }
+];
+
 const INDEXES = [
   {
     name: 'idx_pending_tasks_optimized',
@@ -71,4 +85,4 @@ const COLUMNS_SQL = `
   ORDER BY ordinal_position
 `;
 
-export { COLUMNS_SQL as C, INDEXES as I, TABLE_SQL as T, VERIFY_TABLE_SQL as V };
+export { COLUMNS_SQL as C, INDEXES as I, MIGRATIONS as M, TABLE_SQL as T, VERIFY_TABLE_SQL as V };

package/dist/{schema-C8OnYk6j.d.ts → schema-BHuyH_6Z.d.ts}

@@ -11,6 +11,7 @@ const TABLE_SQL = `
     encrypted_payload TEXT NOT NULL,
     message_type VARCHAR(50) NOT NULL CHECK (message_type IN ('fixed', 'prompted', 'auto', 'instant')),
     next_send_at TIMESTAMP WITH TIME ZONE NOT NULL,
+    lease_until TIMESTAMP WITH TIME ZONE,
     status VARCHAR(50) NOT NULL DEFAULT 'pending' CHECK (status IN ('pending', 'sent', 'failed')),
     retry_count INTEGER DEFAULT 0,
     created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
@@ -18,6 +19,19 @@ const TABLE_SQL = `
   )
 `;
 
+/**
+ * 建表语句用的是 CREATE TABLE IF NOT EXISTS，已经存在的表不会被改动，所以
+ * 后加的列要单独补。initSchema 每次都会跑一遍，Postgres 的 IF NOT EXISTS
+ * 让重复执行也没事。
+ */
+const MIGRATIONS = [
+  {
+    name: 'add_lease_until',
+    sql: 'ALTER TABLE scheduled_messages ADD COLUMN IF NOT EXISTS lease_until TIMESTAMP WITH TIME ZONE',
+    description: 'Task claim lease (2.6.0)'
+  }
+];
+
 const INDEXES = [
   {
     name: 'idx_pending_tasks_optimized',
@@ -71,4 +85,4 @@ const COLUMNS_SQL = `
   ORDER BY ordinal_position
 `;
 
-export { COLUMNS_SQL as C, INDEXES as I, TABLE_SQL as T, VERIFY_TABLE_SQL as V };
+export { COLUMNS_SQL as C, INDEXES as I, MIGRATIONS as M, TABLE_SQL as T, VERIFY_TABLE_SQL as V };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rei-standard/amsg-server",
-  "version": "2.6.0-next.4",
+  "version": "2.6.0-next.6",
   "description": "ReiStandard Active Messaging server SDK with pluggable database adapters. Three-axis push schema (messageKind / messageType / messageSubtype) from @rei-standard/amsg-shared. Auto-emits ReasoningPush when the LLM response carries reasoning_content.",
   "repository": {
     "type": "git",