@rei-standard/amsg-server 2.6.0-next.32 → 2.6.0-next.34

package/dist/{chunk-KZT3YC62.cjs → chunk-5GRXWKQR.cjs}

@@ -1,4 +1,4 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } async function _asyncNullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return await rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
 
 
 
@@ -31,7 +31,7 @@ function isValidTimeZoneId(tzId) {
   try {
     formatterFor(tzId);
     return true;
-  } catch (e) {
+  } catch (e2) {
     return false;
   }
 }
@@ -278,8 +278,8 @@ function hasCredRefs(payload) {
 }
 async function saveLlmCredentials({ db, userId, userKey, credentials }) {
   const entries = [];
-  for (const { credId, value } of credentials) {
-    entries.push({ credId, encryptedValue: await encryptForStorage(JSON.stringify(value), userKey) });
+  for (const { credId, value, owner, kind, ownerGeneration } of credentials) {
+    entries.push({ credId, owner, kind, ownerGeneration, encryptedValue: await encryptForStorage(JSON.stringify(value), userKey) });
   }
   const upserted = await db.upsertLlmCredentials(userId, entries);
   return { upserted };
@@ -669,7 +669,7 @@ function parseBodyAsObject(body, options = {}) {
   if (typeof parsed === "string") {
     try {
       parsed = JSON.parse(parsed);
-    } catch (e2) {
+    } catch (e3) {
       return { ok: false, error: invalidJson };
     }
   }
@@ -1025,6 +1025,9 @@ var CHUNK_NAMESPACE_PREFIX = CHUNK_NS_PREFIX;
 function chunkNamespaceFor(namespace) {
   return CHUNK_NS_PREFIX + namespace;
 }
+function isChunkNamespace(namespace) {
+  return typeof namespace === "string" && namespace.startsWith(CHUNK_NS_PREFIX);
+}
 function chunkKeyFor(key, index) {
   return `${key}${SEP}${index}`;
 }
@@ -1125,19 +1128,29 @@ async function writeClientStateEntries({ db, userId, userKey, entries, now }) {
   const rootRowEntries = [];
   const deletions = [];
   for (const entry of entries) {
+    const cloudFields = {
+      owner: entry.owner,
+      kind: entry.kind,
+      ownerGeneration: entry.ownerGeneration,
+      cloudValue: entry.value,
+      cloudNamespace: entry.namespace,
+      cloudKey: entry.key
+    };
     const rawGuardAt = Number.isInteger(entry.version) && entry.version > 0 ? entry.version : entry.updatedAt;
     const guardAt = Math.min(rawGuardAt, at);
     cleanups.push({
       namespace: chunkNamespaceFor(entry.namespace),
       keyPrefix: chunkKeyPrefixFor(entry.key),
-      updatedAt: guardAt
+      updatedAt: guardAt,
+      ...cloudFields
     });
     if (entry.value === null) {
       deletions.push({ cleanupIndex: cleanups.length, entry });
       cleanups.push({
         namespace: entry.namespace,
         key: entry.key,
-        updatedAt: guardAt
+        updatedAt: guardAt,
+        ...cloudFields
       });
       continue;
     }
@@ -1148,7 +1161,8 @@ async function writeClientStateEntries({ db, userId, userKey, entries, now }) {
         namespace: entry.namespace,
         key: entry.key,
         value: await encryptForStorage(entry.value, userKey),
-        updatedAt: guardAt
+        updatedAt: guardAt,
+        ...cloudFields
       });
     } else {
       const slices = splitStateValue(entry.value);
@@ -1156,7 +1170,8 @@ async function writeClientStateEntries({ db, userId, userKey, entries, now }) {
         namespace: entry.namespace,
         key: entry.key,
         value: buildChunkedRootValue(slices.length),
-        updatedAt: guardAt
+        updatedAt: guardAt,
+        ...cloudFields
       });
       const encryptedSlices = await Promise.all(slices.map((slice) => encryptForStorage(slice, userKey)));
       for (let c = 0; c < encryptedSlices.length; c++) {
@@ -1164,7 +1179,8 @@ async function writeClientStateEntries({ db, userId, userKey, entries, now }) {
           namespace: chunkNamespaceFor(entry.namespace),
           key: chunkKeyFor(entry.key, c),
           value: encryptedSlices[c],
-          updatedAt: guardAt
+          updatedAt: guardAt,
+          ...cloudFields
         });
       }
     }
@@ -1293,6 +1309,7 @@ async function appendPushesToOutbox({ db, userId, userKey, pushes }) {
     await db.appendOutboxMessages(userId, await toOutboxRows(pushes, userKey, Date.now()));
     return true;
   } catch (error) {
+    if (_optionalChain([error, 'optionalAccess', _5 => _5.code]) === "CLOUD_OWNER_RETIRED") throw error;
     console.warn("[amsg-server] outbox \u843D\u884C\u5931\u8D25\uFF08\u4E0D\u5F71\u54CD\u6295\u9012\uFF09:", error && error.message);
     return false;
   }
@@ -1566,7 +1583,7 @@ async function sendResultPush({ db, task, userKey, decryptedPayload, webpush, pu
     await sendTaggedPush(webpush, subscription, JSON.stringify(push));
     return true;
   } catch (error) {
-    if (isTaskCancelledError(error)) throw error;
+    if (isTaskCancelledError(error) || _optionalChain([error, 'optionalAccess', _6 => _6.code]) === "CLOUD_OWNER_RETIRED") throw error;
     console.warn(
       `[amsg-server] \u7ED3\u679C ${push.messageId} \u7684\u63A8\u9001\u6CA1\u53D1\u51FA\u53BB\uFF08\u5DF2\u843D\u8FDB\u6536\u4EF6\u7BB1\uFF0C\u7B49\u5BA2\u6237\u7AEF\u8865\u6536\uFF09:`,
       error && error.message
@@ -1636,6 +1653,7 @@ var DEFAULT_MAX_TOOL_ITERATIONS = 5;
 var DEFAULT_TOTAL_TIMEOUT_MS = 24e4;
 var DEFAULT_MAX_SCHEDULED_TASKS_PER_FIRE = 2;
 var MIN_SCHEDULE_LEAD_MS = 6e4;
+var MAX_DEFER_AFTER_MS = 24 * 60 * 60 * 1e3;
 var SCHEDULABLE_MESSAGE_TYPES = /* @__PURE__ */ new Set(["auto", "prompted", "fixed"]);
 var SCHEDULABLE_RECURRENCE_TYPES = /* @__PURE__ */ new Set(["none", "daily", "weekly"]);
 var SLEEP_BETWEEN_MESSAGES_MS = 1500;
@@ -1670,6 +1688,22 @@ function buildHookTask(task, decryptedPayload) {
     retryCount: _nullishCoalesce(task.retry_count, () => ( 0))
   });
 }
+var BAD_BEFORE_FIRE_MESSAGE = "AGENTIC_BAD_BEFORE_FIRE: onBeforeFire must return ChatMessage[] | { messages, maxToolIterations?, totalTimeoutMs?, tools?, toolChoice? } | { skip: true } | { defer: { afterMs } } | null";
+function readDeferAfterMs(defer) {
+  const afterMs = defer && typeof defer === "object" ? (
+    /** @type {any} */
+    defer.afterMs
+  ) : void 0;
+  if (typeof afterMs !== "number" || !Number.isFinite(afterMs) || afterMs <= 0 || afterMs > MAX_DEFER_AFTER_MS) {
+    throw markPermanent(
+      new TypeError(
+        `${BAD_BEFORE_FIRE_MESSAGE}\uFF08defer.afterMs \u5FC5\u987B\u662F\u6709\u9650\u6B63\u6570\uFF0C\u4E14\u4E0D\u8D85\u8FC7 ${MAX_DEFER_AFTER_MS} \u6BEB\u79D2\uFF09`
+      ),
+      "AGENTIC_BAD_BEFORE_FIRE"
+    );
+  }
+  return afterMs;
+}
 function normalizeBeforeFireResult(result) {
   if (Array.isArray(result)) {
     return { messages: result };
@@ -1686,12 +1720,7 @@ function normalizeBeforeFireResult(result) {
       toolChoice: result.toolChoice
     };
   }
-  throw markPermanent(
-    new TypeError(
-      "AGENTIC_BAD_BEFORE_FIRE: onBeforeFire must return ChatMessage[] | { messages, maxToolIterations?, totalTimeoutMs?, tools?, toolChoice? } | { skip: true } | null"
-    ),
-    "AGENTIC_BAD_BEFORE_FIRE"
-  );
+  throw markPermanent(new TypeError(BAD_BEFORE_FIRE_MESSAGE), "AGENTIC_BAD_BEFORE_FIRE");
 }
 function firstPositiveInt(values, fallback) {
   for (const v of values) {
@@ -1708,7 +1737,7 @@ function firstPositiveNumber(values, fallback) {
 async function runAgenticFire({ task, decryptedPayload, userKey, ctx }) {
   const hooks = ctx.hooks;
   const signal = ctx.signal || new AbortController().signal;
-  const isCancelled = () => signal.aborted || _optionalChain([ctx, 'access', _5 => _5.isTaskCancelled, 'optionalCall', _6 => _6()]) === true;
+  const isCancelled = () => signal.aborted || _optionalChain([ctx, 'access', _7 => _7.isTaskCancelled, 'optionalCall', _8 => _8()]) === true;
   const throwIfCancelled = () => {
     if (!isCancelled()) return;
     if (isTaskCancelledError(signal.reason)) throw signal.reason;
@@ -2026,6 +2055,7 @@ async function runAgenticFire({ task, decryptedPayload, userKey, ctx }) {
   };
   let settledStatus = "failed";
   let settledError = null;
+  let settledRetryAfter = null;
   try {
     const outcome = await runFireChain({
       task,
@@ -2050,7 +2080,11 @@ async function runAgenticFire({ task, decryptedPayload, userKey, ctx }) {
       occurrenceMs
     });
     throwIfCancelled();
-    settledStatus = !outcome.handled ? "not-handled" : outcome.result.status === "skipped" ? "skipped" : "sent";
+    if (!outcome.handled) settledStatus = "not-handled";
+    else if (outcome.result.status === "deferred") {
+      settledStatus = "deferred";
+      settledRetryAfter = outcome.result.retryAfter;
+    } else settledStatus = outcome.result.status === "skipped" ? "skipped" : "sent";
     return outcome;
   } catch (error) {
     if (isCancelled() && !isTaskCancelledError(error)) {
@@ -2070,6 +2104,7 @@ async function runAgenticFire({ task, decryptedPayload, userKey, ctx }) {
       status: settledStatus,
       ...settledStatus === "cancelled" ? { willRetry: false, failureStage: null } : settledStatus === "failed" && ctx._deliveryState ? failureRetryDecision(ctx._deliveryState, settledError) : { willRetry: null, failureStage: null },
       skipReason: settledStatus === "skipped" ? progress.skipReason : null,
+      retryAfter: settledStatus === "deferred" ? settledRetryAfter : null,
       sentCount: progress.sentCount,
       pushedCount: progress.pushedCount,
       total: progress.total,
@@ -2127,6 +2162,27 @@ async function runFireChain({
     progress.skipReason = "before-fire";
     return { handled: true, result: { success: true, messagesSent: 0, status: "skipped", iterations: 0 } };
   }
+  if (typeof before === "object" && !Array.isArray(before) && before.defer != null) {
+    const afterMs = readDeferAfterMs(before.defer);
+    if (ctx._deferSupported !== true) {
+      throw new DeploymentConfigError(
+        "AGENTIC_DEFER_UNSUPPORTED: onBeforeFire \u8FD4\u56DE\u4E86 { defer }\uFF0C\u4F46\u8FD9\u6761\u6295\u9012\u8DEF\u5F84\u4E0D\u652F\u6301\u63A8\u8FDF\u2014\u2014\u53EA\u6709 runScheduledTick / runTask \u4E14\u9002\u914D\u5668\u5B9E\u73B0\u4E86 claimTask\uFF08\u4EFB\u52A1\u8868\u6709 retry_after \u5217\uFF09\u65F6\u53EF\u7528\uFF0C\u8BF7\u6C42\u5185\u5F53\u573A\u6295\u9012\u7684 instant \u4EFB\u52A1\u4E0D\u53EF\u7528",
+        { code: "AGENTIC_DEFER_UNSUPPORTED" }
+      );
+    }
+    return {
+      handled: true,
+      result: {
+        success: false,
+        deferred: true,
+        // 用真实时钟：这个时刻要落进 retry_after，跟数据库捞取条件里的「现在」比。
+        retryAfter: new Date(Date.now() + afterMs).toISOString(),
+        messagesSent: 0,
+        status: "deferred",
+        iterations: 0
+      }
+    };
+  }
   const normalized = normalizeBeforeFireResult(before);
   const maxToolIterations = firstPositiveInt(
     [normalized.maxToolIterations, ctx.maxToolIterations],
@@ -2256,7 +2312,7 @@ async function runFireChain({
       toolResults = toolCalls.map((toolCall) => ({
         tool_call_id: toolCall && typeof toolCall === "object" && typeof toolCall.id === "string" ? toolCall.id : "",
         role: "tool",
-        content: `Tool execution failed: ${_nullishCoalesce(_optionalChain([error, 'optionalAccess', _7 => _7.message]), () => ( String(error)))}`
+        content: `Tool execution failed: ${_nullishCoalesce(_optionalChain([error, 'optionalAccess', _9 => _9.message]), () => ( String(error)))}`
       }));
     }
     const nativeCalls = Array.isArray(assistantMessage.tool_calls) ? assistantMessage.tool_calls : [];
@@ -2431,6 +2487,330 @@ function addTokenCount(sum, value) {
 
 
 
+
+// src/server/lib/cloud-data-guard.js
+var RAW_CLOUD_ADAPTER = /* @__PURE__ */ Symbol("cloud-data-adapter");
+function guardError(code, message) {
+  return Object.assign(new Error(message), { code, status: 409 });
+}
+function validOwner(owner) {
+  return owner && typeof owner.type === "string" && owner.type.trim().length > 0 && owner.type.length <= 100 && typeof owner.id === "string" && owner.id.trim().length > 0 && owner.id.length <= 300;
+}
+function validateGuard(guard) {
+  if (!validOwner(_optionalChain([guard, 'optionalAccess', _10 => _10.owner])))
+    throw guardError("INVALID_CLOUD_OWNER", "Cloud owner is invalid");
+  if (!Number.isSafeInteger(guard.generation) || guard.generation < 0) {
+    throw guardError(
+      "INVALID_CLOUD_OWNER_GENERATION",
+      "Cloud owner generation must be a non-negative integer"
+    );
+  }
+  return { owner: guard.owner, generation: guard.generation };
+}
+async function assertCloudGuard(db, userId, guard) {
+  if (!guard) return;
+  validateGuard(guard);
+  if (typeof db.isCloudOwnerGuardValid !== "function") {
+    throw guardError(
+      "CLOUD_GUARD_UNSUPPORTED",
+      "Adapter cannot validate cloud owner guards"
+    );
+  }
+  if (!await db.isCloudOwnerGuardValid(userId, guard)) {
+    throw guardError(
+      "CLOUD_OWNER_RETIRED",
+      "Cloud owner is retired or its generation changed"
+    );
+  }
+}
+async function resolveMetadata(resolveOwner, input, explicit) {
+  const resolved = typeof resolveOwner === "function" ? await resolveOwner(input) : null;
+  const owner = _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(_optionalChain([explicit, 'optionalAccess', _11 => _11.owner]), () => ( _optionalChain([explicit, 'optionalAccess', _12 => _12.metadata, 'optionalAccess', _13 => _13.cloudOwner]))), () => ( _optionalChain([resolved, 'optionalAccess', _14 => _14.owner]))), () => ( (validOwner(resolved) ? resolved : null)));
+  if (owner !== null && !validOwner(owner))
+    throw guardError("INVALID_CLOUD_OWNER", "Cloud owner is invalid");
+  return { owner, kind: _nullishCoalesce(_nullishCoalesce(_optionalChain([explicit, 'optionalAccess', _15 => _15.kind]), () => ( _optionalChain([resolved, 'optionalAccess', _16 => _16.kind]))), () => ( null)) };
+}
+async function captureCloudTaskGuard(db, userId, payload, resolveOwner, task) {
+  if (!db.cloudDataManagement) return null;
+  if (_optionalChain([payload, 'optionalAccess', _17 => _17.__cloudOwnerGuard])) {
+    const guard2 = validateGuard(payload.__cloudOwnerGuard);
+    await assertCloudGuard(db, userId, guard2);
+    return guard2;
+  }
+  const { owner } = await resolveMetadata(
+    resolveOwner,
+    { type: "task", payload, task },
+    payload
+  );
+  if (!owner) return null;
+  const guard = validateGuard({
+    owner,
+    generation: _nullishCoalesce(_optionalChain([payload, 'optionalAccess', _18 => _18.ownerGeneration]), () => ( 0))
+  });
+  await assertCloudGuard(db, userId, guard);
+  return guard;
+}
+function createCloudGuardedAdapter(db, {
+  masterKey,
+  resolveOwner,
+  guard: inheritedGuard = null,
+  userId: scopedUserId
+} = {}) {
+  db = _nullishCoalesce(db[RAW_CLOUD_ADAPTER], () => ( db));
+  if (!db.cloudDataManagement) return db;
+  const methods = /* @__PURE__ */ new Map();
+  const keyFor = (userId) => deriveUserEncryptionKey(userId, masterKey);
+  const metadataFor = async (userId, input, explicit, userKey) => {
+    const resolved = await resolveMetadata(resolveOwner, input, explicit);
+    const resourceKey = input.type === "state" ? ["state", input.namespace, input.key] : input.type === "credential" ? ["credential", input.credId] : null;
+    let expectedCloudMetadata;
+    if (resourceKey && typeof db.getCloudResourceMetadata === "function") {
+      const stored = await db.getCloudResourceMetadata(
+        userId,
+        JSON.stringify(resourceKey)
+      );
+      expectedCloudMetadata = stored;
+      if (stored) {
+        const previous = JSON.parse(await decryptFromStorage(stored, userKey));
+        if (previous.owner) {
+          if (resolved.owner && (previous.owner.type !== resolved.owner.type || previous.owner.id !== resolved.owner.id)) {
+            throw guardError(
+              "CLOUD_OWNER_IMMUTABLE",
+              "Existing cloud resource ownership cannot be changed by ordinary writes"
+            );
+          }
+          resolved.owner ??= previous.owner;
+          resolved.kind ??= previous.kind;
+        }
+      }
+    }
+    const inheritsOwner = input.type === "task" || input.type === "outbox";
+    let guard;
+    if (inheritedGuard && inheritsOwner) {
+      guard = inheritedGuard;
+    } else if (resolved.owner) {
+      if (inheritedGuard && (resolved.owner.type !== inheritedGuard.owner.type || resolved.owner.id !== inheritedGuard.owner.id)) {
+        throw guardError(
+          "CLOUD_CROSS_OWNER_WRITE",
+          "A task cannot write another cloud owner's resources"
+        );
+      }
+      guard = inheritedGuard || validateGuard({
+        owner: resolved.owner,
+        generation: _nullishCoalesce(_optionalChain([explicit, 'optionalAccess', _19 => _19.ownerGeneration]), () => ( 0))
+      });
+    } else {
+      guard = null;
+    }
+    await assertCloudGuard(db, userId, inheritedGuard);
+    await assertCloudGuard(db, userId, guard);
+    const metadata = {
+      owner: _nullishCoalesce(_optionalChain([guard, 'optionalAccess', _20 => _20.owner]), () => ( resolved.owner)),
+      kind: resolved.kind,
+      generation: _nullishCoalesce(_optionalChain([guard, 'optionalAccess', _21 => _21.generation]), () => ( 0))
+    };
+    return {
+      cloudGuard: guard,
+      encryptedCloudMetadata: await encryptForStorage(
+        JSON.stringify(metadata),
+        userKey
+      ),
+      ...expectedCloudMetadata !== void 0 ? { expectedCloudMetadata } : {}
+    };
+  };
+  const stateIdentity = (row) => {
+    const chunk = isChunkNamespace(row.namespace);
+    const namespace = _nullishCoalesce(row.cloudNamespace, () => ( (chunk ? row.namespace.slice(CHUNK_NAMESPACE_PREFIX.length) : row.namespace)));
+    let key = _nullishCoalesce(_nullishCoalesce(row.cloudKey, () => ( row.key)), () => ( row.keyPrefix));
+    if (chunk && row.cloudKey === void 0 && typeof key === "string")
+      key = key.slice(0, key.lastIndexOf(""));
+    return { namespace, key };
+  };
+  const wrap = (name, fn) => {
+    if (typeof db[name] === "function") methods.set(name, fn);
+  };
+  for (const method of ["createTask", "createTaskSuperseding"]) {
+    wrap(method, async (params, supersedesUuid) => {
+      const key = await keyFor(params.user_id);
+      const payload = JSON.parse(
+        await decryptFromStorage(params.encrypted_payload, key)
+      );
+      delete payload.__cloudOwnerGuard;
+      const metadata = await metadataFor(
+        params.user_id,
+        { type: "task", payload, task: params },
+        payload,
+        key
+      );
+      if (metadata.cloudGuard) payload.__cloudOwnerGuard = metadata.cloudGuard;
+      const next = {
+        ...params,
+        ...metadata,
+        encrypted_payload: await encryptForStorage(JSON.stringify(payload), key)
+      };
+      return method === "createTaskSuperseding" ? db[method](next, supersedesUuid, metadata.cloudGuard) : db[method](next, metadata.cloudGuard);
+    });
+  }
+  wrap(
+    "upsertClientState",
+    async (userId, entries, cleanups = [], now = Date.now()) => {
+      const key = await keyFor(userId);
+      const roots = /* @__PURE__ */ new Map();
+      const rows = [];
+      for (const entry of entries) {
+        const identity = stateIdentity(entry);
+        const token = JSON.stringify([identity.namespace, identity.key]);
+        let metadata = roots.get(token);
+        if (!metadata) {
+          let value = entry.cloudValue;
+          if (value === void 0 && entry.value && !isChunkNamespace(entry.namespace) && !parseChunkedRootCount(entry.value)) {
+            value = await decryptFromStorage(entry.value, key);
+          }
+          metadata = await metadataFor(
+            userId,
+            { type: "state", ...identity, value, row: entry },
+            entry,
+            key
+          );
+          roots.set(token, metadata);
+        }
+        rows.push(
+          isChunkNamespace(entry.namespace) ? { ...entry, cloudGuard: metadata.cloudGuard } : { ...entry, ...metadata }
+        );
+      }
+      const guardedCleanups = [];
+      for (const cleanup of cleanups) {
+        const identity = stateIdentity(cleanup);
+        const token = JSON.stringify([identity.namespace, identity.key]);
+        const metadata = await _asyncNullishCoalesce(roots.get(token), async () => ( await metadataFor(
+          userId,
+          {
+            type: "state",
+            ...identity,
+            value: cleanup.cloudValue,
+            row: cleanup
+          },
+          cleanup,
+          key
+        )));
+        guardedCleanups.push({
+          ...cleanup,
+          cloudGuard: metadata.cloudGuard,
+          cloudMetadataKey: JSON.stringify([
+            "state",
+            identity.namespace,
+            identity.key
+          ]),
+          ...metadata.expectedCloudMetadata !== void 0 ? { expectedCloudMetadata: metadata.expectedCloudMetadata } : {}
+        });
+      }
+      return db.upsertClientState(
+        userId,
+        rows,
+        guardedCleanups,
+        now,
+        inheritedGuard
+      );
+    }
+  );
+  wrap("upsertLlmCredentials", async (userId, entries) => {
+    const key = await keyFor(userId);
+    const rows = [];
+    for (const entry of entries) {
+      const value = JSON.parse(
+        await decryptFromStorage(entry.encryptedValue, key)
+      );
+      const metadata = await metadataFor(
+        userId,
+        { type: "credential", credId: entry.credId, value, row: entry },
+        entry,
+        key
+      );
+      rows.push({ ...entry, ...metadata });
+    }
+    return db.upsertLlmCredentials(userId, rows, inheritedGuard);
+  });
+  wrap("appendOutboxMessages", async (userId, entries) => {
+    const key = await keyFor(userId);
+    const rows = [];
+    for (const entry of entries) {
+      const payload = JSON.parse(await decryptFromStorage(entry.payload, key));
+      const metadata = await metadataFor(
+        userId,
+        { type: "outbox", payload, row: entry },
+        payload,
+        key
+      );
+      rows.push({ ...entry, ...metadata });
+    }
+    return db.appendOutboxMessages(userId, rows, inheritedGuard);
+  });
+  if (inheritedGuard) {
+    wrap("updateTaskById", async (id, updates) => {
+      if (scopedUserId)
+        await assertCloudGuard(db, scopedUserId, inheritedGuard);
+      return db.updateTaskById(id, updates, inheritedGuard);
+    });
+  }
+  wrap(
+    "updateTaskByUuid",
+    async (uuid, userId, encryptedPayload, extraFields) => {
+      const existing = await db.getTaskByUuid(uuid, userId);
+      if (!existing) return null;
+      const key = await keyFor(userId);
+      const originalPayload = JSON.parse(
+        await decryptFromStorage(existing.encrypted_payload, key)
+      );
+      const originalGuard = await captureCloudTaskGuard(
+        db,
+        userId,
+        originalPayload,
+        resolveOwner,
+        existing
+      );
+      if (inheritedGuard && originalGuard && (originalGuard.owner.type !== inheritedGuard.owner.type || originalGuard.owner.id !== inheritedGuard.owner.id)) {
+        throw guardError(
+          "CLOUD_CROSS_OWNER_WRITE",
+          "A task cannot update another cloud owner"
+        );
+      }
+      const guard = inheritedGuard || originalGuard;
+      await assertCloudGuard(db, userId, guard);
+      const payload = JSON.parse(
+        await decryptFromStorage(encryptedPayload, key)
+      );
+      delete payload.__cloudOwnerGuard;
+      if (guard) payload.__cloudOwnerGuard = guard;
+      for (const field of ["owner", "ownerGeneration"]) {
+        if (originalPayload[field] !== void 0)
+          payload[field] = originalPayload[field];
+        else delete payload[field];
+      }
+      if (payload.metadata && typeof payload.metadata === "object") {
+        if (_optionalChain([originalPayload, 'access', _22 => _22.metadata, 'optionalAccess', _23 => _23.cloudOwner]) !== void 0)
+          payload.metadata.cloudOwner = originalPayload.metadata.cloudOwner;
+        else delete payload.metadata.cloudOwner;
+      }
+      return db.updateTaskByUuid(
+        uuid,
+        userId,
+        await encryptForStorage(JSON.stringify(payload), key),
+        extraFields,
+        guard
+      );
+    }
+  );
+  return new Proxy(db, {
+    get(target, property) {
+      if (property === RAW_CLOUD_ADAPTER) return target;
+      if (methods.has(property)) return methods.get(property);
+      const value = Reflect.get(target, property, target);
+      return typeof value === "function" ? value.bind(target) : value;
+    }
+  });
+}
+
+// src/server/lib/message-processor.js
 var DEFAULT_SPLIT_REGEX = /([。！？!?]+)/;
 var SLEEP_BETWEEN_MESSAGES_MS2 = 1500;
 var MULTIPART_WINDOW_USAGE = 0.5;
@@ -2599,6 +2979,19 @@ async function processSingleMessage(task, ctx, providedMasterKey, predecrypted =
     }
     const userKey = predecrypted && predecrypted.userKey || await deriveUserEncryptionKey(task.user_id, masterKey);
     const decryptedPayload = predecrypted && predecrypted.payload || JSON.parse(await decryptFromStorage(task.encrypted_payload, userKey));
+    const cloudGuard = await captureCloudTaskGuard(ctx.db, task.user_id, decryptedPayload, _optionalChain([ctx, 'access', _24 => _24.cloudData, 'optionalAccess', _25 => _25.resolveOwner]), task);
+    if (cloudGuard) {
+      await assertCloudGuard(ctx.db, task.user_id, cloudGuard);
+      const originalWebpush = ctx.webpush;
+      const guardedDb = createCloudGuardedAdapter(ctx.db, { masterKey, resolveOwner: _optionalChain([ctx, 'access', _26 => _26.cloudData, 'optionalAccess', _27 => _27.resolveOwner]), guard: cloudGuard, userId: task.user_id });
+      ctx = { ...ctx, db: guardedDb, webpush: originalWebpush && {
+        ...originalWebpush,
+        async sendNotification(...args) {
+          await assertCloudGuard(guardedDb, task.user_id, cloudGuard);
+          return originalWebpush.sendNotification(...args);
+        }
+      } };
+    }
     const committed = await findCommittedBatch({
       db: ctx.db,
       userId: task.user_id,
@@ -2781,8 +3174,22 @@ async function processMessagesByUuid(uuid, ctx, maxRetries = 2, userId, provided
     if (!task) {
       return { success: false, error: { code: "TASK_NOT_FOUND", message: "\u4EFB\u52A1\u4E0D\u5B58\u5728\u6216\u5DF2\u5904\u7406" } };
     }
-    const result = await processSingleMessage({ ...task, retry_count: retryCount }, { ...ctx, maxDeliveryRetries: maxRetries }, masterKey, null);
+    let attemptDb = ctx.db;
+    if (ctx.db.cloudDataManagement) {
+      try {
+        const userKey = await deriveUserEncryptionKey(task.user_id, masterKey);
+        const payload = JSON.parse(await decryptFromStorage(task.encrypted_payload, userKey));
+        const guard = await captureCloudTaskGuard(ctx.db, task.user_id, payload, _optionalChain([ctx, 'access', _28 => _28.cloudData, 'optionalAccess', _29 => _29.resolveOwner]), task);
+        if (guard) attemptDb = createCloudGuardedAdapter(ctx.db, { masterKey, resolveOwner: _optionalChain([ctx, 'access', _30 => _30.cloudData, 'optionalAccess', _31 => _31.resolveOwner]), guard, userId: task.user_id });
+      } catch (error) {
+        return { success: false, error: { code: error.code || "PROCESSING_ERROR", message: error.message, retriesAttempted: retryCount } };
+      }
+    }
+    const result = await processSingleMessage({ ...task, retry_count: retryCount }, { ...ctx, db: attemptDb, maxDeliveryRetries: maxRetries }, masterKey, null);
     if (!result.success) {
+      if (result.errorCode === "CLOUD_OWNER_RETIRED") {
+        return { success: false, error: { code: result.errorCode, message: result.error, retriesAttempted: retryCount } };
+      }
       const permanent = isPermanentDeliveryFailure({
         permanent: result.permanent,
         errorCode: result.errorCode,
@@ -2794,7 +3201,7 @@ async function processMessagesByUuid(uuid, ctx, maxRetries = 2, userId, provided
         continue;
       }
       try {
-        await ctx.db.updateTaskById(task.id, {
+        await attemptDb.updateTaskById(task.id, {
           status: "failed",
           retry_count: retryCount,
           // 记录的形状跟定时任务那条路一致（同一个 buildErrorExtra）：reason
@@ -2809,8 +3216,11 @@ async function processMessagesByUuid(uuid, ctx, maxRetries = 2, userId, provided
           })
         });
       } catch (_updateError) {
+        if (_optionalChain([_updateError, 'optionalAccess', _32 => _32.code]) === "CLOUD_OWNER_RETIRED") {
+          return { success: false, error: { code: _updateError.code, message: _updateError.message, retriesAttempted: retryCount } };
+        }
         try {
-          await ctx.db.updateTaskById(task.id, { status: "failed", retry_count: retryCount });
+          await attemptDb.updateTaskById(task.id, { status: "failed", retry_count: retryCount });
         } catch (_retryError) {
         }
       }
@@ -2828,7 +3238,7 @@ async function processMessagesByUuid(uuid, ctx, maxRetries = 2, userId, provided
       await ctx.db.deleteTaskById(task.id);
     } catch (error) {
       try {
-        await ctx.db.updateTaskById(task.id, { status: "sent", retry_count: 0 });
+        await attemptDb.updateTaskById(task.id, { status: "sent", retry_count: 0 });
       } catch (_markSentError) {
       }
       return {
@@ -2979,6 +3389,9 @@ function createScheduleMessageHandler(ctx) {
       // 透传给 LLM 中转的非标准参数（thinking 之类），buildLlmRequestBody 会
       // 把它展开进请求体（核心字段优先）。
       llmExtraBody: _nullishCoalesce(payload.llmExtraBody, () => ( null)),
+      owner: payload.owner,
+      kind: payload.kind,
+      ownerGeneration: payload.ownerGeneration,
       metadata: payload.metadata || {}
     };
     const serializedTaskData = JSON.stringify(fullTaskData);
@@ -3240,19 +3653,26 @@ async function deliverTasks(ctx, tasks) {
     deletedOnceOffTasks: 0,
     updatedRecurringTasks: 0,
     staleTasks: [],
+    deferredTasks: [],
     cancelledTasks: [],
     reasoningSkippedTasks: [],
     redeliveredTasks: [],
     failedTasks: []
   };
   const groupsTakenThisTick = /* @__PURE__ */ new Set();
+  const taskCloudGuards = /* @__PURE__ */ new Map();
+  const updateLifecycleTask = (taskId, fields) => {
+    const guard = taskCloudGuards.get(taskId);
+    return guard ? db.updateTaskById(taskId, fields, guard) : db.updateTaskById(taskId, fields);
+  };
   const supportsClaim = typeof db.claimTask === "function";
   async function claimForThisTick(task, serializeGroup) {
     if (!supportsClaim) return true;
     const leaseUntil = new Date(
       Date.now() + (heartbeatEnabled ? heartbeatLeaseTtlMs : claimLeaseMs)
     ).toISOString();
-    return !!await db.claimTask(task.id, task.next_send_at, leaseUntil, serializeGroup);
+    const guard = taskCloudGuards.get(task.id);
+    return !!(guard ? await db.claimTask(task.id, task.next_send_at, leaseUntil, serializeGroup, guard) : await db.claimTask(task.id, task.next_send_at, leaseUntil, serializeGroup));
   }
   function startLeaseHeartbeat(task) {
     const controller = new AbortController();
@@ -3265,9 +3685,12 @@ async function deliverTasks(ctx, tasks) {
       if (stopped) return;
       let renewed;
       try {
-        renewed = await db.renewTaskLease(task.id, new Date(Date.now() + heartbeatLeaseTtlMs).toISOString());
+        const guard = taskCloudGuards.get(task.id);
+        const until = new Date(Date.now() + heartbeatLeaseTtlMs).toISOString();
+        renewed = guard ? await db.renewTaskLease(task.id, until, guard) : await db.renewTaskLease(task.id, until);
       } catch (error) {
-        console.warn("[amsg-server] \u79DF\u7EA6\u7EED\u79DF\u5931\u8D25\uFF08\u4E0B\u4E2A\u5FC3\u8DF3\u518D\u8BD5\uFF09:", error && error.message);
+        if (_optionalChain([error, 'optionalAccess', _33 => _33.code]) === "CLOUD_OWNER_RETIRED") renewed = false;
+        else console.warn("[amsg-server] \u79DF\u7EA6\u7EED\u79DF\u5931\u8D25\uFF08\u4E0B\u4E2A\u5FC3\u8DF3\u518D\u8BD5\uFF09:", error && error.message);
       }
       if (renewed === false) {
         if (stopped || lease.released) return;
@@ -3299,19 +3722,20 @@ async function deliverTasks(ctx, tasks) {
   async function updateTaskWithLastError(taskId, fields) {
     if (fields.lease_until === null) markLeaseReleased(taskId);
     if (!Object.prototype.hasOwnProperty.call(fields, "last_error")) {
-      return db.updateTaskById(taskId, fields);
+      return updateLifecycleTask(taskId, fields);
     }
     const { last_error: _lastError, ...stateFields } = fields;
-    if (adaptersWithoutLastErrorColumn.has(db)) return db.updateTaskById(taskId, stateFields);
+    if (adaptersWithoutLastErrorColumn.has(db)) return updateLifecycleTask(taskId, stateFields);
     let combinedError;
     try {
-      const result2 = await db.updateTaskById(taskId, fields);
+      const result2 = await updateLifecycleTask(taskId, fields);
       lastErrorColumnSuspicions.delete(db);
       return result2;
     } catch (error) {
+      if (_optionalChain([error, 'optionalAccess', _34 => _34.code]) === "CLOUD_OWNER_RETIRED") throw error;
       combinedError = error;
     }
-    const result = await db.updateTaskById(taskId, stateFields);
+    const result = await updateLifecycleTask(taskId, stateFields);
     warnMissingLastErrorColumn(combinedError);
     const suspicions = (lastErrorColumnSuspicions.get(db) || 0) + 1;
     if (suspicions >= 2) {
@@ -3502,8 +3926,16 @@ async function deliverTasks(ctx, tasks) {
     const serializeGroup = serializeKey ? await deriveSerializeGroup(userKey, serializeKey) : null;
     let claimed;
     try {
+      if (decrypted.ok) {
+        const guard = await captureCloudTaskGuard(db, task.user_id, decryptedPayload, _optionalChain([ctx, 'access', _35 => _35.cloudData, 'optionalAccess', _36 => _36.resolveOwner]), task);
+        if (guard) taskCloudGuards.set(task.id, guard);
+      }
       claimed = await claimForThisTick(task, serializeGroup);
     } catch (error) {
+      if (_optionalChain([error, 'optionalAccess', _37 => _37.code]) === "CLOUD_OWNER_RETIRED") {
+        await recordCancelled(task, "owner_retired");
+        return;
+      }
       results.failedCount++;
       results.failedTasks.push({ taskId: task.id, reason: error.message || "\u4EFB\u52A1\u5360\u4F4D\u5931\u8D25", status: "claim_failed" });
       return;
@@ -3533,23 +3965,32 @@ async function deliverTasks(ctx, tasks) {
     const occurrenceMs = Date.parse(task.next_send_at);
     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) {
+    const settleAsStale = async () => {
       try {
+        const cloudGuard = await captureCloudTaskGuard(db, task.user_id, decryptedPayload, _optionalChain([ctx, 'access', _38 => _38.cloudData, 'optionalAccess', _39 => _39.resolveOwner]), task);
+        const guardedDb = createCloudGuardedAdapter(db, { masterKey, resolveOwner: _optionalChain([ctx, 'access', _40 => _40.cloudData, 'optionalAccess', _41 => _41.resolveOwner]), guard: cloudGuard, userId: task.user_id });
+        const guardedWebpush = cloudGuard && ctx.webpush ? {
+          ...ctx.webpush,
+          async sendNotification(...args) {
+            await assertCloudGuard(db, task.user_id, cloudGuard);
+            return ctx.webpush.sendNotification(...args);
+          }
+        } : ctx.webpush;
         const stateAccessors = createStateAccessors({
-          db,
+          db: guardedDb,
           userId: task.user_id,
           userKey,
           maxStateValueBytes: ctx.maxStateValueBytes
         });
         const { emitResult } = createResultEmitter({
-          db,
+          db: guardedDb,
           task,
           userKey,
           decryptedPayload,
           messageIdBase: task.id != null ? `msg_task_${task.id}${occurrenceSuffix(task)}` : `msg_stale_${task.uuid || ""}`,
           sessionId: task.id != null ? `sess_task_${task.id}${occurrenceSuffix(task)}` : `sess_stale_${task.uuid || ""}`,
           occurrenceMs,
-          webpush: ctx.webpush,
+          webpush: guardedWebpush,
           isCancelled: () => lease.lost
         });
         const recurring = isRecurringType(recurrenceType);
@@ -3593,8 +4034,32 @@ async function deliverTasks(ctx, tasks) {
         results.failedCount++;
         results.failedTasks.push({ taskId: task.id, reason: error.message || "\u8FC7\u671F\u4EFB\u52A1\u5904\u7406\u5931\u8D25", status: "stale_update_failed" });
       }
+    };
+    if (Number.isFinite(occurrenceMs) && Date.now() - occurrenceMs > staleAfterMs && notOnFreshRetryChain) {
+      await settleAsStale();
       return;
     }
+    const handleDeferred = async (retryAfter) => {
+      const wakeMs = Date.parse(retryAfter);
+      if (Number.isFinite(occurrenceMs) && wakeMs - occurrenceMs > staleAfterMs) {
+        await settleAsStale();
+        return;
+      }
+      try {
+        const updated = await updateTaskWithLastError(task.id, {
+          retry_after: retryAfter,
+          lease_until: null
+        });
+        if (rowVanished(updated)) {
+          await recordCancelled(task, "cancelled_mid_delivery");
+          return;
+        }
+        results.deferredTasks.push({ taskId: task.id, retryAfter });
+      } catch (error) {
+        results.failedCount++;
+        results.failedTasks.push({ taskId: task.id, reason: error.message || "\u63A8\u8FDF\u5199\u5E93\u5931\u8D25", status: "defer_update_failed" });
+      }
+    };
     let sendResult;
     try {
       sendResult = await processSingleMessage(
@@ -3605,7 +4070,11 @@ async function deliverTasks(ctx, tasks) {
           masterKey,
           webpush: guardWebpushWithLease(ctx.webpush, lease),
           isTaskCancelled: () => lease.lost,
-          signal: lease.signal
+          signal: lease.signal,
+          // onBeforeFire 的 { defer } 要靠 retry_after 这一列落地，没实现
+          // claimTask 的适配器没有这一列（见 lib/agentic-fire.js 的
+          // AGENTIC_DEFER_UNSUPPORTED）。
+          _deferSupported: supportsClaim
         },
         masterKey,
         { userKey, payload: decryptedPayload }
@@ -3625,7 +4094,19 @@ async function deliverTasks(ctx, tasks) {
       );
       return;
     }
+    if (sendResult.deferred) {
+      if (lease.lost) {
+        await recordCancelled(task, "cancelled_mid_delivery");
+        return;
+      }
+      await handleDeferred(sendResult.retryAfter);
+      return;
+    }
     if (!sendResult.success) {
+      if (sendResult.errorCode === "CLOUD_OWNER_RETIRED") {
+        await recordCancelled(task, "owner_retired");
+        return;
+      }
       if (lease.lost) {
         await recordCancelled(task, "cancelled_mid_delivery");
         return;
@@ -3717,6 +4198,9 @@ async function deliverTasks(ctx, tasks) {
       deletedOnceOffTasks: results.deletedOnceOffTasks,
       updatedRecurringTasks: results.updatedRecurringTasks,
       staleTasks: results.staleTasks,
+      // onBeforeFire 返回 { defer } 被推迟的任务（{ taskId, retryAfter }）：这一
+      // 跳没生成也没发，到 retryAfter 之后再问。不计入 successCount / failedCount。
+      deferredTasks: results.deferredTasks,
       // 投递期间行被取消 / 顶替的任务。`cancelled_mid_delivery` = 推送在发出去
       // 之前被拦下；`cancelled_after_delivery` = 推送已经发完，收尾写库才发现
       // 行没了。两种都不计入 successCount / failedCount。
@@ -4558,6 +5042,34 @@ var SQLITE_ALL_INDEXES = [
   ...CLIENT_STATE_INDEXES,
   ...MESSAGE_OUTBOX_INDEXES
 ];
+var CLOUD_DATA_TABLES_SQL = [
+  `CREATE TABLE IF NOT EXISTS cloud_data_records (
+    user_id TEXT NOT NULL, kind TEXT NOT NULL, id TEXT NOT NULL,
+    data TEXT NOT NULL, idempotency_key TEXT, updated_at INTEGER NOT NULL, write_token TEXT,
+    lease_until INTEGER, lease_token TEXT,
+    PRIMARY KEY (user_id, kind, id), UNIQUE (user_id, kind, idempotency_key)
+  )`,
+  `CREATE TABLE IF NOT EXISTS cloud_data_record_chunks (
+    user_id TEXT NOT NULL, kind TEXT NOT NULL, id TEXT NOT NULL, chunk_index INTEGER NOT NULL,
+    value TEXT NOT NULL, write_token TEXT NOT NULL,
+    PRIMARY KEY (user_id, kind, id, chunk_index)
+  )`,
+  `CREATE TABLE IF NOT EXISTS cloud_data_owners (
+    user_id TEXT NOT NULL, owner_type TEXT NOT NULL, owner_id TEXT NOT NULL,
+    active INTEGER NOT NULL, generation INTEGER NOT NULL, updated_at INTEGER NOT NULL,
+    PRIMARY KEY (user_id, owner_type, owner_id)
+  )`,
+  `CREATE TABLE IF NOT EXISTS cloud_resource_metadata (
+    user_id TEXT NOT NULL, resource_key TEXT NOT NULL, encrypted_value TEXT NOT NULL,
+    PRIMARY KEY (user_id, resource_key)
+  )`,
+  // The empty table is a transactional assertion: inserting 0 aborts the batch.
+  `CREATE TABLE IF NOT EXISTS cloud_guard_assertions (
+    allowed INTEGER NOT NULL DEFAULT 1 CONSTRAINT cloud_owner_guard CHECK (allowed = 1),
+    metadata_allowed INTEGER CONSTRAINT cloud_metadata_guard CHECK (metadata_allowed = 1),
+    lease_allowed INTEGER CONSTRAINT cloud_lease_guard CHECK (lease_allowed = 1)
+  )`
+];
 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] : "";
@@ -4590,7 +5102,8 @@ var SQLITE_REQUIRED_SCHEMA = Object.freeze({
     describeTable(CLIENT_STATE_TABLE_SQL),
     describeTable(PUSH_SUBSCRIPTION_TABLE_SQL),
     describeTable(LLM_CREDENTIALS_TABLE_SQL),
-    describeTable(MESSAGE_OUTBOX_TABLE_SQL)
+    describeTable(MESSAGE_OUTBOX_TABLE_SQL),
+    ...CLOUD_DATA_TABLES_SQL.map(describeTable)
   ])),
   indexes: Object.freeze(SQLITE_ALL_INDEXES.filter((index) => index.critical).map((index) => index.name))
 });
@@ -4691,12 +5204,350 @@ var D1Adapter = class {
     const results = await this._db.batch(statements);
     return results.reduce((n, res) => n + (res.meta.changes || 0), 0);
   }
+  /** A complete management implementation needs real transactional batches. */
+  get cloudDataManagement() {
+    return typeof this._db.batch === "function";
+  }
+  _cloudGuardPredicate(userId, guard) {
+    if (!_optionalChain([guard, 'optionalAccess', _42 => _42.owner]) || !Number.isSafeInteger(guard.generation) || guard.generation < 0) {
+      throw new Error("Invalid cloud owner guard");
+    }
+    return {
+      sql: `COALESCE((SELECT active = 1 AND generation = ? FROM cloud_data_owners
+        WHERE user_id = ? AND owner_type = ? AND owner_id = ?), ? = 0)`,
+      args: [guard.generation, userId, guard.owner.type, guard.owner.id, guard.generation]
+    };
+  }
+  async _cloudBatch(statements, userId, guards = [], metadata = /* @__PURE__ */ new Map()) {
+    const assertions = guards.filter(Boolean).map((guard) => {
+      const condition = this._cloudGuardPredicate(userId, guard);
+      return this._db.prepare(`INSERT INTO cloud_guard_assertions (allowed)
+        SELECT 0 WHERE NOT (${condition.sql})`).bind(...condition.args);
+    });
+    for (const item of metadata.values()) {
+      if (Object.hasOwn(item, "expected")) assertions.push(this._db.prepare(
+        `INSERT INTO cloud_guard_assertions (metadata_allowed) SELECT 0 WHERE NOT (
+          (SELECT encrypted_value FROM cloud_resource_metadata WHERE user_id=? AND resource_key=?) IS ?)`
+      ).bind(userId, item.key, item.expected));
+    }
+    const expanded = [...assertions];
+    const indexes = [];
+    for (let i = 0; i < statements.length; i++) {
+      indexes.push(expanded.length);
+      expanded.push(statements[i]);
+      const item = metadata.get(i);
+      if (_optionalChain([item, 'optionalAccess', _43 => _43.value])) {
+        expanded.push(this._db.prepare(
+          `INSERT INTO cloud_resource_metadata
+          (user_id, resource_key, encrypted_value) SELECT ?, ?, ? WHERE changes() > 0
+          ON CONFLICT (user_id, resource_key) DO UPDATE SET encrypted_value = excluded.encrypted_value`
+        ).bind(userId, item.key, item.value));
+      }
+    }
+    if (expanded.length === 0) return [];
+    if (expanded.length === 1 && assertions.length === 0) return [await expanded[0].run()];
+    if ((assertions.length || expanded.length !== statements.length) && !this.cloudDataManagement) {
+      throw new Error("Cloud management requires transactional batches");
+    }
+    try {
+      let results;
+      if (this.cloudDataManagement) results = await this._db.batch(expanded);
+      else {
+        results = [];
+        for (const stmt of expanded) results.push(await stmt.run());
+      }
+      return indexes.map((index) => results[index]);
+    } catch (error) {
+      if (/cloud_metadata_guard/.test(error.message || "")) {
+        throw Object.assign(new Error("Cloud resource ownership changed"), { code: "CLOUD_RESOURCE_CHANGED" });
+      }
+      if (/cloud_owner_guard/.test(error.message || "")) {
+        const denied = new Error("Cloud owner is retired or generation changed");
+        denied.code = "CLOUD_OWNER_RETIRED";
+        throw denied;
+      }
+      throw error;
+    }
+  }
+  async getCloudResourceMetadata(userId, resourceKey) {
+    const row = await this._db.prepare("SELECT encrypted_value FROM cloud_resource_metadata WHERE user_id=? AND resource_key=?").bind(userId, resourceKey).first();
+    return _nullishCoalesce(_optionalChain([row, 'optionalAccess', _44 => _44.encrypted_value]), () => ( null));
+  }
+  async listCloudResourceRows(userId) {
+    const tables = { task: "scheduled_messages", state: "client_state", credential: "llm_credentials", outbox: "message_outbox", subscription: "push_subscriptions", metadata: "cloud_resource_metadata" };
+    const result = { gaps: [] };
+    await Promise.all(Object.entries(tables).map(async ([type, table]) => {
+      try {
+        const response = await this._db.prepare(`SELECT * FROM ${table} WHERE user_id = ?`).bind(userId).all();
+        result[type] = response.results || [];
+      } catch (e4) {
+        result[type] = [];
+        result.gaps.push({ source: type, code: "READ_FAILED", message: "Cloud storage source could not be read" });
+      }
+    }));
+    return result;
+  }
+  async _cloudRecord(row) {
+    if (!row) return null;
+    let data = row.data;
+    const marker = /^\u001famsg-record\u001f([1-9][0-9]*)$/.exec(data);
+    if (marker) {
+      const result = await this._db.prepare(
+        `SELECT chunk_index,value FROM cloud_data_record_chunks
+        WHERE user_id=? AND kind=? AND id=? AND write_token=? ORDER BY chunk_index`
+      ).bind(row.user_id, row.kind, row.id, row.write_token).all();
+      const chunks = result.results || [];
+      if (chunks.length !== Number(marker[1]) || chunks.some((chunk, index) => chunk.chunk_index !== index)) {
+        throw Object.assign(new Error("Cloud management record chunks are incomplete"), { code: "CLOUD_RECORD_INCOMPLETE" });
+      }
+      data = chunks.map((chunk) => chunk.value).join("");
+    }
+    return { id: row.id, userId: row.user_id, kind: row.kind, data, updatedAt: row.updated_at };
+  }
+  async putCloudDataRecord(userId, kind, id, data, { idempotencyKey = null, createOnly = false, leaseToken } = {}) {
+    const slices = [];
+    if (data.length > 200 * 1024) for (let offset = 0; offset < data.length; offset += 200 * 1024) slices.push(data.slice(offset, offset + 200 * 1024));
+    const rootValue = slices.length ? "amsg-record" + slices.length : data;
+    const writeToken = globalThis.crypto.randomUUID();
+    const now = Date.now();
+    const statements = [];
+    if (leaseToken !== void 0) {
+      statements.push(this._db.prepare(
+        `UPDATE cloud_data_records SET data=?,updated_at=?,write_token=?
+        WHERE user_id=? AND kind=? AND id=? AND lease_token=? AND lease_until>?`
+      ).bind(rootValue, now, writeToken, userId, kind, id, leaseToken, now));
+    } else {
+      const conflict = idempotencyKey || createOnly ? "DO NOTHING" : "DO UPDATE SET data=excluded.data,updated_at=excluded.updated_at,write_token=excluded.write_token";
+      statements.push(this._db.prepare(`INSERT INTO cloud_data_records (user_id,kind,id,data,idempotency_key,updated_at,write_token)
+        VALUES (?,?,?,?,?,?,?) ON CONFLICT ${conflict}`).bind(userId, kind, id, rootValue, idempotencyKey, now, writeToken));
+    }
+    const rootGate = "EXISTS (SELECT 1 FROM cloud_data_records WHERE user_id=? AND kind=? AND id=? AND write_token=?)";
+    statements.push(this._db.prepare(
+      `DELETE FROM cloud_data_record_chunks WHERE user_id=? AND kind=? AND id=? AND ${rootGate}`
+    ).bind(userId, kind, id, userId, kind, id, writeToken));
+    for (let index = 0; index < slices.length; index++) {
+      statements.push(this._db.prepare(
+        `INSERT INTO cloud_data_record_chunks (user_id,kind,id,chunk_index,value,write_token)
+        SELECT ?,?,?,?,?,? WHERE ${rootGate}`
+      ).bind(userId, kind, id, index, slices[index], writeToken, userId, kind, id, writeToken));
+    }
+    if (!this.cloudDataManagement) throw new Error("Cloud management requires transactional batches");
+    const results = await this._db.batch(statements);
+    if (leaseToken !== void 0 && !results[0].meta.changes) throw Object.assign(new Error("Cloud operation processing lease was lost"), { code: "CLOUD_LEASE_LOST" });
+    if (idempotencyKey) {
+      return this._cloudRecord(await this._db.prepare(`SELECT * FROM cloud_data_records WHERE user_id=? AND kind=? AND idempotency_key=?`).bind(userId, kind, idempotencyKey).first());
+    }
+    return this.getCloudDataRecord(userId, kind, id);
+  }
+  async getCloudDataRecord(userId, kind, id) {
+    return this._cloudRecord(await this._db.prepare("SELECT * FROM cloud_data_records WHERE user_id=? AND kind=? AND id=?").bind(userId, kind, id).first());
+  }
+  async getCloudDataRecordByIdempotency(userId, kind, idempotencyKey) {
+    return this._cloudRecord(await this._db.prepare("SELECT * FROM cloud_data_records WHERE user_id=? AND kind=? AND idempotency_key=?").bind(userId, kind, idempotencyKey).first());
+  }
+  async _cloudRecordForList(row) {
+    try {
+      return await this._cloudRecord(row);
+    } catch (error) {
+      return {
+        id: row.id,
+        userId: row.user_id,
+        kind: row.kind,
+        data: null,
+        error: error.code === "CLOUD_RECORD_INCOMPLETE" ? error.code : "CLOUD_RECORD_READ_FAILED",
+        updatedAt: row.updated_at
+      };
+    }
+  }
+  async listCloudDataRecords(userId, kind) {
+    const rows = await this._db.prepare("SELECT * FROM cloud_data_records WHERE user_id=? AND kind=? ORDER BY updated_at DESC, id").bind(userId, kind).all();
+    return Promise.all((rows.results || []).map((row) => this._cloudRecordForList(row)));
+  }
+  async listCloudDataRecordsAcrossUsers(kind) {
+    const rows = await this._db.prepare("SELECT * FROM cloud_data_records WHERE kind=? ORDER BY updated_at, id").bind(kind).all();
+    return Promise.all((rows.results || []).map((row) => this._cloudRecordForList(row)));
+  }
+  async claimCloudDataRecord(userId, kind, id, leaseMs, leaseToken = null) {
+    const now = Date.now();
+    const result = await this._db.prepare(
+      `UPDATE cloud_data_records SET lease_until=?,lease_token=?
+      WHERE user_id=? AND kind=? AND id=? AND (lease_until IS NULL OR lease_until <= ?)`
+    ).bind(now + leaseMs, leaseToken, userId, kind, id, now).run();
+    return result.meta.changes > 0;
+  }
+  async releaseCloudDataRecord(userId, kind, id, leaseToken) {
+    const tokenGate = leaseToken === void 0 ? "" : " AND lease_token=?";
+    const params = [userId, kind, id, ...leaseToken === void 0 ? [] : [leaseToken]];
+    await this._db.prepare(`UPDATE cloud_data_records SET lease_until=NULL,lease_token=NULL WHERE user_id=? AND kind=? AND id=?${tokenGate}`).bind(...params).run();
+  }
+  async renewCloudDataRecordLease(userId, kind, id, leaseMs, leaseToken) {
+    const now = Date.now();
+    const result = await this._db.prepare(
+      `UPDATE cloud_data_records SET lease_until=?
+      WHERE user_id=? AND kind=? AND id=? AND lease_token=? AND lease_until>?`
+    ).bind(now + leaseMs, userId, kind, id, leaseToken, now).run();
+    return result.meta.changes > 0;
+  }
+  async deleteCloudDataRecord(userId, kind, id) {
+    if (!this.cloudDataManagement) throw new Error("Cloud management requires transactional batches");
+    const results = await this._db.batch([
+      this._db.prepare("DELETE FROM cloud_data_record_chunks WHERE user_id=? AND kind=? AND id=?").bind(userId, kind, id),
+      this._db.prepare("DELETE FROM cloud_data_records WHERE user_id=? AND kind=? AND id=?").bind(userId, kind, id)
+    ]);
+    return results[1].meta.changes > 0;
+  }
+  async cleanupCloudDataRecords(kind, beforeMs) {
+    if (!this.cloudDataManagement) throw new Error("Cloud management requires transactional batches");
+    const now = Date.now();
+    const results = await this._db.batch([
+      this._db.prepare(`DELETE FROM cloud_data_record_chunks AS c WHERE c.kind=? AND EXISTS
+        (SELECT 1 FROM cloud_data_records r WHERE r.user_id=c.user_id AND r.kind=c.kind AND r.id=c.id
+          AND r.updated_at < ? AND (r.lease_until IS NULL OR r.lease_until <= ?))`).bind(kind, beforeMs, now),
+      this._db.prepare(`DELETE FROM cloud_data_records WHERE kind=? AND updated_at < ?
+        AND (lease_until IS NULL OR lease_until <= ?)`).bind(kind, beforeMs, now)
+    ]);
+    return results[1].meta.changes || 0;
+  }
+  /** Sidecars are indexes only. Remove them only while their backing row is absent. */
+  async cleanupCloudResourceMetadata(userId = null) {
+    const targets = {
+      task: `SELECT 1 FROM scheduled_messages r WHERE r.user_id=m.user_id AND r.uuid=json_extract(m.resource_key,'$[1]')`,
+      state: `SELECT 1 FROM client_state r WHERE r.user_id=m.user_id AND
+        ((r.namespace=json_extract(m.resource_key,'$[1]') AND r.key=json_extract(m.resource_key,'$[2]')) OR
+        (r.namespace=char(31)||'amsg-chunks'||char(31)||json_extract(m.resource_key,'$[1]')
+          AND r.key >= json_extract(m.resource_key,'$[2]')||char(31)
+          AND r.key < json_extract(m.resource_key,'$[2]')||char(32)))`,
+      credential: `SELECT 1 FROM llm_credentials r WHERE r.user_id=m.user_id AND r.cred_id=json_extract(m.resource_key,'$[1]')`,
+      outbox: `SELECT 1 FROM message_outbox r WHERE r.user_id=m.user_id AND r.message_id=json_extract(m.resource_key,'$[1]')`,
+      subscription: `SELECT 1 FROM push_subscriptions r WHERE r.user_id=m.user_id`
+    };
+    const statements = Object.entries(targets).map(([type, exists]) => this._db.prepare(
+      `DELETE FROM cloud_resource_metadata AS m WHERE (? IS NULL OR user_id=?) AND json_valid(resource_key)
+        AND json_extract(resource_key,'$[0]')=? AND NOT EXISTS (${exists})`
+    ).bind(userId, userId, type));
+    const results = await this._cloudBatch(statements, userId);
+    return results.reduce((sum, result) => sum + (result.meta.changes || 0), 0);
+  }
+  async listCloudOwners(userId) {
+    const response = await this._db.prepare("SELECT owner_type,owner_id,active,generation,updated_at FROM cloud_data_owners WHERE user_id=? ORDER BY owner_type,owner_id").bind(userId).all();
+    return (response.results || []).map((row) => ({ owner: { type: row.owner_type, id: row.owner_id }, active: !!row.active, generation: row.generation, updatedAt: row.updated_at }));
+  }
+  async getCloudOwner(userId, owner) {
+    const row = await this._db.prepare("SELECT active,generation,updated_at FROM cloud_data_owners WHERE user_id=? AND owner_type=? AND owner_id=?").bind(userId, owner.type, owner.id).first();
+    return row ? { active: !!row.active, generation: row.generation, updatedAt: row.updated_at } : { active: true, generation: 0, updatedAt: null };
+  }
+  async setCloudOwnerActive(userId, owner, active, expectedGeneration) {
+    const statements = [];
+    if (expectedGeneration !== void 0) {
+      if (!Number.isSafeInteger(expectedGeneration) || expectedGeneration < 0) throw new Error("Invalid expected owner generation");
+      statements.push(this._db.prepare(
+        `INSERT INTO cloud_guard_assertions (allowed) SELECT 0 WHERE
+        COALESCE((SELECT generation FROM cloud_data_owners WHERE user_id=? AND owner_type=? AND owner_id=?),0) <> ?`
+      ).bind(userId, owner.type, owner.id, expectedGeneration));
+    }
+    statements.push(this._db.prepare(
+      `INSERT INTO cloud_data_owners (user_id,owner_type,owner_id,active,generation,updated_at)
+      VALUES (?,?,?,?,1,?) ON CONFLICT (user_id,owner_type,owner_id) DO UPDATE SET
+      active=excluded.active,generation=cloud_data_owners.generation+1,updated_at=excluded.updated_at`
+    ).bind(userId, owner.type, owner.id, active ? 1 : 0, Date.now()));
+    statements.push(this._db.prepare("SELECT active,generation,updated_at FROM cloud_data_owners WHERE user_id=? AND owner_type=? AND owner_id=?").bind(userId, owner.type, owner.id));
+    try {
+      if (!this.cloudDataManagement) throw new Error("Cloud management requires transactional batches");
+      const results = await this._db.batch(statements);
+      const row = results[results.length - 1].results[0];
+      return { active: !!row.active, generation: row.generation, updatedAt: row.updated_at };
+    } catch (error) {
+      if (/cloud_owner_guard/.test(error.message || "")) throw Object.assign(new Error("Cloud owner changed; refresh before restoring"), { code: "CLOUD_OWNER_CHANGED" });
+      throw error;
+    }
+  }
+  async isCloudOwnerGuardValid(userId, guard) {
+    if (!guard) return true;
+    const condition = this._cloudGuardPredicate(userId, guard);
+    const row = await this._db.prepare(`SELECT ${condition.sql} AS valid`).bind(...condition.args).first();
+    return !!_optionalChain([row, 'optionalAccess', _45 => _45.valid]);
+  }
+  /** Delete only the exact physical snapshot; no untrusted SQL identifiers. */
+  async deleteCloudResourceRows(userId, locators, { operationId, leaseToken } = {}) {
+    const specs = {
+      task: { table: "scheduled_messages", keys: ["user_id", "id"], columns: ["id", "user_id", "uuid", "encrypted_payload", "message_type", "next_send_at", "lease_until", "retry_after", "serialize_group", "status", "retry_count", "last_error", "created_at", "updated_at"] },
+      state: { table: "client_state", keys: ["user_id", "namespace", "key"], columns: ["user_id", "namespace", "key", "value", "updated_at"] },
+      credential: { table: "llm_credentials", keys: ["user_id", "cred_id"], columns: ["user_id", "cred_id", "encrypted_value", "created_at", "updated_at"] },
+      outbox: { table: "message_outbox", keys: ["user_id", "message_id"], columns: ["id", "user_id", "message_id", "task_uuid", "session_id", "message_index", "total_messages", "payload", "created_at", "delivered_at", "acked_at"] },
+      subscription: { table: "push_subscriptions", keys: ["user_id"], columns: ["user_id", "subscription", "updated_at"] }
+    };
+    let deleted = 0, changed = 0;
+    for (const locator of locators) {
+      const spec = specs[locator.type];
+      if (!spec || !Array.isArray(locator.rows) || !locator.rows.length || locator.rows.some((row) => row.user_id !== userId)) {
+        changed++;
+        continue;
+      }
+      const statements = [];
+      if (operationId !== void 0) {
+        statements.push(this._db.prepare(
+          `INSERT INTO cloud_guard_assertions (lease_allowed)
+          SELECT 0 WHERE NOT EXISTS (SELECT 1 FROM cloud_data_records WHERE user_id=? AND kind='operation'
+            AND id=? AND lease_token=? AND lease_until >
+            CAST(strftime('%s','now') AS INTEGER)*1000 + CAST(substr(strftime('%f','now'),4,3) AS INTEGER))`
+        ).bind(userId, operationId, _nullishCoalesce(leaseToken, () => ( null))));
+      }
+      if (locator.metadataKey && Object.hasOwn(locator, "encryptedMetadata")) {
+        const identityChecks = locator.rows.map((row) => ({
+          sql: `EXISTS (SELECT 1 FROM ${spec.table} WHERE ${spec.keys.map((column) => `${column} IS ?`).join(" AND ")})`,
+          args: spec.keys.map((column) => row[column])
+        }));
+        for (const check of identityChecks) statements.push(this._db.prepare(
+          `INSERT INTO cloud_guard_assertions (allowed) SELECT 0 WHERE ${check.sql}
+           AND NOT ((SELECT encrypted_value FROM cloud_resource_metadata WHERE user_id=? AND resource_key=?) IS ?)`
+        ).bind(...check.args, userId, locator.metadataKey, locator.encryptedMetadata));
+      }
+      if (locator.type === "state" && locator.logicalState) {
+        const { namespace, key } = locator.logicalState;
+        const identities = JSON.stringify(locator.rows.map((row) => ({ namespace: row.namespace, key: row.key })));
+        statements.push(this._db.prepare(
+          `INSERT INTO cloud_guard_assertions (allowed)
+          SELECT 0 WHERE EXISTS (SELECT 1 FROM client_state r WHERE r.user_id=? AND
+            ((r.namespace=? AND r.key=?) OR (r.namespace=? AND r.key>=? AND r.key<?))
+            AND NOT EXISTS (SELECT 1 FROM json_each(?) e WHERE
+              r.namespace=json_extract(e.value,'$.namespace') AND r.key=json_extract(e.value,'$.key')))`
+        ).bind(userId, namespace, key, "amsg-chunks" + namespace, key + "", key + " ", identities));
+      }
+      for (const row of locator.rows) {
+        const columns = spec.columns.filter((column) => Object.hasOwn(row, column));
+        const predicate = columns.map((column) => `${column} IS ?`).join(" AND ");
+        const values = columns.map((column) => row[column]);
+        const identity = spec.keys.map((column) => `${column} IS ?`).join(" AND ");
+        statements.push(this._db.prepare(
+          `INSERT INTO cloud_guard_assertions (allowed)
+          SELECT 0 WHERE EXISTS (SELECT 1 FROM ${spec.table} WHERE ${identity})
+          AND NOT EXISTS (SELECT 1 FROM ${spec.table} WHERE ${predicate})`
+        ).bind(...spec.keys.map((column) => row[column]), ...values));
+      }
+      for (const row of locator.rows) {
+        const columns = spec.columns.filter((column) => Object.hasOwn(row, column));
+        statements.push(this._db.prepare(`DELETE FROM ${spec.table} WHERE ${columns.map((column) => `${column} IS ?`).join(" AND ")}`).bind(...columns.map((column) => row[column])));
+      }
+      if (locator.metadataKey) statements.push(this._db.prepare("DELETE FROM cloud_resource_metadata WHERE user_id=? AND resource_key=?").bind(userId, locator.metadataKey));
+      try {
+        if (!this.cloudDataManagement) throw new Error("Cloud management requires transactional batches");
+        await this._db.batch(statements);
+        deleted++;
+      } catch (error) {
+        if (/cloud_lease_guard/.test(error.message || "")) throw Object.assign(new Error("Cloud operation processing lease was lost"), { code: "CLOUD_LEASE_LOST" });
+        if (/cloud_owner_guard/.test(error.message || "")) changed++;
+        else throw error;
+      }
+    }
+    return { deleted, changed };
+  }
   async initSchema() {
     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(LLM_CREDENTIALS_TABLE_SQL).run();
     await this._db.prepare(MESSAGE_OUTBOX_TABLE_SQL).run();
+    for (const sql of CLOUD_DATA_TABLES_SQL) await this._db.prepare(sql).run();
     for (const migration of SQLITE_MIGRATIONS) {
       try {
         await this._db.prepare(migration.sql).run();
@@ -4761,15 +5612,21 @@ var D1Adapter = class {
     await this._db.prepare("DROP TABLE IF EXISTS push_subscriptions").run();
     await this._db.prepare("DROP TABLE IF EXISTS llm_credentials").run();
     await this._db.prepare("DROP TABLE IF EXISTS message_outbox").run();
+    for (const table of ["cloud_data_record_chunks", "cloud_data_records", "cloud_data_owners", "cloud_resource_metadata", "cloud_guard_assertions"]) {
+      await this._db.prepare(`DROP TABLE IF EXISTS ${table}`).run();
+    }
   }
-  async createTask(params) {
+  async createTask(params, cloudGuard = params.cloudGuard) {
     const now = this._now();
     const nextSendAt = this._iso(params.next_send_at);
-    const res = await this._db.prepare(
+    const stmt = 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).run();
+    ).bind(params.user_id, params.uuid, params.encrypted_payload, nextSendAt, params.message_type, now, now);
+    const [res] = await this._cloudBatch([stmt], params.user_id, [cloudGuard], /* @__PURE__ */ new Map([
+      [0, { key: JSON.stringify(["task", params.uuid]), value: params.encryptedCloudMetadata, ...Object.hasOwn(params, "expectedCloudMetadata") ? { expected: params.expectedCloudMetadata } : {} }]
+    ]));
     const id = res.meta.last_row_id;
     return this._db.prepare(
       `SELECT id, uuid, next_send_at, status, created_at FROM scheduled_messages WHERE id = ?`
@@ -4787,7 +5644,7 @@ var D1Adapter = class {
    * @returns {Promise<Object>} createTask 的返回行 + `superseded`（旧行是否
    *   真的被删掉；false = 旧行本就不存在）
    */
-  async createTaskSuperseding(params, supersedesUuid) {
+  async createTaskSuperseding(params, supersedesUuid, cloudGuard = params.cloudGuard) {
     const now = this._now();
     const nextSendAt = this._iso(params.next_send_at);
     const statements = [
@@ -4800,13 +5657,9 @@ var D1Adapter = class {
          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 results = await this._cloudBatch(statements, params.user_id, [cloudGuard], /* @__PURE__ */ new Map([
+      [1, { key: JSON.stringify(["task", params.uuid]), value: params.encryptedCloudMetadata, ...Object.hasOwn(params, "expectedCloudMetadata") ? { expected: params.expectedCloudMetadata } : {} }]
+    ]));
     const superseded = (results[0].meta.changes || 0) > 0;
     const id = results[1].meta.last_row_id;
     const row = await this._db.prepare(
@@ -4843,7 +5696,7 @@ var D1Adapter = class {
     ).bind(uuid).first();
     return row ? { status: row.status } : null;
   }
-  async updateTaskById(taskId, updates) {
+  async updateTaskById(taskId, updates, cloudGuard = null) {
     const sets = [];
     const values = [];
     for (const [key, value] of Object.entries(updates)) {
@@ -4858,9 +5711,12 @@ var D1Adapter = class {
       values.push(this._now());
     }
     values.push(taskId);
-    await this._db.prepare(
+    const statement = this._db.prepare(
       `UPDATE scheduled_messages SET ${sets.join(", ")} WHERE id = ?`
-    ).bind(...values).run();
+    ).bind(...values);
+    const ownerUser = cloudGuard ? await this._db.prepare("SELECT user_id FROM scheduled_messages WHERE id=?").bind(taskId).first() : null;
+    if (cloudGuard && !ownerUser) return null;
+    await this._cloudBatch([statement], _optionalChain([ownerUser, 'optionalAccess', _46 => _46.user_id]), [cloudGuard]);
     return this._db.prepare("SELECT * FROM scheduled_messages WHERE id = ?").bind(taskId).first();
   }
   /**
@@ -4872,7 +5728,7 @@ var D1Adapter = class {
    * ——用户以为改期生效了，实际什么都没留下。正文这类字段不受这道门约束：它们
    * 只影响以后的触发，收尾那边本来就不会覆盖（见 run-tick 的收尾守卫）。
    */
-  async updateTaskByUuid(uuid, userId, encryptedPayload, extraFields) {
+  async updateTaskByUuid(uuid, userId, encryptedPayload, extraFields, cloudGuard = null) {
     const now = this._now();
     const sets = ["encrypted_payload = ?", "updated_at = ?"];
     const values = [encryptedPayload, now];
@@ -4891,10 +5747,11 @@ var D1Adapter = class {
       leaseGate = " AND (lease_until IS NULL OR lease_until <= ?)";
       values.push(now);
     }
-    const res = await this._db.prepare(
+    const statement = this._db.prepare(
       `UPDATE scheduled_messages SET ${sets.join(", ")}
        WHERE uuid = ? AND user_id = ? AND status = 'pending'${leaseGate}`
-    ).bind(...values).run();
+    ).bind(...values);
+    const [res] = await this._cloudBatch([statement], userId, [cloudGuard]);
     if (!res.meta.changes) return null;
     return { uuid, updated_at: now };
   }
@@ -4955,7 +5812,7 @@ var D1Adapter = class {
    * @returns {Promise<boolean>} true = 领到了；false = 别人正拿着租约、同分组
    *   有任务正在跑、排期被改过、或行已不是 pending
    */
-  async claimTask(taskId, expectedNextSendAt, leaseUntil, serializeGroup = null) {
+  async claimTask(taskId, expectedNextSendAt, leaseUntil, serializeGroup = null, cloudGuard = null) {
     const expected = typeof expectedNextSendAt === "string" ? expectedNextSendAt : this._iso(expectedNextSendAt);
     const grouped = typeof serializeGroup === "string" && serializeGroup.length > 0;
     const now = this._now();
@@ -4979,9 +5836,12 @@ var D1Adapter = class {
           )`;
       values.push(serializeGroup, taskId, now);
     }
-    const res = await this._db.prepare(
+    const statement = this._db.prepare(
       `UPDATE scheduled_messages SET ${sets.join(", ")} WHERE ${where}`
-    ).bind(...values).run();
+    ).bind(...values);
+    const ownerUser = cloudGuard ? await this._db.prepare("SELECT user_id FROM scheduled_messages WHERE id=?").bind(taskId).first() : null;
+    if (cloudGuard && !ownerUser) return false;
+    const [res] = await this._cloudBatch([statement], _optionalChain([ownerUser, 'optionalAccess', _47 => _47.user_id]), [cloudGuard]);
     return (res.meta.changes || 0) > 0;
   }
   /**
@@ -4993,11 +5853,14 @@ var D1Adapter = class {
    * @param {string|Date} leaseUntil - 新的租期末尾
    * @returns {Promise<boolean>} true = 续上了
    */
-  async renewTaskLease(taskId, leaseUntil) {
-    const res = await this._db.prepare(
+  async renewTaskLease(taskId, leaseUntil, cloudGuard = null) {
+    const statement = 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();
+    ).bind(this._iso(leaseUntil), taskId);
+    const ownerUser = cloudGuard ? await this._db.prepare("SELECT user_id FROM scheduled_messages WHERE id=?").bind(taskId).first() : null;
+    if (cloudGuard && !ownerUser) return false;
+    const [res] = await this._cloudBatch([statement], _optionalChain([ownerUser, 'optionalAccess', _48 => _48.user_id]), [cloudGuard]);
     return (res.meta.changes || 0) > 0;
   }
   async listTasks(userId, opts = {}) {
@@ -5094,7 +5957,7 @@ var D1Adapter = class {
    *   回 `true` = 这个 key 的行已经不在（删掉了，或本来就没有）、`false` = 行还在
    *   （库里那行更新，删除被条件写拦下）；前缀形态不探测，回 `null`。
    */
-  async upsertClientState(userId, entries, cleanups = [], now = Date.now()) {
+  async upsertClientState(userId, entries, cleanups = [], now = Date.now(), cloudGuard = null) {
     const UPSERT_SQL = `INSERT INTO client_state (user_id, namespace, key, value, updated_at)
        VALUES (?, ?, ?, ?, ?)
        ON CONFLICT (user_id, namespace, key) DO UPDATE SET
@@ -5111,8 +5974,12 @@ var D1Adapter = class {
     const PROBE_KEY_SQL = `SELECT COUNT(*) AS n FROM client_state
        WHERE user_id = ? AND namespace = ? AND key = ?`;
     const statements = [];
+    const metadata = /* @__PURE__ */ new Map();
     const probeIndexes = [];
     for (const c of cleanups) {
+      if (typeof c.cloudMetadataKey === "string" && Object.hasOwn(c, "expectedCloudMetadata")) {
+        metadata.set(statements.length, { key: c.cloudMetadataKey, expected: c.expectedCloudMetadata });
+      }
       if (typeof c.key === "string") {
         statements.push(this._db.prepare(CLEANUP_KEY_SQL).bind(userId, c.namespace, c.key, c.updatedAt, now));
         probeIndexes.push(statements.length);
@@ -5130,15 +5997,17 @@ var D1Adapter = class {
         this._db.prepare(UPSERT_SQL).bind(userId, entry.namespace, entry.key, entry.value, entry.updatedAt, 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());
-      }
-    }
+    entries.forEach((entry, index) => metadata.set(upsertStart + index, {
+      key: JSON.stringify(["state", entry.namespace, entry.key]),
+      value: entry.encryptedCloudMetadata,
+      ...Object.hasOwn(entry, "expectedCloudMetadata") ? { expected: entry.expectedCloudMetadata } : {}
+    }));
+    const results = await this._cloudBatch(
+      statements,
+      userId,
+      [cloudGuard, ...entries.map((entry) => entry.cloudGuard), ...cleanups.map((entry) => entry.cloudGuard)],
+      metadata
+    );
     const outcomes = results.slice(upsertStart).map((res) => res.meta.changes > 0);
     let upserted = 0;
     let skipped = 0;
@@ -5151,7 +6020,7 @@ var D1Adapter = class {
       result.cleanupOutcomes = probeIndexes.map((probeAt) => {
         if (probeAt === null) return null;
         const row = results[probeAt] && Array.isArray(results[probeAt].results) ? results[probeAt].results[0] : null;
-        return Number(_nullishCoalesce(_optionalChain([row, 'optionalAccess', _8 => _8.n]), () => ( 0))) === 0;
+        return Number(_nullishCoalesce(_optionalChain([row, 'optionalAccess', _49 => _49.n]), () => ( 0))) === 0;
       });
     }
     return result;
@@ -5362,7 +6231,7 @@ var D1Adapter = class {
    * @param {Array<{ credId: string, encryptedValue: string }>} entries
    * @returns {Promise<number>} 实际写入/覆盖的行数
    */
-  async upsertLlmCredentials(userId, entries) {
+  async upsertLlmCredentials(userId, entries, cloudGuard = null) {
     if (!entries || entries.length === 0) return 0;
     const now = this._now();
     const SQL = `INSERT INTO llm_credentials (user_id, cred_id, encrypted_value, created_at, updated_at)
@@ -5373,13 +6242,12 @@ var D1Adapter = class {
     const statements = entries.map(
       (entry) => this._db.prepare(SQL).bind(userId, entry.credId, entry.encryptedValue, 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 metadata = new Map(entries.map((entry, index) => [index, {
+      key: JSON.stringify(["credential", entry.credId]),
+      value: entry.encryptedCloudMetadata,
+      ...Object.hasOwn(entry, "expectedCloudMetadata") ? { expected: entry.expectedCloudMetadata } : {}
+    }]));
+    const results = await this._cloudBatch(statements, userId, [cloudGuard, ...entries.map((entry) => entry.cloudGuard)], metadata);
     return results.reduce((n, res) => n + ((res.meta.changes || 0) > 0 ? 1 : 0), 0);
   }
   /**
@@ -5487,7 +6355,7 @@ var D1Adapter = class {
    *   `payload` 是整条 push JSON 的 encryptForStorage 密文。
    * @returns {Promise<number>} 实际写入/更新的行数
    */
-  async appendOutboxMessages(userId, rows) {
+  async appendOutboxMessages(userId, rows, cloudGuard = null) {
     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)
@@ -5509,13 +6377,12 @@ var D1Adapter = class {
         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());
-    }
+    const metadata = new Map(rows.map((row, index) => [index, {
+      key: JSON.stringify(["outbox", row.message_id]),
+      value: row.encryptedCloudMetadata,
+      ...Object.hasOwn(row, "expectedCloudMetadata") ? { expected: row.expectedCloudMetadata } : {}
+    }]));
+    const results = await this._cloudBatch(statements, userId, [cloudGuard, ...rows.map((row) => row.cloudGuard)], metadata);
     return results.reduce((n, res) => n + ((res.meta.changes || 0) > 0 ? 1 : 0), 0);
   }
   /**
@@ -6012,7 +6879,7 @@ function createClientStateNamespacesHandler(ctx) {
 }
 
 // src/server/lib/version.js
-var SERVER_VERSION = true ? "2.6.0-next.32" : "0.0.0-dev";
+var SERVER_VERSION = true ? "2.6.0-next.34" : "0.0.0-dev";
 
 // src/server/handlers/capabilities.js
 var SERVER_FEATURES = Object.freeze([
@@ -6125,7 +6992,10 @@ var SERVER_FEATURES = Object.freeze([
   // 工厂配置认 maxDeliveryRetries（投递失败的重试次数上限，默认 3）。
   "max-delivery-retries",
   // Per-task pre-commit retry limit and fire receipt retry decision.
-  "max-generation-retries"
+  "max-generation-retries",
+  // onBeforeFire 认 { defer: { afterMs } }：这次不生成，过一会儿再来问（不占重试
+  // 次数）；onFireSettled 的 status 多一种 'deferred'，带 retryAfter。
+  "before-fire-defer"
 ]);
 function createCapabilitiesHandler(ctx) {
   async function GET(url, headers) {
@@ -6136,12 +7006,927 @@ function createCapabilitiesHandler(ctx) {
     }
     return {
       status: 200,
-      body: { success: true, serverVersion: SERVER_VERSION, features: [...SERVER_FEATURES] }
+      body: { success: true, serverVersion: SERVER_VERSION, features: [...SERVER_FEATURES, ...tenantResult.context.db.cloudDataManagement ? ["cloud-data-management"] : []] }
     };
   }
   return { GET };
 }
 
+// src/server/lib/cloud-data-inventory.js
+var encoder = new TextEncoder();
+async function cloudDataHash(value) {
+  const digest = await crypto.subtle.digest("SHA-256", encoder.encode(value));
+  return Array.from(
+    new Uint8Array(digest),
+    (byte) => byte.toString(16).padStart(2, "0")
+  ).join("");
+}
+function timestamp(value) {
+  if (value == null) return null;
+  const parsed = typeof value === "number" ? value : Date.parse(value);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+function safeOwner(owner) {
+  if (!owner || typeof owner.type !== "string" || !owner.type || typeof owner.id !== "string" || !owner.id)
+    return null;
+  return {
+    type: owner.type,
+    id: owner.id,
+    ...typeof owner.label === "string" ? { label: owner.label } : {}
+  };
+}
+function objectOrText(value) {
+  try {
+    return JSON.parse(value);
+  } catch (e5) {
+    return value;
+  }
+}
+async function buildCloudDataInventory({
+  db,
+  userId,
+  userKey,
+  resolveOwner
+}) {
+  const raw = await db.listCloudResourceRows(userId);
+  const gaps = [...raw.gaps || []];
+  const entries = [];
+  const metadata = new Map(
+    (raw.metadata || []).map((row) => [row.resource_key, row.encrypted_value])
+  );
+  const taskPayloads = /* @__PURE__ */ new Map();
+  const taskByUuid = /* @__PURE__ */ new Map();
+  for (const row of raw.task || []) {
+    try {
+      const payload = JSON.parse(
+        await decryptFromStorage(row.encrypted_payload, userKey)
+      );
+      taskPayloads.set(row.id, payload);
+      if (row.uuid) taskByUuid.set(row.uuid, payload);
+    } catch (e6) {
+    }
+  }
+  const tasks = (raw.task || []).filter((row) => taskPayloads.has(row.id)).map((row) => ({ ...taskPayloads.get(row.id), uuid: row.uuid }));
+  const add = async ({
+    type,
+    identity,
+    rows,
+    value,
+    payload,
+    task,
+    unreadable = false,
+    status = null,
+    namespace,
+    key,
+    credId
+  }) => {
+    const metadataKey = JSON.stringify([type, ...identity]);
+    const id = await cloudDataHash(JSON.stringify([userId, metadataKey]));
+    let stored = null;
+    const encryptedMetadata = metadata.get(metadataKey);
+    if (encryptedMetadata) {
+      try {
+        stored = JSON.parse(
+          await decryptFromStorage(encryptedMetadata, userKey)
+        );
+      } catch (e7) {
+        unreadable = true;
+      }
+    }
+    let resolved = null;
+    if (resolveOwner) {
+      try {
+        resolved = await resolveOwner({
+          type,
+          namespace,
+          key,
+          credId,
+          value,
+          payload,
+          task,
+          tasks
+        });
+      } catch (e8) {
+        gaps.push({
+          source: type,
+          code: "OWNER_RESOLUTION_FAILED",
+          message: "A resource owner could not be resolved"
+        });
+      }
+    }
+    const owner = safeOwner(_optionalChain([stored, 'optionalAccess', _50 => _50.owner])) || safeOwner(_optionalChain([payload, 'optionalAccess', _51 => _51.__cloudOwnerGuard, 'optionalAccess', _52 => _52.owner])) || safeOwner(_optionalChain([payload, 'optionalAccess', _53 => _53.metadata, 'optionalAccess', _54 => _54.cloudOwner])) || safeOwner(_optionalChain([payload, 'optionalAccess', _55 => _55.metadata, 'optionalAccess', _56 => _56.owner])) || safeOwner(_optionalChain([payload, 'optionalAccess', _57 => _57.owner])) || safeOwner(_optionalChain([task, 'optionalAccess', _58 => _58.__cloudOwnerGuard, 'optionalAccess', _59 => _59.owner])) || safeOwner(_optionalChain([task, 'optionalAccess', _60 => _60.metadata, 'optionalAccess', _61 => _61.cloudOwner])) || safeOwner(_optionalChain([task, 'optionalAccess', _62 => _62.metadata, 'optionalAccess', _63 => _63.owner])) || safeOwner(_optionalChain([task, 'optionalAccess', _64 => _64.owner])) || safeOwner(_optionalChain([resolved, 'optionalAccess', _65 => _65.owner]));
+    const kind = _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(_nullishCoalesce(_optionalChain([stored, 'optionalAccess', _66 => _66.kind]), () => ( _optionalChain([payload, 'optionalAccess', _67 => _67.metadata, 'optionalAccess', _68 => _68.kind]))), () => ( _optionalChain([payload, 'optionalAccess', _69 => _69.kind]))), () => ( _optionalChain([resolved, 'optionalAccess', _70 => _70.kind]))), () => ( null));
+    const times = rows.map((row) => timestamp(_nullishCoalesce(row.updated_at, () => ( row.created_at)))).filter((time) => time !== null);
+    const byteSize = rows.reduce(
+      (sum, row) => sum + encoder.encode(
+        String(
+          _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(_nullishCoalesce(_nullishCoalesce(row.value, () => ( row.encrypted_payload)), () => ( row.encrypted_value)), () => ( row.payload)), () => ( row.subscription)), () => ( ""))
+        )
+      ).length,
+      0
+    );
+    const label = type === "state" ? `${namespace}/${key}` : type === "credential" ? credId : type === "task" ? rows[0].uuid || `task row ${rows[0].id}` : type === "outbox" ? rows[0].message_id : "Web Push subscription";
+    entries.push({
+      resource: {
+        id,
+        type,
+        owner,
+        kind: typeof kind === "string" ? kind : null,
+        label,
+        byteSize,
+        updatedAt: times.length ? Math.max(...times) : null,
+        status: unreadable ? "unreadable" : status
+      },
+      locator: {
+        type,
+        rows,
+        metadataKey,
+        encryptedMetadata: encryptedMetadata || null,
+        ...type === "state" ? { logicalState: { namespace, key } } : {}
+      },
+      version: await cloudDataHash(
+        JSON.stringify({ rows, encryptedMetadata: encryptedMetadata || null })
+      )
+    });
+  };
+  for (const row of raw.task || []) {
+    const payload = taskPayloads.get(row.id);
+    await add({
+      type: "task",
+      identity: [_nullishCoalesce(row.uuid, () => ( ["row", row.id]))],
+      rows: [row],
+      payload,
+      task: payload,
+      unreadable: !payload,
+      status: row.status
+    });
+  }
+  const stateRows = raw.state || [];
+  const roots = stateRows.filter((row) => !isChunkNamespace(row.namespace));
+  const chunks = /* @__PURE__ */ new Map();
+  for (const row of stateRows.filter(
+    (row2) => isChunkNamespace(row2.namespace)
+  )) {
+    const separator = row.key.lastIndexOf("");
+    const namespace = row.namespace.slice(CHUNK_NAMESPACE_PREFIX.length);
+    const key = separator >= 0 ? row.key.slice(0, separator) : row.key;
+    const group = JSON.stringify([namespace, key]);
+    if (!chunks.has(group)) chunks.set(group, []);
+    chunks.get(group).push(row);
+  }
+  for (const row of roots) {
+    const group = JSON.stringify([row.namespace, row.key]);
+    const slices = chunks.get(group) || [];
+    chunks.delete(group);
+    const rows = [row, ...slices.sort((a, b) => a.key.localeCompare(b.key))];
+    let value, unreadable = false;
+    try {
+      const count = parseChunkedRootCount(row.value);
+      if (count === null) value = await decryptFromStorage(row.value, userKey);
+      else {
+        if (count > slices.length) throw new Error("Missing state chunks");
+        const parts = [];
+        for (let i = 0; i < count; i++) {
+          const slice = slices.find(
+            (candidate) => candidate.key === chunkKeyFor(row.key, i)
+          );
+          if (!slice || slice.updated_at !== row.updated_at)
+            throw new Error("Mismatched state chunks");
+          parts.push(await decryptFromStorage(slice.value, userKey));
+        }
+        value = parts.join("");
+      }
+    } catch (e9) {
+      unreadable = true;
+    }
+    await add({
+      type: "state",
+      identity: [row.namespace, row.key],
+      namespace: row.namespace,
+      key: row.key,
+      rows,
+      value,
+      unreadable,
+      status: null
+    });
+  }
+  for (const [group, rows] of chunks) {
+    const [namespace, key] = JSON.parse(group);
+    await add({
+      type: "state",
+      identity: [namespace, key],
+      namespace,
+      key,
+      rows,
+      status: "orphan-chunks"
+    });
+  }
+  for (const row of raw.credential || []) {
+    await add({
+      type: "credential",
+      identity: [row.cred_id],
+      credId: row.cred_id,
+      rows: [row],
+      status: null
+    });
+  }
+  for (const row of raw.outbox || []) {
+    let payload, unreadable = false;
+    try {
+      payload = objectOrText(await decryptFromStorage(row.payload, userKey));
+    } catch (e10) {
+      unreadable = true;
+    }
+    await add({
+      type: "outbox",
+      identity: [row.message_id],
+      rows: [row],
+      payload,
+      task: taskByUuid.get(row.task_uuid),
+      unreadable,
+      status: row.acked_at != null ? "acked" : row.delivered_at != null ? "delivered" : "pending"
+    });
+  }
+  for (const row of raw.subscription || []) {
+    await add({
+      type: "subscription",
+      identity: [userId],
+      rows: [row],
+      status: "registered"
+    });
+  }
+  const ownerLabels = /* @__PURE__ */ new Map();
+  for (const { resource } of entries) {
+    const owner = resource.owner;
+    if (!_optionalChain([owner, 'optionalAccess', _71 => _71.label, 'optionalAccess', _72 => _72.trim, 'call', _73 => _73()])) continue;
+    const identity = JSON.stringify([owner.type, owner.id]);
+    const current = ownerLabels.get(identity);
+    if (!current || (_nullishCoalesce(resource.updatedAt, () => ( 0))) > current.updatedAt) {
+      ownerLabels.set(identity, {
+        label: owner.label,
+        updatedAt: _nullishCoalesce(resource.updatedAt, () => ( 0))
+      });
+    }
+  }
+  for (const { resource } of entries) {
+    const owner = resource.owner;
+    if (!owner || _optionalChain([owner, 'access', _74 => _74.label, 'optionalAccess', _75 => _75.trim, 'call', _76 => _76()])) continue;
+    const known = ownerLabels.get(JSON.stringify([owner.type, owner.id]));
+    if (known) resource.owner = { ...owner, label: known.label };
+  }
+  entries.sort((a, b) => a.resource.id.localeCompare(b.resource.id));
+  return { entries, complete: gaps.length === 0, gaps };
+}
+
+// src/server/lib/cloud-data-cleanup.js
+var CLOUD_RESOURCE_TYPES = [
+  "task",
+  "state",
+  "credential",
+  "outbox",
+  "subscription"
+];
+function cloudError(code, message, status = 400) {
+  return Object.assign(new Error(message), { code, status });
+}
+function validCloudOwner(owner) {
+  return owner && typeof owner.type === "string" && owner.type.length > 0 && owner.type.length <= 100 && typeof owner.id === "string" && owner.id.length > 0 && owner.id.length <= 300;
+}
+var ownerEquals = (a, b) => a && b && a.type === b.type && a.id === b.id;
+async function cloudInventory(ctx, db, userId, userKey) {
+  return buildCloudDataInventory({
+    db,
+    userId,
+    userKey,
+    resolveOwner: _optionalChain([ctx, 'access', _77 => _77.cloudData, 'optionalAccess', _78 => _78.resolveOwner])
+  });
+}
+async function save(db, userId, key, kind, value, options) {
+  return db.putCloudDataRecord(
+    userId,
+    kind,
+    value.id,
+    await encryptForStorage(
+      JSON.stringify({
+        ...value,
+        ...value.entries ? { entries: value.entries.map(({ locator, ...entry }) => entry) } : {}
+      }),
+      key
+    ),
+    options
+  );
+}
+async function readCloudRecord(db, userId, key, kind, id) {
+  const record = await db.getCloudDataRecord(userId, kind, id);
+  if (!record)
+    throw cloudError("CLOUD_RECORD_NOT_FOUND", "\u4E91\u7AEF\u7BA1\u7406\u8BB0\u5F55\u4E0D\u5B58\u5728", 404);
+  return JSON.parse(await decryptFromStorage(record.data, key));
+}
+function publicOperation(operation) {
+  const {
+    entries,
+    cursor,
+    attempts,
+    nextAttemptAt,
+    knownResourceIds,
+    knownResourceVersions,
+    ...publicValue
+  } = operation;
+  return publicValue;
+}
+async function makeCleanupPlan(ctx, db, userId, key, input) {
+  const { mode, owner, resourceIds, types } = input;
+  if (!["purge", "retire-owner"].includes(mode))
+    throw cloudError("INVALID_CLEANUP_MODE", "\u6E05\u7406\u6A21\u5F0F\u65E0\u6548");
+  if (owner !== void 0 && !validCloudOwner(owner))
+    throw cloudError("INVALID_CLOUD_OWNER", "\u5F52\u5C5E\u683C\u5F0F\u65E0\u6548");
+  if (mode === "retire-owner" && !validCloudOwner(owner))
+    throw cloudError("INVALID_CLOUD_OWNER", "\u5F7B\u5E95\u79FB\u9664\u9700\u8981\u660E\u786E\u5F52\u5C5E");
+  if (resourceIds !== void 0 && (!Array.isArray(resourceIds) || !resourceIds.length || resourceIds.some((id) => typeof id !== "string")))
+    throw cloudError("INVALID_CLEANUP_SELECTION", "\u8BF7\u9009\u62E9\u81F3\u5C11\u4E00\u9879\u8D44\u6E90");
+  if (types !== void 0 && (!Array.isArray(types) || !types.length || types.some((type) => !CLOUD_RESOURCE_TYPES.includes(type))))
+    throw cloudError("INVALID_CLEANUP_SELECTION", "\u8D44\u6E90\u7C7B\u522B\u65E0\u6548");
+  if (mode === "purge" && !owner && !_optionalChain([resourceIds, 'optionalAccess', _79 => _79.length]))
+    throw cloudError("INVALID_CLEANUP_SELECTION", "\u6E05\u7406\u9700\u8981\u660E\u786E\u8D44\u6E90\u6216\u5F52\u5C5E");
+  if (mode === "retire-owner" && (resourceIds || types))
+    throw cloudError("INVALID_CLEANUP_SELECTION", "\u5F7B\u5E95\u79FB\u9664\u4E0D\u80FD\u9650\u5236\u8D44\u6E90\u7C7B\u522B");
+  const ownerGeneration = mode === "retire-owner" ? (await db.getCloudOwner(userId, owner)).generation : null;
+  const inventory = await cloudInventory(ctx, db, userId, key);
+  if (!inventory.complete)
+    throw cloudError(
+      "CLOUD_INVENTORY_INCOMPLETE",
+      "\u4E91\u7AEF\u6E05\u5355\u4E0D\u5B8C\u6574\uFF0C\u6682\u4E0D\u80FD\u751F\u6210\u6E05\u7406\u8BA1\u5212",
+      409
+    );
+  const entries = inventory.entries.filter(
+    (e) => (!owner || ownerEquals(e.resource.owner, owner)) && (!resourceIds || resourceIds.includes(e.resource.id)) && (!types || types.includes(e.resource.type))
+  );
+  if (resourceIds && new Set(resourceIds).size !== entries.length)
+    throw cloudError(
+      "CLOUD_RESOURCE_NOT_FOUND",
+      "\u90E8\u5206\u9009\u4E2D\u8D44\u6E90\u4E0D\u5B58\u5728\u6216\u4E0D\u5C5E\u4E8E\u5F53\u524D\u8303\u56F4",
+      409
+    );
+  const at = Date.now();
+  const plan = {
+    id: crypto.randomUUID(),
+    mode,
+    ownerGeneration,
+    owner: owner ? { type: owner.type, id: owner.id, label: owner.label } : null,
+    resources: entries.map((e) => e.resource),
+    count: entries.length,
+    counts: CLOUD_RESOURCE_TYPES.map((type) => ({
+      type,
+      count: entries.filter((e) => e.resource.type === type).length
+    })),
+    expiresAt: at + 15 * 60 * 1e3,
+    impacts: mode === "retire-owner" ? [
+      "\u505C\u7528\u6B64\u5F52\u5C5E\uFF0C\u5305\u542B\u6267\u884C\u65F6\u65B0\u589E\u7684\u5168\u90E8\u6240\u5C5E\u8D44\u6E90\u3002",
+      "\u5DF2\u4EA4\u7ED9\u5916\u90E8\u63A8\u9001\u670D\u52A1\u7684\u901A\u77E5\u65E0\u6CD5\u64A4\u56DE\u3002"
+    ] : ["\u4EC5\u6E05\u7406\u9884\u89C8\u4E2D\u7684\u8D44\u6E90\uFF1B\u540E\u7EED\u6B63\u5E38\u5199\u5165\u53EF\u4EE5\u91CD\u65B0\u521B\u5EFA\u3002"],
+    complete: true,
+    gaps: [],
+    entries
+  };
+  await save(db, userId, key, "plan", plan);
+  const { entries: privateEntries, ...publicPlan } = plan;
+  return publicPlan;
+}
+async function startCleanup(ctx, db, userId, key, input) {
+  if (typeof input.planId !== "string" || typeof input.idempotencyKey !== "string" || !input.idempotencyKey.trim() || input.idempotencyKey.length > 200)
+    throw cloudError("INVALID_CLEANUP_OPERATION", "\u9700\u8981\u8BA1\u5212\u7F16\u53F7\u4E0E\u5E42\u7B49\u952E");
+  const existing = await db.getCloudDataRecordByIdempotency(
+    userId,
+    "operation",
+    input.idempotencyKey
+  );
+  if (existing) {
+    const op = JSON.parse(await decryptFromStorage(existing.data, key));
+    if (op.planId !== input.planId)
+      throw cloudError("IDEMPOTENCY_CONFLICT", "\u6B64\u5E42\u7B49\u952E\u5DF2\u7528\u4E8E\u53E6\u4E00\u8BA1\u5212", 409);
+    const resumed = await advanceCleanup(ctx, db, userId, key, op);
+    assertRetirementAcknowledged(resumed);
+    return publicOperation(resumed);
+  }
+  const plan = await readCloudRecord(db, userId, key, "plan", input.planId);
+  if (plan.expiresAt < Date.now())
+    throw cloudError("CLOUD_PLAN_EXPIRED", "\u6E05\u7406\u9884\u89C8\u5DF2\u8FC7\u671F\uFF0C\u8BF7\u91CD\u65B0\u9884\u89C8", 409);
+  if (plan.mode === "retire-owner" && (await db.getCloudOwner(userId, plan.owner)).generation !== plan.ownerGeneration) {
+    throw cloudError("CLOUD_PLAN_CHANGED", "\u5F52\u5C5E\u4EE3\u9645\u5DF2\u53D8\u5316\uFF0C\u8BF7\u91CD\u65B0\u9884\u89C8", 409);
+  }
+  if (plan.mode === "purge") {
+    const current = await cloudInventory(ctx, db, userId, key);
+    if (!current.complete)
+      throw cloudError(
+        "CLOUD_INVENTORY_INCOMPLETE",
+        "\u65E0\u6CD5\u786E\u8BA4\u5F53\u524D\u4E91\u7AEF\u6570\u636E",
+        409
+      );
+    const versions = new Map(
+      current.entries.map((e) => [e.resource.id, e.version])
+    );
+    if (plan.entries.some((e) => versions.get(e.resource.id) !== e.version))
+      throw cloudError(
+        "CLOUD_PLAN_CHANGED",
+        "\u9884\u89C8\u540E\u6570\u636E\u5DF2\u53D8\u5316\uFF0C\u8BF7\u91CD\u65B0\u9884\u89C8",
+        409
+      );
+  }
+  const at = Date.now();
+  const operation = {
+    id: crypto.randomUUID(),
+    planId: plan.id,
+    idempotencyKey: input.idempotencyKey,
+    mode: plan.mode,
+    owner: plan.owner,
+    ownerGeneration: plan.ownerGeneration,
+    fencedGeneration: null,
+    status: "pending",
+    counts: CLOUD_RESOURCE_TYPES.map((type) => ({
+      type,
+      deleted: 0,
+      remaining: plan.entries.filter((e) => e.resource.type === type).length,
+      failed: 0
+    })),
+    errors: [],
+    createdAt: at,
+    updatedAt: at,
+    entries: plan.entries,
+    knownResourceIds: plan.entries.map((entry) => entry.resource.id),
+    knownResourceVersions: Object.fromEntries(
+      plan.entries.map((entry) => [entry.resource.id, entry.version])
+    ),
+    cursor: 0,
+    attempts: 0,
+    nextAttemptAt: 0
+  };
+  const stored = await save(db, userId, key, "operation", operation, {
+    idempotencyKey: input.idempotencyKey
+  });
+  const persisted = JSON.parse(await decryptFromStorage(stored.data, key));
+  if (persisted.planId !== input.planId)
+    throw cloudError("IDEMPOTENCY_CONFLICT", "\u6B64\u5E42\u7B49\u952E\u5DF2\u7528\u4E8E\u53E6\u4E00\u8BA1\u5212", 409);
+  await db.deleteCloudDataRecord(userId, "plan", plan.id);
+  const advanced = await advanceCleanup(ctx, db, userId, key, persisted);
+  assertRetirementAcknowledged(advanced);
+  return publicOperation(advanced);
+}
+function assertRetirementAcknowledged(operation) {
+  if (operation.mode === "retire-owner" && operation.fencedGeneration == null) {
+    throw cloudError(
+      "CLOUD_RETIREMENT_NOT_CONFIRMED",
+      "\u5C1A\u672A\u786E\u8BA4\u4E91\u7AEF\u505C\u7528\uFF0C\u8BF7\u4FDD\u7559\u672C\u5730\u89D2\u8272\u5E76\u91CD\u8BD5\u6216\u67E5\u770B\u4E91\u7AEF\u64CD\u4F5C\u8BB0\u5F55\u3002",
+      503
+    );
+  }
+}
+async function advanceCleanup(ctx, db, userId, key, operation) {
+  if (operation.status === "completed" || operation.status === "failed" || operation.nextAttemptAt > Date.now())
+    return operation;
+  const leaseToken = crypto.randomUUID();
+  const leaseMs = 12e4;
+  if (typeof db.claimCloudDataRecord === "function" && !await db.claimCloudDataRecord(
+    userId,
+    "operation",
+    operation.id,
+    leaseMs,
+    leaseToken
+  ))
+    return operation;
+  const renewLease = async () => {
+    if (!await db.renewCloudDataRecordLease(
+      userId,
+      "operation",
+      operation.id,
+      leaseMs,
+      leaseToken
+    )) {
+      throw cloudError(
+        "CLOUD_LEASE_LOST",
+        "\u6E05\u7406\u5904\u7406\u6743\u5DF2\u4EA4\u7ED9\u53E6\u4E00\u4E2A\u5DE5\u4F5C\u5B9E\u4F8B",
+        409
+      );
+    }
+  };
+  try {
+    operation = await readCloudRecord(
+      db,
+      userId,
+      key,
+      "operation",
+      operation.id
+    );
+    if (operation.status === "completed" || operation.status === "failed")
+      return operation;
+    operation.status = "running";
+    if (operation.mode === "retire-owner") {
+      if (operation.fencedGeneration == null) {
+        const state = await db.setCloudOwnerActive(
+          userId,
+          operation.owner,
+          false,
+          operation.ownerGeneration
+        );
+        operation.fencedGeneration = state.generation;
+        await save(db, userId, key, "operation", operation, { leaseToken });
+      } else {
+        const state = await db.getCloudOwner(userId, operation.owner);
+        if (state.active || state.generation !== operation.fencedGeneration) {
+          throw cloudError(
+            "CLOUD_OWNER_CHANGED",
+            "\u5F52\u5C5E\u5DF2\u53D8\u5316\uFF0C\u5DF2\u505C\u6B62\u65E7\u6E05\u7406\u64CD\u4F5C",
+            409
+          );
+        }
+      }
+      const inventory = await cloudInventory(ctx, db, userId, key);
+      if (!inventory.complete)
+        throw cloudError(
+          "CLOUD_INVENTORY_INCOMPLETE",
+          "\u65E0\u6CD5\u786E\u8BA4\u5F85\u6E05\u7406\u8D44\u6E90",
+          503
+        );
+      const known = new Set(operation.knownResourceIds || []);
+      operation.knownResourceVersions ||= {};
+      operation.entries = inventory.entries.filter((entry) => {
+        if (ownerEquals(entry.resource.owner, operation.owner)) return true;
+        if (!known.has(entry.resource.id)) return false;
+        if (entry.resource.owner || operation.knownResourceVersions[entry.resource.id] !== entry.version) {
+          throw cloudError(
+            "CLOUD_PLAN_CHANGED",
+            "\u5DF2\u8BC6\u522B\u8D44\u6E90\u7684\u5F52\u5C5E\u6216\u5185\u5BB9\u53D1\u751F\u53D8\u5316\uFF0C\u8BF7\u91CD\u65B0\u9884\u89C8",
+            409
+          );
+        }
+        return true;
+      });
+      for (const entry of operation.entries) {
+        known.add(entry.resource.id);
+        operation.knownResourceVersions[entry.resource.id] = entry.version;
+      }
+      operation.knownResourceIds = [...known];
+      operation.cursor = 0;
+      for (const count of operation.counts)
+        count.remaining = operation.entries.filter(
+          (entry) => entry.resource.type === count.type
+        ).length;
+      await save(db, userId, key, "operation", operation, { leaseToken });
+    }
+    const beforeBatch = await cloudInventory(ctx, db, userId, key);
+    if (!beforeBatch.complete)
+      throw cloudError("CLOUD_INVENTORY_INCOMPLETE", "\u65E0\u6CD5\u786E\u8BA4\u5F85\u6E05\u7406\u8D44\u6E90", 503);
+    const currentById = new Map(
+      beforeBatch.entries.map((entry) => [entry.resource.id, entry])
+    );
+    const batch = operation.entries.slice(
+      operation.cursor,
+      operation.cursor + 25
+    );
+    for (const entry of batch) {
+      await renewLease();
+      const currentEntry = currentById.get(entry.resource.id);
+      if (currentEntry && currentEntry.version !== entry.version) {
+        throw cloudError(
+          "CLOUD_PLAN_CHANGED",
+          "\u8D44\u6E90\u5728\u6267\u884C\u524D\u53D8\u5316\uFF0C\u5DF2\u505C\u6B62\u6E05\u7406",
+          409
+        );
+      }
+      const result = currentEntry ? await db.deleteCloudResourceRows(userId, [currentEntry.locator], {
+        operationId: operation.id,
+        leaseToken
+      }) : { changed: 0 };
+      if (result.changed)
+        throw cloudError(
+          "CLOUD_PLAN_CHANGED",
+          "\u8D44\u6E90\u5728\u6267\u884C\u524D\u53D8\u5316\uFF0C\u5DF2\u505C\u6B62\u6E05\u7406",
+          409
+        );
+      const count = operation.counts.find(
+        (c) => c.type === entry.resource.type
+      );
+      count.deleted++;
+      count.remaining = Math.max(0, count.remaining - 1);
+      delete entry.locator;
+      operation.cursor++;
+      operation.updatedAt = Date.now();
+      await save(db, userId, key, "operation", operation, { leaseToken });
+    }
+    await renewLease();
+    const current = await cloudInventory(ctx, db, userId, key);
+    if (!current.complete)
+      throw cloudError(
+        "CLOUD_INVENTORY_INCOMPLETE",
+        "\u6E05\u7406\u540E\u65E0\u6CD5\u786E\u8BA4\u5269\u4F59\u6570\u636E",
+        503
+      );
+    const selected = new Set(operation.entries.map((e) => e.resource.id));
+    const remaining = current.entries.filter(
+      (e) => operation.mode === "retire-owner" ? ownerEquals(e.resource.owner, operation.owner) || (operation.knownResourceIds || []).includes(e.resource.id) : selected.has(e.resource.id)
+    );
+    for (const count of operation.counts)
+      count.remaining = remaining.filter(
+        (e) => e.resource.type === count.type
+      ).length;
+    if (operation.mode === "purge") {
+      const processed = new Set(
+        operation.entries.slice(0, operation.cursor).map((entry) => entry.resource.id)
+      );
+      if (remaining.some((entry) => processed.has(entry.resource.id))) {
+        throw cloudError(
+          "CLOUD_PLAN_CHANGED",
+          "\u5DF2\u6E05\u7406\u8D44\u6E90\u88AB\u91CD\u65B0\u521B\u5EFA\uFF0C\u8BF7\u91CD\u65B0\u9884\u89C8",
+          409
+        );
+      }
+    }
+    operation.status = remaining.length ? "pending" : "completed";
+    if (operation.status === "completed") {
+      operation.entries = [];
+      operation.knownResourceIds = [];
+      operation.knownResourceVersions = {};
+    }
+    operation.errors = [];
+    operation.attempts = 0;
+  } catch (error) {
+    if (error.code === "CLOUD_LEASE_LOST") throw error;
+    operation.attempts = (operation.attempts || 0) + 1;
+    const terminal = ["CLOUD_PLAN_CHANGED", "CLOUD_OWNER_CHANGED"].includes(error.code) || operation.attempts >= 8;
+    operation.status = terminal ? "failed" : "pending";
+    operation.errors = [
+      {
+        code: error.code || "CLOUD_CLEANUP_FAILED",
+        message: error.code === "CLOUD_PLAN_CHANGED" ? error.message : "\u4E91\u7AEF\u6E05\u7406\u672A\u5B8C\u6210\uFF0C\u5C06\u6309\u670D\u52A1\u7AEF\u8BB0\u5F55\u91CD\u8BD5\u3002"
+      }
+    ];
+    operation.nextAttemptAt = Date.now() + Math.min(36e5, 3e4 * 2 ** operation.attempts);
+    if (terminal)
+      for (const count of operation.counts) count.failed = count.remaining;
+  } finally {
+    operation.updatedAt = Date.now();
+    await save(db, userId, key, "operation", operation, { leaseToken });
+    if (typeof db.releaseCloudDataRecord === "function")
+      await db.releaseCloudDataRecord(
+        userId,
+        "operation",
+        operation.id,
+        leaseToken
+      );
+  }
+  return operation;
+}
+async function resumeCloudDataCleanups(ctx) {
+  const db = ctx.db;
+  if (!_optionalChain([db, 'optionalAccess', _80 => _80.cloudDataManagement])) return;
+  const rows = await db.listCloudDataRecordsAcrossUsers("operation");
+  await db.cleanupCloudDataRecords("inventory", Date.now() - 36e5);
+  await db.cleanupCloudDataRecords("plan", Date.now() - 36e5);
+  await db.cleanupCloudResourceMetadata();
+  let processed = 0;
+  for (const row of rows) {
+    try {
+      const key = await deriveUserEncryptionKey(row.userId, ctx.masterKey);
+      const operation = JSON.parse(await decryptFromStorage(row.data, key));
+      if (["completed", "failed"].includes(operation.status) && operation.updatedAt < Date.now() - 30 * 864e5) {
+        await db.deleteCloudDataRecord(row.userId, "operation", operation.id);
+        continue;
+      }
+      if (["pending", "running"].includes(operation.status)) {
+        await advanceCleanup(ctx, db, row.userId, key, operation);
+        if (++processed >= 100) break;
+      }
+    } catch (e11) {
+      console.warn("[amsg] A cloud cleanup operation could not be resumed");
+    }
+  }
+}
+
+// src/server/handlers/cloud-data.js
+function createCloudDataHandler(ctx) {
+  async function run(url, headers, body, method) {
+    const tenant = await ctx.tenantManager.resolveTenant(headers);
+    if (!tenant.ok) return tenant.error;
+    const gate = requireUserId(headers);
+    if (gate.error) return gate.error;
+    const { db, masterKey } = tenant.context;
+    const { userId } = gate;
+    if (!db.cloudDataManagement)
+      return {
+        status: 501,
+        body: {
+          success: false,
+          error: {
+            code: "CLOUD_DATA_NOT_SUPPORTED",
+            message: "\u5F53\u524D\u9002\u914D\u5668\u4E0D\u652F\u6301\u5B8C\u6574\u4E91\u7AEF\u7BA1\u7406"
+          }
+        }
+      };
+    const key = await deriveUserEncryptionKey(userId, masterKey);
+    try {
+      const parsedUrl = new URL(url, "https://cloud.invalid");
+      const path = parsedUrl.pathname;
+      const params = parsedUrl.searchParams;
+      let input;
+      if (method === "POST") {
+        if (getHeader(headers, "x-payload-encrypted") !== "true" || getHeader(headers, "x-encryption-version") !== "1")
+          throw cloudError("ENCRYPTION_REQUIRED", "\u8BF7\u6C42\u5FC5\u987B\u4F7F\u7528\u7248\u672C 1 \u52A0\u5BC6");
+        const parsed = parseEncryptedBody(body);
+        if (!parsed.ok) throw cloudError("INVALID_PAYLOAD", "\u8BF7\u6C42\u683C\u5F0F\u65E0\u6548");
+        try {
+          input = await decryptPayload(parsed.data, key);
+        } catch (e12) {
+          throw cloudError("DECRYPTION_FAILED", "\u8BF7\u6C42\u89E3\u5BC6\u5931\u8D25");
+        }
+        if (!input || typeof input !== "object" || Array.isArray(input))
+          throw cloudError("INVALID_PAYLOAD", "\u8BF7\u6C42\u683C\u5F0F\u65E0\u6548");
+      }
+      let data;
+      if (method === "GET" && (path.endsWith("/summary") || path.endsWith("/resources"))) {
+        const ownerType = params.get("ownerType"), ownerId = params.get("ownerId"), type = params.get("type");
+        if (Boolean(ownerType) !== Boolean(ownerId) || type && !CLOUD_RESOURCE_TYPES.includes(type))
+          throw cloudError("INVALID_CLOUD_FILTER", "\u8D44\u6E90\u7B5B\u9009\u65E0\u6548");
+        const filter = { ownerType, ownerId, type };
+        if (path.endsWith("/summary")) {
+          const inventory = await cloudInventory(ctx, db, userId, key);
+          const resources = inventory.entries.map((e) => e.resource);
+          data = {
+            total: resources.length,
+            counts: CLOUD_RESOURCE_TYPES.map((type2) => ({
+              type: type2,
+              count: resources.filter((r) => r.type === type2).length,
+              byteSize: resources.filter((r) => r.type === type2).reduce((sum, r) => sum + (r.byteSize || 0), 0)
+            })),
+            complete: inventory.complete,
+            gaps: inventory.gaps
+          };
+        } else {
+          const limit = Number(params.get("limit") || 50);
+          if (!Number.isInteger(limit) || limit < 1 || limit > 200)
+            throw cloudError("INVALID_CLOUD_LIMIT", "\u6BCF\u9875\u6570\u91CF\u5FC5\u987B\u4E3A 1\u2013200");
+          let snapshot, offset = 0;
+          const cursor = params.get("cursor");
+          if (cursor) {
+            const match = /^([0-9a-f-]{36}):(\d+)$/.exec(cursor);
+            if (!match)
+              throw cloudError("INVALID_CLOUD_CURSOR", "\u5206\u9875\u6E38\u6807\u65E0\u6548");
+            snapshot = await readCloudRecord(
+              db,
+              userId,
+              key,
+              "inventory",
+              match[1]
+            );
+            offset = Number(match[2]);
+            if (!Number.isSafeInteger(offset) || offset < 0 || offset > snapshot.resources.length)
+              throw cloudError("INVALID_CLOUD_CURSOR", "\u5206\u9875\u6E38\u6807\u65E0\u6548");
+            if (snapshot.expiresAt < Date.now() || JSON.stringify(snapshot.filter) !== JSON.stringify(filter))
+              throw cloudError(
+                "CLOUD_CURSOR_EXPIRED",
+                "\u5206\u9875\u5DF2\u8FC7\u671F\u6216\u7B5B\u9009\u53D8\u5316",
+                409
+              );
+          } else {
+            const inventory = await cloudInventory(ctx, db, userId, key);
+            snapshot = {
+              id: crypto.randomUUID(),
+              filter,
+              expiresAt: Date.now() + 15 * 60 * 1e3,
+              resources: inventory.entries.map((e) => e.resource).filter(
+                (r) => (!type || r.type === type) && (!ownerId || _optionalChain([r, 'access', _81 => _81.owner, 'optionalAccess', _82 => _82.type]) === ownerType && r.owner.id === ownerId)
+              ),
+              complete: inventory.complete,
+              gaps: inventory.gaps
+            };
+            await db.putCloudDataRecord(
+              userId,
+              "inventory",
+              snapshot.id,
+              await encryptForStorage(JSON.stringify(snapshot), key)
+            );
+          }
+          data = {
+            resources: snapshot.resources.slice(offset, offset + limit),
+            nextCursor: offset + limit < snapshot.resources.length ? `${snapshot.id}:${offset + limit}` : null,
+            complete: snapshot.complete,
+            gaps: snapshot.gaps
+          };
+        }
+      } else if (method === "POST" && path.endsWith("/cleanup-plans"))
+        data = await makeCleanupPlan(ctx, db, userId, key, input);
+      else if (method === "POST" && path.endsWith("/cleanup-operations"))
+        data = await startCleanup(ctx, db, userId, key, input);
+      else if (method === "GET" && path.endsWith("/cleanup-operations")) {
+        const records = await db.listCloudDataRecords(userId, "operation");
+        const operations = [];
+        const gaps = [];
+        for (const row of records) {
+          try {
+            operations.push(
+              publicOperation(
+                JSON.parse(await decryptFromStorage(row.data, key))
+              )
+            );
+          } catch (e13) {
+            gaps.push({
+              source: "operation",
+              code: "UNREADABLE_OPERATION",
+              message: `\u65E0\u6CD5\u8BFB\u53D6\u64CD\u4F5C ${row.id}`
+            });
+          }
+        }
+        data = {
+          operations: operations.sort((a, b) => b.createdAt - a.createdAt),
+          complete: gaps.length === 0,
+          gaps
+        };
+      } else if (method === "GET" && path.includes("/cleanup-operations/"))
+        data = publicOperation(
+          await readCloudRecord(
+            db,
+            userId,
+            key,
+            "operation",
+            path.split("/").pop()
+          )
+        );
+      else if (method === "GET" && path.endsWith("/owners")) {
+        const owners = await db.listCloudOwners(userId);
+        data = {
+          owners: owners.map((state) => ({
+            owner: state.owner,
+            retired: !state.active,
+            generation: state.generation,
+            updatedAt: state.updatedAt,
+            complete: true,
+            gaps: []
+          })),
+          complete: true,
+          gaps: []
+        };
+      } else if (path.endsWith("/owner")) {
+        const owner = method === "POST" ? input.owner : { type: params.get("ownerType"), id: params.get("ownerId") };
+        if (!validCloudOwner(owner))
+          throw cloudError("INVALID_CLOUD_OWNER", "\u5F52\u5C5E\u683C\u5F0F\u65E0\u6548");
+        if (method === "POST") {
+          const beforeRestore = await db.getCloudOwner(userId, owner);
+          if (input.action !== "restore")
+            throw cloudError("INVALID_CLOUD_OWNER_ACTION", "\u5F52\u5C5E\u64CD\u4F5C\u65E0\u6548");
+          const rows = await db.listCloudDataRecords(userId, "operation");
+          for (const row of rows) {
+            const op = JSON.parse(await decryptFromStorage(row.data, key));
+            if (op.mode === "retire-owner" && _optionalChain([op, 'access', _83 => _83.owner, 'optionalAccess', _84 => _84.type]) === owner.type && _optionalChain([op, 'access', _85 => _85.owner, 'optionalAccess', _86 => _86.id]) === owner.id && ["pending", "running"].includes(op.status))
+              throw cloudError(
+                "CLOUD_CLEANUP_IN_PROGRESS",
+                "\u6E05\u7406\u5B8C\u6210\u540E\u624D\u80FD\u91CD\u65B0\u542F\u7528",
+                409
+              );
+          }
+          if (!beforeRestore.active)
+            await db.setCloudOwnerActive(
+              userId,
+              owner,
+              true,
+              beforeRestore.generation
+            );
+        }
+        const state = await db.getCloudOwner(userId, owner);
+        data = {
+          owner,
+          retired: !state.active,
+          generation: state.generation,
+          updatedAt: _nullishCoalesce(state.updatedAt, () => ( null)),
+          complete: true,
+          gaps: []
+        };
+      } else throw cloudError("NOT_FOUND", "\u4E91\u7AEF\u7BA1\u7406\u5165\u53E3\u4E0D\u5B58\u5728", 404);
+      return {
+        status: 200,
+        body: {
+          success: true,
+          encrypted: true,
+          version: 1,
+          data: await encryptPayload(data, key)
+        }
+      };
+    } catch (error) {
+      return {
+        status: error.status || 500,
+        body: {
+          success: false,
+          error: {
+            code: error.code || "CLOUD_DATA_FAILED",
+            message: error.status ? error.message : "\u4E91\u7AEF\u7BA1\u7406\u8BF7\u6C42\u5931\u8D25\uFF1B\u672A\u80FD\u786E\u8BA4\u64CD\u4F5C\u7ED3\u679C\u3002"
+          }
+        }
+      };
+    }
+  }
+  return {
+    GET: (url, headers) => run(url, headers, null, "GET"),
+    POST: (url, headers, body) => run(url, headers, body, "POST")
+  };
+}
+
 // src/server/handlers/outbox.js
 var MAX_OUTBOX_PAGE_SIZE = 100;
 var DEFAULT_OUTBOX_PAGE_SIZE = 50;
@@ -6307,7 +8092,7 @@ function createSingleUserServer(config) {
   if (!config.masterKey) throw new Error("[amsg-server single-user] config.masterKey is required");
   const vapid = config.vapid || {};
   const tenantManager = createSingleUserContextManager({
-    db: config.db,
+    db: createCloudGuardedAdapter(config.db, { masterKey: config.masterKey, resolveOwner: _optionalChain([config, 'access', _87 => _87.cloudData, 'optionalAccess', _88 => _88.resolveOwner]) }),
     masterKey: config.masterKey,
     serverToken: config.serverToken
   });
@@ -6339,7 +8124,8 @@ function createSingleUserServer(config) {
     // 定时任务投递失败后的重试次数上限（默认 3）。handlers 用不到，宿主拿这个
     // ctx 去调 runScheduledTick 时它跟着走。
     maxGenerationRetries: config.maxGenerationRetries,
-    maxDeliveryRetries: config.maxDeliveryRetries
+    maxDeliveryRetries: config.maxDeliveryRetries,
+    cloudData: config.cloudData
   };
   return {
     ctx,
@@ -6357,13 +8143,14 @@ function createSingleUserServer(config) {
       pushSubscription: createPushSubscriptionHandler(ctx),
       llmCredentials: createLlmCredentialsHandler(ctx),
       capabilities: createCapabilitiesHandler(ctx),
-      outbox: createOutboxHandler(ctx)
+      outbox: createOutboxHandler(ctx),
+      cloudData: createCloudDataHandler(ctx)
     }
   };
 }
 
 // src/server/lib/schema-version.js
-var SCHEMA_VERSION = "2.6.0";
+var SCHEMA_VERSION = "2.6.0-cloud-data.1";
 function requireIntrospection(db) {
   if (!db || typeof db.describeSchema !== "function") {
     throw new Error(
@@ -6492,6 +8279,7 @@ function createSingleUserCloudflareWorker(buildConfig, options = {}) {
   function buildTickContext(cfg) {
     return {
       db: cfg.db,
+      cloudData: cfg.cloudData,
       masterKey: cfg.masterKey,
       vapid: cfg.vapid || {},
       webpush: cfg.webpush,
@@ -6579,7 +8367,9 @@ function createSingleUserCloudflareWorker(buildConfig, options = {}) {
         body = read.body;
       }
       let result;
-      if (method === "POST" && pathname.endsWith("/init-tenant")) {
+      if (pathname.includes("/cloud-data/") && (method === "GET" || method === "POST")) {
+        result = method === "GET" ? await server.handlers.cloudData.GET(url, headers) : await server.handlers.cloudData.POST(url, headers, body);
+      } else if (method === "POST" && pathname.endsWith("/init-tenant")) {
         result = await server.handlers.init.POST(headers, body);
       } else if (method === "GET" && pathname.endsWith("/get-user-key")) {
         result = await server.handlers.getUserKey.GET(url, headers);
@@ -6644,6 +8434,13 @@ function createSingleUserCloudflareWorker(buildConfig, options = {}) {
       await reportError({ stage: "config", error, cause, path: null });
       return { ok: false, cause };
     }
+    try {
+      await resumeCloudDataCleanups(buildTickContext(cfg));
+    } catch (error) {
+      const cause = summarizeErrorCause(error, "cloud-cleanup");
+      await reportError({ stage: "cloud-cleanup", error, cause, path: null });
+      return { ok: false, cause };
+    }
     if (!pushConfigured(cfg)) {
       console.error("[amsg single-user] scheduled(): VAPID/webpush not configured; skipping tick");
       const cause = summarizeErrorCause(
@@ -6753,4 +8550,5 @@ function createSingleUserCloudflareWorker(buildConfig, options = {}) {
 
 
 
-exports.isValidTimeZoneId = isValidTimeZoneId; exports.advanceOccurrence = advanceOccurrence; exports.planNextOccurrence = planNextOccurrence; exports.nextFutureOccurrence = nextFutureOccurrence; exports.base64UrlToBytes = _amsgshared.base64UrlToBytes; exports.utf8 = _amsgshared.utf8; exports.utf8Decode = _amsgshared.utf8Decode; exports.bytesToBase64Url = _amsgshared.bytesToBase64Url; exports.timingSafeEqualBytes = _amsgshared.timingSafeEqualBytes; exports.deriveUserEncryptionKey = deriveUserEncryptionKey; exports.decryptPayload = decryptPayload; exports.encryptForStorage = encryptForStorage; exports.decryptFromStorage = decryptFromStorage; exports.CRED_ID_MAX_LENGTH = CRED_ID_MAX_LENGTH; exports.CRED_PUT_BATCH_MAX = CRED_PUT_BATCH_MAX; exports.CRED_ROWS_PER_USER_MAX = CRED_ROWS_PER_USER_MAX; exports.CRED_REFS_MAX_ENTRIES = CRED_REFS_MAX_ENTRIES; exports.supportsLlmCredentialsStore = supportsLlmCredentialsStore; exports.isValidCredId = isValidCredId; exports.validateCredValue = validateCredValue; exports.validateCredRefs = validateCredRefs; exports.hasChatCredRef = hasChatCredRef; exports.resolveLlmCredential = resolveLlmCredential; exports.isValidUrl = _amsgshared.isValidUrl; exports.validateAvatarUrl = _amsgshared.validateAvatarUrl; exports.isValidISO8601 = isValidISO8601; exports.isValidUUID = isValidUUID; exports.isValidUUIDv4 = isValidUUIDv4; exports.validateSplitPattern = validateSplitPattern; exports.validateLlmMessagesArray = validateLlmMessagesArray; exports.MAX_TASK_PAYLOAD_BYTES = MAX_TASK_PAYLOAD_BYTES; exports.validateScheduleMessagePayload = validateScheduleMessagePayload; exports.DEFAULT_MAX_REQUEST_BODY_BYTES = DEFAULT_MAX_REQUEST_BODY_BYTES; exports.readRequestBody = readRequestBody; exports.parseJsonBody = parseJsonBody; exports.getHeader = getHeader; exports.createGetUserKeyHandler = createGetUserKeyHandler; exports.NonRetryableError = NonRetryableError; exports.isNonRetryableError = isNonRetryableError; exports.DeploymentConfigError = DeploymentConfigError; exports.sanitizeErrorSummary = sanitizeErrorSummary; exports.summarizeErrorCause = summarizeErrorCause; exports.DEFAULT_MAX_DELIVERY_RETRIES = DEFAULT_MAX_DELIVERY_RETRIES; exports.WEB_PUSH_MAX_BODY_BYTES = WEB_PUSH_MAX_BODY_BYTES; exports.WEB_PUSH_ENCRYPTION_OVERHEAD_BYTES = WEB_PUSH_ENCRYPTION_OVERHEAD_BYTES; exports.MAX_PUSH_PAYLOAD_BYTES = MAX_PUSH_PAYLOAD_BYTES; exports.PUSH_ENVELOPE_RESERVED_BYTES = PUSH_ENVELOPE_RESERVED_BYTES; exports.measurePushPayload = measurePushPayload; exports.createWebCryptoWebPush = createWebCryptoWebPush; exports.DEFAULT_MAX_TOOL_ITERATIONS = DEFAULT_MAX_TOOL_ITERATIONS; exports.DEFAULT_TOTAL_TIMEOUT_MS = DEFAULT_TOTAL_TIMEOUT_MS; exports.DEFAULT_MAX_SCHEDULED_TASKS_PER_FIRE = DEFAULT_MAX_SCHEDULED_TASKS_PER_FIRE; exports.MIN_SCHEDULE_LEAD_MS = MIN_SCHEDULE_LEAD_MS; exports.createScheduleMessageHandler = createScheduleMessageHandler; exports.DEFAULT_CLAIM_LEASE_MS = DEFAULT_CLAIM_LEASE_MS; exports.DEFAULT_LEASE_HEARTBEAT_MS = DEFAULT_LEASE_HEARTBEAT_MS; exports.DEFAULT_HEARTBEAT_LEASE_TTL_MS = DEFAULT_HEARTBEAT_LEASE_TTL_MS; exports.runScheduledTick = runScheduledTick; exports.runTask = runTask; exports.createUpdateMessageHandler = createUpdateMessageHandler; exports.createCancelMessageHandler = createCancelMessageHandler; exports.createMessagesHandler = createMessagesHandler; exports.createGetMessageHandler = createGetMessageHandler; exports.createPushSubscriptionHandler = createPushSubscriptionHandler; exports.createLlmCredentialsHandler = createLlmCredentialsHandler; exports.createD1Adapter = createD1Adapter; exports.createSingleUserServer = createSingleUserServer; exports.SCHEMA_VERSION = SCHEMA_VERSION; exports.getSchemaVersion = getSchemaVersion; exports.ensureSchema = ensureSchema; exports.CORS_ALLOW_HEADERS = CORS_ALLOW_HEADERS; exports.CORS_ALLOW_METHODS = CORS_ALLOW_METHODS; exports.createSingleUserCloudflareWorker = createSingleUserCloudflareWorker;
+
+exports.isValidTimeZoneId = isValidTimeZoneId; exports.advanceOccurrence = advanceOccurrence; exports.planNextOccurrence = planNextOccurrence; exports.nextFutureOccurrence = nextFutureOccurrence; exports.base64UrlToBytes = _amsgshared.base64UrlToBytes; exports.utf8 = _amsgshared.utf8; exports.utf8Decode = _amsgshared.utf8Decode; exports.bytesToBase64Url = _amsgshared.bytesToBase64Url; exports.timingSafeEqualBytes = _amsgshared.timingSafeEqualBytes; exports.deriveUserEncryptionKey = deriveUserEncryptionKey; exports.decryptPayload = decryptPayload; exports.encryptForStorage = encryptForStorage; exports.decryptFromStorage = decryptFromStorage; exports.CRED_ID_MAX_LENGTH = CRED_ID_MAX_LENGTH; exports.CRED_PUT_BATCH_MAX = CRED_PUT_BATCH_MAX; exports.CRED_ROWS_PER_USER_MAX = CRED_ROWS_PER_USER_MAX; exports.CRED_REFS_MAX_ENTRIES = CRED_REFS_MAX_ENTRIES; exports.supportsLlmCredentialsStore = supportsLlmCredentialsStore; exports.isValidCredId = isValidCredId; exports.validateCredValue = validateCredValue; exports.validateCredRefs = validateCredRefs; exports.hasChatCredRef = hasChatCredRef; exports.resolveLlmCredential = resolveLlmCredential; exports.isValidUrl = _amsgshared.isValidUrl; exports.validateAvatarUrl = _amsgshared.validateAvatarUrl; exports.isValidISO8601 = isValidISO8601; exports.isValidUUID = isValidUUID; exports.isValidUUIDv4 = isValidUUIDv4; exports.validateSplitPattern = validateSplitPattern; exports.validateLlmMessagesArray = validateLlmMessagesArray; exports.MAX_TASK_PAYLOAD_BYTES = MAX_TASK_PAYLOAD_BYTES; exports.validateScheduleMessagePayload = validateScheduleMessagePayload; exports.DEFAULT_MAX_REQUEST_BODY_BYTES = DEFAULT_MAX_REQUEST_BODY_BYTES; exports.readRequestBody = readRequestBody; exports.parseJsonBody = parseJsonBody; exports.getHeader = getHeader; exports.createGetUserKeyHandler = createGetUserKeyHandler; exports.NonRetryableError = NonRetryableError; exports.isNonRetryableError = isNonRetryableError; exports.DeploymentConfigError = DeploymentConfigError; exports.sanitizeErrorSummary = sanitizeErrorSummary; exports.summarizeErrorCause = summarizeErrorCause; exports.DEFAULT_MAX_DELIVERY_RETRIES = DEFAULT_MAX_DELIVERY_RETRIES; exports.WEB_PUSH_MAX_BODY_BYTES = WEB_PUSH_MAX_BODY_BYTES; exports.WEB_PUSH_ENCRYPTION_OVERHEAD_BYTES = WEB_PUSH_ENCRYPTION_OVERHEAD_BYTES; exports.MAX_PUSH_PAYLOAD_BYTES = MAX_PUSH_PAYLOAD_BYTES; exports.PUSH_ENVELOPE_RESERVED_BYTES = PUSH_ENVELOPE_RESERVED_BYTES; exports.measurePushPayload = measurePushPayload; exports.createWebCryptoWebPush = createWebCryptoWebPush; exports.DEFAULT_MAX_TOOL_ITERATIONS = DEFAULT_MAX_TOOL_ITERATIONS; exports.DEFAULT_TOTAL_TIMEOUT_MS = DEFAULT_TOTAL_TIMEOUT_MS; exports.DEFAULT_MAX_SCHEDULED_TASKS_PER_FIRE = DEFAULT_MAX_SCHEDULED_TASKS_PER_FIRE; exports.MIN_SCHEDULE_LEAD_MS = MIN_SCHEDULE_LEAD_MS; exports.MAX_DEFER_AFTER_MS = MAX_DEFER_AFTER_MS; exports.createScheduleMessageHandler = createScheduleMessageHandler; exports.DEFAULT_CLAIM_LEASE_MS = DEFAULT_CLAIM_LEASE_MS; exports.DEFAULT_LEASE_HEARTBEAT_MS = DEFAULT_LEASE_HEARTBEAT_MS; exports.DEFAULT_HEARTBEAT_LEASE_TTL_MS = DEFAULT_HEARTBEAT_LEASE_TTL_MS; exports.runScheduledTick = runScheduledTick; exports.runTask = runTask; exports.createUpdateMessageHandler = createUpdateMessageHandler; exports.createCancelMessageHandler = createCancelMessageHandler; exports.createMessagesHandler = createMessagesHandler; exports.createGetMessageHandler = createGetMessageHandler; exports.createPushSubscriptionHandler = createPushSubscriptionHandler; exports.createLlmCredentialsHandler = createLlmCredentialsHandler; exports.createD1Adapter = createD1Adapter; exports.createSingleUserServer = createSingleUserServer; exports.SCHEMA_VERSION = SCHEMA_VERSION; exports.getSchemaVersion = getSchemaVersion; exports.ensureSchema = ensureSchema; exports.CORS_ALLOW_HEADERS = CORS_ALLOW_HEADERS; exports.CORS_ALLOW_METHODS = CORS_ALLOW_METHODS; exports.createSingleUserCloudflareWorker = createSingleUserCloudflareWorker;