@rei-standard/amsg-server 2.6.0-next.13 → 2.6.0-next.16

package/dist/{chunk-TV7N3RTH.mjs → chunk-KVHR3RCU.mjs}

@@ -1,3 +1,7 @@
+import {
+  UPDATABLE_COLUMNS
+} from "./chunk-34I2YSWE.mjs";
+
 // src/server/lib/recurrence.js
 var DAY_MS = 24 * 60 * 60 * 1e3;
 var MAX_LISTED_SKIPPED_OCCURRENCES = 32;
@@ -121,19 +125,11 @@ function nextFutureOccurrence(occurrenceMs, recurrenceType, nowMs, tzId) {
 }
 
 // src/server/lib/validation.js
-import { validateAvatarUrl, validateLlmMessagesShape } from "@rei-standard/amsg-shared";
+import { isValidUrl, validateAvatarUrl, validateLlmMessagesShape } from "@rei-standard/amsg-shared";
 function isValidISO8601(dateString) {
   const date = new Date(dateString);
   return date instanceof Date && !isNaN(date.getTime());
 }
-function isValidUrl(urlString) {
-  try {
-    new URL(urlString);
-    return true;
-  } catch {
-    return false;
-  }
-}
 function isValidUUID(uuid) {
   const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
   return uuidRegex.test(uuid);
@@ -168,9 +164,9 @@ function validateSplitPattern(value) {
   return null;
 }
 function validateLlmMessagesArray(messages) {
-  const err3 = validateLlmMessagesShape(messages);
-  if (!err3) return null;
-  const { code, index: i, toolCallIndex: j } = err3;
+  const err4 = validateLlmMessagesShape(messages);
+  if (!err4) return null;
+  const { code, index: i, toolCallIndex: j } = err4;
   switch (code) {
     case "MESSAGES_NOT_ARRAY":
       return "messages must be a non-empty array";
@@ -200,11 +196,32 @@ function validateScheduleMessagePayload(payload) {
   if (!payload.messageType || !["fixed", "prompted", "auto", "instant"].includes(payload.messageType)) {
     return { valid: false, errorCode: "INVALID_MESSAGE_TYPE", errorMessage: "\u6D88\u606F\u7C7B\u578B\u65E0\u6548", details: { providedType: payload.messageType, allowedTypes: ["fixed", "prompted", "auto", "instant"] } };
   }
-  if (!payload.firstSendTime || !isValidISO8601(payload.firstSendTime)) {
-    return { valid: false, errorCode: "INVALID_TIMESTAMP", errorMessage: "\u65F6\u95F4\u683C\u5F0F\u65E0\u6548", details: { field: "firstSendTime" } };
+  if (payload.immediate !== void 0 && typeof payload.immediate !== "boolean") {
+    return { valid: false, errorCode: "INVALID_PARAMETERS", errorMessage: "immediate \u5FC5\u987B\u662F\u5E03\u5C14\u503C", details: { invalidFields: ["immediate"] } };
   }
-  if (payload.firstSendTime && new Date(payload.firstSendTime) <= /* @__PURE__ */ new Date()) {
-    return { valid: false, errorCode: "INVALID_TIMESTAMP", errorMessage: "\u65F6\u95F4\u5FC5\u987B\u5728\u672A\u6765", details: { field: "firstSendTime", reason: "must be in the future" } };
+  const immediate = payload.immediate === true;
+  if (immediate && payload.messageType === "instant") {
+    return { valid: false, errorCode: "INVALID_PARAMETERS", errorMessage: "messageType 'instant' \u672C\u5C31\u7ACB\u5373\u6295\u9012\uFF0C\u4E0D\u80FD\u518D\u5E26 immediate", details: { invalidFields: ["immediate"] } };
+  }
+  if (immediate) {
+    if (payload.firstSendTime !== void 0 && payload.firstSendTime !== null && !isValidISO8601(payload.firstSendTime)) {
+      return { valid: false, errorCode: "INVALID_TIMESTAMP", errorMessage: "\u65F6\u95F4\u683C\u5F0F\u65E0\u6548", details: { field: "firstSendTime" } };
+    }
+  } else {
+    if (!payload.firstSendTime || !isValidISO8601(payload.firstSendTime)) {
+      return { valid: false, errorCode: "INVALID_TIMESTAMP", errorMessage: "\u65F6\u95F4\u683C\u5F0F\u65E0\u6548", details: { field: "firstSendTime" } };
+    }
+    if (payload.firstSendTime && new Date(payload.firstSendTime) <= /* @__PURE__ */ new Date()) {
+      return { valid: false, errorCode: "INVALID_TIMESTAMP", errorMessage: "\u65F6\u95F4\u5FC5\u987B\u5728\u672A\u6765", details: { field: "firstSendTime", reason: "must be in the future" } };
+    }
+  }
+  if (payload.supersedesUuid !== void 0 && payload.supersedesUuid !== null) {
+    if (typeof payload.supersedesUuid !== "string" || !isValidUUID(payload.supersedesUuid)) {
+      return { valid: false, errorCode: "INVALID_PARAMETERS", errorMessage: "supersedesUuid \u5FC5\u987B\u662F\u5408\u6CD5 UUID", details: { invalidFields: ["supersedesUuid"] } };
+    }
+    if (payload.uuid && payload.supersedesUuid === payload.uuid) {
+      return { valid: false, errorCode: "INVALID_PARAMETERS", errorMessage: "supersedesUuid \u4E0D\u80FD\u4E0E\u672C\u6761\u4EFB\u52A1\u7684 uuid \u76F8\u540C", details: { invalidFields: ["supersedesUuid"] } };
+    }
   }
   if (payload.pushSubscription !== void 0) {
     return {
@@ -239,10 +256,10 @@ function validateScheduleMessagePayload(payload) {
       };
     }
     if (hasMessages) {
-      const err3 = validateLlmMessagesArray(payload.messages);
-      if (err3) {
+      const err4 = validateLlmMessagesArray(payload.messages);
+      if (err4) {
         return {
-          error: { code: "INVALID_PARAMETERS", message: err3, details: { invalidFields: ["messages"] } },
+          error: { code: "INVALID_PARAMETERS", message: err4, details: { invalidFields: ["messages"] } },
           hasCompletePrompt: false,
           hasMessages: true
         };
@@ -292,6 +309,9 @@ function validateScheduleMessagePayload(payload) {
   if (splitErr) {
     return { valid: false, errorCode: "INVALID_PARAMETERS", errorMessage: splitErr, details: { invalidFields: ["splitPattern"] } };
   }
+  if (payload.llmExtraBody !== void 0 && payload.llmExtraBody !== null && (typeof payload.llmExtraBody !== "object" || Array.isArray(payload.llmExtraBody))) {
+    return { valid: false, errorCode: "INVALID_PARAMETERS", errorMessage: "llmExtraBody \u5FC5\u987B\u662F\u666E\u901A\u5BF9\u8C61", details: { invalidFields: ["llmExtraBody"] } };
+  }
   return { valid: true };
 }
 
@@ -436,6 +456,16 @@ function parseEncryptedBody(body) {
   }
   return parsedBody;
 }
+function errorResponse(status, code, message, details) {
+  const error = details === void 0 ? { code, message } : { code, message, details };
+  return { status, body: { success: false, error } };
+}
+function requireUserId(headers) {
+  const userId = getHeader(headers, "x-user-id");
+  if (!userId) return { error: errorResponse(400, "USER_ID_REQUIRED", "\u7F3A\u5C11\u7528\u6237\u6807\u8BC6\u7B26") };
+  if (!isValidUUIDv4(userId)) return { error: errorResponse(400, "INVALID_USER_ID_FORMAT", "X-User-Id \u5FC5\u987B\u662F UUID v4 \u683C\u5F0F") };
+  return { userId };
+}
 function getHeader(headers = {}, name) {
   if (!headers || typeof headers !== "object") {
     return "";
@@ -459,19 +489,9 @@ function createGetUserKeyHandler(ctx) {
       return tenantResult.error;
     }
     const { masterKey } = tenantResult.context;
-    const userId = getHeader(effectiveHeaders, "x-user-id");
-    if (!userId) {
-      return {
-        status: 400,
-        body: { success: false, error: { code: "USER_ID_REQUIRED", message: "\u7F3A\u5C11\u7528\u6237\u6807\u8BC6\u7B26" } }
-      };
-    }
-    if (!isValidUUIDv4(userId)) {
-      return {
-        status: 400,
-        body: { success: false, error: { code: "INVALID_USER_ID_FORMAT", message: "X-User-Id \u5FC5\u987B\u662F UUID v4 \u683C\u5F0F" } }
-      };
-    }
+    const gate = requireUserId(effectiveHeaders);
+    if (gate.error) return gate.error;
+    const { userId } = gate;
     return {
       status: 200,
       body: {
@@ -486,6 +506,14 @@ function createGetUserKeyHandler(ctx) {
   return { GET };
 }
 
+// src/server/lib/agentic-fire.js
+import {
+  assertValidDecision,
+  buildSessionContext,
+  extractAssistantMessage,
+  extractToolCallsFromDecision
+} from "@rei-standard/amsg-shared";
+
 // src/server/lib/db-errors.js
 function isUniqueViolation(error) {
   if (!error || typeof error !== "object") return false;
@@ -495,46 +523,6 @@ function isUniqueViolation(error) {
   return message.includes("duplicate key") || message.includes("unique constraint");
 }
 
-// src/server/lib/push-subscription-store.js
-function supportsPushSubscriptionStore(db) {
-  return !!db && typeof db.getPushSubscription === "function" && typeof db.upsertPushSubscription === "function" && typeof db.deletePushSubscription === "function";
-}
-function isPushSubscriptionShape(subscription) {
-  return !!subscription && typeof subscription === "object" && !Array.isArray(subscription) && typeof /** @type {{ endpoint?: unknown }} */
-  subscription.endpoint === "string" && /** @type {{ endpoint: string }} */
-  subscription.endpoint.trim().length > 0;
-}
-async function savePushSubscription({ db, userId, userKey, subscription, updatedAt }) {
-  const at = Number.isInteger(updatedAt) && updatedAt > 0 ? updatedAt : Date.now();
-  const encrypted = await encryptForStorage(JSON.stringify(subscription), userKey);
-  await db.upsertPushSubscription(userId, encrypted, at);
-  return { updatedAt: at };
-}
-async function loadPushSubscription({ db, userId, userKey }) {
-  const row = await db.getPushSubscription(userId);
-  if (!row || typeof row.subscription !== "string" || !row.subscription) return null;
-  const subscription = JSON.parse(await decryptFromStorage(row.subscription, userKey));
-  return { subscription, updatedAt: row.updated_at ?? null };
-}
-async function resolvePushSubscription({ db, userId, userKey }) {
-  if (!supportsPushSubscriptionStore(db)) {
-    throw new Error("PUSH_SUBSCRIPTION_STORE_UNSUPPORTED: \u5F53\u524D\u6570\u636E\u5E93\u9002\u914D\u5668\u4E0D\u652F\u6301\u7528\u6237\u7EA7\u63A8\u9001\u8BA2\u9605\u5B58\u50A8");
-  }
-  const stored = await loadPushSubscription({ db, userId, userKey });
-  if (!stored) {
-    throw new Error("PUSH_SUBSCRIPTION_MISSING: \u8BE5\u7528\u6237\u8FD8\u6CA1\u6709\u767B\u8BB0\u63A8\u9001\u8BA2\u9605\uFF08PUT /push-subscription\uFF09");
-  }
-  return stored.subscription;
-}
-
-// src/server/lib/message-processor.js
-import {
-  buildContentPush,
-  buildReasoningPush,
-  readReasoningContent,
-  stripReasoningTags
-} from "@rei-standard/amsg-shared";
-
 // src/server/lib/llm.js
 import {
   callLlm,
@@ -542,14 +530,6 @@ import {
   normalizeAiApiUrl
 } from "@rei-standard/amsg-shared";
 
-// src/server/lib/agentic-fire.js
-import {
-  assertValidDecision,
-  buildSessionContext,
-  extractAssistantMessage,
-  extractToolCallsFromDecision
-} from "@rei-standard/amsg-shared";
-
 // src/server/lib/state-chunks.js
 import { chunkReasoningByUtf8Bytes } from "@rei-standard/amsg-shared";
 var STATE_CHUNK_SLICE_BYTES = 200 * 1024;
@@ -635,29 +615,32 @@ async function writeClientStateEntries({ db, userId, userKey, entries }) {
   const physicalRows = [];
   const cleanups = [];
   const rootRowIndexes = [];
+  const rootRowEntries = [];
   let deleted = 0;
   for (const entry of entries) {
+    const guardAt = Number.isInteger(entry.version) && entry.version > 0 ? entry.version : entry.updatedAt;
     cleanups.push({
       namespace: chunkNamespaceFor(entry.namespace),
       keyPrefix: chunkKeyPrefixFor(entry.key),
-      updatedAt: entry.updatedAt
+      updatedAt: guardAt
     });
     if (entry.value === null) {
       cleanups.push({
         namespace: entry.namespace,
         key: entry.key,
-        updatedAt: entry.updatedAt
+        updatedAt: guardAt
       });
       deleted++;
       continue;
     }
     rootRowIndexes.push(physicalRows.length);
+    rootRowEntries.push(entry);
     if (stateValueBytes(entry.value) <= STATE_CHUNK_SLICE_BYTES) {
       physicalRows.push({
         namespace: entry.namespace,
         key: entry.key,
         value: await encryptForStorage(entry.value, userKey),
-        updatedAt: entry.updatedAt
+        updatedAt: guardAt
       });
     } else {
       const slices = splitStateValue(entry.value);
@@ -665,7 +648,7 @@ async function writeClientStateEntries({ db, userId, userKey, entries }) {
         namespace: entry.namespace,
         key: entry.key,
         value: buildChunkedRootValue(slices.length),
-        updatedAt: entry.updatedAt
+        updatedAt: guardAt
       });
       const encryptedSlices = await Promise.all(slices.map((slice) => encryptForStorage(slice, userKey)));
       for (let c = 0; c < encryptedSlices.length; c++) {
@@ -673,27 +656,33 @@ async function writeClientStateEntries({ db, userId, userKey, entries }) {
           namespace: chunkNamespaceFor(entry.namespace),
           key: chunkKeyFor(entry.key, c),
           value: encryptedSlices[c],
-          updatedAt: entry.updatedAt
+          updatedAt: guardAt
         });
       }
     }
   }
   if (physicalRows.length === 0 && cleanups.length === 0) {
-    return { upserted: 0, skipped: 0, deleted: 0 };
+    return { upserted: 0, skipped: 0, deleted: 0, skippedEntries: [] };
   }
   const result = await db.upsertClientState(userId, physicalRows, cleanups);
   let upserted = 0;
   let skipped = 0;
+  const skippedEntries = [];
   if (Array.isArray(result.outcomes) && result.outcomes.length === physicalRows.length) {
-    for (const rootIndex of rootRowIndexes) {
-      if (result.outcomes[rootIndex]) upserted++;
-      else skipped++;
+    for (let i = 0; i < rootRowIndexes.length; i++) {
+      if (result.outcomes[rootRowIndexes[i]]) {
+        upserted++;
+      } else {
+        skipped++;
+        const entry = rootRowEntries[i];
+        skippedEntries.push({ namespace: entry.namespace, key: entry.key });
+      }
     }
   } else {
     upserted = result.upserted;
     skipped = result.skipped;
   }
-  return { upserted, skipped, deleted };
+  return { upserted, skipped, deleted, skippedEntries };
 }
 
 // src/server/lib/state-accessors.js
@@ -754,11 +743,15 @@ function createStateAccessors({ db, userId, userKey, maxStateValueBytes, now })
       if (entry.updatedAt !== void 0 && (!Number.isInteger(entry.updatedAt) || entry.updatedAt <= 0)) {
         throw new TypeError(`writeState: entries[${index}].updatedAt \u5FC5\u987B\u662F\u6B63\u6574\u6570\uFF08epoch \u6BEB\u79D2\uFF09`);
       }
+      if (entry.version !== void 0 && (!Number.isInteger(entry.version) || entry.version <= 0)) {
+        throw new TypeError(`writeState: entries[${index}].version \u5FC5\u987B\u662F\u6B63\u6574\u6570\uFF08\u6BEB\u79D2\u65F6\u95F4\u6233\u6216\u5355\u8C03\u9012\u589E\u7248\u672C\u53F7\uFF09`);
+      }
       return {
         namespace,
         key: entry.key,
         value: entry.value,
-        updatedAt: entry.updatedAt ?? at
+        updatedAt: entry.updatedAt ?? at,
+        ...entry.version !== void 0 ? { version: entry.version } : {}
       };
     });
     return writeClientStateEntries({ db, userId, userKey, entries: normalized });
@@ -793,10 +786,92 @@ function projectTask(row, decryptedPayload, options = {}) {
     ...options.includeMetadata ? { metadata: payload.metadata ?? null } : {},
     // 上一次没发出去的原因（run-tick 记进 payload 的 lastError）。
     // reason 'stale' 表示错过触发时刻太久被判定不再补发；其余是投递失败的
-    // 错误信息。没有记录 → null。
-    lastError: payload.lastError ?? null
+    // 错误信息。payload 里没有时退回行上的 last_error 列（同形状的脱敏摘要，
+    // 等重试期间的失败也记在那里）。没有记录 → null。
+    lastError: payload.lastError ?? parseRowLastError(row.last_error)
   };
 }
+function parseRowLastError(raw) {
+  if (typeof raw !== "string" || !raw) return null;
+  try {
+    return JSON.parse(raw);
+  } catch (_error) {
+    return { reason: raw };
+  }
+}
+
+// src/server/lib/push-subscription-store.js
+function supportsPushSubscriptionStore(db) {
+  return !!db && typeof db.getPushSubscription === "function" && typeof db.upsertPushSubscription === "function" && typeof db.deletePushSubscription === "function";
+}
+function isPushSubscriptionShape(subscription) {
+  return !!subscription && typeof subscription === "object" && !Array.isArray(subscription) && typeof /** @type {{ endpoint?: unknown }} */
+  subscription.endpoint === "string" && /** @type {{ endpoint: string }} */
+  subscription.endpoint.trim().length > 0;
+}
+async function savePushSubscription({ db, userId, userKey, subscription, updatedAt }) {
+  const at = Number.isInteger(updatedAt) && updatedAt > 0 ? updatedAt : Date.now();
+  const encrypted = await encryptForStorage(JSON.stringify(subscription), userKey);
+  await db.upsertPushSubscription(userId, encrypted, at);
+  return { updatedAt: at };
+}
+async function loadPushSubscription({ db, userId, userKey }) {
+  const row = await db.getPushSubscription(userId);
+  if (!row || typeof row.subscription !== "string" || !row.subscription) return null;
+  const subscription = JSON.parse(await decryptFromStorage(row.subscription, userKey));
+  return { subscription, updatedAt: row.updated_at ?? null };
+}
+function codedError(code, message) {
+  const error = new Error(`${code}: ${message}`);
+  error.code = code;
+  return error;
+}
+async function resolvePushSubscription({ db, userId, userKey, legacyFallback = null }) {
+  const fallback = isPushSubscriptionShape(legacyFallback) ? legacyFallback : null;
+  if (!supportsPushSubscriptionStore(db)) {
+    if (fallback) return fallback;
+    throw codedError("PUSH_SUBSCRIPTION_STORE_UNSUPPORTED", "\u5F53\u524D\u6570\u636E\u5E93\u9002\u914D\u5668\u4E0D\u652F\u6301\u7528\u6237\u7EA7\u63A8\u9001\u8BA2\u9605\u5B58\u50A8");
+  }
+  const stored = await loadPushSubscription({ db, userId, userKey });
+  if (!stored) {
+    if (fallback) return fallback;
+    throw codedError("PUSH_SUBSCRIPTION_MISSING", "\u8BE5\u7528\u6237\u8FD8\u6CA1\u6709\u767B\u8BB0\u63A8\u9001\u8BA2\u9605\uFF08PUT /push-subscription\uFF09");
+  }
+  return stored.subscription;
+}
+
+// src/server/lib/outbox-store.js
+function supportsOutbox(db) {
+  return !!db && typeof db.appendOutboxMessages === "function" && typeof db.markOutboxDelivered === "function";
+}
+async function appendPushesToOutbox({ db, userId, userKey, pushes }) {
+  if (!supportsOutbox(db) || !pushes || pushes.length === 0) return false;
+  try {
+    const now = Date.now();
+    const rows = await Promise.all(pushes.map(async (push) => ({
+      message_id: push.messageId,
+      task_uuid: push.taskUuid ?? null,
+      session_id: push.sessionId ?? null,
+      message_index: push.messageIndex ?? null,
+      total_messages: push.totalMessages ?? null,
+      payload: await encryptForStorage(JSON.stringify(push), userKey),
+      created_at: now
+    })));
+    await db.appendOutboxMessages(userId, rows);
+    return true;
+  } catch (error) {
+    console.warn("[amsg-server] outbox \u843D\u884C\u5931\u8D25\uFF08\u4E0D\u5F71\u54CD\u6295\u9012\uFF09:", error && error.message);
+    return false;
+  }
+}
+async function markPushesDelivered({ db, userId, messageIds }) {
+  if (!supportsOutbox(db) || !messageIds || messageIds.length === 0) return;
+  try {
+    await db.markOutboxDelivered(userId, messageIds, Date.now());
+  } catch (error) {
+    console.warn("[amsg-server] outbox \u6807\u8BB0 delivered \u5931\u8D25\uFF08\u5DF2\u5FFD\u7565\uFF09:", error && error.message);
+  }
+}
 
 // src/server/lib/agentic-fire.js
 var DEFAULT_MAX_TOOL_ITERATIONS = 5;
@@ -985,6 +1060,9 @@ async function runAgenticFire({ task, decryptedPayload, userKey, ctx }) {
       maxTokens: decryptedPayload.maxTokens ?? null,
       temperature: decryptedPayload.temperature ?? null,
       splitPattern: decryptedPayload.splitPattern ?? null,
+      // 与凭据同列的投递配置：中转的非标准参数（thinking 之类）跟着任务走，
+      // 自排的后续任务不该突然掉档。
+      llmExtraBody: decryptedPayload.llmExtraBody ?? null,
       metadata
     };
     const encryptedPayload = await encryptForStorage(JSON.stringify(fullTaskData), userKey);
@@ -1018,6 +1096,57 @@ async function runAgenticFire({ task, decryptedPayload, userKey, ctx }) {
       nextSendAt: created.next_send_at ?? nextSendAt
     };
   };
+  const cancelTask = async (uuid) => {
+    if (typeof uuid !== "string" || !uuid.trim()) {
+      throw new TypeError("cancelTask(uuid) \u9700\u8981\u975E\u7A7A\u5B57\u7B26\u4E32 uuid");
+    }
+    if (task.uuid != null && uuid === task.uuid) {
+      throw new RangeError(
+        "cancelTask: \u4E0D\u80FD\u53D6\u6D88\u5F53\u524D\u6B63\u5728 fire \u7684\u4EFB\u52A1\u2014\u2014\u8FD9\u6761\u7684\u6536\u5C3E\u5F52 run-tick \u7BA1\u3002\u8FD9\u6B21\u4E0D\u60F3\u53D1\u7684\u8BDD\uFF0C\u7528 onBeforeFire \u7684 { skip: true } \u6216 onLLMOutput \u7684 'skip-push'\u3002"
+      );
+    }
+    if (!ctx.db || typeof ctx.db.deleteTaskByUuid !== "function") {
+      throw new Error("AGENTIC_CANCEL_UNSUPPORTED: \u5F53\u524D\u6570\u636E\u5E93\u9002\u914D\u5668\u4E0D\u652F\u6301\u5220\u4EFB\u52A1\uFF08\u7F3A deleteTaskByUuid\uFF09");
+    }
+    const cancelled = await ctx.db.deleteTaskByUuid(uuid, task.user_id);
+    return { cancelled: !!cancelled };
+  };
+  const renewTask = async (uuid, nextSendAt) => {
+    if (typeof uuid !== "string" || !uuid.trim()) {
+      throw new TypeError("renewTask(uuid, nextSendAt) \u9700\u8981\u975E\u7A7A\u5B57\u7B26\u4E32 uuid");
+    }
+    if (task.uuid != null && uuid === task.uuid) {
+      throw new RangeError("renewTask: \u4E0D\u80FD\u6539\u5F53\u524D\u6B63\u5728 fire \u7684\u4EFB\u52A1\u2014\u2014\u8FD9\u6761\u7684\u6392\u671F\u63A8\u8FDB\u5F52 run-tick \u7BA1");
+    }
+    if (typeof nextSendAt !== "string" || !nextSendAt.trim()) {
+      throw new RangeError("renewTask: nextSendAt \u5FC5\u586B\uFF0C\u4E14\u5FC5\u987B\u662F ISO 8601 \u5B57\u7B26\u4E32");
+    }
+    const sendAt = new Date(nextSendAt);
+    if (Number.isNaN(sendAt.getTime())) {
+      throw new RangeError(`renewTask: nextSendAt \u89E3\u6790\u4E0D\u51FA\u5408\u6CD5\u65F6\u95F4\uFF1A${nextSendAt}`);
+    }
+    const earliest = nowFn() + MIN_SCHEDULE_LEAD_MS;
+    if (sendAt.getTime() < earliest) {
+      throw new RangeError(
+        `renewTask: nextSendAt \u81F3\u5C11\u8981\u6BD4\u73B0\u5728\u665A ${MIN_SCHEDULE_LEAD_MS / 1e3} \u79D2\uFF08\u6700\u65E9\u53EF\u6392 ${new Date(earliest).toISOString()}\uFF0C\u6536\u5230 ${sendAt.toISOString()}\uFF09`
+      );
+    }
+    if (!ctx.db || typeof ctx.db.getTaskByUuid !== "function" || typeof ctx.db.updateTaskByUuid !== "function") {
+      throw new Error("AGENTIC_RENEW_UNSUPPORTED: \u5F53\u524D\u6570\u636E\u5E93\u9002\u914D\u5668\u4E0D\u652F\u6301\u6539\u4EFB\u52A1\uFF08\u7F3A getTaskByUuid / updateTaskByUuid\uFF09");
+    }
+    const row = await ctx.db.getTaskByUuid(uuid, task.user_id);
+    if (!row) return { renewed: false, reason: "not_found" };
+    const payload = JSON.parse(await decryptFromStorage(row.encrypted_payload, userKey));
+    const nextSendAtIso = sendAt.toISOString();
+    const encrypted = await encryptForStorage(JSON.stringify({ ...payload, firstSendTime: nextSendAtIso }), userKey);
+    const updated = await ctx.db.updateTaskByUuid(uuid, task.user_id, encrypted, {
+      next_send_at: nextSendAtIso,
+      retry_count: 0,
+      ...typeof ctx.db.claimTask === "function" ? { retry_after: null } : {}
+    });
+    if (!updated) return { renewed: false, reason: "not_found" };
+    return { renewed: true, uuid, nextSendAt: nextSendAtIso };
+  };
   const scratch = {};
   const fireCtx = Object.freeze({
     task: buildHookTask(task, decryptedPayload),
@@ -1025,10 +1154,12 @@ async function runAgenticFire({ task, decryptedPayload, userKey, ctx }) {
     readState,
     writeState,
     scheduleTask,
+    cancelTask,
+    renewTask,
     now: new Date(nowFn()),
     scratch
   });
-  const progress = { sentCount: 0, total: 0, iterations: 0, skipReason: null };
+  const progress = { sentCount: 0, total: 0, iterations: 0, skipReason: null, usage: null };
   let settledStatus = "failed";
   let settledError = null;
   try {
@@ -1044,6 +1175,8 @@ async function runAgenticFire({ task, decryptedPayload, userKey, ctx }) {
       writeState,
       scratch,
       scheduleTask,
+      cancelTask,
+      renewTask,
       fireCtx,
       progress
     });
@@ -1061,6 +1194,14 @@ async function runAgenticFire({ task, decryptedPayload, userKey, ctx }) {
       total: progress.total,
       iterations: progress.iterations,
       error: settledError,
+      // 解密 payload 里的 metadata 子字段（与 onStaleSkip 同待遇）：task 行本
+      // 身是密文，宿主要靠它对上「这是哪个角色的哪类任务」——尤其是 fire 在
+      // onBeforeFire 里就失败、宿主还没来得及自己记账的那种结局。凭据字段
+      // （apiKey / pushSubscription）照旧不透传。
+      metadata: decryptedPayload.metadata ?? null,
+      // 最后一轮 LLM 响应的 usage（prompt/completion tokens；没跑到 LLM →
+      // null）。宿主拿它更新用量记账，不用从 llmResponse 里自己扒。
+      usage: progress.usage,
       scratch,
       readState,
       writeState
@@ -1079,6 +1220,8 @@ async function runFireChain({
   writeState,
   scratch,
   scheduleTask,
+  cancelTask,
+  renewTask,
   fireCtx,
   progress
 }) {
@@ -1117,6 +1260,7 @@ async function runFireChain({
     );
     const assistantMessage = extractAssistantMessage(llmResponse);
     messages = [...messages, assistantMessage];
+    progress.usage = llmResponse && typeof llmResponse === "object" && llmResponse.usage || null;
     const sessionCtx = Object.freeze({
       ...buildSessionContext({
         sessionId,
@@ -1134,7 +1278,9 @@ async function runFireChain({
       occurrenceMs,
       readState,
       writeState,
-      scheduleTask
+      scheduleTask,
+      cancelTask,
+      renewTask
     });
     const decision = await hooks.onLLMOutput(sessionCtx);
     assertValidDecision(decision, { inlineToolCalls: true });
@@ -1233,7 +1379,8 @@ async function sendHookPushPayloads({
   const total = pushPayloads.length;
   let sentCount = 0;
   progress.total = total;
-  const afterSendBase = { task, total, scratch, readState, writeState };
+  const afterSendBase = { task, total, scratch, readState, writeState, usage: progress.usage };
+  const sentIds = [];
   try {
     if (!ctx.vapid || !ctx.vapid.email || !ctx.vapid.publicKey || !ctx.vapid.privateKey) {
       throw new Error("VAPID configuration missing - push notifications cannot be sent");
@@ -1241,9 +1388,11 @@ async function sendHookPushPayloads({
     const pushSubscription = await resolvePushSubscription({
       db: ctx.db,
       userId: task.user_id,
-      userKey
+      userKey,
+      legacyFallback: (decryptedPayload && decryptedPayload.pushSubscription) ?? null
     });
     const messageIdBase = task.id != null ? `msg_task_${task.id}${occurrenceSuffix(task)}` : `msg_${randomUUID()}`;
+    const finalized = [];
     for (let i = 0; i < total; i++) {
       const push = { ...pushPayloads[i] };
       if (typeof push.messageId !== "string" || !push.messageId) push.messageId = `${messageIdBase}_hook_${i}`;
@@ -1252,20 +1401,76 @@ async function sendHookPushPayloads({
       push.messageIndex = i + 1;
       push.totalMessages = total;
       stampTaskIdentity(push, task, decryptedPayload, occurrenceMs);
-      await ctx.webpush.sendNotification(pushSubscription, JSON.stringify(push));
+      finalized.push(push);
+    }
+    await appendPushesToOutbox({ db: ctx.db, userId: task.user_id, userKey, pushes: finalized });
+    for (let i = 0; i < total; i++) {
+      await ctx.webpush.sendNotification(pushSubscription, JSON.stringify(finalized[i]));
       sentCount++;
       progress.sentCount = sentCount;
+      sentIds.push(finalized[i].messageId);
       if (i < total - 1) await sleep(SLEEP_BETWEEN_MESSAGES_MS);
     }
   } catch (error) {
+    await markPushesDelivered({ db: ctx.db, userId: task.user_id, messageIds: sentIds });
     await notifyAfterSend(ctx, { ...afterSendBase, sentCount, error });
     throw error;
   }
+  await markPushesDelivered({ db: ctx.db, userId: task.user_id, messageIds: sentIds });
   await notifyAfterSend(ctx, { ...afterSendBase, sentCount, error: null });
   return total;
 }
 
+// src/server/lib/errors.js
+var NonRetryableError = class extends Error {
+  /**
+   * @param {string} message
+   * @param {{ code?: string, cause?: unknown }} [options]
+   */
+  constructor(message, options = {}) {
+    super(message, options.cause !== void 0 ? { cause: options.cause } : void 0);
+    this.name = "NonRetryableError";
+    this.permanent = true;
+    if (options.code) this.code = options.code;
+  }
+};
+function isNonRetryableError(error) {
+  return !!error && typeof error === "object" && /** @type {any} */
+  error.permanent === true;
+}
+function sanitizeErrorSummary(reason) {
+  let s = String(reason ?? "").replace(/\s+/g, " ").trim();
+  s = s.replace(/Bearer\s+[A-Za-z0-9._~+/=-]{8,}/gi, "Bearer [redacted]");
+  s = s.replace(/\b[A-Za-z]{2,6}-[A-Za-z0-9_-]{16,}/g, "[redacted]");
+  s = s.replace(/[A-Za-z0-9+/_.-]{48,}/g, "[redacted]");
+  if (s.length > 500) s = `${s.slice(0, 497)}\u2026`;
+  return s;
+}
+function summarizeErrorCause(error, stage) {
+  const raw = error && typeof error === "object" ? (
+    /** @type {any} */
+    error
+  ) : {};
+  const name = typeof raw.name === "string" && raw.name ? raw.name : "Error";
+  const rawMessage = typeof raw.message === "string" && raw.message ? raw.message : String(error ?? "");
+  const cause = {
+    stage,
+    name: sanitizeErrorSummary(name).slice(0, 100),
+    message: sanitizeErrorSummary(rawMessage)
+  };
+  if (typeof raw.code === "string" && raw.code) {
+    cause.code = sanitizeErrorSummary(raw.code).slice(0, 100);
+  }
+  return cause;
+}
+
 // src/server/lib/message-processor.js
+import {
+  buildContentPush,
+  buildReasoningPush,
+  readReasoningContent,
+  stripReasoningTags
+} from "@rei-standard/amsg-shared";
 var DEFAULT_SPLIT_REGEX = /([。！？!?]+)/;
 var SLEEP_BETWEEN_MESSAGES_MS2 = 1500;
 function splitOnceByRegex(chunk, regex) {
@@ -1287,14 +1492,14 @@ function splitMessageIntoSentences(messageContent, splitPattern = null) {
   }
   return chunks.length > 0 ? chunks : [messageContent];
 }
-async function processSingleMessage(task, ctx, providedMasterKey) {
+async function processSingleMessage(task, ctx, providedMasterKey, predecrypted = null) {
   try {
     const masterKey = providedMasterKey || ctx.masterKey;
     if (!masterKey) {
       return { success: false, messagesSent: 0, error: "TENANT_MASTER_KEY_MISSING" };
     }
-    const userKey = await deriveUserEncryptionKey(task.user_id, masterKey);
-    const decryptedPayload = JSON.parse(await decryptFromStorage(task.encrypted_payload, userKey));
+    const userKey = predecrypted && predecrypted.userKey || await deriveUserEncryptionKey(task.user_id, masterKey);
+    const decryptedPayload = predecrypted && predecrypted.payload || JSON.parse(await decryptFromStorage(task.encrypted_payload, userKey));
     if (ctx.hooks && typeof ctx.hooks.onBeforeFire === "function" && taskNeedsLlm(decryptedPayload)) {
       const agentic = await runAgenticFire({ task, decryptedPayload, userKey, ctx });
       if (agentic.handled) return agentic.result;
@@ -1329,7 +1534,12 @@ async function processSingleMessage(task, ctx, providedMasterKey) {
     if (!ctx.vapid.email || !ctx.vapid.publicKey || !ctx.vapid.privateKey) {
       throw new Error("VAPID configuration missing - push notifications cannot be sent");
     }
-    const pushSubscription = await resolvePushSubscription({ db: ctx.db, userId: task.user_id, userKey });
+    const pushSubscription = await resolvePushSubscription({
+      db: ctx.db,
+      userId: task.user_id,
+      userKey,
+      legacyFallback: decryptedPayload.pushSubscription ?? null
+    });
     const sessionId = task.id != null ? `sess_task_${task.id}${occurrenceSuffix(task)}` : `sess_${randomUUID()}`;
     const source = decryptedPayload.messageType === "instant" ? "instant" : "scheduled";
     const messageSubtype = decryptedPayload.messageSubtype || "chat";
@@ -1337,6 +1547,7 @@ async function processSingleMessage(task, ctx, providedMasterKey) {
     const metadata = decryptedPayload.metadata || {};
     const messageIdBase = task.id != null ? `msg_task_${task.id}${occurrenceSuffix(task)}` : `msg_${randomUUID()}_instant`;
     const occurrenceMs = occurrenceMsOf(task);
+    const pushesToSend = [];
     if (reasoning) {
       const reasoningPush = buildReasoningPush({
         messageType: decryptedPayload.messageType,
@@ -1352,8 +1563,7 @@ async function processSingleMessage(task, ctx, providedMasterKey) {
         metadata
       });
       stampTaskIdentity(reasoningPush, task, decryptedPayload, occurrenceMs);
-      await ctx.webpush.sendNotification(pushSubscription, JSON.stringify(reasoningPush));
-      await new Promise((resolve) => setTimeout(resolve, SLEEP_BETWEEN_MESSAGES_MS2));
+      pushesToSend.push(reasoningPush);
     }
     for (let i = 0; i < messages.length; i++) {
       const contentPush = buildContentPush({
@@ -1372,14 +1582,30 @@ async function processSingleMessage(task, ctx, providedMasterKey) {
         metadata
       });
       stampTaskIdentity(contentPush, task, decryptedPayload, occurrenceMs);
-      await ctx.webpush.sendNotification(pushSubscription, JSON.stringify(contentPush));
-      if (i < messages.length - 1) {
-        await new Promise((resolve) => setTimeout(resolve, SLEEP_BETWEEN_MESSAGES_MS2));
+      pushesToSend.push(contentPush);
+    }
+    await appendPushesToOutbox({ db: ctx.db, userId: task.user_id, userKey, pushes: pushesToSend });
+    const sentIds = [];
+    try {
+      for (let i = 0; i < pushesToSend.length; i++) {
+        await ctx.webpush.sendNotification(pushSubscription, JSON.stringify(pushesToSend[i]));
+        sentIds.push(pushesToSend[i].messageId);
+        if (i < pushesToSend.length - 1) {
+          await new Promise((resolve) => setTimeout(resolve, SLEEP_BETWEEN_MESSAGES_MS2));
+        }
       }
+    } finally {
+      await markPushesDelivered({ db: ctx.db, userId: task.user_id, messageIds: sentIds });
     }
     return { success: true, messagesSent: messages.length };
   } catch (error) {
-    return { success: false, messagesSent: 0, error: error.message };
+    return {
+      success: false,
+      messagesSent: 0,
+      error: error.message,
+      errorCode: error.code || null,
+      permanent: isNonRetryableError(error)
+    };
   }
 }
 async function processMessagesByUuid(uuid, ctx, maxRetries = 2, userId, providedMasterKey) {
@@ -1411,18 +1637,35 @@ async function processMessagesByUuid(uuid, ctx, maxRetries = 2, userId, provided
     }
     const result = await processSingleMessage(task, ctx, masterKey);
     if (!result.success) {
-      if (retryCount < maxRetries) {
+      if (!result.permanent && retryCount < maxRetries) {
         retryCount++;
         await new Promise((resolve) => setTimeout(resolve, 1e3 * retryCount));
         continue;
       }
       try {
-        await ctx.db.updateTaskById(task.id, { status: "failed", retry_count: retryCount });
+        await ctx.db.updateTaskById(task.id, {
+          status: "failed",
+          retry_count: retryCount,
+          last_error: JSON.stringify({
+            at: (/* @__PURE__ */ new Date()).toISOString(),
+            occurrence: task.next_send_at ?? null,
+            reason: sanitizeErrorSummary(result.error)
+          })
+        });
       } catch (_updateError) {
+        try {
+          await ctx.db.updateTaskById(task.id, { status: "failed", retry_count: retryCount });
+        } catch (_retryError) {
+        }
       }
       return {
         success: false,
-        error: { code: "PROCESSING_ERROR", message: result.error, retriesAttempted: retryCount }
+        error: {
+          code: "PROCESSING_ERROR",
+          message: result.error,
+          retriesAttempted: retryCount,
+          ...result.permanent ? { permanent: true } : {}
+        }
       };
     }
     try {
@@ -1457,16 +1700,12 @@ function createScheduleMessageHandler(ctx) {
     const masterKey = tenantCtx.masterKey;
     const isEncrypted = getHeader(headers, "x-payload-encrypted") === "true";
     const encryptionVersion = getHeader(headers, "x-encryption-version");
-    const userId = getHeader(headers, "x-user-id");
     if (!isEncrypted) {
       return { status: 400, body: { success: false, error: { code: "ENCRYPTION_REQUIRED", message: "\u8BF7\u6C42\u4F53\u5FC5\u987B\u52A0\u5BC6" } } };
     }
-    if (!userId) {
-      return { status: 400, body: { success: false, error: { code: "USER_ID_REQUIRED", message: "\u7F3A\u5C11\u7528\u6237\u6807\u8BC6\u7B26" } } };
-    }
-    if (!isValidUUIDv4(userId)) {
-      return { status: 400, body: { success: false, error: { code: "INVALID_USER_ID_FORMAT", message: "X-User-Id \u5FC5\u987B\u662F UUID v4 \u683C\u5F0F" } } };
-    }
+    const gate = requireUserId(headers);
+    if (gate.error) return gate.error;
+    const { userId } = gate;
     if (encryptionVersion !== "1") {
       return { status: 400, body: { success: false, error: { code: "UNSUPPORTED_ENCRYPTION_VERSION", message: "\u52A0\u5BC6\u7248\u672C\u4E0D\u652F\u6301" } } };
     }
@@ -1495,13 +1734,22 @@ function createScheduleMessageHandler(ctx) {
     if (!supportsPushSubscriptionStore(db)) {
       return { status: 501, body: { success: false, error: { code: "PUSH_SUBSCRIPTION_NOT_SUPPORTED", message: "\u5F53\u524D\u6570\u636E\u5E93\u9002\u914D\u5668\u4E0D\u652F\u6301\u7528\u6237\u7EA7\u63A8\u9001\u8BA2\u9605\u5B58\u50A8" } } };
     }
-    let storedSubscription = null;
+    let subscriptionRow;
     try {
-      storedSubscription = await loadPushSubscription({ db, userId, userKey });
+      subscriptionRow = await db.getPushSubscription(userId);
     } catch (_error) {
-      storedSubscription = null;
+      return {
+        status: 503,
+        body: {
+          success: false,
+          error: {
+            code: "PUSH_SUBSCRIPTION_LOOKUP_FAILED",
+            message: "\u63A8\u9001\u8BA2\u9605\u8BFB\u53D6\u5931\u8D25\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5"
+          }
+        }
+      };
     }
-    if (!storedSubscription) {
+    if (!subscriptionRow || typeof subscriptionRow.subscription !== "string" || !subscriptionRow.subscription) {
       return {
         status: 409,
         body: {
@@ -1514,13 +1762,14 @@ function createScheduleMessageHandler(ctx) {
       };
     }
     const taskUuid = payload.uuid || randomUUID();
+    const effectiveSendTime = payload.immediate === true ? (/* @__PURE__ */ new Date()).toISOString() : payload.firstSendTime;
     const fullTaskData = {
       contactName: payload.contactName,
       avatarUrl: payload.avatarUrl || null,
       messageType: payload.messageType,
       messageSubtype: payload.messageSubtype || "chat",
       userMessage: payload.userMessage || null,
-      firstSendTime: payload.firstSendTime,
+      firstSendTime: effectiveSendTime,
       recurrenceType: payload.recurrenceType || "none",
       // daily / weekly 按这个时区的墙钟推进（同一钟点，日期 +1 天 / +7 天）。
       // 不传 → null → 按 UTC 推进。
@@ -1539,6 +1788,9 @@ function createScheduleMessageHandler(ctx) {
       // the message processor to chunk LLM output into individual pushes.
       // null → processor falls back to the default /([。！？!?]+)/ regex.
       splitPattern: payload.splitPattern ?? null,
+      // 透传给 LLM 中转的非标准参数（thinking 之类），buildLlmRequestBody 会
+      // 把它展开进请求体（核心字段优先）。
+      llmExtraBody: payload.llmExtraBody ?? null,
       metadata: payload.metadata || {}
     };
     const encryptedPayload = await encryptForStorage(JSON.stringify(fullTaskData), userKey);
@@ -1563,15 +1815,26 @@ function createScheduleMessageHandler(ctx) {
         };
       }
     }
+    const createParams = {
+      user_id: userId,
+      uuid: taskUuid,
+      encrypted_payload: encryptedPayload,
+      next_send_at: effectiveSendTime,
+      message_type: payload.messageType
+    };
+    const supersedesUuid = payload.supersedesUuid || null;
+    let superseded = false;
     let dbResult;
     try {
-      dbResult = await db.createTask({
-        user_id: userId,
-        uuid: taskUuid,
-        encrypted_payload: encryptedPayload,
-        next_send_at: payload.firstSendTime,
-        message_type: payload.messageType
-      });
+      if (supersedesUuid && typeof db.createTaskSuperseding === "function") {
+        dbResult = await db.createTaskSuperseding(createParams, supersedesUuid);
+        superseded = !!(dbResult && dbResult.superseded);
+      } else {
+        if (supersedesUuid) {
+          superseded = await db.deleteTaskByUuid(supersedesUuid, userId);
+        }
+        dbResult = await db.createTask(createParams);
+      }
     } catch (error) {
       if (isUniqueViolation(error)) {
         return {
@@ -1610,7 +1873,8 @@ function createScheduleMessageHandler(ctx) {
               messagesSent: sendResult.messagesSent,
               sentAt: (/* @__PURE__ */ new Date()).toISOString(),
               status: "sent",
-              retriesUsed: sendResult.retriesUsed || 0
+              retriesUsed: sendResult.retriesUsed || 0,
+              ...supersedesUuid ? { superseded } : {}
             }
           }
         };
@@ -1628,7 +1892,10 @@ function createScheduleMessageHandler(ctx) {
           contactName: payload.contactName,
           nextSendAt: dbResult.next_send_at,
           status: dbResult.status,
-          createdAt: dbResult.created_at
+          createdAt: dbResult.created_at,
+          // supersede 的结果：true = 旧行确实被取消了；false = 旧行本就不存在
+          // （已发出 / 已删除），新任务照常建立。
+          ...supersedesUuid ? { superseded } : {}
         }
       }
     };
@@ -1639,7 +1906,12 @@ function createScheduleMessageHandler(ctx) {
 // src/server/lib/run-tick.js
 var DEFAULT_CLAIM_LEASE_MS = 10 * 60 * 1e3;
 var CLAIM_LEASE_MARGIN_MS = 2 * 60 * 1e3;
+var DEFAULT_LEASE_HEARTBEAT_MS = 30 * 1e3;
+var DEFAULT_HEARTBEAT_LEASE_TTL_MS = 90 * 1e3;
 var STALE_AFTER_MS = 60 * 60 * 1e3;
+function resolveStaleAfterMs(ctx) {
+  return positiveNumber(ctx.staleAfterMs) || STALE_AFTER_MS;
+}
 function isRecurringType(recurrenceType) {
   return recurrenceType === "daily" || recurrenceType === "weekly";
 }
@@ -1653,12 +1925,53 @@ async function deriveSerializeGroup(userKey, rawKey) {
   return bytesToBase64Url(await hmacSha256(utf8(userKey), utf8(rawKey)));
 }
 async function runScheduledTick(ctx) {
+  const tasks = await ctx.db.getPendingTasks(50);
+  const summary = await deliverTasks(ctx, tasks);
+  await ctx.db.cleanupOldTasks(7);
+  if (typeof ctx.db.cleanupOutbox === "function") {
+    try {
+      await ctx.db.cleanupOutbox({
+        ackedBeforeMs: Date.now() - 7 * 24 * 60 * 60 * 1e3,
+        allBeforeMs: Date.now() - 28 * 24 * 60 * 60 * 1e3
+      });
+    } catch (error) {
+      console.warn("[amsg-server] cleanupOutbox \u5931\u8D25\uFF08\u5DF2\u5FFD\u7565\uFF09:", error && error.message);
+    }
+  }
+  return summary;
+}
+async function runTask(ctx, uuid) {
+  if (typeof uuid !== "string" || !uuid.trim()) {
+    throw new TypeError("runTask(ctx, uuid) requires a non-empty uuid string");
+  }
+  const task = await ctx.db.getTaskByUuidOnly(uuid);
+  if (!task) {
+    if (typeof ctx.db.getTaskStatusByUuidOnly === "function") {
+      const settled = await ctx.db.getTaskStatusByUuidOnly(uuid);
+      if (settled) return { ran: false, reason: "already_settled", status: settled.status };
+    }
+    return { ran: false, reason: "not_found" };
+  }
+  const dueMs = Date.parse(task.next_send_at);
+  if (Number.isFinite(dueMs) && dueMs > Date.now()) {
+    return { ran: false, reason: "not_due", nextSendAt: task.next_send_at };
+  }
+  const retryAfterMs = task.retry_after ? Date.parse(task.retry_after) : NaN;
+  if (Number.isFinite(retryAfterMs) && retryAfterMs > Date.now()) {
+    return { ran: false, reason: "retry_pending", retryAfter: task.retry_after };
+  }
+  return { ran: true, summary: await deliverTasks(ctx, [task]) };
+}
+async function deliverTasks(ctx, tasks) {
   const db = ctx.db;
   const masterKey = ctx.masterKey;
   const claimLeaseMs = resolveClaimLeaseMs(ctx);
+  const staleAfterMs = resolveStaleAfterMs(ctx);
   const serializeBy = typeof ctx.serializeBy === "function" ? ctx.serializeBy : null;
+  const heartbeatMs = ctx.leaseHeartbeatMs === 0 ? 0 : positiveNumber(ctx.leaseHeartbeatMs) || DEFAULT_LEASE_HEARTBEAT_MS;
+  const heartbeatEnabled = heartbeatMs > 0 && typeof db.claimTask === "function" && typeof db.renewTaskLease === "function";
+  const heartbeatLeaseTtlMs = Math.max(DEFAULT_HEARTBEAT_LEASE_TTL_MS, heartbeatMs * 2);
   const startTime = Date.now();
-  const tasks = await db.getPendingTasks(50);
   const MAX_CONCURRENT = 8;
   const results = {
     totalTasks: tasks.length,
@@ -1675,11 +1988,57 @@ async function runScheduledTick(ctx) {
   const supportsClaim = typeof db.claimTask === "function";
   async function claimForThisTick(task, serializeGroup) {
     if (!supportsClaim) return true;
-    const leaseUntil = new Date(Date.now() + claimLeaseMs).toISOString();
+    const leaseUntil = new Date(
+      Date.now() + (heartbeatEnabled ? heartbeatLeaseTtlMs : claimLeaseMs)
+    ).toISOString();
     return !!await db.claimTask(task.id, task.next_send_at, leaseUntil, serializeGroup);
   }
+  function startLeaseHeartbeat(task) {
+    if (!heartbeatEnabled) return () => {
+    };
+    let stopped = false;
+    let timer = null;
+    const beat = async () => {
+      if (stopped) return;
+      try {
+        await db.renewTaskLease(task.id, new Date(Date.now() + heartbeatLeaseTtlMs).toISOString());
+      } catch (error) {
+        console.warn("[amsg-server] \u79DF\u7EA6\u7EED\u79DF\u5931\u8D25\uFF08\u4E0B\u4E2A\u5FC3\u8DF3\u518D\u8BD5\uFF09:", error && error.message);
+      }
+      if (!stopped) schedule();
+    };
+    const schedule = () => {
+      timer = setTimeout(beat, heartbeatMs);
+      if (timer && typeof timer.unref === "function") timer.unref();
+    };
+    schedule();
+    return () => {
+      stopped = true;
+      if (timer) clearTimeout(timer);
+    };
+  }
+  const supportsLastError = supportsClaim;
+  async function updateTaskWithLastError(taskId, fields) {
+    try {
+      return await db.updateTaskById(taskId, fields);
+    } catch (error) {
+      if (Object.prototype.hasOwnProperty.call(fields, "last_error") && /last_error/i.test(error.message || "")) {
+        const { last_error: _omit, ...rest } = fields;
+        return db.updateTaskById(taskId, rest);
+      }
+      throw error;
+    }
+  }
+  function lastErrorJson(task, reason, extra) {
+    return JSON.stringify({
+      at: (/* @__PURE__ */ new Date()).toISOString(),
+      occurrence: task.next_send_at ?? null,
+      reason: sanitizeErrorSummary(reason),
+      ...extra || {}
+    });
+  }
   async function updateAndRelease(taskId, fields) {
-    return db.updateTaskById(
+    return updateTaskWithLastError(
       taskId,
       supportsClaim ? { ...fields, lease_until: null, retry_after: null } : fields
     );
@@ -1703,8 +2062,9 @@ async function runScheduledTick(ctx) {
       return { taken: true, rawKey: null };
     }
     if (typeof rawKey !== "string" || !rawKey) return { taken: false, rawKey: null };
-    if (groupsTakenThisTick.has(rawKey)) return { taken: true, rawKey };
-    groupsTakenThisTick.add(rawKey);
+    const scopedKey = `${task.user_id}\0${rawKey}`;
+    if (groupsTakenThisTick.has(scopedKey)) return { taken: true, rawKey };
+    groupsTakenThisTick.add(scopedKey);
     return { taken: false, rawKey };
   }
   async function encryptPayloadWithLastError(task, decryptedPayload, userKey, reason, extra) {
@@ -1731,34 +2091,38 @@ async function runScheduledTick(ctx) {
       console.warn("[amsg-server] onStaleSkip hook \u629B\u9519\uFF08\u5DF2\u5FFD\u7565\uFF09:", hookError && hookError.message);
     }
   }
-  async function handleDeliveryFailure(task, reason, recurrenceType, decryptedPayload, userKey) {
+  async function handleDeliveryFailure(task, reason, recurrenceType, decryptedPayload, userKey, errorCode = null, permanentFlag = false) {
     results.failedCount++;
     const tzId = decryptedPayload ? decryptedPayload.tzId ?? null : null;
+    const permanent = permanentFlag === true || errorCode === "PUSH_SUBSCRIPTION_MISSING" || errorCode === "PUSH_SUBSCRIPTION_STORE_UNSUPPORTED";
     try {
-      if (task.retry_count >= 3) {
+      if (permanent || task.retry_count >= 3) {
         const encrypted = await encryptPayloadWithLastError(task, decryptedPayload, userKey, reason);
         if (isRecurringType(recurrenceType)) {
           const nextSendAt = nextFutureOccurrence(Date.parse(task.next_send_at), recurrenceType, Date.now(), tzId);
           await updateAndRelease(task.id, {
             next_send_at: nextSendAt,
             retry_count: 0,
-            ...encrypted ? { encrypted_payload: encrypted } : {}
+            ...encrypted ? { encrypted_payload: encrypted } : {},
+            ...supportsLastError ? { last_error: lastErrorJson(task, reason) } : {}
           });
-          results.failedTasks.push({ taskId: task.id, reason, retryCount: task.retry_count, status: "occurrence_skipped", nextSendAt });
+          results.failedTasks.push({ taskId: task.id, reason, retryCount: task.retry_count, status: "occurrence_skipped", nextSendAt, ...permanent ? { permanent: true } : {} });
         } else {
           await updateAndRelease(task.id, {
             status: "failed",
-            ...encrypted ? { encrypted_payload: encrypted } : {}
+            ...encrypted ? { encrypted_payload: encrypted } : {},
+            ...supportsLastError ? { last_error: lastErrorJson(task, reason) } : {}
           });
-          results.failedTasks.push({ taskId: task.id, reason, retryCount: task.retry_count, status: "permanently_failed" });
+          results.failedTasks.push({ taskId: task.id, reason, retryCount: task.retry_count, status: "permanently_failed", ...permanent ? { permanent: true } : {} });
         }
       } else {
         const nextRetryTime = new Date(Date.now() + (task.retry_count + 1) * 2 * 60 * 1e3);
         if (supportsClaim) {
-          await db.updateTaskById(task.id, {
+          await updateTaskWithLastError(task.id, {
             retry_after: nextRetryTime.toISOString(),
             lease_until: null,
-            retry_count: task.retry_count + 1
+            retry_count: task.retry_count + 1,
+            ...supportsLastError ? { last_error: lastErrorJson(task, reason) } : {}
           });
         } else {
           await db.updateTaskById(task.id, { next_send_at: nextRetryTime.toISOString(), retry_count: task.retry_count + 1 });
@@ -1819,6 +2183,16 @@ async function runScheduledTick(ctx) {
       results.claimSkippedTasks++;
       return;
     }
+    const stopHeartbeat = startLeaseHeartbeat(task);
+    try {
+      await deliverClaimedTask(task, decrypted);
+    } finally {
+      stopHeartbeat();
+    }
+  }
+  async function deliverClaimedTask(task, decrypted) {
+    const decryptedPayload = decrypted.ok ? decrypted.payload : null;
+    const userKey = decrypted.ok ? decrypted.userKey : null;
     if (!decrypted.ok) {
       await handleDeliveryFailure(task, decrypted.error && decrypted.error.message || "\u4EFB\u52A1\u8F7D\u8377\u89E3\u5BC6\u5931\u8D25", null, null, null);
       return;
@@ -1826,7 +2200,9 @@ async function runScheduledTick(ctx) {
     const recurrenceType = decryptedPayload.recurrenceType;
     const tzId = decryptedPayload.tzId ?? null;
     const occurrenceMs = Date.parse(task.next_send_at);
-    if (Number.isFinite(occurrenceMs) && Date.now() - occurrenceMs > STALE_AFTER_MS && (task.retry_count || 0) === 0) {
+    const retryAfterMs = task.retry_after ? Date.parse(task.retry_after) : NaN;
+    const notOnFreshRetryChain = (task.retry_count || 0) === 0 || Number.isFinite(retryAfterMs) && Date.now() - retryAfterMs > staleAfterMs;
+    if (Number.isFinite(occurrenceMs) && Date.now() - occurrenceMs > staleAfterMs && notOnFreshRetryChain) {
       try {
         const stateAccessors = createStateAccessors({
           db,
@@ -1834,57 +2210,42 @@ async function runScheduledTick(ctx) {
           userKey,
           maxStateValueBytes: ctx.maxStateValueBytes
         });
-        if (isRecurringType(recurrenceType)) {
-          const plan = planNextOccurrence(occurrenceMs, recurrenceType, Date.now(), tzId);
-          const nextSendAt = new Date(plan.nextMs).toISOString();
-          const encrypted = await encryptPayloadWithLastError(task, decryptedPayload, userKey, "stale", {
-            skippedCount: plan.skippedCount,
-            nextSendAt
-          });
-          await updateAndRelease(task.id, {
-            next_send_at: nextSendAt,
-            retry_count: 0,
-            ...encrypted ? { encrypted_payload: encrypted } : {}
-          });
-          results.staleTasks.push({
-            taskId: task.id,
-            reason: "stale",
-            action: "fast_forwarded",
-            nextSendAt,
-            skippedCount: plan.skippedCount
-          });
-          await notifyStaleSkip(task, {
-            reason: "stale",
-            action: "fast_forwarded",
-            metadata: decryptedPayload.metadata ?? null,
-            recurrenceType,
-            occurrenceMs,
-            skippedCount: plan.skippedCount,
-            skippedOccurrences: plan.skippedOccurrences,
-            skippedTruncated: plan.skippedTruncated,
-            nextSendAt,
-            ...stateAccessors
-          });
-        } else {
-          const encrypted = await encryptPayloadWithLastError(task, decryptedPayload, userKey, "stale");
-          await updateAndRelease(task.id, {
-            status: "failed",
-            ...encrypted ? { encrypted_payload: encrypted } : {}
-          });
-          results.staleTasks.push({ taskId: task.id, reason: "stale", action: "expired", skippedCount: 1 });
-          await notifyStaleSkip(task, {
-            reason: "stale",
-            action: "expired",
-            metadata: decryptedPayload.metadata ?? null,
-            recurrenceType: recurrenceType || "none",
-            occurrenceMs,
-            skippedCount: 1,
-            skippedOccurrences: [occurrenceMs],
-            skippedTruncated: false,
-            nextSendAt: null,
-            ...stateAccessors
-          });
-        }
+        const recurring = isRecurringType(recurrenceType);
+        const plan = recurring ? planNextOccurrence(occurrenceMs, recurrenceType, Date.now(), tzId) : null;
+        const nextSendAt = recurring ? new Date(plan.nextMs).toISOString() : null;
+        const action = recurring ? "fast_forwarded" : "expired";
+        const skippedCount = recurring ? plan.skippedCount : 1;
+        const encrypted = await encryptPayloadWithLastError(
+          task,
+          decryptedPayload,
+          userKey,
+          "stale",
+          recurring ? { skippedCount, nextSendAt } : void 0
+        );
+        await updateAndRelease(task.id, {
+          ...recurring ? { next_send_at: nextSendAt, retry_count: 0 } : { status: "failed" },
+          ...encrypted ? { encrypted_payload: encrypted } : {},
+          ...supportsLastError ? { last_error: lastErrorJson(task, "stale", recurring ? { skippedCount, nextSendAt } : void 0) } : {}
+        });
+        results.staleTasks.push({
+          taskId: task.id,
+          reason: "stale",
+          action,
+          ...recurring ? { nextSendAt } : {},
+          skippedCount
+        });
+        await notifyStaleSkip(task, {
+          reason: "stale",
+          action,
+          metadata: decryptedPayload.metadata ?? null,
+          recurrenceType: recurrenceType || "none",
+          occurrenceMs,
+          skippedCount,
+          skippedOccurrences: recurring ? plan.skippedOccurrences : [occurrenceMs],
+          skippedTruncated: recurring ? plan.skippedTruncated : false,
+          nextSendAt,
+          ...stateAccessors
+        });
       } catch (error) {
         results.failedCount++;
         results.failedTasks.push({ taskId: task.id, reason: error.message || "\u8FC7\u671F\u4EFB\u52A1\u5904\u7406\u5931\u8D25", status: "stale_update_failed" });
@@ -1893,13 +2254,34 @@ async function runScheduledTick(ctx) {
     }
     let sendResult;
     try {
-      sendResult = await processSingleMessage(task, { ...ctx, db, masterKey }, masterKey);
+      sendResult = await processSingleMessage(
+        task,
+        { ...ctx, db, masterKey },
+        masterKey,
+        { userKey, payload: decryptedPayload }
+      );
     } catch (error) {
-      await handleDeliveryFailure(task, error.message || "\u6D88\u606F\u53D1\u9001\u5931\u8D25", recurrenceType, decryptedPayload, userKey);
+      await handleDeliveryFailure(
+        task,
+        error.message || "\u6D88\u606F\u53D1\u9001\u5931\u8D25",
+        recurrenceType,
+        decryptedPayload,
+        userKey,
+        error.code || null,
+        error.permanent === true
+      );
       return;
     }
     if (!sendResult.success) {
-      await handleDeliveryFailure(task, sendResult.error || "\u6D88\u606F\u53D1\u9001\u5931\u8D25", recurrenceType, decryptedPayload, userKey);
+      await handleDeliveryFailure(
+        task,
+        sendResult.error || "\u6D88\u606F\u53D1\u9001\u5931\u8D25",
+        recurrenceType,
+        decryptedPayload,
+        userKey,
+        sendResult.errorCode || null,
+        sendResult.permanent === true
+      );
       return;
     }
     try {
@@ -1908,7 +2290,11 @@ async function runScheduledTick(ctx) {
         results.deletedOnceOffTasks++;
       } else {
         const nextSendAt = nextFutureOccurrence(occurrenceMs, recurrenceType, Date.now(), tzId);
-        await updateAndRelease(task.id, { next_send_at: nextSendAt, retry_count: 0 });
+        await updateAndRelease(task.id, {
+          next_send_at: nextSendAt,
+          retry_count: 0,
+          ...supportsLastError ? { last_error: null } : {}
+        });
         results.updatedRecurringTasks++;
       }
       results.successCount++;
@@ -1941,7 +2327,6 @@ async function runScheduledTick(ctx) {
       await Promise.race(processing);
     }
   }
-  await db.cleanupOldTasks(7);
   const executionTime = Date.now() - startTime;
   return {
     totalTasks: results.totalTasks,
@@ -1977,13 +2362,9 @@ function createUpdateMessageHandler(ctx) {
     if (!taskUuid) {
       return { status: 400, body: { success: false, error: { code: "TASK_ID_REQUIRED", message: "\u7F3A\u5C11\u4EFB\u52A1ID" } } };
     }
-    const userId = getHeader(headers, "x-user-id");
-    if (!userId) {
-      return { status: 400, body: { success: false, error: { code: "USER_ID_REQUIRED", message: "\u7F3A\u5C11\u7528\u6237\u6807\u8BC6\u7B26" } } };
-    }
-    if (!isValidUUIDv4(userId)) {
-      return { status: 400, body: { success: false, error: { code: "INVALID_USER_ID_FORMAT", message: "X-User-Id \u5FC5\u987B\u662F UUID v4 \u683C\u5F0F" } } };
-    }
+    const gate = requireUserId(headers);
+    if (gate.error) return gate.error;
+    const { userId } = gate;
     const isEncrypted = getHeader(headers, "x-payload-encrypted") === "true";
     const encryptionVersion = getHeader(headers, "x-encryption-version");
     if (!isEncrypted) {
@@ -2092,7 +2473,11 @@ function createUpdateMessageHandler(ctx) {
       ...Object.prototype.hasOwnProperty.call(updates, "splitPattern") && { splitPattern: updates.splitPattern ?? null }
     };
     const encryptedPayload = await encryptForStorage(JSON.stringify(updatedData), userKey);
-    const extraFields = updates.nextSendAt ? { next_send_at: updates.nextSendAt } : void 0;
+    const extraFields = {
+      retry_count: 0,
+      ...typeof db.claimTask === "function" ? { retry_after: null } : {},
+      ...updates.nextSendAt ? { next_send_at: updates.nextSendAt } : {}
+    };
     const result = await db.updateTaskByUuid(taskUuid, userId, encryptedPayload, extraFields);
     if (!result) {
       return { status: 409, body: { success: false, error: { code: "UPDATE_CONFLICT", message: "\u4EFB\u52A1\u66F4\u65B0\u5931\u8D25\uFF0C\u4EFB\u52A1\u53EF\u80FD\u5DF2\u88AB\u4FEE\u6539\u6216\u5220\u9664" } } };
@@ -2125,13 +2510,9 @@ function createCancelMessageHandler(ctx) {
     if (!taskUuid) {
       return { status: 400, body: { success: false, error: { code: "TASK_ID_REQUIRED", message: "\u7F3A\u5C11\u4EFB\u52A1ID" } } };
     }
-    const userId = getHeader(headers, "x-user-id");
-    if (!userId) {
-      return { status: 400, body: { success: false, error: { code: "USER_ID_REQUIRED", message: "\u7F3A\u5C11\u7528\u6237\u6807\u8BC6\u7B26" } } };
-    }
-    if (!isValidUUIDv4(userId)) {
-      return { status: 400, body: { success: false, error: { code: "INVALID_USER_ID_FORMAT", message: "X-User-Id \u5FC5\u987B\u662F UUID v4 \u683C\u5F0F" } } };
-    }
+    const gate = requireUserId(headers);
+    if (gate.error) return gate.error;
+    const { userId } = gate;
     const deleted = await db.deleteTaskByUuid(taskUuid, userId);
     if (!deleted) {
       return {
@@ -2160,19 +2541,9 @@ function createMessagesHandler(ctx) {
     const tenantCtx = tenantResult.context;
     const db = tenantCtx.db;
     const masterKey = tenantCtx.masterKey;
-    const userId = getHeader(headers, "x-user-id");
-    if (!userId) {
-      return {
-        status: 400,
-        body: { success: false, error: { code: "USER_ID_REQUIRED", message: "\u5FC5\u987B\u63D0\u4F9B X-User-Id \u8BF7\u6C42\u5934" } }
-      };
-    }
-    if (!isValidUUIDv4(userId)) {
-      return {
-        status: 400,
-        body: { success: false, error: { code: "INVALID_USER_ID_FORMAT", message: "X-User-Id \u5FC5\u987B\u662F UUID v4 \u683C\u5F0F" } }
-      };
-    }
+    const gate = requireUserId(headers);
+    if (gate.error) return gate.error;
+    const { userId } = gate;
     const u = new URL(url, "https://dummy");
     const status = u.searchParams.get("status") || "all";
     const limit = Math.min(parseInt(u.searchParams.get("limit") || "20", 10), 100);
@@ -2217,30 +2588,39 @@ function createGetMessageHandler(ctx) {
     const tenantCtx = tenantResult.context;
     const db = tenantCtx.db;
     const masterKey = tenantCtx.masterKey;
-    const userId = getHeader(headers, "x-user-id");
-    if (!userId) {
-      return {
-        status: 400,
-        body: { success: false, error: { code: "USER_ID_REQUIRED", message: "\u5FC5\u987B\u63D0\u4F9B X-User-Id \u8BF7\u6C42\u5934" } }
-      };
-    }
-    if (!isValidUUIDv4(userId)) {
-      return {
-        status: 400,
-        body: { success: false, error: { code: "INVALID_USER_ID_FORMAT", message: "X-User-Id \u5FC5\u987B\u662F UUID v4 \u683C\u5F0F" } }
-      };
-    }
+    const gate = requireUserId(headers);
+    if (gate.error) return gate.error;
+    const { userId } = gate;
     const taskUuid = new URL(url, "https://dummy").searchParams.get("id");
     if (!taskUuid) {
       return { status: 400, body: { success: false, error: { code: "TASK_ID_REQUIRED", message: "\u7F3A\u5C11\u4EFB\u52A1ID" } } };
     }
     const row = await db.getTaskByUuid(taskUuid, userId);
     if (!row) {
-      const taskStatus = await db.getTaskStatus(taskUuid, userId);
+      const statusInfo = typeof db.getTaskStatusInfo === "function" ? await db.getTaskStatusInfo(taskUuid, userId) : null;
+      const taskStatus = statusInfo ? statusInfo.status : await db.getTaskStatus(taskUuid, userId);
       if (!taskStatus) {
         return { status: 404, body: { success: false, error: { code: "TASK_NOT_FOUND", message: "\u6307\u5B9A\u7684\u4EFB\u52A1\u4E0D\u5B58\u5728\u6216\u5DF2\u88AB\u5220\u9664" } } };
       }
-      return { status: 409, body: { success: false, error: { code: "TASK_ALREADY_COMPLETED", message: "\u4EFB\u52A1\u5DF2\u5B8C\u6210\u6216\u5DF2\u5931\u8D25\uFF0C\u65E0\u6CD5\u66F4\u65B0" } } };
+      let lastError = null;
+      if (statusInfo && statusInfo.last_error) {
+        try {
+          lastError = JSON.parse(statusInfo.last_error);
+        } catch (_parseError) {
+          lastError = { reason: statusInfo.last_error };
+        }
+      }
+      return {
+        status: 409,
+        body: {
+          success: false,
+          error: {
+            code: "TASK_ALREADY_COMPLETED",
+            message: "\u4EFB\u52A1\u5DF2\u5B8C\u6210\u6216\u5DF2\u5931\u8D25\uFF0C\u65E0\u6CD5\u66F4\u65B0",
+            details: { status: taskStatus, lastError }
+          }
+        }
+      };
     }
     const userKey = await deriveUserEncryptionKey(userId, masterKey);
     const decrypted = JSON.parse(await decryptFromStorage(row.encrypted_payload, userKey));
@@ -2263,12 +2643,6 @@ function err(status, code, message, details) {
   const error = details === void 0 ? { code, message } : { code, message, details };
   return { status, body: { success: false, error } };
 }
-function requireUserId(headers) {
-  const userId = getHeader(headers, "x-user-id");
-  if (!userId) return { error: err(400, "USER_ID_REQUIRED", "\u7F3A\u5C11\u7528\u6237\u6807\u8BC6\u7B26") };
-  if (!isValidUUIDv4(userId)) return { error: err(400, "INVALID_USER_ID_FORMAT", "X-User-Id \u5FC5\u987B\u662F UUID v4 \u683C\u5F0F") };
-  return { userId };
-}
 var UNSUPPORTED = err(
   501,
   "PUSH_SUBSCRIPTION_NOT_SUPPORTED",
@@ -2376,6 +2750,7 @@ var SQLITE_TABLE_SQL = `
     serialize_group TEXT,
     status TEXT NOT NULL DEFAULT 'pending' CHECK (status IN ('pending', 'sent', 'failed')),
     retry_count INTEGER NOT NULL DEFAULT 0,
+    last_error TEXT,
     created_at TEXT NOT NULL,
     updated_at TEXT NOT NULL
   )
@@ -2395,6 +2770,14 @@ var SQLITE_MIGRATIONS = [
     name: "add_serialize_group",
     sql: "ALTER TABLE scheduled_messages ADD COLUMN serialize_group TEXT",
     description: "Serialization group for runScheduledTick serializeBy (2.6.0)"
+  },
+  {
+    name: "add_last_error",
+    // 上一次投递失败的脱敏摘要（JSON：{ at, occurrence, reason }）。payload 里
+    // 的 lastError 是密文里的完整记录，这一列是它的明文出口——payload 本身
+    // 解密失败时也写得进去，GET /message 对已失败的行也读得出来。
+    sql: "ALTER TABLE scheduled_messages ADD COLUMN last_error TEXT",
+    description: "Sanitized last delivery-failure summary (2.6.0)"
   }
 ];
 var SQLITE_INDEXES = [
@@ -2463,22 +2846,64 @@ var PUSH_SUBSCRIPTION_TABLE_SQL = `
     updated_at INTEGER NOT NULL
   )
 `;
+var MESSAGE_OUTBOX_TABLE_SQL = `
+  CREATE TABLE IF NOT EXISTS message_outbox (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    user_id TEXT NOT NULL,
+    message_id TEXT NOT NULL,
+    task_uuid TEXT,
+    session_id TEXT,
+    message_index INTEGER,
+    total_messages INTEGER,
+    payload TEXT NOT NULL,
+    created_at INTEGER NOT NULL,
+    delivered_at INTEGER,
+    acked_at INTEGER,
+    UNIQUE (user_id, message_id)
+  )
+`;
+var MESSAGE_OUTBOX_INDEX_SQL = `
+  CREATE INDEX IF NOT EXISTS idx_outbox_unacked
+    ON message_outbox (user_id, id)
+    WHERE acked_at IS NULL
+`;
+function parseTableName(sql) {
+  const match = /CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?([A-Za-z_][A-Za-z0-9_]*)/i.exec(sql);
+  return match ? match[1] : "";
+}
+function parseColumnNames(sql) {
+  const body = sql.slice(sql.indexOf("(") + 1, sql.lastIndexOf(")"));
+  const parts = [];
+  let depth = 0;
+  let current = "";
+  for (const ch of body) {
+    if (ch === "(") depth++;
+    else if (ch === ")") depth--;
+    if (ch === "," && depth === 0) {
+      parts.push(current);
+      current = "";
+      continue;
+    }
+    current += ch;
+  }
+  parts.push(current);
+  const TABLE_CONSTRAINTS = /* @__PURE__ */ new Set(["primary", "unique", "foreign", "check", "constraint"]);
+  return parts.map((part) => part.trim()).filter(Boolean).map((part) => part.split(/\s+/)[0]).filter((name) => !TABLE_CONSTRAINTS.has(name.toLowerCase()));
+}
+function describeTable(sql) {
+  return [parseTableName(sql), parseColumnNames(sql)];
+}
+var SQLITE_REQUIRED_SCHEMA = Object.freeze({
+  tables: Object.freeze(Object.fromEntries([
+    describeTable(SQLITE_TABLE_SQL),
+    describeTable(CLIENT_STATE_TABLE_SQL),
+    describeTable(PUSH_SUBSCRIPTION_TABLE_SQL),
+    describeTable(MESSAGE_OUTBOX_TABLE_SQL)
+  ])),
+  indexes: Object.freeze(SQLITE_INDEXES.filter((index) => index.critical).map((index) => index.name))
+});
 
 // src/server/adapters/d1.js
-var UPDATABLE_COLUMNS = /* @__PURE__ */ new Set([
-  "user_id",
-  "uuid",
-  "encrypted_payload",
-  "message_type",
-  "next_send_at",
-  "lease_until",
-  "retry_after",
-  "serialize_group",
-  "status",
-  "retry_count",
-  "created_at",
-  "updated_at"
-]);
 function escapeLikePrefix(prefix) {
   return prefix.replace(/[\\%_]/g, (ch) => `\\${ch}`);
 }
@@ -2503,6 +2928,8 @@ var D1Adapter = class {
     await this._db.prepare(SQLITE_TABLE_SQL).run();
     await this._db.prepare(CLIENT_STATE_TABLE_SQL).run();
     await this._db.prepare(PUSH_SUBSCRIPTION_TABLE_SQL).run();
+    await this._db.prepare(MESSAGE_OUTBOX_TABLE_SQL).run();
+    await this._db.prepare(MESSAGE_OUTBOX_INDEX_SQL).run();
     for (const migration of SQLITE_MIGRATIONS) {
       try {
         await this._db.prepare(migration.sql).run();
@@ -2534,10 +2961,36 @@ var D1Adapter = class {
       indexes: indexResults
     };
   }
+  /**
+   * 活库里现在实际有哪些表 / 列 / 索引。
+   *
+   * 只读不写，纯粹如实回报：拿它跟这一版需要的清单对照的活儿在
+   * lib/schema-version.js（`getSchemaVersion` / `ensureSchema`）。库升级后表结
+   * 构变了而老部署没跑过 initSchema 时，cron 会每分钟静默挂在缺的那一列上，
+   * 界面上一切正常——这个方法就是让宿主查得出来。
+   *
+   * @returns {Promise<{ tables: Record<string, string[]>, indexes: string[] }>}
+   */
+  async describeSchema() {
+    const tableRes = await this._db.prepare(
+      `SELECT name FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%'`
+    ).all();
+    const tables = {};
+    for (const row of tableRes.results || []) {
+      if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(row.name)) continue;
+      const columnRes = await this._db.prepare(`PRAGMA table_info(${row.name})`).all();
+      tables[row.name] = (columnRes.results || []).map((column) => column.name);
+    }
+    const indexRes = await this._db.prepare(
+      `SELECT name FROM sqlite_master WHERE type = 'index' AND name IS NOT NULL`
+    ).all();
+    return { tables, indexes: (indexRes.results || []).map((row) => row.name) };
+  }
   async dropSchema() {
     await this._db.prepare("DROP TABLE IF EXISTS scheduled_messages").run();
     await this._db.prepare("DROP TABLE IF EXISTS client_state").run();
     await this._db.prepare("DROP TABLE IF EXISTS push_subscriptions").run();
+    await this._db.prepare("DROP TABLE IF EXISTS message_outbox").run();
   }
   async createTask(params) {
     const now = this._now();
@@ -2552,9 +3005,48 @@ var D1Adapter = class {
       `SELECT id, uuid, next_send_at, status, created_at FROM scheduled_messages WHERE id = ?`
     ).bind(id).first();
   }
+  /**
+   * 建新任务的同时取消旧的那条（`POST /schedule-message` 的 supersedesUuid）。
+   *
+   * 两条语句走一次 batch（D1 的隐式事务 + 单次网络往返）：不会出现「旧的删了、
+   * 新的没建成」的中间态——INSERT 撞 uuid 唯一索引时整个 batch 回滚，旧行原样
+   * 留着，调用方按既有的 409 冲突路径处理。
+   *
+   * @param {import('./interface.js').InsertTaskParams} params
+   * @param {string} supersedesUuid - 要取消的旧任务 uuid（同一 user_id 下）
+   * @returns {Promise<Object>} createTask 的返回行 + `superseded`（旧行是否
+   *   真的被删掉；false = 旧行本就不存在）
+   */
+  async createTaskSuperseding(params, supersedesUuid) {
+    const now = this._now();
+    const nextSendAt = this._iso(params.next_send_at);
+    const statements = [
+      this._db.prepare(
+        "DELETE FROM scheduled_messages WHERE uuid = ? AND user_id = ?"
+      ).bind(supersedesUuid, params.user_id),
+      this._db.prepare(
+        `INSERT INTO scheduled_messages
+          (user_id, uuid, encrypted_payload, next_send_at, message_type, status, retry_count, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, 'pending', 0, ?, ?)`
+      ).bind(params.user_id, params.uuid, params.encrypted_payload, nextSendAt, params.message_type, now, now)
+    ];
+    let results;
+    if (typeof this._db.batch === "function") {
+      results = await this._db.batch(statements);
+    } else {
+      results = [];
+      for (const stmt of statements) results.push(await stmt.run());
+    }
+    const superseded = (results[0].meta.changes || 0) > 0;
+    const id = results[1].meta.last_row_id;
+    const row = await this._db.prepare(
+      "SELECT id, uuid, next_send_at, status, created_at FROM scheduled_messages WHERE id = ?"
+    ).bind(id).first();
+    return { ...row, superseded };
+  }
   async getTaskByUuid(uuid, userId) {
     return this._db.prepare(
-      `SELECT id, user_id, uuid, encrypted_payload, message_type, next_send_at, status, retry_count, created_at, updated_at
+      `SELECT id, user_id, uuid, encrypted_payload, message_type, next_send_at, status, retry_count, last_error, created_at, updated_at
        FROM scheduled_messages
        WHERE uuid = ? AND user_id = ? AND status = 'pending'
        LIMIT 1`
@@ -2562,12 +3054,25 @@ var D1Adapter = class {
   }
   async getTaskByUuidOnly(uuid) {
     return this._db.prepare(
-      `SELECT id, user_id, uuid, encrypted_payload, message_type, next_send_at, status, retry_count
+      `SELECT id, user_id, uuid, encrypted_payload, message_type, next_send_at, retry_after, status, retry_count
        FROM scheduled_messages
        WHERE uuid = ? AND status = 'pending'
        LIMIT 1`
     ).bind(uuid).first();
   }
+  /**
+   * 这条 uuid 现在是什么状态——不限用户，也不限状态（getTaskByUuidOnly 只看
+   * pending 行）。`runTask` 用它把「这条已经跑完了」和「压根没这条」分开回报。
+   *
+   * @param {string} uuid
+   * @returns {Promise<{ status: string }|null>}
+   */
+  async getTaskStatusByUuidOnly(uuid) {
+    const row = await this._db.prepare(
+      "SELECT status FROM scheduled_messages WHERE uuid = ? LIMIT 1"
+    ).bind(uuid).first();
+    return row ? { status: row.status } : null;
+  }
   async updateTaskById(taskId, updates) {
     const sets = [];
     const values = [];
@@ -2622,7 +3127,7 @@ var D1Adapter = class {
   async getPendingTasks(limit = 50) {
     const now = this._now();
     const res = await this._db.prepare(
-      `SELECT id, user_id, uuid, encrypted_payload, message_type, next_send_at, status, retry_count
+      `SELECT id, user_id, uuid, encrypted_payload, message_type, next_send_at, retry_after, status, retry_count
        FROM scheduled_messages
        WHERE status = 'pending' AND next_send_at <= ?
          AND (lease_until IS NULL OR lease_until <= ?)
@@ -2695,6 +3200,22 @@ var D1Adapter = class {
     ).bind(...values).run();
     return (res.meta.changes || 0) > 0;
   }
+  /**
+   * 投递期间的租约续期（run-tick 的心跳用）。只在行仍是 pending 且确实持有
+   * 租约（lease_until 非空）时生效——收尾把租约放掉之后，迟到的心跳不会把
+   * 租约复活。
+   *
+   * @param {number} taskId
+   * @param {string|Date} leaseUntil - 新的租期末尾
+   * @returns {Promise<boolean>} true = 续上了
+   */
+  async renewTaskLease(taskId, leaseUntil) {
+    const res = await this._db.prepare(
+      `UPDATE scheduled_messages SET lease_until = ?
+       WHERE id = ? AND status = 'pending' AND lease_until IS NOT NULL`
+    ).bind(this._iso(leaseUntil), taskId).run();
+    return (res.meta.changes || 0) > 0;
+  }
   async listTasks(userId, opts = {}) {
     const { status = "all", limit = 20, offset = 0 } = opts;
     const conditions = ["user_id = ?"];
@@ -2709,7 +3230,7 @@ var D1Adapter = class {
     ).bind(...params).first();
     const total = Number(countRow.count) || 0;
     const res = await this._db.prepare(
-      `SELECT id, user_id, uuid, encrypted_payload, message_type, next_send_at, status, retry_count, created_at, updated_at
+      `SELECT id, user_id, uuid, encrypted_payload, message_type, next_send_at, status, retry_count, last_error, created_at, updated_at
        FROM scheduled_messages
        WHERE ${where}
        ORDER BY next_send_at ASC
@@ -2732,6 +3253,20 @@ var D1Adapter = class {
     ).bind(uuid, userId).first();
     return row ? row.status : null;
   }
+  /**
+   * 状态 + 失败摘要（GET /message 用它把「为什么失败」透给已失败的行——那些
+   * 行 getTaskByUuid 读不到，payload 里的 lastError 也就够不着了）。
+   *
+   * @param {string} uuid
+   * @param {string} userId
+   * @returns {Promise<{ status: string, last_error: string|null }|null>}
+   */
+  async getTaskStatusInfo(uuid, userId) {
+    const row = await this._db.prepare(
+      "SELECT status, last_error FROM scheduled_messages WHERE uuid = ? AND user_id = ? LIMIT 1"
+    ).bind(uuid, userId).first();
+    return row ? { status: row.status, last_error: row.last_error ?? null } : null;
+  }
   // ── client_state (single-user cloud state mirror) ──────────────────────
   /**
    * Batch upsert. Last-write-wins per (namespace, key): an entry older
@@ -2862,6 +3397,127 @@ var D1Adapter = class {
     const res = await this._db.prepare("DELETE FROM push_subscriptions WHERE user_id = ?").bind(userId).run();
     return (res.meta.changes || 0) > 0;
   }
+  // ── message_outbox（服务端消息收件箱，客户端 ack）────────────────────────
+  /**
+   * 发送前把这一批 push 落进 outbox（一次 batch）。(user_id, message_id)
+   * 唯一：重试同一 occurrence 带着同一批 messageId 再来时更新 payload、不加
+   * 第二行；客户端已经 ack 过的行不动（ack 是终态，重试不该把它拉回未读）。
+   *
+   * @param {string} userId
+   * @param {Array<{ message_id: string, task_uuid?: string|null, session_id?: string|null,
+   *   message_index?: number|null, total_messages?: number|null, payload: string, created_at: number }>} rows
+   *   `payload` 是整条 push JSON 的 encryptForStorage 密文。
+   * @returns {Promise<number>} 实际写入/更新的行数
+   */
+  async appendOutboxMessages(userId, rows) {
+    if (!rows || rows.length === 0) return 0;
+    const SQL = `INSERT INTO message_outbox
+         (user_id, message_id, task_uuid, session_id, message_index, total_messages, payload, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT (user_id, message_id) DO UPDATE SET
+         payload = excluded.payload,
+         created_at = excluded.created_at,
+         delivered_at = NULL
+       WHERE message_outbox.acked_at IS NULL`;
+    const statements = rows.map(
+      (r) => this._db.prepare(SQL).bind(
+        userId,
+        r.message_id,
+        r.task_uuid ?? null,
+        r.session_id ?? null,
+        r.message_index ?? null,
+        r.total_messages ?? null,
+        r.payload,
+        r.created_at
+      )
+    );
+    let results;
+    if (typeof this._db.batch === "function") {
+      results = await this._db.batch(statements);
+    } else {
+      results = [];
+      for (const stmt of statements) results.push(await stmt.run());
+    }
+    return results.reduce((n, res) => n + ((res.meta.changes || 0) > 0 ? 1 : 0), 0);
+  }
+  /**
+   * 把这一批标记为「Web Push 已发出」。发送失败的段不标——delivered_at 为
+   * null 的行正是客户端最需要拉的那部分。
+   *
+   * @param {string} userId
+   * @param {string[]} messageIds
+   * @param {number} deliveredAt - epoch 毫秒
+   * @returns {Promise<number>}
+   */
+  async markOutboxDelivered(userId, messageIds, deliveredAt) {
+    if (!messageIds || messageIds.length === 0) return 0;
+    const placeholders = messageIds.map(() => "?").join(", ");
+    const res = await this._db.prepare(
+      `UPDATE message_outbox SET delivered_at = ?
+       WHERE user_id = ? AND message_id IN (${placeholders})`
+    ).bind(deliveredAt, userId, ...messageIds).run();
+    return res.meta.changes || 0;
+  }
+  /**
+   * 未 ack 的行（id 升序，游标翻页）。payload 仍是密文，解密在 handler。
+   *
+   * @param {string} userId
+   * @param {number} sinceId - 上一页游标（0 = 从头）
+   * @param {number} limit
+   * @returns {Promise<Array<{ id: number, message_id: string, task_uuid: string|null,
+   *   session_id: string|null, message_index: number|null, total_messages: number|null,
+   *   payload: string, created_at: number, delivered_at: number|null }>>}
+   */
+  async listUnackedOutbox(userId, sinceId = 0, limit = 50) {
+    const res = await this._db.prepare(
+      `SELECT id, message_id, task_uuid, session_id, message_index, total_messages, payload, created_at, delivered_at
+       FROM message_outbox
+       WHERE user_id = ? AND acked_at IS NULL AND id > ?
+       ORDER BY id ASC
+       LIMIT ?`
+    ).bind(userId, sinceId, limit).all();
+    return res.results || [];
+  }
+  /**
+   * 客户端确认收到这一批（幂等：已 ack 的行再 ack 不动）。
+   *
+   * @param {string} userId
+   * @param {string[]} messageIds
+   * @param {number} ackedAt - epoch 毫秒
+   * @returns {Promise<number>} 本次真正被 ack 的行数
+   */
+  async ackOutboxMessages(userId, messageIds, ackedAt) {
+    if (!messageIds || messageIds.length === 0) return 0;
+    const placeholders = messageIds.map(() => "?").join(", ");
+    const res = await this._db.prepare(
+      `UPDATE message_outbox SET acked_at = ?
+       WHERE user_id = ? AND acked_at IS NULL AND message_id IN (${placeholders})`
+    ).bind(ackedAt, userId, ...messageIds).run();
+    return res.meta.changes || 0;
+  }
+  /**
+   * outbox 的例行清理（run-tick 每跳顺手调）：已 ack 的行留短一些，未 ack 的
+   * 也不无限留（Web Push TTL 上限四周，比它更老的推送谁也收不到了）。
+   *
+   * @param {{ ackedBeforeMs?: number, allBeforeMs?: number }} opts - epoch 毫秒阈值
+   * @returns {Promise<number>} 删掉的行数
+   */
+  async cleanupOutbox({ ackedBeforeMs, allBeforeMs } = {}) {
+    let deleted = 0;
+    if (Number.isFinite(ackedBeforeMs)) {
+      const res = await this._db.prepare(
+        "DELETE FROM message_outbox WHERE acked_at IS NOT NULL AND acked_at < ?"
+      ).bind(ackedBeforeMs).run();
+      deleted += res.meta.changes || 0;
+    }
+    if (Number.isFinite(allBeforeMs)) {
+      const res = await this._db.prepare(
+        "DELETE FROM message_outbox WHERE created_at < ?"
+      ).bind(allBeforeMs).run();
+      deleted += res.meta.changes || 0;
+    }
+    return deleted;
+  }
 };
 function createD1Adapter(db) {
   if (!db || typeof db.prepare !== "function") {
@@ -2981,12 +3637,6 @@ function err2(status, code, message, details) {
   const error = details === void 0 ? { code, message } : { code, message, details };
   return { status, body: { success: false, error } };
 }
-function requireUserId2(headers) {
-  const userId = getHeader(headers, "x-user-id");
-  if (!userId) return { error: err2(400, "USER_ID_REQUIRED", "\u7F3A\u5C11\u7528\u6237\u6807\u8BC6\u7B26") };
-  if (!isValidUUIDv4(userId)) return { error: err2(400, "INVALID_USER_ID_FORMAT", "X-User-Id \u5FC5\u987B\u662F UUID v4 \u683C\u5F0F") };
-  return { userId };
-}
 function rejectEntry(entry, index, code, message, extra) {
   const rejection = { index, code, message, ...extra || {} };
   if (entry && typeof entry === "object") {
@@ -3021,6 +3671,10 @@ function validateEntry(entry, index, maxValueBytes) {
   if (!Number.isInteger(entry.updatedAt) || entry.updatedAt <= 0) {
     return rejectEntry(entry, index, "INVALID_STATE_UPDATED_AT", `entries[${index}].updatedAt \u5FC5\u987B\u662F\u6B63\u6574\u6570\uFF08epoch \u6BEB\u79D2\uFF09`);
   }
+  const guard = entry.version ?? entry.builtAt;
+  if (guard !== void 0 && (!Number.isInteger(guard) || guard <= 0)) {
+    return rejectEntry(entry, index, "INVALID_STATE_VERSION", `entries[${index}].version / builtAt \u5FC5\u987B\u662F\u6B63\u6574\u6570\uFF08\u6BEB\u79D2\u65F6\u95F4\u6233\u6216\u5355\u8C03\u9012\u589E\u7248\u672C\u53F7\uFF09`);
+  }
   return null;
 }
 function createClientStateHandler(ctx) {
@@ -3031,7 +3685,7 @@ function createClientStateHandler(ctx) {
     if (getHeader(headers, "x-payload-encrypted") !== "true") {
       return err2(400, "ENCRYPTION_REQUIRED", "\u8BF7\u6C42\u4F53\u5FC5\u987B\u52A0\u5BC6");
     }
-    const gate = requireUserId2(headers);
+    const gate = requireUserId(headers);
     if (gate.error) return gate.error;
     const { userId } = gate;
     if (getHeader(headers, "x-encryption-version") !== "1") {
@@ -3062,14 +3716,20 @@ function createClientStateHandler(ctx) {
     const rejected = [];
     for (let i = 0; i < entries.length; i++) {
       const rejection = validateEntry(entries[i], i, maxValueBytes);
-      if (rejection) rejected.push(rejection);
-      else accepted.push(entries[i]);
+      if (rejection) {
+        rejected.push(rejection);
+      } else {
+        const entry = entries[i];
+        const guard = entry.version ?? entry.builtAt;
+        accepted.push(guard !== void 0 ? { ...entry, version: guard } : entry);
+      }
     }
     if (typeof db.upsertClientState !== "function") {
       return err2(501, "CLIENT_STATE_NOT_SUPPORTED", "\u5F53\u524D\u6570\u636E\u5E93\u9002\u914D\u5668\u4E0D\u652F\u6301 client_state");
     }
-    const { upserted, skipped } = await writeClientStateEntries({ db, userId, userKey, entries: accepted });
+    const { upserted, skipped, skippedEntries } = await writeClientStateEntries({ db, userId, userKey, entries: accepted });
     const data = { upserted, skipped };
+    if (skippedEntries.length > 0) data.skippedEntries = skippedEntries;
     if (rejected.length > 0) data.rejected = rejected;
     return { status: 200, body: { success: true, data } };
   }
@@ -3077,7 +3737,7 @@ function createClientStateHandler(ctx) {
     const tenantResult = await ctx.tenantManager.resolveTenant(headers);
     if (!tenantResult.ok) return tenantResult.error;
     const { db, masterKey } = tenantResult.context;
-    const gate = requireUserId2(headers);
+    const gate = requireUserId(headers);
     if (gate.error) return gate.error;
     const { userId } = gate;
     const namespace = new URL(url, "https://dummy").searchParams.get("namespace") || "";
@@ -3102,7 +3762,7 @@ function createClientStateHandler(ctx) {
     const tenantResult = await ctx.tenantManager.resolveTenant(headers);
     if (!tenantResult.ok) return tenantResult.error;
     const { db } = tenantResult.context;
-    const gate = requireUserId2(headers);
+    const gate = requireUserId(headers);
     if (gate.error) return gate.error;
     const { userId } = gate;
     if (typeof db.clearClientState !== "function") {
@@ -3115,7 +3775,7 @@ function createClientStateHandler(ctx) {
 }
 
 // src/server/lib/version.js
-var SERVER_VERSION = true ? "2.6.0-next.13" : "0.0.0-dev";
+var SERVER_VERSION = true ? "2.6.0-next.16" : "0.0.0-dev";
 
 // src/server/handlers/capabilities.js
 var SERVER_FEATURES = Object.freeze([
@@ -3158,7 +3818,40 @@ var SERVER_FEATURES = Object.freeze([
   // runScheduledTick 认 serializeBy：同一分组的任务同时只跑一条，跨跳也算。
   "tick-serialize-by",
   // 一次 fire 无论什么结局都调 onFireSettled（发完 / 跳过 / 抛错）。
-  "fire-settled-hook"
+  "fire-settled-hook",
+  // PUT /client-state 的 entry 认 version / builtAt 护栏（按内容新旧比较），
+  // 被拦下的 key 在 data.skippedEntries 逐条回报。
+  "client-state-version-guard",
+  // POST /schedule-message 认 immediate: true（不排未来，下一跳 cron 直接触发）。
+  "schedule-immediate",
+  // POST /schedule-message 认 supersedesUuid（建新任务的同一事务里取消旧的）。
+  "schedule-supersede",
+  // 投递期间租约按心跳滚动续租，isolate 死亡后任务 ~90s 内被下一跳接手。
+  "tick-lease-heartbeat",
+  // 导出 runTask(ctx, uuid)：单任务投递入口（CF Queue 消费者用）。
+  "run-task-entrypoint",
+  // 任务行有 last_error 列（脱敏失败摘要）；GET /message 对已失败的行也透出
+  // （409 的 error.details.lastError）。
+  "task-last-error",
+  // 导出 NonRetryableError：hook 抛它 → 直接终审处置，不进重试阶梯。
+  "non-retryable-error",
+  // fire ctx（fireCtx / sessionCtx）带 cancelTask / renewTask。
+  "agentic-cancel-renew-task",
+  // 服务端消息收件箱：push 发送前落 message_outbox，GET /outbox + POST
+  // /outbox/ack 取代「猜哪些没收到」的补收对账。
+  "message-outbox",
+  // onFireSettled 载荷带解密 metadata 与最后一轮 usage；sessionCtx 带 usage。
+  "fire-settled-metadata",
+  "hook-usage",
+  // schedule-message 认 llmExtraBody（原样展开进 LLM 请求体，核心字段优先）。
+  "llm-extra-body",
+  // 500 响应体的 error.cause 带真实原因（stage / name / message），调用方不用
+  // 再去日志里捞「到底哪儿坏了」。
+  "error-cause",
+  // 导出 getSchemaVersion / ensureSchema：表结构够不够用查得出来，也补得上。
+  "schema-self-check",
+  // 单用户 Worker 上有 runTask(uuid, env)：只跑指定那一条任务。
+  "worker-run-task"
 ]);
 function createCapabilitiesHandler(ctx) {
   async function GET(url, headers) {
@@ -3175,6 +3868,116 @@ function createCapabilitiesHandler(ctx) {
   return { GET };
 }
 
+// src/server/handlers/outbox.js
+var MAX_OUTBOX_PAGE_SIZE = 100;
+var DEFAULT_OUTBOX_PAGE_SIZE = 50;
+var MAX_OUTBOX_ACK_IDS = 200;
+function err3(status, code, message, details) {
+  const error = details === void 0 ? { code, message } : { code, message, details };
+  return { status, body: { success: false, error } };
+}
+function createOutboxHandler(ctx) {
+  async function GET(url, headers) {
+    const tenantResult = await ctx.tenantManager.resolveTenant(headers);
+    if (!tenantResult.ok) return tenantResult.error;
+    const { db, masterKey } = tenantResult.context;
+    const gate = requireUserId(headers);
+    if (gate.error) return gate.error;
+    const { userId } = gate;
+    if (typeof db.listUnackedOutbox !== "function") {
+      return err3(501, "OUTBOX_NOT_SUPPORTED", "\u5F53\u524D\u6570\u636E\u5E93\u9002\u914D\u5668\u4E0D\u652F\u6301 message_outbox");
+    }
+    const params = new URL(url, "https://dummy").searchParams;
+    const sinceRaw = params.get("since");
+    const since = sinceRaw == null || sinceRaw === "" ? 0 : Number(sinceRaw);
+    if (!Number.isInteger(since) || since < 0) {
+      return err3(400, "INVALID_OUTBOX_CURSOR", "since \u5FC5\u987B\u662F\u975E\u8D1F\u6574\u6570\uFF08\u4E0A\u4E00\u9875\u54CD\u5E94\u91CC\u7684 cursor\uFF09");
+    }
+    const limitRaw = params.get("limit");
+    let limit = limitRaw == null || limitRaw === "" ? DEFAULT_OUTBOX_PAGE_SIZE : Number(limitRaw);
+    if (!Number.isInteger(limit) || limit <= 0) {
+      return err3(400, "INVALID_OUTBOX_LIMIT", `limit \u5FC5\u987B\u662F 1-${MAX_OUTBOX_PAGE_SIZE} \u7684\u6574\u6570`);
+    }
+    limit = Math.min(limit, MAX_OUTBOX_PAGE_SIZE);
+    const userKey = await deriveUserEncryptionKey(userId, masterKey);
+    const rows = await db.listUnackedOutbox(userId, since, limit);
+    const entries = [];
+    let cursor = since;
+    for (const row of rows) {
+      cursor = Math.max(cursor, row.id);
+      let push;
+      try {
+        push = JSON.parse(await decryptFromStorage(row.payload, userKey));
+      } catch (error) {
+        console.warn("[amsg-server] outbox \u884C\u89E3\u5BC6\u5931\u8D25\uFF08\u5DF2\u8DF3\u8FC7\uFF09:", row.id, error && error.message);
+        continue;
+      }
+      entries.push({
+        id: row.id,
+        messageId: row.message_id,
+        taskUuid: row.task_uuid ?? null,
+        sessionId: row.session_id ?? null,
+        messageIndex: row.message_index ?? null,
+        totalMessages: row.total_messages ?? null,
+        createdAt: row.created_at,
+        deliveredAt: row.delivered_at ?? null,
+        push
+      });
+    }
+    const data = {
+      entries,
+      cursor,
+      // 按「捞满一页」判断还有没有下一页；解密失败被跳过的行不影响游标推进。
+      hasMore: rows.length === limit
+    };
+    const encryptedResponse = await encryptPayload(data, userKey);
+    return { status: 200, body: { success: true, encrypted: true, version: 1, data: encryptedResponse } };
+  }
+  async function POST(headers, body) {
+    const tenantResult = await ctx.tenantManager.resolveTenant(headers);
+    if (!tenantResult.ok) return tenantResult.error;
+    const { db, masterKey } = tenantResult.context;
+    if (getHeader(headers, "x-payload-encrypted") !== "true") {
+      return err3(400, "ENCRYPTION_REQUIRED", "\u8BF7\u6C42\u4F53\u5FC5\u987B\u52A0\u5BC6");
+    }
+    const gate = requireUserId(headers);
+    if (gate.error) return gate.error;
+    const { userId } = gate;
+    if (getHeader(headers, "x-encryption-version") !== "1") {
+      return err3(400, "UNSUPPORTED_ENCRYPTION_VERSION", "\u52A0\u5BC6\u7248\u672C\u4E0D\u652F\u6301");
+    }
+    const parsedBody = parseEncryptedBody(body);
+    if (!parsedBody.ok) return { status: 400, body: { success: false, error: parsedBody.error } };
+    const userKey = await deriveUserEncryptionKey(userId, masterKey);
+    let payload;
+    try {
+      payload = await decryptPayload(parsedBody.data, userKey);
+    } catch (error) {
+      if (error instanceof SyntaxError) {
+        return err3(400, "INVALID_PAYLOAD_FORMAT", "\u89E3\u5BC6\u540E\u7684\u6570\u636E\u4E0D\u662F\u6709\u6548 JSON");
+      }
+      return err3(400, "DECRYPTION_FAILED", "\u8BF7\u6C42\u4F53\u89E3\u5BC6\u5931\u8D25");
+    }
+    if (!isPlainObject(payload)) return err3(400, "INVALID_PAYLOAD_FORMAT", "\u89E3\u5BC6\u540E\u7684\u6570\u636E\u5FC5\u987B\u662F JSON \u5BF9\u8C61");
+    const messageIds = payload.messageIds;
+    if (!Array.isArray(messageIds) || messageIds.length === 0) {
+      return err3(400, "INVALID_OUTBOX_ACK", "messageIds \u5FC5\u987B\u662F\u975E\u7A7A\u6570\u7EC4");
+    }
+    if (messageIds.length > MAX_OUTBOX_ACK_IDS) {
+      return err3(400, "TOO_MANY_OUTBOX_ACK_IDS", `\u5355\u6B21\u6700\u591A ack ${MAX_OUTBOX_ACK_IDS} \u6761`, { count: messageIds.length });
+    }
+    if (!messageIds.every((id) => typeof id === "string" && id.trim())) {
+      return err3(400, "INVALID_OUTBOX_ACK", "messageIds \u7684\u6BCF\u4E00\u9879\u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32");
+    }
+    if (typeof db.ackOutboxMessages !== "function") {
+      return err3(501, "OUTBOX_NOT_SUPPORTED", "\u5F53\u524D\u6570\u636E\u5E93\u9002\u914D\u5668\u4E0D\u652F\u6301 message_outbox");
+    }
+    const acked = await db.ackOutboxMessages(userId, messageIds, Date.now());
+    return { status: 200, body: { success: true, data: { acked } } };
+  }
+  return { GET, POST };
+}
+
 // src/server/single-user.js
 function createSingleUserServer(config) {
   if (!config || !config.db) throw new Error("[amsg-server single-user] config.db is required");
@@ -3221,65 +4024,50 @@ function createSingleUserServer(config) {
       vapidPublicKey: createVapidPublicKeyHandler(ctx),
       clientState: createClientStateHandler(ctx),
       pushSubscription: createPushSubscriptionHandler(ctx),
-      capabilities: createCapabilitiesHandler(ctx)
+      capabilities: createCapabilitiesHandler(ctx),
+      outbox: createOutboxHandler(ctx)
     }
   };
 }
 
-// src/server/lib/webpush-webcrypto.js
-import { sendWebPush as sharedSendWebPush } from "@rei-standard/amsg-shared";
-import { buildVapidJwt, verifyVapidJwt, hmacSha256 as hmacSha2562 } from "@rei-standard/amsg-shared";
-var WEB_PUSH_MAX_BODY_BYTES = 4096;
-var WEB_PUSH_ENCRYPTION_OVERHEAD_BYTES = 16 + 4 + 1 + 65 + 1 + 16;
-var MAX_PUSH_PAYLOAD_BYTES = WEB_PUSH_MAX_BODY_BYTES - WEB_PUSH_ENCRYPTION_OVERHEAD_BYTES;
-var PUSH_ENVELOPE_RESERVED_BYTES = 384;
-var payloadEncoder = new TextEncoder();
-function measurePushPayload(payload, options) {
-  const reserveEnvelope = !!(options && options.reserveEnvelope);
-  const bytes = payloadEncoder.encode(typeof payload === "string" ? payload : String(payload)).length;
-  const envelopeReservedBytes = reserveEnvelope ? PUSH_ENVELOPE_RESERVED_BYTES : 0;
-  const maxBytes = MAX_PUSH_PAYLOAD_BYTES - envelopeReservedBytes;
-  return {
-    bytes,
-    maxBytes,
-    remainingBytes: maxBytes - bytes,
-    withinLimit: bytes <= maxBytes,
-    envelopeReservedBytes
-  };
+// src/server/lib/schema-version.js
+var SCHEMA_VERSION = "2.6.0";
+function requireIntrospection(db) {
+  if (!db || typeof db.describeSchema !== "function") {
+    throw new Error(
+      "[amsg-server] \u8FD9\u4E2A\u6570\u636E\u5E93\u9002\u914D\u5668\u4E0D\u652F\u6301 schema \u81EA\u67E5\uFF08\u6CA1\u5B9E\u73B0 describeSchema\uFF09\u3002\u5185\u7F6E\u9002\u914D\u5668\u91CC\u76EE\u524D\u53EA\u6709 D1 \u5B9E\u73B0\u4E86\u5B83\u3002"
+    );
+  }
 }
-async function sendWebPush(args) {
-  const { payload } = args || {};
-  if (typeof payload === "string") {
-    const size = measurePushPayload(payload);
-    if (!size.withinLimit) {
-      const err3 = new Error(
-        `sendWebPush: payload is ${size.bytes} bytes, over the ${MAX_PUSH_PAYLOAD_BYTES}-byte limit (push services cap the encrypted body at ${WEB_PUSH_MAX_BODY_BYTES} bytes; aes128gcm adds ${WEB_PUSH_ENCRYPTION_OVERHEAD_BYTES} bytes)`
-      );
-      err3.code = "PUSH_PAYLOAD_TOO_LARGE";
-      err3.bytes = size.bytes;
-      err3.maxBytes = MAX_PUSH_PAYLOAD_BYTES;
-      throw err3;
+async function getSchemaVersion(db) {
+  requireIntrospection(db);
+  const live = await db.describeSchema();
+  const liveTables = live && live.tables || {};
+  const liveIndexes = new Set(live && live.indexes || []);
+  const missing = [];
+  for (const [table, columns] of Object.entries(SQLITE_REQUIRED_SCHEMA.tables)) {
+    const liveColumns = liveTables[table];
+    if (!liveColumns) {
+      missing.push(`table:${table}`);
+      continue;
+    }
+    const present = new Set(liveColumns);
+    for (const column of columns) {
+      if (!present.has(column)) missing.push(`column:${table}.${column}`);
     }
   }
-  return sharedSendWebPush(args);
+  for (const index of SQLITE_REQUIRED_SCHEMA.indexes) {
+    if (!liveIndexes.has(index)) missing.push(`index:${index}`);
+  }
+  const ok = missing.length === 0;
+  return { current: ok ? SCHEMA_VERSION : null, required: SCHEMA_VERSION, ok, missing };
 }
-var SCHEDULED_DEFAULT_TTL = 2419200;
-function createWebCryptoWebPush(vapid = {}, { ttl = SCHEDULED_DEFAULT_TTL } = {}) {
-  return {
-    async sendNotification(subscription, payload) {
-      return sendWebPush({
-        subscription,
-        payload,
-        ttl,
-        vapid: {
-          email: vapid.email,
-          publicKey: vapid.publicKey,
-          privateKey: vapid.privateKey
-        },
-        fetch: globalThis.fetch
-      });
-    }
-  };
+async function ensureSchema(db) {
+  const before = await getSchemaVersion(db);
+  if (before.ok) return { ...before, migrated: false, schema: null };
+  const schema = await db.initSchema();
+  const after = await getSchemaVersion(db);
+  return { ...after, migrated: true, schema };
 }
 
 // src/server/cloudflare/single-user-worker.js
@@ -3298,7 +4086,17 @@ var CORS_ALLOW_HEADERS = "Content-Type, X-User-Id, X-Payload-Encrypted, X-Encryp
 var CORS_ALLOW_METHODS = "GET, POST, PUT, DELETE, OPTIONS";
 function corsHeadersFor(cors, requestOrigin) {
   if (!cors || cors.origin == null) return null;
-  const allowOrigin = typeof cors.origin === "function" ? cors.origin(requestOrigin) || null : cors.origin;
+  let allowOrigin;
+  if (typeof cors.origin === "function") {
+    try {
+      allowOrigin = cors.origin(requestOrigin) || null;
+    } catch (error) {
+      console.warn("[amsg single-user] cors.origin \u56DE\u8C03\u629B\u9519\uFF0C\u6309\u4E0D\u653E\u884C\u5904\u7406:", error && error.message);
+      allowOrigin = null;
+    }
+  } else {
+    allowOrigin = cors.origin;
+  }
   if (!allowOrigin) return null;
   const headers = {
     "Access-Control-Allow-Origin": allowOrigin,
@@ -3312,15 +4110,82 @@ function corsHeadersFor(cors, requestOrigin) {
 function degradedCorsHeaders(requestOrigin) {
   return corsHeadersFor({ origin: requestOrigin, maxAge: 0 }, requestOrigin);
 }
-function internalErrorResponse(cors) {
-  return jsonResponse(500, { success: false, error: { code: "INTERNAL_ERROR", message: "\u670D\u52A1\u5668\u5185\u90E8\u9519\u8BEF" } }, cors);
+function internalErrorResponse(cors, cause) {
+  return jsonResponse(500, {
+    success: false,
+    error: {
+      code: "INTERNAL_ERROR",
+      message: "\u670D\u52A1\u5668\u5185\u90E8\u9519\u8BEF",
+      ...cause ? { cause } : {}
+    }
+  }, cors);
 }
-function createSingleUserCloudflareWorker(buildConfig) {
+function pathOf(request) {
+  try {
+    return new URL(request.url).pathname;
+  } catch (_error) {
+    return null;
+  }
+}
+function createSingleUserCloudflareWorker(buildConfig, options = {}) {
+  const onError = typeof options.onError === "function" ? options.onError : null;
   async function resolveConfig(env) {
     const cfg = await buildConfig(env);
     if (!cfg.db) cfg.db = createD1Adapter(env.DB);
     return cfg;
   }
+  async function reportError(info) {
+    if (!onError) return;
+    try {
+      await onError(info);
+    } catch (hookError) {
+      console.warn("[amsg single-user] onError hook \u629B\u9519\uFF08\u5DF2\u5FFD\u7565\uFF09:", hookError && hookError.message);
+    }
+  }
+  function buildTickContext(cfg) {
+    return {
+      db: cfg.db,
+      masterKey: cfg.masterKey,
+      vapid: cfg.vapid || {},
+      webpush: cfg.webpush,
+      // Fire-time hooks (optional; see lib/agentic-fire.js). runScheduledTick
+      // spreads its ctx into processSingleMessage, so these ride along.
+      hooks: cfg.hooks || null,
+      maxToolIterations: cfg.maxToolIterations,
+      totalTimeoutMs: cfg.totalTimeoutMs,
+      // hook 的 ctx.writeState() 用它判断单条 value 的上限，和 PUT /client-state 同一个配置。
+      maxStateValueBytes: cfg.maxStateValueBytes,
+      // hook 的 ctx.scheduleTask() 单次 fire 建任务的条数上限（默认 2）。
+      maxScheduledTasksPerFire: cfg.maxScheduledTasksPerFire,
+      // 任务错过触发时刻太久（> 60 分钟）不再补发时的回执 hook：
+      // (task, { reason, action, metadata, skippedCount, …, readState,
+      // writeState })。一次性任务（action 'expired'）和循环任务快进
+      //（action 'fast_forwarded'）都会调（凭据字段不透传；best-effort，
+      // 见 lib/run-tick.js）。
+      onStaleSkip: cfg.onStaleSkip,
+      // 推送发出（或发挂）之后的 hook：{ task, sentCount, total, error,
+      // scratch, readState, writeState }（best-effort，见 lib/agentic-fire.js）。
+      onAfterSend: cfg.onAfterSend,
+      // 一次 fire 收尾的 hook：{ task, status, skipReason, sentCount, total,
+      // iterations, error, scratch, readState, writeState }。发完 / 跳过 /
+      // 抛错都会调，宿主用它做「开始时占点什么、结束时放掉」那类收尾
+      //（best-effort，见 lib/agentic-fire.js）。
+      onFireSettled: cfg.onFireSettled,
+      // 分组串行：(task) => 分组标识 | null。同一分组的任务同时只跑一条，
+      // 跨跳也算（见 lib/run-tick.js）。不配 = 全并发，与以前一致。
+      serializeBy: cfg.serializeBy,
+      // 任务占位租期（只在心跳关掉时生效；默认 10 分钟，随 totalTimeoutMs 抬高）。
+      claimLeaseMs: cfg.claimLeaseMs,
+      // 租约心跳间隔（默认 30s；0 = 关掉心跳，退回一次性长租约）。
+      leaseHeartbeatMs: cfg.leaseHeartbeatMs,
+      // 补发新鲜度阈值（默认 60 分钟；见 lib/run-tick.js 的 STALE_AFTER_MS）。
+      staleAfterMs: cfg.staleAfterMs
+    };
+  }
+  function pushConfigured(cfg) {
+    const vapid = cfg.vapid || {};
+    return !!(cfg.webpush && vapid.email && vapid.publicKey && vapid.privateKey);
+  }
   async function fetch(request, env) {
     const requestOrigin = request.headers.get("origin") || "";
     const method = request.method.toUpperCase();
@@ -3329,9 +4194,11 @@ function createSingleUserCloudflareWorker(buildConfig) {
       cfg = await resolveConfig(env);
     } catch (error) {
       console.error("[amsg single-user] fetch() config build failed:", error && error.message);
+      const cause = summarizeErrorCause(error, "config");
+      await reportError({ stage: "config", error, cause, path: pathOf(request) });
       const degraded = degradedCorsHeaders(requestOrigin);
       if (method === "OPTIONS" && degraded) return new Response(null, { status: 204, headers: degraded });
-      return internalErrorResponse(degraded);
+      return internalErrorResponse(degraded, cause);
     }
     const cors = corsHeadersFor(cfg.cors, requestOrigin);
     try {
@@ -3367,6 +4234,10 @@ function createSingleUserCloudflareWorker(buildConfig) {
         result = await server.handlers.clientState.GET(url, headers);
       } else if (method === "DELETE" && pathname.endsWith("/client-state")) {
         result = await server.handlers.clientState.DELETE(url, headers);
+      } else if (method === "GET" && pathname.endsWith("/outbox")) {
+        result = await server.handlers.outbox.GET(url, headers);
+      } else if (method === "POST" && pathname.endsWith("/outbox/ack")) {
+        result = await server.handlers.outbox.POST(headers, await request.text());
       } else if (method === "PUT" && pathname.endsWith("/push-subscription")) {
         result = await server.handlers.pushSubscription.PUT(headers, await request.text());
       } else if (method === "GET" && pathname.endsWith("/push-subscription")) {
@@ -3379,56 +4250,110 @@ function createSingleUserCloudflareWorker(buildConfig) {
       return jsonResponse(result.status, result.body, cors);
     } catch (error) {
       console.error("[amsg single-user] fetch() unhandled error:", error && error.message);
-      return internalErrorResponse(cors);
+      const cause = summarizeErrorCause(error, "request");
+      await reportError({ stage: "request", error, cause, path: pathOf(request) });
+      return internalErrorResponse(cors, cause);
     }
   }
   async function scheduled(event, env) {
-    const cfg = await resolveConfig(env);
-    const vapid = cfg.vapid || {};
-    if (!cfg.webpush || !vapid.email || !vapid.publicKey || !vapid.privateKey) {
+    let cfg;
+    try {
+      cfg = await resolveConfig(env);
+    } catch (error) {
+      console.error("[amsg single-user] scheduled(): config build failed; skipping tick:", error && error.message);
+      const cause = summarizeErrorCause(error, "config");
+      await reportError({ stage: "config", error, cause, path: null });
+      return { ok: false, cause };
+    }
+    if (!pushConfigured(cfg)) {
       console.error("[amsg single-user] scheduled(): VAPID/webpush not configured; skipping tick");
-      return;
+      const cause = summarizeErrorCause(
+        { name: "VapidNotConfigured", message: "VAPID / webpush \u672A\u914D\u7F6E\uFF0C\u672C\u8DF3\u8DF3\u8FC7" },
+        "config"
+      );
+      await reportError({ stage: "config", error: null, cause, path: null });
+      return { ok: false, cause };
     }
     try {
-      await runScheduledTick({
-        db: cfg.db,
-        masterKey: cfg.masterKey,
-        vapid,
-        webpush: cfg.webpush,
-        // Fire-time hooks (optional; see lib/agentic-fire.js). runScheduledTick
-        // spreads its ctx into processSingleMessage, so these ride along.
-        hooks: cfg.hooks || null,
-        maxToolIterations: cfg.maxToolIterations,
-        totalTimeoutMs: cfg.totalTimeoutMs,
-        // hook 的 ctx.writeState() 用它判断单条 value 的上限，和 PUT /client-state 同一个配置。
-        maxStateValueBytes: cfg.maxStateValueBytes,
-        // hook 的 ctx.scheduleTask() 单次 fire 建任务的条数上限（默认 2）。
-        maxScheduledTasksPerFire: cfg.maxScheduledTasksPerFire,
-        // 任务错过触发时刻太久（> 60 分钟）不再补发时的回执 hook：
-        // (task, { reason, action, metadata, skippedCount, …, readState,
-        // writeState })。一次性任务（action 'expired'）和循环任务快进
-        //（action 'fast_forwarded'）都会调（凭据字段不透传；best-effort，
-        // 见 lib/run-tick.js）。
-        onStaleSkip: cfg.onStaleSkip,
-        // 推送发出（或发挂）之后的 hook：{ task, sentCount, total, error,
-        // scratch, readState, writeState }（best-effort，见 lib/agentic-fire.js）。
-        onAfterSend: cfg.onAfterSend,
-        // 一次 fire 收尾的 hook：{ task, status, skipReason, sentCount, total,
-        // iterations, error, scratch, readState, writeState }。发完 / 跳过 /
-        // 抛错都会调，宿主用它做「开始时占点什么、结束时放掉」那类收尾
-        //（best-effort，见 lib/agentic-fire.js）。
-        onFireSettled: cfg.onFireSettled,
-        // 分组串行：(task) => 分组标识 | null。同一分组的任务同时只跑一条，
-        // 跨跳也算（见 lib/run-tick.js）。不配 = 全并发，与以前一致。
-        serializeBy: cfg.serializeBy,
-        // 任务占位租期（默认 10 分钟，随 totalTimeoutMs 抬高）。
-        claimLeaseMs: cfg.claimLeaseMs
-      });
+      const summary = await runScheduledTick(buildTickContext(cfg));
+      return { ok: true, summary };
     } catch (error) {
       console.error("[amsg single-user] scheduled(): tick failed:", error && error.message);
+      const cause = summarizeErrorCause(error, "tick");
+      await reportError({ stage: "tick", error, cause, path: null });
+      return { ok: false, cause };
     }
   }
-  return { fetch, scheduled };
+  async function runTask2(uuid, env) {
+    const cfg = await resolveConfig(env);
+    if (!pushConfigured(cfg)) return { ran: false, reason: "not_configured" };
+    return runTask(buildTickContext(cfg), uuid);
+  }
+  async function getSchemaVersion2(env) {
+    const cfg = await resolveConfig(env);
+    return getSchemaVersion(cfg.db);
+  }
+  async function ensureSchema2(env) {
+    const cfg = await resolveConfig(env);
+    return ensureSchema(cfg.db);
+  }
+  return { fetch, scheduled, runTask: runTask2, getSchemaVersion: getSchemaVersion2, ensureSchema: ensureSchema2 };
+}
+
+// src/server/lib/webpush-webcrypto.js
+import { sendWebPush as sharedSendWebPush } from "@rei-standard/amsg-shared";
+import { buildVapidJwt, verifyVapidJwt, hmacSha256 as hmacSha2562 } from "@rei-standard/amsg-shared";
+var WEB_PUSH_MAX_BODY_BYTES = 4096;
+var WEB_PUSH_ENCRYPTION_OVERHEAD_BYTES = 16 + 4 + 1 + 65 + 1 + 16;
+var MAX_PUSH_PAYLOAD_BYTES = WEB_PUSH_MAX_BODY_BYTES - WEB_PUSH_ENCRYPTION_OVERHEAD_BYTES;
+var PUSH_ENVELOPE_RESERVED_BYTES = 384;
+var payloadEncoder = new TextEncoder();
+function measurePushPayload(payload, options) {
+  const reserveEnvelope = !!(options && options.reserveEnvelope);
+  const bytes = payloadEncoder.encode(typeof payload === "string" ? payload : String(payload)).length;
+  const envelopeReservedBytes = reserveEnvelope ? PUSH_ENVELOPE_RESERVED_BYTES : 0;
+  const maxBytes = MAX_PUSH_PAYLOAD_BYTES - envelopeReservedBytes;
+  return {
+    bytes,
+    maxBytes,
+    remainingBytes: maxBytes - bytes,
+    withinLimit: bytes <= maxBytes,
+    envelopeReservedBytes
+  };
+}
+async function sendWebPush(args) {
+  const { payload } = args || {};
+  if (typeof payload === "string") {
+    const size = measurePushPayload(payload);
+    if (!size.withinLimit) {
+      const err4 = new Error(
+        `sendWebPush: payload is ${size.bytes} bytes, over the ${MAX_PUSH_PAYLOAD_BYTES}-byte limit (push services cap the encrypted body at ${WEB_PUSH_MAX_BODY_BYTES} bytes; aes128gcm adds ${WEB_PUSH_ENCRYPTION_OVERHEAD_BYTES} bytes)`
+      );
+      err4.code = "PUSH_PAYLOAD_TOO_LARGE";
+      err4.bytes = size.bytes;
+      err4.maxBytes = MAX_PUSH_PAYLOAD_BYTES;
+      throw err4;
+    }
+  }
+  return sharedSendWebPush(args);
+}
+var SCHEDULED_DEFAULT_TTL = 2419200;
+function createWebCryptoWebPush(vapid = {}, { ttl = SCHEDULED_DEFAULT_TTL } = {}) {
+  return {
+    async sendNotification(subscription, payload) {
+      return sendWebPush({
+        subscription,
+        payload,
+        ttl,
+        vapid: {
+          email: vapid.email,
+          publicKey: vapid.publicKey,
+          privateKey: vapid.privateKey
+        },
+        fetch: globalThis.fetch
+      });
+    }
+  };
 }
 
 export {
@@ -3436,9 +4361,9 @@ export {
   advanceOccurrence,
   planNextOccurrence,
   nextFutureOccurrence,
+  isValidUrl,
   validateAvatarUrl,
   isValidISO8601,
-  isValidUrl,
   isValidUUID,
   isValidUUIDv4,
   validateSplitPattern,
@@ -3456,8 +4381,20 @@ export {
   encryptForStorage,
   decryptFromStorage,
   createGetUserKeyHandler,
+  DEFAULT_MAX_TOOL_ITERATIONS,
+  DEFAULT_TOTAL_TIMEOUT_MS,
+  DEFAULT_MAX_SCHEDULED_TASKS_PER_FIRE,
+  MIN_SCHEDULE_LEAD_MS,
+  NonRetryableError,
+  isNonRetryableError,
+  sanitizeErrorSummary,
+  summarizeErrorCause,
   createScheduleMessageHandler,
+  DEFAULT_CLAIM_LEASE_MS,
+  DEFAULT_LEASE_HEARTBEAT_MS,
+  DEFAULT_HEARTBEAT_LEASE_TTL_MS,
   runScheduledTick,
+  runTask,
   createUpdateMessageHandler,
   createCancelMessageHandler,
   createMessagesHandler,
@@ -3465,11 +4402,16 @@ export {
   createPushSubscriptionHandler,
   createD1Adapter,
   createSingleUserServer,
+  SCHEMA_VERSION,
+  getSchemaVersion,
+  ensureSchema,
+  CORS_ALLOW_HEADERS,
+  CORS_ALLOW_METHODS,
+  createSingleUserCloudflareWorker,
   WEB_PUSH_MAX_BODY_BYTES,
   WEB_PUSH_ENCRYPTION_OVERHEAD_BYTES,
   MAX_PUSH_PAYLOAD_BYTES,
   PUSH_ENVELOPE_RESERVED_BYTES,
   measurePushPayload,
-  createWebCryptoWebPush,
-  createSingleUserCloudflareWorker
+  createWebCryptoWebPush
 };